seekrai 0.4.4__py3-none-any.whl → 0.5.1__py3-none-any.whl

seekrai/resources/files.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Optional, Union
 
 from seekrai.abstract import api_requestor
 from seekrai.filemanager import DownloadManager, UploadManager
+from seekrai.resources.resource_base import ResourceBase
 from seekrai.seekrflow_response import SeekrFlowResponse
 from seekrai.types import (
     FileDeleteResponse,
@@ -12,7 +13,6 @@ from seekrai.types import (
     FileObject,
     FilePurpose,
     FileResponse,
-    SeekrFlowClient,
     SeekrFlowRequest,
 )
 from seekrai.types.files import (
@@ -22,19 +22,17 @@ from seekrai.types.files import (
 from seekrai.utils import normalize_key
 
 
-class Files:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
+def _get_local_file_metadata(file_path: Path) -> Dict[str, Any]:
+    suffix = file_path.suffix.lstrip(".")
+    size_bytes = int(file_path.stat().st_size)
+    return {
+        "suffix": suffix,
+        "size_bytes": size_bytes,
+        "filename": file_path.name,
+    }
 
-    def _get_local_file_metadata(self, file_path: Path) -> Dict[str, Any]:
-        suffix = file_path.suffix.lstrip(".")
-        size_bytes = int(file_path.stat().st_size)
-        return {
-            "suffix": suffix,
-            "size_bytes": size_bytes,
-            "filename": file_path.name,
-        }
 
+class Files(ResourceBase):
     def upload(
         self, file: Path | str, *, purpose: FilePurpose | str = FilePurpose.FineTune
     ) -> FileResponse:
@@ -48,7 +46,7 @@ class Files:
 
         # Do the metadata validation (fail fast before uploading) for Alignment purpose
         if purpose == FilePurpose.Alignment:
-            file_metadata = self._get_local_file_metadata(file)
+            file_metadata = _get_local_file_metadata(file)
             suffix = file_metadata["suffix"]
             size = file_metadata["size_bytes"]
             metadata_validation = self.validate_align_file_metadata(
@@ -98,7 +96,7 @@ class Files:
         # Validate all files before uploading (fail fast)
         if purpose == FilePurpose.Alignment:
             for file_path in file_paths:
-                file_metadata = self._get_local_file_metadata(file_path)
+                file_metadata = _get_local_file_metadata(file_path)
                 suffix = file_metadata["suffix"]
                 size = file_metadata["size_bytes"]
                 metadata_validation = self.validate_align_file_metadata(
@@ -121,31 +119,6 @@ class Files:
 
         return file_responses
 
-    def list(self) -> FileList:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        response, _, _ = requestor.request(
-            options=SeekrFlowRequest(
-                method="GET",
-                url="flow/files",
-            ),
-            stream=False,
-        )
-
-        assert isinstance(response, SeekrFlowResponse)
-        files = [
-            FileResponse(
-                id=file["id"],
-                filename=file["filename"],
-                created_at=file["created_at"],
-                object="file",
-            )
-            for file in response.data["data"]
-        ]
-        return FileList(object="list", data=files)
-
     def retrieve(self, id: str) -> FileResponse:
         requestor = api_requestor.APIRequestor(
             client=self._client,
@@ -217,39 +190,126 @@ class Files:
             options=SeekrFlowRequest(
                 method="POST",
                 url="flow/files/validate_metadata",
-                params=request_body.dict(),
+                params=request_body.model_dump(),
             ),
             stream=False,
         )
 
         return AlignFileMetadataValidationResp(**response.data)
 
+    def list(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_order: Optional[str] = None,
+        purpose: Optional[Union[FilePurpose, str]] = None,
+    ) -> FileList:
+        """
+        List files with pagination, sorting, and filtering options.
 
-class AsyncFiles:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
+        All parameter defaults are handled by the API if not specified.
 
-    async def upload(
-        self, file: Path | str, *, purpose: FilePurpose | str = FilePurpose.FineTune
-    ) -> None:
-        raise NotImplementedError()
+        Args:
+            limit: Maximum number of files to return
+            offset: Number of files to skip
+            sort_by: Field to sort by ('created_at', 'filename', 'type', or 'size')
+            sort_order: Sort order ('asc' or 'desc')
+            purpose: Filter by file purpose (FilePurpose enum or string)
 
-    async def list(self) -> FileList:
+        Returns:
+            A FileList object containing the list of files
+
+        Raises:
+            Exception: If the API request fails
+        """
+        # Build query parameters, only including non-None values
+        params: Dict[str, Any] = {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+        if sort_by is not None:
+            params["sort_by"] = sort_by
+        if sort_order is not None:
+            params["sort_order"] = sort_order
+
+        # Add purpose filter if provided, converting from enum if needed
+        if purpose is not None:
+            params["purpose"] = (
+                purpose.value if isinstance(purpose, FilePurpose) else purpose
+            )
+
+        # Create request and use the API requestor
+        requestor = api_requestor.APIRequestor(client=self._client)
+
+        response, _, _ = requestor.request(
+            options=SeekrFlowRequest(
+                method="GET",
+                url="flow/files",
+                params=params,
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return FileList.parse_obj(response.data)
+
+    def rename(self, id: str, new_filename: str) -> FileResponse:
+        """
+        Rename a file.
+
+        Args:
+            id (str): ID of the file to rename.
+            new_filename (str): New filename for the file.
+
+        Returns:
+            FileResponse: Object containing information about the renamed file.
+        """
         requestor = api_requestor.APIRequestor(
             client=self._client,
         )
 
-        response, _, _ = await requestor.arequest(
+        response, _, _ = requestor.request(
             options=SeekrFlowRequest(
-                method="GET",
-                url="flow/files",
+                method="PUT",
+                url=f"flow/files/{id}/rename",
+                params={"new_filename": new_filename},
             ),
             stream=False,
         )
 
         assert isinstance(response, SeekrFlowResponse)
 
-        return FileList(**response.data)
+        return FileResponse(**response.data)
+
+
+class AsyncFiles(ResourceBase):
+    async def validate_align_file_metadata(
+        self,
+        purpose: FilePurpose,
+        suffix: str,
+        size: int,
+    ) -> AlignFileMetadataValidationResp:
+        requestor = api_requestor.APIRequestor(client=self._client)
+
+        request_body = AlignFileMetadataValidationReq(
+            purpose=purpose,
+            suffix=suffix,
+            size=size,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="POST",
+                url="flow/files/validate_metadata",
+                params=request_body.model_dump(),
+            ),
+            stream=False,
+        )
+
+        return AlignFileMetadataValidationResp(**response.data)
 
     async def retrieve(self, id: str) -> FileResponse:
         requestor = api_requestor.APIRequestor(
@@ -289,3 +349,140 @@ class AsyncFiles:
         assert isinstance(response, SeekrFlowResponse)
 
         return FileDeleteResponse(**response.data)
+
+    async def bulk_upload(
+        self,
+        files: list[Path | str],
+        *,
+        purpose: FilePurpose | str = FilePurpose.FineTune,
+    ) -> list[FileResponse]:
+        """
+        Upload multiple files in bulk asynchronously.
+
+        Args:
+            files: List of file paths to upload
+            purpose: The purpose of the files (defaults to FineTune)
+
+        Returns:
+            List of FileResponse objects for each uploaded file
+        """
+        if isinstance(purpose, str):
+            purpose = FilePurpose(purpose)
+
+        assert isinstance(purpose, FilePurpose)
+
+        # Convert string paths to Path objects
+        file_paths = [Path(file) if isinstance(file, str) else file for file in files]
+
+        # Validate all files before uploading (fail fast)
+        if purpose == FilePurpose.Alignment:
+            for file_path in file_paths:
+                file_metadata = _get_local_file_metadata(file_path)
+                suffix = file_metadata["suffix"]
+                size = file_metadata["size_bytes"]
+                metadata_validation = await self.validate_align_file_metadata(
+                    purpose,
+                    suffix,
+                    size,
+                )
+
+                if not metadata_validation.is_valid:
+                    assert metadata_validation.errors is not None  # To appease linter
+                    raise ValueError(
+                        f"Alignment file metadata validation failed for {file_path.name}: {metadata_validation.errors}"
+                    )
+
+        # Upload the files to s3
+        upload_manager = UploadManager(self._client)
+        file_responses = await upload_manager.bulk_upload_async(
+            "flow/bulk_files", file_paths, purpose=purpose, redirect=True
+        )
+
+        return file_responses
+
+    async def list(
+        self,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        sort_by: Optional[str] = None,
+        sort_order: Optional[str] = None,
+        purpose: Optional[Union[FilePurpose, str]] = None,
+    ) -> FileList:
+        """
+        List files with pagination, sorting, and filtering options.
+
+        All parameter defaults are handled by the API if not specified.
+
+        Args:
+            limit: Maximum number of files to return
+            offset: Number of files to skip
+            sort_by: Field to sort by ('created_at', 'filename', 'type', or 'size')
+            sort_order: Sort order ('asc' or 'desc')
+            purpose: Filter by file purpose (FilePurpose enum or string)
+
+        Returns:
+            A FileList object containing the list of files
+
+        Raises:
+            Exception: If the API request fails
+        """
+        # Build query parameters, only including non-None values
+        params: Dict[str, Any] = {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+        if sort_by is not None:
+            params["sort_by"] = sort_by
+        if sort_order is not None:
+            params["sort_order"] = sort_order
+
+        # Add purpose filter if provided, converting from enum if needed
+        if purpose is not None:
+            params["purpose"] = (
+                purpose.value if isinstance(purpose, FilePurpose) else purpose
+            )
+
+        # Create request and use the API requestor
+        requestor = api_requestor.APIRequestor(client=self._client)
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="GET",
+                url="flow/files",
+                params=params,
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return FileList.parse_obj(response.data)
+
+    async def rename(self, id: str, new_filename: str) -> FileResponse:
+        """
+        Rename a file asynchronously.
+
+        Args:
+            id (str): ID of the file to rename.
+            new_filename (str): New filename for the file.
+
+        Returns:
+            FileResponse: Object containing information about the renamed file.
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="PUT",
+                url=f"flow/files/{id}/rename",
+                params={"new_filename": new_filename},
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return FileResponse(**response.data)

seekrai/resources/finetune.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from pathlib import Path
 
 from seekrai.abstract import api_requestor
+from seekrai.resources.resource_base import ResourceBase
 from seekrai.seekrflow_response import SeekrFlowResponse
 from seekrai.types import (
     FinetuneDownloadResult,
@@ -11,16 +12,12 @@ from seekrai.types import (
     FinetuneRequest,
     FinetuneResponse,
     InfrastructureConfig,
-    SeekrFlowClient,
     SeekrFlowRequest,
     TrainingConfig,
 )
 
 
-class FineTuning:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
+class FineTuning(ResourceBase):
     def create(
         self,
         *,
@@ -246,10 +243,7 @@ class FineTuning:
         return FinetuneListEvents(**response.data)
 
 
-class AsyncFineTuning:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
+class AsyncFineTuning(ResourceBase):
     async def create(
         self,
         *,

seekrai/resources/images.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from seekrai.abstract import api_requestor
+from seekrai.resources.resource_base import ResourceBase
 from seekrai.seekrflow_response import SeekrFlowResponse
 from seekrai.types import (
     ImageRequest,
@@ -10,10 +11,7 @@ from seekrai.types import (
 )
 
 
-class Images:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
+class Images(ResourceBase):
     def generate(
         self,
         *,
@@ -83,7 +81,7 @@ class Images:
         return ImageResponse(**response.data)
 
 
-class AsyncImages:
+class AsyncImages(ResourceBase):
     def __init__(self, client: SeekrFlowClient) -> None:
         self._client = client
 

seekrai/resources/ingestion.py

@@ -1,18 +1,15 @@
 from typing import List
 
 from seekrai.abstract import api_requestor
+from seekrai.resources.resource_base import ResourceBase
 from seekrai.seekrflow_response import SeekrFlowResponse
 from seekrai.types import (
-    SeekrFlowClient,
     SeekrFlowRequest,
 )
 from seekrai.types.ingestion import IngestionList, IngestionRequest, IngestionResponse
 
 
-class Ingestion:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
+class Ingestion(ResourceBase):
     def ingest(
         self,
         files: List[str],
@@ -94,10 +91,7 @@ class Ingestion:
         return IngestionResponse(**response.data)
 
 
-class AsyncIngestion:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
+class AsyncIngestion(ResourceBase):
     async def ingest(
         self,
         files: List[str],

seekrai/resources/models.py

@@ -1,56 +1,14 @@
 from __future__ import annotations
 
-import os
-from pathlib import Path
-from typing import Any, List
-
-from tqdm import tqdm
-from tqdm.utils import CallbackIOWrapper
-
 from seekrai.abstract import api_requestor
-from seekrai.constants import DISABLE_TQDM
+from seekrai.resources.resource_base import ResourceBase
 from seekrai.seekrflow_response import SeekrFlowResponse
-from seekrai.types import ModelList, ModelResponse, SeekrFlowClient, SeekrFlowRequest
-from seekrai.types.models import ModelType
-
-
-class Models:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
-    def upload(
-        self,
-        file: Path | str,
-        *,
-        model_type: ModelType | str = ModelType.OBJECT_DETECTION,
-    ) -> ModelResponse:
-        if isinstance(file, str):
-            file = Path(file)
+from seekrai.types import ModelList, ModelResponse, SeekrFlowRequest
+from seekrai.types.common import ObjectType
+from seekrai.utils import parse_timestamp
 
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-        file_size = os.stat(file.as_posix()).st_size
-
-        with tqdm(
-            total=file_size,
-            unit="B",
-            unit_scale=True,
-            desc=f"Uploading model file {file.name}",
-            disable=bool(DISABLE_TQDM),
-        ) as t:
-            with file.open("rb") as f:
-                reader_wrapper = CallbackIOWrapper(t.update, f, "read")
-                response, _, _ = requestor.request(
-                    options=SeekrFlowRequest(
-                        method="PUT",
-                        url="flow/pt-models",
-                        files={"files": reader_wrapper, "filename": file.name},
-                        params={"purpose": model_type},
-                    ),
-                )
-        return ModelResponse(**response.data)
 
+class Models(ResourceBase):
     def list(
         self,
     ) -> ModelList:
@@ -58,7 +16,7 @@ class Models:
         Method to return list of models on the API
 
         Returns:
-            List[ModelResponse]: List of model objects
+            ModelList: List of model objects
         """
 
         requestor = api_requestor.APIRequestor(
@@ -68,95 +26,36 @@ class Models:
         response, _, _ = requestor.request(
             options=SeekrFlowRequest(
                 method="GET",
-                url="flow/pt-models",
-            ),
-            stream=False,
-        )
-
-        assert isinstance(response, SeekrFlowResponse)
-        return ModelList(**response.data)
-
-    def promote(self, id: str) -> ModelResponse:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        response, _, _ = requestor.request(
-            options=SeekrFlowRequest(
-                method="GET",
-                url=f"flow/pt-models/{id}/promote-model",
-                params={"model_id": id},
-            ),
-            stream=False,
-        )
-
-        assert isinstance(response, SeekrFlowResponse)
-
-        return ModelResponse(**response.data)
-
-    def demote(self, id: str) -> ModelResponse:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
-
-        response, _, _ = requestor.request(
-            options=SeekrFlowRequest(
-                method="GET",
-                url=f"flow/pt-models/{id}/demote-model",
-                params={"model_id": id},
+                url="flow/models",
             ),
             stream=False,
         )
-
         assert isinstance(response, SeekrFlowResponse)
 
-        return ModelResponse(**response.data)
+        model_responses = [
+            ModelResponse(
+                id=str(model["id"]),
+                object=ObjectType.Model,
+                name=model["name"],
+                bytes=model["size"],
+                created_at=parse_timestamp(model["created_at"]),
+                model_type=model["model_type"],
+            )
+            for model in response.data["data"]
+        ]
 
-    def predict(self, id: str, file: Path | str) -> Any:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+        return ModelList(data=model_responses)
 
-        if isinstance(file, str):
-            file = Path(file)
-
-        file_size = os.stat(file.as_posix()).st_size
-
-        with tqdm(
-            total=file_size,
-            unit="B",
-            unit_scale=True,
-            desc=f"Uploading file {file.name}",
-            disable=bool(DISABLE_TQDM),
-        ):
-            with file.open("rb") as f:
-                response, _, _ = requestor.request(
-                    options=SeekrFlowRequest(
-                        method="POST",
-                        url="flow/pt-models/predict",
-                        files={"files": f, "filename": file.name},
-                        params={"model_id": id},
-                    ),
-                    stream=False,
-                )
-
-        assert isinstance(response, SeekrFlowResponse)
-
-        return response.data
-
-
-class AsyncModels:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
 
+class AsyncModels(ResourceBase):
     async def list(
         self,
-    ) -> List[ModelResponse]:
+    ) -> ModelList:
         """
         Async method to return list of models on API
 
         Returns:
-            List[ModelResponse]: List of model objects
+            ModelList: List of model objects
         """
 
         requestor = api_requestor.APIRequestor(
@@ -174,4 +73,16 @@ class AsyncModels:
         assert isinstance(response, SeekrFlowResponse)
         assert isinstance(response.data, list)
 
-        return [ModelResponse(**model) for model in response.data]
+        model_responses = [
+            ModelResponse(
+                id=str(model["id"]),
+                object=ObjectType.Model,
+                name=model["name"],
+                bytes=model["size"],
+                created_at=parse_timestamp(model["created_at"]),
+                model_type=model["model_type"],
+            )
+            for model in response.data["data"]
+        ]
+
+        return ModelList(data=model_responses)