ohmyapi 0.1.6__tar.gz → 0.1.8__tar.gz

ohmyapi-0.1.8/PKG-INFO

@@ -0,0 +1,316 @@
+Metadata-Version: 2.4
+Name: ohmyapi
+Version: 0.1.8
+Summary: A Django-like but async web-framework based on FastAPI and TortoiseORM.
+License-Expression: MIT
+Keywords: fastapi,tortoise,orm,async,web-framework
+Author: Brian Wiborg
+Author-email: me@brianwib.org
+Requires-Python: >=3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Provides-Extra: auth
+Requires-Dist: aerich (>=0.9.1,<0.10.0)
+Requires-Dist: argon2-cffi (>=25.1.0,<26.0.0)
+Requires-Dist: argon2-cffi ; extra == "auth"
+Requires-Dist: crypto (>=1.4.1,<2.0.0)
+Requires-Dist: crypto ; extra == "auth"
+Requires-Dist: fastapi (>=0.117.1,<0.118.0)
+Requires-Dist: ipython (>=9.5.0,<10.0.0)
+Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
+Requires-Dist: passlib (>=1.7.4,<2.0.0)
+Requires-Dist: passlib ; extra == "auth"
+Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
+Requires-Dist: pyjwt ; extra == "auth"
+Requires-Dist: python-multipart (>=0.0.20,<0.0.21)
+Requires-Dist: python-multipart ; extra == "auth"
+Requires-Dist: tortoise-orm (>=0.25.1,<0.26.0)
+Requires-Dist: typer (>=0.19.1,<0.20.0)
+Requires-Dist: uvicorn (>=0.36.0,<0.37.0)
+Description-Content-Type: text/markdown
+
+# OhMyAPI
+
+> Think: Django RestFramework, but less clunky and 100% async.
+
+OhMyAPI is a Django-flavored web-application scaffolding framework and management layer.
+Built around FastAPI and TortoiseORM, it is 100% async.
+
+It is ***blazingly fast***, ***fun to use*** and comes with ***batteries included***!
+
+**Features**
+
+- Django-like project-layout and -structure
+- Django-like project-level settings.py
+- Django-like models via TortoiseORM
+- Django-like `Model.Meta` class for model configuration
+- Easily convert your query results to `pydantic` models via `Model.Schema`
+- Django-like migrations (`makemigrations` & `migrate`) via Aerich
+- Django-like CLI tooling (`startproject`, `startapp`, `shell`, `serve`, etc)
+- Various optional builtin apps you can hook into your project
+- Highly configurable and customizable
+- 100% async
+
+OhMyAPI aims to:
+
+- combine FastAPI, TortoiseORM and Aerich migrations into a high-productivity web-application framework
+- tying everything neatly together into a project structure consisting of apps with models and a router
+- while ***AVOIDING*** to introduce any additional abstractions ontop of Tortoise's model-system or FastAPI's routing
+
+---
+
+## Getting started
+
+**Creating a Project**
+
+```
+pip install ohmyapi
+ohmyapi startproject myproject
+cd myproject
+```
+
+This will create the following directory structure:
+
+```
+myproject/
+  - pyproject.toml
+  - README.md
+  - settings.py
+```
+
+Run your project with:
+
+```
+ohmyapi serve
+```
+
+In your browser go to:
+- http://localhost:8000/docs
+
+**Creating an App**
+
+Create a new app by:
+
+```
+ohmyapi startapp tournament
+```
+
+This will create the following directory structure:
+
+```
+myproject/
+  - tournament/
+    - __init__.py
+    - models.py
+    - routes.py
+  - pyproject.toml
+  - README.md
+  - settings.py
+```
+
+Add 'tournament' to your `INSTALLED_APPS` in `settings.py`.
+
+### Models
+
+Write your first model in `turnament/models.py`:
+
+```python
+from ohmyapi.db import Model, field
+
+
+class Tournament(Model):
+    id = field.data.UUIDField(primary_key=True)
+    name = field.TextField()
+    created = 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('torunament.Team', related_name='events', through='event_team')
+    modified = field.DatetimeField(auto_now=True)
+    prize = 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()
+
+    def __str__(self):
+        return self.name
+```
+
+### API Routes
+
+Next, create your endpoints in `tournament/routes.py`:
+
+```python
+from ohmyapi.router import APIRouter, HTTPException
+from ohmyapi.db.exceptions import DoesNotExist
+
+from .models import Tournament
+
+router = APIRouter(prefix="/tournament")
+
+
+@router.get("/")
+async def list():
+    queryset = Tournament.all()
+    return await Tournament.Schema.many.from_queryset(queryset)
+
+
+@router.get("/:id")
+async def get(id: str):
+    try:
+        queryset = Tournament.get(pk=id)
+        return await Tournament.Schema.one(queryset)
+    except DoesNotExist:
+        raise HTTPException(status_code=404, detail="item not found")
+
+...
+```
+
+## Migrations
+
+Before we can run the app, we need to create and initialize the database.
+
+Similar to Django, first run:
+
+```
+ohmyapi makemigrations [ <app> ]  # no app means all INSTALLED_APPS
+```
+
+This will create a `migrations/` folder in you project root.
+
+```
+myproject/
+  - tournament/
+    - __init__.py
+    - models.py
+    - routes.py
+  - migrations/
+    - tournament/
+  - pyproject.toml
+  - README.md
+  - settings.py
+```
+
+Apply your migrations via:
+
+```
+ohmyapi migrate [ <app> ]  # no app means all INSTALLED_APPS
+```
+
+Run your project:
+
+```
+ohmyapi serve
+```
+
+## Shell
+
+Similar to Django, you can attach to an interactive shell with your project already loaded inside.
+
+```
+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 necessary tables to be created in the database.
+
+`settings.py`:
+
+```
+INSTALLED_APPS = [
+    'ohmyapi_auth',
+    ...
+]
+
+JWT_SECRET = "t0ps3cr3t"
+```
+
+After restarting your project you will have access to the `ohmyapi_auth` app.
+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
+class Team(Model):
+    [...]
+    members = field.ManyToManyField('ohmyapi_auth.User', related_name='tournament_teams', through='tournament_teams')
+    [...]
+```
+
+Remember to run `makemigrations` and `migrate` in order for your model changes to take effect in the database.
+
+Create a super-user:
+
+```
+ohmyapi createsuperuser
+```
+
+## Permissions
+
+### API-Level Permissions
+
+Use FastAPI's `Depends` pattern to implement API-level access-control.
+
+
+In your `routes.py`:
+
+```python
+from ohmyapi.router import APIRouter, Depends
+
+from ohmyapi_auth.models import User
+from ohmyapi_auth import (
+    models as auth,
+    permissions,
+)
+
+from .models import Tournament
+
+router = APIRouter(prefix="/tournament")
+
+
+@router.get("/")
+async def list(user: auth.User = Depends(permissions.require_authenticated)):
+    queryset = Tournament.all()
+    return await Tournament.Schema.many.from_queryset(queryset)
+
+
+...
+```
+
+### Model-Level Permissions
+
+Use Tortoise's `Manager` to implement model-level permissions.
+
+```python
+from ohmyapi.db import Manager
+from typing import Callable
+
+
+class TeamManager(Manager):
+    async def for_user(self, user: ohmyapi_auth.models.User):
+        return await self.filter(members=user).all()
+
+
+class Team(Model):
+    [...]
+
+    class Meta:
+        manager = TeamManager()
+```
+

ohmyapi-0.1.8/README.md

@@ -0,0 +1,283 @@
+# OhMyAPI
+
+> Think: Django RestFramework, but less clunky and 100% async.
+
+OhMyAPI is a Django-flavored web-application scaffolding framework and management layer.
+Built around FastAPI and TortoiseORM, it is 100% async.
+
+It is ***blazingly fast***, ***fun to use*** and comes with ***batteries included***!
+
+**Features**
+
+- Django-like project-layout and -structure
+- Django-like project-level settings.py
+- Django-like models via TortoiseORM
+- Django-like `Model.Meta` class for model configuration
+- Easily convert your query results to `pydantic` models via `Model.Schema`
+- Django-like migrations (`makemigrations` & `migrate`) via Aerich
+- Django-like CLI tooling (`startproject`, `startapp`, `shell`, `serve`, etc)
+- Various optional builtin apps you can hook into your project
+- Highly configurable and customizable
+- 100% async
+
+OhMyAPI aims to:
+
+- combine FastAPI, TortoiseORM and Aerich migrations into a high-productivity web-application framework
+- tying everything neatly together into a project structure consisting of apps with models and a router
+- while ***AVOIDING*** to introduce any additional abstractions ontop of Tortoise's model-system or FastAPI's routing
+
+---
+
+## Getting started
+
+**Creating a Project**
+
+```
+pip install ohmyapi
+ohmyapi startproject myproject
+cd myproject
+```
+
+This will create the following directory structure:
+
+```
+myproject/
+  - pyproject.toml
+  - README.md
+  - settings.py
+```
+
+Run your project with:
+
+```
+ohmyapi serve
+```
+
+In your browser go to:
+- http://localhost:8000/docs
+
+**Creating an App**
+
+Create a new app by:
+
+```
+ohmyapi startapp tournament
+```
+
+This will create the following directory structure:
+
+```
+myproject/
+  - tournament/
+    - __init__.py
+    - models.py
+    - routes.py
+  - pyproject.toml
+  - README.md
+  - settings.py
+```
+
+Add 'tournament' to your `INSTALLED_APPS` in `settings.py`.
+
+### Models
+
+Write your first model in `turnament/models.py`:
+
+```python
+from ohmyapi.db import Model, field
+
+
+class Tournament(Model):
+    id = field.data.UUIDField(primary_key=True)
+    name = field.TextField()
+    created = 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('torunament.Team', related_name='events', through='event_team')
+    modified = field.DatetimeField(auto_now=True)
+    prize = 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()
+
+    def __str__(self):
+        return self.name
+```
+
+### API Routes
+
+Next, create your endpoints in `tournament/routes.py`:
+
+```python
+from ohmyapi.router import APIRouter, HTTPException
+from ohmyapi.db.exceptions import DoesNotExist
+
+from .models import Tournament
+
+router = APIRouter(prefix="/tournament")
+
+
+@router.get("/")
+async def list():
+    queryset = Tournament.all()
+    return await Tournament.Schema.many.from_queryset(queryset)
+
+
+@router.get("/:id")
+async def get(id: str):
+    try:
+        queryset = Tournament.get(pk=id)
+        return await Tournament.Schema.one(queryset)
+    except DoesNotExist:
+        raise HTTPException(status_code=404, detail="item not found")
+
+...
+```
+
+## Migrations
+
+Before we can run the app, we need to create and initialize the database.
+
+Similar to Django, first run:
+
+```
+ohmyapi makemigrations [ <app> ]  # no app means all INSTALLED_APPS
+```
+
+This will create a `migrations/` folder in you project root.
+
+```
+myproject/
+  - tournament/
+    - __init__.py
+    - models.py
+    - routes.py
+  - migrations/
+    - tournament/
+  - pyproject.toml
+  - README.md
+  - settings.py
+```
+
+Apply your migrations via:
+
+```
+ohmyapi migrate [ <app> ]  # no app means all INSTALLED_APPS
+```
+
+Run your project:
+
+```
+ohmyapi serve
+```
+
+## Shell
+
+Similar to Django, you can attach to an interactive shell with your project already loaded inside.
+
+```
+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 necessary tables to be created in the database.
+
+`settings.py`:
+
+```
+INSTALLED_APPS = [
+    'ohmyapi_auth',
+    ...
+]
+
+JWT_SECRET = "t0ps3cr3t"
+```
+
+After restarting your project you will have access to the `ohmyapi_auth` app.
+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
+class Team(Model):
+    [...]
+    members = field.ManyToManyField('ohmyapi_auth.User', related_name='tournament_teams', through='tournament_teams')
+    [...]
+```
+
+Remember to run `makemigrations` and `migrate` in order for your model changes to take effect in the database.
+
+Create a super-user:
+
+```
+ohmyapi createsuperuser
+```
+
+## Permissions
+
+### API-Level Permissions
+
+Use FastAPI's `Depends` pattern to implement API-level access-control.
+
+
+In your `routes.py`:
+
+```python
+from ohmyapi.router import APIRouter, Depends
+
+from ohmyapi_auth.models import User
+from ohmyapi_auth import (
+    models as auth,
+    permissions,
+)
+
+from .models import Tournament
+
+router = APIRouter(prefix="/tournament")
+
+
+@router.get("/")
+async def list(user: auth.User = Depends(permissions.require_authenticated)):
+    queryset = Tournament.all()
+    return await Tournament.Schema.many.from_queryset(queryset)
+
+
+...
+```
+
+### Model-Level Permissions
+
+Use Tortoise's `Manager` to implement model-level permissions.
+
+```python
+from ohmyapi.db import Manager
+from typing import Callable
+
+
+class TeamManager(Manager):
+    async def for_user(self, user: ohmyapi_auth.models.User):
+        return await self.filter(members=user).all()
+
+
+class Team(Model):
+    [...]
+
+    class Meta:
+        manager = TeamManager()
+```

ohmyapi-0.1.8/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "ohmyapi"
+version = "0.1.8"
+description = "A Django-like but async web-framework based on FastAPI and TortoiseORM."
+license = "MIT"
+keywords = ["fastapi", "tortoise", "orm", "async", "web-framework"]
+authors = [
+    {name = "Brian Wiborg", email = "me@brianwib.org"}
+]
+readme = "README.md"
+requires-python = ">=3.13"
+
+dependencies = [
+    "typer >=0.19.1,<0.20.0",
+    "jinja2 >=3.1.6,<4.0.0",
+    "fastapi >=0.117.1,<0.118.0",
+    "tortoise-orm >=0.25.1,<0.26.0",
+    "aerich >=0.9.1,<0.10.0",
+    "uvicorn >=0.36.0,<0.37.0",
+    "ipython >=9.5.0,<10.0.0",
+    "passlib >=1.7.4,<2.0.0",
+    "pyjwt >=2.10.1,<3.0.0",
+    "python-multipart >=0.0.20,<0.0.21",
+    "crypto >=1.4.1,<2.0.0",
+    "argon2-cffi >=25.1.0,<26.0.0",
+]
+
+[tool.poetry.group.dev.dependencies]
+ipython = ">=9.5.0,<10.0.0"
+
+[project.optional-dependencies]
+auth = ["passlib", "pyjwt", "crypto", "argon2-cffi", "python-multipart"]
+
+[tool.poetry]
+packages = [ { include = "ohmyapi", from = "src" } ]
+
+[project.scripts]
+ohmyapi = "ohmyapi.cli:app"

ohmyapi-0.1.8/src/ohmyapi/__main__.py

@@ -0,0 +1,3 @@
+from .cli import app
+
+app()

{ohmyapi-0.1.6 → ohmyapi-0.1.8}/src/ohmyapi/builtin/auth/models.py

@@ -7,12 +7,12 @@ pwd_context = CryptContext(schemes=["argon2"], deprecated="auto")
 
 
 class Group(Model):
-    id = field.IntField(pk=True)
+    id = field.data.UUIDField(pk=True)
     name = field.CharField(max_length=42, index=True)
 
 
 class User(Model):
-    id = field.IntField(pk=True)
+    id = field.data.UUIDField(pk=True)
     email = field.CharField(max_length=255, unique=True, index=True)
     username = field.CharField(max_length=150, unique=True)
     password_hash = field.CharField(max_length=128)

{ohmyapi-0.1.6 → ohmyapi-0.1.8}/src/ohmyapi/builtin/auth/permissions.py

@@ -1,4 +1,5 @@
 from .routes import (
+    get_token,
     get_current_user,
     require_authenticated,
     require_admin,

{ohmyapi-0.1.6 → ohmyapi-0.1.8}/src/ohmyapi/builtin/auth/routes.py

@@ -1,12 +1,13 @@
 import time
-from typing import Dict
+from enum import Enum
+from typing import Any, Dict, List
 
 import jwt
 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
+from ohmyapi.builtin.auth.models import User, Group
 
 import settings
 
@@ -40,14 +41,39 @@ def decode_token(token: str) -> Dict:
         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]:
+    return {
+        'type': token_type,
+        'sub': str(user.id),
+        'user': {
+            'username': user.username,
+            'email': user.email,
+        },
+        'roles': [g.name for g in groups]
+    }
+
+async def get_token(token: str = Depends(oauth2_scheme)) -> Dict:
+    """Dependency: token introspection"""
+    payload = decode_token(token)
+    return payload
+
+
 async def get_current_user(token: str = Depends(oauth2_scheme)) -> User:
     """Dependency: extract user from access token."""
     payload = decode_token(token)
-    username = payload.get("sub")
-    if username is None:
+    user_id = payload.get("sub")
+    if user_id is None:
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid token payload")
 
-    user = await User.filter(username=username).first()
+    user = await User.filter(id=user_id).first()
     if not user:
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="User not found")
     return user
@@ -100,8 +126,8 @@ async def login(form_data: LoginRequest = Body(...)):
     if not user:
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
 
-    access_token = create_token({"sub": user.username, "type": "access"}, ACCESS_TOKEN_EXPIRE_SECONDS)
-    refresh_token = create_token({"sub": user.username, "type": "refresh"}, 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,
@@ -117,20 +143,26 @@ async def refresh_token(refresh_token: str):
     if payload.get("type") != "refresh":
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid refresh token")
 
-    username = payload.get("sub")
-    user = await User.filter(username=username).first()
+    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")
 
-    new_access = create_token({"sub": user.username, "type": "access"}, ACCESS_TOKEN_EXPIRE_SECONDS)
+    new_access = create_token(claims(TokenType.access, user), ACCESS_TOKEN_EXPIRE_SECONDS)
     return {"access_token": new_access, "token_type": "bearer"}
 
 
 @router.get("/me")
-async def me(current_user: User = Depends(get_current_user)):
+async def me(user: User = Depends(get_current_user)):
     """Return the currently authenticated user."""
     return {
-        "username": current_user.username,
-        "is_admin": current_user.is_admin,
-        "is_staff": current_user.is_staff,
+        "email": user.email,
+        "username": user.username,
+        "is_admin": user.is_admin,
+        "is_staff": user.is_staff,
     }
+
+
+@router.get("/introspect")
+async def introspect(token: Dict = Depends(get_token)):
+    return token

{ohmyapi-0.1.6 → ohmyapi-0.1.8}/src/ohmyapi/cli.py

@@ -101,14 +101,12 @@ def createsuperuser(root: str = "."):
 
     import asyncio
     import ohmyapi_auth
+    email = input("E-Mail: ")
     username = input("Username: ")
     password = getpass("Password: ")
-    user = ohmyapi_auth.models.User(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(password)
     asyncio.run(project.init_orm())
     asyncio.run(user.save())
     asyncio.run(project.close_orm())
 
-def main():
-    app()
-

ohmyapi-0.1.8/src/ohmyapi/core/templates/project/README.md.j2

@@ -0,0 +1,2 @@
+# {{ project_name }}
+

ohmyapi-0.1.8/src/ohmyapi/core/templates/project/pyproject.toml.j2

@@ -0,0 +1,37 @@
+[project]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "OhMyAPI project"
+authors = [
+    { name = "You", email = "you@you.tld" }
+]
+requires-python = ">=3.13"
+readme = "README.md"
+license = { text = "MIT" }
+
+dependencies = [
+    "typer >=0.19.1,<0.20.0",
+    "jinja2 >=3.1.6,<4.0.0",
+    "fastapi >=0.117.1,<0.118.0",
+    "tortoise-orm >=0.25.1,<0.26.0",
+    "aerich >=0.9.1,<0.10.0",
+    "uvicorn >=0.36.0,<0.37.0",
+    "ipython >=9.5.0,<10.0.0",
+    "passlib >=1.7.4,<2.0.0",
+    "pyjwt >=2.10.1,<3.0.0",
+    "python-multipart >=0.0.20,<0.0.21",
+    "crypto >=1.4.1,<2.0.0",
+    "argon2-cffi >=25.1.0,<26.0.0",
+]
+
+[tool.poetry.group.dev.dependencies]
+ipython = ">=9.5.0,<10.0.0"
+
+[project.optional-dependencies]
+auth = ["passlib", "pyjwt", "crypto", "argon2-cffi", "python-multipart"]
+
+[tool.poetry]
+package-mode = false
+
+[project.scripts]
+{{ project_name }} = "ohmyapi.cli:app"

ohmyapi-0.1.8/src/ohmyapi/db/__init__.py

@@ -0,0 +1,3 @@
+from .model import Model, field
+from tortoise.manager import Manager
+

ohmyapi-0.1.8/src/ohmyapi/db/exceptions.py

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

ohmyapi-0.1.8/src/ohmyapi/db/model/__init__.py

@@ -0,0 +1 @@
+from .model import Model, field

{ohmyapi-0.1.6 → ohmyapi-0.1.8}/src/ohmyapi/db/model/model.py

@@ -1,4 +1,4 @@
-from tortoise import fields
+from tortoise import fields as field
 from tortoise.models import Model as TortoiseModel
 from tortoise.contrib.pydantic import pydantic_model_creator, pydantic_queryset_creator
 

ohmyapi-0.1.8/src/ohmyapi/router.py

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

ohmyapi-0.1.6/PKG-INFO

@@ -1,204 +0,0 @@
-Metadata-Version: 2.4
-Name: ohmyapi
-Version: 0.1.6
-Summary: A Django-like but async web-framework based on FastAPI and TortoiseORM.
-License-Expression: MIT
-Keywords: fastapi,tortoise,orm,async,web-framework
-Author: Brian Wiborg
-Author-email: me@brianwib.org
-Requires-Python: >=3.13
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: aerich (>=0.9.1,<0.10.0)
-Requires-Dist: argon2-cffi (>=25.1.0,<26.0.0)
-Requires-Dist: crypto (>=1.4.1,<2.0.0)
-Requires-Dist: fastapi (>=0.117.1,<0.118.0)
-Requires-Dist: ipython (>=9.5.0,<10.0.0)
-Requires-Dist: jinja2 (>=3.1.6,<4.0.0)
-Requires-Dist: passlib (>=1.7.4,<2.0.0)
-Requires-Dist: pyjwt (>=2.10.1,<3.0.0)
-Requires-Dist: python-multipart (>=0.0.20,<0.0.21)
-Requires-Dist: tortoise-orm (>=0.25.1,<0.26.0)
-Requires-Dist: typer (>=0.19.1,<0.20.0)
-Requires-Dist: uvicorn (>=0.36.0,<0.37.0)
-Description-Content-Type: text/markdown
-
-# OhMyAPI
-
-> OhMyAPI == Application scaffolding for FastAPI+TortoiseORM.
-
-OhMyAPI is a Django-flavored web-application scaffolding framework.
-Built around FastAPI and TortoiseORM, it 100% async.
-It is blazingly fast and has batteries included.
-
-Features:
-
-- Django-like project-layout and -structure
-- Django-like settings.py
-- Django-like models via TortoiseORM
-- Django-like model.Meta class for model configuration
-- Django-like advanced permissions system
-- Django-like migrations (makemigrations & migrate) via Aerich
-- Django-like CLI for interfacing with your projects (startproject, startapp, shell, serve, etc)
-- various optional builtin apps
-- highly configurable and customizable
-- 100% async
-
-## Getting started
-
-**Creating a Project**
-
-```
-pip install ohmyapi
-ohmyapi startproject myproject
-cd myproject
-```
-
-This will create the following directory structure:
-
-```
-myproject/
-  - pyproject.toml
-  - settings.py
-```
-
-Run your project with:
-
-```
-ohmyapi serve
-```
-
-In your browser go to:
-- http://localhost:8000/docs
-
-**Creating an App**
-
-Create a new app by:
-
-```
-ohmyapi startapp myapp
-```
-
-This will lead to the following directory structure:
-
-```
-myproject/
-  - myapp/
-    - __init__.py
-    - models.py
-    - routes.py
-  - pyproject.toml
-  - settings.py
-```
-
-Add 'myapp' to your `INSTALLED_APPS` in `settings.py`.
-
-Write your first model in `myapp/models.py`:
-
-```python
-from ohmyapi.db import Model, field
-
-
-class Person(Model):
-    id: int = field.IntField(min=1, pk=True)
-    name: str = field.CharField(min_length=1, max_length=255)
-    username: str = field.CharField(min_length=1, max_length=255, unique=True)
-    age: int = field.IntField(min=0)
-```
-
-Next, create your endpoints in `myapp/routes.py`:
-
-```python
-from fastapi import APIRouter, HTTPException
-from tortoise.exceptions import DoesNotExist
-
-from .models import Person
-
-router = APIRouter(prefix="/myapp")
-
-
-@router.get("/")
-async def list():
-    return await Person.Schema.many.from_queryset(Person.all())
-
-
-@router.get("/:id")
-async def get(id: int):
-    try:
-        return await Person.Schema.one(Person.get(pk=id))
-    except DoesNotExist:
-        raise HTTPException(status_code=404, detail="item not found")
-
-...
-```
-
-## Migrations
-
-Before we can run the app, we need to create and initialize the database.
-
-Similar to Django, first run:
-
-```
-ohmyapi makemigrations [ <app> ]  # no app means all INSTALLED_APPS
-```
-
-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
-```
-
-Run your project:
-
-```
-ohmyapi serve
-```
-
-## Shell
-
-Similar to Django, you can attach to an interactive shell with your project already loaded inside.
-
-```
-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.
-
-`settings.py`:
-
-```
-INSTALLED_APPS = [
-    'ohmyapi_auth',
-    ...
-]
-
-JWT_SECRET = "t0ps3cr3t"
-```
-
-Create a super-user:
-
-```
-ohmyapi createsuperuser
-```
-
-

ohmyapi-0.1.6/README.md

@@ -1,177 +0,0 @@
-# OhMyAPI
-
-> OhMyAPI == Application scaffolding for FastAPI+TortoiseORM.
-
-OhMyAPI is a Django-flavored web-application scaffolding framework.
-Built around FastAPI and TortoiseORM, it 100% async.
-It is blazingly fast and has batteries included.
-
-Features:
-
-- Django-like project-layout and -structure
-- Django-like settings.py
-- Django-like models via TortoiseORM
-- Django-like model.Meta class for model configuration
-- Django-like advanced permissions system
-- Django-like migrations (makemigrations & migrate) via Aerich
-- Django-like CLI for interfacing with your projects (startproject, startapp, shell, serve, etc)
-- various optional builtin apps
-- highly configurable and customizable
-- 100% async
-
-## Getting started
-
-**Creating a Project**
-
-```
-pip install ohmyapi
-ohmyapi startproject myproject
-cd myproject
-```
-
-This will create the following directory structure:
-
-```
-myproject/
-  - pyproject.toml
-  - settings.py
-```
-
-Run your project with:
-
-```
-ohmyapi serve
-```
-
-In your browser go to:
-- http://localhost:8000/docs
-
-**Creating an App**
-
-Create a new app by:
-
-```
-ohmyapi startapp myapp
-```
-
-This will lead to the following directory structure:
-
-```
-myproject/
-  - myapp/
-    - __init__.py
-    - models.py
-    - routes.py
-  - pyproject.toml
-  - settings.py
-```
-
-Add 'myapp' to your `INSTALLED_APPS` in `settings.py`.
-
-Write your first model in `myapp/models.py`:
-
-```python
-from ohmyapi.db import Model, field
-
-
-class Person(Model):
-    id: int = field.IntField(min=1, pk=True)
-    name: str = field.CharField(min_length=1, max_length=255)
-    username: str = field.CharField(min_length=1, max_length=255, unique=True)
-    age: int = field.IntField(min=0)
-```
-
-Next, create your endpoints in `myapp/routes.py`:
-
-```python
-from fastapi import APIRouter, HTTPException
-from tortoise.exceptions import DoesNotExist
-
-from .models import Person
-
-router = APIRouter(prefix="/myapp")
-
-
-@router.get("/")
-async def list():
-    return await Person.Schema.many.from_queryset(Person.all())
-
-
-@router.get("/:id")
-async def get(id: int):
-    try:
-        return await Person.Schema.one(Person.get(pk=id))
-    except DoesNotExist:
-        raise HTTPException(status_code=404, detail="item not found")
-
-...
-```
-
-## Migrations
-
-Before we can run the app, we need to create and initialize the database.
-
-Similar to Django, first run:
-
-```
-ohmyapi makemigrations [ <app> ]  # no app means all INSTALLED_APPS
-```
-
-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
-```
-
-Run your project:
-
-```
-ohmyapi serve
-```
-
-## Shell
-
-Similar to Django, you can attach to an interactive shell with your project already loaded inside.
-
-```
-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.
-
-`settings.py`:
-
-```
-INSTALLED_APPS = [
-    'ohmyapi_auth',
-    ...
-]
-
-JWT_SECRET = "t0ps3cr3t"
-```
-
-Create a super-user:
-
-```
-ohmyapi createsuperuser
-```
-

ohmyapi-0.1.6/pyproject.toml

@@ -1,36 +0,0 @@
-[project]
-name = "ohmyapi"
-version = "0.1.6"
-description = "A Django-like but async web-framework based on FastAPI and TortoiseORM."
-license = "MIT"
-keywords = ["fastapi", "tortoise", "orm", "async", "web-framework"]
-authors = [
-    {name = "Brian Wiborg", email = "me@brianwib.org"}
-]
-readme = "README.md"
-requires-python = ">=3.13"
-dependencies = [
-    "typer (>=0.19.1,<0.20.0)",
-    "jinja2 (>=3.1.6,<4.0.0)",
-    "fastapi (>=0.117.1,<0.118.0)",
-    "tortoise-orm (>=0.25.1,<0.26.0)",
-    "aerich (>=0.9.1,<0.10.0)",
-    "uvicorn (>=0.36.0,<0.37.0)",
-    "ipython (>=9.5.0,<10.0.0)",
-    "passlib (>=1.7.4,<2.0.0)",
-    "pyjwt (>=2.10.1,<3.0.0)",
-    "python-multipart (>=0.0.20,<0.0.21)",
-    "crypto (>=1.4.1,<2.0.0)",
-    "argon2-cffi (>=25.1.0,<26.0.0)",
-]
-
-[tool.poetry]
-packages = [{include = "ohmyapi", from = "src"}]
-
-[tool.poetry.scripts]
-ohmyapi = "ohmyapi.cli:main"
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"
-

ohmyapi-0.1.6/src/ohmyapi/core/templates/project/pyproject.toml.j2

@@ -1,13 +0,0 @@
-[tool.poetry]
-name = "{{ project_name }}"
-version = "0.1.0"
-description = "OhMyAPI project"
-authors = ["You <you@example.com>"]
-
-[tool.poetry.dependencies]
-python = "^3.10"
-fastapi = "^0.115"
-uvicorn = "^0.30"
-tortoise-orm = "^0.20"
-aerich = "^0.7"
-

ohmyapi-0.1.6/src/ohmyapi/db/__init__.py

@@ -1,3 +0,0 @@
-from tortoise import fields as field
-from .model import Model
-

ohmyapi-0.1.6/src/ohmyapi/db/model/__init__.py

@@ -1 +0,0 @@
-from .model import Model, fields

ohmyapi-0.1.6/src/ohmyapi/router.py

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