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

lionagi/core/collections/progression.py

@@ -1,221 +0,0 @@
-import contextlib
-
-import lionfuncs as ln
-from pydantic import Field, field_validator
-
-from .abc import Element, ItemNotFoundError, LionIDable, Ordering, get_lion_id
-from .util import _validate_order
-
-
-class Progression(Element, Ordering):
-
-    name: str | None = Field(
-        None,
-        title="Name",
-        description="The name of the progression.",
-    )
-    order: list = Field(
-        default_factory=list,
-        title="Order",
-        description="The order of the progression.",
-    )
-
-    @field_validator("order", mode="before")
-    def _validate_order(cls, value) -> list[str]:
-        """Validate and convert the order field."""
-        return _validate_order(value)
-
-    def __contains__(self, item):
-        """Check if an item or items are in the progression."""
-        if not item:
-            return False
-        if isinstance(item, Progression):
-            return all([i in self.order for i in item.order])
-        if isinstance(item, LionIDable) and len(a := get_lion_id(item)) == 32:
-            return a in self.order
-        item = self._validate_order(item)
-        return all([i in self.order for i in item])
-
-    def __len__(self):
-        return len(self.order)
-
-    def keys(self):
-        yield from range(len(self))
-
-    def values(self):
-        yield from self.order
-
-    def items(self):
-        yield from enumerate(self.order)
-
-    def size(self):
-        return len(self)
-
-    def copy(self):
-        """create a deep copy"""
-        return self.model_copy()
-
-    def append(self, item):
-        """Append an item to the end of the progression."""
-        id_ = get_lion_id(item)
-        self.order.append(id_)
-
-    def extend(self, item):
-        """Extend the progression from the right with item(s)"""
-        if isinstance(item, Progression):
-            self.order.extend(item.order)
-            return
-        order = self._validate_order(item)
-        self.order.extend(order)
-
-    def include(self, item) -> bool:
-        """Include item(s) in the progression. return true if the item is included."""
-        if item not in self:
-            self.extend(item)
-        return item in self
-
-    def __getitem__(self, key):
-        with contextlib.suppress(IndexError):
-            a = self.order[key]
-            if isinstance(a, list) and len(a) > 1:
-                return Progression(order=a)
-            elif isinstance(a, list) and len(a) == 1:
-                return a[0]
-            return a
-
-        raise ItemNotFoundError(f"index {key}")
-
-    def remove(self, item: LionIDable):
-        """Remove the next occurrence of an item from the progression."""
-        if item in self:
-            item = self._validate_order(item)
-            l_ = ln.copy(self.order)
-
-            with contextlib.suppress(Exception):
-                for i in item:
-                    l_.remove(i)
-                self.order = l_
-                return
-
-        raise ItemNotFoundError(f"{item}")
-
-    def __list__(self):
-        return self.order
-
-    def popleft(self):
-        """Remove and return the leftmost item from the progression."""
-        try:
-            return self.order.pop(0)
-        except IndexError as e:
-            raise ItemNotFoundError("None") from e
-
-    def pop(self, index=None):
-        """Remove and return an item from the progression."""
-        try:
-            return self.order.pop(index)
-        except IndexError as e:
-            raise ItemNotFoundError("None") from e
-
-    def exclude(self, item) -> bool:
-        """Exclude an item or items from the progression."""
-        if isinstance(item, int) and item > 0:
-            if item > len(self):
-                raise IndexError("Cannot remove more items than available.")
-            for _ in range(item):
-                self.popleft()
-            return True
-        if isinstance(item, Progression):
-            for i in item:
-                while i in self:
-                    self.remove(i)
-        for i in (a := self._validate_order(item)):
-            while i in self:
-                self.remove(i)
-        return a not in self
-
-    def __add__(self, other):
-        """Add an item or items to the end of the progression."""
-        _copy = self.copy()
-        _copy.include(other)
-        return _copy
-
-    def __radd__(self, other):
-        if not isinstance(other, Progression):
-            _copy = self.copy()
-            l_ = ln.copy(_copy.order)
-            l_.insert(0, get_lion_id(other))
-            _copy.order = l_
-            return _copy
-
-        return other + self
-
-    def __setitem__(self, key, value):
-        a = self._validate_order(value)
-        self.order[key] = a
-
-    def __iadd__(self, other):
-        """Add an item or items to the end of the progression."""
-        return self + other
-
-    def __isub__(self, other):
-        """Remove an item or items from the beginning of the progression."""
-        return self - other
-
-    def __sub__(self, other):
-        """Remove an item or items from the progression."""
-        _copy = self.copy()
-        _copy.remove(other)
-        return _copy
-
-    def __len__(self):
-        """Return the length of the progression."""
-        return len(self.order)
-
-    def __iter__(self):
-        """Iterate over the items in the progression."""
-        return iter(self.order)
-
-    def __next__(self):
-        """Return the next item in the progression."""
-        return self.popleft()
-
-    def __repr__(self):
-        """Return a string representation of the progression."""
-        return f"Progression({self.order})"
-
-    def __str__(self):
-        """Return a string representation of the progression."""
-        return f"Progression({self.order})"
-
-    def __list__(self):
-        """Return a list representation of the progression."""
-        return ln.copy(self.order)
-
-    def __reversed__(self):
-        """Return a reversed progression."""
-        return reversed(self.order)
-
-    def clear(self):
-        """Clear the progression."""
-        self.order = []
-
-    def to_dict(self):
-        """Return a dictionary representation of the progression."""
-        return {"order": self.order, "name": self.name}
-
-    def __bool__(self):
-        return True
-
-    def __eq__(self, other):
-        """Compare two Progression instances for equality."""
-        if not isinstance(other, Progression):
-            return NotImplemented
-        return self.order == other.order and self.name == other.name
-
-    def __hash__(self):
-        """Return a hash value for the Progression instance."""
-        return hash((tuple(self.order), self.name))
-
-
-def progression(order=None, name=None) -> Progression:
-    return Progression(order=order, name=name)

lionagi/core/collections/util.py

@@ -1,73 +0,0 @@
-from collections import deque
-from collections.abc import Generator, Mapping
-
-from .abc import (
-    Component,
-    Element,
-    LionTypeError,
-    Ordering,
-    Record,
-    get_lion_id,
-)
-
-
-def to_list_type(value):
-    """
-    Convert the provided value to a list.
-
-    This function ensures that the input value is converted to a list,
-    regardless of its original type. It handles various types including
-    Component, Mapping, Record, tuple, list, set, Generator, and deque.
-
-    Args:
-        value: The value to convert to a list.
-
-    Returns:
-        list: The converted list.
-
-    Raises:
-        TypeError: If the value cannot be converted to a list.
-    """
-    if isinstance(value, Component) and not isinstance(
-        value, (Record, Ordering)
-    ):
-        return [value]
-    if isinstance(value, (Mapping, Record)):
-        return list(value.values())
-    # if isinstance(value, Ordering):
-    #     return list(value.order)
-    if isinstance(value, (tuple, list, set, Generator, deque)):
-        return list(value)
-    return [value]
-
-
-def _validate_order(value) -> list[str]:
-    """
-    Validate and convert the order field to a list of strings.
-
-    This function ensures that the input value is a valid order and converts it to a list of strings.
-    It handles various input types including string, Ordering, and Element.
-
-    Args:
-        value: The value to validate and convert.
-
-    Returns:
-        list[str]: The validated and converted order list.
-
-    Raises:
-        LionTypeError: If the value contains invalid types.
-    """
-    if value is None:
-        return []
-    if isinstance(value, str) and len(value) == 32:
-        return [value]
-    elif isinstance(value, Ordering):
-        return value.order
-
-    elif isinstance(value, Element):
-        return [value.ln_id]
-
-    try:
-        return [i for item in to_list_type(value) if (i := get_lion_id(item))]
-    except Exception as e:
-        raise LionTypeError("Progression must only contain lion ids.") from e

lionagi/core/director/README.md

@@ -1 +0,0 @@
-director is an agent specialized in writing directives

lionagi/core/director/direct.py

@@ -1,298 +0,0 @@
-from lionagi.core.session.branch import Branch
-from lionagi.core.unit.unit import Unit
-
-
-async def chat(
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    branch=None,
-    form=None,
-    confidence_score=None,
-    reason=False,
-    **kwargs,
-):
-    """
-    Performs a chat operation using the specified parameters.
-
-    Args:
-        instruction (str, optional): The instruction for the chat.
-        context (Any, optional): The context to perform the instruction on.
-        system (Any, optional): The system context for the chat.
-        sender (str, optional): The sender of the instruction.
-        recipient (str, optional): The recipient of the instruction.
-        branch (Branch, optional): The branch to use for the chat.
-        form (Any, optional): The form to create instruction from.
-        confidence_score (float, optional): The confidence score for the operation.
-        reason (bool, optional): Whether to include a reason for the operation.
-        **kwargs: Additional keyword arguments for the chat operation.
-
-    Returns:
-        Any: The result of the chat operation.
-    """
-    branch = branch or Branch()
-    unit = Unit(branch)
-
-    return await unit.chat(
-        instruction=instruction,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        form=form,
-        confidence_score=confidence_score,
-        reason=reason,
-        branch=branch,
-        **kwargs,
-    )
-
-
-async def select(
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    choices=None,
-    branch=None,
-    form=None,
-    confidence_score=None,
-    reason=False,
-    **kwargs,
-):
-    """
-    Performs a select operation using the specified parameters.
-
-    Args:
-        instruction (str, optional): The instruction for the selection.
-        context (Any, optional): The context to perform the instruction on.
-        system (Any, optional): The system context for the selection.
-        sender (str, optional): The sender of the instruction.
-        recipient (str, optional): The recipient of the instruction.
-        choices (list, optional): The choices for the selection.
-        branch (Branch, optional): The branch to use for the selection.
-        form (Any, optional): The form to create instruction from.
-        confidence_score (float, optional): The confidence score for the operation.
-        reason (bool, optional): Whether to include a reason for the operation.
-        **kwargs: Additional keyword arguments for the selection operation.
-
-    Returns:
-        Any: The result of the selection operation.
-    """
-    branch = branch or Branch()
-    unit = Unit(branch)
-
-    return await unit.select(
-        instruction=instruction,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        choices=choices,
-        form=form,
-        confidence_score=confidence_score,
-        reason=reason,
-        **kwargs,
-    )
-
-
-async def predict(
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    branch=None,
-    form=None,
-    confidence_score=None,
-    reason=False,
-    num_sentences=1,
-    **kwargs,
-):
-    """
-    Performs a predict operation using the specified parameters.
-
-    Args:
-        instruction (str, optional): The instruction for the prediction.
-        context (Any, optional): The context to perform the instruction on.
-        system (Any, optional): The system context for the prediction.
-        sender (str, optional): The sender of the instruction.
-        recipient (str, optional): The recipient of the instruction.
-        branch (Branch, optional): The branch to use for the prediction.
-        form (Any, optional): The form to create instruction from.
-        confidence_score (float, optional): The confidence score for the operation.
-        reason (bool, optional): Whether to include a reason for the operation.
-        **kwargs: Additional keyword arguments for the prediction operation.
-
-    Returns:
-        Any: The result of the prediction operation.
-    """
-    branch = branch or Branch()
-    unit = Unit(branch)
-
-    return await unit.predict(
-        instruction=instruction,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        form=form,
-        confidence_score=confidence_score,
-        reason=reason,
-        num_sentences=num_sentences,
-        **kwargs,
-    )
-
-
-async def act(
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    branch=None,
-    form=None,
-    confidence_score=None,
-    reason=False,
-    **kwargs,
-):
-    """
-    Performs an act operation using the specified parameters.
-
-    Args:
-        instruction (str, optional): The instruction for the action.
-        context (Any, optional): The context to perform the instruction on.
-        system (Any, optional): The system context for the action.
-        sender (str, optional): The sender of the instruction.
-        recipient (str, optional): The recipient of the instruction.
-        branch (Branch, optional): The branch to use for the action.
-        form (Any, optional): The form to create instruction from.
-        confidence_score (float, optional): The confidence score for the operation.
-        reason (bool, optional): Whether to include a reason for the operation.
-        **kwargs: Additional keyword arguments for the act operation.
-
-    Returns:
-        Any: The result of the act operation.
-    """
-    branch = branch or Branch()
-    unit = Unit(branch)
-
-    return await unit.act(
-        instruction=instruction,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        form=form,
-        confidence_score=confidence_score,
-        reason=reason,
-        **kwargs,
-    )
-
-
-async def score(
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    branch=None,
-    form=None,
-    confidence_score=None,
-    reason=False,
-    score_range=None,
-    include_endpoints=None,
-    num_digit=None,
-    **kwargs,
-):
-    """
-    Asynchronously performs a scoring task within a given context.
-
-    Args:
-        instruction (str, optional): Additional instruction for the scoring task.
-        context (Any, optional): Context to perform the scoring task on.
-        system (str, optional): System message to use for the scoring task.
-        sender (str, optional): Sender of the instruction. Defaults to None.
-        recipient (str, optional): Recipient of the instruction. Defaults to None.
-        branch (Branch, optional): Branch to perform the task within. Defaults to a new Branch.
-        form (Form, optional): Form to create the instruction from. Defaults to None.
-        confidence_score (bool, optional): Flag to include a confidence score. Defaults to None.
-        reason (bool, optional): Flag to include a reason for the scoring. Defaults to False.
-        score_range (tuple, optional): Range for the score. Defaults to None.
-        include_endpoints (bool, optional): Flag to include endpoints in the score range. Defaults to None.
-        num_digit (int, optional): Number of decimal places for the score. Defaults to None.
-        **kwargs: Additional keyword arguments for further customization.
-
-    Returns:
-        Any: The result of the scoring task.
-    """
-
-    branch = branch or Branch()
-    unit = Unit(branch)
-
-    return await unit.score(
-        instruction=instruction,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        form=form,
-        confidence_score=confidence_score,
-        reason=reason,
-        score_range=score_range,
-        include_endpoints=include_endpoints,
-        num_digit=num_digit,
-        **kwargs,
-    )
-
-
-async def plan(
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    branch=None,
-    form=None,
-    confidence_score=None,
-    reason=False,
-    num_step=3,
-    **kwargs,
-):
-    """
-    Asynchronously generates a step-by-step plan within a given context.
-
-    Args:
-        instruction (str, optional): Additional instruction for the planning task.
-        context (Any, optional): Context to perform the planning task on.
-        system (str, optional): System message to use for the planning task.
-        sender (str, optional): Sender of the instruction. Defaults to None.
-        recipient (str, optional): Recipient of the instruction. Defaults to None.
-        branch (Branch, optional): Branch to perform the task within. Defaults to a new Branch.
-        form (Form, optional): Form to create the instruction from. Defaults to None.
-        confidence_score (bool, optional): Flag to include a confidence score. Defaults to None.
-        reason (bool, optional): Flag to include a reason for the plan. Defaults to False.
-        num_step (int, optional): Number of steps in the plan. Defaults to 3.
-        **kwargs: Additional keyword arguments for further customization.
-
-    Returns:
-        Any: The result of the planning task.
-    """
-
-    branch = branch or Branch()
-    unit = Unit(branch)
-
-    return await unit.plan(
-        instruction=instruction,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        form=form,
-        confidence_score=confidence_score,
-        reason=reason,
-        num_step=num_step,
-        **kwargs,
-    )

lionagi/core/director/director.py

@@ -1,2 +0,0 @@
-# an agent that can write directive
-# it represent communication and sequencing of orders among agents

lionagi/core/director/operations/select.py

@@ -1,3 +0,0 @@
-from lionagi.operations.select import select
-
-__all__ = ["select"]

lionagi/core/director/operations/utils.py

@@ -1,6 +0,0 @@
-from enum import Enum
-from inspect import isclass
-
-
-def is_enum(choices):
-    return isclass(choices) and issubclass(choices, Enum)