dragoneye-python 0.1.0__tar.gz → 0.3.0__tar.gz

{dragoneye_python-0.1.0 → dragoneye_python-0.3.0}/PKG-INFO

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

{dragoneye_python-0.1.0 → dragoneye_python-0.3.0}/dragoneye_python.egg-info/PKG-INFO

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

dragoneye_python-0.3.0/dragoneye_python.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+requirements.txt
+dragoneye_python.egg-info/PKG-INFO
+dragoneye_python.egg-info/SOURCES.txt
+dragoneye_python.egg-info/dependency_links.txt
+dragoneye_python.egg-info/requires.txt
+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/exception.py
+src/dragoneye/types/media.py

dragoneye_python-0.3.0/dragoneye_python.egg-info/top_level.txt

@@ -0,0 +1 @@
+dragoneye

dragoneye_python-0.3.0/pyproject.toml

@@ -0,0 +1,12 @@
+[project]
+name = "dragoneye-python"
+version = "0.3.0"
+requires-python = ">=3.8"
+dynamic = ["dependencies"]
+license = {text = "MIT"}
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+
+[tool.setuptools.package-dir]
+dragoneye = "src/dragoneye"

dragoneye_python-0.3.0/src/dragoneye/__init__.py

@@ -0,0 +1,25 @@
+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.3.0/src/dragoneye/classification.py

@@ -0,0 +1,323 @@
+import asyncio
+import time
+from typing import TYPE_CHECKING, Any, Literal, overload
+
+import aiohttp
+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
+
+    async def predict_image(
+        self,
+        media: Image,
+        model_name: str,
+        timeout_seconds: int | None = 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: int | None = 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}"}
+
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers) as resp:
+                resp.raise_for_status()
+                payload = await resp.json()
+
+        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,
+    ) -> ClassificationPredictImageResponse | ClassificationPredictVideoResponse: ...
+
+    async def _get_results_unified(
+        self, prediction_task_uuid: PredictionTaskUUID, prediction_type: PredictionType
+    ) -> ClassificationPredictImageResponse | ClassificationPredictVideoResponse:
+        url = f"{BASE_API_URL}/prediction-task/results?predictionTaskUuid={prediction_task_uuid}"
+        headers = {"Authorization": f"Bearer {self._client.api_key}"}
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=headers) as resp:
+                    resp.raise_for_status()
+                    payload = await resp.json()
+        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
+
+        match prediction_type:
+            case "image":
+                return ClassificationPredictImageResponse.model_validate(payload)
+            case "video":
+                return ClassificationPredictVideoResponse.model_validate(payload)
+            case _:  # pyright: ignore [reportUnnecessaryComparison]
+                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: int | None,
+        timeout_seconds: int | None = None,
+    ) -> ClassificationPredictImageResponse: ...
+
+    @overload
+    async def _predict_unified(
+        self,
+        media: Video,
+        model_name: str,
+        frames_per_second: int | None,
+        timeout_seconds: int | None = None,
+    ) -> ClassificationPredictVideoResponse: ...
+
+    async def _predict_unified(
+        self,
+        media: Image | Video,
+        model_name: str,
+        frames_per_second: int | None,
+        timeout_seconds: int | None = None,
+    ) -> 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}",
+        }
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(
+                    predict_url, data=predict_data, headers=predict_headers
+                ) as resp:
+                    resp.raise_for_status()
+        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: int | None = 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: int | None,
+    ) -> _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}",
+        }
+
+        try:
+            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()
+        except ClientError as error:
+            raise PredictionTaskBeginError("Error beginning prediction task:", error)
+
+        return _PredictionTaskBeginResponse.model_validate(payload)

dragoneye_python-0.3.0/src/dragoneye/client.py

@@ -0,0 +1,18 @@
+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.3.0/src/dragoneye/constants.py

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

dragoneye_python-0.3.0/src/dragoneye/models.py

@@ -0,0 +1,50 @@
+from typing import 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
+    frame_index: int
+    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.3.0/src/dragoneye/types/common.py

@@ -0,0 +1,31 @@
+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"

dragoneye_python-0.3.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.3.0/src/dragoneye/types/media.py

@@ -0,0 +1,184 @@
+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, Self, Union
+
+
+@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: str | None = 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) -> int | None:
+        """
+        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) -> int | None:
+    try:
+        if hasattr(stream, "tell"):
+            return stream.tell()
+    except Exception:
+        pass
+    return None
+
+
+def _seek_safe(stream: BinaryIO, pos: int | None) -> None:
+    if pos is None:
+        return
+    try:
+        if hasattr(stream, "seek"):
+            stream.seek(pos)
+    except Exception:
+        pass

dragoneye_python-0.1.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.1.0/dragoneye_python.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-requirements.txt
-dragoneye_python.egg-info/PKG-INFO
-dragoneye_python.egg-info/SOURCES.txt
-dragoneye_python.egg-info/dependency_links.txt
-dragoneye_python.egg-info/requires.txt
-dragoneye_python.egg-info/top_level.txt

dragoneye_python-0.1.0/dragoneye_python.egg-info/top_level.txt

@@ -1 +0,0 @@
-

dragoneye_python-0.1.0/pyproject.toml

@@ -1,8 +0,0 @@
-[project]
-name = "dragoneye-python"
-version = "0.1.0"
-requires-python = ">=3.8"
-dynamic = ["dependencies"]
-
-[tool.setuptools.dynamic]
-dependencies = {file = ["requirements.txt"]}