fastpython-native 0.1.0__py3-none-any.whl

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/__main__.py

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

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/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/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/codegen/__init__.py

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