Deployed dc4f73f to dev with MkDocs 1.2.4 and mike 1.1.2

dev/src/cookbook_create_user_programmatically.py

@@ -0,0 +1,25 @@
+import contextlib
+
+from app.db import get_async_session, get_user_db
+from app.models import UserCreate
+from app.users import get_user_manager
+from fastapi_users.manager import UserAlreadyExists
+
+get_async_session_context = contextlib.asynccontextmanager(get_async_session)
+get_user_db_context = contextlib.asynccontextmanager(get_user_db)
+get_user_manager_context = contextlib.asynccontextmanager(get_user_manager)
+
+
+async def create_user(email: str, password: str, is_superuser: bool = False):
+    try:
+        async with get_async_session_context() as session:
+            async with get_user_db_context(session) as user_db:
+                async with get_user_manager_context(user_db) as user_manager:
+                    user = await user_manager.create(
+                        UserCreate(
+                            email=email, password=password, is_superuser=is_superuser
+                        )
+                    )
+                    print(f"User created {user}")
+    except UserAlreadyExists:
+        print(f"User {email} already exists")

dev/src/db_mongodb.py

@@ -0,0 +1,15 @@
+import motor.motor_asyncio
+from fastapi_users.db import MongoDBUserDatabase
+
+from .models import UserDB
+
+DATABASE_URL = "mongodb://localhost:27017"
+client = motor.motor_asyncio.AsyncIOMotorClient(
+    DATABASE_URL, uuidRepresentation="standard"
+)
+db = client["database_name"]
+collection = db["users"]
+
+
+async def get_user_db():
+    yield MongoDBUserDatabase(UserDB, collection)

dev/src/db_mongodb_access_tokens.py

@@ -0,0 +1,21 @@
+import motor.motor_asyncio
+from fastapi_users.db import MongoDBUserDatabase
+from fastapi_users_db_mongodb.access_token import MongoDBAccessTokenDatabase
+
+from .models import AccessToken, UserDB
+
+DATABASE_URL = "mongodb://localhost:27017"
+client = motor.motor_asyncio.AsyncIOMotorClient(
+    DATABASE_URL, uuidRepresentation="standard"
+)
+db = client["database_name"]
+users_collection = db["users"]
+access_tokens_collection = db["access_tokens"]
+
+
+async def get_user_db():
+    yield MongoDBUserDatabase(UserDB, users_collection)
+
+
+async def get_access_token_db():
+    yield MongoDBAccessTokenDatabase(AccessToken, access_tokens_collection)

dev/src/db_ormar.py

@@ -0,0 +1,24 @@
+import databases
+import sqlalchemy
+from fastapi_users.db import OrmarBaseUserModel, OrmarUserDatabase
+
+from .models import UserDB
+
+DATABASE_URL = "sqlite:///test.db"
+metadata = sqlalchemy.MetaData()
+database = databases.Database(DATABASE_URL)
+
+
+class UserModel(OrmarBaseUserModel):
+    class Meta:
+        tablename = "users"
+        metadata = metadata
+        database = database
+
+
+engine = sqlalchemy.create_engine(DATABASE_URL)
+metadata.create_all(engine)
+
+
+async def get_user_db():
+    yield OrmarUserDatabase(UserDB, UserModel)

dev/src/db_sqlalchemy.py

@@ -0,0 +1,34 @@
+from typing import AsyncGenerator
+
+from fastapi import Depends
+from fastapi_users.db import SQLAlchemyBaseUserTable, SQLAlchemyUserDatabase
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.ext.declarative import DeclarativeMeta, declarative_base
+from sqlalchemy.orm import sessionmaker
+
+from .models import UserDB
+
+DATABASE_URL = "sqlite+aiosqlite:///./test.db"
+Base: DeclarativeMeta = declarative_base()
+
+
+class UserTable(Base, SQLAlchemyBaseUserTable):
+    pass
+
+
+engine = create_async_engine(DATABASE_URL)
+async_session_maker = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def create_db_and_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+
+async def get_user_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyUserDatabase(UserDB, session, UserTable)

dev/src/db_sqlalchemy_access_tokens.py

@@ -0,0 +1,46 @@
+from typing import AsyncGenerator
+
+from fastapi import Depends
+from fastapi_users.db import SQLAlchemyBaseUserTable, SQLAlchemyUserDatabase
+from fastapi_users_db_sqlalchemy.access_token import (
+    SQLAlchemyAccessTokenDatabase,
+    SQLAlchemyBaseAccessTokenTable,
+)
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.ext.declarative import DeclarativeMeta, declarative_base
+from sqlalchemy.orm import sessionmaker
+
+from .models import AccessToken, UserDB
+
+DATABASE_URL = "sqlite+aiosqlite:///./test.db"
+Base: DeclarativeMeta = declarative_base()
+
+
+class UserTable(Base, SQLAlchemyBaseUserTable):
+    pass
+
+
+class AccessTokenTable(SQLAlchemyBaseAccessTokenTable, Base):
+    pass
+
+
+engine = create_async_engine(DATABASE_URL)
+async_session_maker = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def create_db_and_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+
+async def get_user_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyUserDatabase(UserDB, session, UserTable)
+
+
+async def get_access_token_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyAccessTokenDatabase(AccessToken, session, AccessTokenTable)

dev/src/db_sqlalchemy_oauth.py

@@ -0,0 +1,42 @@
+from typing import AsyncGenerator
+
+from fastapi import Depends
+from fastapi_users.db import (
+    SQLAlchemyBaseOAuthAccountTable,
+    SQLAlchemyBaseUserTable,
+    SQLAlchemyUserDatabase,
+)
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.ext.declarative import DeclarativeMeta, declarative_base
+from sqlalchemy.orm import relationship, sessionmaker
+
+from .models import UserDB
+
+DATABASE_URL = "sqlite+aiosqlite:///./test.db"
+Base: DeclarativeMeta = declarative_base()
+
+
+class UserTable(Base, SQLAlchemyBaseUserTable):
+    oauth_accounts = relationship("OAuthAccountTable")
+
+
+class OAuthAccountTable(SQLAlchemyBaseOAuthAccountTable, Base):
+    pass
+
+
+engine = create_async_engine(DATABASE_URL)
+async_session_maker = sessionmaker(engine, class_=AsyncSession, expire_on_commit=False)
+
+
+async def create_db_and_tables():
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+
+
+async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
+    async with async_session_maker() as session:
+        yield session
+
+
+async def get_user_db(session: AsyncSession = Depends(get_async_session)):
+    yield SQLAlchemyUserDatabase(UserDB, session, UserTable, OAuthAccountTable)

dev/src/db_tortoise_access_tokens_adapter.py

@@ -0,0 +1,14 @@
+from fastapi_users.db import TortoiseUserDatabase
+from fastapi_users_db_tortoise.access_token import TortoiseAccessTokenDatabase
+
+from .models import AccessToken, AccessTokenModel, UserDB, UserModel
+
+DATABASE_URL = "sqlite://./test.db"
+
+
+async def get_user_db():
+    yield TortoiseUserDatabase(UserDB, UserModel)
+
+
+async def get_access_token_db():
+    yield TortoiseAccessTokenDatabase(AccessToken, AccessTokenModel)

dev/src/db_tortoise_access_tokens_model.py

@@ -0,0 +1,38 @@
+from fastapi_users import models
+from fastapi_users.authentication.strategy.db.models import BaseAccessToken
+from fastapi_users.db import TortoiseBaseUserModel
+from fastapi_users_db_tortoise.access_token import TortoiseBaseAccessTokenModel
+from tortoise import fields
+from tortoise.contrib.pydantic import PydanticModel
+
+
+class User(models.BaseUser):
+    pass
+
+
+class UserCreate(models.BaseUserCreate):
+    pass
+
+
+class UserUpdate(models.BaseUserUpdate):
+    pass
+
+
+class UserModel(TortoiseBaseUserModel):
+    pass
+
+
+class UserDB(User, models.BaseUserDB, PydanticModel):
+    class Config:
+        orm_mode = True
+        orig_model = UserModel
+
+
+class AccessTokenModel(TortoiseBaseAccessTokenModel):
+    user = fields.ForeignKeyField("models.UserModel", related_name="access_tokens")
+
+
+class AccessToken(BaseAccessToken, PydanticModel):
+    class Config:
+        orm_mode = True
+        orig_model = AccessTokenModel

dev/src/db_tortoise_adapter.py

@@ -0,0 +1,9 @@
+from fastapi_users.db import TortoiseUserDatabase
+
+from .models import UserDB, UserModel
+
+DATABASE_URL = "sqlite://./test.db"
+
+
+async def get_user_db():
+    yield TortoiseUserDatabase(UserDB, UserModel)

dev/src/db_tortoise_model.py

@@ -0,0 +1,25 @@
+from fastapi_users import models
+from fastapi_users.db import TortoiseBaseUserModel
+from tortoise.contrib.pydantic import PydanticModel
+
+
+class User(models.BaseUser):
+    pass
+
+
+class UserCreate(models.BaseUserCreate):
+    pass
+
+
+class UserUpdate(models.BaseUserUpdate):
+    pass
+
+
+class UserModel(TortoiseBaseUserModel):
+    pass
+
+
+class UserDB(User, models.BaseUserDB, PydanticModel):
+    class Config:
+        orm_mode = True
+        orig_model = UserModel

dev/src/db_tortoise_oauth_adapter.py

@@ -0,0 +1,9 @@
+from fastapi_users.db import TortoiseUserDatabase
+
+from .models import OAuthAccount, UserDB, UserModel
+
+DATABASE_URL = "sqlite://./test.db"
+
+
+async def get_user_db():
+    yield TortoiseUserDatabase(UserDB, UserModel, OAuthAccount)

dev/src/db_tortoise_oauth_model.py

@@ -0,0 +1,30 @@
+from fastapi_users import models
+from fastapi_users.db import TortoiseBaseOAuthAccountModel, TortoiseBaseUserModel
+from tortoise import fields
+from tortoise.contrib.pydantic import PydanticModel
+
+
+class User(models.BaseUser, models.BaseOAuthAccountMixin):
+    pass
+
+
+class UserCreate(models.BaseUserCreate):
+    pass
+
+
+class UserUpdate(models.BaseUserUpdate):
+    pass
+
+
+class UserModel(TortoiseBaseUserModel):
+    pass
+
+
+class UserDB(User, models.BaseUserDB, PydanticModel):
+    class Config:
+        orm_mode = True
+        orig_model = UserModel
+
+
+class OAuthAccount(TortoiseBaseOAuthAccountModel):
+    user = fields.ForeignKeyField("models.UserModel", related_name="oauth_accounts")

dev/src/user_manager.py

@@ -0,0 +1,32 @@
+from typing import Optional
+
+from fastapi import Depends, Request
+from fastapi_users import BaseUserManager
+
+from .db import get_user_db
+from .models import UserCreate, UserDB
+
+SECRET = "SECRET"
+
+
+class UserManager(BaseUserManager[UserCreate, UserDB]):
+    user_db_model = UserDB
+    reset_password_token_secret = SECRET
+    verification_token_secret = SECRET
+
+    async def on_after_register(self, user: UserDB, request: Optional[Request] = None):
+        print(f"User {user.id} has registered.")
+
+    async def on_after_forgot_password(
+        self, user: UserDB, token: str, request: Optional[Request] = None
+    ):
+        print(f"User {user.id} has forgot their password. Reset token: {token}")
+
+    async def on_after_request_verify(
+        self, user: UserDB, token: str, request: Optional[Request] = None
+    ):
+        print(f"Verification requested for user {user.id}. Verification token: {token}")
+
+
+async def get_user_manager(user_db=Depends(get_user_db)):
+    yield UserManager(user_db)