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

lionagi/core/rule/base.py

@@ -1,234 +0,0 @@
-from abc import abstractmethod
-from typing import Any, Dict, List
-
-from pandas import Series
-
-from lionagi.core.collections.abc import (
-    Actionable,
-    Component,
-    Condition,
-    FieldError,
-)
-from lionagi.libs import SysUtil
-
-_rule_classes = {}
-
-
-class Rule(Component, Condition, Actionable):
-    """
-    Combines a condition and an action that can be applied based on it.
-
-    Attributes:
-        apply_type (str): The type of data to which the rule applies.
-        fix (bool): Indicates whether the rule includes a fix action.
-        fields (list[str]): List of fields to which the rule applies.
-        validation_kwargs (dict): Keyword arguments for validation.
-        applied_log (list): Log of applied rules.
-        invoked_log (list): Log of invoked rules.
-        _is_init (bool): Indicates whether the rule is initialized.
-    """
-
-    exclude_type: list[str] = []
-    apply_type: list[str] | str = None
-    fix: bool = True
-    fields: list[str] = []
-    validation_kwargs: dict = {}
-    applied_log: list = []
-    invoked_log: list = []
-    _is_init: bool = False
-
-    def __init_subclass__(cls, **kwargs):
-        super().__init_subclass__(**kwargs)
-        if cls.__name__ not in _rule_classes:
-            _rule_classes[cls.__name__] = cls
-
-    def add_log(
-        self, field: str, form: Any, apply: bool = True, **kwargs
-    ) -> None:
-        """
-        Adds an entry to the applied or invoked log.
-
-        Args:
-            field (str): The field being validated.
-            form (Any): The form being validated.
-            apply (bool): Indicates whether the log is for an applied rule.
-            **kwargs: Additional configuration parameters.
-        """
-        a = {
-            "type": "rule",
-            "class": self.class_name,
-            "ln_id": self.ln_id,
-            "timestamp": SysUtil.get_timestamp(sep=None)[:-6],
-            "field": field,
-            "form": form.ln_id,
-            "config": kwargs,
-        }
-        if apply:
-            self.applied_log.append(a)
-        else:
-            self.invoked_log.append(a)
-
-    async def applies(
-        self,
-        field: str,
-        value: Any,
-        form: Any,
-        *args,
-        annotation: list[str] = None,
-        use_annotation: bool = True,
-        **kwargs,
-    ) -> bool:
-        """
-        Determines whether the rule applies to a given field and value.
-
-        Args:
-            field (str): The field being validated.
-            value (Any): The value of the field.
-            form (Any): The form being validated.
-            *args: Additional arguments.
-            annotation (list[str], optional): Annotations for the field.
-            use_annotation (bool): Indicates whether to use annotations.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            bool: True if the rule applies, otherwise False.
-        """
-        if self.fields:
-            if field in self.fields:
-                self.add_log(field, form, **kwargs)
-                return True
-
-        if use_annotation:
-            annotation = annotation or form._get_field_annotation(field)
-            annotation = (
-                [annotation] if isinstance(annotation, str) else annotation
-            )
-
-            for i in annotation:
-                if i in self.apply_type and i not in self.exclude_type:
-                    self.add_log(field, form, **kwargs)
-                    return True
-            return False
-
-        a = await self.rule_condition(field, value, *args, **kwargs)
-
-        if a:
-            self.add_log(field, form, **kwargs)
-            return True
-        return False
-
-    async def invoke(self, field: str, value: Any, form: Any) -> Any:
-        """
-        Invokes the rule's validation logic on a field and value.
-
-        Args:
-            field (str): The field being validated.
-            value (Any): The value of the field.
-            form (Any): The form being validated.
-
-        Returns:
-            Any: The validated or fixed value.
-
-        Raises:
-            ValueError: If validation or fixing fails.
-        """
-        try:
-            a = await self.validate(value, **self.validation_kwargs)
-            self.add_log(field, form, apply=False, **self.validation_kwargs)
-            return a
-
-        except Exception as e1:
-            if self.fix:
-                try:
-                    a = await self.perform_fix(value, **self.validation_kwargs)
-                    self.add_log(
-                        field, form, apply=False, **self.validation_kwargs
-                    )
-                    return a
-                except Exception as e2:
-                    raise FieldError(f"failed to fix field") from e2
-            raise FieldError(f"failed to validate field") from e1
-
-    async def rule_condition(self, field, value, *args, **kwargs) -> bool:
-        """
-        Additional condition, if choosing not to use annotation as a qualifier.
-
-        Args:
-            *args: Additional arguments.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            bool: False by default, should be overridden by subclasses.
-        """
-        return False
-
-    async def perform_fix(self, value: Any, *args, **kwargs) -> Any:
-        """
-        Attempts to fix a value if validation fails.
-
-        Args:
-            value (Any): The value to fix.
-            *args: Additional arguments.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Any: The fixed value.
-
-        Raises:
-            ValueError: If the fix fails.
-        """
-        return value
-
-    @abstractmethod
-    async def validate(self, value: Any) -> Any:
-        """
-        Abstract method to validate a value.
-
-        Args:
-            value (Any): The value to validate.
-
-        Returns:
-            Any: The validated value.
-
-        Raises:
-            ValueError: If validation fails.
-        """
-        pass
-
-    def _to_dict(self) -> dict[str, Any]:
-        """
-        Converts the rule's attributes to a dictionary.
-
-        Returns:
-            dict: A dictionary representation of the rule.
-        """
-        return {
-            "ln_id": self.ln_id[:8] + "...",
-            "rule": self.__class__.__name__,
-            "apply_type": self.apply_type,
-            "fix": self.fix,
-            "fields": self.fields,
-            "validation_kwargs": self.validation_kwargs,
-            "num_applied": len(self.applied_log),
-            "num_invoked": len(self.invoked_log),
-        }
-
-    def __str__(self) -> str:
-        """
-        Returns a string representation of the rule using a pandas Series.
-
-        Returns:
-            str: A string representation of the rule.
-        """
-        series = Series(self._to_dict())
-        return series.__str__()
-
-    def __repr__(self) -> str:
-        """
-        Returns a string representation of the rule using a pandas Series.
-
-        Returns:
-            str: A string representation of the rule.
-        """
-        series = Series(self._to_dict())
-        return series.__repr__()

lionagi/core/rule/boolean.py

@@ -1,56 +0,0 @@
-from typing import Any
-
-from lionagi.core.rule.base import Rule
-
-
-class BooleanRule(Rule):
-    """
-    Rule for validating that a value is a boolean.
-
-    Attributes:
-        apply_type (str): The type of data to which the rule applies.
-    """
-
-    fields: list[str] = ["action_required"]
-
-    def __init__(self, apply_type="bool", **kwargs):
-        super().__init__(apply_type=apply_type, **kwargs)
-
-    async def validate(self, value: Any) -> bool:
-        """
-        Validate that the value is a boolean.
-
-        Args:
-            value (Any): The value to validate.
-
-        Returns:
-            bool: The validated value.
-
-        Raises:
-            ValueError: If the value is not a valid boolean.
-        """
-        if isinstance(value, bool):
-            return value
-        raise ValueError(f"Invalid boolean value.")
-
-    async def perform_fix(self, value: Any) -> bool:
-        """
-        Attempt to fix the value by converting it to a boolean.
-
-        Args:
-            value (Any): The value to fix.
-
-        Returns:
-            bool: The fixed value.
-
-        Raises:
-            ValueError: If the value cannot be converted to a boolean.
-        """
-        value = str(value).strip().lower()
-        if value in ["true", "1", "correct", "yes"]:
-            return True
-
-        elif value in ["false", "0", "incorrect", "no", "none", "n/a"]:
-            return False
-
-        raise ValueError(f"Failed to convert {value} into a boolean value")

lionagi/core/rule/choice.py

@@ -1,48 +0,0 @@
-from lionfuncs import string_similarity
-
-from lionagi.core.rule.base import Rule
-
-
-class ChoiceRule(Rule):
-    """
-    Rule for validating that a value is within a set of predefined choices.
-
-    Attributes:
-        apply_type (str): The type of data to which the rule applies.
-        keys (list): The list of valid choices.
-    """
-
-    def __init__(self, apply_type="enum", **kwargs):
-        super().__init__(apply_type=apply_type, **kwargs)
-        self.keys = self.validation_kwargs.get("keys", None)
-
-    async def validate(self, value: str, *args, **kwargs) -> str:
-        """
-        Validate that the value is within the set of predefined choices.
-
-        Args:
-            value (str): The value to validate.
-            *args: Additional arguments.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            str: The validated value.
-
-        Raises:
-            ValueError: If the value is not in the set of choices.
-        """
-        if not value in self.keys:
-            raise ValueError(f"{value} is not in chocies {self.keys}")
-        return value
-
-    async def perform_fix(self, value):
-        """
-        Suggest a fix for a value that is not within the set of predefined choices.
-
-        Args:
-            value (str): The value to suggest a fix for.
-
-        Returns:
-            str: The most similar value from the set of predefined choices.
-        """
-        return string_similarity(value, self.keys, choose_most_similar=True)

lionagi/core/rule/mapping.py

@@ -1,82 +0,0 @@
-from collections.abc import Mapping
-from typing import Any
-
-from lionfuncs import to_dict, validate_mapping
-
-from lionagi.core.rule.choice import ChoiceRule
-
-
-class MappingRule(ChoiceRule):
-    """
-    Rule for validating that a value is a mapping (dictionary) with specific keys.
-
-    Attributes:
-        apply_type (str): The type of data to which the rule applies.
-    """
-
-    def __init__(self, apply_type="dict", **kwargs):
-        super().__init__(apply_type=apply_type, **kwargs)
-
-    async def validate(self, value: Any, *args, **kwargs) -> Any:
-        """
-        Validate that the value is a mapping with specific keys.
-
-        Args:
-            value (Any): The value to validate.
-            *args: Additional arguments.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Any: The validated value.
-
-        Raises:
-            ValueError: If the value is not a valid mapping or has incorrect keys.
-        """
-        if not isinstance(value, Mapping):
-            raise ValueError("Invalid mapping field type.")
-
-        if self.keys:
-            if (keys := set(value.keys())) != set(self.keys):
-                raise ValueError(
-                    f"Invalid mapping keys. Current keys {[i for i in keys]} != {self.keys}"
-                )
-        return value
-
-    async def perform_fix(self, value: Any, *args, **kwargs) -> Any:
-        """
-        Attempt to fix the value by converting it to a dict and validating its keys.
-
-        Args:
-            value (Any): The value to fix.
-            *args: Additional arguments.
-            **kwargs: Additional keyword arguments.
-
-        Returns:
-            Any: The fixed value.
-
-        Raises:
-            ValueError: If the value cannot be fixed.
-        """
-        if not isinstance(value, dict):
-            try:
-                value = to_dict(value)
-            except Exception as e:
-                raise ValueError("Invalid dict field type.") from e
-
-        if self.keys:
-            check_keys = set(value.keys())
-            if check_keys != set(self.keys):
-                try:
-                    return validate_mapping(
-                        value, keys=self.keys, handle_unmatched="force"
-                    )
-                except Exception as e:
-                    raise ValueError("Invalid dict keys.") from e
-
-        else:
-            try:
-                return to_dict(value, fuzzy_parse=True)
-            except Exception as e:
-                raise ValueError("Invalid dict keys.") from e
-
-        return value

lionagi/core/rule/number.py

@@ -1,73 +0,0 @@
-from typing import Any
-
-from lionfuncs import to_num
-
-from lionagi.core.rule.base import Rule
-
-
-class NumberRule(Rule):
-    """
-    Rule for validating that a value is a number within specified bounds.
-
-    Attributes:
-        apply_type (str): The type of data to which the rule applies.
-        upper_bound (int | float | None): The upper bound for the value.
-        lower_bound (int | float | None): The lower bound for the value.
-        num_type (Type[int | float]): The type of number (int or float).
-        precision (int | None): The precision for floating point numbers.
-    """
-
-    fields: list[str] = ["confidence_score", "score"]
-
-    def __init__(self, apply_type="int, float", **kwargs):
-        super().__init__(apply_type=apply_type, **kwargs)
-        self.upper_bound = self.validation_kwargs.get("upper_bound")
-        self.lower_bound = self.validation_kwargs.get("lower_bound")
-        self.num_type = self.validation_kwargs.get("num_type", float)
-        self.precision = self.validation_kwargs.get("precision")
-
-    async def validate(self, value: Any) -> Any:
-        """
-        Validate that the value is a number.
-
-        Args:
-            value (Any): The value to validate.
-
-        Returns:
-            Any: The validated value.
-
-        Raises:
-            ValueError: If the value is not a valid number.
-        """
-        if isinstance(value, (int, float)):
-            return value
-        raise ValueError(f"Invalid number field: {value}")
-
-    async def perform_fix(self, value: Any) -> Any:
-        """
-        Attempt to fix the value by converting it to a number.
-
-        Args:
-            value (Any): The value to fix.
-
-        Returns:
-            Any: The fixed value.
-
-        Raises:
-            ValueError: If the value cannot be converted to a number.
-        """
-        if isinstance(value, (int, float)):
-            return value
-
-        value = to_num(
-            value,
-            **{
-                k: v
-                for k, v in self.validation_kwargs.items()
-                if k in ["num_type", "precision", "upper_bound", "lower_bound"]
-            },
-        )
-
-        if isinstance(value, (int, float)):
-            return value
-        raise ValueError(f"Failed to convert {value} into a numeric value")

lionagi/core/rule/rulebook.py

@@ -1,45 +0,0 @@
-from lionfuncs import lcall
-
-from lionagi.core.rule.base import Rule
-
-"""
-rule config schema
-
-{
-    rule_name: {
-        "fields: [],
-        "config": {},
-        ...
-    }
-}
-"""
-
-
-class RuleBook:
-
-    def __init__(
-        self,
-        rules: dict[str, Rule] | list[Rule] = None,
-        ruleorder: list[str] = None,
-        rule_config: dict[str, dict] = None,
-    ):
-        self.rules = rules
-        self.ruleorder = ruleorder
-        self.rule_config = rule_config or {k: {} for k in self.ruleorder}
-
-    @property
-    def _all_applied_log(self):
-        """return all applied logs from all rules in the rulebook"""
-        return lcall(
-            self.rules.values(), lambda x: x.applied_log, flatten=True
-        )
-
-    @property
-    def _all_invoked_log(self):
-        """return all invoked logs from all rules in the rulebook"""
-        return lcall(
-            self.rules.values(), lambda x: x.invoked_log, flatten=True
-        )
-
-    def __getitem__(self, key: str) -> Rule:
-        return self.rules[key]

lionagi/core/rule/string.py

@@ -1,43 +0,0 @@
-from lionfuncs import to_str
-
-from lionagi.core.rule.base import Rule
-
-
-class StringRule(Rule):
-    """
-    Rule for validating and converting string values.
-
-    Attributes:
-        fields (list[str]): The list of fields to which the rule applies.
-        apply_type (str): The type of data to which the rule applies.
-    """
-
-    fields: list[str] = ["reason", "prediction", "answer"]
-
-    def __init__(self, apply_type="str", **kwargs):
-        super().__init__(apply_type=apply_type, **kwargs)
-
-    async def validate(self, value):
-        """
-        Validate that the value is a string.
-
-        Args:
-            value: The value to validate.
-
-        Returns:
-            str: The validated string value.
-
-        Raises:
-            ValueError: If the value is not a string or is an empty string.
-        """
-        if isinstance(value, str) or value == "":
-            return value
-        raise ValueError(f"Invalid string field type.")
-
-    async def perform_fix(self, value):
-        try:
-            return to_str(value, **self.validation_kwargs)
-        except Exception as e:
-            raise ValueError(
-                f"Failed to convert {value} into a string value"
-            ) from e