lionagi 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

lionagi/fields/file.py

@@ -71,7 +71,7 @@ class File(HashableModel):
         header: str | None = None,
         footer: str | None = None,
     ) -> Path:
-        from lionagi.libs.file.create_path import create_path
+        from lionagi.utils import create_path
 
         fp = create_path(
             directory=directory,

lionagi/fields/reason.py

@@ -4,8 +4,8 @@
 
 from pydantic import Field, field_validator
 
-from lionagi.libs.parse.to_num import to_num
 from lionagi.models import FieldModel, HashableModel
+from lionagi.utils import to_num
 
 __all__ = ("Reason",)
 

lionagi/libs/file/concat.py

@@ -1,12 +1,7 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
 from pathlib import Path
 from typing import Any
 
-from lionagi.libs.file.create_path import create_path
-from lionagi.utils import lcall
+from lionagi.utils import create_path, lcall
 
 from .process import dir_to_files
 

lionagi/libs/file/concat_files.py

@@ -1,10 +1,6 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
-# SPDX-License-Identifier: Apache-2.0
-
 from pathlib import Path
 
-from lionagi.libs.file.create_path import create_path
+from lionagi.utils import create_path
 
 from .process import dir_to_files
 

lionagi/libs/file/save.py

@@ -7,7 +7,7 @@ import logging
 from pathlib import Path
 from typing import Any
 
-from .create_path import create_path
+from lionagi.utils import create_path
 
 
 def save_to_file(

lionagi/libs/package/imports.py

@@ -2,184 +2,15 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import logging
-import shutil
-import subprocess
-import sys
-from collections.abc import Sequence
-from typing import Any
-
-from lionagi.utils import is_import_installed
-
-
-def run_package_manager_command(
-    args: Sequence[str],
-) -> subprocess.CompletedProcess[bytes]:
-    """Run a package manager command, using uv if available, otherwise falling back to pip."""
-    # Check if uv is available in PATH
-    uv_path = shutil.which("uv")
-
-    if uv_path:
-        # Use uv if available
-        try:
-            return subprocess.run(
-                [uv_path] + list(args),
-                check=True,
-                capture_output=True,
-            )
-        except subprocess.CalledProcessError:
-            # If uv fails, fall back to pip
-            print("uv command failed, falling back to pip...")
-
-    # Fall back to pip
-    return subprocess.run(
-        [sys.executable, "-m", "pip"] + list(args),
-        check=True,
-        capture_output=True,
-    )
-
-
-def check_import(
-    package_name: str,
-    module_name: str | None = None,
-    import_name: str | None = None,
-    pip_name: str | None = None,
-    attempt_install: bool = True,
-    error_message: str = "",
-):
-    """
-    Check if a package is installed, attempt to install if not.
-
-    Args:
-        package_name: The name of the package to check.
-        module_name: The specific module to import (if any).
-        import_name: The specific name to import from the module (if any).
-        pip_name: The name to use for pip installation (if different).
-        attempt_install: Whether to attempt installation if not found.
-        error_message: Custom error message to use if package not found.
-
-    Raises:
-        ImportError: If the package is not found and not installed.
-        ValueError: If the import fails after installation attempt.
-    """
-    if not is_import_installed(package_name):
-        if attempt_install:
-            logging.info(
-                f"Package {package_name} not found. Attempting " "to install.",
-            )
-            try:
-                return install_import(
-                    package_name=package_name,
-                    module_name=module_name,
-                    import_name=import_name,
-                    pip_name=pip_name,
-                )
-            except ImportError as e:
-                raise ValueError(
-                    f"Failed to install {package_name}: {e}"
-                ) from e
-        else:
-            logging.info(
-                f"Package {package_name} not found. {error_message}",
-            )
-            raise ImportError(
-                f"Package {package_name} not found. {error_message}",
-            )
-
-    return import_module(
-        package_name=package_name,
-        module_name=module_name,
-        import_name=import_name,
-    )
-
-
-def import_module(
-    package_name: str,
-    module_name: str = None,
-    import_name: str | list = None,
-) -> Any:
-    """
-    Import a module by its path.
-
-    Args:
-        module_path: The path of the module to import.
-
-    Returns:
-        The imported module.
-
-    Raises:
-        ImportError: If the module cannot be imported.
-    """
-    try:
-        full_import_path = (
-            f"{package_name}.{module_name}" if module_name else package_name
-        )
-
-        if import_name:
-            import_name = (
-                [import_name]
-                if not isinstance(import_name, list)
-                else import_name
-            )
-            a = __import__(
-                full_import_path,
-                fromlist=import_name,
-            )
-            if len(import_name) == 1:
-                return getattr(a, import_name[0])
-            return [getattr(a, name) for name in import_name]
-        else:
-            return __import__(full_import_path)
-
-    except ImportError as e:
-        raise ImportError(
-            f"Failed to import module {full_import_path}: {e}"
-        ) from e
-
-
-def install_import(
-    package_name: str,
-    module_name: str | None = None,
-    import_name: str | None = None,
-    pip_name: str | None = None,
-):
-    """
-    Attempt to import a package, installing it if not found.
-
-    Args:
-        package_name: The name of the package to import.
-        module_name: The specific module to import (if any).
-        import_name: The specific name to import from the module (if any).
-        pip_name: The name to use for pip installation (if different).
-
-    Raises:
-        ImportError: If the package cannot be imported or installed.
-        subprocess.CalledProcessError: If pip installation fails.
-    """
-    pip_name = pip_name or package_name
-
-    try:
-        return import_module(
-            package_name=package_name,
-            module_name=module_name,
-            import_name=import_name,
-        )
-    except ImportError:
-        logging.info(f"Installing {pip_name}...")
-        try:
-            run_package_manager_command(["install", pip_name])
-            return import_module(
-                package_name=package_name,
-                module_name=module_name,
-                import_name=import_name,
-            )
-        except subprocess.CalledProcessError as e:
-            raise ImportError(f"Failed to install {pip_name}: {e}") from e
-        except ImportError as e:
-            raise ImportError(
-                f"Failed to import {pip_name} after installation: {e}"
-            ) from e
+from lionagi.utils import (
+    check_import,
+    import_module,
+    install_import,
+    is_import_installed,
+    run_package_manager_command,
+)
 
+# backward compatibility
 
 __all__ = (
     "run_package_manager_command",

lionagi/libs/parse.py

@@ -0,0 +1,30 @@
+# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from lionagi.libs.schema.as_readable import as_readable
+from lionagi.libs.schema.extract_code_block import extract_code_block
+from lionagi.libs.schema.function_to_schema import function_to_schema
+from lionagi.libs.validate.fuzzy_match_keys import fuzzy_match_keys
+from lionagi.libs.validate.fuzzy_validate_mapping import fuzzy_validate_mapping
+from lionagi.libs.validate.string_similarity import string_similarity
+from lionagi.utils import fuzzy_parse_json, to_dict, to_json, to_num
+
+validate_keys = fuzzy_match_keys  # for backward compatibility
+validate_mapping = fuzzy_validate_mapping  # for backward compatibility
+
+
+__all__ = (
+    "as_readable",
+    "extract_code_block",
+    "function_to_schema",
+    "fuzzy_match_keys",
+    "fuzzy_validate_mapping",
+    "string_similarity",
+    "validate_keys",
+    "validate_mapping",
+    "to_dict",
+    "to_json",
+    "to_num",
+    "fuzzy_parse_json",
+)

lionagi/libs/token_transform/synthlang_/resources/frameworks/framework_options.json

@@ -1,52 +1,52 @@
 {
-  "options": {
-    "math": {
-      "name": "Mathematical Framework",
-      "description": "Offers a suite of math glyphs and notation rules.",
-      "glyphs": [
-        {
-          "symbol": "\u21b9",
-          "name": "Focus/Filter",
-          "description": "Used for focusing instructions"
+    "options": {
+        "math": {
+            "name": "Mathematical Framework",
+            "description": "Offers a suite of math glyphs and notation rules.",
+            "glyphs": [
+                {
+                    "symbol": "\u21b9",
+                    "name": "Focus/Filter",
+                    "description": "Used for focusing instructions"
+                },
+                {
+                    "symbol": "\u03a3",
+                    "name": "Summarize",
+                    "description": "Condense large sets of data"
+                },
+                {
+                    "symbol": "\u2295",
+                    "name": "Combine/Merge",
+                    "description": "Merge multiple data sources"
+                },
+                {
+                    "symbol": "\u2022",
+                    "name": "Group Operation",
+                    "description": "Binary operation in group theory"
+                }
+            ]
         },
-        {
-          "symbol": "\u03a3",
-          "name": "Summarize",
-          "description": "Condense large sets of data"
+        "optim": {
+            "name": "Optimization Framework",
+            "description": "Compression and optimization for code/math expressions.",
+            "glyphs": [
+                {
+                    "symbol": "IF",
+                    "name": "Conditional Operator",
+                    "description": "Represents branching logic"
+                }
+            ]
         },
-        {
-          "symbol": "\u2295",
-          "name": "Combine/Merge",
-          "description": "Merge multiple data sources"
-        },
-        {
-          "symbol": "\u2022",
-          "name": "Group Operation",
-          "description": "Binary operation in group theory"
-        }
-      ]
-    },
-    "optim": {
-      "name": "Optimization Framework",
-      "description": "Compression and optimization for code/math expressions.",
-      "glyphs": [
-        {
-          "symbol": "IF",
-          "name": "Conditional Operator",
-          "description": "Represents branching logic"
-        }
-      ]
-    },
-    "custom_algebra": {
-      "name": "Custom Algebraic Framework",
-      "description": "Extra rules for ring, group, field expansions.",
-      "glyphs": [
-        {
-          "symbol": "\u221e",
-          "name": "Infinite Operator",
-          "description": "Represents unbounded algebraic ops"
+        "custom_algebra": {
+            "name": "Custom Algebraic Framework",
+            "description": "Extra rules for ring, group, field expansions.",
+            "glyphs": [
+                {
+                    "symbol": "\u221e",
+                    "name": "Infinite Operator",
+                    "description": "Represents unbounded algebraic ops"
+                }
+            ]
         }
-      ]
     }
-  }
 }

lionagi/protocols/generic/log.py

@@ -11,8 +11,7 @@ from typing import Any
 
 from pydantic import BaseModel, Field, PrivateAttr, field_validator
 
-from lionagi.libs.file.create_path import create_path
-from lionagi.utils import to_dict
+from lionagi.utils import create_path, to_dict
 
 from .._concepts import Manager
 from .element import Element

lionagi/protocols/messages/templates/README.md

@@ -19,14 +19,10 @@ message_text = template.render(**args)
 print(message_text)
 ```
 
-Benefits and Customization •	You can easily rearrange sections within these
-templates without changing your code logic. •	Each message type is clearly
-separated, making it simpler to maintain or adjust one message format without
-affecting the others. •	If you find that you use some snippet (like rendering a
-schema) in multiple templates, you can factor it out into its own partial
-template (like tool_schemas.jinja2) and include it where needed. •	Over time,
-you can add more templates or split existing ones if certain messages become too
-complex.
+Benefits and Customization
+	•	You can easily rearrange sections within these templates without changing your code logic.
+	•	Each message type is clearly separated, making it simpler to maintain or adjust one message format without affecting the others.
+	•	If you find that you use some snippet (like rendering a schema) in multiple templates, you can factor it out into its own partial template (like tool_schemas.jinja2) and include it where needed.
+	•	Over time, you can add more templates or split existing ones if certain messages become too complex.
 
-By establishing this set of base templates and arguments, you have a starting
-point. You can expand or refine as your requirements evolve.
+By establishing this set of base templates and arguments, you have a starting point. You can expand or refine as your requirements evolve.

lionagi/service/providers/exa_/models.py

@@ -1,3 +1,160 @@
-from khive.providers.exa_ import ExaSearchRequest
+from enum import Enum
 
-__all__ = ("ExaSearchRequest",)
+from pydantic import BaseModel, Field
+
+
+class CategoryEnum(str, Enum):
+    company = "company"
+    research_paper = "research paper"
+    news = "news"
+    pdf = "pdf"
+    github = "github"
+    tweet = "tweet"
+    personal_site = "personal site"
+    linkedin_profile = "linkedin profile"
+    financial_report = "financial report"
+
+
+class LivecrawlEnum(str, Enum):
+    never = "never"
+    fallback = "fallback"
+    always = "always"
+
+
+class SearchTypeEnum(str, Enum):
+    keyword = "keyword"
+    neural = "neural"
+    auto = "auto"
+
+
+class ContentsText(BaseModel):
+    includeHtmlTags: bool | None = Field(
+        default=False,
+        description="Whether to include HTML tags in the text. Set to True if you want to retain HTML structure for the LLM to interpret.",
+    )
+    maxCharacters: int | None = Field(
+        default=None,
+        description="The maximum number of characters to return from the webpage text.",
+    )
+
+
+class ContentsHighlights(BaseModel):
+    highlightsPerUrl: int | None = Field(
+        default=1,
+        description="The number of highlight snippets you want per page.",
+    )
+    numSentences: int | None = Field(
+        default=5,
+        description="Number of sentences to return in each highlight snippet.",
+    )
+    query: None | str = Field(
+        default=None,
+        description="A specific query used to generate the highlight snippets.",
+    )
+
+
+class ContentsSummary(BaseModel):
+    query: None | str = Field(
+        default=None,
+        description="A specific query used to generate a summary of the webpage.",
+    )
+
+
+class ContentsExtras(BaseModel):
+    links: int | None = Field(
+        default=None, description="Number of links to return from each page."
+    )
+    imageLinks: int | None = Field(
+        default=None, description="Number of images to return for each result."
+    )
+
+
+class Contents(BaseModel):
+    text: None | ContentsText = Field(
+        default=None,
+        description="Return full or partial text for each page, with optional HTML structure or size limit.",
+    )
+    highlights: None | ContentsHighlights = Field(
+        default=None, description="Return snippet highlights for each page."
+    )
+    summary: None | ContentsSummary = Field(
+        default=None, description="Return a short summary of each page."
+    )
+    livecrawl: None | LivecrawlEnum = Field(
+        default=LivecrawlEnum.never,
+        description="Livecrawling setting for each page. Options: never, fallback, always.",
+    )
+    livecrawlTimeout: int | None = Field(
+        default=10000,
+        description="Timeout in milliseconds for livecrawling. Default 10000.",
+    )
+    subpages: int | None = Field(
+        default=None,
+        description="Number of subpages to crawl within each URL.",
+    )
+    subpageTarget: None | str | list[str] = Field(
+        default=None,
+        description="A target subpage or multiple subpages (list) to crawl, e.g. 'cited papers'.",
+    )
+    extras: None | ContentsExtras = Field(
+        default=None,
+        description="Additional extras like links or images to return for each page.",
+    )
+
+
+class ExaSearchRequest(BaseModel):
+    query: str = Field(
+        ...,
+        description="The main query string describing what you're looking for.",
+    )
+    category: None | CategoryEnum = Field(
+        default=None,
+        description="A data category to focus on, such as 'company', 'research paper', 'news', etc.",
+    )
+    type: None | SearchTypeEnum = Field(
+        default=None,
+        description="The type of search to run. Can be 'auto', 'keyword', or 'neural'.",
+    )
+    useAutoprompt: None | bool = Field(
+        default=False,
+        description="If True, Exa auto-optimizes your query for best results (neural or auto search only).",
+    )
+    numResults: int | None = Field(
+        default=10, description="Number of results to return. Default is 10."
+    )
+    includeDomains: None | list[str] = Field(
+        default=None,
+        description="List of domains you want to include exclusively.",
+    )
+    excludeDomains: None | list[str] = Field(
+        default=None,
+        description="List of domains you do NOT want to see in the results.",
+    )
+    startCrawlDate: None | str = Field(
+        default=None,
+        description="Include results crawled after this ISO date (e.g., '2023-01-01T00:00:00.000Z').",
+    )
+    endCrawlDate: None | str = Field(
+        default=None,
+        description="Include results crawled before this ISO date.",
+    )
+    startPublishedDate: None | str = Field(
+        default=None,
+        description="Only return results published after this ISO date.",
+    )
+    endPublishedDate: None | str = Field(
+        default=None,
+        description="Only return results published before this ISO date.",
+    )
+    includeText: None | list[str] = Field(
+        default=None,
+        description="Strings that must appear in the webpage text. Only a single string up to 5 words is currently supported.",
+    )
+    excludeText: None | list[str] = Field(
+        default=None,
+        description="Strings that must NOT appear in the webpage text. Only a single string up to 5 words is currently supported.",
+    )
+    contents: None | Contents = Field(
+        default=None,
+        description="Dict defining the different ways you want to retrieve webpage contents, including text, highlights, or summaries.",
+    )