nexios 0.1.0__tar.gz

nexios-0.1.0/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.1
+Name: nexios
+Version: 0.1.0
+Summary: Nexio is a modern, high-performance ASGI web framework for Python.
+Home-page: https://github.com/techwithdunamix/nexio
+License: MIT
+Author: Chidebele Dunamis
+Author-email: techwithdunamix@example.com
+Requires-Python: >=3.8
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Programming Language :: Python :: 3.13
+Requires-Dist: aerich
+Requires-Dist: anyio
+Requires-Dist: asgiref
+Requires-Dist: tortoise-orm
+Requires-Dist: uvicorn
+Project-URL: Repository, https://github.com/techwithdunamix/nexio
+Description-Content-Type: text/markdown
+
+![Nexio Logo](docs/logo.svg)
+
+# Nexio HTTP Framework 🚀💻
+
+Welcome to Nexio — a lightning-fast web framework built with Python and written by TechWithDunamix, a Nigerian developer! 🇳🇬💡 Whether you're building APIs, web apps, or anything in between, Nexio is here to make your life easier and faster! ⚡
+
+## Why Nexio? 🤔
+
+- **Blazing Fast**: Built with performance in mind. Don't blink or you might miss it! ⚡
+- **Simplicity**: Write less code, get more done. You'll spend less time debugging and more time building cool stuff. 👨‍💻
+- **Easy to Use**: Everything is straightforward, from routing to database setup — no complicated setups, just plug and play! 🔌🎮
+
+## Quick Start 🚀
+
+Ready to get started? Here's how you can set up Nexio and make your first web app in minutes:
+
+
+### 1. Install Dependencies 📦
+
+Install Nexio and the required dependencies with pip:
+
+```bash
+pip install git+https://github.com/TechWithDunamix/Nexio.git
+```
+
+### 2. Create Your First App 💻
+
+```bash
+nexio create <app_name>
+```
+##### Outputs
+```md
+To get started
+1. cd <app_name>
+    
+2. cd <app_name>
+    
+3. Your app will be available at http://localhost:8000
+```
+# Folder structure
+
+```txt
+project_name/
+├── config/
+│   ├── __init__.py
+│   ├── database.py
+│   └── settings.py
+├── handlers/
+│   ├── __init__.py
+│   └── routes.py
+└── main.py
+```
+
+
+###  Basic Example
+
+```python
+from nexio import get_application
+import uvicorn
+from nexio.routers import Routes
+app = get_application()
+
+async def home(req,res):
+    res.json({"text" :"hello welcome to nexio"})
+
+app.add_route(Routes("/",home))
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+```
+
+
+# Nexio Project Structure Documentation
+
+
+```
+project_name/
+├── config/
+│   ├── __init__.py
+│   ├── database.py
+│   └── settings.py
+├── handlers/
+│   ├── __init__.py
+│   └── routes.py
+└── main.py
+```
+
+## File Descriptions
+
+### main.py
+The application entry point and core configuration file.
+```python
+# Key responsibilities:
+- Initializes the Nexio application
+- Sets up database connections
+- Configures startup/shutdown hooks
+- Mounts routes
+- Starts the ASGI server
+```
+
+Key features:
+- `get_application()`: Creates the main ASGI application instance
+- `connect_db()`: Database connection setup on startup
+- `disconnect_db()`: Clean database shutdown
+- Uvicorn server configuration
+
+### config/database.py
+Database configuration and connection settings.
+```python
+# Key responsibilities:
+- Defines database connection parameters
+- Configures ORM settings
+- Sets up model locations
+```
+
+Key components:
+- `TORTOISE_ORM`: ORM configuration dictionary
+  - Database URL configuration
+  - Model locations and namespacing
+  - Connection settings
+
+### config/settings.py
+Application-wide configuration and settings.
+```python
+# Key responsibilities:
+- Defines core application settings
+- Manages security configurations
+- Sets environment-specific variables
+```
+
+Key settings:
+- `AppConfig`: Application configuration class
+- `SECRET_KEY`: Security key for sessions/encryption
+- Can be extended for additional settings:
+  - Debug modes
+  - API versions
+  - Environment configurations
+
+### handlers/routes.py
+HTTP request handlers and route definitions.
+```python
+# Key responsibilities:
+- Defines endpoint handlers
+- Processes HTTP requests
+- Returns responses
+```
+
+Key components:
+- `home_handler`: Example route handler
+- Request processing logic
+- Response formatting
+- URL parameter handling
+
+## Usage Notes
+
+1. **Configuration Priority**:
+   - `settings.py` loads first
+   - `database.py` uses settings for configuration
+   - `main.py` brings everything together
+
+2. **Database Management**:
+   - Uses Tortoise ORM
+   - Automatic schema generation
+   - Connection lifecycle management
+
+3. **Request Flow**:
+```
+Request → main.py → routes.py → handler → response
+```
+
+4. **Development Workflow**:
+   1. Modify settings in `config/`
+   2. Add routes in `handlers/routes.py`
+   3. Run application from `main.py`
+
+## Common Extensions
+
+The basic structure can be extended with:
+
+1. **Additional Directories**:
+   - `models/`: Database models
+   - `middlewares/`: Custom middleware
+   - `schemas/`: Data validation
+   - `services/`: Business logic
+
+2. **Configuration Files**:
+   - `logging.py`: Logging configuration
+   - `middleware.py`: Middleware settings
+   - `constants.py`: Application constants
+
+## Best Practices
+
+1. **Configuration**:
+   - Keep sensitive data in environment variables
+   - Use different settings for development/production
+   - Document all configuration options
+
+2. **Route Handlers**:
+   - Keep handlers focused and simple
+   - Use type hints for better code clarity
+   - Return consistent response formats
+
+3. **Database**:
+   - Use migrations for schema changes
+   - Implement proper connection pooling
+   - Handle connection errors gracefully
+
+## Quick Start
+```bash
+# 1. Install dependencies
+pip install git+https://github.com/TechWithDunamix/Nexio.git
+
+
+# 2. Run the application
+uvicorn main:app --reload
+
+# 3. Access the API
+curl http://localhost:8000
+```
+
+The application will be available at `http://localhost:8000` with:
+- Database auto-configuration
+- Basic route setup
+- Error handling
+- Clean shutdown support

nexios-0.1.0/nexios/__init__.py

@@ -0,0 +1,33 @@
+from .application import NexioApp 
+from .sessions.middlewares import SessionMiddleware
+from .middlewares.logging import ErrorHandlerMiddleware
+from .middlewares.common import CommonMiddleware
+from .config.settings import BaseConfig
+from .routers import Router
+from .middlewares.cors import CORSMiddleware
+import os
+def get_application(config = BaseConfig) -> NexioApp:
+    config=config()
+    
+    
+    app = NexioApp(
+        middlewares= [
+            ErrorHandlerMiddleware(),
+            CommonMiddleware(),
+            CORSMiddleware(
+                allow_origins=config.CORS_ALLOWED_ORIGINS,
+                blacklist_origins=config.CORS_BLACKLISTED_ORIGINS,
+                allow_methods=config.CORS_ALLOWED_METHODS,
+                allow_credentials=config.CORS_ALLOW_CREDENTIALS,
+                allow_headers=config.CORS_ALLOW_HEADERS,
+                expose_headers = config.EXPOSE_HEADERS,
+                allow_origin_regex=config.ALLOW_ORIGIN_REGEX
+                
+                
+                )
+
+        ],
+        config=config
+    )
+    
+    return app

nexios-0.1.0/nexios/application.py

@@ -0,0 +1,161 @@
+from typing import Any, Callable, AsyncIterator, List, Union
+from .http.request import Request
+from .http.response import NexioResponse
+from .http.response import JSONResponse
+from .types import HTTPMethod
+from .decorators import AllowedMethods
+from .routers import Router, Routes
+from enum import Enum
+from .config.settings import BaseConfig
+import logging
+from contextlib import asynccontextmanager
+
+class NexioApp:
+    def __init__(self, 
+                 config: Enum = BaseConfig,
+                 middlewares: list = None):
+        self.config = config
+        self.routes: List[str] = []
+        self.middlewares: List = middlewares or []
+        self.startup_handlers: List[Callable] = []
+        self.shutdown_handlers: List[Callable] = []
+        self.logger = logging.getLogger("nexio")
+
+    def on_startup(self, handler: Callable) -> Callable:
+        """Decorator to register startup handlers"""
+        self.startup_handlers.append(handler)
+        return handler
+
+    def on_shutdown(self, handler: Callable) -> Callable:
+        """Decorator to register shutdown handlers"""
+        self.shutdown_handlers.append(handler)
+        return handler
+
+    async def startup(self) -> None:
+        """Execute all startup handlers sequentially"""
+        for handler in self.startup_handlers:
+            await handler()
+
+    async def shutdown(self) -> None:
+        """Execute all shutdown handlers sequentially with error handling"""
+        for handler in self.shutdown_handlers:
+            try:
+                await handler()
+            except Exception as e:
+                self.logger.error(f"Shutdown handler error: {str(e)}")
+
+    async def handle_lifespan(self, receive: Callable, send: Callable) -> None:
+        """Handle ASGI lifespan protocol events"""
+        try:
+            while True:
+                message = await receive()
+                
+                if message["type"] == "lifespan.startup":
+                    try:
+                        await self.startup()
+                        await send({"type": "lifespan.startup.complete"})
+                    except Exception as e:
+                        self.logger.error(f"Startup error: {str(e)}")
+                        await send({"type": "lifespan.startup.failed", "message": str(e)})
+                        return
+                
+                elif message["type"] == "lifespan.shutdown":
+                    try:
+                        await self.shutdown()
+                        await send({"type": "lifespan.shutdown.complete"})
+                        return
+                    except Exception as e:
+                        self.logger.error(f"Shutdown error: {str(e)}")
+                        await send({"type": "lifespan.shutdown.failed", "message": str(e)})
+                        return
+
+        except Exception as e:
+            self.logger.error(f"Lifespan error: {str(e)}")
+            if message["type"].startswith("lifespan.startup"):
+                await send({"type": "lifespan.startup.failed", "message": str(e)})
+            else:
+                await send({"type": "lifespan.shutdown.failed", "message": str(e)})
+
+    async def execute_middleware_stack(self, 
+                                     request: Request,
+                                     response: NexioResponse, 
+                                     middleware: Callable, 
+                                     handler: Callable, 
+                                     **kwargs) -> Any:
+        stack = self.middlewares.copy()
+        if callable(middleware):
+            stack.append(middleware)
+        index = -1 
+        
+        async def next_middleware():
+            nonlocal index
+            index += 1
+            
+            if index < len(stack):
+                middleware = stack[index]
+                return await middleware(request, response, next_middleware, **kwargs)
+            else:
+                return await handler(request, response, **kwargs)
+            
+        return await next_middleware()
+
+    async def handle_request(self, scope: dict, receive: Callable, send: Callable) -> None:
+        request = Request(scope, receive, send)
+        response = NexioResponse()
+        request.scope['config'] = self.config
+
+        for path_pattern, handler, middleware in self.routes:
+            match = path_pattern.match(request.url.path)
+            if match:
+                kwargs = match.groupdict()
+                request.url_params = kwargs
+                
+                try:
+                    await self.execute_middleware_stack(request,
+                                                      response,
+                                                      middleware,
+                                                      handler)
+                except Exception as e:
+                    self.logger.error(f"Request handler error: {str(e)}")
+                    error_response = JSONResponse(
+                        {"error": str(e)},
+                        status_code=500
+                    )
+                    await error_response(scope, receive, send)
+                    return
+                await response(scope, receive, send)
+                return
+
+        error_response = JSONResponse({"error": "Not found"}, status_code=404)
+        await error_response(scope, receive, send)
+
+    def route(self, path: str, methods: List[Union[str, HTTPMethod]] = None) -> Callable:
+        """Decorator to register routes with optional HTTP methods"""
+        def decorator(handler: Callable) -> Callable:
+            handler = AllowedMethods(methods)(handler)
+            self.add_route(Routes(path, handler))
+            return handler
+        return decorator
+
+    def add_route(self, route: Routes) -> None:
+        """Add a route to the application"""
+        
+        route, handler, middleware = route()
+        self.routes.append((route, handler, middleware))
+
+    def add_middleware(self, middleware: Callable) -> None:
+        """Add middleware to the application"""
+        if callable(middleware):
+            self.middlewares.append(middleware)
+
+    def mount_router(self, router: Router) -> None:
+        """Mount a router and all its routes to the application"""
+        for route in router.get_routes():
+            self.add_route(route)
+
+    async def __call__(self, scope: dict, receive: Callable, send: Callable) -> None:
+        """ASGI application callable"""
+        if scope["type"] == "lifespan":
+            await self.handle_lifespan(receive, send)
+        elif scope["type"] == "http":    
+            await self.handle_request(scope, receive, send)

nexios-0.1.0/nexios/background.py

@@ -0,0 +1,44 @@
+
+from nexios.utils.cuncurrency import run_in_threadpool
+from __future__ import annotations
+import sys
+import typing
+
+if sys.version_info >= (3, 10):  
+    from typing import ParamSpec
+else: 
+    from typing_extensions import ParamSpec
+
+
+
+P = ParamSpec("P")
+T = typing.TypeVar("T")
+AwaitableCallable = typing.Callable[..., typing.Awaitable[T]]
+
+@typing.overload
+def is_async_callable(obj: AwaitableCallable[T]): ...
+class BackgroundTask:
+    def __init__(self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs) -> None:
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.is_async = is_async_callable(func)
+
+    async def __call__(self) -> None:
+        if self.is_async:
+            await self.func(*self.args, **self.kwargs)
+        else:
+            await run_in_threadpool(self.func, *self.args, **self.kwargs)
+
+
+class BackgroundTasks(BackgroundTask):
+    def __init__(self, tasks: typing.Sequence[BackgroundTask] | None = None):
+        self.tasks = list(tasks) if tasks else []
+
+    def add_task(self, func: typing.Callable[P, typing.Any], *args: P.args, **kwargs: P.kwargs) -> None:
+        task = BackgroundTask(func, *args, **kwargs)
+        self.tasks.append(task)
+
+    async def __call__(self) -> None:
+        for task in self.tasks:
+            await task()

nexios-0.1.0/nexios/cli/create_project.py

@@ -0,0 +1,161 @@
+import os
+
+def create_project_structure(project_name: str):
+    """Create the basic project structure for a Nexio application."""
+    
+    # Base directories
+    directories = [
+        f"{project_name}/controllers",
+    ]
+    
+    # Create directories
+    for directory in directories:
+        os.makedirs(directory, exist_ok=True)
+        create_file(f"{directory}/__init__.py", "")
+    
+    # Create main application files
+    create_file(f"{project_name}/main.py", main_code())
+    create_file(f"{project_name}/models.py", models_code())
+    create_file(f"{project_name}/settings.py", settings_code())
+    create_file(f"{project_name}/controllers/home_handler.py", routes_code())
+    create_file(f"{project_name}/README.md", readme_code())
+
+    print(f"\n✨ Created new Nexio project: {project_name}")
+    print("\nProject structure:")
+    print(f"""
+{project_name}/
+├── controllers/
+│   └── home_handler.py
+├── main.py
+├── models.py
+├── settings.py
+└── README.md
+    """)
+    
+    print("\nTo get started:")
+    print(f"1. cd {project_name}")
+    print("2. Install dependencies using `pip install -r requirements.txt`")
+    print("3. Run migrations using Aerich:")
+    print("   - `aerich init -t settings.TORTOISE_ORM`")
+    print("   - `aerich migrate`")
+    print("   - `aerich upgrade`")
+    print("4. Run the app with uvicorn:")
+    print("   - `uvicorn main:app --reload`")
+    print("\nYour app will be available at http://localhost:8000")
+
+def create_file(file_path: str, content: str):
+    """Create a file with the given content."""
+    with open(file_path, "w") as f:
+        f.write(content)
+
+def main_code():
+    return '''import uvicorn
+from nexio import get_application
+from nexio.routers import Routes
+from tortoise import Tortoise as db
+from contextlib import asynccontextmanager
+import traceback
+import os
+
+from settings import AppConfig
+from controllers.home_handler import home_handler
+
+# Initialize app
+app = get_application(config=AppConfig)
+
+@app.on_startup
+async def connect_db():
+    try:
+        db_path = os.path.join(os.path.dirname(__file__), "db.sqlite3")
+        await db.init(
+            db_url=f"sqlite:///{db_path}",
+            modules={"models": ["models"]}  # Use models.py directly
+        )
+        await db.generate_schemas()
+        print("Database connected")
+    except Exception as e:
+        print(f"Database connection error: {e}")
+        print(traceback.format_exc())
+
+@app.on_shutdown
+async def disconnect_db():
+    try:
+        await db.close_connections()
+        print("Database disconnected")
+    except Exception as e:
+        print(f"Database disconnect error: {e}")
+
+app.add_route(Routes("/", home_handler))
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="127.0.0.1", port=8000)
+'''
+
+def models_code():
+    return '''
+'''
+
+def settings_code():
+    return '''
+    import os
+    from nexio.config.settings import BaseConfig
+
+migration = {
+    "connections": {
+        "default": f"sqlite://{os.path.join(os.path.dirname(__file__), 'database.db')}"
+    },
+    "apps": {
+        "models": {
+            "models": ["nexio.sessions.models","aerich.models"], 
+            "default_connection": "default",
+        },
+    },
+}
+
+class AppConfig(BaseConfig):
+    SECRET_KEY = "your-secret-key"  # Change this in production!
+'''
+
+def routes_code():
+    return '''from nexio.http.request import Request
+from nexio.http.response import NexioResponse
+
+async def home_handler(request: Request, response: NexioResponse, **kwargs):
+    return response.json({
+        "message": "Welcome to your new Nexio application!",
+        "docs": "https://nexio.example.com/docs"  
+    })
+'''
+
+def readme_code():
+    return '''# Nexio Application Setup
+
+## Requirements
+- Python 3.8 or later
+- [Aerich](https://github.com/tortoise/aerich) for migrations
+- [Uvicorn](https://www.uvicorn.org/) for running the app
+
+## Setup Instructions
+
+1. Install the required dependencies:
+   ```bash
+   
+Migrate the database: Run the following command to create the initial migration files:
+
+```bash
+
+aerich init -t settings.migration
+Then, run the following command to apply the migrations to the database:
+```
+bash
+```
+aerich migrate
+aerich upgrade
+```
+To start the application, use Uvicorn:
+
+``bash
+
+uvicorn main:app --reload
+```
+'''

nexios-0.1.0/nexios/cli/main.py

@@ -0,0 +1,20 @@
+import argparse
+from nexios.cli.create_project import create_project_structure
+
+def main():
+    parser = argparse.ArgumentParser(prog="nexio")
+    subparsers = parser.add_subparsers(dest="command")
+    
+    # 'create' subcommand
+    create_parser = subparsers.add_parser('create', help="Create a new Nexio project")
+    create_parser.add_argument('project_name', type=str, help="The name of the project to create")
+    
+    args = parser.parse_args()
+    
+    if args.command == "create":
+        create_project_structure(args.project_name)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

nexios-0.1.0/nexios/config/__init__.py

@@ -0,0 +1 @@
+from .settings import BaseConfig

nexios-0.1.0/nexios/config/settings.py

@@ -0,0 +1,21 @@
+
+from typing import Any
+
+
+class BaseConfig:
+
+    debug :bool  = False
+
+    middleware :list = [] 
+
+    COOKIE_AGE = 259200
+
+
+    def __getattribute__(self, name: str) -> Any:
+        try:
+            return super().__getattribute__(name)
+            
+        except AttributeError:
+            return None
+
+