lionagi 0.5.5__py3-none-any.whl → 0.6.1__py3-none-any.whl

lionagi/core/models/model_params.py

@@ -1,194 +0,0 @@
-# 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
-
-__all__ = ("ModelParams",)
-
-
-class ModelParams(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

lionagi/core/models/types.py

@@ -1,19 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from .base import BaseAutoModel
-from .field_model import FieldModel
-from .model_params import ModelParams
-from .note import Note
-from .operable_model import OperableModel
-from .schema_model import SchemaModel
-
-__all__ = (
-    "BaseAutoModel",
-    "FieldModel",
-    "ModelParams",
-    "Note",
-    "OperableModel",
-    "SchemaModel",
-)

lionagi/core/session/branch.py

@@ -1,130 +0,0 @@
-# Copyright (c) 2023 - 2024, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from pathlib import Path
-
-import pandas as pd
-from pydantic import model_validator
-
-from lionagi.core.generic.types import Component, LogManager, Pile, Progression
-from lionagi.core.typing import ID
-from lionagi.integrations.litellm_.imodel import LiteiModel
-from lionagi.protocols.operatives.instruct import Instruct, OperationInstruct
-from lionagi.service import iModel
-from lionagi.settings import Settings
-
-from ..action.action_manager import ActionManager
-from ..communication.types import MESSAGE_FIELDS, MessageManager
-from .branch_mixins import BranchActionMixin, BranchOperationMixin
-
-
-class Branch(Component, BranchActionMixin, BranchOperationMixin):
-
-    user: str | None = None
-    name: str | None = None
-    msgs: MessageManager = None
-    acts: ActionManager = None
-    imodel: iModel | LiteiModel | None = None
-    parse_imodel: iModel | LiteiModel | None = None
-
-    @model_validator(mode="before")
-    def _validate_data(cls, data: dict) -> dict:
-
-        user = data.pop("user", None)
-        name = data.pop("name", None)
-        message_manager = data.pop("msgs", None)
-        if not message_manager:
-            message_manager = MessageManager(
-                messages=data.pop("messages", None),
-                logger=data.pop("logger", None),
-                system=data.pop("system", None),
-            )
-        if not message_manager.logger:
-            message_manager.logger = LogManager(
-                **Settings.Branch.BRANCH.message_log_config.to_dict()
-            )
-
-        acts = data.pop("acts", None)
-        if not acts:
-            acts = ActionManager()
-            acts.logger = LogManager(
-                **Settings.Branch.BRANCH.action_log_config.to_dict()
-            )
-        if "tools" in data:
-            acts.register_tools(data.pop("tools"))
-
-        imodel = data.pop(
-            "imodel",
-            iModel(**Settings.iModel.CHAT.to_dict()),
-        )
-        parse_imodel = data.pop(
-            "parse_imodel",
-            iModel(**Settings.iModel.PARSE.to_dict()),
-        )
-        out = {
-            "user": user,
-            "name": name,
-            "msgs": message_manager,
-            "acts": acts,
-            "imodel": imodel,
-            "parse_imodel": parse_imodel,
-            **data,
-        }
-        return out
-
-    def dump_log(self, clear: bool = True, persist_path: str | Path = None):
-        self.msgs.logger.dump(clear, persist_path)
-        self.acts.logger.dump(clear, persist_path)
-
-    def to_df(self, *, progress: Progression = None) -> pd.DataFrame:
-        if progress is None:
-            progress = self.msgs.progress
-
-        msgs = [
-            self.msgs.messages[i] for i in progress if i in self.msgs.messages
-        ]
-        p = Pile(items=msgs)
-        return p.to_df(columns=MESSAGE_FIELDS)
-
-    async def aclone(self, sender: ID.Ref = None) -> "Branch":
-        async with self.msgs.messages:
-            return self.clone(sender)
-
-    def clone(self, sender: ID.Ref = None) -> "Branch":
-        """
-        Split a branch, creating a new branch with the same messages and tools.
-
-        Args:
-            branch: The branch to split or its identifier.
-
-        Returns:
-            The newly created branch.
-        """
-        if sender is not None:
-            if not ID.is_id(sender):
-                raise ValueError(
-                    "Input value for branch.clone sender is not a valid sender"
-                )
-            sender = ID.get_id(sender)
-
-        system = self.msgs.system.clone() if self.msgs.system else None
-        tools = (
-            list(self.acts.registry.values()) if self.acts.registry else None
-        )
-        branch_clone = Branch(
-            system=system,
-            user=self.user,
-            messages=[i.clone() for i in self.msgs.messages],
-            tools=tools,
-        )
-        for message in branch_clone.msgs.messages:
-            message.sender = sender or self.ln_id
-            message.recipient = branch_clone.ln_id
-        return branch_clone
-
-    async def instruct(self, instruct: Instruct, /, **kwargs):
-        config = {**instruct.to_dict(), **kwargs}
-        if any(i in config for i in OperationInstruct.reserved_kwargs):
-            return await self.operate(**config)
-        return await self.communicate(**config)