lionagi 0.3.7__py3-none-any.whl → 0.3.8__py3-none-any.whl

lionagi/core/director/operations/select.py

@@ -1,93 +1,3 @@
-from __future__ import annotations
+from lionagi.operations.select import select
 
-from collections.abc import Callable
-from enum import Enum
-
-from lionfuncs import choose_most_similar
-from pydantic import BaseModel
-
-from lionagi.core.director.models import ReasonModel
-from lionagi.core.session.branch import Branch
-
-from .utils import is_enum
-
-PROMPT = "Please select up to {max_num_selections} items from the following list {choices}. Provide the selection(s), and no comments from you"
-
-
-class SelectionModel(BaseModel):
-    selected: list[str | Enum]
-
-
-class ReasonSelectionModel(BaseModel):
-    selected: list[str | Enum]
-    reason: ReasonModel
-
-
-async def select(
-    choices: list[str] | type[Enum],
-    max_num_selections: int = 1,
-    instruction=None,
-    context=None,
-    system=None,
-    sender=None,
-    recipient=None,
-    reason: bool = False,
-    return_enum: bool = False,
-    enum_parser: Callable = None,  # parse the model string response to appropriate type
-    branch: Branch = None,
-    return_pydantic_model=False,
-    **kwargs,  # additional chat arguments
-):
-    selections = []
-    if return_enum and not is_enum(choices):
-        raise ValueError("return_enum can only be True if choices is an Enum")
-
-    if is_enum(choices):
-        selections = [selection.value for selection in choices]
-    else:
-        selections = choices
-
-    prompt = PROMPT.format(
-        max_num_selections=max_num_selections, choices=selections
-    )
-
-    if instruction:
-        prompt = f"{instruction}\n\n{prompt} \n\n "
-
-    branch = branch or Branch()
-    response: SelectionModel | ReasonSelectionModel | str = await branch.chat(
-        instruction=prompt,
-        context=context,
-        system=system,
-        sender=sender,
-        recipient=recipient,
-        pydantic_model=SelectionModel if not reason else ReasonSelectionModel,
-        return_pydantic_model=True,
-        **kwargs,
-    )
-
-    selected = response
-    if isinstance(response, SelectionModel | ReasonSelectionModel):
-        selected = response.selected
-    selected = [selected] if not isinstance(selected, list) else selected
-    corrected_selections = [
-        choose_most_similar(selection, selections) for selection in selected
-    ]
-
-    if return_enum:
-        out = []
-        if not enum_parser:
-            enum_parser = lambda x: x
-        for selection in corrected_selections:
-            selection = enum_parser(selection)
-            for member in choices.__members__.values():
-                if member.value == selection:
-                    out.append(member)
-        corrected_selections = out
-
-    if return_pydantic_model:
-        if not isinstance(response, SelectionModel | ReasonSelectionModel):
-            return SelectionModel(selected=corrected_selections)
-        response.selected = corrected_selections
-        return response
-    return corrected_selections
+__all__ = ["select"]

lionagi/core/rule/choice.py

@@ -1,4 +1,4 @@
-from lionfuncs import choose_most_similar
+from lionfuncs import string_similarity
 
 from lionagi.core.rule.base import Rule
 
@@ -45,4 +45,4 @@ class ChoiceRule(Rule):
         Returns:
             str: The most similar value from the set of predefined choices.
         """
-        return choose_most_similar(value, self.keys)
+        return string_similarity(value, self.keys, choose_most_similar=True)

lionagi/operations/__init__.py

@@ -0,0 +1,6 @@
+from .brainstorm import brainstorm
+from .rank import rank
+from .score import score
+from .select import select
+
+__all__ = ["brainstorm", "rank", "score", "select"]

lionagi/operations/brainstorm.py

@@ -0,0 +1,87 @@
+from typing import Any
+
+from lion_core.operative.step_model import StepModel
+from lion_core.session.branch import Branch
+from lion_service import iModel
+from pydantic import BaseModel, Field
+
+from .config import DEFAULT_CHAT_CONFIG
+
+
+class BrainstormModel(BaseModel):
+
+    topic: str = Field(
+        default_factory=str,
+        description="**Specify the topic or theme for the brainstorming session.**",
+    )
+    ideas: list[StepModel] = Field(
+        default_factory=list,
+        description="**Provide a list of ideas needed to accomplish the objective. Each step should be as described in a `PlanStepModel`.**",
+    )
+
+
+PROMPT = "Please follow prompt and provide {num_steps} different ideas for the next step"
+
+
+async def brainstorm(
+    num_steps: int = 3,
+    instruction=None,
+    guidance=None,
+    context=None,
+    system=None,
+    reason: bool = False,
+    actions: bool = False,
+    tools: Any = None,
+    imodel: iModel = None,
+    branch: Branch = None,
+    sender=None,
+    recipient=None,
+    clear_messages: bool = False,
+    system_sender=None,
+    system_datetime=None,
+    return_branch=False,
+    num_parse_retries: int = 3,
+    retry_imodel: iModel = None,
+    branch_user=None,
+    **kwargs,  # additional operate arguments
+):
+    if branch and branch.imodel:
+        imodel = imodel or branch.imodel
+    else:
+        imodel = imodel or iModel(**DEFAULT_CHAT_CONFIG)
+
+    prompt = PROMPT.format(num_steps=num_steps)
+
+    branch = branch or Branch(imodel=imodel)
+    if branch_user:
+        branch.user = branch_user
+
+    if system:
+        branch.add_message(
+            system=system,
+            system_datetime=system_datetime,
+            sender=system_sender,
+        )
+    _context = [{"operation": prompt}]
+    if context:
+        _context.append(context)
+
+    response = await branch.operate(
+        instruction=instruction,
+        guidance=guidance,
+        context=_context,
+        sender=sender,
+        recipient=recipient,
+        reason=reason,
+        actions=actions,
+        tools=tools,
+        clear_messages=clear_messages,
+        operative_model=BrainstormModel,
+        retry_imodel=retry_imodel,
+        num_parse_retries=num_parse_retries,
+        imodel=imodel,
+        **kwargs,
+    )
+    if return_branch:
+        return response, branch
+    return response

lionagi/operations/config.py

@@ -0,0 +1,6 @@
+DEFAULT_CHAT_CONFIG = {
+    "provider": "openai",
+    "task": "chat",
+    "model": "gpt-4o-mini",
+    "api_key": "OPENAI_API_KEY",
+}

lionagi/operations/rank.py

@@ -0,0 +1,102 @@
+import asyncio
+from typing import Any
+
+import numpy as np
+from lion_core.session.branch import Branch
+from lion_core.session.session import Session
+from lion_service import iModel
+from lionfuncs import alcall, to_list
+
+from .config import DEFAULT_CHAT_CONFIG
+from .score import score
+
+PROMPT = (
+    "Given all items: \n {choices} \n\n Please follow prompt and give score "
+    "to the item of interest: \n {item} \n\n"
+)
+
+
+async def rank(
+    choices: list[Any],
+    num_scorers: int = 5,
+    instruction=None,
+    guidance=None,
+    context=None,
+    system=None,
+    reason: bool = False,
+    actions: bool = False,
+    tools: Any = None,
+    imodel: iModel = None,
+    branch: Branch = None,  # branch won't be used for the vote, it is for configuration
+    clear_messages: bool = False,
+    system_sender=None,
+    system_datetime=None,
+    num_parse_retries: int = 0,
+    retry_imodel: iModel = None,
+    return_session: bool = False,
+    **kwargs,  # additional kwargs for score function
+) -> dict:
+
+    if branch and branch.imodel:
+        imodel = imodel or branch.imodel
+    else:
+        imodel = imodel or iModel(**DEFAULT_CHAT_CONFIG)
+
+    branch = branch or Branch(imodel=imodel)
+    session = Session(default_branch=branch)
+
+    async def _score(item):
+        async with session.branches.async_lock:
+            b_ = session.new_branch(messages=session.default_branch.messages)
+
+        prompt = PROMPT.format(choices=choices, item=item)
+        if instruction:
+            prompt = f"{instruction}\n\n{prompt} \n\n "
+
+        kwargs["branch"] = b_
+        kwargs["score_range"] = kwargs.get("score_range", (1, 10))
+        kwargs["num_scores"] = kwargs.get("num_scores", 1)
+        kwargs["precision"] = kwargs.get("precision", 1)
+
+        response = await score(
+            instruction=prompt,
+            guidance=guidance,
+            context=context,
+            system=system,
+            system_datetime=system_datetime,
+            system_sender=system_sender,
+            sender=session.ln_id,
+            recipient=b_.ln_id,
+            default_score=-1,
+            reason=reason,
+            actions=actions,
+            tools=tools,
+            clear_messages=clear_messages,
+            num_parse_retries=num_parse_retries,
+            retry_imodel=retry_imodel,
+            **kwargs,
+        )
+
+        if response.score == -1:
+            return None
+
+        return response
+
+    async def _group_score(item):
+        tasks = [asyncio.create_task(_score(item)) for _ in range(num_scorers)]
+        responses = await asyncio.gather(*tasks)
+        responses = [i for i in responses if i is not None]
+        scores = to_list(
+            [i.score for i in responses], dropna=True, flatten=True
+        )
+        return {
+            "item": item,
+            "scores": scores,
+            "average": np.mean(scores) if scores else -1,
+        }
+
+    results = await alcall(choices, _group_score)
+    results = sorted(results, key=lambda x: x["average"], reverse=True)
+    if return_session:
+        return results, session
+    return results

lionagi/operations/score.py

@@ -0,0 +1,144 @@
+import logging
+from typing import Any
+
+import numpy as np
+from lion_core.session.branch import Branch
+from lion_service import iModel
+from lionfuncs import to_num
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+from .config import DEFAULT_CHAT_CONFIG
+
+PROMPT = "Please follow prompt and provide {num_scores} numeric score(s) in {score_range} for the given context. Return as {return_precision} format"
+
+
+class ScoreModel(BaseModel):
+
+    score: list | float = Field(
+        default_factory=list,
+        description="** A numeric score or a list of numeric scores.**",
+    )
+
+    model_config = ConfigDict(
+        population_by_field_name=True,
+        arbitrary_types_allowed=True,
+    )
+
+    @field_validator("score", mode="before")
+    def validate_score(cls, value) -> list:
+        return [value] if not isinstance(value, list) else value
+
+
+async def score(
+    score_range=(1, 10),
+    instruction=None,
+    guidance=None,
+    context=None,
+    system=None,
+    reason: bool = False,
+    actions: bool = False,
+    tools: Any = None,
+    imodel: iModel = None,
+    branch: Branch = None,
+    sender=None,
+    recipient=None,
+    clear_messages: bool = False,
+    system_sender=None,
+    system_datetime=None,
+    return_branch=False,
+    num_parse_retries: int = 0,
+    retry_imodel: iModel = None,
+    num_scores: int = 1,
+    use_average: bool = False,
+    precision: int = 0,
+    default_score=np.nan,
+    **kwargs,
+) -> ScoreModel:
+
+    if branch and branch.imodel:
+        imodel = imodel or branch.imodel
+    else:
+        imodel = imodel or iModel(**DEFAULT_CHAT_CONFIG)
+
+    branch = branch or Branch(imodel=imodel)
+
+    return_precision = "integer" if precision == 0 else f"num:{precision}f"
+    prompt = PROMPT.format(
+        num_scores=num_scores,
+        score_range=score_range,
+        return_precision=return_precision,
+    )
+    if instruction:
+        prompt = f"{instruction}\n\n{prompt} \n\n "
+
+    if system:
+        branch.add_message(
+            system=system,
+            system_datetime=system_datetime,
+            sender=system_sender,
+        )
+
+    _context = [{"operation": prompt}]
+    if context:
+        _context.append(context)
+
+    kwargs["frozen"] = False
+    response = await branch.operate(
+        instruction=instruction,
+        guidance=guidance,
+        context=_context,
+        sender=sender,
+        recipient=recipient,
+        reason=reason,
+        actions=actions,
+        tools=tools,
+        clear_messages=clear_messages,
+        operative_model=ScoreModel,
+        imodel=imodel,
+        retry_imodel=retry_imodel,
+        num_parse_retries=num_parse_retries,
+        **kwargs,
+    )
+
+    return_kind = int if precision == 0 else float
+    err = None
+    try:
+        if isinstance(response, dict):
+            response = ScoreModel(**response)
+
+        response.score = [
+            to_num(
+                i,
+                upper_bound=score_range[1],
+                lower_bound=score_range[0],
+                num_type=return_kind,
+                precision=precision,
+                num_count=num_scores,
+            )
+            for i in response.score
+        ]
+        if use_average:
+            scores = response.score
+            scores = [scores] if not isinstance(scores, list) else scores
+            response.score = np.mean(scores)
+
+        if response.score and num_scores == 1:
+            if isinstance(response.score, list):
+                response.score = response.score[0]
+
+        if return_branch:
+            return response, branch
+        return response
+
+    except Exception as e:
+        err = e
+        pass
+
+    logging.error(
+        f"Error converting score to {return_kind}: {err}, "
+        f"value is set to default: {default_score}"
+    )
+    response.score = default_score
+    if return_branch:
+        return response, branch
+    return response

lionagi/operations/select.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from enum import Enum
+from typing import Any
+
+from lion_core.session.branch import Branch
+from lion_service import iModel
+from lionfuncs import string_similarity
+from pydantic import BaseModel, Field
+
+from lionagi.libs.sys_util import SysUtil
+
+from .config import DEFAULT_CHAT_CONFIG
+
+PROMPT = "Please select up to {max_num_selections} items from the following list {choices}. Provide the selection(s) into appropriate field in format required, and no comments from you"
+
+
+class SelectionModel(BaseModel):
+    selected: list[str | Enum] = Field(default_factory=list)
+
+
+async def select(
+    choices: list[str] | type[Enum],
+    max_num_selections: int = 1,
+    instruction=None,
+    guidance=None,
+    context=None,
+    system=None,
+    reason: bool = False,
+    actions: bool = False,
+    tools: Any = None,
+    imodel: iModel = None,
+    branch: Branch = None,
+    sender=None,
+    recipient=None,
+    return_enum: bool = False,
+    enum_parser: Callable = None,  # parse the model string response to appropriate type
+    clear_messages: bool = False,
+    system_sender=None,
+    system_datetime=None,
+    return_branch=False,
+    num_parse_retries: int = 3,
+    retry_imodel: iModel = None,
+    branch_user=None,
+    **kwargs,
+) -> SelectionModel | tuple[SelectionModel, Branch]:
+
+    if branch and branch.imodel:
+        imodel = imodel or branch.imodel
+    else:
+        imodel = imodel or iModel(**DEFAULT_CHAT_CONFIG)
+
+    selections = []
+    if return_enum and not _is_enum(choices):
+        raise ValueError("return_enum can only be True if choices is an Enum")
+
+    if _is_enum(choices):
+        selections = [selection.value for selection in choices]
+    else:
+        selections = choices
+
+    prompt = PROMPT.format(
+        max_num_selections=max_num_selections, choices=selections
+    )
+
+    if instruction:
+        prompt = f"{instruction}\n\n{prompt} \n\n "
+
+    branch = branch or Branch(imodel=imodel)
+    if branch_user:
+        try:
+            a = SysUtil.get_id(branch_user)
+            branch.user = a
+        except:
+            branch.user = branch_user
+    if system:
+        branch.add_message(
+            system=system,
+            system_datetime=system_datetime,
+            system_sender=system_sender,
+        )
+
+    kwargs["frozen"] = False
+    response_model: SelectionModel = await branch.operate(
+        instruction=prompt,
+        guidance=guidance,
+        context=context,
+        sender=sender,
+        recipient=recipient,
+        reason=reason,
+        actions=actions,
+        operative_model=SelectionModel,
+        clear_messages=clear_messages,
+        imodel=imodel,
+        num_parse_retries=num_parse_retries,
+        retry_imodel=retry_imodel,
+        tools=tools,
+        **kwargs,
+    )
+
+    selected = response_model
+    if isinstance(response_model, BaseModel) and hasattr(
+        response_model, "selected"
+    ):
+        selected = response_model.selected
+    selected = [selected] if not isinstance(selected, list) else selected
+    corrected_selections = [
+        string_similarity(
+            word=selection,
+            correct_words=selections,
+            return_most_similar=True,
+        )
+        for selection in selected
+    ]
+
+    if return_enum:
+        out = []
+        if not enum_parser:
+            enum_parser = lambda x: x
+        for selection in corrected_selections:
+            selection = enum_parser(selection)
+            for member in choices.__members__.values():
+                if member.value == selection:
+                    out.append(member)
+        corrected_selections = out
+
+    if isinstance(response_model, BaseModel):
+        response_model.selected = corrected_selections
+
+    elif isinstance(response_model, dict):
+        response_model["selected"] = corrected_selections
+
+    if return_branch:
+        return response_model, branch
+    return response_model
+
+
+def _is_enum(choices):
+    return inspect.isclass(choices) and issubclass(choices, Enum)

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.3.7"
+__version__ = "0.3.8"