dragoneye-python 0.2.0__tar.gz → 0.4.0__tar.gz

dragoneye_python-0.4.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: dragoneye-python
+Version: 0.4.0
+License-Expression: MIT
+Requires-Python: >=3.8
+Requires-Dist: requests
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: backoff>=2.0.0
+Requires-Dist: aiohttp

dragoneye_python-0.4.0/dragoneye_python.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: dragoneye-python
+Version: 0.4.0
+License-Expression: MIT
+Requires-Python: >=3.8
+Requires-Dist: requests
+Requires-Dist: pydantic>=2
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: backoff>=2.0.0
+Requires-Dist: aiohttp

{dragoneye_python-0.2.0 → dragoneye_python-0.4.0}/dragoneye_python.egg-info/SOURCES.txt

@@ -1,4 +1,3 @@
-LICENSE
 README.md
 pyproject.toml
 requirements.txt
@@ -10,6 +9,9 @@ dragoneye_python.egg-info/top_level.txt
 src/dragoneye/__init__.py
 src/dragoneye/classification.py
 src/dragoneye/client.py
+src/dragoneye/constants.py
+src/dragoneye/models.py
 src/dragoneye/types/__init__.py
 src/dragoneye/types/common.py
-src/dragoneye/types/image.py
+src/dragoneye/types/exception.py
+src/dragoneye/types/media.py

dragoneye_python-0.4.0/dragoneye_python.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests
+pydantic>=2
+typing-extensions>=4.0.0
+backoff>=2.0.0
+aiohttp

{dragoneye_python-0.2.0 → dragoneye_python-0.4.0}/pyproject.toml

@@ -1,8 +1,13 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
 [project]
 name = "dragoneye-python"
-version = "0.2.0"
+version = "0.4.0"
 requires-python = ">=3.8"
 dynamic = ["dependencies"]
+license = "MIT"
 
 [tool.setuptools.dynamic]
 dependencies = {file = ["requirements.txt"]}

dragoneye_python-0.4.0/requirements.txt

@@ -0,0 +1,5 @@
+requests
+pydantic>=2
+typing-extensions>=4.0.0
+backoff>=2.0.0
+aiohttp

{dragoneye_python-0.2.0 → dragoneye_python-0.4.0}/src/dragoneye/__init__.py

@@ -1,12 +1,14 @@
 from .classification import (
     Classification,
+)
+from .client import Dragoneye
+from .models import (
     ClassificationObjectPrediction,
     ClassificationPredictImageResponse,
     ClassificationTraitRootPrediction,
 )
-from .client import Dragoneye
 from .types.common import NormalizedBbox, TaxonID, TaxonPrediction, TaxonType
-from .types.image import Image
+from .types.media import Image, Video
 
 __all__ = [
     "Classification",
@@ -15,6 +17,7 @@ __all__ = [
     "ClassificationTraitRootPrediction",
     "Dragoneye",
     "Image",
+    "Video",
     "NormalizedBbox",
     "TaxonID",
     "TaxonPrediction",

dragoneye_python-0.4.0/src/dragoneye/classification.py

@@ -0,0 +1,367 @@
+import asyncio
+import logging
+import time
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional, Union, overload
+
+import aiohttp
+import backoff
+from aiohttp import ClientError
+from pydantic import BaseModel
+
+from .constants import FAILED_STATUS_PREFIX, PREDICTED_STATUS
+from .models import (
+    ClassificationPredictImageResponse,
+    ClassificationPredictVideoResponse,
+    PredictionTaskStatusResponse,
+)
+from .types.common import (
+    BASE_API_URL,
+    PredictionTaskState,
+    PredictionTaskUUID,
+    PredictionType,
+)
+from .types.exception import (
+    PredictionTaskBeginError,
+    PredictionTaskError,
+    PredictionTaskResultsUnavailableError,
+    PredictionTimeoutException,
+    PredictionUploadError,
+)
+from .types.media import Image, Media, Video
+
+if TYPE_CHECKING:
+    from .client import Dragoneye
+
+
+class _PresignedPostRequest(BaseModel):
+    url: str
+    fields: Dict[str, Any]
+
+
+class _MediaUploadUrl(BaseModel):
+    blob_path: str
+    presigned_post_request: _PresignedPostRequest
+
+
+class _PredictionTaskBeginResponse(BaseModel):
+    prediction_task_uuid: PredictionTaskUUID
+    prediction_type: PredictionType
+    signed_urls: List[_MediaUploadUrl]
+
+
+def _is_task_successful(status: PredictionTaskState) -> bool:
+    return status == PREDICTED_STATUS
+
+
+def _is_task_failed(status: PredictionTaskState) -> bool:
+    return status.startswith(FAILED_STATUS_PREFIX)
+
+
+def _is_task_complete(status: PredictionTaskState) -> bool:
+    """
+    Returns True if the prediction task is complete, either successfully or unsuccessfully.
+
+    Avoid enum to allow additional states to be backwards compatible.
+    """
+    return _is_task_successful(status) or _is_task_failed(status)
+
+
+class Classification:
+    def __init__(self, client: "Dragoneye"):
+        self._client = client
+
+        # Create a reusable backoff decorator for 429 rate limit errors
+        def _should_retry_429(exception: Exception) -> bool:
+            """Check if exception is a 429 rate limit error"""
+            return (
+                isinstance(exception, aiohttp.ClientResponseError)
+                and exception.status == 429
+            )
+
+        # Store the backoff decorator as an instance method
+        self._backoff_on_429 = backoff.on_exception(
+            wait_gen=backoff.expo,
+            exception=aiohttp.ClientResponseError,
+            max_tries=client.max_retries,
+            max_time=client.max_backoff_time,
+            on_backoff=lambda e: logging.info(
+                f"Rate limit exceeded - backing off: {e}"
+            ),
+            on_giveup=lambda e: logging.info(f"Rate limit exceeded - giving up: {e}"),
+            giveup=lambda e: not _should_retry_429(e),
+            jitter=client.backoff_jitter,
+        )
+
+    async def predict_image(
+        self,
+        media: Image,
+        model_name: str,
+        timeout_seconds: Optional[int] = None,
+    ) -> ClassificationPredictImageResponse:
+        return await self._predict_unified(
+            media=media,
+            model_name=model_name,
+            frames_per_second=None,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def predict_video(
+        self,
+        media: Video,
+        model_name: str,
+        frames_per_second: int = 1,
+        timeout_seconds: Optional[int] = None,
+    ) -> ClassificationPredictVideoResponse:
+        return await self._predict_unified(
+            media=media,
+            model_name=model_name,
+            frames_per_second=frames_per_second,
+            timeout_seconds=timeout_seconds,
+        )
+
+    async def status(
+        self, prediction_task_uuid: PredictionTaskUUID
+    ) -> PredictionTaskStatusResponse:
+        """
+        Given a prediction task UUID, return
+        """
+        url = f"{BASE_API_URL}/prediction-task/status?predictionTaskUuid={prediction_task_uuid}"
+        headers = {"Authorization": f"Bearer {self._client.api_key}"}
+
+        @self._backoff_on_429
+        async def _make_request():
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers) as resp:
+                    resp.raise_for_status()
+                    payload = await resp.json()
+            return payload
+
+        payload = await _make_request()
+        return PredictionTaskStatusResponse.model_validate(payload)
+
+    async def get_image_results(
+        self,
+        prediction_task_uuid: PredictionTaskUUID,
+    ) -> ClassificationPredictImageResponse:
+        return await self._get_results_unified(
+            prediction_task_uuid=prediction_task_uuid,
+            prediction_type="image",
+        )
+
+    async def get_video_results(
+        self,
+        prediction_task_uuid: PredictionTaskUUID,
+    ) -> ClassificationPredictVideoResponse:
+        return await self._get_results_unified(
+            prediction_task_uuid=prediction_task_uuid,
+            prediction_type="video",
+        )
+
+    @overload
+    async def _get_results_unified(
+        self,
+        prediction_task_uuid: PredictionTaskUUID,
+        prediction_type: Literal["image"],
+    ) -> ClassificationPredictImageResponse: ...
+
+    @overload
+    async def _get_results_unified(
+        self,
+        prediction_task_uuid: PredictionTaskUUID,
+        prediction_type: Literal["video"],
+    ) -> ClassificationPredictVideoResponse: ...
+
+    @overload
+    async def _get_results_unified(
+        self,
+        prediction_task_uuid: PredictionTaskUUID,
+        prediction_type: PredictionType,
+    ) -> Union[
+        ClassificationPredictImageResponse, ClassificationPredictVideoResponse
+    ]: ...
+
+    async def _get_results_unified(
+        self, prediction_task_uuid: PredictionTaskUUID, prediction_type: PredictionType
+    ) -> Union[ClassificationPredictImageResponse, ClassificationPredictVideoResponse]:
+        url = f"{BASE_API_URL}/prediction-task/results?predictionTaskUuid={prediction_task_uuid}"
+        headers = {"Authorization": f"Bearer {self._client.api_key}"}
+
+        @self._backoff_on_429
+        async def _make_request():
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers) as resp:
+                    resp.raise_for_status()
+                    payload = await resp.json()
+            return payload
+
+        try:
+            payload = await _make_request()
+        except ClientError as error:
+            raise PredictionTaskResultsUnavailableError(
+                f"Error getting prediction task results: {error}"
+            )
+
+        # Add the prediction task uuid to the response before returning
+        payload["prediction_task_uuid"] = prediction_task_uuid
+
+        if prediction_type == "image":
+            return ClassificationPredictImageResponse.model_validate(payload)
+        elif prediction_type == "video":
+            return ClassificationPredictVideoResponse.model_validate(payload)
+        else:
+            raise ValueError(f"Unsupported prediction type: {prediction_type}")
+
+    ##### Internal API methods #####
+    @overload
+    async def _predict_unified(
+        self,
+        media: Image,
+        model_name: str,
+        frames_per_second: Optional[int],
+        timeout_seconds: Optional[int] = None,
+    ) -> ClassificationPredictImageResponse: ...
+
+    @overload
+    async def _predict_unified(
+        self,
+        media: Video,
+        model_name: str,
+        frames_per_second: Optional[int],
+        timeout_seconds: Optional[int] = None,
+    ) -> ClassificationPredictVideoResponse: ...
+
+    async def _predict_unified(
+        self,
+        media: Union[Image, Video],
+        model_name: str,
+        frames_per_second: Optional[int],
+        timeout_seconds: Optional[int] = None,
+    ) -> Union[ClassificationPredictImageResponse, ClassificationPredictVideoResponse]:
+        prediction_task_begin_response = await self._begin_prediction_task(
+            mime_type=media.mime_type,
+            frames_per_second=frames_per_second,
+        )
+
+        await self._upload_media_to_prediction_task(
+            media, prediction_task_begin_response.signed_urls[0]
+        )
+
+        predict_url = f"{BASE_API_URL}/predict"
+        predict_data = {
+            "model_name": model_name,
+            "prediction_task_uuid": prediction_task_begin_response.prediction_task_uuid,
+        }
+        predict_headers = {
+            "Authorization": f"Bearer {self._client.api_key}",
+        }
+
+        @self._backoff_on_429
+        async def _make_request():
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    predict_url, data=predict_data, headers=predict_headers
+                ) as resp:
+                    resp.raise_for_status()
+
+        try:
+            await _make_request()
+        except ClientError as error:
+            raise PredictionTaskError("Error initiating prediction:", error)
+
+        status = await self._wait_for_prediction_task_completion(
+            prediction_task_uuid=prediction_task_begin_response.prediction_task_uuid,
+            timeout_seconds=timeout_seconds,
+        )
+
+        if _is_task_failed(status.status):
+            raise PredictionTaskError(f"Prediction task failed: {status.status}")
+
+        return await self._get_results_unified(
+            prediction_task_uuid=status.prediction_task_uuid,
+            prediction_type=prediction_task_begin_response.prediction_type,
+        )
+
+    async def _wait_for_prediction_task_completion(
+        self,
+        prediction_task_uuid: PredictionTaskUUID,
+        polling_interval: float = 1.0,
+        timeout_seconds: Optional[int] = None,
+    ) -> PredictionTaskStatusResponse:
+        start_time = time.monotonic()
+        while True:
+            # Check if we've exceeded the timeout
+            if timeout_seconds is not None:
+                elapsed = time.monotonic() - start_time
+                if elapsed >= timeout_seconds:
+                    raise PredictionTimeoutException(
+                        f"Prediction task {prediction_task_uuid} did not complete within {timeout_seconds} seconds."
+                    )
+
+            status = await self.status(prediction_task_uuid)
+            if _is_task_complete(status.status):
+                return status
+
+            await asyncio.sleep(polling_interval)
+
+    async def _upload_media_to_prediction_task(
+        self, media: Media, signed_url: _MediaUploadUrl
+    ) -> None:
+        # Build multipart form: include all presigned fields + the file
+        form = aiohttp.FormData()
+        for k, v in signed_url.presigned_post_request.fields.items():
+            form.add_field(k, str(v))
+
+        file_obj = media.bytes_io()
+        try:
+            file_obj.seek(0)
+        except Exception:
+            pass  # if it's already at start or non-seekable
+
+        form.add_field(
+            "file",
+            file_obj,
+            filename="file",
+        )
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    signed_url.presigned_post_request.url,
+                    data=form,
+                ) as resp:
+                    resp.raise_for_status()
+        except ClientError as error:
+            raise PredictionUploadError(
+                "Error uploading media to prediction task:", error
+            )
+
+    async def _begin_prediction_task(
+        self,
+        mime_type: str,
+        frames_per_second: Optional[int],
+    ) -> _PredictionTaskBeginResponse:
+        url = f"{BASE_API_URL}/prediction-task/begin"
+
+        form_data = aiohttp.FormData()
+        form_data.add_field("mimetype", mime_type)
+        if frames_per_second is not None:
+            form_data.add_field("frames_per_second", str(frames_per_second))
+
+        headers = {
+            "Authorization": f"Bearer {self._client.api_key}",
+        }
+
+        @self._backoff_on_429
+        async def _make_request():
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, data=form_data, headers=headers) as resp:
+                    resp.raise_for_status()
+                    payload = await resp.json()
+            return payload
+
+        try:
+            payload = await _make_request()
+        except ClientError as error:
+            raise PredictionTaskBeginError("Error beginning prediction task:", error)
+
+        return _PredictionTaskBeginResponse.model_validate(payload)

dragoneye_python-0.4.0/src/dragoneye/client.py

@@ -0,0 +1,29 @@
+import os
+from typing import Callable, Optional
+
+import backoff
+
+from dragoneye.classification import Classification
+
+
+class Dragoneye:
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        max_retries: int = 10,
+        max_backoff_time: int = 120,
+        backoff_jitter: Callable[[float], float] = backoff.full_jitter,
+    ):
+        if api_key is None:
+            api_key = os.getenv("DRAGONEYE_API_KEY")
+
+        assert api_key is not None, (
+            "API key is required - set the DRAGONEYE_API_KEY environment variable or pass it to the [Dragoneye] constructor"
+        )
+
+        self.api_key = api_key
+        self.max_retries = max_retries
+        self.max_backoff_time = max_backoff_time
+        self.backoff_jitter = backoff_jitter
+
+        self.classification = Classification(self)

dragoneye_python-0.4.0/src/dragoneye/constants.py

@@ -0,0 +1,2 @@
+PREDICTED_STATUS = "predicted"
+FAILED_STATUS_PREFIX = "failed"

dragoneye_python-0.4.0/src/dragoneye/models.py

@@ -0,0 +1,49 @@
+from typing import Dict, Sequence
+
+from pydantic import BaseModel
+
+from dragoneye.types.common import (
+    NormalizedBbox,
+    PredictionTaskState,
+    PredictionTaskUUID,
+    PredictionType,
+    TaxonID,
+    TaxonPrediction,
+)
+
+
+class PredictionTaskStatusResponse(BaseModel):
+    prediction_task_uuid: PredictionTaskUUID
+    prediction_type: PredictionType
+    status: PredictionTaskState
+
+
+class ClassificationTraitRootPrediction(BaseModel):
+    id: TaxonID
+    name: str
+    displayName: str
+    taxons: Sequence[TaxonPrediction]
+
+
+class ClassificationObjectPrediction(BaseModel):
+    normalizedBbox: NormalizedBbox
+    category: TaxonPrediction
+    traits: Sequence[ClassificationTraitRootPrediction]
+
+
+class ClassificationPredictImageResponse(BaseModel):
+    predictions: Sequence[ClassificationObjectPrediction]
+    prediction_task_uuid: PredictionTaskUUID
+
+
+class ClassificationVideoObjectPrediction(ClassificationObjectPrediction):
+    frame_id: str
+    timestamp_microseconds: int
+
+
+class ClassificationPredictVideoResponse(BaseModel):
+    timestamp_us_to_predictions: Dict[
+        int, Sequence[ClassificationVideoObjectPrediction]
+    ]
+    frames_per_second: int
+    prediction_task_uuid: PredictionTaskUUID

{dragoneye_python-0.2.0 → dragoneye_python-0.4.0}/src/dragoneye/types/common.py

@@ -1,8 +1,11 @@
 from enum import Enum
-from typing import NewType, Optional, Sequence, Tuple
+from typing import Literal, NewType, Optional, Sequence, Tuple
 
 from pydantic import BaseModel
 
+PredictionType = Literal["image", "video"]
+PredictionTaskState = NewType("PredictionTaskState", str)
+
 NormalizedBbox = NewType("NormalizedBbox", Tuple[float, float, float, float])
 
 
@@ -13,6 +16,8 @@ class TaxonType(str, Enum):
 
 TaxonID = NewType("TaxonID", int)
 
+PredictionTaskUUID = NewType("PredictionTaskUUID", str)
+
 
 class TaxonPrediction(BaseModel):
     id: TaxonID

dragoneye_python-0.4.0/src/dragoneye/types/exception.py

@@ -0,0 +1,18 @@
+class PredictionTaskError(Exception):
+    pass
+
+
+class PredictionUploadError(Exception):
+    pass
+
+
+class PredictionTaskBeginError(Exception):
+    pass
+
+
+class PredictionTaskResultsUnavailableError(Exception):
+    pass
+
+
+class PredictionTimeoutException(Exception):
+    pass

dragoneye_python-0.4.0/src/dragoneye/types/media.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import mimetypes
+import os
+from dataclasses import dataclass
+from io import BufferedReader, BytesIO
+from pathlib import Path
+from typing import BinaryIO, ClassVar, Optional, Tuple, Union
+
+from typing_extensions import Self
+
+
+@dataclass(frozen=True)
+class Media:
+    """Generic binary media + mime_type with conservative, non-destructive access."""
+
+    file_or_bytes: Union[bytes, BytesIO, BinaryIO, BufferedReader]
+    mime_type: str
+
+    # Subclasses set this to enforce a family of mimetypes, e.g. ("image/",)
+    ACCEPT_PREFIXES: ClassVar[Tuple[str, ...]] = ()
+
+    def __post_init__(self) -> None:
+        # Enforce subtype-specific mimetype families when specified.
+        if self.ACCEPT_PREFIXES and not any(
+            self.mime_type.startswith(p) for p in self.ACCEPT_PREFIXES
+        ):
+            raise ValueError(
+                f"{self.__class__.__name__} requires mime_type starting with "
+                f"{' or '.join(self.ACCEPT_PREFIXES)}; got {self.mime_type!r}"
+            )
+
+    # ---------- Convenience constructors ----------
+
+    @classmethod
+    def from_bytes(cls, data: bytes, mime_type: str) -> Self:
+        return cls(file_or_bytes=data, mime_type=mime_type)
+
+    @classmethod
+    def from_stream(cls, stream: BinaryIO, *, mime_type: str) -> Self:
+        """
+        Accepts any readable binary stream (e.g., open('file', 'rb')).
+        Keeps the stream as-is; reading is deferred to bytes_io().
+        """
+        return cls(file_or_bytes=stream, mime_type=mime_type)
+
+    @classmethod
+    def from_path(
+        cls,
+        path: Union[str, os.PathLike[str]],
+        *,
+        mime_type: Optional[str] = None,
+        guess_from_extension: bool = True,
+        read_into_memory: bool = False,
+    ) -> Self:
+        """
+        Create a Media (or subclass) from a filesystem path.
+
+        - `path`: Path to the file on disk.
+        - `mime_type`: Explicit mime type. If omitted and `guess_from_extension=True`,
+           we'll try to guess from the file extension.
+        - `read_into_memory=True`: load file bytes into memory (closes file immediately).
+          Otherwise, keep an open file stream.
+        """
+        path = Path(path)
+        if not path.exists():
+            raise FileNotFoundError(path)
+
+        mt = mime_type or (
+            mimetypes.guess_type(path.name)[0] if guess_from_extension else None
+        )
+        if mt is None:
+            raise ValueError(
+                f"mime_type is required for {path} (no extension-based guess available)."
+            )
+
+        if read_into_memory:
+            data = path.read_bytes()
+            return cls(file_or_bytes=data, mime_type=mt)
+        else:
+            f = path.open("rb")
+            return cls(file_or_bytes=f, mime_type=mt)
+
+    # ---------- Utilities ----------
+
+    def bytes_io(self) -> BytesIO:
+        """
+        Returns a fresh BytesIO with the full content.
+        - If we wrap a BytesIO, we non-destructively rewind and copy.
+        - If we wrap a stream, we read it (without assuming seekability).
+        - If we hold bytes, we just wrap them.
+        """
+        src = self.file_or_bytes
+
+        if isinstance(src, bytes):
+            return BytesIO(src)
+
+        if isinstance(src, BytesIO):
+            # Non-destructively copy contents
+            pos = src.tell()
+            try:
+                src.seek(0)
+            except Exception:
+                pass
+            data = src.read()
+            try:
+                src.seek(pos)
+            except Exception:
+                pass
+            return BytesIO(data)
+
+        # For any readable object with .read()
+        if hasattr(src, "read"):
+            pos = _tell_safe(src)
+            data = src.read()
+            _seek_safe(src, pos)
+            return BytesIO(data)
+
+        raise TypeError(
+            "Invalid media source: expected bytes, BytesIO, or a readable binary stream."
+        )
+
+    def size_bytes(self) -> Optional[int]:
+        """
+        Best-effort size inference without consuming the stream.
+        Returns None if size can't be determined cheaply.
+        """
+        src = self.file_or_bytes
+        if isinstance(src, bytes):
+            return len(src)
+        if isinstance(src, BytesIO):
+            pos = src.tell()
+            try:
+                src.seek(0, os.SEEK_END)
+                end = src.tell()
+            finally:
+                _seek_safe(src, pos)
+            return end
+        if hasattr(src, "fileno"):
+            try:
+                return os.fstat(src.fileno()).st_size  # type: ignore[arg-type]
+            except Exception:
+                return None
+        # Path-based size if it looks like a buffered reader with .name
+        if hasattr(src, "name"):
+            try:
+                return Path(src.name).stat().st_size  # type: ignore[arg-type]
+            except Exception:
+                return None
+        return None
+
+
+@dataclass(frozen=True)
+class Image(Media):
+    """Media restricted to image/* mimetypes."""
+
+    ACCEPT_PREFIXES: ClassVar[Tuple[str, ...]] = ("image/",)
+
+
+@dataclass(frozen=True)
+class Video(Media):
+    """Media restricted to video/* mimetypes."""
+
+    ACCEPT_PREFIXES: ClassVar[Tuple[str, ...]] = ("video/",)
+
+
+# ---------- Helpers ----------
+
+
+def _tell_safe(stream: BinaryIO) -> Optional[int]:
+    try:
+        if hasattr(stream, "tell"):
+            return stream.tell()
+    except Exception:
+        pass
+    return None
+
+
+def _seek_safe(stream: BinaryIO, pos: Optional[int]) -> None:
+    if pos is None:
+        return
+    try:
+        if hasattr(stream, "seek"):
+            stream.seek(pos)
+    except Exception:
+        pass

dragoneye_python-0.2.0/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 dragoneyeAI
-
-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.

dragoneye_python-0.2.0/PKG-INFO

@@ -1,7 +0,0 @@
-Metadata-Version: 2.1
-Name: dragoneye-python
-Version: 0.2.0
-Requires-Python: >=3.8
-License-File: LICENSE
-Requires-Dist: requests
-Requires-Dist: pydantic>=2

dragoneye_python-0.2.0/dragoneye_python.egg-info/PKG-INFO

@@ -1,7 +0,0 @@
-Metadata-Version: 2.1
-Name: dragoneye-python
-Version: 0.2.0
-Requires-Python: >=3.8
-License-File: LICENSE
-Requires-Dist: requests
-Requires-Dist: pydantic>=2

dragoneye_python-0.2.0/dragoneye_python.egg-info/requires.txt

@@ -1,2 +0,0 @@
-requests
-pydantic>=2

dragoneye_python-0.2.0/requirements.txt

@@ -1,2 +0,0 @@
-requests
-pydantic>=2

dragoneye_python-0.2.0/src/dragoneye/classification.py

@@ -1,117 +0,0 @@
-import io
-from typing import TYPE_CHECKING, BinaryIO, Sequence
-
-import requests
-from pydantic import BaseModel
-
-from .types.common import BASE_API_URL, NormalizedBbox, TaxonID, TaxonPrediction
-from .types.image import Image, assert_consistent_data_type
-
-if TYPE_CHECKING:
-    from .client import Dragoneye
-
-
-class ClassificationTraitRootPrediction(BaseModel):
-    id: TaxonID
-    name: str
-    displayName: str
-    taxons: Sequence[TaxonPrediction]
-
-
-class ClassificationObjectPrediction(BaseModel):
-    normalizedBbox: NormalizedBbox
-    category: TaxonPrediction
-    traits: Sequence[ClassificationTraitRootPrediction]
-
-
-class ClassificationPredictImageResponse(BaseModel):
-    predictions: Sequence[ClassificationObjectPrediction]
-
-
-class ClassificationProductPrediction(BaseModel):
-    category: TaxonPrediction
-    traits: Sequence[ClassificationTraitRootPrediction]
-
-
-class ClassificationPredictProductResponse(BaseModel):
-    predictions: Sequence[ClassificationProductPrediction]
-
-
-class Classification:
-    def __init__(self, client: "Dragoneye"):
-        self._client = client
-
-    def predict(
-        self, image: Image, model_name: str
-    ) -> ClassificationPredictImageResponse:
-        url = f"{BASE_API_URL}/predict"
-
-        files = {}
-        data = {}
-
-        if image.file_or_bytes is not None:
-            if isinstance(image.file_or_bytes, bytes):
-                files["image_file"] = io.BytesIO(image.file_or_bytes)
-            elif isinstance(image.file_or_bytes, BinaryIO):  # pyright: ignore [reportUnnecessaryIsInstance]
-                files["image_file"] = image.file_or_bytes
-            else:
-                raise ValueError("Invalid image type: Must be bytes or BinaryIO")
-        elif image.url is not None:
-            data["image_url"] = image.url
-        else:
-            raise ValueError(
-                "Missing image: Either image file or image url must be specified"
-            )
-
-        data["model_name"] = model_name
-
-        headers = {"Authorization": f"Bearer {self._client.api_key}"}
-
-        try:
-            response = requests.post(url, files=files, data=data, headers=headers)
-            response.raise_for_status()
-        except requests.RequestException as error:
-            raise Exception(
-                "Error during Dragoneye Classification prediction request:", error
-            )
-
-        return ClassificationPredictImageResponse.model_validate(response.json())
-
-    def predict_product(
-        self, images: Sequence[Image], model_name: str
-    ) -> ClassificationPredictProductResponse:
-        url = f"{BASE_API_URL}/predict-product"
-
-        files = []
-        data = {}
-
-        assert_consistent_data_type(images)
-
-        for image in images:
-            if image.file_or_bytes is not None:
-                if isinstance(image.file_or_bytes, bytes):
-                    files.append(("image_file", io.BytesIO(image.file_or_bytes)))
-                elif (
-                    isinstance(image.file_or_bytes, BinaryIO)  # pyright: ignore [reportUnnecessaryIsInstance]
-                    or issubclass(type(image.file_or_bytes), BinaryIO)
-                    or isinstance(image.file_or_bytes, io.BufferedReader)
-                ):
-                    files.append(("image_file", image.file_or_bytes))
-                else:
-                    raise ValueError("Invalid image type: Must be bytes or BinaryIO")
-            elif image.url is not None:
-                data.setdefault("image_urls", []).append(image.url)
-
-        data["model_name"] = model_name
-
-        headers = {"Authorization": f"Bearer {self._client.api_key}"}
-
-        try:
-            response = requests.post(url, files=files, data=data, headers=headers)
-            response.raise_for_status()
-        except requests.RequestException as error:
-            raise Exception(
-                "Error during Dragoneye Classification prediction request:", error
-            )
-
-        return ClassificationPredictProductResponse.model_validate(response.json())

dragoneye_python-0.2.0/src/dragoneye/client.py

@@ -1,18 +0,0 @@
-import os
-from typing import Optional
-
-from dragoneye.classification import Classification
-
-
-class Dragoneye:
-    def __init__(self, api_key: Optional[str] = None):
-        if api_key is None:
-            api_key = os.getenv("DRAGONEYE_API_KEY")
-
-        assert (
-            api_key is not None
-        ), "API key is required - set the DRAGONEYE_API_KEY environment variable or pass it to the [Dragoneye] constructor"
-
-        self.api_key = api_key
-
-        self.classification = Classification(self)

dragoneye_python-0.2.0/src/dragoneye/types/image.py

@@ -1,12 +0,0 @@
-from typing import BinaryIO, NamedTuple, Optional, Sequence, Union
-
-
-class Image(NamedTuple):
-    file_or_bytes: Optional[Union[bytes, BinaryIO]] = None
-    url: Optional[str] = None
-
-
-def assert_consistent_data_type(images: Sequence[Image]) -> None:
-    assert all(image.file_or_bytes is not None for image in images) ^ all(
-        image.url is not None for image in images
-    )