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

dtlpy/__init__.py

@@ -108,7 +108,7 @@ from .entities import (
     # compute
     ClusterProvider, ComputeType, ComputeStatus, Toleration, DeploymentResource, DeploymentResources,
     NodePool, AuthenticationIntegration, Authentication, ComputeCluster, ComputeContext, Compute, KubernetesCompute,
-    ServiceDriver
+    ServiceDriver, ExportType, OutputExportType
 )
 from .ml import BaseModelAdapter
 from .utilities import Converter, BaseServiceRunner, Progress, Context, AnnotationFormat

dtlpy/__version__.py

@@ -1 +1 @@
-version = '1.114.16'
+version = '1.115.44'

dtlpy/entities/__init__.py

@@ -22,7 +22,7 @@ from .trigger import Trigger, TriggerResource, TriggerAction, TriggerExecutionMo
     TriggerType
 from .project import Project, MemberRole
 from .artifact import ItemArtifact, LocalArtifact, LinkArtifact, ArtifactType, Artifact
-from .dataset import Dataset, ExpirationOptions, IndexDriver, ExportType
+from .dataset import Dataset, ExpirationOptions, IndexDriver, ExportType, OutputExportType
 from .codebase import Codebase
 from .annotation import Annotation, FrameAnnotation, ViewAnnotationOptions, AnnotationStatus, AnnotationType, \
     ExportVersion

dtlpy/entities/analytic.py

@@ -75,7 +75,15 @@ class ServiceSample(BaseSample):
                  service_type: entities.ServiceType = None,
                  interval: int = None,
                  driver_id: str = None,
-                 other_keys: dict = None
+                 other_keys: dict = None,
+                 concurrency_limit: int = None,
+                 concurrency_count: int = None,
+                 cpu_limit: int = None,
+                 ram_limit: int = None,
+                 gpu_limit: int = None,
+                 gpu: int = None,
+                 gpu_memory: int = None,
+                 gpu_memory_limit: int = None
                  ):
         super().__init__(
             start_time=start_time,
@@ -102,6 +110,14 @@ class ServiceSample(BaseSample):
         self.service_type = service_type if service_type is not None else entities.ServiceType.REGULAR
         self.interval = interval
         self.driver_id = driver_id
+        self.concurrency_limit = concurrency_limit
+        self.concurrency_count = concurrency_count
+        self.cpu_limit = cpu_limit
+        self.ram_limit = ram_limit
+        self.gpu_limit = gpu_limit
+        self.gpu = gpu
+        self.gpu_memory = gpu_memory
+        self.gpu_memory_limit = gpu_memory_limit
 
     def to_json(self):
         _json = super().to_json()
@@ -120,7 +136,15 @@ class ServiceSample(BaseSample):
             'queueSize': self.queue_size,
             'numExecutions': self.num_executions,
             'interval': self.interval,
-            'driverId': self.driver_id
+            'driverId': self.driver_id,
+            'concurrencyLimit': self.concurrency_limit,
+            'concurrencyCount': self.concurrency_count,
+            'cpuLimit': self.cpu_limit,
+            'ramLimit': self.ram_limit,
+            'gpuLimit': self.gpu_limit,
+            'gpu': self.gpu,
+            'gpuMemory': self.gpu_memory,
+            'gpuMemoryLimit': self.gpu_memory_limit
         })
         _json.update({
             'entityType': self.entity_type
@@ -153,7 +177,15 @@ class ServiceSample(BaseSample):
             num_executions=_json.get('data', {}).get('numExecutions', None),
             service_type=_json.get('type', entities.ServiceType.REGULAR),
             interval=_json.get('data', {}).get('interval', None),
-            driver_id=_json.get('data', {}).get('driverId', None)
+            driver_id=_json.get('data', {}).get('driverId', None),
+            concurrency_limit=_json.get('data', {}).get('concurrencyLimit', None),
+            concurrency_count=_json.get('data', {}).get('concurrencyCount', None),
+            cpu_limit=_json.get('data', {}).get('cpuLimit', None),
+            ram_limit=_json.get('data', {}).get('ramLimit', None),
+            gpu_limit=_json.get('data', {}).get('gpuLimit', None),
+            gpu=_json.get('data', {}).get('gpu', None),
+            gpu_memory=_json.get('data', {}).get('gpuMemory', None),
+            gpu_memory_limit=_json.get('data', {}).get('gpuMemoryLimit', None)
         )
         return inst
 
@@ -177,7 +209,8 @@ class ExecutionSample(BaseSample):
                  trigger_id=None,
                  function_name=None,
                  duration=None,
-                 other_keys: dict = None
+                 other_keys: dict = None,
+                 function_duration=None
                  ):
         super().__init__(
             start_time=start_time,
@@ -199,6 +232,7 @@ class ExecutionSample(BaseSample):
         self.trigger_id = trigger_id
         self.function_name = function_name
         self.duration = duration
+        self.function_duration = function_duration
 
     def to_json(self):
         _json = super().to_json()
@@ -212,7 +246,8 @@ class ExecutionSample(BaseSample):
         })
         _json['data'].update({
             'functionName': self.function_name,
-            'duration': self.duration
+            'duration': self.duration,
+            'functionDuration': self.function_duration,
         })
         _json['context'] = {k: v for k, v in _json['context'].items() if v is not None}
         _json['data'] = {k: v for k, v in _json['data'].items() if v is not None}
@@ -237,7 +272,8 @@ class ExecutionSample(BaseSample):
             action=_json.get('action', None),
             status=_json.get('data', {}).get('status', None),
             function_name=_json.get('data', {}).get('functionName', None),
-            duration=_json.get('data', {}).get('duration', None)
+            duration=_json.get('data', {}).get('duration', None),
+            function_duration=_json.get('data', {}).get('functionDuration', None)
         )
         return inst
 

dtlpy/entities/codebase.py

@@ -59,12 +59,8 @@ class GitCodebase(entities.DlEntity):
     @property
     def codebases(self):
         if self._codebases is None:
-            if self._item is not None:
-                dataset = self.item.dataset
-            else:
-                dataset = None
             self._codebases = repositories.Codebases(client_api=self.client_api,
-                                                     dataset=dataset)
+                                                     dataset=None)
         assert isinstance(self._codebases, repositories.Codebases)
         return self._codebases
 

dtlpy/entities/compute.py

@@ -217,7 +217,8 @@ class ComputeCluster:
             node_pools: Optional[List[NodePool]] = None,
             metadata: Optional[Dict] = None,
             authentication: Optional[Authentication] = None,
-            plugins: Optional[dict] = None
+            plugins: Optional[dict] = None,
+            deployment_configuration: Optional[Dict] = None
     ):
         self.name = name
         self.endpoint = endpoint
@@ -228,6 +229,9 @@ class ComputeCluster:
         self.authentication = authentication if authentication is not None else Authentication(
             AuthenticationIntegration("", ""))
         self.plugins = plugins
+        self.deployment_configuration = deployment_configuration if deployment_configuration is not None else {}
+
+
 
     @classmethod
     def from_json(cls, _json):
@@ -239,7 +243,8 @@ class ComputeCluster:
             node_pools=[NodePool.from_json(np) for np in _json.get('nodePools', list())],
             metadata=_json.get('metadata'),
             authentication=Authentication.from_json(_json.get('authentication', dict())),
-            plugins=_json.get('plugins')
+            plugins=_json.get('plugins'),
+            deployment_configuration=_json.get('deploymentConfiguration'),
         )
 
     def to_json(self):
@@ -251,7 +256,8 @@ class ComputeCluster:
             'nodePools': [np.to_json() for np in self.node_pools],
             'metadata': self.metadata,
             'authentication': self.authentication.to_json(),
-            'plugins': self.plugins
+            'plugins': self.plugins,
+            'deploymentConfiguration':  self.deployment_configuration
         }
 
     @classmethod
@@ -265,7 +271,8 @@ class ComputeCluster:
             node_pools=node_pools,
             metadata={},
             authentication=Authentication(AuthenticationIntegration(integration.id, integration.type)),
-            plugins=devops_output['config'].get('plugins')
+            plugins=devops_output['config'].get('plugins'),
+            deployment_configuration=devops_output['config'].get('deploymentConfiguration', {})
         )
 
 
@@ -422,7 +429,7 @@ class KubernetesCompute(Compute):
             metadata=_json.get('metadata'),
             client_api=client_api,
             settings=ComputeSettings.from_json(_json.get('settings', dict())) if _json.get('settings') else None,
-            url=_json.get('url'),
+            url=_json.get('url')
         )
 
     def to_json(self):

dtlpy/entities/dataset.py

@@ -22,6 +22,10 @@ class ExportType(str, Enum):
     JSON = "json"
     ZIP = "zip"
 
+class OutputExportType(str, Enum):
+    JSON = "json"
+    ZIP = "zip"
+    FOLDERS = "folders"
 
 class ExpirationOptions:
     """
@@ -703,7 +707,8 @@ class Dataset(entities.BaseEntity):
                timeout: int = 0,
                dataset_lock: bool = False,
                lock_timeout_sec: int = None,
-               export_summary: bool = False):
+               export_summary: bool = False,
+               output_export_type: OutputExportType = None):
         """
         Export dataset items and annotations.
 
@@ -721,6 +726,7 @@ class Dataset(entities.BaseEntity):
         :param bool export_summary: Download dataset export summary
         :param int lock_timeout_sec: Timeout for locking the dataset during export in seconds
         :param entities.ExportType export_type: Type of export ('json' or 'zip')
+        :param entities.OutputExportType output_export_type: Output format ('json', 'zip', or 'folders'). If None, defaults to 'json'
         :param int timeout: Maximum time in seconds to wait for the export to complete
         :return: Exported item
         :rtype: dtlpy.entities.item.Item
@@ -732,7 +738,8 @@ class Dataset(entities.BaseEntity):
             export_item = dataset.export(filters=filters,
                                          include_feature_vectors=True,
                                          include_annotations=True,
-                                         export_type=dl.ExportType.JSON)
+                                         export_type=dl.ExportType.JSON,
+                                         output_export_type=dl.OutputExportType.JSON)
         """
 
         return self.datasets.export(dataset=self,
@@ -746,7 +753,8 @@ class Dataset(entities.BaseEntity):
                                     timeout=timeout,
                                     dataset_lock=dataset_lock,
                                     lock_timeout_sec=lock_timeout_sec,
-                                    export_summary=export_summary)
+                                    export_summary=export_summary,
+                                    output_export_type=output_export_type)
 
     def upload_annotations(self,
                            local_path,
@@ -984,6 +992,7 @@ class Dataset(entities.BaseEntity):
             dataset_lock=False,
             lock_timeout_sec=None,
             export_summary=False,
+            raise_on_error=False
     ):
         """
         Download dataset by filters.
@@ -1007,6 +1016,7 @@ class Dataset(entities.BaseEntity):
         :param bool without_relative_path: bool - download items without the relative path from platform
         :param float alpha: opacity value [0 1], default 1
         :param str export_version:  `V2` - exported items will have original extension in filename, `V1` - no original extension in filenames
+        :param bool raise_on_error: raise an exception if an error occurs
         :return: `List` of local_path per each downloaded item
 
         **Example**:
@@ -1038,7 +1048,8 @@ class Dataset(entities.BaseEntity):
                                    export_version=export_version,
                                    dataset_lock=dataset_lock,
                                    lock_timeout_sec=lock_timeout_sec,
-                                   export_summary=export_summary
+                                   export_summary=export_summary,
+                                   raise_on_error=raise_on_error
                                    )
 
     def download_folder(
@@ -1059,6 +1070,7 @@ class Dataset(entities.BaseEntity):
             dataset_lock=False,
             lock_timeout_sec=None,
             export_summary=False,
+            raise_on_error=False
     ):
         """
         Download dataset folder.
@@ -1082,6 +1094,7 @@ class Dataset(entities.BaseEntity):
         :param bool without_relative_path: bool - download items without the relative path from platform
         :param float alpha: opacity value [0 1], default 1
         :param str export_version:  `V2` - exported items will have original extension in filename, `V1` - no original extension in filenames
+        :param bool raise_on_error: raise an exception if an error occurs
         :return: `List` of local_path per each downloaded item
 
         **Example**:
@@ -1116,7 +1129,8 @@ class Dataset(entities.BaseEntity):
                                    export_version=export_version,
                                    dataset_lock=dataset_lock,
                                    lock_timeout_sec=lock_timeout_sec,
-                                    export_summary=export_summary
+                                    export_summary=export_summary,
+                                    raise_on_error=raise_on_error
                                    )
 
     def delete_labels(self, label_names):

dtlpy/entities/driver.py

@@ -51,6 +51,12 @@ class Driver(entities.BaseEntity):
     name = attr.ib()
     id = attr.ib()
     path = attr.ib()
+    bucket_name = attr.ib()
+    end_point = attr.ib()
+    elastic_index = attr.ib()
+    elastic_index_path = attr.ib()
+    directory = attr.ib()
+    mount_path = attr.ib()
     # api
     _client_api = attr.ib(type=ApiClient, repr=False)
     _repositories = attr.ib(repr=False)
@@ -89,7 +95,14 @@ class Driver(entities.BaseEntity):
                    name=_json.get('name', None),
                    id=_json.get('id', None),
                    client_api=client_api,
-                   path=_json.get('path', None))
+                   path=_json.get('path', None),
+                   bucket_name=_json.get('bucketName', None),
+                   end_point=_json.get('endpoint', None),
+                   elastic_index=_json.get('elasticIndex', None),
+                   elastic_index_path=_json.get('elasticIndexPath', None),
+                   directory=_json.get('directory', None),
+                   mount_path=_json.get('mountPath', None)
+                   )
 
         inst.is_fetched = is_fetched
         return inst
@@ -108,7 +121,6 @@ class Driver(entities.BaseEntity):
                                                               attr.fields(Driver).created_at,
                                                               attr.fields(Driver).integration_id,
                                                               attr.fields(Driver).integration_type,
-                                                              attr.fields(Driver).path
                                                               ))
         output_dict['allowExternalDelete'] = self.allow_external_delete
         output_dict['allowExternalModification'] = self.allow_external_modification

dtlpy/entities/filters.py

@@ -1,10 +1,17 @@
+import numpy as np
 import urllib.parse
 import logging
 import json
 import os
 import io
-from enum import Enum
+import copy
+from typing import Generator, Tuple, Optional
+from collections import deque
+from concurrent.futures import ThreadPoolExecutor, wait, FIRST_COMPLETED
+from bson import ObjectId
+
 
+from enum import Enum
 from .. import exceptions, entities
 
 logger = logging.getLogger(name="dtlpy")
@@ -62,6 +69,8 @@ class FiltersOperations(str, Enum):
     EXISTS = "exists"
     MATCH = "match"
     NIN = "nin"
+    GREATER_THAN_OR_EQUAL = "gte"
+    LESS_THAN_OR_EQUAL = "lte"
 
 
 class FiltersMethod(str, Enum):
@@ -215,9 +224,15 @@ class Filters:
 
     def __override(self, field, values, operator=None):
         if field in self._unique_fields:
+            indices_to_remove = []
             for i_single_filter, single_filter in enumerate(self.and_filter_list):
                 if single_filter.field == field:
-                    self.and_filter_list.pop(i_single_filter)
+                    indices_to_remove.append(i_single_filter)
+            
+            # Remove indices in descending order to avoid IndexError
+            # When removing items, indices shift down, so we must remove from highest to lowest
+            for index in sorted(indices_to_remove, reverse=True):
+                self.and_filter_list.pop(index)
         self.and_filter_list.append(SingleFilter(field=field, values=values, operator=operator))
 
     def generate_url_query_params(self, url):
@@ -366,7 +381,11 @@ class Filters:
             query_dict["join"] = self.join
         if "join" in query_dict and "on" not in query_dict["join"]:
             if self.resource == FiltersResource.ITEM:
-                query_dict["join"]["on"] = {"resource": FiltersResource.ANNOTATION.value, "local": "itemId", "forigen": "id"}
+                query_dict["join"]["on"] = {
+                    "resource": FiltersResource.ANNOTATION.value,
+                    "local": "itemId",
+                    "forigen": "id",
+                }
             else:
                 query_dict["join"]["on"] = {"resource": FiltersResource.ITEM.value, "local": "id", "forigen": "itemId"}
 
@@ -599,6 +618,140 @@ class Filters:
         names = [i.name for i in all_filter_items]
         return names
 
+    @staticmethod
+    def _get_split_filters(dataset, filters, max_items, max_workers=4, max_depth=None) -> Generator[dict, None, None]:
+        """
+        Generator that yields filter chunks for large datasets using a bounded
+        thread pool. Splits ranges by id until each subset holds <= max_items.
+
+        :param dataset: Dataset object to get filters for
+        :param filters: Base filters to apply
+        :param max_items: Maximum number of items per filter chunk
+        :param max_workers: Maximum number of threads for parallel processing
+        :param max_depth: Maximum depth of the filter tree. Default calculated by the formula: np.ceil(np.log2(count/max_items) + 3).
+        :yield: Filter payloads covering subsets of items
+        """
+        if max_items <= 0:
+            raise ValueError("_get_split_filters : max_items must be greater than 0")
+
+        if filters is None:
+            filters = entities.Filters()
+
+        from_id, count = Filters._get_first_last_item(
+            items_repo=dataset.items, filters=filters, order_by_direction=FiltersOrderByDirection.ASCENDING
+        )
+        to_id, count = Filters._get_first_last_item(
+            items_repo=dataset.items, filters=filters, order_by_direction=FiltersOrderByDirection.DESCENDING
+        )
+
+        if from_id is None or to_id is None or count == 0:
+            return
+
+        max_depth = max_depth if max_depth is not None else np.ceil(np.log2(count / max_items) + 3)
+
+        def make_filter_dict(range_from_id, range_to_id, strict_from: bool = False):
+            fdict = copy.deepcopy(filters.prepare())
+            lower_op = "$gt" if strict_from else "$gte"
+            fdict["filter"].setdefault("$and", []).extend(
+                [{"id": {lower_op: range_from_id}}, {"id": {"$lte": range_to_id}}]
+            )
+            return fdict
+
+        def task(range_from_id, range_to_id, depth, strict_from: bool):
+            fdict = make_filter_dict(range_from_id, range_to_id, strict_from)
+            range_filters = entities.Filters(custom_filter=fdict, page_size=1)
+            actual_from, count = Filters._get_first_last_item(
+                dataset.items, range_filters, FiltersOrderByDirection.ASCENDING
+            )
+            if count == 0:
+                return ("none", None, None)
+            if count <= max_items or depth >= max_depth:
+                return ("yield", fdict, None)
+            actual_to, count = Filters._get_first_last_item(
+                dataset.items, range_filters, FiltersOrderByDirection.DESCENDING
+            )
+            if not actual_from or not actual_to or actual_from == actual_to:
+                return ("yield", fdict, None)
+            mid = Filters._get_middle_id(actual_from, actual_to)
+            if not mid or mid == actual_from or mid == actual_to:
+                return ("yield", fdict, None)
+            # Left child: [actual_from, mid] inclusive; Right child: (mid, actual_to] exclusive lower bound
+            return (
+                "split",
+                None,
+                (
+                    (actual_from, mid, depth + 1, False),  # left child includes lower bound
+                    (mid, actual_to, depth + 1, True),  # right child excludes midpoint
+                ),
+            )
+
+        pending = deque([(from_id, to_id, 0, False)])
+        futures = set()
+
+        with ThreadPoolExecutor(max_workers=max_workers) as pool:
+            while futures or pending:
+                # Submit all pending tasks
+                while pending:
+                    fr, to, d, strict = pending.popleft()
+                    futures.add(pool.submit(task, fr, to, d, strict))
+
+                if not futures:
+                    break
+
+                done, futures = wait(futures, return_when=FIRST_COMPLETED)
+                for fut in done:
+                    try:
+                        kind, fdict, ranges = fut.result()
+                    except Exception as e:
+                        logger.warning(f"split filters task failed: {e}")
+                        continue
+                    if kind == "yield" and fdict is not None:
+                        yield fdict
+                    elif kind == "split" and ranges is not None:
+                        left, right = ranges
+                        pending.append(left)
+                        pending.append(right)
+
+    @staticmethod
+    def _get_first_last_item(
+        items_repo, filters, order_by_direction=FiltersOrderByDirection.ASCENDING
+    ) -> Tuple[Optional[str], int]:
+        filters_dict = copy.deepcopy(filters.prepare())
+        filters_dict["sort"] = {"id": order_by_direction.value}
+        filters_dict["page"] = 0
+        filters_dict["pageSize"] = 1
+        cloned_filters = entities.Filters(custom_filter=filters_dict)
+
+        try:
+            pages = items_repo.list(filters=cloned_filters)
+            return (pages.items[0].id if pages.items else None, pages.items_count)
+        except Exception:
+            return None, 0
+
+    @staticmethod
+    def _get_middle_id(from_id, to_id):
+        """Calculate middle ObjectId between two ObjectIds with sub-second precision.
+
+        Computes the midpoint in the full 12-byte ObjectId numeric space to avoid
+        second-level rounding inherent to datetime-based construction.
+        """
+        try:
+            # Convert ObjectId strings to integers using base 16 (hexadecimal)
+            start_int = int(str(ObjectId(from_id)), base=16)  
+            end_int = int(str(ObjectId(to_id)), base=16)
+            if start_int >= end_int:
+                return from_id
+            mid_int = (start_int + end_int) // 2
+            if mid_int <= start_int:
+                mid_int = start_int + 1
+            if mid_int > end_int:
+                mid_int = end_int
+            # Convert back to 12-byte ObjectId format
+            mid_bytes = mid_int.to_bytes(length=12, byteorder="big")
+            return str(ObjectId(mid_bytes))
+        except Exception:
+            return from_id  # Fallback to from_id if calculation fails
+
 
 class SingleFilter:
     def __init__(self, field, values, operator: FiltersOperations = None):

dtlpy/entities/item.py

@@ -1,7 +1,7 @@
-import warnings
 from collections import namedtuple
 from enum import Enum
 import traceback
+import mimetypes
 import logging
 import attr
 import copy
@@ -354,7 +354,10 @@ class Item(entities.BaseEntity):
 
     @property
     def mimetype(self):
-        return self.metadata.get('system', dict()).get('mimetype', None)
+        mimetype = self.metadata.get('system', dict()).get('mimetype', None)
+        if mimetype is None:
+            mimetype = mimetypes.guess_type(self.filename)[0]
+        return mimetype
 
     @property
     def size(self):
@@ -457,6 +460,7 @@ class Item(entities.BaseEntity):
             dataset_lock=False,
             lock_timeout_sec=None,
             export_summary=False,
+            raise_on_error=False
     ):
         """
         Download dataset by filters.
@@ -478,6 +482,7 @@ class Item(entities.BaseEntity):
         :param bool with_text: optional - add text to annotations, default = False
         :param float alpha: opacity value [0 1], default 1
         :param str export_version:  exported items will have original extension in filename, `V1` - no original extension in filenames
+        :param bool raise_on_error: raise an exception if an error occurs
         :return: generator of local_path per each downloaded item
         :rtype: generator or single item
 
@@ -531,7 +536,8 @@ class Item(entities.BaseEntity):
                                    filters=filters,
                                    dataset_lock=dataset_lock,
                                    lock_timeout_sec=lock_timeout_sec,
-                                   export_summary=export_summary)
+                                   export_summary=export_summary,
+                                   raise_on_error=raise_on_error)
 
     def delete(self):
         """

dtlpy/entities/prompt_item.py

@@ -132,7 +132,13 @@ class Prompt:
             elif element['mimetype'] == PromptType.AUDIO:
                 raise NotImplementedError('Audio prompt is not supported yet')
             elif element['mimetype'] == PromptType.VIDEO:
-                raise NotImplementedError('Video prompt is not supported yet')
+                data = {
+                    "type": "video_url",
+                    "video_url": {
+                        "url": element['value']
+                    }
+                }
+                messages.append(data)
             else:
                 raise ValueError(f'Invalid mimetype: {element["mimetype"]}')
         return messages, self.key

dtlpy/entities/service.py

@@ -135,6 +135,7 @@ class KubernetesRuntime(ServiceRuntime):
                  pod_type: InstanceCatalog = DEFAULT_POD_TYPE,
                  num_replicas=DEFAULT_NUM_REPLICAS,
                  concurrency=DEFAULT_CONCURRENCY,
+                 dynamic_concurrency=None,
                  runner_image=None,
                  autoscaler=None,
                  **kwargs):
@@ -147,6 +148,7 @@ class KubernetesRuntime(ServiceRuntime):
         self._proxy_image = kwargs.get('proxyImage', None)
         self.single_agent = kwargs.get('singleAgent', None)
         self.preemptible = kwargs.get('preemptible', None)
+        self.dynamic_concurrency = kwargs.get('dynamicConcurrency', dynamic_concurrency)
 
         self.autoscaler = kwargs.get('autoscaler', autoscaler)
         if self.autoscaler is not None and isinstance(self.autoscaler, dict):
@@ -178,6 +180,9 @@ class KubernetesRuntime(ServiceRuntime):
         if self.preemptible is not None:
             _json['preemptible'] = self.preemptible
 
+        if self.dynamic_concurrency is not None:
+            _json['dynamicConcurrency'] = self.dynamic_concurrency
+
         return _json