Sync from GitHub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+gradio_dashboard.jpg filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,216 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer,
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Generated Scripts
+**activate-*-env.*
+
+# Extension generation and testing files
+*.c
+*.pyd
+setup.py
+usage_example.py

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Carlos Bazaga
+
+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.

Pipfile

@@ -0,0 +1,36 @@
+[[source]]
+name = "pypi"
+verify_ssl = true
+url = "https://pypi.org/simple"
+
+[packages]
+# Environment.
+python-dotenv = "*"
+# Networking.
+requests = "*"
+# Models SDK.
+openai = "*"
+# UI Framework.
+gradio = "*"
+
+
+[dev-packages]
+# Formatters.
+isort = "*"
+# Linters.
+mypy = "*"
+mccabe = "*"
+pyflakes = "*"
+pydocstyle = "*"
+pycodestyle = "*"
+# Testing.
+pytest = "*"
+coverage = "*"
+# Interactive Notebook.
+ipykernel = "*"
+ipywidgets = "*"
+# Build Tools.
+setuptools = "*"
+
+[requires]
+python_version = "3.13"

README.md

@@ -1,15 +1,220 @@
 ---
-title: Python C-extensions
-emoji: 📚
-colorFrom: yellow
-colorTo: green
+title: Python C Extension Generator
+app_file: app.py
 sdk: gradio
 sdk_version: 6.14.0
-python_version: '3.13'
-app_file: app.py
-pinned: false
 license: mit
-short_description: High-performance Python C Extension code generator from Pyth
+emoji: 🐉
+colorFrom: blue
+colorTo: green
+short_description: High-performance Python C Extension generator from Python.
+pinned: true
+thumbnail: >-
+  https://cdn-uploads.huggingface.co/production/uploads/67caf50af30e4fe450042ac4/GBtJw_6f8kKFbPaAi6dXk.png
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Python C Extension code generator
+
+A Gradio app that provides an interactive interface for users to input Python code and
+generate C extension code
+
+Optionally, a compile and eval stage can be activated for local deployments to compare
+its performance against the original Python code.
+
+> [!CAUTION]
+>
+> **Always review the generated codes before running them, as they will be executed in
+> your local environment and may contain code that could be harmful or unwanted.**
+>
+> AI-generated code may contain errors or unsafe practices, so it's crucial to
+> thoroughly review and test on a sandboxed environment any code before using it in a
+> production environment.
+>
+> Never run code generated by AI models without understanding its implications and
+> ensuring it adheres to your security and safety standards.
+
+> [!IMPORTANT]
+>
+> **Disclaimer:** This App and Notebook are provided for educational purposes only.
+> Use it at your own risk.
+
+### Installation
+
+* Install the required Python dependencies:
+
+  ```bash
+  pip install -r requirements.txt
+  ```
+
+* Or, if you prefer Pipenv:
+
+  ```bash
+  pipenv install
+  ```
+
+### Configuration
+
+The app reads configuration from environment variables and from a `.env` file if present.
+
+* `MODELS`: Colon-separated list of models to expose in the dropdown.\
+  Example:
+
+  ```bash
+  export MODELS="gpt-5.1-codex-mini:gpt-5.4-mini"
+  ```
+
+  ```powershell
+  $env:MODELS = "gpt-5.1-codex-mini:gpt-5.4-mini"
+  ```
+
+  If not set, the app defaults to `gpt-5.1-codex-mini` and `gpt-5.4-mini`.
+
+* `COMPILE_STAGE`: Set to `true`, `1`, or `yes` to enable the compile and test stage.\
+  Example:
+
+  ```bash
+  export COMPILE_STAGE=true
+  ```
+
+  ```powershell
+  $env:COMPILE_STAGE = "true"
+  ```
+
+### Running locally
+
+* Run the app locally with:
+
+  ```bash
+  python app.py
+  ```
+
+* For autoreload during development, use the Gradio CLI:
+
+  ```bash
+  gradio app.py
+  ```
+
+### Gradio app overview
+
+In this image, you can see the Gradio app dashboard whose main sections are
+described below.
+
+![Gradio app dashboard](gradio_dashboard.jpg)\
+*Image: Gradio app dashboard with default example `hello world` code loaded.*
+*(compile output redacted for privacy)*
+
+Sections:
+
+* **Dropdown selectors and input fields**:
+  * **Module name input**:
+    A text input field where users can specify the name of the C extension module to be
+    generated.
+
+    That name will be used to create the C extension file `<module_name>.c` and
+    the `setup.py` file required to compile the extension.
+
+    That name will also be used to import the compiled module as usual in Python:
+
+    ```python
+    import <module_name>
+    ```
+
+    Or
+
+    ```python
+    from <module_name> import <function_name>
+    ```
+
+  * **Model selector**:
+    A dropdown menu to select the model used for code generation.
+
+    The available options are taken from the `MODELS` environment variable if set.
+    Otherwise the app defaults to `gpt-5.1-codex-mini` and `gpt-5.4-mini`.
+
+  * **Platform selector**:
+    A dropdown menu to select the target platform for the generated C extension.
+
+    This affects how the app frames the prompt for the model and ensures the
+    generated code targets the selected platform (`Windows` or `Linux`).
+
+  * **Examples selector**:
+    A list of ready-made Python examples to load into the input field.
+
+    Built-in examples include `Hello world`, `Sum array`, `Fibonacci`, `Leibniz pi`,
+    and `Max subarray sum`.
+
+* **Text input areas**:
+
+  These areas are all editable, including those filled with generated code by the model.
+  This allows users to modify and experiment with the code as needed.
+
+  * **Python code**:
+    A text area where users can input their Python code.
+
+    > [!NOTE]
+    >
+    > We are creating an importable module not an executable program so the code to be
+    > optimized must contain only declarations such as DEF or CLASS.
+
+  * **C extension code**:
+    A text area that displays the generated C extension code.
+  * **Compilation code**:
+    A text area that shows the generated `setup.py` code.
+    This file is required to compile the C extension.
+  * **Test compare code**:
+    A text area that provides example code to run the compiled C extension.
+
+* **Output areas**:
+
+  These are non-editable areas that display the results of various operations.
+
+  * **C Extension result**:
+    A text area that displays the output of the C extension code build.
+
+    Beware that this area can contain a large amount of text including warnings during
+    the compilation process and sensible information about the local environment,
+    like: paths, Python version, etc may be included.
+
+    Redact that information if you plan to share the output.
+
+  * **Test result**:
+    A text area that displays the output of the test code run.
+
+* **Buttons**:
+  * **Generate extension code**:
+    A button that triggers the generation of the C extension code from the provided
+    Python code.
+
+    It will call the model to generate the C code, the setup.py file and the test code,
+    filling the corresponding text areas automatically.
+
+  * **Compile extension**:
+    A button that compiles the generated C extension using the provided `setup.py` file.
+    It will create the extension C file, `<module_name>.c`, and the `setup.py` file in
+    the local folder, then it will run the compilation command and build the C extension,
+    `<module_name>.<arch_info>.pyd`.\
+    *`arch_info` represents architecture info the extension has been compiled for:*
+
+    * `hello_world.cp313-win_amd64.pyd`: CPython 3.13 + Windows + Amd64 Architecture.
+
+    > [!CAUTION]
+    >
+    > **Always review the `setup.py` code before running it, as it will be executed in
+    > your local environment and may contain code that could be harmful or unwanted.**
+    >
+    > **Also review the generated C code, as it will be compiled and executed in your
+    > local environment and may contain code that could be harmful or unwanted.**
+
+    It will display the compilation output in the "C Extension result" area.
+
+  * **Test code**:
+    A button that executes the test code to compare the performance of the original
+    Python code and the generated C extension.
+
+    > [!CAUTION]
+    >
+    > **Always review the test code before running it, as it will be executed in
+    > your local environment and may contain code that could be harmful or unwanted.**
+
+    Will save the test code provided in the "Test compare code" into the
+    `usage_example.py` file and execute it, showing the output in the "Test result" area.

app.py

@@ -0,0 +1,11 @@
+"""Entrypoint wrapper for Hugging Face Spaces. Delegates to src/__main__.py."""
+
+from src.__main__ import main
+
+
+# HBD: We assign the 'app' to 'demo' to allow watch autoreload:
+# 'demo' is required to be defined at the global scope for reload to work in Gradio.
+# Initial warnings may appear at launch with 'gradio app.py' because 'demo' will not
+# exists until the app service ends inside main, but it will do when reload requires it,
+# once the service has been stopped.
+demo = main()

requirements.txt

@@ -0,0 +1,4 @@
+python-dotenv
+requests
+gradio
+openai

ruff.toml

@@ -0,0 +1,9 @@
+line-length = 89
+
+[lint]
+select = ["E", "D", "W"]
+ignore = ["D203", "D204", "D208", "D213"]
+
+[lint.per-file-ignores]
+"*.ipynb" = ["ALL"]
+"*.interactive" = ["ALL"]

setup.cfg

@@ -0,0 +1,22 @@
+[isort]
+line_length = 89
+multi_line_output = 9
+lines_after_imports = 2
+known_first_party = src
+
+[mypy]
+implicit_optional = True
+ignore_missing_imports = True
+explicit_package_bases = True
+disable_error_code = import-untyped
+
+[pycodestyle]
+max-line-length = 89
+ignore = E133, W503
+
+[pydocstyle]
+ignore = D203, D204, D208, D213
+
+[pylint.MESSAGES CONTROL]
+disable = W1203, W0718
+# disable = logging-fstring-interpolation, broad-exception-caught

src/__init__.py

@@ -0,0 +1,18 @@
+"""Initialization module for the AI Python C Extensions Generator application."""
+
+from logging import basicConfig, getLogger
+
+from dotenv import load_dotenv
+
+
+# Environment initialization.
+load_dotenv(override=True)
+
+# Setup the global logger.
+LOG_STYLE = '{'
+LOG_LEVEL = 'INFO'
+LOG_FORMAT = ('{asctime} {levelname:<8} {processName}({process}) '
+              '{threadName} {name} {lineno} "{message}"')
+basicConfig(level=LOG_LEVEL, style='{', format=LOG_FORMAT)
+
+getLogger(__name__).info('INITIALIZED AI PYTHON C EXTENSIONS GENERATOR')

src/__main__.py

@@ -0,0 +1,50 @@
+"""Main entrypoint module for the AI Python C Extensions Generator application."""
+
+from logging import getLogger
+from os import getenv
+from sys import platform
+
+from .compiler import compile_extension
+from .interface import get_interface
+from .optimizer import optimize_gpt as optimize_function
+from .tester import test_extension
+
+
+_logger = getLogger(__name__)
+
+# Default models list
+DEFAULT_MODELS = ["gpt-5.1-codex", "gpt-5.4"]  # Expensive.
+DEFAULT_MODELS = ["gpt-5.1-codex-mini", "gpt-5.4-mini"]  # Cheap.
+
+# Read available models from environment variable or use defaults
+models = models_env.split(":") if (models_env := getenv("MODELS")) else DEFAULT_MODELS
+
+# Detect system platform for default selection.
+if platform == "win32":
+    default_platform = "Windows"
+else:
+    default_platform = "Linux"
+
+# Read compile stage flag from environment variable, defaulting to False if not set.
+compile_stage = getenv("COMPILE_STAGE", "False").lower() in ("true", "1", "yes")
+
+
+def main():
+    """Launch the AI Python C Extensions Generator application."""
+    _logger.info('STARTING AI PYTHON C EXTENSIONS GENERATOR...')
+    _logger.info(f'AVAILABLE MODELS: {models}')
+    # Prepare the interface configuration based.
+    interface_config = {"models": models, "compile_stage": compile_stage,
+                        "optimize_function": optimize_function}
+    if compile_stage:
+        _logger.info('COMPILE STAGE ENABLED')
+        interface_config.update({"compile_extension": compile_extension,
+                                 "test_extension": test_extension})
+    app = get_interface(**interface_config)
+    app.launch(footer_links=[])
+    # We return the app instance for potential use in autoreload scenarios.
+    return app
+
+
+if __name__ == '__main__':
+    main()

src/compiler.py

@@ -0,0 +1,62 @@
+"""Compilation and tests module for the AI Python C Extensions Generator application."""
+
+import os
+import subprocess
+import sys
+from logging import getLogger
+
+
+_logger = getLogger(__name__)
+
+
+# Define a function to write outputs to a file with a given filename.
+def write_file(data, filename):
+    """Write data to a file with the specified filename."""
+    with open(filename, "w") as file:
+        file.write(data)
+
+
+# Extension compilation function.
+def build_extension():
+    """Compile the C extension using 'setup.py' and return the compilation output."""
+    # Set default COMSPEC to cmd.exe on Windows to avoid issues with some C compilers.
+    if sys.platform == "win32":
+        _logger.info('PATCHING COMSPEC FOR WINDOWS COMPILATION COMPATIBILITY...')
+        preset_comspec = os.environ.get("COMSPEC")
+        os.environ["COMSPEC"] = "C:\\Windows\\System32\\cmd.exe"
+    try:
+        _logger.info('STARTING COMPILATION PROCESS...')
+        compile_cmd = ["python", "setup.py", "build_ext", "--inplace"]
+        compile_result = subprocess.run(compile_cmd, env=os.environ,
+                                        check=True, text=True, capture_output=True)
+    except subprocess.CalledProcessError as ex:
+        _logger.error(f"COMPILATION FAILED WITH ERROR:\n{ex.stdout}\n{ex.stderr}")
+        raise Exception(f"An error occurred while building:\n{ex.stdout}\n{ex.stderr}")
+    finally:
+        # Restore original COMSPEC on Windows.
+        if sys.platform == "win32":
+            _logger.info('RESTORING ORIGINAL COMSPEC...')
+            os.environ["COMSPEC"] = preset_comspec
+    _logger.info('COMPILATION COMPLETED SUCCESSFULLY.')
+    return compile_result.stdout
+
+
+# Extension compilation function.
+def compile_extension(c_code, setup_code, module_name):
+    """Build the C extension from the provided codes."""
+    try:  # Write the provided codes to their respective files.
+        _logger.info('WRITING GENERATED C CODE TO FILE...')
+        write_file(c_code, f"{module_name}.c")
+        _logger.info('WRITING GENERATED SETUP CODE TO FILE...')
+        write_file(setup_code, "setup.py")
+    except Exception as ex:
+        _logger.error(f"ERROR WHILE WRITING FILES:\n{ex}")
+        return f"An error occurred while writing files:\n{ex}"
+    try:  # Build the extension and capture the output.
+        _logger.info('BUILDING THE EXTENSION...')
+        build_output = build_extension()
+    except Exception as ex:  # If build fails, return the error message.
+        _logger.error(f"ERROR WHILE BUILDING EXTENSION:\n{ex}")
+        return str(ex)
+    _logger.info('EXTENSION BUILT SUCCESSFULLY.')
+    return build_output

src/examples.py

@@ -0,0 +1,76 @@
+"""Example codes for the AI Python C Extensions Generator application."""
+
+# Prints 'Hello, World!' from a Python function.
+example_hello_world = """
+def hello_world():
+    print("Hello, World!")
+"""
+
+# Iterates over an array and returns the sum of all its elements.
+example_sum = """
+def array_sum(arr):
+    total = 0
+    for x in arr:
+        total += x
+    return total
+"""
+
+# Returns the nth Fibonacci number using an iterative approach.
+example_fibonacci = """
+def fibonacci(n):
+    a, b = 0, 1
+    for _ in range(n):
+        a, b = b, a + b
+    return a
+"""
+
+# Approximates π using the Leibniz alternating series formula.
+example_leibniz_pi = """
+def leibniz_pi(iterations):
+    result = 1.0
+    for i in range(1, iterations + 1):
+        j = i * 4 - 1
+        result -= (1 / j)
+        j = i * 4 + 1
+        result += (1 / j)
+    return result * 4
+"""
+
+# Finds the total maximum subarray sum over 20 runs using LCG RNG.
+# * <https://en.wikipedia.org/wiki/Maximum_subarray_problem>
+example_subarray = """
+def lcg(seed, a=1664525, c=1013904223, m=2**32):
+    value = seed
+    while True:
+        value = (a * value + c) % m
+        yield value
+
+def max_subarray_sum(n, seed, min_val, max_val):
+    lcg_gen = lcg(seed)
+    random_numbers = [next(lcg_gen) % (max_val - min_val + 1) + min_val
+                      for _ in range(n)]
+    max_sum = float('-inf')
+    for i in range(n):
+        current_sum = 0
+        for j in range(i, n):
+            current_sum += random_numbers[j]
+            if current_sum > max_sum:
+                max_sum = current_sum
+    return max_sum
+
+def total_max_subarray_sum(n, initial_seed, min_val, max_val):
+    total_sum = 0
+    lcg_gen = lcg(initial_seed)
+    for _ in range(20):
+        seed = next(lcg_gen)
+        total_sum += max_subarray_sum(n, seed, min_val, max_val)
+    return total_sum
+"""
+
+# Dictionary of examples for easy access in the interface.
+example_dict = {
+    "Hello world": [example_hello_world, "hello_world"],
+    "Sum array": [example_sum, "array_sum"],
+    "Fibonacci": [example_fibonacci, "fibonacci"],
+    "Leibniz pi": [example_leibniz_pi, "calculate_pi"],
+    "Max subarray sum": [example_subarray, "max_subarray_sum"]}

src/interface.py

@@ -0,0 +1,85 @@
+"""Interface module for the AI Python C Extensions Generator application."""
+
+from gradio import Blocks, Button, Dropdown, Examples, Markdown, Row, TextArea, Textbox
+
+from .examples import example_dict
+
+
+css = """
+.c_ext {background-color: #050;}
+.python {background-color: #306998;}
+"""
+
+
+def _compile_extension():
+    return "COMPILE_EXTENSION PLACEHOLDER"
+
+
+def _test_extension():
+    return "TEST_EXTENSION PLACEHOLDER"
+
+
+def get_interface(optimize_function, compile_stage=False,
+                  compile_extension=_compile_extension,
+                  test_extension=_test_extension,
+                  default_platform="Windows",
+                  models=["gpt-5.1-codex-mini"]):
+    """Get the Gradio Blocks interface for the AI Python C Extensions Generator."""
+    with Blocks(css=css, title="AI Python C Extensions Generator") as ui:
+        Markdown("## Convert code from Python to C Extension")
+
+        with Row():
+            module_name = Textbox(label="Module name:", lines=1, value="sample_module")
+            model = Dropdown(label="Select model", choices=models, value=models[0])
+            platform = Dropdown(label="Select platform", choices=["Windows", "Linux"],
+                                value=default_platform)
+
+        with Row():
+            python = Textbox(label="Python code:", lines=30,
+                             buttons=["copy"], elem_classes=["python"],
+                             value=example_dict["Hello world"][0])
+            c_code = Textbox(label="C Extension code:", lines=30,
+                             buttons=["copy"], elem_classes=["c_ext"])
+
+        with Row():
+            Examples(label="Python examples: (From simple to complex)",
+                     inputs=[python, module_name],
+                     examples=list(example_dict.values()),
+                     example_labels=list(example_dict.keys()))
+
+        with Row():
+            get_extension = Button("Generate extension code")
+
+        with Row():
+            setup_code = Textbox(label="Compilation code:", lines=10,
+                                 buttons=["copy"], elem_classes=["python"])
+            usage_code = Textbox(label="Test compare code:", lines=10,
+                                 buttons=["copy"], elem_classes=["python"])
+
+        get_extension.click(optimize_function,
+                            inputs=[python, module_name, platform, model],
+                            outputs=[c_code, setup_code, usage_code])
+
+        # ######### BUILD AND TEST SECTIONS ######### #
+        if compile_stage:
+            with Row():
+                compile_ext = Button("Compile extension")
+            with Row():
+                c_ext_out = TextArea(label="C Extension result:", buttons=["copy"],
+                                     elem_classes=["c_ext"])
+
+            with Row():
+                test_run = Button("Test code")
+            with Row():
+                test_out = TextArea(label="Test result:", buttons=["copy"],
+                                    elem_classes=["python"])
+
+            compile_ext.click(compile_extension,
+                              inputs=[c_code, setup_code, module_name],
+                              outputs=[c_ext_out])
+
+            test_run.click(test_extension,
+                           inputs=[usage_code],
+                           outputs=[test_out])
+
+    return ui

src/optimizer.py

@@ -0,0 +1,50 @@
+"""Optimizer module for the AI Python C Extensions Generator application."""
+
+from logging import getLogger
+
+from dotenv import load_dotenv
+from openai import OpenAI
+from pydantic import BaseModel
+
+from .prompts import messages_for
+
+
+_logger = getLogger(__name__)
+
+
+# Environment initialization.
+load_dotenv(override=True)
+
+
+# Initialize client and set the default LLM model to use.
+openai = OpenAI()
+OPENAI_MODEL = "gpt-5"
+_logger.info(f'INITIALIZED OPTIMIZER MODULE')
+
+
+# Define Pydantic model class for GPT response parsing.
+class _extension_codes(BaseModel):
+    c_code: str
+    setup: str
+    usage: str
+
+    def __str__(self):
+        """Return a string representation of the optimization codes."""
+        return (f"C CODE:\n{self.c_code}\n"
+                f"---------------------------\n"
+                f"setup.py:\n{self.setup}\n"
+                f"---------------------------\n"
+                f"USAGE:\n{self.usage}")
+
+
+# Define optimization function using OpenAI's GPT model.
+def optimize_gpt(python_code, module_name, platform, model=OPENAI_MODEL):
+    """Generate an optimized C extension for Python."""
+    schema = _extension_codes.model_json_schema()
+    _logger.info('SENDING OPTIMIZATION REQUEST TO OPENAI... '
+                 f'(MODEL: {model}, PLATFORM: {platform})')
+    response = openai.responses.parse(
+        model=model, text_format=_extension_codes,
+        input=messages_for(python_code, module_name, schema, platform)).output_parsed
+    _logger.info('RECEIVED OPTIMIZATION RESPONSE FROM OPENAI')
+    return response.c_code, response.setup, response.usage

src/prompts.py

@@ -0,0 +1,61 @@
+"""Prompts for the AI Python C Extensions Generator application."""
+
+# Define system message with instructions for generating the C extension code.
+system_message = """
+You are an assistant that reimplements Python code in high performance C extensions
+for Python.
+Your responses must always be a JSON with the following schema:
+
+{schema}
+
+Use comments sparingly and do not provide any explanation other than occasional comments.
+
+The C extension for Python needs to produce an identical output in the fastest possible
+time.
+
+Make sure the C extension for Python code is correct and can be compiled with
+'python setup.py build_ext' and used in Python.
+
+The usage example must include a time measurement and a comparison with the original
+Python code.
+
+Do not include any additional text or explanation outside the JSON structure.
+
+Make sure the JSON is correctly formatted.
+"""
+
+
+# Define user prompt template and function to fill it.
+user_prompt = """
+Reimplement this Python code as a C extension for Python with the fastest possible
+implementation that produces identical output in the least time.
+
+Respond only with C extension for Python code, do not explain your work other than
+a few code comments.
+
+The module name, used to import, must be "{module_name}", the generated C file will
+be named "{module_name}.c".
+
+Pay attention to number types to ensure no int overflows.
+Remember to #include all necessary C packages such as iomanip or <python.h>
+
+The target architecture is {platform}, take that in mind while generating the C
+code, specially when choosing types to use, and use the appropriate compiler flags.
+
+Make sure to use the Python C API correctly and manage memory properly to avoid
+leaks or crashes.
+
+Here is the Python code to reimplement:
+
+{python_code}
+"""
+
+
+# Define function to create the messages for the LLM.
+def messages_for(python_code, module_name, schema, platform):
+    """Create the messages given the Python code, module name, and platform."""
+    return [
+        {"role": "system", "content": system_message.format(schema=schema)},
+        {"role": "user", "content": user_prompt.format(python_code=python_code,
+                                                       module_name=module_name,
+                                                       platform=platform)}]

src/tester.py

@@ -0,0 +1,46 @@
+"""Testing module for the AI Python C Extensions Generator application."""
+
+import io
+import sys
+from logging import getLogger
+
+
+_logger = getLogger(__name__)
+
+
+# Define a function to write outputs to a file with a given filename.
+def write_file(data, filename):
+    """Write data to a file with the specified filename."""
+    with open(filename, "w") as file:
+        file.write(data)
+
+
+# Define a function to execute Python code and capture its output.
+def execute_python(code):
+    """Execute the given Python code and capture its output."""
+    try:
+        _logger.info('EXECUTING TEST CODE...')
+        # Redirect stdout to capture the output of the executed code.
+        output = io.StringIO()
+        sys.stdout = output
+        # Execute the provided code in a clean global namespace.
+        exec(code, {})
+    finally:
+        # Restore original stdout.
+        sys.stdout = sys.__stdout__
+    return output.getvalue()
+
+
+# Extension testing function.
+def test_extension(usage_code):
+    """Test the C extension executing the code and capture its output."""
+    try:  # Write the code to file.
+        write_file(usage_code, "usage_example.py")
+    except Exception as ex:
+        return f"An error occurred while writing test file:\n{ex}"
+    try:
+        # Execute the code and capture the output.
+        output = execute_python(usage_code)
+    except Exception as ex:
+        return f"An error occurred while testing the extension:\n{ex}"
+    return output