fastpython-native 0.2.0__py3-none-any.whl → 0.2.3__py3-none-any.whl

fastpython/__init__.py

@@ -22,4 +22,4 @@ __all__ = [
     "simd",
     "memory",
 ]
-__version__ = "0.2.0"
+__version__ = "0.2.3"

fastpython/api.py

@@ -4,10 +4,12 @@ Provides decorators and pre-start compilation helpers to turn Python functions
 into hardware-optimized machine code.
 """
 
+from __future__ import annotations
+
 import functools
 import inspect
 import time
-from typing import Callable, Dict, Any, Optional
+from typing import Callable, Dict, Any, Optional, Tuple
 
 from .hardware.cpu import get_cpu_info
 from .compiler.toolchain import CompilerToolchain

fastpython/cli.py

@@ -76,8 +76,27 @@ def main():
         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__")
+        from .importer import auto_accelerate, transform_source
+        auto_accelerate(project_dir=str(target_script.parent), verbose=True)
+
+        with open(target_script, "r", encoding="utf-8") as f:
+            src = f.read()
+
+        try:
+            tree, candidates = transform_source(src, str(target_script), verbose=True)
+            if candidates:
+                cpu = get_cpu_info()
+                print(f"[FastPython.Run] Pre-accelerated {len(candidates)} functions in '{target_script.name}': {', '.join(candidates)}")
+            code = compile(tree, str(target_script), "exec")
+            globs = {
+                "__name__": "__main__",
+                "__file__": str(target_script),
+                "__builtins__": __builtins__,
+                "_FASTPYTHON_MAIN_ACCELERATED": True
+            }
+            exec(code, globs)
+        except Exception:
+            runpy.run_path(str(target_script), run_name="__main__")
 
 
 if __name__ == "__main__":

fastpython/codegen/transpiler.py

@@ -89,6 +89,12 @@ class PythonToCTranspiler(ast.NodeVisitor):
         # Check return annotation
         if node.returns:
             self.return_type = self._resolve_type_annotation(node.returns)
+        elif "return" not in self.type_hints:
+            # Infer return type from return statements if possible
+            for stmt in ast.walk(node):
+                if isinstance(stmt, ast.Return) and stmt.value is not None:
+                    self.return_type = self._infer_expr_type(stmt.value)
+                    break
 
         # Process function body
         for stmt in node.body:
@@ -260,6 +266,13 @@ class PythonToCTranspiler(ast.NodeVisitor):
         left = self.visit(node.left)
         right = self.visit(node.right)
         if isinstance(node.op, ast.Pow):
+            if isinstance(node.right, ast.Constant):
+                if node.right.value == 2:
+                    return f"(({left}) * ({left}))"
+                elif node.right.value == 3:
+                    return f"(({left}) * ({left}) * ({left}))"
+                elif node.right.value == 0.5:
+                    return f"sqrt((double)({left}))"
             return f"pow((double)({left}), (double)({right}))"
         elif isinstance(node.op, ast.FloorDiv):
             return f"((int64_t)({left}) / (int64_t)({right}))"

fastpython/importer.py

@@ -1,7 +1,8 @@
 """
 Automatic Project Importer & AST Hook for FastPython.
-Intercepts imports of project modules, detects computational functions,
+Intercepts imports of project modules, detects computational functions (at root or nested),
 and compiles them Ahead-of-Time (AOT) to hardware-native machine code.
+Also auto-accelerates the main script (__main__) when imported at the top of the entry point.
 """
 
 import sys
@@ -10,7 +11,7 @@ import ast
 from pathlib import Path
 from importlib.abc import MetaPathFinder, Loader
 from importlib.machinery import ModuleSpec
-from typing import Optional, List, Set
+from typing import Optional, List, Set, Tuple
 
 from .hardware.cpu import get_cpu_info
 
@@ -35,6 +36,57 @@ def is_acceleration_candidate(node: ast.FunctionDef) -> bool:
     return has_loop or (has_arithmetic and len(node.body) > 1)
 
 
+class AutoAccelerateTransformer(ast.NodeTransformer):
+    """
+    AST transformer that walks the entire syntax tree (including nested blocks,
+    if __name__ == '__main__': blocks, and classes) and decorates eligible
+    computational functions with FastPython native compilation.
+    """
+    def __init__(self, verbose: bool = True):
+        self.candidates: List[str] = []
+        self.verbose = verbose
+
+    def visit_FunctionDef(self, node: ast.FunctionDef):
+        self.generic_visit(node)
+
+        already_decorated = False
+        for dec in node.decorator_list:
+            if isinstance(dec, ast.Name) and "compile" in dec.id.lower():
+                already_decorated = True
+            elif isinstance(dec, ast.Call) and isinstance(dec.func, ast.Name) and "compile" in dec.func.id.lower():
+                already_decorated = True
+
+        if not already_decorated and is_acceleration_candidate(node):
+            self.candidates.append(node.name)
+            call_node = ast.Call(
+                func=ast.Name(id="_fastpython_compile", ctx=ast.Load()),
+                args=[],
+                keywords=[
+                    ast.keyword(arg="fastmath", value=ast.Constant(value=True)),
+                    ast.keyword(arg="verbose", value=ast.Constant(value=self.verbose)),
+                ]
+            )
+            node.decorator_list.insert(0, call_node)
+
+        return node
+
+
+def transform_source(source: str, filename: str, verbose: bool = True) -> Tuple[ast.AST, List[str]]:
+    """Parses Python source, applies AutoAccelerateTransformer across all scopes, and injects imports."""
+    tree = ast.parse(source, filename=filename)
+    transformer = AutoAccelerateTransformer(verbose=verbose)
+    transformer.visit(tree)
+    if transformer.candidates:
+        import_stmt = ast.ImportFrom(
+            module="fastpython",
+            names=[ast.alias(name="compile_native", asname="_fastpython_compile")],
+            level=0
+        )
+        tree.body.insert(0, import_stmt)
+        ast.fix_missing_locations(tree)
+    return tree, transformer.candidates
+
+
 class FastPythonLoader(Loader):
     def __init__(self, fullname: str, filepath: str, verbose: bool = True):
         self.fullname = fullname
@@ -51,40 +103,14 @@ class FastPythonLoader(Loader):
             source = f.read()
 
         try:
-            tree = ast.parse(source, filename=self.filepath)
+            tree, candidates = transform_source(source, self.filepath, verbose=self.verbose)
         except Exception:
-            # Fall back to standard execution if parsing fails
             exec(compile(source, self.filepath, "exec"), module.__dict__)
             return
 
-        candidates: List[str] = []
-        for node in tree.body:
-            if isinstance(node, ast.FunctionDef) and is_acceleration_candidate(node):
-                candidates.append(node.name)
-                # Inject decorator: @_fastpython_compile(fastmath=True)
-                call_node = ast.Call(
-                    func=ast.Name(id="_fastpython_compile", ctx=ast.Load()),
-                    args=[],
-                    keywords=[
-                        ast.keyword(arg="fastmath", value=ast.Constant(value=True)),
-                        ast.keyword(arg="verbose", value=ast.Constant(value=self.verbose)),
-                    ]
-                )
-                node.decorator_list.insert(0, call_node)
-
-        if candidates:
-            if self.verbose:
-                cpu = get_cpu_info()
-                print(f"[FastPython.Auto] Accelerating module '{self.fullname}' ({len(candidates)} functions: {', '.join(candidates)}) for {cpu.brand.strip()}...")
-
-            # Inject import of compile_native at top of module
-            import_stmt = ast.ImportFrom(
-                module="fastpython",
-                names=[ast.alias(name="compile_native", asname="_fastpython_compile")],
-                level=0
-            )
-            tree.body.insert(0, import_stmt)
-            ast.fix_missing_locations(tree)
+        if candidates and self.verbose:
+            cpu = get_cpu_info()
+            print(f"[FastPython.Auto] Accelerating module '{self.fullname}' ({len(candidates)} functions: {', '.join(candidates)}) for {cpu.brand.strip()}...")
 
         code_obj = compile(tree, filename=self.filepath, mode="exec")
         exec(code_obj, module.__dict__)
@@ -176,17 +202,42 @@ _HOOK_INSTALLED = False
 def auto_accelerate(project_dir: Optional[str] = None, verbose: bool = True):
     """
     Installs the FastPython automatic compilation hook.
-    Every module imported in the project will be analyzed and compiled AOT into
-    hardware-native machine code before execution.
+    Every module imported in the project, as well as the main script entry point,
+    will be analyzed and compiled AOT into hardware-native machine code before execution.
     """
     global _HOOK_INSTALLED
-    if _HOOK_INSTALLED:
-        return
 
     root = project_dir or os.getcwd()
-    finder = FastPythonFinder(project_root=root, verbose=verbose)
-    sys.meta_path.insert(0, finder)
-    _HOOK_INSTALLED = True
-    if verbose:
-        cpu = get_cpu_info()
-        print(f"[FastPython.Auto] Hook active for project '{root}'. Hardware: {cpu.summary()}")
+
+    if not _HOOK_INSTALLED:
+        finder = FastPythonFinder(project_root=root, verbose=verbose)
+        sys.meta_path.insert(0, finder)
+        _HOOK_INSTALLED = True
+        if verbose:
+            cpu = get_cpu_info()
+            print(f"[FastPython.Auto] Hook active for project '{root}'. Hardware: {cpu.summary()}")
+
+    # Check if imported directly from __main__ entry point script
+    try:
+        f = sys._getframe(1)
+        while f:
+            globs = f.f_globals
+            if globs.get("__name__") == "__main__":
+                main_file = globs.get("__file__")
+                if main_file and os.path.isfile(main_file) and not globs.get("_FASTPYTHON_MAIN_ACCELERATED"):
+                    globs["_FASTPYTHON_MAIN_ACCELERATED"] = True
+                    with open(main_file, "r", encoding="utf-8") as fp:
+                        main_source = fp.read()
+                    tree, candidates = transform_source(main_source, main_file, verbose=verbose)
+                    if candidates:
+                        if verbose:
+                            cpu = get_cpu_info()
+                            print(f"[FastPython.Auto] Accelerating main script '{Path(main_file).name}' ({len(candidates)} functions: {', '.join(candidates)}) for {cpu.brand.strip()}...")
+                        code_obj = compile(tree, filename=main_file, mode="exec")
+                        exec(code_obj, globs)
+                        sys.exit(0)
+                break
+            f = f.f_back
+    except Exception as e:
+        import traceback
+        traceback.print_exc()

fastpython/memory/__init__.py

@@ -1,4 +1,14 @@
-from .aligned_mem import allocate, AlignedBuffer
+try:
+    from .aligned_mem import allocate, AlignedBuffer
+except (ImportError, Exception):
+    def allocate(size, alignment=64):
+        return bytearray(size)
+    class AlignedBuffer:
+        def __init__(self, size, alignment=64):
+            self.buf = bytearray(size)
+        def __len__(self):
+            return len(self.buf)
+
 from .arena import BumpArena
 
 __all__ = ["allocate", "AlignedBuffer", "BumpArena"]

fastpython/memory/arena.py

@@ -4,7 +4,17 @@ Replaces heap malloc/free cycles with instantaneous O(1) pointer bumps.
 """
 
 from typing import Optional
-from .aligned_mem import allocate, AlignedBuffer
+
+try:
+    from .aligned_mem import allocate, AlignedBuffer
+except (ImportError, Exception):
+    def allocate(size, alignment=64):
+        return bytearray(size)
+    class AlignedBuffer:
+        def __init__(self, size, alignment=64):
+            self.buf = bytearray(size)
+        def __len__(self):
+            return len(self.buf)
 
 
 class BumpArena:

fastpython/server/__init__.py

@@ -1,6 +1,10 @@
 import time
 from typing import Optional, Dict, Any
-from . import native_server
+
+try:
+    from . import native_server
+except (ImportError, Exception):
+    native_server = None
 
 
 class FastWebServer:
@@ -16,16 +20,21 @@ class FastWebServer:
 
     def start(self):
         if not self.is_running:
-            native_server.start(self.port, self.threads)
-            self.is_running = True
+            if native_server is not None:
+                native_server.start(self.port, self.threads)
+                self.is_running = True
+            else:
+                raise RuntimeError("FastWebServer native server module is not built for this Python environment.")
 
     def stop(self):
-        if self.is_running:
+        if self.is_running and native_server is not None:
             native_server.stop()
             self.is_running = False
 
     def stats(self) -> Dict[str, Any]:
-        return native_server.get_stats()
+        if native_server is not None:
+            return native_server.get_stats()
+        return {}
 
     def __enter__(self):
         self.start()

fastpython/simd/__init__.py

@@ -1,4 +1,16 @@
-from .fast_simd import find_char, find_crlf, parse_http_request, dumps
+try:
+    from .fast_simd import find_char, find_crlf, parse_http_request, dumps
+except (ImportError, Exception):
+    import json
+    def dumps(obj):
+        return json.dumps(obj)
+    def find_char(buf, char):
+        return buf.find(char)
+    def find_crlf(buf):
+        return buf.find(b"\r\n")
+    def parse_http_request(req):
+        return {}
+
 from .fast_json import fast_scan_keys
 
 __all__ = ["find_char", "find_crlf", "parse_http_request", "dumps", "fast_scan_keys"]

fastpython/simd/fast_json.py

@@ -4,7 +4,17 @@ Leverages AVX2 vector registers to parse JSON documents at multi-gigabyte/sec th
 """
 
 from typing import Any, Dict, List, Union
-from .fast_simd import dumps as fast_dumps, find_char, find_crlf
+
+try:
+    from .fast_simd import dumps as fast_dumps, find_char, find_crlf
+except (ImportError, Exception):
+    import json
+    def fast_dumps(obj):
+        return json.dumps(obj)
+    def find_char(buf, char):
+        return buf.find(char)
+    def find_crlf(buf):
+        return buf.find(b"\r\n")
 
 
 def fast_scan_keys(json_bytes: bytes) -> Dict[str, Union[int, float, str, bool, None]]:

{fastpython_native-0.2.0.dist-info → fastpython_native-0.2.3.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: fastpython-native
-Version: 0.2.0
+Version: 0.2.3
 Summary: AOT Hardware-Adaptive Native Machine Code Compiler for Python
-Author: FastPython Team
+Author: alex9347
 Keywords: compiler,performance,aot,simd,avx2,jit,optimization
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Microsoft :: Windows

{fastpython_native-0.2.0.dist-info → fastpython_native-0.2.3.dist-info}/RECORD

@@ -1,29 +1,29 @@
-fastpython/__init__.py,sha256=hn1Vl9J1xUfjzP3fFZXW16ILnfHRqmcebtTif-Ie-NA,583
+fastpython/__init__.py,sha256=ZLYZPgE1RLUPl7djtVM2llzhMITq5CmLMkxqvL377QM,583
 fastpython/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
-fastpython/api.py,sha256=ZXSTpYrUqnrCEnc1nx8LqbF9g6X-ePUNZ2RPCzrQCu8,6887
+fastpython/api.py,sha256=Urm-aEzv_ohMmEHBbgpKpvsb3NPFf2k1-lvN8dWfz-U,6930
 fastpython/auto.py,sha256=aHFcXX8gijt01sYlbZymyS4wSzXFZHLLeGvtB1u30OM,283
-fastpython/cli.py,sha256=5ezV99gntwqJNOnNzaVSYLmVXhOCd0Aa7iRm-GCbmnQ,3184
-fastpython/importer.py,sha256=pq0ghgpK2qFdIIFVv97klm6oeXZcuKgZFZl9JRSpgVg,7275
+fastpython/cli.py,sha256=BRLhrNabnlSY9Xsod6Ji3gboWhFGDXtFRO1zHmOkZlY,4037
+fastpython/importer.py,sha256=8dHjkPMgSs0lCHo06ReHArx-N6xzeSj1lo4hf-PSTPc,9650
 fastpython/jit.py,sha256=3LyZ-HZvs5uS_rssvSrvKz5aArplz8ZiaRQ1sKcFRDU,922
 fastpython/accelerators/fast_raytracer.c,sha256=r5Uf3aOIL72c8MzDRRAfTG08q8uGRLvEX_7taHRY1N4,10854
 fastpython/accelerators/raytracer.py,sha256=IAPf2luONvkSj3rWET1vSBC6t6mizMoYoDCdNiSuQMI,5648
 fastpython/codegen/__init__.py,sha256=fqqGp_3A9TwzdnC8vWKyfe3zwN6YLPSt_ZnG_DmtzPA,173
-fastpython/codegen/transpiler.py,sha256=r-P50B1ZTZw0WqWqA2ycVXPtUMxzpcA04hYBYXWmB9A,20330
+fastpython/codegen/transpiler.py,sha256=KXRVJgOyFelrNuEm7XaI-DWby5JYdfXwoA51UGl4Gf0,21011
 fastpython/compiler/__init__.py,sha256=oQfnYP3KTfl6Nyr8rBWmTwUGCPqvjIVgo-qzbsiI_r0,158
 fastpython/compiler/cache.py,sha256=l-7CMjWzqaxfKEKdYhgzVBmWjoRVkf0cnr_iP-zNmS0,2269
 fastpython/compiler/toolchain.py,sha256=LDVH4LyoRW3r5ooTaYntGUJRz2pPbbK3treOk3CAxFM,5037
 fastpython/hardware/__init__.py,sha256=moeI5cy5Rb_owglRaUktFwHLF-8fiLQOE7sISpDsA6I,86
 fastpython/hardware/cpu.py,sha256=g68IdKvmZeZhl59q23rE2YcG5AsXxmrMt8fsSWTTDco,7383
-fastpython/memory/__init__.py,sha256=aGD04hLevPOtCVWt3BOEg5ZycekyiXuiXI1dcSJ6bR4,132
+fastpython/memory/__init__.py,sha256=tVzju63avhsALJU6gpZYBJJOIIttVEd1zBRAlkPnUic,416
 fastpython/memory/aligned_mem.c,sha256=sYEfnOmuwpBeXca-mNX3EwlVgvAL5S6JzZWLh712Mq8,3318
-fastpython/memory/arena.py,sha256=34ZwW-d6FjA7940ZIOxZz99iJupJBxn_KjCFsFYintk,1635
-fastpython/server/__init__.py,sha256=uLFW9kKwxc0mlBalIDzDJc-zCTCgVVvIueofR8knrD0,979
+fastpython/memory/arena.py,sha256=1qRA5AuTKshM-q9XRwkk6MPFKV_0klc_3ChKPlLSrgg,1919
+fastpython/server/__init__.py,sha256=TYX33EDgngQB-E5BBVFRE_u0vn9tGJOcqcuwDBJIzk8,1320
 fastpython/server/native_server.c,sha256=LupO6CkSy1f01297ILWzf_eN7lOWwtiY1ACn1KtUEHw,7195
-fastpython/simd/__init__.py,sha256=txxoUEhe5Fq67Vh1pdXFYBWXk4Q3l1MmLa76pRltKBc,196
-fastpython/simd/fast_json.py,sha256=BV63OYI0sY7q_MUYhuol-s4RHpCvZMFz8lZsyBD6uCU,2191
+fastpython/simd/__init__.py,sha256=ID-MWvL0UYooW-DnZLdPNv6IzXxNlfNCxWHVbCD-ln4,474
+fastpython/simd/fast_json.py,sha256=lr7Y9XMJDF7_4R5nBuiJ641_yfBRXwxHt-KDchhrjPI,2423
 fastpython/simd/fast_simd.c,sha256=zltkJBr-Jx1kWFWfmLBuzhkizYOhYGRxpVtACnV5csc,9446
-fastpython_native-0.2.0.dist-info/METADATA,sha256=uHTsQWjJJisl2HgihnvPsukSa15TfMTXVZzpZPeZAYE,10736
-fastpython_native-0.2.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-fastpython_native-0.2.0.dist-info/entry_points.txt,sha256=IGbP7VbTQmM-57joccriVqB2ieX5uU4u0K5k49HvhE0,51
-fastpython_native-0.2.0.dist-info/top_level.txt,sha256=XjyQFL6KqwXjTwH8faHiYGaSiNuJMpZ2ChIn64covz4,11
-fastpython_native-0.2.0.dist-info/RECORD,,
+fastpython_native-0.2.3.dist-info/METADATA,sha256=0Dy7C2TGqEoaM3svPiKAUrLXB3tue8RDOhFBYWF4e6Y,10729
+fastpython_native-0.2.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+fastpython_native-0.2.3.dist-info/entry_points.txt,sha256=IGbP7VbTQmM-57joccriVqB2ieX5uU4u0K5k49HvhE0,51
+fastpython_native-0.2.3.dist-info/top_level.txt,sha256=XjyQFL6KqwXjTwH8faHiYGaSiNuJMpZ2ChIn64covz4,11
+fastpython_native-0.2.3.dist-info/RECORD,,