frogml-core 0.0.113__py3-none-any.whl → 0.0.115__py3-none-any.whl

frogml_core/llmops/provider/openai/client.py

@@ -1,126 +0,0 @@
-import json
-import os
-from typing import Dict, Iterable, List, Optional, Union
-from urllib.parse import urljoin
-
-import requests
-from dacite import Config, from_dict
-from requests import Response
-from typing_extensions import Literal
-
-from frogml_core.exceptions.frogml_external_exception import FrogmlExternalException
-from frogml_core.llmops.generation._steaming import BaseSSEDecoder  # noqa
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion import (
-    ChatCompletion,
-)
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_chunk import (
-    ChatCompletionChunk,
-)
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_tool_choice_option_param import (
-    ChatCompletionToolChoiceOptionParam,
-)
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion_tool_param import (
-    ChatCompletionToolParam,
-)
-from frogml_core.llmops.generation.streaming import ChatCompletionStream
-from frogml_core.utils.dict_utils import remove_none_value_keys
-
-
-class OpenAIChatCompletionStream(
-    BaseSSEDecoder[ChatCompletionChunk], ChatCompletionStream
-):
-    def __init__(self, response: requests.Response):
-        super().__init__(response=response, parse_to=ChatCompletionChunk)
-
-
-class OpenAIClient:
-    base_url: str
-
-    def __init__(self):
-        self.base_url: str = os.environ.get(
-            "_QWAK_OPEN_AI_BASE_URL", "https://api.openai.com"
-        )
-
-    def invoke_chat_completion(
-        self,
-        api_key: str,
-        model: str,
-        messages: List[Dict],
-        frequency_penalty: Optional[float] = None,
-        logit_bias: Optional[Dict[str, int]] = None,
-        logprobs: Optional[bool] = None,
-        max_tokens: Optional[int] = None,
-        n: Optional[int] = None,
-        presence_penalty: Optional[float] = None,
-        response_format: Literal["text", "json_object"] = None,
-        seed: Optional[int] = None,
-        stop: Union[Optional[str], List[str]] = None,
-        stream: Optional[bool] = False,
-        temperature: Optional[float] = None,
-        top_logprobs: Optional[int] = None,
-        top_p: Optional[float] = None,
-        user: Optional[str] = None,
-        tool_choice: Optional[ChatCompletionToolChoiceOptionParam] = None,
-        tools: Iterable[ChatCompletionToolParam] = None,
-        extra_headers: Optional[Dict[str, str]] = None,
-        extra_body: Optional[Dict[str, str]] = None,
-        timeout_seconds: Optional[float] = None,
-    ) -> Union[ChatCompletion, ChatCompletionStream]:
-        url: str = urljoin(self.base_url, "v1/chat/completions")
-        headers: Dict[str, str] = {
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}",
-        }
-        body = {
-            "messages": messages,
-            "model": model,
-            "frequency_penalty": frequency_penalty,
-            "logit_bias": logit_bias,
-            "logprobs": logprobs,
-            "max_tokens": max_tokens,
-            "n": n,
-            "presence_penalty": presence_penalty,
-            "response_format": {"type": response_format} if response_format else None,
-            "seed": seed,
-            "stop": stop,
-            "temperature": temperature,
-            "tool_choice": tool_choice if tools else None,
-            "tools": tools if tools else None,
-            "top_logprobs": top_logprobs,
-            "top_p": top_p,
-            "user": user,
-            "stream": stream if stream else None,
-        }
-        body = remove_none_value_keys(body)
-
-        if extra_headers:
-            headers.update(extra_headers)
-
-        if extra_body:
-            body.update(extra_body)
-
-        http_request_timeout_seconds: float = (
-            timeout_seconds
-            if timeout_seconds
-            else float(os.environ.get("_QWAK_OPEN_AI_TIMEOUT_SECONDS", 60.0))
-        )
-        response: Response = requests.post(
-            url=url,
-            data=json.dumps(body),
-            headers=headers,
-            stream=stream,
-            timeout=http_request_timeout_seconds,
-        )
-
-        try:
-            response.raise_for_status()
-        except requests.exceptions.HTTPError as e:
-            raise FrogmlExternalException(message=e.response.content.decode())
-        if stream:
-            return OpenAIChatCompletionStream(response=response)
-        else:
-            return from_dict(
-                data_class=ChatCompletion,
-                data=response.json(),
-                config=Config(check_types=False),
-            )

frogml_core/llmops/provider/openai/provider.py

@@ -1,93 +0,0 @@
-import random
-from typing import Dict, List, Optional, Union
-
-from frogml_core.clients.integration_management.integration_utils import (
-    IntegrationUtils,
-)
-from frogml_core.clients.integration_management.openai.openai_system_secret import (
-    OpenAIApiKeySystemSecret,
-)
-from frogml_core.exceptions import FrogmlException
-from frogml_core.llmops.generation.chat.openai.types.chat.chat_completion import (
-    ChatCompletion,
-)
-from frogml_core.llmops.generation.streaming import ChatCompletionStream
-from frogml_core.llmops.model.descriptor import OpenAIChat
-from frogml_core.llmops.prompt.chat.message import (
-    AIMessage,
-    BaseMessage,
-    HumanMessage,
-    SystemMessage,
-)
-from frogml_core.llmops.prompt.chat.value import ChatPromptValue
-from frogml_core.llmops.provider.openai.client import OpenAIClient
-
-
-class OpenAIProvider:
-    client: OpenAIClient
-
-    def __init__(self):
-        self.client = OpenAIClient()
-
-    def _get_random_openai_api_key(self) -> Optional[str]:
-        openai_api_keys: List[OpenAIApiKeySystemSecret] = (
-            IntegrationUtils().get_openai_api_keys()
-        )
-        if len(openai_api_keys) == 0:
-            return None
-
-        return random.choice(openai_api_keys).get_api_key()  # nosec
-
-    def _chat_value_to_json(self, chat_prompt_value: ChatPromptValue) -> List[Dict]:
-        return [self._map_message(m) for m in chat_prompt_value.messages]
-
-    def _map_message(self, message: BaseMessage) -> Dict[str, str]:
-        role: str
-        content: str = message.content
-
-        if isinstance(message, AIMessage):
-            role = "assistant"
-        elif isinstance(message, SystemMessage):
-            role = "system"
-        elif isinstance(message, HumanMessage):
-            role = "user"
-        else:
-            raise FrogmlException(f"Can't handle message of type: {repr(message)}")
-
-        return {"role": role, "content": content}
-
-    def create_chat_completion(
-        self,
-        chat_prompt_value: ChatPromptValue,
-        chat_model_descriptor: OpenAIChat,
-        stream: bool = False,
-    ) -> Union[ChatCompletion, ChatCompletionStream]:
-        openai_api_key: Optional[str] = self._get_random_openai_api_key()
-        if not openai_api_key:
-            raise FrogmlException(
-                "Could not find Open AI integration, Please create one."
-            )
-
-        d = chat_model_descriptor
-
-        return self.client.invoke_chat_completion(
-            stream=stream,
-            api_key=openai_api_key,
-            model=d.model_id,
-            messages=self._chat_value_to_json(chat_prompt_value),
-            frequency_penalty=d.frequency_penalty,
-            logit_bias=d.logit_bias,
-            logprobs=d.logprobs,
-            max_tokens=d.max_tokens,
-            n=d.n,
-            presence_penalty=d.presence_penalty,
-            response_format=d.response_format,
-            seed=d.seed,
-            stop=d.stop,
-            temperature=d.temperature,
-            top_logprobs=d.top_logprobs,
-            top_p=d.top_p,
-            user=d.user,
-            tool_choice=d.tool_choice,
-            tools=d.tools,
-        )

frogml_core/vector_store/__init__.py

@@ -1,4 +0,0 @@
-from .client import VectorStoreClient
-from .collection import Collection
-
-__all__ = ["VectorStoreClient", "Collection"]

frogml_core/vector_store/client.py

@@ -1,151 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, List, Optional
-
-from typeguard import typechecked
-
-from frogml_proto.qwak.vectors.v1.collection.collection_pb2 import (
-    VectorCollectionDefinition,
-    VectorCollectionMetric,
-)
-from frogml_core.clients.vector_store import VectorManagementClient, VectorServingClient
-from frogml_core.exceptions import FrogmlException
-from frogml_core.vector_store.collection import Collection
-
-
-class VectorStoreClient:
-    """
-    The `VectorStoreClient` class is designed to interact with Qwak's vector store service. A vector store is a
-    specialized storage service optimized for storing and querying high-dimensional vectors. These vectors can be
-    representations extracted from images, text, or any other type of data.
-    Vector stores are often used in machine learning applications for operations such as nearest neighbor searches,
-    similarity measures, and clustering.
-    """
-
-    _vector_management_client: VectorManagementClient
-
-    _metric_dict: Dict[str, VectorCollectionMetric] = {
-        "l2_squared": VectorCollectionMetric.COLLECTION_METRIC_L2_SQUARED,
-        "cosine": VectorCollectionMetric.COLLECTION_METRIC_COSINE,
-        "dot_product": VectorCollectionMetric.COLLECTION_METRIC_DOT_PRODUCT,
-        "l1": VectorCollectionMetric.COLLECTION_METRIC_L1,
-        "hamming": VectorCollectionMetric.COLLECTION_METRIC_HAMMING,
-    }
-
-    def __init__(self, edge_services_url: Optional[str] = None):
-        """
-        Initializes a `VectorStoreClient` client object to interact with Qwak's vector store service
-        """
-        self._vector_management_client = VectorManagementClient()
-        self._vector_serving_client = VectorServingClient(
-            edge_services_url=edge_services_url
-        )
-
-    @typechecked
-    def create_collection(
-        self,
-        name: str,
-        dimension: int,
-        description: str = None,
-        metric: str = "l2_squared",
-        vectorizer: Optional[str] = None,
-        multi_tenant: bool = False,
-    ) -> Collection:
-        """
-        Creates a new collection with the given name and dimension.
-        Each collection in the vector store can be thought of as a table or a namespace that holds vectors of a
-        particular dimension. For example, you may have a collection named "image_embeddings" where each vector is of
-        dimension 512, representing an embedding of an image.
-
-        Parameters:
-            name (str): The name of the collection to create.
-            dimension (int): The dimension of the vectors in the collection.
-            description (str, optional): A human-readable description of the collection.
-            metric (int): The distance metric used by the collection when executing similarity search
-            vectorizer (str): an optional Qwak model used for vector embedding in case natural input is provided
-            multi_tenant (bool): Whether this collection has multitenancy. defaults to False and cannot be changed
-                                after the collection is created
-
-        Returns:
-            Collection: The Collection object which is used to interact with the vector store.
-
-        Raises:
-            QwakException: if any of the collection creation parameters are invalid
-        """
-        proto_definition = self._vector_management_client.create_collection(
-            name=name,
-            description=description,
-            dimension=dimension,
-            metric=self._metrics_mapper(metric),
-            vectorizer=vectorizer,
-            multi_tenant=multi_tenant,
-        ).definition
-
-        return self._collection_from_definition(proto_definition)
-
-    @typechecked
-    def delete_collection(self, name: str) -> None:
-        """
-        Deletes a collection with the given name.
-
-        Parameters:
-            name (str): The name of the collection to delete.
-
-        Raises:
-            QwakException: in case the deletion failed for any reason
-        """
-        self._vector_management_client.delete_collection_by_name(name=name)
-
-    @typechecked
-    def get_collection_by_name(self, name: str) -> Collection:
-        """
-        Fetches a collection by its name.
-
-        Parameters:
-            name (str): The name of the collection to fetch.
-
-        Returns:
-            collection: a Collection object
-
-        Raises:
-            QwakException: in case the collection doesn't exist
-        """
-        proto_definition = self._vector_management_client.get_collection_by_name(
-            name
-        ).definition
-        return self._collection_from_definition(proto_definition)
-
-    def list_collections(self) -> List[Collection]:
-        """
-        Lists all available collections in the current Qwak account
-
-         Returns:
-             list: A list of Collection objects.
-        """
-        proto_definitions = self._vector_management_client.list_collections()
-        return [
-            self._collection_from_definition(collection.definition)
-            for collection in proto_definitions
-        ]
-
-    def _collection_from_definition(
-        self, collection_definition: VectorCollectionDefinition
-    ):
-        return Collection(
-            id=collection_definition.id,
-            name=collection_definition.collection_spec.name,
-            metric=collection_definition.collection_spec.metric,
-            dimension=collection_definition.collection_spec.dimension,
-            description=collection_definition.collection_spec.description,
-            vectorizer=collection_definition.collection_spec.vectorizer.qwak_model_name,
-            vector_serving_client=self._vector_serving_client,
-            muli_tenant=collection_definition.collection_spec.multi_tenancy_enabled,
-        )
-
-    def _metrics_mapper(self, metric: str) -> VectorCollectionMetric:
-        if metric in self._metric_dict:
-            return self._metric_dict[metric]
-
-        raise FrogmlException(
-            f"Unsupported metric type '{metric}'. Currently supported metrics are {list(self._metric_dict.keys())}"
-        )