ramses-rf 0.22.40__py3-none-any.whl → 0.51.1__py3-none-any.whl

ramses_rf/helpers.py

@@ -1,15 +1,37 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
 """RAMSES RF - Helper functions."""
+
 from __future__ import annotations
 
 import asyncio
+from collections.abc import Awaitable, Callable
 from copy import deepcopy
 from inspect import iscoroutinefunction
+from typing import Any, TypeAlias
+
+_SchemaT: TypeAlias = dict[str, Any]
+
+
+def is_subset(inner: _SchemaT, outer: _SchemaT) -> bool:
+    """Return True is one dict (or list) is a subset of another."""
 
+    def _is_subset(
+        a: dict[str, Any] | list[Any] | Any, b: dict[str, Any] | list[Any] | Any
+    ) -> bool:
+        if isinstance(a, dict):
+            return isinstance(b, dict) and all(
+                k in b and _is_subset(v, b[k]) for k, v in a.items()
+            )
+        if isinstance(a, list):
+            return isinstance(b, list) and all(
+                any(_is_subset(x, y) for y in b) for x in a
+            )
+        return bool(a == b)
 
-def merge(src: dict, dst: dict, _dc: bool = None) -> dict:  # TODO: move to ramses_rf?
+    return _is_subset(inner, outer)
+
+
+def deep_merge(src: _SchemaT, dst: _SchemaT, _dc: bool = False) -> _SchemaT:
     """Deep merge a src dict (precedent) into a dst dict and return the result.
 
     run me with nosetests --with-doctest file.py
@@ -22,13 +44,12 @@ def merge(src: dict, dst: dict, _dc: bool = None) -> dict:  # TODO: move to rams
 
     new_dst = dst if _dc else deepcopy(dst)  # start with copy of dst, merge src into it
     for key, value in src.items():  # values are only: dict, list, value or None
-
         if isinstance(value, dict):  # is dict
             node = new_dst.setdefault(key, {})  # get node or create one
-            merge(value, node, _dc=True)
+            deep_merge(value, node, _dc=True)
 
         elif not isinstance(value, list):  # is value
-            new_dst[key] = value  # src takes precidence, assert will fail
+            new_dst[key] = value  # src takes precedence, assert will fail
 
         elif key not in new_dst or not isinstance(new_dst[key], list):  # is list
             new_dst[key] = src[key]  # not expected, but maybe
@@ -40,7 +61,9 @@ def merge(src: dict, dst: dict, _dc: bool = None) -> dict:  # TODO: move to rams
     return new_dst
 
 
-def shrink(value: dict, keep_falsys: bool = False, keep_hints: bool = False) -> dict:
+def shrink(
+    value: _SchemaT, keep_falsys: bool = False, keep_hints: bool = False
+) -> _SchemaT:
     """Return a minimized dict, after removing all the meaningless items.
 
     Specifically, removes items with:
@@ -48,7 +71,7 @@ def shrink(value: dict, keep_falsys: bool = False, keep_hints: bool = False) ->
     - falsey values
     """
 
-    def walk(node):
+    def walk(node: Any) -> Any:
         if isinstance(node, dict):
             return {
                 k: walk(v)
@@ -66,29 +89,44 @@ def shrink(value: dict, keep_falsys: bool = False, keep_hints: bool = False) ->
     if not isinstance(value, dict):
         raise TypeError("value is not a dict")
 
-    return walk(value)
+    result: _SchemaT = walk(value)
+    return result
 
 
-def schedule_task(fnc, *args, delay=None, period=None, **kwargs) -> asyncio.Task:
+def schedule_task(
+    fnc: Awaitable[Any] | Callable[..., Any],
+    *args: Any,
+    delay: float | None = None,
+    period: float | None = None,
+    **kwargs: Any,
+) -> asyncio.Task[Any]:
     """Start a coro after delay seconds."""
 
-    async def execute_func(fnc, *args, **kwargs):
-        if iscoroutinefunction(fnc):
+    async def execute_fnc(
+        fnc: Awaitable[Any] | Callable[..., Any], *args: Any, **kwargs: Any
+    ) -> Any:
+        if iscoroutinefunction(fnc):  # Awaitable, else Callable
             return await fnc(*args, **kwargs)
-        return fnc(*args, **kwargs)
-
-    async def schedule_func(delay, period, fnc, *args, **kwargs):
+        return fnc(*args, **kwargs)  # type: ignore[operator]
+
+    async def schedule_fnc(
+        fnc: Awaitable[Any] | Callable[..., Any],
+        delay: float | None,
+        period: float | None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
         if delay:
             await asyncio.sleep(delay)
 
         if not period:
-            asyncio.create_task(execute_func(fnc, *args, **kwargs), name=str(fnc))
+            await execute_fnc(fnc, *args, **kwargs)
             return
 
         while period:
-            asyncio.create_task(execute_func(fnc, *args, **kwargs), name=str(fnc))
+            await execute_fnc(fnc, *args, **kwargs)
             await asyncio.sleep(period)
 
-    return asyncio.create_task(
-        schedule_func(delay, period, fnc, *args, **kwargs), name=str(fnc)
+    return asyncio.create_task(  # do we need to pass in an event loop?
+        schedule_fnc(fnc, delay, period, *args, **kwargs), name=str(fnc)
     )

ramses_rf/schemas.py

@@ -1,43 +1,31 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
 """RAMSES RF - a RAMSES-II protocol decoder & analyser.
 
 Schema processor for upper layer.
 """
+
 from __future__ import annotations
 
 import logging
 import re
-from types import SimpleNamespace
-from typing import Any, Callable, TextIO
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Final
 
-import voluptuous as vol  # type: ignore[import]
+import voluptuous as vol
 
-from .const import (
-    DEFAULT_MAX_ZONES,
-    DEV_ROLE,
-    DEV_ROLE_MAP,
-    DEV_TYPE,
-    DEV_TYPE_MAP,
-    DEVICE_ID_REGEX,
-    DONT_CREATE_MESSAGES,
-    SZ_ZONE_IDX,
-    ZON_ROLE_MAP,
-    SystemType,
-    __dev_mode__,
-)
-from .helpers import shrink
-from .protocol.const import (
-    SZ_ACTUATORS,
-    SZ_DEVICES,
+# TODO: deprecate re-exporting (via as) in favour of direct imports
+from ramses_tx.const import (
+    SZ_ACTUATORS as SZ_ACTUATORS,
+    SZ_CONFIG as SZ_CONFIG,
+    SZ_DEVICES as SZ_DEVICES,
     SZ_NAME,
-    SZ_SENSOR,
+    SZ_SENSOR as SZ_SENSOR,
     SZ_ZONE_TYPE,
     SZ_ZONES,
 )
-from .protocol.frame import _DeviceIdT
-from .protocol.schemas import (  # noqa: F401
+
+# TODO: deprecate re-exporting (via as) in favour of direct imports
+from ramses_tx.schemas import (  # noqa: F401
     SCH_DEVICE_ID_ANY,
     SCH_DEVICE_ID_APP,
     SCH_DEVICE_ID_BDR,
@@ -48,51 +36,68 @@ from .protocol.schemas import (  # noqa: F401
     SCH_DEVICE_ID_UFC,
     SCH_ENGINE_DICT,
     SCH_GLOBAL_TRAITS_DICT,
-    SCH_TRAITS,
-    SZ_ALIAS,
+    SCH_TRAITS as SCH_TRAITS,
+    SZ_ALIAS as SZ_ALIAS,
     SZ_BLOCK_LIST,
-    SZ_CLASS,
+    SZ_CLASS as SZ_CLASS,
     SZ_DISABLE_SENDING,
     SZ_ENFORCE_KNOWN_LIST,
-    SZ_FAKED,
-    SZ_KNOWN_LIST,
+    SZ_FAKED as SZ_FAKED,
+    SZ_KNOWN_LIST as SZ_KNOWN_LIST,
     SZ_PACKET_LOG,
+    SZ_SCHEME as SZ_SCHEME,
+    DeviceIdT,
     sch_packet_log_dict_factory,
     select_device_filter_mode,
 )
 
-# from .systems import _SystemT  # circular import
+from . import exceptions as exc
+
+# TODO: deprecate re-exporting (via as) in favour of direct imports
+from .const import (
+    DEFAULT_MAX_ZONES as DEFAULT_MAX_ZONES,
+    DEV_ROLE_MAP,
+    DEV_TYPE_MAP,
+    DEVICE_ID_REGEX,
+    DONT_CREATE_MESSAGES,
+    SZ_ZONE_IDX,
+    ZON_ROLE_MAP,
+    DevRole,
+    DevType,
+    SystemType,
+)
 
+if TYPE_CHECKING:
+    from .device import Device
+    from .gateway import Gateway
+    from .system import Evohome
 
-DEV_MODE = __dev_mode__ and False
 
 _LOGGER = logging.getLogger(__name__)
-if DEV_MODE:
-    _LOGGER.setLevel(logging.DEBUG)
 
 
 #
 # 0/5: Schema strings
-SZ_SCHEMA = "schema"
-SZ_MAIN_TCS = "main_tcs"
+SZ_SCHEMA: Final = "schema"
+SZ_MAIN_TCS: Final = "main_tcs"
 
-SZ_CONTROLLER = DEV_TYPE_MAP[DEV_TYPE.CTL]
-SZ_SYSTEM = "system"
-SZ_APPLIANCE_CONTROL = DEV_ROLE_MAP[DEV_ROLE.APP]
-SZ_ORPHANS = "orphans"
-SZ_ORPHANS_HEAT = "orphans_heat"
-SZ_ORPHANS_HVAC = "orphans_hvac"
+SZ_CONTROLLER = DEV_TYPE_MAP[DevType.CTL]
+SZ_SYSTEM: Final = "system"
+SZ_APPLIANCE_CONTROL = DEV_ROLE_MAP[DevRole.APP]
+SZ_ORPHANS: Final = "orphans"
+SZ_ORPHANS_HEAT: Final = "orphans_heat"
+SZ_ORPHANS_HVAC: Final = "orphans_hvac"
 
-SZ_DHW_SYSTEM = "stored_hotwater"
-SZ_DHW_SENSOR = DEV_ROLE_MAP[DEV_ROLE.DHW]
-SZ_DHW_VALVE = DEV_ROLE_MAP[DEV_ROLE.HTG]
-SZ_HTG_VALVE = DEV_ROLE_MAP[DEV_ROLE.HT1]
+SZ_DHW_SYSTEM: Final = "stored_hotwater"
+SZ_DHW_SENSOR = DEV_ROLE_MAP[DevRole.DHW]
+SZ_DHW_VALVE = DEV_ROLE_MAP[DevRole.HTG]
+SZ_HTG_VALVE = DEV_ROLE_MAP[DevRole.HT1]
 
-SZ_SENSOR_FAKED = "sensor_faked"
+SZ_SENSOR_FAKED: Final = "sensor_faked"
 
-SZ_UFH_SYSTEM = "underfloor_heating"
-SZ_UFH_CTL = DEV_TYPE_MAP[DEV_TYPE.UFC]  # ufh_controller
-SZ_CIRCUITS = "circuits"
+SZ_UFH_SYSTEM: Final = "underfloor_heating"
+SZ_UFH_CTL = DEV_TYPE_MAP[DevType.UFC]  # ufh_controller
+SZ_CIRCUITS: Final = "circuits"
 
 HEAT_ZONES_STRS = tuple(ZON_ROLE_MAP[t] for t in ZON_ROLE_MAP.HEAT_ZONES)
 
@@ -109,7 +114,7 @@ def ErrorRenamedKey(new_key: str) -> Callable[[Any], None]:
 
 
 #
-# 1/5: Schemas for CH/DHW systems, aka Heat/TCS (temp control systems)
+# 1/7: Schemas for CH/DHW systems, aka Heat/TCS (temp control systems)
 SCH_TCS_SYS_CLASS = (SystemType.EVOHOME, SystemType.HOMETRONICS, SystemType.SUNDIAL)
 SCH_TCS_SYS = vol.Schema(
     {
@@ -117,7 +122,6 @@ SCH_TCS_SYS = vol.Schema(
             None, SCH_DEVICE_ID_APP
         ),
         vol.Optional("heating_control"): ErrorRenamedKey(SZ_APPLIANCE_CONTROL),
-        # vol.Optional(SZ_CLASS, default=SystemType.EVOHOME): vol.Any(*SCH_TCS_SYS_CLASS),
     },
     extra=vol.PREVENT_EXTRA,
 )
@@ -134,8 +138,8 @@ SCH_TCS_DHW = vol.Schema(
 
 _CH_TCS_UFH_CIRCUIT = vol.Schema(
     {
-        vol.Required(SCH_UFH_IDX): vol.Any(
-            {vol.Optional(SZ_ZONE_IDX): vol.Any(SCH_ZON_IDX)},
+        vol.Required(SCH_UFH_IDX): vol.Schema(
+            {vol.Optional(SZ_ZONE_IDX): SCH_ZON_IDX},
         ),
     },
     extra=vol.PREVENT_EXTRA,
@@ -163,7 +167,7 @@ SCH_TCS_ZONES_ZON = vol.Schema(
         vol.Optional(SZ_ZONE_TYPE): ErrorRenamedKey(SZ_CLASS),
         vol.Optional("zone_sensor"): ErrorRenamedKey(SZ_SENSOR),
         # vol.Optional(SZ_SENSOR_FAKED): bool,
-        vol.Optional(f"_{SZ_NAME}"): vol.Any(str, None),
+        vol.Optional(f"_{SZ_NAME}"): vol.Any(None, str),
     },
     extra=vol.PREVENT_EXTRA,
 )
@@ -178,8 +182,8 @@ SCH_TCS = vol.Schema(
         vol.Optional(SZ_SYSTEM, default={}): vol.Any({}, SCH_TCS_SYS),
         vol.Optional(SZ_DHW_SYSTEM, default={}): vol.Any({}, SCH_TCS_DHW),
         vol.Optional(SZ_UFH_SYSTEM, default={}): vol.Any({}, SCH_TCS_UFH),
-        vol.Optional(SZ_ORPHANS, default=[]): vol.Any(
-            [], vol.Unique([SCH_DEVICE_ID_ANY])
+        vol.Optional(SZ_ORPHANS, default=[]): vol.All(
+            [SCH_DEVICE_ID_ANY], vol.Unique()
         ),
         vol.Optional(SZ_ZONES, default={}): vol.Any({}, SCH_TCS_ZONES),
         vol.Optional(vol.Remove("is_tcs")): vol.Coerce(bool),
@@ -189,17 +193,19 @@ SCH_TCS = vol.Schema(
 
 
 #
-# 2/5: Schemas for Ventilation control systems, aka HVAC/VCS
-SZ_REMOTES = "remotes"
-SZ_SENSORS = "sensors"
+# 2/7: Schemas for Ventilation control systems, aka HVAC/VCS
+SZ_REMOTES: Final = "remotes"
+SZ_SENSORS: Final = "sensors"
 
 SCH_VCS_DATA = vol.Schema(
     {
-        vol.Optional(SZ_REMOTES, default=[]): vol.Any(
-            [], vol.Unique([SCH_DEVICE_ID_ANY])
+        vol.Optional(SZ_REMOTES, default=[]): vol.All(
+            [SCH_DEVICE_ID_ANY],
+            vol.Unique(),  # vol.Length(min=1)
         ),
-        vol.Optional(SZ_SENSORS, default=[]): vol.Any(
-            [], vol.Unique([SCH_DEVICE_ID_ANY])
+        vol.Optional(SZ_SENSORS, default=[]): vol.All(
+            [SCH_DEVICE_ID_ANY],
+            vol.Unique(),  # vol.Length(min=1)
         ),
         vol.Optional(vol.Remove("is_vcs")): vol.Coerce(bool),
     },
@@ -221,37 +227,33 @@ SCH_VCS = vol.All(SCH_VCS_KEYS, SCH_VCS_DATA)
 
 
 #
-# 3/5: Global Schema for Heat/HVAC systems
+# 3/7: Global Schema for Heat/HVAC systems
 SCH_GLOBAL_SCHEMAS_DICT = {  # System schemas - can be 0-many Heat/HVAC schemas
-    # orphans are devices to create that wont be in a (cached) schema...
+    # orphans are devices to create that won't be in a (cached) schema...
     vol.Optional(SZ_MAIN_TCS): vol.Any(None, SCH_DEVICE_ID_CTL),
     vol.Optional(vol.Remove("main_controller")): vol.Any(None, SCH_DEVICE_ID_CTL),
     vol.Optional(SCH_DEVICE_ID_CTL): vol.Any(SCH_TCS, SCH_VCS),
     vol.Optional(SCH_DEVICE_ID_ANY): SCH_VCS,  # must be after SCH_DEVICE_ID_CTL
-    vol.Optional(SZ_ORPHANS_HEAT): vol.All(
-        vol.Unique([SCH_DEVICE_ID_ANY]), vol.Length(min=0)
-    ),
-    vol.Optional(SZ_ORPHANS_HVAC): vol.All(
-        vol.Unique([SCH_DEVICE_ID_ANY]), vol.Length(min=0)
-    ),
+    vol.Optional(SZ_ORPHANS_HEAT): vol.All([SCH_DEVICE_ID_ANY], vol.Unique()),
+    vol.Optional(SZ_ORPHANS_HVAC): vol.All([SCH_DEVICE_ID_ANY], vol.Unique()),
 }
-
+SCH_GLOBAL_SCHEMAS = vol.Schema(SCH_GLOBAL_SCHEMAS_DICT, extra=vol.PREVENT_EXTRA)
 
 #
-# 4/5: Gateway (parser/state) configuration
-SZ_DISABLE_DISCOVERY = "disable_discovery"
-SZ_ENABLE_EAVESDROP = "enable_eavesdrop"
-SZ_MAX_ZONES = "max_zones"  # TODO: move to TCS-attr from GWY-layer
-SZ_REDUCE_PROCESSING = "reduce_processing"
-SZ_USE_ALIASES = "use_aliases"  # use friendly device names from known_list
-SZ_USE_NATIVE_OT = "use_native_ot"  # favour OT (3220s) over RAMSES
-
-SCH_GATEWAY_DICT = SCH_ENGINE_DICT | {
+# 4/7: Gateway (parser/state) configuration
+SZ_DISABLE_DISCOVERY: Final = "disable_discovery"
+SZ_ENABLE_EAVESDROP: Final = "enable_eavesdrop"
+SZ_MAX_ZONES: Final = "max_zones"  # TODO: move to TCS-attr from GWY-layer
+SZ_REDUCE_PROCESSING: Final = "reduce_processing"
+SZ_USE_ALIASES: Final = "use_aliases"  # use friendly device names from known_list
+SZ_USE_NATIVE_OT: Final = "use_native_ot"  # favour OT (3220s) over RAMSES
+
+SCH_GATEWAY_DICT = {
     vol.Optional(SZ_DISABLE_DISCOVERY, default=False): bool,
     vol.Optional(SZ_ENABLE_EAVESDROP, default=False): bool,
     vol.Optional(SZ_MAX_ZONES, default=DEFAULT_MAX_ZONES): vol.All(
         int, vol.Range(min=1, max=16)
-    ),  # TODO: no default
+    ),  # NOTE: no default
     vol.Optional(SZ_REDUCE_PROCESSING, default=0): vol.All(
         int, vol.Range(min=0, max=DONT_CREATE_MESSAGES)
     ),
@@ -260,40 +262,46 @@ SCH_GATEWAY_DICT = SCH_ENGINE_DICT | {
         "always", "prefer", "avoid", "never"
     ),
 }
+SCH_GATEWAY_CONFIG = vol.Schema(SCH_GATEWAY_DICT, extra=vol.REMOVE_EXTRA)
 
 
 #
-# 5/5: the Global (gateway) Schema
-SZ_CONFIG = "config"
-
-SCH_GLOBAL_CONFIG = vol.All(
+# 5/7: the Global (gateway) Schema
+SCH_GLOBAL_CONFIG = (
     vol.Schema(
         {
-            # Gateway/engine Configuraton, incl. packet_log, serial_port params...
-            vol.Optional(SZ_CONFIG, default={}): SCH_GATEWAY_DICT
+            # Gateway/engine Configuration, incl. packet_log, serial_port params...
+            vol.Optional(SZ_CONFIG, default={}): SCH_GATEWAY_DICT | SCH_ENGINE_DICT
         },
         extra=vol.PREVENT_EXTRA,
     )
     .extend(SCH_GLOBAL_SCHEMAS_DICT)
     .extend(SCH_GLOBAL_TRAITS_DICT)
-    .extend(sch_packet_log_dict_factory(default_backups=0)),
+    .extend(sch_packet_log_dict_factory(default_backups=0))
 )
 
 
 #
-# 6/5: External Schemas, to be used by clients of this library
-def NormaliseRestoreCache():
-    def normalise_restore_cache(node_value) -> None:
-        if not isinstance(node_value, bool):
+# 6/7: External Schemas, to be used by clients of this library
+def NormaliseRestoreCache() -> Callable[[bool | dict[str, bool]], dict[str, bool]]:
+    """Convert a short-hand restore_cache bool to a dict.
+
+    restore_cache: bool ->  restore_cache:
+                              restore_schema: bool
+                              restore_state: bool
+    """
+
+    def normalise_restore_cache(node_value: bool | dict[str, bool]) -> dict[str, bool]:
+        if isinstance(node_value, dict):
             return node_value
         return {SZ_RESTORE_SCHEMA: node_value, SZ_RESTORE_STATE: node_value}
 
     return normalise_restore_cache
 
 
-SZ_RESTORE_CACHE = "restore_cache"
-SZ_RESTORE_SCHEMA = "restore_schema"
-SZ_RESTORE_STATE = "restore_state"
+SZ_RESTORE_CACHE: Final = "restore_cache"
+SZ_RESTORE_SCHEMA: Final = "restore_schema"
+SZ_RESTORE_STATE: Final = "restore_state"
 
 SCH_RESTORE_CACHE_DICT = {
     vol.Optional(SZ_RESTORE_CACHE, default=True): vol.Any(
@@ -309,91 +317,20 @@ SCH_RESTORE_CACHE_DICT = {
 
 
 #
-# 6/5: Other stuff
-def extract_schema(**kwargs) -> dict:
-    """Return the schema embedded with a global configuration."""
-    return {
-        k: v
-        for k, v in kwargs.items()
-        if DEVICE_ID_REGEX.ANY.match(k)
-        or k in (SZ_MAIN_TCS, SZ_ORPHANS_HEAT, SZ_ORPHANS_HVAC)
-    }
-
-    # def extract_config(**kwargs) -> dict:
-    #     """Return the config embedded with a global configuration."""
-    #     return {
-    #         k: v
-    #         for k, v in kwargs.items()
-    #         if not DEVICE_ID_REGEX.ANY.match(k) and k not in (
-    #             SZ_MAIN_TCS, SZ_ORPHANS_HEAT, SZ_ORPHANS_HVAC
-    #         )
-    #     }
-
-    # def split_configuration(**kwargs) -> tuple[dict, dict]:
-    #     """Split a global configuration into non-schema (config) & schema."""
-    #     return extract_config(**kwargs), extract_schema(**kwargs),
-
-    pass
-
-
-def load_config(
-    port_name: None | str,
-    input_file: TextIO,
-    config: dict[str, Any] = None,
-    packet_log: None | dict[str, Any] = None,
-    block_list: dict[_DeviceIdT, dict] = None,
-    known_list: dict[_DeviceIdT, dict] = None,
-    **schema,
-) -> tuple[SimpleNamespace, dict, dict, dict]:
-    """Process the configuration, including any filter lists.
-
-    Returns:
-     - config (includes config.enforce_known_list)
-     - schema (processed further later on)
-     - known_list (is a dict)
-     - block_list (is a dict)
-    """
-
-    if port_name and input_file:
-        _LOGGER.warning(
-            "Serial port was specified (%s), so input file (%s) will be ignored",
-            port_name,
-            input_file,
-        )
-    elif port_name is None:
-        config[SZ_DISABLE_SENDING] = True
-
-    if config[SZ_DISABLE_SENDING]:
-        config[SZ_DISABLE_DISCOVERY] = True
-
-    if config[SZ_ENABLE_EAVESDROP]:
-        _LOGGER.warning(
-            f"{SZ_ENABLE_EAVESDROP} enabled: this is strongly discouraged"
-            " for routine use (there be dragons here)"
-        )
-
-    config[SZ_ENFORCE_KNOWN_LIST] = select_device_filter_mode(
-        config[SZ_ENFORCE_KNOWN_LIST], known_list, block_list
-    )
-
-    config[SZ_PACKET_LOG] = packet_log
-
-    # assert schema == extract_schema(**schema)
-
-    return (SimpleNamespace(**config), schema, known_list, block_list)
+# 7/7: Other stuff
+def _get_device(gwy: Gateway, dev_id: DeviceIdT, **kwargs: Any) -> Device:  # , **traits
+    """Get a device from the gateway.
 
-
-def _get_device(gwy, dev_id: str, **kwargs) -> Any:  # Device
-    """Raise an LookupError if a device_id is filtered out by a list.
+    Raise a LookupError if a device_id is filtered out by a list.
 
     The underlying method is wrapped only to provide a better error message.
     """
 
-    def check_filter_lists(dev_id: str) -> None:
+    def check_filter_lists(dev_id: DeviceIdT) -> None:
         """Raise an LookupError if a device_id is filtered out by a list."""
 
         err_msg = None
-        if gwy.config.enforce_known_list and dev_id not in gwy._include:
+        if gwy._enforce_known_list and dev_id not in gwy._include:
             err_msg = f"it is in the {SZ_SCHEMA}, but not in the {SZ_KNOWN_LIST}"
         if dev_id in gwy._exclude:
             err_msg = f"it is in the {SZ_SCHEMA}, but also in the {SZ_BLOCK_LIST}"
@@ -408,29 +345,46 @@ def _get_device(gwy, dev_id: str, **kwargs) -> Any:  # Device
     return gwy.get_device(dev_id, **kwargs)
 
 
-def load_schema(gwy, **kwargs) -> None:
-    """Process the schema, and the configuration and return True if it is valid."""
+def load_schema(
+    gwy: Gateway, known_list: dict[DeviceIdT, Any] | None = None, **schema: Any
+) -> None:
+    """Instantiate all entities in the schema, and faked devices in the known_list."""
+
+    from .device import Fakeable  # circular import
+
+    known_list = known_list or {}
+
+    # schema: dict = SCH_GLOBAL_SCHEMAS_DICT(schema)
 
     [
-        load_tcs(gwy, ctl_id, schema)
-        for ctl_id, schema in kwargs.items()
+        load_tcs(gwy, ctl_id, schema)  # type: ignore[arg-type]
+        for ctl_id, schema in schema.items()
         if re.match(DEVICE_ID_REGEX.ANY, ctl_id) and SZ_REMOTES not in schema
     ]
-    if kwargs.get(SZ_MAIN_TCS):
-        gwy._tcs = gwy.system_by_id.get(kwargs[SZ_MAIN_TCS])
+    if schema.get(SZ_MAIN_TCS):
+        gwy._tcs = gwy.system_by_id.get(schema[SZ_MAIN_TCS])
     [
-        load_fan(gwy, fan_id, schema)
-        for fan_id, schema in kwargs.items()
+        load_fan(gwy, fan_id, schema)  # type: ignore[arg-type]
+        for fan_id, schema in schema.items()
         if re.match(DEVICE_ID_REGEX.ANY, fan_id) and SZ_REMOTES in schema
     ]
     [  # NOTE: class favoured, domain ignored
         _get_device(gwy, device_id)  # domain=key[-4:])
         for key in (SZ_ORPHANS_HEAT, SZ_ORPHANS_HVAC)
-        for device_id in kwargs.get(key, [])
+        for device_id in schema.get(key, [])
     ]  # TODO: pass domain (Heat/HVAC), or generalise to SZ_ORPHANS
 
+    # create any devices in the known list that are faked, or fake those already created
+    for device_id, traits in known_list.items():
+        if traits.get(SZ_FAKED):
+            dev = _get_device(gwy, device_id)  # , **traits)
+            if not isinstance(dev, Fakeable):
+                raise exc.SystemSchemaInconsistent(f"Device is not fakeable: {dev}")
+            if not dev.is_faked:
+                dev._make_fake()
+
 
-def load_fan(gwy, fan_id: str, schema: dict) -> Any:  # Device
+def load_fan(gwy: Gateway, fan_id: DeviceIdT, schema: dict[str, Any]) -> Device:
     """Create a FAN using its schema (i.e. with remotes, sensors)."""
 
     fan = _get_device(gwy, fan_id)
@@ -439,27 +393,27 @@ def load_fan(gwy, fan_id: str, schema: dict) -> Any:  # Device
     return fan
 
 
-def load_tcs(gwy, ctl_id: str, schema: dict) -> Any:  # System
+def load_tcs(gwy: Gateway, ctl_id: DeviceIdT, schema: dict[str, Any]) -> Evohome:
     """Create a TCS using its schema."""
     # print(schema)
     # schema = SCH_TCS_ZONES_ZON(schema)
 
     ctl = _get_device(gwy, ctl_id)
-    ctl.tcs._update_schema(**schema)  # TODO
+    ctl.tcs._update_schema(**schema)
 
-    for dev_id in schema.get(SZ_UFH_SYSTEM, {}).keys():  # UFH controllers
+    for dev_id in schema.get(SZ_UFH_SYSTEM, {}):  # UFH controllers
         _get_device(gwy, dev_id, parent=ctl.tcs)  # , **_schema)
 
     for dev_id in schema.get(SZ_ORPHANS, []):
         _get_device(gwy, dev_id, parent=ctl)
 
-    if False and DEV_MODE:
-        import json
+    # if DEV_MODE:
+    #     import json
 
-        src = json.dumps(shrink(schema), sort_keys=True)
-        dst = json.dumps(shrink(gwy.system_by_id[ctl.id].schema), sort_keys=True)
-        # assert dst == src, "They don't match!"
-        print(src)
-        print(dst)
+    #     src = json.dumps(shrink(schema), sort_keys=True)
+    #     dst = json.dumps(shrink(gwy.system_by_id[ctl.id].schema), sort_keys=True)
+    #     # assert dst == src, "They don't match!"
+    #     print(src)
+    #     print(dst)
 
     return ctl.tcs