vp2py 3.0.0__tar.gz

vp2py-3.0.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.3
+Name: vp2py
+Version: 3.0.0
+Summary: An implementation of a Varphi-to-Python compiler.
+Author: Varphi
+Author-email: Varphi <support@varphi-lang.com>
+Requires-Dist: typer
+Requires-Dist: varphi-devkit>=3.0.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# The Varphi-to-Python Compiler
+This is the source code repository for a compiler that converts the [Varphi programming language](https://varphi-lang.com/) into Python.

vp2py-3.0.0/README.md

@@ -0,0 +1,2 @@
+# The Varphi-to-Python Compiler
+This is the source code repository for a compiler that converts the [Varphi programming language](https://varphi-lang.com/) into Python.

vp2py-3.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "vp2py"
+version = "3.0.0"
+description = "An implementation of a Varphi-to-Python compiler."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "typer",
+    "varphi-devkit>=3.0.0",
+]
+
+[[project.authors]]
+name = "Varphi"
+email = "support@varphi-lang.com"
+
+[project.scripts]
+vp2py = "vp2py.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "black",
+    "pytest",
+    "vermin",
+]

vp2py-3.0.0/pyproject.toml.orig

@@ -0,0 +1,27 @@
+[project]
+name = "vp2py"
+version = "3.0.0"
+description = "An implementation of a Varphi-to-Python compiler."
+readme = "README.md"
+authors = [
+    { name = "Varphi", email = "support@varphi-lang.com" }
+]
+requires-python = ">=3.10"
+dependencies = [
+    "typer",
+    "varphi-devkit>=3.0.0",
+]
+
+[project.scripts]
+vp2py = "vp2py.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.9.18,<0.10.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "black",
+    "pytest",
+    "vermin"
+]

vp2py-3.0.0/src/vp2py/__init__.py

@@ -0,0 +1,3 @@
+from .compiler import VarphiToPythonCompiler
+
+__all__ = ["VarphiToPythonCompiler"]

vp2py-3.0.0/src/vp2py/cli.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+import typer
+
+
+def vp2py(
+    input_file: Path = typer.Argument(
+        ...,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        resolve_path=True,
+        help="Path to input Varphi source file",
+    ),
+    debug: bool = typer.Option(
+        False,
+        "--debug/--no-debug",
+        help="Compile with debugging capabilities",
+    ),
+):
+    """Compile a Varphi source code file to Python"""
+    from .compiler import VarphiToPythonCompiler
+
+    compiler = VarphiToPythonCompiler()
+    if debug:
+        compiler.toggle_debug()
+
+    # Read file, compile, and print result to stdout
+    result = compiler.compile(input_file.read_text(encoding="utf-8"))
+    typer.echo(result)
+
+
+def main():
+    typer.run(vp2py)
+
+
+if __name__ == "__main__":
+    main()

vp2py-3.0.0/src/vp2py/compiler.py

@@ -0,0 +1,110 @@
+from varphi_devkit import (
+    VarphiCompiler,
+    BuiltinSymbol,
+    Variable,
+    Direction,
+    Character,
+    ReadWriteTupleElement,
+)
+
+TEMPLATE = """\
+from vp2py.lib import State, main
+from varphi_devkit import BuiltinSymbol, Direction, Variable, Character, VarphiTransition
+
+# --- State Registry ---
+state_registry = {{
+{state_registry_entries}
+}}
+
+# --- Transition Definitions ---
+{instruction_definitions}
+
+# --- Runtime Setup ---
+initial_state = state_registry['{initial_state}']
+k = {num_tapes}
+
+if __name__ == "__main__":
+    import argparse
+    parser = argparse.ArgumentParser(description="Varphi Turing Machine Runtime")
+    parser.add_argument("--debug", action="store_true", default={debug_mode}, help="Enable step-by-step debug mode")
+    parser.add_argument("-b", "--blank-char", type=str, default="_", help="Character representing a BLANK cell in input/output (Default: _)")
+    args = parser.parse_args()
+    
+    # Pass the state_registry to main!
+    main(k, initial_state, state_registry, args.debug, args.blank_char)
+"""
+
+
+class VarphiToPythonCompiler(VarphiCompiler):
+    debug_mode: bool
+
+    def __init__(self):
+        super().__init__()
+        self.debug_mode = False
+
+    def toggle_debug(self):
+        self.debug_mode = not self.debug_mode
+
+    def _format_symbol(self, s: ReadWriteTupleElement) -> str:
+        """Converts devkit symbol objects to valid strings to inject into the compiled code."""
+        if s == BuiltinSymbol.BLANK:
+            return "BuiltinSymbol.BLANK"
+        if isinstance(s, Variable):
+            return f"Variable({s.id})"
+        if isinstance(s, Character):
+            return f"Character({repr(s.value)})"
+        raise ValueError(f"Unknown symbol type: {type(s)}")
+
+    def _format_direction(self, d: Direction) -> str:
+        """Converts devkit direction enums to valid Python code strings."""
+        return f"Direction.{d.name}"
+
+    def _generate_compiled_program(self) -> str:
+        # Use the devkit's pre-discovered states directly
+        all_states = self.states
+
+        # Build the dictionary mapping strings to the State objects directly to avoid keyword collisions
+        registry_entries = "\n".join(
+            f"    '{name}': State('{name}')," for name in all_states
+        )
+
+        # Map the pre-sorted IR transitions to VarphiTransition instantiations
+        instructions_code = []
+        for transitions in self.ir.values():
+            for t in transitions:
+                read_str = "(" + ", ".join(
+                    self._format_symbol(s) for s in t.read_symbols
+                )
+                read_str += ",)" if len(t.read_symbols) == 1 else ")"
+
+                write_str = "(" + ", ".join(
+                    self._format_symbol(s) for s in t.write_symbols
+                )
+                write_str += ",)" if len(t.write_symbols) == 1 else ")"
+
+                shift_str = "(" + ", ".join(
+                    self._format_direction(d) for d in t.shift_directions
+                )
+                shift_str += ",)" if len(t.shift_directions) == 1 else ")"
+
+                code = (
+                    f"state_registry['{t.current_state}'].add_transition(\n"
+                    f"    VarphiTransition(\n"
+                    f"        current_state='{t.current_state}',\n"
+                    f"        read_symbols={read_str},\n"
+                    f"        next_state='{t.next_state}',\n"
+                    f"        write_symbols={write_str},\n"
+                    f"        shift_directions={shift_str},\n"
+                    f"        line_number={t.line_number}\n"
+                    f"    )\n"
+                    f")"
+                )
+                instructions_code.append(code)
+
+        return TEMPLATE.format(
+            state_registry_entries=registry_entries,
+            instruction_definitions="\n\n".join(instructions_code),
+            initial_state=self.initial_state,
+            num_tapes=self._tape_count,
+            debug_mode=self.debug_mode,
+        )

vp2py-3.0.0/src/vp2py/lib/__init__.py

@@ -0,0 +1,12 @@
+from .model import State, Tape, Head, TuringMachine
+from .functions import main
+from .exceptions import VarphiRuntimeError
+
+__all__ = [
+    "State",
+    "Tape",
+    "Head",
+    "TuringMachine",
+    "main",
+    "VarphiRuntimeError",
+]

vp2py-3.0.0/src/vp2py/lib/exceptions.py

@@ -0,0 +1,2 @@
+class VarphiRuntimeError(Exception):
+    pass

vp2py-3.0.0/src/vp2py/lib/functions.py

@@ -0,0 +1,44 @@
+import sys
+from .io import VarphiIO, DebugView
+from .model import State, TuringMachine
+
+
+def main(
+    k: int,
+    initial_state: State,
+    state_registry: dict,
+    debug: bool,
+    blank_char: str = "_",
+) -> None:
+    io = VarphiIO.from_stdin(blank_char)
+    tm = TuringMachine(k, io.tapes, initial_state, state_registry)
+    time_complexity = 0
+    SEPARATOR = "—" * 60
+
+    while tm.peek():
+        if debug:
+            print(f"\n{SEPARATOR}", file=sys.stderr)
+            print(
+                f"STEP {time_complexity + 1} [State: {tm.state.name}]", file=sys.stderr
+            )
+            print(f"{SEPARATOR}", file=sys.stderr)
+            print(DebugView(tm, blank_char), file=sys.stderr)
+            try:
+                input("\n>> Press ENTER to step forward...")
+            except (KeyboardInterrupt, EOFError):
+                print("\nInterrupted.", file=sys.stderr)
+                return
+
+        tm.step()
+        time_complexity += 1
+
+    if sys.stdout.isatty():
+        print(f"\n{SEPARATOR}", file=sys.stderr)
+        print(f"HALTED at state '{tm.state.name}'", file=sys.stderr)
+        print(f"Time taken: {time_complexity} steps", file=sys.stderr)
+        print(
+            f"Space used: {sum(head.space_complexity() for head in tm.heads)} cells",
+            file=sys.stderr,
+        )
+
+    VarphiIO(tm.tapes).print(blank_char)

vp2py-3.0.0/src/vp2py/lib/io.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+import sys
+from dataclasses import dataclass
+from typing import Tuple
+from .model import Tape, TuringMachine
+from .exceptions import VarphiRuntimeError
+from varphi_devkit import BuiltinSymbol, Character
+
+
+@dataclass(frozen=True)
+class VarphiIO:
+    tapes: Tuple[Tape, ...]
+
+    @staticmethod
+    def from_stdin(blank_char: str) -> VarphiIO:
+        if sys.stdin.isatty():
+            print("Number of input tapes: ", end="", file=sys.stderr, flush=True)
+
+        header = sys.stdin.readline()
+        if not header:
+            return VarphiIO(tuple())
+
+        try:
+            num_tapes = int(header.strip())
+        except ValueError:
+            raise VarphiRuntimeError(
+                f'Runtime Error: Expected an integer for number of tapes, got "{header.strip()}".'
+            )
+        if num_tapes <= 0:
+            raise VarphiRuntimeError(
+                f'Runtime Error: Expected a positive number of tapes, got "{num_tapes}".'
+            )
+
+        tapes = []
+        for i in range(num_tapes):
+            if sys.stdin.isatty():
+                print(f"Tape {i + 1}: ", end="", file=sys.stderr, flush=True)
+
+            line = sys.stdin.readline().strip("\r\n")
+
+            parsed_tape = []
+            for char in line:
+                if char == blank_char:
+                    parsed_tape.append(BuiltinSymbol.BLANK)
+                else:
+                    parsed_tape.append(Character(char))
+
+            tapes.append(Tape(parsed_tape))
+
+        return VarphiIO(tuple(tapes))
+
+    def print(self, blank_char: str) -> None:
+        show_labels = sys.stdout.isatty()
+        if show_labels:
+            print("Number of tapes: ", end="", file=sys.stderr, flush=True)
+
+        print(len(self.tapes))
+
+        for i, tape in enumerate(self.tapes):
+            if show_labels:
+                print(f"Tape {i + 1}: ", end="", file=sys.stderr, flush=True)
+            print(tape.to_string(blank_char))
+
+
+@dataclass
+class DebugView:
+    machine: TuringMachine
+    blank_char: str
+
+    def __str__(self) -> str:
+        line_number = (
+            self.machine._next_transition.line_number
+            if self.machine._next_transition
+            else "?"
+        )
+        lines = [f"State: {self.machine.state.name} (Line {line_number})"]
+
+        max_radius = 0
+        for head in self.machine.heads:
+            if not head.tape._tape:
+                continue
+
+            dist_left = (
+                abs(head.index - head.tape._min_idx)
+                if head.tape._min_idx is not None
+                else 0
+            )
+            dist_right = (
+                abs(head.index - head.tape._max_idx)
+                if head.tape._max_idx is not None
+                else 0
+            )
+            max_radius = max(max_radius, dist_left, dist_right)
+
+        for i, head in enumerate(self.machine.heads):
+            start = head.index - max_radius
+            end = head.index + max_radius
+
+            chars = []
+            for idx in range(start, end + 1):
+                val = head.tape._tape.get(idx, BuiltinSymbol.BLANK)
+                val_str = self.blank_char if val == BuiltinSymbol.BLANK else val.value
+
+                if idx == head.index:
+                    chars.append(f"[{val_str}]")
+                else:
+                    chars.append(val_str)
+
+            lines.append(f"Tape {i + 1}: {''.join(chars)}")
+
+        return "\n".join(lines)

vp2py-3.0.0/src/vp2py/lib/model.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+from typing import Dict, Tuple, Optional, Set
+import random
+from collections import defaultdict
+
+from varphi_devkit import (
+    BuiltinSymbol,
+    Direction,
+    Variable,
+    Character,
+    ReadWriteTupleElement,
+    VarphiTransition,
+)
+
+
+class State:
+    """A state in the Turing machine."""
+
+    name: str
+    transitions: list[VarphiTransition]
+
+    def __init__(self, name: str) -> None:
+        """Initialize a new state."""
+        self.name = name
+        self.transitions = []
+
+    def add_transition(self, transition: VarphiTransition) -> None:
+        """Append a VarphiTransition to the state."""
+        self.transitions.append(transition)
+
+    def get_transition(
+        self, tape_readings: tuple[Character | BuiltinSymbol, ...]
+    ) -> Optional[Tuple[VarphiTransition, Dict[Variable, Character | BuiltinSymbol]]]:
+        """
+        Evaluate current tape readings against the state's transitions to find the highest-specificity match.
+
+        Args:
+            tape_readings: A tuple of the actual characters currently read by the machine's heads.
+
+        Returns:
+            A tuple containing the winning VarphiTransition and its variable bindings, or None if the machine halts as a result of this situation.
+        """
+        candidates = []
+        best_specificity = None
+
+        for transition in self.transitions:
+            bindings = self._check_match(transition.read_symbols, tape_readings)
+
+            if bindings is not None:
+                # The transition rule applies
+                current_specificity = transition.specificity
+
+                if best_specificity is None:
+                    best_specificity = current_specificity
+
+                # Once the best (lowest) specificity is set, we will only consider
+                # scores that are the same as that scores
+                # Since the transitions have been sorted by the devkit by specificity, we can
+                # stop collecting transitions once we see one that has a higher specificity than the
+                # best specificity
+                elif current_specificity > best_specificity:
+                    break
+
+                candidates.append((transition, bindings))
+
+        if not candidates:
+            # No transition rules apply, so the machine will halt
+            return None
+
+        # Resolve nondeterministic ties
+        return random.choice(candidates)
+
+    def _check_match(
+        self,
+        pattern: tuple[ReadWriteTupleElement, ...],
+        readings: tuple[Character | BuiltinSymbol, ...],
+    ) -> Optional[Dict[Variable, Character | BuiltinSymbol]]:
+        """
+        Verify if a given pattern matches the current tape readings and extract variable bindings.
+
+        Returns the variable bindings (or an empty dictionary if there aren't variables) if the pattern applies,
+        otherwise returns None
+        """
+        bindings = {}
+
+        for pattern_symbol, read_symbol in zip(pattern, readings):
+            if isinstance(pattern_symbol, Variable):
+                if pattern_symbol not in bindings:
+                    # Bind the variable to the read symbol
+                    bindings[pattern_symbol] = read_symbol
+                elif bindings[pattern_symbol] != read_symbol:
+                    # We've bound the variable previously, but there's a mismatch
+                    # This rule cannot possibly apply
+                    return None
+            elif pattern_symbol != read_symbol:
+                # The pattern and read symbols don't match up, so the rule doesn't apply
+                return None
+        # If we're here, the rule applies. Return the variable bindings
+        return bindings
+
+    def __repr__(self) -> str:
+        return f"State({self.name})"
+
+
+class Tape:
+    """Represents a two-way infinite tape of the Turing machine."""
+
+    _tape: defaultdict[int, Character | BuiltinSymbol]
+    _min_idx: Optional[int]
+    _max_idx: Optional[int]
+
+    def __init__(self, initial_values: list[Character | BuiltinSymbol]) -> None:
+        self._tape = defaultdict(lambda: BuiltinSymbol.BLANK)
+        self._min_idx = None
+        self._max_idx = None
+
+        for i, val in enumerate(initial_values):
+            if val != BuiltinSymbol.BLANK:
+                self[i] = val
+
+    def __getitem__(self, index: int) -> Character | BuiltinSymbol:
+        self._update_bounds(index)
+        return self._tape[index]
+
+    def __setitem__(self, index: int, value: Character | BuiltinSymbol) -> None:
+        self._update_bounds(index)
+        self._tape[index] = value
+
+    def _update_bounds(self, index: int) -> None:
+        if self._min_idx is None or self._max_idx is None:
+            self._min_idx = index
+            self._max_idx = index
+        else:
+            self._max_idx = max(self._max_idx, index)
+            self._min_idx = min(self._min_idx, index)
+
+    def to_string(self, blank_char: str) -> str:
+        if self._min_idx is None or self._max_idx is None:
+            return ""
+
+        min_i, max_i = self._min_idx, self._max_idx
+
+        while max_i >= min_i and self._tape[max_i] == BuiltinSymbol.BLANK:
+            max_i -= 1
+        while min_i <= max_i and self._tape[min_i] == BuiltinSymbol.BLANK:
+            min_i += 1
+
+        if min_i > max_i:
+            return ""
+
+        return "".join(
+            blank_char if self._tape[i] == BuiltinSymbol.BLANK else self._tape[i].value
+            for i in range(min_i, max_i + 1)
+        )
+
+    @property
+    def is_empty(self) -> bool:
+        return self._min_idx is None
+
+
+class Head:
+    """Represents a read/write head positioned on a specific tape."""
+
+    tape: Tape
+    index: int
+    user_input_cell_range: Optional[tuple[int, int]]
+    new_accessed_cells: Set[int]
+
+    def __init__(self, tape: Tape) -> None:
+        self.tape = tape
+        self.index = 0
+        self.new_accessed_cells = set()
+
+        if tape.is_empty:
+            self.user_input_cell_range = None
+        else:
+            self.user_input_cell_range = (tape._min_idx, tape._max_idx)
+
+    def move(self, direction: Direction) -> None:
+        if direction == Direction.LEFT:
+            self.index -= 1
+        elif direction == Direction.RIGHT:
+            self.index += 1
+
+    def read(self) -> Character | BuiltinSymbol:
+        self._check_access()
+        return self.tape[self.index]
+
+    def write(self, value: Character | BuiltinSymbol) -> None:
+        self._check_access()
+        self.tape[self.index] = value
+
+    def _check_access(self):
+        if self.user_input_cell_range is None:
+            self.new_accessed_cells.add(self.index)
+        else:
+            start, end = self.user_input_cell_range
+            if self.index < start or self.index > end:
+                self.new_accessed_cells.add(self.index)
+
+    def space_complexity(self) -> int:
+        return len(self.new_accessed_cells)
+
+
+class TuringMachine:
+    tapes: tuple[Tape, ...]
+    heads: tuple[Head, ...]
+    state: State
+    state_registry: dict[str, State]
+    _next_transition: Optional[VarphiTransition]
+    _current_bindings: dict[Variable, Character | BuiltinSymbol]
+
+    def __init__(
+        self,
+        k: int,
+        tapes: tuple[Tape, ...],
+        initial_state: State,
+        state_registry: dict[str, State],
+    ) -> None:
+        """
+        Initialize the machine.
+
+        Args:
+            k: The required number of tapes for this machine configuration.
+            tapes: A tuple of initial tapes provided by user input. Missing tapes are generated as blanks.
+            initial_state: The entry state of the machine.
+            state_registry: A dictionary mapping state names to live State objects.
+        """
+        self.tapes = tapes  # Keep all tapes so they are printed at the end
+        missing_count = k - len(self.tapes)
+        if missing_count > 0:
+            self.tapes += tuple(Tape([]) for _ in range(missing_count))
+
+        # We only make heads for the first k tapes (we safely ignore excess tapes during execution)
+        self.heads = tuple(Head(t) for t in self.tapes[:k])
+        self.state = initial_state
+        self.state_registry = state_registry
+        self._next_transition = None
+        self._current_bindings = {}
+
+    def peek(self) -> bool:
+        """
+        Preview the next transition by evaluating current tape readings against the state.
+        This will select and "arm" the machine with the next transition, but won't execute it
+        Return True if a next transition has been selected, False if the machine will halt
+        """
+        reads = tuple(h.read() for h in self.heads)
+        result = self.state.get_transition(reads)
+
+        if result is None:
+            # No transition applies; halt
+            self._next_transition = None
+            self._current_bindings = {}
+            return False
+
+        self._next_transition, self._current_bindings = result
+        return True
+
+    def step(self) -> None:
+        """Execute the transition locked in by the previous call to peek()."""
+        transition = self._next_transition
+        bindings = self._current_bindings
+
+        if transition is None:
+            return
+
+        # Perform the string-to-object dictionary lookup here
+        self.state = self.state_registry[transition.next_state]
+
+        for i, head in enumerate(self.heads):
+            sym = transition.write_symbols[i]
+            val_to_write = bindings[sym] if isinstance(sym, Variable) else sym
+            head.write(val_to_write)
+            head.move(transition.shift_directions[i])