python-ember-mug 0.7.0b4__tar.gz → 0.7.0b6__tar.gz

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-ember-mug
-Version: 0.7.0b4
+Version: 0.7.0b6
 Summary: Python Library for Ember Mugs.
 Home-page: https://github.com/sopelj/python-ember-mug
 License: MIT

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/ember_mug/__init__.py

@@ -5,4 +5,4 @@ __all__ = ('EmberMug',)
 
 __author__ = """Jesse Sopel"""
 __email__ = 'jesse.sopel@gmail.com'
-__version__ = '0.7.0b4'
+__version__ = '0.7.0b6'

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/ember_mug/cli/commands.py

@@ -12,7 +12,7 @@ from typing import TYPE_CHECKING
 
 from bleak import BleakError
 
-from ..consts import ATTR_LABELS, EXTRA_ATTRS
+from ..consts import ATTR_LABELS, EXTRA_ATTRS, VolumeLevel
 from ..data import Colour
 from ..mug import EmberMug
 from ..scanner import discover_mugs, find_mug
@@ -103,7 +103,11 @@ async def get_mug_value(args: Namespace) -> None:
     attributes = [a.replace('-', '_') for a in args.attributes]
     async with mug.connection(adapter=args.adapter):
         for attr in attributes:
-            value = await getattr(mug, f'get_{attr}')()
+            try:
+                value = await getattr(mug, f'get_{attr}')()
+            except NotImplementedError as e:
+                print(e)
+                sys.exit(1)
             setattr(mug.data, attr, value)
             data[attr] = value
     if args.raw:
@@ -114,7 +118,7 @@ async def get_mug_value(args: Namespace) -> None:
 
 async def set_mug_value(args: Namespace) -> None:
     """Set one or more values on the mug."""
-    attrs = ('name', 'target_temp', 'temperature_unit', 'led_colour')
+    attrs = ('name', 'target_temp', 'temperature_unit', 'led_colour', 'volume_level')
     values = [(attr, value) for attr in attrs if (value := getattr(args, attr))]
     if not values:
         print('Please specify at least one attribute and value to set.')
@@ -127,7 +131,11 @@ async def set_mug_value(args: Namespace) -> None:
         for attr, value in values:
             method = getattr(mug, f'set_{attr.replace("-", "_")}')
             print(f'Setting {attr} to {value}')
-            await method(value)
+            try:
+                await method(value)
+            except NotImplementedError as e:
+                print(e)
+                sys.exit(1)
 
 
 def colour_type(value: str) -> Colour:
@@ -205,6 +213,12 @@ class EmberMugCli:
         set_parser.add_argument('--target-temp', help='Target Temperature', type=float, required=False)
         set_parser.add_argument('--temperature-unit', help='Temperature Unit', choices=['C', 'F'], required=False)
         set_parser.add_argument('--led-colour', help='LED Colour', type=colour_type, required=False)
+        set_parser.add_argument(
+            '--volume-level',
+            help='Volume Level',
+            choices=[v.value for v in VolumeLevel],
+            required=False,
+        )
 
     async def run(self) -> None:
         """Run the specified command based on subparser."""

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/ember_mug/consts.py

@@ -205,6 +205,7 @@ EXTRA_ATTRS = {'dsk', 'udsk', 'battery_voltage', 'date_time_zone'}
 
 # Validation
 MUG_NAME_REGEX = re.compile(r"^[A-Za-z0-9,.\[\]#()!\"\';:|\-_+<>%= ]{1,16}$")
+MUG_NAME_PATTERN = MUG_NAME_REGEX.pattern
 MAC_ADDRESS_REGEX = re.compile(r"^([0-9A-Fa-f]{2}:){5}([0-9A-Fa-f]{2})$")
 
 IS_LINUX = platform.system() == "Linux"

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/ember_mug/data.py

@@ -155,6 +155,11 @@ class Model:
             return INITIAL_ATTRS - EXTRA_ATTRS
         return INITIAL_ATTRS
 
+    @cached_property
+    def all_attributes(self) -> set[str]:
+        """All attributes."""
+        return self.initial_attributes | self.update_attributes
+
     @cached_property
     def update_attributes(self) -> set[str]:
         """Attributes to update based on model and extra."""
@@ -279,8 +284,9 @@ class MugData:
         data = {k: asdict(v) if is_dataclass(v) else v for k, v in asdict(self).items()}
         data.update(
             {
-                f'{attr}_display': getattr(self, f'{attr}_display')
-                for attr in ('led_colour', 'liquid_state', 'liquid_level', 'current_temp', 'target_temp')
+                f'{attr}_display': getattr(self, f'{attr}_display', None)
+                for attr in self.model.all_attributes
+                if hasattr(self, f'{attr}_display')
             },
         )
         return data

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/ember_mug/mug.py

@@ -31,8 +31,8 @@ from .utils import (
     bytes_to_big_int,
     bytes_to_little_int,
     decode_byte_string,
+    discover_services,
     encode_byte_string,
-    log_services,
     temp_from_bytes,
 )
 
@@ -69,6 +69,10 @@ class EmberMug:
         self._latest_events: dict[int, float] = {}
         self._client_kwargs: dict[str, str] = {}
 
+        # Just shortcuts, the value doesn't change once initialized
+        self.is_travel_mug = self.data.model.is_travel_mug
+        self.is_cup = self.data.model.is_cup
+
         logger.debug("New mug connection initialized.")
         self.set_client_options(**kwargs)
 
@@ -105,7 +109,7 @@ class EmberMug:
                     ble_device_callback=lambda: self.device,
                 )
                 if self.debug is True:
-                    log_services(client.services)
+                    await discover_services(client)
                 self._expected_disconnect = False
             except (asyncio.TimeoutError, BleakError) as error:
                 logger.error("%s: Failed to connect to the mug: %s", self.device, error)
@@ -195,10 +199,14 @@ class EmberMug:
 
     async def get_led_colour(self) -> Colour:
         """Get RGBA colours from mug gatt."""
+        if self.is_travel_mug is True:
+            raise NotImplementedError('The Travel Mug does not have an LED colour attribute')
         return Colour.from_bytes(await self._read(MugCharacteristic.LED))
 
     async def set_led_colour(self, colour: Colour) -> None:
         """Set new target temp for mug."""
+        if self.is_travel_mug is True:
+            raise NotImplementedError('The Travel Mug does not have an LED colour attribute')
         colour = Colour(*colour[:3], 255)  # It always expects 255 for alpha
         await self._write(MugCharacteristic.LED, colour.as_bytearray())
         self.data.led_colour = colour
@@ -226,13 +234,9 @@ class EmberMug:
 
     async def get_volume_level(self) -> VolumeLevel | None:
         """Get volume level from mug gatt."""
-        try:
-            volume_bytes = await self._read(MugCharacteristic.VOLUME)
-        except BleakError as e:
-            if not self.data.model.is_travel_mug:
-                raise NotImplementedError('Ony the travel mug has a volume')
-            logger.error('Failed to fetch volume attribute: %s', e)
-            return None
+        if self.is_travel_mug is False:
+            raise NotImplementedError('The Mug and Cup do not have a volume level attribute')
+        volume_bytes = await self._read(MugCharacteristic.VOLUME)
         volume_int = bytes_to_little_int(volume_bytes)
         return VolumeLevel.from_state(volume_int)
 
@@ -240,8 +244,10 @@ class EmberMug:
         """Set volume_level on Travel Mug."""
         if volume not in (0, 1, 2):
             raise ValueError('Volume level must be between 0 and 2 inclusively')
+        if self.is_travel_mug is False:
+            raise NotImplementedError('The Mug and Cup do not have a volume level attribute')
         volume_level = volume if isinstance(volume, VolumeLevel) else VolumeLevel.from_state(volume)
-        await self._write(MugCharacteristic.VOLUME, bytearray(bytearray([volume_level.state])))
+        await self._write(MugCharacteristic.VOLUME, bytearray([volume_level.state]))
         self.data.volume_level = volume_level
 
     async def get_liquid_state(self) -> LiquidState:
@@ -252,13 +258,17 @@ class EmberMug:
 
     async def get_name(self) -> str:
         """Get mug name from gatt."""
+        if self.is_cup is True:
+            raise NotImplementedError('The Cup does not have a name attribute')
         name_bytes: bytearray = await self._read(MugCharacteristic.MUG_NAME)
         return bytes(name_bytes).decode("utf8")
 
     async def set_name(self, name: str) -> None:
         """Assign new name to mug."""
         if MUG_NAME_REGEX.match(name) is None:
-            raise ValueError('Name cannot contain any special characters')
+            raise ValueError('Name cannot contain any special characters and must be 16 characters or less')
+        if self.is_cup is True:
+            raise NotImplementedError('The Cup does not have a name attribute')
         await self._write(MugCharacteristic.MUG_NAME, bytearray(name.encode("utf8")))
         self.data.name = name
 

python_ember_mug-0.7.0b6/ember_mug/utils.py

@@ -0,0 +1,100 @@
+"""Helpful utils for processing mug data."""
+from __future__ import annotations
+
+import base64
+import contextlib
+import logging
+import re
+from typing import TYPE_CHECKING, Any
+
+from bleak import BleakError
+
+if TYPE_CHECKING:
+    from bleak import BleakClient
+
+logger = logging.getLogger(__name__)
+
+
+def decode_byte_string(data: bytes | bytearray) -> str:
+    """Convert bytes to text as Ember expects."""
+    if not data:
+        return ''
+    with contextlib.suppress(ValueError):
+        b64_as_str = base64.encodebytes(data).decode("utf-8")
+        return re.sub("[\r\n]", "", b64_as_str)
+    logger.warning('Failed to decode bytes "%s". Forcing to string.', data)
+    return str(data)
+
+
+def encode_byte_string(data: str) -> bytes:
+    """Encode string from Ember Mug."""
+    return re.sub(b"[\r\n]", b"", base64.encodebytes(data.encode("utf8")))
+
+
+def bytes_to_little_int(data: bytearray | bytes) -> int:
+    """Convert bytes to little int."""
+    return int.from_bytes(data, byteorder="little", signed=False)
+
+
+def bytes_to_big_int(data: bytearray | bytes) -> int:
+    """Convert bytes to big int."""
+    return int.from_bytes(data, byteorder="big")
+
+
+def temp_from_bytes(temp_bytes: bytearray, metric: bool = True) -> float:
+    """Get temperature from bytearray and convert to Fahrenheit if needed."""
+    temp = float(bytes_to_little_int(temp_bytes)) * 0.01
+    if metric is False:
+        # Convert to fahrenheit
+        temp = (temp * 9 / 5) + 32
+    return round(temp, 2)
+
+
+async def discover_services(client: BleakClient) -> dict[str, Any]:
+    """Log all services and all values for debugging/development."""
+    logger.info("Logging all services that were discovered")
+    services: dict[str, Any] = {}
+    for service in client.services:
+        logger.debug("[Service] %s: %s", service.uuid, service.description)
+        characteristics: dict[str, Any] = {}
+        services[service.uuid] = {
+            'uuid': service.uuid,
+            'characteristics': characteristics,
+        }
+        for characteristic in service.characteristics:
+            value: bytes | BleakError | None = None
+            if "read" in characteristic.properties:
+                try:
+                    value = bytes(await client.read_gatt_char(characteristic.uuid))
+                except BleakError as e:
+                    value = e
+            logger.debug(
+                "\t[Characteristic] %s: %s | Description: %s | Value: '%s'",
+                characteristic.uuid,
+                ",".join(characteristic.properties),
+                characteristic.description,
+                value,
+            )
+            descriptors: list[dict[str, Any]] = []
+            characteristics[characteristic.uuid] = {
+                'uuid': characteristic.uuid,
+                'properties': characteristic.properties,
+                'value': value,
+                'descriptors': descriptors,
+            }
+            for descriptor in characteristic.descriptors:
+                value = bytes(await client.read_gatt_descriptor(descriptor.handle))
+                logger.debug(
+                    "\t\t[Descriptor] %s: Handle: %s | Value: '%s'",
+                    descriptor.uuid,
+                    descriptor.handle,
+                    value,
+                )
+                descriptors.append(
+                    {
+                        'uuid': descriptor.uuid,
+                        'handle': descriptor.handle,
+                        'value': value,
+                    },
+                )
+    return services

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/pyproject.toml

@@ -1,7 +1,7 @@
 [tool]
 [tool.poetry]
 name = "python-ember-mug"
-version = "0.7.0b4"
+version = "0.7.0b6"
 homepage = "https://github.com/sopelj/python-ember-mug"
 description = "Python Library for Ember Mugs."
 authors = ["Jesse Sopel <jesse.sopel@gmail.com>"]

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/tests/test_consts.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 from uuid import UUID
 
-from ember_mug.consts import LiquidState, MugCharacteristic
+from ember_mug.consts import LiquidState, MugCharacteristic, VolumeLevel
 
 
 def test_mug_uuids() -> None:
@@ -20,3 +20,13 @@ def test_liquid_state() -> None:
     assert LiquidState(5).label == "Heating"
     assert LiquidState(6).label == "Perfect"
     assert LiquidState(7).label == "Warm (No control)"
+
+
+def test_volume_level() -> None:
+    assert VolumeLevel.from_state(0) == VolumeLevel.LOW
+    assert VolumeLevel.from_state(1) == VolumeLevel.MEDIUM
+    assert VolumeLevel.from_state(2) == VolumeLevel.HIGH
+
+    assert VolumeLevel.HIGH.state == 2
+    assert VolumeLevel.MEDIUM.state == 1
+    assert VolumeLevel.LOW.state == 0

{python_ember_mug-0.7.0b4 → python_ember_mug-0.7.0b6}/tests/test_mug_data.py

@@ -92,6 +92,7 @@ def test_mug_dict(mug_data: MugData) -> None:
         'liquid_state': LiquidState.UNKNOWN,
         'liquid_state_display': 'Unknown',
         'meta': {'mug_id': 'test_id', 'serial_number': 'serial number'},
+        'meta_display': 'Serial Number: serial number',
         'name': '',
         'target_temp': 0.0,
         'target_temp_display': '0.00°C',

python_ember_mug-0.7.0b6/tests/test_utils.py

@@ -0,0 +1,70 @@
+"""Tests for `ember_mug.utils`."""
+from unittest.mock import AsyncMock, MagicMock, Mock, call, patch
+
+from ember_mug.utils import (
+    bytes_to_big_int,
+    bytes_to_little_int,
+    decode_byte_string,
+    discover_services,
+    encode_byte_string,
+    temp_from_bytes,
+)
+
+
+def test_bytes_to_little_int() -> None:
+    assert bytes_to_little_int(b'\x05') == 5
+
+
+def test_bytes_to_big_int() -> None:
+    assert bytes_to_big_int(b'\x01\xc2') == 450
+
+
+def test_temp_from_bytes() -> None:
+    raw_data = bytearray(b'\xcd\x15')  # int: 5581
+    assert temp_from_bytes(raw_data) == 55.81
+    assert temp_from_bytes(raw_data, metric=False) == 132.46
+
+
+def test_decode_byte_string() -> None:
+    assert decode_byte_string(b'abcd12345') == 'YWJjZDEyMzQ1'
+    assert decode_byte_string(b'') == ''
+
+
+def test_encode_byte_string() -> None:
+    assert encode_byte_string('abcd12345') == b'YWJjZDEyMzQ1'
+
+
+@patch('ember_mug.utils.logger')
+async def test_discover_services(read_gatt_descriptor: Mock) -> None:
+    mock_descriptor = MagicMock(uuid='test-desc', handle=2)
+    mock_characteristic = MagicMock(
+        uuid='char-abc',
+        description='test char',
+        properties=['read'],
+        descriptors=[mock_descriptor],
+    )
+    mock_service = MagicMock(
+        uuid='service-abc',
+        description='test service',
+        characteristics=[mock_characteristic],
+    )
+    client = AsyncMock(services=[mock_service])
+    client.read_gatt_char = AsyncMock(return_value=bytearray(b'test char'))
+    client.read_gatt_descriptor = AsyncMock(return_value=bytearray(b'test descriptor'))
+    await discover_services(client)
+    read_gatt_descriptor.assert_has_calls(
+        [
+            call.info('Logging all services that were discovered'),
+            call.debug('[Service] %s: %s', 'service-abc', 'test service'),
+            call.debug(
+                "\t[Characteristic] %s: %s | Description: %s | Value: '%s'",
+                'char-abc',
+                'read',
+                'test char',
+                b'test char',
+            ),
+            call.debug("\t\t[Descriptor] %s: Handle: %s | Value: '%s'", 'test-desc', 2, b'test descriptor'),
+        ],
+    )
+    client.read_gatt_char.assert_called_once_with('char-abc')
+    client.read_gatt_descriptor.assert_called_once_with(2)

python_ember_mug-0.7.0b4/ember_mug/utils.py

@@ -1,62 +0,0 @@
-"""Helpful utils for processing mug data."""
-from __future__ import annotations
-
-import base64
-import contextlib
-import logging
-import re
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from bleak import BleakGATTServiceCollection
-
-logger = logging.getLogger(__name__)
-
-
-def decode_byte_string(data: bytes | bytearray) -> str:
-    """Convert bytes to text as Ember expects."""
-    if not data:
-        return ''
-    with contextlib.suppress(ValueError):
-        b64_as_str = base64.encodebytes(data).decode("utf-8")
-        return re.sub("[\r\n]", "", b64_as_str)
-    logger.warning('Failed to decode bytes "%s". Forcing to string.', data)
-    return str(data)
-
-
-def encode_byte_string(data: str) -> bytes:
-    """Encode string from Ember Mug."""
-    return re.sub(b"[\r\n]", b"", base64.encodebytes(data.encode("utf8")))
-
-
-def bytes_to_little_int(data: bytearray | bytes) -> int:
-    """Convert bytes to little int."""
-    return int.from_bytes(data, byteorder="little", signed=False)
-
-
-def bytes_to_big_int(data: bytearray | bytes) -> int:
-    """Convert bytes to big int."""
-    return int.from_bytes(data, byteorder="big")
-
-
-def temp_from_bytes(temp_bytes: bytearray, metric: bool = True) -> float:
-    """Get temperature from bytearray and convert to Fahrenheit if needed."""
-    temp = float(bytes_to_little_int(temp_bytes)) * 0.01
-    if metric is False:
-        # Convert to fahrenheit
-        temp = (temp * 9 / 5) + 32
-    return round(temp, 2)
-
-
-def log_services(services: BleakGATTServiceCollection) -> None:
-    """Log services for debugging."""
-    logger.debug("Logging all services that were discovered")
-    for service in services:
-        logger.debug(
-            "Service '%s' (UUID: %s) has the characteristics:\n %s",
-            service.description,
-            service.uuid,
-            "\n".join(
-                f'{characteristic.uuid}: {characteristic.description}' for characteristic in service.characteristics
-            ),
-        )

python_ember_mug-0.7.0b4/tests/test_utils.py

@@ -1,32 +0,0 @@
-"""Tests for `ember_mug.utils`."""
-
-from ember_mug.utils import (
-    bytes_to_big_int,
-    bytes_to_little_int,
-    decode_byte_string,
-    encode_byte_string,
-    temp_from_bytes,
-)
-
-
-def test_bytes_to_little_int() -> None:
-    assert bytes_to_little_int(b'\x05') == 5
-
-
-def test_bytes_to_big_int() -> None:
-    assert bytes_to_big_int(b'\x01\xc2') == 450
-
-
-def test_temp_from_bytes() -> None:
-    raw_data = bytearray(b'\xcd\x15')  # int: 5581
-    assert temp_from_bytes(raw_data) == 55.81
-    assert temp_from_bytes(raw_data, metric=False) == 132.46
-
-
-def test_decode_byte_string() -> None:
-    assert decode_byte_string(b'abcd12345') == 'YWJjZDEyMzQ1'
-    assert decode_byte_string(b'') == ''
-
-
-def test_encode_byte_string() -> None:
-    assert encode_byte_string('abcd12345') == b'YWJjZDEyMzQ1'