creatine 0.1.0__tar.gz

creatine-0.1.0/LICENSE

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

creatine-0.1.0/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: creatine
+Version: 0.1.0
+Summary: A lightweight Python web framework with WSGI and ASGI support.
+Author: Fazliddin
+License: MIT
+Project-URL: Homepage, https://github.com/fazliddinio/creatine
+Project-URL: Repository, https://github.com/fazliddinio/creatine
+Project-URL: Issues, https://github.com/fazliddinio/creatine/issues
+Keywords: web,framework,wsgi,asgi,http
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Jinja2>=3.1
+Requires-Dist: parse>=1.20
+Requires-Dist: requests>=2.30
+Requires-Dist: requests-wsgi-adapter>=0.4
+Requires-Dist: WebOb>=1.8
+Requires-Dist: whitenoise>=6.5
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: gunicorn>=22.0; extra == "dev"
+Requires-Dist: uvicorn>=0.30; extra == "dev"
+Dynamic: license-file
+
+# Creatine
+
+A lightweight Python web framework with WSGI and ASGI support.
+
+## Installation
+
+```bash
+pip install creatine
+```
+
+For development:
+
+```bash
+pip install creatine[dev]
+```
+
+## Quick Start
+
+```python
+from creatine import Creatine
+
+app = Creatine()
+
+
+@app.route("/")
+def home(req, resp):
+    resp.text = "Hello, World!"
+
+
+@app.route("/greeting/{name}")
+def greeting(req, resp, name):
+    resp.text = f"Hello, {name}"
+
+
+@app.route("/book")
+class BookResource:
+    def get(self, req, resp):
+        resp.text = "Books Page"
+
+    def post(self, req, resp):
+        resp.text = "Book created"
+
+
+@app.route("/json")
+def json_handler(req, resp):
+    resp.json = {"message": "hello"}
+
+
+@app.route("/template")
+def template_handler(req, resp):
+    resp.html = app.template("index.html", context={"title": "Hello"})
+```
+
+## Running the Server
+
+```bash
+# Built-in dev server
+creatine runserver app:app
+
+# With Gunicorn (WSGI)
+gunicorn app:app
+
+# With Uvicorn (ASGI)
+uvicorn app:asgi_app
+```
+
+## ASGI & Async Handlers
+
+Creatine supports both sync and async handlers when running under ASGI:
+
+```python
+app = Creatine()
+
+asgi_app = app.as_asgi()
+
+@app.route("/async")
+async def async_handler(req, resp):
+    resp.json = {"async": True}
+```
+
+## Middleware
+
+```python
+from creatine import Middleware
+from creatine.log import LoggingMiddleware
+
+# Built-in request logging
+app.add_middleware(LoggingMiddleware)
+
+# Custom middleware
+class AuthMiddleware(Middleware):
+    def process_request(self, req):
+        print(f"Auth check: {req.url}")
+
+    def process_response(self, req, resp):
+        print(f"Completed: {resp.status_code}")
+
+app.add_middleware(AuthMiddleware)
+```
+
+## ORM
+
+Built-in SQLite ORM for simple data persistence:
+
+```python
+from creatine import Database, Table, Column, ForeignKey
+
+db = Database("./app.db")
+
+class Author(Table):
+    name = Column(str)
+    age = Column(int)
+
+class Book(Table):
+    title = Column(str)
+    author = ForeignKey(Author)
+
+db.create(Author)
+db.create(Book)
+
+author = Author(name="Jane", age=30)
+db.save(author)
+db.update(author)
+db.delete(Author, id=1)
+```
+
+## Features
+
+- WSGI and ASGI compatible
+- Async handler support
+- Parameterized and basic routing
+- Class-based and function-based handlers
+- Built-in SQLite ORM with foreign keys
+- Jinja2 templates
+- Static files via WhiteNoise
+- Middleware pipeline with built-in logging
+- Custom exception handlers
+- Test client (based on Requests)
+- CLI (`creatine runserver`)
+- GitHub Actions CI with pytest and mypy
+
+## Tests
+
+```bash
+pytest
+```
+
+## Project Structure
+
+```
+creatine/
+├── __init__.py      # Package exports and version
+├── __main__.py      # CLI entry point
+├── api.py           # Core Creatine application class
+├── asgi.py          # ASGI adapter
+├── exceptions.py    # HTTPError
+├── log.py           # Logging middleware
+├── middleware.py     # Middleware base class
+├── orm.py           # SQLite ORM
+├── response.py      # Response wrapper
+├── route.py         # Route matching and dispatch
+└── utils.py         # Static file and test helpers
+```
+
+## License
+
+MIT

creatine-0.1.0/README.md

@@ -0,0 +1,167 @@
+# Creatine
+
+A lightweight Python web framework with WSGI and ASGI support.
+
+## Installation
+
+```bash
+pip install creatine
+```
+
+For development:
+
+```bash
+pip install creatine[dev]
+```
+
+## Quick Start
+
+```python
+from creatine import Creatine
+
+app = Creatine()
+
+
+@app.route("/")
+def home(req, resp):
+    resp.text = "Hello, World!"
+
+
+@app.route("/greeting/{name}")
+def greeting(req, resp, name):
+    resp.text = f"Hello, {name}"
+
+
+@app.route("/book")
+class BookResource:
+    def get(self, req, resp):
+        resp.text = "Books Page"
+
+    def post(self, req, resp):
+        resp.text = "Book created"
+
+
+@app.route("/json")
+def json_handler(req, resp):
+    resp.json = {"message": "hello"}
+
+
+@app.route("/template")
+def template_handler(req, resp):
+    resp.html = app.template("index.html", context={"title": "Hello"})
+```
+
+## Running the Server
+
+```bash
+# Built-in dev server
+creatine runserver app:app
+
+# With Gunicorn (WSGI)
+gunicorn app:app
+
+# With Uvicorn (ASGI)
+uvicorn app:asgi_app
+```
+
+## ASGI & Async Handlers
+
+Creatine supports both sync and async handlers when running under ASGI:
+
+```python
+app = Creatine()
+
+asgi_app = app.as_asgi()
+
+@app.route("/async")
+async def async_handler(req, resp):
+    resp.json = {"async": True}
+```
+
+## Middleware
+
+```python
+from creatine import Middleware
+from creatine.log import LoggingMiddleware
+
+# Built-in request logging
+app.add_middleware(LoggingMiddleware)
+
+# Custom middleware
+class AuthMiddleware(Middleware):
+    def process_request(self, req):
+        print(f"Auth check: {req.url}")
+
+    def process_response(self, req, resp):
+        print(f"Completed: {resp.status_code}")
+
+app.add_middleware(AuthMiddleware)
+```
+
+## ORM
+
+Built-in SQLite ORM for simple data persistence:
+
+```python
+from creatine import Database, Table, Column, ForeignKey
+
+db = Database("./app.db")
+
+class Author(Table):
+    name = Column(str)
+    age = Column(int)
+
+class Book(Table):
+    title = Column(str)
+    author = ForeignKey(Author)
+
+db.create(Author)
+db.create(Book)
+
+author = Author(name="Jane", age=30)
+db.save(author)
+db.update(author)
+db.delete(Author, id=1)
+```
+
+## Features
+
+- WSGI and ASGI compatible
+- Async handler support
+- Parameterized and basic routing
+- Class-based and function-based handlers
+- Built-in SQLite ORM with foreign keys
+- Jinja2 templates
+- Static files via WhiteNoise
+- Middleware pipeline with built-in logging
+- Custom exception handlers
+- Test client (based on Requests)
+- CLI (`creatine runserver`)
+- GitHub Actions CI with pytest and mypy
+
+## Tests
+
+```bash
+pytest
+```
+
+## Project Structure
+
+```
+creatine/
+├── __init__.py      # Package exports and version
+├── __main__.py      # CLI entry point
+├── api.py           # Core Creatine application class
+├── asgi.py          # ASGI adapter
+├── exceptions.py    # HTTPError
+├── log.py           # Logging middleware
+├── middleware.py     # Middleware base class
+├── orm.py           # SQLite ORM
+├── response.py      # Response wrapper
+├── route.py         # Route matching and dispatch
+└── utils.py         # Static file and test helpers
+```
+
+## License
+
+MIT

creatine-0.1.0/creatine/__init__.py

@@ -0,0 +1,19 @@
+"""Creatine — A lightweight Python web framework."""
+
+from .api import Creatine
+from .exceptions import HTTPError
+from .middleware import Middleware
+from .orm import Database, Table, Column, ForeignKey
+from .response import Response
+
+__version__ = "0.1.0"
+__all__ = [
+    "Creatine",
+    "HTTPError",
+    "Middleware",
+    "Database",
+    "Table",
+    "Column",
+    "ForeignKey",
+    "Response",
+]

creatine-0.1.0/creatine/__main__.py

@@ -0,0 +1,101 @@
+"""CLI entry point for the Creatine framework.
+
+Usage:
+    python -m creatine runserver app:app
+    python -m creatine runserver app:app --host 0.0.0.0 --port 5000
+"""
+
+import argparse
+import importlib
+import logging
+import sys
+from typing import Any
+
+
+def import_app(app_path: str) -> Any:
+    """Import an application from a 'module:attribute' path.
+
+    Args:
+        app_path: Import path like 'app:app' or 'myapp.main:application'.
+
+    Returns:
+        The imported application object.
+
+    Raises:
+        SystemExit: If the module or attribute cannot be found.
+    """
+    module_path, _, attr = app_path.partition(":")
+    if not attr:
+        attr = "app"
+
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as e:
+        print(f"Error: Could not import module '{module_path}': {e}")
+        sys.exit(1)
+
+    try:
+        return getattr(module, attr)
+    except AttributeError:
+        print(f"Error: Module '{module_path}' has no attribute '{attr}'")
+        sys.exit(1)
+
+
+def runserver(args: argparse.Namespace) -> None:
+    """Start the development server using wsgiref."""
+    from wsgiref.simple_server import make_server
+
+    # Configure logging so LoggingMiddleware output is visible
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s [%(name)s] %(message)s",
+        datefmt="%H:%M:%S",
+    )
+
+    app = import_app(args.app)
+
+    print(f"\n  Creatine dev server")
+    print(f"  http://{args.host}:{args.port}")
+    print(f"  Press Ctrl+C to stop.\n")
+
+    server = make_server(args.host, args.port, app)
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nServer stopped.")
+
+
+def main() -> None:
+    """Parse CLI arguments and dispatch to the appropriate command."""
+    parser = argparse.ArgumentParser(
+        prog="creatine",
+        description="Creatine — A Python Web Framework",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # runserver command
+    server_parser = subparsers.add_parser(
+        "runserver", help="Start the development server"
+    )
+    server_parser.add_argument(
+        "app",
+        help="Application path (module:attribute), e.g. app:app",
+    )
+    server_parser.add_argument(
+        "--host", default="127.0.0.1", help="Host to bind to (default: 127.0.0.1)"
+    )
+    server_parser.add_argument(
+        "--port", type=int, default=8000, help="Port to bind to (default: 8000)"
+    )
+
+    args = parser.parse_args()
+
+    if args.command == "runserver":
+        runserver(args)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()