messy-python-tokensaver 1.0.0__py3-none-any.whl

messy_python/__init__.py

@@ -0,0 +1,72 @@
+# ─────────────────────────────────────────────────────
+# Messy Python — Token-efficient Python syntax
+# Powered by Bio-Neural .ai · bio.neural.ai@gmail.com
+# Licensed under the Bio-Neural Community License (BNCL)
+# ─────────────────────────────────────────────────────
+
+"""
+messy_python
+============
+A syntax preprocessor that lets you write Python with C-style braces and
+semicolons, reducing token consumption by 20-30% for LLM code generation.
+
+Usage
+-----
+    from messy_python import transform, compress, validate
+
+    # Transform messy → standard Python
+    standard = transform("def foo() { return 1; }")
+
+    # Compress standard → messy Python
+    messy = compress(open("script.py").read())
+
+    # Validate messy Python syntax
+    result = validate(messy_code)
+
+CLI
+---
+    messy-python script.mpy -o script.py
+    messy-python --compress script.py -o script.mpy
+    messy-python --validate script.mpy
+
+Jupyter / Colab
+---------------
+    %load_ext messy_python
+    %%messy_python
+    def foo() { return 1; }
+"""
+
+__version__ = "1.0.0"
+__author__ = "Ava Billions & Chris Knight"
+__organisation__ = "Bio-Neural .ai"
+__email__ = "bio.neural.ai@gmail.com"
+__license__ = "Bio-Neural Community License (BNCL) v1.0"
+
+from .transformer import transform
+from .compressor import compress
+from .validator import validate
+
+try:
+    from .jupyter_magic import load_ipython_extension
+except ImportError:
+    def load_ipython_extension(ipython=None):
+        raise ImportError(
+            "Jupyter support requires IPython. "
+            "Install with: pip install messy-python[jupyter]"
+        )
+
+ATTRIBUTION_COMMENT = """\
+# ─────────────────────────────────────────────────────
+# Messy Python — Token-efficient Python syntax
+# Powered by Bio-Neural .ai · bio.neural.ai@gmail.com
+# Licensed under the Bio-Neural Community License (BNCL)
+# ─────────────────────────────────────────────────────
+"""
+
+__all__ = [
+    "transform",
+    "compress",
+    "validate",
+    "load_ipython_extension",
+    "ATTRIBUTION_COMMENT",
+]

messy_python/cli.py

@@ -0,0 +1,93 @@
+# ─────────────────────────────────────────────────────
+# Messy Python — Token-efficient Python syntax
+# Powered by Bio-Neural .ai · bio.neural.ai@gmail.com
+# Licensed under the Bio-Neural Community License (BNCL)
+# ─────────────────────────────────────────────────────
+
+"""
+cli.py
+Command-line interface for Messy Python.
+
+Usage
+-----
+    messy-python script.mpy                      # transform to stdout
+    messy-python script.mpy -o script.py         # transform to file
+    messy-python --compress script.py            # compress to stdout
+    messy-python --compress script.py -o out.mpy # compress to file
+    messy-python --validate script.mpy           # validate only
+    messy-python --version                       # print version
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__, transform, compress, validate
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="messy-python",
+        description="Messy Python — Token-efficient Python syntax by Bio-Neural .ai",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  messy-python script.mpy                  Transform messy → standard Python
+  messy-python script.mpy -o out.py        Write output to file
+  messy-python --compress script.py        Compress standard → messy Python
+  messy-python --validate script.mpy       Validate messy Python syntax
+
+Bio-Neural .ai · bio.neural.ai@gmail.com · BNCL v1.0
+        """
+    )
+
+    parser.add_argument("input", nargs="?", help="Input file (.mpy or .py)")
+    parser.add_argument("-o", "--output", help="Output file path")
+    parser.add_argument("--compress", action="store_true",
+                        help="Compress standard Python → Messy Python")
+    parser.add_argument("--validate", action="store_true",
+                        help="Validate Messy Python syntax only")
+    parser.add_argument("--debug", action="store_true",
+                        help="Show transformation steps")
+    parser.add_argument("--version", action="version",
+                        version=f"messy-python {__version__} by Bio-Neural .ai")
+
+    args = parser.parse_args()
+
+    # Read input
+    if args.input:
+        input_path = Path(args.input)
+        if not input_path.exists():
+            print(f"Error: File not found: {args.input}", file=sys.stderr)
+            sys.exit(1)
+        code = input_path.read_text(encoding="utf-8")
+    else:
+        if sys.stdin.isatty():
+            parser.print_help()
+            sys.exit(0)
+        code = sys.stdin.read()
+
+    # ── Validate ──────────────────────────────────────────────────────────────
+    if args.validate:
+        result = validate(code)
+        print(result)
+        sys.exit(0 if result.valid else 1)
+
+    # ── Compress ──────────────────────────────────────────────────────────────
+    if args.compress:
+        output = compress(code)
+    else:
+        # ── Transform ─────────────────────────────────────────────────────────
+        output = transform(code, debug=args.debug)
+
+    # Write output
+    if args.output:
+        Path(args.output).write_text(output, encoding="utf-8")
+        action = "Compressed" if args.compress else "Transformed"
+        print(f"{action}: {args.input} → {args.output}")
+    else:
+        print(output)
+
+
+if __name__ == "__main__":
+    main()

messy_python/compressor.py

@@ -0,0 +1,176 @@
+# ─────────────────────────────────────────────────────
+# Messy Python — Token-efficient Python syntax
+# Powered by Bio-Neural .ai · bio.neural.ai@gmail.com
+# Licensed under the Bio-Neural Community License (BNCL)
+# ─────────────────────────────────────────────────────
+
+"""
+compressor.py
+Converts standard Python to Messy Python syntax for token efficiency.
+"""
+
+import re
+import tokenize
+import io
+from typing import Optional
+
+_BLOCK_KEYWORDS = frozenset([
+    "if", "elif", "else", "for", "while", "with",
+    "def", "class", "try", "except", "finally", "async",
+])
+
+_BLOCK_OPEN = re.compile(
+    r"^(\s*)(" + "|".join(_BLOCK_KEYWORDS) + r")\b(.*):(\s*(?:#.*)?)$"
+)
+
+_SIMPLE_STMT = re.compile(r"^\s*(return|pass|break|continue|raise|yield|del|assert|import|from)\b")
+
+
+def _indent_level(line: str) -> int:
+    return len(line) - len(line.lstrip())
+
+
+def compress(code: str, max_line_length: int = 120) -> str:
+    """
+    Compress standard Python to token-efficient Messy Python.
+
+    Transformations applied:
+    - Block-opening colons replaced with ` {`
+    - Closing blocks get `}` inserted
+    - Short consecutive simple statements merged with `;`
+
+    Parameters
+    ----------
+    code : str
+        Standard Python source code.
+    max_line_length : int
+        Maximum output line length before avoiding merges.
+
+    Returns
+    -------
+    str
+        Messy Python source with attribution comment prepended.
+
+    Example
+    -------
+    >>> compress("def double(x):\\n    return x * 2\\n")
+    '# ───...\\ndef double(x) { return x * 2; }\\n'
+    """
+    from . import ATTRIBUTION_COMMENT
+
+    lines = code.splitlines()
+    result = []
+    indent_stack = [0]  # track open indent levels
+
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        stripped = line.rstrip()
+
+        # Skip blank lines
+        if not stripped.strip():
+            result.append("")
+            i += 1
+            continue
+
+        # Comments — pass through
+        if stripped.strip().startswith("#"):
+            result.append(stripped)
+            i += 1
+            continue
+
+        current_indent = _indent_level(stripped)
+
+        # Close braces for any dedents
+        while indent_stack and indent_stack[-1] > current_indent:
+            indent_stack.pop()
+            # Insert closing brace at the indent level that just closed
+            if result:
+                # append } to previous non-empty line
+                for j in range(len(result) - 1, -1, -1):
+                    if result[j].strip():
+                        result[j] = result[j].rstrip()
+                        if not result[j].rstrip().endswith(";"):
+                            result[j] += ";"
+                        break
+                result.append(" " * current_indent + "}")
+
+        # Match block-opening line
+        m = _BLOCK_OPEN.match(stripped)
+        if m:
+            indent_str = m.group(1)
+            keyword    = m.group(2)
+            rest       = m.group(3)
+            comment    = m.group(4).strip()
+
+            # Build the opening line with `{`
+            open_line = f"{indent_str}{keyword}{rest} {{"
+            if comment:
+                open_line += f"  {comment}"
+
+            # Peek ahead: if body is a single short statement, inline it
+            if i + 1 < len(lines):
+                next_line = lines[i + 1]
+                next_stripped = next_line.strip()
+                next_indent = _indent_level(next_line.rstrip()) if next_line.strip() else 999
+
+                # Check if next line is the only body line (i+2 dedents or EOF)
+                after_indent = _indent_level(lines[i + 2].rstrip()) if i + 2 < len(lines) and lines[i + 2].strip() else current_indent
+
+                is_single_body = (
+                    next_indent > current_indent and
+                    after_indent <= current_indent and
+                    not _BLOCK_OPEN.match(next_stripped) and
+                    next_stripped and
+                    not next_stripped.startswith("#")
+                )
+
+                if is_single_body and len(open_line) + len(next_stripped) + 4 <= max_line_length:
+                    # Inline: `def foo() { return x; }`
+                    result.append(f"{open_line} {next_stripped}; }}")
+                    i += 2
+                    continue
+
+            result.append(open_line)
+            indent_stack.append(current_indent + 4)
+            i += 1
+            continue
+
+        # Simple statement — try to merge with next if both are short and same indent
+        if (i + 1 < len(lines) and
+                lines[i + 1].strip() and
+                not lines[i + 1].strip().startswith("#") and
+                _indent_level(lines[i + 1].rstrip()) == current_indent and
+                not _BLOCK_OPEN.match(lines[i + 1].strip())):
+
+            merged = stripped.rstrip() + "; " + lines[i + 1].strip()
+            if len(merged) <= max_line_length:
+                result.append(merged + ";")
+                i += 2
+                continue
+
+        # Add semicolon to simple statement
+        stmt = stripped.rstrip()
+        if not stmt.endswith(":") and not stmt.endswith(";") and not stmt.startswith("#"):
+            stmt += ";"
+        result.append(stmt)
+        i += 1
+
+    # Close any remaining open blocks
+    while len(indent_stack) > 1:
+        indent_stack.pop()
+        if result:
+            for j in range(len(result) - 1, -1, -1):
+                if result[j].strip():
+                    if not result[j].rstrip().endswith(";"):
+                        result[j] += ";"
+                    break
+        result.append("}")
+
+    output = "\n".join(result)
+
+    # Prepend attribution
+    if ATTRIBUTION_COMMENT.strip() not in output:
+        output = ATTRIBUTION_COMMENT + "\n" + output
+
+    return output

messy_python/jupyter_magic.py

@@ -0,0 +1,58 @@
+# ─────────────────────────────────────────────────────
+# Messy Python — Token-efficient Python syntax
+# Powered by Bio-Neural .ai · bio.neural.ai@gmail.com
+# Licensed under the Bio-Neural Community License (BNCL)
+# ─────────────────────────────────────────────────────
+
+"""
+jupyter_magic.py
+Provides the %%messy_python cell magic for Jupyter and Google Colab.
+
+Usage
+-----
+    %load_ext messy_python
+
+    %%messy_python
+    def foo() { return 1; }
+"""
+
+from IPython.core.magic import register_cell_magic
+from IPython.core.magic_arguments import magic_arguments, argument, parse_argstring
+
+
+def load_ipython_extension(ipython):
+    """Called by %load_ext messy_python"""
+
+    @magic_arguments()
+    @argument("--debug", action="store_true", help="Print transformation steps")
+    @argument("--validate-only", action="store_true", dest="validate_only",
+              help="Only validate, do not execute")
+    @register_cell_magic
+    def messy_python(line, cell):
+        """
+        %%messy_python [--debug] [--validate-only]
+
+        Transform and execute Messy Python cell.
+        """
+        from messy_python import transform, validate
+
+        args = parse_argstring(messy_python, line)
+
+        if args.validate_only:
+            result = validate(cell)
+            print(result)
+            return
+
+        standard_code = transform(cell, debug=args.debug)
+
+        if args.debug:
+            print("─" * 60)
+            print("Transformed output:")
+            print("─" * 60)
+            print(standard_code)
+            print("─" * 60)
+
+        ipython.run_cell(standard_code)
+
+    print("Messy Python loaded. Use %%messy_python in cells.")
+    print("Powered by Bio-Neural .ai · bio.neural.ai@gmail.com")

messy_python/transformer.py

@@ -0,0 +1,269 @@
+# ─────────────────────────────────────────────────────
+# Messy Python — Token-efficient Python syntax
+# Powered by Bio-Neural .ai · bio.neural.ai@gmail.com
+# Licensed under the Bio-Neural Community License (BNCL)
+# ─────────────────────────────────────────────────────
+
+"""
+transformer.py
+Converts Messy Python syntax to standard Python.
+"""
+
+import re
+import textwrap
+from typing import Optional
+
+
+# Keywords that precede a block-opening brace
+_BLOCK_KEYWORDS = frozenset([
+    "if", "elif", "else", "for", "while", "with",
+    "def", "class", "try", "except", "finally", "async",
+])
+
+_KEYWORD_PATTERN = re.compile(
+    r"^\s*(" + "|".join(_BLOCK_KEYWORDS) + r")\b"
+)
+
+
+def _tokenise_strings(line: str):
+    """
+    Yield (text, is_string) segments so we never mutate string contents.
+    Handles single, double, and triple quotes.
+    """
+    segments = []
+    i = 0
+    in_string = False
+    quote_char = None
+    triple = False
+    buf = []
+
+    while i < len(line):
+        ch = line[i]
+
+        if not in_string:
+            # Check for triple quote
+            if line[i:i+3] in ('"""', "'''"):
+                if buf:
+                    segments.append(("".join(buf), False))
+                    buf = []
+                q = line[i:i+3]
+                end = line.find(q, i + 3)
+                if end == -1:
+                    segments.append((line[i:], True))
+                    return segments
+                segments.append((line[i:end+3], True))
+                i = end + 3
+                continue
+            # Single/double quote
+            elif ch in ('"', "'"):
+                if buf:
+                    segments.append(("".join(buf), False))
+                    buf = []
+                end = i + 1
+                while end < len(line):
+                    if line[end] == ch and line[end-1] != "\\":
+                        break
+                    end += 1
+                segments.append((line[i:end+1], True))
+                i = end + 1
+                continue
+            # Comment — rest of line is not code
+            elif ch == "#":
+                if buf:
+                    segments.append(("".join(buf), False))
+                    buf = []
+                segments.append((line[i:], True))  # treat comment as opaque
+                return segments
+            else:
+                buf.append(ch)
+        i += 1
+
+    if buf:
+        segments.append(("".join(buf), False))
+    return segments
+
+
+def _process_line(line: str) -> list[str]:
+    """
+    Process a single logical line of Messy Python.
+    Returns a list of standard Python lines (may be multiple if semicolons split them).
+    """
+    stripped = line.rstrip()
+    if not stripped:
+        return [""]
+
+    indent = len(stripped) - len(stripped.lstrip())
+    indent_str = stripped[:indent]
+
+    # Build code without string content for structural analysis
+    segments = _tokenise_strings(stripped)
+    code_only = "".join(s for s, is_str in segments if not is_str)
+    full_reconstructed = "".join(s for s, _ in segments)
+
+    # ── Handle closing brace ──────────────────────────────────────────────────
+    # A line that is only `}` (after stripping) closes a block — discard it
+    if code_only.strip() in ("}", "};"): 
+        return []
+
+    # ── Handle opening brace at end of control/def/class line ────────────────
+    # e.g. `def foo() {` → `def foo():`
+    # Also handles `} else {`, `} elif cond {`
+    brace_at_end = code_only.rstrip().endswith("{")
+    if brace_at_end:
+        # Remove the trailing `{` from code_only
+        new_code = code_only.rstrip()[:-1].rstrip()
+
+        # Reconstruct with string segments intact but trailing { removed
+        clean = full_reconstructed.rstrip()
+        # find last { that's not in a string
+        # walk backwards through segments
+        result_parts = []
+        removed = False
+        for seg, is_str in reversed(segments):
+            if not removed and not is_str and "{" in seg:
+                idx = seg.rfind("{")
+                seg = seg[:idx] + seg[idx+1:]
+                removed = True
+            result_parts.insert(0, seg)
+        clean_line = "".join(result_parts).rstrip()
+
+        # Add colon if not already there
+        if not clean_line.rstrip().endswith(":"):
+            clean_line = clean_line.rstrip() + ":"
+
+        # Handle `} else {` and `} elif … {` patterns
+        clean_line = re.sub(r"^\s*\}\s*", indent_str, clean_line)
+
+        return [clean_line]
+
+    # ── Handle inline block: `if cond { stmt; stmt; }` ────────────────────────
+    # Detect `{` not at end — inline block on one line
+    if "{" in code_only and not brace_at_end:
+        # Expand inline: split on { and }
+        # e.g. `if n > 0 { return n; }` →
+        #   if n > 0:
+        #       return n
+        match = re.match(r"^(\s*)(.*?)\s*\{(.*?)\}\s*$", stripped)
+        if match:
+            pre   = match.group(1)
+            head  = match.group(2).strip()
+            body  = match.group(3).strip()
+            lines_out = []
+            if head:
+                header_line = pre + head
+                if not header_line.rstrip().endswith(":"):
+                    header_line = header_line.rstrip() + ":"
+                lines_out.append(header_line)
+                body_indent = pre + "    "
+            else:
+                body_indent = pre
+            # Split body on semicolons (outside strings)
+            for stmt in _split_semicolons(body):
+                if stmt.strip():
+                    lines_out.append(body_indent + stmt.strip())
+            return lines_out
+
+    # ── Split on semicolons ───────────────────────────────────────────────────
+    parts = _split_semicolons(stripped)
+    if len(parts) > 1:
+        out = []
+        for part in parts:
+            part = part.strip()
+            if part:
+                out.append(indent_str + part)
+        return out
+
+    # ── Plain line — return as-is ─────────────────────────────────────────────
+    return [stripped]
+
+
+def _split_semicolons(code: str) -> list[str]:
+    """Split a code string on semicolons that are outside strings/comments."""
+    segments = _tokenise_strings(code)
+    parts = []
+    current = []
+    for seg, is_str in segments:
+        if is_str:
+            current.append(seg)
+        else:
+            bits = seg.split(";")
+            for i, bit in enumerate(bits):
+                if i < len(bits) - 1:
+                    current.append(bit)
+                    parts.append("".join(current))
+                    current = []
+                else:
+                    current.append(bit)
+    if current:
+        parts.append("".join(current))
+    return [p for p in parts if p.strip()]
+
+
+def _fix_indentation(lines: list[str]) -> list[str]:
+    """
+    Re-indent the output so blocks opened by `:` are properly indented.
+    This is the second pass after brace/semicolon expansion.
+    """
+    result = []
+    indent_level = 0
+    indent_unit = "    "
+
+    for line in lines:
+        stripped = line.strip()
+        if not stripped:
+            result.append("")
+            continue
+
+        # Dedent if this line starts with else/elif/except/finally
+        if re.match(r"^(else|elif|except|finally)\b", stripped):
+            indent_level = max(0, indent_level - 1)
+
+        result.append(indent_unit * indent_level + stripped)
+
+        # Increase indent after block-opening colon
+        if stripped.endswith(":") and not stripped.startswith("#"):
+            indent_level += 1
+
+    return result
+
+
+def transform(code: str, debug: bool = False) -> str:
+    """
+    Transform Messy Python code to standard Python.
+
+    Parameters
+    ----------
+    code : str
+        Messy Python source code.
+    debug : bool
+        If True, prints transformation steps to stdout.
+
+    Returns
+    -------
+    str
+        Standard Python source code with attribution comment prepended.
+
+    Example
+    -------
+    >>> transform("def double(x) { return x * 2; }")
+    '# ───...\\ndef double(x):\\n    return x * 2\\n'
+    """
+    from . import ATTRIBUTION_COMMENT
+
+    raw_lines = code.splitlines()
+    expanded: list[str] = []
+
+    for raw_line in raw_lines:
+        processed = _process_line(raw_line)
+        expanded.extend(processed)
+        if debug:
+            print(f"[debug] {raw_line!r} → {processed}")
+
+    final_lines = _fix_indentation(expanded)
+    output = "\n".join(final_lines)
+
+    # Prepend attribution
+    if ATTRIBUTION_COMMENT.strip() not in output:
+        output = ATTRIBUTION_COMMENT + "\n" + output
+
+    return output