seekrai 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

seekrai/resources/files.py

@@ -5,6 +5,7 @@ from typing import Any, Dict
 
 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(
@@ -71,30 +69,55 @@ class Files:
 
         return file_response
 
-    def list(self) -> FileList:
-        requestor = api_requestor.APIRequestor(
-            client=self._client,
-        )
+    def bulk_upload(
+        self,
+        files: list[Path | str],
+        *,
+        purpose: FilePurpose | str = FilePurpose.FineTune,
+    ) -> list[FileResponse]:
+        """
+        Upload multiple files in bulk.
+
+        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)
 
-        response, _, _ = requestor.request(
-            options=SeekrFlowRequest(
-                method="GET",
-                url="flow/files",
-            ),
-            stream=False,
+        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 = 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 = upload_manager.bulk_upload(
+            "flow/bulk_files", file_paths, purpose=purpose, redirect=True
         )
 
-        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)
+        return file_responses
 
     def retrieve(self, id: str) -> FileResponse:
         requestor = api_requestor.APIRequestor(
@@ -167,29 +190,19 @@ 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)
 
-
-class AsyncFiles:
-    def __init__(self, client: SeekrFlowClient) -> None:
-        self._client = client
-
-    async def upload(
-        self, file: Path | str, *, purpose: FilePurpose | str = FilePurpose.FineTune
-    ) -> None:
-        raise NotImplementedError()
-
-    async def list(self) -> FileList:
+    def list(self) -> FileList:
         requestor = api_requestor.APIRequestor(
             client=self._client,
         )
 
-        response, _, _ = await requestor.arequest(
+        response, _, _ = requestor.request(
             options=SeekrFlowRequest(
                 method="GET",
                 url="flow/files",
@@ -198,8 +211,43 @@ class AsyncFiles:
         )
 
         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)
 
-        return FileList(**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(
@@ -239,3 +287,70 @@ 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) -> FileList:
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="GET",
+                url="flow/files",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+
+        return FileList(**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

@@ -0,0 +1,173 @@
+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 (
+    SeekrFlowRequest,
+)
+from seekrai.types.ingestion import IngestionList, IngestionRequest, IngestionResponse
+
+
+class Ingestion(ResourceBase):
+    def ingest(
+        self,
+        files: List[str],
+    ) -> IngestionResponse:
+        """
+        Start an ingestion job for the specified files.
+
+        Args:
+            files (List[str]): List of file IDs to ingest.
+
+        Returns:
+            IngestionResponse: Object containing information about the created ingestion job.
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        parameter_payload = IngestionRequest(
+            files=files,
+        ).model_dump()
+
+        response, _, _ = requestor.request(
+            options=SeekrFlowRequest(
+                method="POST",
+                url="flow/alignment/ingestion",
+                params=parameter_payload,
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return IngestionResponse(**response.data)
+
+    def list(self) -> IngestionList:
+        """
+        Lists ingestion job history
+
+        Returns:
+            IngestionList: Object containing a list of ingestion jobs
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = requestor.request(
+            options=SeekrFlowRequest(
+                method="GET",
+                url="flow/alignment/ingestion",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return IngestionList(**response.data)
+
+    def retrieve(self, id: str) -> IngestionResponse:
+        """
+        Retrieves ingestion job details
+
+        Args:
+            id (str): Ingestion job ID to retrieve.
+
+        Returns:
+            IngestionResponse: Object containing information about ingestion job.
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = requestor.request(
+            options=SeekrFlowRequest(
+                method="GET",
+                url=f"flow/alignment/ingestion/{id}",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return IngestionResponse(**response.data)
+
+
+class AsyncIngestion(ResourceBase):
+    async def ingest(
+        self,
+        files: List[str],
+    ) -> IngestionResponse:
+        """
+        Start an ingestion job for the specified files asynchronously.
+
+        Args:
+            files (List[str]): List of file IDs to ingest.
+
+        Returns:
+            IngestionResponse: Object containing information about the created ingestion job.
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        parameter_payload = IngestionRequest(
+            files=files,
+        ).model_dump()
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="POST",
+                url="flow/alignment/ingestion",
+                params=parameter_payload,
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return IngestionResponse(**response.data)
+
+    async def list(self) -> IngestionList:
+        """
+        Lists ingestion job history asynchronously
+
+        Returns:
+            IngestionList: Object containing a list of ingestion jobs
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="GET",
+                url="flow/alignment/ingestion",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return IngestionList(**response.data)
+
+    async def retrieve(self, id: str) -> IngestionResponse:
+        """
+        Retrieves ingestion job details asynchronously
+
+        Args:
+            id (str): Ingestion job ID to retrieve.
+
+        Returns:
+            IngestionResponse: Object containing information about ingestion job.
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="GET",
+                url=f"flow/alignment/ingestion/{id}",
+            ),
+            stream=False,
+        )
+
+        assert isinstance(response, SeekrFlowResponse)
+        return IngestionResponse(**response.data)