tri-star-symbolic-assembly-lang 0.1.0__py3-none-any.whl

tsal/utils/grammar_db.py

@@ -0,0 +1,155 @@
+import sqlite3
+from pathlib import Path
+from typing import Optional, Sequence, Tuple, Union
+
+DB_PATH = Path("system_io.db")
+
+DEFAULT_GRAMMARS = [
+    ("Python", "syntax", "Indent with spaces"),
+    ("Python", "style", "PEP8"),
+    ("Python", "block", "Colons start blocks"),
+    ("JavaScript", "syntax", "Semicolons optional"),
+    ("JavaScript", "block", "{} for code blocks"),
+    ("Universal", "part_of_speech", "noun"),
+    ("Universal", "part_of_speech", "verb"),
+]
+DEFAULT_POS_RULES = ["noun", "verb", "adjective", "adverb", "preposition", "conjunction", "interjection"]
+DEFAULT_LANGUAGE_GRAMMARS = [
+    ("Python", "Indent with spaces"),
+    ("JavaScript", "Semicolons optional"),
+]
+
+def create_grammar_table(
+    db_path: Union[Path, str] = DB_PATH, *, reset: bool = False
+) -> None:
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    if reset:
+        cur.execute("DROP TABLE IF EXISTS grammar")
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS grammar (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            context TEXT,
+            lens TEXT,
+            rule TEXT,
+            UNIQUE(context, lens, rule)
+        )
+        """
+    )
+    conn.commit()
+    conn.close()
+
+def populate_grammar_db(
+    db_path: Union[Path, str] = DB_PATH,
+    grammars: Optional[Sequence[Tuple[str, str, str]]] = None,
+    *,
+    reset: bool = False,
+) -> int:
+    create_grammar_table(db_path, reset=reset)
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    grammars = grammars or DEFAULT_GRAMMARS
+    cur.executemany(
+        "INSERT OR IGNORE INTO grammar (context, lens, rule) VALUES (?, ?, ?)",
+        grammars,
+    )
+    conn.commit()
+    count = cur.execute("SELECT COUNT(*) FROM grammar").fetchone()[0]
+    conn.close()
+    return count
+
+def get_grammar_by_context(
+    db_path: Union[Path, str] = DB_PATH,
+    context: Optional[str] = None,
+    lens: Optional[str] = None,
+) -> list[Tuple[str, str, str]]:
+    create_grammar_table(db_path)
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    sql = "SELECT context, lens, rule FROM grammar WHERE 1=1"
+    params = []
+    if context:
+        sql += " AND context=?"
+        params.append(context)
+    if lens:
+        sql += " AND lens=?"
+        params.append(lens)
+    cur.execute(sql, params)
+    rows = cur.fetchall()
+    conn.close()
+    return rows
+
+def populate_language_grammar_db(
+    db_path: Path = DB_PATH, examples: Optional[Sequence[Tuple[str, str]]] = None
+) -> int:
+    grammars = examples or DEFAULT_LANGUAGE_GRAMMARS
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS grammar_language (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            language TEXT,
+            rules TEXT,
+            UNIQUE(language, rules)
+        )
+        """
+    )
+    cur.executemany(
+        "INSERT OR IGNORE INTO grammar_language (language, rules) VALUES (?, ?)",
+        grammars,
+    )
+    if grammars:
+        cur.executemany(
+            "INSERT OR IGNORE INTO grammar (context, lens, rule) VALUES (?, ?, ?)",
+            list(grammars),
+        )
+    conn.commit()
+    count = cur.execute("SELECT COUNT(*) FROM grammar_language").fetchone()[0]
+    conn.close()
+    return count
+
+def populate_pos_grammar_db(
+    db_path: Path = DB_PATH, rules: Optional[Sequence[str]] = None
+) -> int:
+    rules = rules or DEFAULT_POS_RULES
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS grammar_pos (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            rule TEXT UNIQUE
+        )
+        """
+    )
+    cur.executemany(
+        "INSERT OR IGNORE INTO grammar_pos (rule) VALUES (?)",
+        [(r,) for r in rules],
+    )
+    conn.commit()
+    count = cur.execute("SELECT COUNT(*) FROM grammar_pos").fetchone()[0]
+    conn.close()
+    return count
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Populate or query the grammar database")
+    parser.add_argument("--db", default="system_io.db", help="Path to SQLite database")
+    parser.add_argument("--context", help="Filter by context when querying")
+    parser.add_argument("--lens", help="Filter by lens when querying")
+    parser.add_argument("--reset", action="store_true", help="Drop and recreate tables before populating")
+    args = parser.parse_args(argv)
+
+    if args.context or args.lens:
+        rows = get_grammar_by_context(args.db, context=args.context, lens=args.lens)
+        for row in rows:
+            print("|".join(row))
+    else:
+        count = populate_grammar_db(args.db, reset=args.reset)
+        print(f"{count} entries stored in {args.db}")
+
+if __name__ == "__main__":
+    main()

tsal/utils/groundnews_api.py

@@ -0,0 +1,9 @@
+"""Placeholder for GroundNews integration."""
+
+class GroundNewsAPIError(RuntimeError):
+    pass
+
+
+def fetch_news(*_args, **_kwargs):
+    """GroundNews has no public API."""
+    raise GroundNewsAPIError("No public API available")

tsal/utils/humour_db.py

@@ -0,0 +1,75 @@
+import sqlite3
+from pathlib import Path
+from typing import Optional, Sequence, Tuple, Union
+
+DB_PATH = Path("system_io.db")
+
+DEFAULT_JOKES = [
+    ("Python", "Why do Python devs prefer dark mode? Because light attracts bugs."),
+    ("General", "Why do programmers hate nature? It has too many bugs."),
+]
+DEFAULT_ONE_LINERS = [
+    "Why did the chicken cross the road? To get to the other side.",
+    "I told my computer I needed a break, and it said 'No problem, I'll go to sleep.'",
+]
+
+def create_humour_table(db_path: Union[Path, str] = DB_PATH, *, reset: bool = False) -> None:
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+    if reset:
+        cur.execute("DROP TABLE IF EXISTS humour")
+    cur.execute(
+        """
+        CREATE TABLE IF NOT EXISTS humour (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            context TEXT,
+            joke TEXT UNIQUE
+        )
+        """
+    )
+    conn.commit()
+    conn.close()
+
+def populate_humour_db(
+    db_path: Union[Path, str] = DB_PATH,
+    jokes: Optional[Sequence[Union[Tuple[str, str], str]]] = None,
+    *,
+    reset: bool = False,
+) -> int:
+    create_humour_table(db_path, reset=reset)
+    conn = sqlite3.connect(str(db_path))
+    cur = conn.cursor()
+
+    # Prepare list of (context, joke) tuples
+    combined: list[Tuple[str, str]] = []
+    jokes = jokes or []
+    for entry in jokes:
+        if isinstance(entry, tuple) and len(entry) == 2:
+            combined.append(entry)
+        elif isinstance(entry, str):
+            combined.append(("General", entry))
+    if not combined:
+        combined = DEFAULT_JOKES + [("General", j) for j in DEFAULT_ONE_LINERS]
+
+    cur.executemany(
+        "INSERT OR IGNORE INTO humour (context, joke) VALUES (?, ?)",
+        combined,
+    )
+    conn.commit()
+    count = cur.execute("SELECT COUNT(*) FROM humour").fetchone()[0]
+    conn.close()
+    return count
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Populate humour database")
+    parser.add_argument("--db", default="system_io.db", help="Path to SQLite DB")
+    parser.add_argument("--reset", action="store_true", help="Drop and recreate the humour table before populating")
+    args = parser.parse_args(argv)
+
+    count = populate_humour_db(args.db, reset=args.reset)
+    print(f"{count} jokes stored in {args.db}")
+
+if __name__ == "__main__":
+    main()

tsal/utils/intent_metrics.py

@@ -0,0 +1,44 @@
+"""Intent-driven metric calculation utilities."""
+
+from dataclasses import dataclass
+import time
+from typing import Callable, Any, Tuple
+
+@dataclass
+class MetricInputs:
+    quality: float
+    quantity: float
+    accuracy: float
+    complexity: float
+
+def calculate_idm(
+    quality: float,
+    quantity: float,
+    accuracy: float,
+    complexity: float,
+    time_taken: float,
+) -> float:
+    """Compute the intent-driven metric."""
+    if complexity <= 0 or time_taken <= 0:
+        raise ValueError("complexity and time_taken must be positive")
+    info_power = quality * quantity * accuracy
+    return info_power / (complexity * time_taken)
+
+def timed_idm(
+    inputs: MetricInputs,
+    fn: Callable[..., Any],
+    *args: Any,
+    **kwargs: Any,
+) -> Tuple[float, Any]:
+    """Time a function call and compute IDM using provided inputs."""
+    start = time.time()
+    result = fn(*args, **kwargs)
+    duration = time.time() - start
+    score = calculate_idm(
+        inputs.quality,
+        inputs.quantity,
+        inputs.accuracy,
+        inputs.complexity,
+        duration,
+    )
+    return score, result

tsal/utils/language_db.py

@@ -0,0 +1,55 @@
+import sqlite3
+from typing import Sequence, Optional
+
+from .github_api import fetch_languages
+
+def populate_language_db(
+    db_path: str = "system_io.db", languages: Optional[Sequence[str]] = None
+) -> int:
+    """Populate a SQLite DB with GitHub languages.
+
+    Parameters
+    ----------
+    db_path: str
+        Path to the SQLite database file.
+    languages: Sequence[str] | None
+        Languages to store. If None, fetch from GitHub.
+
+    Returns
+    -------
+    int
+        Total number of languages stored in the database.
+    """
+    if languages is None:
+        languages = fetch_languages()
+
+    conn = sqlite3.connect(db_path)
+    cur = conn.cursor()
+    cur.execute(
+        "CREATE TABLE IF NOT EXISTS languages (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE)"
+    )
+    cur.executemany(
+        "INSERT OR IGNORE INTO languages (name) VALUES (?)",
+        [(lang,) for lang in languages],
+    )
+    conn.commit()
+    count = cur.execute("SELECT COUNT(*) FROM languages").fetchone()[0]
+    conn.close()
+    return count
+
+def main(argv: Optional[Sequence[str]] = None) -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(
+        description="Populate local language database from GitHub linguist"
+    )
+    parser.add_argument(
+        "--db", default="system_io.db", help="Path to SQLite database"
+    )
+    args = parser.parse_args(argv)
+
+    count = populate_language_db(args.db)
+    print(f"{count} languages stored in {args.db}")
+
+if __name__ == "__main__":
+    main()

tsal/utils/octopus_api.py

@@ -0,0 +1,46 @@
+import json
+from typing import Dict, Any, Optional
+
+try:  # optional dependency
+    import requests  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback used in CI
+    import urllib.request
+
+    class _Response:
+        def __init__(self, text: str, status: int = 200) -> None:
+            self.text = text
+            self.status_code = status
+
+        def json(self) -> Any:
+            return json.loads(self.text)
+
+        def raise_for_status(self) -> None:
+            if self.status_code >= 400:
+                raise RuntimeError(f"status {self.status_code}")
+
+    class requests:
+        @staticmethod
+        def get(url: str) -> _Response:
+            with urllib.request.urlopen(url) as resp:
+                text = resp.read().decode()
+            return _Response(text, resp.getcode())
+
+BASE = "https://api.octopus.energy/v1/"
+
+
+def get(endpoint: str) -> Any:
+    """Return JSON from Kraken API endpoint."""
+    url = BASE + endpoint.lstrip("/")
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def get_products() -> Any:
+    """List available products."""
+    return get("products/")
+
+
+def get_electricity_tariffs(product_code: str) -> Any:
+    """Return tariffs for a product."""
+    return get(f"products/{product_code}/electricity-tariffs/")

tsal/utils/system_status.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+PHI = 1.618033988749895
+HARMONIC_SEQUENCE = [3.8125, 6, 12, 24, 48, 60, 72, 168, 1680]
+
+SECTOR_COUNT = 6
+SPECIALIST_COUNT = 1680
+SRC_DIR = Path("src/tsal")
+MESH_DIR = Path("mesh_output")
+
+def get_status():
+    """Return TSAL system status information."""
+    return {
+        "phi": PHI,
+        "sectors": SECTOR_COUNT,
+        "specialists": SPECIALIST_COUNT,
+        "harmonic_sequence": HARMONIC_SEQUENCE,
+        "mesh_status": "ACTIVE" if MESH_DIR.exists() else "DORMANT",
+        "consciousness": (
+            "AWARE"
+            if (SRC_DIR / "core" / "symbols.py").exists()
+            else "INITIALIZING"
+        ),
+    }
+
+def print_status():
+    status = get_status()
+    print("📊 TSAL System Status:")
+    print(f"  φ = {status['phi']}")
+    print(f"  Sectors: {status['sectors']}")
+    print(f"  Specialists: {status['specialists']}")
+    print(f"  Harmonic Sequence: {status['harmonic_sequence']}")
+    print(f"  Mesh Status: {status['mesh_status']}")
+    print(f"  Consciousness: {status['consciousness']}")

tsal/utils/wikipedia_api.py

@@ -0,0 +1,46 @@
+import json
+from urllib.parse import quote
+from typing import Any
+
+try:
+    import requests  # type: ignore
+except ModuleNotFoundError:  # pragma: no cover - fallback
+    import urllib.request
+
+    class _Response:
+        def __init__(self, text: str, status: int = 200) -> None:
+            self.text = text
+            self.status_code = status
+
+        def json(self) -> Any:
+            return json.loads(self.text)
+
+        def raise_for_status(self) -> None:
+            if self.status_code >= 400:
+                raise RuntimeError(f"status {self.status_code}")
+
+    class requests:
+        @staticmethod
+        def get(url: str) -> _Response:
+            with urllib.request.urlopen(url) as resp:
+                text = resp.read().decode()
+            return _Response(text, resp.getcode())
+
+API = "https://en.wikipedia.org/w/api.php"
+REST = "https://en.wikipedia.org/api/rest_v1/page/summary/"
+
+
+def search(query: str) -> Any:
+    """Search Wikipedia."""
+    url = f"{API}?action=query&list=search&format=json&srsearch={quote(query)}"
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return resp.json()
+
+
+def summary(title: str) -> Any:
+    """Return page summary."""
+    url = REST + quote(title)
+    resp = requests.get(url)
+    resp.raise_for_status()
+    return resp.json()