lionagi 0.13.2__py3-none-any.whl → 0.13.4__py3-none-any.whl

lionagi/config.py

@@ -68,7 +68,7 @@ class AppSettings(BaseSettings, frozen=True):
     LIONAGI_EMBEDDING_MODEL: str = "text-embedding-3-small"
 
     LIONAGI_CHAT_PROVIDER: str = "openai"
-    LIONAGI_CHAT_MODEL: str = "gpt-4o"
+    LIONAGI_CHAT_MODEL: str = "gpt-4.1-nano"
 
     # default storage
     LIONAGI_AUTO_STORE_EVENT: bool = False

lionagi/fields/action.py

@@ -21,7 +21,6 @@ __all__ = (
 
 
 def parse_action_request(content: str | dict) -> list[dict]:
-
     json_blocks = []
 
     if isinstance(content, BaseModel):

lionagi/fields/reason.py

@@ -11,7 +11,6 @@ __all__ = ("Reason",)
 
 
 class Reason(HashableModel):
-
     title: str | None = None
     content: str | None = None
     confidence_score: float | None = Field(

lionagi/libs/file/save.py

@@ -82,7 +82,7 @@ def save_chunks(
     for i, chunk in enumerate(chunks):
         file_path = create_path(
             directory=output_path,
-            filename=f"chunk_{i+1}",
+            filename=f"chunk_{i + 1}",
             extension="json",
             timestamp=timestamp,
             random_hash_digits=random_hash_digits,

lionagi/libs/schema/as_readable.py

@@ -11,81 +11,84 @@ from lionagi.utils import to_dict
 # Try to import rich for enhanced console output
 try:
     from rich.align import Align
-    from rich.box import ROUNDED
+    from rich.box import MINIMAL, ROUNDED
     from rich.console import Console
+    from rich.markdown import Markdown
     from rich.padding import Padding
     from rich.panel import Panel
+    from rich.style import Style
     from rich.syntax import Syntax
+    from rich.text import Text
     from rich.theme import Theme
 
+    DARK_THEME = Theme(
+        {
+            "info": "bright_cyan",
+            "warning": "bright_yellow",
+            "error": "bold bright_red",
+            "success": "bold bright_green",
+            "panel.border": "bright_blue",
+            "panel.title": "bold bright_cyan",
+            "markdown.h1": "bold bright_magenta",
+            "markdown.h2": "bold bright_blue",
+            "markdown.h3": "bold bright_cyan",
+            "markdown.h4": "bold bright_green",
+            "markdown.code": "bright_yellow on grey23",
+            "markdown.code_block": "bright_white on grey15",
+            "markdown.paragraph": "bright_white",
+            "markdown.text": "bright_white",
+            "markdown.emph": "italic bright_yellow",
+            "markdown.strong": "bold bright_white",
+            "markdown.item": "bright_cyan",
+            "markdown.item.bullet": "bright_blue",
+            "json.key": "bright_cyan",
+            "json.string": "bright_green",
+            "json.number": "bright_yellow",
+            "json.boolean": "bright_magenta",
+            "json.null": "bright_red",
+            "yaml.key": "bright_cyan",
+            "yaml.string": "bright_green",
+            "yaml.number": "bright_yellow",
+            "yaml.boolean": "bright_magenta",
+        }
+    )
+
+    LIGHT_THEME = Theme(
+        {
+            "info": "blue",
+            "warning": "dark_orange",
+            "error": "bold red",
+            "success": "bold green4",
+            "panel.border": "blue",
+            "panel.title": "bold blue",
+            "markdown.h1": "bold dark_magenta",
+            "markdown.h2": "bold dark_blue",
+            "markdown.h3": "bold dark_cyan",
+            "markdown.h4": "bold dark_green",
+            "markdown.code": "dark_orange on grey93",
+            "markdown.code_block": "black on grey82",
+            "markdown.paragraph": "black",
+            "markdown.text": "black",
+            "markdown.emph": "italic dark_orange",
+            "markdown.strong": "bold black",
+            "markdown.item": "dark_blue",
+            "markdown.item.bullet": "blue",
+            "json.key": "dark_blue",
+            "json.string": "dark_green",
+            "json.number": "dark_orange",
+            "json.boolean": "dark_magenta",
+            "json.null": "dark_red",
+            "yaml.key": "dark_blue",
+            "yaml.string": "dark_green",
+            "yaml.number": "dark_orange",
+            "yaml.boolean": "dark_magenta",
+        }
+    )
     RICH_AVAILABLE = True
 except ImportError:
     RICH_AVAILABLE = False
-
-# Custom themes for dark and light modes
-DARK_THEME = Theme(
-    {
-        "info": "bright_cyan",
-        "warning": "bright_yellow",
-        "error": "bold bright_red",
-        "success": "bold bright_green",
-        "panel.border": "bright_blue",
-        "panel.title": "bold bright_cyan",
-        "markdown.h1": "bold bright_magenta",
-        "markdown.h2": "bold bright_blue",
-        "markdown.h3": "bold bright_cyan",
-        "markdown.h4": "bold bright_green",
-        "markdown.code": "bright_yellow on grey23",
-        "markdown.code_block": "bright_white on grey15",
-        "markdown.paragraph": "bright_white",
-        "markdown.text": "bright_white",
-        "markdown.emph": "italic bright_yellow",
-        "markdown.strong": "bold bright_white",
-        "markdown.item": "bright_cyan",
-        "markdown.item.bullet": "bright_blue",
-        "json.key": "bright_cyan",
-        "json.string": "bright_green",
-        "json.number": "bright_yellow",
-        "json.boolean": "bright_magenta",
-        "json.null": "bright_red",
-        "yaml.key": "bright_cyan",
-        "yaml.string": "bright_green",
-        "yaml.number": "bright_yellow",
-        "yaml.boolean": "bright_magenta",
-    }
-)
-
-LIGHT_THEME = Theme(
-    {
-        "info": "blue",
-        "warning": "dark_orange",
-        "error": "bold red",
-        "success": "bold green4",
-        "panel.border": "blue",
-        "panel.title": "bold blue",
-        "markdown.h1": "bold dark_magenta",
-        "markdown.h2": "bold dark_blue",
-        "markdown.h3": "bold dark_cyan",
-        "markdown.h4": "bold dark_green",
-        "markdown.code": "dark_orange on grey93",
-        "markdown.code_block": "black on grey82",
-        "markdown.paragraph": "black",
-        "markdown.text": "black",
-        "markdown.emph": "italic dark_orange",
-        "markdown.strong": "bold black",
-        "markdown.item": "dark_blue",
-        "markdown.item.bullet": "blue",
-        "json.key": "dark_blue",
-        "json.string": "dark_green",
-        "json.number": "dark_orange",
-        "json.boolean": "dark_magenta",
-        "json.null": "dark_red",
-        "yaml.key": "dark_blue",
-        "yaml.string": "dark_green",
-        "yaml.number": "dark_orange",
-        "yaml.boolean": "dark_magenta",
-    }
-)
+    DARK_THEME = None
+    LIGHT_THEME = None
 
 
 def in_notebook() -> bool:
@@ -172,6 +175,8 @@ def as_readable(
     use_rich: bool = True,
     theme: str = "dark",
     max_panel_width: int = 140,
+    panel: bool = True,
+    border: bool = True,
 ) -> str:
     """
     Convert `input_` into a human-readable string. If `format_curly=True`, uses
@@ -191,6 +196,7 @@ def as_readable(
         theme: Color theme - "dark" (default) or "light". Dark uses GitHub Dark Dimmed,
                light uses Solarized Light inspired colors.
         max_panel_width: Maximum width for panels and code blocks in characters.
+        panel: If True, wraps the output in a panel for better visibility.
 
     Returns:
         A formatted string representation of `input_` (unless display_str=True).
@@ -249,7 +255,6 @@ def as_readable(
         final_str = "\n\n".join(rendered).strip()
 
         # 4) If Markdown requested, wrap with code fences
-        #    - If we used format_curly, we might do "```yaml" instead. But user specifically asked for JSON code blocks previously
         if md:
             if format_curly:
                 return f"```yaml\n{final_str}\n```"
@@ -260,137 +265,78 @@ def as_readable(
 
     str_ = _inner(input_).strip()
     if max_chars is not None and len(str_) > max_chars:
-        str1 = str_[:max_chars] + "...\n\n[Truncated output]\n\n"
-        if str_.endswith("\n```"):
-            str1 += "```"
-        str_ = str1
-    if display_str:
-        if md and in_notebook():
-            # If in IPython environment, display Markdown
-            from IPython.display import Markdown, display
-
-            display(Markdown(str_))
-        elif RICH_AVAILABLE and in_console() and use_rich:
-            # Use rich for enhanced console output
-            # Select theme and syntax highlighting based on user preference
-            console_theme = DARK_THEME if theme == "dark" else LIGHT_THEME
-            syntax_theme = (
-                "github-dark" if theme == "dark" else "solarized-light"
-            )
-            panel_style = "bright_blue" if theme == "dark" else "blue"
-
-            console = Console(theme=console_theme)
-
-            # Check if content looks like markdown prose (not code)
-            is_markdown_prose = isinstance(str_, str) and (
-                str_.startswith("#")
-                or str_.startswith("**")
-                or str_.startswith("- ")
-                or str_.startswith("1.")
-                or "<multi_reasoning>" in str_
-                or "\n### " in str_
-                or "\n## " in str_
-                or "\n# " in str_
-                or "│" in str_  # Rich table content
-            )
-
-            if md and is_markdown_prose:
-                # Display as formatted markdown
-                # Create markdown with max width
-                from rich.markdown import Markdown as RichMarkdown
-
-                md_content = RichMarkdown(str_, code_theme=syntax_theme)
-
-                # Calculate appropriate width
-                console_width = console.width
-                panel_width = min(console_width - 4, max_panel_width)
-
-                # Add left margin padding for better alignment
-                panel = Panel(
-                    Padding(md_content, (0, 2)),
-                    border_style=panel_style,
-                    box=ROUNDED,
-                    width=panel_width,
-                    expand=False,
-                )
-
-                # Left align with margin
-                aligned_panel = Align.left(panel, pad=True)
-                console.print(Padding(aligned_panel, (0, 0, 0, 4)))
-
-            elif md:
-                # Extract content from markdown code blocks if present
-                content = str_
-                if content.startswith("```") and content.endswith("```"):
-                    # Remove code fences
-                    lines = content.split("\n")
-                    if len(lines) > 2:
-                        lang = lines[0][3:].strip() or "json"
-                        content = "\n".join(lines[1:-1])
-                    else:
-                        lang = "json"
-                else:
-                    lang = "yaml" if format_curly else "json"
-
-                # Calculate appropriate width
-                console_width = console.width
-                panel_width = min(console_width - 4, max_panel_width)
-
-                # Create syntax highlighted output
-                syntax = Syntax(
-                    content,
-                    lang,
-                    theme=syntax_theme,
-                    line_numbers=True,
-                    background_color="default",
-                    word_wrap=True,
+        trunc = str_[:max_chars] + "...\n\n[Truncated output]"
+        str_ = trunc + ("\n```" if str_.endswith("\n```") else "")
+
+    # -------------------- PRINT / DISPLAY LOGIC ---------------------------
+    if not display_str:
+        return str_  # caller will handle printing
+
+    # (1) IPython notebook --------------------------------------------------
+    if md and in_notebook():
+        from IPython.display import Markdown, display
+
+        display(Markdown(str_))
+        return
+
+    # (2) Rich console ------------------------------------------------------
+    if RICH_AVAILABLE and in_console() and use_rich:
+        console_theme = DARK_THEME if theme == "dark" else LIGHT_THEME
+        syntax_theme = "github-dark" if theme == "dark" else "solarized-light"
+        console = Console(theme=console_theme)
+
+        # determine prose / fenced code
+        is_fenced_code = (
+            md and str_.startswith("```") and str_.rstrip().endswith("```")
+        )
+        is_prose_md = md and not is_fenced_code
+        panel_width = min(console.width - 4, max_panel_width)
+
+        def _out(rich_obj):
+            if not panel:
+                console.print(Padding(rich_obj, (0, 0, 0, 2)))
+                return
+
+            console.print(
+                Padding(
+                    Panel(
+                        Align.left(rich_obj, pad=False),
+                        border_style="panel.border" if border else "",
+                        box=ROUNDED if border else MINIMAL,
+                        width=panel_width,
+                        expand=False,
+                    ),
+                    (0, 0, 0, 4),
                 )
+            )
 
-                # Add left margin padding for better alignment
-                panel = Panel(
-                    syntax,
-                    border_style=panel_style,
-                    box=ROUNDED,
-                    width=panel_width,
-                    expand=False,
-                )
+        # 2‑a prose markdown ------------------------------------------------
+        if is_prose_md:
+            from rich.markdown import Markdown as RichMarkdown
 
-                # Left align with margin
-                aligned_panel = Align.left(panel, pad=True)
-                console.print(Padding(aligned_panel, (0, 0, 0, 4)))
+            _out(RichMarkdown(str_, code_theme=syntax_theme))
+            return
 
-            else:
-                # Plain text output with rich formatting
-                if format_curly:
-                    syntax = Syntax(
-                        str_,
-                        "yaml",
-                        theme=syntax_theme,
-                        background_color="default",
-                        word_wrap=True,
-                    )
-                else:
-                    syntax = Syntax(
-                        str_,
-                        "json",
-                        theme=syntax_theme,
-                        background_color="default",
-                        word_wrap=True,
-                    )
-
-                # For plain syntax, add left margin
-                # Create a constrained width container if console is too wide
-                if console.width > max_panel_width:
-                    content = Align.left(
-                        syntax, width=max_panel_width, pad=False
-                    )
-                    # Add left margin
-                    console.print(Padding(content, (0, 0, 0, 4)))
-                else:
-                    # Just add left margin
-                    console.print(Padding(syntax, (0, 0, 0, 4)))
+        # 2‑b code (fenced or explicit) -------------------------------------
+        if is_fenced_code:
+            lines = str_.splitlines()
+            lang, code = (
+                (lines[0][3:].strip() or ("yaml" if format_curly else "json")),
+                "\n".join(lines[1:-1]),
+            )
         else:
-            # Fallback to regular print
-            print(str_)
-    else:
-        return str_
+            lang, code = ("yaml" if format_curly else "json"), str_
+
+        syntax = Syntax(
+            code,
+            lang,
+            theme=syntax_theme,
+            line_numbers=False,
+            word_wrap=True,
+            background_color="default",
+        )
+        _out(syntax)
+        return
+
+    # (3) Plain fallback ----------------------------------------------------
+    print(str_)

lionagi/libs/schema/extract_docstring.py

@@ -52,8 +52,7 @@ def extract_docstring(
         )
     else:
         raise ValueError(
-            f'{style} is not supported. Please choose either "google" or'
-            ' "reST".'
+            f'{style} is not supported. Please choose either "google" or "reST".'
         )
     return func_description, params_description
 

lionagi/libs/token_transform/synthlang_/base.py

@@ -21,7 +21,6 @@ __all__ = (
 
 
 class SynthlangFramework(Resource):
-
     category: ResourceCategory = Field(
         default=ResourceCategory.FRAMEWORK, frozen=True
     )
@@ -72,7 +71,6 @@ class SynthlangFramework(Resource):
         framework_options: list[FRAMEWORK_CHOICES] = None,
         additional_text: str = "",
     ) -> str:
-
         framework_options_text = self.build_framework_text(framework_options)
         base_prompt = self.load_base_system_prompt()
         template_details = (

lionagi/libs/validate/string_similarity.py

@@ -297,8 +297,7 @@ def string_similarity(
         score_func = algorithm
     else:
         raise ValueError(
-            "algorithm must be a string specifying a built-in algorithm or "
-            "a callable"
+            "algorithm must be a string specifying a built-in algorithm or a callable"
         )
 
     # Calculate similarities

lionagi/models/hashable_model.py

@@ -5,7 +5,6 @@ from lionagi.utils import UNDEFINED, hash_dict
 
 
 class HashableModel(BaseModel):
-
     def to_dict(self, **kwargs) -> dict:
         """provides interface, specific methods need to be implemented in subclass kwargs for pydantic model_dump"""
         return {

lionagi/models/schema_model.py

@@ -10,7 +10,6 @@ __all__ = ("SchemaModel",)
 
 
 class SchemaModel(HashableModel):
-
     model_config = ConfigDict(
         extra="forbid",
         validate_default=False,

lionagi/operations/ReAct/utils.py

@@ -113,7 +113,6 @@ class ReActAnalysis(HashableModel):
 
 
 class Analysis(HashableModel):
-
     answer: str | None = None
 
     @field_validator("answer", mode="before")

lionagi/operations/__init__.py

@@ -2,4 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from .flow import flow
+from .node import BranchOperations, Operation
 from .types import *

lionagi/operations/_act/act.py

@@ -20,7 +20,6 @@ async def _act(
     suppress_errors: bool = False,
     verbose_action: bool = False,
 ) -> "ActionResponseModel":
-
     _request = {}
 
     if isinstance(action_request, BaseModel):