readerboard 0.4.0__tar.gz → 0.5.0__tar.gz

{readerboard-0.4.0/readerboard.egg-info → readerboard-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: readerboard
-Version: 0.4.0
+Version: 0.5.0
 Summary: An HTTP service for BetaBrite and Alpha protocol LED signs: several sources share one sign, with alerts, expiring messages and clock sync
 Author: mjaksn
 License-Expression: MIT
@@ -55,8 +55,10 @@ An HTTP service that drives a BetaBrite Classic sign, either through a serial ca
 through an Ethernet to RS-232 adapter.
 
 Several sources can share the sign at once. Each registers a named **slot**, and the sign
-rotates through the registered slots by itself. An **alert** takes the whole display over
-until it is released, after which the rotation resumes.
+rotates through the registered slots by itself. A **variable** is a value that messages
+call by name, such as a temperature, and changing it does not blank the sign or restart
+the message showing it. An **alert** takes the whole display over until it is released,
+after which the rotation resumes.
 
 ## What it does
 
@@ -64,6 +66,10 @@ until it is released, after which the rotation resumes.
   automation owns `doorbell`, without either knowing about the other.
 - **The sign does the rotating.** Each message lives in its own sign file and the sign
   cycles them on its own, so rotation costs no serial traffic at all.
+- **Live values without a blink.** A message such as `Outside <var:temp><degree>F` calls
+  the variable `temp`, and a new value is one small write that the sign shows the next
+  time it draws the message, with no blank and no restart. One variable can appear in
+  any number of messages, and a value that stops arriving can be made to go stale.
 - **Alerts.** Take the display over, optionally with a deadline, then hand it back.
 - **It keeps the sign's clock right**, at startup, hourly, and whenever the link comes
   back. That last trigger is the one that matters: a sign returning from a power cut
@@ -270,6 +276,21 @@ curl -X PUT http://localhost:5001/messages/doorbell \
      -d '{"message": "<amber>Someone at the door", "ttl_seconds": 300}'
 ```
 
+Show a live value. Create the variable first, then a message that calls it:
+
+```
+curl -X PUT http://localhost:5001/variables/temp \
+     -H 'X-API-Key: YOUR-KEY' -H 'Content-Type: application/json' \
+     -d '{"value": "72", "ttl_seconds": 1800, "stale_value": "--"}'
+
+curl -X PUT http://localhost:5001/messages/weather \
+     -H 'X-API-Key: YOUR-KEY' -H 'Content-Type: application/json' \
+     -d '{"message": "Outside <var:temp><degree>F", "display_mode": "ROTATE"}'
+```
+
+From then on only the variable needs writing, and the message picks each new value up
+on its next pass across the sign.
+
 Take the sign over for thirty seconds:
 
 ```
@@ -296,8 +317,8 @@ Silence it with `{"command": "SPEAKER", "parameter": "OFF"}`, and turn it back o
 lives on the sign and survives a restart, so it is also the first thing to check if
 `SOUND` ever seems to do nothing.
 
-The full API is at `/docs`. Every markup token, display mode and control
-command is listed by the `/enumerations` reads there, which answer at
+The full API is at `/docs`. Every markup token, value token, display mode and
+control command is listed by the `/enumerations` reads there, which answer at
 request time rather than being frozen into the description.
 
 ### Writing messages
@@ -311,6 +332,59 @@ displays correctly. A character the sign cannot render is rejected with a 400, a
 unknown token: a write is told what the sign would have made of it rather than being
 shown something it did not ask for.
 
+### Live values: variables
+
+A variable lives in a small file of its own on the sign, and a message or an alert
+calls it with `<var:name>`. Writing a new value rewrites that file and nothing else,
+which the sign takes without blanking, so a message showing a temperature or a count can
+change every minute and never restart. In a scrolling mode the new value appears on the
+message's next pass. An alert carrying a live wind speed works the same way, and keeps
+the sign while the number changes.
+
+A few things are worth knowing, all of them measured on the sign:
+
+- **Create the variable before a message calls it.** A message or an alert naming a
+  variable that does not exist is refused with a 400, and a variable that a message or
+  the alert still calls cannot be deleted: that is a 409 naming what calls it.
+- **Formatting in a value carries on after it.** A value of `<red>DOWN` turns the rest
+  of the message red as well, and so does a character set or a speed. If the text after
+  the call matters, set it again in the message after the call.
+- **A value takes the message markup, less two tokens.** `<week_day>` draws as a literal
+  `9` from inside a variable, and a variable cannot call another. `GET
+  /enumerations/value-tokens` lists what is allowed.
+- **Keep a changing number from pushing the text around it.** With the sign's usual
+  proportional spacing, `11` and `88` are different widths and the text after them moves.
+  Put `<fixed_width>` in the message before the call and send values of the same length.
+  Fixed width also left-justifies the line.
+- **A value that stops arriving can go stale.** Give a `ttl_seconds` and a `stale_value`
+  such as `--`, and once the time passes without a new value the sign shows the stale
+  value instead. The variable itself stays, since messages call it.
+- **A value that does not fit is refused.** Each holds `variable_capacity` bytes after
+  rendering, 32 by default. The sign does not cut an overlong value short, it empties it,
+  so the service refuses one rather than send it.
+
+A Home Assistant `rest_command` that keeps a sensor on the sign:
+
+```yaml
+rest_command:
+  sign_temperature:
+    url: http://readerboard.local:5001/variables/temp
+    method: put
+    headers:
+      X-API-Key: !secret readerboard_key
+    content_type: application/json
+    payload: '{"value": "{{ value }}", "ttl_seconds": 1800, "stale_value": "--"}'
+```
+
+Call it from an automation triggered by the sensor, with the reading as `value`:
+
+```yaml
+actions:
+  - action: rest_command.sign_temperature
+    data:
+      value: "{{ states('sensor.outside_temperature') | round(0) | int }}"
+```
+
 ### Recovering a sign that has stopped responding
 
 A sign mounted out of reach can wedge: a stray bit corrupts what its decoder is
@@ -361,9 +435,11 @@ telnet serial protocol, `/dev/ttyUSB0` or `COM3` for a cable plugged straight in
 and the port, and pyserial's answer to one that has a slash names neither the setting
 nor the value.
 
-Two settings reallocate the sign's memory when changed, and **that erases every message
-on it**: `slot_count` and `slot_capacity`. The service will do it, and say so loudly in
-the log, but they are not settings to fiddle with.
+Four settings reallocate the sign's memory when changed, and **that erases every message
+on it**: `slot_count`, `slot_capacity`, `variable_count` and `variable_capacity`. The
+service will do it, and say so loudly in the log, but they are not settings to fiddle
+with. With `variable_count` at 0, `variable_capacity` allocates nothing, so changing it
+alone reallocates nothing either.
 
 ## Security
 

{readerboard-0.4.0 → readerboard-0.5.0}/README.md

@@ -11,8 +11,10 @@ An HTTP service that drives a BetaBrite Classic sign, either through a serial ca
 through an Ethernet to RS-232 adapter.
 
 Several sources can share the sign at once. Each registers a named **slot**, and the sign
-rotates through the registered slots by itself. An **alert** takes the whole display over
-until it is released, after which the rotation resumes.
+rotates through the registered slots by itself. A **variable** is a value that messages
+call by name, such as a temperature, and changing it does not blank the sign or restart
+the message showing it. An **alert** takes the whole display over until it is released,
+after which the rotation resumes.
 
 ## What it does
 
@@ -20,6 +22,10 @@ until it is released, after which the rotation resumes.
   automation owns `doorbell`, without either knowing about the other.
 - **The sign does the rotating.** Each message lives in its own sign file and the sign
   cycles them on its own, so rotation costs no serial traffic at all.
+- **Live values without a blink.** A message such as `Outside <var:temp><degree>F` calls
+  the variable `temp`, and a new value is one small write that the sign shows the next
+  time it draws the message, with no blank and no restart. One variable can appear in
+  any number of messages, and a value that stops arriving can be made to go stale.
 - **Alerts.** Take the display over, optionally with a deadline, then hand it back.
 - **It keeps the sign's clock right**, at startup, hourly, and whenever the link comes
   back. That last trigger is the one that matters: a sign returning from a power cut
@@ -226,6 +232,21 @@ curl -X PUT http://localhost:5001/messages/doorbell \
      -d '{"message": "<amber>Someone at the door", "ttl_seconds": 300}'
 ```
 
+Show a live value. Create the variable first, then a message that calls it:
+
+```
+curl -X PUT http://localhost:5001/variables/temp \
+     -H 'X-API-Key: YOUR-KEY' -H 'Content-Type: application/json' \
+     -d '{"value": "72", "ttl_seconds": 1800, "stale_value": "--"}'
+
+curl -X PUT http://localhost:5001/messages/weather \
+     -H 'X-API-Key: YOUR-KEY' -H 'Content-Type: application/json' \
+     -d '{"message": "Outside <var:temp><degree>F", "display_mode": "ROTATE"}'
+```
+
+From then on only the variable needs writing, and the message picks each new value up
+on its next pass across the sign.
+
 Take the sign over for thirty seconds:
 
 ```
@@ -252,8 +273,8 @@ Silence it with `{"command": "SPEAKER", "parameter": "OFF"}`, and turn it back o
 lives on the sign and survives a restart, so it is also the first thing to check if
 `SOUND` ever seems to do nothing.
 
-The full API is at `/docs`. Every markup token, display mode and control
-command is listed by the `/enumerations` reads there, which answer at
+The full API is at `/docs`. Every markup token, value token, display mode and
+control command is listed by the `/enumerations` reads there, which answer at
 request time rather than being frozen into the description.
 
 ### Writing messages
@@ -267,6 +288,59 @@ displays correctly. A character the sign cannot render is rejected with a 400, a
 unknown token: a write is told what the sign would have made of it rather than being
 shown something it did not ask for.
 
+### Live values: variables
+
+A variable lives in a small file of its own on the sign, and a message or an alert
+calls it with `<var:name>`. Writing a new value rewrites that file and nothing else,
+which the sign takes without blanking, so a message showing a temperature or a count can
+change every minute and never restart. In a scrolling mode the new value appears on the
+message's next pass. An alert carrying a live wind speed works the same way, and keeps
+the sign while the number changes.
+
+A few things are worth knowing, all of them measured on the sign:
+
+- **Create the variable before a message calls it.** A message or an alert naming a
+  variable that does not exist is refused with a 400, and a variable that a message or
+  the alert still calls cannot be deleted: that is a 409 naming what calls it.
+- **Formatting in a value carries on after it.** A value of `<red>DOWN` turns the rest
+  of the message red as well, and so does a character set or a speed. If the text after
+  the call matters, set it again in the message after the call.
+- **A value takes the message markup, less two tokens.** `<week_day>` draws as a literal
+  `9` from inside a variable, and a variable cannot call another. `GET
+  /enumerations/value-tokens` lists what is allowed.
+- **Keep a changing number from pushing the text around it.** With the sign's usual
+  proportional spacing, `11` and `88` are different widths and the text after them moves.
+  Put `<fixed_width>` in the message before the call and send values of the same length.
+  Fixed width also left-justifies the line.
+- **A value that stops arriving can go stale.** Give a `ttl_seconds` and a `stale_value`
+  such as `--`, and once the time passes without a new value the sign shows the stale
+  value instead. The variable itself stays, since messages call it.
+- **A value that does not fit is refused.** Each holds `variable_capacity` bytes after
+  rendering, 32 by default. The sign does not cut an overlong value short, it empties it,
+  so the service refuses one rather than send it.
+
+A Home Assistant `rest_command` that keeps a sensor on the sign:
+
+```yaml
+rest_command:
+  sign_temperature:
+    url: http://readerboard.local:5001/variables/temp
+    method: put
+    headers:
+      X-API-Key: !secret readerboard_key
+    content_type: application/json
+    payload: '{"value": "{{ value }}", "ttl_seconds": 1800, "stale_value": "--"}'
+```
+
+Call it from an automation triggered by the sensor, with the reading as `value`:
+
+```yaml
+actions:
+  - action: rest_command.sign_temperature
+    data:
+      value: "{{ states('sensor.outside_temperature') | round(0) | int }}"
+```
+
 ### Recovering a sign that has stopped responding
 
 A sign mounted out of reach can wedge: a stray bit corrupts what its decoder is
@@ -317,9 +391,11 @@ telnet serial protocol, `/dev/ttyUSB0` or `COM3` for a cable plugged straight in
 and the port, and pyserial's answer to one that has a slash names neither the setting
 nor the value.
 
-Two settings reallocate the sign's memory when changed, and **that erases every message
-on it**: `slot_count` and `slot_capacity`. The service will do it, and say so loudly in
-the log, but they are not settings to fiddle with.
+Four settings reallocate the sign's memory when changed, and **that erases every message
+on it**: `slot_count`, `slot_capacity`, `variable_count` and `variable_capacity`. The
+service will do it, and say so loudly in the log, but they are not settings to fiddle
+with. With `variable_count` at 0, `variable_capacity` allocates nothing, so changing it
+alone reallocates nothing either.
 
 ## Security
 

{readerboard-0.4.0 → readerboard-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "readerboard"
-version = "0.4.0"
+version = "0.5.0"
 description = "An HTTP service for BetaBrite and Alpha protocol LED signs: several sources share one sign, with alerts, expiring messages and clock sync"
 readme = "README.md"
 requires-python = ">=3.11"

{readerboard-0.4.0 → readerboard-0.5.0}/readerboard/__init__.py

@@ -7,4 +7,4 @@ and against the release tag, before anything is published. See
 
 __all__ = ["__version__"]
 
-__version__ = "0.4.0"
+__version__ = "0.5.0"

{readerboard-0.4.0 → readerboard-0.5.0}/readerboard/api/app.py

@@ -45,6 +45,10 @@ Several sources can share the sign at once. Each registers a named **slot**, and
 the sign rotates through the registered slots by itself. An **alert** takes the
 whole display over until it is released, then the rotation resumes.
 
+A **variable** is a value a slot's message or an alert calls with `<var:name>`.
+Changing it rewrites only the variable, so the sign shows the new value without
+blanking or restarting what calls it.
+
 Every write needs an `X-API-Key` header, and so does `GET /sign/information`,
 which reads the sign rather than the service: it puts a question on the wire and
 holds the sign until the answer comes back. The service's own reads and
@@ -53,13 +57,14 @@ holds the sign until the answer comes back. The service's own reads and
 
 A failure is reported by the status code, with the reason in a `detail` field:
 400 for a command the sign does not have, a parameter it will not accept, a
-message too long for its slot or markup the sign cannot render, 401 for a
-missing or wrong `X-API-Key`, 404 for a slot nothing has registered, 409 when
-every message slot is already in use, 503 when the sign is unreachable, answers
-with something the service cannot read, or no API key is configured at all, 500
-for something the service has no code for, and 422 for a body that is not the
-shape the endpoint declares, which includes a display mode the sign does not
-have.
+message or value too long for its file, markup the sign cannot render or a call
+to a variable that does not exist, 401 for a missing or wrong `X-API-Key`, 404
+for a slot or variable that does not exist, 409 when every slot or every
+variable is already in use or a variable something still calls is deleted, 503
+when the sign is unreachable, stops partway through an answer or answers with
+something the service cannot read, or no API key is configured at all, 500 for
+something the service has no code for, and 422 for a body that is not the shape
+the endpoint declares, which includes a display mode the sign does not have.
 """
 
 
@@ -99,7 +104,7 @@ async def _refresh_loop(app: FastAPI, interval: float) -> None:
 
 
 async def _sweep_loop(app: FastAPI, interval: float) -> None:
-    """Expire slots and alerts whose deadlines have passed."""
+    """Expire slots and alerts, and turn variables stale, once their deadlines pass."""
     registry: MessageRegistry = app.state.registry
     alerts: AlertService = app.state.alerts
 
@@ -137,7 +142,12 @@ def create_app(settings: Settings | None = None, transport: Transport | None = N
         )
         store = StateStore(settings.state_path)
         state = store.load()
-        layout = Layout(settings.slot_count, settings.slot_capacity)
+        layout = Layout(
+            settings.slot_count,
+            settings.slot_capacity,
+            settings.variable_count,
+            settings.variable_capacity,
+        )
         alerts = AlertService(controller, store, state)
         registry = MessageRegistry(
             controller, layout, store, state, alert_active=lambda: alerts.active is not None
@@ -145,6 +155,9 @@ def create_app(settings: Settings | None = None, transport: Transport | None = N
         # An alert holding the sign makes the registry hold back run sequence
         # writes; releasing it is what lets them through.
         alerts.set_release_hook(registry.flush_deferred)
+        # And an alert calling a variable is rendered by the registry, under its
+        # lock, so the variable cannot be deleted while the alert calls it.
+        alerts.set_rendering(registry.rendering)
         clock = ClockService(
             controller,
             interval_seconds=settings.clock_sync_interval_seconds,
@@ -240,6 +253,7 @@ def create_app(settings: Settings | None = None, transport: Transport | None = N
         clock = get_clock(request)
 
         used, total = registry.occupancy
+        variables_used, variables_total = registry.variable_occupancy
         return HealthResponse(
             status="ok" if controller.is_connected else "degraded",
             version=__version__,
@@ -253,6 +267,8 @@ def create_app(settings: Settings | None = None, transport: Transport | None = N
             ),
             slots_used=used,
             slots_total=total,
+            variables_used=variables_used,
+            variables_total=variables_total,
             sign_in_sync=registry.in_sync,
             alert_active=alerts.active is not None,
             clock_last_synced_at=clock.last_sync_at,

{readerboard-0.4.0 → readerboard-0.5.0}/readerboard/api/errors.py

@@ -18,7 +18,14 @@ from readerboard.protocol.markup import MarkupError
 from readerboard.protocol.replies import ReplyError
 from readerboard.services import commands
 from readerboard.services.alerts import AlertTooLong
-from readerboard.services.registry import MessageTooLong, UnknownSlot
+from readerboard.services.registry import (
+    MessageTooLong,
+    UnknownSlot,
+    UnknownVariable,
+    VariableInUse,
+    VariablesDisabled,
+    VariableTooLong,
+)
 from readerboard.sign.layout import LayoutFull
 from readerboard.transport.base import TransportError
 
@@ -26,11 +33,18 @@ STATUS_FOR_ERROR: tuple[tuple[type[Exception], int], ...] = (
     (MarkupError, status.HTTP_400_BAD_REQUEST),
     (ProtocolError, status.HTTP_400_BAD_REQUEST),
     (MessageTooLong, status.HTTP_400_BAD_REQUEST),
+    (VariableTooLong, status.HTTP_400_BAD_REQUEST),
+    (VariablesDisabled, status.HTTP_400_BAD_REQUEST),
     (AlertTooLong, status.HTTP_400_BAD_REQUEST),
     (commands.UnknownCommand, status.HTTP_400_BAD_REQUEST),
     (commands.BadParameter, status.HTTP_400_BAD_REQUEST),
     (UnknownSlot, status.HTTP_404_NOT_FOUND),
+    (UnknownVariable, status.HTTP_404_NOT_FOUND),
     (LayoutFull, status.HTTP_409_CONFLICT),
+    # Deleting a variable a message still calls would leave that message
+    # calling a file the next variable could be given. Not the caller's
+    # request being malformed, which is what makes it a conflict.
+    (VariableInUse, status.HTTP_409_CONFLICT),
     (TransportError, status.HTTP_503_SERVICE_UNAVAILABLE),
     # A sign that answers with something unreadable is as unusable as one
     # that does not answer, and neither is the caller's doing. The route

{readerboard-0.4.0 → readerboard-0.5.0}/readerboard/api/models.py

@@ -14,9 +14,10 @@ from typing import Annotated
 
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
+from readerboard.protocol.markup import VARIABLE_NAME_PATTERN
 from readerboard.protocol.replies import GeneralInformation
 from readerboard.protocol.tokens import COMMAND_BY_NAME, MODE_BY_NAME
-from readerboard.sign.state import AlertState, SlotState
+from readerboard.sign.state import AlertState, SlotState, VariableState
 
 SlotKey = Annotated[
     str,
@@ -28,6 +29,19 @@ SlotKey = Annotated[
     ),
 ]
 
+# The same pattern the markup checks a <var:name> against, so that no variable
+# can be created under a name no message could call.
+VariableName = Annotated[
+    str,
+    Field(
+        pattern=VARIABLE_NAME_PATTERN,
+        description=(
+            "the variable's name, one to 32 lowercase letters, digits and underscores. "
+            "A message calls it as <var:name>"
+        ),
+    ),
+]
+
 
 def _normalise_mode(value: str) -> str:
     upper = value.strip().upper()
@@ -47,8 +61,9 @@ class MessageRequest(BaseModel):
         min_length=1,
         max_length=4096,
         description=(
-            "the message, including markup tokens such as <red> and <degree>. It cannot "
-            "be empty: an empty message holds a slot open around nothing, and the sign "
+            "the message, including markup tokens such as <red> and <degree>, and "
+            "<var:name> to call a variable, which has to exist first. It cannot be "
+            "empty: an empty message holds a slot open around nothing, and the sign "
             "cycles to a file with no text in it. Use DELETE to give the slot back"
         ),
     )
@@ -98,6 +113,95 @@ class SlotResponse(BaseModel):
         )
 
 
+class VariableRequest(BaseModel):
+    """A value for a variable, which the messages calling it show."""
+
+    model_config = ConfigDict(extra="forbid")
+
+    value: str = Field(
+        max_length=1024,
+        description=(
+            "the value, with the same markup a message takes except <week_day> and "
+            "<var:name>, which the sign draws as a literal character from inside a "
+            "variable. Formatting set here carries on into the message after the call: "
+            "a value of <red>DOWN turns the rest of the message red too. May be empty, "
+            "which shows nothing where the variable is called"
+        ),
+    )
+    ttl_seconds: float | None = Field(
+        default=None,
+        gt=0,
+        description=(
+            "show stale_value in its place this many seconds from now unless a fresh "
+            "value arrives first. The variable itself stays, since messages call it. "
+            "Omit to keep the value until replaced"
+        ),
+    )
+    stale_value: str = Field(
+        default="",
+        max_length=1024,
+        description=(
+            "what to show once ttl_seconds has passed, such as --. Empty shows nothing. "
+            "Checked against the variable's size now, not when it is needed"
+        ),
+    )
+    source: str | None = Field(
+        default=None,
+        max_length=128,
+        description="who wrote this, recorded so the variable list is readable",
+    )
+
+
+class VariableResponse(BaseModel):
+    """A variable."""
+
+    name: str
+    label: str = Field(description="the sign file this variable occupies, a through z")
+    value: str
+    stale_value: str
+    stale: bool = Field(
+        description="true once ttl_seconds has passed, when the sign shows stale_value instead"
+    )
+    source: str | None
+    expires_at: datetime | None = Field(
+        description=(
+            "when the value goes stale, or null if it never will or already has, which "
+            "stale tells apart"
+        )
+    )
+    updated_at: datetime
+    called_by: list[str] = Field(
+        description=(
+            "the keys of the slots whose messages call this variable. It cannot be deleted "
+            "while any do, nor while called_by_alert is true"
+        )
+    )
+    called_by_alert: bool = Field(
+        description=(
+            "true while the alert holding the sign calls this variable. It cannot be "
+            "deleted until the alert is released or replaced with one that does not"
+        )
+    )
+
+    @classmethod
+    def of(
+        cls, variable: VariableState, called_by: list[str], *, called_by_alert: bool
+    ) -> VariableResponse:
+        """Render a stored variable as the API's view of it."""
+        return cls(
+            name=variable.name,
+            label=variable.label,
+            value=variable.value,
+            stale_value=variable.stale_value,
+            stale=variable.stale,
+            source=variable.source,
+            expires_at=variable.expires_at,
+            updated_at=variable.updated_at,
+            called_by=called_by,
+            called_by_alert=called_by_alert,
+        )
+
+
 class SignInformationResponse(BaseModel):
     """What the sign says about itself."""
 
@@ -141,7 +245,8 @@ class AlertRequest(BaseModel):
         max_length=4096,
         description=(
             "the alert text. The sign's priority file holds 125 bytes once markup has "
-            "been rendered, and cannot be resized. It cannot be empty: a write with no "
+            "been rendered, and cannot be resized. It can call variables with "
+            "<var:name>, as a message can. It cannot be empty: a write with no "
             "text still carries the formatting bytes around it, which the sign reads as "
             "a blank priority message and displays, so the sign would sit blank with "
             "the rotation suppressed behind it and an alert reported as active"
@@ -222,6 +327,8 @@ class HealthResponse(BaseModel):
     link: LinkHealth
     slots_used: int
     slots_total: int
+    variables_used: int
+    variables_total: int = Field(description="0 when variables are switched off")
     sign_in_sync: bool = Field(
         description=(
             "false when the sign is behind the service's record, which is a removal or "