ohmyapi 0.1.19__tar.gz → 0.1.21__tar.gz

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ohmyapi
-Version: 0.1.19
+Version: 0.1.21
 Summary: A Django-like but async web-framework based on FastAPI and TortoiseORM.
 License-Expression: MIT
 Keywords: fastapi,tortoise,orm,async,web-framework
@@ -118,31 +118,35 @@ Write your first model in `turnament/models.py`:
 ```python
 from ohmyapi.db import Model, field
 
+from datetime import datetime
+from decimal import Decimal
+from uuid import UUID
+
 
 class Tournament(Model):
-    id = field.data.UUIDField(primary_key=True)
-    name = field.TextField()
-    created = field.DatetimeField(auto_now_add=True)
+    id: UUID = field.data.UUIDField(primary_key=True)
+    name: str = field.TextField()
+    created: datetime = field.DatetimeField(auto_now_add=True)
 
     def __str__(self):
         return self.name
 
 
 class Event(Model):
-    id = field.data.UUIDField(primary_key=True)
-    name = field.TextField()
-    tournament = field.ForeignKeyField('tournament.Tournament', related_name='events')
-    participants = field.ManyToManyField('tournament.Team', related_name='events', through='event_team')
-    modified = field.DatetimeField(auto_now=True)
-    prize = field.DecimalField(max_digits=10, decimal_places=2, null=True)
+    id: UUID = field.data.UUIDField(primary_key=True)
+    name: str = field.TextField()
+    tournament: UUID = field.ForeignKeyField('tournament.Tournament', related_name='events')
+    participants: field.ManyToManyRelation[Team] = field.ManyToManyField('tournament.Team', related_name='events', through='event_team')
+    modified: datetime = field.DatetimeField(auto_now=True)
+    prize: Decimal = field.DecimalField(max_digits=10, decimal_places=2, null=True)
 
     def __str__(self):
         return self.name
 
 
 class Team(Model):
-    id = field.data.UUIDField(primary_key=True)
-    name = field.TextField()
+    id: UUID = field.data.UUIDField(primary_key=True)
+    name: str = field.TextField()
 
     def __str__(self):
         return self.name
@@ -242,9 +246,13 @@ It comes with a `User` and `Group` model, as well as endpoints for JWT auth.
 You can use the models as `ForeignKeyField` in your application models:
 
 ```python
+from ohmyapi.db import Model, field
+from ohmyapi_auth.models import User
+
+
 class Team(Model):
     [...]
-    members = field.ManyToManyField('ohmyapi_auth.User', related_name='tournament_teams', through='tournament_teams')
+    members: field.ManyToManyRelation[User] = field.ManyToManyField('ohmyapi_auth.User', related_name='tournament_teams', through='tournament_teams')
     [...]
 ```
 

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/README.md

@@ -86,31 +86,35 @@ Write your first model in `turnament/models.py`:
 ```python
 from ohmyapi.db import Model, field
 
+from datetime import datetime
+from decimal import Decimal
+from uuid import UUID
+
 
 class Tournament(Model):
-    id = field.data.UUIDField(primary_key=True)
-    name = field.TextField()
-    created = field.DatetimeField(auto_now_add=True)
+    id: UUID = field.data.UUIDField(primary_key=True)
+    name: str = field.TextField()
+    created: datetime = field.DatetimeField(auto_now_add=True)
 
     def __str__(self):
         return self.name
 
 
 class Event(Model):
-    id = field.data.UUIDField(primary_key=True)
-    name = field.TextField()
-    tournament = field.ForeignKeyField('tournament.Tournament', related_name='events')
-    participants = field.ManyToManyField('tournament.Team', related_name='events', through='event_team')
-    modified = field.DatetimeField(auto_now=True)
-    prize = field.DecimalField(max_digits=10, decimal_places=2, null=True)
+    id: UUID = field.data.UUIDField(primary_key=True)
+    name: str = field.TextField()
+    tournament: UUID = field.ForeignKeyField('tournament.Tournament', related_name='events')
+    participants: field.ManyToManyRelation[Team] = field.ManyToManyField('tournament.Team', related_name='events', through='event_team')
+    modified: datetime = field.DatetimeField(auto_now=True)
+    prize: Decimal = field.DecimalField(max_digits=10, decimal_places=2, null=True)
 
     def __str__(self):
         return self.name
 
 
 class Team(Model):
-    id = field.data.UUIDField(primary_key=True)
-    name = field.TextField()
+    id: UUID = field.data.UUIDField(primary_key=True)
+    name: str = field.TextField()
 
     def __str__(self):
         return self.name
@@ -210,9 +214,13 @@ It comes with a `User` and `Group` model, as well as endpoints for JWT auth.
 You can use the models as `ForeignKeyField` in your application models:
 
 ```python
+from ohmyapi.db import Model, field
+from ohmyapi_auth.models import User
+
+
 class Team(Model):
     [...]
-    members = field.ManyToManyField('ohmyapi_auth.User', related_name='tournament_teams', through='tournament_teams')
+    members: field.ManyToManyRelation[User] = field.ManyToManyField('ohmyapi_auth.User', related_name='tournament_teams', through='tournament_teams')
     [...]
 ```
 

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ohmyapi"
-version = "0.1.19"
+version = "0.1.21"
 description = "A Django-like but async web-framework based on FastAPI and TortoiseORM."
 license = "MIT"
 keywords = ["fastapi", "tortoise", "orm", "async", "web-framework"]
@@ -27,6 +27,8 @@ dependencies = [
 
 [tool.poetry.group.dev.dependencies]
 ipython = ">=9.5.0,<10.0.0"
+black = "^25.9.0"
+isort = "^6.0.1"
 
 [project.optional-dependencies]
 auth = ["passlib", "pyjwt", "crypto", "argon2-cffi", "python-multipart"]
@@ -36,3 +38,23 @@ packages = [ { include = "ohmyapi", from = "src" } ]
 
 [project.scripts]
 ohmyapi = "ohmyapi.cli:app"
+
+[tool.black]
+line-length = 88
+target-version = ['py39', 'py310', 'py311', 'py312', 'py313']
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"  # makes imports compatible with black
+line_length = 88
+multi_line_output = 3
+include_trailing_comma = true
+

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/__init__.py

@@ -1,2 +1 @@
 from . import db
-

ohmyapi-0.1.21/src/ohmyapi/builtin/auth/__init__.py

@@ -0,0 +1 @@
+from . import models, permissions, routes

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/builtin/auth/models.py

@@ -1,29 +1,34 @@
 from functools import wraps
-from typing import Optional, List
-from ohmyapi.router import HTTPException
-from ohmyapi.db import Model, field, pre_save, pre_delete
+from typing import List, Optional
+from uuid import UUID
+
 from passlib.context import CryptContext
 from tortoise.contrib.pydantic import pydantic_queryset_creator
 
+from ohmyapi.db import Model, field, pre_delete, pre_save
+from ohmyapi.router import HTTPException
+
 pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
 
 
 class Group(Model):
-    id: str = field.data.UUIDField(pk=True)
+    id: UUID = field.data.UUIDField(pk=True)
     name: str = field.CharField(max_length=42, index=True)
 
 
 class User(Model):
-    id: str = field.data.UUIDField(pk=True)
+    id: UUID = field.data.UUIDField(pk=True)
     email: str = field.CharField(max_length=255, unique=True, index=True)
     username: str = field.CharField(max_length=150, unique=True)
     password_hash: str = field.CharField(max_length=128)
     is_admin: bool = field.BooleanField(default=False)
     is_staff: bool = field.BooleanField(default=False)
-    groups: field.ManyToManyRelation[Group] = field.ManyToManyField("ohmyapi_auth.Group", related_name="users", through='user_groups')
+    groups: field.ManyToManyRelation[Group] = field.ManyToManyField(
+        "ohmyapi_auth.Group", related_name="users", through="user_groups"
+    )
 
     class Schema:
-        exclude = 'password_hash',
+        exclude = ("password_hash",)
 
     def set_password(self, raw_password: str) -> None:
         """Hash and store the password."""

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/builtin/auth/routes.py

@@ -3,13 +3,12 @@ from enum import Enum
 from typing import Any, Dict, List
 
 import jwt
+import settings
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from pydantic import BaseModel
 
-from ohmyapi.builtin.auth.models import User, Group
-
-import settings
+from ohmyapi.builtin.auth.models import Group, User
 
 # Router
 router = APIRouter(prefix="/auth", tags=["auth"])
@@ -17,8 +16,12 @@ router = APIRouter(prefix="/auth", tags=["auth"])
 # Secrets & config (should come from settings/env in real projects)
 JWT_SECRET = getattr(settings, "JWT_SECRET", "changeme")
 JWT_ALGORITHM = getattr(settings, "JWT_ALGORITHM", "HS256")
-ACCESS_TOKEN_EXPIRE_SECONDS = getattr(settings, "JWT_ACCESS_TOKEN_EXPIRE_SECONDS", 15 * 60)
-REFRESH_TOKEN_EXPIRE_SECONDS = getattr(settings, "JWT_REFRESH_TOKEN_EXPIRE_SECONDS", 7 * 24 * 60 * 60)
+ACCESS_TOKEN_EXPIRE_SECONDS = getattr(
+    settings, "JWT_ACCESS_TOKEN_EXPIRE_SECONDS", 15 * 60
+)
+REFRESH_TOKEN_EXPIRE_SECONDS = getattr(
+    settings, "JWT_REFRESH_TOKEN_EXPIRE_SECONDS", 7 * 24 * 60 * 60
+)
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
 
@@ -36,30 +39,38 @@ def decode_token(token: str) -> Dict:
     try:
         return jwt.decode(token, JWT_SECRET, algorithms=[JWT_ALGORITHM])
     except jwt.ExpiredSignatureError:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token expired")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Token expired"
+        )
     except jwt.InvalidTokenError:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token"
+        )
 
 
 class TokenType(str, Enum):
     """
     Helper for indicating the token type when generating claims.
     """
+
     access = "access"
     refresh = "refresh"
 
 
-def claims(token_type: TokenType, user: User, groups: List[Group] = []) -> Dict[str, Any]:
+def claims(
+    token_type: TokenType, user: User, groups: List[Group] = []
+) -> Dict[str, Any]:
     return {
-        'type': token_type,
-        'sub': str(user.id),
-        'user': {
-            'username': user.username,
-            'email': user.email,
+        "type": token_type,
+        "sub": str(user.id),
+        "user": {
+            "username": user.username,
+            "email": user.email,
         },
-        'roles': [g.name for g in groups]
+        "roles": [g.name for g in groups],
     }
 
+
 async def get_token(token: str = Depends(oauth2_scheme)) -> Dict:
     """Dependency: token introspection"""
     payload = decode_token(token)
@@ -71,11 +82,15 @@ async def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
     payload = decode_token(token)
     user_id = payload.get("sub")
     if user_id is None:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token payload")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token payload"
+        )
 
     user = await User.filter(id=user_id).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found"
+        )
     return user
 
 
@@ -101,15 +116,13 @@ async def require_staff(current_user: User = Depends(get_current_user)) -> User:
 
 
 async def require_group(
-    group_name: str, 
-    current_user: User = Depends(get_current_user)
+    group_name: str, current_user: User = Depends(get_current_user)
 ) -> User:
     """Ensure the current user belongs to the given group."""
     user_groups = await current_user.groups.all()
     if not any(g.name == group_name for g in user_groups):
         raise HTTPException(
-            status_code=403,
-            detail=f"User must belong to group '{group_name}'"
+            status_code=403, detail=f"User must belong to group '{group_name}'"
         )
     return current_user
 
@@ -124,15 +137,21 @@ async def login(form_data: LoginRequest = Body(...)):
     """Login with username & password, returns access and refresh tokens."""
     user = await User.authenticate(form_data.username, form_data.password)
     if not user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials"
+        )
 
-    access_token = create_token(claims(TokenType.access, user), ACCESS_TOKEN_EXPIRE_SECONDS)
-    refresh_token = create_token(claims(TokenType.refresh, user), REFRESH_TOKEN_EXPIRE_SECONDS)
+    access_token = create_token(
+        claims(TokenType.access, user), ACCESS_TOKEN_EXPIRE_SECONDS
+    )
+    refresh_token = create_token(
+        claims(TokenType.refresh, user), REFRESH_TOKEN_EXPIRE_SECONDS
+    )
 
     return {
         "access_token": access_token,
         "refresh_token": refresh_token,
-        "token_type": "bearer"
+        "token_type": "bearer",
     }
 
 
@@ -141,14 +160,20 @@ async def refresh_token(refresh_token: str):
     """Exchange refresh token for new access token."""
     payload = decode_token(refresh_token)
     if payload.get("type") != "refresh":
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid refresh token")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid refresh token"
+        )
 
     user_id = payload.get("sub")
     user = await User.filter(id=user_id).first()
     if not user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found"
+        )
 
-    new_access = create_token(claims(TokenType.access, user), ACCESS_TOKEN_EXPIRE_SECONDS)
+    new_access = create_token(
+        claims(TokenType.access, user), ACCESS_TOKEN_EXPIRE_SECONDS
+    )
     return {"access_token": new_access, "token_type": "bearer"}
 
 
@@ -161,4 +186,3 @@ async def introspect(token: Dict = Depends(get_token)):
 async def me(user: User = Depends(get_current_user)):
     """Return the currently authenticated user."""
     return User.Schema.one.from_orm(user)
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/cli.py

@@ -2,17 +2,17 @@ import asyncio
 import atexit
 import importlib
 import sys
+from getpass import getpass
+from pathlib import Path
+
 import typer
 import uvicorn
 
-from getpass import getpass
-from ohmyapi.core import scaffolding, runtime
-from pathlib import Path
+from ohmyapi.core import runtime, scaffolding
 
-app = typer.Typer(help="OhMyAPI — Django-flavored FastAPI scaffolding with tightly integrated TortoiseORM.")
-banner = """OhMyAPI Shell | Project: {project_name}
-Find your loaded project singleton via identifier: `p`
-"""
+app = typer.Typer(
+    help="OhMyAPI — Django-flavored FastAPI scaffolding with tightly integrated TortoiseORM."
+)
 
 
 @app.command()
@@ -40,52 +40,51 @@ def serve(root: str = ".", host="127.0.0.1", port=8000):
 
 @app.command()
 def shell(root: str = "."):
-    """
-    Launch an interactive IPython shell with the project and apps loaded.
-    """
     project_path = Path(root).resolve()
     project = runtime.Project(project_path)
 
-    # Ensure the ORM is shutdown
-    async def close_project():
+    banner = f"""
+    OhMyAPI Project Shell: {getattr(project.settings, 'PROJECT_NAME', 'MyProject')}
+    Find your loaded project singleton via identifier: `p`; i.e.: `p.apps`
+    """
+
+    async def init_and_cleanup():
+        try:
+            await project.init_orm()
+            return True
+        except Exception as e:
+            print(f"Failed to initialize ORM: {e}")
+            return False
+
+    async def cleanup():
         try:
             await project.close_orm()
             print("Tortoise ORM closed successfully.")
         except Exception as e:
             print(f"Error closing ORM: {e}")
 
-    def cleanup():
-        loop = None
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            pass
-        if loop and loop.is_running():
-            asyncio.create_task(close_project())
-        else:
-            asyncio.run(close_project())
-
-    # Ensure the ORM is initialized
-    asyncio.run(project.init_orm())
+    loop = asyncio.new_event_loop()
+    asyncio.set_event_loop(loop)
+    loop.run_until_complete(init_and_cleanup())
+
+    # Prepare shell vars that are to be directly available
+    shell_vars = {"p": project}
 
     try:
         from IPython import start_ipython
-        shell_vars = {
-            "p": project,
-        }
         from traitlets.config.loader import Config
+
         c = Config()
         c.TerminalIPythonApp.display_banner = True
-        c.TerminalInteractiveShell.banner2 = banner.format(**{
-            "project_name": f"{f'{project.settings.PROJECT_NAME} ' if getattr(project.settings, 'PROJECT_NAME', '') else ''}[{Path(project_path).resolve()}]",
-        })
-        atexit.register(cleanup)
+        c.TerminalInteractiveShell.banner2 = banner
+
         start_ipython(argv=[], user_ns=shell_vars, config=c)
     except ImportError:
-        typer.echo("IPython is not installed. Falling back to built-in Python shell.")
         import code
-        atexit.register(cleanup)
-        code.interact(local={"p": project})
+
+        code.interact(local=shell_vars, banner=banner)
+    finally:
+        loop.run_until_complete(cleanup())
 
 
 @app.command()
@@ -125,11 +124,15 @@ def createsuperuser(root: str = "."):
     project_path = Path(root).resolve()
     project = runtime.Project(project_path)
     if not project.is_app_installed("ohmyapi_auth"):
-        print("Auth app not installed! Please add 'ohmyapi_auth' to your INSTALLED_APPS.")
+        print(
+            "Auth app not installed! Please add 'ohmyapi_auth' to your INSTALLED_APPS."
+        )
         return
 
     import asyncio
+
     import ohmyapi_auth
+
     email = input("E-Mail: ")
     username = input("Username: ")
     password1, password2 = "foo", "bar"
@@ -138,9 +141,10 @@ def createsuperuser(root: str = "."):
         password2 = getpass("Repeat Password: ")
         if password1 != password2:
             print("Passwords didn't match!")
-    user = ohmyapi_auth.models.User(email=email, username=username, is_staff=True, is_admin=True)
+    user = ohmyapi_auth.models.User(
+        email=email, username=username, is_staff=True, is_admin=True
+    )
     user.set_password(password1)
     asyncio.run(project.init_orm())
     asyncio.run(user.save())
     asyncio.run(project.close_orm())
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/core/runtime.py

@@ -2,16 +2,18 @@
 import copy
 import importlib
 import importlib.util
+import json
 import pkgutil
 import sys
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict, Generator, List, Optional
 
 import click
 from aerich import Command as AerichCommand
 from aerich.exceptions import NotInitedError
+from fastapi import APIRouter, FastAPI
 from tortoise import Tortoise
-from fastapi import FastAPI, APIRouter
+
 from ohmyapi.db.model import Model
 
 
@@ -43,7 +45,9 @@ class Project:
                     orig = importlib.import_module(full)
                     sys.modules[alias] = orig
                     try:
-                        sys.modules[f"{alias}.models"] = importlib.import_module(f"{full}.models")
+                        sys.modules[f"{alias}.models"] = importlib.import_module(
+                            f"{full}.models"
+                        )
                     except ModuleNotFoundError:
                         pass
 
@@ -51,7 +55,9 @@ class Project:
         try:
             self.settings = importlib.import_module("settings")
         except Exception as e:
-            raise RuntimeError(f"Failed to import project settings from {self.project_path}") from e
+            raise RuntimeError(
+                f"Failed to import project settings from {self.project_path}"
+            ) from e
 
         # Load installed apps
         for app_name in getattr(self.settings, "INSTALLED_APPS", []):
@@ -103,11 +109,16 @@ class Project:
         for app_name, app in self._apps.items():
             modules = list(dict.fromkeys(app.model_modules))
             if modules:
-                config["apps"][app_name] = {"models": modules, "default_connection": "default"}
+                config["apps"][app_name] = {
+                    "models": modules,
+                    "default_connection": "default",
+                }
 
         return config
 
-    def build_aerich_command(self, app_label: str, db_url: Optional[str] = None) -> AerichCommand:
+    def build_aerich_command(
+        self, app_label: str, db_url: Optional[str] = None
+    ) -> AerichCommand:
         # Resolve label to flat_label
         if app_label in self._apps:
             flat_label = app_label
@@ -128,7 +139,7 @@ class Project:
         return AerichCommand(
             tortoise_config=tortoise_cfg,
             app=flat_label,
-            location=str(self.migrations_dir)
+            location=str(self.migrations_dir),
         )
 
     # --- ORM lifecycle ---
@@ -143,7 +154,9 @@ class Project:
         await Tortoise.close_connections()
 
     # --- Migration helpers ---
-    async def makemigrations(self, app_label: str, name: str = "auto", db_url: Optional[str] = None) -> None:
+    async def makemigrations(
+        self, app_label: str, name: str = "auto", db_url: Optional[str] = None
+    ) -> None:
         cmd = self.build_aerich_command(app_label, db_url=db_url)
         async with cmd as c:
             await c.init()
@@ -157,7 +170,9 @@ class Project:
                 await c.init_db(safe=True)
                 await c.migrate(name=name)
 
-    async def migrate(self, app_label: Optional[str] = None, db_url: Optional[str] = None) -> None:
+    async def migrate(
+        self, app_label: Optional[str] = None, db_url: Optional[str] = None
+    ) -> None:
         labels: List[str]
         if app_label:
             if app_label in self._apps:
@@ -218,30 +233,47 @@ class App:
             pass
 
     def __repr__(self):
-        out = ""
-        out += f"App: {self.name}\n"
-        out += f"Models:\n"
-        for model in self.models:
-            out += f" - {model.__name__}\n"
-        out += "Routes:\n"
-        for route in (self.routes or []):
-            out += f" - {route}\n"
-        return out
+        return json.dumps(self.dict(), indent=2)
 
     def __str__(self):
         return self.__repr__()
 
+    def _serialize_route(self, route):
+        """Convert APIRoute to JSON-serializable dict."""
+        return {
+            "path": route.path,
+            "name": route.name,
+            "methods": list(route.methods),
+            "endpoint": route.endpoint.__name__,  # just the function name
+            "response_model": (
+                getattr(route, "response_model", None).__name__
+                if getattr(route, "response_model", None)
+                else None
+            ),
+            "tags": getattr(route, "tags", None),
+        }
+
+    def _serialize_router(self):
+        return [self._serialize_route(route) for route in self.routes]
+
+    def dict(self) -> Dict[str, Any]:
+        return {
+            "models": [m.__name__ for m in self.models],
+            "routes": self._serialize_router(),
+        }
+
     @property
-    def models(self) -> List[Model]:
-        models: List[Model] = []
+    def models(self) -> Generator[Model, None, None]:
         for mod in self.model_modules:
             models_mod = importlib.import_module(mod)
             for obj in models_mod.__dict__.values():
-                if isinstance(obj, type) and getattr(obj, "_meta", None) is not None and obj.__name__ != 'Model':
-                    models.append(obj)
-        return models
+                if (
+                    isinstance(obj, type)
+                    and getattr(obj, "_meta", None) is not None
+                    and obj.__name__ != "Model"
+                ):
+                    yield obj
 
     @property
     def routes(self):
         return self.router.routes
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/core/scaffolding.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+
 from jinja2 import Environment, FileSystemLoader
 
 # Base templates directory
@@ -8,14 +9,21 @@ env = Environment(loader=FileSystemLoader(str(TEMPLATE_DIR)))
 
 def render_template_file(template_path: Path, context: dict, output_path: Path):
     """Render a single Jinja2 template file to disk."""
-    template = env.get_template(str(template_path.relative_to(TEMPLATE_DIR)).replace("\\", "/"))
+    template = env.get_template(
+        str(template_path.relative_to(TEMPLATE_DIR)).replace("\\", "/")
+    )
     content = template.render(**context)
     output_path.parent.mkdir(exist_ok=True)
     with open(output_path, "w", encoding="utf-8") as f:
         f.write(content)
 
 
-def render_template_dir(template_subdir: str, target_dir: Path, context: dict, subdir_name: str | None = None):
+def render_template_dir(
+    template_subdir: str,
+    target_dir: Path,
+    context: dict,
+    subdir_name: str | None = None,
+):
     """
     Recursively render all *.j2 templates from TEMPLATE_DIR/template_subdir into target_dir.
     If subdir_name is given, files are placed inside target_dir/subdir_name.
@@ -23,14 +31,18 @@ def render_template_dir(template_subdir: str, target_dir: Path, context: dict, s
     template_dir = TEMPLATE_DIR / template_subdir
     for root, _, files in template_dir.walk():
         root_path = Path(root)
-        rel_root = root_path.relative_to(template_dir)  # path relative to template_subdir
+        rel_root = root_path.relative_to(
+            template_dir
+        )  # path relative to template_subdir
 
         for f in files:
             if not f.endswith(".j2"):
                 continue
 
             template_rel_path = rel_root / f
-            output_rel_path = Path(*template_rel_path.parts).with_suffix("")  # remove .j2
+            output_rel_path = Path(*template_rel_path.parts).with_suffix(
+                ""
+            )  # remove .j2
 
             # optionally wrap in subdir_name
             if subdir_name:
@@ -54,7 +66,11 @@ def startapp(name: str, project: str):
     """Create a new app inside a project: templates go into <project_dir>/<name>/"""
     target_dir = Path(project)
     target_dir.mkdir(exist_ok=True)
-    render_template_dir("app", target_dir, {"project_name": target_dir.resolve().name, "app_name": name}, subdir_name=name)
+    render_template_dir(
+        "app",
+        target_dir,
+        {"project_name": target_dir.resolve().name, "app_name": name},
+        subdir_name=name,
+    )
     print(f"✅ App '{name}' created in project '{target_dir}' successfully.")
     print(f"🔧 Remember to add '{name}' to your INSTALLED_APPS!")
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/core/templates/app/routes.py.j2

@@ -1,6 +1,6 @@
 from ohmyapi.router import APIRouter
 
-from . import models
+from .models import ...
 
 # Expose your app's routes via `router = fastapi.APIRouter`.
 # Use prefixes wisely to avoid cross-app namespace-collisions.

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/db/exceptions.py

@@ -1,2 +1 @@
 from tortoise.exceptions import *
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/db/model/model.py

@@ -1,6 +1,32 @@
+from uuid import UUID
+
+from pydantic import GetCoreSchemaHandler
+from pydantic_core import core_schema
 from tortoise import fields as field
-from tortoise.models import Model as TortoiseModel
 from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
+from tortoise.models import Model as TortoiseModel
+
+
+def __uuid_schema_monkey_patch(cls, source_type, handler):
+    # Always treat UUID as string schema
+    return core_schema.no_info_after_validator_function(
+        # Accept UUID or str, always return UUID internally
+        lambda v: v if isinstance(v, UUID) else UUID(str(v)),
+        core_schema.union_schema(
+            [
+                core_schema.str_schema(),
+                core_schema.is_instance_schema(UUID),
+            ]
+        ),
+        # But when serializing, always str()
+        serialization=core_schema.plain_serializer_function_ser_schema(
+            str, when_used="always"
+        ),
+    )
+
+
+# Monkey-patch UUID
+UUID.__get_pydantic_core_schema__ = classmethod(__uuid_schema_monkey_patch)
 
 
 class ModelMeta(type(TortoiseModel)):
@@ -43,4 +69,3 @@ class Model(TortoiseModel, metaclass=ModelMeta):
     class Schema:
         include = None
         exclude = None
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/router.py

@@ -1,2 +1 @@
 from fastapi import APIRouter, Depends, HTTPException
-

ohmyapi-0.1.19/src/ohmyapi/builtin/auth/__init__.py

@@ -1,4 +0,0 @@
-from . import models
-from . import routes
-from . import permissions
-

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/builtin/auth/permissions.py

@@ -1,8 +1,8 @@
 from .routes import (
-    get_token,
     get_current_user,
-    require_authenticated,
+    get_token,
     require_admin,
-    require_staff,
+    require_authenticated,
     require_group,
+    require_staff,
 )

{ohmyapi-0.1.19 → ohmyapi-0.1.21}/src/ohmyapi/db/__init__.py

@@ -1,10 +1,10 @@
-from .model import Model, field
 from tortoise.manager import Manager
 from tortoise.queryset import QuerySet
 from tortoise.signals import (
-    pre_delete,
     post_delete,
-    pre_save,
     post_save,
+    pre_delete,
+    pre_save,
 )
 
+from .model import Model, field