langroid 0.58.2__py3-none-any.whl → 0.59.0b1__py3-none-any.whl

langroid/language_models/provider_params.py

@@ -4,7 +4,7 @@ Provider-specific parameter configurations for various LLM providers.
 
 from typing import Any, Dict, Optional
 
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Constants
 LANGDB_BASE_URL = "https://api.us-east-1.langdb.ai"
@@ -24,10 +24,7 @@ class LangDBParams(BaseSettings):
     thread_id: Optional[str] = None
     base_url: str = LANGDB_BASE_URL
 
-    class Config:
-        # allow setting of fields via env vars,
-        # e.g. LANGDB_PROJECT_ID=1234
-        env_prefix = "LANGDB_"
+    model_config = SettingsConfigDict(env_prefix="LANGDB_")
 
 
 class PortkeyParams(BaseSettings):
@@ -61,10 +58,7 @@ class PortkeyParams(BaseSettings):
     custom_headers: Optional[Dict[str, str]] = None  # Optional: additional headers
     base_url: str = PORTKEY_BASE_URL
 
-    class Config:
-        # allow setting of fields via env vars,
-        # e.g. PORTKEY_API_KEY=xxx, PORTKEY_PROVIDER=anthropic
-        env_prefix = "PORTKEY_"
+    model_config = SettingsConfigDict(env_prefix="PORTKEY_")
 
     def get_headers(self) -> Dict[str, str]:
         """Generate Portkey-specific headers from parameters."""
@@ -73,7 +67,6 @@ class PortkeyParams(BaseSettings):
 
         headers = {}
 
-        # API key - from params or environment
         if self.api_key and self.api_key != DUMMY_API_KEY:
             headers["x-portkey-api-key"] = self.api_key
         else:
@@ -81,45 +74,35 @@ class PortkeyParams(BaseSettings):
             if portkey_key:
                 headers["x-portkey-api-key"] = portkey_key
 
-        # Provider
         if self.provider:
             headers["x-portkey-provider"] = self.provider
 
-        # Virtual key
         if self.virtual_key:
             headers["x-portkey-virtual-key"] = self.virtual_key
 
-        # Trace ID
         if self.trace_id:
             headers["x-portkey-trace-id"] = self.trace_id
 
-        # Metadata
         if self.metadata:
             headers["x-portkey-metadata"] = json.dumps(self.metadata)
 
-        # Retry configuration
         if self.retry:
             headers["x-portkey-retry"] = json.dumps(self.retry)
 
-        # Cache configuration
         if self.cache:
             headers["x-portkey-cache"] = json.dumps(self.cache)
 
-        # Cache force refresh
         if self.cache_force_refresh is not None:
             headers["x-portkey-cache-force-refresh"] = str(
                 self.cache_force_refresh
             ).lower()
 
-        # User identifier
         if self.user:
             headers["x-portkey-user"] = self.user
 
-        # Organization identifier
         if self.organization:
             headers["x-portkey-organization"] = self.organization
 
-        # Add any custom headers
         if self.custom_headers:
             headers.update(self.custom_headers)
 
@@ -138,7 +121,6 @@ class PortkeyParams(BaseSettings):
             _, provider, model = parts
             return provider, model
         else:
-            # Fallback: just remove "portkey/" prefix and return empty provider
             model = model_string.replace("portkey/", "")
             return "", model
 
@@ -157,7 +139,6 @@ class PortkeyParams(BaseSettings):
         """
         import os
 
-        # Common environment variable patterns for different providers
         env_patterns = [
             f"{provider.upper()}_API_KEY",
             f"{provider.upper()}_KEY",

langroid/language_models/provider_params.py-e

@@ -0,0 +1,153 @@
+"""
+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

@@ -3,7 +3,7 @@ from textwrap import dedent
 from typing import Any, Callable, Dict, List, Union
 from uuid import uuid4
 
-from langroid.pydantic_v1 import BaseModel, Extra, Field
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 Number = Union[int, float]
 Embedding = List[Number]
@@ -51,13 +51,21 @@ class DocMetaData(BaseModel):
     id: str = Field(default_factory=lambda: str(uuid4()))
     window_ids: List[str] = []  # for RAG: ids of chunks around this one
 
+    @field_validator("id", mode="before")
+    @classmethod
+    def convert_id_to_string(cls, v: Any) -> str:
+        """Convert id to string if it's not already."""
+        if v is None:
+            return str(uuid4())
+        return str(v)
+
     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().dict(*args, **kwargs)
+        original_dict = super().model_dump(*args, **kwargs)
 
         for key, value in original_dict.items():
             if isinstance(value, bool):
@@ -92,8 +100,7 @@ class DocMetaData(BaseModel):
         )
         return ", ".join(components)
 
-    class Config:
-        extra = Extra.allow
+    model_config = ConfigDict(extra="allow")
 
 
 class Document(BaseModel):

langroid/mytypes.py-e

@@ -0,0 +1,132 @@
+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/code_parser.py

@@ -2,12 +2,12 @@ from functools import reduce
 from typing import Callable, List
 
 import tiktoken
+from pydantic_settings import BaseSettings
 from pygments import lex
 from pygments.lexers import get_lexer_by_name
 from pygments.token import Token
 
 from langroid.mytypes import Document
-from langroid.pydantic_v1 import BaseSettings
 
 
 def chunk_code(

langroid/parsing/file_attachment.py

@@ -5,7 +5,7 @@ from pathlib import Path
 from typing import Any, BinaryIO, Dict, Optional, Union
 from urllib.parse import urlparse
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 
 class FileAttachment(BaseModel):

langroid/parsing/file_attachment.py-e

@@ -0,0 +1,246 @@
+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(),
+                ),
+            )