lionagi 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

lionagi/core/models/new_model_params.py

@@ -0,0 +1,195 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import inspect
+
+from pydantic import BaseModel
+
+from lionagi.libs.parse import validate_boolean
+from lionagi.libs.utils import copy
+
+from ..typing.pydantic_ import (
+    Field,
+    FieldInfo,
+    PrivateAttr,
+    create_model,
+    field_validator,
+    model_validator,
+)
+from ..typing.typing_ import Callable, Self
+from .field_model import FieldModel
+from .schema_model import SchemaModel
+
+
+class NewModelParams(SchemaModel):
+    """Configuration class for dynamically creating new Pydantic models."""
+
+    name: str | None = None
+    parameter_fields: dict[str, FieldInfo] = Field(default_factory=dict)
+    base_type: type[BaseModel] = Field(default=BaseModel)
+    field_models: list[FieldModel] = Field(default_factory=list)
+    exclude_fields: list = Field(default_factory=list)
+    field_descriptions: dict = Field(default_factory=dict)
+    inherit_base: bool = Field(default=True)
+    config_dict: dict | None = Field(default=None)
+    doc: str | None = Field(default=None)
+    frozen: bool = False
+    _validators: dict[str, Callable] | None = PrivateAttr(default=None)
+    _use_keys: set[str] = PrivateAttr(default_factory=set)
+
+    @property
+    def use_fields(self):
+        """Get field definitions to use in new model."""
+        params = {
+            k: v
+            for k, v in self.parameter_fields.items()
+            if k in self._use_keys
+        }
+        params.update(
+            {
+                f.name: f.field_info
+                for f in self.field_models
+                if f.name in self._use_keys
+            }
+        )
+        return {k: (v.annotation, v) for k, v in params.items()}
+
+    @field_validator("parameter_fields", mode="before")
+    def validate_parameters(cls, value):
+        """Validate parameter field definitions."""
+        if value is None:
+            return {}
+        if not isinstance(value, dict):
+            raise ValueError("Fields must be a dictionary.")
+        for k, v in value.items():
+            if not isinstance(k, str):
+                raise ValueError("Field names must be strings.")
+            if not isinstance(v, FieldInfo):
+                raise ValueError("Field values must be FieldInfo objects.")
+        return copy(value)
+
+    @field_validator("base_type", mode="before")
+    def validate_base(cls, value) -> type[BaseModel]:
+        """Validate base model type."""
+        if value is None:
+            return BaseModel
+        if isinstance(value, type) and issubclass(value, BaseModel):
+            return value
+        if isinstance(value, BaseModel):
+            return value.__class__
+        raise ValueError("Base must be a BaseModel subclass or instance.")
+
+    @field_validator("exclude_fields", mode="before")
+    def validate_fields(cls, value) -> list[str]:
+        """Validate excluded fields list."""
+        if value is None:
+            return []
+        if isinstance(value, dict):
+            value = list(value.keys())
+        if isinstance(value, set | tuple):
+            value = list(value)
+        if isinstance(value, list):
+            if not all(isinstance(i, str) for i in value):
+                raise ValueError("Field names must be strings.")
+            return copy(value)
+        raise ValueError("Fields must be a list, set, or dictionary.")
+
+    @field_validator("field_descriptions", mode="before")
+    def validate_field_descriptions(cls, value) -> dict[str, str]:
+        """Validate field descriptions dictionary."""
+        if value is None:
+            return {}
+        if not isinstance(value, dict):
+            raise ValueError("Field descriptions must be a dictionary.")
+        for k, v in value.items():
+            if not isinstance(k, str):
+                raise ValueError("Field names must be strings.")
+            if not isinstance(v, str):
+                raise ValueError("Field descriptions must be strings.")
+        return value
+
+    @field_validator("inherit_base", mode="before")
+    def validate_inherit_base(cls, value) -> bool:
+        """Validate inherit_base flag."""
+        try:
+            return validate_boolean(value)
+        except Exception:
+            return True
+
+    @field_validator("name", mode="before")
+    def validate_name(cls, value) -> str:
+        """Validate model name."""
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError("Name must be a string.")
+        return value
+
+    @field_validator("field_models", mode="before")
+    def _validate_field_models(cls, value):
+        """Validate field model definitions."""
+        if value is None:
+            return []
+        value = [value] if not isinstance(value, list) else value
+        if not all(isinstance(i, FieldModel) for i in value):
+            raise ValueError("Field models must be FieldModel objects.")
+        return value
+
+    @model_validator(mode="after")
+    def validate_param_model(self) -> Self:
+        """Validate complete model configuration."""
+        if self.base_type is not None:
+            self.parameter_fields.update(copy(self.base_type.model_fields))
+
+        self.parameter_fields.update(
+            {f.name: f.field_info for f in self.field_models}
+        )
+
+        use_keys = list(self.parameter_fields.keys())
+        use_keys.extend(list(self._use_keys))
+
+        if self.exclude_fields:
+            use_keys = [i for i in use_keys if i not in self.exclude_fields]
+
+        self._use_keys = set(use_keys)
+
+        validators = {}
+
+        for i in self.field_models:
+            if i.field_validator is not None:
+                validators.update(i.field_validator)
+        self._validators = validators
+
+        if self.field_descriptions:
+            for i in self.field_models:
+                if i.name in self.field_descriptions:
+                    i.description = self.field_descriptions[i.name]
+
+        if not isinstance(self.name, str):
+            if hasattr(self.base_type, "class_name"):
+                if callable(self.base_type.class_name):
+                    self.name = self.base_type.class_name()
+                else:
+                    self.name = self.base_type.class_name
+            elif inspect.isclass(self.base_type):
+                self.name = self.base_type.__name__
+
+        return self
+
+    def create_new_model(self) -> type[BaseModel]:
+        """Create new Pydantic model with specified configuration."""
+        a: type[BaseModel] = create_model(
+            self.name or "StepModel",
+            __config__=self.config_dict,
+            __doc__=self.doc,
+            __base__=self.base_type if self.inherit_base else None,
+            __validators__=self._validators,
+            **self.use_fields,
+        )
+        if self.frozen:
+            a.model_config["frozen"] = True
+        return a
+
+
+__all__ = ["NewModelParams"]

lionagi/core/models/note.py

@@ -0,0 +1,351 @@
+# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.libs.parse import flatten, nget, ninsert, npop, nset, to_list
+from lionagi.libs.utils import copy
+
+from ..typing.pydantic_ import ConfigDict, Field, field_serializer
+from ..typing.typing_ import (
+    UNDEFINED,
+    Any,
+    ItemsView,
+    Iterator,
+    ValuesView,
+    override,
+)
+from .base import BaseAutoModel
+
+INDICE_TYPE = str | list[str | int]
+
+
+class Note(BaseAutoModel):
+    """Container for managing nested dictionary data structures.
+
+    Provides:
+    - Deep nested data access
+    - Dictionary-like interface
+    - Flattening capabilities
+    - Update operations
+
+    Example:
+        ```python
+        note = Note(
+            user={
+                "name": "John",
+                "settings": {
+                    "theme": "dark"
+                }
+            }
+        )
+
+        # Access nested data
+        name = note.get(["user", "name"])
+        theme = note["user"]["settings"]["theme"]
+
+        # Update nested structure
+        note.update(["user", "settings"], {"language": "en"})
+        ```
+
+    Attributes:
+        content: Nested dictionary structure
+        model_config: Configuration allowing arbitrary types
+    """
+
+    content: dict[str, Any] = Field(
+        default_factory=dict
+    )  # Nested data structure
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        use_enum_values=True,
+        populate_by_name=True,
+    )
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize Note with dictionary data.
+
+        Args:
+            **kwargs: Key-value pairs for initial content
+        """
+        super().__init__()
+        self.content = kwargs
+
+    @field_serializer("content")
+    def _serialize_content(self, value: Any) -> dict[str, Any]:
+        """Serialize content to dictionary format.
+
+        Args:
+            value: Content to serialize
+
+        Returns:
+            Deep copy of content dictionary
+        """
+        output_dict = copy(value, deep=True)
+        return output_dict
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert Note to dictionary, excluding undefined values.
+
+        Returns:
+            Dictionary representation with UNDEFINED values removed
+        """
+        out = copy(self.content)
+        for k, v in self.content.items():
+            if v is UNDEFINED:
+                out.pop(k)
+        return out
+
+    def pop(
+        self,
+        indices: INDICE_TYPE,
+        /,
+        default: Any = UNDEFINED,
+    ) -> Any:
+        """Remove and return item from nested structure.
+
+        Args:
+            indices: Path to item
+            default: Value to return if not found
+
+        Returns:
+            Removed value or default
+
+        Raises:
+            KeyError: If path not found and no default
+        """
+        indices = to_list(indices, flatten=True, dropna=True)
+        return npop(self.content, indices, default)
+
+    def insert(self, indices: INDICE_TYPE, value: Any, /) -> None:
+        """Insert value into nested structure at specified indices.
+
+        Args:
+            indices: Path where to insert
+            value: Value to insert
+        """
+        indices = to_list(indices, flatten=True, dropna=True)
+        ninsert(self.content, indices, value)
+
+    def set(self, indices: INDICE_TYPE, value: Any, /) -> None:
+        """Set value in nested structure at specified indices.
+
+        Args:
+            indices: Path where to set
+            value: Value to set
+        """
+        indices = to_list(indices, flatten=True, dropna=True)
+        if self.get(indices, None) is None:
+            self.insert(indices, value)
+        else:
+            nset(self.content, indices, value)
+
+    def get(
+        self,
+        indices: INDICE_TYPE,
+        /,
+        default: Any = UNDEFINED,
+    ) -> Any:
+        """Get value from nested structure at specified indices.
+
+        Args:
+            indices: Path to value
+            default: Value to return if not found
+
+        Returns:
+            Value at path or default
+
+        Raises:
+            KeyError: If path not found and no default
+        """
+        indices = to_list(indices, flatten=True, dropna=True)
+        return nget(self.content, indices, default)
+
+    def keys(self, /, flat: bool = False, **kwargs: Any) -> list:
+        """Get keys of the Note.
+
+        Args:
+            flat: If True, return flattened keys
+            kwargs: Additional flattening options
+
+        Returns:
+            List of keys, optionally flattened
+        """
+        if flat:
+            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
+            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
+            return flatten(self.content, **kwargs).keys()
+        return list(self.content.keys())
+
+    def values(self, /, flat: bool = False, **kwargs: Any) -> ValuesView:
+        """Get values of the Note.
+
+        Args:
+            flat: If True, return flattened values
+            kwargs: Additional flattening options
+
+        Returns:
+            View of values, optionally flattened
+        """
+        if flat:
+            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
+            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
+            return flatten(self.content, **kwargs).values()
+        return self.content.values()
+
+    def items(self, /, flat: bool = False, **kwargs: Any) -> ItemsView:
+        """Get items of the Note.
+
+        Args:
+            flat: If True, return flattened items
+            kwargs: Additional flattening options
+
+        Returns:
+            View of items, optionally flattened
+        """
+        if flat:
+            kwargs["coerce_keys"] = kwargs.get("coerce_keys", False)
+            kwargs["coerce_sequence"] = kwargs.get("coerce_sequence", "list")
+            return flatten(self.content, **kwargs).items()
+        return self.content.items()
+
+    def clear(self) -> None:
+        """Clear all content."""
+        self.content.clear()
+
+    def update(
+        self,
+        indices: INDICE_TYPE,
+        value: Any,
+    ) -> None:
+        """Update nested structure at specified indices.
+
+        Args:
+            indices: Location to update
+            value: New value to set
+
+        Raises:
+            ValueError: If trying to update dict with non-dict
+        """
+        existing = None
+        if not indices:
+            existing = self.content
+        else:
+            existing = self.get(indices, None)
+
+        if existing is None:
+            if not isinstance(value, (list, dict)):
+                value = [value]
+            self.set(indices, value)
+
+        if isinstance(existing, list):
+            if isinstance(value, list):
+                existing.extend(value)
+            else:
+                existing.append(value)
+
+        elif isinstance(existing, dict):
+            if isinstance(value, self.__class__):
+                value = value.content
+
+            if isinstance(value, dict):
+                existing.update(value)
+            else:
+                raise ValueError(
+                    "Cannot update a dictionary with a non-dictionary value."
+                )
+
+    @classmethod
+    def from_dict(cls, kwargs: Any) -> "Note":
+        """Create Note instance from dictionary.
+
+        Args:
+            kwargs: Dictionary to initialize with
+
+        Returns:
+            New Note instance
+        """
+        return cls(**kwargs)
+
+    def __contains__(self, indices: INDICE_TYPE) -> bool:
+        """Check if indices exist in content.
+
+        Args:
+            indices: Path to check
+
+        Returns:
+            True if path exists, False otherwise
+        """
+        return self.content.get(indices, UNDEFINED) is not UNDEFINED
+
+    def __len__(self) -> int:
+        """Get length of content.
+
+        Returns:
+            Number of top-level keys
+        """
+        return len(self.content)
+
+    def __iter__(self) -> Iterator[str]:
+        """Get iterator over content.
+
+        Returns:
+            Iterator over top-level keys
+        """
+        return iter(self.content)
+
+    def __next__(self) -> str:
+        """Get next item from content iterator.
+
+        Returns:
+            Next key in iteration
+        """
+        return next(iter(self.content))
+
+    @override
+    def __str__(self) -> str:
+        """Get string representation of content.
+
+        Returns:
+            String representation of content dict
+        """
+        return str(self.content)
+
+    @override
+    def __repr__(self) -> str:
+        """Get detailed string representation of content.
+
+        Returns:
+            Detailed string representation of content dict
+        """
+        return repr(self.content)
+
+    def __getitem__(self, indices: INDICE_TYPE) -> Any:
+        """Get item using index notation.
+
+        Args:
+            indices: Path to value
+
+        Returns:
+            Value at path
+
+        Raises:
+            KeyError: If path not found
+        """
+        indices = to_list(indices, flatten=True, dropna=True)
+        return self.get(indices)
+
+    def __setitem__(self, indices: INDICE_TYPE, value: Any) -> None:
+        """Set item using index notation.
+
+        Args:
+            indices: Path where to set
+            value: Value to set
+        """
+        self.set(indices, value)
+
+
+__all__ = [
+    "Note",
+    "INDICE_TYPE",
+]