Nexios is a fast, minimalist Python framework for building async APIs with clean architecture , zero boilerplate , and a Pythonic feel .
# Create virtual environment
python -m venv venv
source venv/bin/activate # or `venv\Scripts\activate` on Windows
# Install Nexios
pip install nexiosfrom nexios import NexiosApp
app = NexiosApp()
@app.get("/")
async def index(request, response):
return response.json({
"message": "Welcome to Nexios!"
})
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="127.0.0.1", port=8000)from nexios import NexiosApp, MakeConfig
config = MakeConfig({
"debug": True,
"cors_enabled": True,
"allowed_hosts": ["localhost", "example.com"]
})
app = NexiosApp(
config=config,
title="My API",
version="1.0.0"
)Quick Development
Use nexios run --reload for automatic reloading during development. 🔄
from nexios import NexiosApp
app = NexiosApp()
@app.get("/users/{user_id:int}")
async def get_user(request, response, user_id: int):
return response.json({"id": user_id}) # user_id is automatically converted to intfrom pydantic import BaseModel
class User(BaseModel):
id: int
name: str
email: str
@app.post("/users")
async def create_user(request, response):
data = await request.json
user = User(**data) # Automatic validation
return response.json(user.dict())from nexios import NexiosApp
from uuid import UUID
app = NexiosApp()
@app.get("/users/{user_id:int}/posts/{post_id:uuid}")
async def get_user_post(request, response):
user_id = request.path_params.user_id
post_id = request.path_params.post_id
return response.json({
"user_id": user_id,
"post_id": str(post_id)
})@app.ws_route("/ws")
async def websocket_endpoint(websocket):
await websocket.accept()
try:
while True:
data = await websocket.receive_json()
await websocket.send_json({"echo": data})
except WebSocketDisconnect:
print("Client disconnected")from nexios.websockets import Channel
@app.ws_route("/chat/{room_id}")
async def chat_room(websocket, room_id: str):
channel = Channel(f"room:{room_id}")
await channel.connect(websocket)
try:
while True:
message = await websocket.receive_json()
await channel.broadcast(message)
except WebSocketDisconnect:
await channel.disconnect(websocket)from nexios.http import Request, Response
from nexios_contrib.mail import MailDepend
@app.post("/send-email")
async def send_email(
request: Request,
response: Response,
mail_client: MailClient = MailDepend()
):
result = await mail_client.send_email(
to="user@example.com",
subject="Welcome!",
body="Thanks for joining us"
)
return response.json({"success": result.success})@app.post("/send-welcome")
async def send_welcome(
request: Request,
response: Response,
mail_client: MailClient = MailDepend()
):
result = await mail_client.send_template_email(
to="user@example.com",
subject="Welcome!",
template_name="welcome",
context={"name": "John", "company": "Acme Corp"}
)
return response.json({"success": result.success})from nexios_contrib.mail import send_email_async
@app.post("/send-async")
async def send_async(
request: Request,
response: Response
):
task = await send_email_async(
request=request,
to="user@example.com",
subject="Processing...",
body="We'll notify you when done"
)
return response.json({"task_id": task.id})
async def basic_middleware(request, response, call_next):
print("do something before handler")
await call_next()
print("do something after handler")
app.add_middleware(basic_middleware())from nexios.middleware import BaseMiddleware
class BasicMiddleware(BaseMiddleware):
async def process_request(request, response, call_next):
print("do something before handler")
await call_next()
async def process_response(request, response, call_next):
print("do something after handler")from nexios.auth.middleware import AuthenticationMiddleware
from nexios.auth.backends.jwt import JWTAuthBackend
from nexios.auth.decorator import auth
auth = AuthenticationMiddleware(
backend = JWTAuthBackend(),
user_model = UserModel
)
app.add_middleware(auth)
@app.get("/protected")
@auth(["jwt"])
async def protected(request, response):
user = request.user
return response.json({"message": f"Hello {user.username}"})from nexios import Depend
# Both generator and async generator dependencies are supported.
# Cleanup in the finally block is always run after the request.
def get_db():
db = connect()
try:
yield db
finally:
db.close()
async def get_async_db():
db = await async_connect()
try:
yield db
finally:
await db.close()
@app.get("/users")
async def list_users(
request,
response,
db=Depend(get_db) # or db=Depend(get_async_db)
):
users = await db.query("SELECT * FROM users")
return response.json(users)from nexios.dependecies import Context
async def get_current_user(
ctx = Context()
): request = ctx.request
token = request.headers.get("Authorization")
return await auth.get_user(token)
@app.get("/profile")
async def profile(
request,
response,
user=Depend(get_current_user)
):
return response.json(user.to_dict())Production Ready
Nexios is built for production use with:
Python Version
Nexios requires Python 3.9+ for:
Nexios comes with a powerful command-line interface that makes development and deployment a breeze. The Nexios CLI is your primary tool for managing Nexios applications throughout their lifecycle.
# Create a new Nexios project
nexios new my-awesome-appImportant Note
Do not use the Nexios CLI if you are still learning Python.
For complete documentation on using the Nexios CLI, check out the CLI Documentation.
Nexios embraces the Zen of Python, particularly the second principle: "Explicit is better than implicit." Here's how:
/docs