dtlpy 1.115.44__py3-none-any.whl → 1.116.6__py3-none-any.whl

dtlpy/entities/package_defaults.py

@@ -1,5 +1,5 @@
-DEFAULT_PACKAGE_ENTRY_POINT = 'main.py'
-DEFAULT_PACKAGE_CLASS_NAME = 'ServiceRunner'
-DEFAULT_PACKAGE_FUNCTION_NAME = 'run'
-DEFAULT_PACKAGE_MODULE_NAME = 'default_module'
-DEFAULT_PACKAGE_NAME = 'default_package'
+DEFAULT_PACKAGE_ENTRY_POINT = 'main.py'
+DEFAULT_PACKAGE_CLASS_NAME = 'ServiceRunner'
+DEFAULT_PACKAGE_FUNCTION_NAME = 'run'
+DEFAULT_PACKAGE_MODULE_NAME = 'default_module'
+DEFAULT_PACKAGE_NAME = 'default_package'

dtlpy/entities/package_function.py

@@ -1,185 +1,185 @@
-import logging
-import typing
-import json
-from enum import Enum
-from .. import exceptions, entities
-
-logger = logging.getLogger(name='dtlpy')
-
-
-class PackageInputType(str, Enum):
-    DATASET = "Dataset"
-    ITEM = "Item"
-    ANNOTATION = "Annotation"
-    EXECUTION = "Execution"
-    TASK = "Task"
-    ASSIGNMENT = "Assignment"
-    SERVICE = "Service"
-    PACKAGE = "Package"
-    PROJECT = "Project"
-    RECIPE = "Recipe"
-    JSON = "Json"
-    STRING = "String"
-    NUMBER = "Number"
-    INT = "Integer"
-    FLOAT = "Float"
-    BOOLEAN = "Boolean"
-    MODEL = "Model"
-    DATASETS = "Dataset[]"
-    ITEMS = "Item[]"
-    ANNOTATIONS = "Annotation[]"
-    EXECUTIONS = "Execution[]"
-    TASKS = "Task[]"
-    ASSIGNMENTS = "Assignment[]"
-    SERVICES = "Service[]"
-    PACKAGES = "Package[]"
-    PROJECTS = "Project[]"
-    JSONS = "Json[]"
-    STRINGS = "String[]"
-    NUMBERS = "Number[]"
-    INTS = "Integer[]"
-    FLOATS = "Float[]"
-    BOOLEANS = "Boolean[]"
-    MODELS = "Model[]"
-    RECIPES = "Recipe[]"
-
-
-class PackageFunction(entities.DlEntity):
-    """
-    Webhook object
-    """
-
-    # platform
-    name: str = entities.DlProperty(location=['name'],
-                                    _type=str,
-                                    default=entities.package_defaults.DEFAULT_PACKAGE_FUNCTION_NAME)
-    description: str = entities.DlProperty(location=['description'],
-                                           _type=str)
-    display_name: typing.Union[str, None] = entities.DlProperty(location=['displayName'],
-                                                                _type=typing.Union[str, None])
-    display_icon: typing.Union[str, None] = entities.DlProperty(location=['displayIcon'],
-                                                                _type=typing.Union[str, None])
-
-    outputs: typing.Union[typing.List['entities.FunctionIO'], None] = entities.DlProperty(location=['output'],
-                                                                                          _kls='FunctionIO')
-    inputs: typing.Union[typing.List['entities.FunctionIO'], None] = entities.DlProperty(location=['input'],
-                                                                                         _kls='FunctionIO')
-    compute_config: str = entities.DlProperty(location=['computeConfig'], _type=str, default=None)
-
-    def __repr__(self):
-        # TODO need to move to DlEntity
-        return f"PackageFunction(name={self.name}, description={self.description})"
-
-    @classmethod
-    def from_json(cls, _json):
-        inst = cls(_dict=_json)
-        return inst
-
-    @outputs.default
-    def get_outputs(self):
-        outputs = list()
-        return outputs
-
-    @inputs.default
-    def get_inputs(self):
-        inputs = list()
-        return inputs
-
-    def to_json(self):
-        _json = self._dict.copy()
-        return _json
-
-
-class FunctionIO(entities.DlEntity):
-    INPUT_TYPES: list = [val for key, val in PackageInputType.__dict__.items() if not key.startswith('_')]
-    type = entities.DlProperty(location=['type'], _type=str)
-    value = entities.DlProperty(location=['value'], _type=str)
-    name = entities.DlProperty(location=['name'], _type=str)
-    actions = entities.DlProperty(location=['actions'], _type=list)
-    description = entities.DlProperty(location=['description'], _type=str)
-    integration = entities.DlProperty(location=['integration'], _type=dict)
-    mandatory = entities.DlProperty(location=['mandatory'], _type=bool)
-
-    def __repr__(self):
-        # TODO need to move to DlEntity
-        return f"FunctionIO(type={self.type}, name={self.name}, value={self.value})"
-
-    @name.default
-    def set_name(self):
-        if self.type == PackageInputType.ITEM:
-            return 'item'
-        elif self.type == PackageInputType.DATASET:
-            return 'dataset'
-        elif self.type == PackageInputType.ANNOTATION:
-            return 'annotation'
-        elif self.type == PackageInputType.PROJECT:
-            return 'project'
-        elif self.type == PackageInputType.PACKAGE:
-            return 'package'
-        elif self.type == PackageInputType.SERVICE:
-            return 'service'
-        elif self.type == PackageInputType.EXECUTION:
-            return 'execution'
-        elif self.type == PackageInputType.MODEL:
-            return 'model'
-        else:
-            return 'config'
-
-    @type.validator
-    def check_type(self, value):
-        if value not in self.INPUT_TYPES:
-            raise exceptions.PlatformException(
-                error='400',
-                message='Invalid input type: {!r}. Please one from dl.PackageInputType'.format(value))
-
-    @staticmethod
-    def is_json_serializable(val):
-        try:
-            json.dumps(val)
-            is_json_serializable = True
-        except Exception:
-            is_json_serializable = False
-        return is_json_serializable
-
-    @value.validator
-    def check_value(self, value):
-        value_ok = True
-        expected_value = 'Expected value should be:'
-        if self.type == PackageInputType.JSON:
-            expected_value = '{} json serializable'.format(expected_value)
-            if not self.is_json_serializable(value):
-                value_ok = False
-        else:
-            expected_value = 'Unknown value type: {}'.format(type(value))
-            if type(value) not in [dict, str, float, int, bool, list]:
-                value_ok = False
-
-        if not value_ok and value is not None:
-            raise exceptions.PlatformException('400', 'Illegal value. {}'.format(expected_value))
-
-    def to_json(self, resource='package'):
-        """
-        :param resource:
-        """
-        if resource == 'package':
-            _json = {
-                'name': self.name,
-                'type': self.type,
-            }
-            if self.actions:
-                _json['actions'] = self.actions
-            if self.description:
-                _json['description'] = self.description
-        elif resource in ['execution', 'service']:
-            _json = {
-                self.name: self.value
-            }
-        else:
-            raise exceptions.PlatformException('400', 'Please select resource from: package, execution')
-
-        return _json
-
-    @classmethod
-    def from_json(cls, _json):
-        inst = cls(_dict=_json)
-        return inst
+import logging
+import typing
+import json
+from enum import Enum
+from .. import exceptions, entities
+
+logger = logging.getLogger(name='dtlpy')
+
+
+class PackageInputType(str, Enum):
+    DATASET = "Dataset"
+    ITEM = "Item"
+    ANNOTATION = "Annotation"
+    EXECUTION = "Execution"
+    TASK = "Task"
+    ASSIGNMENT = "Assignment"
+    SERVICE = "Service"
+    PACKAGE = "Package"
+    PROJECT = "Project"
+    RECIPE = "Recipe"
+    JSON = "Json"
+    STRING = "String"
+    NUMBER = "Number"
+    INT = "Integer"
+    FLOAT = "Float"
+    BOOLEAN = "Boolean"
+    MODEL = "Model"
+    DATASETS = "Dataset[]"
+    ITEMS = "Item[]"
+    ANNOTATIONS = "Annotation[]"
+    EXECUTIONS = "Execution[]"
+    TASKS = "Task[]"
+    ASSIGNMENTS = "Assignment[]"
+    SERVICES = "Service[]"
+    PACKAGES = "Package[]"
+    PROJECTS = "Project[]"
+    JSONS = "Json[]"
+    STRINGS = "String[]"
+    NUMBERS = "Number[]"
+    INTS = "Integer[]"
+    FLOATS = "Float[]"
+    BOOLEANS = "Boolean[]"
+    MODELS = "Model[]"
+    RECIPES = "Recipe[]"
+
+
+class PackageFunction(entities.DlEntity):
+    """
+    Webhook object
+    """
+
+    # platform
+    name: str = entities.DlProperty(location=['name'],
+                                    _type=str,
+                                    default=entities.package_defaults.DEFAULT_PACKAGE_FUNCTION_NAME)
+    description: str = entities.DlProperty(location=['description'],
+                                           _type=str)
+    display_name: typing.Union[str, None] = entities.DlProperty(location=['displayName'],
+                                                                _type=typing.Union[str, None])
+    display_icon: typing.Union[str, None] = entities.DlProperty(location=['displayIcon'],
+                                                                _type=typing.Union[str, None])
+
+    outputs: typing.Union[typing.List['entities.FunctionIO'], None] = entities.DlProperty(location=['output'],
+                                                                                          _kls='FunctionIO')
+    inputs: typing.Union[typing.List['entities.FunctionIO'], None] = entities.DlProperty(location=['input'],
+                                                                                         _kls='FunctionIO')
+    compute_config: str = entities.DlProperty(location=['computeConfig'], _type=str, default=None)
+
+    def __repr__(self):
+        # TODO need to move to DlEntity
+        return f"PackageFunction(name={self.name}, description={self.description})"
+
+    @classmethod
+    def from_json(cls, _json):
+        inst = cls(_dict=_json)
+        return inst
+
+    @outputs.default
+    def get_outputs(self):
+        outputs = list()
+        return outputs
+
+    @inputs.default
+    def get_inputs(self):
+        inputs = list()
+        return inputs
+
+    def to_json(self):
+        _json = self._dict.copy()
+        return _json
+
+
+class FunctionIO(entities.DlEntity):
+    INPUT_TYPES: list = [val for key, val in PackageInputType.__dict__.items() if not key.startswith('_')]
+    type = entities.DlProperty(location=['type'], _type=str)
+    value = entities.DlProperty(location=['value'], _type=str)
+    name = entities.DlProperty(location=['name'], _type=str)
+    actions = entities.DlProperty(location=['actions'], _type=list)
+    description = entities.DlProperty(location=['description'], _type=str)
+    integration = entities.DlProperty(location=['integration'], _type=dict)
+    mandatory = entities.DlProperty(location=['mandatory'], _type=bool)
+
+    def __repr__(self):
+        # TODO need to move to DlEntity
+        return f"FunctionIO(type={self.type}, name={self.name}, value={self.value})"
+
+    @name.default
+    def set_name(self):
+        if self.type == PackageInputType.ITEM:
+            return 'item'
+        elif self.type == PackageInputType.DATASET:
+            return 'dataset'
+        elif self.type == PackageInputType.ANNOTATION:
+            return 'annotation'
+        elif self.type == PackageInputType.PROJECT:
+            return 'project'
+        elif self.type == PackageInputType.PACKAGE:
+            return 'package'
+        elif self.type == PackageInputType.SERVICE:
+            return 'service'
+        elif self.type == PackageInputType.EXECUTION:
+            return 'execution'
+        elif self.type == PackageInputType.MODEL:
+            return 'model'
+        else:
+            return 'config'
+
+    @type.validator
+    def check_type(self, value):
+        if value not in self.INPUT_TYPES:
+            raise exceptions.PlatformException(
+                error='400',
+                message='Invalid input type: {!r}. Please one from dl.PackageInputType'.format(value))
+
+    @staticmethod
+    def is_json_serializable(val):
+        try:
+            json.dumps(val)
+            is_json_serializable = True
+        except Exception:
+            is_json_serializable = False
+        return is_json_serializable
+
+    @value.validator
+    def check_value(self, value):
+        value_ok = True
+        expected_value = 'Expected value should be:'
+        if self.type == PackageInputType.JSON:
+            expected_value = '{} json serializable'.format(expected_value)
+            if not self.is_json_serializable(value):
+                value_ok = False
+        else:
+            expected_value = 'Unknown value type: {}'.format(type(value))
+            if type(value) not in [dict, str, float, int, bool, list]:
+                value_ok = False
+
+        if not value_ok and value is not None:
+            raise exceptions.PlatformException('400', 'Illegal value. {}'.format(expected_value))
+
+    def to_json(self, resource='package'):
+        """
+        :param resource:
+        """
+        if resource == 'package':
+            _json = {
+                'name': self.name,
+                'type': self.type,
+            }
+            if self.actions:
+                _json['actions'] = self.actions
+            if self.description:
+                _json['description'] = self.description
+        elif resource in ['execution', 'service']:
+            _json = {
+                self.name: self.value
+            }
+        else:
+            raise exceptions.PlatformException('400', 'Please select resource from: package, execution')
+
+        return _json
+
+    @classmethod
+    def from_json(cls, _json):
+        inst = cls(_dict=_json)
+        return inst

dtlpy/entities/package_module.py

@@ -1,113 +1,113 @@
-import importlib.util
-import inspect
-import logging
-import typing
-
-from .. import entities
-
-logger = logging.getLogger(name='dtlpy')
-
-
-class PackageModule(entities.DlEntity):
-    """
-    PackageModule object
-    """
-    # platform
-    name: str = entities.DlProperty(location=['name'], _type=str)
-    init_inputs: typing.List['entities.FunctionIO'] = entities.DlProperty(location=['initInputs'],
-                                                                          _type=typing.Union[list, None],
-                                                                          _kls='FunctionIO')
-
-    entry_point = entities.DlProperty(location=['entryPoint'],
-                                      _type=str,
-                                      default=entities.package_defaults.DEFAULT_PACKAGE_ENTRY_POINT)
-    class_name = entities.DlProperty(location=['className'],
-                                     _type=dict,
-                                     default=entities.package_defaults.DEFAULT_PACKAGE_CLASS_NAME)
-    functions: typing.List['entities.PackageFunction'] = entities.DlProperty(location=['functions'],
-                                                                             _type=list,
-                                                                             default=list(),
-                                                                             _kls='PackageFunction')
-    compute_config: str = entities.DlProperty(location=['computeConfig'], _type=str, default=None)
-
-    def __repr__(self):
-        # TODO need to move to DlEntity
-        return f"PackageModule(name={self.name}, entry_point={self.entry_point}, class_name={self.class_name})"
-
-    @functions.validator
-    def validate_functions(self, value: list):
-        if not isinstance(value, list):
-            raise Exception('Module functions must be a list.')
-        if not self.unique_functions(value):
-            raise Exception('Cannot have 2 functions by the same name in one module.')
-
-    @staticmethod
-    def unique_functions(functions: list):
-        return len(functions) == len(set([function.name for function in functions]))
-
-    @name.default
-    def set_name(self):
-        logger.warning('No module name was given. Using default name: {}'.format(
-            entities.package_defaults.DEFAULT_PACKAGE_MODULE_NAME))
-        return entities.package_defaults.DEFAULT_PACKAGE_MODULE_NAME
-
-    @init_inputs.default
-    def set_init_inputs(self):
-        return list()
-
-    @classmethod
-    def from_json(cls, _json):
-        inst = cls(_dict=_json)
-        return inst
-
-    @classmethod
-    def from_entry_point(cls, entry_point):
-        """
-        Create a dl.PackageModule entity using decorator on the service class.
-
-        :param entry_point: path to the python file with the runner class (relative to the package path)
-        :return:
-        """
-        file_spec = importlib.util.spec_from_file_location(entry_point, entry_point)
-        file_module = importlib.util.module_from_spec(file_spec)
-        file_spec.loader.exec_module(file_module)
-        module = None
-        for cls_name, cls_inst in inspect.getmembers(file_module, predicate=inspect.isclass):
-            spec = getattr(cls_inst, '__dtlpy__', None)
-            if spec is not None:
-                functions = spec['functions']
-                available_methods = [name for name in ['train', 'predict']
-                                     if 'BaseModelAdapter' not in getattr(cls_inst, name).__qualname__]
-                if "train" not in available_methods:
-                    # remove train_model from functions list if train is not available
-                    functions[:] = [d for d in functions if d.get('name') != "train_model"]
-                if "predict" not in available_methods:
-                    # remove predict_items from functions list if predict is not available
-                    functions[:] = [d for d in functions if d.get('name') != "predict_items"]
-                if "extract_features" not in available_methods:
-                    # remove extract_item_features from functions list if extract_features is not available
-                    functions[:] = [d for d in functions if d.get('name') != "extract_item_features"]
-                spec['entryPoint'] = entry_point
-                spec['functions'] = functions
-                module = cls.from_json(spec)
-                break
-        if module is None:
-            raise ValueError('Failed to find a decorated Runner class in file: {}'.format(entry_point))
-        return module
-
-    def add_function(self, function):
-        """
-        :param function:
-        """
-        if not isinstance(self.functions, list):
-            self.functions = [self.functions]
-        if isinstance(function, entities.PackageFunction):
-            self.functions.append(function)
-        elif isinstance(function, dict):
-            self.functions.append(entities.PackageFunction.from_json(function))
-        else:
-            raise ValueError('Unknown function type: {}. Expecting dl.PackageFunction or dict')
-
-    def to_json(self):
-        _json = self._dict.copy()
-        return _json
+import importlib.util
+import inspect
+import logging
+import typing
+
+from .. import entities
+
+logger = logging.getLogger(name='dtlpy')
+
+
+class PackageModule(entities.DlEntity):
+    """
+    PackageModule object
+    """
+    # platform
+    name: str = entities.DlProperty(location=['name'], _type=str)
+    init_inputs: typing.List['entities.FunctionIO'] = entities.DlProperty(location=['initInputs'],
+                                                                          _type=typing.Union[list, None],
+                                                                          _kls='FunctionIO')
+
+    entry_point = entities.DlProperty(location=['entryPoint'],
+                                      _type=str,
+                                      default=entities.package_defaults.DEFAULT_PACKAGE_ENTRY_POINT)
+    class_name = entities.DlProperty(location=['className'],
+                                     _type=dict,
+                                     default=entities.package_defaults.DEFAULT_PACKAGE_CLASS_NAME)
+    functions: typing.List['entities.PackageFunction'] = entities.DlProperty(location=['functions'],
+                                                                             _type=list,
+                                                                             default=list(),
+                                                                             _kls='PackageFunction')
+    compute_config: str = entities.DlProperty(location=['computeConfig'], _type=str, default=None)
+
+    def __repr__(self):
+        # TODO need to move to DlEntity
+        return f"PackageModule(name={self.name}, entry_point={self.entry_point}, class_name={self.class_name})"
+
+    @functions.validator
+    def validate_functions(self, value: list):
+        if not isinstance(value, list):
+            raise Exception('Module functions must be a list.')
+        if not self.unique_functions(value):
+            raise Exception('Cannot have 2 functions by the same name in one module.')
+
+    @staticmethod
+    def unique_functions(functions: list):
+        return len(functions) == len(set([function.name for function in functions]))
+
+    @name.default
+    def set_name(self):
+        logger.warning('No module name was given. Using default name: {}'.format(
+            entities.package_defaults.DEFAULT_PACKAGE_MODULE_NAME))
+        return entities.package_defaults.DEFAULT_PACKAGE_MODULE_NAME
+
+    @init_inputs.default
+    def set_init_inputs(self):
+        return list()
+
+    @classmethod
+    def from_json(cls, _json):
+        inst = cls(_dict=_json)
+        return inst
+
+    @classmethod
+    def from_entry_point(cls, entry_point):
+        """
+        Create a dl.PackageModule entity using decorator on the service class.
+
+        :param entry_point: path to the python file with the runner class (relative to the package path)
+        :return:
+        """
+        file_spec = importlib.util.spec_from_file_location(entry_point, entry_point)
+        file_module = importlib.util.module_from_spec(file_spec)
+        file_spec.loader.exec_module(file_module)
+        module = None
+        for cls_name, cls_inst in inspect.getmembers(file_module, predicate=inspect.isclass):
+            spec = getattr(cls_inst, '__dtlpy__', None)
+            if spec is not None:
+                functions = spec['functions']
+                available_methods = [name for name in ['train', 'predict']
+                                     if 'BaseModelAdapter' not in getattr(cls_inst, name).__qualname__]
+                if "train" not in available_methods:
+                    # remove train_model from functions list if train is not available
+                    functions[:] = [d for d in functions if d.get('name') != "train_model"]
+                if "predict" not in available_methods:
+                    # remove predict_items from functions list if predict is not available
+                    functions[:] = [d for d in functions if d.get('name') != "predict_items"]
+                if "extract_features" not in available_methods:
+                    # remove extract_item_features from functions list if extract_features is not available
+                    functions[:] = [d for d in functions if d.get('name') != "extract_item_features"]
+                spec['entryPoint'] = entry_point
+                spec['functions'] = functions
+                module = cls.from_json(spec)
+                break
+        if module is None:
+            raise ValueError('Failed to find a decorated Runner class in file: {}'.format(entry_point))
+        return module
+
+    def add_function(self, function):
+        """
+        :param function:
+        """
+        if not isinstance(self.functions, list):
+            self.functions = [self.functions]
+        if isinstance(function, entities.PackageFunction):
+            self.functions.append(function)
+        elif isinstance(function, dict):
+            self.functions.append(entities.PackageFunction.from_json(function))
+        else:
+            raise ValueError('Unknown function type: {}. Expecting dl.PackageFunction or dict')
+
+    def to_json(self):
+        _json = self._dict.copy()
+        return _json