seekrai 0.0.1__py3-none-any.whl

seekrai/legacy/finetune.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any, Dict, List
+
+import seekrai
+from seekrai.legacy.base import API_KEY_WARNING, deprecated
+
+
+class Finetune:
+    @classmethod
+    @deprecated  # type: ignore
+    def create(
+        cls,
+        training_file: str,  # training file_id
+        model: str,
+        n_epochs: int = 1,
+        n_checkpoints: int | None = 1,
+        batch_size: int | None = 32,
+        learning_rate: float = 0.00001,
+        suffix: (
+            str | None
+        ) = None,  # resulting finetuned model name will include the suffix
+        estimate_price: bool = False,
+        wandb_api_key: str | None = None,
+        confirm_inputs: bool = False,
+    ):
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        if estimate_price:
+            raise ValueError("Price estimation is not supported in version >= 1.0.1")
+
+        if confirm_inputs:
+            raise ValueError("Input confirmation is not supported in version >= 1.0.1")
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.fine_tuning.create(
+            training_file=training_file,
+            model=model,
+            n_epochs=n_epochs,
+            n_checkpoints=n_checkpoints,
+            batch_size=batch_size,
+            learning_rate=learning_rate,
+            suffix=suffix,
+            wandb_api_key=wandb_api_key,
+        ).model_dump()
+
+    @classmethod
+    @deprecated  # type: ignore
+    def list(
+        cls,
+    ) -> Dict[str, Any]:
+        """Legacy finetuning list function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.fine_tuning.list().model_dump()
+
+    @classmethod
+    @deprecated  # type: ignore
+    def retrieve(
+        cls,
+        fine_tune_id: str,
+    ) -> Dict[str, Any]:
+        """Legacy finetuning retrieve function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.fine_tuning.retrieve(id=fine_tune_id).model_dump()
+
+    @classmethod
+    @deprecated  # type: ignore
+    def cancel(
+        cls,
+        fine_tune_id: str,
+    ) -> Dict[str, Any]:
+        """Legacy finetuning cancel function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.fine_tuning.cancel(id=fine_tune_id).model_dump()
+
+    @classmethod
+    @deprecated  # type: ignore
+    def list_events(
+        cls,
+        fine_tune_id: str,
+    ) -> Dict[str, Any]:
+        """Legacy finetuning list events function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.fine_tuning.list_events(id=fine_tune_id).model_dump()
+
+    @classmethod
+    @deprecated  # type: ignore
+    def get_checkpoints(
+        cls,
+        fine_tune_id: str,
+    ) -> List[Any]:
+        """Legacy finetuning get checkpoints function."""
+
+        finetune_events = list(cls.retrieve(fine_tune_id=fine_tune_id)["events"])
+
+        saved_events = [i for i in finetune_events if i["type"] in ["CHECKPOINT_SAVE"]]
+
+        return saved_events
+
+    @classmethod
+    @deprecated  # type: ignore
+    def get_job_status(cls, fine_tune_id: str) -> str:
+        """Legacy finetuning get job status function."""
+        return str(cls.retrieve(fine_tune_id=fine_tune_id)["status"])
+
+    @classmethod
+    @deprecated  # type: ignore
+    def is_final_model_available(cls, fine_tune_id: str) -> bool:
+        """Legacy finetuning is final model available function."""
+
+        finetune_events = list(cls.retrieve(fine_tune_id=fine_tune_id)["events"])
+
+        for i in finetune_events:
+            if i["type"] in ["JOB_COMPLETE", "JOB_ERROR"]:
+                if i["checkpoint_path"] != "":
+                    return False
+                else:
+                    return True
+        return False
+
+    @classmethod
+    @deprecated  # type: ignore
+    def download(
+        cls,
+        fine_tune_id: str,
+        output: str | None = None,
+        step: int = -1,
+    ) -> Dict[str, Any]:
+        """Legacy finetuning download function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.fine_tuning.download(
+            id=fine_tune_id, output=output, checkpoint_step=step
+        ).model_dump()

seekrai/legacy/images.py

@@ -0,0 +1,25 @@
+import warnings
+from typing import Any, Dict
+
+import seekrai
+from seekrai.legacy.base import API_KEY_WARNING, deprecated
+
+
+class Image:
+    @classmethod
+    @deprecated  # type: ignore
+    def create(
+        cls,
+        prompt: str,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Legacy image function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return client.images.generate(prompt=prompt, **kwargs).model_dump()

seekrai/legacy/models.py

@@ -0,0 +1,44 @@
+import warnings
+from typing import Any, Dict, List
+
+import seekrai
+from seekrai.legacy.base import API_KEY_WARNING, deprecated
+
+
+class Models:
+    @classmethod
+    @deprecated  # type: ignore
+    def list(
+        cls,
+    ) -> List[Dict[str, Any]]:
+        """Legacy model list function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        return [item.model_dump() for item in client.models.list()]
+
+    @classmethod
+    @deprecated  # type: ignore
+    def info(
+        cls,
+        model: str,
+    ) -> Dict[str, Any]:
+        """Legacy model info function."""
+
+        api_key = None
+        if seekrai.api_key:
+            warnings.warn(API_KEY_WARNING)
+            api_key = seekrai.api_key
+
+        client = seekrai.SeekrFlow(api_key=api_key)
+
+        model_list = client.models.list()
+
+        for item in model_list:
+            if item.id == model:
+                return item.model_dump()

seekrai/resources/__init__.py

@@ -0,0 +1,25 @@
+from seekrai.resources.chat import AsyncChat, Chat
+from seekrai.resources.completions import AsyncCompletions, Completions
+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.models import AsyncModels, Models
+
+
+__all__ = [
+    "AsyncCompletions",
+    "Completions",
+    "AsyncChat",
+    "Chat",
+    "AsyncEmbeddings",
+    "Embeddings",
+    "AsyncFineTuning",
+    "FineTuning",
+    "AsyncFiles",
+    "Files",
+    "AsyncImages",
+    "Images",
+    "AsyncModels",
+    "Models",
+]

seekrai/resources/chat/__init__.py

@@ -0,0 +1,24 @@
+from functools import cached_property
+
+from seekrai.resources.chat.completions import AsyncChatCompletions, ChatCompletions
+from seekrai.types import (
+    SeekrFlowClient,
+)
+
+
+class Chat:
+    def __init__(self, client: SeekrFlowClient) -> None:
+        self._client = client
+
+    @cached_property
+    def completions(self) -> ChatCompletions:
+        return ChatCompletions(self._client)
+
+
+class AsyncChat:
+    def __init__(self, client: SeekrFlowClient) -> None:
+        self._client = client
+
+    @cached_property
+    def completions(self) -> AsyncChatCompletions:
+        return AsyncChatCompletions(self._client)

seekrai/resources/chat/completions.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+from typing import Any, AsyncGenerator, Dict, Iterator, List
+
+from seekrai.abstract import api_requestor
+from seekrai.seekrflow_response import SeekrFlowResponse
+from seekrai.types import (
+    ChatCompletionChunk,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    SeekrFlowClient,
+    SeekrFlowRequest,
+)
+
+
+class ChatCompletions:
+    def __init__(self, client: SeekrFlowClient) -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        messages: List[Dict[str, str]],
+        model: str,
+        max_tokens: int | None = None,
+        stop: List[str] | None = None,
+        temperature: float = 0.7,
+        top_p: float = 1,
+        top_k: int = 5,
+        repetition_penalty: float = 1,
+        stream: bool = False,
+        logprobs: int = 0,
+        echo: bool = False,
+        n: int = 1,
+        safety_model: str | None = None,
+        response_format: Dict[str, str | Dict[str, Any]] | None = None,
+        tools: Dict[str, str | Dict[str, Any]] | None = None,
+        tool_choice: str | Dict[str, str | Dict[str, str]] | None = None,
+    ) -> ChatCompletionResponse | Iterator[ChatCompletionChunk]:
+        """
+        Method to generate completions based on a given prompt using a specified model.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages in the format
+                `[{"role": seekrai.types.chat_completions.MessageRole, "content": TEXT}, ...]`
+            model (str): The name of the model to query.
+            max_tokens (int, optional): The maximum number of tokens to generate.
+                Defaults to 512.
+            stop (List[str], optional): List of strings at which to stop generation.
+                Defaults to None.
+            temperature (float, optional): A decimal number that determines the degree of randomness in the response.
+                Defaults to None.
+            top_p (float, optional): The top_p (nucleus) parameter is used to dynamically adjust the number
+                    of choices for each predicted token based on the cumulative probabilities.
+                Defaults to None.
+            top_k (int, optional): The top_k parameter is used to limit the number of choices for the
+                    next predicted word or token.
+                Defaults to None.
+            repetition_penalty (float, optional): A number that controls the diversity of generated text
+                    by reducing the likelihood of repeated sequences. Higher values decrease repetition.
+                Defaults to None.
+            stream (bool, optional): Flag indicating whether to stream the generated completions.
+                Defaults to False.
+            logprobs (int, optional): Number of top-k logprobs to return
+                Defaults to None.
+            echo (bool, optional): Echo prompt in output. Can be used with logprobs to return prompt logprobs.
+                Defaults to None.
+            n (int, optional): Number of completions to generate. Setting to None will return a single generation.
+                Defaults to None.
+            safety_model (str, optional): A moderation model to validate tokens. Choice between available moderation
+                    models found [here](https://docs.seekrflow.ai/docs/inference-models#moderation-models).
+                Defaults to None.
+            response_format (Dict[str, Any], optional): An object specifying the format that the model must output.
+                Defaults to None.
+            tools (Dict[str, str | Dict[str, str | Dict[str, Any]]], optional): A list of tools the model may call.
+                    Currently, only functions are supported as a tool.
+                    Use this to provide a list of functions the model may generate JSON inputs for.
+                Defaults to None
+            tool_choice: Controls which (if any) function is called by the model. auto means the model can pick
+                    between generating a message or calling a function. Specifying a particular function
+                    via {"type": "function", "function": {"name": "my_function"}} forces the model to call that function.
+                    Sets to `auto` if None.
+                Defaults to None.
+
+        Returns:
+            ChatCompletionResponse | Iterator[ChatCompletionChunk]: Object containing the completions
+            or an iterator over completion chunks.
+        """
+
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        parameter_payload = ChatCompletionRequest(
+            model=model,
+            messages=messages,
+            top_p=top_p,
+            top_k=top_k,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stop=stop,
+            repetition_penalty=repetition_penalty,
+            stream=stream,
+            logprobs=logprobs,
+            echo=echo,
+            n=n,
+            safety_model=safety_model,
+            response_format=response_format,
+            tools=tools,
+            tool_choice=tool_choice,
+        ).model_dump()
+
+        response, _, _ = requestor.request(
+            options=SeekrFlowRequest(
+                method="POST",
+                url="chat/completions",
+                params=parameter_payload,
+            ),
+            stream=stream,
+        )
+
+        if stream:
+            # must be an iterator
+            assert not isinstance(response, SeekrFlowResponse)
+            return (ChatCompletionChunk(**line.data) for line in response)
+        assert isinstance(response, SeekrFlowResponse)
+        return ChatCompletionResponse(**response.data)
+
+
+class AsyncChatCompletions:
+    def __init__(self, client: SeekrFlowClient) -> None:
+        self._client = client
+
+    async def create(
+        self,
+        *,
+        messages: List[Dict[str, str]],
+        model: str,
+        max_tokens: int | None = None,
+        stop: List[str] | None = None,
+        temperature: float | None = None,
+        top_p: float | None = None,
+        top_k: int | None = None,
+        repetition_penalty: float | None = None,
+        stream: bool = False,
+        logprobs: int | None = None,
+        echo: bool | None = None,
+        n: int | None = None,
+        safety_model: str | None = None,
+        response_format: Dict[str, Any] | None = None,
+        # tools: Dict[str, str | Dict[str, str | Dict[str, Any]]] | None = None,
+        # tool_choice: str | Dict[str, str | Dict[str, str]] | None = None,
+    ) -> AsyncGenerator[ChatCompletionChunk, None] | ChatCompletionResponse:
+        """
+        Async method to generate completions based on a given prompt using a specified model.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages in the format
+                `[{"role": seekrai.types.chat_completions.MessageRole, "content": TEXT}, ...]`
+            model (str): The name of the model to query.
+            max_tokens (int, optional): The maximum number of tokens to generate.
+                Defaults to 512.
+            stop (List[str], optional): List of strings at which to stop generation.
+                Defaults to None.
+            temperature (float, optional): A decimal number that determines the degree of randomness in the response.
+                Defaults to None.
+            top_p (float, optional): The top_p (nucleus) parameter is used to dynamically adjust the number
+                    of choices for each predicted token based on the cumulative probabilities.
+                Defaults to None.
+            top_k (int, optional): The top_k parameter is used to limit the number of choices for the
+                    next predicted word or token.
+                Defaults to None.
+            repetition_penalty (float, optional): A number that controls the diversity of generated text
+                    by reducing the likelihood of repeated sequences. Higher values decrease repetition.
+                Defaults to None.
+            stream (bool, optional): Flag indicating whether to stream the generated completions.
+                Defaults to False.
+            logprobs (int, optional): Number of top-k logprobs to return
+                Defaults to None.
+            echo (bool, optional): Echo prompt in output. Can be used with logprobs to return prompt logprobs.
+                Defaults to None.
+            n (int, optional): Number of completions to generate. Setting to None will return a single generation.
+                Defaults to None.
+            safety_model (str, optional): A moderation model to validate tokens. Choice between available moderation
+                    models found [here](https://docs.seekrflow.ai/docs/inference-models#moderation-models).
+                Defaults to None.
+            response_format (Dict[str, Any], optional): An object specifying the format that the model must output.
+                Defaults to None.
+            tools (Dict[str, str | Dict[str, str | Dict[str, Any]]], optional): A list of tools the model may call.
+                    Currently, only functions are supported as a tool.
+                    Use this to provide a list of functions the model may generate JSON inputs for.
+                Defaults to None
+            tool_choice: Controls which (if any) function is called by the model. auto means the model can pick
+                    between generating a message or calling a function. Specifying a particular function
+                    via {"type": "function", "function": {"name": "my_function"}} forces the model to call that function.
+                    Sets to `auto` if None.
+                Defaults to None.
+
+        Returns:
+            AsyncGenerator[ChatCompletionChunk, None] | ChatCompletionResponse: Object containing the completions
+            or an iterator over completion chunks.
+        """
+
+        requestor = api_requestor.APIRequestor(
+            client=self._client,
+        )
+
+        parameter_payload = ChatCompletionRequest(
+            model=model,
+            messages=messages,
+            top_p=top_p,
+            top_k=top_k,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            stop=stop,
+            repetition_penalty=repetition_penalty,
+            stream=stream,
+            logprobs=logprobs,
+            echo=echo,
+            n=n,
+            safety_model=safety_model,
+            response_format=response_format,
+            # tools=tools,
+            # tool_choice=tool_choice,
+        ).model_dump()
+
+        response, _, _ = await requestor.arequest(
+            options=SeekrFlowRequest(
+                method="POST",
+                url="chat/completions",
+                params=parameter_payload,
+            ),
+            stream=stream,
+        )
+
+        if stream:
+            # must be an iterator
+            assert not isinstance(response, SeekrFlowResponse)
+            return (ChatCompletionChunk(**line.data) async for line in response)
+        assert isinstance(response, SeekrFlowResponse)
+        return ChatCompletionResponse(**response.data)