lionagi 0.13.1__py3-none-any.whl → 0.13.3__py3-none-any.whl

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

@@ -3,10 +3,93 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import json
+import sys
 from typing import Any
 
 from lionagi.utils import to_dict
 
+# Try to import rich for enhanced console output
+try:
+    from rich.align import Align
+    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
+    DARK_THEME = None
+    LIGHT_THEME = None
+
 
 def in_notebook() -> bool:
     """
@@ -22,6 +105,18 @@ def in_notebook() -> bool:
         return False
 
 
+def in_console() -> bool:
+    """
+    Checks if we're running in a console/terminal environment.
+    Returns True if stdout is a TTY and not in a notebook.
+    """
+    return (
+        hasattr(sys.stdout, "isatty")
+        and sys.stdout.isatty()
+        and not in_notebook()
+    )
+
+
 def format_dict(data: Any, indent: int = 0) -> str:
     """
     Recursively format Python data (dicts, lists, strings, etc.) into a
@@ -77,6 +172,11 @@ def as_readable(
     format_curly: bool = False,
     display_str: bool = False,
     max_chars: int | None = None,
+    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
@@ -84,14 +184,22 @@ def as_readable(
 
     - For Pydantic models or nested data, uses `to_dict` to get a dictionary.
     - If the result is a list of items, each is processed and concatenated.
+    - When in console and rich is available, provides syntax highlighting.
 
     Args:
         input_: The data to convert (could be a single item or list).
         md: If True, wraps the final output in code fences for Markdown display.
         format_curly: If True, use `format_dict`. Otherwise, produce JSON text.
+        display_str: If True, prints the output instead of returning it.
+        max_chars: If set, truncates output to this many characters.
+        use_rich: If True and rich is available, uses rich for console output.
+        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_`.
+        A formatted string representation of `input_` (unless display_str=True).
     """
 
     # 1) Convert the input to a Python dict/list structure
@@ -108,6 +216,7 @@ def as_readable(
         return to_dict(obj, **to_dict_kwargs)
 
     def _inner(i_: Any) -> Any:
+        items = []
         try:
             if isinstance(i_, list):
                 # Already a list. Convert each item
@@ -146,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```"
@@ -157,18 +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_))
+        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),
+                )
+            )
+
+        # 2‑a prose markdown ------------------------------------------------
+        if is_prose_md:
+            from rich.markdown import Markdown as RichMarkdown
+
+            _out(RichMarkdown(str_, code_theme=syntax_theme))
+            return
+
+        # 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:
-            # Otherwise, just print the string
-            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/_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):

lionagi/operations/interpret/interpret.py

@@ -23,10 +23,7 @@ async def interpret(
         "Return only the re-written prompt. Do not assume any details not mentioned in the input, nor "
         "give additional instruction than what is explicitly stated."
     )
-    guidance = (
-        f"Domain hint: {domain or 'general'}. "
-        f"Desired style: {style or 'concise'}. "
-    )
+    guidance = f"Domain hint: {domain or 'general'}. Desired style: {style or 'concise'}. "
     if sample_writing:
         guidance += f" Sample writing: {sample_writing}"
 

lionagi/operations/manager.py

@@ -8,7 +8,6 @@ experimental
 
 
 class OperationManager(Manager):
-
     def __init__(self, *args, **kwargs):
         super().__init__()
         self.registry: dict[str, Callable] = {}

lionagi/operations/plan/plan.py

@@ -231,7 +231,6 @@ async def plan(
 
         # We now handle multiple strategies:
         match execution_strategy:
-
             # ---------------------------------------------------------
             # Strategy A: SEQUENTIAL
             # ---------------------------------------------------------

lionagi/operations/select/utils.py

@@ -65,7 +65,6 @@ def parse_to_representation(
 
 
 def get_choice_representation(choice: Any) -> str:
-
     if isinstance(choice, str):
         return choice
 
@@ -77,7 +76,6 @@ def get_choice_representation(choice: Any) -> str:
 
 
 def parse_selection(selection_str: str, choices: Any):
-
     select_from = []
 
     if isinstance(choices, dict):

lionagi/protocols/forms/flow.py

@@ -46,7 +46,9 @@ class FlowDefinition(BaseModel):
             ins_str, outs_str = seg.split("->", 1)
             inputs = [x.strip() for x in ins_str.split(",") if x.strip()]
             outputs = [y.strip() for y in outs_str.split(",") if y.strip()]
-            step = FlowStep(name=f"step_{i+1}", inputs=inputs, outputs=outputs)
+            step = FlowStep(
+                name=f"step_{i + 1}", inputs=inputs, outputs=outputs
+            )
             self.steps.append(step)
 
     def get_required_fields(self) -> set[str]:

lionagi/protocols/generic/pile.py

@@ -851,8 +851,7 @@ class Pile(Element, Collective[E], Generic[E]):
                 if self.strict_type:
                     if type(i) not in self.item_type:
                         raise TypeError(
-                            "Invalid item type in pile."
-                            f" Expected {self.item_type}",
+                            f"Invalid item type in pile. Expected {self.item_type}",
                         )
                 else:
                     if not any(issubclass(type(i), t) for t in self.item_type):

lionagi/protocols/generic/processor.py

@@ -149,7 +149,6 @@ class Processor(Observer):
                 next_event = await self.dequeue()
 
             if await self.request_permission(**next_event.request):
-
                 if next_event.streaming:
                     task = asyncio.create_task(next_event.stream())
                 else:

lionagi/protocols/graph/graph.py

@@ -21,7 +21,6 @@ __all__ = ("Graph",)
 
 
 class Graph(Element, Relational):
-
     internal_nodes: Pile[Node] = Field(
         default_factory=lambda: Pile(item_type={Node}, strict_type=False),
         title="Internal Nodes",
@@ -52,8 +51,7 @@ class Graph(Element, Relational):
         """Add a node to the graph."""
         if not isinstance(node, Relational):
             raise RelationError(
-                "Failed to add node: Invalid node type: "
-                "not a <Relational> entity."
+                "Failed to add node: Invalid node type: not a <Relational> entity."
             )
         _id = ID.get_id(node)
         try:

lionagi/protocols/mail/package.py

@@ -91,7 +91,6 @@ class Package(Observable):
         item: Any,
         request_source: ID[Communicatable] = None,
     ):
-
         super().__init__()
         self.id = IDType.create()
         self.created_at = time(type_="timestamp")

lionagi/protocols/messages/assistant_response.py

@@ -15,7 +15,6 @@ from .message import MessageRole, RoledMessage, Template, jinja_env
 def prepare_assistant_response(
     assistant_response: BaseModel | list[BaseModel] | dict | str | Any, /
 ) -> dict:
-
     assistant_response = (
         [assistant_response]
         if not isinstance(assistant_response, list)
@@ -26,7 +25,6 @@ def prepare_assistant_response(
     model_responses = []
 
     for i in assistant_response:
-
         if isinstance(i, BaseModel):
             i = i.model_dump(exclude_none=True, exclude_unset=True)
 

lionagi/protocols/messages/message.py

@@ -232,7 +232,6 @@ class RoledMessage(Node, Sendable):
             self.template = template
 
     def __str__(self) -> str:
-
         content_preview = (
             f"{str(self.content)[:75]}..."
             if len(str(self.content)) > 75

lionagi/service/connections/endpoint_config.py

@@ -73,6 +73,12 @@ class EndpointConfig(BaseModel):
 
         return self
 
+    @field_validator("provider", mode="before")
+    def _validate_provider(cls, v: str):
+        if not v:
+            raise ValueError("Provider must be specified")
+        return v.strip().lower()
+
     @property
     def full_url(self):
         if not self.endpoint_params:

lionagi/service/connections/match_endpoint.py

@@ -2,6 +2,8 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+from lionagi.service.connections.endpoint_config import EndpointConfig
+
 from .endpoint import Endpoint
 
 
@@ -45,13 +47,29 @@ def match_endpoint(
         from .providers.perplexity_ import PerplexityChatEndpoint
 
         return PerplexityChatEndpoint(**kwargs)
-    if provider == "claude_code" and (
-        "query" in endpoint or "code" in endpoint
-    ):
-        from lionagi.service.connections.providers.claude_code_ import (
-            ClaudeCodeEndpoint,
-        )
+    if provider == "claude_code":
+        if "cli" in endpoint:
+            from .providers.claude_code_cli import ClaudeCodeCLIEndpoint
+
+            return ClaudeCodeCLIEndpoint(**kwargs)
+
+        if "query" in endpoint or "code" in endpoint:
+            from lionagi.service.connections.providers.claude_code_ import (
+                ClaudeCodeEndpoint,
+            )
+
+            return ClaudeCodeEndpoint(**kwargs)
+
+    from .providers.oai_ import OpenaiChatEndpoint
 
-        return ClaudeCodeEndpoint(**kwargs)
+    config = EndpointConfig(
+        provider=provider,
+        endpoint=endpoint or "chat/completions",
+        name="openai_compatible_chat",
+        auth_type="bearer",
+        content_type="application/json",
+        method="POST",
+        requires_tokens=True,
+    )
 
-    return None
+    return Endpoint(config, **kwargs)