Buckets:
AnonymousSpottedToad/human_verified_bucket / codebase /python /nijaru_zenith /benchmarks /zenith_app.py
| """Zenith benchmark application.""" | |
| from datetime import datetime | |
| from pydantic import BaseModel | |
| from sqlalchemy import select | |
| from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine | |
| from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, sessionmaker | |
| from zenith import Auth, Inject, Service, Zenith | |
| from zenith.auth import JWTManager | |
| from zenith.web.responses import JSONResponse | |
| # Models | |
| class Base(DeclarativeBase): | |
| pass | |
| class User(Base): | |
| __tablename__ = "users" | |
| id: Mapped[int] = mapped_column(primary_key=True) | |
| name: Mapped[str] | |
| email: Mapped[str] | |
| created_at: Mapped[datetime] | |
| class UserModel(BaseModel): | |
| id: int | |
| name: str | |
| email: str | |
| created_at: datetime | |
| class CreateUserModel(BaseModel): | |
| name: str | |
| email: str | |
| # Context | |
| class UsersService(Service): | |
| def __init__(self): | |
| super().__init__() | |
| self.db = None | |
| async def initialize(self): | |
| engine = create_async_engine("sqlite+aiosqlite:///:memory:") | |
| async with engine.begin() as conn: | |
| await conn.run_sync(Base.metadata.create_all) | |
| AsyncSessionLocal = sessionmaker( | |
| engine, class_=AsyncSession, expire_on_commit=False | |
| ) | |
| self.db = AsyncSessionLocal | |
| # Seed data | |
| async with self.db() as session: | |
| for i in range(100): | |
| user = User( | |
| name=f"User {i}", | |
| email=f"user{i}@example.com", | |
| created_at=datetime.now(), | |
| ) | |
| session.add(user) | |
| await session.commit() | |
| async def get_user(self, user_id: int) -> UserModel | None: | |
| async with self.db() as session: | |
| result = await session.execute(select(User).where(User.id == user_id)) | |
| user = result.scalar_one_or_none() | |
| if user: | |
| return UserModel( | |
| id=user.id, | |
| name=user.name, | |
| email=user.email, | |
| created_at=user.created_at, | |
| ) | |
| return None | |
| async def list_users(self, limit: int = 100) -> list[UserModel]: | |
| async with self.db() as session: | |
| result = await session.execute(select(User).limit(limit)) | |
| users = result.scalars().all() | |
| return [ | |
| UserModel( | |
| id=user.id, | |
| name=user.name, | |
| email=user.email, | |
| created_at=user.created_at, | |
| ) | |
| for user in users | |
| ] | |
| async def create_user(self, data: CreateUserModel) -> UserModel: | |
| async with self.db() as session: | |
| user = User(name=data.name, email=data.email, created_at=datetime.now()) | |
| session.add(user) | |
| await session.commit() | |
| await session.refresh(user) | |
| return UserModel( | |
| id=user.id, name=user.name, email=user.email, created_at=user.created_at | |
| ) | |
| # App | |
| app = Zenith() | |
| # Configure auth | |
| jwt_manager = JWTManager(secret_key="benchmark-secret-key-123") | |
| app.dependency_overrides[Auth] = lambda: jwt_manager | |
| # Initialize context | |
| users_service = UsersService() | |
| async def startup(): | |
| await users_service.initialize() | |
| app.dependency_overrides[UsersService] = lambda: users_service | |
| # Routes | |
| async def hello_world(): | |
| return {"message": "Hello, World!"} | |
| async def get_user( | |
| user_id: int, users: UsersService = Inject(UsersService) | |
| ) -> UserModel: | |
| user = await users.get_user(user_id) | |
| if not user: | |
| return JSONResponse({"error": "User not found"}, status_code=404) | |
| return user | |
| async def list_users( | |
| limit: int = 100, users: UsersService = Inject(UsersService) | |
| ) -> list[UserModel]: | |
| return await users.list_users(limit) | |
| async def create_user( | |
| data: CreateUserModel, users: UsersService = Inject(UsersService) | |
| ) -> UserModel: | |
| return await users.create_user(data) | |
| async def protected_route(current_user=Auth(required=True)): | |
| return {"user": current_user} | |
| async def validate_data(data: CreateUserModel): | |
| return {"validated": True, "data": data.model_dump()} | |
| async def upload_file(file_content: bytes): | |
| return {"size": len(file_content), "message": "File processed"} | |
| if __name__ == "__main__": | |
| import uvicorn | |
| uvicorn.run(app, host="127.0.0.1", port=8000, log_level="error") | |
Xet Storage Details
- Size:
- 4.6 kB
- Xet hash:
- 6f4c1f7b1229b14741ce19052b14a829de5481931b8fe07fbb9c47aeb3a4377e
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.