added list_projects method

Author: Narek Mkhitaryan

src/superannotate/lib/app/interface/sdk_interface.py

@@ -69,6 +69,7 @@
 from lib.infrastructure.annotation_adapter import MultimodalLargeAnnotationAdapter
 from lib.infrastructure.utils import extract_project_folder
 from lib.infrastructure.validators import wrap_error
+from lib.app.serializers import WMProjectSerializer
 
 logger = logging.getLogger("sa")
 
@@ -2967,6 +2968,62 @@ def list_items(
                 exclude.add("custom_metadata")
         return BaseSerializer.serialize_iterable(res, exclude=exclude)
 
+    def list_projects(
+        self,
+        *,
+        include: List[Literal["custom_fields"]] = None,
+        **filters,
+    ):
+        # TODO finalize doc
+        """
+        Search projects by filtering criteria.
+
+        :param include: Specifies additional fields to include in the response.
+
+                Possible values are
+
+                - "custom_fields": Includes custom field added to the project.
+        :type include: list of str, optional
+
+        :param filters: Specifies filtering criteria (e.g., name, ID, status), with all conditions combined using
+                        logical AND. Only projects matching all criteria are returned. If no operation is specified,
+                        an exact match is applied.
+
+
+                Supported operations:
+                    - __ne: Value is not equal.
+                    - __in: Value is in the list.
+                    - __notin: Value is not in the list.
+                    - __contains: Value has the substring.
+                    - __starts: Value starts with the prefix.
+                    - __ends: Value ends with the suffix.
+
+                Filter params::
+
+                - id: int
+                - id__in: list[int]
+                - name: str
+                - name__in:  list[str]
+                - name__contains: str
+                - name__starts: str
+                - name__ends: str
+                - status: Literal[“NotStarted”, “InProgress”, “Completed”, “OnHold”]
+                - status__ne: Literal[“NotStarted”, “InProgress”, “Completed”, “OnHold”]
+                - status__in: List[Literal[“NotStarted”, “InProgress”, “Completed”, “OnHold”]]
+                - status__notin: List[Literal[“NotStarted”, “InProgress”, “Completed”, “OnHold”]]
+                - custom_field: Optional[dict] – Specifies custom fields attributes to filter projects by.
+                  Custom fields can be accessed using the `custom_field__` prefix followed by the attribute name.
+
+        :type filters: ProjectFilters
+
+        :return: A list of project metadata that matches the filtering criteria.
+        :rtype: list of dicts
+        """
+        return [
+            WMProjectSerializer(p).serialize()
+            for p in self.controller.projects.list_projects(include=include, **filters)
+        ]
+
     def attach_items(
         self,
         project: Union[NotEmptyStr, dict],

src/superannotate/lib/app/serializers.py

@@ -1,12 +1,12 @@
 from abc import ABC
+from enum import Enum
 from typing import Any
 from typing import List
 from typing import Set
 from typing import Union
 
 import lib.core as constance
 from lib.core.entities import BaseEntity
-from lib.core.enums import BaseTitledEnum
 from lib.core.pydantic_v1 import BaseModel
 
 
@@ -18,7 +18,7 @@ def __init__(self, entity: BaseEntity):
     def _fill_enum_values(data: dict):
         if isinstance(data, dict):
             for key, value in data.items():
-                if isinstance(value, BaseTitledEnum):
+                if isinstance(value, Enum):
                     data[key] = value.name
         return data
 
@@ -133,6 +133,26 @@ def serialize(
         return data
 
 
+class WMProjectSerializer(BaseSerializer):
+    def serialize(
+        self,
+        fields: List[str] = None,
+        by_alias: bool = False,
+        flat: bool = False,
+        exclude: Set[str] = None,
+        exclude_unset=False,
+    ):
+
+        to_exclude = {"sync_status": True, "unverified_users": True, "classes": True}
+        if exclude:
+            for field in exclude:
+                to_exclude[field] = True
+        data = super().serialize(fields, by_alias, flat, to_exclude)
+        if not data.get("status"):
+            data["status"] = "Undefined"
+        return data
+
+
 class FolderSerializer(BaseSerializer):
     def serialize(
         self,

src/superannotate/lib/core/entities/base.py

@@ -25,202 +25,6 @@
 _missing = object()
 
 
-class BaseModel(BaseModel):
-    ...
-    # """
-    # Added new extra keys
-    # - use_enum_names: that's for BaseTitledEnum to use names instead of enum objects
-    # """
-    #
-    # def _iter(
-    #     self,
-    #     to_dict: bool = False,
-    #     by_alias: bool = False,
-    #     include: Optional[Union["AbstractSetIntStr", "MappingIntStrAny"]] = None,
-    #     exclude: Optional[Union["AbstractSetIntStr", "MappingIntStrAny"]] = None,
-    #     exclude_unset: bool = False,
-    #     exclude_defaults: bool = False,
-    #     exclude_none: bool = False,
-    # ) -> "TupleGenerator":  # noqa
-    #
-    #     # Merge field set excludes with explicit exclude parameter with explicit overriding field set options.
-    #     # The extra "is not None" guards are not logically necessary but optimizes performance for the simple case.
-    #     if exclude is not None or self.__exclude_fields__ is not None:
-    #         exclude = ValueItems.merge(self.__exclude_fields__, exclude)
-    #
-    #     if include is not None or self.__include_fields__ is not None:
-    #         include = ValueItems.merge(self.__include_fields__, include, intersect=True)
-    #
-    #     allowed_keys = self._calculate_keys(
-    #         include=include, exclude=exclude, exclude_unset=exclude_unset  # type: ignore
-    #     )
-    #     if allowed_keys is None and not (
-    #         by_alias or exclude_unset or exclude_defaults or exclude_none
-    #     ):
-    #         # huge boost for plain _iter()
-    #         yield from self.__dict__.items()
-    #         return
-    #
-    #     value_exclude = ValueItems(self, exclude) if exclude is not None else None
-    #     value_include = ValueItems(self, include) if include is not None else None
-    #
-    #     for field_key, v in self.__dict__.items():
-    #         if (allowed_keys is not None and field_key not in allowed_keys) or (
-    #             exclude_none and v is None
-    #         ):
-    #             continue
-    #
-    #         if exclude_defaults:
-    #             model_field = self.__fields__.get(field_key)
-    #             if (
-    #                 not getattr(model_field, "required", True)
-    #                 and getattr(model_field, "default", _missing) == v
-    #             ):
-    #                 continue
-    #
-    #         if by_alias and field_key in self.__fields__:
-    #             dict_key = self.__fields__[field_key].alias
-    #         else:
-    #             dict_key = field_key
-    #
-    #         # if to_dict or value_include or value_exclude:
-    #         v = self._get_value(
-    #             v,
-    #             to_dict=to_dict,
-    #             by_alias=by_alias,
-    #             include=value_include and value_include.for_element(field_key),
-    #             exclude=value_exclude and value_exclude.for_element(field_key),
-    #             exclude_unset=exclude_unset,
-    #             exclude_defaults=exclude_defaults,
-    #             exclude_none=exclude_none,
-    #         )
-    #         yield dict_key, v
-    #
-    # @classmethod
-    # @no_type_check
-    # def _get_value(
-    #     cls,
-    #     v: Any,
-    #     to_dict: bool,
-    #     by_alias: bool,
-    #     include: Optional[Union["AbstractSetIntStr", "MappingIntStrAny"]],
-    #     exclude: Optional[Union["AbstractSetIntStr", "MappingIntStrAny"]],
-    #     exclude_unset: bool,
-    #     exclude_defaults: bool,
-    #     exclude_none: bool,
-    # ) -> Any:
-    #
-    #     if isinstance(v, BaseModel):
-    #         v_dict = v.dict(
-    #             by_alias=by_alias,
-    #             exclude_unset=exclude_unset,
-    #             exclude_defaults=exclude_defaults,
-    #             include=include,
-    #             exclude=exclude,
-    #             exclude_none=exclude_none,
-    #         )
-    #         if ROOT_KEY in v_dict:
-    #             return v_dict[ROOT_KEY]
-    #         return v_dict
-    #     value_exclude = ValueItems(v, exclude) if exclude else None
-    #     value_include = ValueItems(v, include) if include else None
-    #
-    #     if isinstance(v, dict):
-    #         return {
-    #             k_: cls._get_value(
-    #                 v_,
-    #                 to_dict=to_dict,
-    #                 by_alias=by_alias,
-    #                 exclude_unset=exclude_unset,
-    #                 exclude_defaults=exclude_defaults,
-    #                 include=value_include and value_include.for_element(k_),
-    #                 exclude=value_exclude and value_exclude.for_element(k_),
-    #                 exclude_none=exclude_none,
-    #             )
-    #             for k_, v_ in v.items()
-    #             if (not value_exclude or not value_exclude.is_excluded(k_))
-    #             and (not value_include or value_include.is_included(k_))
-    #         }
-    #
-    #     elif sequence_like(v):
-    #         seq_args = (
-    #             cls._get_value(
-    #                 v_,
-    #                 to_dict=to_dict,
-    #                 by_alias=by_alias,
-    #                 exclude_unset=exclude_unset,
-    #                 exclude_defaults=exclude_defaults,
-    #                 include=value_include and value_include.for_element(i),
-    #                 exclude=value_exclude and value_exclude.for_element(i),
-    #                 exclude_none=exclude_none,
-    #             )
-    #             for i, v_ in enumerate(v)
-    #             if (not value_exclude or not value_exclude.is_excluded(i))
-    #             and (not value_include or value_include.is_included(i))
-    #         )
-    #
-    #         return (
-    #             v.__class__(*seq_args)
-    #             if is_namedtuple(v.__class__)
-    #             else v.__class__(seq_args)
-    #         )
-    #     elif (
-    #         isinstance(v, BaseTitledEnum)
-    #         and getattr(cls.Config, "use_enum_names", False)
-    #         and to_dict
-    #     ):
-    #         return v.name
-    #     elif isinstance(v, Enum) and getattr(cls.Config, "use_enum_values", False):
-    #         return v.name
-    #     else:
-    #         return v
-    #
-    # def json(
-    #     self,
-    #     *,
-    #     include: Optional[Union["AbstractSetIntStr", "MappingIntStrAny"]] = None,
-    #     exclude: Optional[Union["AbstractSetIntStr", "MappingIntStrAny"]] = None,
-    #     by_alias: bool = False,
-    #     skip_defaults: Optional[bool] = None,
-    #     exclude_unset: bool = False,
-    #     exclude_defaults: bool = False,
-    #     exclude_none: bool = False,
-    #     encoder: Optional[Callable[[Any], Any]] = None,
-    #     models_as_dict: bool = True,
-    #     **dumps_kwargs: Any,
-    # ) -> str:
-    #     """
-    #     Generate a JSON representation of the model, `include` and `exclude` arguments as per `dict()`.
-    #
-    #     `encoder` is an optional function to supply as `default` to json.dumps(), other arguments as per `json.dumps()`.
-    #     """
-    #     if skip_defaults is not None:
-    #         warnings.warn(
-    #             f'{self.__class__.__name__}.json(): "skip_defaults" is deprecated and replaced by "exclude_unset"',
-    #             DeprecationWarning,
-    #         )
-    #         exclude_unset = skip_defaults
-    #     encoder = cast(Callable[[Any], Any], encoder or self.__json_encoder__)
-    #
-    #     # We don't directly call `self.dict()`, which does exactly this with `to_dict=True`
-    #     # because we want to be able to keep raw `BaseModel` instances and not as `dict`.
-    #     # This allows users to write custom JSON encoders for given `BaseModel` classes.
-    #     data = dict(
-    #         self._iter(
-    #             to_dict=False,
-    #             by_alias=by_alias,
-    #             include=include,
-    #             exclude=exclude,
-    #             exclude_unset=exclude_unset,
-    #             exclude_defaults=exclude_defaults,
-    #             exclude_none=exclude_none,
-    #         )
-    #     )
-    #     if self.__custom_root_type__:
-    #         data = data[ROOT_KEY]
-    #     return self.__config__.json_dumps(data, default=encoder, **dumps_kwargs)
-
-
 class StringDate(datetime):
     @classmethod
     def __get_validators__(cls):

src/superannotate/lib/core/entities/filters.py

@@ -0,0 +1,39 @@
+from typing import List
+from typing import Literal
+from typing import Optional
+
+from typing_extensions import TypedDict
+
+
+class BaseFilters(TypedDict, total=False):
+    id: Optional[int]
+    id__in: Optional[List[int]]
+    name: Optional[str]
+    name__in: Optional[List[str]]
+    name__contains: Optional[str]
+    name__starts: Optional[str]
+    name__ends: Optional[str]
+
+
+class ItemFilters(BaseFilters):
+    annotation_status: Optional[str]
+    annotation_status__in: Optional[List[str]]
+    annotation_status__ne: Optional[List[str]]
+    approval_status: Optional[str]
+    approval_status__in: Optional[List[str]]
+    approval_status__ne: Optional[str]
+    assignments__user_id: Optional[str]
+    assignments__user_id__in: Optional[List[str]]
+    assignments__user_id__ne: Optional[str]
+    assignments__user_role: Optional[str]
+    assignments__user_role__in: Optional[List[str]]
+    assignments__user_role__ne: Optional[str]
+    assignments__user_role__notin: Optional[List[str]]
+
+
+class ProjectFilters(BaseFilters):
+    # TODO finalize fields
+    status: Literal["NotStarted", "InProgress", "Completed", "OnHold"]
+    status__ne: Literal["NotStarted", "InProgress", "Completed", "OnHold"]
+    status__in: List[Literal["NotStarted", "InProgress", "Completed", "OnHold"]]
+    status__notin: List[Literal["NotStarted", "InProgress", "Completed", "OnHold"]]