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

{dragoneye_python-0.4.0 → dragoneye_python-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragoneye-python
-Version: 0.4.0
+Version: 0.5.1
 License-Expression: MIT
 Requires-Python: >=3.8
 Requires-Dist: requests

{dragoneye_python-0.4.0 → dragoneye_python-0.5.1}/dragoneye_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dragoneye-python
-Version: 0.4.0
+Version: 0.5.1
 License-Expression: MIT
 Requires-Python: >=3.8
 Requires-Dist: requests

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dragoneye-python"
-version = "0.4.0"
+version = "0.5.1"
 requires-python = ">=3.8"
 dynamic = ["dependencies"]
 license = "MIT"
@@ -13,4 +13,4 @@ license = "MIT"
 dependencies = {file = ["requirements.txt"]}
 
 [tool.setuptools.package-dir]
-dragoneye = "src/dragoneye"
+dragoneye = "src/dragoneye"

dragoneye_python-0.5.1/src/dragoneye/__init__.py

@@ -0,0 +1,32 @@
+from .classification import (
+    Classification,
+)
+from .client import Dragoneye
+from .models import (
+    ClassificationAttributeOption,
+    ClassificationAttributeResponse,
+    ClassificationCategory,
+    ClassificationCategoryPrediction,
+    ClassificationObjectPrediction,
+    ClassificationPredictImageResponse,
+    ClassificationPredictVideoResponse,
+    ClassificationVideoObjectPrediction,
+)
+from .types.common import NormalizedBbox
+from .types.media import Image, Video
+
+__all__ = [
+    "Classification",
+    "ClassificationAttributeOption",
+    "ClassificationAttributeResponse",
+    "ClassificationCategory",
+    "ClassificationCategoryPrediction",
+    "ClassificationObjectPrediction",
+    "ClassificationPredictImageResponse",
+    "ClassificationPredictVideoResponse",
+    "ClassificationVideoObjectPrediction",
+    "Dragoneye",
+    "Image",
+    "NormalizedBbox",
+    "Video",
+]

{dragoneye_python-0.4.0 → dragoneye_python-0.5.1}/src/dragoneye/classification.py

@@ -97,12 +97,14 @@ class Classification:
         media: Image,
         model_name: str,
         timeout_seconds: Optional[int] = None,
+        **kwargs: Any,
     ) -> ClassificationPredictImageResponse:
         return await self._predict_unified(
             media=media,
             model_name=model_name,
             frames_per_second=None,
             timeout_seconds=timeout_seconds,
+            **kwargs,
         )
 
     async def predict_video(
@@ -111,12 +113,14 @@ class Classification:
         model_name: str,
         frames_per_second: int = 1,
         timeout_seconds: Optional[int] = None,
+        **kwargs: Any,
     ) -> ClassificationPredictVideoResponse:
         return await self._predict_unified(
             media=media,
             model_name=model_name,
             frames_per_second=frames_per_second,
             timeout_seconds=timeout_seconds,
+            **kwargs,
         )
 
     async def status(
@@ -219,6 +223,7 @@ class Classification:
         model_name: str,
         frames_per_second: Optional[int],
         timeout_seconds: Optional[int] = None,
+        **kwargs: Any,
     ) -> ClassificationPredictImageResponse: ...
 
     @overload
@@ -228,6 +233,7 @@ class Classification:
         model_name: str,
         frames_per_second: Optional[int],
         timeout_seconds: Optional[int] = None,
+        **kwargs: Any,
     ) -> ClassificationPredictVideoResponse: ...
 
     async def _predict_unified(
@@ -236,10 +242,12 @@ class Classification:
         model_name: str,
         frames_per_second: Optional[int],
         timeout_seconds: Optional[int] = None,
+        **kwargs: Any,
     ) -> Union[ClassificationPredictImageResponse, ClassificationPredictVideoResponse]:
         prediction_task_begin_response = await self._begin_prediction_task(
             mime_type=media.mime_type,
             frames_per_second=frames_per_second,
+            file_name=media.name,
         )
 
         await self._upload_media_to_prediction_task(
@@ -247,9 +255,10 @@ class Classification:
         )
 
         predict_url = f"{BASE_API_URL}/predict"
-        predict_data = {
+        predict_data: dict[str, Any] = {
             "model_name": model_name,
             "prediction_task_uuid": prediction_task_begin_response.prediction_task_uuid,
+            **kwargs,
         }
         predict_headers = {
             "Authorization": f"Bearer {self._client.api_key}",
@@ -339,11 +348,16 @@ class Classification:
         self,
         mime_type: str,
         frames_per_second: Optional[int],
+        file_name: Optional[str],
     ) -> _PredictionTaskBeginResponse:
         url = f"{BASE_API_URL}/prediction-task/begin"
 
         form_data = aiohttp.FormData()
         form_data.add_field("mimetype", mime_type)
+        form_data.add_field("response_version", "object")
+        if file_name is not None:
+            form_data.add_field("file_name", file_name)
+
         if frames_per_second is not None:
             form_data.add_field("frames_per_second", str(frames_per_second))
 

{dragoneye_python-0.4.0 → dragoneye_python-0.5.1}/src/dragoneye/models.py

@@ -1,4 +1,4 @@
-from typing import Dict, Sequence
+from typing import Dict, List, Optional
 
 from pydantic import BaseModel
 
@@ -7,8 +7,6 @@ from dragoneye.types.common import (
     PredictionTaskState,
     PredictionTaskUUID,
     PredictionType,
-    TaxonID,
-    TaxonPrediction,
 )
 
 
@@ -18,22 +16,38 @@ class PredictionTaskStatusResponse(BaseModel):
     status: PredictionTaskState
 
 
-class ClassificationTraitRootPrediction(BaseModel):
-    id: TaxonID
+class ClassificationAttributeOption(BaseModel):
+    option_id: int
     name: str
-    displayName: str
-    taxons: Sequence[TaxonPrediction]
+    score: float
+
+
+class ClassificationAttributeResponse(BaseModel):
+    attribute_id: int
+    name: str
+    options: List[ClassificationAttributeOption]
+
+
+class ClassificationCategory(BaseModel):
+    id: int
+    name: str
+    score: float
+
+
+class ClassificationCategoryPrediction(BaseModel):
+    category: ClassificationCategory
+    attributes: List[ClassificationAttributeResponse]
 
 
 class ClassificationObjectPrediction(BaseModel):
     normalizedBbox: NormalizedBbox
-    category: TaxonPrediction
-    traits: Sequence[ClassificationTraitRootPrediction]
+    predictions: List[ClassificationCategoryPrediction]
 
 
 class ClassificationPredictImageResponse(BaseModel):
-    predictions: Sequence[ClassificationObjectPrediction]
+    object_predictions: List[ClassificationObjectPrediction]
     prediction_task_uuid: PredictionTaskUUID
+    original_file_name: Optional[str]
 
 
 class ClassificationVideoObjectPrediction(ClassificationObjectPrediction):
@@ -43,7 +57,8 @@ class ClassificationVideoObjectPrediction(ClassificationObjectPrediction):
 
 class ClassificationPredictVideoResponse(BaseModel):
     timestamp_us_to_predictions: Dict[
-        int, Sequence[ClassificationVideoObjectPrediction]
+        int, List[ClassificationVideoObjectPrediction]
     ]
     frames_per_second: int
     prediction_task_uuid: PredictionTaskUUID
+    original_file_name: Optional[str]

dragoneye_python-0.5.1/src/dragoneye/types/common.py

@@ -0,0 +1,12 @@
+from typing import Literal, NewType, Tuple
+
+PredictionType = Literal["image", "video"]
+PredictionTaskState = NewType("PredictionTaskState", str)
+
+NormalizedBbox = NewType("NormalizedBbox", Tuple[float, float, float, float])
+
+PredictionTaskUUID = NewType("PredictionTaskUUID", str)
+
+TimestampUs = NewType("TimestampUs", int)
+
+BASE_API_URL = "https://api.dragoneye.ai"

{dragoneye_python-0.4.0 → dragoneye_python-0.5.1}/src/dragoneye/types/media.py

@@ -15,6 +15,7 @@ class Media:
     """Generic binary media + mime_type with conservative, non-destructive access."""
 
     file_or_bytes: Union[bytes, BytesIO, BinaryIO, BufferedReader]
+    name: Optional[str]
     mime_type: str
 
     # Subclasses set this to enforce a family of mimetypes, e.g. ("image/",)
@@ -33,16 +34,33 @@ class Media:
     # ---------- Convenience constructors ----------
 
     @classmethod
-    def from_bytes(cls, data: bytes, mime_type: str) -> Self:
-        return cls(file_or_bytes=data, mime_type=mime_type)
+    def from_bytes(
+        cls, data: bytes, mime_type: str, name: Optional[str] = None
+    ) -> Self:
+        """
+        Create a Media (or subclass) from raw bytes.
+
+        - `data`: Raw bytes of the media content.
+        - `mime_type`: The MIME type of the media (e.g., 'image/jpeg').
+        - `name`: Optional non-unique descriptive identifier provided by the user
+          for identifying or tracking responses to inputs.
+        """
+        return cls(file_or_bytes=data, mime_type=mime_type, name=name)
 
     @classmethod
-    def from_stream(cls, stream: BinaryIO, *, mime_type: str) -> Self:
+    def from_stream(
+        cls, stream: BinaryIO, *, mime_type: str, name: Optional[str] = None
+    ) -> Self:
         """
         Accepts any readable binary stream (e.g., open('file', 'rb')).
         Keeps the stream as-is; reading is deferred to bytes_io().
+
+        - `stream`: A readable binary stream.
+        - `mime_type`: The MIME type of the media (e.g., 'image/jpeg').
+        - `name`: Optional non-unique descriptive identifier provided by the user
+          for identifying or tracking responses to inputs.
         """
-        return cls(file_or_bytes=stream, mime_type=mime_type)
+        return cls(file_or_bytes=stream, mime_type=mime_type, name=name)
 
     @classmethod
     def from_path(
@@ -50,6 +68,7 @@ class Media:
         path: Union[str, os.PathLike[str]],
         *,
         mime_type: Optional[str] = None,
+        name: Optional[str] = None,
         guess_from_extension: bool = True,
         read_into_memory: bool = False,
     ) -> Self:
@@ -59,6 +78,9 @@ class Media:
         - `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.
+        - `name`: Optional non-unique descriptive identifier provided by the user
+          for identifying or tracking responses to inputs. If not provided, will
+          default to the filename from the path.
         - `read_into_memory=True`: load file bytes into memory (closes file immediately).
           Otherwise, keep an open file stream.
         """
@@ -74,12 +96,15 @@ class Media:
                 f"mime_type is required for {path} (no extension-based guess available)."
             )
 
+        # Use provided name or extract from path
+        media_name = name if name is not None else path.name
+
         if read_into_memory:
             data = path.read_bytes()
-            return cls(file_or_bytes=data, mime_type=mt)
+            return cls(file_or_bytes=data, mime_type=mt, name=media_name)
         else:
             f = path.open("rb")
-            return cls(file_or_bytes=f, mime_type=mt)
+            return cls(file_or_bytes=f, mime_type=mt, name=media_name)
 
     # ---------- Utilities ----------
 
@@ -111,10 +136,10 @@ class Media:
 
         # For any readable object with .read()
         if hasattr(src, "read"):
-            pos = _tell_safe(src)
-            data = src.read()
-            _seek_safe(src, pos)
-            return BytesIO(data)
+            pos = _tell_safe(src) # pyright: ignore [reportArgumentType]
+            data = src.read() # pyright: ignore [reportUnknownMemberType, reportAttributeAccessIssue, reportUnknownVariableType]
+            _seek_safe(src, pos) # pyright: ignore [reportArgumentType]
+            return BytesIO(data) # pyright: ignore [reportUnknownArgumentType]
 
         raise TypeError(
             "Invalid media source: expected bytes, BytesIO, or a readable binary stream."

dragoneye_python-0.4.0/src/dragoneye/__init__.py

@@ -1,25 +0,0 @@
-from .classification import (
-    Classification,
-)
-from .client import Dragoneye
-from .models import (
-    ClassificationObjectPrediction,
-    ClassificationPredictImageResponse,
-    ClassificationTraitRootPrediction,
-)
-from .types.common import NormalizedBbox, TaxonID, TaxonPrediction, TaxonType
-from .types.media import Image, Video
-
-__all__ = [
-    "Classification",
-    "ClassificationObjectPrediction",
-    "ClassificationPredictImageResponse",
-    "ClassificationTraitRootPrediction",
-    "Dragoneye",
-    "Image",
-    "Video",
-    "NormalizedBbox",
-    "TaxonID",
-    "TaxonPrediction",
-    "TaxonType",
-]

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

@@ -1,31 +0,0 @@
-from enum import Enum
-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])
-
-
-class TaxonType(str, Enum):
-    CATEGORY = ("category",)
-    TRAIT = ("trait",)
-
-
-TaxonID = NewType("TaxonID", int)
-
-PredictionTaskUUID = NewType("PredictionTaskUUID", str)
-
-
-class TaxonPrediction(BaseModel):
-    id: TaxonID
-    type: TaxonType
-    name: str
-    displayName: str
-    score: Optional[float]
-    children: Sequence["TaxonPrediction"]
-
-
-BASE_API_URL = "https://api.dragoneye.ai"