ohmyapi 0.1.18__tar.gz → 0.1.20__tar.gz

{ohmyapi-0.1.18 → ohmyapi-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ohmyapi
-Version: 0.1.18
+Version: 0.1.20
 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.18 → ohmyapi-0.1.20}/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.18 → ohmyapi-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ohmyapi"
-version = "0.1.18"
+version = "0.1.20"
 description = "A Django-like but async web-framework based on FastAPI and TortoiseORM."
 license = "MIT"
 keywords = ["fastapi", "tortoise", "orm", "async", "web-framework"]

{ohmyapi-0.1.18 → ohmyapi-0.1.20}/src/ohmyapi/builtin/auth/models.py

@@ -1,20 +1,22 @@
-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 functools import wraps
+from typing import Optional, List
 from passlib.context import CryptContext
 from tortoise.contrib.pydantic import pydantic_queryset_creator
+from uuid import UUID
 
 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)

{ohmyapi-0.1.18 → ohmyapi-0.1.20}/src/ohmyapi/cli.py

@@ -10,9 +10,6 @@ from ohmyapi.core import scaffolding, runtime
 from pathlib import Path
 
 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.command()
@@ -40,52 +37,50 @@ 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()

ohmyapi-0.1.20/src/ohmyapi/db/model/model.py

@@ -0,0 +1,67 @@
+from pydantic_core import core_schema
+from pydantic import GetCoreSchemaHandler
+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 uuid import UUID
+
+
+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)):
+    def __new__(cls, name, bases, attrs):
+        new_cls = super().__new__(cls, name, bases, attrs)
+
+        schema_opts = getattr(new_cls, "Schema", None)
+
+        class BoundSchema:
+            @property
+            def model(self):
+                """Return a Pydantic model class for serializing results."""
+                include = getattr(schema_opts, "include", None)
+                exclude = getattr(schema_opts, "exclude", None)
+                return pydantic_model_creator(
+                    new_cls,
+                    name=f"{new_cls.__name__}Schema",
+                    include=include,
+                    exclude=exclude,
+                )
+
+            @property
+            def readonly(self):
+                """Return a Pydantic model class for serializing readonly results."""
+                include = getattr(schema_opts, "include", None)
+                exclude = getattr(schema_opts, "exclude", None)
+                return pydantic_model_creator(
+                    new_cls,
+                    name=f"{new_cls.__name__}SchemaReadonly",
+                    include=include,
+                    exclude=exclude,
+                    exclude_readonly=True,
+                )
+
+        new_cls.Schema = BoundSchema()
+        return new_cls
+
+
+class Model(TortoiseModel, metaclass=ModelMeta):
+    class Schema:
+        include = None
+        exclude = None
+

ohmyapi-0.1.18/src/ohmyapi/db/model/model.py

@@ -1,34 +0,0 @@
-from tortoise import fields as field
-from tortoise.models import Model as TortoiseModel
-from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
-
-
-class ModelMeta(type(TortoiseModel)):
-    def __new__(cls, name, bases, attrs):
-        new_cls = super().__new__(cls, name, bases, attrs)
-
-        schema_opts = getattr(new_cls, "Schema", None)
-
-        class BoundSchema:
-            @property
-            def model(self):
-                """Return a Pydantic model class for 'one' results."""
-                include = getattr(schema_opts, "include", None)
-                exclude = getattr(schema_opts, "exclude", None)
-                return pydantic_model_creator(
-                    new_cls,
-                    name=f"{new_cls.__name__}Schema",
-                    include=include,
-                    exclude=exclude,
-                    exclude_readonly=True,
-                )
-
-        new_cls.Schema = BoundSchema()
-        return new_cls
-
-
-class Model(TortoiseModel, metaclass=ModelMeta):
-    class Schema:
-        include = None
-        exclude = None
-