lionagi 0.10.1__py3-none-any.whl → 0.10.3__py3-none-any.whl

lionagi/_types.py

@@ -1 +1,2 @@
+from .fields import *
 from .protocols.types import *

lionagi/adapters/toml_adapter.py

@@ -141,7 +141,7 @@ class TomlFileAdapter(Adapter):
         dict | list[dict]
             The loaded data from file.
         """
-        with open(obj, "r", encoding="utf-8") as f:
+        with open(obj, encoding="utf-8") as f:
             result = toml.load(f, **kwargs)
 
         # Handle array of tables in TOML for "many" case

lionagi/fields/__init__.py

@@ -0,0 +1,29 @@
+from .action import ActionRequestModel, ActionResponseModel
+from .base import (
+    CodeSnippet,
+    Outline,
+    OutlineItem,
+    Section,
+    Source,
+    TextSnippet,
+)
+from .file import CodeFile, Documentation, File
+from .instruct import Instruct, InstructResponse
+from .reason import Reason
+
+__all__ = (
+    "ActionRequestModel",
+    "ActionResponseModel",
+    "Source",
+    "TextSnippet",
+    "CodeSnippet",
+    "Section",
+    "OutlineItem",
+    "Outline",
+    "File",
+    "CodeFile",
+    "Documentation",
+    "Instruct",
+    "InstructResponse",
+    "Reason",
+)

lionagi/{libs/fields → fields}/action.py

@@ -16,9 +16,7 @@ from lionagi.utils import to_dict, to_json, to_list
 
 __all__ = (
     "ActionRequestModel",
-    "ACTION_REQUESTS_FIELD",
     "ActionResponseModel",
-    "ACTION_RESPONSES_FIELD",
 )
 
 

lionagi/fields/base.py

@@ -0,0 +1,151 @@
+from enum import Enum
+
+from pydantic import Field, HttpUrl
+
+from lionagi.models import HashableModel
+
+__all__ = (
+    "Source",
+    "TextSnippet",
+    "CodeSnippet",
+    "Section",
+    "OutlineItem",
+    "Outline",
+)
+
+
+class Source(HashableModel):
+    """
+    Represents a citation or external source, such as:
+     - a website,
+     - documentation link,
+     - research paper,
+     - or any external resource.
+    """
+
+    title: str = Field(
+        ...,
+        description="Short label or title for the reference (e.g. 'Pydantic Docs', 'RFC 3986').",
+    )
+
+    url: str | HttpUrl | None = Field(
+        None,
+        description="Full URL or local path pointing to the resource. Must conform to standard URL format.",
+    )
+
+    note: str | None = Field(
+        default=None,
+        description=(
+            "Optional additional note explaining why this reference is relevant or what it contains."
+        ),
+    )
+
+
+class SnippetType(str, Enum):
+    TEXT = "text"
+    CODE = "code"
+
+
+class TextSnippet(HashableModel):
+    """
+    Specialized snippet for textual/prose content.
+    """
+
+    type: SnippetType = Field(
+        SnippetType.TEXT,
+        description=(
+            "Must be 'text' for textual snippets. Ensures explicit type distinction."
+        ),
+    )
+    content: str = Field(
+        ...,
+        description=(
+            "The actual text. Can be a paragraph, bullet list, or any narrative content."
+        ),
+    )
+
+
+class CodeSnippet(HashableModel):
+    """
+    Specialized snippet for source code or command-line examples.
+    """
+
+    type: SnippetType = Field(
+        SnippetType.CODE,
+        description=(
+            "Must be 'code' for code snippets. Allows separate handling or formatting."
+        ),
+    )
+    content: str = Field(
+        ...,
+        description=(
+            "The actual code or command sequence. Should be well-formatted so it can be rendered properly."
+        ),
+    )
+
+
+class Section(HashableModel):
+    """
+    A single section of a document or article. Each section has:
+     - A title
+     - A sequential list of content snippets (text or code),
+       which appear in the intended reading order.
+     - Optional sources specifically cited in this section.
+    """
+
+    title: str = Field(
+        ...,
+        description=(
+            "The section heading or label, e.g., 'Introduction', 'Implementation Steps'."
+        ),
+    )
+    snippets: list[TextSnippet | CodeSnippet] = Field(
+        default_factory=list,
+        description=(
+            "Ordered list of content snippets. Could be multiple text blocks, code examples, etc."
+        ),
+    )
+
+    sources: list[Source] = Field(
+        default_factory=list,
+        description=(
+            "References specifically cited in this section. "
+            "If sources are stored at the doc-level, this can be omitted."
+        ),
+    )
+
+
+class OutlineItem(HashableModel):
+    """
+    Represents a single outline item, which could become a full section later.
+    """
+
+    heading: str = Field(
+        ...,
+        description="Short name or label for this item, e.g., 'Chapter 1: Basics'.",
+    )
+    summary: str | None = Field(
+        default=None,
+        description=(
+            "A brief description of what this section will cover, if known."
+        ),
+    )
+
+
+class Outline(HashableModel):
+    """
+    A top-level outline for a document or article.
+    Usually used in early planning stages.
+    """
+
+    topic: str = Field(
+        ..., description="Working title or overarching topic of the document."
+    )
+    items: list[OutlineItem] = Field(
+        default_factory=list,
+        description="List of major outline points or sections planned.",
+    )
+    notes: str | None = Field(
+        default=None,
+        description="Any additional remarks, questions, or brainstorming notes for the outline.",
+    )

lionagi/{libs/fields → fields}/file.py

@@ -1,26 +1,29 @@
 from pathlib import Path
 
-from pydantic import BaseModel, Field, field_validator
+from pydantic import Field, field_validator
 
-from lionagi.models import FieldModel
+from .base import HashableModel, Source
 
-
-class Source(BaseModel):
-    title: str | None = None
-    url: str | None = None
+__all__ = (
+    "File",
+    "CodeFile",
+    "Documentation",
+)
 
 
-class File(BaseModel):
+class File(HashableModel):
     """
-    Represents a generic file with an optional name, content, and brief description.
-    Useful for capturing and validating metadata about any kind of file within a project.
+    Represents a generic file with an optional name, content, and brief
+    description. Useful for capturing and validating metadata about any
+    kind of file within a project.
     """
 
     file_name: str | None = Field(
         default=None,
         description=(
-            "Provide the name of the file or its relative path in the project. "
-            "If an absolute path is given, it will be converted to a string. "
+            "Provide the name of the file or its relative path in the "
+            "project. If an absolute path is given, it will be converted"
+            " to a string. "
         ),
         examples=[
             "session.py",
@@ -32,8 +35,8 @@ class File(BaseModel):
         default=None,
         description=(
             "Paste or generate the full textual content of the file here. "
-            "For example, this might include plain text, Markdown, or any other text format.\n"
-            "Examples:\n"
+            "For example, this might include plain text, Markdown, or any "
+            "other text format.\nExamples:\n"
             "  - '# My Title\\nSome description...'\n"
             "  - 'function greet() { return \"Hello\"; }'"
         ),
@@ -41,8 +44,9 @@ class File(BaseModel):
     description: str | None = Field(
         default=None,
         description=(
-            "Briefly explain the file's purpose or function within the project. "
-            "This can be a short summary describing why this file exists or what it does.\n"
+            "Briefly explain the file's purpose or function within the "
+            "project. This can be a short summary describing why this "
+            "file is needed and/or what it does."
         ),
         examples=[
             "Manages user session logic for the LionAGI framework.",
@@ -56,6 +60,38 @@ class File(BaseModel):
             return str(value)
         return value
 
+    def render_content(
+        self,
+        header: str | None = None,
+        footer: str | None = None,
+    ) -> str:
+        text = f"\n{header}\n\n" if header else ""
+        text += self.content if self.content else ""
+        if not footer:
+            return text
+        return text + f"\n\n{footer}\n"
+
+    def persist(
+        self,
+        directory: Path | str,
+        overwrite: bool = True,
+        timestamp: bool = False,
+        random_hash_digits: int = None,
+        header: str | None = None,
+        footer: str | None = None,
+    ) -> Path:
+        from lionagi.utils import create_path
+
+        fp = create_path(
+            directory=directory,
+            filename=self.file_name,
+            file_exist_ok=overwrite,
+            timestamp=timestamp,
+            random_hash_digits=random_hash_digits,
+        )
+        fp.write_text(self.render_content(header=header, footer=footer))
+        return fp
+
 
 class CodeFile(File):
     """
@@ -83,7 +119,7 @@ class CodeFile(File):
         default=None,
         description=(
             "Provide or generate the **full source code**. This should be the primary text content "
-            "of the code file, including all function/class definitions.\n"
+            "of the code file, including all function/class definitions.\nNo md codeblock, only raw code"
         ),
         examples=[
             'def my_function():\\n    print("Hello, world!")',
@@ -112,10 +148,6 @@ class Documentation(File):
             "Provide the primary Markdown (or similar) content for the documentation. "
             "This can include headings, bullet points, tables, code snippets, etc.\n"
         ),
-        examples=[
-            "# Getting Started\\nThis guide walks you through ...",
-            "# API Reference\\n## Session Class\\n...",
-        ],
     )
     sources: list[Source] | None = Field(
         default=None,
@@ -125,23 +157,22 @@ class Documentation(File):
         ),
     )
 
-
-FILE_FIELD = FieldModel(
-    name="file",
-    annotation=File | None,
-    default=None,
-)
-
-CODE_FILE_FIELD = FieldModel(
-    name="code_file",
-    annotation=CodeFile | None,
-    default=None,
-)
-
-DOCUMENTATION_FIELD = FieldModel(
-    name="documentation",
-    annotation=Documentation | None,
-    default=None,
-)
-
-# File: lionagi/libs/fields/file.py
+    def render_content(
+        self,
+        header: str | None = None,
+        footer: str | None = None,
+        include_source: bool = False,
+    ) -> str:
+        """
+        Renders the documentation content, optionally including citations for sources.
+        """
+        footer = footer or ""
+        if include_source and self.sources:
+            footer = "\n\n## Sources\n"
+            for source in self.sources:
+                footer += f"- [{source.title}]({source.url})\n"
+                footer += f"  - {source.note}\n" if source.note else ""
+        return super().render_content(header=header, footer=footer)
+
+
+# File: lionagi/fields/file.py

lionagi/{libs/fields → fields}/instruct.py

@@ -16,8 +16,6 @@ from lionagi.utils import to_num
 __all__ = (
     "Instruct",
     "InstructResponse",
-    "INSTRUCT_FIELD",
-    "LIST_INSTRUCT_FIELD",
 )
 
 
@@ -150,4 +148,4 @@ LIST_INSTRUCT_FIELD_MODEL = FieldModel(
     default=None,
 )
 
-# File: lionagi/libs/fields/instruct.py
+# File: lionagi/fields/instruct.py

lionagi/{libs/fields → fields}/reason.py

@@ -7,12 +7,7 @@ from pydantic import BaseModel, Field, field_validator
 from lionagi.models import FieldModel
 from lionagi.utils import to_num
 
-__all__ = (
-    "Reason",
-    "REASON_FIELD",
-    "CONFIDENCE_SCORE_FIELD",
-    "validate_confidence_score",
-)
+__all__ = ("Reason",)
 
 
 class Reason(BaseModel):
@@ -27,10 +22,9 @@ class Reason(BaseModel):
             "how well you've met user expectations. Use this guide:\n"
             "  • 1.0: Highly confident\n"
             "  • 0.8-1.0: Reasonably sure\n"
-            "  • 0.5-0.8: Re-check or refine\n"
-            "  • 0.0-0.5: Off track"
+            "  • 0.5-0.8: Re-check, refine or backtrack\n"
+            "  • 0.0-0.5: Off track, stop"
         ),
-        examples=[0.821, 0.257, 0.923, 0.439],
     )
 
     @field_validator("confidence_score", mode="before")
@@ -51,15 +45,6 @@ def validate_confidence_score(cls, v):
         return -1
 
 
-CONFIDENCE_SCORE_FIELD = FieldModel(
-    name="confidence_score",
-    annotation=float | None,
-    default=None,
-    validator=validate_confidence_score,
-    validator_kwargs={"mode": "before"},
-)
-
-
 REASON_FIELD = FieldModel(
     name="reason",
     annotation=Reason | None,
@@ -67,4 +52,4 @@ REASON_FIELD = FieldModel(
     description="**Provide a concise reason for the decision made.**",
 )
 
-# File: lionagi/libs/fields/reason.py
+# File: lionagi/fields/reason.py

lionagi/libs/package/imports.py

@@ -2,165 +2,20 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-import importlib.metadata
-import importlib.util
-import logging
-import subprocess
-from typing import Any
-
-from lionagi.utils import run_package_manager_command
-
-
-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
-
-
-def is_import_installed(package_name: str) -> bool:
-    """
-    Check if a package is installed.
-
-    Args:
-        package_name: The name of the package to check.
-
-    Returns:
-        bool: True if the package is installed, False otherwise.
-    """
-    return importlib.util.find_spec(package_name) is not None
+from lionagi.utils import (
+    check_import,
+    import_module,
+    install_import,
+    is_import_installed,
+    run_package_manager_command,
+)
+
+# backward compatibility
+
+__all__ = (
+    "run_package_manager_command",
+    "check_import",
+    "import_module",
+    "install_import",
+    "is_import_installed",
+)

lionagi/libs/token_transform/synthlang_/base.py

@@ -31,7 +31,7 @@ class SynthlangFramework(Resource):
         import json
 
         fp = here / FRAMEWORK_PATH / "framework_options.json"
-        with open(fp, "r", encoding="utf-8") as f:
+        with open(fp, encoding="utf-8") as f:
             return json.load(f)
 
     @classmethod

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

@@ -49,4 +49,4 @@
             ]
         }
     }
-}
+}

lionagi/libs/token_transform/synthlang_/resources/mapping/lion_emoji_mapping.toml

@@ -58,4 +58,4 @@ False = "⊭"
 "⧦⧦⧦" = "⧦"
 "  " = "◻︎"
 "◻︎◻︎" = "◼︎"
-"###" = "#"
+"###" = "#"

lionagi/libs/token_transform/synthlang_/resources/mapping/python_math_mapping.toml

@@ -38,4 +38,4 @@ False = "⊭"
 "⧦⧦⧦" = "⧦"
 "  " = "◻︎"
 "◻︎◻︎" = "◼︎"
-"###" = "#"
+"###" = "#"

lionagi/libs/token_transform/synthlang_/resources/mapping/rust_chinese_mapping.toml

@@ -57,4 +57,4 @@ self = "自"
 Clone = "隆"
 clone = "隆"
 derive = "衍"
-"println!" = "印"
+"println!" = "印"

lionagi/operations/ReAct/ReAct.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING, Any, Literal
 
 from pydantic import BaseModel
 
-from lionagi.libs.fields.instruct import Instruct
+from lionagi.fields.instruct import Instruct
 from lionagi.libs.schema.as_readable import as_readable
 from lionagi.libs.validate.common_field_validators import (
     validate_model_to_type,