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

lionagi/core/unit/util.py

@@ -0,0 +1,71 @@
+retry_kwargs = {
+    "retries": 0,  # kwargs for rcall, number of retries if failed
+    "delay": 0,  # number of seconds to delay before retrying
+    "backoff_factor": 1,  # exponential backoff factor, default 1 (no backoff)
+    "default": None,  # default value to return if all retries failed
+    "timeout": None,  # timeout for the rcall, default None (no timeout)
+    "timing": False,  # if timing will return a tuple (output, duration)
+}
+
+oai_fields = [
+    "id",
+    "object",
+    "created",
+    "model",
+    "choices",
+    "usage",
+    "system_fingerprint",
+]
+
+choices_fields = ["index", "message", "logprobs", "finish_reason"]
+
+usage_fields = ["prompt_tokens", "completion_tokens", "total_tokens"]
+
+from typing import Callable
+from lionagi.core.action.tool import Tool
+from lionagi.core.action.tool_manager import func_to_tool
+
+
+def process_tools(tool_obj, branch):
+    if isinstance(tool_obj, Callable):
+        _process_tool(tool_obj, branch)
+    else:
+        if isinstance(tool_obj, bool):
+            return
+        for i in tool_obj:
+            _process_tool(i, branch)
+
+
+def _process_tool(tool_obj, branch):
+    if (
+        isinstance(tool_obj, Tool)
+        and tool_obj.schema_["function"]["name"] not in branch.tool_manager.registry
+    ):
+        branch.register_tools(tool_obj)
+    if isinstance(tool_obj, Callable):
+        tool = func_to_tool(tool_obj)[0]
+        if tool.schema_["function"]["name"] not in branch.tool_manager.registry:
+            branch.register_tools(tool)
+
+
+async def _direct(
+    directive,
+    form=None,
+    template=None,
+    reason=False,
+    confidence_score=None,
+    instruction=None,
+    context=None,
+    template_kwargs={},
+    **kwargs,
+):
+    if not form:
+        form = template(
+            instruction=instruction,
+            context=context,
+            confidence_score=confidence_score,
+            reason=reason,
+            **template_kwargs,
+        )
+
+    return await directive.direct(form=form, return_form=True, **kwargs)

lionagi/core/validator/validator.py

@@ -0,0 +1,364 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from typing import Any, Dict, List, Union
+from lionagi.libs import SysUtil
+from lionagi.libs.ln_func_call import lcall
+from lionagi.core.collections.abc import FieldError
+from ..rule.base import Rule
+from ..rule._default import DEFAULT_RULES
+from ..rule.rulebook import RuleBook
+from ..report.form import Form
+from ..report.report import Report
+
+_DEFAULT_RULEORDER = [
+    "choice",
+    "actionrequest",
+    "number",
+    "mapping",
+    "str",
+    "bool",
+]
+
+_DEFAULT_RULES = {
+    "choice": DEFAULT_RULES.CHOICE.value,
+    "actionrequest": DEFAULT_RULES.ACTION.value,
+    "bool": DEFAULT_RULES.BOOL.value,
+    "number": DEFAULT_RULES.NUMBER.value,
+    "mapping": DEFAULT_RULES.MAPPING.value,
+    "str": DEFAULT_RULES.STR.value,
+}
+
+
+class Validator:
+    """
+    Validator class to manage the validation of forms using a RuleBook.
+    """
+
+    def __init__(
+        self,
+        *,
+        rulebook: RuleBook = None,
+        rules: Dict[str, Rule] = None,
+        order: List[str] = None,
+        init_config: Dict[str, Dict] = None,
+        active_rules: Dict[str, Rule] = None,
+    ):
+        """
+        Initialize the Validator.
+
+        Args:
+            rulebook (RuleBook, optional): The RuleBook containing validation rules.
+            rules (Dict[str, Rule], optional): Dictionary of validation rules.
+            order (List[str], optional): List defining the order of rule application.
+            init_config (Dict[str, Dict], optional): Configuration for initializing rules.
+            active_rules (Dict[str, Rule], optional): Dictionary of currently active rules.
+        """
+
+        self.ln_id: str = SysUtil.create_id()
+        self.timestamp: str = SysUtil.get_timestamp(sep=None)[:-6]
+        self.rulebook = rulebook or RuleBook(
+            rules or _DEFAULT_RULES, order or _DEFAULT_RULEORDER, init_config
+        )
+        self.active_rules: Dict[str, Rule] = active_rules or self._initiate_rules()
+        self.validation_log = []
+
+    def _initiate_rules(self) -> Dict[str, Rule]:
+        """
+        Initialize rules from the rulebook.
+
+        Returns:
+            dict: A dictionary of active rules.
+        """
+
+        def _init_rule(rule_name: str) -> Rule:
+
+            if not issubclass(self.rulebook[rule_name], Rule):
+                raise FieldError(
+                    f"Invalid rule class for {rule_name}, must be a subclass of Rule"
+                )
+
+            _config = self.rulebook.rule_config[rule_name] or {}
+            if not isinstance(_config, dict):
+                raise FieldError(
+                    f"Invalid config for {rule_name}, must be a dictionary"
+                )
+
+            _rule = self.rulebook.rules[rule_name](**_config.get("config", {}))
+            _rule.fields = _config.get("fields", [])
+            _rule._is_init = True
+            return _rule
+
+        _rules = lcall(self.rulebook.ruleorder, _init_rule)
+
+        return {
+            rule_name: _rules[idx]
+            for idx, rule_name in enumerate(self.rulebook.ruleorder)
+            if getattr(_rules[idx], "_is_init", None)
+        }
+
+    async def validate_field(
+        self,
+        field: str,
+        value: Any,
+        form: Form,
+        *args,
+        annotation=None,
+        strict=True,
+        use_annotation=True,
+        **kwargs,
+    ) -> Any:
+        """
+        Validate a specific field in a form.
+
+        Args:
+            field (str): The field to validate.
+            value (Any): The value of the field.
+            form (Form): The form containing the field.
+            *args: Additional arguments.
+            annotation (list[str], optional): Annotations for the field.
+            strict (bool): Whether to enforce strict validation.
+            use_annotation (bool): Whether to use annotations for validation.
+            **kwargs: Additional keyword arguments.
+
+        Returns:
+            Any: The validated value.
+
+        Raises:
+            LionFieldError: If validation fails.
+        """
+        for rule in self.active_rules.values():
+            try:
+                if await rule.applies(
+                    field,
+                    value,
+                    form,
+                    *args,
+                    annotation=annotation,
+                    use_annotation=use_annotation,
+                    **kwargs,
+                ):
+                    return await rule.invoke(field, value, form)
+            except Exception as e:
+                self.log_validation_error(field, value, str(e))
+                raise FieldError(f"Failed to validate {field}") from e
+
+        if strict:
+            error_message = (
+                f"Failed to validate {field} because no rule applied. To return the "
+                f"original value directly when no rule applies, set strict=False."
+            )
+            self.log_validation_error(field, value, error_message)
+            raise FieldError(error_message)
+
+    async def validate_report(
+        self, report: Report, forms: List[Form], strict: bool = True
+    ) -> Report:
+        """
+        Validate a report based on active rules.
+
+        Args:
+            report (Report): The report to validate.
+            forms (list[Form]): A list of forms to include in the report.
+            strict (bool): Whether to enforce strict validation.
+
+        Returns:
+            Report: The validated report.
+        """
+        report.fill(forms, strict=strict)
+        return report
+
+    async def validate_response(
+        self,
+        form: Form,
+        response: Union[dict, str],
+        strict: bool = True,
+        use_annotation: bool = True,
+    ) -> Form:
+        """
+        Validate a response for a given form.
+
+        Args:
+            form (Form): The form to validate against.
+            response (dict | str): The response to validate.
+            strict (bool): Whether to enforce strict validation.
+            use_annotation (bool): Whether to use annotations for validation.
+
+        Returns:
+            Form: The validated form.
+
+        Raises:
+            ValueError: If the response format is invalid.
+        """
+        if isinstance(response, str):
+            if len(form.requested_fields) == 1:
+                response = {form.requested_fields[0]: response}
+            else:
+                raise ValueError(
+                    "Response is a string, but form has multiple fields to be filled"
+                )
+
+        dict_ = {}
+        for k, v in response.items():
+            if k in form.requested_fields:
+                kwargs = form.validation_kwargs.get(k, {})
+                _annotation = form._field_annotations[k]
+                if (keys := form._get_field_attr(k, "choices", None)) is not None:
+                    v = await self.validate_field(
+                        field=k,
+                        value=v,
+                        form=form,
+                        annotation=_annotation,
+                        strict=strict,
+                        keys=keys,
+                        use_annotation=use_annotation,
+                        **kwargs,
+                    )
+
+                elif (_keys := form._get_field_attr(k, "keys", None)) is not None:
+
+                    v = await self.validate_field(
+                        field=k,
+                        value=v,
+                        form=form,
+                        annotation=_annotation,
+                        strict=strict,
+                        keys=_keys,
+                        use_annotation=use_annotation,
+                        **kwargs,
+                    )
+
+                else:
+                    v = await self.validate_field(
+                        field=k,
+                        value=v,
+                        form=form,
+                        annotation=_annotation,
+                        strict=strict,
+                        use_annotation=use_annotation,
+                        **kwargs,
+                    )
+            dict_[k] = v
+        form.fill(**dict_)
+        return form
+
+    def add_rule(self, rule_name: str, rule: Rule, config: dict = None):
+        """
+        Add a new rule to the validator.
+
+        Args:
+            rule_name (str): The name of the rule.
+            rule (Rule): The rule object.
+            config (dict, optional): Configuration for the rule.
+        """
+        if rule_name in self.active_rules:
+            raise ValueError(f"Rule '{rule_name}' already exists.")
+        self.active_rules[rule_name] = rule
+        self.rulebook.rules[rule_name] = rule
+        self.rulebook.ruleorder.append(rule_name)
+        self.rulebook.rule_config[rule_name] = config or {}
+
+    def remove_rule(self, rule_name: str):
+        """
+        Remove an existing rule from the validator.
+
+        Args:
+            rule_name (str): The name of the rule to remove.
+        """
+        if rule_name not in self.active_rules:
+            raise ValueError(f"Rule '{rule_name}' does not exist.")
+        del self.active_rules[rule_name]
+        del self.rulebook.rules[rule_name]
+        self.rulebook.ruleorder.remove(rule_name)
+        del self.rulebook.rule_config[rule_name]
+
+    def list_active_rules(self) -> list:
+        """
+        List all active rules.
+
+        Returns:
+            list: A list of active rule names.
+        """
+        return list(self.active_rules.keys())
+
+    def enable_rule(self, rule_name: str, enable: bool = True):
+        """
+        Enable a specific rule.
+
+        Args:
+            rule_name (str): The name of the rule.
+            enable (bool): Whether to enable or disable the rule.
+        """
+        if rule_name not in self.active_rules:
+            raise ValueError(f"Rule '{rule_name}' does not exist.")
+        self.active_rules[rule_name].enabled = enable
+
+    def disable_rule(self, rule_name: str):
+        """
+        Disable a specific rule.
+
+        Args:
+            rule_name (str): The name of the rule to disable.
+        """
+        self.enable_rule(rule_name, enable=False)
+
+    def log_validation_attempt(self, form: Form, result: dict):
+        """
+        Log a validation attempt.
+
+        Args:
+            form (Form): The form being validated.
+            result (dict): The result of the validation.
+        """
+        log_entry = {
+            "form_id": form.ln_id,
+            "timestamp": SysUtil.get_timestamp(),
+            "result": result,
+        }
+        self.validation_log.append(log_entry)
+
+    def log_validation_error(self, field: str, value: Any, error: str):
+        """
+        Log a validation error.
+
+        Args:
+            field (str): The field that failed validation.
+            value (Any): The value of the field.
+            error (str): The error message.
+        """
+        log_entry = {
+            "field": field,
+            "value": value,
+            "error": error,
+            "timestamp": SysUtil.get_timestamp(),
+        }
+        self.validation_log.append(log_entry)
+
+    def get_validation_summary(self) -> Dict[str, Any]:
+        """
+        Get a summary of validation results.
+
+        Returns:
+            dict: A summary of validation attempts, errors, and successful attempts.
+        """
+        summary = {
+            "total_attempts": len(self.validation_log),
+            "errors": [log for log in self.validation_log if "error" in log],
+            "successful_attempts": [
+                log for log in self.validation_log if "result" in log
+            ],
+        }
+        return summary

lionagi/core/work/work.py

@@ -0,0 +1,74 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from enum import Enum
+import asyncio
+from typing import Any
+
+from lionagi.libs import SysUtil
+from lionagi.core.collections.abc import Component
+
+
+class WorkStatus(str, Enum):
+    """Enum to represent different statuses of work."""
+
+    PENDING = "PENDING"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+
+
+class Work(Component):
+    """
+    A class representing a unit of work.
+
+    Attributes:
+        status (WorkStatus): The current status of the work.
+        result (Any): The result of the work, if completed.
+        error (Any): Any error encountered during the work.
+        async_task (asyncio.Task | None): The asynchronous task associated with the work.
+        completion_timestamp (str | None): The timestamp when the work was completed.
+        duration (float | None): The duration of the work.
+    """
+
+    status: WorkStatus = WorkStatus.PENDING
+    result: Any = None
+    error: Any = None
+    async_task: asyncio.Task | None = None
+    completion_timestamp: str | None = None
+    duration: float | None = None
+
+    async def perform(self):
+        """Perform the work and update the status, result, and duration."""
+        try:
+            result, duration = await self.async_task
+            self.result = result
+            self.status = WorkStatus.COMPLETED
+            self.duration = duration
+            del self.async_task
+        except Exception as e:
+            self.error = e
+            self.status = WorkStatus.FAILED
+        finally:
+            self.completion_timestamp = SysUtil.get_timestamp(sep=None)[:-6]
+
+    def __str__(self):
+        return (
+            f"Work(id={self.ln_id[:8]}.., status={self.status.value}, "
+            f"created_at={self.timestamp[:-7]}, "
+            f"completed_at={self.completion_timestamp[:-7]}, "
+            f"duration={float(self.duration) if self.duration else 0:.04f} sec(s))"
+        )

lionagi/core/work/work_function.py

@@ -0,0 +1,92 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+from lionagi.libs.ln_func_call import rcall
+from lionagi.core.work.worklog import WorkLog
+
+
+class WorkFunction:
+    """
+    A class representing a work function.
+
+    Attributes:
+        assignment (str): The assignment description of the work function.
+        function (Callable): The function to be performed.
+        retry_kwargs (dict): The retry arguments for the function.
+        worklog (WorkLog): The work log for the function.
+        guidance (str): The guidance or documentation for the function.
+    """
+
+    def __init__(
+        self, assignment, function, retry_kwargs=None, guidance=None, capacity=10
+    ):
+        """
+        Initializes a WorkFunction instance.
+
+        Args:
+            assignment (str): The assignment description of the work function.
+            function (Callable): The function to be performed.
+            retry_kwargs (dict, optional): The retry arguments for the function.
+                Defaults to None.
+            guidance (str, optional): The guidance or documentation for the function.
+                Defaults to None.
+            capacity (int, optional): The capacity of the work log. Defaults to 10.
+        """
+        self.assignment = assignment
+        self.function = function
+        self.retry_kwargs = retry_kwargs or {}
+        self.worklog = WorkLog(capacity)
+        self.guidance = guidance or self.function.__doc__
+
+    @property
+    def name(self):
+        """
+        Gets the name of the function.
+
+        Returns:
+            str: The name of the function.
+        """
+        return self.function.__name__
+
+    def is_progressable(self):
+        """
+        Checks if the work function is progressable.
+
+        Returns:
+            bool: True if the work function is progressable, otherwise False.
+        """
+        return self.worklog.pending_work and not self.worklog.stopped
+
+    async def perform(self, *args, **kwargs):
+        """
+        Performs the work function with retry logic.
+
+        Args:
+            *args: Positional arguments for the function.
+            **kwargs: Keyword arguments for the function.
+
+        Returns:
+            Any: The result of the function call.
+        """
+        kwargs = {**self.retry_kwargs, **kwargs}
+        return await rcall(self.function, *args, timing=True, **kwargs)
+
+    async def forward(self):
+        """
+        Forwards the work log and processes the work queue.
+        """
+        await self.worklog.forward()
+        await self.worklog.queue.process()

lionagi/core/work/work_queue.py

@@ -0,0 +1,81 @@
+"""
+Copyright 2024 HaiyangLi
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+"""
+
+import asyncio
+
+
+class WorkQueue:
+    """
+    A class representing a queue for managing work.
+
+    Attributes:
+        capacity (int): The maximum number of tasks the queue can handle.
+        queue (asyncio.Queue): The queue holding the tasks.
+        _stop_event (asyncio.Event): Event to signal stopping of the queue.
+        semaphore (asyncio.Semaphore): Semaphore to control access based on capacity.
+    """
+
+    def __init__(self, capacity=5):
+
+        self.queue = asyncio.Queue()
+        self._stop_event = asyncio.Event()
+        self.capacity = capacity
+        self.semaphore = asyncio.Semaphore(capacity)
+
+    async def enqueue(self, work) -> None:
+        """Enqueue a work item."""
+        await self.queue.put(work)
+
+    async def dequeue(self):
+        """Dequeue a work item."""
+        return await self.queue.get()
+
+    async def join(self) -> None:
+        """Block until all items in the queue have been processed."""
+        await self.queue.join()
+
+    async def stop(self) -> None:
+        """Signal the queue to stop processing."""
+        self._stop_event.set()
+
+    @property
+    def available_capacity(self):
+        """Return the available capacity of the queue."""
+        available = self.capacity - self.queue.qsize()
+        return available if available > 0 else None
+
+    @property
+    def stopped(self) -> bool:
+        """Return whether the queue has been stopped."""
+        return self._stop_event.is_set()
+
+    async def process(self) -> None:
+        """Process the work items in the queue."""
+        tasks = set()
+        while self.queue.qsize() > 0 and not self.stopped:
+            if not self.available_capacity and tasks:
+                _, done = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+                tasks.difference_update(done)
+
+            async with self.semaphore:
+                next = await self.dequeue()
+                if next is None:
+                    break
+                task = asyncio.create_task(next.perform())
+                tasks.add(task)
+
+            if tasks:
+                await asyncio.wait(tasks)