pyberry-framework 0.1.0__tar.gz

pyberry_framework-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include pyproject.toml
+recursive-include src/pyberry/core *.pyx *.pxd *.c
+recursive-include docs *.md
+global-exclude *.pyc
+global-exclude __pycache__
+global-exclude *.so

pyberry_framework-0.1.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: pyberry-framework
+Version: 0.1.0
+Summary: A fast, compiled async web framework
+Author: Your Name
+Author-email: your.email@example.com
+Description-Content-Type: text/markdown
+Requires-Dist: granian
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: summary
+
+# PyBerry Technical Documentation
+
+Welcome to the PyBerry technical documentation. PyBerry is an experimental, ultra-high-performance web framework built specifically for **Free-Threaded Python 3.14+ (No GIL)**. 
+
+By combining the **Rust Server Gateway Interface (RSGI)** via Granian, **Cython Ahead-Of-Time (AOT) compilation**, and a custom **C-based Radix Tree Router**, PyBerry regularly exceeds 100,000 Requests/sec on a single worker process locally.
+
+## Key Features
+- **Free-Threaded Architecture (No GIL):** Utilizes Python 3.13/3.14+ free-threading for massive concurrent performance within a single worker process.
+- **AOT Compilation (Cython):** Transpiles Python dataclasses and logic directly into C extensions (`@cython.cclass`), compiling the entire application ahead-of-time for maximum speed.
+- **Rust-Powered Networking (Granian & RSGI):** Uses Granian's RSGI server interface to bypass slow WSGI/ASGI translation and directly feed memory views from Rust to Python.
+- **C-Implemented Radix Router:** High-performance, O(K) complexity routing engine written in native C for instant path resolution, complete with dynamic path variables (e.g. `/users/{id}`) support.
+- **Automatic Type Casting:** Path parameters and query string variables are automatically cast into their respective Python types (e.g. `int`, `bool`) based on your function's type hints.
+- **Smart Asynchronous Execution (`FastFuture`):** Custom C-level wrappers around awaitables that heavily reduce `asyncio` overhead when calling async Python functions.
+- **Built-in Developer CLI:** `pyberry run`, `pyberry dev`, `pyberry build`, and `pyberry check` provide a seamless Developer Experience (DX) out of the box.
+
+## Table of Contents
+1. [Architecture Overview](architecture.md)
+2. [Command Line Interface (CLI)](cli.md)
+3. [Modular Project Design](modular.md)
+4. [Fast HTTP Responses & Exceptions](responses.md)
+5. [The Core Runtime](#the-core-runtime)
+6. [AOT Transpiler Engine](#aot-transpiler-engine)
+
+## Quick Start
+```bash
+# Build the application for production (transpiles and Cythonizes)
+pyberry build user_app.py
+
+# Run in production mode with Granian RSGI
+pyberry run --workers 1
+```
+
+## The Core Runtime
+The core of PyBerry is written entirely in Cython (`.pyx`) to bypass standard Python interpreter overhead during request handling.
+
+- **`pyberry.core.rsgi`**: The main entry point for the Granian RSGI protocol. It bridges the Rust network stack to our C-level route handlers, ensuring minimal object allocation.
+- **`pyberry.core.router`**: A fully C-implemented Radix Tree (Trie) router. It can instantly match static routes with `O(K)` complexity (where K is the path length) and supports dynamic `{parameter}` injection via named regex groups for Python handlers.
+- **`pyberry.core.future`**: Provides `FastFuture`, a lightweight awaitable wrapper that bypasses traditional `asyncio.Future` overhead to maximize async throughput.
+
+## AOT Transpiler Engine
+PyBerry doesn't just run Python; it compiles it.
+
+Using Python's built-in `ast` module (`pyberry.compiler.transformer`), PyBerry reads your standard Python application and injects Cython optimizations before compilation:
+1. **Type Mapping:** Python type hints (`int`, `str`) are mapped to Cython equivalents.
+2. **Dataclass Optimization:** Automatically injects `@cython.cclass` into your Pydantic/Dataclass models to convert them into C-structs.
+3. **Await Wrapping:** Overrides the `await` keyword to wrap coroutines in our custom `FastFuture`.
+
+The transpiled `.py` file is then compiled by GCC into a shared object (`.so`) during the `pyberry build` step, running your business logic as native C code.

pyberry_framework-0.1.0/docs/README.md

@@ -0,0 +1,48 @@
+# PyBerry Technical Documentation
+
+Welcome to the PyBerry technical documentation. PyBerry is an experimental, ultra-high-performance web framework built specifically for **Free-Threaded Python 3.14+ (No GIL)**. 
+
+By combining the **Rust Server Gateway Interface (RSGI)** via Granian, **Cython Ahead-Of-Time (AOT) compilation**, and a custom **C-based Radix Tree Router**, PyBerry regularly exceeds 100,000 Requests/sec on a single worker process locally.
+
+## Key Features
+- **Free-Threaded Architecture (No GIL):** Utilizes Python 3.13/3.14+ free-threading for massive concurrent performance within a single worker process.
+- **AOT Compilation (Cython):** Transpiles Python dataclasses and logic directly into C extensions (`@cython.cclass`), compiling the entire application ahead-of-time for maximum speed.
+- **Rust-Powered Networking (Granian & RSGI):** Uses Granian's RSGI server interface to bypass slow WSGI/ASGI translation and directly feed memory views from Rust to Python.
+- **C-Implemented Radix Router:** High-performance, O(K) complexity routing engine written in native C for instant path resolution, complete with dynamic path variables (e.g. `/users/{id}`) support.
+- **Automatic Type Casting:** Path parameters and query string variables are automatically cast into their respective Python types (e.g. `int`, `bool`) based on your function's type hints.
+- **Smart Asynchronous Execution (`FastFuture`):** Custom C-level wrappers around awaitables that heavily reduce `asyncio` overhead when calling async Python functions.
+- **Built-in Developer CLI:** `pyberry run`, `pyberry dev`, `pyberry build`, and `pyberry check` provide a seamless Developer Experience (DX) out of the box.
+
+## Table of Contents
+1. [Architecture Overview](architecture.md)
+2. [Command Line Interface (CLI)](cli.md)
+3. [Modular Project Design](modular.md)
+4. [Fast HTTP Responses & Exceptions](responses.md)
+5. [The Core Runtime](#the-core-runtime)
+6. [AOT Transpiler Engine](#aot-transpiler-engine)
+
+## Quick Start
+```bash
+# Build the application for production (transpiles and Cythonizes)
+pyberry build user_app.py
+
+# Run in production mode with Granian RSGI
+pyberry run --workers 1
+```
+
+## The Core Runtime
+The core of PyBerry is written entirely in Cython (`.pyx`) to bypass standard Python interpreter overhead during request handling.
+
+- **`pyberry.core.rsgi`**: The main entry point for the Granian RSGI protocol. It bridges the Rust network stack to our C-level route handlers, ensuring minimal object allocation.
+- **`pyberry.core.router`**: A fully C-implemented Radix Tree (Trie) router. It can instantly match static routes with `O(K)` complexity (where K is the path length) and supports dynamic `{parameter}` injection via named regex groups for Python handlers.
+- **`pyberry.core.future`**: Provides `FastFuture`, a lightweight awaitable wrapper that bypasses traditional `asyncio.Future` overhead to maximize async throughput.
+
+## AOT Transpiler Engine
+PyBerry doesn't just run Python; it compiles it.
+
+Using Python's built-in `ast` module (`pyberry.compiler.transformer`), PyBerry reads your standard Python application and injects Cython optimizations before compilation:
+1. **Type Mapping:** Python type hints (`int`, `str`) are mapped to Cython equivalents.
+2. **Dataclass Optimization:** Automatically injects `@cython.cclass` into your Pydantic/Dataclass models to convert them into C-structs.
+3. **Await Wrapping:** Overrides the `await` keyword to wrap coroutines in our custom `FastFuture`.
+
+The transpiled `.py` file is then compiled by GCC into a shared object (`.so`) during the `pyberry build` step, running your business logic as native C code.

pyberry_framework-0.1.0/docs/architecture.md

@@ -0,0 +1,47 @@
+# Architecture Overview
+
+PyBerry achieves unprecedented speed by bypassing the traditional Python WSGI/ASGI stack and running native C code as much as possible, driven by a Rust networking layer.
+
+## Request Lifecycle
+
+1. **Client Request**: A client sends an HTTP request.
+2. **Rust Layer (Granian)**: The Granian HTTP server, written in Rust, accepts the TCP connection and parses the HTTP request.
+3. **RSGI Interface**: Granian hands the request over to Python using the **RSGI** protocol, which passes minimal metadata (scope) to the `app()` coroutine in `pyberry.core.rsgi`.
+4. **Security Middleware**: Before routing, `validate_request` (`security.pyx`) performs fast C-level validation (e.g., CORS checks).
+5. **C-Level Routing (`router.pyx`)**:
+   - The Radix Tree router looks up the path in `O(K)` time.
+   - If it maps to a direct C-function pointer, it executes it with zero Python overhead.
+   - If it maps to a Python route, it uses regular expressions to extract path parameters (`{user_id}`), applies automatic type casting, and invokes the Python function.
+6. **Execution**: The user's handler executes. Because the user's code was compiled via `pyberry build`, it runs natively as a Cython C-extension.
+7. **Response**: The `Response` object is returned and serialized directly back into Granian's response stream.
+
+## Why Free-Threaded Python?
+Traditional Python uses the Global Interpreter Lock (GIL), meaning only one thread can execute Python bytecode at a time. This severely bottlenecks multi-core Rust web servers (like Granian) when they try to hand off thousands of concurrent requests to Python workers.
+
+By targeting **Python 3.13/3.14+ (Free-Threaded)**, PyBerry runs with `PYTHON_GIL=0`. This allows multiple requests to be processed truly concurrently within the *same* worker process, allowing a single worker to hit 100k+ RPS.
+
+## The AOT Compiler (`pyberry/compiler/`)
+The Ahead-Of-Time transpiler takes standard Python files and supercharges them.
+
+- **AST Parsing**: Reads standard Python syntax (`ast.parse()`).
+- **Transformation**: Uses `ast.NodeTransformer` to rewrite AST nodes.
+- **Compilation**: Outputs modified Python code and uses Cython (`cythonize`) and GCC to build a `.so` library.
+
+### Example Transformation:
+**User writes:**
+```python
+@dataclass
+class User:
+    id: int
+```
+
+**PyBerry transpiles to:**
+```python
+import cython
+
+@cython.cclass
+@dataclass
+class User:
+    id: cython.int
+```
+This forces the Python object to be represented as a C-struct in memory.

pyberry_framework-0.1.0/docs/cli.md

@@ -0,0 +1,62 @@
+# Command Line Interface (CLI)
+
+The `pyberry` CLI is the control center for transpiling, building, and running your web applications.
+
+## `pyberry build <app_file.py>`
+Prepares your application for production by compiling it.
+
+**Under the hood:**
+1. Triggers `pyberry.compiler.transpile` to parse the Python AST of your app.
+2. Injects Cython optimizations (like `FastFuture` wrappers and `@cython.cclass`).
+3. Outputs a `.berry_build/app_compiled.py` file.
+4. Generates a `setup.py` file and invokes `gcc` to Cythonize the code into a native shared object (`.so`).
+
+**Usage:**
+```bash
+pyberry build user_app.py
+```
+
+## `pyberry run`
+Starts the production server using Granian.
+
+**Under the hood:**
+1. Automatically sets `PYTHON_GIL=0` in the environment to enable Free-Threaded processing.
+2. Sets the `PYTHONPATH` to include the `.berry_build` directory.
+3. Creates a `run_wrapper.py` that imports your compiled application.
+4. Spawns `granian` using the `rsgi` interface.
+
+**Options:**
+- `--workers <N>`: Sets the number of worker processes. Default is `1`. Due to the GIL-less architecture, a single worker is often capable of saturating local hardware limits.
+
+**Usage:**
+```bash
+pyberry run --workers 1
+```
+
+## `pyberry dev <app_file.py>`
+Starts the server in development mode.
+
+**Under the hood:**
+1. Skips the AOT compilation step for faster startup.
+2. Runs the code using the standard Python interpreter instead of the compiled `.so` extension.
+3. Attempts to enable hot-reloading (Note: Granian currently disables hot-reloading when free-threaded Python is active).
+
+**Usage:**
+```bash
+pyberry dev user_app.py
+```
+
+## `pyberry check`
+Performs a comprehensive system check to ensure all dependencies for PyBerry's maximum performance are met across Linux, macOS, and Windows.
+
+**What it checks:**
+1. **Python version:** Checks if you're on Python 3.13+ for free-threading support.
+2. **Free-threading / GIL status:** Verifies that your Python executable is actually running with the GIL disabled.
+3. **Granian:** Ensures the Granian RSGI web server is installed.
+4. **Cython:** Confirms Cython is available in your environment for AOT transpilation.
+5. **C Compiler:** Checks for `gcc`/`clang` on Linux/macOS, or `cl.exe` (MSVC) on Windows to ensure C extensions can be successfully compiled.
+
+**Usage:**
+```bash
+pyberry check
+```

pyberry_framework-0.1.0/docs/logging.md

@@ -0,0 +1,57 @@
+# High-Performance Logging in PyBerry
+
+PyBerry features a highly optimized, zero-latency background logging system built natively in Cython. It is designed to provide beautiful, colorized terminal output and persistent file logging without hindering the framework's extreme Requests-Per-Second (RPS) throughput.
+
+## Zero-Dependency, Lock-Free C Architecture
+
+Traditional logging (such as `print` statements or synchronous file I/O) blocks the asynchronous event loop and severely degrades framework performance under load.
+
+Initially, PyBerry attempted to solve this using Python's `queue.SimpleQueue`. However, at an extreme scale of 60,000+ RPS, three major bottlenecks emerged:
+1. **Hidden Locks**: `queue.SimpleQueue` relies on a C-level mutex. Acquiring and releasing this lock 60,000 times per second created massive contention between the main event loop and the logging thread.
+2. **Python Object Allocation**: The old architecture required encoding strings into new Python `bytes` objects and creating `tuple` wrappers for every log entry. This meant allocating over 100,000 temporary objects per second, thrashing the CPython memory allocator and requiring the Global Interpreter Lock (GIL).
+3. **CPU False Sharing**: Thread read/write indices shared the same CPU cache line, causing processor cores to constantly invalidate each other's cache.
+
+To achieve true zero-latency, PyBerry's logging has been completely rewritten in Cython with a **Lock-Free SPSC (Single-Producer, Single-Consumer) Ring Buffer**:
+
+1. **The Hot Path (`push_log`)**: 
+   When a request completes, PyBerry extracts the raw C string pointers from the Python strings in O(1) time using `PyUnicode_AsUTF8()`, avoiding all memory allocation. It then copies these C strings directly into a statically allocated C struct array. We intentionally **do not drop the GIL** during this step (`nogil`), because the lock-free C copy takes just a few nanoseconds, whereas a Python context switch to release/acquire the GIL takes ~50-100ns. By staying within the GIL for this microsecond operation, we save massive context-switching overhead.
+   
+2. **Lock-Free Atomics**: 
+   The C ring buffer uses C11 atomic operations (`stdatomic.h`) to update the read/write indices. Because it's an SPSC queue, the main thread never blocks waiting for a lock. Additionally, the indices are padded with 64 empty bytes to prevent CPU false sharing across cores.
+
+3. **The Pure C Background Worker (`pthread`)**: 
+   The most critical optimization was moving the background worker entirely out of Python. Previously, the background thread was a Python daemon that woke up and acquired the GIL to format strings and execute `sys.stdout.write`. This created severe **GIL Contention**, artificially capping throughput at ~35K RPS. Now, PyBerry spawns a pure C thread (`pthread_create`) that operates 100% independently of the Python Interpreter. It formats strings and performs standard C I/O (`fprintf`) without ever requesting the GIL.
+
+This strict C-level separation guarantees that your async event loop hands off log data in mere nanoseconds, allowing the framework to operate at maximum speed (60K+ RPS) even while logging everything.
+
+## Output Targets
+
+The background logger pushes logs to two destinations simultaneously:
+
+1. **Terminal (sys.stdout)**: Colorized output where the HTTP method changes color based on type (GET is Green, POST is Blue, DELETE is Red) and the status codes indicate success or failure.
+2. **File (`berrypy.log`)**: A plain-text version of the log is appended to `berrypy.log`, which is generated automatically in your project's root directory when you run `pyberry init`.
+
+*Example Output:*
+```text
+[2026-05-29 08:24:47] GET /users/42 - 200
+[2026-05-29 08:24:47] POST /auth/login - 403
+```
+
+## Toggling Logging for Peak Benchmarking
+
+While the hot path enqueue operation takes less than a microsecond, executing the background thread does consume some CPU cycles at extreme scale (e.g., 100,000+ RPS).
+
+If you are running load tests or benchmarking the absolute maximum capability of the framework, you should disable logging entirely. When disabled, the logger returns instantaneously without even pushing to the queue.
+
+### How to Disable Logging
+
+Open the generated `security.py` file in your PyBerry project root, and set `LOGGING_ENABLED` to `False`:
+
+```python
+# security.py
+
+# Turn off for peak benchmarking (RPS)
+LOGGING_ENABLED = False
+```
+
+When you are finished benchmarking, you can switch it back to `True` for development or standard production usage.

pyberry_framework-0.1.0/docs/modular.md

@@ -0,0 +1,55 @@
+# Modular Project Design
+
+One of the unique features of PyBerry is how it handles multi-file projects while maintaining maximum Cython compilation performance.
+
+## The Problem
+Normally, if you write a single Cython/Python script and compile it, any files it imports are loaded via the standard Python interpreter. This means if you put your models and business logic in a separate file, they lose all the speed benefits of Cython compilation and `@cython.cclass`.
+
+## The PyBerry Solution
+When you run `pyberry build user_app.py`, the CLI automatically scans your entire working directory (excluding virtual environments, caches, etc.) and performs full-project transpilation.
+
+**What happens during `build`:**
+1. Every local `.py` file is parsed by the AST Transpiler.
+2. `@cython.cclass` and other optimizations are injected into all dataclasses across all files.
+3. The entire file tree is mirrored into `.berry_build/`.
+4. A multi-extension `setup.py` is generated that Cythonizes the entire project simultaneously.
+
+## Example Project Structure
+```text
+my_project/
+├── models.py
+└── user_app.py
+```
+
+### `models.py`
+```python
+from dataclasses import dataclass
+
+@dataclass
+class User:
+    id: int
+    name: str
+    
+    def is_valid(self) -> bool:
+        return self.id > 0
+```
+
+### `user_app.py`
+```python
+from pyberry.core.rsgi import router
+from pyberry.core.responses import JSONResponse
+from models import User # Seamlessly imported!
+
+@router.add_python_route("GET", "/user/{user_id}")
+def get_user(req, user_id: int):
+    # This instantiation runs in C
+    user = User(id=user_id, name="Test User")
+    
+    return JSONResponse({
+        "id": user.id,
+        "name": user.name,
+        "is_valid": user.is_valid()
+    })
+```
+
+Because `.berry_build` is added to the `PYTHONPATH` during `pyberry run`, the import `from models import User` natively resolves to the compiled `.so` (or `.pyd`) binary extension, giving your modular code the exact same speed as if it were all written in a single file!

pyberry_framework-0.1.0/docs/responses.md

@@ -0,0 +1,39 @@
+# Fast HTTP Responses & Exceptions
+
+PyBerry provides native, highly-optimized response classes that seamlessly integrate with Granian's RSGI server interface.
+
+## Standard Responses
+All response objects can be imported from `pyberry.core.responses`. They automatically handle serialization and `Content-Type` headers for you.
+
+- `JSONResponse(content: dict, status: int = 200, headers: list = None)`
+- `HTMLResponse(content: str, status: int = 200, headers: list = None)`
+- `PlainTextResponse(content: str, status: int = 200, headers: list = None)`
+
+### Example Usage:
+```python
+from pyberry.core.rsgi import router
+from pyberry.core.responses import JSONResponse
+
+@router.add_python_route("GET", "/")
+def index(req):
+    return JSONResponse({"status": "ok", "message": "Welcome to PyBerry!"})
+```
+
+## Error Handling (`HTTPException`)
+For fast, short-circuit error handling, PyBerry provides an `HTTPException`.
+
+When you raise an `HTTPException` inside a route, it is caught directly at the Rust-to-Cython boundary (`rsgi.pyx`). This completely bypasses the normal Python response allocation cycle and instantly passes the error back to Granian in C, ensuring minimal overhead during error states.
+
+### Example Usage:
+```python
+from pyberry.core.rsgi import router
+from pyberry.core.responses import JSONResponse, HTTPException
+
+@router.add_python_route("GET", "/user/{user_id}")
+def get_user(req, user_id: int):
+    if user_id <= 0:
+        # Instantly breaks execution and returns 400 Bad Request
+        raise HTTPException(400, "Invalid user ID")
+    
+    return JSONResponse({"id": user_id, "name": "Valid User"})
+```

pyberry_framework-0.1.0/docs/security.md

@@ -0,0 +1,51 @@
+# PyBerry Security
+
+Security in PyBerry is designed to be **secure by default**. We prioritize zero-configuration, robust protection for all applications out of the box, mitigating common web vulnerabilities such as Host Header Injection (BadHost) and Cross-Site Request Forgery (CSRF) via strict CORS policies.
+
+## The `security.py` File
+
+When you scaffold a new project using `pyberry init`, a `security.py` file is automatically generated in your project's root directory. PyBerry detects this file and automatically applies its configurations to your application at runtime. 
+
+There is **no need** to manually import or configure these settings inside your `user_app.py`.
+
+### Default Configuration
+
+```python
+# security.py
+# High-grade security configurations for PyBerry
+
+# Allowed Hosts prevents Host Header Injection attacks (BadHost vulnerabilities).
+# Only requests with a matching Host header will be processed.
+# In production, replace "localhost" and "127.0.0.1" with your actual domain names.
+ALLOWED_HOSTS = ["localhost", "127.0.0.1"]
+
+# Strict CORS policy
+CORS_ENABLED = True
+```
+
+## Security Mechanisms
+
+### 1. Host Header Validation (BadHost Mitigation)
+
+Many modern web vulnerabilities, such as cache poisoning and password reset poisoning, originate from **Host Header Injection**. Frameworks that blindly trust the incoming `Host` header can be easily exploited (e.g., historical vulnerabilities in Starlette/FastAPI).
+
+PyBerry actively validates the `Host` header against the `ALLOWED_HOSTS` list defined in your `security.py`. 
+- If a request is received with an untrusted `Host` header, PyBerry immediately intercepts the request and returns an HTTP `400 Bad Request` response, preventing any malicious payload from reaching your application logic.
+- To allow all hosts (e.g., during testing or behind a trusted reverse proxy that rewrites the host), you can set `ALLOWED_HOSTS = ["*"]`.
+
+### 2. CORS (Cross-Origin Resource Sharing)
+
+By default, PyBerry enforces a strict CORS policy when `CORS_ENABLED = True` is set in your `security.py`. 
+- The framework performs an extremely strict block on cross-origin requests by ensuring that the request's `Origin` header matches the `Host` header. 
+- If they do not match, the request is intercepted and an HTTP `403 Forbidden` response is returned.
+
+## Going to Production
+
+When deploying your PyBerry application to a production environment, ensure you update your `security.py` with your actual domain name(s):
+
+```python
+# security.py
+ALLOWED_HOSTS = ["api.mycoolapp.com", "mycoolapp.com"]
+```
+
+Because PyBerry handles these validations at the C-extension level before the request even reaches the Python runtime, malicious requests incur virtually zero performance overhead on your server.

pyberry_framework-0.1.0/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=42", "Cython>=3.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyberry-framework"
+version = "0.1.0"
+dynamic = ["description", "readme", "authors"]
+dependencies = [
+    "granian"
+]
+
+[project.scripts]
+pyberry = "pyberry.cli:main"

pyberry_framework-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyberry_framework-0.1.0/setup.py

@@ -0,0 +1,39 @@
+import os
+from setuptools import setup, Extension
+from Cython.Build import cythonize
+
+# Read the README for the PyPI long description
+long_description = ""
+if os.path.exists("docs/README.md"):
+    with open("docs/README.md", "r", encoding="utf-8") as fh:
+        long_description = fh.read()
+
+extensions = [
+    Extension("pyberry.core.request", ["src/pyberry/core/request.pyx"]),
+    Extension("pyberry.core.response", ["src/pyberry/core/response.pyx"]),
+    Extension("pyberry.core.router", ["src/pyberry/core/router.pyx"]),
+    Extension("pyberry.core.security", ["src/pyberry/core/security.pyx"]),
+    Extension("pyberry.core.future", ["src/pyberry/core/future.pyx"]),
+    Extension("pyberry.core.rsgi", ["src/pyberry/core/rsgi.pyx"]),
+    Extension("pyberry.core.logger", ["src/pyberry/core/logger.pyx"]),
+]
+
+setup(
+    name="pyberry-framework",
+    version="0.1.0",
+    author="Your Name",
+    author_email="your.email@example.com",
+    description="A fast, compiled async web framework",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    package_dir={"": "src"},
+    ext_modules=cythonize(
+        extensions,
+        compiler_directives={"language_level": "3"}
+    ),
+    entry_points={
+        'console_scripts': [
+            'pyberry=pyberry.cli:main',
+        ],
+    },
+)

pyberry_framework-0.1.0/src/pyberry/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pyberry_framework-0.1.0/src/pyberry/app.py

@@ -0,0 +1,13 @@
+from pyberry.core.rsgi import router
+
+def get(path):
+    def decorator(func):
+        print("REGISTERING:", path); router.add_python_route("GET", path, func)
+        return func
+    return decorator
+
+def post(path):
+    def decorator(func):
+        router.add_python_route("POST", path, func)
+        return func
+    return decorator