lionagi 0.15.8__tar.gz → 0.15.11__tar.gz

{lionagi-0.15.8 → lionagi-0.15.11}/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
       matrix:
         python-version: ['3.10', '3.11', '3.12', '3.13']
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
       with:
@@ -59,7 +59,7 @@ jobs:
       contents: read
       packages: write
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Set up Python
       uses: actions/setup-python@v5
       with:

{lionagi-0.15.8 → lionagi-0.15.11}/.github/workflows/codeql.yml

@@ -24,7 +24,7 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
 
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v3

{lionagi-0.15.8 → lionagi-0.15.11}/.github/workflows/release.yml

@@ -14,7 +14,7 @@ jobs:
       matrix:
         python-version: ['3.10', '3.11', '3.12', '3.13']
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v5
       with:
@@ -39,7 +39,7 @@ jobs:
     needs: test
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Set up Python
       uses: actions/setup-python@v5
       with:

{lionagi-0.15.8 → lionagi-0.15.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lionagi
-Version: 0.15.8
+Version: 0.15.11
 Summary: An Intelligence Operating System.
 Author-email: HaiyangLi <quantocean.li@gmail.com>
 License:            Apache License
@@ -228,7 +228,7 @@ Requires-Dist: json-repair>=0.40.0
 Requires-Dist: pillow>=11.0.0
 Requires-Dist: psutil>=6.0.0
 Requires-Dist: pydantic-settings>=2.8.0
-Requires-Dist: pydapter[pandas]>=1.0.0
+Requires-Dist: pydapter[pandas]>=1.0.2
 Requires-Dist: python-dotenv>=1.1.0
 Requires-Dist: tiktoken>=0.9.0
 Requires-Dist: toml>=0.8.0

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/__init__.py

@@ -7,9 +7,9 @@ import logging
 from pydantic import BaseModel, Field
 
 from . import _types as types
-from .operations import Operation
-from .operations import OperationGraphBuilder as Builder
-from .operations import brainstorm, flow, plan
+from . import ln as ln
+from .operations.builder import OperationGraphBuilder as Builder
+from .operations.node import Operation
 from .service.imodel import iModel
 from .session.session import Branch, Session
 from .version import __version__
@@ -28,7 +28,5 @@ __all__ = (
     "logger",
     "Builder",
     "Operation",
-    "brainstorm",
-    "flow",
-    "plan",
+    "ln",
 )

lionagi-0.15.11/lionagi/adapters/async_postgres_adapter.py

@@ -0,0 +1,98 @@
+"""
+Clean LionAGI async PostgreSQL adapter for integration into lionagi core.
+
+This adapter leverages pydapter v1.0.2+ CRUD operations.
+"""
+
+from __future__ import annotations
+
+from typing import ClassVar, TypeVar
+
+import sqlalchemy as sa
+from pydapter.extras.async_postgres_ import AsyncPostgresAdapter
+from sqlalchemy.ext.asyncio import create_async_engine
+
+from ._utils import check_async_postgres_available
+
+_ASYNC_POSTGRES_AVAILABLE = check_async_postgres_available()
+
+if isinstance(_ASYNC_POSTGRES_AVAILABLE, ImportError):
+    raise _ASYNC_POSTGRES_AVAILABLE
+
+T = TypeVar("T")
+
+
+class LionAGIAsyncPostgresAdapter(AsyncPostgresAdapter[T]):
+    """
+    Zero-config async PostgreSQL adapter for lionagi Nodes.
+
+    - Auto-creates tables with lionagi schema
+    - Changes default adapt_meth to "to_dict" for lionagi Elements
+    - Everything else handled by parent AsyncPostgresAdapter
+    """
+
+    obj_key: ClassVar[str] = "lionagi_async_pg"
+
+    @classmethod
+    async def to_obj(
+        cls,
+        subj,
+        /,
+        *,
+        many: bool = True,
+        adapt_meth: str = "as_jsonable",  # Default to to_dict for lionagi
+        **kw,
+    ):
+        """Write lionagi Node(s) to PostgreSQL with CRUD support."""
+        # Auto-create table if needed
+        if table := kw.get("table"):
+            if engine_url := (kw.get("dsn") or kw.get("engine_url")):
+                await cls._ensure_table(engine_url, table)
+            elif engine := kw.get("engine"):
+                await cls._ensure_table(engine, table)
+
+        return await super().to_obj(
+            subj, many=many, adapt_meth=adapt_meth, **kw
+        )
+
+    @classmethod
+    async def _ensure_table(cls, engine_or_url, table_name: str):
+        """Create table with lionagi schema if it doesn't exist."""
+        # Handle both engine and URL
+        should_dispose = None
+        if isinstance(engine_or_url, str):
+            engine = create_async_engine(engine_or_url, future=True)
+            should_dispose = True
+        else:
+            engine = engine_or_url
+            should_dispose = False
+
+        try:
+            async with engine.begin() as conn:
+                # Determine JSON type based on database
+                engine_url = str(engine.url)
+                json_type = (
+                    sa.dialects.postgresql.JSONB
+                    if "postgresql" in engine_url
+                    else sa.JSON
+                )
+
+                # Create table with lionagi schema
+                await conn.run_sync(
+                    lambda sync_conn: sa.Table(
+                        table_name,
+                        sa.MetaData(),
+                        sa.Column("id", sa.String, primary_key=True),
+                        sa.Column("content", json_type),
+                        sa.Column(
+                            "metadata", json_type
+                        ),  # Use metadata directly now
+                        sa.Column(
+                            "created_at", sa.Float
+                        ),  # Stored as float timestamp
+                        sa.Column("embedding", json_type, nullable=True),
+                    ).create(sync_conn, checkfirst=True)
+                )
+        finally:
+            if should_dispose:
+                await engine.dispose()

lionagi-0.15.11/lionagi/libs/file/_utils.py

@@ -0,0 +1,10 @@
+def check_docling_available():
+    try:
+        from docling.document_converter import DocumentConverter  # noqa: F401
+
+        return True
+    except Exception:
+        return ImportError(
+            "The 'docling' package is required for this feature. "
+            "Please install it via 'pip install lionagi[reader]'."
+        )

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/libs/file/process.py

@@ -8,11 +8,14 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 from typing import Any, Literal
 
-from lionagi.utils import lcall
+from lionagi import ln
 
+from ._utils import check_docling_available
 from .chunk import chunk_content
 from .save import save_chunks
 
+_HAS_DOCLING = check_docling_available()
+
 
 def dir_to_files(
     directory: str | Path,
@@ -206,24 +209,24 @@ def chunk(
             reader_tool = lambda x: Path(x).read_text(encoding="utf-8")
 
         if reader_tool == "docling":
-            from lionagi.libs.package.imports import check_import
+            if _HAS_DOCLING is not True:
+                raise _HAS_DOCLING
 
-            DocumentConverter = check_import(
-                "docling",
-                module_name="document_converter",
-                import_name="DocumentConverter",
+            from docling.document_converter import (  # noqa: F401
+                DocumentConverter,
             )
+
             converter = DocumentConverter()
             reader_tool = lambda x: converter.convert(
                 x
             ).document.export_to_markdown()
 
-        texts = lcall(files, reader_tool)
+        texts = ln.lcall(files, reader_tool)
 
     else:
         texts = [text]
 
-    chunks = lcall(
+    chunks = ln.lcall(
         texts,
         chunk_content,
         chunk_by=chunk_by,
@@ -244,15 +247,15 @@ def chunk(
         output_file = Path(output_file)
         if output_file.suffix == ".csv":
             p = Pile(chunks)
-            p.to_csv_file(output_file)
+            p.dump(output_file, "csv")
 
-        elif output_file.suffix == ".json":
+        if output_file.suffix == "json":
             p = Pile(chunks)
-            p.to_json_file(output_file, use_pd=True)
+            p.dump(output_file, "json")
 
-        elif output_file.suffix in Pile.list_adapters():
+        if output_file.suffix == ".parquet":
             p = Pile(chunks)
-            p.adapt_to(output_file.suffix, fp=output_file)
+            p.dump(output_file, "parquet")
 
         else:
             raise ValueError(f"Unsupported output file format: {output_file}")

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/libs/file/save.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import json
 import logging
 from pathlib import Path
 from typing import Any
@@ -78,6 +77,8 @@ def save_chunks(
     random_hash_digits: int,
 ) -> None:
     """Helper function to save chunks to files."""
+    from lionagi import ln
+
     output_path = Path(output_dir)
     for i, chunk in enumerate(chunks):
         file_path = create_path(
@@ -88,7 +89,7 @@ def save_chunks(
             random_hash_digits=random_hash_digits,
         )
         save_to_file(
-            json.dumps(chunk, ensure_ascii=False, indent=2),
+            ln.json_dumps(chunk),
             directory=file_path.parent,
             filename=file_path.name,
             verbose=verbose,

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/libs/schema/load_pydantic_model_from_schema.py

@@ -11,6 +11,7 @@ from typing import Any, TypeVar
 
 from pydantic import BaseModel, PydanticUserError
 
+from lionagi import ln
 from lionagi.utils import is_import_installed
 
 _HAS_DATAMODEL_CODE_GENERATOR = is_import_installed("datamodel_code_generator")
@@ -98,7 +99,7 @@ def load_pydantic_model_from_schema(
                         sanitized_title  # Update the name to use
                     )
             schema_dict = schema
-            schema_input_data = json.dumps(schema)
+            schema_input_data = ln.json_dumps(schema_dict)
         except TypeError as e:
             error_msg = "Invalid dictionary provided for schema"
             raise ValueError(error_msg) from e

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/libs/unstructured/pdf_to_image.py

@@ -1,4 +1,4 @@
-from lionagi.utils import check_import, is_import_installed
+from lionagi.utils import import_module, is_import_installed
 
 _HAS_PDF2IMAGE = is_import_installed("pdf2image")
 
@@ -25,7 +25,7 @@ def pdf_to_images(
 
     import os
 
-    convert_from_path = check_import(
+    convert_from_path = import_module(
         "pdf2image", import_name="convert_from_path"
     )
 

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/ln/__init__.py

@@ -1,5 +1,13 @@
 from ._async_call import AlcallParams, BcallParams, alcall, bcall
+from ._extract_json import extract_json
+from ._fuzzy_json import fuzzy_json
 from ._hash import hash_dict
+from ._json_dump import (
+    DEFAULT_SERIALIZER,
+    DEFAULT_SERIALIZER_OPTION,
+    get_orjson_default,
+    json_dumps,
+)
 from ._list_call import LcallParams, lcall
 from ._models import DataClass, Params
 from ._to_list import ToListParams, to_list
@@ -46,4 +54,34 @@ __all__ = (
     "bcall",
     "AlcallParams",
     "BcallParams",
+    "get_orjson_default",
+    "DEFAULT_SERIALIZER",
+    "DEFAULT_SERIALIZER_OPTION",
+    "json_dumps",
+    "TaskGroup",
+    "create_task_group",
+    "CancelScope",
+    "move_on_after",
+    "fail_after",
+    "ConnectionPool",
+    "WorkerPool",
+    "parallel_requests",
+    "retry_with_timeout",
+    "Lock",
+    "Semaphore",
+    "CapacityLimiter",
+    "Event",
+    "Condition",
+    "get_cancelled_exc_class",
+    "shield",
+    "ResourceTracker",
+    "resource_leak_detector",
+    "track_resource",
+    "untrack_resource",
+    "cleanup_check",
+    "get_global_tracker",
+    "is_coro_func",
+    "ConcurrencyEvent",
+    "fuzzy_json",
+    "extract_json",
 )

lionagi-0.15.11/lionagi/ln/_extract_json.py

@@ -0,0 +1,60 @@
+import re
+from typing import Any
+
+import orjson
+
+from ._fuzzy_json import fuzzy_json
+
+# Precompile the regex for extracting JSON code blocks
+_JSON_BLOCK_PATTERN = re.compile(r"```json\s*(.*?)\s*```", re.DOTALL)
+
+
+def extract_json(
+    input_data: str | list[str],
+    /,
+    *,
+    fuzzy_parse: bool = False,
+    return_one_if_single: bool = True,
+) -> dict[str, Any] | list[dict[str, Any]]:
+    """Extract and parse JSON content from a string or markdown code blocks.
+    Attempts direct JSON parsing first. If that fails, looks for JSON content
+    within markdown code blocks denoted by ```json.
+
+    Args:
+        input_data (str | list[str]): The input string or list of strings to parse.
+        fuzzy_parse (bool): If True, attempts fuzzy JSON parsing on failed attempts.
+        return_one_if_single (bool): If True and only one JSON object is found,
+            returns a dict instead of a list with one dict.
+    """
+
+    # If input_data is a list, join into a single string
+    if isinstance(input_data, list):
+        input_str = "\n".join(input_data)
+    else:
+        input_str = input_data
+
+    # 1. Try direct parsing
+    try:
+        if fuzzy_parse:
+            return fuzzy_json(input_str)
+        return orjson.loads(input_str)
+    except Exception:
+        pass
+
+    # 2. Attempt extracting JSON blocks from markdown
+    matches = _JSON_BLOCK_PATTERN.findall(input_str)
+    if not matches:
+        return []
+
+    # If only one match, return single dict; if multiple, return list of dicts
+    if return_one_if_single and len(matches) == 1:
+        data_str = matches[0]
+        if fuzzy_parse:
+            return fuzzy_json(data_str)
+        return orjson.loads(data_str)
+
+    # Multiple matches
+    if fuzzy_parse:
+        return [fuzzy_json(m) for m in matches]
+    else:
+        return [orjson.loads(m) for m in matches]

lionagi-0.15.11/lionagi/ln/_fuzzy_json.py

@@ -0,0 +1,116 @@
+import contextlib
+import re
+from typing import Any
+
+import orjson
+
+
+def fuzzy_json(str_to_parse: str, /) -> dict[str, Any] | list[dict[str, Any]]:
+    """
+    Attempt to parse a JSON string, trying a few minimal "fuzzy" fixes if needed.
+
+    Steps:
+    1. Parse directly with json.loads.
+    2. Replace single quotes with double quotes, normalize spacing, and try again.
+    3. Attempt to fix unmatched brackets using fix_json_string.
+    4. If all fail, raise ValueError.
+
+    Args:
+        str_to_parse: The JSON string to parse
+
+    Returns:
+        Parsed JSON (dict or list of dicts)
+
+    Raises:
+        ValueError: If the string cannot be parsed as valid JSON
+        TypeError: If the input is not a string
+    """
+    _check_valid_str(str_to_parse)
+
+    # 1. Direct attempt
+    with contextlib.suppress(Exception):
+        return orjson.loads(str_to_parse)
+
+    # 2. Try cleaning: replace single quotes with double and normalize
+    cleaned = _clean_json_string(str_to_parse.replace("'", '"'))
+    with contextlib.suppress(Exception):
+        return orjson.loads(cleaned)
+
+    # 3. Try fixing brackets
+    fixed = fix_json_string(cleaned)
+    with contextlib.suppress(Exception):
+        return orjson.loads(fixed)
+
+    # If all attempts fail
+    raise ValueError("Invalid JSON string")
+
+
+def _check_valid_str(str_to_parse: str, /):
+    if not isinstance(str_to_parse, str):
+        raise TypeError("Input must be a string")
+    if not str_to_parse.strip():
+        raise ValueError("Input string is empty")
+
+
+def _clean_json_string(s: str) -> str:
+    """Basic normalization: replace unescaped single quotes, trim spaces, ensure keys are quoted."""
+    # Replace unescaped single quotes with double quotes
+    # '(?<!\\)'" means a single quote not preceded by a backslash
+    s = re.sub(r"(?<!\\)'", '"', s)
+    # Collapse multiple whitespaces
+    s = re.sub(r"\s+", " ", s)
+    # Ensure keys are quoted
+    # This attempts to find patterns like { key: value } and turn them into {"key": value}
+    s = re.sub(r'([{,])\s*([^"\s]+)\s*:', r'\1"\2":', s)
+    return s.strip()
+
+
+def fix_json_string(str_to_parse: str, /) -> str:
+    """Try to fix JSON string by ensuring brackets are matched properly."""
+    if not str_to_parse:
+        raise ValueError("Input string is empty")
+
+    brackets = {"{": "}", "[": "]"}
+    open_brackets = []
+    pos = 0
+    length = len(str_to_parse)
+
+    while pos < length:
+        char = str_to_parse[pos]
+
+        if char == "\\":
+            pos += 2  # Skip escaped chars
+            continue
+
+        if char == '"':
+            pos += 1
+            # skip string content
+            while pos < length:
+                if str_to_parse[pos] == "\\":
+                    pos += 2
+                    continue
+                if str_to_parse[pos] == '"':
+                    pos += 1
+                    break
+                pos += 1
+            continue
+
+        if char in brackets:
+            open_brackets.append(brackets[char])
+        elif char in brackets.values():
+            if not open_brackets:
+                # Extra closing bracket
+                # Better to raise error than guess
+                raise ValueError("Extra closing bracket found.")
+            if open_brackets[-1] != char:
+                # Mismatched bracket
+                raise ValueError("Mismatched brackets.")
+            open_brackets.pop()
+
+        pos += 1
+
+    # Add missing closing brackets if any
+    if open_brackets:
+        str_to_parse += "".join(reversed(open_brackets))
+
+    return str_to_parse

lionagi-0.15.11/lionagi/ln/_json_dump.py

@@ -0,0 +1,75 @@
+import datetime as dt
+import decimal
+from collections.abc import Callable
+from pathlib import Path
+from uuid import UUID
+
+import orjson
+
+
+def _get_default_serializers():
+    return {
+        dt.datetime: lambda o: o.isoformat(),
+        Path: lambda o: str(o),
+        UUID: lambda o: str(o),
+        decimal.Decimal: lambda o: str(o),
+        set: lambda o: list(o),
+        frozenset: lambda o: list(o),
+    }
+
+
+def _get_default_serializer_order():
+    return [dt.datetime, Path, UUID, decimal.Decimal, set, frozenset]
+
+
+def get_orjson_default(
+    order: list[type] = None,
+    additional: dict[type, Callable] = None,
+    extend_default: bool = True,
+) -> Callable:
+    """get the default function for orjson.dumps
+    Args:
+        order: order of types to check. Defaults to None.
+        additional: additional serializers
+        extend_default: when order is provided, whether to extend the default order or replace it.
+    """
+    dict_ = _get_default_serializers()
+    dict_.update(additional or {})
+    order_ = _get_default_serializer_order()
+
+    if order:
+        if len(additional or {}) > 0 and extend_default:
+            order_.extend([k for k in order if k not in order_])
+        else:
+            order_ = list(order)
+    else:
+        if len(additional or {}) > 0:
+            order_.extend([k for k in additional.keys() if k not in order_])
+
+    def default(obj):
+        for t in order_:
+            if isinstance(obj, t) and t in dict_:
+                return dict_[t](obj)
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+    return default
+
+
+DEFAULT_SERIALIZER = get_orjson_default()
+DEFAULT_SERIALIZER_OPTION = (
+    orjson.OPT_INDENT_2
+    | orjson.OPT_SORT_KEYS
+    | orjson.OPT_APPEND_NEWLINE
+    | orjson.OPT_SERIALIZE_DATACLASS
+)
+
+
+def json_dumps(d_, decode=True, /) -> str:
+    by_ = orjson.dumps(
+        d_,
+        default=DEFAULT_SERIALIZER,
+        option=DEFAULT_SERIALIZER_OPTION,
+    )
+    if decode:
+        return by_.decode("utf-8")
+    return by_

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/ln/_models.py

@@ -70,7 +70,6 @@ class Params:
             _validate_strict(k)
 
     def default_kw(self) -> Any:
-
         # create a partial function with the current parameters
         dict_ = self.to_dict()
 

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/models/field_model.py

@@ -16,7 +16,6 @@ from typing import Annotated, Any
 from typing_extensions import Self, override
 
 from .._errors import ValidationError
-from ..utils import UNDEFINED
 
 # Cache of valid Pydantic Field parameters
 _PYDANTIC_FIELD_PARAMS: set[str] | None = None
@@ -660,13 +659,16 @@ def to_dict(self) -> dict[str, Any]:
 
     # Convert metadata to dictionary
     for meta in self.metadata:
-        if meta.key not in ("nullable", "listable", "validator"):
+        if meta.key not in (
+            "nullable",
+            "listable",
+            "validator",
+            "name",
+            "validator_kwargs",
+            "annotation",
+        ):
             result[meta.key] = meta.value
 
-    # Add annotation if available
-    if hasattr(self, "annotation"):
-        result["annotation"] = self.base_type
-
     return result
 
 

{lionagi-0.15.8 → lionagi-0.15.11}/lionagi/operations/__init__.py

@@ -8,6 +8,8 @@ from .flow import flow
 from .node import BranchOperations, Operation
 from .plan.plan import PlanOperation, plan
 
+Builder = OperationGraphBuilder
+
 __all__ = (
     "ExpansionStrategy",
     "OperationGraphBuilder",
@@ -19,4 +21,5 @@ __all__ = (
     "PlanOperation",
     "brainstorm",
     "BrainstormOperation",
+    "Builder",
 )