zwave-js-server-python 0.35.0__py3-none-any.whl → 0.35.1__py3-none-any.whl

zwave_js_server/event.py

@@ -57,7 +57,7 @@ class EventBase:
 
     def emit(self, event_name: str, data: dict) -> None:
         """Run all callbacks for an event."""
-        for listener in self._listeners.get(event_name, []):
+        for listener in self._listeners.get(event_name, []).copy():
             listener(data)
 
     def _handle_event_protocol(self, event: Event) -> None:

zwave_js_server/model/device_config.py

@@ -3,7 +3,7 @@ Model for a Zwave Node's device config.
 
 https://zwave-js.github.io/node-zwave-js/#/api/node?id=deviceconfig
 """
-from typing import Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from ..const import TYPING_EXTENSION_FOR_TYPEDDICT_REQUIRED
 
@@ -138,7 +138,7 @@ class DeviceConfigDataType(TypedDict, total=False):
     paramInformation: Dict[str, dict]
     supportsZWavePlus: bool
     proprietary: dict
-    compat: Dict[str, dict]
+    compat: Dict[str, Any]
     metadata: DeviceMetadataDataType
     isEmbedded: bool
 

{zwave_js_server_python-0.35.0.dist-info → zwave_js_server_python-0.35.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zwave-js-server-python
-Version: 0.35.0
+Version: 0.35.1
 Summary: Python wrapper for zwave-js-server
 Home-page: https://github.com/home-assistant-libs/zwave-js-server-python
 Author: Home Assistant Team

{zwave_js_server_python-0.35.0.dist-info → zwave_js_server_python-0.35.1.dist-info}/RECORD

@@ -1,11 +1,8 @@
-scripts/__init__.py,sha256=-eA0KPzIlF2qFKS5muKslF9AS1Bygp7zgmzrx9Yc0-o,22
-scripts/generate_multilevel_sensor_constants.py,sha256=_v-ul_JCa0GhEYjXAcANA1w9X-_9UC0LDRf-13OtGTA,8114
-scripts/run_mock_server.py,sha256=LQLmXH7IY4KLxkgYNXBD8wmDMsYywJ2KIl2pdnptrIA,13720
 zwave_js_server/__init__.py,sha256=Ey3O4Tha56uU-M92oLJmQHupCJ7B9oZmxlQTo8pGUM8,45
 zwave_js_server/__main__.py,sha256=1gWC927sa3FwcA47ndmrRWW0HlfYVdiUarjEsccRF2k,3624
 zwave_js_server/client.py,sha256=5t1c0xI9dokP8IOR01uMAk5oxMylAp91hTlJPkMEtRE,14827
 zwave_js_server/dump.py,sha256=hTyeW8fPleyQyYyPjFeR_JxwmFRHvtpmpn1L9uNpfiw,1213
-zwave_js_server/event.py,sha256=u51M7Oow5Tt3DlNlJq16_C5g_zAV3_P445qfsOAjQMA,1951
+zwave_js_server/event.py,sha256=E2bIEb635al9MsCB5rkk3ZklU4-YkmqmXtifzlbxXaQ,1958
 zwave_js_server/exceptions.py,sha256=MaCynJuy2JkXA7FW_tpdpIokiHJuFoLwxktPSey5iBA,5402
 zwave_js_server/firmware.py,sha256=F5selNpOWWICuLs3L8zBjddnGKrEmip7LriijjL9pDA,878
 zwave_js_server/version.py,sha256=RDFP2kSU3cCVIQbgMWggdeDnvhtVsZzzZg9pOjH7CC8,364
@@ -29,7 +26,7 @@ zwave_js_server/model/__init__.py,sha256=XfyKH8lxZ3CB7CbRkOr5sR-eV0GrklZiBtNPmln
 zwave_js_server/model/association.py,sha256=FsgKAha7mw6dpk7u7zdQoNEajTyiL0S5eOYcY4M2Rx4,529
 zwave_js_server/model/command_class.py,sha256=pb_aXIl1_r9iHzdEyRr300y5xu62uE6GzmF6540CQd4,1256
 zwave_js_server/model/device_class.py,sha256=KpSM101bGa_3Mig4C-_rkE4CzqImK2JPIUtlG-TFcvU,1886
-zwave_js_server/model/device_config.py,sha256=PfwyGakw82VcET7ERlARykFDZsslRXCKYfQfkxddjI0,6655
+zwave_js_server/model/device_config.py,sha256=7NaMa4BZ5tGe2p0YtOQFIUjBwRVF7GYWVExLwAgIUtE,6659
 zwave_js_server/model/driver.py,sha256=dwbLNWdzKQa50191zWMP9duZVag0Ns4FnGLi8lTwxCE,6022
 zwave_js_server/model/endpoint.py,sha256=DwthJmJ9vw6jmCFowykaAtutK-hO5qBO7EkkEcKtSFg,5153
 zwave_js_server/model/firmware.py,sha256=0AlV2mbjlmejV1eh0oHCUU-2Ysyec9a0X9BTvHG3wYs,2493
@@ -57,9 +54,9 @@ zwave_js_server/util/node.py,sha256=KUg-Z-7hdDLGKKCYLktc4oOgiPbDT7ZUYqUH_IPLwO4,
 zwave_js_server/util/command_class/__init__.py,sha256=sRxti47ekLTzfk8B609CMQumIbcD6mon2ZS0zwh9omY,59
 zwave_js_server/util/command_class/meter.py,sha256=Qkif1ul4KpV_k6Dc7yNXlSjlJLLTH8mCitgQk9J9W0A,1277
 zwave_js_server/util/command_class/multilevel_sensor.py,sha256=p92YLNRze5z3UWhfIDJO95F-j5tqx1PKUG9oamo9Dng,1446
-zwave_js_server_python-0.35.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-zwave_js_server_python-0.35.0.dist-info/METADATA,sha256=4N1uE0C6DV_sjtNiC10CbmXKk4NDDIfBLl-xqIWmYkE,1712
-zwave_js_server_python-0.35.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-zwave_js_server_python-0.35.0.dist-info/entry_points.txt,sha256=_8Swg1yhKiBElo6k1fxIEd6E8uPz8PDxQpwQoZ29FZE,74
-zwave_js_server_python-0.35.0.dist-info/top_level.txt,sha256=v0ZjpwAaM9UZi0qaqAo3mwTHhQM-pMf3STb_iJX2Eyc,24
-zwave_js_server_python-0.35.0.dist-info/RECORD,,
+zwave_js_server_python-0.35.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+zwave_js_server_python-0.35.1.dist-info/METADATA,sha256=-Hgzn0O6X8Fcc3h6qWVLPnhaODmfOCSFUU4MBfv2k1U,1712
+zwave_js_server_python-0.35.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+zwave_js_server_python-0.35.1.dist-info/entry_points.txt,sha256=_8Swg1yhKiBElo6k1fxIEd6E8uPz8PDxQpwQoZ29FZE,74
+zwave_js_server_python-0.35.1.dist-info/top_level.txt,sha256=-hwsl-i4Av5Op_yfOHC_OP56KPmzp_iVEkeohRIN5Ng,16
+zwave_js_server_python-0.35.1.dist-info/RECORD,,

{zwave_js_server_python-0.35.0.dist-info → zwave_js_server_python-0.35.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
-scripts
 zwave_js_server

scripts/__init__.py

@@ -1 +0,0 @@
-"""Scripts module."""

scripts/generate_multilevel_sensor_constants.py

@@ -1,245 +0,0 @@
-"""Script to generate Multilevel Sensor CC constants."""
-from __future__ import annotations
-
-import json
-import pathlib
-import re
-import subprocess
-from collections import defaultdict
-from typing import Callable, List
-
-import requests
-from slugify import slugify
-
-GITHUB_PROJECT = "zwave-js/node-zwave-js"
-BRANCH_NAME = "master"
-SENSOR_TYPES_FILE_PATH = "packages/config/config/sensorTypes.json"
-DEFAULT_SCALES_FILE_PATH = "packages/config/config/scales.json"
-
-CONST_FILE_PATH = pathlib.Path(__file__).parent.joinpath(
-    "../zwave_js_server/const/command_class/multilevel_sensor.py"
-)
-
-
-def remove_comments(text: str) -> str:
-    """Remove comments from a JSON string."""
-    return "\n".join(
-        line for line in text.split("\n") if not line.strip().startswith("//")
-    )
-
-
-def remove_paranthesis(text: str) -> str:
-    """Remove text in paranethesis from a string."""
-    return re.sub(r"\([^)]*\)", "", text)
-
-
-def enum_name_format(name: str, should_remove_paranthesis: bool) -> str:
-    """Convert sensor/scale name to enum format."""
-    if should_remove_paranthesis:
-        name = remove_paranthesis(name)
-    return slugify(name, separator="_").upper()
-
-
-def normalize_name(name: str) -> str:
-    """Convert a sensor/scale name into a normalized name."""
-    return enum_name_format(name, True).replace("_", " ").title()
-
-
-def format_for_class_name(name: str) -> str:
-    """Convert sensor/scale name to class name format."""
-    return f"{normalize_name(name).replace(' ', '')}Scale"
-
-
-def normalize_scale_definition(scale_definitions: dict[str, dict]) -> dict[str, int]:
-    """Convert a scales definition dictionary into a normalized dictionary."""
-    scale_def_ = {}
-    for scale_id, scale_props in scale_definitions.items():
-        scale_id = int(scale_id, 16)
-        scale_name_ = enum_name_format(scale_props["label"], True)
-        scale_def_[scale_name_] = scale_id
-
-    return dict(sorted(scale_def_.items(), key=lambda kv: kv[0]))
-
-
-sensor_types = json.loads(
-    remove_comments(
-        requests.get(
-            (
-                f"https://raw.githubusercontent.com/{GITHUB_PROJECT}/{BRANCH_NAME}/"
-                f"{SENSOR_TYPES_FILE_PATH}"
-            )
-        ).text
-    )
-)
-default_scales = json.loads(
-    remove_comments(
-        requests.get(
-            (
-                f"https://raw.githubusercontent.com/{GITHUB_PROJECT}/{BRANCH_NAME}/"
-                f"{DEFAULT_SCALES_FILE_PATH}"
-            )
-        ).text
-    )
-)
-
-scales = {
-    normalize_name(scale_name): normalize_scale_definition(scale_def)
-    for scale_name, scale_def in default_scales.items()
-}
-
-sensors = {}
-for sensor_id, sensor_props in sensor_types.items():
-    sensor_id = int(sensor_id, 16)
-    scale_def = sensor_props["scales"]
-    remove_paranthesis_ = True
-    if sensor_id in (87, 88):
-        remove_paranthesis_ = False
-    sensor_name = enum_name_format(sensor_props["label"], remove_paranthesis_)
-    sensors[sensor_name] = {"id": sensor_id}
-    if isinstance(scale_def, str):
-        sensors[sensor_name]["scale"] = normalize_name(
-            scale_def.replace("$SCALES:", "")
-        )
-    else:
-        scales[sensor_name] = normalize_scale_definition(scale_def)
-        sensors[sensor_name]["scale"] = normalize_name(sensor_name)
-
-scales = dict(sorted(scales.items(), key=lambda kv: kv[0]))
-sensors = dict(sorted(sensors.items(), key=lambda kv: kv[0]))
-
-
-def generate_int_enum_class_definition(
-    class_name: str,
-    enum_dict: dict[str, str | dict],
-    enum_ref_url: str | None = None,
-    get_id_func: Callable | None = None,
-    docstring_info: str = "",
-) -> List[str]:
-    """Generate an IntEnum class definition as an array of lines of string."""
-    class_def = []
-    class_def.append(f"class {class_name}(IntEnum):")
-    docstring = (
-        f'"""Enum for known {docstring_info} multilevel sensor types."""'.replace(
-            "  ", " "
-        )
-    )
-    class_def.append(f"    {docstring}")
-    if enum_ref_url:
-        class_def.append(f"    # {enum_ref_url}")
-    for enum_name, enum_id in enum_dict.items():
-        if get_id_func:
-            enum_id = get_id_func(enum_id)
-        class_def.append(f"    {enum_name} = {enum_id}")
-    return class_def
-
-
-SENSOR_TYPE_URL = (
-    f"https://github.com/{GITHUB_PROJECT}/blob/{BRANCH_NAME}/{SENSOR_TYPES_FILE_PATH}"
-)
-
-lines = [
-    '"""Constants for the Multilevel Sensor CC."""',
-    "",
-    "# ----------------------------------------------------------------------------------- #",
-    "# **BEGINNING OF AUTOGENERATED CONTENT** (TO ADD ADDITIONAL MANUAL CONTENT, LOOK FOR  #",
-    '# THE "END OF AUTOGENERATED CONTENT" COMMENT BLOCK AND ADD YOUR CODE BELOW IT)        #',
-    "# ----------------------------------------------------------------------------------- #",
-    "",
-    "from enum import IntEnum",
-    "from typing import Dict, Set, Type, Union",
-    'CC_SPECIFIC_SCALE = "scale"',
-    'CC_SPECIFIC_SENSOR_TYPE = "sensorType"',
-]
-
-lines.extend(
-    generate_int_enum_class_definition(
-        "MultilevelSensorType",
-        sensors,
-        SENSOR_TYPE_URL,
-        get_id_func=lambda x: x["id"],
-    )
-)
-
-unit_name_to_enum_map = defaultdict(list)
-for scale_name, scale_dict in scales.items():
-    lines.extend(
-        generate_int_enum_class_definition(
-            format_for_class_name(scale_name),
-            scale_dict,
-            SENSOR_TYPE_URL,
-            docstring_info=f"scales for {scale_name}",
-        )
-    )
-    for unit_name in scale_dict.keys():
-        unit_name_to_enum_map[unit_name].append(
-            f"{format_for_class_name(scale_name)}.{unit_name}"
-        )
-unit_name_to_enum_map = dict(
-    sorted(unit_name_to_enum_map.items(), key=lambda kv: kv[0])
-)
-for unit_name, enum_list in unit_name_to_enum_map.items():
-    unit_name_to_enum_map[unit_name] = sorted(enum_list)
-
-scale_class_names = [format_for_class_name(scale_name) for scale_name in scales]
-lines.extend(
-    [f"MultilevelSensorScaleType = Union[{', '.join(sorted(scale_class_names))}]", ""]
-)
-
-multilevel_sensor_type_to_scale_map_line = (
-    "MULTILEVEL_SENSOR_TYPE_TO_SCALE_MAP: Dict[MultilevelSensorType, "
-    "Type[MultilevelSensorScaleType]] = {"
-)
-for sensor_name, sensor_def in sensors.items():
-    multilevel_sensor_type_to_scale_map_line += (
-        f"    MultilevelSensorType.{sensor_name}: "
-        f"{format_for_class_name(sensor_def['scale'])},"
-    )
-multilevel_sensor_type_to_scale_map_line += "}"
-lines.append(multilevel_sensor_type_to_scale_map_line)
-lines.append("")
-
-for unit_name, unit_enums in unit_name_to_enum_map.items():
-    lines.append(
-        f"UNIT_{unit_name}: Set[MultilevelSensorScaleType] = {{{','.join(sorted(unit_enums))}}}"
-    )
-
-lines.extend(
-    [
-        "",
-        "# ----------------------------------------------------------------------------------- #",
-        "# **END OF AUTOGENERATED CONTENT** (DO NOT EDIT/REMOVE THIS COMMENT BLOCK AND DO NOT  #",
-        "# EDIT ANYTHING ABOVE IT. IF A NEW IMPORT IS NEEDED, UPDATE THE LINES AROUND 135      #",
-        "# IN scripts/generate_multilevel_sensor_constants.py THEN RE-RUN THE SCRIPT. ALL      #",
-        "# LINES WRITTEN BELOW THIS BLOCK WILL BE PRESERVED AS LONG AS THIS BLOCK REMAINS)     #",
-        "# ----------------------------------------------------------------------------------- #",
-        "",
-    ]
-)
-
-existing_const_file = CONST_FILE_PATH.read_text(encoding="utf-8").splitlines()
-
-manually_written_code_start_idx = (
-    next(
-        i
-        for i, line in enumerate(existing_const_file)
-        if "**END OF AUTOGENERATED CONTENT**" in line
-    )
-    + 6
-)
-if len(existing_const_file) > manually_written_code_start_idx:
-    lines.extend(
-        [
-            line.strip("\n")
-            for line in existing_const_file[manually_written_code_start_idx:]
-        ]
-    )
-
-CONST_FILE_PATH.write_text("\n".join(lines), encoding="utf-8")
-
-if subprocess.run(["which", "black"], capture_output=True, check=True).stdout:
-    subprocess.run(
-        ["black", CONST_FILE_PATH],
-        check=True,
-    )
-else:
-    print("Could not run black on new file, please run it to properly format it.")

scripts/run_mock_server.py

@@ -1,385 +0,0 @@
-"""Run a mock zwave-js-server instance off of a network state dump."""
-import argparse
-import asyncio
-import json
-import logging
-from collections import defaultdict
-from collections.abc import Hashable
-from typing import Any, DefaultDict, List, Optional, Union
-
-from aiohttp import WSMsgType, web, web_request
-
-from zwave_js_server.client import SIZE_PARSE_JSON_EXECUTOR
-from zwave_js_server.const import MAX_SERVER_SCHEMA_VERSION, MIN_SERVER_SCHEMA_VERSION
-from zwave_js_server.model.version import VersionInfoDataType
-
-DATEFMT = "%Y-%m-%d %H:%M:%S"
-FMT = "%(asctime)s [%(levelname)s] %(message)s"
-
-
-class ExitException(Exception):
-    """Represent an exit error."""
-
-
-# https://stackoverflow.com/a/1151686
-class HashableDict(dict):
-    """Dictionary that can be used as a key in a dictionary."""
-
-    def __key(self) -> tuple:
-        return tuple((k, self[k]) for k in sorted(self))
-
-    def __hash__(self) -> int:  # type: ignore
-        return hash(self.__key())
-
-    def __eq__(self, other: Any) -> bool:
-        # pylint: disable=protected-access
-        return isinstance(other, HashableDict) and self.__key() == other.__key()
-
-
-class MockZwaveJsServer:
-    """
-    Class to represent a mock zwave-js-server instance.
-
-    The last client that connected to the server will be the one that receives ws msgs.
-    """
-
-    def __init__(
-        self,
-        network_state_dump: List[dict],
-        events_to_replay: List[dict],
-        command_results: DefaultDict[HashableDict, list],
-    ) -> None:
-        """Initialize class."""
-        self.network_state_dump = network_state_dump
-        self.app = web.Application()
-        self.app.add_routes(
-            [
-                web.get("/", self.server_handler),
-                web.post("/replay", self.replay_handler),
-            ]
-        )
-        self.primary_ws_resp: Optional[web.WebSocketResponse] = None
-        self.events_to_replay = events_to_replay
-        self.command_results = command_results
-
-    async def send_json(self, data: dict) -> None:
-        """Send JSON."""
-        logging.debug("Sending JSON: %s", data)
-        assert self.primary_ws_resp is not None
-        await self.primary_ws_resp.send_json(data)
-
-    async def send_command_result(
-        self,
-        data: dict,
-        message_id: str,
-    ) -> None:
-        """Send message."""
-        await self.send_json({**data, "messageId": message_id})
-
-    async def send_success_command_result(
-        self,
-        result: Optional[dict],
-        message_id: str,
-    ) -> None:
-        """Send success message."""
-        if result is None:
-            result = {}
-        await self.send_command_result(
-            {"result": result, "type": "result", "success": True}, message_id
-        )
-
-    async def process_record(self, record: dict) -> None:
-        """Process a replay dump record."""
-        if record.get("record_type") not in ("event", "command"):
-            raise TypeError(f"Malformed record: {record}")
-        if record["record_type"] == "event":
-            await self.send_json(record["data"])
-        else:
-            add_command_result(self.command_results, record)
-
-    async def server_handler(
-        self, request: web_request.Request
-    ) -> web.WebSocketResponse:
-        """Handle websocket requests to the server."""
-        ws_resp = web.WebSocketResponse(autoclose=False)
-        self.primary_ws_resp = ws_resp
-        await ws_resp.prepare(request)
-
-        version_info: VersionInfoDataType = self.network_state_dump[0]
-        # adjust min/max schemas if needed to get things to work
-        if MAX_SERVER_SCHEMA_VERSION > version_info["maxSchemaVersion"]:
-            version_info["maxSchemaVersion"] = MAX_SERVER_SCHEMA_VERSION
-        if MIN_SERVER_SCHEMA_VERSION < version_info["minSchemaVersion"]:
-            version_info["minSchemaVersion"] = MIN_SERVER_SCHEMA_VERSION
-        await self.send_json(version_info)
-
-        async for msg in ws_resp:
-            if msg.type == WSMsgType.TEXT:
-                logging.debug("Message received: %s", msg.data)
-                if msg.data == "close":
-                    await ws_resp.close()
-                elif msg.data == "error":
-                    logging.warning("Error from client: %s", msg.data)
-
-                try:
-                    if len(msg.data) > SIZE_PARSE_JSON_EXECUTOR:
-                        data: dict = await asyncio.get_event_loop().run_in_executor(
-                            None, msg.json
-                        )
-                    else:
-                        data = msg.json()
-                except ValueError as err:
-                    raise ExitException(f"Received invalid JSON {msg.data}") from err
-
-                if "command" not in data:
-                    raise ExitException(f"Malformed message: {data}")
-
-                cmd = data["command"]
-                message_id = data["messageId"]
-                if cmd == "set_api_schema":
-                    await self.send_json(self.network_state_dump[1])
-                elif cmd == "driver.get_log_config":
-                    await self.send_success_command_result(
-                        {
-                            "config": {
-                                "enabled": True,
-                                "level": "silly",
-                                "logToFile": False,
-                                "nodeFilter": [],
-                                "filename": None,
-                                "forceConsole": False,
-                            }
-                        },
-                        message_id,
-                    )
-                elif cmd == "start_listening":
-                    await self.send_json(self.network_state_dump[2])
-                    await asyncio.sleep(1)
-                    for event in self.events_to_replay:
-                        await self.send_json(event)
-                elif resp_list := self.command_results[sanitize_msg(data)]:
-                    await self.send_command_result(resp_list.pop(0), message_id)
-                else:
-                    raise ExitException(f"Unhandled command received: {data}")
-            elif msg.type == WSMsgType.ERROR:
-                logging.error(
-                    "Connection closed with exception %s",
-                    ws_resp.exception(),
-                )
-
-        logging.info("Connection closed")
-
-        return ws_resp
-
-    async def replay_handler(self, request: web_request.Request) -> web.Response:
-        """Handle requests to replay dump."""
-        try:
-            data = await request.json()
-        except json.decoder.JSONDecodeError:
-            return web.Response(status=400, reason="Invalid JSON.")
-
-        if isinstance(data, list):
-            for record in data:
-                try:
-                    await self.process_record(record)
-                except Exception as err:
-                    return web.Response(status=400, reason=err.args[0])
-        elif isinstance(data, dict):
-            try:
-                await self.process_record(data)
-            except Exception as err:
-                return web.Response(status=400, reason=err.args[0])
-        else:
-            return web.Response(status=400, reason=f"Malformed message: {data}")
-        return web.Response(status=200)
-
-
-def _hashable_value(item: Union[dict, list, Hashable]) -> Union[tuple, list, Hashable]:
-    """Return hashable value from item."""
-    if isinstance(item, dict):
-        return make_dict_hashable(item)
-    if isinstance(item, list):
-        return make_list_hashable(item)
-    return item
-
-
-def make_list_hashable(lst: list) -> tuple:
-    """Make a list hashable."""
-    return tuple(_hashable_value(item) for item in lst)
-
-
-def make_dict_hashable(dct: dict) -> HashableDict:
-    """Convert a dictionary to a hashable dictionary."""
-    return HashableDict({key: _hashable_value(value) for key, value in dct.items()})
-
-
-def sanitize_msg(msg: dict) -> HashableDict:
-    """Sanitize command message."""
-    msg = msg.copy()
-    msg.pop("messageId", None)
-    return make_dict_hashable(msg)
-
-
-def add_command_result(
-    command_results: DefaultDict[HashableDict, list],
-    record: dict,
-) -> None:
-    """Add a command result to command_results map."""
-    if "result_msg" not in record:
-        logging.warning(
-            "The following record cannot be used because the client did not wait for "
-            "a response: %s",
-            record,
-        )
-        return
-    command_msg = sanitize_msg(record["command_msg"])
-    # Response message doesn't need to be sanitized here because it will be sanitized
-    # in the MockZwaveJsServer.send_command_result method.
-    result_msg = record["result_msg"]
-    command_results[command_msg].append(result_msg)
-
-
-def get_args() -> argparse.Namespace:
-    """Get arguments."""
-    parser = argparse.ArgumentParser(description="Dump Instance")
-    parser.add_argument(
-        "network_state_path", type=str, help="File path to network state dump JSON."
-    )
-    parser.add_argument("--host", type=str, help="Host to bind to", default="127.0.0.1")
-    parser.add_argument(
-        "--port", type=int, help="Port to run on (defaults to 3000)", default=3000
-    )
-    parser.add_argument(
-        "--log-level",
-        type=str.upper,
-        help="Log level",
-        default="INFO",
-        choices=["DEBUG", "INFO", "WARNING", "ERROR"],
-    )
-    parser.add_argument(
-        "--events-to-replay-path",
-        type=str,
-        help=(
-            "File path to events to replay JSON. Events provided by "
-            "--combined-replay-dump-path option will be first, followed by events "
-            "from this file."
-        ),
-        default=None,
-    )
-    parser.add_argument(
-        "--command-results-path",
-        type=str,
-        help=(
-            "File path to command result JSON. Command results provided by "
-            "--combined-replay-dump-path option will be first, followed by results "
-            "from this file."
-        ),
-        default=None,
-    )
-    parser.add_argument(
-        "--combined-replay-dump-path",
-        type=str,
-        help=(
-            "File path to the combined event and command result dump JSON. Events and "
-            "command results will be extracted in the order they were received."
-        ),
-        default=None,
-    )
-    return parser.parse_args()
-
-
-def main() -> None:
-    """Run main entrypoint."""
-    args = get_args()
-
-    with open(args.network_state_path, "r", encoding="utf8") as fp:
-        network_state_dump: List[dict] = json.load(fp)
-
-    events_to_replay = []
-    command_results: DefaultDict[HashableDict, list] = defaultdict(list)
-
-    if args.combined_replay_dump_path:
-        with open(args.combined_replay_dump_path, "r", encoding="utf8") as fp:
-            records: List[dict] = json.load(fp)
-
-            for record in records:
-                if record.get("record_type") not in ("event", "command"):
-                    raise ExitException(
-                        f"Invalid record in combined replay dump file: {record}"
-                    )
-                if record["record_type"] == "event":
-                    events_to_replay.append(record["data"])
-                else:
-                    add_command_result(command_results, record)
-
-    if args.events_to_replay_path:
-        with open(args.events_to_replay_path, "r", encoding="utf8") as fp:
-            records = json.load(fp)
-            if (
-                bad_record := next(
-                    (
-                        record
-                        for record in records
-                        if record.get("record_type") != "event"
-                    ),
-                    None,
-                )
-            ) is not None:
-                raise ExitException(
-                    f"Malformed record in events to replay file: {bad_record}"
-                )
-            events_to_replay.extend([record["data"] for record in records])
-
-    if args.command_results_path:
-        with open(args.command_results_path, "r", encoding="utf8") as fp:
-            records = json.load(fp)
-            if (
-                bad_record := next(
-                    (
-                        record
-                        for record in records
-                        if record.get("record_type") != "command"
-                    ),
-                    None,
-                )
-            ) is not None:
-                raise ExitException(
-                    f"Malformed record in command results dump file: {bad_record}"
-                )
-            for record in records:
-                add_command_result(command_results, record)
-
-    # adapted from homeassistant.bootstrap.async_enable_logging
-    logging.basicConfig(level=args.log_level)
-    try:
-        # pylint: disable=import-outside-toplevel
-        from colorlog import ColoredFormatter
-
-        colorfmt = f"%(log_color)s{FMT}%(reset)s"
-        logging.getLogger().handlers[0].setFormatter(
-            ColoredFormatter(
-                colorfmt,
-                datefmt=DATEFMT,
-                log_colors={
-                    "DEBUG": "cyan",
-                    "INFO": "green",
-                    "WARNING": "yellow",
-                    "ERROR": "red",
-                    "CRITICAL": "red",
-                },
-            )
-        )
-    except ImportError:
-        logging.getLogger().handlers[0].setFormatter(
-            logging.Formatter(fmt=FMT, datefmt=DATEFMT)
-        )
-
-    server = MockZwaveJsServer(network_state_dump, events_to_replay, command_results)
-    web.run_app(server.app, host=args.host, port=args.port)
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except ExitException as error:
-        logging.error("Fatal error: %s", error)