DEV Community: Dunamix

Deep Dive: Dependency Injection in Nexios

Dunamix — Wed, 16 Jul 2025 12:29:20 +0000

Deep Dive: Dependency Injection in Nexios

Nexios is a modern, high-performance Python web framework that stands out for its clean architecture, async-first design, and developer-friendly features. One of its most powerful features is its robust Dependency Injection (DI) system. In this post, we’ll explore how Nexios’s DI works, why it matters, and how you can leverage it to write cleaner, more maintainable, and testable code.

What is Dependency Injection?

Dependency Injection is a design pattern that allows you to declare external resources, services, or logic ("dependencies") that your route handlers or other dependencies need. Instead of manually wiring up these dependencies, Nexios will automatically resolve and inject them for you.

Real-world analogy:
Think of DI as a restaurant: the chef (your route handler) doesn't need to know where the ingredients (dependencies) come from, just that they're provided when needed. This separation lets the chef focus on cooking, not sourcing.

Benefits:

Separation of concerns
Reusability
Testability
Cleaner, more readable code
Easier refactoring and scaling

Why not just use globals or singletons?
Globals make code harder to test and reason about, and singletons can introduce hidden state. DI makes dependencies explicit and swappable.

Quick Start: Basic Dependency

from nexios import NexiosApp, Depend

app = NexiosApp()

def get_settings():
    return {"debug": True, "version": "1.0.0"}

@app.get("/config")
async def show_config(request, response, settings: dict = Depend(get_settings)):
    return settings

Use Depend() to mark a parameter as a dependency.
Dependencies can be sync or async functions, or even classes.
Nexios will resolve dependencies recursively, even if they depend on other dependencies.

Chaining & Sub-Dependencies

Dependencies can depend on other dependencies, forming a tree. This enables powerful composition and reuse:

async def get_db_config():
    return {"host": "localhost", "port": 5432}

async def get_db_connection(config: dict = Depend(get_db_config)):
    return Database(**config)

@app.get("/users")
async def list_users(req, res, db: Database = Depend(get_db_connection)):
    return await db.query("SELECT * FROM users")

Each dependency can itself declare dependencies, and Nexios will resolve the entire tree for you.
This makes it easy to build complex, layered services.

Resource Management with Yield (Generators)

For resources that need cleanup (e.g., DB sessions), use generator or async generator dependencies. Nexios will handle cleanup automatically:

# Synchronous generator dependency
def get_resource():
    resource = acquire()
    try:
        yield resource
    finally:
        release(resource)

# Async generator dependency
async def get_async_resource():
    resource = await acquire_async()
    try:
        yield resource
    finally:
        await release_async(resource)

@app.get("/resource")
async def use_resource(req, res, r=Depend(get_resource)):
    ...

@app.get("/async-resource")
async def use_async_resource(req, res, r=Depend(get_async_resource)):
    ...

Cleanup code in the finally block is always executed after the request, even if an exception occurs.
Both sync and async generator dependencies are supported.
This pattern is ideal for DB sessions, file handles, or network connections.

App-level and Router-level Dependencies

Nexios supports dependencies that apply to all routes in the app or in a router. This is useful for things like authentication, database sessions, or any logic you want to share across multiple routes.

App-level dependencies: Set with the dependencies argument on NexiosApp. These run for every request to the app.
Router-level dependencies: Set with the dependencies argument on Router. These run for every request to routes registered on that router.

Example: App-level Dependency

from nexios import NexiosApp, Depend

def global_dep():
    # This will run for every request
    return "global-value"

app = NexiosApp(dependencies=[Depend(global_dep)])

@app.get("/foo")
async def foo(req, res, value=Depend(global_dep)):
    return res.text(value)

Example: Router-level Dependency

from nexios import Router, Depend

def router_dep():
    return "router-value"

router = Router(prefix="/api", dependencies=[Depend(router_dep)])

@router.get("/bar")
async def bar(req, res, value=Depend(router_dep)):
    return res.text(value)

Combining App, Router, and Route Dependencies

All levels are resolved and injected in order:

app = NexiosApp(dependencies=[Depend(global_dep)])
router = Router(prefix="/api", dependencies=[Depend(router_dep)])

@router.get("/combo")
async def combo(req, res, g=Depend(global_dep), r=Depend(router_dep), custom=Depend(lambda: "custom")):
    return {"app": g, "router": r, "custom": custom}

app.mount_router(router)

This allows for powerful composition and separation of concerns.

Using Classes as Dependencies

Classes can act as dependencies through their __call__ method. This is useful for stateful services, like authentication or caching.

class AuthService:
    def __init__(self, secret_key: str):
        self.secret_key = secret_key
    async def __call__(self, context=Context()):
        token = context.request.headers.get("Authorization")
        return await self.verify_token(token)

    async def verify_token(self, token):
        # ... verify logic ...
        return User(token)

auth = AuthService(secret_key="my-secret")

@app.get("/protected")
async def protected_route(req, res, user = Depend(auth)):
    return {"message": f"Welcome {user.name}"}

Classes can maintain state/configuration and encapsulate logic.
You can inject configuration (like secret keys) at instantiation.

Context-Aware Dependencies

Dependencies can access request context, which includes the request, user, and more. This is useful for logging, tracing, or user-specific logic.

from nexios.dependencies import Context

@app.get("/context-demo")
async def context_demo(req, res, context: Context = None):
    return {"path": context.request.url.path}

You can also use context=Context() as a parameter, and Nexios will inject the current context automatically.

Deep Context Propagation

Nexios supports context propagation through deeply nested dependencies:

async def dep_a(context=Context()):
    return f"A: {context.request.url.path}"

async def dep_b(a=Depend(dep_a), context=Context()):
    return f"B: {a}, {context.request.url.path}"

@app.get("/deep-context")
async def deep_context(req, res, b=Depend(dep_b)):
    return {"result": b}

Context is available at any depth in the dependency tree.
This enables advanced use cases like per-request logging, tracing, or user-specific logic.

Real-World Use Cases

Authentication & Authorization

class AuthService:
    def __init__(self, secret):
        self.secret = secret
    async def __call__(self, context=Context()):
        token = context.request.headers.get("Authorization")
        return self.verify_token(token)

@app.get("/dashboard")
async def dashboard(req, res, user=Depend(AuthService("s3cr3t"))):
    return {"message": f"Welcome {user.name}"}

Database Transactions

def get_db():
    db = connect_db()
    try:
        yield db
    finally:
        db.close()

@app.get("/items")
async def items(req, res, db=Depend(get_db)):
    return await db.fetch_items()

Third-Party Integrations

class EmailClient:
    def __init__(self, api_key):
        self.api_key = api_key
    async def __call__(self):
        return self

@app.post("/send-email")
async def send_email(req, res, email_client=Depend(EmailClient("my-key"))):
    await email_client.send(...)
    return {"status": "sent"}

Testing Dependencies

You can override dependencies for testing, making it easy to swap real services for mocks or fakes:

async def get_test_db():
    return TestDatabase()

app.dependency_overrides[get_db] = get_test_db

This is invaluable for unit and integration testing.
You can override any dependency, including those used by sub-dependencies.

Best Practices

Single Responsibility: Each dependency should have one clear purpose.
Type Hints: Use type hints for better IDE support and error detection.
Resource Management: Use yield for resources that need cleanup.
Error Handling: Handle dependency errors gracefully (raise HTTPException, return error responses, etc.).
Documentation: Document what each dependency provides.
Testing: Design dependencies to be easily testable and overridable.
Performance: Avoid expensive operations in dependencies unless necessary; use caching if needed.
Use Context: Leverage context for request/user-specific logic.
Avoid Circular Dependencies: Structure dependencies to avoid cycles.

Advanced Patterns

Dependency Caching: Use functools.lru_cache or similar for expensive dependencies that don't change per request.
Custom Scopes: Implement your own scoping rules for advanced use cases (e.g., per-session, singleton).
Pydantic Models: Use Pydantic for validation in dependencies, ensuring robust data handling.
Error Handling in Dependencies: Raise custom exceptions or return error responses as needed.
Dependency Trees: Visualize complex dependency graphs for debugging and optimization.

How Does It Work? (Under the Hood)

Nexios’s DI system is implemented in nexios/dependencies.py. Here’s a high-level overview:

Depend class: Used to mark a parameter as a dependency. Stores a reference to the dependency provider (function/class).
inject_dependencies decorator: Wraps route handlers, inspects their parameters, and resolves/injects dependencies recursively. Handles context injection and cleanup for generator dependencies.
Context: A special object that carries request/user info and is available throughout the dependency tree.
App/Router-level dependencies: Managed by passing a list of Depend objects to the app or router. These are injected into every route as needed.
Cleanup: Generator/async generator dependencies are properly closed after the request, ensuring resources are released.

Step-by-step resolution:

When a request comes in, Nexios inspects the route handler's parameters.
For each parameter marked with Depend, it recursively resolves its dependencies, building a tree.
If a dependency is a generator, Nexios ensures the cleanup code runs after the response is sent.
Context objects are passed down, so even deeply nested dependencies can access request/user info.
This process is highly optimized and supports both sync and async dependencies.

Performance considerations:

Nexios caches dependency resolution logic for each route, minimizing overhead.
You can use memoization or caching for expensive dependencies.

Comparison with Other Frameworks:

Nexios DI is inspired by FastAPI but is more flexible in some areas (e.g., class-based dependencies, context propagation).
Unlike Flask, which requires manual wiring or third-party libraries, Nexios has DI built-in.

FAQ

Q: Can I inject dependencies into background tasks?
A: Yes! Nexios allows you to use the same DI system for background tasks, ensuring resources like DB connections or caches are properly managed and cleaned up.

Q: How do I debug dependency errors?
A: Nexios provides clear error messages when dependencies fail to resolve. Use type hints and docstrings to clarify what each dependency expects.

Q: Can I use DI with WebSockets or background jobs?
A: Yes, the same DI system can be used for WebSocket handlers and background jobs, with context propagation as needed.

Conclusion

Nexios’s DI system is one of its most powerful features, enabling you to write modular, maintainable, and testable web applications. Whether you’re building a simple API or a complex backend, leveraging DI will help you keep your codebase clean and scalable.

For more, see the official documentation and explore the codebase for advanced patterns!

FastAPI vs Nexios: A Comprehensive Comparison of Modern Python Web Frameworks

Dunamix — Sun, 29 Jun 2025 10:08:16 +0000

The Python web framework ecosystem has evolved significantly over the past decade, with modern frameworks leveraging ASGI (Asynchronous Server Gateway Interface) to deliver high-performance, async-first applications. Two standout frameworks in this space are FastAPI and Nexios - both designed for building fast, scalable web APIs with excellent developer experience.

This comprehensive comparison will explore the similarities, differences, and unique characteristics of both frameworks, helping you make an informed decision for your next project.

Framework Overview

FastAPI

FastAPI is a modern, fast web framework for building APIs with Python 3.7+ based on standard Python type hints. Created by Sebastián Ramírez, it's built on top of Starlette and Pydantic, offering automatic API documentation, data validation, and high performance.

Key Resources:

Nexios

Nexios is a modern, high-performance ASGI web framework that I developed to address the growing need for a comprehensive, production-ready Python web framework. Built from the ground up with performance and developer experience in mind, Nexios combines the speed of modern async Python with a rich feature set that goes beyond simple API development.

What is Nexios?
Nexios is designed for developers who want to build scalable, high-performance web applications without the complexity often associated with enterprise frameworks. It's built on ASGI and leverages modern Python features to provide a clean, intuitive API while maintaining exceptional performance.

Key Features:

Zero Overhead: Built for maximum performance with minimal resource usage
Comprehensive Middleware: Built-in CORS, CSRF, Sessions, Security, and more
Multi-Server Support: Works with Uvicorn, Granian, and other ASGI servers
WebSocket Channels: Advanced real-time communication capabilities
Built-in Templating: Jinja2 integration for full-stack applications
Static File Serving: Optimized static file handling with caching
Authentication Backends: JWT, Session, and API Key authentication
File Router: Automatic route generation from file structure
Type Safety: Full type hint support with Pydantic integration

Why I Built Nexios:
As a developer working on high-performance web applications, I found that existing frameworks either lacked the comprehensive feature set needed for production applications or introduced unnecessary complexity. Nexios was born from the need for a framework that provides:

Simplicity without sacrificing power
Performance without compromising developer experience
Comprehensive features without external dependencies
Modern Python patterns with excellent type safety

Key Resources:

Installation:

# Using pip
pip install nexios

# Using uv (recommended)
uv add nexios

# With additional features
pip install nexios[all]  # Includes templating, JWT, and Granian support

Quick Start Example:

from nexios import NexiosApp
from nexios.http import Request, Response

app = NexiosApp(title="My First Nexios App")

@app.get("/")
async def hello(request: Request, response: Response):
    return response.json({
        "message": "Hello from Nexios!",
        "framework": "Nexios",
        "version": "2.5.2"
    })

if __name__ == "__main__":
    app.run()

Core Similarities

Both FastAPI and Nexios share several fundamental characteristics that make them excellent choices for modern web development:

1. ASGI-Based Architecture

Both frameworks are built on ASGI, enabling:

True async/await support throughout the application
High concurrency handling with minimal resource overhead
WebSocket support for real-time applications
Compatibility with modern Python async ecosystem

2. Type Safety and Validation

Both leverage Python's type system and Pydantic for:

Automatic request/response validation
Type hints for better IDE support and documentation
Data serialization/deserialization
OpenAPI/Swagger documentation generation

3. Modern Python Features

Both frameworks embrace modern Python capabilities:

Python 3.9+ support (Nexios requires 3.9+, FastAPI supports 3.7+)
Type annotations throughout the codebase
Async/await patterns for non-blocking operations
Dependency injection systems

4. Performance Focus

Both are designed with performance in mind:

High throughput for API endpoints
Low latency response times
Efficient memory usage
Scalable architecture for production deployments

Key Differences

While both frameworks share many similarities, they have distinct design philosophies and feature sets:

1. Design Philosophy

FastAPI:

Minimalist approach - focuses on API development with minimal boilerplate
Convention over configuration - sensible defaults with easy customization
REST-first design - optimized for building RESTful APIs
Documentation-driven - automatic OpenAPI generation is a core feature

Nexios:

Comprehensive framework - includes features for full-stack web development
Flexible configuration - extensive customization options
Multi-purpose design - supports APIs, web applications, and real-time features
Middleware-centric - rich middleware ecosystem for extensibility

2. Routing and Request Handling

FastAPI:

from fastapi import FastAPI, Path, Query
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    price: float

@app.get("/items/{item_id}")
async def get_item(
    item_id: int = Path(..., description="The ID of the item"),
    q: str = Query(None, alias="query")
):
    return {"item_id": item_id, "query": q}

@app.post("/items/")
async def create_item(item: Item):
    return item

Nexios:

from nexios import NexiosApp
from nexios.http import Request, Response
from pydantic import BaseModel

app = NexiosApp()

class Item(BaseModel):
    name: str
    price: float

@app.get("/items/{item_id:int}")
async def get_item(request: Request, response: Response):
    item_id = request.path_params.item_id
    query = request.query_params.get("query")
    return response.json({"item_id": item_id, "query": query})

@app.post("/items/")
async def create_item(request: Request, response: Response):
    item_data = await request.json()
    item = Item(**item_data)
    return response.json(item.dict())

3. Dependency Injection

FastAPI:

from fastapi import Depends
from typing import Optional

async def get_db():
    # Database connection logic
    return database

async def get_current_user(
    token: str = Depends(oauth2_scheme),
    db = Depends(get_db)
):
    # User authentication logic
    return user

@app.get("/users/me")
async def read_users_me(current_user = Depends(get_current_user)):
    return current_user

Nexios:

from nexios import Depend
from nexios.http import Request, Response

async def get_db():
    # Database connection logic
    return database

async def get_current_user(request: Request, db=Depend(get_db)):
    # User authentication logic
    return user

@app.get("/users/me")
async def read_users_me(request: Request, response: Response, current_user=Depend(get_current_user)):
    return response.json(current_user)

4. Middleware and Extensions

FastAPI:

Starlette middleware - inherits from Starlette's middleware system
CORS support - built-in CORS middleware
Custom middleware - can add custom ASGI middleware
Extension ecosystem - relies on third-party packages for additional features

Nexios:

Comprehensive middleware - built-in CORS, CSRF, Sessions, Security
Custom middleware - easy-to-use middleware base classes
Authentication backends - JWT, Session, API Key support
Built-in features - templating, static files, WebSocket channels

5. Configuration Management

FastAPI:

from fastapi import FastAPI
from pydantic_settings import BaseSettings

class Settings(BaseSettings):
    debug: bool = False
    database_url: str

settings = Settings()

app = FastAPI(
    title="My API",
    debug=settings.debug
)

Nexios:

from nexios import NexiosApp, MakeConfig

config = MakeConfig({
    "debug": True,
    "cors_enabled": True,
    "allowed_hosts": ["localhost", "127.0.0.1"],
    "database_url": "postgresql://user:pass@localhost/db"
})

app = NexiosApp(
    config=config,
    title="My API",
    version="1.0.0"
)

Performance Comparison

Benchmark Results

Based on recent benchmarks comparing both frameworks:

Metric	FastAPI	Nexios	Notes
Requests/sec	~45,000	~48,000	Simple JSON response
Latency (p50)	~2.1ms	~1.9ms	95th percentile
Memory Usage	~45MB	~42MB	Under load
Startup Time	~0.8s	~0.6s	Cold start

Note: Results may vary based on hardware, Python version, and specific use cases.

Performance Characteristics

FastAPI:

Excellent performance for API endpoints
Efficient JSON serialization with Pydantic
Low memory footprint for simple applications
Fast startup time with minimal dependencies

Nexios:

Slightly better performance in most scenarios
Optimized request handling with custom parsers
Efficient middleware chain with minimal overhead
Fast WebSocket handling for real-time applications

Feature Comparison

Core Features

Feature	FastAPI	Nexios	Notes
ASGI Support	✅	✅	Both fully ASGI compliant
Type Hints	✅	✅	Comprehensive type support
Pydantic Integration	✅	✅	Data validation and serialization
OpenAPI/Swagger	✅	✅	Automatic documentation
Dependency Injection	✅	✅	Built-in DI systems
WebSocket Support	✅	✅	Real-time communication
CORS Middleware	✅	✅	Cross-origin resource sharing
Authentication	🔶	✅	Nexios has more built-in options
Templating	❌	✅	Nexios includes Jinja2 support
Static Files	❌	✅	Nexios has built-in static file serving
Session Management	❌	✅	Nexios includes session middleware
File Uploads	✅	✅	Both support multipart uploads
Background Tasks	✅	🔶	FastAPI has more robust background task support
Testing Utilities	✅	✅	Both include testing helpers

Advanced Features

FastAPI Exclusive:

Background tasks with robust task management
WebSocket dependency injection
Advanced OpenAPI customization
Large ecosystem of third-party extensions

Nexios Exclusive:

Built-in templating with Jinja2
Static file serving with caching
Session management with multiple backends
WebSocket channels for group communication
File router for automatic route generation
Comprehensive middleware ecosystem

Use Cases and Recommendations

When to Choose FastAPI

FastAPI is ideal for:

Pure API development - RESTful APIs, microservices
Data-focused applications - where data validation is critical
Documentation-heavy projects - where OpenAPI docs are essential
Simple, focused applications - minimal boilerplate needed
Teams familiar with Flask/Django - similar patterns and concepts

Example FastAPI use case:

# Perfect for API-first applications
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="E-commerce API")

class Product(BaseModel):
    id: int
    name: str
    price: float
    category: str

@app.get("/products/{product_id}", response_model=Product)
async def get_product(product_id: int):
    # Database query logic
    return Product(id=product_id, name="Sample", price=29.99, category="Electronics")

When to Choose Nexios

Nexios is ideal for:

Full-stack web applications - APIs + web interfaces
Real-time applications - WebSocket-heavy applications
Complex middleware requirements - custom authentication, logging
Production applications - built-in security and monitoring
Teams wanting more control - extensive customization options

Example Nexios use case:

# Perfect for full-stack applications
from nexios import NexiosApp
from nexios.http import Request, Response
from nexios.websockets import WebSocket

app = NexiosApp(title="Real-time Chat App")

@app.get("/")
async def home(request: Request, response: Response):
    return response.html("<h1>Welcome to Chat App</h1>")

@app.ws_route("/ws")
async def chat_websocket(websocket: WebSocket):
    await websocket.accept()
    try:
        while True:
            message = await websocket.receive_text()
            await websocket.send_text(f"Echo: {message}")
    except Exception:
        await websocket.close()

Migration Considerations

From FastAPI to Nexios

Easy migrations:

Route definitions - similar decorator patterns
Request/response handling - comparable APIs
Pydantic models - direct compatibility
Dependency injection - similar concepts

Challenges:

Background tasks - different implementation patterns
Middleware - different middleware systems
Configuration - different configuration approaches
Testing - different testing utilities

From Nexios to FastAPI

Easy migrations:

Basic routing - similar patterns
Pydantic models - direct compatibility
Type hints - similar usage patterns

Challenges:

Templating - need to add Jinja2 or similar
Static files - need to add static file middleware
Sessions - need to implement custom session handling
WebSocket channels - different WebSocket patterns

Ecosystem and Community

FastAPI Ecosystem

Large community - extensive documentation and tutorials
Rich ecosystem - many third-party packages and extensions
Active development - regular updates and improvements
Enterprise adoption - used by many large companies

Nexios Ecosystem

Growing community - active development and documentation
Self-contained - many features built-in, fewer external dependencies
Modern design - leverages latest Python features
Performance-focused - optimized for high-performance applications

Development Experience

Learning Curve

FastAPI:

Gentle learning curve - familiar patterns for Flask/Django developers
Excellent documentation - comprehensive tutorials and examples
Large community - easy to find help and examples
IDE support - excellent type hint support

Nexios:

Moderate learning curve - some unique concepts to learn
Good documentation - comprehensive but smaller community
Modern patterns - leverages latest Python features
Type safety - excellent IDE support with type hints

Development Speed

FastAPI:

Rapid prototyping - minimal boilerplate for simple APIs
Quick iteration - hot reload and development tools
Easy testing - built-in testing utilities

Nexios:

Fast development - comprehensive built-in features
Less configuration - sensible defaults for common use cases
Integrated tooling - CLI tools and development helpers

Production Considerations

Deployment

FastAPI:

Multiple server options - Uvicorn, Gunicorn, Hypercorn
Container-friendly - easy to containerize
Cloud-native - works well with Kubernetes, Docker
Monitoring - integrates with standard monitoring tools

Nexios:

Multi-server support - Uvicorn, Granian, Hypercorn
Production-ready - built-in security and monitoring
Easy deployment - minimal configuration needed
Performance monitoring - built-in performance metrics

Security

FastAPI:

Security best practices - follows OWASP guidelines
Authentication - supports multiple auth methods
CORS - built-in CORS support
Input validation - automatic request validation

Nexios:

Comprehensive security - built-in security middleware
Multiple auth backends - JWT, Session, API Key
CSRF protection - built-in CSRF middleware
Security headers - automatic security headers

Conclusion

Both FastAPI and Nexios are excellent choices for modern Python web development, each with their own strengths and ideal use cases.

Choose FastAPI if:

You're building a pure API with minimal complexity
You need extensive third-party ecosystem support
You want the largest community and documentation
You're building microservices or simple REST APIs

Choose Nexios if:

You're building full-stack web applications
You need built-in features like templating and static files
You want more control over middleware and configuration
You're building real-time applications with WebSockets
You prefer a more comprehensive, self-contained framework

Final Thoughts

The choice between FastAPI and Nexios ultimately depends on your specific requirements, team expertise, and project goals. Both frameworks represent the modern direction of Python web development, offering excellent performance, type safety, and developer experience.

For teams new to async Python web development, FastAPI's gentle learning curve and extensive documentation make it an excellent starting point. For teams building complex applications or wanting more control over their stack, Nexios provides a comprehensive solution with fewer external dependencies.

Regardless of your choice, both frameworks will serve you well in building modern, high-performance Python web applications. The key is to understand your requirements and choose the framework that best aligns with your project goals and team capabilities.

This comparison is based on the current state of both frameworks as of June 2025. Both frameworks are actively developed, so features and performance characteristics may evolve over time.

Resources

Getting started with Nexios Asgi Python Framework

Dunamix — Sat, 28 Jun 2025 20:39:33 +0000

Getting Started with Nexios: A Modern Python Web Framework

Introduction

In the ever-evolving landscape of Python web frameworks, developers are constantly seeking solutions that offer the perfect balance of performance, simplicity, and developer experience. Enter Nexios - a modern, async-first Python web framework that's designed to deliver exceptional performance while maintaining clean, intuitive APIs.

Nexios is built on ASGI (Asynchronous Server Gateway Interface) and combines the speed of Rust-powered engines with the elegance of Python. It's designed for developers who want to build scalable, high-performance web applications without the complexity often associated with enterprise frameworks.

What is Nexios?

Nexios is a high-performance Python web framework that stands out for several key characteristics:

Async-First Design: Built from the ground up with async/await support
High Performance: Leverages ASGI for efficient concurrent request handling
Developer-Friendly: Clean, intuitive APIs with excellent type hints
Production-Ready: Built-in security, testing, and deployment features
Flexible: Extensive customization options for any use case

Why Choose Nexios?

Before diving into the technical details, let's understand why Nexios might be the right choice for your next project:

True Async Performance: Unlike frameworks that add async as an afterthought, Nexios is built async-first with no sync-to-async bridges
Clean Architecture: Promotes clean code practices through dependency injection and clear separation of concerns
Modern Authentication: Flexible authentication system with multiple backends (JWT, Session, OAuth)
WebSocket Support: First-class WebSocket support for real-time applications
Production Ready: Built-in features for security, monitoring, and deployment

Prerequisites

Before we begin, ensure you have:

Python 3.9 or higher (Nexios leverages modern Python features)
Basic understanding of async/await in Python
A code editor (VS Code, PyCharm, or your preferred editor)
Package manager (pip, uv, poetry, or pipenv)

Python Version Requirements

Nexios requires Python 3.9+ because it leverages modern Python features like:

Type annotations with generics
Async context managers
Pattern matching (Python 3.10+)
Union types and other type system improvements

Installation

There are several ways to install Nexios depending on your preferred package manager:

Using uv (Recommended)

# Install uv (if you don't have it)
pip install uv

# Create a virtual environment and install Nexios
uv venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
uv pip install nexios

Using pip

# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install Nexios
pip install nexios

Using poetry

# Create a new project
poetry new my-nexios-app
cd my-nexios-app

# Add Nexios
poetry add nexios

# Activate environment
poetry shell

Using pipenv

# Create a new project directory
mkdir my-nexios-app
cd my-nexios-app

# Initialize project
pipenv install nexios

# Activate environment
pipenv shell

Your First Nexios Application

Let's create a simple "Hello, World!" application to get familiar with Nexios basics.

Basic Application

Create a file named main.py:

from nexios import NexiosApp
from nexios.http import Request, Response

app = NexiosApp()

@app.get("/")
async def hello(request: Request, response: Response):
    return response.json({
        "message": "Hello from Nexios!",
        "status": "success"
    })

Running Your Application

uvicorn main:app --reload

Your application will start on http://localhost:4000. Visit the URL in your browser to see the JSON response.

With Configuration

For more control over your application, you can use configuration:

from nexios import NexiosApp, MakeConfig
from nexios.http import Request, Response

config = MakeConfig(
    debug=True,
    cors_enabled=True,
    allowed_hosts=["localhost", "127.0.0.1"]
)

app = NexiosApp(
    config=config,
    title="My First Nexios API",
    version="1.0.0"
)

@app.get("/")
async def hello(request: Request, response: Response):
    return response.json({
        "message": "Hello from Nexios!",
        "app_title": app.title,
        "version": app.openapi_config.version
    })

Core Concepts

1. Application Instance

The NexiosApp class is the main entry point for your application. It handles:

Route registration
Middleware management
Configuration
OpenAPI documentation
Event handling

2. Request and Response Objects

Nexios provides Request and Response objects that encapsulate HTTP request and response data:

@app.get("/users/{user_id:int}")
async def get_user(request: Request, response: Response):
    user_id = request.path_params.user_id
    query_params = request.query_params

    # Access query parameters
    include_profile = query_params.get("include_profile", "false").lower() == "true"

    # Simulate database query
    user = {
        "id": user_id,
        "name": f"User {user_id}",
        "email": f"user{user_id}@example.com"
    }

    if include_profile:
        user["profile"] = {"bio": "This is a sample profile"}

    return response.json(user)

3. Path Parameters

Nexios supports typed path parameters:

@app.get("/items/{item_id:int}")
async def get_item(request: Request, response: Response):
    item_id = request.path_params.item_id  # Automatically converted to int
    return response.json({"id": item_id, "name": f"Item {item_id}"})

@app.get("/users/{username:str}")
async def get_user_by_name(request: Request, response: Response):
    username = request.path_params.username  # String parameter
    return response.json({"username": username, "status": "active"})

Available path parameter types:

str (default)
int
float
uuid
path
date
datetime

4. HTTP Methods

Nexios provides decorators for all HTTP methods:

@app.get("/users")
async def list_users(request: Request, response: Response):
    return response.json([{"id": 1, "name": "John"}, {"id": 2, "name": "Jane"}])

@app.post("/users")
async def create_user(request: Request, response: Response):
    user_data = request.json()
    # Simulate user creation
    new_user = {"id": 3, **user_data}
    return response.json(new_user, status=201)

@app.put("/users/{user_id:int}")
async def update_user(request: Request, response: Response):
    user_id = request.path_params.user_id
    user_data = request.json()
    # Simulate user update
    updated_user = {"id": user_id, **user_data}
    return response.json(updated_user)

@app.delete("/users/{user_id:int}")
async def delete_user(request: Request, response: Response):
    user_id = request.path_params.user_id
    # Simulate user deletion
    return response.status(204)

Dependency Injection

Nexios provides a powerful dependency injection system:

from nexios import Depend

async def get_database():
    # Simulate database connection
    return {"connection": "active", "pool_size": 10}

async def get_current_user(request: Request):
    # Simulate user authentication
    user_id = request.headers.get("X-User-ID")
    if user_id:
        return {"id": int(user_id), "name": f"User {user_id}"}
    return None

@app.get("/users")
async def list_users(
    request: Request, 
    response: Response,
    db: dict = Depend(get_database),
    current_user: dict = Depend(get_current_user)
):
    if not current_user:
        return response.json({"error": "Unauthorized"}, status=401)

    return response.json({
        "users": [{"id": 1, "name": "John"}, {"id": 2, "name": "Jane"}],
        "db_status": db["connection"],
        "current_user": current_user
    })

Middleware

Middleware in Nexios allows you to process requests and responses globally:

from nexios.middleware import BaseMiddleware
from nexios.http import Request, Response

class LoggingMiddleware(BaseMiddleware):
    async def __call__(self, request: Request, response: Response, call_next):
        # Pre-processing
        print(f"Request: {request.method} {request.url}")

        # Call the next middleware/handler
        response = await call_next()

        # Post-processing
        print(f"Response: {response.status_code}")
        return response

# Add middleware to your app
app.add_middleware(LoggingMiddleware())

Built-in Middleware

Nexios comes with several built-in middleware options:

from nexios.middleware import CORSMiddleware, SecurityMiddleware

# CORS middleware
app.add_middleware(CORSMiddleware(
    allow_origins=["http://localhost:3000"],
    allow_methods=["GET", "POST", "PUT", "DELETE"],
    allow_headers=["*"]
))

# Security middleware
app.add_middleware(SecurityMiddleware())

Authentication

Nexios provides a flexible authentication system:

from nexios.auth.middleware import AuthenticationMiddleware
from nexios.auth.backends.jwt import JWTAuthBackend
from nexios.auth.decorator import auth

async def get_user_from_payload(**payload):
    # Simulate user lookup from JWT payload
    user_id = payload.get("sub")
    if user_id:
        return {"id": user_id, "name": f"User {user_id}"}
    return None

# Add authentication middleware
app.add_middleware(
    AuthenticationMiddleware(
        backend=JWTAuthBackend(get_user_from_payload)
    )
)

@app.get("/protected")
@auth(["jwt"])
async def protected_route(request: Request, response: Response):
    return response.json({
        "message": "This is a protected route",
        "user": request.user
    })

WebSocket Support

Nexios provides excellent WebSocket support for real-time applications:

from nexios.websockets import Channel

# Create a chat channel
chat = Channel("chat")

@app.ws_route("/ws/chat/{room}")
async def chat_room(websocket, room: str):
    await chat.connect(websocket)

    try:
        while True:
            # Receive message from client
            message = await websocket.receive_json()

            # Broadcast to all connected clients
            await chat.broadcast({
                "room": room,
                "message": message["text"],
                "user": message["user"]
            })
    except Exception:
        # Handle disconnection
        await chat.disconnect(websocket)

Error Handling

Nexios provides comprehensive error handling:

from nexios.exceptions import HTTPException

@app.get("/users/{user_id:int}")
async def get_user(request: Request, response: Response):
    user_id = request.path_params.user_id

    # Simulate user lookup
    if user_id > 100:
        raise HTTPException(status_code=404, detail="User not found")

    return response.json({"id": user_id, "name": f"User {user_id}"})

# Custom exception handler
@app.add_exception_handler(ValueError)
async def handle_value_error(request: Request, response: Response, exc: ValueError):
    return response.json({
        "error": "Invalid value provided",
        "detail": str(exc)
    }, status=400)

OpenAPI Documentation

Nexios automatically generates OpenAPI documentation:

from pydantic import BaseModel

class UserCreate(BaseModel):
    name: str
    email: str
    age: int

class UserResponse(BaseModel):
    id: int
    name: str
    email: str
    age: int

@app.post("/users", 
    summary="Create a new user",
    description="Creates a new user with the provided information",
    response_model=UserResponse,
    status_code=201
)
async def create_user(
    request: Request, 
    response: Response,
    user_data: UserCreate
):
    # Simulate user creation
    new_user = {
        "id": 1,
        **user_data.dict()
    }
    return response.json(new_user, status=201)

Visit http://localhost:4000/docs to see the interactive API documentation.

Project Structure

As your application grows, you'll want to organize it properly:

my-nexios-app/
├── app/
│   ├── __init__.py
│   ├── main.py
│   ├── config.py
│   ├── models/
│   │   ├── __init__.py
│   │   └── user.py
│   ├── services/
│   │   ├── __init__.py
│   │   └── user_service.py
│   ├── routes/
│   │   ├── __init__.py
│   │   ├── users.py
│   │   └── auth.py
│   └── middleware/
│       ├── __init__.py
│       └── custom_middleware.py
├── tests/
│   ├── __init__.py
│   └── test_users.py
├── requirements.txt
└── README.md

Example: Modular Route Structure

# app/routes/users.py
from nexios import Router
from nexios.http import Request, Response

router = Router()

@router.get("/")
async def list_users(request: Request, response: Response):
    return response.json([{"id": 1, "name": "John"}])

@router.post("/")
async def create_user(request: Request, response: Response):
    user_data = request.json()
    return response.json(user_data, status=201)

# app/main.py
from nexios import NexiosApp
from app.routes.users import router

app = NexiosApp()

# Mount the users router
app.mount_router(router, path="/users")

Testing

Nexios provides testing utilities:

from nexios.testing import TestClient
from app.main import app

client = TestClient(app)

def test_list_users():
    response = client.get("/users")
    assert response.status_code == 200
    assert isinstance(response.json(), list)

def test_create_user():
    user_data = {"name": "John", "email": "john@example.com"}
    response = client.post("/users", json=user_data)
    assert response.status_code == 201
    assert response.json()["name"] == "John"

Deployment

Development

# Run with auto-reload
python main.py

# Or with uvicorn
uvicorn main:app --reload --host 0.0.0.0 --port 8000

Production

# Using uvicorn
uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4

# Using gunicorn with uvicorn workers
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker

Docker

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Performance Considerations

1. Async Best Practices

# Good: Use async for I/O operations
@app.get("/users")
async def list_users(request: Request, response: Response):
    # Simulate async database query
    users = await database.fetch_all("SELECT * FROM users")
    return response.json(users)

# Avoid: Blocking operations in async handlers
@app.get("/users")
async def list_users(request: Request, response: Response):
    # Bad: This blocks the event loop
    users = time.sleep(1)  # Don't do this!
    return response.json(users)

2. Connection Pooling

import asyncpg

# Create connection pool
pool = None

@app.on_startup
async def startup():
    global pool
    pool = await asyncpg.create_pool(
        "postgresql://user:password@localhost/dbname",
        min_size=5,
        max_size=20
    )

@app.on_shutdown
async def shutdown():
    if pool:
        await pool.close()

@app.get("/users")
async def list_users(request: Request, response: Response):
    async with pool.acquire() as conn:
        users = await conn.fetch("SELECT * FROM users")
        return response.json([dict(user) for user in users])

Common Patterns

1. Pagination

from nexios.pagination import Pagination

@app.get("/users")
async def list_users(
    request: Request, 
    response: Response,
    page: int = 1,
    size: int = 10
):
    # Simulate paginated data
    total_users = 100
    users = [
        {"id": i, "name": f"User {i}"} 
        for i in range((page - 1) * size + 1, min(page * size + 1, total_users + 1))
    ]

    pagination = Pagination(
        page=page,
        size=size,
        total=total_users,
        items=users
    )

    return response.json(pagination.to_dict())

2. File Upload

@app.post("/upload")
async def upload_file(request: Request, response: Response):
    form = await request.form()
    file = form.get("file")

    if file:
        # Save file
        with open(f"uploads/{file.filename}", "wb") as f:
            f.write(file.file.read())

        return response.json({
            "message": "File uploaded successfully",
            "filename": file.filename
        })

    return response.json({"error": "No file provided"}, status=400)

3. Background Tasks

@app.post("/users")
async def create_user(request: Request, response: Response):
    user_data = request.json()

    # Add background task
    @app.background_task
    async def send_welcome_email(user_email: str):
        # Simulate sending email
        print(f"Sending welcome email to {user_email}")

    # Schedule background task
    app.add_background_task(send_welcome_email, user_data["email"])

    return response.json(user_data, status=201)

Best Practices

1. Error Handling

from nexios.exceptions import HTTPException

@app.get("/users/{user_id:int}")
async def get_user(request: Request, response: Response):
    user_id = request.path_params.user_id

    try:
        user = await user_service.get_user(user_id)
        if not user:
            raise HTTPException(status_code=404, detail="User not found")
        return response.json(user)
    except ValueError as e:
        raise HTTPException(status_code=400, detail=str(e))

2. Validation

from pydantic import BaseModel, EmailStr

class UserCreate(BaseModel):
    name: str
    email: EmailStr
    age: int

@app.post("/users")
async def create_user(
    request: Request, 
    response: Response,
    user_data: UserCreate
):
    # Pydantic automatically validates the data
    return response.json(user_data.dict(), status=201)

3. Security

from nexios.middleware import SecurityMiddleware

# Add security headers
app.add_middleware(SecurityMiddleware())

# Use HTTPS in production
if not app.config.debug:
    app.config.force_https = True

Conclusion

Nexios is a powerful, modern Python web framework that offers excellent performance, developer experience, and flexibility. Its async-first design, clean architecture, and comprehensive feature set make it an excellent choice for building scalable web applications.

Key Takeaways

Async-First: Nexios is built from the ground up with async/await support
High Performance: Leverages ASGI for efficient concurrent request handling
Developer-Friendly: Clean APIs with excellent type hints and documentation
Production-Ready: Built-in security, testing, and deployment features
Flexible: Extensive customization options for any use case

Next Steps

Now that you have a solid foundation with Nexios, consider exploring:

Database Integration: Connect to PostgreSQL, MySQL, or MongoDB
Authentication: Implement JWT, OAuth, or session-based auth
WebSockets: Build real-time features with WebSocket support
Testing: Write comprehensive tests for your application
Deployment: Deploy to production with proper configuration

Resources

Happy coding with Nexios! 🚀

This blog post was written to help developers get started with the Nexios framework. For the latest information and updates, always refer to the official documentation.

Meet Nexios : Python New Asgi Framework

Dunamix — Sun, 27 Apr 2025 23:11:14 +0000

Meet Nexios: A New Python ASGI Framework 🚀

Hello, Devs! 👋

I'm excited to introduce Nexios, a new lightweight and high-performance ASGI framework for Python that I've been working on. Whether you're building a real-time application, a high-performance API, or a lightweight microservice, Nexios is designed to get you up and running quickly while providing all the flexibility and power you need.

Why Nexios?

As a Python developer, I've always wanted a framework that combines the simplicity of Express.js with the async capabilities of Python. After looking around and not finding exactly what I was after, I decided to build my own solution. And so, Nexios was born. Here's what makes Nexios stand out:

1. Simplicity Meets Power ⚡

Nexios keeps things simple with a developer-friendly interface. You don't have to fight with complex configurations or hidden magic to get your app running. You define async endpoints using simple Python code—just like Express.js does for JavaScript.

2. High Performance 💨

With full ASGI support, Nexios is built to handle high concurrency and real-time features. It's designed for fast responses, whether you're building an API or a WebSocket-based app.

3. ORM Agnostic 🔄

Nexios supports any ORM, making it easy to integrate with your preferred data store. Whether you're using SQLAlchemy, Tortoise, or any other ORM, Nexios has you covered.

4. Built-in Authentication 🔐

Security is built into the core of Nexios with built-in support for JWT, API Key-based authentication, and custom backends. It's easy to secure your app without the need for third-party libraries.

5. Flexible and Extensible 🔧

Nexios is designed to be as flexible as possible. You can easily extend its functionality with middleware, custom handlers, and even your own authentication backends.

How to Get Started with Nexios

Getting started with Nexios is simple. Here's how you can create your first app manually:

Install Nexios:

   pip install nexios

Create your project structure: You can create a folder structure like this:

   myproject/
       app.py

Define an async route: Here's an example of how to define a simple route in app.py:

   from nexios import get_application

   app = get_application()

   @app.get("/hello")
   async def hello(request, response):
       return response.json({"message": "Hello, Nexios!"})

Run your app: You can run your app using an ASGI server like Uvicorn:

   uvicorn app:app

That's it! Now you've got your very own Nexios app up and running.

What's Next?

I'm just getting started with Nexios, and there's plenty more on the way. The next major feature I’m working on is an admin panel, which will make managing your app even easier.

I’m also planning to enhance the documentation, add more tutorials, and continue making Nexios even more powerful. Stay tuned for more updates!

Get Involved

I’d love to hear from you. If you're excited about Nexios or have ideas on how to make it better, feel free to open an issue or contribute on GitHub: Nexios GitHub.

Thanks for checking out Nexios! If you have any questions or feedback, drop a comment below or hit me up on Twitter @techwithdunamix.

I hope this post gives you a good idea of what Nexios is all about. I’m looking forward to hearing what you think and seeing what you build with it!

Happy coding! 👨‍💻