python-ember-mug 1.1.1__tar.gz → 1.2.0__tar.gz

{python_ember_mug-1.1.1 → python_ember_mug-1.2.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: python-ember-mug
-Version: 1.1.1
+Version: 1.2.0
 Summary: Python Library for Ember Mugs.
 Project-URL: Changelog, https://sopelj.github.io/python-ember-mug/changelog/
 Project-URL: Documentation, https://sopelj.github.io/python-ember-mug/
 Project-URL: Source code, https://github.com/sopelj/python-ember-mug/
 Project-URL: Bug Tracker, https://github.com/sopelj/python-ember-mug/issues
-Author-email: Jesse Sopel <jesse.sopel@gmail.com>
+Author-email: Jesse Sopel <jesse@sopelj.ca>
 License-Expression: MIT
 License-File: LICENSE
 Classifier: Intended Audience :: Developers
@@ -20,6 +20,8 @@ Requires-Python: >=3.11
 Requires-Dist: bleak-retry-connector>=3.5.0
 Requires-Dist: bleak>=0.22.2; python_version < '3.13'
 Requires-Dist: bleak>=0.22.3; python_version <= '3.13'
+Provides-Extra: dev
+Requires-Dist: ipython; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: black; extra == 'docs'
 Requires-Dist: mkdocs-autorefs; extra == 'docs'

{python_ember_mug-1.1.1 → python_ember_mug-1.2.0}/ember_mug/__init__.py

@@ -6,4 +6,4 @@ __all__ = ("EmberMug",)
 
 __author__ = """Jesse Sopel"""
 __email__ = "jesse.sopel@gmail.com"
-__version__ = "1.1.1"
+__version__ = "1.2.0"

{python_ember_mug-1.1.1 → python_ember_mug-1.2.0}/ember_mug/consts.py

@@ -149,10 +149,10 @@ TRAVEL_MUG_SERVICE_UUIDS = (
     str(MugCharacteristic.TRAVEL_MUG_SERVICE_OTHER),
 )
 
-DEVICE_SERVICE_UUIDS = (
+DEVICE_SERVICE_UUIDS = [
     str(MugCharacteristic.STANDARD_SERVICE),
     *TRAVEL_MUG_SERVICE_UUIDS,
-)
+]
 
 
 class LiquidState(IntEnum):

{python_ember_mug-1.1.1 → python_ember_mug-1.2.0}/ember_mug/scanner.py

@@ -5,29 +5,37 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, cast
 
 from bleak import BleakScanner
 
 from .consts import DEVICE_SERVICE_UUIDS, IS_LINUX
 
 if TYPE_CHECKING:
+    from typing import NotRequired, TypedDict
+
     from bleak.backends.device import BLEDevice
     from bleak.backends.scanner import AdvertisementData
 
+    class ScannerKwargs(TypedDict):
+        """Optional kwargs for scanner."""
+
+        adapter: NotRequired[str]
+        service_uuids: NotRequired[list[str]]
+
 
 DEFAULT_TIMEOUT = 30
 
 logger = logging.getLogger(__name__)
 
 
-def build_scanner_kwargs(adapter: str | None = None) -> dict[str, Any]:
+def build_scanner_kwargs(adapter: str | None = None, *, service_uuids: list[str] | None = None) -> ScannerKwargs:
     """Add Adapter to kwargs for scanner if specified and using BlueZ."""
     if adapter and IS_LINUX is not True:
         msg = "The adapter option is only valid for the Linux BlueZ Backend."
         raise ValueError(msg)
-    kwargs = {"service_uuids": DEVICE_SERVICE_UUIDS}
-    return kwargs | {"adapter": adapter} if adapter else kwargs
+    kwargs = {"service_uuids": service_uuids} if service_uuids else {}
+    return cast("ScannerKwargs", kwargs | {"adapter": adapter} if adapter else kwargs)
 
 
 async def discover_devices(
@@ -47,7 +55,7 @@ async def discover_devices(
         ```
 
     """
-    async with BleakScanner(**build_scanner_kwargs(adapter)) as scanner:
+    async with BleakScanner(**build_scanner_kwargs(adapter, service_uuids=DEVICE_SERVICE_UUIDS)) as scanner:
         await asyncio.sleep(wait)
         return [
             (d, a)

{python_ember_mug-1.1.1 → python_ember_mug-1.2.0}/ember_mug/utils.py

@@ -134,7 +134,7 @@ def guess_model_from_name(name: str | None) -> DeviceModel | None:
 
 def get_model_info_from_advertiser_data(advertisement: AdvertisementData) -> ModelInfo:
     """Extract model info from manufacturer data in advertiser data."""
-    from ember_mug.data import ModelInfo
+    from ember_mug.data import ModelInfo  # noqa: PLC0415
 
     model_data = advertisement.manufacturer_data.get(EMBER_BLE_SIG, None)
     if model_data is not None:

{python_ember_mug-1.1.1 → python_ember_mug-1.2.0}/pyproject.toml

@@ -1,16 +1,12 @@
-[tool]
-
 [project]
 name = "python-ember-mug"
 readme = "README.md"
 description = "Python Library for Ember Mugs."
-authors = [
-    { name = "Jesse Sopel", email = "jesse.sopel@gmail.com" },
-]
-license =  "MIT"
+authors = [{ name = "Jesse Sopel", email = "jesse@sopelj.ca" }]
+license = "MIT"
 requires-python = ">=3.11"
 dynamic = ["version"]
-classifiers=[
+classifiers = [
     'Intended Audience :: Developers',
     'License :: OSI Approved :: MIT License',
     'Natural Language :: English',
@@ -26,23 +22,20 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-test = [
-  "pytest>=7.2.1",
-  "pytest-cov",
-  "pytest-asyncio",
-]
+test = ["pytest>=7.2.1", "pytest-cov", "pytest-asyncio"]
 docs = [
-  "mkdocs>=1.6.1",
-  "mkdocs-include-markdown-plugin>=7.0.0,<8.0.0",
-  "mkdocs-material>=9.5.44,<10.0.0",
-  "mkdocs-material-extensions",
-  "mkdocstrings-python>=1.12.0",
-  "mkdocs-autorefs",
-  "mkdocs-literate-nav",
-  "mkdocs-gen-files",
-  "black",
-  "termynal",
+    "mkdocs>=1.6.1",
+    "mkdocs-include-markdown-plugin>=7.0.0,<8.0.0",
+    "mkdocs-material>=9.5.44,<10.0.0",
+    "mkdocs-material-extensions",
+    "mkdocstrings-python>=1.12.0",
+    "mkdocs-autorefs",
+    "mkdocs-literate-nav",
+    "mkdocs-gen-files",
+    "black",
+    "termynal",
 ]
+dev = ["ipython"]
 
 [project.urls]
 "Changelog" = "https://sopelj.github.io/python-ember-mug/changelog/"
@@ -62,12 +55,15 @@ build-backend = "hatchling.build"
 [tool.hatch.version]
 path = "ember_mug/__init__.py"
 
+[tool.hatch.build]
+exclude = ["/docs", "/tests"]
+
 [tool.hatch.build.targets.sdist]
-packages = ["ember_mug", "tests"]
+packages = ["ember_mug"]
 exclude = [".gitignore"]
 
 [tool.hatch.build.targets.wheel]
-packages = ["ember_mug", "tests"]
+packages = ["ember_mug"]
 exclude = [".gitignore"]
 
 [tool.hatch.envs.default]
@@ -111,15 +107,15 @@ exclude = '''
 
 [tool.coverage.report]
 exclude_lines = [
-  "pragma: no cover",
-  "def __repr__",
-  "def __str__",
-  "def main",
-  "raise AssertionError",
-  "raise NotImplementedError",
-  "if __name__ == .__main__.:",
-  "if TYPE_CHECKING:",
-  "if typing.TYPE_CHECKING:"
+    "pragma: no cover",
+    "def __repr__",
+    "def __str__",
+    "def main",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "if typing.TYPE_CHECKING:",
 ]
 
 [tool.ruff]
@@ -162,7 +158,7 @@ ignore = ["D203", "D212", "PLR2004"]
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**/*.py" = [
-    "D103",  # No docstrings in tests needed
-    "S101",  # We needs asserts in tests
+    "D103",   # No docstrings in tests needed
+    "S101",   # We needs asserts in tests
     "SLF001",
 ]

python_ember_mug-1.1.1/tests/__init__.py

@@ -1 +0,0 @@
-"""Unit test package for python-ember-mug."""

python_ember_mug-1.1.1/tests/cli/__init__.py

@@ -1 +0,0 @@
-"""Tests for the CLI module."""

python_ember_mug-1.1.1/tests/cli/test_commands.py

@@ -1,380 +0,0 @@
-"""Test the CLI commands."""
-
-from __future__ import annotations
-
-import sys
-from argparse import ArgumentTypeError, Namespace
-from typing import TYPE_CHECKING, Any
-from unittest.mock import AsyncMock, Mock, call, patch
-
-import pytest
-from bleak import BleakError, BLEDevice
-
-from ember_mug import EmberMug
-from ember_mug.cli.commands import (
-    EmberMugCli,
-    colour_type,
-    discover_cmd,
-    fetch_info_cmd,
-    find_device_cmd,
-    get_device,
-    get_device_value_cmd,
-    poll_device_cmd,
-    set_device_value_cmd,
-)
-from ember_mug.consts import DeviceColour, DeviceModel
-from ember_mug.data import Colour, ModelInfo, MugData
-
-from ..conftest import TEST_MAC, TEST_MUG_ADVERTISEMENT, mock_connection
-
-if TYPE_CHECKING:
-    from collections.abc import Generator
-
-    from pytest import CaptureFixture  # noqa: PT013
-
-
-@pytest.fixture
-def mock_mug_with_connection() -> Generator[AsyncMock, None, None]:
-    with patch("ember_mug.cli.commands.get_device") as mock:
-        mock_mug = AsyncMock()
-        mock_mug.connection = Mock(return_value=mock_connection)
-        mock.return_value = mock_mug
-        yield mock_mug
-
-
-def mock_namespace(**kwargs: Any) -> Namespace:
-    defaults = {
-        "imperial": False,
-        "extra": False,
-        "raw": False,
-        "debug": False,
-        "adapter": None,
-    }
-    defaults.update(**kwargs)
-    return Namespace(**defaults)
-
-
-@patch("ember_mug.cli.commands.EmberMug", spec=EmberMug)
-@patch("ember_mug.cli.commands.find_device_cmd")
-async def test_get_device(
-    mock_find_device_cmd: AsyncMock,
-    mock_ember_mug: AsyncMock,
-    capsys: CaptureFixture,
-    ble_device: BLEDevice,
-) -> None:
-    mock_find_device_cmd.return_value = ble_device, TEST_MUG_ADVERTISEMENT
-    args = mock_namespace(extra=True)
-    mug = await get_device(args)
-    assert mug is not None
-    mock_find_device_cmd.assert_called_once_with(args)
-    mock_ember_mug.assert_called_once_with(
-        ble_device,
-        ModelInfo(DeviceModel.MUG_2_10_OZ, DeviceColour.BLACK),
-        use_metric=True,
-        debug=False,
-    )
-    captured = capsys.readouterr()
-    assert captured.out == "Connecting...\n"
-
-    # Raw prints nothing
-    args = mock_namespace(extra=True, raw=True)
-    mug = await get_device(args)
-    assert mug is not None
-    captured = capsys.readouterr()
-    assert captured.out == ""
-
-
-@patch("ember_mug.cli.commands.find_device")
-async def test_find_device(mock_find_mug: AsyncMock, capsys: CaptureFixture, ble_device: BLEDevice) -> None:
-    mock_find_mug.return_value = (ble_device, TEST_MUG_ADVERTISEMENT)
-    args = mock_namespace(mac=ble_device.address)
-    device, advertisement = await find_device_cmd(args)
-    assert device == ble_device
-    assert advertisement == TEST_MUG_ADVERTISEMENT
-    mock_find_mug.assert_called_once_with(mac=ble_device.address, adapter=None)
-    captured = capsys.readouterr()
-    assert captured.out == f"Found device: {ble_device}\n"
-
-    # Raw prints nothing
-    args = Namespace(mac=ble_device.address, adapter=None, raw=True)
-    await find_device_cmd(args)
-    captured = capsys.readouterr()
-    assert captured.out == ""
-
-
-@patch("ember_mug.cli.commands.find_device")
-async def test_find_device_no_device(mock_find_mug: AsyncMock, capsys: CaptureFixture) -> None:
-    mock_find_mug.return_value = (None, None)
-    args = mock_namespace(mac=TEST_MAC)
-    with pytest.raises(SystemExit, match="1"):
-        await find_device_cmd(args)
-    mock_find_mug.assert_called_once_with(mac=TEST_MAC, adapter=None)
-    captured = capsys.readouterr()
-    assert captured.out == "No device was found.\n"
-
-
-@patch("ember_mug.cli.commands.find_device")
-async def test_find_device_bleak_error(mock_find_mug: AsyncMock, capsys: CaptureFixture) -> None:
-    mock_find_mug.side_effect = BleakError("Test Error")
-    args = mock_namespace(mac=TEST_MAC)
-    with pytest.raises(SystemExit, match="1"):
-        await find_device_cmd(args)
-    mock_find_mug.assert_called_once_with(mac=TEST_MAC, adapter=None)
-    captured = capsys.readouterr()
-    assert captured.out == "An error occurred trying to find a device: Test Error\n"
-
-
-@patch("ember_mug.cli.commands.discover_devices")
-async def test_discover(mock_discover_mugs: AsyncMock, capsys: CaptureFixture, ble_device: BLEDevice) -> None:
-    mock_discover_mugs.return_value = [(ble_device, TEST_MUG_ADVERTISEMENT)]
-    args = mock_namespace(mac=TEST_MAC)
-    mugs = await discover_cmd(args)
-    assert mugs == [(ble_device, TEST_MUG_ADVERTISEMENT)]
-    mock_discover_mugs.assert_called_once_with(mac=TEST_MAC)
-    captured = capsys.readouterr()
-    assert captured.out == (
-        f"Found mug: {ble_device}\n"
-        "Name: Ember Ceramic Mug\n"
-        "Model: Ember Mug 2 (10oz) [CM19/CM21M]\n"
-        "Colour: Black\n"
-        "Capacity: 295ml\n"
-    )
-
-    mock_discover_mugs.reset_mock()
-    args = mock_namespace(mac=TEST_MAC, raw=True)
-    mugs = await discover_cmd(args)
-    assert mugs == [(ble_device, TEST_MUG_ADVERTISEMENT)]
-    mock_discover_mugs.assert_called_once_with(mac=TEST_MAC)
-    captured = capsys.readouterr()
-    assert captured.out == f"{TEST_MAC}\n"
-
-
-@patch("ember_mug.cli.commands.discover_devices")
-async def test_discover_no_device(mock_discover_mugs: AsyncMock, capsys: CaptureFixture) -> None:
-    mock_discover_mugs.return_value = []
-    args = mock_namespace(mac=TEST_MAC)
-    with pytest.raises(SystemExit, match="1"):
-        await discover_cmd(args)
-    mock_discover_mugs.assert_called_once_with(mac=TEST_MAC)
-    captured = capsys.readouterr()
-    assert captured.out == 'No devices were found. Be sure it is in pairing mode. Or use "find" if already paired.\n'
-
-
-@patch("ember_mug.cli.commands.discover_devices")
-async def test_discover_bleak_error(mock_discover_mugs: AsyncMock, capsys: CaptureFixture) -> None:
-    mock_discover_mugs.side_effect = BleakError("Test Error")
-    args = mock_namespace(mac=TEST_MAC)
-    with pytest.raises(SystemExit, match="1"):
-        await discover_cmd(args)
-    mock_discover_mugs.assert_called_once_with(mac=TEST_MAC)
-    captured = capsys.readouterr()
-    assert captured.out == "An error occurred trying to discover devices: Test Error\n"
-
-
-@patch("ember_mug.cli.commands.print_info")
-async def test_fetch_info(
-    mock_print_info: AsyncMock,
-    mock_mug_with_connection: AsyncMock,
-    capsys: CaptureFixture,
-) -> None:
-    # Test normal
-    args = mock_namespace(mac=TEST_MAC)
-    await fetch_info_cmd(args)
-    captured = capsys.readouterr()
-    assert captured.out == "Connected.\nFetching Info\n"
-    mock_print_info.assert_called_once_with(mock_mug_with_connection)
-
-    # Test with Raw
-    args = mock_namespace(mac=TEST_MAC, raw=True)
-    await fetch_info_cmd(args)
-    captured = capsys.readouterr()
-    assert captured.out == ""
-
-
-@patch("asyncio.sleep")
-@patch("ember_mug.cli.commands.print_info")
-@patch("ember_mug.cli.commands.print_changes")
-@patch("ember_mug.cli.commands.CommandLoop", lambda: [1])
-async def test_poll_device_cmd(
-    mock_print_changes: AsyncMock,
-    mock_print_info: AsyncMock,
-    mock_sleep: AsyncMock,
-    mock_mug_with_connection: AsyncMock,
-    capsys: CaptureFixture,
-) -> None:
-    # Test normal
-    args = mock_namespace(mac=TEST_MAC)
-    await poll_device_cmd(args)
-    captured = capsys.readouterr()
-    assert captured.out == "Connected.\nFetching Info\n\nWatching for changes\n"
-    mock_sleep.assert_has_calls([call(1)] * 60)
-
-    # Test with Raw
-    mock_sleep.reset_mock()
-    args = mock_namespace(mac=TEST_MAC, raw=True)
-    await poll_device_cmd(args)
-    mock_sleep.assert_has_calls([call(1)] * 60)
-    captured = capsys.readouterr()
-    assert captured.out == ""
-
-
-@patch("ember_mug.cli.commands.print_table")
-async def test_get_device_value_cmd(
-    mocked_print_table: Mock,
-    mock_mug_with_connection: AsyncMock,
-    capsys: CaptureFixture,
-) -> None:
-    mock_mug_with_connection.data = MugData(ModelInfo())
-    mock_mug_with_connection.data.get_formatted_attr = Mock(return_value="test")  # type: ignore[assignment]
-    mock_mug_with_connection.get_target_temp.return_value = 55.5
-    mock_mug_with_connection.get_name.return_value = "test"
-    args = mock_namespace(attributes=["target_temp", "name"])
-    await get_device_value_cmd(args)
-    mock_mug_with_connection.get_target_temp.assert_called_once()
-    mocked_print_table.assert_called_once_with([("Target Temp", "test"), ("Device Name", "test")])
-
-    mock_mug_with_connection.get_led_colour.return_value = 55.5
-    args = mock_namespace(attributes=["led_colour", "name"], raw=True)
-    await get_device_value_cmd(args)
-    captured = capsys.readouterr()
-    assert captured.out == "55.5\ntest\n"
-
-    mock_mug_with_connection.get_name.side_effect = NotImplementedError
-    args = mock_namespace(attributes=["name"], raw=True)
-    with pytest.raises(SystemExit, match="1"):
-        await get_device_value_cmd(args)
-
-
-async def test_set_device_value_cmd_no_value(capsys: CaptureFixture) -> None:
-    with pytest.raises(SystemExit, match="1"):
-        await set_device_value_cmd(Namespace())
-    captured = capsys.readouterr()
-    assert captured.out == (
-        "Please specify at least one attribute and value to set.\n"
-        "Options: --name, --target-temp, --temperature-unit, --led-colour, --volume-level\n"
-    )
-
-
-async def test_set_device_value_cmd(mock_mug_with_connection: AsyncMock) -> None:
-    mock_mug_with_connection.data = MugData(ModelInfo())
-    args = mock_namespace(name="test")
-    await set_device_value_cmd(args)
-    mock_mug_with_connection.set_name.assert_called_once_with("test")
-
-    mock_mug_with_connection.reset_mock()
-    mock_mug_with_connection.set_name.side_effect = NotImplementedError("Unable to set name on Cup")
-    with pytest.raises(SystemExit, match="1"):
-        await set_device_value_cmd(args)
-
-
-@pytest.mark.parametrize(
-    ("value", "error"),
-    [
-        ("1,2,3,4,5,6", "Three or four values should be specified for colour"),
-        ("260,1,1,1", "Colour values must be between 0 and 255"),
-        ("invalid", '"invalid" is not a valid rgba or hex colour'),
-    ],
-)
-def test_colour_type_raises(value: str, error: str) -> None:
-    with pytest.raises(ArgumentTypeError, match=error):
-        colour_type(value)
-
-
-def test_colour_type() -> None:
-    assert colour_type("#ffffff") == Colour(255, 255, 255, 255)
-    assert colour_type("#ffffffaa") == Colour(255, 255, 255, 170)
-    assert colour_type("1,2,3") == Colour(1, 2, 3, 255)
-    assert colour_type("1,2,3,4") == Colour(1, 2, 3, 4)
-
-
-def test_ember_cli():
-    cli = EmberMugCli()
-
-    args = cli.parser.parse_args(["find"])
-    assert args.command == "find"
-
-    args = cli.parser.parse_args(["discover"])
-    assert args.command == "discover"
-
-    args = cli.parser.parse_args(["info", "-m", TEST_MAC, "--imperial"])
-    assert args.command == "info"
-    assert args.mac == TEST_MAC
-    assert args.imperial is True
-
-    args = cli.parser.parse_args(["poll"])
-    assert args.command == "poll"
-
-    args = cli.parser.parse_args(["get", "led-colour"])
-    assert args.command == "get"
-    assert args.attributes == ["led-colour"]
-
-    args = cli.parser.parse_args(["set", "--name", "TEST"])
-    assert args.command == "set"
-    assert args.name == "TEST"
-
-
-@patch("ember_mug.consts.IS_LINUX", False)
-def test_ember_cli_windows():
-    del sys.modules["ember_mug.cli.commands"]  # force re-import
-    from ember_mug.cli.commands import EmberMugCli
-
-    cli = EmberMugCli()
-
-    args = cli.parser.parse_args(["find"])
-    assert args.command == "find"
-
-    with pytest.raises(SystemExit, match="2"):
-        cli.parser.parse_args(["info", "--adapter", "hci0"])
-
-
-@patch("sys.argv", ["file.py", "find", "-m", TEST_MAC])
-async def test_cli_run():
-    cli = EmberMugCli()
-    mock_find = AsyncMock()
-    with patch.object(cli, "_commands", {"find": mock_find}):
-        await cli.run()
-
-    mock_find.assert_called_once()
-    args = mock_find.mock_calls[0].args[0]
-    assert args.command == "find"
-    assert args.mac == TEST_MAC
-    assert args.debug is False
-    assert args.raw is False
-    assert args.adapter is None
-
-
-@patch("sys.argv", ["file.py", "discover", "--debug"])
-@patch("logging.basicConfig")
-async def test_cli_run_discover_debug(mock_logging_config: Mock):
-    cli = EmberMugCli()
-    mock_discover = AsyncMock()
-    with patch.object(cli, "_commands", {"discover": mock_discover}):
-        await cli.run()
-
-    mock_discover.assert_called_once()
-    mock_logging_config.assert_called_once()
-    args = mock_discover.mock_calls[0].args[0]
-    assert args.command == "discover"
-    assert args.debug is True
-    assert args.raw is False
-    assert args.adapter is None
-
-
-@patch("ember_mug.consts.IS_LINUX", False)
-@patch("sys.argv", ["file.py", "find", "-m", TEST_MAC, "--raw"])
-async def test_cli_run_non_linux():
-    del sys.modules["ember_mug.cli.commands"]  # force re-import
-    from ember_mug.cli.commands import EmberMugCli
-
-    cli = EmberMugCli()
-    mock_find = AsyncMock()
-    with patch.object(cli, "_commands", {"find": mock_find}):
-        await cli.run()
-
-    mock_find.assert_called_once()
-    args = mock_find.mock_calls[0].args[0]
-    assert args.command == "find"
-    assert args.mac == TEST_MAC
-    assert args.debug is False
-    assert args.raw is True
-    assert args.adapter is None

python_ember_mug-1.1.1/tests/cli/test_helpers.py

@@ -1,92 +0,0 @@
-"""Test the CLI helper functions."""
-
-from __future__ import annotations
-
-from argparse import ArgumentTypeError
-from textwrap import dedent
-from typing import TYPE_CHECKING
-
-import pytest
-
-from ember_mug.cli.helpers import build_sub_rows, print_changes, print_info, print_table, validate_mac
-from ember_mug.consts import LiquidState
-from ember_mug.data import Change
-
-if TYPE_CHECKING:
-    from pytest import CaptureFixture  # noqa: PT013
-
-    from ember_mug import EmberMug
-
-
-def test_validate_mac() -> None:
-    with pytest.raises(ArgumentTypeError, match="Invalid MAC Address"):
-        validate_mac("potato")
-    assert validate_mac("9C:DA:8C:19:27:DA") == "9c:da:8c:19:27:da"
-
-
-def test_build_sub_rows() -> None:
-    sub_rows = build_sub_rows(("Test", "test1, test2, test3", "test4"))
-    assert sub_rows[0][0] == "Test"
-    assert sub_rows[0][1] == "test1"
-    assert sub_rows[0][2] == "test4"
-    assert sub_rows[1][0] == ""
-    assert sub_rows[1][1] == "test2"
-    assert sub_rows[1][2] == ""
-    assert sub_rows[2][1] == "test3"
-
-
-def test_print_changes(capsys: CaptureFixture) -> None:
-    changes = [
-        Change("name", "Mug Name", "Test Mug"),
-        Change("liquid_level", 1, 2),
-        Change("liquid_state", LiquidState.EMPTY, LiquidState.HEATING),
-        Change("target_temp", 45, 55),
-    ]
-    print_changes(changes, True)
-    captured = capsys.readouterr()
-    assert captured.out == dedent(
-        """\
-        Name changed from "Mug Name" to "Test Mug"
-        Liquid Level changed from "3.33%" to "6.67%"
-        Liquid State changed from "Empty" to "Heating"
-        Target Temp changed from "45.00°C" to "55.00°C"
-        """,
-    )
-
-
-def test_print_table(ember_mug: EmberMug, capsys: CaptureFixture) -> None:
-    print_table([])
-    captured = capsys.readouterr()
-    assert captured.out == ""
-
-
-def test_print_info(ember_mug: EmberMug, capsys: CaptureFixture) -> None:
-    ember_mug.debug = False
-    print_info(ember_mug)
-    captured = capsys.readouterr()
-    assert captured.out == dedent(
-        """\
-        Device Data
-        +--------------+---------+
-        | Device Name  |         |
-        +--------------+---------+
-        | Meta         | None    |
-        +--------------+---------+
-        | Battery      | None    |
-        +--------------+---------+
-        | Firmware     | None    |
-        +--------------+---------+
-        | LED Colour   | #ffffff |
-        +--------------+---------+
-        | Liquid State | Unknown |
-        +--------------+---------+
-        | Liquid Level | 0.00%   |
-        +--------------+---------+
-        | Current Temp | 0.00°C  |
-        +--------------+---------+
-        | Target Temp  | 0.00°C  |
-        +--------------+---------+
-        | Use Metric   | True    |
-        +--------------+---------+
-        """,
-    )