dtlpy 1.114.13__py3-none-any.whl → 1.114.14__py3-none-any.whl

dtlpy/__init__.py

@@ -65,7 +65,7 @@ from .entities import (
     # main entities
     Project, Dataset, ExpirationOptions, ExportVersion, Trigger, Item, Execution, AnnotationCollection, Annotation,
     Recipe, IndexDriver, AttributesTypes, AttributesRange, Dpk, App, AppModule, AppScope,
-    Ontology, Label, Task, TaskPriority, ConsensusTaskType, Assignment, Service, Package, Codebase, Model,
+    Ontology, Label, Task, TaskPriority, ConsensusTaskType, AllocationMethod, Assignment, Service, Package, Codebase, Model,
     PackageModule, PackageFunction,
     # annotations
     Box, Cube, Cube3d, Point, Note, Message, Segmentation, Ellipse, Classification, Subtitle, Polyline, Pose, Gis, GisType,
@@ -484,5 +484,8 @@ CONSENSUS_TASK_TYPE_CONSENSUS = ConsensusTaskType.CONSENSUS
 CONSENSUS_TASK_TYPE_QUALIFICATION = ConsensusTaskType.QUALIFICATION
 CONSENSUS_TASK_TYPE_HONEYPOT = ConsensusTaskType.HONEYPOT
 
+TASK_TYPE_PULLING = AllocationMethod.PULLING
+TASK_TYPE_DISTRIBUTION = AllocationMethod.DISTRIBUTION
+
 SERVICE_MODE_TYPE_REGULAR = ServiceModeType.REGULAR
 SERVICE_MODE_TYPE_DEBUG = ServiceModeType.DEBUG

dtlpy/__version__.py

@@ -1 +1 @@
-version = '1.114.13'
+version = '1.114.14'

dtlpy/entities/__init__.py

@@ -48,7 +48,7 @@ from .service import Service, KubernetesAutoscalerType, KubernetesRabbitmqAutosc
 from .execution import Execution, ExecutionStatus
 from .command import Command, CommandsStatus
 from .assignment import Assignment, Workload, WorkloadUnit
-from .task import Task, ItemAction, TaskPriority, ConsensusTaskType
+from .task import Task, ItemAction, TaskPriority, ConsensusTaskType, AllocationMethod
 from .directory_tree import DirectoryTree
 from .user import User
 from .bot import Bot

dtlpy/entities/driver.py

@@ -30,8 +30,9 @@ class ExternalStorage(str, Enum):
     GCS = "gcs"
     AZUREBLOB = "azureblob"
     AZURE_DATALAKE_GEN2 = 'azureDatalakeGen2'
-    KEY_VALUE = "key_value"
-    AWS_STS = 'aws-sts'
+    POWERSCALE_S3 = 'powerscaleS3'
+    MIN_IO = 's3'
+    POWERSCALE_NFS = 'powerscaleNfs'
 
 
 @attr.s()

dtlpy/entities/filters.py

@@ -7,7 +7,7 @@ from enum import Enum
 
 from .. import exceptions, entities
 
-logger = logging.getLogger(name='dtlpy')
+logger = logging.getLogger(name="dtlpy")
 
 
 class FiltersKnownFields(str, Enum):
@@ -19,7 +19,7 @@ class FiltersKnownFields(str, Enum):
     LABEL = "label"
     NAME = "name"
     HIDDEN = "hidden"
-    TYPE = 'type'
+    TYPE = "type"
 
 
 class FiltersResource(str, Enum):
@@ -33,22 +33,22 @@ class FiltersResource(str, Enum):
     TRIGGER = "triggers"
     MODEL = "models"
     WEBHOOK = "webhooks"
-    RECIPE = 'recipe'
-    DATASET = 'datasets'
-    ONTOLOGY = 'ontology'
-    TASK = 'tasks'
-    PIPELINE = 'pipeline'
-    PIPELINE_EXECUTION = 'pipelineState'
-    COMPOSITION = 'composition'
-    FEATURE = 'feature_vectors'
-    FEATURE_SET = 'feature_sets'
-    ORGANIZATIONS = 'organizations'
-    DRIVERS = 'drivers'
-    SETTINGS = 'setting'
-    RESOURCE_EXECUTION = 'resourceExecution'
-    METRICS = 'metrics',
-    SERVICE_DRIVER = 'serviceDrivers',
-    COMPUTE = 'compute'
+    RECIPE = "recipe"
+    DATASET = "datasets"
+    ONTOLOGY = "ontology"
+    TASK = "tasks"
+    PIPELINE = "pipeline"
+    PIPELINE_EXECUTION = "pipelineState"
+    COMPOSITION = "composition"
+    FEATURE = "feature_vectors"
+    FEATURE_SET = "feature_sets"
+    ORGANIZATIONS = "organizations"
+    DRIVERS = "drivers"
+    SETTINGS = "setting"
+    RESOURCE_EXECUTION = "resourceExecution"
+    METRICS = ("metrics",)
+    SERVICE_DRIVER = ("serviceDrivers",)
+    COMPUTE = "compute"
 
 
 class FiltersOperations(str, Enum):
@@ -61,7 +61,7 @@ class FiltersOperations(str, Enum):
     LESS_THAN = "lt"
     EXISTS = "exists"
     MATCH = "match"
-    NIN = 'nin'
+    NIN = "nin"
 
 
 class FiltersMethod(str, Enum):
@@ -80,21 +80,19 @@ class Filters:
     """
 
     def __init__(
-            self,
-            field=None,
-            values=None,
-            operator: FiltersOperations = None,
-            method: FiltersMethod = None,
-            custom_filter=None,
-            resource: FiltersResource = FiltersResource.ITEM,
-            use_defaults=True,
-            context=None,
-            page_size=None,
+        self,
+        field=None,
+        values=None,
+        operator: FiltersOperations = None,
+        method: FiltersMethod = None,
+        custom_filter=None,
+        resource: FiltersResource = FiltersResource.ITEM,
+        use_defaults=True,
+        context=None,
+        page_size=None,
     ):
         if page_size is None:
-            if resource in [FiltersResource.EXECUTION,
-                            FiltersResource.PIPELINE_EXECUTION,
-                            FiltersResource.DPK]:
+            if resource in [FiltersResource.EXECUTION, FiltersResource.PIPELINE_EXECUTION, FiltersResource.DPK]:
                 page_size = 100
             else:
                 page_size = 1000
@@ -103,7 +101,7 @@ class Filters:
         self.and_filter_list = list()
         self._unique_fields = list()
         self.custom_filter = custom_filter
-        self.known_operators = ['or', 'and', 'in', 'ne', 'eq', 'gt', 'lt', 'exists']
+        self.known_operators = ["or", "and", "in", "ne", "eq", "gt", "lt", "exists"]
         self._resource = resource
         self.page = 0
         self.page_size = page_size
@@ -113,7 +111,7 @@ class Filters:
         self.recursive = True
 
         # system only - task and assignment attributes
-        self._user_query = 'true'
+        self._user_query = "true"
         self._ref_task = False
         self._ref_assignment = False
         self._ref_op = None
@@ -131,9 +129,11 @@ class Filters:
     def __validate_page_size(self):
         max_page_size = self.__max_page_size
         if self.page_size > max_page_size:
-            logger.warning('Cannot list {} with page size greater than {}. Changing page_size to {}.'.format(
-                self.resource, max_page_size, max_page_size
-            ))
+            logger.warning(
+                "Cannot list {} with page size greater than {}. Changing page_size to {}.".format(
+                    self.resource, max_page_size, max_page_size
+                )
+            )
             self.page_size = max_page_size
 
     @property
@@ -145,7 +145,7 @@ class Filters:
 
     @property
     def resource(self):
-        return f'{self._resource.value}' if isinstance(self._resource, FiltersResource) else f'{self._resource}'
+        return f"{self._resource.value}" if isinstance(self._resource, FiltersResource) else f"{self._resource}"
 
     @resource.setter
     def resource(self, resource):
@@ -198,8 +198,10 @@ class Filters:
         """
         if method is None:
             method = self.method
-        if 'metadata.system.refs.metadata' in field and self.resource == FiltersResource.ITEM:
-            logger.warning('Filtering by metadata.system.refs.metadata may cause incorrect results. please use match operator')
+        if "metadata.system.refs.metadata" in field and self.resource == FiltersResource.ITEM:
+            logger.warning(
+                "Filtering by metadata.system.refs.metadata may cause incorrect results. please use match operator"
+            )
 
         # create SingleFilter object and add to self.filter_list
         if method == FiltersMethod.OR:
@@ -207,17 +209,16 @@ class Filters:
         elif method == FiltersMethod.AND:
             self.__override(field=field, values=values, operator=operator)
         else:
-            raise exceptions.PlatformException(error='400',
-                                               message='Unknown method {}, please select from: or/and'.format(method))
+            raise exceptions.PlatformException(
+                error="400", message="Unknown method {}, please select from: or/and".format(method)
+            )
 
     def __override(self, field, values, operator=None):
         if field in self._unique_fields:
             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)
-        self.and_filter_list.append(
-            SingleFilter(field=field, values=values, operator=operator)
-        )
+        self.and_filter_list.append(SingleFilter(field=field, values=values, operator=operator))
 
     def generate_url_query_params(self, url):
         """
@@ -225,13 +226,13 @@ class Filters:
 
         :param str url:
         """
-        url = '{}?'.format(url)
+        url = "{}?".format(url)
         for f in self.and_filter_list:
             if isinstance(f.values, list):
-                url = '{}{}={}&'.format(url, f.field, ','.join(f.values))
+                url = "{}{}={}&".format(url, f.field, ",".join(f.values))
             else:
-                url = '{}{}={}&'.format(url, f.field, f.values)
-        return '{}&pageOffset={}&pageSize={}'.format(url, self.page, self.page_size)
+                url = "{}{}={}&".format(url, f.field, f.values)
+        return "{}&pageOffset={}&pageSize={}".format(url, self.page, self.page_size)
 
     def has_field(self, field):
         """
@@ -272,15 +273,11 @@ class Filters:
         :param str field: field to pop
         """
         if self.join is not None:
-            for single_filter in self.join['filter']['$and']:
+            for single_filter in self.join["filter"]["$and"]:
                 if field in single_filter:
-                    self.join['filter']['$and'].remove(single_filter)
+                    self.join["filter"]["$and"].remove(single_filter)
 
-    def add_join(self, field,
-                 values,
-                 operator: FiltersOperations = None,
-                 method: FiltersMethod = FiltersMethod.AND
-                 ):
+    def add_join(self, field, values, operator: FiltersOperations = None, method: FiltersMethod = FiltersMethod.AND):
         """
         join a query to the filter
 
@@ -296,43 +293,42 @@ class Filters:
             filter.add_join(field='metadata.user', values=['1','2'], operator=dl.FiltersOperations.IN)
         """
         if self.resource not in [FiltersResource.ITEM, FiltersResource.ANNOTATION]:
-            raise exceptions.PlatformException(error='400',
-                                               message='Cannot join to {} filters'.format(self.resource))
+            raise exceptions.PlatformException(error="400", message="Cannot join to {} filters".format(self.resource))
 
         if self.join is None:
             self.join = dict()
-        if 'on' not in self.join:
+        if "on" not in self.join:
             if self.resource == FiltersResource.ITEM:
-                self.join['on'] = {'resource': FiltersResource.ANNOTATION.value, 'local': 'itemId', 'forigen': 'id'}
+                self.join["on"] = {"resource": FiltersResource.ANNOTATION.value, "local": "itemId", "forigen": "id"}
             else:
-                self.join['on'] = {'resource': FiltersResource.ITEM.value, 'local': 'id', 'forigen': 'itemId'}
-        if 'filter' not in self.join:
-            self.join['filter'] = dict()
-        join_method = '$' + method
-        if join_method not in self.join['filter']:
-            self.join['filter'][join_method] = list()
-        self.join['filter'][join_method].append(SingleFilter(field=field, values=values, operator=operator).prepare())
+                self.join["on"] = {"resource": FiltersResource.ITEM.value, "local": "id", "forigen": "itemId"}
+        if "filter" not in self.join:
+            self.join["filter"] = dict()
+        join_method = "$" + method
+        if join_method not in self.join["filter"]:
+            self.join["filter"][join_method] = list()
+        self.join["filter"][join_method].append(SingleFilter(field=field, values=values, operator=operator).prepare())
 
     def __add_defaults(self):
         if self._use_defaults:
             # add items defaults
             if self.resource == FiltersResource.ITEM:
-                self._unique_fields = ['type', 'hidden']
-                self.add(field='hidden', values=False, method=FiltersMethod.AND)
-                self.add(field='type', values='file', method=FiltersMethod.AND)
+                self._unique_fields = ["type", "hidden"]
+                self.add(field="hidden", values=False, method=FiltersMethod.AND)
+                self.add(field="type", values="file", method=FiltersMethod.AND)
             # add service defaults
             elif self.resource == FiltersResource.SERVICE:
-                self._unique_fields = ['global']
-                self.add(field='global', values=True, operator=FiltersOperations.NOT_EQUAL, method=FiltersMethod.AND)
+                self._unique_fields = ["global"]
+                self.add(field="global", values=True, operator=FiltersOperations.NOT_EQUAL, method=FiltersMethod.AND)
             elif self.resource == FiltersResource.PACKAGE:
-                self._unique_fields = ['global']
-                self.add(field='global', values=True, operator=FiltersOperations.NOT_EQUAL, method=FiltersMethod.AND)
+                self._unique_fields = ["global"]
+                self.add(field="global", values=True, operator=FiltersOperations.NOT_EQUAL, method=FiltersMethod.AND)
             # add annotations defaults
             elif self.resource == FiltersResource.ANNOTATION:
-                self._unique_fields = ['type']
+                self._unique_fields = ["type"]
                 values = [annotation_type.value for annotation_type in entities.AnnotationType]
                 values.remove(entities.AnnotationType.NOTE.value)
-                self.add(field='type', values=values, operator=FiltersOperations.IN, method=FiltersMethod.AND)
+                self.add(field="type", values=values, operator=FiltersOperations.IN, method=FiltersMethod.AND)
 
     def __generate_query(self):
         filters_dict = dict()
@@ -341,27 +337,40 @@ class Filters:
             or_filters = list()
             for single_filter in self.or_filter_list:
                 or_filters.append(
-                    single_filter.prepare(recursive=self.recursive and self.resource == FiltersResource.ITEM))
-            filters_dict['$or'] = or_filters
+                    single_filter.prepare(recursive=self.recursive and self.resource == FiltersResource.ITEM)
+                )
+            filters_dict["$or"] = or_filters
 
         if len(self.and_filter_list) > 0:
             and_filters = list()
             for single_filter in self.and_filter_list:
                 and_filters.append(
-                    single_filter.prepare(recursive=self.recursive and self.resource == FiltersResource.ITEM))
-            filters_dict['$and'] = and_filters
+                    single_filter.prepare(recursive=self.recursive and self.resource == FiltersResource.ITEM)
+                )
+            filters_dict["$and"] = and_filters
 
         return filters_dict
 
     def __generate_custom_query(self):
-        filters_dict = dict()
-        if 'filter' in self.custom_filter or 'join' in self.custom_filter:
-            if 'filter' in self.custom_filter:
-                filters_dict = self.custom_filter['filter']
-            self.join = self.custom_filter.get('join', self.join)
+        if "filter" not in self.custom_filter:
+            query_dict = {"filter": self.custom_filter}
         else:
-            filters_dict = self.custom_filter
-        return filters_dict
+            query_dict = self.custom_filter
+        if "resource" not in query_dict:
+            query_dict["resource"] = self.resource
+        if "page" not in query_dict:
+            query_dict["page"] = self.page
+        if "pageSize" not in query_dict:
+            query_dict["pageSize"] = self.page_size
+        if self.join is not None and 'join' not in query_dict:
+            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"}
+            else:
+                query_dict["join"]["on"] = {"resource": FiltersResource.ITEM.value, "local": "id", "forigen": "itemId"}
+
+        return query_dict
 
     def __generate_ref_query(self):
         refs = list()
@@ -371,7 +380,7 @@ class Filters:
                 self._ref_task_id = [self._ref_task_id]
 
             for ref_id in self._ref_task_id:
-                task_refs.append({'type': 'task', 'id': ref_id})
+                task_refs.append({"type": "task", "id": ref_id})
 
             refs += task_refs
 
@@ -381,7 +390,7 @@ class Filters:
                 self._ref_assignment_id = [self._ref_assignment_id]
 
             for ref_id in self._ref_assignment_id:
-                assignment_refs.append({'type': 'assignment', 'id': ref_id})
+                assignment_refs.append({"type": "assignment", "id": ref_id})
 
             refs += assignment_refs
 
@@ -404,62 +413,59 @@ class Filters:
         ########
         _json = dict()
 
-        if self.custom_filter is None:
-            _json['filter'] = self.__generate_query()
-        else:
-            _json['filter'] = self.__generate_custom_query()
+        if self.custom_filter is not None:
+            _json = self.__generate_custom_query()
+            return _json
+
+        _json["filter"] = self.__generate_query()
 
         ##################
         # filter options #
         ##################
         if not query_only:
             if len(self.sort) > 0:
-                _json['sort'] = self.sort
+                _json["sort"] = self.sort
 
             self.__validate_page_size()
 
-            _json['page'] = self.page
-            _json['pageSize'] = self.page_size
-            _json['resource'] = self.resource
+            _json["page"] = self.page
+            _json["pageSize"] = self.page_size
+            _json["resource"] = self.resource
 
         ########
         # join #
         ########
         if self.join is not None:
-            _json['join'] = self.join
+            _json["join"] = self.join
 
         #####################
         # operation or refs #
         #####################
         if self._ref_assignment or self._ref_task:
-            _json['references'] = {
-                'operation': self._ref_op,
-                'refs': self.__generate_ref_query()
-            }
+            _json["references"] = {"operation": self._ref_op, "refs": self.__generate_ref_query()}
         elif operation is not None:
-            if operation == 'update':
+            if operation == "update":
                 if update:
-                    _json[operation] = {'metadata': {'user': update}}
+                    _json[operation] = {"metadata": {"user": update}}
                 else:
                     _json[operation] = dict()
                 if system_metadata and system_update:
-                    _json['systemSpace'] = True
-                    _json[operation]['metadata'] = _json[operation].get('metadata', dict())
-                    _json[operation]['metadata']['system'] = system_update
-            elif operation == 'delete':
+                    _json["systemSpace"] = True
+                    _json[operation]["metadata"] = _json[operation].get("metadata", dict())
+                    _json[operation]["metadata"]["system"] = system_update
+            elif operation == "delete":
                 _json[operation] = True
-                _json.pop('sort', None)
+                _json.pop("sort", None)
                 if self.resource == FiltersResource.ITEM:
-                    _json.pop('page', None)
-                    _json.pop('pageSize', None)
+                    _json.pop("page", None)
+                    _json.pop("pageSize", None)
             else:
-                raise exceptions.PlatformException(error='400',
-                                                   message='Unknown operation: {}'.format(operation))
+                raise exceptions.PlatformException(error="400", message="Unknown operation: {}".format(operation))
 
         if self.context is not None:
-            _json['context'] = self.context
+            _json["context"] = self.context
         if self._system_space is not None:
-            _json['systemSpace'] = self._system_space
+            _json["systemSpace"] = self._system_space
         return _json
 
     def print(self, indent=2):
@@ -479,7 +485,7 @@ class Filters:
             filter.sort_by(field='metadata.user', values=dl.FiltersOrderByDirection.ASCENDING)
         """
         if value not in [FiltersOrderByDirection.ASCENDING, FiltersOrderByDirection.DESCENDING]:
-            raise exceptions.PlatformException(error='400', message='Sort can be by ascending or descending order only')
+            raise exceptions.PlatformException(error="400", message="Sort can be by ascending or descending order only")
         self.sort[field] = value.value if isinstance(value, FiltersOrderByDirection) else value
 
     def platform_url(self, resource) -> str:
@@ -492,21 +498,21 @@ class Filters:
         """
         _json = self.prepare()
         # add the view option
-        _json['view'] = 'icons'
+        _json["view"] = "icons"
         # convert from enum to string
         _json["resource"] = f'{_json["resource"]}'
         # convert the dictionary to a json string
-        _json['dqlFilter'] = json.dumps({'filter': _json.pop('filter'),
-                                         'join': _json.pop('join', None),
-                                         'sort': _json.get('sort', None)})
+        _json["dqlFilter"] = json.dumps(
+            {"filter": _json.pop("filter"), "join": _json.pop("join", None), "sort": _json.get("sort", None)}
+        )
         # set the page size as the UI default
-        _json['pageSize'] = 100
-        _json['page'] = _json['page']
+        _json["pageSize"] = 100
+        _json["page"] = _json["page"]
         # build the url for the dataset data browser
         if isinstance(resource, entities.Dataset):
-            url = resource.platform_url + f'?{urllib.parse.urlencode(_json)}'
+            url = resource.platform_url + f"?{urllib.parse.urlencode(_json)}"
         else:
-            raise NotImplementedError('Not implemented for resource type: {}'.format(type(resource)))
+            raise NotImplementedError("Not implemented for resource type: {}".format(type(resource)))
         return url
 
     def open_in_web(self, resource):
@@ -518,7 +524,7 @@ class Filters:
         if isinstance(resource, entities.Dataset):
             resource._client_api._open_in_web(url=self.platform_url(resource=resource))
         else:
-            raise NotImplementedError('Not implemented for resource type: {}'.format(type(resource)))
+            raise NotImplementedError("Not implemented for resource type: {}".format(type(resource)))
 
     def save(self, project: entities.Project, filter_name: str):
         """
@@ -529,32 +535,29 @@ class Filters:
         :return: True if success
         """
         _json_filter = self.prepare()
-        shebang_dict = {"type": "dql",
-                        "shebang": "dataloop",
-                        "metadata": {
-                            "version": "1.0.0",
-                            "system": {
-                                "mimetype": "dql"
-                            },
-                            "dltype": "filter",
-                            "filterFieldsState": [],
-                            "resource": "items",
-                            "filter": _json_filter.pop('filter'),
-                            "join": _json_filter.pop('join')
-                        }
-                        }
+        shebang_dict = {
+            "type": "dql",
+            "shebang": "dataloop",
+            "metadata": {
+                "version": "1.0.0",
+                "system": {"mimetype": "dql"},
+                "dltype": "filter",
+                "filterFieldsState": [],
+                "resource": "items",
+                "filter": _json_filter.pop("filter"),
+                "join": _json_filter.pop("join"),
+            },
+        }
         b_dataset = project.datasets._get_binaries_dataset()
         byte_io = io.BytesIO()
         byte_io.name = filter_name
         byte_io.write(json.dumps(shebang_dict).encode())
         byte_io.seek(0)
-        b_dataset.items.upload(local_path=byte_io,
-                               remote_path='/.dataloop/dqlfilters/items',
-                               remote_name=filter_name)
+        b_dataset.items.upload(local_path=byte_io, remote_path="/.dataloop/dqlfilters/items", remote_name=filter_name)
         return True
 
     @classmethod
-    def load(cls, project: entities.Project, filter_name: str) -> 'Filters':
+    def load(cls, project: entities.Project, filter_name: str) -> "Filters":
         """
         Load a saved filter from the project by name
 
@@ -563,20 +566,23 @@ class Filters:
         :return: dl.Filters
         """
         b_dataset = project.datasets._get_binaries_dataset()
-        f = entities.Filters(custom_filter={
-            'filter': {'$and': [{'filename': f'/.dataloop/dqlfilters/items/{filter_name}'}]},
-            'page': 0,
-            'pageSize': 1000,
-            'resource': 'items'
-        })
+        f = entities.Filters(
+            custom_filter={
+                "filter": {"$and": [{"filename": f"/.dataloop/dqlfilters/items/{filter_name}"}]},
+                "page": 0,
+                "pageSize": 1000,
+                "resource": "items",
+            }
+        )
         pages = b_dataset.items.list(filters=f)
         if pages.items_count == 0:
             raise exceptions.NotFound(
-                f'Saved filter not found: {filter_name}. Run `Filters.list()` to list existing filters')
+                f"Saved filter not found: {filter_name}. Run `Filters.list()` to list existing filters"
+            )
         with open(pages.items[0].download()) as f:
             data = json.load(f)
-            custom_filter = data['metadata']['filter']
-            custom_filter['join'] = data['metadata']['join']
+            custom_filter = data["metadata"]["filter"]
+            custom_filter["join"] = data["metadata"]["join"]
         return cls(custom_filter=custom_filter)
 
     @staticmethod
@@ -587,9 +593,7 @@ class Filters:
         :return: a list of all the saved filters' names
         """
         b_dataset = project.datasets._get_binaries_dataset()
-        f = entities.Filters(use_defaults=False,
-                             field='dir',
-                             values='/.dataloop/dqlfilters/items')
+        f = entities.Filters(use_defaults=False, field="dir", values="/.dataloop/dqlfilters/items")
         pages = b_dataset.items.list(filters=f)
         all_filter_items = list(pages.all())
         names = [i.name for i in all_filter_items]
@@ -604,11 +608,11 @@ class SingleFilter:
 
     @staticmethod
     def __add_recursive(value):
-        if not value.endswith('*') and not os.path.splitext(value)[-1].startswith('.'):
-            if value.endswith('/'):
-                value = value + '**'
+        if not value.endswith("*") and not os.path.splitext(value)[-1].startswith("."):
+            if value.endswith("/"):
+                value = value + "**"
             else:
-                value = value + '/**'
+                value = value + "/**"
         return value
 
     def prepare(self, recursive=False):
@@ -620,7 +624,7 @@ class SingleFilter:
         _json = dict()
         values = self.values
 
-        if recursive and self.field == 'filename':
+        if recursive and self.field == "filename":
             if isinstance(values, str):
                 values = self.__add_recursive(value=values)
             elif isinstance(values, list):
@@ -632,7 +636,7 @@ class SingleFilter:
         else:
             value = dict()
             op = self.operator.value if isinstance(self.operator, FiltersOperations) else self.operator
-            value['${}'.format(op)] = values
+            value["${}".format(op)] = values
             _json[self.field] = value
 
         return _json