solpython 0.1.0__py3-none-any.whl

pysol/executor.py

@@ -0,0 +1,127 @@
+"""Execute Python source via the on-chain compiler and VM."""
+
+import json
+from pathlib import Path
+
+_ARTIFACTS_DIR = Path(__file__).parent / "contracts" / "artifacts"
+
+
+def _patch_evm():
+    """Disable EIP-3860 contract size limits in py-evm."""
+    from eth.vm.forks.shanghai.computation import ShanghaiComputation
+    from eth.vm.forks.spurious_dragon.computation import SpuriousDragonComputation
+
+    @classmethod
+    def _no_validate(cls, message):
+        pass
+
+    @classmethod
+    def _no_consume(cls, computation):
+        pass
+
+    @classmethod
+    def _no_validate_code(cls, code):
+        pass
+
+    ShanghaiComputation.validate_create_message = _no_validate
+    ShanghaiComputation.consume_initcode_gas_cost = _no_consume
+    SpuriousDragonComputation.validate_contract_code = _no_validate_code
+
+
+def _load_artifact(name: str) -> dict:
+    path = _ARTIFACTS_DIR / f"{name}.json"
+    if not path.exists():
+        raise FileNotFoundError(
+            f"Contract artifacts not found at {path}. "
+            f"Run `pysol-compile` or `python -m pysol.build` first."
+        )
+    return json.loads(path.read_text())
+
+
+def _setup_evm():
+    """Create a local EVM and deploy compiler + VM contracts."""
+    _patch_evm()
+    from web3 import Web3
+    from eth_tester import EthereumTester
+    from eth_tester.backends.pyevm.main import PyEVMBackend
+
+    genesis_params = PyEVMBackend._generate_genesis_params(
+        overrides={"gas_limit": 1_000_000_000}
+    )
+    backend = PyEVMBackend(genesis_parameters=genesis_params)
+    tester = EthereumTester(backend=backend)
+    w3 = Web3(Web3.EthereumTesterProvider(ethereum_tester=tester))
+
+    compiler_art = _load_artifact("PythonCompiler")
+    vm_art = _load_artifact("VM")
+
+    sender = w3.eth.accounts[0]
+    gas = 1_000_000_000
+
+    # Deploy PythonCompiler
+    Compiler = w3.eth.contract(abi=compiler_art["abi"], bytecode=compiler_art["bytecode"])
+    tx_hash = Compiler.constructor().transact({"from": sender, "gas": gas})
+    receipt = w3.eth.get_transaction_receipt(tx_hash)
+    compiler = w3.eth.contract(address=receipt["contractAddress"], abi=compiler_art["abi"])
+
+    # Deploy VM
+    VM = w3.eth.contract(abi=vm_art["abi"], bytecode=vm_art["bytecode"])
+    tx_hash = VM.constructor().transact({"from": sender, "gas": gas})
+    receipt = w3.eth.get_transaction_receipt(tx_hash)
+    vm = w3.eth.contract(address=receipt["contractAddress"], abi=vm_art["abi"])
+
+    return w3, compiler, vm, sender, gas
+
+
+def _decode_output(w3, receipt) -> str:
+    """Decode Print and PrintString events from transaction receipt."""
+    print_topic = w3.keccak(text="Print(uint256[])").hex()
+    print_str_topic = w3.keccak(text="PrintString(string)").hex()
+
+    parts = []
+    for log in receipt["logs"]:
+        topic0 = log["topics"][0].hex()
+        if topic0 == print_topic:
+            decoded = w3.codec.decode(["uint256[]"], log["data"])
+            for v in decoded[0]:
+                parts.append(str(v))
+        elif topic0 == print_str_topic:
+            decoded = w3.codec.decode(["string"], log["data"])
+            parts.append(decoded[0])
+
+    return "\n".join(parts)
+
+
+def run(source: str, *, verbose: bool = False) -> str:
+    """Compile and execute Python source, return printed output."""
+    w3, compiler, vm, sender, gas = _setup_evm()
+
+    if verbose:
+        print(f"[solpython] Compiling {len(source)} chars of Python...")
+
+    bytecode = compiler.functions.compile(source).call({"from": sender, "gas": gas})
+
+    if verbose:
+        print(f"[solpython] Generated {len(bytecode)} bytes of bytecode")
+
+    tx_hash = vm.functions.execute(bytecode).transact({"from": sender, "gas": gas})
+    receipt = w3.eth.get_transaction_receipt(tx_hash)
+
+    return _decode_output(w3, receipt)
+
+
+def run_with_imports(source: str, modules: dict[str, str], *, verbose: bool = False) -> str:
+    """Compile and execute Python source with imported modules."""
+    w3, compiler, vm, sender, gas = _setup_evm()
+
+    names = list(modules.keys())
+    sources = [modules[n] for n in names]
+
+    bytecode = compiler.functions.compileWithImports(source, names, sources).call(
+        {"from": sender, "gas": gas}
+    )
+
+    tx_hash = vm.functions.execute(bytecode).transact({"from": sender, "gas": gas})
+    receipt = w3.eth.get_transaction_receipt(tx_hash)
+
+    return _decode_output(w3, receipt)

solpython-0.1.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.4
+Name: solpython
+Version: 0.1.0
+Summary: Python-to-EVM compiler — run Python on-chain via a Solidity smart contract pipeline
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: web3>=6.0
+Requires-Dist: eth-tester>=0.10.0
+Requires-Dist: py-evm>=0.10.0
+Provides-Extra: build
+Requires-Dist: py-solc-x>=2.0; extra == "build"
+Dynamic: license-file
+
+# solpython
+
+A Python-to-EVM compiler written entirely in Solidity. Feed it Python source code as a string, get EVM-compatible bytecode out — no off-chain tooling required.
+
+644 tests across 46 test suites.
+
+## Architecture
+
+Six-phase compiler pipeline, each phase implemented as a Solidity contract:
+
+```
+Python source (string)
+       │
+       ▼
+  ┌──────────┐
+  │  Lexer   │  Tokenizes source into token stream
+  └────┬─────┘
+       │ Token[]
+       ▼
+  ┌──────────┐
+  │  Parser  │  Recursive descent → AST (struct array in storage)
+  └────┬─────┘
+       │ ASTNode[]
+       ▼
+  ┌───────────────┐
+  │   Semantic    │  Symbol table, scope resolution, type inference
+  │   Analyzer    │
+  └────┬──────────┘
+       │
+       ▼
+  ┌───────────────┐
+  │     Code      │  AST → custom stack-based bytecode
+  │   Generator   │
+  └────┬──────────┘
+       │ bytes (bytecode)
+       ▼
+  ┌──────────┐
+  │    VM    │  Stack machine executes bytecode
+  └──────────┘
+```
+
+Alternative backends:
+- **Solidity Backend** — AST → Solidity source code transpiler
+- **Yul Backend** — AST → Yul IR transpiler
+
+## Supported Python Features
+
+**Core:**
+- Integer arithmetic (`+`, `-`, `*`, `/`, `//`, `%`, `**`) with negative numbers
+- Augmented assignment (`+=`, `-=`, `*=`, `/=`)
+- Comparisons (`==`, `!=`, `<`, `>`, `<=`, `>=`, `is`, `is not`)
+- Chained comparisons (`a < b < c`)
+- Boolean operators (`and`, `or`, `not`)
+- Ternary expressions (`a if cond else b`)
+- `if` / `elif` / `else`
+- `while` loops
+- `for` loops with `range()`, list iteration, `break`, `continue`
+- `for...else` / `while...else`
+- Function definitions with recursion, default parameters, keyword arguments
+- Nested function definitions
+- `return` statements
+- `pass` statement
+
+**Data Types:**
+- Integers (tagged, -2^62 to 2^62-1)
+- Booleans (`True`, `False`) with proper tagging
+- `None` type with safety checks
+- Strings with methods (`upper`, `lower`, `split`, `contains`, `charAt`, slice)
+- Lists with indexing, negative indexing, `len()`, `append()`
+- Dicts with string/int keys, `items()`, `values()`, `get()`, `update()`
+- Sets with `add()`, `remove()`, `in` operator
+- Tuples with unpacking (`a, b = 1, 2`)
+- Float (6-digit fixed-point)
+
+**Builtins:**
+- `print()` — integer and string output
+- `len()`, `type()`, `isinstance()`
+- `range()`, `enumerate()`, `zip()`
+- `map()`, `filter()`
+- `sorted()`, `reversed()`
+- `abs()`, `min()`, `max()`
+- f-strings and `%s`/`%d` formatting
+
+**Advanced:**
+- `try` / `except` / `finally` / `raise`
+- `class` with methods, `self`, single inheritance
+- `import` / `from...import` with static linking
+- `global` / `nonlocal` keywords
+- Virtual file system (VFS) for module loading
+- Garbage collection (reference counting)
+- Constant folding and dead code elimination
+- Structured error messages with line/column info
+
+## Build & Test
+
+Requires [Foundry](https://book.getfoundry.sh/).
+
+```shell
+forge build          # compile
+forge test           # run all 644 tests
+forge test -vvv      # verbose output
+forge test --match-test testFibonacci   # run a single test
+```
+
+## Example
+
+```python
+def fib(n):
+    if n <= 1:
+        return n
+    return fib(n - 1) + fib(n - 2)
+
+print(fib(10))  # → 55
+```
+
+This compiles to bytecode that runs entirely on-chain via the Solidity VM contract.
+
+## Project Structure
+
+```
+src/
+  types/                  AST node, token, and type info structs
+  libraries/              String utility library
+  phases/
+    Lexer.sol             Tokenizer
+    Parser.sol            Recursive descent parser
+    SemanticAnalyzer.sol  Symbol table, scope resolution
+    CodeGenerator.sol     AST → bytecode
+    VM.sol                Stack-based bytecode interpreter
+    SolidityBackend.sol   AST → Solidity source transpiler
+    YulBackend.sol        AST → Yul IR transpiler
+  optimizer/
+    ConstantFolder.sol    Compile-time constant folding
+  gc/
+    RefCounter.sol        Reference counting GC
+  vfs/
+    VFS.sol               Virtual file system
+  venv/
+    Venv.sol              Compilation environment
+  PythonCompiler.sol      Top-level orchestrator
+
+test/
+  46 test suites covering lexer, parser, semantic analysis,
+  code generation, VM execution, and end-to-end integration.
+
+  Key files:
+    Integration.t.sol     End-to-end compiler tests (fibonacci, fizzbuzz, bubble sort)
+    E2E.t.sol             Feature-specific end-to-end tests
+    TypeClassify.t.sol    Type system and tagging verification
+    Exception.t.sol       Exception handling tests
+    GC.t.sol              Garbage collection tests
+```
+
+## Value Tagging
+
+The VM uses a tagged value system to distinguish types:
+
+| Type     | Tag                        | Range                         |
+|----------|----------------------------|-------------------------------|
+| Integer  | (none)                     | -2^62 to 2^62-1              |
+| Boolean  | BOOL_OFFSET (2^66)         | 2^66 (False), 2^66+1 (True)  |
+| None     | NONE_VALUE                 | Fixed sentinel                |
+| Float    | Tag at bits 252-255        | 6-digit fixed-point           |
+| List     | ID 0 to 2^60-1             | GC-tracked                    |
+| Dict     | ID 2^60 to 2^61-1          | GC-tracked                    |
+| Set      | ID 2^61 to 2^62-1          | GC-tracked                    |
+| String   | ID >= 2^62                 | Static + runtime              |
+
+## Known Limitations
+
+- No generators/iterators
+- No class inheritance beyond single-level
+- No closures (inner functions cannot capture outer variables)
+- Float arithmetic uses 6-digit fixed-point, not IEEE 754
+- GC is reference counting only (no cycle detection)
+- Solidity/Yul backends don't support all features (see `BACKEND_LIMITATIONS.md`)
+
+## License
+
+MIT

solpython-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+pysol/__init__.py,sha256=4Vtm2aieXEP5tMfUHGOMRJi8_oyQWnJe51y1DySdQos,89
+pysol/build.py,sha256=HUF8iFaegQcCY0DP45xsoFUCEWqPqIaXb4YhwXABETk,4483
+pysol/executor.py,sha256=Etb6ORTkbGPQXa5ebhJnIPvMsFyX7XRDYLDR4RdDgVg,4344
+pysol/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysol/cli/main.py,sha256=pkIz2rMGX2baxd4-h-VW-JfNjGTc1SmcbjMw_KC_bSE,2852
+pysol/contracts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pysol/contracts/artifacts/PythonCompiler.json,sha256=01k6L0j8ZBWn2JG6CNdlRmhxpa-cHewJjY86-V3XfnU,437747
+pysol/contracts/artifacts/VM.json,sha256=_qK4oc1KN2Zy0bhRMvrGorYhp2mHbKWGddqjQv4kSEE,91038
+solpython-0.1.0.dist-info/licenses/LICENSE,sha256=GTNYUQJMKq5FV1co1N2BKUIxkAPPa2FCc8sLKO7x9FA,1065
+solpython-0.1.0.dist-info/METADATA,sha256=d_Hw8LDflajFOzuGxjkWeR7drizAosU1Hvdm50VL3cQ,6497
+solpython-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+solpython-0.1.0.dist-info/entry_points.txt,sha256=_s3EKcXf0MyFyfvA2r3llhjghAuMwS0PNRgFLxERppo,84
+solpython-0.1.0.dist-info/top_level.txt,sha256=rM0iJ3CoB_QH43ATGuXjYgViiQkxBgtslv7tJqxUulM,6
+solpython-0.1.0.dist-info/RECORD,,

solpython-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

solpython-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+pysol-compile = pysol.build:build
+solpython = pysol.cli.main:main

solpython-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 taco-jpg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solpython-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pysol