Deployment package structure¶

deployment_folder.zip
    deployment_package/
        - deployment.py
        - requirements.txt (optional)
        - libraries/    (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):
        """
        Initialization 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 (version) that might be useful in your
        code.
            It contains the following keys:
                - project (str): name of the project that hosts the deployment
                - project_id (str): unique identifier of the project
                - deployment_id (str): unique identifier of the deployment
                - deployment (str): name of the deployment
                - version_id (str): unique identifier of the deployment version
                - version (str): name of the version
                - process_id (int): unique identifier of the instance process
                - input_type (str): deployment input type, either 'structured' or 'plain'
                - output_type (str): deployment output type, either 'structured' or 'plain'
                - input_fields (list): list with all input fields of the deployment
                - output_fields (list): list with all output fields of the deployment
                - language (str) : programming language the deployment is running
                - environment_variables (dict/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, context):
        """
        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.
        :param dict context: a dictionary containing details of the request that might be useful in your code.
            It contains the following keys:
                - id (str): the id of the request
                - user_id (str): unique identifier of the (service) user that sent the request
                - request_mode (str): mode of the request, either 'express' or 'batch'
                - streaming_update (func): used to stream partial output updates to.
            For a pipeline request, it contains the additional keys:
                - pipeline_request_id (str): unique identifier of the pipeline request
                - pipeline_id (str): unique identifier of the pipeline
                - pipeline_version_id (str): unique identifier of the pipeline version
                - pipeline_object_id (str): unique identifier of the object in the pipeline. Deployments and operators
                in pipelines are assigned a unique identifier.


        :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()
        }

   # (OPTIONAL) Uncomment these lines in case you want to use 'requests' functionality
    # def requests(self, data, context):
    #     """
    #     Method for deployment requests, called once with a list of requests.
    #
    #     :param list[dict/str] data: request input data. In case of deployments with structured data, a list of Python
    #         dictionaries 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 list of strings.
    #    :param dict context: a dictionary containing details of the request that might be useful in your code.
    #        It contains the following keys:
    #            - id (str): the id of the request
    #            - user_id (str): unique identifier of the (service) user that sent the request
    #            - request_mode (str): mode of the request, either 'express' or 'batch'
    #            - streaming_update (func): used to stream partial output updates to.

    #        For a pipeline request, it contains the additional keys:
    #            - pipeline_request_id (str): unique identifier of the pipeline request
    #            - pipeline_id (str): unique identifier of the pipeline
    #            - pipeline_version_id (str): unique identifier of the pipeline version
    #            - pipeline_object_id (str): unique identifier of the object in the pipeline. Deployments and operators
    #            in pipelines are assigned a unique identifier.
    #     :return list[dict/str] or dict/str: request output. In case of deployments with structured output data, a
    #         Python dictionary (or list of dictionaries) 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 (or list of strings).
    #         In this example, a list of dictionaries with the key: output.
    #     """
    #
    #     print(f"Processing requests {context['id']} for My Deployment")
    #
    #     # You can run any code to handle the requests here.
    #
    #     # For a structured deployment, we return a list of Python dicts as output. In this example, we are assuming
    #     # this deployment receives a list of dicts with one input field called 'input' and outputs a list of dicts
    #     # with one field called 'output'. It is also possible to return a single dict as output and thereby reducing
    #     # the number of requests from many to one.
    #
    #     output = []
    #     for item in data:
    #         output.append({
    #             "output": item['input'] * random.random()
    #         })
    #     return output