ohmyapi 0.1.0__tar.gz → 0.1.2__tar.gz

{ohmyapi-0.1.0 → ohmyapi-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ohmyapi
-Version: 0.1.0
+Version: 0.1.2
 Summary: A Django-like but async web-framework based on FastAPI and TortoiseORM.
 License-Expression: MIT
 Keywords: fastapi,tortoise,orm,async,web-framework
@@ -28,8 +28,9 @@ Description-Content-Type: text/markdown
 
 > OhMyAPI == Application scaffolding for FastAPI+TortoiseORM.
 
-OhMyAPI is a blazingly fast, async Python web application framework with batteries included.
-It is built around FastAPI and TortoiseORM and is thus 100% async.
+OhMyAPI is a Django-flavored web-application scaffolding framework.
+It is blazingly fast, async and has batteries included.
+Built around FastAPI and TortoiseORM makes it 100% async.
 
 Features:
 
@@ -49,7 +50,7 @@ Features:
 **Creating a Project**
 
 ```
-pip install ohmyapi  # TODO: not yet published
+pip install ohmyapi
 ohmyapi startproject myproject
 cd myproject
 ```
@@ -119,13 +120,13 @@ router = APIRouter(prefix="/myapp")
 
 @router.get("/")
 async def list():
-    return await Person.all()
+    return await Person.Schema.many.from_queryset(Person.all())
 
 
 @router.get("/:id")
 async def get(id: int):
     try:
-        await Person.get(pk=id)
+        return await Person.Schema.one(Person.get(pk=id))
     except DoesNotExist:
         raise HTTPException(status_code=404, detail="item not found")
 
@@ -142,7 +143,21 @@ Similar to Django, first run:
 ohmyapi makemigrations [ <app> ]  # no app means all INSTALLED_APPS
 ```
 
-And the apply your migrations via:
+This will create a `migrations/` folder in you project root.
+
+```
+myproject/
+  - myapp/
+    - __init__.py
+    - models.py
+    - routes.py
+  - migrations/
+    - myapp/
+  - pyproject.toml
+  - settings.py
+```
+
+Apply your migrations via:
 
 ```
 ohmyapi migrate [ <app> ]  # no app means all INSTALLED_APPS
@@ -165,6 +180,7 @@ ohmyapi shell
 ## Authentication
 
 A builtin auth app is available.
+
 Simply add `ohmyapi_auth` to your INSTALLED_APPS and define a JWT_SECRET in your `settings.py`.
 Remember to `makemigrations` and `migrate` for the auth tables to be created in the database.
 
@@ -179,3 +195,10 @@ INSTALLED_APPS = [
 JWT_SECRET = "t0ps3cr3t"
 ```
 
+Create a super-user:
+
+```
+ohmyapi createsuperuser
+```
+
+

{ohmyapi-0.1.0 → ohmyapi-0.1.2}/README.md

@@ -2,8 +2,9 @@
 
 > OhMyAPI == Application scaffolding for FastAPI+TortoiseORM.
 
-OhMyAPI is a blazingly fast, async Python web application framework with batteries included.
-It is built around FastAPI and TortoiseORM and is thus 100% async.
+OhMyAPI is a Django-flavored web-application scaffolding framework.
+It is blazingly fast, async and has batteries included.
+Built around FastAPI and TortoiseORM makes it 100% async.
 
 Features:
 
@@ -23,7 +24,7 @@ Features:
 **Creating a Project**
 
 ```
-pip install ohmyapi  # TODO: not yet published
+pip install ohmyapi
 ohmyapi startproject myproject
 cd myproject
 ```
@@ -93,13 +94,13 @@ router = APIRouter(prefix="/myapp")
 
 @router.get("/")
 async def list():
-    return await Person.all()
+    return await Person.Schema.many.from_queryset(Person.all())
 
 
 @router.get("/:id")
 async def get(id: int):
     try:
-        await Person.get(pk=id)
+        return await Person.Schema.one(Person.get(pk=id))
     except DoesNotExist:
         raise HTTPException(status_code=404, detail="item not found")
 
@@ -116,7 +117,21 @@ Similar to Django, first run:
 ohmyapi makemigrations [ <app> ]  # no app means all INSTALLED_APPS
 ```
 
-And the apply your migrations via:
+This will create a `migrations/` folder in you project root.
+
+```
+myproject/
+  - myapp/
+    - __init__.py
+    - models.py
+    - routes.py
+  - migrations/
+    - myapp/
+  - pyproject.toml
+  - settings.py
+```
+
+Apply your migrations via:
 
 ```
 ohmyapi migrate [ <app> ]  # no app means all INSTALLED_APPS
@@ -139,6 +154,7 @@ ohmyapi shell
 ## Authentication
 
 A builtin auth app is available.
+
 Simply add `ohmyapi_auth` to your INSTALLED_APPS and define a JWT_SECRET in your `settings.py`.
 Remember to `makemigrations` and `migrate` for the auth tables to be created in the database.
 
@@ -152,3 +168,10 @@ INSTALLED_APPS = [
 
 JWT_SECRET = "t0ps3cr3t"
 ```
+
+Create a super-user:
+
+```
+ohmyapi createsuperuser
+```
+

{ohmyapi-0.1.0 → ohmyapi-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ohmyapi"
-version = "0.1.0"
+version = "0.1.2"
 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.0 → ohmyapi-0.1.2}/src/ohmyapi/builtin/auth/models.py

@@ -1,23 +1,30 @@
 from typing import Optional, List
 from ohmyapi.db import Model, field
 from passlib.context import CryptContext
+from tortoise.contrib.pydantic import pydantic_queryset_creator
 
 pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
 
 
 class Group(Model):
     id = field.IntField(pk=True)
-    name = field.CharField(max_length=42)
+    name = field.CharField(max_length=42, index=True)
 
 
 class User(Model):
     id = field.IntField(pk=True)
+    email = CharField(unique=True, index=True)
     username = field.CharField(max_length=150, unique=True)
     password_hash = field.CharField(max_length=128)
     is_admin = field.BooleanField(default=False)
     is_staff = field.BooleanField(default=False)
     groups: Optional[List[Group]] = field.ManyToManyField("ohmyapi_auth.Group", related_name="users")
 
+
+    class Schema:
+        exclude = 'password_hash',
+
+
     def set_password(self, raw_password: str) -> None:
         """Hash and store the password."""
         self.password_hash = pwd_context.hash(raw_password)

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

@@ -0,0 +1,46 @@
+from tortoise import fields
+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 one(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__}SchemaOne",
+                    include=include,
+                    exclude=exclude,
+                    exclude_readonly=True,
+                )
+
+            @property
+            def many(self):
+                """Return a Pydantic queryset class for 'many' results."""
+                include = getattr(schema_opts, "include", None)
+                exclude = getattr(schema_opts, "exclude", None)
+                return pydantic_queryset_creator(
+                    new_cls,
+                    name=f"{new_cls.__name__}SchemaMany",
+                    include=include,
+                    exclude=exclude,
+                )
+
+        new_cls.Schema = BoundSchema()
+        return new_cls
+
+
+class Model(TortoiseModel, metaclass=ModelMeta):
+    class Schema:
+        include = None
+        exclude = None
+

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

@@ -1,80 +0,0 @@
-from tortoise import fields
-from tortoise.models import Model as TortoiseModel
-from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
-
-
-class Model(TortoiseModel):
-    """
-    Base Tortoise model with attached Pydantic schema generators via .Schema
-    """
-
-    class Schema:
-        """
-        Provides convenient access to auto-generated Pydantic schemas.
-        """
-
-        def __init__(self, model_cls):
-            self.model_cls = model_cls
-
-        @property
-        def id(self):
-            # Minimal schema with just the primary key field
-            pk_field = self.model_cls._meta.pk_attr
-            return pydantic_model_creator(
-                self.model_cls, name=f"{self.model_cls.__name__}SchemaId", include=(pk_field,)
-            )
-
-        @property
-        def get(self):
-            # Full schema for reading
-            return pydantic_model_creator(
-                self.model_cls, name=f"{self.model_cls.__name__}SchemaGet"
-            )
-
-        @property
-        def post(self):
-            # Input schema for creation (no readonly fields like ID/PK)
-            return pydantic_model_creator(
-                self.model_cls,
-                name=f"{self.model_cls.__name__}SchemaPost",
-                exclude_readonly=True,
-            )
-
-        @property
-        def put(self):
-            # Input schema for updating
-            return pydantic_model_creator(
-                self.model_cls,
-                name=f"{self.model_cls.__name__}SchemaPut",
-                exclude_readonly=True,
-            )
-
-        @property
-        def delete(self):
-            # Schema for delete operations (just PK)
-            pk_field = self.model_cls._meta.pk_attr
-            return pydantic_model_creator(
-                self.model_cls, name=f"{self.model_cls.__name__}SchemaDelete", include=(pk_field,)
-            )
-
-        @property
-        def list(self):
-            # Schema for list endpoints
-            return pydantic_queryset_creator(self.model_cls)
-
-        def from_fields(self, *fields: str):
-            # Generate schema restricted to given fields
-            valid = [f for f in fields if f in self.model_cls._meta.fields_map]
-            return pydantic_model_creator(
-                self.model_cls,
-                name=f"{self.model_cls.__name__}SchemaFields",
-                include=valid,
-            )
-
-    def __init_subclass__(cls, **kwargs):
-        """
-        Automatically attach .Schema to all subclasses
-        """
-        super().__init_subclass__(**kwargs)
-        cls.Schema = cls.Schema(cls)
-