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

lionagi/core/collections/progression.py

@@ -0,0 +1,236 @@
+"""
+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 contextlib
+from lionagi.libs import SysUtil
+from pydantic import Field, field_validator
+from .abc import Ordering, get_lion_id, ItemNotFoundError, LionIDable, Element
+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):
+        for idx, item in enumerate(self.order):
+            yield idx, item
+
+    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_ = SysUtil.create_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_ = SysUtil.create_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 SysUtil.create_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

@@ -0,0 +1,64 @@
+from collections.abc import Mapping, Generator
+from collections import deque
+
+from .abc import LionTypeError, Record, Ordering, Component, get_lion_id, Element
+
+
+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/direct.py

@@ -0,0 +1,314 @@
+"""
+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.core.unit.unit import Unit
+from lionagi.core.session.branch import Branch
+
+
+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

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