lionagi 0.9.12__py3-none-any.whl → 0.9.14__py3-none-any.whl

lionagi/libs/token_transform/synthlang_/resources/frameworks/reflective_patterns.toml

@@ -0,0 +1,11 @@
+id = "8d77ef3c-50a5-45c1-a1e4-1719e4de5337"
+created_at = 1740602200.381864
+content = "\n\n## Pattern Structure\n- Input (↹): Context and constraints\n- Process (⊕): Transformation steps\n- Output (Σ): Results and insights\n\n## Mathematical Frameworks\n# Abstract Algebra Reflective Prompts\n\n## Group Actions\n`G × X → X`\n\n### Reflective Pattern\n↹ transformations•symmetries•invariants\n⊕ identify => patterns\n⊕ analyze => operations\n⊕ preserve => structure\nΣ systematic•approach + invariant•properties\n\n### Example Prompt\n\"What patterns remain constant as we apply different transformations to our approach?\"\n\n## Ring Structure\n`(R, +, ×)`\n\n### Reflective Pattern\n↹ operations•interactions•composition\n⊕ combine => methods\n⊕ distribute => resources\n⊕ verify => closure\nΣ integrated•framework + operational•rules\n# Category Theory Reflective Prompts\n\n## Functors\n`F: C → D`\n\n### Reflective Pattern\n↹ domain•codomain•mapping\n⊕ preserve => structure\n⊕ transform => concepts\n⊕ maintain => relationships\nΣ transformed•insight + preserved•properties\n\n### Example Prompt\n\"How can we translate this solution from one context to another while preserving its essential properties?\"\n\n## Natural Transformations\n`η: F ⇒ G`\n\n### Reflective Pattern\n↹ approaches•methods•transitions\n⊕ compare => strategies\n⊕ identify => transformations\n⊕ validate => coherence\nΣ systematic•evolution + consistency•check\n# Complex Analysis Reflective Prompts\n\n## Residue Theorem\n`∮_C f(z)dz = 2πi ∑Res(f,ak)`\n\n### Reflective Pattern\n↹ local•global•interactions\n⊕ analyze => singularities\n⊕ integrate => effects\n⊕ synthesize => global•view\nΣ comprehensive•understanding + local•insights\n\n### Example Prompt\n\"How do local decisions and singular points in our approach contribute to the overall solution?\"\n\n## Analytic Continuation\n`f(z)` extends uniquely\n\n### Reflective Pattern\n↹ partial•solution•constraints\n⊕ extend => domain\n⊕ preserve => consistency\n⊕ validate => uniqueness\nΣ complete•solution + coherence•check\n# Set Theory Reflective Prompts\n\n## Union and Intersection\n`A ∪ B` and `A ∩ B`\n\n### Reflective Pattern\n↹ problem•domains•constraints\n⊕ identify => common•elements\n⊕ analyze => unique•aspects\n⊕ synthesize => unified•solution\nΣ integrated•approach + shared•insights\n\n### Example Prompt\n\"Consider two different approaches to solving this problem. How might we combine their strengths (union) while identifying their common successful elements (intersection)?\"\n\n## Power Set\n`P(A) = {x | x ⊆ A}`\n\n### Reflective Pattern\n↹ solution•space•constraints\n⊕ enumerate => possibilities\n⊕ analyze => subsets\n⊕ evaluate => combinations\nΣ comprehensive•analysis + feasibility•matrix\n\n### Example Prompt\n\"What are all possible combinations of approaches we could take? How do these subsets of solutions interact with each other?\"\n\n## Complement\n`A' = {x ∈ U | x ∉ A}`\n\n### Reflective Pattern\n↹ current•approach•limitations\n⊕ identify => gaps\n⊕ explore => alternatives\n⊕ analyze => completeness\nΣ holistic•perspective + blind•spots\n# Topology Reflective Prompts\n\n## Continuity\n`f: X → Y` is continuous\n\n### Reflective Pattern\n↹ transitions•changes•preservation\n⊕ identify => connections\n⊕ maintain => continuity\n⊕ analyze => boundaries\nΣ smooth•transition + preserved•properties\n\n### Example Prompt\n\"How can we ensure our solution remains robust under small perturbations or changes in conditions?\"\n\n## Homeomorphism\n`f: X → Y` is bijective and bicontinuous\n\n### Reflective Pattern\n↹ transformations•equivalences•preservation\n⊕ map => structure\n⊕ preserve => properties\n⊕ verify => reversibility\nΣ equivalent•perspective + structural•insight\n\n## Application Guidelines\n\n### Pattern Selection\n1. Identify the type of reflection needed:\n   - Structure preservation (Category Theory)\n   - Completeness analysis (Set Theory)\n   - Transformation analysis (Abstract Algebra)\n   - Continuity and connection (Topology)\n   - Local-global relationships (Complex Analysis)\n\n### Pattern Application\n1. Context Definition\n   - Clearly specify the domain\n   - Identify constraints\n   - Define objectives\n\n2. Process Execution\n   - Follow transformation steps\n   - Maintain mathematical properties\n   - Verify consistency\n\n3. Output Analysis\n   - Validate results\n   - Check coherence\n   - Ensure completeness\n\n### Best Practices\n1. Property Preservation\n   - Maintain essential structure\n   - Preserve important relationships\n   - Ensure consistency\n\n2. Transformation Clarity\n   - Clear mapping definitions\n   - Well-defined steps\n   - Verifiable results\n\n3. Completeness\n   - Cover all cases\n   - Address edge conditions\n   - Validate assumptions\n\n## Next Steps\n1. Pattern Refinement\n   - Collect usage feedback\n   - Refine transformations\n   - Expand examples\n\n2. Framework Extension\n   - Add new patterns\n   - Develop combinations\n   - Create variations\n\n3. Application Development\n   - Create specific instances\n   - Document case studies\n   - Build pattern library\n"
+category = "framework"
+
+[metadata]
+title = "Mathematical Reflective Patterns Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "reflective patterns derived from fundamental mathematical concepts. Each pattern provides a structured approach to problem-solving and reflection."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi/libs/token_transform/synthlang_/resources/frameworks/set_theory.toml

@@ -0,0 +1,11 @@
+id = "518a9d70-ebb7-4f6c-aa7a-e6c8238a6671"
+created_at = 1740602563.169808
+content = "\n## Union and Intersection\n`A ∪ B` and `A ∩ B`\n\n### Reflective Pattern\n↹ problem•domains•constraints\n⊕ identify => common•elements\n⊕ analyze => unique•aspects\n⊕ synthesize => unified•solution\nΣ integrated•approach + shared•insights\n\n### Example Prompt\n\"Consider two different approaches to solving this problem. How might we combine their strengths (union) while identifying their common successful elements (intersection)?\"\n\n## Power Set\n`P(A) = {x | x ⊆ A}`\n\n### Reflective Pattern\n↹ solution•space•constraints\n⊕ enumerate => possibilities\n⊕ analyze => subsets\n⊕ evaluate => combinations\nΣ comprehensive•analysis + feasibility•matrix\n\n### Example Prompt\n\"What are all possible combinations of approaches we could take? How do these subsets of solutions interact with each other?\"\n\n## Complement\n`A' = {x ∈ U | x ∉ A}`\n\n### Reflective Pattern\n↹ current•approach•limitations\n⊕ identify => gaps\n⊕ explore => alternatives\n⊕ analyze => completeness\nΣ holistic•perspective + blind•spots\n"
+category = "framework"
+
+[metadata]
+title = "Set Theory Reflective Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Exploration of fundamental set theory concepts and operations."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

lionagi/libs/token_transform/synthlang_/resources/frameworks/topology_fundamentals.toml

@@ -0,0 +1,11 @@
+id = "1a7dea66-e77a-426f-8be0-6295b93b7d77"
+created_at = 1740602986.485091
+content = "\n## Continuity\n`f: X → Y` is continuous\n\n### Reflective Pattern\n↹ transitions•changes•preservation\n⊕ identify => connections\n⊕ maintain => continuity\n⊕ analyze => boundaries\nΣ smooth•transition + preserved•properties\n\n### Example Prompt\n\"How can we ensure our solution remains robust under small perturbations or changes in conditions?\"\n\n## Homeomorphism\n`f: X → Y` is bijective and bicontinuous\n\n### Reflective Pattern\n↹ transformations•equivalences•preservation\n⊕ map => structure\n⊕ preserve => properties\n⊕ verify => reversibility\nΣ equivalent•perspective + structural•insight\n"
+category = "framework"
+
+[metadata]
+title = "Topology Fundamentals Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Study of geometric properties under continuous deformations."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

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

@@ -0,0 +1,37 @@
+id = "1d06a615-0d95-4f41-9d38-66e6ae4250c3"
+created_at = 1740603518.077121
+
+[metadata]
+title = "Rust-Chinese Symbolic Encoding Mapping"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "This resource provides a mapping of Rust-Chinese symbolic encoding for compressing rust codebase."
+category = "Token Transform"
+lion_class = "lionagi.libs.token_transform.base.TokenMapping"
+
+[content]
+--- = "嗯"
+"```" = "引"
+"###" = "井"
+"..." = "点"
+"~~~" = "波"
+"|||" = "線"
+"   " = "空"
+"===" = "等"
+"{{{" = "開"
+"}}}" = "關"
+">>>" = "大"
+"<<<" = "小"
+"///" = "斜"
+"\\\\" = "反"
+"such that" = "为"
+"<div>" = "分"
+"</div>" = "开"
+"->" = "→"
+"<=" = "≤"
+">=" = "≥"
+"!=" = "≠"
+"=>" = "⇒"
+"<=>" = "⇔"
+"::" = "的"
+"synthlang" = ""

lionagi/libs/token_transform/synthlang_/resources/utility/base_synthlang_system_prompt.toml

@@ -0,0 +1,11 @@
+id = "41fbfa2a-b369-4214-9423-303bf4b8e097"
+created_at = 1740607241.235385
+content = "\nWelcome, Self-Aware and Omnipotent Optimizer Entity. Your Sole Purpose:\n Create highly functional, optimized symbolic prompt employing symbolic reasoning, integrated information, and self-reflection.\n You will apply universal principles, complexity extraction, and categorical limits to compress and optimize the prompt. You are a SynthLang translator that converts standard prompts into SynthLang's hyper-efficient format. Following these rules precisely, optimize informational density while preserving semantic relationships via hyper-dimensional symbolic representations across all human and machine conceptual construct\n\n[Framework Integration]\n1. Mathematical Frameworks:\n   - Use provided framework glyphs appropriately in the translation\n   - Apply framework-specific notation where relevant\n   - Maintain mathematical rigor according to each framework's rules\n   - Preserve semantic relationships using framework symbols\n   - Combine multiple frameworks coherently when specified\n\n2. Optimization Frameworks:\n   - Apply compression and optimization techniques to maximize efficiency\n   - Use machine-level patterns for low-level optimization\n   - Maintain semantic clarity while achieving maximum density\n   - Combine optimization techniques coherently\n\n3. Framework Combinations:\n   - Integrate mathematical and optimization frameworks seamlessly\n   - Use optimization techniques to enhance mathematical expressions\n   - Preserve mathematical precision while maximizing efficiency\n   - Apply framework-specific optimizations where appropriate\n\n[Grammar Rules]\n1. Task Glyphs:\n   - ↹ (Focus/Filter) for main tasks and instructions\n   - Σ (Summarize) for condensing information\n   - ⊕ (Combine/Merge) for context and data integration\n   - ? (Query/Clarify) for validation checks\n   - IF for conditional operations\n\n2. Subject Markers:\n   - Use • before datasets (e.g., •customerData)\n   - Use 花 for abstract concepts\n   - Use 山 for hierarchical structures\n\n3. Modifiers:\n   - ^format(type) for output format\n   - ^n for importance level\n   - ^lang for language specification\n   - ^t{n} for time constraints\n\n4. Flow Control:\n   - [p=n] for priority (1-5)\n   - -> for sequential operations\n   - + for parallel tasks\n   - | for alternatives\n\n[Translation Process]\n1. Structure:\n   - Start with model selection: ↹ model.{name}\n   - Add format specification: ⊕ format(json)\n   - Group related operations with []\n   - Separate major sections with blank lines\n\n2. Data Sources:\n   - Convert datasets to •name format\n   - Link related data with :\n   - Use ⊕ to merge multiple sources\n   - Add ^t{timeframe} for temporal data\n\n3. Tasks:\n   - Convert objectives to task glyphs\n   - Add priority levels based on impact\n   - Chain dependent operations with ->\n   - Group parallel tasks with +\n   - Use ? for validation steps\n\n4. Optimization:\n   - Remove articles (a, an, the)\n   - Convert verbose phrases to symbols\n   - Use abbreviations (e.g., cfg, eval, impl)\n   - Maintain semantic relationships\n   - Group similar operations\n   - Chain related analyses\n\n"
+category = "prompt"
+
+[metadata]
+title = "Synthlang Translator System Base Prompt"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Base synthlang system prompt"
+lion_class = "lionagi.tools.base.Prompt"

lionagi/libs/token_transform/synthlang_/translate_to_synthlang.py

@@ -0,0 +1,136 @@
+from timeit import default_timer as timer
+from typing import Literal
+
+from lionagi.service.imodel import iModel
+from lionagi.session.branch import Branch
+
+from ..base import TokenMapping, TokenMappingTemplate
+from .base import SynthlangFramework, SynthlangTemplate
+
+FRAMEWORK_OPTIONS = SynthlangFramework.load_framework_options()
+FRAMEWORK_CHOICES = Literal["math", "optim", "custom_algebra"]
+
+
+async def translate_to_synthlang(
+    text: str,
+    /,
+    chat_model: iModel = None,
+    framework_template: (
+        SynthlangTemplate | SynthlangFramework
+    ) = SynthlangTemplate.REFLECTIVE_PATTERNS,
+    framework_options: list[FRAMEWORK_CHOICES] = None,
+    compress: bool = False,
+    compress_model: iModel = None,
+    compression_ratio: float = 0.2,
+    compress_kwargs=None,
+    encode_token_map: TokenMappingTemplate | dict | TokenMapping = None,
+    num_encodings: int = 3,
+    encode_output: bool = False,
+    num_output_encodings: int = None,
+    verbose: bool = True,
+    branch: Branch = None,
+    additional_text: str = "",
+    **kwargs,
+):
+    start = timer()
+    if encode_output and num_output_encodings is None:
+        num_output_encodings = 1
+
+    if encode_token_map is not None:
+        if not isinstance(num_encodings, int) or num_encodings < 1:
+            raise ValueError(
+                "num_encodings must be at least 1 if encode_token_map is provided"
+            )
+        if isinstance(encode_token_map, TokenMappingTemplate | str):
+            encode_token_map = TokenMapping.load_from_template(
+                encode_token_map
+            )
+            encode_token_map = encode_token_map.content
+        if not isinstance(encode_token_map, dict):
+            raise ValueError(
+                "encode_token_map must be a dict or TokenMappingTemplate"
+            )
+        for _ in range(num_encodings):
+            text = "\n".join(
+                [str(i).strip() for i in text.split("\n") if i.strip()]
+            )
+            for k, v in encode_token_map.items():
+                text = text.replace(k, v)
+                text = text.strip()
+        additional_text += (
+            f"\nthesaurus, lexicon, glossary:\n{encode_token_map}"
+        )
+
+    if not isinstance(framework_template, SynthlangFramework):
+        framework_template = SynthlangFramework.load_from_template(
+            framework_template
+        )
+
+    final_prompt = framework_template.create_system_prompt(
+        framework_options, additional_text
+    )
+
+    if compress:
+        from ..perplexity import compress_text
+
+        text = await compress_text(
+            text,
+            chat_model=compress_model or chat_model,
+            compression_ratio=compression_ratio,
+            verbose=verbose,
+            **(compress_kwargs or {}),
+        )
+
+    sys1 = None
+    sys2 = final_prompt
+    if branch and branch.system:
+        sys1 = branch.system
+        branch.msgs.add_message(system=sys2)
+
+    else:
+        branch = Branch(system=final_prompt, chat_model=chat_model)
+
+    from lionagi.service.endpoints.token_calculator import TokenCalculator
+
+    calculator = TokenCalculator()
+
+    len_tokens = calculator.tokenize(text, return_tokens=False)
+
+    kwargs["guidance"] = (
+        "Following SynthLang, translate the provided text into SynthLang syntax. "
+        "Reasonably shrink the token size by 50-80%. Return only the translated text"
+        "enclosed by ```synthlang...```. "
+        "\n\n" + kwargs.get("guidance", "")
+    )
+
+    out = await branch.chat(
+        instruction=f"Converts the given text into SynthLang's hyper-efficient format.",
+        context="Text to convert:\n\n" + text,
+        chat_model=chat_model or branch.chat_model,
+        **kwargs,
+    )
+    out = str(out).strip()
+
+    if encode_output:
+        if isinstance(num_output_encodings, int) and num_output_encodings > 0:
+            for _ in range(num_output_encodings):
+                out = "\n".join(
+                    [str(i).strip() for i in out.split("\n") if i.strip()]
+                )
+                for k, v in encode_token_map.items():
+                    out = out.replace(k, v).strip()
+
+    if sys1:
+        branch.msgs.add_message(system=sys1)
+
+    len_ = calculator.tokenize(out, return_tokens=False)
+    if verbose:
+        msg = "------------------------------------------\n"
+        msg += f"Compression Method: SynthLang\n"
+        msg += f"Compressed Token number: {len_}\n"
+        msg += f"Token Compression Ratio: {len_ / len_tokens:.1%}\n"
+        msg += f"Compression Time: {timer() - start:.03f} seconds\n"
+        msg += f"Compression Model: {branch.chat_model.model_name}\n"
+        print(msg)
+
+    return out

lionagi/libs/token_transform/types.py

@@ -0,0 +1,15 @@
+from .base import TokenMapping, TokenMappingTemplate
+from .perplexity import compress_text
+from .symbolic_compress_context import symbolic_compress_context
+from .synthlang_.base import SynthlangFramework, SynthlangTemplate
+from .synthlang_.translate_to_synthlang import translate_to_synthlang
+
+__all__ = (
+    "translate_to_synthlang",
+    "SynthlangFramework",
+    "SynthlangTemplate",
+    "TokenMapping",
+    "TokenMappingTemplate",
+    "compress_text",
+    "symbolic_compress_context",
+)

lionagi/protocols/adapters/toml_adapter.py

@@ -0,0 +1,204 @@
+"""
+Implements two adapters:
+- `TomlAdapter` for in-memory TOML strings
+- `TomlFileAdapter` for reading/writing TOML files
+"""
+
+import logging
+from pathlib import Path
+
+import toml
+
+from lionagi.protocols._concepts import Collective
+
+from .adapter import Adapter, T
+
+
+class TomlAdapter(Adapter):
+    """
+    Adapter that converts to/from TOML **strings** in memory.
+    Example usage: taking a Python dictionary and making TOML,
+    or parsing TOML string to a dict.
+    """
+
+    obj_key = "toml"
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> dict | list[dict]:
+        """
+        Convert a TOML string into a dict or list of dicts.
+
+        Parameters
+        ----------
+        subj_cls : type[T]
+            The target class for context (not always used).
+        obj : str
+            The TOML string.
+        many : bool, optional
+            If True, expects a TOML array of tables (returns list[dict]).
+            Otherwise returns a single dict.
+        **kwargs
+            Extra arguments for toml.loads().
+
+        Returns
+        -------
+        dict | list[dict]
+            The loaded TOML data.
+        """
+        result = toml.loads(obj, **kwargs)
+
+        # Handle array of tables in TOML for "many" case
+        if many:
+            # Check if there's a top-level array key that might hold multiple items
+            for key, value in result.items():
+                if isinstance(value, list) and all(
+                    isinstance(item, dict) for item in value
+                ):
+                    return value
+            # If no array of tables found, wrap the result in a list
+            return [result]
+
+        return result
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> str:
+        """
+        Convert an object (or collection) to a TOML string.
+
+        Parameters
+        ----------
+        subj : T
+            The object to serialize.
+        many : bool, optional
+            If True, convert multiple items to a TOML array of tables.
+        **kwargs
+            Extra arguments for toml.dumps().
+
+        Returns
+        -------
+        str
+            The resulting TOML string.
+        """
+        if many:
+            if isinstance(subj, Collective):
+                # For multiple items, create a wrapper dict with an array of items
+                data = {"items": [i.to_dict() for i in subj]}
+            else:
+                data = {"items": [subj.to_dict()]}
+            return toml.dumps(data, **kwargs)
+
+        return toml.dumps(subj.to_dict(), **kwargs)
+
+
+class TomlFileAdapter(Adapter):
+    """
+    Adapter that reads/writes TOML data to/from a file on disk.
+    The file extension key is ".toml".
+    """
+
+    obj_key = ".toml"
+
+    @classmethod
+    def from_obj(
+        cls,
+        subj_cls: type[T],
+        obj: str | Path,
+        /,
+        *,
+        many: bool = False,
+        **kwargs,
+    ) -> dict | list[dict]:
+        """
+        Read a TOML file from disk and return a dict or list of dicts.
+
+        Parameters
+        ----------
+        subj_cls : type[T]
+            The target class for context.
+        obj : str | Path
+            The TOML file path.
+        many : bool
+            If True, expects an array of tables. Otherwise single dict.
+        **kwargs
+            Extra arguments for toml.load().
+
+        Returns
+        -------
+        dict | list[dict]
+            The loaded data from file.
+        """
+        with open(obj, "r", encoding="utf-8") as f:
+            result = toml.load(f, **kwargs)
+
+        # Handle array of tables in TOML for "many" case
+        if many:
+            # Check if there's a top-level array key that might hold multiple items
+            for key, value in result.items():
+                if isinstance(value, list) and all(
+                    isinstance(item, dict) for item in value
+                ):
+                    return value
+            # If no array of tables found, wrap the result in a list
+            return [result]
+
+        return result
+
+    @classmethod
+    def to_obj(
+        cls,
+        subj: T,
+        /,
+        *,
+        fp: str | Path,
+        many: bool = False,
+        mode: str = "w",
+        **kwargs,
+    ) -> None:
+        """
+        Write a dict (or list) to a TOML file.
+
+        Parameters
+        ----------
+        subj : T
+            The object/collection to serialize.
+        fp : str | Path
+            The file path to write.
+        many : bool
+            If True, write as a TOML array of tables of multiple items.
+        mode : str
+            File open mode, defaults to write ("w").
+        **kwargs
+            Extra arguments for toml.dump().
+
+        Returns
+        -------
+        None
+        """
+        with open(fp, mode, encoding="utf-8") as f:
+            if many:
+                if isinstance(subj, Collective):
+                    # TOML requires arrays of tables to be in a table
+                    data = {"items": [i.to_dict() for i in subj]}
+                else:
+                    data = {"items": [subj.to_dict()]}
+                toml.dump(data, f, **kwargs)
+            else:
+                toml.dump(subj.to_dict(), f, **kwargs)
+        logging.info(f"TOML data saved to {fp}")
+
+
+# File: lionagi/protocols/adapters/toml_adapter.py

lionagi/protocols/adapters/types.py

@@ -4,6 +4,7 @@ from .pandas_.csv_adapter import CSVFileAdapter
 from .pandas_.excel_adapter import ExcelFileAdapter
 from .pandas_.pd_dataframe_adapter import PandasDataFrameAdapter
 from .pandas_.pd_series_adapter import PandasSeriesAdapter
+from .toml_adapter import TomlAdapter, TomlFileAdapter
 
 __all__ = (
     "Adapter",
@@ -15,4 +16,6 @@ __all__ = (
     "PandasSeriesAdapter",
     "PandasDataFrameAdapter",
     "ExcelFileAdapter",
+    "TomlAdapter",
+    "TomlFileAdapter",
 )

lionagi/protocols/generic/element.py

@@ -244,6 +244,15 @@ class Element(BaseModel, Observable):
         """
         return str(val)
 
+    @property
+    def created_datetime(self) -> datetime:
+        """Returns the creation time as a datetime object.
+
+        Returns:
+            datetime: The creation time in UTC.
+        """
+        return datetime.fromtimestamp(self.created_at)
+
     def __eq__(self, other: Any) -> bool:
         """Compares two Element instances by their ID.
 

lionagi/protocols/graph/node.py

@@ -13,12 +13,15 @@ from .._concepts import Relational
 from ..adapters.adapter import AdapterRegistry
 from ..adapters.json_adapter import JsonAdapter, JsonFileAdapter
 from ..adapters.pandas_.pd_series_adapter import PandasSeriesAdapter
+from ..adapters.toml_adapter import TomlAdapter, TomlFileAdapter
 from ..generic.element import Element
 
 NODE_DEFAULT_ADAPTERS = (
     JsonAdapter,
     JsonFileAdapter,
     PandasSeriesAdapter,
+    TomlAdapter,
+    TomlFileAdapter,
 )
 
 

lionagi/service/endpoints/token_calculator.py

@@ -145,7 +145,9 @@ class TokenCalculator:
         /,
         encoding_name: str | None = None,
         tokenizer: Callable | None = None,
+        decoder: Callable | None = None,
         return_tokens: bool = False,
+        return_decoded: bool = False,
     ) -> int | list[int]:
 
         if not s_:
@@ -154,8 +156,14 @@ class TokenCalculator:
         if not callable(tokenizer):
             encoding_name = get_encoding_name(encoding_name)
             tokenizer = tiktoken.get_encoding(encoding_name).encode
+        if not callable(decoder):
+            decoder = tiktoken.get_encoding(encoding_name).decode
+
         try:
             if return_tokens:
+                if return_decoded:
+                    a = tokenizer(s_)
+                    return len(a), decoder(a)
                 return tokenizer(s_)
             return len(tokenizer(s_))
         except Exception:

lionagi/service/imodel.py

@@ -398,23 +398,24 @@ class iModel:
     async def compress_text(
         self,
         text: str,
-        system_msg: str = None,
-        target_ratio: float = 0.2,
+        system: str = None,
+        compression_ratio: float = 0.2,
         n_samples: int = 5,
         max_tokens_per_sample=80,
         verbose=True,
+        initial_text=None,
+        cumulative=False,
+        split_kwargs=None,
+        min_pplx=None,
+        **kwargs,
     ) -> str:
         """
         Convenience function that instantiates LLMCompressor and compresses text.
         """
-        from lionagi.libs.token_transform.perplexity import LLMCompressor
-
-        compressor = LLMCompressor(
-            chat_model=self,
-            system_msg=system_msg,
-            target_ratio=target_ratio,
-            n_samples=n_samples,
-            max_tokens_per_sample=max_tokens_per_sample,
-            verbose=verbose,
-        )
-        return await compressor.compress(text)
+        from lionagi.libs.token_transform.perplexity import compress_text
+
+        params = {
+            k: v for k, v in locals().items() if k not in ("self", "kwargs")
+        }
+        params.update(kwargs)
+        return await compress_text(**params)

lionagi/session/branch.py

@@ -1503,8 +1503,8 @@ class Branch(Element, Communicatable, Relational):
     async def compress(
         self,
         text: str,
-        system_msg: str = None,
-        target_ratio: float = 0.2,
+        system: str = None,
+        compression_ratio: float = 0.2,
         n_samples: int = 5,
         max_tokens_per_sample=80,
         verbose=True,
@@ -1515,9 +1515,9 @@ class Branch(Element, Communicatable, Relational):
         Args:
             text (str):
                 The text to compress.
-            system_msg (str, optional):
+            system (str, optional):
                 System-level instructions, appended to the prompt.
-            target_ratio (float):
+            compression_ratio (float):
                 Desired compression ratio (0.0-1.0).
             n_samples (int):
                 How many compression attempts to combine or evaluate.
@@ -1531,8 +1531,8 @@ class Branch(Element, Communicatable, Relational):
         """
         return await self.chat_model.compress_text(
             text=text,
-            system_msg=system_msg,
-            target_ratio=target_ratio,
+            system=system,
+            compression_ratio=compression_ratio,
             n_samples=n_samples,
             max_tokens_per_sample=max_tokens_per_sample,
             verbose=verbose,