Fix session

Author: dshabin

src/superannotate/lib/core/usecases.py

@@ -2485,14 +2485,21 @@ def __init__(
         self._annotation_status_code = annotation_status_code
         self._image_quality_in_editor = image_quality_in_editor
         self._limit = limit
+        self._auth_data = None
 
-    @property
-    def upload_auth_data(self):
-        return self._backend_service.get_s3_upload_auth_token(
-            project_id=self._project.uuid,
+    def validate_auth_data(self):
+        response = self._backend_service.get_s3_upload_auth_token(
             team_id=self._project.team_id,
             folder_id=self._folder.uuid,
+            project_id=self._project.uuid,
         )
+        if "error" in response:
+            raise AppException(response.get("error"))
+        self._auth_data = response
+
+    @property
+    def upload_auth_data(self):
+        return self._auth_data
 
     @property
     def limit(self):
@@ -2501,15 +2508,16 @@ def limit(self):
         return self._limit
 
     def execute(self):
-        extracted_paths = VideoPlugin.extract_frames(
-            video_path=self._video_path,
-            start_time=self._start_time,
-            end_time=self._end_time,
-            extract_path=self._extract_path,
-            limit=self.limit,
-            target_fps=self._target_fps,
-        )
-        self._response.data = extracted_paths
+        if self.is_valid():
+            extracted_paths = VideoPlugin.extract_frames(
+                video_path=self._video_path,
+                start_time=self._start_time,
+                end_time=self._end_time,
+                extract_path=self._extract_path,
+                limit=self.limit,
+                target_fps=self._target_fps,
+            )
+            self._response.data = extracted_paths
         return self._response
 
 
@@ -4172,14 +4180,18 @@ def validate_project_type(self):
                 "The function does not support projects containing videos attached with URLs"
             )
 
+    def validate_auth_data(self):
+        response = self._backend_client.get_s3_upload_auth_token(
+            team_id=self._project.team_id,
+            folder_id=self._folder.uuid,
+            project_id=self._project.uuid,
+        )
+        if "error" in response:
+            raise AppException(response.get("error"))
+        self._auth_data = response
+
     @property
     def auth_data(self):
-        if not self._auth_data:
-            self._auth_data = self._backend_client.get_s3_upload_auth_token(
-                team_id=self._project.team_id,
-                folder_id=self._folder.uuid,
-                project_id=self._project.uuid,
-            )
         return self._auth_data
 
     @property
@@ -4308,39 +4320,41 @@ def images_to_upload(self):
         return self._images_to_upload
 
     def execute(self):
-        images_to_upload, duplications = self.images_to_upload
-        images_to_upload = images_to_upload[: self.auth_data["availableImageCount"]]
-        uploaded_images = []
-        failed_images = []
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=self.MAX_WORKERS
-        ) as executor:
-            results = [
-                executor.submit(self._upload_image, image_path)
-                for image_path in images_to_upload
-            ]
-            for future in concurrent.futures.as_completed(results):
-                processed_image = future.result()
-                if processed_image.uploaded and processed_image.entity:
-                    uploaded_images.append(processed_image)
-                else:
-                    failed_images.append(processed_image.path)
-                yield
-
-        uploaded = []
-        for i in range(0, len(uploaded_images), 100):
-            response = AttachFileUrlsUseCase(
-                project=self._project,
-                folder=self._folder,
-                limit=self.auth_data["availableImageCount"],
-                backend_service_provider=self._backend_client,
-                attachments=[image.entity for image in uploaded_images[i : i + 100]],
-                annotation_status=self._annotation_status,
-            ).execute()
-
-            attachments, duplications = response.data
-            uploaded.extend(attachments)
-        uploaded = [image["name"] for image in uploaded]
-        failed_images = [image.split("/")[-1] for image in failed_images]
-
-        self._response.data = uploaded, failed_images, duplications
+        if self.is_valid():
+            images_to_upload, duplications = self.images_to_upload
+            images_to_upload = images_to_upload[: self.auth_data["availableImageCount"]]
+            uploaded_images = []
+            failed_images = []
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=self.MAX_WORKERS
+            ) as executor:
+                results = [
+                    executor.submit(self._upload_image, image_path)
+                    for image_path in images_to_upload
+                ]
+                for future in concurrent.futures.as_completed(results):
+                    processed_image = future.result()
+                    if processed_image.uploaded and processed_image.entity:
+                        uploaded_images.append(processed_image)
+                    else:
+                        failed_images.append(processed_image.path)
+                    yield
+
+            uploaded = []
+            for i in range(0, len(uploaded_images), 100):
+                response = AttachFileUrlsUseCase(
+                    project=self._project,
+                    folder=self._folder,
+                    limit=self.auth_data["availableImageCount"],
+                    backend_service_provider=self._backend_client,
+                    attachments=[image.entity for image in uploaded_images[i : i + 100]],
+                    annotation_status=self._annotation_status,
+                ).execute()
+
+                attachments, duplications = response.data
+                uploaded.extend(attachments)
+            uploaded = [image["name"] for image in uploaded]
+            failed_images = [image.split("/")[-1] for image in failed_images]
+
+            self._response.data = uploaded, failed_images, duplications
+        return self._response

src/superannotate/lib/infrastructure/controller.py

@@ -107,9 +107,12 @@ def team_id(self) -> int:
 
     @timed_lru_cache(seconds=3600)
     def get_auth_data(self, project_id: int, team_id: int, folder_id: int):
-        return self._backend_client.get_s3_upload_auth_token(
+        response = self._backend_client.get_s3_upload_auth_token(
             team_id, folder_id, project_id
         )
+        if "error" in response:
+            raise AppException(response.get("error"))
+        return response
 
     def get_s3_repository(self, team_id: int, project_id: int, folder_id: int):
         auth_data = self.get_auth_data(project_id, team_id, folder_id)

src/superannotate/lib/infrastructure/services.py

@@ -31,14 +31,12 @@ def __init__(self, api_url: str, auth_token: str, logger, paginate_by=None):
         self.logger = logger
         self._paginate_by = paginate_by
         self.team_id = auth_token.split("=")[-1]
-        self._session = None
 
     @timed_lru_cache(seconds=360)
     def get_session(self):
-        if not self._session:
-            self._session = requests.Session()
-            self._session.headers.update(self.default_headers)
-        return self._session
+        session = requests.Session()
+        session.headers.update(self.default_headers)
+        return session
 
     @property
     def default_headers(self):
@@ -82,8 +80,8 @@ def _request(
         session.headers.update(headers if headers else {})
         with self.safe_api():
             req = requests.Request(method=method, url=url, **kwargs, params=params)
-            prepared = self._session.prepare_request(req)
-            response = self._session.send(request=prepared)
+            prepared = session.prepare_request(req)
+            response = session.send(request=prepared)
         if response.status_code == 404 and retried < 3:
             return self._request(
                 url,

tests/integration/test_interface.py

@@ -7,7 +7,6 @@
 from tests.integration.base import BaseTestCase
 
 
-
 class TestInterface(BaseTestCase):
     PROJECT_NAME = "Interface test"
     TEST_FOLDER_PATH = "data_set/sample_project_vector"