dtlpy 1.88.15__py3-none-any.whl → 1.90.37__py3-none-any.whl

dtlpy/ml/base_feature_extractor_adapter.py

@@ -0,0 +1,28 @@
+from abc import ABC
+
+from base_model_adapter import BaseModelAdapter
+from .. import entities
+
+
+class BaseFeatureExtractorAdapter(BaseModelAdapter, ABC):
+    def __int__(self, model_entity: entities.Model = None):
+        super().__init__(model_entity)
+
+    def extract_features(self, batch: list, **kwargs):
+        """ Runs inference with the model, but does not predict. Instead, extracts features for the input batch.
+
+            Virtual method - need to implement
+
+        :param batch: `list` a list containing a batch of items whose features will be extracted
+        """
+        raise NotImplementedError("Please implement 'extract_features' method in {}".format(self.__class__.__name__))
+
+    def extract_dataset_features(self, dataset: entities.Dataset, **kwargs):
+        """ Runs inference to extract features for all items in a dataset.
+
+            Virtual method - need to implement
+
+        :param dataset: `entities.Dataset` dataset entity whose items will have their features extracted
+        """
+        raise NotImplementedError("Please implement 'extract_dataset_features' method in "
+                                  "{}".format(self.__class__.__name__))

dtlpy/ml/base_model_adapter.py

@@ -157,6 +157,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         """
         import dtlpymetrics
         compare_types = model.output_type
+        if not filters:
+            filters = entities.Filters()
         if filters is not None and isinstance(filters, dict):
             filters = entities.Filters(custom_filter=filters)
         model = dtlpymetrics.scoring.create_model_score(model=model,
@@ -252,9 +254,22 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
             else:
                 self.logger.debug("Downloading subset {!r} of {}".format(subset,
                                                                          self.model_entity.dataset.name))
+
+                if self.configuration.get("include_model_annotations", False):
+                    annotation_filters = None
+                else:
+                    annotation_filters = entities.Filters(
+                        field="metadata.system.model.name",
+                        values=False,
+                        operator=entities.FiltersOperations.EXISTS,
+                        resource=entities.FiltersResource.ANNOTATION
+                        )
+
                 ret_list = dataset.items.download(filters=filters,
                                                   local_path=data_subset_base_path,
-                                                  annotation_options=annotation_options)
+                                                  annotation_options=annotation_options,
+                                                  annotation_filters=annotation_filters
+                                                  )
 
         self.convert_from_dtlpy(data_path=data_path, **kwargs)
         return root_path, data_path, output_path
@@ -395,10 +410,13 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         self.logger.debug("Predicting dataset (name:{}, id:{}, using batch size {}".format(dataset.name,
                                                                                            dataset.id,
                                                                                            batch_size))
+        if not filters:
+            filters = entities.Filters()
         if filters is not None and isinstance(filters, dict):
             filters = entities.Filters(custom_filter=filters)
         pages = dataset.items.list(filters=filters, page_size=batch_size)
-        self.predict_items(items=list(pages.all()),
+        items = [item for item in pages.all() if item.type == 'file']
+        self.predict_items(items=items,
                            with_upload=with_upload,
                            cleanup=cleanup,
                            batch_size=batch_size,
@@ -424,6 +442,9 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         output_path = None
         try:
             logger.info("Received {s} for training".format(s=model.id))
+            model = model.wait_for_model_ready()
+            if model.status == 'failed':
+                raise ValueError("Model is in failed state, cannot train.")
 
             ##############
             # Set status #
@@ -523,6 +544,8 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         # Predicting #
         ##############
         logger.info(f"Calling prediction, dataset: {dataset.name!r} ({model.id!r}), filters: {filters}")
+        if not filters:
+            filters = entities.Filters()
         self.predict_dataset(dataset=dataset,
                              filters=filters,
                              with_upload=True)
@@ -614,17 +637,21 @@ class BaseModelAdapter(utilities.BaseServiceRunner):
         """
         for prediction in predictions:
             if prediction.type == entities.AnnotationType.SEGMENTATION:
+                color = None
                 try:
-                    color = self.model_entity.dataset._get_ontology().color_map.get(prediction.label)
+                    color = item.dataset._get_ontology().color_map.get(prediction.label, None)
                 except (exceptions.BadRequest, exceptions.NotFound):
-                    color = None
-                    logger.warning("Can't get annotation color from item's dataset, using model's dataset.")
+                    ...
+                if color is None:
+                    if self.model_entity._dataset is not None:
+                        try:
+                            color = self.model_entity.dataset._get_ontology().color_map.get(prediction.label,
+                                                                                            (255, 255, 255))
+                        except (exceptions.BadRequest, exceptions.NotFound):
+                            ...
                 if color is None:
-                    try:
-                        color = self.model_entity.dataset._get_ontology().color_map.get(prediction.label)
-                    except (exceptions.BadRequest, exceptions.NotFound):
-                        logger.warning("Can't get annotation color from model's dataset, using default.")
-                        color = prediction.color
+                    logger.warning("Can't get annotation color from model's dataset, using default.")
+                    color = prediction.color
                 prediction.color = color
 
             prediction.item_id = item.id

dtlpy/repositories/__init__.py

@@ -50,3 +50,4 @@ from .apps import Apps
 from .dpks import Dpks
 from .messages import Messages
 from .compositions import Compositions
+from .schema import Schema

dtlpy/repositories/apps.py

@@ -183,7 +183,13 @@ class Apps:
             return success
         raise exceptions.PlatformException(response)
 
-    def install(self, dpk: entities.Dpk, app_name: str = None, organization_id: str = None) -> entities.App:
+    def install(self,
+                dpk: entities.Dpk,
+                app_name: str = None,
+                organization_id: str = None,
+                custom_installation: dict = None,
+                scope: entities.AppScope = None
+                ) -> entities.App:
         """
         Install the specified app in the project.
 
@@ -191,6 +197,9 @@ class Apps:
         :param entities.App dpk: the app entity
         :param str app_name: installed app name. default is the dpk name
         :param str organization_id: the organization which you want to apply on the filter.
+        :param dict custom_installation: partial installation.
+        :param str scope: the scope of the app. default is project.
+
         :return the installed app.
         :rtype entities.App
 
@@ -203,13 +212,15 @@ class Apps:
 
         if app_name is None:
             app_name = dpk.display_name
+        if isinstance(scope, entities.AppScope):
+            scope = scope.value
         app = entities.App.from_json(_json={'name': app_name,
                                             'projectId': self.project.id,
                                             'orgId': organization_id,
                                             'dpkName': dpk.name,
-                                            "dpkConfig": dpk.to_json(),
+                                            "customInstallation": custom_installation,
                                             'dpkVersion': dpk.version,
-                                            'scope': dpk.scope
+                                            'scope': scope
                                             },
                                      client_api=self._client_api,
                                      project=self.project)
@@ -242,7 +253,8 @@ class Apps:
                 error='400',
                 message='You must provide an identifier in inputs')
         if app_name is not None:
-            app_id = self.__get_by_name(app_name)
+            app = self.__get_by_name(app_name)
+            app_id = app.id
 
         success, response = self._client_api.gen_request(req_type='delete', path='/apps/{}'.format(app_id))
         if not success:
@@ -250,3 +262,69 @@ class Apps:
 
         logger.debug(f"App deleted successfully (id: {app_id}, name: {app_name}")
         return success
+
+    def resume(self, app: entities.App = None, app_id: str = None) -> bool:
+        """
+        Activate an app entity.
+
+        Note: You are required to add either app or app_id.
+
+        :param entities.App app: the app entity
+        :param str app_id: optional - the id of the app.
+        :return whether we succeed activating the specified app.
+        :rtype bool
+
+        **Example**
+        .. code-block:: python
+            # succeed = dl.apps.resume(app)
+        """
+        if app_id is not None and app is None:
+            app = self.get(app_id=app_id)
+        if app is None:
+            raise exceptions.PlatformException(error='400', message='You must provide app or app_id')
+
+        if app and app.status == entities.CompositionStatus.INSTALLED:
+            raise exceptions.PlatformException(
+                error='400',
+                message='Application is already active'
+            )
+
+        success, response = self._client_api.gen_request(req_type='post', path='/apps/{}/activate'.format(app.id))
+        if not success:
+            raise exceptions.PlatformException(response)
+
+        logger.debug(f"App resumed successfully (id: {app.id}, name: {app.name}")
+        return success
+
+    def pause(self, app: entities.App = None, app_id: str = None) -> bool:
+        """
+        Pausing an app entity.
+
+        Note: You are required to add either app or app_id.
+
+        :param entities.App app: the app entity
+        :param str app_id: optional - the id of the app.
+        :return whether we succeed pausing the specified app.
+        :rtype bool
+
+        **Example**
+        .. code-block:: python
+            # succeed = dl.apps.pause(app)
+        """
+        if app_id is not None and app is None:
+            app = self.get(app_id=app_id)
+        if app is None:
+            raise exceptions.PlatformException(error='400', message='You must provide app or app_id')
+
+        if app and app.status == entities.CompositionStatus.UNINSTALLED:
+            raise exceptions.PlatformException(
+                error='400',
+                message='Application is already inactive'
+            )
+
+        success, response = self._client_api.gen_request(req_type='post', path='/apps/{}/deactivate'.format(app.id))
+        if not success:
+            raise exceptions.PlatformException(response)
+
+        logger.debug(f"App paused successfully (id: {app.id}, name: {app.name}")
+        return success

dtlpy/repositories/dpks.py

@@ -2,6 +2,7 @@ import json
 import logging
 import os
 from typing import List, Optional
+from pathlib import Path
 
 from .. import exceptions, entities, services, miscellaneous, assets
 from ..services.api_client import ApiClient
@@ -25,27 +26,33 @@ class Dpks:
         self._project = project
 
     def init(self, directory: str = None, name: str = None, description: str = None,
-             categories: List[str] = None, icon: str = None, scope: str = None):
+             attributes: dict = None, icon: str = None, scope: str = None):
         """
         Initialize a dpk project with the specified projects.
 
         :param str directory: the directory where to initialize the project
         :param str name: the name of the dpk.
         :param str description: the description of the dpk.
-        :param str categories: the categories of the dpk.
+        :param str attributes: the attributes of the dpk.
         :param str icon: the icon of the dpk.
         :param str scope: the scope of the dpk.
 
         ** Example **
         .. code-block:: python
-            dl.dpks.init(name='Hello World', description='A description of the dpk', categories=['starter', 'advanced'],
+            dl.dpks.init(name='Hello World', description='A description of the dpk', attributes={
+                "Provider": "Dataloop",
+                "License": "",
+                "Category": "Model",
+                "Computer Vision": "Object Detection",
+                "Media Type": "Image"
+              },
                         icon='path_to_icon', scope='organization')
         """
         if directory is None:
             directory = os.getcwd()
         dpk = entities.Dpk.from_json(_json={'name': miscellaneous.JsonUtils.get_if_absent(name),
                                             'description': miscellaneous.JsonUtils.get_if_absent(description),
-                                            'categories': miscellaneous.JsonUtils.get_if_absent(categories),
+                                            'attributes': miscellaneous.JsonUtils.get_if_absent(attributes),
                                             'icon': miscellaneous.JsonUtils.get_if_absent(icon),
                                             'scope': miscellaneous.JsonUtils.get_if_absent(scope, 'organization'),
                                             'components': dict()
@@ -189,11 +196,17 @@ class Dpks:
             dpk = dpk_v.items[0]
         return dpk
 
-    def publish(self, dpk: entities.Dpk = None, ignore_max_file_size: bool = False) -> entities.Dpk:
+    def publish(self, dpk: entities.Dpk = None, ignore_max_file_size: bool = False, manifest_filepath='dataloop.json') -> entities.Dpk:
         """
         Upload a dpk entity to the dataloop platform.
 
-        :param entities.Dpk dpk: the dpk to publish
+        :param entities.Dpk dpk: Optional. The DPK entity to publish. If None, a new DPK is created
+                             from the manifest file.
+        :param bool ignore_max_file_size: Optional. If True, the maximum file size check is ignored
+                                        during the packaging of the codebase.
+        :param str manifest_filepath: Optional. Path to the manifest file. Can be absolute or relative.
+                                    Defaults to 'dataloop.json'
+
         :return the published dpk
         :rtype dl.entities.Dpk
 
@@ -202,16 +215,31 @@ class Dpks:
         .. code-block:: python
             published_dpk = dl.dpks.publish()
         """
+        manifest_path = Path(manifest_filepath).resolve()
 
         if dpk is None:
-            if not os.path.exists(os.path.abspath('dataloop.json')):
-                raise ValueError('dataloop.json file must be exists in order to publish a dpk')
-            with open('dataloop.json', 'r') as f:
+            if not manifest_path.exists():
+                raise FileNotFoundError(f'{manifest_filepath} file must exist in order to publish a dpk')
+            with open(manifest_filepath, 'r') as f:
                 json_file = json.load(f)
             dpk = entities.Dpk.from_json(_json=json_file,
                                          client_api=self._client_api,
                                          project=self.project)
 
+        if not dpk.context:
+            dpk.context = {}
+        if 'project' not in dpk.context:
+            if not self.project:
+                raise exceptions.PlatformException('400', 'project id must be provided in the context')
+            dpk.context['project'] = self.project.id
+        if 'org' not in dpk.context and dpk.scope == 'organization':
+            if not self.project:
+                raise exceptions.PlatformException('400', 'org id must be provided in the context')
+            dpk.context['org'] = self.project.org['id']
+
+        if self.project and self.project.id != dpk.context['project']:
+            logger.warning("the project id that provide different from the dpk project id")
+
         if dpk.codebase is None:
             dpk.codebase = self.project.codebases.pack(directory=os.getcwd(),
                                                        name=dpk.display_name,

dtlpy/repositories/executions.py

@@ -285,7 +285,7 @@ class Executions:
         :param str service_id: service id to execute on
         :param filters: Filters entity for a filtering before execute
         :param str function_name: function name to run
-        :param List[FunctionIO] or dict execution_inputs: input dictionary or list of FunctionIO entities
+        :param List[FunctionIO] or dict execution_inputs: input dictionary or list of FunctionIO entities, that represent the extra inputs of the function
         :param bool wait: wait until create task finish
         :return: execution object
         :rtype: dtlpy.entities.execution.Execution
@@ -307,15 +307,18 @@ class Executions:
         if filters is None:
             raise exceptions.PlatformException('400', 'Please provide filter')
 
+        if execution_inputs is None:
+            execution_inputs = dict()
+
         if isinstance(execution_inputs, dict):
-            customer_inputs = execution_inputs
+            extra_inputs = execution_inputs
         else:
             if not isinstance(execution_inputs, list):
                 execution_inputs = [execution_inputs]
             if len(execution_inputs) > 0 and isinstance(execution_inputs[0], entities.FunctionIO):
-                customer_inputs = dict()
+                extra_inputs = dict()
                 for single_input in execution_inputs:
-                    customer_inputs.update(single_input.to_json(resource='execution'))
+                    extra_inputs.update(single_input.to_json(resource='execution'))
             else:
                 raise exceptions.PlatformException('400', 'Unknown input type')
 
@@ -323,7 +326,7 @@ class Executions:
         payload = dict()
         payload['batch'] = dict()
         payload['batch']['query'] = filters.prepare()
-        payload['batch']['args'] = customer_inputs
+        payload['batch']['args'] = extra_inputs
 
         if function_name is not None:
             payload['functionName'] = function_name
@@ -597,7 +600,8 @@ class Executions:
                                                      service=self._service)
             if timeout is None:
                 timeout = execution.service.execution_timeout + 60
-            if execution.latest_status['status'] in ['failed', 'success', 'terminated', 'aborted', 'canceled', 'system-failure']:
+            if execution.latest_status['status'] in ['failed', 'success', 'terminated', 'aborted', 'canceled',
+                                                     'system-failure']:
                 break
             elapsed = int(time.time()) - start
             i += 1

dtlpy/repositories/features.py

@@ -18,6 +18,8 @@ class Features:
                  item: entities.Item = None,
                  annotation: entities.Annotation = None,
                  feature_set: entities.FeatureSet = None):
+        if project is not None and project_id is None:
+            project_id = project.id
         self._project = project
         self._project_id = project_id
         self._item = item
@@ -34,6 +36,9 @@ class Features:
 
     @property
     def project(self) -> entities.Project:
+        if self._project is None and self._project_id is None and self._item is not None:
+            self._project = self._item.project
+            self._project_id = self._project.id
         if self._project is None and self._project_id is not None:
             # get from id
             self._project = repositories.Projects(client_api=self._client_api).get(project_id=self._project_id)
@@ -96,8 +101,9 @@ class Features:
             filters.add(field='featureSetId', values=self._feature_set.id)
         if self._item is not None:
             filters.add(field='entityId', values=self._item.id)
-        if self._project_id is not None:
-            filters.context = {"projects": [self._project_id]}
+        if self._project_id is None:
+            self._project_id = self.project.id
+        filters.context = {"projects": [self._project_id]}
 
         paged = entities.PagedEntities(items_repository=self,
                                        filters=filters,

dtlpy/repositories/integrations.py

@@ -111,6 +111,7 @@ class Integrations:
         aws-sts - {key: "", secret: "", roleArns: ""}
         aws-cross - {}
         gcp-cross - {}
+        gcp-workload-identity-federation - {"secret": "", "content": "{}", "clientId": ""}
 
         **Prerequisites**: You must be an *owner* in the organization.
 

dtlpy/repositories/models.py

@@ -1,14 +1,16 @@
-import json
-
+import time
 from typing import List
 import logging
-import os
 
 from .. import entities, repositories, exceptions, miscellaneous
 from ..services.api_client import ApiClient
 
 logger = logging.getLogger(name='dtlpy')
 
+MIN_INTERVAL = 1
+BACKOFF_FACTOR = 1.2
+MAX_INTERVAL = 12
+
 
 class Models:
     """
@@ -197,7 +199,7 @@ class Models:
     def _set_model_filter(self,
                           metadata: dict,
                           train_filter: entities.Filters = None,
-                          validation_filter: entities.Filters = None, ):
+                          validation_filter: entities.Filters = None):
         if metadata is None:
             metadata = {}
         if 'system' not in metadata:
@@ -283,6 +285,7 @@ class Models:
             output_type=None,
             train_filter: entities.Filters = None,
             validation_filter: entities.Filters = None,
+            app: entities.App = None
     ) -> entities.Model:
         """
         Create a Model entity
@@ -304,6 +307,7 @@ class Models:
         :param str output_type: dl.AnnotationType - the type of annotations the model produces (class, box segment, text, etc)
         :param dtlpy.entities.filters.Filters train_filter: Filters entity or a dictionary to define the items' scope in the specified dataset_id for the model train
         :param dtlpy.entities.filters.Filters validation_filter: Filters entity or a dictionary to define the items' scope in the specified dataset_id for the model validation
+        :param dtlpy.entities.App app: App entity to connect the model to
         :return: Model Entity
 
         **Example**:
@@ -340,10 +344,12 @@ class Models:
                 raise exceptions.PlatformException('Please provide project_id')
             project_id = self._project.id
         else:
-            if project_id != self._project_id and not package.is_global:
-                logger.warning(
-                    "Note! you are specified project_id {!r} which is different from repository context: {!r}".format(
-                        project_id, self._project_id))
+            if project_id != self._project_id:
+                if (isinstance(package, entities.Package) and not package.is_global) or \
+                        (isinstance(package, entities.Dpk) and not package.scope != 'public'):
+                    logger.warning(
+                        "Note! you are specified project_id {!r} which is different from repository context: {!r}".format(
+                            project_id, self._project_id))
 
         if model_artifacts is None:
             model_artifacts = []
@@ -365,6 +371,29 @@ class Models:
             'outputType': output_type,
         }
 
+        if app is not None:
+            if not isinstance(package, entities.Dpk):
+                raise ValueError('package must be a Dpk entity')
+            if app.dpk_name != package.name or app.dpk_version != package.version:
+                raise ValueError('App and package must be the same')
+            component_name = None
+            compute_config = None
+            for model in package.components.models:
+                if model['name'] == model_name:
+                    component_name = model['name']
+                    compute_config = model.get('computeConfigs', None)
+                    break
+            if component_name is None:
+                raise ValueError('Model name not found in package')
+            payload['app'] = {
+                "id": app.id,
+                "componentName": component_name,
+                "dpkName": package.name,
+                "dpkVersion": package.version
+            }
+            if compute_config is not None:
+                payload['app']['computeConfig'] = compute_config
+
         if configuration is not None:
             payload['configuration'] = configuration
 
@@ -378,7 +407,8 @@ class Models:
             payload['status'] = status
 
         if train_filter or validation_filter:
-            metadata = self._set_model_filter(metadata={}, train_filter=train_filter,
+            metadata = self._set_model_filter(metadata={},
+                                              train_filter=train_filter,
                                               validation_filter=validation_filter)
             payload['metadata'] = metadata
 
@@ -411,6 +441,7 @@ class Models:
               tags: list = None,
               train_filter: entities.Filters = None,
               validation_filter: entities.Filters = None,
+              wait=True,
               ) -> entities.Model:
         """
         Clones and creates a new model out of existing one
@@ -427,6 +458,7 @@ class Models:
         :param list tags:  `list` of `str` - label of the model
         :param dtlpy.entities.filters.Filters train_filter: Filters entity or a dictionary to define the items' scope in the specified dataset_id for the model train
         :param dtlpy.entities.filters.Filters validation_filter: Filters entity or a dictionary to define the items' scope in the specified dataset_id for the model validation
+        :param bool wait: `bool` wait for model to be ready
         :return: dl.Model which is a clone version of the existing model
         """
         from_json = {"name": model_name,
@@ -478,9 +510,24 @@ class Models:
                                              client_api=self._client_api,
                                              project=self._project,
                                              package=from_model._package)
-
+        if wait:
+            new_model = self.wait_for_model_ready(model=new_model)
         return new_model
 
+    def wait_for_model_ready(self, model: entities.Model):
+        """
+        Wait for model to be ready
+
+        :param model: Model entity
+        """
+        sleep_time = MIN_INTERVAL
+        while model.status == entities.ModelStatus.CLONING:
+            model = self.get(model_id=model.id)
+            time.sleep(sleep_time)
+            sleep_time = min(sleep_time * BACKOFF_FACTOR, MAX_INTERVAL)
+            time.sleep(sleep_time)
+        return model
+
     @property
     def platform_url(self):
         return self._client_api._get_resource_url("projects/{}/models".format(self.project.id))

dtlpy/repositories/packages.py

@@ -155,7 +155,8 @@ class Packages:
             package_name: str = None,
             package_id: str = None,
             checkout: bool = False,
-            fetch=None) -> entities.Package:
+            fetch=None,
+            log_error=True) -> entities.Package:
         """
         Get Package object to use in your code.
 
@@ -165,6 +166,7 @@ class Packages:
         :param str package_name: package name
         :param bool checkout: set the package as a default package object (cookies)
         :param fetch: optional - fetch entity from platform, default taken from cookie
+        :param bool log_error: log error if package not found
         :return: Package object
         :rtype: dtlpy.entities.package.Package
 
@@ -187,7 +189,8 @@ class Packages:
             if package_id is not None:
                 success, response = self._client_api.gen_request(
                     req_type="get",
-                    path="/packages/{}".format(package_id))
+                    path="/packages/{}".format(package_id),
+                    log_error=log_error)
                 if not success:
                     raise exceptions.PlatformException(response)
                 package = entities.Package.from_json(client_api=self._client_api,

dtlpy/repositories/pipeline_executions.py

@@ -257,7 +257,7 @@ class PipelineExecutions:
 
         :param pipeline_id: pipeline id
         :param filters: Filters entity for a filtering before execute
-        :param execution_inputs: list of the dl.FunctionIO or dict of pipeline input - example {'item': 'item_id'}
+        :param execution_inputs: list of the dl.FunctionIO or dict of pipeline input - example {'item': 'item_id'}, that represent the extra inputs of the function
         :param bool wait: wait until create task finish
         :return: entities.PipelineExecution object
         :rtype: dtlpy.entities.pipeline_execution.PipelineExecution
@@ -277,22 +277,25 @@ class PipelineExecutions:
 
         if filters is None:
             raise exceptions.PlatformException('400', 'Please provide filter')
-        customer_input = dict()
+        extra_input = dict()
+
+        if execution_inputs is None:
+            execution_inputs = {}
 
         if isinstance(execution_inputs, dict):
-            customer_input = execution_inputs
+            extra_input = execution_inputs
         else:
             if not isinstance(execution_inputs, list):
                 execution_inputs = [execution_inputs]
             if len(execution_inputs) > 0 and isinstance(execution_inputs[0], entities.FunctionIO):
                 for single_input in execution_inputs:
-                    customer_input.update(single_input.to_json(resource='execution'))
+                    extra_input.update(single_input.to_json(resource='execution'))
             else:
                 raise exceptions.PlatformException('400', 'Unknown input type')
         payload = dict()
         payload['batch'] = dict()
         payload['batch']['query'] = filters.prepare()
-        payload['batch']['args'] = customer_input
+        payload['batch']['args'] = extra_input
 
         success, response = self._client_api.gen_request(
             path='/pipelines/{}/execute'.format(pipeline_id),