dtlpy 1.118.14__py3-none-any.whl → 1.119.5__py3-none-any.whl

dtlpy/entities/dpk.py

@@ -1,10 +1,15 @@
 from collections import namedtuple
-from typing import List, Union
+from typing import List, Union, Tuple
 import traceback
 import enum
+import tempfile
+import inspect
+import os
+import typing
 
-from .. import entities, repositories, exceptions
+from .. import entities, repositories, exceptions, assets
 from ..services.api_client import ApiClient
+from . import package_defaults
 
 
 class SlotType(str, enum.Enum):
@@ -29,6 +34,18 @@ DEFAULT_STOPS = {SlotType.ITEM_VIEWER: {"type": "itemViewer",
                                             }
                  }
 
+DEFAULT_RUNTIME = {
+    "podType": "regular-xs",
+    "concurrency": 1,
+    "runnerImage": "docker.io/dataloopai/dtlpy-agent:cpu.py3.10.opencv",
+    "autoscaler": {
+        "type": "rabbitmq",
+        "minReplicas": 0,
+        "maxReplicas": 2,
+        "queueLength": 100
+    }
+}
+
 
 class Slot(entities.DlEntity):
     type: str = entities.DlProperty(location=['type'], _type=str)
@@ -468,3 +485,299 @@ class Dpk(entities.DlEntity):
         )
 
         return res
+
+    @staticmethod
+    def _parse_function_io(func) -> Tuple[List[dict], List[dict]]:
+        """
+        Parse function inputs and outputs from function signature and type hints.
+        
+        This helper function extracts:
+        - Inputs: from function parameters (inspect.signature)
+        - Outputs: from return type hints (typing.get_type_hints)
+        
+        :param func: The function to parse
+        :return: Tuple of (inputs, outputs) where each is a list of dicts with 'name' and 'type' keys
+        :rtype: Tuple[List[dict], List[dict]]
+        """
+        # ============================================
+        # PARSE INPUTS FROM FUNCTION SIGNATURE
+        # ============================================
+        # Get all parameter names from the function signature
+        params = list(inspect.signature(func).parameters)
+        inputs = []
+        
+        # Create a mapping of known input type names (lowercase) to PackageInputType values
+        # This allows matching parameter names like 'item', 'items', 'annotation', etc. to their types
+        inputs_types = {i.name.lower(): i.value for i in list(entities.PackageInputType)}
+        
+        # Process each parameter
+        for arg in params:
+            # Check if the parameter name matches a known PackageInputType (case-insensitive)
+            # For example: 'item' -> PackageInputType.ITEM, 'items' -> PackageInputType.ITEMS
+            if arg in inputs_types:
+                inpt_type = inputs_types[arg]
+            else:
+                # If parameter name doesn't match a known type, default to JSON
+                inpt_type = entities.PackageInputType.JSON
+            
+            # Create input dict with name and type
+            inputs.append({
+                'name': arg,
+                'type': inpt_type
+            })
+        
+        # ============================================
+        # PARSE OUTPUTS FROM TYPE HINTS
+        # ============================================
+        outputs = []
+        try:
+            # Get return type hint from function annotations
+            # Returns None if no return type is specified
+            hint_outputs = typing.get_type_hints(func).get('return', None)
+            
+            if hint_outputs is not None:
+                # ============================================
+                # STEP 1: Extract output types from type hint
+                # ============================================
+                # Handle different return type patterns:
+                # - Tuple[Type1, Type2, ...] -> multiple outputs
+                # - List[Type] -> single output that's a list
+                # - Type -> single output
+                output_types = []
+                
+                if hasattr(hint_outputs, '__origin__') and hint_outputs.__origin__ is tuple:
+                    # Multiple returns: Tuple[Type1, Type2, ...]
+                    # Extract all types from the tuple
+                    output_types = list(hint_outputs.__args__) if hasattr(hint_outputs, '__args__') else []
+                elif hasattr(hint_outputs, '__args__'):
+                    # Single generic type (e.g., List[Item], Dict[str, int])
+                    # Extract the inner type from the generic
+                    output_types = [hint_outputs.__args__[0]]
+                else:
+                    # Single simple type (e.g., Item, str, int)
+                    output_types = [hint_outputs]
+                
+                # ============================================
+                # STEP 2: Process each output type
+                # ============================================
+                for idx, output_type in enumerate(output_types):
+                    io_type = output_type
+                    is_list = False
+                    
+                    # ============================================
+                    # STEP 2a: Check if it's a List type
+                    # ============================================
+                    # Handle List[Type] patterns (e.g., List[Item], List[Annotation])
+                    if hasattr(io_type, '__origin__'):
+                        origin = io_type.__origin__
+                        origin_str = str(origin)
+                        
+                        # Check if origin is list or typing.List
+                        # This handles both 'list' and 'typing.List' cases
+                        if origin is list or origin_str.startswith('typing.List') or origin_str.startswith('<class \'list\'>'):
+                            is_list = True
+                            # Extract inner type from List[InnerType]
+                            # Example: List[Item] -> extract 'Item'
+                            if hasattr(io_type, '__args__') and len(io_type.__args__) > 0:
+                                io_type = io_type.__args__[0]
+                    
+                    # ============================================
+                    # STEP 2b: Handle special type cases
+                    # ============================================
+                    # Handle Enum types - convert to string name
+                    if isinstance(io_type, enum.Enum):
+                        io_type = io_type.name
+                    
+                    # Handle nested generic types (only if not already extracted from List)
+                    # Example: Optional[List[Item]] -> extract List[Item] first, then Item
+                    if not is_list and hasattr(io_type, '__args__'):
+                        io_type = io_type.__args__[0]
+                    
+                    # ============================================
+                    # STEP 2c: Extract type name as string
+                    # ============================================
+                    # Convert type to string representation
+                    if isinstance(io_type, type):
+                        # Direct type object (e.g., Item class) -> get class name
+                        type_str = io_type.__name__
+                    else:
+                        # Type hint object -> convert to string
+                        type_str = str(io_type)
+                        # Extract class name from fully qualified name
+                        # Example: "dtlpy.entities.item.Item" -> "Item"
+                        if '.' in type_str:
+                            type_str = type_str.rsplit('.', maxsplit=1)[-1]
+                    
+                    # ============================================
+                    # STEP 2d: Map type string to PackageInputType
+                    # ============================================
+                    # Map Python type names to PackageInputType enum values
+                    # Special case: 'str' maps to STRING
+                    if type_str == 'str':
+                        mapped_type = entities.PackageInputType.STRING
+                    else:
+                        mapped_type = None
+                        
+                        # If it's a list, try to find the array version first
+                        # Example: Item -> ITEMS, Annotation -> ANNOTATIONS
+                        if is_list:
+                            array_type_name = f"{type_str.upper()}S"  # Item -> ITEMS
+                            for pkg_input_type in entities.PackageInputType:
+                                if pkg_input_type.name.upper() == array_type_name:
+                                    mapped_type = pkg_input_type
+                                    break
+                        
+                        # If not found or not a list, try the regular type
+                        # Example: Item -> ITEM, Annotation -> ANNOTATION
+                        if mapped_type is None:
+                            for pkg_input_type in entities.PackageInputType:
+                                if pkg_input_type.name.upper() == type_str.upper():
+                                    mapped_type = pkg_input_type
+                                    break
+                        
+                        # Default to JSON if no match found
+                        # This handles unknown types gracefully
+                        if mapped_type is None:
+                            mapped_type = entities.PackageInputType.JSON
+                    
+                    # ============================================
+                    # STEP 2e: Create output dict
+                    # ============================================
+                    # Name outputs: 'output' for single, 'output_0', 'output_1', etc. for multiple
+                    output_name = 'output' if len(output_types) == 1 else f'output_{idx}'
+                    outputs.append({
+                        'name': output_name,
+                        'type': mapped_type
+                    })
+        except Exception:
+            # If type hints extraction fails (e.g., no type hints, invalid syntax),
+            # leave outputs empty - this is not a fatal error
+            pass
+        
+        return inputs, outputs
+
+    @classmethod
+    def from_function(
+        cls,
+        func,
+        name: str = None,
+        version: str = '1.0.0',
+        description: str = None,
+        project: 'entities.Project' = None,
+        client_api: ApiClient = None,
+        scope: str = 'project',
+        runtime: dict = None,
+        execution_timeout: int = 3600,
+    ) -> 'entities.Dpk':
+        """
+        Build a DPK from a Python function (codebase + components). Does not publish or install.
+        Runtime is held on the service component (modules have no runtime). Use the runtime param to override defaults.
+
+        :param Callable func: Function to deploy
+        :param str name: DPK name (default: function __name__)
+        :param str version: DPK version (default: '1.0.0')
+        :param str description: DPK description
+        :param entities.Project project: Project (required)
+        :param ApiClient client_api: API client (required)
+        :param str scope: 'project' or 'organization'
+        :param dict runtime: podType, concurrency, runnerImage, autoscaler; default: DEFAULT_RUNTIME
+        :param int execution_timeout: Service timeout in seconds (default: 3600)
+        :return: Built DPK (with codebase); use Service.from_function to publish, install, and get the Service
+        :rtype: dtlpy.entities.Dpk
+        """
+        if client_api is None:
+            raise ValueError('client_api is required')
+        if project is None:
+            raise ValueError('project is required for codebase packing')
+
+        # Get function name if name not provided
+        if name is None:
+            name = func.__name__
+
+        # Resolve runtime: use copy to avoid mutating caller's dict or DEFAULT_RUNTIME
+        if runtime is None:
+            runtime = dict(DEFAULT_RUNTIME)
+        else:
+            runtime = dict(runtime)
+
+        # Create temporary directory for the function code
+        dpk_dir = tempfile.mkdtemp()
+
+        # Create main.py file with the function
+        main_file = os.path.join(dpk_dir, package_defaults.DEFAULT_PACKAGE_ENTRY_POINT)
+
+        # Read the partial main template (ServiceRunner class structure)
+        with open(assets.paths.PARTIAL_MAIN_FILEPATH, 'r') as f:
+            main_template = f.read()
+
+        # Extract function source code and adjust indentation
+        lines = inspect.getsourcelines(func)
+        tabs_diff = lines[0][0].count('    ') - 1
+        for line_index in range(len(lines[0])):
+            line_tabs = lines[0][line_index].count('    ') - tabs_diff
+            lines[0][line_index] = ('    ' * line_tabs) + lines[0][line_index].strip() + '\n'
+
+        method_func_string = "".join(lines[0])
+
+        # Write main.py with ServiceRunner class and function
+        with open(main_file, 'w') as f:
+            f.write(f'{main_template}\n    @staticmethod\n{method_func_string}')
+
+        # Parse function inputs and outputs from signature and type hints
+        inputs, outputs = cls._parse_function_io(func)
+
+        # Build module dict (no runtime on module/functions)
+        function_dict = {
+            'name': func.__name__,
+            'input': inputs,
+            'output': outputs,
+        }
+        module_dict = {
+            'name': package_defaults.DEFAULT_PACKAGE_MODULE_NAME,
+            'entryPoint': package_defaults.DEFAULT_PACKAGE_ENTRY_POINT,
+            'className': package_defaults.DEFAULT_PACKAGE_CLASS_NAME,
+            'functions': [function_dict],
+        }
+
+        # Service component (smart-search style): holds runtime, references module
+        service_name = f"{name}-service".replace("_", "-")
+        service_entry = {
+            "name": service_name,
+            "moduleName": package_defaults.DEFAULT_PACKAGE_MODULE_NAME,
+            "packageRevision": "latest",
+            "runtime": runtime,
+            "executionTimeout": execution_timeout,
+        }
+
+        components_dict = {
+            "modules": [module_dict],
+            "services": [service_entry],
+        }
+
+        # Create DPK entity
+        dpk_json = {
+            'name': name,
+            'version': version,
+            'display_name': name,
+            'description': description or f'DPK created from function {func.__name__}',
+            'scope': scope,
+            'components': components_dict,
+            'context': {
+                'project': project.id
+            }
+        }
+
+        dpk = cls.from_json(
+            _json=dpk_json,
+            client_api=client_api,
+            project=project
+        )
+
+        # Pack the temporary directory as codebase
+        dpk.codebase = project.codebases.pack(
+            directory=dpk_dir,
+            name=name,
+            extension='dpk'
+        )
+
+        return dpk

dtlpy/entities/model.py

@@ -51,29 +51,6 @@ class PlotSample:
         return _json
 
 
-# class MatrixSample:
-#     def __init__(self, figure, legend, x, y):
-#         """
-#         Create a single metric sample for Model
-#
-#         :param figure: figure name identifier
-#         :param legend: line name identifier
-#         :param x: x value for the current sample
-#         :param y: y value for the current sample
-#         """
-#         self.figure = figure
-#         self.legend = legend
-#         self.x = x
-#         self.y = y
-#
-#     def to_json(self) -> dict:
-#         _json = {'figure': self.figure,
-#                  'legend': self.legend,
-#                  'data': {'x': self.x,
-#                           'y': self.y}}
-#         return _json
-
-
 @attr.s
 class Model(entities.BaseEntity):
     """

dtlpy/entities/service.py

@@ -8,6 +8,7 @@ from urllib.parse import urlsplit
 import attr
 from .. import repositories, entities
 from ..services.api_client import ApiClient
+from .dpk import Dpk
 
 logger = logging.getLogger(name='dtlpy')
 
@@ -359,6 +360,50 @@ class Service(entities.BaseEntity):
         inst.is_fetched = is_fetched
         return inst
 
+    @classmethod
+    def from_function(
+        cls,
+        func,
+        name: str = None,
+        version: str = '1.0.0',
+        description: str = None,
+        project: 'entities.Project' = None,
+        client_api: ApiClient = None,
+        scope: str = 'project',
+        runtime: dict = None,
+        execution_timeout: int = 3600,
+    ) -> 'Service':
+        """
+        Create a Service from a Python function: build DPK via Dpk.from_function, then publish, install, and return the Service.
+        """        
+        built_dpk = Dpk.from_function(
+            func=func,
+            name=name,
+            version=version,
+            description=description,
+            project=project,
+            client_api=client_api,
+            scope=scope,
+            runtime=runtime,
+            execution_timeout=execution_timeout,
+        )
+        published_dpk = project.dpks.publish(dpk=built_dpk)
+        app = project.apps.install(dpk=published_dpk, app_name=published_dpk.display_name)
+        service_name = f"{built_dpk.name}-service".replace("_", "-")
+        filters = entities.Filters(
+            resource=entities.FiltersResource.SERVICE,
+            field='name',
+            values=service_name,
+            use_defaults=False
+        )
+        services = project.services.list(filters=filters)
+        if services.items_count == 0:
+            raise RuntimeError(
+                "No service found with name %s for installed app (app id=%s). "
+                "The app was installed but the service may not be listed yet." % (service_name, app.id)
+            )
+        return services.items[0]
+
     ############
     # Entities #
     ############
@@ -397,7 +442,7 @@ class Service(entities.BaseEntity):
                         dpk_id=dpk_id,
                         version=dpk_version)
 
-                assert isinstance(self._package, entities.Dpk)
+                assert isinstance(self._package, Dpk)
             except:
                 self._package = repositories.Packages(client_api=self._client_api).get(package_id=self.package_id,
                                                                                        fetch=None,

dtlpy/repositories/annotations.py

@@ -653,7 +653,8 @@ class Annotations:
                                 not a.get('clean', False) and a.get("metadata", {}).get('system', {}).get('objectId',
                                                                                                           None) ==
                                 annotation.get("metadata", {}).get('system', {}).get('objectId', None) and a['label'] ==
-                                annotation['label']]
+                                annotation['label']
+                                and a['type'] == annotation['type']]
                     if len(to_merge) == 0:
                         # no annotation to merge with
                         continue
@@ -677,7 +678,8 @@ class Annotations:
                     to_merge = [a for a in exist_annotations if
                                 a.object_id == ann.get("metadata", {}).get('system', {}).get('objectId',
                                                                                              None) and a.label == ann[
-                                    'label']]
+                                    'label']
+                                and a.type == ann['type']]
                     if len(to_merge) == 0:
                         # no annotation to merge with
                         continue

dtlpy/repositories/apps.py

@@ -11,7 +11,7 @@ class Apps:
     def __init__(self, client_api: ApiClient, project: entities.Project = None, project_id: str = None):
         self._client_api = client_api
         self._project = project
-        self._project_id = project_id 
+        self._project_id = project_id
         self._commands = None
 
     @property

dtlpy/repositories/computes.py

@@ -358,7 +358,7 @@ class Computes:
             project_id = project.id
         compute = self.create(
             config['config']['name'],
-            ComputeContext([], org_id, project_id),
+            ComputeContext(labels=[], org=org_id, project=project_id),
             [],
             cluster,
             ComputeType.KUBERNETES,

dtlpy/repositories/feature_sets.py

@@ -223,7 +223,7 @@ class FeatureSets:
 
     @_api_reference.add(path='/features/sets', method='post')
     def create(
-        self, name: str, size: int, set_type: str, entity_type: entities.FeatureEntityType, project_id: str = None, model_id: set = None, org_id: str = None
+        self, name: str, size: int, set_type: str, entity_type: entities.FeatureEntityType, project_id: str = None, model_id: str = None, org_id: str = None
     ):
         """
         Create a new Feature Set