unitlab 2.3.0__py3-none-any.whl

unitlab/__init__.py

@@ -0,0 +1,11 @@
+import logging
+
+from .client import UnitlabClient
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(message)s",
+    datefmt="%Y-%m-%d %H:%M:%S",
+)
+
+__all__ = ["UnitlabClient"]

unitlab/__main__.py

@@ -0,0 +1,3 @@
+from .main import app
+
+app()

unitlab/client.py

@@ -0,0 +1,236 @@
+import asyncio
+import glob
+import logging
+import os
+import urllib.parse
+
+import aiofiles
+import aiohttp
+import requests
+import tqdm
+
+from .utils import get_api_url, handle_exceptions
+
+logger = logging.getLogger(__name__)
+
+
+class UnitlabClient:
+    """A client with a connection to the Unitlab.ai platform.
+
+    Note:
+        Please refer to the `Python SDK quickstart <https://docs.unitlab.ai/cli-python-sdk/unitlab-python-sdk>`__ for a full example of working with the Python SDK.
+
+    First install the SDK.
+
+    .. code-block:: bash
+
+        pip install --upgrade unitlab
+
+    Import the ``unitlab`` package in your python file and set up a client with an API key. An API key can be created on <https://unitlab.ai/>`__.
+
+    .. code-block:: python
+
+        from unitlab import UnitlabClient
+        api_key = 'YOUR_API_KEY'
+        client = UnitlabClient(api_key)
+
+    Or store your Unitlab API key in your environment (``UNITLAB_API_KEY = 'YOUR_API_KEY'``):
+
+    .. code-block:: python
+
+        from unitlab import UnitlabClient
+        client = UnitlabClient()
+
+    Args:
+        api_key: Your Unitlab.ai API key. If no API key given, reads ``UNITLAB_API_KEY`` from the environment. Defaults to :obj:`None`.
+    Raises:
+        :exc:`~unitlab.exceptions.AuthenticationError`: If an invalid API key is used or (when not passing the API key directly) if ``UNITLAB_API_KEY`` is not found in your environment.
+    """
+
+    def __init__(self, api_key, api_url=None):
+        self.api_key = api_key
+        self.api_url = api_url or get_api_url()
+        self.api_session = requests.Session()
+        adapter = requests.adapters.HTTPAdapter(max_retries=3)
+        self.api_session.mount("http://", adapter)
+        self.api_session.mount("https://", adapter)
+
+    def close(self) -> None:
+        """Close :class:`UnitlabClient` connections.
+
+        You can manually close the Unitlab client's connections:
+
+        .. code-block:: python
+
+            client = UnitlabClient()
+            client.projects()
+            client.close()
+
+        Or use the client as a context manager:
+
+        .. code-block:: python
+
+            with UnitlabClient() as client:
+                client.projects()
+        """
+        self.api_session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(
+        self,
+        exc_type,
+        exc_value,
+        traceback,
+    ) -> None:
+        self.close()
+
+    def _get_headers(self):
+        return {"Authorization": f"Api-Key {self.api_key}"}
+
+    @handle_exceptions
+    def _get(self, endpoint):
+        return self.api_session.get(
+            urllib.parse.urljoin(self.api_url, endpoint), headers=self._get_headers()
+        )
+
+    @handle_exceptions
+    def _post(self, endpoint, data=None):
+        return self.api_session.post(
+            urllib.parse.urljoin(self.api_url, endpoint),
+            json=data or {},
+            headers=self._get_headers(),
+        )
+
+    def projects(self, pretty=0):
+        return self._get(f"/api/sdk/projects/?pretty={pretty}")
+
+    def project(self, project_id, pretty=0):
+        return self._get(f"/api/sdk/projects/{project_id}/?pretty={pretty}")
+
+    def project_members(self, project_id, pretty=0):
+        return self._get(f"/api/sdk/projects/{project_id}/members/?pretty={pretty}")
+
+    def project_upload_data(self, project_id, directory, batch_size=100):
+        if not os.path.isdir(directory):
+            raise ValueError(f"Directory {directory} does not exist")
+
+        files = [
+            file
+            for files_list in (
+                glob.glob(os.path.join(directory, "") + extension)
+                for extension in ["*jpg", "*png", "*jpeg", "*webp"]
+            )
+            for file in files_list
+        ]
+        filtered_files = []
+        for file in files:
+            file_size = os.path.getsize(file) / 1024 / 1024
+            if file_size > 6:
+                logger.warning(
+                    f"File {file} is too large ({file_size:.4f} megabytes) skipping, max size is 6 MB"
+                )
+                continue
+            filtered_files.append(file)
+
+        num_files = len(filtered_files)
+        num_batches = (num_files + batch_size - 1) // batch_size
+
+        async def post_file(session: aiohttp.ClientSession, file: str, project_id: str):
+            async with aiofiles.open(file, "rb") as f:
+                form_data = aiohttp.FormData()
+                form_data.add_field("project", project_id)
+                form_data.add_field(
+                    "file", await f.read(), filename=os.path.basename(file)
+                )
+                try:
+                    await asyncio.sleep(0.1)
+                    async with session.post(
+                        urllib.parse.urljoin(self.api_url, "/api/sdk/upload-data/"),
+                        data=form_data,
+                    ) as response:
+                        response.raise_for_status()
+                        return 1
+                except Exception as e:
+                    logger.error(f"Error uploading file {file} - {e}")
+                    return 0
+
+        async def main():
+            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:
+                    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
+                                )
+                            )
+                        for f in asyncio.as_completed(tasks):
+                            pbar.update(await f)
+
+        asyncio.run(main())
+
+    def datasets(self, pretty=0):
+        return self._get(f"/api/sdk/datasets/?pretty={pretty}")
+
+    def dataset_download(self, dataset_id, export_type):
+        response = self._post(
+            f"/api/sdk/datasets/{dataset_id}/",
+            data={"download_type": "annotation", "export_type": export_type},
+        )
+
+        with self.api_session.get(url=response["file"], stream=True) as r:
+            r.raise_for_status()
+            filename = f"dataset-{dataset_id}.json"
+            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)
+
+    def dataset_download_files(self, dataset_id):
+        response = self._post(
+            f"/api/sdk/datasets/{dataset_id}/", data={"download_type": "files"}
+        )
+        folder = f"dataset-files-{dataset_id}"
+        os.makedirs(folder, exist_ok=True)
+        dataset_files = [
+            dataset_file
+            for dataset_file in response
+            if not os.path.isfile(os.path.join(folder, dataset_file["file_name"]))
+        ]
+
+        async def download_file(session: aiohttp.ClientSession, dataset_file: dict):
+            async with session.get(url=dataset_file["source"]) as r:
+                try:
+                    r.raise_for_status()
+                except Exception as e:
+                    logger.error(
+                        f"Error downloading file {dataset_file['file_name']} - {e}"
+                    )
+                    return 0
+                async with aiofiles.open(
+                    os.path.join(folder, dataset_file["file_name"]), "wb"
+                ) as f:
+                    async for chunk in r.content.iter_any():
+                        await f.write(chunk)
+                    return 1
+
+        async def main():
+            with tqdm.tqdm(total=len(dataset_files), ncols=80) as pbar:
+                async with aiohttp.ClientSession() as session:
+                    tasks = [
+                        download_file(session=session, dataset_file=dataset_file)
+                        for dataset_file in dataset_files
+                    ]
+                    for f in asyncio.as_completed(tasks):
+                        pbar.update(await f)
+
+        asyncio.run(main())

unitlab/exceptions.py

@@ -0,0 +1,42 @@
+from typing import Optional
+
+
+class UnitlabError(Exception):
+    """Base class for exceptions."""
+
+    def __init__(self, message: str, detail: Optional[Exception] = None):
+        """
+        Args:
+            message: An informative message about the exception.
+            detail: The detail of the exception raised by Python or another library. Defaults to :obj:`None`.
+        """
+        super().__init__(message, detail)
+        self.message = message
+        self.detail = detail
+
+    def __str__(self) -> str:
+        return self.message
+
+
+class ConfigurationError(UnitlabError):
+    """Raised when a configuration error occurs."""
+
+    pass
+
+
+class AuthenticationError(UnitlabError):
+    """Raised when an API key fails authentication."""
+
+    pass
+
+
+class NetworkError(UnitlabError):
+    """Raised when an HTTP error occurs."""
+
+    pass
+
+
+class SubscriptionError(NetworkError):
+    """Raised when a subscription error occurs"""
+
+    pass

unitlab/main.py

@@ -0,0 +1,109 @@
+from enum import Enum
+from pathlib import Path
+from uuid import UUID
+
+import typer
+import validators
+from typing_extensions import Annotated
+
+from . import utils
+from .client import UnitlabClient
+
+app = typer.Typer()
+project_app = typer.Typer()
+dataset_app = typer.Typer()
+
+app.add_typer(project_app, name="project", help="Project commands")
+app.add_typer(dataset_app, name="dataset", help="Dataset commands")
+
+
+API_KEY = Annotated[
+    str,
+    typer.Option(
+        default_factory=utils.get_api_key, help="The api-key obtained from unitlab.ai"
+    ),
+]
+
+
+class DownloadType(str, Enum):
+    annotation = "annotation"
+    files = "files"
+
+
+class AnnotationType(str, Enum):
+    IMG_BBOX = "img_bbox"
+    IMG_SEMANTIC_SEGMENTATION = "img_semantic_segmentation"
+    IMG_INSTANCE_SEGMENTATION = "img_instance_segmentation"
+    IMG_POLYGON = "img_polygon"
+    IMG_LINE = "img_line"
+    IMG_POINT = "img_point"
+
+
+@app.command(help="Configure the credentials")
+def configure(
+    api_key: Annotated[str, typer.Option(help="The api-key obtained from unitlab.ai")],
+    api_url: Annotated[str, typer.Option()] = "https://api.unitlab.ai",
+):
+    if not validators.url(api_url, simple_host=True):
+        raise typer.BadParameter("Invalid api url")
+    utils.write_config(api_key=api_key, api_url=api_url)
+
+
+def get_client(api_key: str) -> UnitlabClient:
+    return UnitlabClient(api_key=api_key)
+
+
+@project_app.command(name="list", help="Project list")
+def project_list(api_key: API_KEY):
+    print(get_client(api_key).projects(pretty=1))
+
+
+@project_app.command(name="detail", help="Project detail")
+def project_detail(pk: UUID, api_key: API_KEY):
+    print(get_client(api_key).project(project_id=pk, pretty=1))
+
+
+@project_app.command(help="Project members")
+def members(pk: UUID, api_key: API_KEY):
+    print(get_client(api_key).project_members(project_id=pk, pretty=1))
+
+
+@project_app.command(help="Upload data")
+def upload(
+    pk: UUID,
+    api_key: API_KEY,
+    directory: Annotated[
+        Path, typer.Option(help="Directory containing the data to be uploaded")
+    ],
+):
+    get_client(api_key).project_upload_data(str(pk), directory=directory)
+
+
+@dataset_app.command(name="list", help="List datasets")
+def dataset_list(api_key: API_KEY):
+    print(get_client(api_key).datasets(pretty=1))
+
+
+@dataset_app.command(name="download", help="Download dataset")
+def dataset_download(
+    pk: UUID,
+    api_key: API_KEY,
+    download_type: Annotated[
+        DownloadType,
+        typer.Option(help="Download type (annotation, files)"),
+    ] = DownloadType.annotation,
+    export_type: Annotated[
+        str, typer.Option(help="Export type (COCO, YOLOv8, YOLOv5)")
+    ] = "COCO",
+):
+    if download_type == DownloadType.annotation:
+        if not export_type:
+            raise typer.BadParameter(
+                "Export type is required when download type is annotation"
+            )
+        return get_client(api_key).dataset_download(pk, export_type)
+    get_client(api_key).dataset_download_files(pk)
+
+
+if __name__ == "__main__":
+    app()

unitlab/utils.py

@@ -0,0 +1,65 @@
+import logging
+from configparser import ConfigParser
+from pathlib import Path
+
+import requests
+
+from . import exceptions
+
+logger = logging.getLogger(__name__)
+
+CONFIG_FILE_PATH = Path.home() / ".unitlab" / "credentials"
+
+
+def handle_exceptions(f):
+    def throw_exception(*args, **kwargs):
+        try:
+            r = f(*args, **kwargs)
+            if r.status_code == 401:
+                raise exceptions.AuthenticationError("Authentication failed")
+            r.raise_for_status()
+            return r.json()
+        except requests.exceptions.RequestException as e:
+            raise exceptions.NetworkError(str(e))
+
+    return throw_exception
+
+
+def write_config(api_key: str, api_url: str):
+    config = ConfigParser()
+    config.add_section("default")
+    config.set("default", "api_key", api_key)
+    config.set("default", "api_url", api_url)
+
+    CONFIG_FILE_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE_PATH, "w") as configfile:
+        config.write(configfile)
+    logger.info(f"Credentials saved to {CONFIG_FILE_PATH}")
+
+
+def read_config():
+    if not CONFIG_FILE_PATH.exists():
+        raise exceptions.ConfigurationError(
+            f"No configuration file found at {CONFIG_FILE_PATH}. Please run `unitlab configure --help` for more information."
+        )
+    config = ConfigParser()
+    config.read(CONFIG_FILE_PATH)
+    return config
+
+
+def get_api_key() -> str:
+    config = read_config()
+    try:
+        return config.get("default", "api_key")
+    except Exception:
+        raise exceptions.ConfigurationError(
+            f"Key `api_key` not found in {CONFIG_FILE_PATH}. Please run `unitlab configure` or provide the api-key using the --api-key option."
+        )
+
+
+def get_api_url() -> str:
+    config = read_config()
+    try:
+        return config.get("default", "api_url")
+    except Exception:
+        return "https://api.unitlab.ai"

unitlab-2.3.0.dist-info/METADATA

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: unitlab
+Version: 2.3.0
+Home-page: https://github.com/teamunitlab/unitlab-sdk
+Author: Unitlab Inc.
+Author-email: team@unitlab.ai
+License: MIT
+Keywords: unitlab-sdk
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+License-File: LICENSE.md
+Requires-Dist: aiohttp
+Requires-Dist: aiofiles
+Requires-Dist: requests
+Requires-Dist: tqdm
+Requires-Dist: typer
+Requires-Dist: validators
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist

unitlab-2.3.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+unitlab/__init__.py,sha256=Wtk5kQ_MTlxtd3mxJIn2qHVK5URrVcasMMPjD3BtrVM,214
+unitlab/__main__.py,sha256=6Hs2PV7EYc5Tid4g4OtcLXhqVHiNYTGzSBdoOnW2HXA,29
+unitlab/client.py,sha256=j8m0An4Bt3ARA1ps7P2o-NLcfWFPoaXG_PxIdBDAEpQ,8374
+unitlab/exceptions.py,sha256=68Tr6LreEzjQ3Vns8HAaWdtewtkNUJOvPazbf6NSnXU,950
+unitlab/main.py,sha256=3_awGLQ39dOA4WpOLkngzTK1X9ttOs9avh4PvJFlH34,3039
+unitlab/utils.py,sha256=U95JqeUvKP0p5Ka0KIar0e8Uqe_4TZmZ7N68UdEGfpk,1888
+unitlab-2.3.0.dist-info/licenses/LICENSE.md,sha256=Gn7RRvByorAcAaM-WbyUpsgi5ED1-bKFFshbWfYYz2Y,1069
+unitlab-2.3.0.dist-info/METADATA,sha256=9gk8MoNLgV1jPR9TdT_NSvM8wqAqxU10isgBNjQzgNY,903
+unitlab-2.3.0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+unitlab-2.3.0.dist-info/entry_points.txt,sha256=ig-PjKEqSCj3UTdyANgEi4tsAU84DyXdaOJ02NHX4bY,45
+unitlab-2.3.0.dist-info/top_level.txt,sha256=Al4ZlTYE3fTJK2o6YLCDMH5_DjuQkffRBMxgmWbKaqQ,8
+unitlab-2.3.0.dist-info/RECORD,,

unitlab-2.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (77.0.3)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

unitlab-2.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+unitlab = unitlab.main:app

unitlab-2.3.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

unitlab-2.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+unitlab