python-mystrom 2.4.0__tar.gz → 2.6.0__tar.gz

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: python-mystrom
-Version: 2.4.0
+Version: 2.6.0
 Summary: Asynchronous Python API client for interacting with myStrom devices
 License: MIT
+License-File: LICENSE
 Keywords: myStrom,API,client,asynchronous
 Author: Fabian Affolter
 Author-email: fabian@affolter-engineering.ch
@@ -12,6 +13,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: aiohttp
 Requires-Dist: click
 Requires-Dist: requests

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/pymystrom/__init__.py

@@ -20,12 +20,15 @@ async def _request(
     data: Optional[Any] = None,
     json_data: Optional[dict] = None,
     params: Optional[Mapping[str, str]] = None,
+    token: Optional[str] = None,
 ) -> Any:
     """Handle a request to the myStrom device."""
     headers = {
         "User-Agent": USER_AGENT,
         "Accept": "application/json, text/plain, */*",
     }
+    if token:
+        headers["Token"] = token
 
     if self._session is None:
         self._session = aiohttp.ClientSession()
@@ -53,7 +56,12 @@ async def _request(
         ) from exception
 
     content_type = response.headers.get("Content-Type", "")
-    if (response.status // 100) in [4, 5]:
+    if response.status == 404:
+        raise MyStromConnectionError(
+            "Error occurred while authenticating with myStrom device."
+        )
+
+    elif (response.status // 100) in [4, 5]:
         response.close()
 
     if "application/json" in content_type:

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/pymystrom/bulb.py

@@ -21,6 +21,7 @@ class MyStromBulb:
         self,
         host: str,
         mac: str,
+        token: Optional[str] = None,
         session: aiohttp.client.ClientSession = None,
     ) -> None:
         """Initialize the bulb."""
@@ -38,10 +39,11 @@ class MyStromBulb:
         self._state = None
         self._transition_time = 0
         self.uri = URL.build(scheme="http", host=self._host).join(URI_BULB) / self._mac
+        self.token = token
 
     async def get_state(self) -> None:
         """Get the state of the bulb."""
-        response = await request(self, uri=self.uri)
+        response = await request(self, uri=self.uri, token=self.token)
         self._consumption = response[self._mac]["power"]
         self._firmware = response[self._mac]["fw_version"]
         self._color = response[self._mac]["color"]
@@ -93,7 +95,7 @@ class MyStromBulb:
     async def set_on(self):
         """Turn the bulb on with the previous settings."""
         response = await request(
-            self, uri=self.uri, method="POST", data={"action": "on"}
+            self, uri=self.uri, method="POST", data={"action": "on"}, token=self.token
         )
         return response
 
@@ -109,7 +111,9 @@ class MyStromBulb:
             "action": "on",
             "color": value,
         }
-        response = await request(self, uri=self.uri, method="POST", data=data)
+        response = await request(
+            self, uri=self.uri, method="POST", data=data, token=self.token
+        )
         return response
 
     async def set_color_hsv(self, hue, saturation, value):
@@ -122,7 +126,9 @@ class MyStromBulb:
         #     'color': f"{hue};{saturation};{value}",
         # }
         data = "action=on&color={};{};{}".format(hue, saturation, value)
-        response = await request(self, uri=self.uri, method="POST", data=data)
+        response = await request(
+            self, uri=self.uri, method="POST", data=data, token=self.token
+        )
         return response
 
     async def set_white(self):
@@ -144,7 +150,9 @@ class MyStromBulb:
         await self.set_transition_time((duration / max_brightness))
         for i in range(0, duration):
             data = "action=on&color=3;{}".format(i)
-            await request(self, uri=self.uri, method="POST", data=data)
+            await request(
+                self, uri=self.uri, method="POST", data=data, token=self.token
+            )
             await asyncio.sleep(duration / max_brightness)
 
     async def set_flashing(self, duration, hsv1, hsv2):
@@ -159,14 +167,18 @@ class MyStromBulb:
     async def set_transition_time(self, value):
         """Set the transition time in ms."""
         response = await request(
-            self, uri=self.uri, method="POST", data={"ramp": int(round(value))}
+            self,
+            uri=self.uri,
+            method="POST",
+            data={"ramp": int(round(value))},
+            token=self.token,
         )
         return response
 
     async def set_off(self):
         """Turn the bulb off."""
         response = await request(
-            self, uri=self.uri, method="POST", data={"action": "off"}
+            self, uri=self.uri, method="POST", data={"action": "off"}, token=self.token
         )
         return response
 

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/pymystrom/cli.py

@@ -47,11 +47,15 @@ def config():
     prompt="MAC address of the device",
     help="MAC address of the device.",
 )
-def read_config(ip, mac):
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
+def read_config(ip, mac, token):
     """Read the current configuration of a myStrom device."""
     click.echo("Read configuration from %s" % ip)
     try:
-        request = requests.get("http://{}/{}/{}/".format(ip, URI, mac), timeout=TIMEOUT)
+        headers = {"Token": token} if token else {}
+        request = requests.get(
+            "http://{}/{}/{}/".format(ip, URI, mac), timeout=TIMEOUT, headers=headers
+        )
         click.echo(request.json())
     except requests.exceptions.ConnectionError:
         click.echo("Communication issue with the device")
@@ -71,6 +75,7 @@ def button():
     prompt="MAC address of the button",
     help="MAC address of the button.",
 )
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
 @click.option(
     "--single",
     prompt="URL for a single tap",
@@ -87,7 +92,7 @@ def button():
     "--long", prompt="URL for a long tab", default="", help="URL for a long tab."
 )
 @click.option("--touch", prompt="URL for a touch", default="", help="URL for a touch.")
-def write_config(ip, mac, single, double, long, touch):
+def write_config(ip, mac, token, single, double, long, touch):
     """Write the current configuration of a myStrom button."""
     click.echo("Write configuration to device %s" % ip)
     data = {
@@ -97,8 +102,12 @@ def write_config(ip, mac, single, double, long, touch):
         "touch": touch,
     }
     try:
+        headers = {"Token": token} if token else {}
         request = requests.post(
-            "http://{}/{}/{}/".format(ip, URI, mac), data=data, timeout=TIMEOUT
+            "http://{}/{}/{}/".format(ip, URI, mac),
+            data=data,
+            timeout=TIMEOUT,
+            headers=headers,
         )
 
         if request.status_code == 200:
@@ -116,6 +125,7 @@ def write_config(ip, mac, single, double, long, touch):
     prompt="MAC address of the button",
     help="MAC address of the button.",
 )
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
 @click.option(
     "--hass",
     prompt="IP address of the Home Assistant instance",
@@ -133,7 +143,7 @@ def write_config(ip, mac, single, double, long, touch):
     default="",
     help="ID of the myStrom button.",
 )
-def write_ha_config(ip, mac, hass, port, id):
+def write_ha_config(ip, mac, token, hass, port, id):
     """Write the configuration for Home Assistant to a myStrom button."""
     click.echo("Write configuration for Home Assistant to device %s..." % ip)
 
@@ -145,8 +155,12 @@ def write_ha_config(ip, mac, hass, port, id):
         "touch": action.format("touch", hass, port, id),
     }
     try:
+        headers = {"Token": token} if token else {}
         request = requests.post(
-            "http://{}/{}/{}/".format(ip, URI, mac), data=data, timeout=TIMEOUT
+            "http://{}/{}/{}/".format(ip, URI, mac),
+            data=data,
+            timeout=TIMEOUT,
+            headers=headers,
         )
 
         if request.status_code == 200:
@@ -170,7 +184,8 @@ def write_ha_config(ip, mac, hass, port, id):
     prompt="MAC address of the button",
     help="MAC address of the Wifi Button.",
 )
-def reset_config(ip, mac):
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
+def reset_config(ip, mac, token):
     """Reset the current configuration of a myStrom WiFi Button."""
     click.echo("Reset configuration of button %s..." % ip)
     data = {
@@ -180,8 +195,12 @@ def reset_config(ip, mac):
         "touch": "",
     }
     try:
+        headers = {"Token": token} if token else {}
         request = requests.post(
-            "http://{}/{}/{}/".format(ip, URI, mac), data=data, timeout=TIMEOUT
+            "http://{}/{}/{}/".format(ip, URI, mac),
+            data=data,
+            timeout=TIMEOUT,
+            headers=headers,
         )
 
         if request.status_code == 200:
@@ -201,11 +220,15 @@ def reset_config(ip, mac):
     prompt="MAC address of the button",
     help="MAC address of the Wifi Button.",
 )
-def read_config(ip, mac):
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
+def read_config(ip, mac, token):
     """Read the current configuration of a myStrom WiFi Button."""
     click.echo("Read the configuration of button %s..." % ip)
     try:
-        request = requests.get("http://{}/{}/{}/".format(ip, URI, mac), timeout=TIMEOUT)
+        headers = {"Token": token} if token else {}
+        request = requests.get(
+            "http://{}/{}/{}/".format(ip, URI, mac), timeout=TIMEOUT, headers=headers
+        )
         click.echo(request.json())
     except requests.exceptions.ConnectionError:
         click.echo("Communication issue with the device. No action performed")
@@ -222,9 +245,10 @@ def bulb():
 @click.option(
     "--mac", prompt="MAC address of the bulb", help="MAC address of the bulb."
 )
-async def on(ip, mac):
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
+async def on(ip, mac, token):
     """Switch the bulb on."""
-    async with MyStromBulb(ip, mac) as bulb:
+    async with MyStromBulb(ip=ip, mac=mac, token=token) as bulb:
         await bulb.set_color_hex("00FFFFFF")
 
 
@@ -234,6 +258,7 @@ async def on(ip, mac):
 @click.option(
     "--mac", prompt="MAC address of the bulb", help="MAC address of the bulb."
 )
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
 @click.option(
     "--hue", prompt="Set the hue of the bulb", help="Set the hue of the bulb."
 )
@@ -247,9 +272,9 @@ async def on(ip, mac):
     prompt="Set the value of the bulb",
     help="Set the value of the bulb.",
 )
-async def color(ip, mac, hue, saturation, value):
+async def color(ip, mac, token, hue, saturation, value):
     """Switch the bulb on with the given color."""
-    async with MyStromBulb(ip, mac) as bulb:
+    async with MyStromBulb(ip=ip, mac=mac, token=token) as bulb:
         await bulb.set_color_hsv(hue, saturation, value)
 
 
@@ -259,9 +284,10 @@ async def color(ip, mac, hue, saturation, value):
 @click.option(
     "--mac", prompt="MAC address of the bulb", help="MAC address of the bulb."
 )
-async def off(ip, mac):
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
+async def off(ip, mac, token):
     """Switch the bulb off."""
-    async with MyStromBulb(ip, mac) as bulb:
+    async with MyStromBulb(ip=ip, mac=mac, token=token) as bulb:
         await bulb.set_off()
 
 
@@ -271,15 +297,16 @@ async def off(ip, mac):
 @click.option(
     "--mac", prompt="MAC address of the bulb", help="MAC address of the bulb."
 )
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
 @click.option(
     "--time",
     prompt="Time to flash",
     help="Time to flash the bulb in seconds.",
     default=10,
 )
-async def flash(ip, mac, time):
+async def flash(ip, mac, token, time):
     """Flash the bulb off."""
-    async with MyStromBulb(ip, mac) as bulb:
+    async with MyStromBulb(ip=ip, mac=mac, token=token) as bulb:
         await bulb.set_flashing(time, [100, 50, 30], [200, 0, 71])
 
 
@@ -289,15 +316,16 @@ async def flash(ip, mac, time):
 @click.option(
     "--mac", prompt="MAC address of the bulb", help="MAC address of the bulb."
 )
+@click.option("--token", prompt="Token of the device", help="Token of the device.")
 @click.option(
     "--time",
     prompt="Time for the complete rainbow",
     help="Time to perform the rainbow in seconds.",
     default=30,
 )
-async def rainbow(ip, mac, time):
+async def rainbow(ip, mac, token, time):
     """Let the buld change the color and show a rainbow."""
-    async with MyStromBulb(ip, mac) as bulb:
+    async with MyStromBulb(ip=ip, mac=mac, token=token) as bulb:
         await bulb.set_rainbow(time)
         await bulb.set_transition_time(1000)
 

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/pymystrom/pir.py

@@ -13,10 +13,16 @@ URI_PIR = URL("api/v1/")
 class MyStromPir:
     """A class for a myStrom PIR."""
 
-    def __init__(self, host: str, session: aiohttp.client.ClientSession = None) -> None:
+    def __init__(
+        self,
+        host: str,
+        session: aiohttp.client.ClientSession = None,
+        token: Optional[str] = None,
+    ) -> None:
         """Initialize the switch."""
         self._close_session = False
         self._host = host
+        self._token = token
         self._session = session
         self._intensity = None
         self._day = None
@@ -36,25 +42,25 @@ class MyStromPir:
     async def get_settings(self) -> None:
         """Get the current settings from the PIR."""
         url = URL(self.uri).join(URL("settings"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         self._settings = response
 
     async def get_actions(self) -> None:
         """Get the current action settings from the PIR."""
         url = URL(self.uri).join(URL("action"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         self._actions = response
 
     async def get_pir(self) -> None:
         """Get the current PIR settings."""
         url = URL(self.uri).join(URL("settings/pir"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         self._pir = response
 
     async def get_sensors_state(self) -> None:
         """Get the state of the sensors from the PIR."""
         url = URL(self.uri).join(URL("sensors"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         # The return data has the be re-written as the temperature is not rounded
         self._sensors = {
             "motion": response["motion"],
@@ -66,7 +72,7 @@ class MyStromPir:
         """Get the temperatures from the PIR."""
         # There is a different URL for the temp endpoint
         url = URL.build(scheme="http", host=self._host) / "temp"
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         self._temperature_raw = response
         self._temperature_measured = round(response["measured"], 2)
         self._temperature_compensated = round(response["compensated"], 2)
@@ -75,13 +81,13 @@ class MyStromPir:
     async def get_motion(self) -> None:
         """Get the state of the motion sensor from the PIR."""
         url = URL(self.uri).join(URL("motion"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         self._motion = response["motion"]
 
     async def get_light(self) -> None:
         """Get the state of the light sensor from the PIR."""
         url = URL(self.uri).join(URL("light"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         self._intensity = response["intensity"]
         self._day = response["day"]
         self._light_raw = response["raw"]

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/pymystrom/switch.py

@@ -12,10 +12,16 @@ from .device_types import DEVICE_MAPPING_LITERAL, DEVICE_MAPPING_NUMERIC
 class MyStromSwitch:
     """A class for a myStrom switch/plug."""
 
-    def __init__(self, host: str, session: aiohttp.client.ClientSession = None) -> None:
+    def __init__(
+        self,
+        host: str,
+        session: aiohttp.client.ClientSession = None,
+        token: Optional[str] = None,
+    ) -> None:
         """Initialize the switch."""
         self._close_session = False
         self._host = host
+        self._token = token
         self._session = session
         self._consumption = 0
         self._consumedWs = 0
@@ -33,26 +39,26 @@ class MyStromSwitch:
         """Turn the relay on."""
         parameters = {"state": "1"}
         url = URL(self.uri).join(URL("relay"))
-        await request(self, uri=url, params=parameters)
+        await request(self, uri=url, params=parameters, token=self._token)
         await self.get_state()
 
     async def turn_off(self) -> None:
         """Turn the relay off."""
         parameters = {"state": "0"}
         url = URL(self.uri).join(URL("relay"))
-        await request(self, uri=url, params=parameters)
+        await request(self, uri=url, params=parameters, token=self._token)
         await self.get_state()
 
     async def toggle(self) -> None:
         """Toggle the relay."""
         url = URL(self.uri).join(URL("toggle"))
-        await request(self, uri=url)
+        await request(self, uri=url, token=self._token)
         await self.get_state()
 
     async def get_state(self) -> None:
         """Get the details from the switch/plug."""
         url = URL(self.uri).join(URL("report"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         try:
             self._consumption = response["power"]
         except KeyError:
@@ -81,15 +87,16 @@ class MyStromSwitch:
 
         # Try the new API (Devices with newer firmware)
         url = URL(self.uri).join(URL("api/v1/info"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         if not isinstance(response, dict):
             # Fall back to the old API version if the device runs with old firmware
             url = URL(self.uri).join(URL("info.json"))
-            response = await request(self, uri=url)
+            response = await request(self, uri=url, token=self._token)
 
-        self._firmware = response["version"]
-        self._mac = response["mac"]
-        self._device_type = response["type"]
+        # Tolerate missing keys on legacy firmware (e.g., v1 devices)
+        self._firmware = response.get("version")
+        self._mac = response.get("mac")
+        self._device_type = response.get("type")
 
     @property
     def device_type(self) -> Optional[str]:
@@ -160,7 +167,7 @@ class MyStromSwitch:
     async def get_temperature_full(self) -> str:
         """Get current temperature in celsius."""
         url = URL(self.uri).join(URL("temp"))
-        response = await request(self, uri=url)
+        response = await request(self, uri=url, token=self._token)
         return response
 
     async def close(self) -> None:

{python_mystrom-2.4.0 → python_mystrom-2.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "python-mystrom"
-version = "2.4.0"
+version = "2.6.0"
 description = "Asynchronous Python API client for interacting with myStrom devices"
 authors = ["Fabian Affolter <fabian@affolter-engineering.ch>"]
 license = "MIT"