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.
