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

langroid/pydantic_v1/__init__.py

@@ -1,10 +1,67 @@
 """
-If we're on Pydantic v2, use the v1 namespace, else just use the main namespace.
+Compatibility layer for Langroid's Pydantic migration.
 
-This allows compatibility with both Pydantic v1 and v2
+IMPORTANT: You are importing from langroid.pydantic_v1 but getting Pydantic v2 classes!
+Langroid has fully migrated to Pydantic v2, and this compatibility layer is deprecated.
 """
 
+import warnings
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Only show the visual warning, not the standard deprecation warning
+# The standard warning is too noisy and shows the import line
+logger.warning(
+    """
+╔════════════════════════════════════════════════════════════════════════╗
+║                    ⚠️  DEPRECATION WARNING ⚠️                          ║
+╠════════════════════════════════════════════════════════════════════════╣
+║                                                                        ║
+║  You are importing from langroid.pydantic_v1, but you're actually      ║
+║  getting Pydantic v2 classes. Langroid has fully migrated to v2.       ║
+║                                                                        ║
+║  Please update your imports:                                           ║
+║    OLD: from langroid.pydantic_v1 import BaseModel, Field              ║
+║    NEW: from pydantic import BaseModel, Field                          ║
+║                                                                        ║
+║  Also ensure your code uses Pydantic v2 patterns:                      ║
+║    • Use model_dump() instead of dict()                                ║
+║    • Use model_dump_json() instead of json()                           ║
+║    • Use ConfigDict instead of class Config                            ║
+║    • Use model_validate() instead of parse_obj()                       ║
+║                                                                        ║
+║  This compatibility layer will be removed in a future version.         ║
+╚════════════════════════════════════════════════════════════════════════╝
+"""
+)
+
+# Import from pydantic v2 directly (not from pydantic.v1)
+# This allows existing code to continue working if it's already v2-compatible
+from pydantic import *  # noqa: F403, F401
+
+# BaseSettings has moved in v2, import it explicitly
 try:
-    from pydantic.v1 import *  # noqa: F403, F401
+    from pydantic_settings import BaseSettings  # noqa: F401
 except ImportError:
-    from pydantic import *  # type: ignore # noqa: F403, F401
+    # Fallback for older pydantic versions
+    from pydantic import BaseSettings  # type: ignore[no-redef] # noqa: F401
+
+# Explicitly export all items for mypy
+__all__ = [
+    "BaseModel",
+    "BaseSettings",
+    "SettingsConfigDict",
+    "Field",
+    "ConfigDict",
+    "ValidationError",
+    "field_validator",
+    "model_validator",
+    "create_model",
+    "HttpUrl",
+    "AnyUrl",
+    "TypeAdapter",
+    "parse_obj_as",
+    "validator",
+    "root_validator",
+]

langroid/pydantic_v1/main.py

@@ -1,4 +1,10 @@
-try:
-    from pydantic.v1.main import *  # noqa: F403, F401
-except ImportError:
-    from pydantic.main import *  # type: ignore # noqa: F403, F401
+"""
+Compatibility layer for Pydantic v2 migration.
+
+This module now imports directly from Pydantic v2 since all internal code
+has been migrated to use Pydantic v2 patterns.
+"""
+
+# Import from pydantic.main but don't trigger the warning again
+# The warning is already shown when importing from langroid.pydantic_v1
+from pydantic.main import *  # noqa: F403, F401

langroid/utils/configuration.py

@@ -4,8 +4,7 @@ from contextlib import contextmanager
 from typing import Any, Dict, Iterator, List, Literal, cast
 
 from dotenv import find_dotenv, load_dotenv
-
-from langroid.pydantic_v1 import BaseSettings
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Global reentrant lock to serialize any modifications to the global settings.
 _global_lock = threading.RLock()
@@ -22,8 +21,7 @@ class Settings(BaseSettings):
     quiet: bool = False  # quiet mode (i.e. suppress all output)?
     notebook: bool = False  # running in a notebook?
 
-    class Config:
-        extra = "forbid"
+    model_config = SettingsConfigDict(extra="forbid")
 
 
 # Load environment variables from .env file.
@@ -60,8 +58,10 @@ class SettingsProxy:
         # Return a dict view of the settings as seen by the caller.
         # Note that temporary overrides are not “merged” with global settings.
         if hasattr(_thread_local, "override"):
-            return cast(Dict[str, Any], cast(Settings, _thread_local.override.dict()))
-        return _global_settings.dict()
+            return cast(
+                Dict[str, Any], cast(Settings, _thread_local.override.model_dump())
+            )
+        return _global_settings.model_dump()
 
 
 settings = SettingsProxy()
@@ -76,7 +76,7 @@ def update_global_settings(cfg: BaseSettings, keys: List[str]) -> None:
 
     This updates the global default.
     """
-    config_dict = cfg.dict()
+    config_dict = cfg.model_dump()
     filtered_config = {key: config_dict[key] for key in keys if key in config_dict}
     new_settings = Settings(**filtered_config)
     _global_settings.__dict__.update(new_settings.__dict__)
@@ -117,7 +117,9 @@ def quiet_mode(quiet: bool = True) -> Iterator[None]:
     if quiet is already True (from an outer context),
     then it remains True even if a nested context passes quiet=False.
     """
-    current_effective = settings.dict()  # get the current thread's effective settings
+    current_effective = (
+        settings.model_dump()
+    )  # get the current thread's effective settings
     # Create a new settings instance from the current effective state.
     temp = Settings(**current_effective)
     # Merge the new flag: once quiet is enabled, it stays enabled.
@@ -132,6 +134,6 @@ def set_env(settings_instance: BaseSettings) -> None:
 
     Each field in the settings is written to os.environ.
     """
-    for field_name, field in settings_instance.__class__.__fields__.items():
-        env_var_name = field.field_info.extra.get("env", field_name).upper()
-        os.environ[env_var_name] = str(settings_instance.dict()[field_name])
+    for field_name, field in settings_instance.__class__.model_fields.items():
+        env_var_name = field.alias or field_name.upper()
+        os.environ[env_var_name] = str(settings_instance.model_dump()[field_name])

langroid/utils/constants.py

@@ -1,4 +1,4 @@
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 
 # Define the ANSI escape sequences for various colors and reset

langroid/utils/globals.py

@@ -1,6 +1,8 @@
-from typing import Any, Dict, Optional, Type, TypeVar
+from typing import Any, Dict, Optional, Type, TypeVar, cast
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
+from pydantic.fields import ModelPrivateAttr
+from pydantic_core import PydanticUndefined
 
 T = TypeVar("T", bound="GlobalState")
 
@@ -18,9 +20,23 @@ class GlobalState(BaseModel):
         Returns:
             The global instance of the subclass.
         """
-        if cls._instance is None:
-            cls._instance = cls()
-        return cls._instance
+        # Get the actual value from ModelPrivateAttr when accessing on class
+        instance_attr = getattr(cls, "_instance", None)
+        actual_instance: Optional["GlobalState"]
+        if isinstance(instance_attr, ModelPrivateAttr):
+            default_value = instance_attr.default
+            if default_value is PydanticUndefined:
+                actual_instance = None
+            else:
+                actual_instance = cast(Optional["GlobalState"], default_value)
+        else:
+            actual_instance = instance_attr
+
+        if actual_instance is None:
+            new_instance = cls()
+            cls._instance = new_instance
+            return new_instance
+        return actual_instance  # type: ignore
 
     @classmethod
     def set_values(cls: Type[T], **kwargs: Dict[str, Any]) -> None:

langroid/utils/html_logger.py

@@ -10,7 +10,8 @@ from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
+
 from langroid.utils.logging import setup_logger
 
 

langroid/utils/object_registry.py

@@ -2,7 +2,7 @@ import time
 from typing import TYPE_CHECKING, Dict, Optional, TypeAlias, TypeVar
 from uuid import uuid4
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 if TYPE_CHECKING:
     from langroid.agent.base import Agent

langroid/utils/pydantic_utils.py

@@ -15,9 +15,9 @@ from typing import (
 
 import numpy as np
 import pandas as pd
+from pydantic import BaseModel, ValidationError, create_model
 
 from langroid.mytypes import DocMetaData, Document
-from langroid.pydantic_v1 import BaseModel, ValidationError, create_model
 
 logger = logging.getLogger(__name__)
 
@@ -42,7 +42,7 @@ def flatten_dict(
 
 def has_field(model_class: Type[BaseModel], field_name: str) -> bool:
     """Check if a Pydantic model class has a field with the given name."""
-    return field_name in model_class.__fields__
+    return field_name in model_class.model_fields
 
 
 def _recursive_purge_dict_key(d: Dict[str, Any], k: str) -> None:
@@ -125,29 +125,31 @@ def flatten_pydantic_model(
     while models_to_process:
         current_model, current_prefix = models_to_process.pop()
 
-        for name, field in current_model.__fields__.items():
-            if isinstance(field.outer_type_, type) and issubclass(
-                field.outer_type_, BaseModel
-            ):
+        for name, field in current_model.model_fields.items():
+            field_type = field.annotation if hasattr(field, "annotation") else field
+            if isinstance(field_type, type) and issubclass(field_type, BaseModel):
                 new_prefix = (
                     f"{current_prefix}{name}__" if current_prefix else f"{name}__"
                 )
-                models_to_process.append((field.outer_type_, new_prefix))
+                models_to_process.append((field_type, new_prefix))
             else:
                 flattened_name = f"{current_prefix}{name}"
 
-                if field.default_factory is not field.default_factory:
+                if (
+                    hasattr(field, "default_factory")
+                    and field.default_factory is not None
+                ):
                     flattened_fields[flattened_name] = (
-                        field.outer_type_,
+                        field_type,
                         field.default_factory,
                     )
-                elif field.default is not field.default:
+                elif hasattr(field, "default") and field.default is not ...:
                     flattened_fields[flattened_name] = (
-                        field.outer_type_,
+                        field_type,
                         field.default,
                     )
                 else:
-                    flattened_fields[flattened_name] = (field.outer_type_, ...)
+                    flattened_fields[flattened_name] = (field_type, ...)
 
     return create_model("FlatModel", __base__=base_model, **flattened_fields)
 
@@ -155,7 +157,7 @@ def flatten_pydantic_model(
 def get_field_names(model: Type[BaseModel]) -> List[str]:
     """Get all field names from a possibly nested Pydantic model."""
     mdl = flatten_pydantic_model(model)
-    fields = list(mdl.__fields__.keys())
+    fields = list(mdl.model_fields.keys())
     # fields may be like a__b__c , so we only want the last part
     return [f.split("__")[-1] for f in fields]
 
@@ -180,19 +182,22 @@ def generate_simple_schema(
         Dict[str, Any]: A dictionary representing the JSON schema of the provided model,
                         with specified fields excluded.
     """
-    if hasattr(model, "__fields__"):
+    if hasattr(model, "model_fields"):
         output: Dict[str, Any] = {}
-        for field_name, field in model.__fields__.items():
+        for field_name, field in model.model_fields.items():
             if field_name in exclude:
                 continue  # Skip excluded fields
 
-            field_type = field.type_
-            if issubclass(field_type, BaseModel):
+            field_type = field.annotation if hasattr(field, "annotation") else field
+            if isinstance(field_type, type) and issubclass(field_type, BaseModel):
                 # Recursively generate schema for nested models
                 output[field_name] = generate_simple_schema(field_type, exclude)
-            else:
+            elif field_type is not None and hasattr(field_type, "__name__"):
                 # Represent the type as a string here
                 output[field_name] = {"type": field_type.__name__}
+            else:
+                # Fallback for complex types
+                output[field_name] = {"type": str(field_type)}
         return output
     else:
         # Non-model type, return a simplified representation
@@ -218,14 +223,28 @@ def flatten_pydantic_instance(
 
     """
     flat_data: Dict[str, Any] = {}
-    for name, value in instance.dict().items():
+    for name, value in instance.model_dump().items():
         # Assuming nested pydantic model will be a dict here
         if isinstance(value, dict):
-            nested_flat_data = flatten_pydantic_instance(
-                instance.__fields__[name].type_(**value),
-                prefix=f"{prefix}{name}__",
-                force_str=force_str,
+            # Get field info from model_fields
+            field_info = instance.model_fields[name]
+            # Try to get the nested model type from field annotation
+            field_type = (
+                field_info.annotation if hasattr(field_info, "annotation") else None
             )
+            if (
+                field_type
+                and isinstance(field_type, type)
+                and issubclass(field_type, BaseModel)
+            ):
+                nested_flat_data = flatten_pydantic_instance(
+                    field_type(**value),
+                    prefix=f"{prefix}{name}__",
+                    force_str=force_str,
+                )
+            else:
+                # Skip non-Pydantic nested fields for safety
+                continue
             flat_data.update(nested_flat_data)
         else:
             flat_data[f"{prefix}{name}"] = str(value) if force_str else value
@@ -531,10 +550,19 @@ def extra_metadata(document: Document, doc_cls: Type[Document] = Document) -> Li
         in the document's metadata.
     """
     # Convert metadata to dict, including extra fields.
-    metadata_fields = set(document.metadata.dict().keys())
+    metadata_fields = set(document.metadata.model_dump().keys())
 
     # Get defined fields in the metadata of doc_cls
-    defined_fields = set(doc_cls.__fields__["metadata"].type_.__fields__.keys())
+    metadata_field = doc_cls.model_fields["metadata"]
+    metadata_type = (
+        metadata_field.annotation
+        if hasattr(metadata_field, "annotation")
+        else metadata_field
+    )
+    if isinstance(metadata_type, type) and hasattr(metadata_type, "model_fields"):
+        defined_fields = set(metadata_type.model_fields.keys())
+    else:
+        defined_fields = set()
 
     # Identify extra fields not in defined fields.
     extra_fields = list(metadata_fields - defined_fields)
@@ -561,14 +589,13 @@ def extend_document_class(d: Document) -> Type[Document]:
     # Extract the fields from the original metadata class, including types,
     # correctly handling special types like List[str].
     original_metadata_fields = {
-        k: (v.outer_type_ if v.shape != 1 else v.type_, ...)
-        for k, v in DocMetaData.__fields__.items()
+        k: (v.annotation, ...) for k, v in DocMetaData.model_fields.items()
     }
     # Extract extra fields from the metadata instance with their types
     extra_fields = {
         k: (type(v), ...)
         for k, v in d.metadata.__dict__.items()
-        if k not in DocMetaData.__fields__
+        if k not in DocMetaData.model_fields
     }
 
     # Combine original and extra fields for the new metadata class

langroid/utils/types.py

@@ -3,7 +3,7 @@ import logging
 from inspect import signature
 from typing import Any, Optional, Type, TypeVar, Union, get_args, get_origin
 
-from langroid.pydantic_v1 import BaseModel
+from pydantic import BaseModel
 
 logger = logging.getLogger(__name__)
 PrimitiveType = Union[int, float, bool, str]
@@ -55,7 +55,7 @@ def to_string(msg: Any) -> str:
     if isinstance(msg, str):
         return msg
     if isinstance(msg, BaseModel):
-        return msg.json()
+        return msg.model_dump_json()
     # last resort: use json.dumps() or str() to make it a str
     try:
         return json.dumps(msg)

langroid/vector_store/base.py

@@ -5,11 +5,11 @@ from typing import Dict, List, Optional, Sequence, Tuple, Type
 
 import numpy as np
 import pandas as pd
+from pydantic_settings import BaseSettings
 
 from langroid.embedding_models.base import EmbeddingModel, EmbeddingModelsConfig
 from langroid.embedding_models.models import OpenAIEmbeddingsConfig
 from langroid.mytypes import DocMetaData, Document, EmbeddingFunction
-from langroid.pydantic_v1 import BaseSettings
 from langroid.utils.algorithms.graph import components, topological_sort
 from langroid.utils.configuration import settings
 from langroid.utils.object_registry import ObjectRegistry
@@ -82,7 +82,7 @@ class VectorStore(ABC):
         else:
             logger.warning(
                 f"""
-                Unknown vector store config: {config.__repr_name__()},
+                Unknown vector store config: {config.__class__.__name__},
                 so skipping vector store creation!
                 If you intended to use a vector-store, please set a specific 
                 vector-store in your script, typically in the `vecdb` field of a 
@@ -160,7 +160,7 @@ class VectorStore(ABC):
         If full_eval is True, sanitization is bypassed - use only with trusted input!
         """
         # convert each doc to a dict, using dotted paths for nested fields
-        dicts = [flatten_dict(doc.dict(by_alias=True)) for doc in docs]
+        dicts = [flatten_dict(doc.model_dump(by_alias=True)) for doc in docs]
         df = pd.DataFrame(dicts)
 
         try:

langroid/vector_store/lancedb.py

@@ -15,8 +15,7 @@ from typing import (
 
 import pandas as pd
 from dotenv import load_dotenv
-
-from langroid.pydantic_v1 import BaseModel, ValidationError, create_model
+from pydantic import BaseModel, ValidationError, create_model
 
 if TYPE_CHECKING:
     from lancedb.query import LanceVectorQueryBuilder
@@ -175,11 +174,12 @@ class LanceDB(VectorStore):
         fields = {"id": (str, ...), "vector": (Vector(n), ...)}
 
         sorted_fields = dict(
-            sorted(doc_cls.__fields__.items(), key=lambda item: item[0])
+            sorted(doc_cls.model_fields.items(), key=lambda item: item[0])
         )
         # Add both statically and dynamically defined fields from doc_cls
         for field_name, field in sorted_fields.items():
-            fields[field_name] = (field.outer_type_, field.default)
+            field_type = field.annotation if hasattr(field, "annotation") else field
+            fields[field_name] = (field_type, field.default)
 
         # Create the new model with dynamic fields
         NewModel = create_model(
@@ -227,7 +227,7 @@ class LanceDB(VectorStore):
                     dict(
                         id=ids[i + j],
                         vector=embedding_vecs[i + j],
-                        **doc.dict(),
+                        **doc.model_dump(),
                     )
                     for j, doc in enumerate(documents[i : i + b])
                 ]

langroid/vector_store/meilisearch.py

@@ -33,7 +33,7 @@ class MeiliSearchConfig(VectorStoreConfig):
     cloud: bool = False
     collection_name: str | None = None
     primary_key: str = "id"
-    port = 7700
+    port: int = 7700
 
 
 class MeiliSearch(VectorStore):
@@ -193,7 +193,7 @@ class MeiliSearch(VectorStore):
             dict(
                 id=d.id(),
                 content=d.content,
-                metadata=d.metadata.dict(),
+                metadata=d.metadata.model_dump(),
             )
             for d in documents
         ]

langroid/vector_store/pineconedb.py

@@ -17,11 +17,11 @@ from typing import (
 
 from dotenv import load_dotenv
 
+# import dataclass
+from pydantic import BaseModel
+
 from langroid import LangroidImportError
 from langroid.mytypes import Document
-
-# import dataclass
-from langroid.pydantic_v1 import BaseModel
 from langroid.utils.configuration import settings
 from langroid.vector_store.base import VectorStore, VectorStoreConfig
 
@@ -246,7 +246,7 @@ class PineconeDB(VectorStore):
             return
 
         super().maybe_add_ids(documents)
-        document_dicts = [doc.dict() for doc in documents]
+        document_dicts = [doc.model_dump() for doc in documents]
         document_ids = [doc.id() for doc in documents]
         embedding_vectors = self.embedding_fn([doc.content for doc in documents])
         vectors = [

langroid/vector_store/postgres.py

@@ -341,7 +341,7 @@ class PostgresDB(VectorStore):
                         "id": doc.metadata.id,
                         "embedding": embedding,
                         "document": doc.content,
-                        "cmetadata": doc.metadata.dict(),
+                        "cmetadata": doc.metadata.model_dump(),
                     }
                     for doc, embedding in zip(batch_docs, batch_embeddings)
                 ]

langroid/vector_store/qdrantdb.py

@@ -328,7 +328,7 @@ class QdrantDB(VectorStore):
         colls = self.list_collections(empty=True)
         if len(documents) == 0:
             return
-        document_dicts = [doc.dict() for doc in documents]
+        document_dicts = [doc.model_dump() for doc in documents]
         embedding_vecs = self.embedding_fn([doc.content for doc in documents])
         sparse_embedding_vecs = self.get_sparse_embeddings(
             [doc.content for doc in documents]
@@ -416,7 +416,7 @@ class QdrantDB(VectorStore):
             raise ValueError("No collection name set, cannot retrieve docs")
         docs = []
         offset = 0
-        filter = Filter() if where == "" else Filter.parse_obj(json.loads(where))
+        filter = Filter() if where == "" else Filter.model_validate(json.loads(where))
         while True:
             results, next_page_offset = self.client.scroll(
                 collection_name=self.config.collection_name,
@@ -473,7 +473,7 @@ class QdrantDB(VectorStore):
         if where is None or where == "":
             filter = Filter()
         else:
-            filter = Filter.parse_obj(json.loads(where))
+            filter = Filter.model_validate(json.loads(where))
         requests = [
             SearchRequest(
                 vector=NamedVector(

langroid/vector_store/weaviatedb.py

@@ -185,7 +185,7 @@ class WeaviateDB(VectorStore):
         if len(documents) == 0:
             return
 
-        document_dicts = [doc.dict() for doc in documents]
+        document_dicts = [doc.model_dump() for doc in documents]
         embedding_vecs = self.embedding_fn([doc.content for doc in documents])
         if self.config.collection_name is None:
             raise ValueError("No collection name set, cannot ingest docs")

{langroid-0.58.3.dist-info → langroid-0.59.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langroid
-Version: 0.58.3
+Version: 0.59.0
 Summary: Harness LLMs with Multi-Agent Programming
 Author-email: Prasad Chalasani <pchalasani@gmail.com>
 License: MIT
@@ -35,7 +35,8 @@ Requires-Dist: onnxruntime<2.0.0,>=1.16.1
 Requires-Dist: openai<2.0.0,>=1.61.1
 Requires-Dist: pandas<3.0.0,>=2.0.3
 Requires-Dist: prettytable<4.0.0,>=3.8.0
-Requires-Dist: pydantic<3.0.0,>=1
+Requires-Dist: pydantic-settings<3.0.0,>=2.0.0
+Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pygithub<2.0.0,>=1.58.1
 Requires-Dist: pygments<3.0.0,>=2.15.1
 Requires-Dist: pymupdf4llm<0.1.0,>=0.0.17