fastpython-native 0.1.0__tar.gz

fastpython_native-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: fastpython-native
+Version: 0.1.0
+Summary: AOT Hardware-Adaptive Native Machine Code Compiler for Python
+Author: FastPython Team
+Keywords: compiler,performance,aot,simd,avx2,jit,optimization
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# FastPython ⚡
+
+> **AOT Hardware-Adaptive Native Machine Code Compiler for Python**
+
+FastPython erkennt beim Start automatisch die Architektur und Fähigkeiten deiner Host-CPU (AVX2, AVX-512, FMA3, BMI2, Cache & Kerne), analysiert deine Python-Funktionen, übersetzt rechenintensive Schleifen und Algorithmen in optimierten C99/C++ Code und kompiliert diesen **vor dem Start** in hardwarenahen Maschinencode.
+
+Beim wiederholten Starten sorgt ein intelligentes SHA-256 Caching dafür, dass keine Kompilierungszeit anfällt und das Modul in **unter 1 Millisekunde** direkt aus dem Cache geladen wird.
+
+---
+
+## 🚀 Benchmark-Ergebnisse (auf AMD Ryzen 7 5700X, 16 Threads, AVX2, FMA3)
+
+| Bereich / Algorithmus | Standard CPython | FastPython (Host AOT) | Beschleunigung |
+| :--- | :---: | :---: | :---: |
+| **Fraktale: Mandelbrot Multi-Core** (250x250, 16 Threads) | 662,7 ms | **1,45 ms** | **⚡ 458,2x schneller** |
+| **Stochastik: Monte Carlo Pi** (3 Mio. Samples) | 4.234,6 ms | **13,7 ms** | **⚡ 308,6x schneller** |
+| **Lineare Algebra: Vector Dot** (1.000.000 Floats SIMD) | 121,5 ms | **0,73 ms** | **⚡ 167,4x schneller** |
+| **Zahlentheorie: Collatz-Suche** (50.000 Zahlen) | 698,3 ms | **7,2 ms** | **⚡ 96,8x schneller** |
+| **Fraktale: Mandelbrot Single-Core** (250x250, AVX2) | 651,4 ms | **8,58 ms** | **⚡ 75,9x schneller** |
+
+---
+
+## 🛠️ Verwendung
+
+### 1. Zero-Touch Projekt-Beschleunigung (Empfohlen)
+
+Füge einfach in deiner `main.py` als erste Zeile hinzu:
+
+```python
+import fastpython.auto  # Aktiviert automatische Hardware-AOT-Kompilierung für das Projekt
+
+# Ab hier: Importiere deine ganz normalen Projektdateien (ohne Decorator oder Änderungen!)
+import simulation
+import math_utils
+
+# Alle Funktionen in diesen Dateien laufen jetzt im nativen Maschinencode!
+simulation.run()
+```
+
+Führe dein Skript wie gewohnt mit Python aus:
+```bash
+python main.py
+```
+FastPython fängt alle Projekt-Imports ab, identifiziert rechenintensive Funktionen in allen Projektdateien, kompiliert sie vor der Ausführung in AVX2-Maschinencode und sichert sie im Cache. Bei jedem weiteren Start startet das Programm ohne Verzögerung sofort im nativen Modus.
+
+---
+
+### 2. Als gezielter Decorator für einzelne Funktionen
+
+```python
+from fastpython import compile_native
+
+@compile_native(fastmath=True, parallel=True)
+def calculate_pi(n: int) -> float:
+    acc = 0.0
+    sign = 1.0
+    for i in range(n):
+        denom = 2.0 * float(i) + 1.0
+        acc += sign / denom
+        sign = -sign
+    return 4.0 * acc
+
+print(calculate_pi(20_000_000))  # 20 Millionen Iterationen in ~25ms!
+```
+
+---
+
+### 3. Über das Command Line Interface (CLI)
+
+```bash
+# Host-Hardware analysieren
+python -m fastpython info
+
+# Benchmark-Suite ausführen
+python -m fastpython benchmark
+
+# Eigenes Skript mit FastPython starten
+python -m fastpython run dein_skript.py
+
+# Cache leeren
+python -m fastpython clear-cache
+```
+
+---
+
+## ⚙️ Wie es unter der Haube funktioniert
+
+1. **Hardware-Profiling (`fastpython.hardware`)**:
+   Liest über Low-Level CPUID und System-APIs ab, welche Befehlssätze dein Prozessor unterstützt (z. B. AVX2, FMA3, NEON).
+2. **AST-Transpiler (`fastpython.codegen`)**:
+   Untersucht den Python Abstract Syntax Tree (AST), extrahiert numerische Datentypen (int64_t, double) und entfernt das Python-Objekt-Boxing in inneren Schleifen.
+3. **Host-Compiler (`fastpython.compiler`)**:
+   Generiert die native C-Erweiterung und ruft den lokalen Compiler (MSVC BuildTools / Clang / GCC) mit maximalen Hardware-Flags (`/arch:AVX2 /fp:fast /O2 /Oi /Ot`) auf.
+4. **Caching-Layer**:
+   Hasht Quellcode + CPU-Fingerprint + Compiler-Flags. Bei erneutem Start wird der kompilierte Maschinencode (`.pyd` / `.so`) sofort eingebunden.

fastpython_native-0.1.0/README.md

@@ -0,0 +1,95 @@
+# FastPython ⚡
+
+> **AOT Hardware-Adaptive Native Machine Code Compiler for Python**
+
+FastPython erkennt beim Start automatisch die Architektur und Fähigkeiten deiner Host-CPU (AVX2, AVX-512, FMA3, BMI2, Cache & Kerne), analysiert deine Python-Funktionen, übersetzt rechenintensive Schleifen und Algorithmen in optimierten C99/C++ Code und kompiliert diesen **vor dem Start** in hardwarenahen Maschinencode.
+
+Beim wiederholten Starten sorgt ein intelligentes SHA-256 Caching dafür, dass keine Kompilierungszeit anfällt und das Modul in **unter 1 Millisekunde** direkt aus dem Cache geladen wird.
+
+---
+
+## 🚀 Benchmark-Ergebnisse (auf AMD Ryzen 7 5700X, 16 Threads, AVX2, FMA3)
+
+| Bereich / Algorithmus | Standard CPython | FastPython (Host AOT) | Beschleunigung |
+| :--- | :---: | :---: | :---: |
+| **Fraktale: Mandelbrot Multi-Core** (250x250, 16 Threads) | 662,7 ms | **1,45 ms** | **⚡ 458,2x schneller** |
+| **Stochastik: Monte Carlo Pi** (3 Mio. Samples) | 4.234,6 ms | **13,7 ms** | **⚡ 308,6x schneller** |
+| **Lineare Algebra: Vector Dot** (1.000.000 Floats SIMD) | 121,5 ms | **0,73 ms** | **⚡ 167,4x schneller** |
+| **Zahlentheorie: Collatz-Suche** (50.000 Zahlen) | 698,3 ms | **7,2 ms** | **⚡ 96,8x schneller** |
+| **Fraktale: Mandelbrot Single-Core** (250x250, AVX2) | 651,4 ms | **8,58 ms** | **⚡ 75,9x schneller** |
+
+---
+
+## 🛠️ Verwendung
+
+### 1. Zero-Touch Projekt-Beschleunigung (Empfohlen)
+
+Füge einfach in deiner `main.py` als erste Zeile hinzu:
+
+```python
+import fastpython.auto  # Aktiviert automatische Hardware-AOT-Kompilierung für das Projekt
+
+# Ab hier: Importiere deine ganz normalen Projektdateien (ohne Decorator oder Änderungen!)
+import simulation
+import math_utils
+
+# Alle Funktionen in diesen Dateien laufen jetzt im nativen Maschinencode!
+simulation.run()
+```
+
+Führe dein Skript wie gewohnt mit Python aus:
+```bash
+python main.py
+```
+FastPython fängt alle Projekt-Imports ab, identifiziert rechenintensive Funktionen in allen Projektdateien, kompiliert sie vor der Ausführung in AVX2-Maschinencode und sichert sie im Cache. Bei jedem weiteren Start startet das Programm ohne Verzögerung sofort im nativen Modus.
+
+---
+
+### 2. Als gezielter Decorator für einzelne Funktionen
+
+```python
+from fastpython import compile_native
+
+@compile_native(fastmath=True, parallel=True)
+def calculate_pi(n: int) -> float:
+    acc = 0.0
+    sign = 1.0
+    for i in range(n):
+        denom = 2.0 * float(i) + 1.0
+        acc += sign / denom
+        sign = -sign
+    return 4.0 * acc
+
+print(calculate_pi(20_000_000))  # 20 Millionen Iterationen in ~25ms!
+```
+
+---
+
+### 3. Über das Command Line Interface (CLI)
+
+```bash
+# Host-Hardware analysieren
+python -m fastpython info
+
+# Benchmark-Suite ausführen
+python -m fastpython benchmark
+
+# Eigenes Skript mit FastPython starten
+python -m fastpython run dein_skript.py
+
+# Cache leeren
+python -m fastpython clear-cache
+```
+
+---
+
+## ⚙️ Wie es unter der Haube funktioniert
+
+1. **Hardware-Profiling (`fastpython.hardware`)**:
+   Liest über Low-Level CPUID und System-APIs ab, welche Befehlssätze dein Prozessor unterstützt (z. B. AVX2, FMA3, NEON).
+2. **AST-Transpiler (`fastpython.codegen`)**:
+   Untersucht den Python Abstract Syntax Tree (AST), extrahiert numerische Datentypen (int64_t, double) und entfernt das Python-Objekt-Boxing in inneren Schleifen.
+3. **Host-Compiler (`fastpython.compiler`)**:
+   Generiert die native C-Erweiterung und ruft den lokalen Compiler (MSVC BuildTools / Clang / GCC) mit maximalen Hardware-Flags (`/arch:AVX2 /fp:fast /O2 /Oi /Ot`) auf.
+4. **Caching-Layer**:
+   Hasht Quellcode + CPU-Fingerprint + Compiler-Flags. Bei erneutem Start wird der kompilierte Maschinencode (`.pyd` / `.so`) sofort eingebunden.

fastpython_native-0.1.0/fastpython/__init__.py

@@ -0,0 +1,19 @@
+from .api import compile_native, accelerate, AcceleratedFunction
+from .hardware.cpu import get_cpu_info, CPUFeatures
+from .importer import auto_accelerate
+from .server import FastWebServer
+from . import simd
+from . import memory
+
+__all__ = [
+    "compile_native",
+    "accelerate",
+    "AcceleratedFunction",
+    "get_cpu_info",
+    "CPUFeatures",
+    "auto_accelerate",
+    "FastWebServer",
+    "simd",
+    "memory",
+]
+__version__ = "0.2.0"

fastpython_native-0.1.0/fastpython/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

fastpython_native-0.1.0/fastpython/api.py

@@ -0,0 +1,185 @@
+"""
+Public API for FastPython.
+Provides decorators and pre-start compilation helpers to turn Python functions
+into hardware-optimized machine code.
+"""
+
+import functools
+import inspect
+import time
+from typing import Callable, Dict, Any, Optional
+
+from .hardware.cpu import get_cpu_info
+from .compiler.toolchain import CompilerToolchain
+from .compiler.cache import ModuleCache
+from .codegen.transpiler import generate_c_extension_source
+
+
+_GLOBAL_TOOLCHAIN: Optional[CompilerToolchain] = None
+_GLOBAL_CACHE: Optional[ModuleCache] = None
+
+
+def get_toolchain() -> CompilerToolchain:
+    global _GLOBAL_TOOLCHAIN
+    if _GLOBAL_TOOLCHAIN is None:
+        _GLOBAL_TOOLCHAIN = CompilerToolchain()
+    return _GLOBAL_TOOLCHAIN
+
+
+def get_cache() -> ModuleCache:
+    global _GLOBAL_CACHE
+    if _GLOBAL_CACHE is None:
+        _GLOBAL_CACHE = ModuleCache()
+    return _GLOBAL_CACHE
+
+
+class AcceleratedFunction:
+    """Wrapper that holds both the original Python function and the compiled native function."""
+    def __init__(
+        self,
+        py_func: Callable[..., Any],
+        type_hints: Optional[Dict[str, Any]] = None,
+        parallel: bool = False,
+        fastmath: bool = True,
+        verbose: bool = True,
+        eager: bool = True,
+        source_code: Optional[str] = None
+    ):
+        self.py_func = py_func
+        self.func_name = getattr(py_func, "__name__", "anonymous")
+        self.type_hints = type_hints or getattr(py_func, "__annotations__", {})
+        self.parallel = parallel
+        self.fastmath = fastmath
+        self.verbose = verbose
+        self.source_code = source_code
+        self.native_func: Optional[Callable[..., Any]] = None
+        self.compilation_time_ms: float = 0.0
+        self.is_compiled: bool = False
+
+        if eager:
+            self._compile_or_load()
+
+    def _compile_or_load(self, sample_args: Optional[tuple] = None):
+        if self.is_compiled:
+            return
+
+        toolchain = get_toolchain()
+        cache = get_cache()
+        cpu = get_cpu_info()
+
+        # Update type hints from sample_args if not specified
+        if sample_args and not self.type_hints:
+            sig = inspect.signature(self.py_func)
+            inferred = {}
+            for param, val in zip(sig.parameters.values(), sample_args):
+                if isinstance(val, int):
+                    inferred[param.name] = "int64_t"
+                elif isinstance(val, float):
+                    inferred[param.name] = "double"
+                elif isinstance(val, bool):
+                    inferred[param.name] = "bool"
+                elif hasattr(val, "__len__") and hasattr(val, "__getitem__"):
+                    inferred[param.name] = "double* __restrict"
+            self.type_hints.update(inferred)
+
+        t0 = time.perf_counter()
+
+        try:
+            # Get source code
+            if self.source_code:
+                raw_source = self.source_code
+            else:
+                try:
+                    raw_source = inspect.getsource(self.py_func)
+                except Exception:
+                    raw_source = ""
+
+            if not raw_source:
+                raise ValueError("Could not determine source code for function")
+
+            # Compute hash from source + settings first
+            meta = f"parallel={self.parallel}_fastmath={self.fastmath}_hints={self.type_hints}"
+            code_hash = cache.compute_hash(raw_source, meta)
+            mod_name = f"native_{self.func_name}_{code_hash}"
+            c_path, pyd_path = cache.get_module_paths(mod_name, code_hash)
+
+            if not cache.is_cached(pyd_path):
+                if self.verbose:
+                    print(f"[FastPython] Compiling '{self.func_name}' for host: {cpu.summary()}...")
+
+                # Generate C source with matching module name
+                c_source = generate_c_extension_source(
+                    self.py_func,
+                    module_name=mod_name,
+                    type_hints=self.type_hints,
+                    parallel=self.parallel,
+                    fastmath=self.fastmath,
+                    source_code=raw_source
+                )
+
+                with open(c_path, "w", encoding="utf-8") as f:
+                    f.write(c_source)
+
+                toolchain.compile_extension(
+                    c_source_path=c_path,
+                    output_pyd_path=pyd_path,
+                    fastmath=self.fastmath,
+                    parallel=self.parallel
+                )
+                elapsed = (time.perf_counter() - t0) * 1000
+                self.compilation_time_ms = elapsed
+                if self.verbose:
+                    print(f"[FastPython] '{self.func_name}' successfully compiled in {elapsed:.1f}ms! Ready for execution.")
+            else:
+                if self.verbose:
+                    print(f"[FastPython] Loading cached native binary for '{self.func_name}' [hash={code_hash}]")
+
+            self.native_func = cache.load_extension(mod_name, pyd_path, self.func_name)
+        except Exception as e:
+            if self.verbose:
+                print(f"[FastPython] Native compilation fallback for '{self.func_name}': {e}. Using pure Python.")
+            self.native_func = None
+
+        self.is_compiled = True
+
+    def __call__(self, *args, **kwargs):
+        if not self.is_compiled:
+            self._compile_or_load(sample_args=args)
+
+        if self.native_func:
+            return self.native_func(*args, **kwargs)
+        return self.py_func(*args, **kwargs)
+
+
+def compile_native(
+    func: Optional[Callable[..., Any]] = None,
+    *,
+    types: Optional[Dict[str, Any]] = None,
+    parallel: bool = False,
+    fastmath: bool = True,
+    verbose: bool = True,
+    eager: bool = True,
+    source_code: Optional[str] = None
+):
+    """
+    Decorator that compiles a Python function into host-native machine code before execution.
+    """
+    def decorator(fn: Callable[..., Any]) -> AcceleratedFunction:
+        wrapper = AcceleratedFunction(
+            py_func=fn,
+            type_hints=types,
+            parallel=parallel,
+            fastmath=fastmath,
+            verbose=verbose,
+            eager=eager,
+            source_code=source_code
+        )
+        functools.update_wrapper(wrapper, fn)
+        return wrapper
+
+    if func is not None:
+        return decorator(func)
+    return decorator
+
+
+accelerate = compile_native

fastpython_native-0.1.0/fastpython/auto.py

@@ -0,0 +1,10 @@
+"""
+FastPython Auto-Import Module.
+Simply writing 'import fastpython.auto' at the top of your main script
+automatically accelerates and AOT-compiles all project modules upon import.
+"""
+
+from .importer import auto_accelerate
+
+# Activate automatically when imported
+auto_accelerate()

fastpython_native-0.1.0/fastpython/cli.py

@@ -0,0 +1,84 @@
+"""
+Command Line Interface for FastPython.
+Allows users to:
+- Inspect host hardware CPU features: python -m fastpython info
+- Run benchmarks: python -m fastpython benchmark
+- Execute accelerated scripts: python -m fastpython run <script.py>
+"""
+
+import sys
+import os
+import argparse
+import runpy
+from pathlib import Path
+from .hardware.cpu import get_cpu_info
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="fastpython",
+        description="FastPython: AOT Hardware-Native Machine Code Acceleration for Python"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # Command: info
+    subparsers.add_parser("info", help="Display host CPU architecture, features, and optimization flags")
+
+    # Command: benchmark
+    subparsers.add_parser("benchmark", help="Run the multi-domain FastPython benchmark suite")
+
+    # Command: run
+    run_parser = subparsers.add_parser("run", help="Execute a Python script with FastPython AOT pre-compilation")
+    run_parser.add_argument("script", help="Path to Python script to execute")
+    run_parser.add_argument("script_args", nargs=argparse.REMAINDER, help="Arguments to pass to script")
+
+    # Command: clear-cache
+    subparsers.add_parser("clear-cache", help="Clear the local .fastpython_cache directory")
+
+    args = parser.parse_args()
+
+    if args.command == "info" or args.command is None and len(sys.argv) == 1:
+        cpu = get_cpu_info()
+        print("=" * 65)
+        print(" FastPython Hardware Profiler")
+        print("=" * 65)
+        print(f" CPU Model:       {cpu.brand}")
+        print(f" Vendor:          {cpu.vendor}")
+        print(f" Architecture:    {cpu.architecture}")
+        print(f" Threads / Cores: {cpu.logical_cores} logical / {cpu.physical_cores} physical")
+        print(f" AVX Support:     AVX={cpu.has_avx}, AVX2={cpu.has_avx2}, AVX-512={cpu.has_avx512f}")
+        print(f" Math Extensions: FMA3={cpu.has_fma}, SSE4.2={cpu.has_sse42}, BMI2={cpu.has_bmi2}")
+        print("-" * 65)
+        print(f" MSVC Flags:      {' '.join(cpu.get_msvc_flags())}")
+        print(f" GCC Flags:       {' '.join(cpu.get_gcc_flags())}")
+        print("=" * 65)
+
+    elif args.command == "benchmark":
+        bench_script = Path(__file__).resolve().parent.parent / "benchmarks" / "run_all_benchmarks.py"
+        runpy.run_path(str(bench_script), run_name="__main__")
+
+    elif args.command == "clear-cache":
+        cache_dir = Path.cwd() / ".fastpython_cache"
+        if cache_dir.exists():
+            import shutil
+            shutil.rmtree(cache_dir)
+            print(f"Cleared cache at: {cache_dir}")
+        else:
+            print("No cache directory found.")
+
+    elif args.command == "run":
+        target_script = Path(args.script).resolve()
+        if not target_script.exists():
+            print(f"Error: Script '{args.script}' not found.")
+            sys.exit(1)
+
+        # Set sys.argv for the target script
+        sys.argv = [str(target_script)] + args.script_args
+        sys.path.insert(0, str(target_script.parent))
+
+        # Execute script
+        runpy.run_path(str(target_script), run_name="__main__")
+
+
+if __name__ == "__main__":
+    main()

fastpython_native-0.1.0/fastpython/codegen/__init__.py

@@ -0,0 +1,3 @@
+from .transpiler import PythonToCTranspiler, generate_c_extension_source, TranspileError
+
+__all__ = ["PythonToCTranspiler", "generate_c_extension_source", "TranspileError"]