python-ember-mug 1.0.1__tar.gz → 1.1.0__tar.gz

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-ember-mug
-Version: 1.0.1
+Version: 1.1.0
 Summary: Python Library for Ember Mugs.
 Project-URL: Documentation, https://sopelj.github.io/python-ember-mug/
 Project-URL: Source code, https://github.com/sopelj/python-ember-mug/
@@ -13,18 +13,16 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.10
-Requires-Dist: async-timeout; python_version < '3.11'
-Requires-Dist: bleak-retry-connector>=3.1.2
-Requires-Dist: bleak>=0.21.0
+Requires-Python: >=3.11
+Requires-Dist: bleak-retry-connector>=3.5.0
+Requires-Dist: bleak>=0.22.2
 Provides-Extra: docs
 Requires-Dist: black; extra == 'docs'
 Requires-Dist: mkdocs-autorefs; extra == 'docs'
 Requires-Dist: mkdocs-gen-files; extra == 'docs'
-Requires-Dist: mkdocs-include-markdown-plugin<7.0.0,>=3.6.1; extra == 'docs'
+Requires-Dist: mkdocs-include-markdown-plugin<8.0.0,>=3.6.1; extra == 'docs'
 Requires-Dist: mkdocs-literate-nav; extra == 'docs'
 Requires-Dist: mkdocs-material-extensions; extra == 'docs'
 Requires-Dist: mkdocs-material<10.0.0,>=8.4.1; extra == 'docs'
@@ -102,15 +100,15 @@ Attributes by device:
 ### Python
 
 ```python
-from ember_mug.scanner import find_mug, discover_mugs
+from ember_mug.scanner import find_device, discover_devices
 from ember_mug.utils import get_model_info_from_advertiser_data
 from ember_mug.mug import EmberMug
 
 # if first time with mug in pairing
-mugs = await discover_mugs()
+devices = await discover_devices()
 
 # after paired you can simply use
-device, advertisement = await find_mug()
+device, advertisement = await find_device()
 model_info = get_model_info_from_advertiser_data(advertisement)
 mug = EmberMug(device, model_info)
 await mug.update_all()

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/README.md

@@ -62,15 +62,15 @@ Attributes by device:
 ### Python
 
 ```python
-from ember_mug.scanner import find_mug, discover_mugs
+from ember_mug.scanner import find_device, discover_devices
 from ember_mug.utils import get_model_info_from_advertiser_data
 from ember_mug.mug import EmberMug
 
 # if first time with mug in pairing
-mugs = await discover_mugs()
+devices = await discover_devices()
 
 # after paired you can simply use
-device, advertisement = await find_mug()
+device, advertisement = await find_device()
 model_info = get_model_info_from_advertiser_data(advertisement)
 mug = EmberMug(device, model_info)
 await mug.update_all()

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/ember_mug/__init__.py

@@ -1,8 +1,9 @@
 """Top-level package for Python Ember Mug."""
+
 from .mug import EmberMug
 
 __all__ = ("EmberMug",)
 
 __author__ = """Jesse Sopel"""
 __email__ = "jesse.sopel@gmail.com"
-__version__ = "1.0.1"
+__version__ = "1.1.0"

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/ember_mug/cli/commands.py

@@ -14,7 +14,7 @@ from bleak import AdvertisementData, BleakError
 from ember_mug.consts import ATTR_LABELS, EXTRA_ATTRS, IS_LINUX, VolumeLevel
 from ember_mug.data import Colour
 from ember_mug.mug import EmberMug
-from ember_mug.scanner import discover_mugs, find_mug
+from ember_mug.scanner import discover_devices, find_device
 
 from ..formatting import format_capacity
 from ..utils import get_model_info_from_advertiser_data
@@ -29,9 +29,9 @@ all_attrs = list(ATTR_LABELS) + list(EXTRA_ATTRS)
 get_attribute_names = [n.replace("_", "-") for n in all_attrs]
 
 
-async def get_mug(args: Namespace) -> EmberMug:
-    """Help to get the mug based on args."""
-    device, advertisement = await find_device(args)
+async def get_device(args: Namespace) -> EmberMug:
+    """Help to get the devices based on command args."""
+    device, advertisement = await find_device_cmd(args)
     mug = EmberMug(
         device,
         get_model_info_from_advertiser_data(advertisement),
@@ -43,10 +43,10 @@ async def get_mug(args: Namespace) -> EmberMug:
     return mug
 
 
-async def find_device(args: Namespace) -> tuple[BLEDevice, AdvertisementData]:
+async def find_device_cmd(args: Namespace) -> tuple[BLEDevice, AdvertisementData]:
     """Find a single device that has already been paired."""
     try:
-        device, advertisement = await find_mug(mac=args.mac, adapter=args.adapter)
+        device, advertisement = await find_device(mac=args.mac, adapter=args.adapter)
     except BleakError as e:
         print(f"An error occurred trying to find a device: {e}")
         sys.exit(1)
@@ -58,10 +58,10 @@ async def find_device(args: Namespace) -> tuple[BLEDevice, AdvertisementData]:
     return device, advertisement
 
 
-async def discover(args: Namespace) -> list[tuple[BLEDevice, AdvertisementData]]:
+async def discover_cmd(args: Namespace) -> list[tuple[BLEDevice, AdvertisementData]]:
     """Discover new devices in pairing mode."""
     try:
-        mugs = await discover_mugs(mac=args.mac)
+        mugs = await discover_devices(mac=args.mac)
     except BleakError as e:
         print(f"An error occurred trying to discover devices: {e}")
         sys.exit(1)
@@ -83,9 +83,9 @@ async def discover(args: Namespace) -> list[tuple[BLEDevice, AdvertisementData]]
     return mugs
 
 
-async def fetch_info(args: Namespace) -> None:
+async def fetch_info_cmd(args: Namespace) -> None:
     """Fetch all information from a mug and end."""
-    mug = await get_mug(args)
+    mug = await get_device(args)
     async with mug.connection(adapter=args.adapter):
         if not args.raw:
             print("Connected.\nFetching Info")
@@ -93,9 +93,9 @@ async def fetch_info(args: Namespace) -> None:
     print_info(mug)
 
 
-async def poll_mug(args: Namespace) -> None:
+async def poll_device_cmd(args: Namespace) -> None:
     """Fetch all information and keep polling for changes."""
-    mug = await get_mug(args)
+    mug = await get_device(args)
     async with mug.connection(adapter=args.adapter):
         if not args.raw:
             print("Connected.\nFetching Info")
@@ -111,9 +111,9 @@ async def poll_mug(args: Namespace) -> None:
             print_changes(await mug.update_all(), mug.data.use_metric)
 
 
-async def get_mug_value(args: Namespace) -> None:
+async def get_device_value_cmd(args: Namespace) -> None:
     """Get values from the mug and print them."""
-    mug = await get_mug(args)
+    mug = await get_device(args)
     data = {}
     attributes = [a.replace("-", "_") for a in args.attributes]
     async with mug.connection(adapter=args.adapter):
@@ -131,8 +131,8 @@ async def get_mug_value(args: Namespace) -> None:
         print_table([(ATTR_LABELS.get(attr, attr), str(mug.data.get_formatted_attr(attr))) for attr in data])
 
 
-async def set_mug_value(args: Namespace) -> None:
-    """Set one or more values on the mug."""
+async def set_device_value_cmd(args: Namespace) -> None:
+    """Set one or more values on the device."""
     attrs = ("name", "target_temp", "temperature_unit", "led_colour", "volume_level")
     values = [(attr, value) for attr in attrs if (value := getattr(args, attr, None))]
     if not values:
@@ -141,7 +141,7 @@ async def set_mug_value(args: Namespace) -> None:
         print(f'Options: {", ".join(options)}')
         sys.exit(1)
 
-    mug = await get_mug(args)
+    mug = await get_device(args)
     async with mug.connection(adapter=args.adapter):
         for attr, value in values:
             method = getattr(mug, f'set_{attr.replace("-", "_")}')
@@ -180,12 +180,12 @@ class EmberMugCli:
     """Very simple CLI Interface to interact with a mug."""
 
     _commands: ClassVar[dict[str, Callable[[Namespace], Awaitable]]] = {
-        "find": find_device,
-        "discover": discover,
-        "info": fetch_info,
-        "poll": poll_mug,
-        "get": get_mug_value,
-        "set": set_mug_value,
+        "find": find_device_cmd,
+        "discover": discover_cmd,
+        "info": fetch_info_cmd,
+        "poll": poll_device_cmd,
+        "get": get_device_value_cmd,
+        "set": set_device_value_cmd,
     }
 
     def __init__(self) -> None:

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/ember_mug/mug.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from enum import Enum
 from functools import cached_property
 from time import time
@@ -389,7 +389,7 @@ class EmberMug:
         """Get date and time zone."""
         date_time_zone_bytes = await self._read(MugCharacteristic.DATE_TIME_AND_ZONE)
         time_value = bytes_to_big_int(date_time_zone_bytes[:4])
-        return datetime.fromtimestamp(time_value, timezone.utc) if time_value > 0 else None
+        return datetime.fromtimestamp(time_value, UTC) if time_value > 0 else None
 
     async def get_firmware(self) -> MugFirmwareInfo:
         """Get firmware info."""

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/ember_mug/scanner.py

@@ -4,19 +4,12 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
-import sys
 from typing import TYPE_CHECKING, Any
 
 from bleak import BleakScanner
 
 from .consts import DEVICE_SERVICE_UUIDS, IS_LINUX
 
-if sys.version_info < (3, 11):
-    # library required before Python 3.11
-    import async_timeout
-else:
-    async_timeout = asyncio
-
 if TYPE_CHECKING:
     from bleak.backends.device import BLEDevice
     from bleak.backends.scanner import AdvertisementData
@@ -36,12 +29,22 @@ def build_scanner_kwargs(adapter: str | None = None) -> dict[str, Any]:
     return kwargs | {"adapter": adapter} if adapter else kwargs
 
 
-async def discover_mugs(
+async def discover_devices(
     mac: str | None = None,
     adapter: str | None = None,
     wait: int = 5,
 ) -> list[tuple[BLEDevice, AdvertisementData]]:
-    """Discover new mugs in pairing mode."""
+    """
+    Discover new devices in pairing mode.
+
+    Example:
+    -------
+        ```python
+        devices = await discover_devices()
+        for device, advertisement in devices:
+            print(device.address, advertisement)
+        ```
+    """
     async with BleakScanner(**build_scanner_kwargs(adapter)) as scanner:
         await asyncio.sleep(wait)
         return [
@@ -51,17 +54,25 @@ async def discover_mugs(
         ]
 
 
-async def find_mug(
+async def find_device(
     mac: str | None = None,
     adapter: str | None = None,
     timeout: int = DEFAULT_TIMEOUT,
 ) -> tuple[BLEDevice, AdvertisementData] | tuple[None, None]:
-    """Find a mug."""
+    """
+    Find a device that has previously been discovered.
+
+    Example:
+    -------
+        ```python
+        device = await find_device("my:mac:addr")
+        ```
+    """
     if mac is not None:
         mac = mac.lower()
     async with BleakScanner(**build_scanner_kwargs(adapter)) as scanner:
         with contextlib.suppress(asyncio.TimeoutError):
-            async with async_timeout.timeout(timeout):
+            async with asyncio.timeout(timeout):
                 async for device, advertisement in scanner.advertisement_data():
                     if (not mac and device.name and device.name.startswith("Ember")) or (
                         mac and device.address.lower() == mac

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/pyproject.toml

@@ -8,21 +8,19 @@ authors = [
     { name = "Jesse Sopel", email = "jesse.sopel@gmail.com" },
 ]
 license =  "MIT"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 dynamic = ["version"]
 classifiers=[
     'Intended Audience :: Developers',
     'License :: OSI Approved :: MIT License',
     'Natural Language :: English',
     'Programming Language :: Python :: 3',
-    'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
 ]
 dependencies = [
-    "bleak-retry-connector>=3.1.2",
-    "bleak>=0.21.0",
-    "async-timeout; python_version < '3.11'",
+    "bleak-retry-connector>=3.5.0",
+    "bleak>=0.22.2",
 ]
 
 [project.optional-dependencies]
@@ -33,7 +31,7 @@ test = [
 ]
 docs = [
   "mkdocs>=1.1.21",
-  "mkdocs-include-markdown-plugin>=3.6.1,<7.0.0",
+  "mkdocs-include-markdown-plugin>=3.6.1,<8.0.0",
   "mkdocs-material>=8.4.1,<10.0.0",
   "mkdocstrings[python]",
   "mkdocs-material-extensions",
@@ -78,7 +76,7 @@ python = "3.12"
 features = ["test"]
 
 [[tool.hatch.envs.test.matrix]]
-python = ["3.10", "3.11", "3.12"]
+python = ["3.11", "3.12"]
 
 [tool.hatch.envs.test.scripts]
 cov = "pytest -vvv --asyncio-mode=auto --cov=ember_mug --cov-branch --cov-report=xml --cov-report=term-missing tests"
@@ -95,7 +93,7 @@ serve = "mkdocs serve --dev-addr localhost:8000"
 [tool.black]
 line-length = 120
 skip-string-normalization = true
-target-version = ['py310', 'py311', 'py312']
+target-version = ["py311", "py312"]
 include = '\.pyi?$'
 exclude = '''
 /(
@@ -126,7 +124,7 @@ exclude_lines = [
 [tool.ruff]
 fix = true
 line-length = 120
-target-version = "py310"
+target-version = "py311"
 select = [
     "A",
     "ASYNC",

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/tests/cli/test_commands.py

@@ -13,13 +13,13 @@ from ember_mug import EmberMug
 from ember_mug.cli.commands import (
     EmberMugCli,
     colour_type,
-    discover,
-    fetch_info,
-    find_device,
-    get_mug,
-    get_mug_value,
-    poll_mug,
-    set_mug_value,
+    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
@@ -34,7 +34,7 @@ if TYPE_CHECKING:
 
 @pytest.fixture()
 def mock_mug_with_connection() -> Generator[AsyncMock, None, None]:
-    with patch("ember_mug.cli.commands.get_mug") as mock:
+    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
@@ -54,18 +54,18 @@ def mock_namespace(**kwargs: Any) -> Namespace:
 
 
 @patch("ember_mug.cli.commands.EmberMug", spec=EmberMug)
-@patch("ember_mug.cli.commands.find_device")
-async def test_get_mug(
-    mock_find_device: AsyncMock,
+@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.return_value = ble_device, TEST_MUG_ADVERTISEMENT
+    mock_find_device_cmd.return_value = ble_device, TEST_MUG_ADVERTISEMENT
     args = mock_namespace(extra=True)
-    mug = await get_mug(args)
+    mug = await get_device(args)
     assert mug is not None
-    mock_find_device.assert_called_once_with(args)
+    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),
@@ -77,17 +77,17 @@ async def test_get_mug(
 
     # Raw prints nothing
     args = mock_namespace(extra=True, raw=True)
-    mug = await get_mug(args)
+    mug = await get_device(args)
     assert mug is not None
     captured = capsys.readouterr()
     assert captured.out == ""
 
 
-@patch("ember_mug.cli.commands.find_mug")
+@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(args)
+    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)
@@ -96,38 +96,38 @@ async def test_find_device(mock_find_mug: AsyncMock, capsys: CaptureFixture, ble
 
     # Raw prints nothing
     args = Namespace(mac=ble_device.address, adapter=None, raw=True)
-    await find_device(args)
+    await find_device_cmd(args)
     captured = capsys.readouterr()
     assert captured.out == ""
 
 
-@patch("ember_mug.cli.commands.find_mug")
+@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(args)
+        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_mug")
+@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(args)
+        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_mugs")
+@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(args)
+    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()
@@ -141,30 +141,30 @@ async def test_discover(mock_discover_mugs: AsyncMock, capsys: CaptureFixture, b
 
     mock_discover_mugs.reset_mock()
     args = mock_namespace(mac=TEST_MAC, raw=True)
-    mugs = await discover(args)
+    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_mugs")
+@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(args)
+        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_mugs")
+@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(args)
+        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"
@@ -178,14 +178,14 @@ async def test_fetch_info(
 ) -> None:
     # Test normal
     args = mock_namespace(mac=TEST_MAC)
-    await fetch_info(args)
+    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(args)
+    await fetch_info_cmd(args)
     captured = capsys.readouterr()
     assert captured.out == ""
 
@@ -194,7 +194,7 @@ async def test_fetch_info(
 @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_mug(
+async def test_poll_device_cmd(
     mock_print_changes: AsyncMock,
     mock_print_info: AsyncMock,
     mock_sleep: AsyncMock,
@@ -203,7 +203,7 @@ async def test_poll_mug(
 ) -> None:
     # Test normal
     args = mock_namespace(mac=TEST_MAC)
-    await poll_mug(args)
+    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)
@@ -211,14 +211,14 @@ async def test_poll_mug(
     # Test with Raw
     mock_sleep.reset_mock()
     args = mock_namespace(mac=TEST_MAC, raw=True)
-    await poll_mug(args)
+    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_mug_value(
+async def test_get_device_value_cmd(
     mocked_print_table: Mock,
     mock_mug_with_connection: AsyncMock,
     capsys: CaptureFixture,
@@ -228,25 +228,25 @@ async def test_get_mug_value(
     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_mug_value(args)
+    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_mug_value(args)
+    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_mug_value(args)
+        await get_device_value_cmd(args)
 
 
-async def test_set_mug_value_no_value(capsys: CaptureFixture) -> None:
+async def test_set_device_value_cmd_no_value(capsys: CaptureFixture) -> None:
     with pytest.raises(SystemExit, match="1"):
-        await set_mug_value(Namespace())
+        await set_device_value_cmd(Namespace())
     captured = capsys.readouterr()
     assert captured.out == (
         "Please specify at least one attribute and value to set.\n"
@@ -254,16 +254,16 @@ async def test_set_mug_value_no_value(capsys: CaptureFixture) -> None:
     )
 
 
-async def test_set_mug_value(mock_mug_with_connection: AsyncMock) -> None:
+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_mug_value(args)
+    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_mug_value(args)
+        await set_device_value_cmd(args)
 
 
 @pytest.mark.parametrize(

{python_ember_mug-1.0.1 → python_ember_mug-1.1.0}/tests/test_scanner.py

@@ -5,7 +5,7 @@ import pytest
 from bleak.backends.device import BLEDevice
 
 from ember_mug.consts import DEVICE_SERVICE_UUIDS
-from ember_mug.scanner import build_scanner_kwargs, discover_mugs, find_mug
+from ember_mug.scanner import build_scanner_kwargs, discover_devices, find_device
 
 from .conftest import TEST_MUG_ADVERTISEMENT
 
@@ -29,34 +29,34 @@ def test_build_scanner_kwargs_other() -> None:
 
 @patch("asyncio.sleep")
 @patch("ember_mug.scanner.BleakScanner")
-async def test_discover_mugs(mock_scanner: AsyncMock, mock_sleep: AsyncMock) -> None:
+async def test_discover_devices(mock_scanner: AsyncMock, mock_sleep: AsyncMock) -> None:
     mock_scanner.return_value.__aenter__.return_value.discovered_devices_and_advertisement_data = {
         m.address: (m, TEST_MUG_ADVERTISEMENT) for m in EXAMPLE_MUGS
     }
-    mugs = await discover_mugs()
-    assert len(mugs) == 2
-    mugs = await discover_mugs(mac="32:36:a5:be:88:cb")
-    assert len(mugs) == 1
-    device_1, advertisement_1 = mugs[0]
+    devices = await discover_devices()
+    assert len(devices) == 2
+    devices = await discover_devices(mac="32:36:a5:be:88:cb")
+    assert len(devices) == 1
+    device_1, advertisement_1 = devices[0]
     assert device_1.address == "32:36:a5:be:88:cb"
     mock_sleep.assert_called_with(5)
 
 
 @patch("asyncio.sleep")
 @patch("ember_mug.scanner.BleakScanner")
-async def test_find_mug(mock_scanner: AsyncMock, mock_sleep: AsyncMock) -> None:
+async def test_find_device(mock_scanner: AsyncMock, mock_sleep: AsyncMock) -> None:
     mock_data_iterator = MagicMock()
     mock_data_iterator().__aiter__.return_value = [(m, TEST_MUG_ADVERTISEMENT) for m in EXAMPLE_MUGS]
     mock_scanner.return_value.__aenter__.return_value.advertisement_data = mock_data_iterator
 
     # Without filter
-    mug, advertisement = await find_mug()
-    assert mug is not None
-    assert mug.name == "Ember Ceramic Mug"
-    assert mug.address == MUG_1.address
+    device, advertisement = await find_device()
+    assert device is not None
+    assert device.name == "Ember Ceramic Mug"
+    assert device.address == MUG_1.address
 
     # With Filter
-    mug, advertisement = await find_mug(mac=MUG_2.address)
-    assert mug is not None
-    assert mug.name == "Ember Ceramic Mug"
-    assert mug.address == MUG_2.address
+    device, advertisement = await find_device(mac=MUG_2.address)
+    assert device is not None
+    assert device.name == "Ember Ceramic Mug"
+    assert device.address == MUG_2.address