neutronapi 0.1.0__tar.gz

neutronapi-0.1.0/LICENSE

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

neutronapi-0.1.0/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include neutronapi *.py
+recursive-exclude neutronapi/tests *
+recursive-exclude apps *
+exclude manage.py

neutronapi-0.1.0/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: neutronapi
+Version: 0.1.0
+Summary: High-performance Python framework built directly on uvicorn with built-in database models, migrations, and background tasks. Django that was built async-first.
+Author-email: Aaron Kazah <aaron@neutronapi.com>
+License-Expression: MIT
+Keywords: api,framework,async,django,fastapi,uvicorn,orm,migrations,background-tasks
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: uvicorn[standard]>=0.23.0
+Requires-Dist: aiosqlite>=0.19.0
+Requires-Dist: PyJWT>=2.8.0
+Provides-Extra: postgres
+Requires-Dist: asyncpg>=0.29.0; extra == "postgres"
+Provides-Extra: dev
+Requires-Dist: httpx>=0.24.0; extra == "dev"
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Dynamic: license-file
+
+# NeutronAPI
+
+**High-performance Python framework built directly on uvicorn with built-in database models, migrations, and background tasks. If you want Django that was built async-first, this is for you.**
+
+Batteries included async API framework with command-line management.
+
+## Installation
+
+```bash
+pip install neutronapi
+```
+
+## Quick Start
+
+```bash
+# 1. Create project
+neutronapi startproject blog
+cd blog
+
+# 2. Create an app
+python manage.py startapp posts
+
+# 3. Start server  
+python manage.py start               # Dev mode (auto-reload)
+
+# 4. Test
+python manage.py test
+```
+
+## Getting Started Tutorial
+
+**1. Create Project**
+```bash
+neutronapi startproject blog
+cd blog
+```
+
+**2. Create App Module**  
+```bash
+python manage.py startapp posts
+```
+
+**3. Configure in `apps/settings.py`**
+```python
+import os
+
+# ASGI application entry point (required for server)
+ENTRY = "apps.entry:app"  # module:variable format
+
+# Database
+DATABASES = {
+    'default': {
+        'ENGINE': 'aiosqlite',
+        'NAME': 'db.sqlite3',
+    }
+}
+```
+
+**4. Create API in `apps/posts/api.py`**
+```python
+from neutronapi.base import API
+
+class PostAPI(API):
+    name = "posts"
+    
+    @API.endpoint("/posts", methods=["GET"])
+    async def list_posts(self, scope, receive, send, **kwargs):
+        posts = [{"id": 1, "title": "Hello World"}]
+        return await self.response(posts)
+    
+    @API.endpoint("/posts", methods=["POST"])
+    async def create_post(self, scope, receive, send, **kwargs):
+        # Get request data from scope["body"]
+        return await self.response({"id": 2, "title": "New Post"})
+```
+
+**5. Register API in `apps/entry.py`**
+```python
+from neutronapi.application import Application
+from apps.posts.api import PostAPI
+
+app = Application({
+    "posts": PostAPI()
+})
+```
+
+**6. Start Server**
+```bash
+python manage.py start
+# Visit: http://127.0.0.1:8000/posts
+```
+
+## Project Structure
+
+```
+myproject/
+├── manage.py           # Management commands
+├── apps/
+│   ├── __init__.py
+│   ├── settings.py     # Configuration 
+│   └── entry.py        # ASGI application
+└── db.sqlite3          # Database
+```
+
+## Background Tasks
+
+```python
+from neutronapi.background import Task, TaskFrequency
+
+class CleanupTask(Task):
+    name = "cleanup"
+    frequency = TaskFrequency.MINUTELY
+    
+    async def run(self, **kwargs):
+        print("Cleaning up logs...")
+
+# Add to application
+app = Application(
+    apis={"ping": PingAPI()},
+    tasks={"cleanup": CleanupTask()}
+)
+
+## Database Models
+
+```python
+from neutronapi.db.models import Model
+from neutronapi.db.fields import CharField, IntegerField, DateTimeField
+
+class User(Model):
+    name = CharField(max_length=100)
+    age = IntegerField()
+    created_at = DateTimeField(auto_now_add=True)
+    
+    # Table name inferred from class name (user -> users)
+```
+
+## Server Commands
+
+```bash
+# Development (auto-reload, localhost)
+python manage.py start
+
+# Production (multi-worker, optimized)  
+python manage.py start --production
+
+# Custom configuration
+python manage.py start --host 0.0.0.0 --port 8080 --workers 4
+```
+
+## Testing
+
+```bash
+# SQLite (default)
+python manage.py test
+
+# PostgreSQL (auto Docker bootstrap)
+DATABASE_PROVIDER=asyncpg python manage.py test
+
+# Specific tests
+python manage.py test app.tests.test_models.TestUser.test_creation
+```
+
+## Commands
+
+```bash
+python manage.py start              # Start server
+python manage.py test               # Run tests  
+python manage.py migrate            # Run migrations
+python manage.py startapp posts     # Create new app
+```

neutronapi-0.1.0/README.md

@@ -0,0 +1,170 @@
+# NeutronAPI
+
+**High-performance Python framework built directly on uvicorn with built-in database models, migrations, and background tasks. If you want Django that was built async-first, this is for you.**
+
+Batteries included async API framework with command-line management.
+
+## Installation
+
+```bash
+pip install neutronapi
+```
+
+## Quick Start
+
+```bash
+# 1. Create project
+neutronapi startproject blog
+cd blog
+
+# 2. Create an app
+python manage.py startapp posts
+
+# 3. Start server  
+python manage.py start               # Dev mode (auto-reload)
+
+# 4. Test
+python manage.py test
+```
+
+## Getting Started Tutorial
+
+**1. Create Project**
+```bash
+neutronapi startproject blog
+cd blog
+```
+
+**2. Create App Module**  
+```bash
+python manage.py startapp posts
+```
+
+**3. Configure in `apps/settings.py`**
+```python
+import os
+
+# ASGI application entry point (required for server)
+ENTRY = "apps.entry:app"  # module:variable format
+
+# Database
+DATABASES = {
+    'default': {
+        'ENGINE': 'aiosqlite',
+        'NAME': 'db.sqlite3',
+    }
+}
+```
+
+**4. Create API in `apps/posts/api.py`**
+```python
+from neutronapi.base import API
+
+class PostAPI(API):
+    name = "posts"
+    
+    @API.endpoint("/posts", methods=["GET"])
+    async def list_posts(self, scope, receive, send, **kwargs):
+        posts = [{"id": 1, "title": "Hello World"}]
+        return await self.response(posts)
+    
+    @API.endpoint("/posts", methods=["POST"])
+    async def create_post(self, scope, receive, send, **kwargs):
+        # Get request data from scope["body"]
+        return await self.response({"id": 2, "title": "New Post"})
+```
+
+**5. Register API in `apps/entry.py`**
+```python
+from neutronapi.application import Application
+from apps.posts.api import PostAPI
+
+app = Application({
+    "posts": PostAPI()
+})
+```
+
+**6. Start Server**
+```bash
+python manage.py start
+# Visit: http://127.0.0.1:8000/posts
+```
+
+## Project Structure
+
+```
+myproject/
+├── manage.py           # Management commands
+├── apps/
+│   ├── __init__.py
+│   ├── settings.py     # Configuration 
+│   └── entry.py        # ASGI application
+└── db.sqlite3          # Database
+```
+
+## Background Tasks
+
+```python
+from neutronapi.background import Task, TaskFrequency
+
+class CleanupTask(Task):
+    name = "cleanup"
+    frequency = TaskFrequency.MINUTELY
+    
+    async def run(self, **kwargs):
+        print("Cleaning up logs...")
+
+# Add to application
+app = Application(
+    apis={"ping": PingAPI()},
+    tasks={"cleanup": CleanupTask()}
+)
+
+## Database Models
+
+```python
+from neutronapi.db.models import Model
+from neutronapi.db.fields import CharField, IntegerField, DateTimeField
+
+class User(Model):
+    name = CharField(max_length=100)
+    age = IntegerField()
+    created_at = DateTimeField(auto_now_add=True)
+    
+    # Table name inferred from class name (user -> users)
+```
+
+## Server Commands
+
+```bash
+# Development (auto-reload, localhost)
+python manage.py start
+
+# Production (multi-worker, optimized)  
+python manage.py start --production
+
+# Custom configuration
+python manage.py start --host 0.0.0.0 --port 8080 --workers 4
+```
+
+## Testing
+
+```bash
+# SQLite (default)
+python manage.py test
+
+# PostgreSQL (auto Docker bootstrap)
+DATABASE_PROVIDER=asyncpg python manage.py test
+
+# Specific tests
+python manage.py test app.tests.test_models.TestUser.test_creation
+```
+
+## Commands
+
+```bash
+python manage.py start              # Start server
+python manage.py test               # Run tests  
+python manage.py migrate            # Run migrations
+python manage.py startapp posts     # Create new app
+```

neutronapi-0.1.0/neutronapi/__init__.py

@@ -0,0 +1,21 @@
+"""NeutronAPI - High-performance Python framework built directly on uvicorn.
+
+If you want Django that was built async-first, this is for you.
+"""
+
+__version__ = "0.1.0"
+
+from .base import API, Response, Endpoint
+from .application import Application
+from .background import Background, Task, TaskFrequency, TaskPriority
+
+__all__ = [
+    'API',
+    'Response', 
+    'Endpoint',
+    'Application',
+    'Background',
+    'Task',
+    'TaskFrequency',
+    'TaskPriority',
+]

neutronapi-0.1.0/neutronapi/application.py

@@ -0,0 +1,113 @@
+from typing import Dict, Optional, Callable, List, Any
+import asyncio
+
+from neutronapi.base import API
+from neutronapi.middleware.cors import CORS
+from neutronapi.middleware.routing import RoutingMiddleware
+from neutronapi.middleware.allowed_hosts import AllowedHostsMiddleware
+from neutronapi.background import Background, TaskFrequency, TaskPriority
+
+
+class Application:
+    """ASGI application that composes APIs + middleware + optional background tasks.
+
+    Prefer using this class directly. The create_application() helper remains for compatibility.
+    """
+
+    def __init__(
+        self,
+        apis: Dict[str, API],
+        *,
+        tasks: Optional[Dict[str, Any]] = None,
+        version: str = "1.0.0",
+        allowed_hosts: Optional[List[str]] = None,
+        static_hosts: Optional[List[str]] = None,
+        static_resolver: Optional[Callable] = None,
+        cors_allow_all: bool = True,
+    ) -> None:
+        self.apis = apis
+        self.version = version
+        
+        # Simple handler that routes to APIs
+        async def app(scope, receive, send):
+            if scope["type"] == "http":
+                path = scope.get("path", "/").lstrip("/")
+                
+                # Check if path matches any API
+                if path in self.apis:
+                    api = self.apis[path]
+                    await api.handle(scope, receive, send)
+                    return
+                
+                # Default 404 for unmatched paths
+                await send({
+                    "type": "http.response.start",
+                    "status": 404,
+                    "headers": [[b"content-type", b"text/plain"]],
+                })
+                await send({
+                    "type": "http.response.body",
+                    "body": b"Not Found",
+                })
+        
+        # Skip hosts middleware if no allowed_hosts specified (for testing)
+        if allowed_hosts:
+            hosts_app = AllowedHostsMiddleware(app, allowed_hosts=allowed_hosts)
+        else:
+            hosts_app = app
+        cors_wrapped = CORS(hosts_app, allow_all_origins=cors_allow_all)
+        self.app = RoutingMiddleware(
+            default_app=cors_wrapped,
+            static_hosts=static_hosts,
+            static_resolver=static_resolver,
+        )
+
+        # lifecycle hooks
+        self.app.on_startup = []
+        self.app.on_shutdown = []
+        
+        # Expose lifecycle hooks on Application instance for compatibility
+        self.on_startup = self.app.on_startup
+        self.on_shutdown = self.app.on_shutdown
+
+        # Handle tasks dict - clean API-like pattern
+        if tasks:
+            from neutronapi.background import Background
+            self.background = Background()
+            
+            # Register all tasks
+            for name, task in tasks.items():
+                self.background.register_task(task)
+            
+            async def _start_background():
+                await self.background.start()
+            
+            async def _stop_background():
+                await self.background.stop()
+
+            self.app.on_startup.append(_start_background)
+            self.app.on_shutdown.append(_stop_background)
+
+    async def __call__(self, scope, receive, send, **kwargs):
+        return await self.app(scope, receive, send, **kwargs)
+
+
+def create_application(
+    apis: Dict[str, API],
+    static_hosts: Optional[List[str]] = None,
+    static_resolver: Optional[Callable] = None,
+    allowed_hosts: Optional[List[str]] = None,
+    version: str = "1.0.0",
+    expose_docs: bool = False,  # kept for compatibility; no-op
+):
+    """Compatibility wrapper that returns an Application instance.
+
+    Docs are not injected automatically; pass your own docs API if desired.
+    """
+    return Application(
+        apis,
+        version=version,
+        allowed_hosts=allowed_hosts,
+        static_hosts=static_hosts,
+        static_resolver=static_resolver,
+    )

neutronapi-0.1.0/neutronapi/authentication/__init__.py

@@ -0,0 +1,9 @@
+__all__ = [
+    "JWTAuthentication",
+    "Authentication",
+    "Encryption",
+]
+
+from .base import Authentication
+from .jwt import JWTAuthentication
+from .encryption import Encryption

neutronapi-0.1.0/neutronapi/authentication/base.py

@@ -0,0 +1,34 @@
+import bcrypt
+import asyncio
+from typing import Any, List, Optional
+import abc
+
+
+class Authentication(abc.ABC):
+    @classmethod
+    @abc.abstractmethod
+    async def authenticate(cls, email: str, password: str) -> Optional[Any]:
+        raise NotImplementedError("Subclasses must implement authenticate")
+
+    @classmethod
+    @abc.abstractmethod
+    async def authorize(cls, scope: List[str]) -> bool:
+        raise NotImplementedError("Subclasses must implement authorize")
+
+    @staticmethod
+    async def hash_password(password: str) -> str:
+        def _hash():
+            salt = bcrypt.gensalt()
+            hashed = bcrypt.hashpw(password.encode("utf-8"), salt)
+            return hashed.decode("utf-8")
+
+        return await asyncio.to_thread(_hash)
+
+    @staticmethod
+    async def check_password(hashed_password: str, plain_password: str) -> bool:
+        def _check():
+            return bcrypt.checkpw(
+                plain_password.encode("utf-8"), hashed_password.encode("utf-8")
+            )
+
+        return await asyncio.to_thread(_check)