unitlab 2.2.0__tar.gz → 2.3.0__tar.gz

{unitlab-2.2.0/src/unitlab.egg-info → unitlab-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: unitlab
-Version: 2.2.0
+Version: 2.3.0
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -9,12 +9,11 @@ Keywords: unitlab-sdk
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 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
@@ -22,3 +21,11 @@ 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.2.0 → unitlab-2.3.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import find_packages, setup
 
 setup(
     name="unitlab",
-    version="2.2.0",
+    version="2.3.0",
     license="MIT",
     author="Unitlab Inc.",
     author_email="team@unitlab.ai",
@@ -13,12 +13,11 @@ setup(
         "Development Status :: 4 - Beta",
         "Intended Audience :: Developers",
         "License :: OSI Approved :: MIT License",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
     ],
     package_dir={"": "src"},
     url="https://github.com/teamunitlab/unitlab-sdk",

{unitlab-2.2.0 → unitlab-2.3.0}/src/unitlab/client.py

@@ -9,8 +9,6 @@ import aiohttp
 import requests
 import tqdm
 
-from . import exceptions
-from .dataset import DatasetUploadHandler
 from .utils import get_api_url, handle_exceptions
 
 logger = logging.getLogger(__name__)
@@ -182,9 +180,6 @@ class UnitlabClient:
     def datasets(self, pretty=0):
         return self._get(f"/api/sdk/datasets/?pretty={pretty}")
 
-    def licenses(self):
-        return self._get("/api/sdk/licenses/")
-
     def dataset_download(self, dataset_id, export_type):
         response = self._post(
             f"/api/sdk/datasets/{dataset_id}/",
@@ -239,92 +234,3 @@ class UnitlabClient:
                         pbar.update(await f)
 
         asyncio.run(main())
-
-    def _finalize_dataset(self, dataset_id):
-        return self._post(f"/api/sdk/datasets/{dataset_id}/finalize/")
-
-    def _dataset_data_upload(
-        self, dataset_id, upload_handler: DatasetUploadHandler, batch_size=15
-    ):
-        image_ids = upload_handler.getImgIds()
-        url = urllib.parse.urljoin(
-            self.api_url, f"/api/sdk/datasets/{dataset_id}/upload/"
-        )
-
-        async def main():
-            with tqdm.tqdm(total=len(image_ids), ncols=80) as pbar:
-                async with aiohttp.ClientSession(
-                    headers=self._get_headers()
-                ) as session:
-                    try:
-                        for i in range((len(image_ids) + batch_size - 1) // batch_size):
-                            tasks = []
-                            for image_id in image_ids[
-                                i * batch_size : min(
-                                    (i + 1) * batch_size, len(image_ids)
-                                )
-                            ]:
-                                tasks.append(
-                                    upload_handler.upload_image(session, url, image_id)
-                                )
-                            for f in asyncio.as_completed(tasks):
-                                try:
-                                    pbar.update(await f)
-                                except exceptions.SubscriptionError as e:
-                                    raise e
-                    except exceptions.SubscriptionError as e:
-                        raise e
-
-        asyncio.run(main())
-
-    def dataset_upload(
-        self,
-        name,
-        annotation_type,
-        annotation_path,
-        data_path,
-        license_id=None,
-        batch_size=15,
-    ):
-        upload_handler = DatasetUploadHandler(
-            annotation_type, annotation_path, data_path
-        )
-        dataset_id = self._post(
-            "/api/sdk/datasets/create/",
-            data={
-                "name": name,
-                "annotation_type": annotation_type,
-                "classes": [
-                    {"name": category["name"], "value": category["id"]}
-                    for category in upload_handler.categories
-                ],
-                "license": license_id,
-            },
-        )["pk"]
-        self._dataset_data_upload(dataset_id, upload_handler, batch_size=batch_size)
-        self._finalize_dataset(dataset_id)
-
-    def dataset_update(self, pk, annotation_path, data_path, batch_size=15):
-        dataset = self._get(f"api/sdk/datasets/{pk}/")
-        upload_handler = DatasetUploadHandler(
-            dataset["annotation_type"], annotation_path, data_path
-        )
-        new_dataset = self._post(
-            f"/api/sdk/datasets/{pk}/update/",
-            data={
-                "classes": [
-                    {"name": category["name"], "value": category["id"]}
-                    for category in sorted(
-                        upload_handler.loadCats(upload_handler.getCatIds()),
-                        key=lambda x: x["id"],
-                    )
-                ]
-            },
-        )
-        upload_handler.original_category_referecences = {
-            int(k): v for k, v in new_dataset["original_category_referecences"].items()
-        }
-        self._dataset_data_upload(
-            new_dataset["pk"], upload_handler, batch_size=batch_size
-        )
-        self._finalize_dataset(new_dataset["pk"])

{unitlab-2.2.0 → unitlab-2.3.0}/src/unitlab/main.py

@@ -84,49 +84,6 @@ def dataset_list(api_key: API_KEY):
     print(get_client(api_key).datasets(pretty=1))
 
 
-@dataset_app.command(name="upload", help="Upload dataset")
-def dataset_upload(
-    api_key: API_KEY,
-    name: Annotated[str, typer.Option(help="Name of the dataset")],
-    annotation_type: Annotated[AnnotationType, typer.Option(help="Annotation format")],
-    annotation_path: Annotated[Path, typer.Option(help="Path to the COCO json file")],
-    data_path: Annotated[
-        Path, typer.Option(help="Directory containing the data to be uploaded")
-    ],
-):
-    client = get_client(api_key)
-    licenses = client.licenses()
-    chosen_license = None
-    if licenses:
-        LicenseEnum = Enum(
-            "LicenseEnum",
-            {license["pk"]: str(idx) for idx, license in enumerate(licenses)},
-        )
-        help_prompt = ", ".join(
-            f"{idx}: {license['name']}" for idx, license in enumerate(licenses)
-        )
-        chosen_license = typer.prompt(f"Select license {help_prompt}", type=LicenseEnum)
-    client.dataset_upload(
-        name,
-        annotation_type.value,
-        annotation_path,
-        data_path,
-        license_id=chosen_license.name if chosen_license else None,
-    )
-
-
-@dataset_app.command(name="update", help="Update dataset")
-def dataset_update(
-    pk: UUID,
-    api_key: API_KEY,
-    annotation_path: Annotated[Path, typer.Option(help="Path to the COCO json file")],
-    data_path: Annotated[
-        Path, typer.Option(help="Directory containing the data to be uploaded")
-    ],
-):
-    get_client(api_key).dataset_update(pk, annotation_path, data_path)
-
-
 @dataset_app.command(name="download", help="Download dataset")
 def dataset_download(
     pk: UUID,

{unitlab-2.2.0 → unitlab-2.3.0/src/unitlab.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: unitlab
-Version: 2.2.0
+Version: 2.3.0
 Home-page: https://github.com/teamunitlab/unitlab-sdk
 Author: Unitlab Inc.
 Author-email: team@unitlab.ai
@@ -9,12 +9,11 @@ Keywords: unitlab-sdk
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 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
@@ -22,3 +21,11 @@ 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.2.0 → unitlab-2.3.0}/src/unitlab.egg-info/SOURCES.txt

@@ -5,7 +5,6 @@ setup.py
 src/unitlab/__init__.py
 src/unitlab/__main__.py
 src/unitlab/client.py
-src/unitlab/dataset.py
 src/unitlab/exceptions.py
 src/unitlab/main.py
 src/unitlab/utils.py

unitlab-2.2.0/src/unitlab/dataset.py

@@ -1,333 +0,0 @@
-import asyncio
-import copy
-import itertools
-import json
-import logging
-import os
-from collections import defaultdict
-
-import aiofiles
-import aiohttp
-
-from .exceptions import SubscriptionError
-
-logger = logging.getLogger(__name__)
-
-
-class COCO:
-    def __init__(self, annotation_type, annotation_path, data_path):
-        """
-        :param annotation_type (str): one of ['img_bbox', 'img_semantic_segmentation', 'img_polygon', 'img_keypoints']
-        :param annotation_path (str): location of annotation file
-        :param data_path (str): directory containing the images
-        :return:
-        """
-        self.annotation_type = annotation_type
-        self.annotation_path = annotation_path
-        self.data_path = data_path
-        self.anns, self.cats, self.imgs = dict(), dict(), dict()
-        self.imgToAnns, self.catToImgs = defaultdict(list), defaultdict(list)
-        self._load_dataset()
-
-    @staticmethod
-    def _is_array_like(obj):
-        return hasattr(obj, "__iter__") and hasattr(obj, "__len__")
-
-    def _validate(self):
-        if not os.path.isdir(self.data_path):
-            raise ValueError(
-                "Data path '{}' does not exist or is not a directory".format(
-                    self.data_path
-                )
-            )
-        for required_key in ["images", "annotations", "categories"]:
-            if required_key not in self.dataset.keys():
-                raise KeyError(
-                    "Required key '{}' not found in the COCO dataset".format(
-                        required_key
-                    )
-                )
-            if len(self.dataset[required_key]) == 0:
-                raise ValueError(
-                    "Required key '{}' does not contain values".format(required_key)
-                )
-
-    def _load_dataset(self):
-        with open(self.annotation_path, "r") as f:
-            self.dataset = json.load(f)
-        self._validate()
-        self.createIndex()
-
-    def createIndex(self):
-        anns, cats, imgs = {}, {}, {}
-        imgToAnns, catToImgs = defaultdict(list), defaultdict(list)
-        for ann in self.dataset["annotations"]:
-            imgToAnns[ann["image_id"]].append(ann)
-            anns[ann["id"]] = ann
-
-        for img in self.dataset["images"]:
-            imgs[img["id"]] = img
-
-        for cat in self.dataset["categories"]:
-            cats[cat["id"]] = cat
-
-        for ann in self.dataset["annotations"]:
-            catToImgs[ann["category_id"]].append(ann["image_id"])
-
-        # create class members
-        self.anns = anns
-        self.imgToAnns = imgToAnns
-        self.catToImgs = catToImgs
-        self.imgs = imgs
-        self.cats = cats
-        self.categories = sorted(
-            copy.deepcopy(self.loadCats(self.getCatIds())), key=lambda x: x["id"]
-        )
-        self.classes = [cat["name"] for cat in self.categories]
-        self.original_category_referecences = dict()
-        for i, category in enumerate(self.categories):
-            self.original_category_referecences[category["id"]] = i
-            category["id"] = i
-
-    def getAnnIds(self, imgIds=[], catIds=[], areaRng=[], iscrowd=None):
-        """
-        Get ann ids that satisfy given filter conditions. default skips that filter
-        :param imgIds  (int array)     : get anns for given imgs
-               catIds  (int array)     : get anns for given cats
-               areaRng (float array)   : get anns for given area range (e.g. [0 inf])
-               iscrowd (boolean)       : get anns for given crowd label (False or True)
-        :return: ids (int array)       : integer array of ann ids
-        """
-        imgIds = imgIds if self._is_array_like(imgIds) else [imgIds]
-        catIds = catIds if self._is_array_like(catIds) else [catIds]
-
-        if len(imgIds) == len(catIds) == len(areaRng) == 0:
-            anns = self.dataset["annotations"]
-        else:
-            if not len(imgIds) == 0:
-                lists = [
-                    self.imgToAnns[imgId] for imgId in imgIds if imgId in self.imgToAnns
-                ]
-                anns = list(itertools.chain.from_iterable(lists))
-            else:
-                anns = self.dataset["annotations"]
-            anns = (
-                anns
-                if len(catIds) == 0
-                else [ann for ann in anns if ann["category_id"] in catIds]
-            )
-            anns = (
-                anns
-                if len(areaRng) == 0
-                else [
-                    ann
-                    for ann in anns
-                    if ann["area"] > areaRng[0] and ann["area"] < areaRng[1]
-                ]
-            )
-        if iscrowd:
-            ids = [ann["id"] for ann in anns if ann["iscrowd"] == iscrowd]
-        else:
-            ids = [ann["id"] for ann in anns]
-        return ids
-
-    def getCatIds(self, catNms=[], supNms=[], catIds=[]):
-        """
-        filtering parameters. default skips that filter.
-        :param catNms (str array)  : get cats for given cat names
-        :param supNms (str array)  : get cats for given supercategory names
-        :param catIds (int array)  : get cats for given cat ids
-        :return: ids (int array)   : integer array of cat ids
-        """
-        catNms = catNms if self._is_array_like(catNms) else [catNms]
-        supNms = supNms if self._is_array_like(supNms) else [supNms]
-        catIds = catIds if self._is_array_like(catIds) else [catIds]
-
-        if len(catNms) == len(supNms) == len(catIds) == 0:
-            cats = self.dataset["categories"]
-        else:
-            cats = self.dataset["categories"]
-            cats = (
-                cats
-                if len(catNms) == 0
-                else [cat for cat in cats if cat["name"] in catNms]
-            )
-            cats = (
-                cats
-                if len(supNms) == 0
-                else [cat for cat in cats if cat["supercategory"] in supNms]
-            )
-            cats = (
-                cats
-                if len(catIds) == 0
-                else [cat for cat in cats if cat["id"] in catIds]
-            )
-        ids = [cat["id"] for cat in cats]
-        return ids
-
-    def getImgIds(self, imgIds=[], catIds=[]):
-        """
-        Get img ids that satisfy given filter conditions.
-        :param imgIds (int array) : get imgs for given ids
-        :param catIds (int array) : get imgs with all given cats
-        :return: ids (int array)  : integer array of img ids
-        """
-        imgIds = imgIds if self._is_array_like(imgIds) else [imgIds]
-        catIds = catIds if self._is_array_like(catIds) else [catIds]
-
-        if len(imgIds) == len(catIds) == 0:
-            ids = self.imgs.keys()
-        else:
-            ids = set(imgIds)
-            for i, catId in enumerate(catIds):
-                if i == 0 and len(ids) == 0:
-                    ids = set(self.catToImgs[catId])
-                else:
-                    ids &= set(self.catToImgs[catId])
-        return list(ids)
-
-    def loadAnns(self, ids=[]):
-        """
-        Load anns with the specified ids.
-        :param ids (int array)       : integer ids specifying anns
-        :return: anns (object array) : loaded ann objects
-        """
-        if self._is_array_like(ids):
-            return [self.anns[id] for id in ids]
-        elif isinstance(ids, int):
-            return [self.anns[ids]]
-
-    def loadCats(self, ids=[]):
-        """
-        Load cats with the specified ids.
-        :param ids (int array)       : integer ids specifying cats
-        :return: cats (object array) : loaded cat objects
-        """
-        if self._is_array_like(ids):
-            return [self.cats[id] for id in ids]
-        elif isinstance(ids, int):
-            return [self.cats[ids]]
-
-    def loadImgs(self, ids=[]):
-        """
-        Load anns with the specified ids.
-        :param ids (int array)       : integer ids specifying img
-        :return: imgs (object array) : loaded img objects
-        """
-        if self._is_array_like(ids):
-            return [self.imgs[id] for id in ids]
-        elif isinstance(ids, int):
-            return [self.imgs[ids]]
-
-
-class DatasetUploadHandler(COCO):
-    def get_img_bbox_payload(self, anns):
-        predicted_classes = set()
-        bboxes = []
-        for ann in anns:
-            bbox = ann["bbox"]
-            bboxes.append(
-                {
-                    "point": [
-                        [bbox[0], bbox[1]],
-                        [bbox[0] + bbox[2], bbox[1]],
-                        [bbox[0] + bbox[2], bbox[1] + bbox[3]],
-                        [bbox[0], bbox[1] + bbox[3]],
-                    ],
-                    "class": self.original_category_referecences.get(
-                        ann["category_id"]
-                    ),
-                    "recognition": ann.get("recognition", ""),
-                }
-            )
-            predicted_classes.add(
-                self.original_category_referecences.get(ann["category_id"])
-            )
-        return json.dumps(
-            {
-                "bboxes": [bboxes],
-                "predicted_classes": list(predicted_classes),
-                "classes": self.classes,
-            }
-        )
-
-    def get_img_semantic_segmentation_payload(self, anns):
-        predicted_classes = set()
-        annotations = []
-        for ann in anns:
-            annotations.append(
-                {
-                    "segmentation": ann["segmentation"],
-                    "category_id": self.original_category_referecences.get(
-                        ann["category_id"]
-                    ),
-                }
-            )
-            predicted_classes.add(
-                self.original_category_referecences.get(ann["category_id"])
-            )
-        return json.dumps(
-            {
-                "annotations": annotations,
-                "predicted_classes": list(predicted_classes),
-                "classes": self.classes,
-            }
-        )
-
-    def get_img_instance_segmentation_payload(self, anns):
-        return self.get_img_semantic_segmentation_payload(anns)
-
-    def get_img_polygon_payload(self, anns):
-        return self.get_img_semantic_segmentation_payload(anns)
-
-    def get_img_line_payload(self, anns):
-        return self.get_img_semantic_segmentation_payload(anns)
-
-    def get_img_point_payload(self, anns):
-        return self.get_img_semantic_segmentation_payload(anns)
-
-    def get_payload(self, img_id):
-        image = self.imgs[img_id]
-        ann_ids = self.getAnnIds(imgIds=img_id)
-        anns = self.loadAnns(ann_ids)
-        if not os.path.isfile(os.path.join(self.data_path, image["file_name"])):
-            logger.warning(
-                "Image file not found: {}".format(
-                    os.path.join(self.data_path, image["file_name"])
-                )
-            )
-            return
-        if len(anns) == 0:
-            logger.warning("No annotations found for image: {}".format(img_id))
-            return
-        return getattr(self, f"get_{self.annotation_type}_payload")(anns)
-
-    async def upload_image(self, session, url, image_id):
-        image = self.loadImgs(image_id)[0]
-        file_name = image["file_name"]
-        payload = self.get_payload(image_id)
-        if payload:
-            async with aiofiles.open(
-                os.path.join(self.data_path, file_name), "rb"
-            ) as f:
-                form_data = aiohttp.FormData()
-                form_data.add_field("file", await f.read(), filename=file_name)
-                form_data.add_field("result", self.get_payload(image_id))
-                try:
-                    # rate limiting
-                    await asyncio.sleep(0.1)
-                    async with session.post(url, data=form_data) as response:
-                        if response.status == 403:
-                            raise SubscriptionError(
-                                "You have reached the maximum number of datasources for your subscription."
-                            )
-                        elif response.status == 400:
-                            logger.error(await response.text())
-                            return 0
-                        response.raise_for_status()
-                        return 1
-                except SubscriptionError as e:
-                    raise e
-                except Exception as e:
-                    logger.error(f"Error uploading file {file_name} - {e}")
-        return 0