seekrai 0.4.2__tar.gz → 0.4.4__tar.gz

{seekrai-0.4.2 → seekrai-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: seekrai
-Version: 0.4.2
+Version: 0.4.4
 Summary: Python client for SeekrAI
 Home-page: https://gitlab.cb.ntent.com/ml/seekr-py
 License: Apache-2.0

{seekrai-0.4.2 → seekrai-0.4.4}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "seekrai"
-version = "0.4.2"
+version = "0.4.4"
 authors = [
     "SeekrFlow <support@seekr.com>"
 ]

{seekrai-0.4.2 → seekrai-0.4.4}/src/seekrai/client.py

@@ -19,8 +19,10 @@ class SeekrFlow:
     models: resources.Models
     fine_tuning: resources.FineTuning
     alignment: resources.Alignment
+    ingestion: resources.Ingestion
     projects: resources.Projects
     deployments: resources.Deployments
+    agents: resources.Agents
 
     # client options
     client: SeekrFlowClient
@@ -81,8 +83,10 @@ class SeekrFlow:
         self.models = resources.Models(self.client)
         self.fine_tuning = resources.FineTuning(self.client)
         self.alignment = resources.Alignment(self.client)
+        self.ingestion = resources.Ingestion(self.client)
         self.projects = resources.Projects(self.client)
         self.deployments = resources.Deployments(self.client)
+        self.agents = resources.Agents(self.client)
 
 
 class AsyncSeekrFlow:
@@ -94,8 +98,10 @@ class AsyncSeekrFlow:
     models: resources.AsyncModels
     fine_tuning: resources.AsyncFineTuning
     alignment: resources.AsyncAlignment
+    ingestion: resources.AsyncIngestion
     projects: resources.AsyncProjects
     deployments: resources.AsyncDeployments
+    agents: resources.Agents
 
     # client options
     client: SeekrFlowClient
@@ -156,8 +162,10 @@ class AsyncSeekrFlow:
         self.models = resources.AsyncModels(self.client)
         self.fine_tuning = resources.AsyncFineTuning(self.client)
         self.alignment = resources.AsyncAlignment(self.client)
+        self.ingestion = resources.AsyncIngestion(self.client)
         self.projects = resources.AsyncProjects(self.client)
         self.deployments = resources.AsyncDeployments(self.client)
+        self.agents = resources.Agents(self.client)
 
 
 Client = SeekrFlow

{seekrai-0.4.2 → seekrai-0.4.4}/src/seekrai/filemanager.py

@@ -341,3 +341,92 @@ class UploadManager:
         assert isinstance(response, SeekrFlowResponse)
 
         return FileResponse(**response.data)
+
+    def bulk_upload(
+        self,
+        url: str,
+        files: list[Path],
+        *,
+        purpose: FilePurpose,
+        redirect: bool = False,
+    ) -> list[FileResponse]:
+        """
+        Upload multiple files in a bulk request.
+
+        Args:
+            url: API endpoint to upload to
+            files: List of file paths to upload
+            purpose: The purpose of the files
+            redirect: Whether to redirect after upload
+
+        Returns:
+            List of FileResponse objects for each uploaded file
+        """
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        # Prepare files for multipart form upload
+        # Format needs to be a list of tuples: [('files', (filename, file_stream)), ...]
+        files_tuples = []
+        file_streams = []
+        progress_bars = []
+
+        try:
+            for file_path in files:
+                file_size = os.stat(file_path.as_posix()).st_size
+
+                # Create progress bar
+                progress_bar = tqdm(
+                    total=file_size,
+                    unit="B",
+                    unit_scale=True,
+                    desc=f"Uploading file {file_path.name}",
+                    disable=bool(DISABLE_TQDM),
+                )
+                progress_bars.append(progress_bar)
+
+                # Open file and track for cleanup
+                file_stream = file_path.open("rb")
+                file_streams.append(file_stream)
+
+                # Create wrapper for progress tracking
+                reader_wrapper = CallbackIOWrapper(
+                    progress_bar.update, file_stream, "read"
+                )
+
+                # Add to files list as a tuple
+                files_tuples.append(("files", (file_path.name, reader_wrapper)))
+
+            # Make the request
+            response, _, _ = requestor.request(
+                options=SeekrFlowRequest(
+                    method="PUT",
+                    url=url,
+                    files=files_tuples,  # Pass as a list of tuples (field_name, (filename, file_stream))
+                    params={"purpose": purpose.value},
+                    allow_redirects=redirect,
+                ),
+                stream=False,
+            )
+
+            assert isinstance(response, SeekrFlowResponse)
+
+            # Parse the response
+            if isinstance(response.data, list):
+                file_responses = [
+                    FileResponse(**file_data) for file_data in response.data
+                ]
+            else:
+                # Handle case where response might be a single object
+                file_responses = [FileResponse(**response.data)]
+
+            return file_responses
+
+        finally:
+            # Clean up resources
+            for file_stream in file_streams:
+                file_stream.close()
+
+            for progress_bar in progress_bars:
+                progress_bar.close()

{seekrai-0.4.2 → seekrai-0.4.4}/src/seekrai/resources/__init__.py

@@ -1,3 +1,4 @@
+from seekrai.resources.agents import Agents
 from seekrai.resources.alignment import Alignment, AsyncAlignment
 from seekrai.resources.chat import AsyncChat, Chat
 from seekrai.resources.completions import AsyncCompletions, Completions
@@ -6,6 +7,7 @@ from seekrai.resources.embeddings import AsyncEmbeddings, Embeddings
 from seekrai.resources.files import AsyncFiles, Files
 from seekrai.resources.finetune import AsyncFineTuning, FineTuning
 from seekrai.resources.images import AsyncImages, Images
+from seekrai.resources.ingestion import AsyncIngestion, Ingestion
 from seekrai.resources.models import AsyncModels, Models
 from seekrai.resources.projects import AsyncProjects, Projects
 
@@ -25,10 +27,13 @@ __all__ = [
     "Files",
     "AsyncImages",
     "Images",
+    "Ingestion",
+    "AsyncIngestion",
     "AsyncModels",
     "Models",
     "AsyncProjects",
     "Projects",
     "AsyncDeployments",
     "Deployments",
+    "Agents",
 ]

seekrai-0.4.4/src/seekrai/resources/agents/__init__.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from .agent_inference import AgentInference
+
+
+class Agents:
+    def __init__(self, client: Any) -> None:
+        self.agent = AgentInference(client)

seekrai-0.4.4/src/seekrai/resources/agents/agent_inference.py

@@ -0,0 +1,70 @@
+from typing import Any, Dict, Iterator, Union
+
+from seekrai.abstract import api_requestor
+from seekrai.seekrflow_response import SeekrFlowResponse
+from seekrai.types import SeekrFlowRequest
+
+
+class AgentInference:
+    def __init__(self, client: Any) -> None:
+        self._client = client
+
+    def run(
+        self,
+        agent_id: Union[int, str],
+        query: str,
+        *,
+        stream: bool = False,
+        thread_id: Union[str, None] = None,
+        headers: Union[Dict[str, str], None] = None,
+        **model_settings: Any,
+    ) -> Union[Dict[str, Any], Iterator[Dict[str, Any]]]:
+        """
+        Run an inference call on a deployed agent.
+
+        Args:
+            agent_id (Union[int, str]): The unique identifier of the deployed agent.
+            query (str): The user query or prompt.
+            stream (bool, optional): Whether to stream the response. Defaults to False.
+            thread_id (str, optional): An optional thread identifier.
+            headers (dict, optional): Optional HTTP headers to include in the request.
+                                    If provided, these will be merged with default headers.
+            **model_settings: Additional parameters (such as temperature, max_tokens, etc).
+
+        Returns:
+            A dictionary with the response (if non-streaming) or an iterator over response chunks.
+        """
+        payload: Dict[str, Any] = {"prompt": query}
+        if thread_id is not None:
+            payload["thread_id"] = thread_id
+        payload.update(model_settings)
+
+        default_headers = {}
+        if self._client.api_key:
+            default_headers["x-api-key"] = self._client.api_key
+        if self._client.supplied_headers:
+            default_headers.update(self._client.supplied_headers)
+
+        request_headers = default_headers.copy()
+        if headers:
+            request_headers.update(headers)
+
+        requestor = api_requestor.APIRequestor(client=self._client)
+        endpoint = f"agents/{agent_id}/run"
+
+        response, _, _ = requestor.request(
+            options=SeekrFlowRequest(
+                method="POST",
+                url=endpoint,
+                params=payload,
+                headers=request_headers,
+            ),
+            stream=stream,
+        )
+
+        if stream:
+            assert not isinstance(response, SeekrFlowResponse)
+            return (chunk.data for chunk in response)
+        else:
+            assert isinstance(response, SeekrFlowResponse)
+            return response.data

{seekrai-0.4.2 → seekrai-0.4.4}/src/seekrai/resources/files.py

@@ -71,6 +71,56 @@ class Files:
 
         return file_response
 
+    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)
+
+        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 = self._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
+        )
+
+        return file_responses
+
     def list(self) -> FileList:
         requestor = api_requestor.APIRequestor(
             client=self._client,

seekrai-0.4.4/src/seekrai/resources/ingestion.py

@@ -0,0 +1,179 @@
+from typing import List
+
+from seekrai.abstract import api_requestor
+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
+
+    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:
+    def __init__(self, client: SeekrFlowClient) -> None:
+        self._client = client
+
+    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)

{seekrai-0.4.2 → seekrai-0.4.4}/src/seekrai/types/common.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from pydantic import ConfigDict, Field
 
@@ -72,6 +72,11 @@ class SeekrFlowRequest(BaseModel):
     url: str
     headers: Dict[str, str] | None = None
     params: Dict[str, Any] | None = None
-    files: Dict[str, Any] | None = None
+    files: (
+        Dict[str, Any]
+        | List[Tuple[str, Tuple[str, Any, Optional[str]]]]
+        | List[Tuple[str, Any]]
+        | None
+    ) = None
     allow_redirects: bool = True
     override_headers: bool = False

{seekrai-0.4.2 → seekrai-0.4.4}/src/seekrai/types/files.py

@@ -35,6 +35,8 @@ class AlignmentFileType(str, Enum):
     DOC = "doc"
     DOCX = "docx"
     PDF = "pdf"
+    PPT = "ppt"
+    PPTX = "pptx"
 
 
 FileType = Union[TrainingFileType, AlignmentFileType]

seekrai-0.4.4/src/seekrai/types/ingestion.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from datetime import datetime
+from enum import Enum
+from typing import List, Literal
+
+from pydantic import Field
+
+from seekrai.types.abstract import BaseModel
+
+
+class IngestionJobStatus(Enum):
+    QUEUED = "queued"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class IngestionRequest(BaseModel):
+    files: List[str] = Field(
+        default=..., description="List of file ids to use for alignment"
+    )
+    method: str = Field(default="best", description="Method to use for ingestion")
+
+
+class IngestionResponse(BaseModel):
+    id: str = Field(default=..., description="Ingestion job ID")
+    created_at: datetime
+    status: IngestionJobStatus
+    output_files: List[str]
+
+
+class IngestionList(BaseModel):
+    # object type
+    object: Literal["list"] | None = None
+    # list of fine-tune job objects
+    data: List[IngestionResponse] | None = None

seekrai-0.4.2/src/seekrai/types/ingestion.py

@@ -1,8 +0,0 @@
-from enum import Enum
-
-
-class IngestionJobStatus(Enum):
-    QUEUED = "queued"
-    RUNNING = "running"
-    COMPLETED = "completed"
-    FAILED = "failed"