Deployment package structure¶

deployment_folder.zip
        deployment_package/
                - deployment.py

                - requirements.txt (optional)
                - libraries/    (optional)
                - ubiops.yaml   (optional)
                - other files & artifacts (optional)

deployment_folder.zip
        deployment_package/
                - deployment.R

                - renv.lock or install_packages.R (optional)
                - ubiops.yaml   (optional)
                - other files & artifacts (optional)

"""
The file containing the deployment code is required to be called 'deployment.py' and should contain the 'Deployment'
class and 'request' method.
"""

# Always use absolute imports when importing modules from the deployment package directory. For example
# `import my_module` instead of `import .my_module`

import random


class Deployment:

    def __init__(self, base_directory, context):
    """
    Initialisation method for the deployment. It can for example be used for loading modules that have to be kept in
    memory or setting up connections. Load your external deployment files (such as pickles or .h5 files) here.
    :param str base_directory: absolute path to the directory where the deployment.py file is located
    :param dict context: a dictionary containing details of the deployment that might be useful in your code.
        It contains the following keys:
            - deployment (str): name of the deployment
            - version (str): name of the version
            - input_type (str): deployment input type, either 'structured' or 'plain'
            - output_type (str): deployment output type, either 'structured' or 'plain'
            - language (str): programming language the deployment is running
            - environment_variables (str): the custom environment variables configured for the deployment.
                You can also access those as normal environment variables via os.environ
    """

    print("Initialising My Deployment")

    def request(self, data):
    """
    Method for deployment requests, called separately for each individual request.
    :param dict/str data: request input data. In case of deployments with structured data, a Python dictionary
        with as keys the input fields as defined upon deployment creation via the platform. In case of a deployment
        with plain input, it is a string.
    :return dict/str: request output. In case of deployments with structured output data, a Python dictionary
        with as keys the output fields as defined upon deployment creation via the platform. In case of a deployment
        with plain output, it is a string. In this example, a dictionary with the key: output.
    """

    print("Processing request for My Deployment")

    # You can run any code to handle the request here.

    # For a structured deployment, we return a Python dict with output. In this example, we are assuming this
    # deployment receives one input field called 'input' and outputs one field called 'output'
    return {
        "output": data['input'] * random.random()
    }

# This file (containing the deployment code) is required to be called 'deployment.R' and should contain an 'init'
# and 'request' method.

#' @title Init
#' @description Initialisation method for the deployment.
#'     It can for example be used for loading modules that have to be kept in memory or setting up connections.
#' @param base_directory (str) absolute path to the directory where the deployment.R file is located
#' @param context (named list) details of the deployment that might be useful in your code
init <- function(base_directory, context) {
    print("Initialising My Deployment")
}


#' @title Request
#' @description Method for deployment requests, called separately for each individual request.
#' @param input_data (str or named list) request input data
#'     - In case of structured input: a named list, with as keys the input fields as defined upon deployment creation
#'     - In case of plain input: a string
#' @param base_directory (str) absolute path to the directory where the deployment.R file is located
#' @param context (named list) details of the deployment that might be useful in your code
#' @return output data (str or named list) request result
#'     - In case of structured output: a named list, with as keys the output fields as defined upon deployment creation
#'     - In case of plain output: a string
request <- function(input_data, base_directory, context) {
    print("Processing request for My Deployment")


    # ADD YOUR CODE HERE...


    # Another script can be called using: source(file.path(base_directory, "<script name>.R"))
    # Environment variables can be obtained via: Sys.getenv("ENV_VAR", unset = "")


    # In this example, the input field "input" in multiplied by a random number and returned in output field "output"
    list( output = input_data[["input"]] * runif(1) )
}