truefoundry 0.5.0rc7__py3-none-any.whl → 0.5.1rc2__py3-none-any.whl

truefoundry/langchain/truefoundry_chat.py

@@ -1,130 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from langchain.chat_models.base import SimpleChatModel
-from langchain.pydantic_v1 import Extra, Field, root_validator
-from langchain.schema.messages import (
-    AIMessage,
-    BaseMessage,
-    ChatMessage,
-    HumanMessage,
-    SystemMessage,
-)
-
-from truefoundry.common.request_utils import requests_retry_session
-from truefoundry.langchain.utils import (
-    validate_tfy_environment,
-)
-from truefoundry.logger import logger
-
-
-class TrueFoundryChat(SimpleChatModel):
-    """`TrueFoundry LLM Gateway` chat models API.
-
-    To use, you must have the environment variable ``TFY_API_KEY`` set with your API key and ``TFY_HOST`` set with your host or pass it as a named parameter to the constructor.
-    """
-
-    model: str = Field(description="The model to use for chat.")
-    """The model to use for chat."""
-    tfy_llm_gateway_url: Optional[str] = Field(default=None)
-    """TrueFoundry LLM Gateway endpoint URL. Automatically inferred from env var `TFY_LLM_GATEWAY_URL` if not provided."""
-    tfy_api_key: Optional[str] = Field(default=None)
-    """TrueFoundry API Key. Automatically inferred from env var `TFY_API_KEY` if not provided."""
-    model_parameters: Optional[dict] = Field(default_factory=dict)
-    """Model parameters"""
-    request_timeout: int = Field(default=30)
-    """The timeout for the request in seconds."""
-    max_retries: int = Field(default=5)
-    """The number of retries for HTTP requests."""
-    retry_backoff_factor: float = Field(default=0.3)
-    """The backoff factor for exponential backoff during retries."""
-    system_prompt: str = Field(default="You are a AI assistant")
-
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-        allow_population_by_field_name = True
-
-    @root_validator()
-    def validate_environment(cls, values: Dict) -> Dict:
-        values = validate_tfy_environment(values)
-        if not values["tfy_api_key"]:
-            raise ValueError(
-                "Did not find `tfy_api_key`, please add an environment variable"
-                " `TFY_API_KEY` which contains it, or pass"
-                "  `tfy_api_key` as a named parameter."
-            )
-        if not values["tfy_llm_gateway_url"]:
-            raise ValueError(
-                "Did not find `tfy_llm_gateway_url`, please add an environment variable"
-                " `TFY_LLM_GATEWAY_URL` which contains it, or pass"
-                "  `tfy_llm_gateway_url` as a named parameter."
-            )
-        return values
-
-    @property
-    def _llm_type(self) -> str:
-        """Return type of chat model."""
-        return "truefoundry-chat"
-
-    def _call(
-        self,
-        messages: List[BaseMessage],
-        stop: Optional[List[str]] = None,
-        **kwargs: Any,
-    ) -> str:
-        if len(messages) == 0:
-            raise ValueError("No messages provided to chat.")
-
-        if not isinstance(messages[0], SystemMessage):
-            messages.insert(0, SystemMessage(content=self.system_prompt))
-
-        message_dicts = [
-            TrueFoundryChat._convert_message_to_dict(message) for message in messages
-        ]
-
-        payload = {**self.model_parameters} if self.model_parameters else {}
-
-        if stop:
-            payload["stop_sequences"] = stop
-
-        payload["messages"] = message_dicts
-        payload["model"] = self.model
-
-        session = requests_retry_session(
-            retries=self.max_retries, backoff_factor=self.retry_backoff_factor
-        )
-
-        url = f"{self.tfy_llm_gateway_url}/openai/chat/completions"
-        logger.debug(f"Chat using - model: {self.model} at endpoint: {url}")
-        response = session.post(
-            url=url,
-            json=payload,
-            headers={
-                "Authorization": f"Bearer {self.tfy_api_key}",
-            },
-            timeout=self.request_timeout,
-        )
-        response.raise_for_status()
-        output = response.json()
-        return output["choices"][0]["message"]["content"]
-
-    @staticmethod
-    def _convert_message_to_dict(message: BaseMessage) -> dict:
-        if isinstance(message, ChatMessage):
-            message_dict = {"role": message.role, "content": message.content}
-        elif isinstance(message, HumanMessage):
-            message_dict = {"role": "user", "content": message.content}
-        elif isinstance(message, AIMessage):
-            message_dict = {"role": "assistant", "content": message.content}
-        elif isinstance(message, SystemMessage):
-            message_dict = {"role": "system", "content": message.content}
-        else:
-            raise ValueError(f"Got unknown message type: {message}")
-        if message.additional_kwargs:
-            logger.debug(
-                "Additional message arguments are unsupported by TrueFoundry LLM Gateway "
-                " and will be ignored: %s",
-                message.additional_kwargs,
-            )
-        return message_dict

truefoundry/langchain/truefoundry_embeddings.py

@@ -1,171 +0,0 @@
-import concurrent.futures
-import math
-from typing import Dict, List, Optional
-
-import tqdm
-from langchain.embeddings.base import Embeddings
-from langchain.pydantic_v1 import BaseModel, Extra, Field, root_validator
-
-from truefoundry.common.request_utils import requests_retry_session
-from truefoundry.langchain.utils import (
-    validate_tfy_environment,
-)
-from truefoundry.logger import logger
-
-EMBEDDER_BATCH_SIZE = 32
-PARALLEL_WORKERS = 4
-
-
-class TrueFoundryEmbeddings(BaseModel, Embeddings):
-    """`TrueFoundry LLM Gateway` embedding models API.
-
-    To use, you must have the environment variable ``TFY_API_KEY`` set with your API key and ``TFY_HOST`` set with your host or pass it
-    as a named parameter to the constructor.
-    """
-
-    model: str = Field(description="The model to use for embedding.")
-    """The model to use for embedding."""
-    tfy_llm_gateway_url: Optional[str] = Field(default=None)
-    """TrueFoundry LLM Gateway endpoint URL. Automatically inferred from env var `TFY_LLM_GATEWAY_URL` if not provided."""
-    tfy_api_key: Optional[str] = Field(default=None)
-    """TrueFoundry API Key. Automatically inferred from env var `TFY_API_KEY` if not provided."""
-    model_parameters: Optional[dict] = Field(default_factory=dict)
-    """Model parameters"""
-    request_timeout: int = Field(default=30)
-    """The timeout for the request in seconds."""
-    max_retries: int = Field(default=5)
-    """The number of retries for HTTP requests."""
-    retry_backoff_factor: float = Field(default=0.3)
-    """The backoff factor for exponential backoff during retries."""
-    batch_size: int = Field(default=EMBEDDER_BATCH_SIZE)
-    """The batch size to use for embedding."""
-    parallel_workers: int = Field(default=PARALLEL_WORKERS)
-    """The number of parallel workers to use for embedding."""
-
-    __private_attributes__ = {"_executor"}
-
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-        allow_population_by_field_name = True
-
-    @root_validator()
-    def validate_environment(cls, values: Dict) -> Dict:
-        values = validate_tfy_environment(values)
-        if not values["tfy_api_key"]:
-            raise ValueError(
-                "Did not find `tfy_api_key`, please add an environment variable"
-                " `TFY_API_KEY` which contains it, or pass"
-                "  `tfy_api_key` as a named parameter."
-            )
-        if not values["tfy_llm_gateway_url"]:
-            raise ValueError(
-                "Did not find `tfy_llm_gateway_url`, please add an environment variable"
-                " `TFY_LLM_GATEWAY_URL` which contains it, or pass"
-                "  `tfy_llm_gateway_url` as a named parameter."
-            )
-        return values
-
-    def _init_private_attributes(self):
-        self._executor = concurrent.futures.ThreadPoolExecutor(
-            max_workers=self.parallel_workers
-        )
-
-    @property
-    def _llm_type(self) -> str:
-        """Return type of embedding model."""
-        return "truefoundry-embeddings"
-
-    def __del__(self):
-        """
-        Destructor method to clean up the executor when the object is deleted.
-
-        Returns:
-            None
-        """
-        self._executor.shutdown()
-
-    def _remote_embed(self, texts, query_mode=False):
-        """
-        Perform remote embedding using a HTTP POST request to a designated endpoint.
-
-        Args:
-            texts (List[str]): A list of text strings to be embedded.
-            query_mode (bool): A flag to indicate if running in query mode or in embed mode (indexing).
-        Returns:
-            List[List[float]]: A list of embedded representations of the input texts.
-        """
-        session = requests_retry_session(
-            retries=self.max_retries, backoff_factor=self.retry_backoff_factor
-        )
-
-        payload = {
-            "input": texts,
-            "model": self.model,
-        }
-
-        url = f"{self.tfy_llm_gateway_url}/openai/embeddings"
-        logger.debug(
-            f"Embedding using - model: {self.model} at endpoint: {url}, for {len(texts)} texts"
-        )
-        response = session.post(
-            url=url,
-            json=payload,
-            headers={
-                "Authorization": f"Bearer {self.tfy_api_key}",
-            },
-            timeout=self.request_timeout,
-        )
-        response.raise_for_status()
-        output = response.json()
-        return [data["embedding"] for data in output["data"]]
-
-    def _embed(self, texts: List[str], query_mode: bool):
-        """
-        Perform embedding on a list of texts using remote embedding in chunks.
-
-        Args:
-            texts (List[str]): A list of text strings to be embedded.
-            query_mode (bool): A flag to indicate if running in query mode or in embed mode (indexing).
-        Returns:
-            List[List[float]]: A list of embedded representations of the input texts.
-        """
-        embeddings = []
-
-        def _feeder():
-            for i in range(0, len(texts), self.batch_size):
-                chunk = texts[i : i + self.batch_size]
-                yield chunk
-
-        embeddings = list(
-            tqdm.tqdm(
-                self._executor.map(self._remote_embed, _feeder()),
-                total=int(math.ceil(len(texts) / self.batch_size)),
-            )
-        )
-        return [item for batch in embeddings for item in batch]
-
-    def embed_documents(self, texts: List[str]) -> List[List[float]]:
-        """
-        Embed a list of text documents.
-
-        Args:
-            texts (List[str]): A list of text documents to be embedded.
-
-        Returns:
-            List[List[float]]: A list of embedded representations of the input documents.
-        """
-        return self._embed(texts, query_mode=False)
-
-    def embed_query(self, text: str) -> List[float]:
-        """
-        Embed a query text.
-
-        Args:
-            text (str): The query text to be embedded.
-
-        Returns:
-            List[float]: The embedded representation of the input query text.
-        """
-        return self._embed([text], query_mode=True)[0]

truefoundry/langchain/truefoundry_llm.py

@@ -1,106 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-from langchain.llms.base import LLM
-from langchain.pydantic_v1 import Extra, Field, root_validator
-
-from truefoundry.common.request_utils import requests_retry_session
-from truefoundry.langchain.utils import (
-    validate_tfy_environment,
-)
-from truefoundry.logger import logger
-
-
-class TrueFoundryLLM(LLM):
-    """`TrueFoundry LLM Gateway` completion models API.
-
-    To use, you must have the environment variable ``TFY_API_KEY`` set with your API key and ``TFY_HOST`` set with your host or pass it as a named parameter to the constructor.
-    """
-
-    model: str = Field(description="The model to use for completion.")
-    """The model to use for completion."""
-    tfy_llm_gateway_url: Optional[str] = Field(default=None)
-    """TrueFoundry LLM Gateway endpoint URL. Automatically inferred from env var `TFY_LLM_GATEWAY_URL` if not provided."""
-    tfy_api_key: Optional[str] = Field(default=None)
-    """TrueFoundry API Key. Automatically inferred from env var `TFY_API_KEY` if not provided."""
-    model_parameters: Optional[dict] = Field(default_factory=dict)
-    """Model parameters"""
-    request_timeout: int = Field(default=30)
-    """The timeout for the request in seconds."""
-    max_retries: int = Field(default=5)
-    """The number of retries for HTTP requests."""
-    retry_backoff_factor: float = Field(default=0.3)
-    """The backoff factor for exponential backoff during retries."""
-
-    class Config:
-        """Configuration for this pydantic object."""
-
-        extra = Extra.forbid
-        allow_population_by_field_name = True
-
-    @root_validator()
-    def validate_environment(cls, values: Dict) -> Dict:
-        values = validate_tfy_environment(values)
-        if not values["tfy_api_key"]:
-            raise ValueError(
-                "Did not find `tfy_api_key`, please add an environment variable"
-                " `TFY_API_KEY` which contains it, or pass"
-                "  `tfy_api_key` as a named parameter."
-            )
-        if not values["tfy_llm_gateway_url"]:
-            raise ValueError(
-                "Did not find `tfy_llm_gateway_url`, please add an environment variable"
-                " `TFY_LLM_GATEWAY_URL` which contains it, or pass"
-                "  `tfy_llm_gateway_url` as a named parameter."
-            )
-        return values
-
-    @property
-    def _llm_type(self) -> str:
-        """Return type of llm model."""
-        return "truefoundry-llm"
-
-    def _call(
-        self,
-        prompt: str,
-        stop: Optional[List[str]] = None,
-        **kwargs: Any,
-    ) -> str:
-        """Call out to the deployed model
-
-        Args:
-            prompt: The prompt to pass into the model.
-            stop: Optional list of stop words to use when generating.
-
-        Returns:
-            The string generated by the model.
-
-        Example:
-            .. code-block:: python
-
-                response = model("I have a joke for you...")
-        """
-
-        payload = {**self.model_parameters} if self.model_parameters else {}
-        if stop:
-            payload["stop_sequences"] = stop
-
-        payload["prompt"] = prompt
-        payload["model"] = self.model
-
-        session = requests_retry_session(
-            retries=self.max_retries, backoff_factor=self.retry_backoff_factor
-        )
-
-        url = f"{self.tfy_llm_gateway_url}/openai/completions"
-        logger.debug(f"Completion using - model: {self.model} at endpoint: {url}")
-        response = session.post(
-            url=url,
-            json=payload,
-            headers={
-                "Authorization": f"Bearer {self.tfy_api_key}",
-            },
-            timeout=self.request_timeout,
-        )
-        response.raise_for_status()
-        output = response.json()
-        return output["choices"][0]["text"]

truefoundry/langchain/utils.py

@@ -1,44 +0,0 @@
-import os
-from typing import Dict, List, Optional
-from urllib.parse import urljoin
-
-from langchain.pydantic_v1 import BaseModel
-
-from truefoundry.deploy.lib.auth.servicefoundry_session import ServiceFoundrySession
-
-
-class ModelParameters(BaseModel):
-    temperature: Optional[float]
-    maximum_length: Optional[int]
-    top_p: Optional[float]
-    top_k: Optional[int]
-    repetition_penalty: Optional[float]
-    frequency_penalty: Optional[float]
-    presence_penalty: Optional[float]
-    stop_sequences: Optional[List[str]]
-
-
-def validate_tfy_environment(values: Dict):
-    gateway_url = values["tfy_llm_gateway_url"] or os.getenv("TFY_LLM_GATEWAY_URL")
-    api_key = values["tfy_api_key"] or os.getenv("TFY_API_KEY")
-
-    if gateway_url and api_key:
-        values["tfy_llm_gateway_url"] = gateway_url
-        values["tfy_api_key"] = api_key
-        return values
-
-    sfy_session = ServiceFoundrySession()
-    if not sfy_session:
-        raise Exception(
-            "Unauthenticated: Please login using truefoundry login --host <https://example-domain.com>"
-        )
-
-    if not gateway_url:
-        gateway_url = urljoin(sfy_session.base_url, "/api/llm")
-
-    if not api_key:
-        api_key = sfy_session.access_token
-
-    values["tfy_llm_gateway_url"] = gateway_url
-    values["tfy_api_key"] = api_key
-    return values

truefoundry/ml/log_types/artifacts/model_extras.py

@@ -1,48 +0,0 @@
-import enum
-from typing import List, Type, TypeVar
-
-from truefoundry.ml.autogen.client import (  # type: ignore[attr-defined]
-    ModelSchemaDto,
-)
-from truefoundry.ml.exceptions import MlFoundryException
-from truefoundry.pydantic_v1 import BaseModel
-
-T = TypeVar("T")
-
-
-class BaseEnum(enum.Enum):
-    @classmethod
-    def values(cls: Type[T]) -> List[T]:
-        return [member.value for member in cls]
-
-    @classmethod
-    def _missing_(cls: Type[T], value: object):
-        raise MlFoundryException(
-            f"Unknown value for type {cls.__name__}: {value}", status_code=400
-        )
-
-
-@enum.unique
-class CustomMetricValueType(str, BaseEnum):
-    FLOAT = "float"
-
-
-@enum.unique
-class CustomMetricType(str, BaseEnum):
-    METRIC = "metric"
-    PROJECTION = "projection"
-
-
-class CustomMetric(BaseModel):
-    class Config:
-        validate_assignment = True
-        use_enum_values = True
-        extra = "allow"
-
-    name: str
-    value_type: CustomMetricValueType
-    type: CustomMetricType
-
-
-class ModelSchema(ModelSchemaDto):
-    pass