langroid 0.59.0b3__py3-none-any.whl → 0.59.2__py3-none-any.whl

langroid/language_models/provider_params.py-e

@@ -1,153 +0,0 @@
-"""
-Provider-specific parameter configurations for various LLM providers.
-"""
-
-from typing import Any, Dict, Optional
-
-from pydantic import ConfigDict
-from pydantic_settings import BaseSettings
-
-# Constants
-LANGDB_BASE_URL = "https://api.us-east-1.langdb.ai"
-PORTKEY_BASE_URL = "https://api.portkey.ai"
-DUMMY_API_KEY = "xxx"
-
-
-class LangDBParams(BaseSettings):
-    """
-    Parameters specific to LangDB integration.
-    """
-
-    api_key: str = DUMMY_API_KEY
-    project_id: str = ""
-    label: Optional[str] = None
-    run_id: Optional[str] = None
-    thread_id: Optional[str] = None
-    base_url: str = LANGDB_BASE_URL
-
-    model_config = ConfigDict(env_prefix="LANGDB_")
-
-
-class PortkeyParams(BaseSettings):
-    """
-    Parameters specific to Portkey integration.
-
-    Portkey is an AI gateway that provides a unified API for multiple LLM providers,
-    with features like automatic retries, fallbacks, load balancing, and observability.
-
-    Example usage:
-        # Use Portkey with Anthropic
-        config = OpenAIGPTConfig(
-            chat_model="portkey/anthropic/claude-3-sonnet-20240229",
-            portkey_params=PortkeyParams(
-                api_key="your-portkey-api-key",
-                provider="anthropic"
-            )
-        )
-    """
-
-    api_key: str = DUMMY_API_KEY  # Portkey API key
-    provider: str = ""  # Required: e.g., "openai", "anthropic", "cohere", etc.
-    virtual_key: Optional[str] = None  # Optional: virtual key for the provider
-    trace_id: Optional[str] = None  # Optional: trace ID for request tracking
-    metadata: Optional[Dict[str, Any]] = None  # Optional: metadata for logging
-    retry: Optional[Dict[str, Any]] = None  # Optional: retry configuration
-    cache: Optional[Dict[str, Any]] = None  # Optional: cache configuration
-    cache_force_refresh: Optional[bool] = None  # Optional: force cache refresh
-    user: Optional[str] = None  # Optional: user identifier
-    organization: Optional[str] = None  # Optional: organization identifier
-    custom_headers: Optional[Dict[str, str]] = None  # Optional: additional headers
-    base_url: str = PORTKEY_BASE_URL
-
-    model_config = ConfigDict(env_prefix="PORTKEY_")
-
-    def get_headers(self) -> Dict[str, str]:
-        """Generate Portkey-specific headers from parameters."""
-        import json
-        import os
-
-        headers = {}
-
-        if self.api_key and self.api_key != DUMMY_API_KEY:
-            headers["x-portkey-api-key"] = self.api_key
-        else:
-            portkey_key = os.getenv("PORTKEY_API_KEY", "")
-            if portkey_key:
-                headers["x-portkey-api-key"] = portkey_key
-
-        if self.provider:
-            headers["x-portkey-provider"] = self.provider
-
-        if self.virtual_key:
-            headers["x-portkey-virtual-key"] = self.virtual_key
-
-        if self.trace_id:
-            headers["x-portkey-trace-id"] = self.trace_id
-
-        if self.metadata:
-            headers["x-portkey-metadata"] = json.dumps(self.metadata)
-
-        if self.retry:
-            headers["x-portkey-retry"] = json.dumps(self.retry)
-
-        if self.cache:
-            headers["x-portkey-cache"] = json.dumps(self.cache)
-
-        if self.cache_force_refresh is not None:
-            headers["x-portkey-cache-force-refresh"] = str(
-                self.cache_force_refresh
-            ).lower()
-
-        if self.user:
-            headers["x-portkey-user"] = self.user
-
-        if self.organization:
-            headers["x-portkey-organization"] = self.organization
-
-        if self.custom_headers:
-            headers.update(self.custom_headers)
-
-        return headers
-
-    def parse_model_string(self, model_string: str) -> tuple[str, str]:
-        """
-        Parse a model string like "portkey/anthropic/claude-3-sonnet"
-        and extract provider and model name.
-
-        Returns:
-            tuple: (provider, model_name)
-        """
-        parts = model_string.split("/", 2)
-        if len(parts) >= 3 and parts[0] == "portkey":
-            _, provider, model = parts
-            return provider, model
-        else:
-            model = model_string.replace("portkey/", "")
-            return "", model
-
-    def get_provider_api_key(
-        self, provider: str, default_key: str = DUMMY_API_KEY
-    ) -> str:
-        """
-        Get the API key for the provider from environment variables.
-
-        Args:
-            provider: The provider name (e.g., "anthropic", "openai")
-            default_key: Default key to return if not found
-
-        Returns:
-            The API key for the provider
-        """
-        import os
-
-        env_patterns = [
-            f"{provider.upper()}_API_KEY",
-            f"{provider.upper()}_KEY",
-        ]
-
-        for pattern in env_patterns:
-            key = os.getenv(pattern, "")
-            if key:
-                return key
-
-        return default_key

langroid/mytypes.py-e

@@ -1,132 +0,0 @@
-from enum import Enum
-from textwrap import dedent
-from typing import Any, Callable, Dict, List, Union
-from uuid import uuid4
-
-from pydantic import BaseModel, Extra, Field
-
-Number = Union[int, float]
-Embedding = List[Number]
-Embeddings = List[Embedding]
-EmbeddingFunction = Callable[[List[str]], Embeddings]
-
-
-class Entity(str, Enum):
-    """
-    Enum for the different types of entities that can respond to the current message.
-    """
-
-    AGENT = "Agent"
-    LLM = "LLM"
-    USER = "User"
-    SYSTEM = "System"
-
-    def __eq__(self, other: object) -> bool:
-        """Allow case-insensitive equality (==) comparison with strings."""
-        if other is None:
-            return False
-        if isinstance(other, str):
-            return self.value.lower() == other.lower()
-        return super().__eq__(other)
-
-    def __ne__(self, other: object) -> bool:
-        """Allow case-insensitive non-equality (!=) comparison with strings."""
-        return not self.__eq__(other)
-
-    def __hash__(self) -> int:
-        """Override this to ensure hashability of the enum,
-        so it can be used sets and dictionary keys.
-        """
-        return hash(self.value.lower())
-
-
-class DocMetaData(BaseModel):
-    """Metadata for a document."""
-
-    source: str = "context"  # just reference
-    source_content: str = "context"  # reference and content
-    title: str = "Unknown Title"
-    published_date: str = "Unknown Date"
-    is_chunk: bool = False  # if it is a chunk, don't split
-    id: str = Field(default_factory=lambda: str(uuid4()))
-    window_ids: List[str] = []  # for RAG: ids of chunks around this one
-
-    def dict_bool_int(self, *args: Any, **kwargs: Any) -> Dict[str, Any]:
-        """
-        Special dict method to convert bool fields to int, to appease some
-        downstream libraries,  e.g. Chroma which complains about bool fields in
-        metadata.
-        """
-        original_dict = super().model_dump(*args, **kwargs)
-
-        for key, value in original_dict.items():
-            if isinstance(value, bool):
-                original_dict[key] = 1 * value
-
-        return original_dict
-
-    def __str__(self) -> str:
-        title_str = (
-            ""
-            if "unknown" in self.title.lower() or self.title.strip() == ""
-            else f"Title: {self.title}"
-        )
-        date_str = ""
-        if (
-            "unknown" not in self.published_date.lower()
-            and self.published_date.strip() != ""
-        ):
-            try:
-                from dateutil import parser
-
-                # Try to parse the date string
-                date_obj = parser.parse(self.published_date)
-                # Format to include only the date part (year-month-day)
-                date_only = date_obj.strftime("%Y-%m-%d")
-                date_str = f"Date: {date_only}"
-            except (ValueError, ImportError, TypeError):
-                # If parsing fails, just use the original date
-                date_str = f"Date: {self.published_date}"
-        components = [self.source] + (
-            [] if title_str + date_str == "" else [title_str, date_str]
-        )
-        return ", ".join(components)
-
-    model_config = ConfigDict(extra="allow")
-
-class Document(BaseModel):
-    """Interface for interacting with a document."""
-
-    content: str
-    metadata: DocMetaData
-
-    def id(self) -> str:
-        return self.metadata.id
-
-    @staticmethod
-    def from_string(
-        content: str,
-        source: str = "context",
-        is_chunk: bool = True,
-    ) -> "Document":
-        return Document(
-            content=content,
-            metadata=DocMetaData(source=source, is_chunk=is_chunk),
-        )
-
-    def __str__(self) -> str:
-        return dedent(
-            f"""
-        CONTENT: {self.content}         
-        SOURCE:{str(self.metadata)}
-        """
-        )
-
-
-class NonToolAction(str, Enum):
-    """
-    Possible options to handle non-tool msgs from LLM.
-    """
-
-    FORWARD_USER = "user"  # forward msg to user
-    DONE = "done"  # task done

langroid/parsing/file_attachment.py-e

@@ -1,246 +0,0 @@
-import base64
-import mimetypes
-import uuid
-from pathlib import Path
-from typing import Any, BinaryIO, Dict, Optional, Union
-from urllib.parse import urlparse
-
-from pydantic import BaseModel
-
-
-class FileAttachment(BaseModel):
-    """Represents a file attachment to be sent to an LLM API."""
-
-    content: bytes
-    filename: Optional[str] = None
-    mime_type: str = "application/octet-stream"
-    url: str | None = None
-    detail: str | None = None
-
-    def __init__(self, **data: Any) -> None:
-        """Initialize with sensible defaults for filename if not provided."""
-        if "filename" not in data or data["filename"] is None:
-            # Generate a more readable unique filename
-            unique_id = str(uuid.uuid4())[:8]
-            data["filename"] = f"attachment_{unique_id}.bin"
-        super().__init__(**data)
-
-    @classmethod
-    def _from_path(
-        cls,
-        file_path: Union[str, Path],
-        detail: Optional[str] = None,
-    ) -> "FileAttachment":
-        """Create a FileAttachment from a file path.
-
-        Args:
-            file_path: Path to the file to attach
-
-        Returns:
-            FileAttachment instance
-        """
-        path = Path(file_path)
-        with open(path, "rb") as f:
-            content = f.read()
-
-        mime_type, _ = mimetypes.guess_type(path)
-        if mime_type is None:
-            mime_type = "application/octet-stream"
-
-        return cls(
-            content=content,
-            filename=path.name,
-            mime_type=mime_type,
-            detail=detail,
-        )
-
-    @classmethod
-    def _from_url(
-        cls,
-        url: str,
-        content: Optional[bytes] = None,
-        filename: Optional[str] = None,
-        mime_type: Optional[str] = None,
-        detail: Optional[str] = None,
-    ) -> "FileAttachment":
-        """Create a FileAttachment from a URL.
-
-        Args:
-            url: URL to the file
-            content: Optional raw bytes content (if already fetched)
-            filename: Optional name to use for the file
-            mime_type: MIME type of the content, guessed from filename or url
-
-        Returns:
-            FileAttachment instance
-        """
-        if filename is None and url:
-            # Extract filename from URL if possible
-
-            parsed_url = urlparse(url)
-            path = parsed_url.path
-            filename = path.split("/")[-1] if path else None
-
-        if mime_type is None and filename:
-            mime_type, _ = mimetypes.guess_type(filename)
-
-        return cls(
-            content=content or b"",  # Empty bytes if no content provided
-            filename=filename,
-            mime_type=mime_type or "application/octet-stream",
-            url=url,
-            detail=detail,
-        )
-
-    @classmethod
-    def from_path(
-        cls,
-        path: Union[str, Path],
-        detail: str | None = None,
-    ) -> "FileAttachment":
-        """Create a FileAttachment from either a local file path or a URL.
-
-        Args:
-            path_or_url: Path to the file or URL to fetch
-
-        Returns:
-            FileAttachment instance
-        """
-        # Convert to string if Path object
-        path_str = str(path)
-
-        # Check if it's a URL
-        if path_str.startswith(("http://", "https://", "ftp://")):
-            return cls._from_url(url=path_str, detail=detail)
-        else:
-            # Assume it's a local file path
-            return cls._from_path(path_str, detail=detail)
-
-    @classmethod
-    def from_bytes(
-        cls,
-        content: bytes,
-        filename: Optional[str] = None,
-        mime_type: Optional[str] = None,
-    ) -> "FileAttachment":
-        """Create a FileAttachment from bytes content.
-
-        Args:
-            content: Raw bytes content
-            filename: Optional name to use for the file
-            mime_type: MIME type of the content, guessed from filename if provided
-
-        Returns:
-            FileAttachment instance
-        """
-        if mime_type is None and filename is not None:
-            mime_type, _ = mimetypes.guess_type(filename)
-
-        return cls(
-            content=content,
-            filename=filename,
-            mime_type=mime_type or "application/octet-stream",
-        )
-
-    @classmethod
-    def from_io(
-        cls,
-        file_obj: BinaryIO,
-        filename: Optional[str] = None,
-        mime_type: Optional[str] = None,
-    ) -> "FileAttachment":
-        """Create a FileAttachment from a file-like object.
-
-        Args:
-            file_obj: File-like object with binary content
-            filename: Optional name to use for the file
-            mime_type: MIME type of the content, guessed from filename if provided
-
-        Returns:
-            FileAttachment instance
-        """
-        content = file_obj.read()
-        return cls.from_bytes(content, filename, mime_type)
-
-    @classmethod
-    def from_text(
-        cls,
-        text: str,
-        filename: Optional[str] = None,
-        mime_type: str = "text/plain",
-        encoding: str = "utf-8",
-    ) -> "FileAttachment":
-        """Create a FileAttachment from text content.
-
-        Args:
-            text: Text content to include
-            filename: Optional name to use for the file
-            mime_type: MIME type of the content
-            encoding: Text encoding to use
-
-        Returns:
-            FileAttachment instance
-        """
-        content = text.encode(encoding)
-        return cls(content=content, filename=filename, mime_type=mime_type)
-
-    def to_base64(self) -> str:
-        """Convert content to base64 encoding.
-
-        Returns:
-            Base64 encoded string
-        """
-        return base64.b64encode(self.content).decode("utf-8")
-
-    def to_data_uri(self) -> str:
-        """Convert content to a data URI.
-
-        Returns:
-            A data URI string containing the base64-encoded content with MIME type
-        """
-        base64_content = self.to_base64()
-        return f"data:{self.mime_type};base64,{base64_content}"
-
-    def to_dict(self, model: str) -> Dict[str, Any]:
-        """
-        Convert to a dictionary suitable for API requests.
-        Tested only for PDF files.
-
-        Returns:
-            Dictionary with file data
-        """
-        if (
-            self.mime_type
-            and self.mime_type.startswith("image/")
-            or "gemini" in model.lower()
-        ):
-            # for gemini models, we use `image_url` for both pdf-files and images
-
-            image_url_dict = {}
-
-            # If we have a URL and it's a full http/https URL, use it directly
-            if self.url and (
-                self.url.startswith("http://") or self.url.startswith("https://")
-            ):
-                image_url_dict["url"] = self.url
-            # Otherwise use base64 data URI
-            else:
-                image_url_dict["url"] = self.to_data_uri()
-
-            # Add detail parameter if specified
-            if self.detail:
-                image_url_dict["detail"] = self.detail
-
-            return dict(
-                type="image_url",
-                image_url=image_url_dict,
-            )
-        else:
-            # For non-image files
-            return dict(
-                type="file",
-                file=dict(
-                    filename=self.filename,
-                    file_data=self.to_data_uri(),
-                ),
-            )