hirundo 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

hirundo/storage.py

@@ -1,51 +1,139 @@
 import typing
 from enum import Enum
-from typing import Union
+from pathlib import Path
 
 import pydantic
 import requests
 from pydantic import BaseModel, model_validator
 from pydantic_core import Url
 
-from hirundo._constraints import S3BucketUrl, StorageIntegrationName
+from hirundo._constraints import S3BucketUrl, StorageConfigName
 from hirundo._env import API_HOST
 from hirundo._headers import get_auth_headers, json_headers
+from hirundo._http import raise_for_status_with_reason
 from hirundo._timeouts import MODIFY_TIMEOUT, READ_TIMEOUT
-from hirundo.git import GitRepo
+from hirundo.git import GitRepo, GitRepoOut
 from hirundo.logger import get_logger
 
 logger = get_logger(__name__)
 
+S3_PREFIX = "s3://"
 
-class StorageS3(BaseModel):
-    endpoint_url: Union[Url, None] = None
+
+class StorageS3Base(BaseModel):
+    endpoint_url: typing.Optional[Url] = None
     bucket_url: S3BucketUrl
     region_name: str
     # ⬆️ We could restrict this, but if we're allowing custom endpoints then the validation may be wrong
-    access_key_id: Union[str, None] = None
-    secret_access_key: Union[str, None] = None
+    access_key_id: typing.Optional[str] = None
+
+    def get_url(self, path: typing.Union[str, Path]) -> Url:
+        """
+        Get the full URL for a file in the S3 bucket
+
+        Chains the bucket URL with the path, ensuring that the path is formatted correctly
+
+        Args:
+            - path: The path to the file in the S3 bucket, e.g. `my-file.txt` or `/my-folder/my-file.txt`
+
+        Returns:
+            The full URL to the file in the S3 bucket, e.g. `s3://my-bucket/my-file.txt` or `s3://my-bucket/my-folder/my-file.txt`,
+            where `s3://my-bucket` is the bucket URL provided in the S3 storage config
+        """
+        return Url(
+            f"{S3_PREFIX}{self.bucket_url.removeprefix(S3_PREFIX).removesuffix('/')}/{str(path).removeprefix('/')}"
+        )
+
+
+class StorageS3(StorageS3Base):
+    secret_access_key: typing.Optional[str] = None
 
 
-class StorageGCP(BaseModel):
+class StorageS3Out(StorageS3Base):
+    pass
+
+
+class StorageGCPBase(BaseModel):
     bucket_name: str
     project: str
-    credentials_json: Union[dict, None] = None
 
+    def get_url(self, path: typing.Union[str, Path]) -> Url:
+        """
+        Get the full URL for a file in the GCP bucket
+
+        Chains the bucket URL with the path, ensuring that the path is formatted correctly
+
+        Args:
+            - path: The path to the file in the GCP bucket, e.g. `my-file.txt` or `/my-folder/my-file.txt`
+
+        Returns:
+            The full URL to the file in the GCP bucket, e.g. `gs://my-bucket/my-file.txt` or `gs://my-bucket/my-folder/my-file.txt`,
+            where `my-bucket` is the bucket name provided in the GCP storage config
+        """
+        return Url(f"gs://{self.bucket_name}/{str(path).removeprefix('/')}")
+
+
+class StorageGCP(StorageGCPBase):
+    credentials_json: typing.Optional[dict] = None
 
-# TODO: Azure storage integration is coming soon
+
+class StorageGCPOut(StorageGCPBase):
+    pass
+
+
+# TODO: Azure storage config is coming soon
 # class StorageAzure(BaseModel):
+#     account_url: HttpUrl
+#     container_name: str
+#     tenant_id: str
+
+#     def get_url(self, path: typing.Union[str, Path]) -> Url:
+#         """
+#         Get the full URL for a file in the Azure container
+
+#         Chains the container URL with the path, ensuring that the path is formatted correctly
+
+#         Args:
+#             - path: The path to the file in the Azure container, e.g. `my-file.txt` or `/my-folder/my-file.txt`
+
+#         Returns:
+#             The full URL to the file in the Azure container
+#         """
+#         return Url(f"{str(self.account_url)}/{self.container_name}/{str(path).removeprefix('/')}")
+# class StorageAzureOut(BaseModel):
 #     container: str
-#     account_name: str
-#     account_key: str
+#     account_url: str
+
+
+def get_git_repo_url(
+    repo_url: typing.Union[str, Url], path: typing.Union[str, Path]
+) -> Url:
+    """
+    Get the full URL for a file in the git repository
+
+    Chains the repository URL with the path, ensuring that the path is formatted correctly
+
+    Args:
+        - repo_url: The URL of the git repository, e.g. `https://my-git-repository.com`
+        - path: The path to the file in the git repository, e.g. `my-file.txt` or `/my-folder/my-file.txt`
+
+    Returns:
+        The full URL to the file in the git repository, e.g. `https://my-git-repository.com/my-file.txt` or `https://my-git-repository.com/my-folder/my-file.txt`
+    """
+    if not isinstance(repo_url, Url):
+        repo_url = Url(repo_url)
+    return Url(
+        f"{repo_url.scheme}{str(repo_url).removeprefix(repo_url.scheme)}/{str(path).removeprefix('/')}"
+    )
 
 
 class StorageGit(BaseModel):
-    repo_id: Union[int, None] = None
+    repo_id: typing.Optional[int] = None
     """
     The ID of the Git repository in the Hirundo system.
     Either `repo_id` or `repo` must be provided.
     """
-    repo: Union[GitRepo, None] = None
+    repo: typing.Optional[GitRepo] = None
     """
     The Git repository to link to.
     Either `repo_id` or `repo` must be provided.
@@ -61,53 +149,95 @@ class StorageGit(BaseModel):
             raise ValueError("Either repo_id or repo must be provided")
         return self
 
+    def get_url(self, path: typing.Union[str, Path]) -> Url:
+        """
+        Get the full URL for a file in the git repository
+
+        Chains the repository URL with the path, ensuring that the path is formatted correctly
+
+        Args:
+            - path: The path to the file in the git repository, e.g. `my-file.txt` or `/my-folder/my-file.txt`
+
+        Returns:
+            The full URL to the file in the git repository, e.g. `https://my-git-repository.com/my-file.txt` or `https://my-git-repository.com/my-folder/my-file.txt`,
+            where `https://my-git-repository.com` is the repository URL provided in the git storage config's git repo
+        """
+        if not self.repo:
+            raise ValueError("Repo must be provided to use `get_url`")
+        repo_url = self.repo.repository_url
+        return get_git_repo_url(repo_url, path)
+
+
+class StorageGitOut(BaseModel):
+    repo: GitRepoOut
+    branch: str
+
+    def get_url(self, path: typing.Union[str, Path]) -> Url:
+        """
+        Get the full URL for a file in the git repository
+
+        Chains the repository URL with the path, ensuring that the path is formatted correctly
+
+        Args:
+            - path: The path to the file in the git repository, e.g. `my-file.txt` or `/my-folder/my-file.txt`
+
+        Returns:
+            The full URL to the file in the git repository, e.g. `https://my-git-repository.com/my-file.txt` or `https://my-git-repository.com/my-folder/my-file.txt`,
+            where `https://my-git-repository.com` is the repository URL provided in the git storage config's git repo
+        """
+        repo_url = self.repo.repository_url
+        return get_git_repo_url(repo_url, path)
+
 
 class StorageTypes(str, Enum):
     """
-    Enum for the different types of storage integrations.
+    Enum for the different types of storage configs.
     Supported types are:
     """
 
     S3 = "S3"
     GCP = "GCP"
-    # AZURE = "Azure"  TODO: Azure storage integration is coming soon
+    # AZURE = "Azure"  TODO: Azure storage config is coming soon
     GIT = "Git"
     LOCAL = "Local"
     """
-    Local storage integration is only supported for on-premises installations.
+    Local storage config is only supported for on-premises installations.
     """
 
 
-class StorageIntegration(BaseModel):
-    id: Union[int, None] = None
+class StorageConfig(BaseModel):
+    id: typing.Optional[int] = None
+    """
+    The ID of the `StorageConfig` in the Hirundo system.
+    """
 
-    organization_id: Union[int, None] = None
+    organization_id: typing.Optional[int] = None
     """
-    The ID of the organization that the `StorageIntegration` belongs to.
+    The ID of the organization that the `StorageConfig` belongs to.
     If not provided, it will be assigned to your default organization.
     """
 
-    name: StorageIntegrationName
+    name: StorageConfigName
     """
-    A name to identify the `StorageIntegration` in the Hirundo system.
+    A name to identify the `StorageConfig` in the Hirundo system.
     """
     type: typing.Optional[StorageTypes] = pydantic.Field(
         examples=[
             StorageTypes.S3,
             StorageTypes.GCP,
-            # StorageTypes.AZURE,  TODO: Azure storage integration is coming soon
+            # StorageTypes.AZURE,  TODO: Azure storage is coming soon
             StorageTypes.GIT,
         ]
     )
     """
-    The type of the `StorageIntegration`.
+    The type of the `StorageConfig`.
     Supported types are:
     - `S3`
     - `GCP`
     - `Azure` (coming soon)
     - `Git`
     """
-    s3: Union[StorageS3, None] = pydantic.Field(
+    s3: typing.Optional[StorageS3] = pydantic.Field(
         default=None,
         examples=[
             {
@@ -122,10 +252,10 @@ class StorageIntegration(BaseModel):
         ],
     )
     """
-    The Amazon Web Services (AWS) S3 storage integration details.
+    The Amazon Web Services (AWS) S3 storage config details.
     Use this if you want to link to an S3 bucket.
     """
-    gcp: Union[StorageGCP, None] = pydantic.Field(
+    gcp: typing.Optional[StorageGCP] = pydantic.Field(
         default=None,
         examples=[
             None,
@@ -151,11 +281,11 @@ class StorageIntegration(BaseModel):
         ],
     )
     """
-    The Google Cloud (GCP) Storage integration details.
+    The Google Cloud (GCP) Storage config details.
     Use this if you want to link to an GCS bucket.
     """
     azure: None = None
-    # azure: Union[StorageAzure, None] = pydantic.Field(
+    # azure: typing.Optional[StorageAzure] = pydantic.Field(
     #     default=None,
     #     examples=[
     #         None,
@@ -167,8 +297,8 @@ class StorageIntegration(BaseModel):
     #         },
     #         None,
     #     ],
-    # )  TODO: Azure storage integration is coming soon
-    git: Union[StorageGit, None] = pydantic.Field(
+    # )  TODO: Azure storage config is coming soon
+    git: typing.Optional[StorageGit] = pydantic.Field(
         default=None,
         examples=[
             None,
@@ -186,73 +316,116 @@ class StorageIntegration(BaseModel):
         ],
     )
     """
-    The Git storage integration details.
+    The Git storage config details.
     Use this if you want to link to a Git repository.
     """
 
     @staticmethod
-    def list(organization_id: typing.Union[int, None] = None) -> list[dict]:
+    def get_by_id(storage_config_id: int) -> "ResponseStorageConfig":
         """
-        Lists all the `StorageIntegration`'s created by user's default organization
-        Note: The return type is `list[dict]` and not `list[StorageIntegration]`
+        Retrieves a `StorageConfig` instance from the server by its ID
 
         Args:
-            organization_id: The ID of the organization to list `StorageIntegration`'s for.
-            If not provided, it will list `StorageIntegration`'s for the default organization.
+            storage_config_id: The ID of the `StorageConfig` to retrieve
         """
-        storage_integrations = requests.get(
-            f"{API_HOST}/storage-integration/",
-            params={"storage_integration_organization_id": organization_id},
+        storage_config = requests.get(
+            f"{API_HOST}/storage-config/{storage_config_id}",
             headers=get_auth_headers(),
             timeout=READ_TIMEOUT,
         )
-        storage_integrations.raise_for_status()
-        return storage_integrations.json()
+        raise_for_status_with_reason(storage_config)
+        return ResponseStorageConfig(**storage_config.json())
 
     @staticmethod
-    def delete_by_id(storage_integration_id) -> None:
+    def get_by_name(name: str, storage_type: StorageTypes) -> "ResponseStorageConfig":
         """
-        Deletes a `StorageIntegration` instance from the server by its ID
+        Retrieves a `StorageConfig` instance from the server by its name
 
         Args:
-            storage_integration_id: The ID of the `StorageIntegration` to delete
+            name: The name of the `StorageConfig` to retrieve
+            storage_type: The type of the `StorageConfig` to retrieve
+
+            Note: The type is required because the name is not unique across different storage types
         """
-        storage_integration = requests.delete(
-            f"{API_HOST}/storage-integration/{storage_integration_id}",
+        storage_config = requests.get(
+            f"{API_HOST}/storage-config/by-name/{name}?storage_type={storage_type.value}",
+            headers=get_auth_headers(),
+            timeout=READ_TIMEOUT,
+        )
+        raise_for_status_with_reason(storage_config)
+        return ResponseStorageConfig(**storage_config.json())
+
+    @staticmethod
+    def list(
+        organization_id: typing.Optional[int] = None,
+    ) -> list["ResponseStorageConfig"]:
+        """
+        Lists all the `StorageConfig`'s created by user's default organization
+        Note: The return type is `list[dict]` and not `list[StorageConfig]`
+
+        Args:
+            organization_id: The ID of the organization to list `StorageConfig`'s for.
+            If not provided, it will list `StorageConfig`'s for the default organization.
+        """
+        storage_configs = requests.get(
+            f"{API_HOST}/storage-config/",
+            params={"storage_config_organization_id": organization_id},
+            headers=get_auth_headers(),
+            timeout=READ_TIMEOUT,
+        )
+        raise_for_status_with_reason(storage_configs)
+        return [ResponseStorageConfig(**si) for si in storage_configs.json()]
+
+    @staticmethod
+    def delete_by_id(storage_config_id) -> None:
+        """
+        Deletes a `StorageConfig` instance from the server by its ID
+
+        Args:
+            storage_config_id: The ID of the `StorageConfig` to delete
+        """
+        storage_config = requests.delete(
+            f"{API_HOST}/storage-config/{storage_config_id}",
             headers=get_auth_headers(),
             timeout=MODIFY_TIMEOUT,
         )
-        storage_integration.raise_for_status()
-        logger.info("Deleted storage integration with ID: %s", storage_integration_id)
+        raise_for_status_with_reason(storage_config)
+        logger.info("Deleted storage config with ID: %s", storage_config_id)
 
     def delete(self) -> None:
         """
-        Deletes the `StorageIntegration` instance from the server
+        Deletes the `StorageConfig` instance from the server
         """
         if not self.id:
-            raise ValueError("No StorageIntegration has been created")
+            raise ValueError("No StorageConfig has been created")
         self.delete_by_id(self.id)
 
-    def create(self) -> int:
+    def create(self, replace_if_exists: bool = False) -> int:
         """
-        Create a `StorageIntegration` instance on the server
+        Create a `StorageConfig` instance on the server
+
+        Args:
+            replace_if_exists: If a `StorageConfig` with the same name and type already exists, replace it.
         """
         if self.git and self.git.repo:
-            self.git.repo_id = self.git.repo.create()
-        storage_integration = requests.post(
-            f"{API_HOST}/storage-integration/",
-            json=self.model_dump(),
+            self.git.repo_id = self.git.repo.create(replace_if_exists=replace_if_exists)
+        storage_config = requests.post(
+            f"{API_HOST}/storage-config/",
+            json={
+                **self.model_dump(mode="json"),
+                "replace_if_exists": replace_if_exists,
+            },
             headers={
                 **json_headers,
                 **get_auth_headers(),
             },
             timeout=MODIFY_TIMEOUT,
         )
-        storage_integration.raise_for_status()
-        storage_integration_id = storage_integration.json()["id"]
-        self.id = storage_integration_id
-        logger.info("Created storage integration with ID: %s", storage_integration_id)
-        return storage_integration_id
+        raise_for_status_with_reason(storage_config)
+        storage_config_id = storage_config.json()["id"]
+        self.id = storage_config_id
+        logger.info("Created storage config with ID: %s", storage_config_id)
+        return storage_config_id
 
     @model_validator(mode="after")
     def validate_storage_type(self):
@@ -281,15 +454,13 @@ class StorageIntegration(BaseModel):
         return self
 
 
-class StorageLink(BaseModel):
-    storage_integration: StorageIntegration
-    """
-    The `StorageIntegration` instance to link to.
-    """
-    path: str = "/"
-    """
-    Path for the `root` to link to within the `StorageIntegration` instance,
-    e.g. a prefix path/folder within an S3 Bucket / GCP Bucket / Azure Blob storage / Git repo.
-
-    Note: Only files in this path will be retrieved and it will be used as the root for paths in the CSV.
-    """
+class ResponseStorageConfig(BaseModel):
+    id: int
+    name: StorageConfigName
+    type: StorageTypes
+    organization_name: str
+    creator_name: str
+    s3: typing.Optional[StorageS3Out]
+    gcp: typing.Optional[StorageGCPOut]
+    # azure: typing.Optional[StorageAzureOut]
+    git: typing.Optional[StorageGitOut]

hirundo-0.1.9.dist-info/METADATA

@@ -0,0 +1,212 @@
+Metadata-Version: 2.1
+Name: hirundo
+Version: 0.1.9
+Summary: This package is used to interface with Hirundo's platform. It provides a simple API to optimize your ML datasets.
+Author-email: Hirundo <dev@hirundo.io>
+License: MIT License
+        
+        Copyright (c) 2024, Hirundo
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/Hirundo-io/hirundo-client
+Keywords: dataset,machine learning,data science,data engineering
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyyaml>=6.0.1
+Requires-Dist: types-PyYAML>=6.0.12
+Requires-Dist: pydantic>=2.7.1
+Requires-Dist: twine>=5.0.0
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: types-requests>=2.31.0
+Requires-Dist: typer>=0.12.3
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: stamina>=24.2.0
+Requires-Dist: httpx-sse>=0.4.0
+Requires-Dist: pandas>=2.2.2
+Requires-Dist: tqdm>=4.66.5
+Provides-Extra: dev
+Requires-Dist: pyyaml>=6.0.1; extra == "dev"
+Requires-Dist: types-PyYAML>=6.0.12; extra == "dev"
+Requires-Dist: pydantic>=2.7.1; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.0.1; extra == "dev"
+Requires-Dist: types-requests>=2.31.0; extra == "dev"
+Requires-Dist: types-setuptools>=69.5.0; extra == "dev"
+Requires-Dist: typer>=0.12.3; extra == "dev"
+Requires-Dist: httpx>=0.27.0; extra == "dev"
+Requires-Dist: stamina>=24.2.0; extra == "dev"
+Requires-Dist: httpx-sse>=0.4.0; extra == "dev"
+Requires-Dist: pytest>=8.2.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.6; extra == "dev"
+Requires-Dist: uv>=0.5.8; extra == "dev"
+Requires-Dist: pre-commit>=3.7.1; extra == "dev"
+Requires-Dist: virtualenv>=20.6.6; extra == "dev"
+Requires-Dist: ruff>=0.8.2; extra == "dev"
+Requires-Dist: bumpver; extra == "dev"
+Requires-Dist: platformdirs>=4.3.6; extra == "dev"
+Requires-Dist: safety>=3.2.13; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.4.7; extra == "docs"
+Requires-Dist: sphinx-autobuild>=2024.4.16; extra == "docs"
+Requires-Dist: sphinx-click>=5.0.1; extra == "docs"
+Requires-Dist: autodoc_pydantic>=2.2.0; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: sphinx-multiversion; extra == "docs"
+Requires-Dist: esbonio; extra == "docs"
+Requires-Dist: starlette>0.40.0; extra == "docs"
+Requires-Dist: markupsafe>=3.0.2; extra == "docs"
+
+# Hirundo
+
+This package exposes access to Hirundo APIs for dataset optimization for Machine Learning.
+
+Dataset optimization is currently available for datasets labelled for classification and object detection.
+
+
+Support dataset storage configs include:
+   - Google Cloud (GCP) Storage
+   - Amazon Web Services (AWS) S3
+   - Git LFS (Large File Storage) repositories (e.g. GitHub or HuggingFace)
+
+Optimizing a classification dataset
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Currently ``hirundo`` requires a CSV file with the following columns (all columns are required):
+   - ``image_path``: The location of the image within the dataset ``root``
+   - ``label``: The label of the image, i.e. which the class that was annotated for this image
+
+And outputs a CSV with the same columns and:
+   - ``suspect_level``: mislabel suspect level
+   - ``suggested_label``: suggested label
+   - ``suggested_label_conf``: suggested label confidence
+
+Optimizing an object detection (OD) dataset
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Currently ``hirundo`` requires a CSV file with the following columns (all columns are required):
+   - ``image_path``: The location of the image within the dataset ``root``
+   - ``bbox_id``: The index of the bounding box within the dataset. Used to indicate label suspects
+   - ``label``: The label of the image, i.e. which the class that was annotated for this image
+   - ``x1``, ``y1``, ``x2``, ``y2``: The bounding box coordinates of the object within the image
+
+And outputs a CSV with the same columns and:
+   - ``suspect_level``: object mislabel suspect level
+   - ``suggested_label``: suggested object label
+   - ``suggested_label_conf``: suggested object label confidence
+
+Note: This Python package must be used alongside a Hirundo server, either the SaaS platform, a custom VPC deployment or an on-premises installation.
+
+
+## Installation
+
+You can install the codebase with a simple `pip install hirundo` to install the latest version of this package. If you prefer to install from the Git repository and/or need a specific version or branch, you can simply clone the repository, check out the relevant commit and then run `pip install .` to install that version. A full list of dependencies can be found in `requirements.txt`, but these will be installed automatically by either of these commands.
+
+## Usage
+
+Classification example:
+```python
+from hirundo import (
+    HirundoCSV,
+    LabelingType,
+    OptimizationDataset,
+    StorageGCP,
+    StorageConfig,
+    StorageTypes,
+)
+
+gcp_bucket = StorageGCP(
+    bucket_name="cifar100bucket",
+    project="Hirundo-global",
+    credentials_json=json.loads(os.environ["GCP_CREDENTIALS"]),
+)
+test_dataset = OptimizationDataset(
+    name="TEST-GCP cifar 100 classification dataset",
+    labeling_type=LabelingType.SINGLE_LABEL_CLASSIFICATION,
+    storage_config=StorageConfig(
+        name="cifar100bucket",
+        type=StorageTypes.GCP,
+        gcp=gcp_bucket,
+    ),
+    data_root_url=gcp_bucket.get_url(path="/pytorch-cifar/data"),
+    labeling_info=HirundoCSV(
+        csv_url=gcp_bucket.get_url(path="/pytorch-cifar/data/cifar100.csv"),
+    ),
+    classes=cifar100_classes,
+)
+
+test_dataset.run_optimization()
+results = test_dataset.check_run()
+print(results)
+```
+
+
+Object detection example:
+
+```python
+from hirundo import (
+    GitRepo,
+    HirundoCSV,
+    LabelingType,
+    OptimizationDataset,
+    StorageGit,
+    StorageConfig,
+    StorageTypes,
+)
+
+git_storage = StorageGit(
+    repo=GitRepo(
+        name="BDD-100k-validation-dataset",
+        repository_url="https://git@hf.co/datasets/hirundo-io/bdd100k-validation-only.git",
+    ),
+    branch="main",
+)
+test_dataset = OptimizationDataset(
+    name="TEST-HuggingFace-BDD-100k-validation-OD-validation-dataset",
+    labeling_type=LabelingType.OBJECT_DETECTION,
+    storage_config=StorageConfig(
+        name="BDD-100k-validation-dataset",
+        type=StorageTypes.GIT,
+        git=git_storage,
+    ),
+    data_root_url=git_storage.get_url(path="/BDD100K Val from Hirundo.zip/bdd100k"),
+    labeling_info=HirundoCSV(
+        csv_url=git_storage.get_url(
+            path="/BDD100K Val from Hirundo.zip/bdd100k/bdd100k.csv"
+        ),
+    ),
+    classes=[
+        "traffic light",
+        "traffic sign",
+        "car",
+        "pedestrian",
+        "bus",
+        "truck",
+        "rider",
+        "bicycle",
+        "motorcycle",
+        "train",
+        "other vehicle",
+        "other person",
+        "trailer",
+    ],
+)
+
+test_dataset.run_optimization()
+results = test_dataset.check_run()
+print(results)
+```
+
+Note: Currently we only support the main CPython release 3.9, 3.10 and 3.11. PyPy support may be introduced in the future.
+
+## Further documentation
+
+To learn more about how to use this library, please visit the [http://docs.hirundo.io/](documentation) or see the Google Colab examples.