Fix get_fodlers

Author: Vaghinak Basentsyan

src/superannotate/__init__.py

@@ -243,7 +243,6 @@
     "upload_videos_from_folder_to_project",
     # Annotation Section
     "create_annotation_class",
-    "delete_annotation_class",
     "prepare_export",
     "download_export",
     "set_images_annotation_statuses",

src/superannotate/lib/app/helpers.py

@@ -131,7 +131,7 @@ def check_types(obj, **kwargs):
         if attr_name == "return":
             continue
         try:
-            if attr_type.__origin__ is list:
+            if getattr(attr_type, "__origin__") and attr_type.__origin__ is list:
                 if attr_type.__args__:
                     for elem in kwargs[attr_name]:
                         if type(elem) in attr_type.__args__:
@@ -140,7 +140,7 @@ def check_types(obj, **kwargs):
                             errors.append(f"Invalid input {attr_name}")
                 elif not isinstance(kwargs[attr_name], list):
                     errors.append(f"Argument {attr_name} is not of type {attr_type}")
-            elif attr_type.__origin__ is Union:
+            elif getattr(attr_type, "__origin__") and attr_type.__origin__ is Union:
                 if kwargs.get(attr_name) and not isinstance(
                     kwargs[attr_name], attr_type.__args__
                 ):

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

@@ -1166,9 +1166,11 @@ def unassign_images(project: Union[str, dict], image_names: List[str]):
     """
     project_name, folder_name = extract_project_folder(project)
 
-    controller.un_assign_images(
+    response = controller.un_assign_images(
         project_name=project_name, folder_name=folder_name, image_names=image_names
     )
+    if response.errors:
+        raise AppException(response.errors)
 
 
 @Trackable
@@ -1183,7 +1185,11 @@ def unassign_folder(project_name: str, folder_name: str):
     :param folder_name: folder name to remove assignees
     :type folder_name: str
     """
-    controller.un_assign_folder(project_name=project_name, folder_name=folder_name)
+    response = controller.un_assign_folder(
+        project_name=project_name, folder_name=folder_name
+    )
+    if response.errors:
+        raise AppException(response.errors)
 
 
 @Trackable
@@ -3536,4 +3542,4 @@ def aggregate_annotations_as_df(
         include_tags,
         verbose,
         folder_names,
-    )
+    )

src/superannotate/lib/app/serializers.py

@@ -27,11 +27,11 @@ def serialize(self):
         data = super().serialize()
         users = []
         for user in data["users"]:
-            user["user_role"] = constance.UserRole.get_name(data["user_role"])
+            user["user_role"] = constance.UserRole.get_name(user["user_role"])
             users.append(user)
         data["users"] = users
         for user in data["pending_invitations"]:
-            user["user_role"] = constance.UserRole.get_name(data["user_role"])
+            user["user_role"] = constance.UserRole.get_name(user["user_role"])
         return data
 
 

src/superannotate/lib/core/entities.py

@@ -47,6 +47,11 @@ def __init__(
         name: str = None,
         project_type: int = None,
         description: str = None,
+        attachment_name: str = None,
+        attachment_path: str = None,
+        creator_id: str = None,
+        entropy_status: int = None,
+        sharing_status: int = None,
         status: int = None,
         folder_id: int = None,
         upload_state: int = None,
@@ -62,6 +67,11 @@ def __init__(
         self.name = name
         self.project_type = project_type
         self.description = description
+        self.attachment_name = attachment_name
+        self.attachment_path = attachment_path
+        self.creator_id = creator_id
+        self.entropy_status = entropy_status
+        self.sharing_status = sharing_status
         self.status = status
         self.folder_id = folder_id
         self.upload_state = upload_state
@@ -92,6 +102,11 @@ def to_dict(self):
             "type": self.project_type,
             "description": self.description,
             "status": self.status,
+            "attachment_path": self.attachment_path,
+            "attachment_name": self.attachment_name,
+            "entropy_status": self.entropy_status,
+            "sharing_status": self.sharing_status,
+            "creator_id": self.creator_id,
             "folder_id": self.folder_id,
             "upload_state": self.upload_state,
             "users": self.users,

src/superannotate/lib/core/enums.py

@@ -31,6 +31,7 @@ class ProjectType(BaseTitledEnum):
 
 
 class UserRole(BaseTitledEnum):
+    SUPER_AMIN = "Superadmin", 1
     ADMIN = "Admin", 2
     ANNOTATOR = "Annotator", 3
     QA = "QA", 4

src/superannotate/lib/core/serviceproviders.py

@@ -287,4 +287,4 @@ def run_segmentation(
     def run_prediction(
         self, team_id: int, project_id: int, ml_model_id: int, image_ids: list
     ):
-        raise NotImplementedError
+        raise NotImplementedError

src/superannotate/lib/core/usecases.py

@@ -1600,13 +1600,13 @@ def __init__(
         self,
         service: SuerannotateServiceProvider,
         project: ProjectEntity,
-        folder_name: str,
+        folder: FolderEntity,
         image_names: list,
         user: str,
     ):
         super().__init__()
         self._project = project
-        self._folder_name = folder_name
+        self._folder = folder
         self._image_names = image_names
         self._user = user
         self._service = service
@@ -1623,7 +1623,7 @@ def execute(self):
                 is_assigned = self._service.assign_images(
                     team_id=self._project.team_id,
                     project_id=self._project.uuid,
-                    folder_name=self._folder_name,
+                    folder_name=self._folder.name,
                     user=self._user,
                     image_names=self._image_names[
                         i : i + self.CHUNK_SIZE  # noqa: E203
@@ -1643,23 +1643,29 @@ def __init__(
         self,
         service: SuerannotateServiceProvider,
         project_entity: ProjectEntity,
-        folder_name: str,
+        folder: FolderEntity,
         image_names: list,
     ):
         super().__init__()
         self._project_entity = project_entity
-        self._folder_name = folder_name
+        self._folder = folder
         self._image_names = image_names
         self._service = service
 
     def execute(self):
+        # todo handling to backend side
         for i in range(0, len(self._image_names), self.CHUNK_SIZE):
-            self._response.data = self._service.un_assign_images(
+            is_un_assigned = self._service.un_assign_images(
                 team_id=self._project_entity.team_id,
                 project_id=self._project_entity.uuid,
-                folder_name=self._folder_name,
-                image_names=self._image_names[i : i + self.CHUNK_SIZE],
+                folder_name=self._folder.name,
+                image_names=self._image_names[i : i + self.CHUNK_SIZE],  # noqa: E203
             )
+            if not is_un_assigned:
+                self._response.errors = AppException(
+                    f"Cant un assign {', '.join(self._image_names[i : i + self.CHUNK_SIZE])}"
+                )
+
         return self._response
 
 
@@ -1668,19 +1674,21 @@ def __init__(
         self,
         service: SuerannotateServiceProvider,
         project_entity: ProjectEntity,
-        folder_name: str,
+        folder: FolderEntity,
     ):
         super().__init__()
         self._service = service
         self._project_entity = project_entity
-        self._folder_name = folder_name
+        self._folder = folder
 
     def execute(self):
-        self._response.data = self._service.un_assign_folder(
+        is_un_assigned = self._service.un_assign_folder(
             team_id=self._project_entity.team_id,
             project_id=self._project_entity.uuid,
-            folder_name=self._folder_name,
+            folder_name=self._folder.name,
         )
+        if not is_un_assigned:
+            self._response.errors = AppException(f"Cant un assign {self._folder.name}")
         return self._response
 
 
@@ -1689,29 +1697,29 @@ def __init__(
         self,
         service: SuerannotateServiceProvider,
         project_entity: ProjectEntity,
-        folder_name: str,
+        folder: FolderEntity,
         users: List[str],
     ):
         super().__init__()
         self._service = service
         self._project_entity = project_entity
-        self._folder_name = folder_name
+        self._folder = folder
         self._users = users
 
     def execute(self):
         is_assigned = self._service.assign_folder(
             team_id=self._project_entity.team_id,
             project_id=self._project_entity.uuid,
-            folder_name=self._folder_name,
+            folder_name=self._folder.name,
             users=self._users,
         )
         if is_assigned:
             logger.info(
-                f'Assigned {self._folder_name} to users: {", ".join(self._users)}'
+                f'Assigned {self._folder.name} to users: {", ".join(self._users)}'
             )
         else:
             self._response.errors = AppException(
-                "Couldn't assign folder to users: {', '.join(self._users)"
+                f"Couldn't assign folder to users: {', '.join(self._users)}"
             )
         return self._response
 

src/superannotate/lib/infrastructure/controller.py

@@ -765,41 +765,42 @@ def assign_images(
         self, project_name: str, folder_name: str, image_names: list, user: str
     ):
         project_entity = self._get_project(project_name)
+        folder = self._get_folder(project_entity, folder_name)
         use_case = usecases.AssignImagesUseCase(
             project=project_entity,
             service=self._backend_client,
-            folder_name=folder_name,
+            folder=folder,
             image_names=image_names,
             user=user,
         )
         return use_case.execute()
 
     def un_assign_images(self, project_name, folder_name, image_names):
         project = self._get_project(project_name)
-        folder_name = self.get_folder_name(folder_name)
+        folder = self._get_folder(folder_name)
         use_case = usecases.UnAssignImagesUseCase(
             project_entity=project,
             service=self._backend_client,
-            folder_name=folder_name,
+            folder=folder,
             image_names=image_names,
         )
         return use_case.execute()
 
     def un_assign_folder(self, project_name: str, folder_name: str):
         project_entity = self._get_project(project_name)
+        folder = self._get_folder(project_entity, folder_name)
         use_case = usecases.UnAssignFolderUseCase(
-            service=self._backend_client,
-            project_entity=project_entity,
-            folder_name=folder_name,
+            service=self._backend_client, project_entity=project_entity, folder=folder,
         )
         return use_case.execute()
 
     def assign_folder(self, project_name: str, folder_name: str, users: List[str]):
         project_entity = self._get_project(project_name)
+        folder = self._get_folder(project_entity, folder_name)
         use_case = usecases.AssignFolderUseCase(
             service=self._backend_client,
             project_entity=project_entity,
-            folder_name=folder_name,
+            folder=folder,
             users=users,
         )
         return use_case.execute()

src/superannotate/lib/infrastructure/repositories.py

@@ -118,6 +118,12 @@ def dict2entity(data: dict):
                 name=data["name"],
                 project_type=data["type"],
                 status=data["status"],
+                attachment_name=data["attachment_name"],
+                attachment_path=data["attachment_path"],
+                entropy_status=data["entropy_status"],
+                sharing_status=data.get("sharing_status"),
+                creator_id=data["creator_id"],
+                upload_state=data["upload_state"],
                 description=data["description"],
                 folder_id=data.get("folder_id"),
                 users=data.get("users", ()),