goosebit 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

goosebit/auth/__init__.py

@@ -1,139 +1,139 @@
+from __future__ import annotations
+
 import logging
+from typing import Annotated, Iterable
 
 from argon2.exceptions import VerifyMismatchError
 from fastapi import Depends, HTTPException
-from fastapi.requests import Request
-from fastapi.security import SecurityScopes
-from fastapi.websockets import WebSocket
+from fastapi.requests import HTTPConnection, Request
+from fastapi.security import OAuth2PasswordBearer, SecurityScopes
 from joserfc import jwt
 from joserfc.errors import BadSignatureError
 
-from goosebit.settings import PWD_CXT, SECRET, USERS
+from goosebit.settings import PWD_CXT, USERS, config
+from goosebit.settings.schema import User
 
 logger = logging.getLogger(__name__)
 
-async def authenticate_user(request: Request):
-    form_data = await request.form()
-    username = form_data.get("username")
-    password = form_data.get("password")
+
+oauth2_auth = OAuth2PasswordBearer(tokenUrl="login", auto_error=False)
+
+
+async def session_auth(connection: HTTPConnection) -> str:
+    return connection.cookies.get("session_id")
+
+
+def create_token(username: str) -> str:
+    return jwt.encode(header={"alg": "HS256"}, claims={"username": username}, key=config.secret_key)
+
+
+def get_user_from_token(token: str) -> User | None:
+    if token is None:
+        return
+    try:
+        token_data = jwt.decode(token, config.secret_key)
+        username = token_data.claims["username"]
+        return USERS.get(username)
+    except (BadSignatureError, LookupError, ValueError):
+        pass
+
+
+def login_user(username: str, password: str) -> str:
     user = USERS.get(username)
     if user is None:
         raise HTTPException(
-            status_code=302,
-            headers={"location": str(request.url_for("login"))},
-            detail="Invalid credentials",
+            status_code=401,
+            detail="Invalid username or password",
+            headers={"WWW-Authenticate": "Bearer"},
         )
     try:
-        if not PWD_CXT.verify(user.hashed_pwd, password):
-            raise HTTPException(
-                status_code=302,
-                headers={"location": str(request.url_for("login"))},
-                detail="Invalid credentials",
-            )
+        PWD_CXT.verify(user.hashed_pwd, password)
     except VerifyMismatchError:
         raise HTTPException(
-            status_code=302,
-            headers={"location": str(request.url_for("login"))},
-            detail="Invalid credentials",
+            status_code=401,
+            detail="Invalid username or password",
+            headers={"WWW-Authenticate": "Bearer"},
         )
+    return create_token(user.username)
+
+
+def get_current_user(
+    session_token: Annotated[str, Depends(session_auth)] = None,
+    oauth2_token: Annotated[str, Depends(oauth2_auth)] = None,
+) -> User:
+    session_user = get_user_from_token(session_token)
+    oauth2_user = get_user_from_token(oauth2_token)
+    user = session_user or oauth2_user
     return user
 
 
-def create_session(username: str) -> str:
-    return jwt.encode(header={"alg": "HS256"}, claims={"username": username}, key=SECRET)
+# using | Request because oauth2_auth.__call__ expects is
+async def get_user_from_request(connection: HTTPConnection | Request) -> User:
+    token = await session_auth(connection) or await oauth2_auth(connection)
+    return get_user_from_token(token)
 
 
-def authenticate_session(request: Request):
-    session_id = request.cookies.get("session_id")
-    if session_id is None:
-        raise HTTPException(
-            status_code=302,
-            headers={"location": str(request.url_for("login"))},
-            detail="Invalid session ID",
-        )
-    user = get_user_from_session(session_id)
+def redirect_if_unauthenticated(connection: HTTPConnection, user: Annotated[User, Depends(get_current_user)]):
     if user is None:
         raise HTTPException(
             status_code=302,
-            headers={"location": str(request.url_for("login"))},
+            headers={"location": str(connection.url_for("login_get"))},
             detail="Invalid username",
         )
-    return user
 
 
-def authenticate_api_session(request: Request):
-    session_id = request.cookies.get("session_id")
-    user = get_user_from_session(session_id)
-    if user is None:
-        raise HTTPException(status_code=401, detail="Not logged in")
-    return user
+def redirect_if_authenticated(connection: HTTPConnection, user: Annotated[User, Depends(get_current_user)]):
+    if user is not None:
+        raise HTTPException(
+            status_code=302,
+            headers={"location": str(connection.url_for("ui_root"))},
+            detail="Already logged in",
+        )
 
 
-def authenticate_ws_session(websocket: WebSocket):
-    session_id = websocket.cookies.get("session_id")
-    user = get_user_from_session(session_id)
+def validate_current_user(user: Annotated[User, Depends(get_current_user)]):
     if user is None:
-        raise HTTPException(status_code=401, detail="Not logged in")
+        raise HTTPException(
+            status_code=401,
+            detail="Not authenticated",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
     return user
 
 
-def auto_redirect(request: Request):
-    session_id = request.cookies.get("session_id")
-    if get_user_from_session(session_id) is None:
-        return request
-    raise HTTPException(
-        status_code=302,
-        headers={"location": str(request.url_for("ui_root"))},
-        detail="Already logged in",
-    )
-
-
-def get_user_from_session(session_id: str):
-    if session_id is None:
-        return
-    try:
-        session_data = jwt.decode(session_id, SECRET)
-        return session_data.claims["username"]
-    except (BadSignatureError, LookupError, ValueError):
-        pass
-
-
-def get_current_user(request: Request):
-    session_id = request.cookies.get("session_id")
-    user = get_user_from_session(session_id)
-    if user is None:
-        return None
-    return USERS[user]
-
-
 def validate_user_permissions(
-    request: Request,
-    security: SecurityScopes,
-    username: str = Depends(authenticate_session),
-) -> Request:
-    user = USERS[username]
-    if security.scopes is None:
-        return request
-    for scope in security.scopes:
-        if scope not in user.permissions:
-            logger.warning(f"User {username} does not have permission {scope}")
-            raise HTTPException(
-                status_code=403,
-                detail="Not enough permissions",
-            )
-
-
-def validate_ws_user_permissions(
-    websocket: WebSocket,
+    connection: HTTPConnection,
     security: SecurityScopes,
-    username: str = Depends(authenticate_ws_session),
-) -> WebSocket:
-    user = USERS[username]
-    if security.scopes is None:
-        return websocket
-    for scope in security.scopes:
-        if scope not in user.permissions:
-            raise HTTPException(
-                status_code=403,
-                detail="Not enough permissions",
-            )
+    user: User = Depends(get_current_user),
+) -> HTTPConnection:
+    if not check_permissions(security.scopes, user.permissions):
+        logger.warning(f"{user.username} does not have sufficient permissions")
+        raise HTTPException(
+            status_code=403,
+            detail="Not enough permissions",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return connection
+
+
+def check_permissions(scopes: Iterable[str] | None, permissions: Iterable[str]) -> bool:
+    deny_permissions = [p.lstrip("!") for p in permissions if p.startswith("!")]
+    allow_permissions = [p for p in permissions if not p.startswith("!")]
+    if scopes is None:
+        return True
+    for scope in scopes:
+        if any([_check_permission(scope, permission) for permission in deny_permissions]):
+            return False
+        if not any([_check_permission(scope, permission) for permission in allow_permissions]):
+            return False
+    return True
+
+
+def _check_permission(scope: str, permission: str) -> bool:
+    split_scope = scope.split(".")
+    for idx, permission in enumerate(permission.split(".")):
+        if permission == "*":
+            continue
+        if not split_scope[idx] == permission:
+            return False
+    return True

goosebit/db/__init__.py

@@ -0,0 +1,11 @@
+from tortoise import Tortoise
+
+from goosebit.db.config import TORTOISE_CONF
+
+
+async def init():
+    await Tortoise.init(config=TORTOISE_CONF)
+
+
+async def close():
+    await Tortoise.close_connections()

goosebit/db/config.py

@@ -0,0 +1,10 @@
+from goosebit.settings import config
+
+TORTOISE_CONF = {
+    "connections": {"default": config.db_uri},
+    "apps": {
+        "models": {
+            "models": ["goosebit.db.models", "aerich.models"],
+        },
+    },
+}

goosebit/db/migrations/models/0_20240830054046_init.py

@@ -0,0 +1,136 @@
+from tortoise import BaseDBAsyncClient
+
+
+async def upgrade(db: BaseDBAsyncClient) -> str:
+    dialect = db.schema_generator.DIALECT
+
+    if dialect == "postgres":
+        return """
+CREATE TABLE IF NOT EXISTS "hardware" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "model" VARCHAR(255) NOT NULL,
+    "revision" VARCHAR(255) NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "software" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "uri" VARCHAR(255) NOT NULL,
+    "size" BIGINT NOT NULL,
+    "hash" VARCHAR(255) NOT NULL,
+    "version" VARCHAR(255) NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "device" (
+    "uuid" VARCHAR(255) NOT NULL  PRIMARY KEY,
+    "name" VARCHAR(255),
+    "force_update" BOOL NOT NULL  DEFAULT False,
+    "sw_version" VARCHAR(255),
+    "feed" VARCHAR(255) NOT NULL  DEFAULT 'default',
+    "update_mode" SMALLINT NOT NULL  DEFAULT 3,
+    "last_state" SMALLINT NOT NULL  DEFAULT 1,
+    "progress" INT,
+    "log_complete" BOOL NOT NULL  DEFAULT False,
+    "last_log" TEXT,
+    "last_seen" BIGINT,
+    "last_ip" VARCHAR(15),
+    "last_ipv6" VARCHAR(40),
+    "assigned_software_id" INT REFERENCES "software" ("id") ON DELETE SET NULL,
+    "hardware_id" INT NOT NULL REFERENCES "hardware" ("id") ON DELETE CASCADE
+);
+COMMENT ON COLUMN "device"."update_mode" IS 'NONE: 0\nLATEST: 1\nPINNED: 2\nROLLOUT: 3\nASSIGNED: 4';
+COMMENT ON COLUMN "device"."last_state" IS 'NONE: 0\nUNKNOWN: 1\nREGISTERED: 2\nRUNNING: 3\nERROR: 4\nFINISHED: 5';
+CREATE TABLE IF NOT EXISTS "rollout" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "created_at" TIMESTAMPTZ NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "name" VARCHAR(255),
+    "feed" VARCHAR(255) NOT NULL  DEFAULT 'default',
+    "paused" BOOL NOT NULL  DEFAULT False,
+    "success_count" INT NOT NULL  DEFAULT 0,
+    "failure_count" INT NOT NULL  DEFAULT 0,
+    "software_id" INT NOT NULL REFERENCES "software" ("id") ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS "tag" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "name" VARCHAR(255) NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "aerich" (
+    "id" SERIAL NOT NULL PRIMARY KEY,
+    "version" VARCHAR(255) NOT NULL,
+    "app" VARCHAR(100) NOT NULL,
+    "content" JSONB NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "software_compatibility" (
+    "software_id" INT NOT NULL REFERENCES "software" ("id") ON DELETE CASCADE,
+    "hardware_id" INT NOT NULL REFERENCES "hardware" ("id") ON DELETE CASCADE
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "uidx_software_co_softwar_2683cc" ON "software_compatibility" ("software_id", "hardware_id");
+CREATE TABLE IF NOT EXISTS "device_tags" (
+    "device_id" VARCHAR(255) NOT NULL REFERENCES "device" ("uuid") ON DELETE CASCADE,
+    "tag_id" INT NOT NULL REFERENCES "tag" ("id") ON DELETE CASCADE
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "uidx_device_tags_device__2ab77e" ON "device_tags" ("device_id", "tag_id");"""
+
+    else:
+        return """
+CREATE TABLE IF NOT EXISTS "hardware" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "model" VARCHAR(255) NOT NULL,
+    "revision" VARCHAR(255) NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "software" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "uri" VARCHAR(255) NOT NULL,
+    "size" BIGINT NOT NULL,
+    "hash" VARCHAR(255) NOT NULL,
+    "version" VARCHAR(255) NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "device" (
+    "uuid" VARCHAR(255) NOT NULL  PRIMARY KEY,
+    "name" VARCHAR(255),
+    "force_update" INT NOT NULL  DEFAULT 0,
+    "sw_version" VARCHAR(255),
+    "feed" VARCHAR(255) NOT NULL  DEFAULT 'default',
+    "update_mode" SMALLINT NOT NULL  DEFAULT 3 /* NONE: 0\nLATEST: 1\nPINNED: 2\nROLLOUT: 3\nASSIGNED: 4 */,
+    "last_state" SMALLINT NOT NULL  DEFAULT 1 /* NONE: 0\nUNKNOWN: 1\nREGISTERED: 2\nRUNNING: 3\nERROR: 4\nFINISHED: 5 */,
+    "progress" INT,
+    "log_complete" INT NOT NULL  DEFAULT 0,
+    "last_log" TEXT,
+    "last_seen" BIGINT,
+    "last_ip" VARCHAR(15),
+    "last_ipv6" VARCHAR(40),
+    "assigned_software_id" INT REFERENCES "software" ("id") ON DELETE SET NULL,
+    "hardware_id" INT NOT NULL REFERENCES "hardware" ("id") ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS "rollout" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "created_at" TIMESTAMP NOT NULL  DEFAULT CURRENT_TIMESTAMP,
+    "name" VARCHAR(255),
+    "feed" VARCHAR(255) NOT NULL  DEFAULT 'default',
+    "paused" INT NOT NULL  DEFAULT 0,
+    "success_count" INT NOT NULL  DEFAULT 0,
+    "failure_count" INT NOT NULL  DEFAULT 0,
+    "software_id" INT NOT NULL REFERENCES "software" ("id") ON DELETE CASCADE
+);
+CREATE TABLE IF NOT EXISTS "tag" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "name" VARCHAR(255) NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "aerich" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+    "version" VARCHAR(255) NOT NULL,
+    "app" VARCHAR(100) NOT NULL,
+    "content" JSON NOT NULL
+);
+CREATE TABLE IF NOT EXISTS "software_compatibility" (
+    "software_id" INT NOT NULL REFERENCES "software" ("id") ON DELETE CASCADE,
+    "hardware_id" INT NOT NULL REFERENCES "hardware" ("id") ON DELETE CASCADE
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "uidx_software_co_softwar_2683cc" ON "software_compatibility" ("software_id", "hardware_id");
+CREATE TABLE IF NOT EXISTS "device_tags" (
+    "device_id" VARCHAR(255) NOT NULL REFERENCES "device" ("uuid") ON DELETE CASCADE,
+    "tag_id" INT NOT NULL REFERENCES "tag" ("id") ON DELETE CASCADE
+);
+CREATE UNIQUE INDEX IF NOT EXISTS "uidx_device_tags_device__2ab77e" ON "device_tags" ("device_id", "tag_id");"""
+
+
+async def downgrade(db: BaseDBAsyncClient) -> str:
+    return """
+        """

goosebit/{models.py → db/models.py}

@@ -7,7 +7,7 @@ from urllib.request import url2pathname
 import semver
 from tortoise import Model, fields
 
-from goosebit.telemetry import devices_count
+from goosebit.api.telemetry.metrics import devices_count
 
 
 class UpdateModeEnum(IntEnum):
@@ -55,12 +55,13 @@ class Tag(Model):
 class Device(Model):
     uuid = fields.CharField(max_length=255, primary_key=True)
     name = fields.CharField(max_length=255, null=True)
-    assigned_firmware = fields.ForeignKeyField("models.Firmware", related_name="assigned_devices", null=True)
+    assigned_software = fields.ForeignKeyField(
+        "models.Software", related_name="assigned_devices", null=True, on_delete=fields.SET_NULL
+    )
     force_update = fields.BooleanField(default=False)
-    fw_version = fields.CharField(max_length=255, null=True)
+    sw_version = fields.CharField(max_length=255, null=True)
     hardware = fields.ForeignKeyField("models.Hardware", related_name="devices")
     feed = fields.CharField(max_length=255, default="default")
-    flavor = fields.CharField(max_length=255, default="default")
     update_mode = fields.IntEnumField(UpdateModeEnum, default=UpdateModeEnum.ROLLOUT)
     last_state = fields.IntEnumField(UpdateStateEnum, default=UpdateStateEnum.UNKNOWN)
     progress = fields.IntField(null=True)
@@ -95,8 +96,7 @@ class Rollout(Model):
     created_at = fields.DatetimeField(auto_now_add=True)
     name = fields.CharField(max_length=255, null=True)
     feed = fields.CharField(max_length=255, default="default")
-    flavor = fields.CharField(max_length=255, default="default")
-    firmware = fields.ForeignKeyField("models.Firmware", related_name="rollouts")
+    software = fields.ForeignKeyField("models.Software", related_name="rollouts")
     paused = fields.BooleanField(default=False)
     success_count = fields.IntField(default=0)
     failure_count = fields.IntField(default=0)
@@ -108,7 +108,7 @@ class Hardware(Model):
     revision = fields.CharField(max_length=255)
 
 
-class Firmware(Model):
+class Software(Model):
     id = fields.IntField(primary_key=True)
     uri = fields.CharField(max_length=255)
     size = fields.BigIntField()
@@ -116,8 +116,8 @@ class Firmware(Model):
     version = fields.CharField(max_length=255)
     compatibility = fields.ManyToManyField(
         "models.Hardware",
-        related_name="firmwares",
-        through="firmware_compatibility",
+        related_name="softwares",
+        through="software_compatibility",
     )
 
     @classmethod
@@ -136,5 +136,12 @@ class Firmware(Model):
         return Path(url2pathname(unquote(urlparse(self.uri).path)))
 
     @property
-    def local(self):
+    def local(self) -> bool:
         return urlparse(self.uri).scheme == "file"
+
+    @property
+    def path_user(self) -> str:
+        if self.local:
+            return self.path.name
+        else:
+            return self.uri

goosebit/realtime/logs.py

@@ -1,10 +1,11 @@
+from __future__ import annotations
+
 from fastapi import APIRouter, Security
 from fastapi.websockets import WebSocket, WebSocketDisconnect
 from pydantic import BaseModel
 from websockets.exceptions import ConnectionClosed
 
-from goosebit.auth import validate_ws_user_permissions
-from goosebit.permissions import Permissions
+from goosebit.auth import validate_user_permissions
 from goosebit.updater.manager import get_update_manager
 
 router = APIRouter(prefix="/logs")
@@ -18,7 +19,7 @@ class RealtimeLogModel(BaseModel):
 
 @router.websocket(
     "/{dev_id}",
-    dependencies=[Security(validate_ws_user_permissions, scopes=[Permissions.HOME.READ])],
+    dependencies=[Security(validate_user_permissions, scopes=["home.read"])],
 )
 async def device_logs(websocket: WebSocket, dev_id: str):
     await websocket.accept()

goosebit/realtime/routes.py

@@ -1,12 +1,12 @@
 from fastapi import APIRouter, Depends
 
-from goosebit.auth import authenticate_ws_session
+from goosebit.auth import validate_current_user
 
 from . import logs
 
 router = APIRouter(
     prefix="/realtime",
-    dependencies=[Depends(authenticate_ws_session)],
+    dependencies=[Depends(validate_current_user)],
     tags=["realtime"],
 )
 

goosebit/schema/devices.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import time
+from enum import Enum, IntEnum, StrEnum
+from typing import Annotated
+
+from pydantic import BaseModel, BeforeValidator, computed_field
+
+from goosebit.db.models import Device, UpdateModeEnum, UpdateStateEnum
+from goosebit.updater.manager import get_update_manager
+
+
+class ConvertableEnum(StrEnum):
+    @classmethod
+    def convert(cls, value: IntEnum):
+        return cls(str(value))
+
+
+def enum_factory(name: str, base: type[Enum]) -> type[ConvertableEnum]:
+    enum_dict = {item.name: str(item) for item in base}
+    return ConvertableEnum(name, enum_dict)  # type: ignore
+
+
+UpdateStateSchema = enum_factory("UpdateStateSchema", UpdateStateEnum)
+UpdateModeSchema = enum_factory("UpdateModeSchema", UpdateModeEnum)
+
+
+class DeviceSchema(BaseModel):
+    uuid: str
+    name: str | None
+    sw_version: str | None
+    sw_target_version: str | None
+    sw_assigned: int | None
+    hw_model: str
+    hw_revision: str
+    feed: str
+    progress: int | None
+    last_state: Annotated[UpdateStateSchema, BeforeValidator(UpdateStateSchema.convert)]
+    update_mode: Annotated[UpdateModeSchema, BeforeValidator(UpdateModeSchema.convert)]
+    force_update: bool
+    last_ip: str | None
+    last_seen: int | None
+    poll_seconds: int
+
+    @computed_field
+    def online(self) -> bool | None:
+        return self.last_seen < self.poll_seconds if self.last_seen is not None else None
+
+    @classmethod
+    async def convert(cls, device: Device):
+        manager = await get_update_manager(device.uuid)
+        _, target_software = await manager.get_update()
+        last_seen = device.last_seen
+        if last_seen is not None:
+            last_seen = round(time.time() - device.last_seen)
+
+        return cls(
+            uuid=device.uuid,
+            name=device.name,
+            sw_version=device.sw_version,
+            sw_target_version=(target_software.version if target_software is not None else None),
+            sw_assigned=(device.assigned_software.id if device.assigned_software is not None else None),
+            hw_model=device.hardware.model,
+            hw_revision=device.hardware.revision,
+            feed=device.feed,
+            progress=device.progress,
+            last_state=device.last_state,
+            update_mode=device.update_mode,
+            force_update=device.force_update,
+            last_ip=device.last_ip,
+            last_seen=last_seen,
+            poll_seconds=manager.poll_seconds,
+        )

goosebit/schema/rollouts.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from goosebit.db.models import Rollout
+
+
+class RolloutSchema(BaseModel):
+    id: int
+    created_at: int
+    name: str | None
+    feed: str
+    sw_file: str
+    sw_version: str
+    paused: bool
+    success_count: int
+    failure_count: int
+
+    @classmethod
+    async def convert(cls, rollout: Rollout):
+        return cls(
+            id=rollout.id,
+            created_at=int(rollout.created_at.timestamp() * 1000),
+            name=rollout.name,
+            feed=rollout.feed,
+            sw_file=rollout.software.path.name,
+            sw_version=rollout.software.version,
+            paused=rollout.paused,
+            success_count=rollout.success_count,
+            failure_count=rollout.failure_count,
+        )

goosebit/schema/software.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import asyncio
+
+from pydantic import BaseModel
+
+from goosebit.db.models import Hardware, Software
+
+
+class HardwareSchema(BaseModel):
+    id: int
+    model: str
+    revision: str
+
+    @classmethod
+    async def convert(cls, hardware: Hardware):
+        return cls(id=hardware.id, model=hardware.model, revision=hardware.revision)
+
+
+class SoftwareSchema(BaseModel):
+    id: int
+    name: str
+    size: int
+    hash: str
+    version: str
+    compatibility: list[HardwareSchema]
+
+    @classmethod
+    async def convert(cls, software: Software):
+        return cls(
+            id=software.id,
+            name=software.path_user,
+            size=software.size,
+            hash=software.hash,
+            version=software.version,
+            compatibility=await asyncio.gather(*[HardwareSchema.convert(h) for h in software.compatibility]),
+        )

goosebit/settings/__init__.py

@@ -0,0 +1,17 @@
+import logging.config
+
+from .const import PWD_CXT  # noqa: F401
+from .schema import GooseBitSettings
+
+config = GooseBitSettings()
+
+
+logging.config.dictConfig(config.logging)
+
+logger = logging.getLogger(__name__)
+
+if config.config_file is not None:
+    logger.info(f"Loading settings from: {config.config_file}")
+
+
+USERS = {u.username: u for u in config.users}