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

lionagi/core/generic/edge.py

@@ -1,15 +1,15 @@
 """
-Module for representing conditions and edges between nodes in a graph structure.
+Module for representing conditions and edges between nodes in a graph.
 
-This module provides the base for creating and managing edges that connect nodes
-within a graph. It includes support for conditional edges, allowing the dynamic
-evaluation of connections based on custom logic.
+This module provides the base for creating and managing edges that connect
+nodes within a graph. It includes support for conditional edges, allowing
+the dynamic evaluation of connections based on custom logic.
 """
 
 from typing import Any
 from pydantic import Field, field_validator
-from lionagi.core.generic.component import BaseComponent, BaseNode
-from lionagi.core.generic.condition import Condition
+from .component import BaseComponent
+from .condition import Condition
 
 
 class Edge(BaseComponent):
@@ -19,12 +19,14 @@ class Edge(BaseComponent):
     Attributes:
         head (str): The identifier of the head node of the edge.
         tail (str): The identifier of the tail node of the edge.
-        condition (Optional[Condition]): An optional condition that must be met
+        condition (Condition | None): Optional condition that must be met
             for the edge to be considered active.
-        label (Optional[str]): An optional label for the edge.
+        label (str | None): An optional label for the edge.
+        bundle (bool): A flag indicating if the edge is bundled.
 
     Methods:
-        check_condition: Evaluates if the condition associated with the edge is met.
+        check_condition: Evaluates if the condition is met.
+        string_condition: Retrieves the condition class source code.
     """
 
     head: str = Field(
@@ -37,7 +39,8 @@ class Edge(BaseComponent):
     )
     condition: Condition | None = Field(
         default=None,
-        description="An optional condition that must be met for the edge to be considered active.",
+        description="Optional condition that must be met for the edge "
+                    "to be considered active.",
     )
     label: str | None = Field(
         default=None,
@@ -51,20 +54,19 @@ class Edge(BaseComponent):
     @field_validator("head", "tail", mode="before")
     def _validate_head_tail(cls, value):
         """
-        Validates the head and tail fields to ensure they are valid node identifiers.
+        Validates head and tail fields to ensure valid node identifiers.
 
         Args:
-            value: The value of the field being validated.
-            values: A dictionary of all other values on the model.
-            field: The model field being validated.
+            value (Any): The value of the field being validated.
 
         Returns:
-            The validated value, ensuring it is a valid identifier.
+            str: The validated value, ensuring it is a valid identifier.
 
         Raises:
             ValueError: If the validation fails.
         """
-        if isinstance(value, BaseNode):
+
+        if isinstance(value, BaseComponent):
             return value.id_
         return value
 
@@ -73,7 +75,7 @@ class Edge(BaseComponent):
         Evaluates if the condition associated with the edge is met.
 
         Args:
-            obj (dict[str, Any]): The context object used for condition evaluation.
+            obj (dict[str, Any]): Context for condition evaluation.
 
         Returns:
             bool: True if the condition is met, False otherwise.
@@ -87,19 +89,23 @@ class Edge(BaseComponent):
 
     def string_condition(self):
         """
-        Retrieves the source code of the condition class associated with this edge as a string.
+        Retrieves the condition class source code as a string.
 
-        This method is useful for serialization and debugging, allowing the condition logic to be inspected or stored
-        in a human-readable format. It employs advanced introspection techniques to locate and extract the exact class
-        definition, handling edge cases like dynamically defined classes or classes defined in interactive environments.
+        This method is useful for serialization and debugging, allowing
+        the condition logic to be inspected or stored in a human-readable
+        format. It employs advanced introspection techniques to locate and
+        extract the exact class definition, handling edge cases like
+        dynamically defined classes or classes defined interactively.
 
         Returns:
-            str: The source code of the condition's class, if available. If the condition is None or the source code
-                cannot be located, this method returns None.
+            str | None: The condition class source code if available.
+                If the condition is None or the source code cannot be
+                located, this method returns None.
 
         Raises:
-            TypeError: If the source code of the condition's class cannot be found due to the class being defined in a
-                non-standard manner or in the interactive interpreter (__main__ context).
+            TypeError: If the condition class source code cannot be found
+                due to the class being defined in a non-standard manner or
+                in the interactive interpreter (__main__ context).
         """
         if self.condition is None:
             return
@@ -139,9 +145,8 @@ class Edge(BaseComponent):
 
     def __str__(self) -> str:
         """
-        Returns a simple string representation of the Relationship.
+        Returns a simple string representation of the Edge.
         """
-
         return (
             f"Edge (id_={self.id_}, from={self.head}, to={self.tail}, "
             f"label={self.label})"
@@ -149,12 +154,7 @@ class Edge(BaseComponent):
 
     def __repr__(self) -> str:
         """
-        Returns a detailed string representation of the Relationship.
-
-        Examples:
-            >>> edge = Relationship(source_node_id="node1", target_node_id="node2")
-            >>> repr(edge)
-            'Relationship(id_=None, from=node1, to=node2, content=None, metadata=None, label=None)'
+        Returns a detailed string representation of the Edge.
         """
         return (
             f"Edge(id_={self.id_}, from={self.head}, to={self.tail}, "

lionagi/core/graph/graph.py

@@ -92,7 +92,7 @@ class Graph(BaseStructure):
         for node_id, node in self.internal_nodes.items():
             node_info = node.to_dict()
             node_info.pop("id_")
-            node_info.update({"class_name": node.class_name()})
+            node_info.update({"class_name": node.class_name})
             g.add_node(node_id, **node_info)
 
         for _edge in list(self.internal_edges.values()):

lionagi/core/tool/tool_manager.py

@@ -159,15 +159,16 @@ class ToolManager:
                 else:
                     raise ValueError(f"Function {tool} is not registered.")
 
-        if isinstance(tools, bool):
-            tool_kwarg = {"tools": self.to_tool_schema_list()}
-            kwargs = tool_kwarg | kwargs
-
-        else:
-            if not isinstance(tools, list):
-                tools = [tools]
-            tool_kwarg = {"tools": func_call.lcall(tools, tool_check)}
-            kwargs = tool_kwarg | kwargs
+        if tools:
+            if isinstance(tools, bool):
+                tool_kwarg = {"tools": self.to_tool_schema_list()}
+                kwargs = tool_kwarg | kwargs
+
+            else:
+                if not isinstance(tools, list):
+                    tools = [tools]
+                tool_kwarg = {"tools": func_call.lcall(tools, tool_check)}
+                kwargs = tool_kwarg | kwargs
 
         return kwargs
 

lionagi/experimental/report/form.py

@@ -0,0 +1,64 @@
+from pydantic import Field
+
+# from lionagi import logging as _logging
+from lionagi.core.generic import BaseComponent
+from lionagi.experimental.report.util import get_input_output_fields, system_fields
+
+
+class Form(BaseComponent):
+
+    assignment: str = Field(..., examples=["input1, input2 -> output"])
+
+    input_fields: list[str] = Field(default_factory=list)
+    output_fields: list[str] = Field(default_factory=list)
+
+    def __init__(self, **kwargs):
+        """
+        at initialization, all relevant fields if not already provided, are set to None,
+        not every field is required to be filled, nor required to be declared at initialization
+        """
+        super().__init__(**kwargs)
+        self.input_fields, self.output_fields = get_input_output_fields(self.assignment)
+        for i in self.input_fields + self.output_fields:
+            if i not in self.model_fields:
+                self._add_field(i, value=None)
+
+    @property
+    def workable(self):
+        if self.filled:
+            return False
+
+        for i in self.input_fields:
+            if not getattr(self, i, None):
+                return False
+
+        return True
+
+    @property
+    def work_fields(self):
+        dict_ = self.to_dict()
+        return {
+            k: v
+            for k, v in dict_.items()
+            if k not in system_fields and k in self.input_fields + self.output_fields
+        }
+
+    @property
+    def filled(self):
+        return all([value is not None for _, value in self.work_fields.items()])
+
+    def fill(self, form: "Form" = None, **kwargs):
+        """
+        only work fields for this form can be filled
+        a field can only be filled once
+        """
+        if self.filled:
+            raise ValueError("Form is already filled")
+
+        fields = form.work_fields if form else {}
+        kwargs = {**fields, **kwargs}
+
+        for k, v in kwargs.items():
+            if k not in self.work_fields:
+                raise ValueError(f"Field {k} is not a valid work field")
+            setattr(self, k, v)

lionagi/experimental/report/report.py

@@ -0,0 +1,138 @@
+from typing import Any, Type
+from pydantic import Field
+
+# from lionagi import logging as _logging
+from lionagi.core.generic import BaseComponent
+from lionagi.experimental.report.form import Form
+from lionagi.experimental.report.util import get_input_output_fields
+
+
+class Report(BaseComponent):
+
+    assignment: str = Field(..., examples=["input1, input2 -> output"])
+
+    forms: dict[str, Form] = Field(
+        default_factory=dict,
+        description="A dictionary of forms related to the report, in {assignment: Form} format.",
+    )
+
+    form_assignments: list = Field(
+        [],
+        description="assignment for the report",
+        examples=[["a, b -> c", "a -> e", "b -> f", "c -> g", "e, f, g -> h"]],
+    )
+
+    form_template: Type[Form] = Field(
+        Form, description="The template for the forms in the report."
+    )
+
+    input_fields: list[str] = Field(default_factory=list)
+    output_fields: list[str] = Field(default_factory=list)
+
+    def __init__(self, **kwargs):
+        """
+        at initialization, all relevant fields if not already provided, are set to None
+        """
+        super().__init__(**kwargs)
+        self.input_fields, self.output_fields = get_input_output_fields(self.assignment)
+
+        # if assignments is not provided, set it to assignment
+        if self.form_assignments == []:
+            self.form_assignments.append(self.assignment)
+
+        # create forms
+        new_forms = {i: self.form_template(assignment=i) for i in self.form_assignments}
+
+        # add new forms into the report (will ignore new forms already in the
+        # report with same assignment)
+        for k, v in new_forms.items():
+            if k not in self.forms:
+                self.forms[k] = v
+
+        # if the fields are not declared in the report, add them to report
+        # with value set to None
+        for k, v in self.forms.items():
+            for f in list(v.work_fields.keys()):
+                if f not in self.model_fields:
+                    field = v.model_fields[f]
+                    self._add_field(f, value=None, field=field)
+
+        # if there are fields in the report that are not in the forms, add them to
+        # the forms with values
+        for k, v in self.model_fields.items():
+            if getattr(self, k, None) is not None:
+                for f in self.forms.values():
+                    if k in f.work_fields:
+                        f.fill(**{k: getattr(self, k)})
+
+    @property
+    def work_fields(self) -> dict[str, Any]:
+        """
+        all work fields across all forms, including intermediate output fields,
+        this information is extracted from the forms
+        """
+
+        all_fields = {}
+        for form in self.forms.values():
+            for k, v in form.work_fields.items():
+                if k not in all_fields:
+                    all_fields[k] = v
+        return all_fields
+
+    def fill(self, **kwargs):
+        """
+        fill the information to both the report and forms
+        """
+        kwargs = {**self.work_fields, **kwargs}
+        for k, v in kwargs.items():
+            if k in self.work_fields and getattr(self, k, None) is None:
+                setattr(self, k, v)
+
+        for form in self.forms.values():
+            if not form.filled:
+                _kwargs = {k: v for k, v in kwargs.items() if k in form.work_fields}
+                form.fill(**_kwargs)
+
+    @property
+    def filled(self):
+        return all([value is not None for _, value in self.work_fields.items()])
+
+    @property
+    def workable(self) -> bool:
+
+        if self.filled:
+            # _logging.info("The report is already filled, no need to work on it.")
+            return False
+
+        for i in self.input_fields:
+            if not getattr(self, i, None):
+                # _logging.error(f"Field '{i}' is required to work on the report.")
+                return False
+
+        # this is the required fields from report's own assignment
+        fields = self.input_fields
+        fields.extend(self.output_fields)
+
+        # if the report's own assignment is not in the forms, return False
+        for f in fields:
+            if f not in self.work_fields:
+                # _logging.error(f"Field {f} is a required deliverable, not found in work field.")
+                return False
+
+        # get all the output fields from all the forms
+        outs = []
+        for form in self.forms.values():
+            outs.extend(form.output_fields)
+
+        # all output fields should be unique, not a single output field should be
+        # calculated by more than one form
+        if len(outs) != len(set(outs)):
+            # _logging.error("There are duplicate output fields in the forms.")
+            return False
+
+        return True
+
+    @property
+    def next_forms(self) -> list[Form] | None:
+        a = [i for i in self.forms.values() if i.workable]
+        return a if len(a) > 0 else None

lionagi/experimental/report/util.py

@@ -0,0 +1,47 @@
+from lionagi.libs import convert
+
+system_fields = [
+    "id_",
+    "node_id",
+    "meta",
+    "metadata",
+    "timestamp",
+    "content",
+    "assignment",
+    "assignments",
+    "task",
+    "template_name",
+    "version",
+    "description",
+    "in_validation_kwargs",
+    "out_validation_kwargs",
+    "fix_input",
+    "fix_output",
+    "input_fields",
+    "output_fields",
+    "choices",
+    "prompt_fields",
+    "prompt_fields_annotation",
+    "instruction_context",
+    "instruction",
+    "instruction_output_fields",
+    "inputs",
+    "outputs",
+    "process",
+    "_validate_field",
+    "_process_input",
+    "_process_response",
+    "_validate_field_choices",
+    "_validate_input_choices",
+    "_validate_output_choices",
+]
+
+
+def get_input_output_fields(str_: str) -> list[list[str]]:
+
+    inputs, outputs = str_.split("->")
+
+    input_fields = [convert.strip_lower(i) for i in inputs.split(",")]
+    output_fields = [convert.strip_lower(o) for o in outputs.split(",")]
+
+    return input_fields, output_fields

lionagi/experimental/tool/schema.py

@@ -34,16 +34,16 @@ class Tool(Node):
         out = None
 
         if self.pre_processor:
-            kwargs = await func_call.unified_call(self.pre_processor, kwargs)
+            kwargs = await func_call.call_handler(self.pre_processor, kwargs)
         try:
-            out = await func_call.unified_call(self.func, **kwargs)
+            out = await func_call.call_handler(self.func, **kwargs)
 
         except Exception as e:
             _logging.error(f"Error invoking function {self.func_name}: {e}")
             return None
 
         if self.post_processor:
-            return await func_call.unified_call(self.post_processor, out)
+            return await func_call.call_handler(self.post_processor, out)
 
         return out
 

lionagi/experimental/tool/tool_manager.py

@@ -75,7 +75,7 @@ class ToolManager:
         func = tool.func
         parser = tool.parser
         try:
-            out = await func_call.unified_call(func, **kwargs)
+            out = await func_call.call_handler(func, **kwargs)
             return parser(out) if parser else out
 
         except Exception as e:

lionagi/experimental/validator/rule.py

@@ -0,0 +1,139 @@
+from lionagi.libs import validation_funcs
+from abc import abstractmethod
+
+
+class Rule:
+
+    def __init__(self, **kwargs):
+        self.validation_kwargs = kwargs
+        self.fix = kwargs.get("fix", False)
+
+    @abstractmethod
+    def condition(self, **kwargs):
+        pass
+
+    @abstractmethod
+    async def validate(self, value, **kwargs):
+        pass
+
+
+class ChoiceRule(Rule):
+
+    def condition(self, choices=None):
+        return choices is not None
+
+    def check(self, choices=None):
+        if choices and not isinstance(choices, list):
+            try:
+                choices = [i.value for i in choices]
+            except Exception as e:
+                raise ValueError(f"failed to get choices") from e
+        return choices
+
+    def fix(self, value, choices=None, **kwargs):
+        v_ = validation_funcs["enum"](value, choices=choices, fix_=True, **kwargs)
+        return v_
+
+    async def validate(self, value, choices=None, **kwargs):
+        if self.condition(choices):
+            if value in self.check(choices):
+                return value
+            if self.fix:
+                kwargs = {**self.validation_kwargs, **kwargs}
+                return self.fix(value, choices, **kwargs)
+            raise ValueError(f"{value} is not in chocies {choices}")
+
+
+class ActionRequestRule(Rule):
+
+    def condition(self, annotation=None):
+        return any("actionrequest" in i for i in annotation)
+
+    async def validate(self, value, annotation=None):
+        if self.condition(annotation):
+            try:
+                return validation_funcs["action"](value)
+            except Exception as e:
+                raise ValueError(f"failed to validate field") from e
+
+
+class BooleanRule(Rule):
+
+    def condition(self, annotation=None):
+        return "bool" in annotation and "str" not in annotation
+
+    async def validate(self, value, annotation=None):
+        if self.condition(annotation):
+            try:
+                return validation_funcs["bool"](
+                    value, fix_=self.fix, **self.validation_kwargs
+                )
+            except Exception as e:
+                raise ValueError(f"failed to validate field") from e
+
+
+class NumberRule(Rule):
+
+    def condition(self, annotation=None):
+        return (
+            any([i in annotation for i in ["int", "float", "number"]])
+            and "str" not in annotation
+        )
+
+    async def validate(self, value, annotation=None):
+        if self.condition(annotation):
+            if "float" in annotation:
+                self.validation_kwargs["num_type"] = float
+                if "precision" not in self.validation_kwargs:
+                    self.validation_kwargs["precision"] = 32
+
+            try:
+                return validation_funcs["number"](
+                    value, fix_=self.fix, **self.validation_kwargs
+                )
+            except Exception as e:
+                raise ValueError(f"failed to validate field") from e
+
+
+class DictRule(Rule):
+
+    def condition(self, annotation=None):
+        return "dict" in annotation
+
+    async def validate(self, value, annotation=None, keys=None):
+        if self.condition(annotation):
+            if "str" not in annotation or keys:
+                try:
+                    return validation_funcs["dict"](
+                        value, keys=keys, fix_=self.fix, **self.validation_kwargs
+                    )
+                except Exception as e:
+                    raise ValueError(f"failed to validate field") from e
+            raise ValueError(f"failed to validate field")
+
+
+class StringRule(Rule):
+
+    def condition(self, annotation=None):
+        return "str" in annotation
+
+    async def validate(self, value, annotation=None):
+        if self.condition(annotation):
+            try:
+                return validation_funcs["str"](
+                    value, fix_=self.fix, **self.validation_kwargs
+                )
+            except Exception as e:
+                raise ValueError(f"failed to validate field") from e
+
+
+from enum import Enum
+
+
+class DEFAULT_RULES(Enum):
+    CHOICE = ChoiceRule
+    ACTION_REQUEST = ActionRequestRule
+    BOOL = BooleanRule
+    NUMBER = NumberRule
+    DICT = DictRule
+    STR = StringRule

lionagi/experimental/validator/validator.py

@@ -0,0 +1,56 @@
+from pydantic import BaseModel, Field
+from .rule import DEFAULT_RULES, Rule
+
+
+rules_ = {
+    "choice": DEFAULT_RULES.CHOICE.value,
+    "actionrequest": DEFAULT_RULES.ACTION_REQUEST.value,
+    "bool": DEFAULT_RULES.BOOL.value,
+    "number": DEFAULT_RULES.NUMBER.value,
+    "dict": DEFAULT_RULES.DICT.value,
+    "str": DEFAULT_RULES.STR.value,
+}
+
+order_ = [
+    "choice",
+    "actionrequest",
+    "bool",
+    "number",
+    "dict",
+    "str",
+]
+
+
+class Validator(BaseModel):
+    """
+    rules contain all rules that this validator can apply to data
+    the order determines which rule gets applied in what sequence.
+    notice, if a rule is not present in the orders, it will not be applied.
+    """
+
+    rules: dict[str, Rule] = Field(
+        default=rules_,
+        description="The rules to be used for validation.",
+    )
+
+    order: list[str] = Field(
+        default=order_,
+        description="The order in which the rules should be applied.",
+    )
+
+    async def validate(self, value, *args, strict=False, **kwargs):
+
+        for i in self.order:
+            if i in self.rules:
+                try:
+                    if (
+                        a := await self.rules[i].validate(value, *args, **kwargs)
+                        is not None
+                    ):
+                        return a
+                except Exception as e:
+                    raise ValueError(f"failed to validate field") from e
+        if strict:
+            raise ValueError(f"failed to validate field")
+
+        return value

lionagi/experimental/work/__init__.py

@@ -0,0 +1,10 @@
+from .schema import WorkLog
+from .work_function import WorkFunction, work
+from .worker import Worker
+
+__all__ = [
+    "WorkLog",
+    "WorkFunction",
+    "work",
+    "Worker",
+]