Changed validation message

Author: Vaghinak Basentsyan

src/superannotate/__init__.py

@@ -299,4 +299,4 @@
 logging.config.fileConfig(
     os.path.join(WORKING_DIR, "logging.conf"), disable_existing_loggers=False
 )
-sys.tracebacklimit = 1
+sys.tracebacklimit = 0

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

@@ -74,7 +74,6 @@ def init(path_to_config_json: str):
 @validate_arguments
 def set_auth_token(token: str):
     controller.set_token(token)
-    controller.init(controller.config_path)
 
 
 @Trackable
@@ -566,7 +565,7 @@ def copy_image(
 
     if copy_annotation_status:
         res = controller.get_image(
-            project_name=source_project,
+            project_name=source_project_name,
             image_name=image_name,
             folder_path=source_folder_name,
         )
@@ -2185,6 +2184,8 @@ def set_image_annotation_status(
     )
     if response.errors:
         raise AppException(response.errors)
+    image = controller.get_image_metadata(project_name, folder_name, image_name).data
+    return ImageSerializer(image).serialize()
 
 
 @Trackable

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

@@ -34,22 +34,29 @@ def validate(cls, value: Union[str]) -> Union[str]:
         return value
 
 
+def to_chunks(t, size=2):
+    it = iter(t)
+    return zip(*[it] * size)
+
+
 def validate_arguments(func):
     @wraps(func)
     def wrapped(*args, **kwargs):
         try:
             return pydantic_validate_arguments(func)(*args, **kwargs)
         except ValidationError as e:
-            messages = defaultdict(list)
+            error_messages = defaultdict(list)
             for error in e.errors():
-                messages[error["loc"][0]].append(f"{error['loc'][-1]} {error['msg']}")
-            raise AppException(
-                "\n".join(
-                    [
-                        f"Invalid {message}: {','.join(text)}"
-                        for message, text in messages.items()
-                    ]
+                error_messages[error["loc"][0]].append(
+                    f"{''.join([f'  {i[0]} -> {i[1]}' for i in to_chunks(error['loc'])])}  {error['loc'][-1]} {error['msg']}"
                 )
-            )
+            texts = ["\n"]
+            for error, text in error_messages.items():
+                texts.append(
+                    "{} {}{}".format(
+                        error, " " * (21 - len(error)), f"\n {' ' * 21}".join(text)
+                    )
+                )
+            raise AppException("\n".join(texts))
 
     return wrapped

src/superannotate/lib/core/serviceproviders.py

@@ -16,6 +16,10 @@ def __call__(cls, *args, **kwargs):
             SingleInstanceMetaClass._instances[cls] = super().__call__(*args, **kwargs)
         return SingleInstanceMetaClass._instances[cls]
 
+    def get_instance(cls):
+        if cls._instances:
+            return cls._instances[cls]
+
 
 class SuerannotateServiceProvider(metaclass=SingleInstanceMetaClass):
     @abstractmethod

src/superannotate/lib/core/types.py

@@ -22,8 +22,8 @@ class AttributeGroup(BaseModel):
 
 class ClassesJson(BaseModel):
     name: StrictStr
-    color: Optional[StrictStr]
-    attribute_groups: Optional[List[AttributeGroup]]
+    color: StrictStr
+    attribute_groups: List[AttributeGroup]
 
 
 class Metadata(BaseModel):

src/superannotate/lib/core/usecases.py

@@ -380,14 +380,19 @@ def execute(self):
 
             if self._include_workflow:
                 new_workflows = self._workflows_repo(self._backend_service, project)
-                workflow_attributes = []
                 for workflow in self.workflows.get_all():
+                    existing_workflow_ids = list(map(lambda i: i.uuid, new_workflows.get_all()))
                     workflow_data = copy.copy(workflow)
                     workflow_data.project_id = project.uuid
                     workflow_data.class_id = annotation_classes_mapping[
                         workflow.class_id
                     ].uuid
-                    new_workflow = new_workflows.insert(workflow_data)
+                    new_workflows.insert(workflow_data)
+                    workflows = new_workflows.get_all()
+                    new_workflow = [
+                        work_flow for work_flow in workflows if work_flow.uuid not in existing_workflow_ids
+                    ][0]
+                    workflow_attributes = []
                     for attribute in workflow_data.attribute:
                         for annotation_attribute in annotation_classes_mapping[
                             workflow.class_id
@@ -811,13 +816,13 @@ def execute(self):
             )
             if "error" in response:
                 raise AppException(response["error"])
-            folder_str = (
-                "" if self._folder_names is None else "/".join(self._folder_names)
-            )
 
+            report_message = self._project.name
+            if self._folder_names:
+                report_message = f"[{', '.join(self._folder_names)}]"
             logger.info(
                 f"Prepared export {response['name']} for project "
-                f"{self._project.name}/{folder_str} (project ID {self._project.uuid})."
+                f"{report_message} (project ID {self._project.uuid})."
             )
             self._response.data = response
 
@@ -1018,10 +1023,10 @@ def validate_folder(self):
 
     def execute(self):
         if self.is_valid():
-            is_updated = self._folders.update(self._folder)
-            if not is_updated:
+            folder = self._folders.update(self._folder)
+            if not folder:
                 self._response.errors = AppException("Couldn't rename folder.")
-            self._response.data = self._folder
+            self._response.data = folder
         return self._response
 
 
@@ -2281,9 +2286,7 @@ def fill_classes_data(self, annotations: dict):
         for annotation in (
             i for i in annotations["instances"] if i.get("type", None) == "template"
         ):
-            template_name = templates.get(
-                annotation.get("templateId"), None
-            )
+            template_name = templates.get(annotation.get("templateId"), None)
             if template_name:
                 annotation["templateName"] = template_name
 
@@ -2292,26 +2295,26 @@ def fill_classes_data(self, annotations: dict):
             if annotation_class_id not in annotation_classes:
                 continue
             annotation["className"] = annotation_classes[annotation_class_id]["name"]
-            for attribute in annotation["attributes"]:
+            for attribute in [i for i in annotation["attributes"] if "groupId" in i]:
                 if (
-                    attribute["groupName"]
+                    attribute["groupId"]
                     not in annotation_classes[annotation_class_id]["attribute_groups"]
                 ):
                     continue
                 attribute["groupName"] = annotation_classes[annotation_class_id][
                     "attribute_groups"
                 ][attribute["groupId"]]["name"]
                 if (
-                    attribute["name"]
+                    attribute["groupId"]
                     not in annotation_classes[annotation_class_id]["attribute_groups"][
                         attribute["groupId"]
                     ]["attributes"]
                 ):
-                    del attribute["groupName"]
+                    del attribute["groupId"]
                     continue
                 attribute["name"] = annotation_classes[annotation_class_id][
                     "attribute_groups"
-                ][attribute["groupId"]]["attributes"]
+                ][attribute["groupId"]]["name"]
 
     def execute(self):
         if self.is_valid():
@@ -3336,7 +3339,7 @@ def fill_classes_data(self, annotations: dict):
                     continue
                 attribute["id"] = annotation_classes[annotation_class_name][
                     "attribute_groups"
-                ][attribute["groupName"]]["attributes"]
+                ][attribute["groupName"]]["attributes"][attribute["name"]]
 
     def execute(self):
         if self.is_valid():
@@ -3424,6 +3427,8 @@ def __init__(
         self._annotations_to_upload = None
         self._missing_annotations = None
         self.missing_attribute_groups = set()
+        self.missing_classes = set()
+        self.missing_attributes = set()
 
     @property
     def s3_client(self):
@@ -3474,6 +3479,7 @@ def fill_classes_data(self, annotations: dict):
             annotation_class_name = annotation["className"]
             if annotation_class_name not in annotation_classes:
                 if annotation_class_name not in unknown_classes:
+                    self.missing_classes.add(annotation_class_name)
                     unknown_classes[annotation_class_name] = {
                         "id": -(len(unknown_classes) + 1),
                         "attribute_groups": {},
@@ -3516,6 +3522,7 @@ def fill_classes_data(self, annotations: dict):
                     ][attribute["groupName"]]["attributes"]
                 ):
                     del attribute["groupId"]
+                    self.missing_attributes.add(attribute["name"])
                     continue
                 attribute["id"] = annotation_classes[annotation_class_name][
                     "attribute_groups"
@@ -3661,10 +3668,7 @@ def execute(self):
                 failed_annotations,
                 missing_annotations,
             )
-        if self.missing_attribute_groups:
-            logger.warning(
-                f"Couldn't find annotation groups [{', '.join(self.missing_attribute_groups)}]"
-            )
+        self.report_missing_data()
         return self._response
 
     def upload_to_s3(
@@ -3706,6 +3710,18 @@ def upload_to_s3(
             bucket.put_object(Key=image_info["annotation_bluemap_path"], Body=file)
         return image_id_name_map[image_id], True
 
+    def report_missing_data(self):
+        if self.missing_classes:
+            logger.warning(f"Couldn't find classes [{', '.join(self.missing_classes)}]")
+        if self.missing_attribute_groups:
+            logger.warning(
+                f"Couldn't find annotation groups [{', '.join(self.missing_attribute_groups)}]"
+            )
+        if self.missing_attributes:
+            logger.warning(
+                f"Couldn't find attributes [{', '.join(self.missing_attributes)}]"
+            )
+
 
 class CreateModelUseCase(BaseUseCase):
     def __init__(
@@ -4295,6 +4311,7 @@ def execute(self):
                 image_ids=image_ids,
             )
             if not res.ok:
+                # todo add error message in the response
                 return self._response
 
             success_images = []
@@ -4782,24 +4799,14 @@ def images_to_upload(self):
                     duplicated_paths.append(path)
             filtered_paths = [
                 path
-                for path in filtered_paths
+                for path in paths
                 if not any(
-                    [
-                        path.endswith(extension)
-                        for extension in self.exclude_file_patterns
-                    ]
-                )
-            ]
-            duplicated_paths = [
-                path
-                for path in duplicated_paths
-                if not any(
-                    [
-                        path.endswith(extension)
-                        for extension in self.exclude_file_patterns
-                    ]
+                    [extension in path for extension in self.exclude_file_patterns]
                 )
             ]
+            excluded_paths = [path for path in paths if path not in filtered_paths]
+            if excluded_paths:
+                logger.info(f"Excluded paths {', '.join(excluded_paths)}")
 
             image_entities = (
                 GetBulkImages(

src/superannotate/lib/infrastructure/controller.py

@@ -89,6 +89,7 @@ def init(self, config_path):
         else:
             self._backend_client.api_url = main_endpoint
             self._backend_client._auth_token = token
+            self._backend_client.get_session.cache_clear()
         self._team_id = int(self.configs.get_one("token").value.split("=")[-1])
         self._team = None
 
@@ -108,13 +109,21 @@ def team_name(self):
             _, self._team_name = self.get_team()
         return self._team_name
 
+    @staticmethod
+    def _validate_token(token: str):
+        try:
+            int(token.split("=")[-1])
+        except ValueError:
+            raise AppException("Invalid token.")
+
     def set_token(self, token):
+        self._validate_token(token)
+        self._team_id = int(token.split("=")[-1])
         self.configs.insert(ConfigEntity("token", token))
-        self._backend_client = SuperannotateBackendService(
-            api_url=self.configs.get_one("main_endpoint").value,
-            auth_token=self.configs.get_one("token").value,
-            logger=self._logger,
-        )
+        self._backend_client = SuperannotateBackendService.get_instance()
+        self._backend_client._api_url = self.configs.get_one("main_endpoint").value
+        self._backend_client._auth_token = self.configs.get_one("token").value
+        self._backend_client.get_session.cache_clear()
 
     @property
     def projects(self):

src/superannotate/lib/infrastructure/helpers.py

@@ -12,6 +12,7 @@ def wrapper_cache(func):
 
         @wraps(func)
         def wrapped_func(*args, **kwargs):
+            wrapped_func.cache_clear = func.cache_clear
             if datetime.utcnow() >= func.expiration:
                 func.cache_clear()
                 func.expiration = datetime.utcnow() + func.lifetime

src/superannotate/lib/infrastructure/repositories.py

@@ -269,7 +269,9 @@ def insert(self, entity: FolderEntity) -> FolderEntity:
     def update(self, entity: FolderEntity):
         project_id = entity.project_id
         team_id = entity.team_id
-        return self._service.update_folder(project_id, team_id, entity.to_dict())
+        response = self._service.update_folder(project_id, team_id, entity.to_dict())
+        if response:
+            return self.dict2entity(response)
 
     def delete(self, entity: FolderEntity):
         return self._service.delete_folders(

src/superannotate/lib/infrastructure/services.py

@@ -346,7 +346,8 @@ def update_folder(self, project_id: int, team_id: int, folder_data: dict):
         )
         params = {"project_id": project_id, "team_id": team_id}
         res = self._request(update_folder_url, "put", data=folder_data, params=params)
-        return res.ok
+        if res.ok:
+            return res.json()
 
     def get_project_settings(self, project_id: int, team_id: int):
         get_settings_url = urljoin(