goosebit 0.2.3__tar.gz → 0.2.5__tar.gz

{goosebit-0.2.3 → goosebit-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: goosebit
-Version: 0.2.3
+Version: 0.2.5
 Summary: 
 Author: Upstream Data
 Author-email: brett@upstreamdata.ca
@@ -8,10 +8,10 @@ Requires-Python: >=3.11,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: postgresql
 Requires-Dist: aerich (>=0.7.2,<0.8.0)
 Requires-Dist: aiocache (>=0.12.2,<0.13.0)
-Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: argon2-cffi (>=23.1.0,<24.0.0)
 Requires-Dist: asyncpg (>=0.29.0,<0.30.0) ; extra == "postgresql"
 Requires-Dist: fastapi[uvicorn] (>=0.111.0,<0.112.0)
@@ -20,9 +20,9 @@ Requires-Dist: itsdangerous (>=2.2.0,<3.0.0)
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
 Requires-Dist: joserfc (>=1.0.0,<2.0.0)
 Requires-Dist: libconf (>=2.0.1,<3.0.0)
-Requires-Dist: opentelemetry-distro (>=0.47b0,<0.48)
-Requires-Dist: opentelemetry-exporter-prometheus (>=0.47b0,<0.48)
-Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.47b0,<0.48)
+Requires-Dist: opentelemetry-distro (>=0.49b1,<0.50)
+Requires-Dist: opentelemetry-exporter-prometheus (>=0.49b1,<0.50)
+Requires-Dist: opentelemetry-instrumentation-fastapi (>=0.49b1,<0.50)
 Requires-Dist: pydantic-settings (>=2.4.0,<3.0.0)
 Requires-Dist: python-multipart (>=0.0.9,<0.0.10)
 Requires-Dist: semver (>=3.0.2,<4.0.0)
@@ -34,6 +34,8 @@ Description-Content-Type: text/markdown
 
 <img src="docs/img/goosebit-logo.png" style="width: 100px; height: 100px; display: block;">
 
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/UpstreamDataInc/goosebit/badge)](https://scorecard.dev/viewer/?uri=github.com/UpstreamDataInc/goosebit)
+
 ---
 
 A simplistic, opinionated remote update server implementing hawkBit™'s [DDI API](https://eclipse.dev/hawkbit/apis/ddi_api/).
@@ -43,10 +45,18 @@ A simplistic, opinionated remote update server implementing hawkBit™'s [DDI AP
 ### Installation
 
 1. Install dependencies using [Poetry](https://python-poetry.org/):
+
     ```bash
     poetry install
     ```
-2. Launch gooseBit:
+
+2. Create the database:
+
+    ```bash
+    poetry run aerich upgrade
+    ```
+
+3. Launch gooseBit:
     ```bash
     python main.py
     ```
@@ -117,6 +127,12 @@ After a model change create the migration
 poetry run aerich migrate
 ```
 
+To seed some sample data (attention: drops all current data) use
+
+```bash
+poetry run generate-sample-data
+```
+
 ### Code formatting and linting
 
 Code is formatted using different tools
@@ -139,7 +155,7 @@ poetry run pre-commit install
 To manually apply the hooks to all files use:
 
 ```bash
-pre-commit run --all-files
+poetry run pre-commit run --all-files
 ```
 
 ### Testing

{goosebit-0.2.3 → goosebit-0.2.5}/README.md

@@ -2,6 +2,8 @@
 
 <img src="docs/img/goosebit-logo.png" style="width: 100px; height: 100px; display: block;">
 
+[![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/UpstreamDataInc/goosebit/badge)](https://scorecard.dev/viewer/?uri=github.com/UpstreamDataInc/goosebit)
+
 ---
 
 A simplistic, opinionated remote update server implementing hawkBit™'s [DDI API](https://eclipse.dev/hawkbit/apis/ddi_api/).
@@ -11,10 +13,18 @@ A simplistic, opinionated remote update server implementing hawkBit™'s [DDI AP
 ### Installation
 
 1. Install dependencies using [Poetry](https://python-poetry.org/):
+
     ```bash
     poetry install
     ```
-2. Launch gooseBit:
+
+2. Create the database:
+
+    ```bash
+    poetry run aerich upgrade
+    ```
+
+3. Launch gooseBit:
     ```bash
     python main.py
     ```
@@ -85,6 +95,12 @@ After a model change create the migration
 poetry run aerich migrate
 ```
 
+To seed some sample data (attention: drops all current data) use
+
+```bash
+poetry run generate-sample-data
+```
+
 ### Code formatting and linting
 
 Code is formatted using different tools
@@ -107,7 +123,7 @@ poetry run pre-commit install
 To manually apply the hooks to all files use:
 
 ```bash
-pre-commit run --all-files
+poetry run pre-commit run --all-files
 ```
 
 ### Testing

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/__init__.py

@@ -1,27 +1,37 @@
 import importlib.metadata
 from contextlib import asynccontextmanager
+from logging import getLogger
 from typing import Annotated
 
-from fastapi import Depends, FastAPI
+from fastapi import Depends, FastAPI, HTTPException
+from fastapi.exception_handlers import http_exception_handler
 from fastapi.openapi.docs import get_swagger_ui_html
 from fastapi.requests import Request
 from fastapi.responses import RedirectResponse
 from fastapi.security import OAuth2PasswordRequestForm
 from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor as Instrumentor
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from tortoise.exceptions import ValidationError
 
 from goosebit import api, db, realtime, ui, updater
 from goosebit.api.telemetry import metrics
 from goosebit.auth import get_user_from_request, login_user, redirect_if_authenticated
+from goosebit.settings import config
 from goosebit.ui.nav import nav
 from goosebit.ui.static import static
 from goosebit.ui.templates import templates
 
+logger = getLogger(__name__)
+
 
 @asynccontextmanager
 async def lifespan(_: FastAPI):
-    await db.init()
+    db_ready = await db.init()
+    if not db_ready:
+        logger.exception("DB does not exist, try running `poetry run aerich upgrade`.")
     await metrics.init()
-    yield
+    if db_ready:
+        yield
     await db.close()
 
 
@@ -52,6 +62,19 @@ app.mount("/static", static, name="static")
 Instrumentor.instrument_app(app)
 
 
+# Custom exception handler for Tortoise ValidationError
+@app.exception_handler(ValidationError)
+async def tortoise_validation_exception_handler(request: Request, exc: ValidationError):
+    raise HTTPException(422, str(exc))
+
+
+# Extend default handler to do logging
+@app.exception_handler(StarletteHTTPException)
+async def custom_http_exception_handler(request, exc):
+    logger.warning(f"HTTPException, request={request.url}, status={exc.status_code}, detail={exc.detail}")
+    return await http_exception_handler(request, exc)
+
+
 @app.middleware("http")
 async def attach_user(request: Request, call_next):
     request.scope["user"] = await get_user_from_request(request)
@@ -64,6 +87,12 @@ async def attach_nav(request: Request, call_next):
     return await call_next(request)
 
 
+@app.middleware("http")
+async def attach_config(request: Request, call_next):
+    request.scope["config"] = config
+    return await call_next(request)
+
+
 @app.get("/", include_in_schema=False)
 def root_redirect(request: Request):
     return RedirectResponse(request.url_for("ui_root"))

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/api/v1/devices/device/routes.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from fastapi import APIRouter, Depends, Security
+from fastapi import APIRouter, Depends, HTTPException, Security
 from fastapi.requests import Request
 
 from goosebit.api.v1.devices.device.responses import DeviceLogResponse, DeviceResponse
@@ -12,16 +12,22 @@ router = APIRouter(prefix="/{dev_id}")
 
 @router.get(
     "",
-    dependencies=[Security(validate_user_permissions, scopes=["home.read"])],
+    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
 )
 async def device_get(_: Request, updater: UpdateManager = Depends(get_update_manager)) -> DeviceResponse:
-    return await DeviceResponse.convert(await updater.get_device())
+    device = await updater.get_device()
+    if device is None:
+        raise HTTPException(404)
+    await device.fetch_related("assigned_software", "hardware")
+    return DeviceResponse.model_validate(device)
 
 
 @router.get(
     "/log",
-    dependencies=[Security(validate_user_permissions, scopes=["home.read"])],
+    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
 )
 async def device_logs(_: Request, updater: UpdateManager = Depends(get_update_manager)) -> DeviceLogResponse:
     device = await updater.get_device()
+    if device is None:
+        raise HTTPException(404)
     return DeviceLogResponse(log=device.last_log)

goosebit-0.2.5/goosebit/api/v1/devices/responses.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from goosebit.schema.devices import DeviceSchema
+
+
+class DevicesResponse(BaseModel):
+    devices: list[DeviceSchema]

goosebit-0.2.5/goosebit/api/v1/devices/routes.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import asyncio
+
+from fastapi import APIRouter, Security
+from fastapi.requests import Request
+
+from goosebit.api.responses import StatusResponse
+from goosebit.auth import validate_user_permissions
+from goosebit.db.models import Device
+from goosebit.schema.devices import DeviceSchema
+from goosebit.schema.software import SoftwareSchema
+from goosebit.updater.manager import delete_devices, get_update_manager
+
+from . import device
+from .requests import DevicesDeleteRequest
+from .responses import DevicesResponse
+
+router = APIRouter(prefix="/devices", tags=["devices"])
+
+
+@router.get(
+    "",
+    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
+)
+async def devices_get(_: Request) -> DevicesResponse:
+    devices = await Device.all().prefetch_related("hardware", "assigned_software", "assigned_software__compatibility")
+    response = DevicesResponse(devices=devices)
+
+    async def set_assigned_sw(d: DeviceSchema):
+        updater = await get_update_manager(d.uuid)
+        _, target = await updater.get_update()
+        if target is not None:
+            await target.fetch_related("compatibility")
+            d.assigned_software = SoftwareSchema.model_validate(target)
+        return d
+
+    response.devices = await asyncio.gather(*[set_assigned_sw(d) for d in response.devices])
+    return response
+
+
+@router.delete(
+    "",
+    dependencies=[Security(validate_user_permissions, scopes=["device.delete"])],
+)
+async def devices_delete(_: Request, config: DevicesDeleteRequest) -> StatusResponse:
+    await delete_devices(config.devices)
+    return StatusResponse(success=True)
+
+
+router.include_router(device.router)

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/api/v1/rollouts/responses.py

@@ -1,19 +1,14 @@
-import asyncio
+from __future__ import annotations
 
 from pydantic import BaseModel
 
 from goosebit.api.responses import StatusResponse
-from goosebit.db.models import Rollout
 from goosebit.schema.rollouts import RolloutSchema
 
 
 class RolloutsPutResponse(StatusResponse):
-    id: int
+    id: int | None = None
 
 
 class RolloutsResponse(BaseModel):
     rollouts: list[RolloutSchema]
-
-    @classmethod
-    async def convert(cls, devices: list[Rollout]):
-        return cls(rollouts=await asyncio.gather(*[RolloutSchema.convert(d) for d in devices]))

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/api/v1/rollouts/routes.py

@@ -1,9 +1,9 @@
-from fastapi import APIRouter, Security
+from fastapi import APIRouter, HTTPException, Security
 from fastapi.requests import Request
 
 from goosebit.api.responses import StatusResponse
 from goosebit.auth import validate_user_permissions
-from goosebit.db.models import Rollout
+from goosebit.db.models import Rollout, Software
 
 from .requests import RolloutsDeleteRequest, RolloutsPatchRequest, RolloutsPutRequest
 from .responses import RolloutsPutResponse, RolloutsResponse
@@ -16,7 +16,8 @@ router = APIRouter(prefix="/rollouts", tags=["rollouts"])
     dependencies=[Security(validate_user_permissions, scopes=["rollout.read"])],
 )
 async def rollouts_get(_: Request) -> RolloutsResponse:
-    return await RolloutsResponse.convert(await Rollout.all().prefetch_related("software"))
+    rollouts = await Rollout.all().prefetch_related("software", "software__compatibility")
+    return RolloutsResponse(rollouts=rollouts)
 
 
 @router.post(
@@ -24,6 +25,9 @@ async def rollouts_get(_: Request) -> RolloutsResponse:
     dependencies=[Security(validate_user_permissions, scopes=["rollout.write"])],
 )
 async def rollouts_put(_: Request, rollout: RolloutsPutRequest) -> RolloutsPutResponse:
+    software = await Software.filter(id=rollout.software_id)
+    if len(software) == 0:
+        raise HTTPException(404, f"No software with ID {rollout.software_id} found")
     rollout = await Rollout.create(
         name=rollout.name,
         feed=rollout.feed,

goosebit-0.2.5/goosebit/api/v1/software/responses.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+from goosebit.schema.software import SoftwareSchema
+
+
+class SoftwareResponse(BaseModel):
+    software: list[SoftwareSchema]

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/api/v1/software/routes.py

@@ -1,6 +1,9 @@
-from pathlib import Path
+from __future__ import annotations
 
-import aiofiles
+import random
+import string
+
+from anyio import Path, open_file
 from fastapi import APIRouter, File, Form, HTTPException, Security, UploadFile
 from fastapi.requests import Request
 
@@ -21,7 +24,8 @@ router = APIRouter(prefix="/software", tags=["software"])
     dependencies=[Security(validate_user_permissions, scopes=["software.read"])],
 )
 async def software_get(_: Request) -> SoftwareResponse:
-    return await SoftwareResponse.convert(await Software.all().prefetch_related("compatibility"))
+    software = await Software.all().prefetch_related("compatibility")
+    return SoftwareResponse(software=software)
 
 
 @router.delete(
@@ -42,8 +46,8 @@ async def software_delete(_: Request, delete_req: SoftwareDeleteRequest) -> Stat
 
         if software.local:
             path = software.path
-            if path.exists():
-                path.unlink()
+            if await path.exists():
+                await path.unlink()
 
         await software.delete()
         success = True
@@ -66,12 +70,21 @@ async def post_update(_: Request, file: UploadFile | None = File(None), url: str
                 raise HTTPException(409, "Software with same URL already exists and is referenced by rollout")
 
         software = await create_software_update(url, None)
-    else:
+    elif file is not None:
         # local file
-        file_path = config.artifacts_dir.joinpath(file.filename)
-
-        async with aiofiles.tempfile.NamedTemporaryFile("w+b") as f:
-            await f.write(await file.read())
-            software = await create_software_update(file_path.absolute().as_uri(), Path(f.name))
+        artifacts_dir = Path(config.artifacts_dir)
+        file_path = artifacts_dir.joinpath(file.filename)
+        tmp_file_path = artifacts_dir.joinpath("tmp", ("".join(random.choices(string.ascii_lowercase, k=12)) + ".tmp"))
+        await tmp_file_path.parent.mkdir(parents=True, exist_ok=True)
+        file_absolute_path = await file_path.absolute()
+        tmp_file_absolute_path = await tmp_file_path.absolute()
+        try:
+            async with await open_file(tmp_file_path, "w+b") as f:
+                await f.write(await file.read())
+            software = await create_software_update(file_absolute_path.as_uri(), tmp_file_absolute_path)
+        finally:
+            await tmp_file_path.unlink(missing_ok=True)
+    else:
+        raise HTTPException(422)
 
     return {"id": software.id}

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/auth/__init__.py

@@ -16,7 +16,11 @@ from goosebit.settings.schema import User
 logger = logging.getLogger(__name__)
 
 
-oauth2_auth = OAuth2PasswordBearer(tokenUrl="login", auto_error=False)
+oauth2_bearer = OAuth2PasswordBearer(tokenUrl="login", auto_error=False)
+
+
+async def oauth2_auth(connection: HTTPConnection):
+    return await oauth2_bearer(connection)
 
 
 async def session_auth(connection: HTTPConnection) -> str:
@@ -27,15 +31,15 @@ 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:
+def get_user_from_token(token: str | None) -> User | None:
     if token is None:
-        return
+        return None
     try:
         token_data = jwt.decode(token, config.secret_key)
         username = token_data.claims["username"]
         return USERS.get(username)
     except (BadSignatureError, LookupError, ValueError):
-        pass
+        return None
 
 
 def login_user(username: str, password: str) -> str:
@@ -58,9 +62,9 @@ def login_user(username: str, password: str) -> str:
 
 
 def get_current_user(
-    session_token: Annotated[str, Depends(session_auth)] = None,
-    oauth2_token: Annotated[str, Depends(oauth2_auth)] = None,
-) -> User:
+    session_token: Annotated[str | None, Depends(session_auth)] = None,
+    oauth2_token: Annotated[str | None, Depends(oauth2_auth)] = None,
+) -> User | None:
     session_user = get_user_from_token(session_token)
     oauth2_user = get_user_from_token(oauth2_token)
     user = session_user or oauth2_user
@@ -68,7 +72,7 @@ def get_current_user(
 
 
 # using | Request because oauth2_auth.__call__ expects is
-async def get_user_from_request(connection: HTTPConnection | Request) -> User:
+async def get_user_from_request(connection: HTTPConnection | Request) -> User | None:
     token = await session_auth(connection) or await oauth2_auth(connection)
     return get_user_from_token(token)
 

goosebit-0.2.5/goosebit/db/__init__.py

@@ -0,0 +1,22 @@
+from logging import getLogger
+
+from tortoise import Tortoise
+from tortoise.exceptions import OperationalError
+
+from goosebit.db.config import TORTOISE_CONF
+from goosebit.db.models import Device
+
+logger = getLogger(__name__)
+
+
+async def init() -> bool:
+    await Tortoise.init(config=TORTOISE_CONF)
+    try:
+        await Device.first()
+    except OperationalError:
+        return False
+    return True
+
+
+async def close():
+    await Tortoise.close_connections()

goosebit-0.2.5/goosebit/db/migrations/models/1_20241109151811_update.py

@@ -0,0 +1,11 @@
+from tortoise import BaseDBAsyncClient
+
+
+async def upgrade(db: BaseDBAsyncClient) -> str:
+    return """
+        ALTER TABLE "device" DROP COLUMN "log_complete";"""
+
+
+async def downgrade(db: BaseDBAsyncClient) -> str:
+    return """
+        ALTER TABLE "device" ADD "log_complete" INT NOT NULL  DEFAULT 0;"""

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/db/models.py

@@ -1,11 +1,15 @@
+from __future__ import annotations
+
 from enum import IntEnum
-from pathlib import Path
 from typing import Self
 from urllib.parse import unquote, urlparse
 from urllib.request import url2pathname
 
 import semver
+from anyio import Path
+from semver import Version
 from tortoise import Model, fields
+from tortoise.exceptions import ValidationError
 
 from goosebit.api.telemetry.metrics import devices_count
 
@@ -65,7 +69,6 @@ class Device(Model):
     update_mode = fields.IntEnumField(UpdateModeEnum, default=UpdateModeEnum.ROLLOUT)
     last_state = fields.IntEnumField(UpdateStateEnum, default=UpdateStateEnum.UNKNOWN)
     progress = fields.IntField(null=True)
-    log_complete = fields.BooleanField(default=False)
     last_log = fields.TextField(null=True)
     last_seen = fields.BigIntField(null=True)
     last_ip = fields.CharField(max_length=15, null=True)
@@ -73,6 +76,14 @@ class Device(Model):
     tags = fields.ManyToManyField("models.Tag", related_name="devices", through="device_tags")
 
     async def save(self, *args, **kwargs):
+        # Check if the software is compatible with the hardware before saving
+        if self.assigned_software and self.hardware:
+            # Check if the assigned software is compatible with the hardware
+            await self.fetch_related("assigned_software", "hardware")
+            is_compatible = await self.assigned_software.compatibility.filter(id=self.hardware.id).exists()
+            if not is_compatible:
+                raise ValidationError("The assigned software is not compatible with the device's hardware.")
+
         is_new = self._saved_in_db is False
         await super().save(*args, **kwargs)
         if is_new:
@@ -127,12 +138,12 @@ class Software(Model):
             return None
         return sorted(
             updates,
-            key=lambda x: semver.Version.parse(x.version),
+            key=lambda x: semver.Version.parse(x.version, optional_minor_and_patch=True),
             reverse=True,
         )[0]
 
     @property
-    def path(self):
+    def path(self) -> Path:
         return Path(url2pathname(unquote(urlparse(self.uri).path)))
 
     @property
@@ -145,3 +156,7 @@ class Software(Model):
             return self.path.name
         else:
             return self.uri
+
+    @property
+    def parsed_version(self) -> Version:
+        return semver.Version.parse(self.version, optional_minor_and_patch=True)

{goosebit-0.2.3 → goosebit-0.2.5}/goosebit/realtime/logs.py

@@ -19,7 +19,7 @@ class RealtimeLogModel(BaseModel):
 
 @router.websocket(
     "/{dev_id}",
-    dependencies=[Security(validate_user_permissions, scopes=["home.read"])],
+    dependencies=[Security(validate_user_permissions, scopes=["device.read"])],
 )
 async def device_logs(websocket: WebSocket, dev_id: str):
     await websocket.accept()

goosebit-0.2.5/goosebit/schema/devices.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import time
+from enum import Enum, IntEnum, StrEnum
+from typing import Annotated
+
+from pydantic import BaseModel, BeforeValidator, ConfigDict, Field, computed_field
+
+from goosebit.db.models import UpdateModeEnum, UpdateStateEnum
+from goosebit.schema.software import HardwareSchema, SoftwareSchema
+from goosebit.updater.manager import DeviceUpdateManager
+
+
+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):
+    model_config = ConfigDict(from_attributes=True)
+
+    uuid: str
+    name: str | None
+    sw_version: str | None
+
+    assigned_software: SoftwareSchema | None = Field(exclude=True)
+    hardware: HardwareSchema | None = Field(exclude=True)
+
+    feed: str
+    progress: int | None
+    last_state: Annotated[UpdateStateSchema, BeforeValidator(UpdateStateSchema.convert)]  # type: ignore[valid-type]
+    update_mode: Annotated[UpdateModeSchema, BeforeValidator(UpdateModeSchema.convert)]  # type: ignore[valid-type]
+    force_update: bool
+    last_ip: str | None
+    last_seen: Annotated[
+        int | None, BeforeValidator(lambda last_seen: round(time.time() - last_seen) if last_seen is not None else None)
+    ]
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def online(self) -> bool | None:
+        return self.last_seen < (self.poll_seconds + 10) if self.last_seen is not None else None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def sw_target_version(self) -> str | None:
+        return self.assigned_software.version if self.assigned_software is not None else None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def sw_assigned(self) -> int | None:
+        return self.assigned_software.id if self.assigned_software is not None else None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def hw_model(self) -> str | None:
+        return self.hardware.model if self.hardware is not None else None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def hw_revision(self) -> str | None:
+        return self.hardware.revision if self.hardware is not None else None
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def poll_seconds(self) -> int:
+        return DeviceUpdateManager(self.uuid).poll_seconds