Clean up modules (#16)

* Move get_current_user_id* dependencies to user/auth

* Rename the export module to function/export

* Rename database/connections.py to database/utils.py

* Rename provision/databases.py to provision/utils.py

* Move provision settings to provision/settings.py

* Clean up env_prefix for settings

* Finish provision settings extraction

* Factor out driver settings

* Remove async from non-async dependencies

* Add missing yama/user/auth/__init__.py

Author: k11v

backend/yama/__main__.py

@@ -4,9 +4,10 @@
 from typer import Typer
 
 from yama.api.settings import Settings as APISettings
-from yama.database.connections import sqlalchemy_async_connection
-from yama.database.provision.databases import setup_database, teardown_database
+from yama.database.provision.settings import Settings as DatabaseProvisionSettings
+from yama.database.provision.utils import setup_database, teardown_database
 from yama.database.settings import Settings as DatabaseSettings
+from yama.database.utils import sqlalchemy_async_connection
 
 app = Typer()
 database_app = Typer()
@@ -28,24 +29,22 @@ def api() -> None:
 @database_app.command()
 def up() -> None:
     async def f() -> None:
-        settings = DatabaseSettings()
-
-        if settings.provision is None:
-            raise ValueError("Provision settings are required")
+        database_settings = DatabaseSettings()
+        database_provision_settings = DatabaseProvisionSettings()
 
         async with sqlalchemy_async_connection(
-            host=settings.host,
-            port=settings.port,
-            username=settings.provision.username,
-            password=settings.provision.password,
-            database=settings.provision.database,
+            host=database_settings.host,
+            port=database_settings.port,
+            username=database_provision_settings.username,
+            password=database_provision_settings.password,
+            database=database_provision_settings.database,
         ) as conn:
             autocommit_conn = await conn.execution_options(isolation_level="AUTOCOMMIT")
 
             await setup_database(
                 autocommit_conn,
-                database=settings.database,
-                migrate_executable=settings.provision.migrate_executable,
+                database=database_settings.database,
+                migrate_executable=database_provision_settings.migrate_executable,
             )
 
     asyncio.run(f())
@@ -54,21 +53,21 @@ async def f() -> None:
 @database_app.command()
 def down() -> None:
     async def f() -> None:
-        settings = DatabaseSettings()
-
-        if settings.provision is None:
-            raise ValueError("Provision settings are required")
+        database_settings = DatabaseSettings()
+        database_provision_settings = DatabaseProvisionSettings()
 
         async with sqlalchemy_async_connection(
-            host=settings.host,
-            port=settings.port,
-            username=settings.provision.username,
-            password=settings.provision.password,
-            database=settings.provision.database,
+            host=database_settings.host,
+            port=database_settings.port,
+            username=database_provision_settings.username,
+            password=database_provision_settings.password,
+            database=database_provision_settings.database,
         ) as conn:
             autocommit_conn = await conn.execution_options(isolation_level="AUTOCOMMIT")
 
-            await teardown_database(autocommit_conn, database=settings.database)
+            await teardown_database(
+                autocommit_conn, database=database_settings.database
+            )
 
     asyncio.run(f())
 

backend/yama/api/routes.py

@@ -5,8 +5,9 @@
 from fastapi import FastAPI
 from pydantic import BaseModel
 
-from yama.database.connections import sqlalchemy_async_engine
 from yama.database.settings import Settings as DatabaseSettings
+from yama.database.utils import sqlalchemy_async_engine
+from yama.file.driver.settings import Settings as FileDriverSettings
 from yama.file.routes import files_file_error_handler
 from yama.file.routes import router as file_router
 from yama.file.settings import Settings as FileSettings
@@ -20,6 +21,7 @@
 async def lifespan(_app: FastAPI) -> AsyncIterator[dict[str, Any]]:
     database_settings = DatabaseSettings()  # pyright: ignore[reportCallIssue]
     file_settings = FileSettings()  # pyright: ignore[reportCallIssue]
+    file_driver_settings = FileDriverSettings()  # pyright: ignore[reportCallIssue]
     user_settings = UserSettings()  # pyright: ignore[reportCallIssue]
 
     async with sqlalchemy_async_engine(
@@ -34,6 +36,7 @@ async def lifespan(_app: FastAPI) -> AsyncIterator[dict[str, Any]]:
         yield {
             "engine": engine,
             "file_settings": file_settings,
+            "file_driver_settings": file_driver_settings,
             "user_settings": user_settings,
         }
 

backend/yama/api/settings.py

@@ -2,7 +2,7 @@
 
 
 class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix="yama_api__")
+    model_config = SettingsConfigDict(env_prefix="yama__api__")
 
     host: str
     port: int

backend/yama/database/dependencies.py

@@ -5,14 +5,14 @@
 from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine
 
 
-# `get_engine()` is a lifetime dependency that provides
-# an `AsyncEngine` created by the lifespan
-async def get_engine(request: Request) -> AsyncEngine:
+# get_engine is a lifetime dependency that provides an AsyncEngine created by the
+# lifespan.
+def get_engine(*, request: Request) -> AsyncEngine:
     return request.state.engine  # type: ignore[no-any-return]
 
 
 async def get_connection(
-    engine: Annotated[AsyncEngine, Depends(get_engine)],
+    *, engine: Annotated[AsyncEngine, Depends(get_engine)]
 ) -> AsyncIterator[AsyncConnection]:
     async with engine.connect() as connection:
         yield connection

backend/yama/database/provision/settings.py

@@ -0,0 +1,14 @@
+from pathlib import Path
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="yama__database__provision__",
+    )
+
+    database: str
+    username: str
+    password: str
+    migrate_executable: Path

backend/yama/database/provision/databases.py renamed to backend/yama/database/provision/utils.py

@@ -1,23 +1,13 @@
-from pathlib import Path
-
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
-class ProvisionSettings(BaseSettings):
-    database: str
-    username: str
-    password: str
-    migrate_executable: Path
-
-
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_prefix="yama_database__", env_nested_delimiter="__"
+        env_prefix="yama__database__", env_nested_delimiter="__"
     )
 
     host: str
     port: int
     database: str
     username: str
     password: str
-    provision: ProvisionSettings | None = None

backend/yama/database/settings.py

@@ -3,7 +3,6 @@
 from yama.file.settings import Settings
 
 
-# `get_settings()` is a lifetime dependency that provides
-# `Settings` created by the lifespan
-async def get_settings(request: Request) -> Settings:
+# get_settings is a lifetime dependency that provides Settings created by the lifespan.
+def get_settings(*, request: Request) -> Settings:
     return request.state.file_settings  # type: ignore[no-any-return]

backend/yama/database/connections.py renamed to backend/yama/database/utils.py

@@ -1,15 +1,19 @@
 from typing import Annotated, assert_never
 
-from fastapi import Depends
+from fastapi import Depends, Request
 
-from yama.file.dependencies import get_settings
+from yama.file.driver.settings import Settings
 from yama.file.driver.utils import Driver, FileSystemDriver
-from yama.file.settings import FileSystemDriverSettings, Settings
 
 
-async def get_driver(*, settings: Annotated[Settings, Depends(get_settings)]) -> Driver:
-    match settings.driver:
-        case FileSystemDriverSettings(file_system_dir=file_system_dir):
-            return FileSystemDriver(file_system_dir=file_system_dir)
+# get_settings is a lifetime dependency that provides Settings created by the lifespan.
+def get_settings(*, request: Request) -> Settings:
+    return request.state.file_driver_settings  # type: ignore[no-any-return]
+
+
+def get_driver(*, settings: Annotated[Settings, Depends(get_settings)]) -> Driver:
+    match settings.type:
+        case "file-system":
+            return FileSystemDriver(file_system_dir=settings.file_system_dir)
         case _:
             assert_never(settings.driver)

backend/yama/file/dependencies.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+from typing import Literal
+
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="yama__file__driver__")
+
+    type: Literal["file-system"]
+    file_system_dir: Path

backend/yama/file/driver/dependencies.py

@@ -43,7 +43,7 @@
 )
 from yama.file.settings import Settings
 from yama.file.utils import FilesFileError
-from yama.user.dependencies import get_current_user_id, get_current_user_id_or_none
+from yama.user.auth.dependencies import get_current_user_id, get_current_user_id_or_none
 from yama.user.dependencies import get_settings as get_user_settings
 from yama.user.settings import Settings as UserSettings
 

backend/yama/file/driver/settings.py

@@ -1,5 +1,3 @@
-from pathlib import Path
-from typing import Literal, TypeAlias
 from uuid import UUID
 
 from pydantic_settings import BaseSettings, SettingsConfigDict
@@ -8,21 +6,12 @@
 MAX_FILE_PATH_LENGTH = 4095
 
 
-class FileSystemDriverSettings(BaseSettings):
-    type: Literal["file-system"]
-    file_system_dir: Path
-
-
-DriverSettings: TypeAlias = FileSystemDriverSettings
-
-
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_prefix="yama_file__", env_nested_delimiter="__"
+        env_prefix="yama__file__", env_nested_delimiter="__"
     )
 
     chunk_size: int = 1024 * 1024 * 10  # 10 MiB
     max_file_size: int = 1024 * 1024 * 512  # 512 MiB
-    driver: DriverSettings
     files_base_url: str
     root_file_id: UUID

backend/yama/file/routes.py

@@ -4,7 +4,7 @@
 
 
 class Settings(BaseSettings):
-    model_config = SettingsConfigDict(env_prefix="yama_export__")
+    model_config = SettingsConfigDict(env_prefix="yama__export__")
 
     latexmk_executable: Path = Path("latexmk")
     pandoc_executable: Path = Path("pandoc")

backend/yama/file/settings.py

@@ -1,9 +1,14 @@
 from typing import Annotated, Literal
+from uuid import UUID
 
-from fastapi import Form, HTTPException
+from fastapi import Depends, Form, HTTPException
+from fastapi.security import OAuth2PasswordBearer
 from pydantic import ValidationError
 
-from yama.user.auth.models import GrantIn, GrantInAdapter
+from yama.user.auth.models import INVALID_TOKEN_EXCEPTION, GrantIn, GrantInAdapter
+from yama.user.auth.utils import InvalidTokenError, access_token_to_user_id
+from yama.user.dependencies import get_settings
+from yama.user.settings import Settings
 
 
 def get_grant_in(
@@ -26,3 +31,31 @@ def get_grant_in(
         )
     except ValidationError:
         raise HTTPException(400, "Invalid grant.")
+
+
+_get_oauth2_token = OAuth2PasswordBearer(tokenUrl="/auth")
+_get_oauth2_token_or_none = OAuth2PasswordBearer(tokenUrl="/auth", auto_error=False)
+
+
+def get_current_user_id(
+    *,
+    token: Annotated[str, Depends(_get_oauth2_token)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> UUID:
+    try:
+        return access_token_to_user_id(token, settings=settings)
+    except InvalidTokenError:
+        raise INVALID_TOKEN_EXCEPTION
+
+
+def get_current_user_id_or_none(
+    *,
+    token: Annotated[str | None, Depends(_get_oauth2_token_or_none)],
+    settings: Annotated[Settings, Depends(get_settings)],
+) -> UUID | None:
+    if token is None:
+        return None
+    try:
+        return access_token_to_user_id(token, settings=settings)
+    except InvalidTokenError:
+        return None

backend/yama/export/__init__.py renamed to backend/yama/function/__init__.py

@@ -1,42 +1,8 @@
-from typing import Annotated
-from uuid import UUID
+from fastapi import Request
 
-from fastapi import Depends, Request
-from fastapi.security import OAuth2PasswordBearer
-
-from yama.user.auth.models import INVALID_TOKEN_EXCEPTION
-from yama.user.auth.utils import InvalidTokenError, access_token_to_user_id
 from yama.user.settings import Settings
 
 
 # get_settings is a lifetime dependency that provides Settings created by the lifespan.
-async def get_settings(*, request: Request) -> Settings:
+def get_settings(*, request: Request) -> Settings:
     return request.state.user_settings  # type: ignore[no-any-return]
-
-
-_get_oauth2_token = OAuth2PasswordBearer(tokenUrl="/auth")
-_get_oauth2_token_or_none = OAuth2PasswordBearer(tokenUrl="/auth", auto_error=False)
-
-
-def get_current_user_id(
-    *,
-    token: Annotated[str, Depends(_get_oauth2_token)],
-    settings: Annotated[Settings, Depends(get_settings)],
-) -> UUID:
-    try:
-        return access_token_to_user_id(token, settings=settings)
-    except InvalidTokenError:
-        raise INVALID_TOKEN_EXCEPTION
-
-
-def get_current_user_id_or_none(
-    *,
-    token: Annotated[str | None, Depends(_get_oauth2_token_or_none)],
-    settings: Annotated[Settings, Depends(get_settings)],
-) -> UUID | None:
-    if token is None:
-        return None
-    try:
-        return access_token_to_user_id(token, settings=settings)
-    except InvalidTokenError:
-        return None

backend/yama/function/export/__init__.py

@@ -6,7 +6,7 @@
 from sqlalchemy.ext.asyncio import AsyncConnection
 
 from yama.database.dependencies import get_connection
-from yama.user.dependencies import get_current_user_id
+from yama.user.auth.dependencies import get_current_user_id
 from yama.user.models import Handle, UserCreateIn, UserDb, UserOut, UserType
 from yama.user.utils import (
     hash_password,

backend/yama/export/models.py renamed to backend/yama/function/export/models.py

@@ -21,7 +21,7 @@ class AuthSettings(BaseSettings):
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_prefix="yama_user__", env_nested_delimiter="__"
+        env_prefix="yama__user__", env_nested_delimiter="__"
     )
 
     public_user_id: UUID