unitlab 2.4.1__tar.gz → 2.4.3__tar.gz

{unitlab-2.4.1 → unitlab-2.4.3}/.claude/settings.local.json

@@ -36,7 +36,14 @@
       "Bash(git update-ref:*)",
       "Bash(gh api:*)",
       "Bash(for user in Shahrullo shohmax mrakhror maxunitlab)",
-      "Bash(do echo \"Removing $user...\")"
+      "Bash(do echo \"Removing $user...\")",
+      "WebFetch(domain:unitlab-storage.s3.us-east-2.amazonaws.com)",
+      "Bash(ps:*)",
+      "WebFetch(domain:127.0.0.1)",
+      "Bash(DATASET_ID=\"b727a6fd-7786-4d40-b75b-56e7f52f378b\")",
+      "Bash(pipenv run:*)",
+      "Bash(DS=\"b727a6fd-7786-4d40-b75b-56e7f52f378b\")",
+      "Bash(python3 -c \"import sys,json; d=json.load\\(sys.stdin\\); print\\(''''OK'''' if ''''file'''' in d else d\\)\")"
     ]
   }
 }

{unitlab-2.4.1 → unitlab-2.4.3}/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Team Unitlab
+Copyright (c) 2026 Team Unitlab
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{unitlab-2.4.1 → unitlab-2.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: unitlab
-Version: 2.4.1
+Version: 2.4.3
 Summary: Python SDK for the Unitlab.ai data annotation platform
 Project-URL: Homepage, https://unitlab.ai
 Project-URL: Documentation, https://docs.unitlab.ai
@@ -19,18 +19,15 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
-Requires-Dist: aiofiles>=23.0
-Requires-Dist: aiohttp>=3.9
-Requires-Dist: requests>=2.28
+Requires-Dist: httpx>=0.27
 Requires-Dist: tqdm>=4.60
 Requires-Dist: typer>=0.9
 Requires-Dist: validators>=0.20
 Provides-Extra: dev
-Requires-Dist: aioresponses>=0.7; extra == 'dev'
 Requires-Dist: build>=1.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.21; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
-Requires-Dist: responses>=0.23; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
 Requires-Dist: twine>=5.0; extra == 'dev'
 Description-Content-Type: text/markdown

{unitlab-2.4.1 → unitlab-2.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "unitlab"
-version = "2.4.1"
+version = "2.4.3"
 description = "Python SDK for the Unitlab.ai data annotation platform"
 readme = "README.md"
 license = "MIT"
@@ -23,9 +23,7 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "aiohttp>=3.9",
-    "aiofiles>=23.0",
-    "requests>=2.28",
+    "httpx>=0.27",
     "tqdm>=4.60",
     "typer>=0.9",
     "validators>=0.20",
@@ -35,8 +33,7 @@ dependencies = [
 dev = [
     "pytest>=7.0",
     "pytest-asyncio>=0.21",
-    "responses>=0.23",
-    "aioresponses>=0.7",
+    "respx>=0.21",
     "ruff>=0.4",
     "build>=1.0",
     "twine>=5.0",

{unitlab-2.4.1 → unitlab-2.4.3}/src/unitlab/cli.py

@@ -39,7 +39,7 @@ class DownloadType(str, Enum):
 
 class DatasetSplit(str, Enum):
     train = "train"
-    val = "val"
+    validation = "validation"
     test = "test"
 
 
@@ -120,24 +120,17 @@ def dataset_download(
         typer.Option(help="Download type (annotation, files)"),
     ] = DownloadType.annotation,
     export_type: Annotated[
-        str, typer.Option(help="Export type (COCO, YOLOv8, YOLOv5 ..etc)")
+        str,
+        typer.Option(help="Export type (e.g. COCO, YOLOv8, YOLOv5, UUEF)"),
     ] = "COCO",
     split_type: Annotated[
-        DatasetSplit, typer.Option(help="Dataset split (train, val, test)")
+        DatasetSplit, typer.Option(help="Dataset split (train, validation, test)")
     ] = DatasetSplit.train,
 ):
     if download_type == DownloadType.annotation:
-        if not export_type:
-            raise typer.BadParameter(
-                "Export type is required when download type is annotation"
-            )
-        if not split_type:
-            raise typer.BadParameter(
-                "Split type is required when download type is annotation"
-            )
-        get_client(api_key).dataset_download(pk, export_type, split_type)
+        get_client(api_key).dataset_download(str(pk), export_type, split_type.value)
     else:
-        typer.echo(get_client(api_key).dataset_download_files(pk))
+        typer.echo(get_client(api_key).dataset_download_files(str(pk)))
 
 
 if __name__ == "__main__":

{unitlab-2.4.1 → unitlab-2.4.3}/src/unitlab/client.py

@@ -4,13 +4,12 @@ import asyncio
 import functools
 import logging
 import os
+import uuid
 from pathlib import Path
 from typing import Any
-from urllib.parse import urljoin, urlparse
+from urllib.parse import urlparse
 
-import aiofiles
-import aiohttp
-import requests
+import httpx
 import tqdm
 
 from ._config import get_api_key, get_api_url
@@ -28,6 +27,27 @@ _UPLOAD_CONCURRENCY = 20
 _DOWNLOAD_CONCURRENCY = 50
 
 
+def _extract_error_message(response: httpx.Response) -> str:
+    """Extract a human-readable message from an error response."""
+    try:
+        body = response.json()
+        if isinstance(body, dict):
+            for key in ("detail", "message"):
+                if key in body:
+                    return str(body[key])
+            parts = []
+            for field, errors in body.items():
+                if isinstance(errors, list):
+                    parts.append(f"{field}: {', '.join(str(e) for e in errors)}")
+                else:
+                    parts.append(f"{field}: {errors}")
+            if parts:
+                return "; ".join(parts)
+    except (ValueError, KeyError):
+        pass
+    return response.text
+
+
 def handle_exceptions(f):
     """Catch exceptions and throw Unitlab exceptions."""
 
@@ -37,23 +57,23 @@ def handle_exceptions(f):
             r = f(self, *args, **kwargs)
             r.raise_for_status()
             return r.json()
-        except requests.exceptions.Timeout as e:
+        except httpx.TimeoutException as e:
             raise TimeoutError(message=str(e), detail=e) from e
-        except requests.exceptions.HTTPError as e:
-            text = e.response.text.lower()
+        except httpx.HTTPStatusError as e:
+            text = _extract_error_message(e.response)
             if e.response.status_code == 401:
                 raise AuthenticationError(
                     message="Authentication failed", detail=e
                 ) from e
             if e.response.status_code == 403:
-                raise SubscriptionError(
-                    message=f"Forbidden: {e.response.status_code} {e.response.reason}",
-                    detail=e,
-                ) from e
-            if "not found" in text:
+                msg = f"Forbidden: {e.response.status_code} {e.response.reason_phrase}"
+                raise SubscriptionError(message=msg, detail=e) from e
+            if e.response.status_code == 404 or "not found" in text.lower():
                 raise NotFoundError(message=text, detail=e) from e
             raise NetworkError(message=text, detail=e) from e
-        except requests.exceptions.RequestException as e:
+        except ValueError as e:
+            raise NetworkError(message="Unexpected response format", detail=e) from e
+        except httpx.HTTPError as e:
             raise NetworkError(message=str(e), detail=e) from e
 
     return wrapper
@@ -123,11 +143,12 @@ class UnitlabClient:
         self.api_url: str = (
             api_url or os.environ.get("UNITLAB_API_URL") or get_api_url()
         )
-        self.api_session = requests.Session()
-        self.api_session.headers["Authorization"] = f"Api-Key {self.api_key}"
-        adapter = requests.adapters.HTTPAdapter(max_retries=3)
-        self.api_session.mount("http://", adapter)
-        self.api_session.mount("https://", adapter)
+        self._client = httpx.Client(
+            base_url=self.api_url,
+            headers={"Authorization": f"Api-Key {self.api_key}"},
+            transport=httpx.HTTPTransport(retries=3),
+            timeout=60.0,
+        )
 
     def close(self) -> None:
         """Close :class:`UnitlabClient` connections.
@@ -147,7 +168,7 @@ class UnitlabClient:
             with UnitlabClient() as client:
                 client.projects()
         """
-        self.api_session.close()
+        self._client.close()
 
     def __enter__(self) -> UnitlabClient:
         return self
@@ -160,21 +181,15 @@ class UnitlabClient:
     ) -> None:
         self.close()
 
-    def _get_headers(self) -> dict[str, str]:
-        return {"Authorization": f"Api-Key {self.api_key}"}
-
     @handle_exceptions
-    def _get(self, endpoint: str) -> requests.Response:
-        return self.api_session.get(urljoin(self.api_url, endpoint))
+    def _get(self, endpoint: str) -> httpx.Response:
+        return self._client.get(endpoint)
 
     @handle_exceptions
     def _post(
         self, endpoint: str, data: dict[str, Any] | None = None
-    ) -> requests.Response:
-        return self.api_session.post(
-            urljoin(self.api_url, endpoint),
-            json=data if data is not None else {},
-        )
+    ) -> httpx.Response:
+        return self._client.post(endpoint, json=data if data is not None else {})
 
     def projects(self, pretty: int = 0) -> Any:
         return self._get(f"/api/sdk/projects/?pretty={pretty}")
@@ -233,26 +248,28 @@ class UnitlabClient:
         num_batches = (num_files + batch_size - 1) // batch_size
         semaphore = asyncio.Semaphore(_UPLOAD_CONCURRENCY)
 
+        # Medical projects use session-based upload with finalize
+        session_id = str(uuid.uuid4()) if generic_type == "medical" else None
+
         async def post_file(
-            session: aiohttp.ClientSession, file: str, project_id: str
+            client: httpx.AsyncClient, file: str, project_id: str
         ) -> int:
-            async with semaphore, aiofiles.open(file, "rb") as f:
-                form_data = aiohttp.FormData()
-                form_data.add_field(
-                    "file", await f.read(), filename=os.path.basename(file)
-                )
+            async with semaphore:
+                extra_data: dict[str, str] = {}
                 if generic_type == "text":
-                    form_data.add_field("sentences_per_chunk", str(sentences_per_chunk))
+                    extra_data["sentences_per_chunk"] = str(sentences_per_chunk)
                 elif generic_type == "video":
-                    form_data.add_field("fps", str(fps))
+                    extra_data["fps"] = str(fps)
+                if session_id:
+                    extra_data["session_id"] = session_id
 
                 try:
-                    async with session.post(
-                        urljoin(
-                            self.api_url, f"/api/sdk/projects/{project_id}/upload-data/"
-                        ),
-                        data=form_data,
-                    ) as response:
+                    with open(file, "rb") as f:
+                        response = await client.post(
+                            f"/api/sdk/projects/{project_id}/upload-data/",
+                            files={"file": (os.path.basename(file), f)},
+                            data=extra_data,
+                        )
                         response.raise_for_status()
                         return 1
                 except Exception as e:
@@ -262,22 +279,30 @@ class UnitlabClient:
         async def main() -> None:
             logger.info(f"Uploading {num_files} files to project {project_id}")
             with tqdm.tqdm(total=num_files, ncols=80) as pbar:
-                async with aiohttp.ClientSession(
-                    headers=self._get_headers()
-                ) as session:
+                async with httpx.AsyncClient(
+                    base_url=self.api_url,
+                    headers={"Authorization": f"Api-Key {self.api_key}"},
+                    timeout=600.0,
+                ) as client:
                     for i in range(num_batches):
-                        tasks = []
-                        for file in filtered_files[
-                            i * batch_size : min((i + 1) * batch_size, num_files)
-                        ]:
-                            tasks.append(
-                                post_file(
-                                    session=session, file=file, project_id=project_id
-                                )
-                            )
+                        tasks = [
+                            post_file(client=client, file=file, project_id=project_id)
+                            for file in filtered_files[
+                                i * batch_size : min((i + 1) * batch_size, num_files)
+                            ]
+                        ]
                         for f in asyncio.as_completed(tasks):
                             pbar.update(await f)
 
+                    # Finalize medical session after all uploads
+                    if session_id:
+                        response = await client.post(
+                            f"/api/sdk/projects/{project_id}/"
+                            f"medical-upload-sessions/{session_id}/finalize/",
+                        )
+                        response.raise_for_status()
+                        logger.info("Medical session finalized")
+
         asyncio.run(main())
 
     def datasets(self, pretty: int = 0) -> Any:
@@ -295,17 +320,21 @@ class UnitlabClient:
             },
         )
 
-        with requests.get(url=response["file"], stream=True) as r:
-            r.raise_for_status()
+        file_url = response["file"]
+        try:
+            with httpx.stream("GET", file_url, timeout=300.0) as r:
+                r.raise_for_status()
 
-            parsed_url = urlparse(response["file"])
-            filename = os.path.basename(parsed_url.path)
+                parsed_url = urlparse(file_url)
+                filename = os.path.basename(parsed_url.path)
 
-            with open(filename, "wb") as f:
-                for chunk in r.iter_content(chunk_size=1024 * 1024):
-                    f.write(chunk)
-            logger.info(f"File: {os.path.abspath(filename)}")
-            return os.path.abspath(filename)
+                with open(filename, "wb") as f:
+                    for chunk in r.iter_bytes():
+                        f.write(chunk)
+                logger.info(f"File: {os.path.abspath(filename)}")
+                return os.path.abspath(filename)
+        except httpx.HTTPError as e:
+            raise NetworkError(message=f"Failed to download file: {e}", detail=e) from e
 
     def dataset_download_files(self, dataset_id: str) -> str:
         """Download files from a dataset.
@@ -350,26 +379,27 @@ class UnitlabClient:
         semaphore = asyncio.Semaphore(_DOWNLOAD_CONCURRENCY)
 
         async def download_file(
-            session: aiohttp.ClientSession, dataset_file: dict[str, str]
+            client: httpx.AsyncClient, dataset_file: dict[str, str]
         ) -> int:
-            async with semaphore, session.get(url=dataset_file["source"]) as r:
+            async with semaphore:
                 try:
-                    r.raise_for_status()
+                    async with client.stream("GET", dataset_file["source"]) as r:
+                        r.raise_for_status()
+                        with open(dataset_file["file_path"], "wb") as f:
+                            async for chunk in r.aiter_bytes():
+                                f.write(chunk)
+                        return 1
                 except Exception as e:
                     logger.error(
                         f"Error downloading file {dataset_file['file_name']} - {e}"
                     )
                     return 0
-                async with aiofiles.open(dataset_file["file_path"], "wb") as f:
-                    async for chunk in r.content.iter_any():
-                        await f.write(chunk)
-                    return 1
 
         async def main() -> None:
             with tqdm.tqdm(total=len(files_to_download), ncols=80) as pbar:
-                async with aiohttp.ClientSession() as session:
+                async with httpx.AsyncClient(timeout=600.0) as client:
                     tasks = [
-                        download_file(session=session, dataset_file=df)
+                        download_file(client=client, dataset_file=df)
                         for df in files_to_download
                     ]
                     for f in asyncio.as_completed(tasks):