ohmyapi 0.1.0__tar.gz → 0.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ohmyapi
-Version: 0.1.0
+Version: 0.1.1
 Summary: A Django-like but async web-framework based on FastAPI and TortoiseORM.
 License-Expression: MIT
 Keywords: fastapi,tortoise,orm,async,web-framework
@@ -142,7 +142,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 +179,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.
 

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

@@ -116,7 +116,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 +153,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.
 

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

@@ -1,6 +1,6 @@
 [project]
 name = "ohmyapi"
-version = "0.1.0"
+version = "0.1.1"
 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.1}/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.1/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)
-