langroid 0.58.2__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
@@ -287,6 +288,9 @@ class OpenAIGPTConfig(LLMConfig):
     langdb_params: LangDBParams = LangDBParams()
     portkey_params: PortkeyParams = PortkeyParams()
     headers: Dict[str, str] = {}
+    http_client_factory: Optional[Callable[[], Any]] = None  # Factory for httpx.Client
+    http_verify_ssl: bool = True  # Simple flag for SSL verification
+    http_client_config: Optional[Dict[str, Any]] = None  # Config dict for httpx.Client
 
     def __init__(self, **kwargs) -> None:  # type: ignore
         local_model = "api_base" in kwargs and kwargs["api_base"] is not None
@@ -313,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:
         """
@@ -327,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", [])
@@ -362,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
 
 
@@ -404,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
@@ -631,6 +669,32 @@ class OpenAIGPT(LanguageModel):
                 # Add Portkey-specific headers
                 self.config.headers.update(self.config.portkey_params.get_headers())
 
+            # Create http_client if needed - Priority order:
+            # 1. http_client_factory (most flexibility, not cacheable)
+            # 2. http_client_config (cacheable, moderate flexibility)
+            # 3. http_verify_ssl=False (cacheable, simple SSL bypass)
+            http_client = None
+            async_http_client = None
+            http_client_config_used = None
+
+            if self.config.http_client_factory is not None:
+                # Use the factory to create http_client (not cacheable)
+                http_client = self.config.http_client_factory()
+                # Don't set async_http_client from sync client - create separately
+                # This avoids type mismatch issues
+                async_http_client = None
+            elif self.config.http_client_config is not None:
+                # Use config dict (cacheable)
+                http_client_config_used = self.config.http_client_config
+            elif not self.config.http_verify_ssl:
+                # Simple SSL bypass (cacheable)
+                http_client_config_used = {"verify": False}
+                logging.warning(
+                    "SSL verification has been disabled. This is insecure and "
+                    "should only be used in trusted environments (e.g., "
+                    "corporate networks with self-signed certificates)."
+                )
+
             if self.config.use_cached_client:
                 self.client = get_openai_client(
                     api_key=self.api_key,
@@ -638,6 +702,8 @@ class OpenAIGPT(LanguageModel):
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
+                    http_client=http_client,
+                    http_client_config=http_client_config_used,
                 )
                 self.async_client = get_async_openai_client(
                     api_key=self.api_key,
@@ -645,23 +711,56 @@ class OpenAIGPT(LanguageModel):
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
+                    http_client=async_http_client,
+                    http_client_config=http_client_config_used,
                 )
             else:
                 # Create new clients without caching
-                self.client = OpenAI(
+                client_kwargs: Dict[str, Any] = dict(
                     api_key=self.api_key,
                     base_url=self.api_base,
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
                 )
-                self.async_client = AsyncOpenAI(
+                if http_client is not None:
+                    client_kwargs["http_client"] = http_client
+                elif http_client_config_used is not None:
+                    # Create http_client from config for non-cached scenario
+                    try:
+                        from httpx import Client
+
+                        client_kwargs["http_client"] = Client(**http_client_config_used)
+                    except ImportError:
+                        raise ValueError(
+                            "httpx is required to use http_client_config. "
+                            "Install it with: pip install httpx"
+                        )
+                self.client = OpenAI(**client_kwargs)
+
+                async_client_kwargs: Dict[str, Any] = dict(
                     api_key=self.api_key,
                     base_url=self.api_base,
                     organization=self.config.organization,
                     timeout=Timeout(self.config.timeout),
                     default_headers=self.config.headers,
                 )
+                if async_http_client is not None:
+                    async_client_kwargs["http_client"] = async_http_client
+                elif http_client_config_used is not None:
+                    # Create async http_client from config for non-cached scenario
+                    try:
+                        from httpx import AsyncClient
+
+                        async_client_kwargs["http_client"] = AsyncClient(
+                            **http_client_config_used
+                        )
+                    except ImportError:
+                        raise ValueError(
+                            "httpx is required to use http_client_config. "
+                            "Install it with: pip install httpx"
+                        )
+                self.async_client = AsyncOpenAI(**async_client_kwargs)
 
         self.cache: CacheDB | None = None
         use_cache = self.config.cache_config is not None
@@ -1413,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:
@@ -1465,7 +1564,7 @@ class OpenAIGPT(LanguageModel):
                     ),
                 ),
             ),
-            openai_response.dict(),
+            openai_response.model_dump(),
         )
 
     def _cache_store(self, k: str, v: Any) -> None:
@@ -1616,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:
@@ -1694,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:
@@ -1992,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,
                 )
             )
@@ -2010,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