lionagi 0.9.13__py3-none-any.whl → 0.9.15__py3-none-any.whl

lionagi/libs/token_transform/synthlang.py

@@ -1,415 +1,9 @@
-# synthlang.py
-"""
-SynthLang translator and system prompt generator.
-We incorporate the simpler framework approach (a list of frameworks to enable),
-and rely on a chosen template from the included FRAMEWORK_TEMPLATES.
-We also integrate optional perplexity compression from `compress_perplexity.py`.
-"""
-# For the optional compression step:
-from timeit import default_timer as timer
-from typing import Literal
-
-from lionagi.session.branch import Branch
-from lionagi.settings import Settings
-
-from .perplexity import compress_text, iModel
-
-########################################################################
-# 1) Template Data
-#    Each item is a dictionary capturing your multi-line text blocks.
-########################################################################
-
-group_theory = {
-    "title": "Group Theory Analysis",
-    "domain": "mathematics",
-    "category": "Abstract Algebra",
-    "overview": "Investigation of algebraic structures using group theory and ring theory.",
-    "content": """# Structures
-Let G be a group with operation •
-Let H be a subgroup of G
-Let N be a normal subgroup of G
-
-# Properties
-P(x): "x is a homomorphism"
-Q(x): "x preserves group structure"
-R(x): "x maps to kernel"
-
-# Objectives
-1. Prove fundamental homomorphism theorem
-2. Show group action properties
-3. Analyze quotient groups
-""",
-}
-
-category_theory = {
-    "title": "Category Theory Concepts",
-    "domain": "mathematics",
-    "category": "Category Theory",
-    "overview": "Abstract mathematical framework dealing with relationships between structures.",
-    "content": """# Basic Definitions
-C = (Ob(C), hom(C), ∘)
-F: C → D (Functor)
-...
-""",
-}
-
-complex_analysis = {
-    "title": "Complex Analysis Foundations",
-    "domain": "mathematics",
-    "category": "Complex Analysis",
-    "overview": "Advanced study of complex functions, including integration and residue theory.",
-    "content": """# Complex Integration
-∮ f(z)dz = 2πi∑Res(f,ak)
-...
-""",
-}
-
-math_logic = {
-    "title": "Mathematical Logic Foundations",
-    "domain": "mathematics",
-    "category": "Mathematical Logic",
-    "overview": "Exploration of fundamental mathematical logic concepts.",
-    "content": """# Sets and Axioms
-Let A be the set of all propositions.
-...
-""",
-}
-
-number_theory = {
-    "title": "Number Theory Principles",
-    "domain": "mathematics",
-    "category": "Number Theory",
-    "overview": "Study of integers, prime numbers, and arithmetic functions.",
-    "content": """# Congruence Relations
-a ≡ b (mod n)
-...
-""",
-}
-
-set_theory = {
-    "title": "Set Theory Foundations",
-    "domain": "mathematics",
-    "category": "Set Theory",
-    "overview": "Exploration of fundamental set theory concepts and operations.",
-    "content": """# Basic Definitions
-Let U be the universal set
-...
-""",
-}
-
-symbolic_systems = {
-    "title": "Symbolic Systems Analysis",
-    "domain": "computer-science",
-    "category": "Symbolic Systems",
-    "overview": "Analysis of symbolic computation in AI and formal languages.",
-    "content": """# Core Concepts
-Let Σ be a finite alphabet
-...
-""",
-}
-
-symbolic_exploration_system_supression = {
-    "title": "Systematic Suppression Exploration",
-    "domain": "societal",
-    "category": "Real-World Simulations",
-    "overview": "Analysis of suppression mechanisms using symbolic logic.",
-    "content": """# Sets and Categories
-Let U be the set of actions representing policies ...
-""",
-}
-
-topology_fundamentals = {
-    "title": "Topology Fundamentals",
-    "domain": "mathematics",
-    "category": "Topology",
-    "overview": "Study of geometric properties under continuous deformations.",
-    "content": """# Open Sets
-(X,τ) topological space
-...
-""",
-}
-
-FRAMEWORK_TEMPLATES = {
-    "group_theory": group_theory,
-    "category_theory": category_theory,
-    "complex_analysis": complex_analysis,
-    "math_logic": math_logic,
-    "number_theory": number_theory,
-    "set_theory": set_theory,
-    "symbolic_systems": symbolic_systems,
-    "symbolic_exploration_system_supression": symbolic_exploration_system_supression,
-    "topology_fundamentals": topology_fundamentals,
-}
-
-
-########################################################################
-# 2) Framework Definitions (Simplified)
-########################################################################
-
-# Instead of a complex dict with "selectedGlyphs", let's do a simpler approach:
-# We define each "framework" by name, description, and glyphs. The user can pick them by name.
-FRAMEWORK_OPTIONS = {
-    "math": {
-        "name": "Mathematical Framework",
-        "description": "Offers a suite of math glyphs and notation rules.",
-        "glyphs": [
-            {
-                "symbol": "↹",
-                "name": "Focus/Filter",
-                "description": "Used for focusing instructions",
-            },
-            {
-                "symbol": "Σ",
-                "name": "Summarize",
-                "description": "Condense large sets of data",
-            },
-            {
-                "symbol": "⊕",
-                "name": "Combine/Merge",
-                "description": "Merge multiple data sources",
-            },
-            {
-                "symbol": "•",
-                "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": "∞",
-                "name": "Infinite Operator",
-                "description": "Represents unbounded algebraic ops",
-            }
-        ],
-    },
-}
-
-########################################################################
-# 3) SynthLang Base Prompt
-########################################################################
-
-BASE_PROMPT = """You are a SynthLang translator. You convert standard text into SynthLang format with these rules:
-
-[Framework Integration]
-- Use relevant framework glyphs wherever possible.
-- Combine multiple frameworks if requested.
-
-[Grammar Rules]
-1) Task Glyphs:
-   - ↹ (Focus/Filter) for main tasks
-   - Σ (Summarize) for condensing info
-   - ⊕ (Combine) for merging data
-   - ? (Query) for clarifications
-   - IF for conditionals
-
-2) Subject Markers:
-   - Use • before datasets (e.g., •myData)
-   - Use 花 for abstract concepts
-   - Use 山 for hierarchical structures
-
-3) Modifiers:
-   - ^format(type) for output format
-   - ^n for importance level
-   - ^lang for language
-   - ^t{n} for time constraints
-
-4) Flow Control:
-   - [p=n] for priority
-   - -> for sequential
-   - + for parallel
-   - | for alternatives
-
-[Output Style]
-- Maximize compression by removing articles & filler
-- Use glyphs for repeated phrases
-- Preserve semantic meaning
-"""
-
-
-########################################################################
-# 4) Utility to build the "Active Frameworks" block
-########################################################################
-
-
-def build_frameworks_text(frameworks: list[str]) -> str:
-    """
-    Takes a list of framework keys (e.g. ["math", "optim"]) and returns
-    a textual block describing them.
-    """
-    lines = []
-    if not frameworks:
-        frameworks = FRAMEWORK_OPTIONS.keys()
-
-    for fw_key in frameworks:
-        fw = FRAMEWORK_OPTIONS.get(fw_key, None)
-        if fw:
-            lines.append(f"{fw['name']}: {fw['description']}")
-            lines.append("Glyphs:")
-            for g in fw["glyphs"]:
-                lines.append(
-                    f"  {g['symbol']} -> {g['name']} ({g['description']})"
-                )
-            lines.append("")
-    return "\n".join(lines).strip()
-
-
-########################################################################
-# 5) Main: create the SynthLang prompt
-########################################################################
-
-
-def create_synthlang_system_prompt(
-    template_name: Literal[
-        "group_theory",
-        "category_theory",
-        "complex_analysis",
-        "math_logic",
-        "number_theory",
-        "set_theory",
-        "symbolic_systems",
-        "symbolic_exploration_system_supression",
-        "topology_fundamentals",
-    ],
-    frameworks: list[str],
-    additional_text: str = "",
-) -> str:
-    """
-    Merges:
-    - BASE_PROMPT
-    - "Active Frameworks" block (from frameworks list)
-    - The chosen template (from FRAMEWORK_TEMPLATES)
-    - plus additional text if desired
-    """
-    template_block = FRAMEWORK_TEMPLATES[template_name]
-    frameworks_text = build_frameworks_text(frameworks)
-
-    # We show the user the "domain", "category", etc. from the template
-    template_details = (
-        f"Title: {template_block['title']}\n"
-        f"Domain: {template_block['domain']}\n"
-        f"Category: {template_block['category']}\n"
-        f"Overview: {template_block['overview']}\n"
-        "Excerpt:\n"
-        f"{template_block['content']}\n"
-    )
-
-    prompt = (
-        f"{BASE_PROMPT}\n\n"
-        "[Active Frameworks]\n"
-        f"{frameworks_text}\n\n"
-        "[Template]\n"
-        f"{template_details}\n"
-    )
-
-    if additional_text.strip():
-        prompt += f"\n[Additional]\n{additional_text.strip()}\n"
-
-    # Usually you might want the entire final text to be the system instruction:
-    return prompt
-
-
-########################################################################
-# 6) Translate text into SynthLang format
-########################################################################
-
-
-# TODO: refactor using SynthLang package
-async def translate_to_synthlang(
-    text: str,
-    template_name: str = "symbolic_systems",
-    frameworks: list[str] = None,
-    compress: bool = False,
-    chat_model: iModel = None,
-    compress_model: iModel = None,
-    compression_ratio: float = 0.2,
-    compress_kwargs=None,
-    verbose: bool = True,
-    branch: Branch = None,
-    **kwargs,
-) -> str:
-    """
-    Optionally compress the input text using perplexity, then build a final
-    "SynthLang" style system prompt that includes frameworks, templates, etc.
-
-    :param text: The original text to be translated/compressed
-    :param template_name: Key in FRAMEWORK_TEMPLATES
-    :param frameworks: e.g. ["math", "optim"] to enable these frameworks
-    :param compress: If True, uses perplexity-based compression
-    :param chat_model: The model for perplexity compression
-    :param compression_ratio: float ratio of final token usage
-    :param compress_kwargs: Additional arguments to pass to compression
-    :return: A string in SynthLang style
-    """
-    from .synthlang import create_synthlang_system_prompt
-
-    start = timer()
-    chat_model = chat_model or iModel(**Settings.iModel.CHAT)
-    if compress:
-        text = await compress_text(
-            text,
-            chat_model=compress_model or chat_model,
-            target_ratio=compression_ratio,
-            **(compress_kwargs or {}),
-        )
-
-    # Build final system prompt
-    final_prompt = create_synthlang_system_prompt(
-        template_name=template_name,
-        frameworks=frameworks,
-    )
-
-    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. "
-        "Shrink the token size by 60-85%. Return only the translated text.\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,
-        **kwargs,
-    )
-    if sys1:
-        branch.msgs.add_message(system=sys1)
-
-    len_ = calculator.tokenize(out, return_tokens=False)
-    if verbose:
-        msg = ""
-        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
+from .synthlang_.base import SynthlangFramework, SynthlangTemplate
+from .synthlang_.translate_to_synthlang import translate_to_synthlang
+
+# backwards compatibility
+__all__ = (
+    "translate_to_synthlang",
+    "SynthlangFramework",
+    "SynthlangTemplate",
+)

lionagi/libs/token_transform/synthlang_/base.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+from enum import Enum
+from pathlib import Path
+from typing import Literal
+
+from pydantic import Field
+
+from lionagi.tools.base import Prompt, Resource, ResourceCategory
+
+here = Path(__file__).parent.resolve()
+
+FRAMEWORK_PATH = "resources/frameworks"
+FRAMEWORK_CHOICES = Literal["math", "optim", "custom_algebra"]
+
+
+__all__ = (
+    "SynthlangFramework",
+    "SynthlangTemplate",
+)
+
+
+class SynthlangFramework(Resource):
+
+    category: ResourceCategory = Field(
+        default=ResourceCategory.FRAMEWORK, frozen=True
+    )
+
+    @classmethod
+    def load_framework_options(cls) -> dict:
+        import json
+
+        fp = here / FRAMEWORK_PATH / "framework_options.json"
+        with open(fp, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    @classmethod
+    def load_from_template(
+        cls, template: SynthlangTemplate | str
+    ) -> SynthlangFramework:
+        return SynthlangTemplate.load(template)
+
+    @classmethod
+    def load_base_system_prompt(cls) -> Prompt:
+        fp = here / "resources/utility" / "base_synthlang_system_prompt.toml"
+        return SynthlangFramework.adapt_from(fp, ".toml", many=False)
+
+    @classmethod
+    def build_framework_text(
+        cls, framework_options: list[FRAMEWORK_CHOICES] = None
+    ) -> str:
+        FRAMEWORK_OPTIONS = cls.load_framework_options()
+        lines = []
+        if not framework_options:
+            framework_options = FRAMEWORK_OPTIONS["options"].keys()
+
+        for fw_key in framework_options:
+            fw = FRAMEWORK_OPTIONS.get(fw_key, None)
+            if fw:
+                print(fw)
+                lines.append(f"{fw['name']}: {fw['description']}")
+                lines.append("Glyphs:")
+                for g in fw["glyphs"]:
+                    lines.append(
+                        f"  {g['symbol']} -> {g['name']} ({g['description']})"
+                    )
+                lines.append("")
+        return "\n".join(lines).strip()
+
+    def create_system_prompt(
+        self,
+        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 = (
+            f"Title: {self.meta_obj.title}\n"
+            f"Domain: {str(self.meta_obj.domain)}\n"
+            f"Category: {str(self.category)}\n"
+            f"Overview: {self.meta_obj.overview}\n"
+            "Excerpt:\n"
+            f"{self.content}\n"
+        )
+        prompt = (
+            f"{base_prompt.content}\n\n"
+            "[Active Frameworks]\n"
+            f"{framework_options_text}\n\n"
+            "[Template]\n"
+            f"{template_details}\n"
+        )
+        if additional_text.strip():
+            prompt += f"\n[Additional]\n{additional_text.strip()}\n"
+
+        return prompt.strip()
+
+
+class SynthlangTemplate(str, Enum):
+    ABSTRACT_ALGEBRA = "abstract_algebra"
+    CATEGORY_THEORY = "category_theory"
+    COMPLEX_ANALYSIS = "complex_analysis"
+    GROUP_THEORY = "group_theory"
+    MATH_LOGIC = "math_logic"
+    REFLECTIVE_PATTERNS = "reflective_patterns"
+    SET_THEORY = "set_theory"
+    TOPOLOGY_FUNDAMENTALS = "topology_fundamentals"
+
+    @property
+    def fp(self) -> Path:
+        return here / FRAMEWORK_PATH / f"{self.value}.toml"
+
+    @classmethod
+    def list_templates(cls) -> list[str]:
+        return [template.value for template in cls]
+
+    @classmethod
+    def load(cls, framework: str) -> SynthlangFramework:
+        framework = str(framework).strip().lower()
+        framework = framework.replace(" ", "_").replace("-", "_")
+        if ".toml" in framework:
+            framework = framework.replace(".toml", "").strip()
+        if "synthlangtemplate." in framework:
+            framework = framework.replace("synthlangtemplate.", "").strip()
+        try:
+            framework = cls(framework)
+        except ValueError:
+            raise ValueError(f"Invalid synthlang framework name: {framework}")
+
+        return SynthlangFramework.adapt_from(framework.fp, ".toml", many=False)

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

@@ -0,0 +1,11 @@
+id = "11968433-1402-4783-b167-25afbe0a6c4f"
+created_at = 1740606622.114634
+content = "\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 = "framework"
+
+[metadata]
+title = "Abstract Algebra Reflective Symbolic Compression"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "A resource for learning and exploring abstract algebra concepts."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

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

@@ -0,0 +1,11 @@
+id = "b8588217-3da0-4809-8a8e-1bc9489a718a"
+created_at = 1740606718.863813
+content = "\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"
+category = "framework"
+
+[metadata]
+title = "Category Theory Concepts Symbolic Compression"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Abstract mathematical framework dealing with mathematical structures and relationships between them."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

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

@@ -0,0 +1,11 @@
+id = "f7ea039c-829b-453c-a562-85e8e66df2b0"
+created_at = 1740602435.49488
+content = "\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"
+category = "framework"
+
+[metadata]
+title = "Complex Analysis Foundations"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Advanced study of complex functions, including integration and residue theory."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

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

@@ -0,0 +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"
+                },
+                {
+                    "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"
+                }
+            ]
+        },
+        "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"
+                }
+            ]
+        }
+    }
+}

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

@@ -0,0 +1,11 @@
+id = "c077186b-30cd-42d9-88ae-563859a00db3"
+created_at = 1740602288.669331
+content = "# Structures\nLet G be a group with operation •\nLet H be a subgroup of G\nLet N be a normal subgroup of G\n\n# Properties\nP(x): \"x is a homomorphism\"\nQ(x): \"x preserves group structure\"\nR(x): \"x maps to kernel\"\n\n# Objectives\n1. Prove fundamental homomorphism theorem\n2. Show group action properties\n3. Analyze quotient groups\n"
+category = "framework"
+
+[metadata]
+title = "Group Theory Analysis"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Investigation of algebraic structures using group theory and ring theory."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"

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

@@ -0,0 +1,11 @@
+id = "bc244d9c-3fcc-4e7c-9a13-d0e208904c22"
+created_at = 1740602490.430191
+content = "\n# Sets and Axioms\nLet A be the set of all logical propositions.\nLet T be the subset of A that are tautologies.\nLet C be the subset of A that are contradictions.\n\n# Predicates\nP(x): \"x is a well-formed formula\"\nQ(x): \"x is satisfiable\"\nR(x): \"x is valid\"\n\n# Objectives\n1. Prove completeness theorem using predicate calculus\n2. Demonstrate soundness of the system\n3. Show relationship between syntax and semantics\n\n# Complex Integration\n∮ f(z)dz = 2πi∑Res(f,ak)\nLet f(z) = ∑(n=0 to ∞) an(z-z₀)ⁿ\nRes(f,a) = 1/(2πi)∮ f(z)dz\nw = f(z) preserves angles\n∂u/∂x = ∂v/∂y\n∂u/∂y = -∂v/∂x\n"
+category = "framework"
+
+[metadata]
+title = "Mathematical Logic Foundations"
+domain = "Symbolic Compression"
+version = "1.0"
+overview = "Exploration of fundamental mathematical logic concepts using set theory and predicate calculus."
+lion_class = "lionagi.libs.token_transform.synthlang_.base.SynthlangFramework"