lionagi 0.0.316__py3-none-any.whl → 0.1.1__py3-none-any.whl

lionagi/core/prompt/prompt_template.py

@@ -1,312 +0,0 @@
-"""
-This module defines the PromptTemplate and ScoredTemplate classes for creating and managing prompt templates.
-
-The PromptTemplate class is a base class for creating prompt templates with input and output fields, validation,
-and processing. The ScoredTemplate class extends the PromptTemplate class and adds fields for confidence score and reason.
-"""
-
-from typing import Any
-from lionagi.libs import convert, func_call
-from lionagi.core.schema.base_node import BaseComponent
-
-from pydantic import Field
-from .field_validator import validation_funcs
-
-
-_non_prompt_words = [
-    "id_",
-    "node_id",
-    "meta",
-    "timestamp",
-    "metadata",
-    "signature",
-    "task",
-    "template_name",
-]
-
-
-class PromptTemplate(BaseComponent):
-    """
-    A base class for creating and managing prompt templates.
-
-    Attributes:
-        signature (str): The signature indicating the input and output fields.
-        choices (dict[str, list[str]]): The choices to select from for each field.
-        out_validation_kwargs (dict[str, Any]): The validation keyword arguments for output fields.
-        in_validation_kwargs (dict[str, Any]): The validation keyword arguments for input fields.
-        task (str | dict[str, Any] | None): The task to follow.
-        fix_input (bool): Whether to fix input fields.
-        fix_output (bool): Whether to fix output fields.
-        template_name (str): The name of the prompt template.
-        version (str | float | int): The version of the prompt template.
-        description (dict | str | None): The description of the prompt template.
-        input_fields (list[str]): The input fields of the prompt template.
-        output_fields (list[str]): The output fields of the prompt template.
-
-    Methods:
-        __init__(self, template_name="default_prompt_template", version_=None, description_=None, task=None, **kwargs):
-            Initializes a new instance of the PromptTemplate class.
-        _validate_input_choices(self, fix_=fix_input):
-            Validates the input choices based on the defined choices.
-        _validate_output_choices(self, fix_=fix_output):
-            Validates the output choices based on the defined choices.
-        _get_input_output_fields(str_) -> tuple[list[str], list[str]]:
-            Extracts the input and output fields from the signature string.
-        instruction_context(self) -> str:
-            Returns the instruction context based on the input fields.
-        instruction(self) -> str:
-            Returns the instruction based on the task and input/output fields.
-        instruction_output_fields(self) -> dict[str, str]:
-            Returns a dictionary mapping output fields to their descriptions.
-        prompt_fields_annotation(self) -> dict[str, list[str]]:
-            Returns a dictionary mapping prompt fields to their annotated types.
-        _validate_field(self, k, v, choices=None, fix_=False, **kwargs) -> bool:
-            Validates a single field based on its annotated type and choices.
-        _process_input(self, fix_=False):
-            Processes and validates the input fields.
-        _process_response(self, out_, fix_=True):
-            Processes and validates the output fields.
-        in_(self) -> dict[str, Any]:
-            Returns a dictionary mapping input fields to their values.
-        out(self) -> dict[str, Any]:
-            Returns a dictionary mapping output fields to their values.
-        process(self, in_=None, out_=None):
-            Processes and validates the input and output fields.
-    """
-
-    signature: str = Field("null", description="signature indicating inputs, outputs")
-    choices: dict[str, list[str]] = Field(
-        default_factory=dict, description="choices to select from"
-    )
-    out_validation_kwargs: dict[str, Any] = Field(
-        default_factory=dict, description="validation kwargs for output"
-    )
-    in_validation_kwargs: dict[str, Any] = Field(
-        default_factory=dict, description="validation kwargs for input"
-    )
-    task: str | dict[str, Any] | None = Field(None, description="task to follow")
-    fix_input: bool = Field(True, description="whether to fix input")
-    fix_output: bool = Field(True, description="whether to fix output")
-
-    def __init__(
-        self,
-        template_name: str = "default_prompt_template",
-        version_: str | float | int = None,
-        description_: dict | str | None = None,
-        task: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.template_name = template_name
-        self.meta_insert(["version"], version_)
-        self.meta_insert(["description"], description_ or "")
-        self.task = task
-        self.input_fields, self.output_fields = self._get_input_output_fields(
-            self.signature
-        )
-        self.process(in_=True)
-
-    def _validate_input_choices(self, fix_=fix_input):
-        if len(self.choices) >= 1:
-            for k, choices in self.choices.items():
-                if k in self.input_fields and not self._validate_field(
-                    k, getattr(self, k), choices, fix_
-                ):
-                    raise ValueError(
-                        f"Invalid choice for field {k}: {getattr(self, k)} is not in {choices}"
-                    )
-
-    def _validate_output_choices(self, fix_=fix_output):
-        if len(self.choices) >= 1:
-            for k, choices in self.choices.items():
-                if k in self.output_fields and not self._validate_field(
-                    k, getattr(self, k), choices, fix_
-                ):
-                    raise ValueError(
-                        f"Invalid choice for field {k}: {getattr(self, k)} is not in {choices}"
-                    )
-
-    @property
-    def version(self):
-        return self.metadata["version"]
-
-    @version.setter
-    def version(self, value):
-        self.metadata["version"] = value
-
-    @property
-    def description(self):
-        return self.metadata["description"]
-
-    @description.setter
-    def description(self, value):
-        self.metadata["description"] = value
-
-    @property
-    def prompt_fields(self):
-        return [
-            _field for _field in self.property_keys if _field not in _non_prompt_words
-        ]
-
-    @staticmethod
-    def _get_input_output_fields(str_):
-        _inputs, _outputs = str_.split("->")
-
-        _inputs = [convert.strip_lower(i) for i in _inputs.split(",")]
-        _outputs = [convert.strip_lower(o) for o in _outputs.split(",")]
-
-        return _inputs, _outputs
-
-    @property
-    def instruction_context(self):
-        a = "".join(
-            f"""
-        ## input: {i}:
-        - description: {self.model_fields[i].description}
-        - value: {str(self.__getattribute__(self.input_fields[idx]))}
-        """
-            for idx, i in enumerate(self.input_fields)
-        )
-        return a.replace("        ", "")
-
-    @property
-    def instruction(self):
-        ccc = f"""
-        0. Your task is {self.task},
-        1. provided: {self.input_fields}, 
-        2. requested: {self.output_fields}
-        ----------
-        """
-        return ccc.replace("        ", "")
-
-    @property
-    def instruction_output_fields(self):
-        return {i: self.model_fields[i].description for i in self.output_fields}
-
-    @property
-    def prompt_fields_annotation(self):
-        dict_ = {i: self.model_fields[i].annotation for i in self.prompt_fields}
-        for k, v in dict_.items():
-            if "|" in str(v):
-                v = str(v)
-                v = v.split("|")
-                dict_[k] = func_call.lcall(v, convert.strip_lower)
-            else:
-                dict_[k] = [v.__name__]
-
-        return dict_
-
-    def _validate_field(self, k, v, choices=None, fix_=False, **kwargs):
-
-        str_ = self.prompt_fields_annotation[k]
-
-        if choices:
-            v_ = validation_funcs["enum"](v, choices=choices, fix_=fix_, **kwargs)
-            if v_ not in choices:
-                raise ValueError(f"{v} is not in chocies {choices}")
-            setattr(self, k, v_)
-            return True
-
-        if "lionagi.core.prompt.action_template.actionrequest" in str_:
-            self.__setattr__(k, validation_funcs["action"](v))
-            return True
-
-        elif "bool" in str_:
-            self.__setattr__(k, validation_funcs["bool"](v, fix_=fix_, **kwargs))
-            return True
-
-        elif "int" in str_ or "float" in str_:
-            self.__setattr__(k, validation_funcs["number"](v, fix_=fix_, **kwargs))
-            return True
-
-        elif "str" in str_:
-            self.__setattr__(k, validation_funcs["str"](v, fix_=fix_, **kwargs))
-            return True
-
-        return False
-
-    def _process_input(self, fix_=False):
-        kwargs = self.in_validation_kwargs.copy()
-        for k, v in self.in_.items():
-            if k not in kwargs:
-                kwargs = {k: {}}
-
-            if self._field_has_choices(k):
-                self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
-                if self._validate_field(
-                    k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
-                ):
-                    continue
-                else:
-                    raise ValueError(f"{k} has no choices")
-
-            elif self._validate_field(k, v, fix_=fix_, **kwargs[k]):
-                continue
-            else:
-                raise ValueError(f"failed to validate field {k}")
-
-    def _field_has_choices(self, k):
-        try:
-            a = (
-                self.model_fields[k].json_schema_extra["choices"] is not None
-                and "choices" in self.model_fields[k].json_schema_extra
-            )
-            return a if isinstance(a, bool) else False
-        except Exception:
-            return False
-
-    def _process_response(self, out_, fix_=True):
-        kwargs = self.out_validation_kwargs.copy()
-        for k, v in out_.items():
-            if k not in kwargs:
-                kwargs = {k: {}}
-
-            if self._field_has_choices(k):
-                self.choices[k] = self.model_fields[k].json_schema_extra["choices"]
-                if self._validate_field(
-                    k, v, choices=self.choices[k], fix_=fix_, **kwargs[k]
-                ):
-                    continue
-                else:
-                    raise ValueError(f"{k} has no choices")
-
-            elif self._validate_field(k, v, fix_=fix_, **kwargs[k]):
-                continue
-
-            else:
-                raise ValueError(f"failed to validate field {k} with value {v}")
-
-    @property
-    def in_(self):
-        return {i: self.__getattribute__(i) for i in self.input_fields}
-
-    @property
-    def out(self):
-        return {i: self.__getattribute__(i) for i in self.output_fields}
-
-    def process(self, in_=None, out_=None):
-        if in_:
-            self._process_input(fix_=self.fix_input)
-            self._validate_input_choices(fix_=self.fix_input)
-        if out_:
-            self._process_response(out_, fix_=self.fix_output)
-            self._validate_output_choices(fix_=self.fix_output)
-        return self
-
-
-# class Weather(PromptTemplate):
-#     sunny: bool = Field(True, description="true if the weather is sunny outside else false")
-#     rainy: bool = Field(False, description="true if it is raining outside else false")
-#     play1: bool = Field(True, description="conduct play1")
-#     play2: bool = Field(False, description="conduct play2")
-#     signature: str = Field("sunny, rainy -> play1, play2")
-
-# predictor = Weather(
-#     template_name="predictor",
-#     task_ = "decides to conduct one of play1 and play2",
-#     version_=0.1,
-#     description_="predicts the weather and decides play",
-#     signature = "sunny, play1 -> play2"
-#     )
-
-# predictor.to_instruction()

lionagi/core/schema/__init__.py

@@ -1,22 +0,0 @@
-from .base_node import BaseNode, BaseRelatableNode, Tool, TOOL_TYPE
-from .data_node import DataNode
-from .data_logger import DLog, DataLogger
-from .structure import Relationship, Graph, Structure
-from .action_node import ActionNode, ActionSelection
-from .condition import Condition
-
-__all__ = [
-    "BaseNode",
-    "BaseRelatableNode",
-    "Tool",
-    "DataNode",
-    "DLog",
-    "DataLogger",
-    "Relationship",
-    "Graph",
-    "Structure",
-    "ActionNode",
-    "TOOL_TYPE",
-    "ActionSelection",
-    "Condition",
-]

lionagi/core/schema/action_node.py

@@ -1,29 +0,0 @@
-from enum import Enum
-
-from .base_node import BaseNode
-
-
-class ActionSelection(BaseNode):
-
-    def __init__(self, action: str = "chat", action_kwargs=None):
-        if action_kwargs is None:
-            action_kwargs = {}
-        super().__init__()
-        self.action = action
-        self.action_kwargs = action_kwargs
-
-
-class ActionNode(BaseNode):
-
-    def __init__(
-        self, instruction, action: str = "chat", tools=None, action_kwargs=None
-    ):
-        if tools is None:
-            tools = []
-        if action_kwargs is None:
-            action_kwargs = {}
-        super().__init__()
-        self.instruction = instruction
-        self.action = action
-        self.tools = tools
-        self.action_kwargs = action_kwargs

lionagi/core/schema/base_mixin.py

@@ -1,296 +0,0 @@
-from abc import ABC
-from functools import singledispatchmethod
-from typing import Any, TypeVar, Type, Callable
-
-import pandas as pd
-from pydantic import BaseModel, ValidationError
-
-from lionagi.libs import nested, convert, ParseUtil, SysUtil
-
-T = TypeVar("T")  # Generic type for return type of from_obj method
-
-
-class BaseToObjectMixin(ABC, BaseModel):
-
-    def to_json_str(self, *args, **kwargs) -> str:
-        """
-        Serializes the model instance into a JSON string.
-
-        This method utilizes the model's `model_dump_json` method, typically available in Pydantic
-        models or models with similar serialization mechanisms, to convert the instance into a JSON
-        string. It supports passing arbitrary arguments to the underlying `model_dump_json` method.
-
-        Args:
-                *args: Variable-length argument list to be passed to `model_dump_json`.
-                **kwargs: Arbitrary keyword arguments, with `by_alias=True` set by default to use
-                                  model field aliases in the output JSON, if any.
-
-        Returns:
-                str: A JSON string representation of the model instance.
-        """
-        return self.model_dump_json(*args, by_alias=True, **kwargs)
-
-    def to_dict(self, *args, **kwargs) -> dict[str, Any]:
-        """
-        Converts the model instance into a dictionary.
-
-        Leveraging the model's `model_dump` method, this function produces a dictionary representation
-        of the model. The dictionary keys correspond to the model's field names, with an option to use
-        aliases instead of the original field names.
-
-        Args:
-                *args: Variable-length argument list for the `model_dump` method.
-                **kwargs: Arbitrary keyword arguments. By default, `by_alias=True` is applied, indicating
-                                  that field aliases should be used as keys in the resulting dictionary.
-
-        Returns:
-                dict[str, Any]: The dictionary representation of the model instance.
-        """
-        return self.model_dump(*args, by_alias=True, **kwargs)
-
-    def to_xml(self) -> str:
-        """
-        Serializes the model instance into an XML string.
-
-        This method converts the model instance into an XML format. It first transforms the instance
-        into a dictionary and then recursively constructs an XML tree representing the model's data.
-        The root element of the XML tree is named after the class of the model instance.
-
-        Returns:
-                str: An XML string representation of the model instance.
-        """
-
-        import xml.etree.ElementTree as ET
-
-        root = ET.Element(self.__class__.__name__)
-
-        def convert(dict_obj, parent):
-            for key, val in dict_obj.items():
-                if isinstance(val, dict):
-                    element = ET.SubElement(parent, key)
-                    convert(val, element)
-                else:
-                    element = ET.SubElement(parent, key)
-                    element.text = str(val)
-
-        convert(self.to_dict(), root)
-        return ET.tostring(root, encoding="unicode")
-
-    def to_pd_series(self, *args, pd_kwargs: dict | None = None, **kwargs) -> pd.Series:
-        """
-        Converts the model instance into a pandas Series.
-
-        This method first transforms the model instance into a dictionary and then constructs a pandas
-        Series from it. The Series' index corresponds to the model's field names, with an option to
-        customize the Series creation through `pd_kwargs`.
-
-        Args:
-                *args: Variable-length argument list for the `to_dict` method.
-                pd_kwargs (dict | None): Optional dictionary of keyword arguments to pass to the pandas
-                                                                 Series constructor. Defaults to None, in which case an empty
-                                                                 dictionary is used.
-                **kwargs: Arbitrary keyword arguments for the `to_dict` method, influencing the dictionary
-                                  representation used for Series creation.
-
-        Returns:
-                pd.Series: A pandas Series representation of the model instance.
-        """
-        pd_kwargs = {} if pd_kwargs is None else pd_kwargs
-        dict_ = self.to_dict(*args, **kwargs)
-        return pd.Series(dict_, **pd_kwargs)
-
-
-class BaseFromObjectMixin(ABC, BaseModel):
-
-    @singledispatchmethod
-    @classmethod
-    def from_obj(cls: Type[T], obj: Any, *args, **kwargs) -> T:
-        raise NotImplementedError(f"Unsupported type: {type(obj)}")
-
-    @from_obj.register(dict)
-    @classmethod
-    def _from_dict(cls, obj: dict, *args, **kwargs) -> T:
-        return cls.model_validate(obj, *args, **kwargs)
-
-    @from_obj.register(str)
-    @classmethod
-    def _from_str(cls, obj: str, *args, fuzzy_parse=False, **kwargs) -> T:
-        obj = ParseUtil.fuzzy_parse_json(obj) if fuzzy_parse else convert.to_dict(obj)
-        try:
-            return cls.from_obj(obj, *args, **kwargs)
-        except ValidationError as e:
-            raise ValueError(f"Invalid JSON for deserialization: {e}") from e
-
-    @from_obj.register(list)
-    @classmethod
-    def _from_list(cls, obj: list[Any], *args, **kwargs) -> list[T]:
-        return [cls.from_obj(item, *args, **kwargs) for item in obj]
-
-    @from_obj.register(pd.Series)
-    @classmethod
-    def _from_pd_series(cls, obj: pd.Series, *args, pd_kwargs=None, **kwargs) -> T:
-        if pd_kwargs is None:
-            pd_kwargs = {}
-        return cls.from_obj(obj.to_dict(**pd_kwargs), *args, **kwargs)
-
-    @from_obj.register(pd.DataFrame)
-    @classmethod
-    def _from_pd_dataframe(
-        cls, obj: pd.DataFrame, *args, pd_kwargs=None, **kwargs
-    ) -> list[T]:
-        if pd_kwargs is None:
-            pd_kwargs = {}
-        return [
-            cls.from_obj(row, *args, **pd_kwargs, **kwargs) for _, row in obj.iterrows()
-        ]
-
-    @from_obj.register(BaseModel)
-    @classmethod
-    def _from_base_model(cls, obj: BaseModel, pydantic_kwargs=None, **kwargs) -> T:
-        if pydantic_kwargs is None:
-            pydantic_kwargs = {"by_alias": True}
-        config_ = {**obj.model_dump(**pydantic_kwargs), **kwargs}
-        return cls.from_obj(**config_)
-
-
-class BaseMetaManageMixin(ABC, BaseModel):
-
-    def meta_keys(self, flattened: bool = False, **kwargs) -> list[str]:
-        """
-        Retrieves a list of metadata keys.
-
-        Args:
-                flattened (bool): If True, returns keys from a flattened metadata structure.
-                **kwargs: Additional keyword arguments passed to the flattening function.
-
-        Returns:
-                list[str]: List of metadata keys.
-        """
-        if flattened:
-            return nested.get_flattened_keys(self.metadata, **kwargs)
-        return list(self.metadata.keys())
-
-    def meta_has_key(self, key: str, flattened: bool = False, **kwargs) -> bool:
-        """
-        Checks if a specified key exists in the metadata.
-
-        Args:
-                key (str): The key to check.
-                flattened (bool): If True, checks within a flattened metadata structure.
-                **kwargs: Additional keyword arguments for flattening.
-
-        Returns:
-                bool: True if key exists, False otherwise.
-        """
-        if flattened:
-            return key in nested.get_flattened_keys(self.metadata, **kwargs)
-        return key in self.metadata
-
-    def meta_get(
-        self, key: str, indices: list[str | int] = None, default: Any = None
-    ) -> Any:
-        """
-        Retrieves the value associated with a given key from the metadata.
-
-        Args:
-                key (str): The key for the desired value.
-                indices: Optional indices for nested retrieval.
-                default (Any): The default value to return if the key is not found.
-
-        Returns:
-                Any: The value associated with the key or the default value.
-        """
-        if indices:
-            return nested.nget(self.metadata, key, indices, default)
-        return self.metadata.get(key, default)
-
-    def meta_change_key(self, old_key: str, new_key: str) -> bool:
-        """
-        Renames a key in the metadata.
-
-        Args:
-                old_key (str): The current key name.
-                new_key (str): The new key name.
-
-        Returns:
-                bool: True if the key was changed, False otherwise.
-        """
-        if old_key in self.metadata:
-            SysUtil.change_dict_key(self.metadata, old_key, new_key)
-            return True
-        return False
-
-    def meta_insert(self, indices: str | list, value: Any, **kwargs) -> bool:
-        """
-        Inserts a value into the metadata at specified indices.
-
-        Args:
-                indices (str | list): The indices where the value should be inserted.
-                value (Any): The value to insert.
-                **kwargs: Additional keyword arguments.
-
-        Returns:
-                bool: True if the insertion was successful, False otherwise.
-        """
-        return nested.ninsert(self.metadata, indices, value, **kwargs)
-
-    # ToDo: do a nested pop
-    def meta_pop(self, key: str, default: Any = None) -> Any:
-        """
-        Removes a key from the metadata and returns its value.
-
-        Args:
-                key (str): The key to remove.
-                default (Any): The default value to return if the key is not found.
-
-        Returns:
-                Any: The value of the removed key or the default value.
-        """
-        return self.metadata.pop(key, default)
-
-    def meta_merge(
-        self, additional_metadata: dict[str, Any], overwrite: bool = False, **kwargs
-    ) -> None:
-        """
-        Merges additional metadata into the existing metadata.
-
-        Args:
-                additional_metadata (dict[str, Any]): The metadata to merge in.
-                overwrite (bool): If True, existing keys will be overwritten by those in additional_metadata.
-                **kwargs: Additional keyword arguments for the merge.
-
-        Returns:
-                None
-        """
-        nested.nmerge(
-            [self.metadata, additional_metadata], overwrite=overwrite, **kwargs
-        )
-
-        for key, value in additional_metadata.items():
-            if overwrite or key not in self.metadata:
-                self.metadata[key] = value
-
-    def meta_clear(self) -> None:
-        """
-        Clears all metadata.
-
-        Returns:
-                None
-        """
-        self.metadata.clear()
-
-    def meta_filter(self, condition: Callable[[Any, Any], bool]) -> dict[str, Any]:
-        """
-        Filters the metadata based on a condition.
-
-        Args:
-                condition (Callable[[Any, Any], bool]): The condition function to apply.
-
-        Returns:
-                dict[str, Any]: The filtered metadata.
-        """
-        return nested.nfilter(self.metadata, condition)
-
-
-class BaseComponentMixin(BaseFromObjectMixin, BaseToObjectMixin, BaseMetaManageMixin):
-    pass