langroid 0.58.3__py3-none-any.whl → 0.59.0__py3-none-any.whl

langroid/language_models/openai_gpt.py

@@ -12,6 +12,7 @@ from typing import (
     Callable,
     Dict,
     List,
+    Mapping,
     Optional,
     Tuple,
     Type,
@@ -24,6 +25,8 @@ from cerebras.cloud.sdk import AsyncCerebras, Cerebras
 from groq import AsyncGroq, Groq
 from httpx import Timeout
 from openai import AsyncOpenAI, OpenAI
+from pydantic import BaseModel
+from pydantic_settings import BaseSettings, SettingsConfigDict
 from rich import print
 from rich.markup import escape
 
@@ -78,7 +81,6 @@ from langroid.language_models.utils import (
     retry_with_exponential_backoff,
 )
 from langroid.parsing.parse_json import parse_imperfect_json
-from langroid.pydantic_v1 import BaseModel, BaseSettings
 from langroid.utils.configuration import settings
 from langroid.utils.constants import Colors
 from langroid.utils.system import friendly_error
@@ -220,7 +222,7 @@ class OpenAICallParams(BaseModel):
     extra_body: Dict[str, Any] | None = None  # additional params for API request body
 
     def to_dict_exclude_none(self) -> Dict[str, Any]:
-        return {k: v for k, v in self.dict().items() if v is not None}
+        return {k: v for k, v in self.model_dump().items() if v is not None}
 
 
 class LiteLLMProxyConfig(BaseSettings):
@@ -229,8 +231,7 @@ class LiteLLMProxyConfig(BaseSettings):
     api_key: str = ""  # read from env var LITELLM_API_KEY if set
     api_base: str = ""  # read from env var LITELLM_API_BASE if set
 
-    class Config:
-        env_prefix = "LITELLM_"
+    model_config = SettingsConfigDict(env_prefix="LITELLM_")
 
 
 class OpenAIGPTConfig(LLMConfig):
@@ -259,7 +260,7 @@ class OpenAIGPTConfig(LLMConfig):
     litellm_proxy: LiteLLMProxyConfig = LiteLLMProxyConfig()
     ollama: bool = False  # use ollama's OpenAI-compatible endpoint?
     min_output_tokens: int = 1
-    use_chat_for_completion = True  # do not change this, for OpenAI models!
+    use_chat_for_completion: bool = True  # do not change this, for OpenAI models!
     timeout: int = 20
     temperature: float = 0.2
     seed: int | None = 42
@@ -316,8 +317,43 @@ class OpenAIGPTConfig(LLMConfig):
 
         super().__init__(**kwargs)
 
-    class Config:
-        env_prefix = "OPENAI_"
+    model_config = SettingsConfigDict(env_prefix="OPENAI_")
+
+    def model_copy(
+        self, *, update: Mapping[str, Any] | None = None, deep: bool = False
+    ) -> "OpenAIGPTConfig":
+        """
+        Override model_copy to handle unpicklable fields properly.
+
+        This preserves fields like http_client_factory during normal copying
+        while still allowing exclusion for pickling operations.
+        """
+        # Save references to unpicklable fields
+        http_client_factory = self.http_client_factory
+        streamer = self.streamer
+        streamer_async = self.streamer_async
+
+        # Get the current model data, excluding problematic fields
+        data = self.model_dump(
+            exclude={"http_client_factory", "streamer", "streamer_async"}
+        )
+
+        # Apply any updates
+        if update:
+            data.update(update)
+
+        # Create a new instance with the copied data
+        new_instance = self.__class__(**data)
+
+        # Restore the unpicklable fields if they weren't overridden by update
+        if "http_client_factory" not in (update or {}):
+            new_instance.http_client_factory = http_client_factory
+        if "streamer" not in (update or {}):
+            new_instance.streamer = streamer
+        if "streamer_async" not in (update or {}):
+            new_instance.streamer_async = streamer_async
+
+        return new_instance
 
     def _validate_litellm(self) -> None:
         """
@@ -330,12 +366,12 @@ class OpenAIGPTConfig(LLMConfig):
             import litellm
         except ImportError:
             raise LangroidImportError("litellm", "litellm")
+
         litellm.telemetry = False
         litellm.drop_params = True  # drop un-supported params without crashing
-        # modify params to fit the model expectations, and avoid crashing
-        # (e.g. anthropic doesn't like first msg to be system msg)
         litellm.modify_params = True
         self.seed = None  # some local mdls don't support seed
+
         if self.api_key == DUMMY_API_KEY:
             keys_dict = litellm.utils.validate_environment(self.chat_model)
             missing_keys = keys_dict.get("missing_keys", [])
@@ -365,8 +401,7 @@ class OpenAIGPTConfig(LLMConfig):
         class DynamicConfig(OpenAIGPTConfig):
             pass
 
-        DynamicConfig.Config.env_prefix = prefix.upper() + "_"
-
+        DynamicConfig.model_config = SettingsConfigDict(env_prefix=prefix.upper() + "_")
         return DynamicConfig
 
 
@@ -407,7 +442,7 @@ class OpenAIGPT(LanguageModel):
             config: configuration for openai-gpt model
         """
         # copy the config to avoid modifying the original
-        config = config.copy()
+        config = config.model_copy()
         super().__init__(config)
         self.config: OpenAIGPTConfig = config
         # save original model name such as `provider/model` before
@@ -1477,7 +1512,7 @@ class OpenAIGPT(LanguageModel):
 
             if has_function:
                 function_call = LLMFunctionCall(name=function_name)
-                function_call_dict = function_call.dict()
+                function_call_dict = function_call.model_dump()
                 if function_args == "":
                     function_call.arguments = None
                 else:
@@ -1529,7 +1564,7 @@ class OpenAIGPT(LanguageModel):
                     ),
                 ),
             ),
-            openai_response.dict(),
+            openai_response.model_dump(),
         )
 
     def _cache_store(self, k: str, v: Any) -> None:
@@ -1680,7 +1715,7 @@ class OpenAIGPT(LanguageModel):
         cached, hashed_key, response = completions_with_backoff(**args)
         # assume response is an actual response rather than a streaming event
         if not isinstance(response, dict):
-            response = response.dict()
+            response = response.model_dump()
         if "message" in response["choices"][0]:
             msg = response["choices"][0]["message"]["content"].strip()
         else:
@@ -1758,7 +1793,7 @@ class OpenAIGPT(LanguageModel):
         )
         # assume response is an actual response rather than a streaming event
         if not isinstance(response, dict):
-            response = response.dict()
+            response = response.model_dump()
         if "message" in response["choices"][0]:
             msg = response["choices"][0]["message"]["content"].strip()
         else:
@@ -2056,7 +2091,7 @@ class OpenAIGPT(LanguageModel):
         if functions is not None:
             args.update(
                 dict(
-                    functions=[f.dict() for f in functions],
+                    functions=[f.model_dump() for f in functions],
                     function_call=function_call,
                 )
             )
@@ -2074,7 +2109,7 @@ class OpenAIGPT(LanguageModel):
                     tools=[
                         dict(
                             type="function",
-                            function=t.function.dict()
+                            function=t.function.model_dump()
                             | ({"strict": t.strict} if t.strict is not None else {}),
                         )
                         for t in tools

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/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/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/md_parser.py

@@ -1,7 +1,7 @@
 import re
-from typing import List
+from typing import Any, List
 
-from langroid.pydantic_v1 import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 
 HEADER_CONTEXT_SEP = "\n...\n"
 
@@ -24,8 +24,8 @@ class Node(BaseModel):
     # Forward references will be resolved with the update_forward_refs call below.
 
 
-# Resolve forward references for Node (required for recursive models in Pydantic v1)
-Node.update_forward_refs()
+# Resolve forward references for Node (required for recursive models in Pydantic)
+Node.model_rebuild()
 
 
 def _cleanup_text(text: str) -> str:
@@ -180,6 +180,16 @@ class MarkdownChunkConfig(BaseModel):
     rollup: bool = True  # whether to roll up chunks
     header_context_sep: str = HEADER_CONTEXT_SEP  # separator for header context
 
+    @field_validator("chunk_size", mode="before")
+    @classmethod
+    def convert_chunk_size_to_int(cls, v: Any) -> int:
+        """Convert chunk_size to int, maintaining backward compatibility
+        with Pydantic V1.
+        """
+        if isinstance(v, float):
+            return int(v)
+        return int(v)
+
 
 # A simple tokenizer that counts tokens as whitespace-separated words.
 def count_words(text: str) -> int:

langroid/parsing/parser.py

@@ -4,6 +4,8 @@ from enum import Enum
 from typing import Any, Dict, List, Literal, Optional
 
 import tiktoken
+from pydantic import field_validator, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from langroid.mytypes import Document
 from langroid.parsing.md_parser import (
@@ -12,7 +14,6 @@ from langroid.parsing.md_parser import (
     count_words,
 )
 from langroid.parsing.para_sentence_split import create_chunks, remove_extra_whitespace
-from langroid.pydantic_v1 import BaseSettings, root_validator
 from langroid.utils.object_registry import ObjectRegistry
 
 logger = logging.getLogger(__name__)
@@ -32,8 +33,7 @@ class BaseParsingConfig(BaseSettings):
 
     library: str
 
-    class Config:
-        extra = "ignore"  # Ignore unknown settings
+    model_config = SettingsConfigDict(extra="ignore")  # Ignore unknown settings
 
 
 class LLMPdfParserConfig(BaseSettings):
@@ -69,7 +69,8 @@ class PdfParsingConfig(BaseParsingConfig):
     llm_parser_config: Optional[LLMPdfParserConfig] = None
     marker_config: Optional[MarkerConfig] = None
 
-    @root_validator(pre=True)
+    @model_validator(mode="before")
+    @classmethod
     def enable_configs(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         """Ensure correct config is set based on library selection."""
         library = values.get("library")
@@ -114,6 +115,17 @@ class ParsingConfig(BaseSettings):
     chunk_size_variation: float = 0.30  # max variation from chunk_size
     overlap: int = 50  # overlap between chunks
     max_chunks: int = 10_000
+
+    @field_validator("chunk_size", mode="before")
+    @classmethod
+    def convert_chunk_size_to_int(cls, v: Any) -> int:
+        """Convert chunk_size to int, maintaining backward compatibility
+        with Pydantic V1.
+        """
+        if isinstance(v, float):
+            return int(v)
+        return int(v)
+
     # offset to subtract from page numbers:
     # e.g. if physical page 12 is displayed as page 1, set page_number_offset = 11
     page_number_offset: int = 0
@@ -203,7 +215,8 @@ class Parser:
             # add_window_ids)
             chunk_docs = [
                 Document(
-                    content=c, metadata=d.metadata.copy(update=dict(is_chunk=True))
+                    content=c,
+                    metadata=d.metadata.model_copy(update=dict(is_chunk=True)),
                 )
                 for c in chunks
                 if c.strip() != ""
@@ -255,7 +268,8 @@ class Parser:
             # add_window_ids)
             chunk_docs = [
                 Document(
-                    content=c, metadata=d.metadata.copy(update=dict(is_chunk=True))
+                    content=c,
+                    metadata=d.metadata.model_copy(update=dict(is_chunk=True)),
                 )
                 for c in chunks
                 if c.strip() != ""
@@ -287,7 +301,8 @@ class Parser:
             # add_window_ids)
             chunk_docs = [
                 Document(
-                    content=c, metadata=d.metadata.copy(update=dict(is_chunk=True))
+                    content=c,
+                    metadata=d.metadata.model_copy(update=dict(is_chunk=True)),
                 )
                 for c in chunks
                 if c.strip() != ""

langroid/parsing/repo_loader.py

@@ -18,10 +18,12 @@ if TYPE_CHECKING:
     from github.Label import Label
     from github.Repository import Repository
 
+from pydantic import BaseModel, Field
+from pydantic_settings import BaseSettings
+
 from langroid.mytypes import DocMetaData, Document
 from langroid.parsing.document_parser import DocumentParser, DocumentType
 from langroid.parsing.parser import Parser, ParsingConfig
-from langroid.pydantic_v1 import BaseModel, BaseSettings, Field
 
 logger = logging.getLogger(__name__)
 

langroid/parsing/search.py

@@ -64,7 +64,7 @@ def find_fuzzy_matches_in_docs(
         return orig_doc_matches
     if len(orig_doc_matches) == 0:
         return []
-    if set(orig_doc_matches[0][0].__fields__) != {"content", "metadata"}:
+    if set(orig_doc_matches[0][0].model_fields) != {"content", "metadata"}:
         # If there are fields beyond just content and metadata,
         # we do NOT want to create new document objects with content fields
         # based on words_before and words_after, since we don't know how to

langroid/parsing/url_loader.py

@@ -7,12 +7,12 @@ from typing import TYPE_CHECKING, Any, Dict, List, Literal, Optional
 
 import markdownify as md
 from dotenv import load_dotenv
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from langroid.exceptions import LangroidImportError
 from langroid.mytypes import DocMetaData, Document
 from langroid.parsing.document_parser import DocumentParser, ImagePdfParser
 from langroid.parsing.parser import Parser, ParsingConfig
-from langroid.pydantic_v1 import BaseSettings
 
 if TYPE_CHECKING:
     from firecrawl import FirecrawlApp
@@ -54,20 +54,13 @@ class FirecrawlConfig(BaseCrawlerConfig):
     params: Dict[str, Any] = {}
     timeout: Optional[int] = None
 
-    class Config:
-        # Leverage Pydantic's BaseSettings to
-        # allow setting of fields via env vars,
-        # e.g. FIRECRAWL_MODE=scrape and FIRECRAWL_API_KEY=...
-        env_prefix = "FIRECRAWL_"
+    model_config = SettingsConfigDict(env_prefix="FIRECRAWL_")
 
 
 class ExaCrawlerConfig(BaseCrawlerConfig):
     api_key: str = ""
 
-    class Config:
-        # Allow setting of fields via env vars with prefix EXA_
-        # e.g., EXA_API_KEY=your_api_key
-        env_prefix = "EXA_"
+    model_config = SettingsConfigDict(env_prefix="EXA_")
 
 
 class Crawl4aiConfig(BaseCrawlerConfig):
@@ -81,49 +74,22 @@ class Crawl4aiConfig(BaseCrawlerConfig):
     browser_config: Optional["BrowserConfig"] = None
     run_config: Optional["CrawlerRunConfig"] = None
 
-    _refs_resolved: bool = False
+    model_config = SettingsConfigDict(arbitrary_types_allowed=True)
 
-    def __init_subclass__(cls, **kwargs: Any) -> None:
-        """Resolve forward references when class is first subclassed or instantiated."""
-        super().__init_subclass__(**kwargs)
-        cls._resolve_forward_refs()
 
-    @classmethod
-    def _resolve_forward_refs(cls) -> None:
-        """Resolve forward references only when needed."""
-        if not cls._refs_resolved:
-            try:
-                from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig
-                from crawl4ai.content_scraping_strategy import ContentScrapingStrategy
-                from crawl4ai.deep_crawling import DeepCrawlStrategy
-                from crawl4ai.extraction_strategy import ExtractionStrategy
-                from crawl4ai.markdown_generation_strategy import (
-                    MarkdownGenerationStrategy,
-                )
-
-                # Create namespace for update_forward_refs
-                namespace = {
-                    "BrowserConfig": BrowserConfig,
-                    "CrawlerRunConfig": CrawlerRunConfig,
-                    "ContentScrapingStrategy": ContentScrapingStrategy,
-                    "DeepCrawlStrategy": DeepCrawlStrategy,
-                    "ExtractionStrategy": ExtractionStrategy,
-                    "MarkdownGenerationStrategy": MarkdownGenerationStrategy,
-                }
-
-                cls.update_forward_refs(**namespace)
-                cls._refs_resolved = True
-            except ImportError:
-                # If crawl4ai is not installed, leave forward refs as strings
-                pass
-
-    def __init__(self, **kwargs: Any) -> None:
-        """Initialize and ensure forward refs are resolved."""
-        self._resolve_forward_refs()
-        super().__init__(**kwargs)
+# Resolve forward references for Crawl4aiConfig after the class is defined
+try:
+    from crawl4ai.async_configs import BrowserConfig, CrawlerRunConfig
+    from crawl4ai.content_scraping_strategy import ContentScrapingStrategy
+    from crawl4ai.deep_crawling import DeepCrawlStrategy
+    from crawl4ai.extraction_strategy import ExtractionStrategy
+    from crawl4ai.markdown_generation_strategy import MarkdownGenerationStrategy
 
-    class Config:
-        arbitrary_types_allowed = True
+    # Rebuild the model with resolved references
+    Crawl4aiConfig.model_rebuild()
+except ImportError:
+    # If crawl4ai is not installed, leave forward refs as strings
+    pass
 
 
 class BaseCrawler(ABC):
@@ -347,7 +313,7 @@ class FirecrawlCrawler(BaseCrawler):
                     )
                     processed_urls.add(url)
                     new_pages += 1
-            pbar.update(new_pages)  # Update progress bar with new pages
+            pbar.model_copy(update=new_pages)  # Update progress bar with new pages
 
             # Break if crawl is complete
             if status["status"] == "completed":

langroid/parsing/urls.py

@@ -9,11 +9,10 @@ from urllib.parse import urldefrag, urljoin, urlparse
 import fire
 import requests
 from bs4 import BeautifulSoup
+from pydantic import BaseModel, HttpUrl, TypeAdapter, ValidationError
 from rich import print
 from rich.prompt import Prompt
 
-from langroid.pydantic_v1 import BaseModel, HttpUrl, ValidationError, parse_obj_as
-
 logger = logging.getLogger(__name__)
 
 
@@ -106,7 +105,8 @@ class Url(BaseModel):
 
 def is_url(s: str) -> bool:
     try:
-        Url(url=parse_obj_as(HttpUrl, s))
+        url_adapter = TypeAdapter(HttpUrl)
+        Url(url=url_adapter.validate_python(s))
         return True
     except ValidationError:
         return False
@@ -133,7 +133,8 @@ def get_urls_paths_bytes_indices(
             byte_list.append(i)
             continue
         try:
-            Url(url=parse_obj_as(HttpUrl, item))
+            url_adapter = TypeAdapter(HttpUrl)
+            Url(url=url_adapter.validate_python(item))
             urls.append(i)
         except ValidationError:
             if os.path.exists(item):

langroid/prompts/prompts_config.py

@@ -1,4 +1,4 @@
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings
 
 
 class PromptsConfig(BaseSettings):