pycololight 2.0.0__tar.gz → 2.2.0__tar.gz

pycololight-2.2.0/CHANGELOG.md

@@ -0,0 +1,73 @@
+# Changelog
+
+## [2.2.0](https://github.com/BazaJayGee66/pycololight/compare/2.1.0...2.2.0) (2026-11-01)
+
+
+### Features
+
+* add full type hints and ship a py.typed marker ([#9](https://github.com/BazaJayGee66/pycololight/issues/9)) ([03da40a](https://github.com/BazaJayGee66/pycololight/commit/03da40a8eb01bdf6e38eb11621ffcc3ac1850f63))
+
+
+### Bug Fixes
+
+* open a socket per call so polls and commands can't share one ([#6](https://github.com/BazaJayGee66/pycololight/issues/6)) ([16aba29](https://github.com/BazaJayGee66/pycololight/commit/16aba298bc8dc8326df326c7f289c2fb74be0efe))
+* report no brightness while the light is off ([#7](https://github.com/BazaJayGee66/pycololight/issues/7)) ([66e38d1](https://github.com/BazaJayGee66/pycololight/commit/66e38d1413d76ba68a7db2200dfc97add92a190e))
+
+## 2.1.0
+
+### New Features
+
+- Add ability to set timeout for device
+
+## 2.0.0
+
+This release enables support for the cololight strip device.
+
+### New Features
+
+- Add support for the cololight strip device
+- Add dynamic effects for the cololight strip device
+- Add custom effects for the cololight strip device
+
+### Breaking Changes
+
+- A device (`hexagon` or `strip`) must now be passed when creating `PyCololight` object
+
+## 1.0.0
+
+### New Features
+
+- Add state to get light state (on/off) and brightness - Thanks [@pim12345](https://github.com/pim12345)
+
+### Fixes
+
+- Add missing exceptions
+- Add BrightnessException if brightness not between 0 and 100
+- Refactor for simpler code
+- Rename `include_default_effects` to `restore_default_effects`
+- Remove `count` property
+- Add type hints, and docstring
+
+## 0.0.2
+
+### New Features
+
+### Fixes
+
+- Refactor for simpler code
+
+## 0.0.1
+
+Initial Release
+
+### New Features
+
+- Turn On
+- Turn Off
+- Set brightness
+- Set colour
+- Set effect
+- Include/Exclude default effects
+- Add custom effect
+
+### Fixes

{pycololight-2.0.0 → pycololight-2.2.0}/PKG-INFO

@@ -1,16 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: pycololight
-Version: 2.0.0
+Version: 2.2.0
 Summary: A Python3 wrapper for interacting with LifeSmart Cololight
-Home-page: https://github.com/BazaJayGee66/pycololight
-License: MIT
 Author: BazaJayGee66
-Requires-Python: >=3.8,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
 Project-URL: Repository, https://github.com/BazaJayGee66/pycololight
 Description-Content-Type: text/markdown
 
@@ -48,11 +43,11 @@ light.effect = "Sunrise"
 
 # Create custom effect
 light.add_custom_effect(
-  name="custom effect",
-  colour_scheme="Shadow",
-  colour="Red, Yellow",
-  cycle_speed=11,
-  mode=1
+    name="custom effect",
+    colour_scheme="Shadow",
+    colour="Red, Yellow",
+    cycle_speed=11,
+    mode=1,
 )
 
 # Turn off
@@ -60,4 +55,3 @@ light.on = 0
 ```
 
 Mapping of modes for custom effects can be found [here](https://github.com/BazaJayGee66/pycololight/blob/main/MODES.md)
-

{pycololight-2.0.0 → pycololight-2.2.0}/README.md

@@ -32,11 +32,11 @@ light.effect = "Sunrise"
 
 # Create custom effect
 light.add_custom_effect(
-  name="custom effect",
-  colour_scheme="Shadow",
-  colour="Red, Yellow",
-  cycle_speed=11,
-  mode=1
+    name="custom effect",
+    colour_scheme="Shadow",
+    colour="Red, Yellow",
+    cycle_speed=11,
+    mode=1,
 )
 
 # Turn off

{pycololight-2.0.0 → pycololight-2.2.0}/pycololight/__init__.py

@@ -1,15 +1,27 @@
+from .effects import (
+    ColourException,
+    ColourSchemeException,
+    CycleSpeedException,
+    Effects,
+    ModeExecption,
+)
 from .pycololight import (
-    PyCololight,
-    DefaultEffectExecption,
     BrightnessException,
+    DefaultEffectExecption,
+    PyCololight,
     UnavailableException,
     UnsupportedDeviceException,
 )
 
-from .effects import (
-    Effects,
-    CycleSpeedException,
-    ColourSchemeException,
-    ColourException,
-    ModeExecption,
-)
+__all__ = [
+    "BrightnessException",
+    "ColourException",
+    "ColourSchemeException",
+    "CycleSpeedException",
+    "DefaultEffectExecption",
+    "Effects",
+    "ModeExecption",
+    "PyCololight",
+    "UnavailableException",
+    "UnsupportedDeviceException",
+]

{pycololight-2.0.0 → pycololight-2.2.0}/pycololight/constants.py

@@ -1,6 +1,14 @@
+from typing import TypedDict
+
 COMMAND_PREFIX = "535a30300000000000"
 
-CUSTOM_EFFECT_COLOURS = {
+
+class ColourScheme(TypedDict):
+    decimal: int
+    colours: tuple[str, ...]
+
+
+CUSTOM_EFFECT_COLOURS: dict[str, ColourScheme] = {
     "Breath": {
         "decimal": 128,
         "colours": (

{pycololight-2.0.0 → pycololight-2.2.0}/pycololight/effects.py

@@ -1,8 +1,8 @@
 from .constants import (
     CUSTOM_EFFECT_COLOURS,
+    DEFAULT_EFFECTS,
     HEXAGON_CUSTOM_EFFECT_MODES,
     STRIP_CUSTOM_EFFECT_MODES,
-    DEFAULT_EFFECTS,
     STRIP_DYANMIC_EFFECTS,
 )
 
@@ -28,13 +28,13 @@ class Effects:
     Effects for cololight devices
     """
 
-    def __init__(self, device) -> None:
+    def __init__(self, device: str) -> None:
         self._device = device
         self._default_effects = DEFAULT_EFFECTS.copy()
         self._dynamic_effects = self._device_dynamic_effects()
         self._modes = self._device_modes()
 
-    def _cycle_speed_hex(self, cycle_speed, mode):
+    def _cycle_speed_hex(self, cycle_speed: int, mode: int) -> str:
         if not 1 <= cycle_speed <= 32:
             raise CycleSpeedException
         if mode in [2]:
@@ -44,10 +44,10 @@ class Effects:
         else:
             cycle_speed_value = list(reversed(range(33)))[cycle_speed - 1]
 
-        cycle_speed_hex = "{:02x}".format(cycle_speed_value)
+        cycle_speed_hex = f"{cycle_speed_value:02x}"
         return cycle_speed_hex
 
-    def _colour_hex(self, colour_scheme, colour, mode):
+    def _colour_hex(self, colour_scheme: str, colour: str, mode: int) -> str:
         if colour_scheme not in self.custom_effect_colour_schemes():
             raise ColourSchemeException
         if colour not in self.custom_effect_colour_scheme_colours(colour_scheme):
@@ -59,16 +59,16 @@ class Effects:
             # These modes have a lower starting decimal of 128
             starting_decimal = starting_decimal - 128
         colour_decimal = starting_decimal + colour_key
-        colour_hex = "{:02x}".format(colour_decimal)
+        colour_hex = f"{colour_decimal:02x}"
         return colour_hex
 
-    def _mode_hex(self, mode):
+    def _mode_hex(self, mode: int) -> tuple[str, str]:
         if not 1 <= mode <= len(self._modes):
             raise ModeExecption
 
         return self._modes[mode - 1]
 
-    def _device_dynamic_effects(self):
+    def _device_dynamic_effects(self) -> dict[str, list[str]]:
         if self._device == "strip":
             dynamic_effects = STRIP_DYANMIC_EFFECTS.copy()
         else:
@@ -76,7 +76,7 @@ class Effects:
 
         return dynamic_effects
 
-    def _device_modes(self):
+    def _device_modes(self) -> list[tuple[str, str]]:
         if self._device == "hexagon":
             modes = HEXAGON_CUSTOM_EFFECT_MODES.copy()
         if self._device == "strip":
@@ -84,7 +84,7 @@ class Effects:
 
         return modes
 
-    def _device_mode_lower(self, mode):
+    def _device_mode_lower(self, mode: int) -> bool:
         hexagon_lower_modes = [13, 14, 15, 22, 23, 24]
         strip_lower_modes = [10]
 
@@ -96,21 +96,21 @@ class Effects:
         return mode in lower_modes
 
     @property
-    def default_effects(self) -> dict:
+    def default_effects(self) -> dict[str, list[str]]:
         """
         Returns a dict of default effects with names and command hex values for the device.
         """
         return self._default_effects
 
     @property
-    def dynamic_effects(self) -> dict:
+    def dynamic_effects(self) -> dict[str, list[str]]:
         """
         Returns a dict of dynamic effects with names and command hex values for the device.
         """
         return self._dynamic_effects
 
     @property
-    def effects(self) -> dict:
+    def effects(self) -> dict[str, list[str]]:
         """
         Return a dict of all effects with names and command hex values for the device.
         """
@@ -139,13 +139,13 @@ class Effects:
 
         return custom_effect_hex
 
-    def custom_effect_colour_schemes(self) -> list:
+    def custom_effect_colour_schemes(self) -> list[str]:
         """
         Returns a list of the available colour schemes for custom efects.
         """
         return list(CUSTOM_EFFECT_COLOURS.keys())
 
-    def custom_effect_colour_scheme_colours(self, colour_scheme) -> list:
+    def custom_effect_colour_scheme_colours(self, colour_scheme: str) -> list[str]:
         """
         Returns a list of the available colours for a given colour schemes for custom efects.
         """

{pycololight-2.0.0 → pycololight-2.2.0}/pycololight/pycololight.py

@@ -29,28 +29,36 @@ class PyCololight:
     """
 
     def __init__(
-        self, device, host, port=8900, default_effects=True, dynamic_effects=False
-    ):
+        self,
+        device: str,
+        host: str,
+        port: int = 8900,
+        timeout: float = 4,
+        default_effects: bool = True,
+        dynamic_effects: bool = False,
+    ) -> None:
         self.supported_devices = ["hexagon", "strip"]
         self.device = self._check_supported_devices(device)
         self.host = host
         self.port = port
+        self.timeout = timeout
         self._counter = 1
         self._on = False
-        self._brightness = None
-        self._colour = None
-        self._effect = None
+        self._brightness: int | None = None
+        self._colour: tuple[int, int, int] | None = None
+        self._effect: str | None = None
         self._device_effects = Effects(device)
         self._effects = self._initial_effects(default_effects, dynamic_effects)
-        self._sock = None
 
-    def _check_supported_devices(self, device):
+    def _check_supported_devices(self, device: str) -> str:
         if device not in self.supported_devices:
             raise UnsupportedDeviceException
         else:
             return device
 
-    def _initial_effects(self, default_effects, dynamic_effects):
+    def _initial_effects(
+        self, default_effects: bool, dynamic_effects: bool
+    ) -> dict[str, list[str]]:
         initial_effects = {}
 
         if default_effects:
@@ -60,39 +68,29 @@ class PyCololight:
 
         return initial_effects
 
-    def _toggle_counter(self):
+    def _toggle_counter(self) -> None:
         self._counter = 2 if self._counter == 1 else 1
 
-    def _get_counter(self):
+    def _get_counter(self) -> str:
         count = f"000000000000000000000000000000000{self._counter}0000000000000000000"
         self._toggle_counter()
         return count
 
-    def _socket_connect(self):
-        self._sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        self._sock.settimeout(4)
+    def _send(self, commands: list[bytes], response: bool = False) -> bytes | None:
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as sock:
+            sock.settimeout(self.timeout)
+            for command in commands:
+                sock.sendto(command, (self.host, self.port))
 
-    def _socket_close(self):
-        self._sock.close()
+            if response:
+                try:
+                    return sock.recvfrom(4096)[0]
+                except TimeoutError:
+                    raise UnavailableException
 
-    def _send(self, commands, response=False):
-        self._socket_connect()
-        for command in commands:
-            self._sock.sendto(command, (self.host, self.port))
+        return None
 
-        if not response:
-            self._socket_close()
-
-    def _receive(self):
-        try:
-            data = self._sock.recvfrom(4096)[0]
-            self._socket_close()
-            return data
-        except socket.timeout:
-            self._socket_close()
-            raise UnavailableException
-
-    def _get_config(self, config_type):
+    def _get_config(self, config_type: str) -> str:
         if config_type == "command":
             config = f"{COMMAND_PREFIX}20{self._get_counter()}4010301c"
         elif config_type == "effect":
@@ -103,20 +101,21 @@ class PyCololight:
         return config
 
     @property
-    def state(self):
+    def state(self) -> None:
         """
         Gets state (on/off) and brightness from device, and updates local state.
         """
-        self._send(
+        data = self._send(
             [bytes.fromhex(f"{self._get_config('state')}")],
             response=True,
         )
-        data = self._receive()
+        assert data is not None
         if data[40] == 207:
             self._on = True
             self._brightness = data[41]
         elif data[40] == 206:
             self._on = False
+            self._brightness = None
         else:
             return
 
@@ -128,7 +127,7 @@ class PyCololight:
         return self._on
 
     @on.setter
-    def on(self, brightness: int):
+    def on(self, brightness: int) -> None:
         """
         Turns the device on with desired brightness, or turns the device off if brightness is 0.
         """
@@ -137,18 +136,19 @@ class PyCololight:
             self.brightness = brightness
         else:
             self._on = False
+            self._brightness = None
             command = bytes.fromhex("{}{}".format(self._get_config("command"), "e1e"))
             self._send([command])
 
     @property
-    def brightness(self) -> int:
+    def brightness(self) -> int | None:
         """
         Returns the current set brightness.
         """
         return self._brightness
 
     @brightness.setter
-    def brightness(self, brightness: int):
+    def brightness(self, brightness: int) -> None:
         """
         Sets the brightness of the device.
         """
@@ -166,14 +166,14 @@ class PyCololight:
         self._send([command])
 
     @property
-    def colour(self) -> tuple:
+    def colour(self) -> tuple[int, int, int] | None:
         """
         Returns the current set colour hue.
         """
         return self._colour
 
     @colour.setter
-    def colour(self, colour: tuple):
+    def colour(self, colour: tuple[int, int, int]) -> None:
         """
         Sets the colour of the device.
         """
@@ -187,14 +187,14 @@ class PyCololight:
         self._send([command])
 
     @property
-    def effect(self) -> str:
+    def effect(self) -> str | None:
         """
         Returns the current set effect name.
         """
         return self._effect
 
     @effect.setter
-    def effect(self, effect: str):
+    def effect(self, effect: str) -> None:
         """
         Set the effect of the device.
         """
@@ -212,39 +212,39 @@ class PyCololight:
         self._send(commands)
 
     @property
-    def default_effects(self) -> list:
+    def default_effects(self) -> list[str]:
         """
         Returns a list of names of the default effects for the device.
         """
         return list(self._device_effects.default_effects.keys())
 
     @property
-    def dynamic_effects(self) -> list:
+    def dynamic_effects(self) -> list[str]:
         """
         Returns a list of names of the dynamic effects for the device.
         """
         return list(self._device_effects.dynamic_effects.keys())
 
     @property
-    def effects(self) -> list:
+    def effects(self) -> list[str]:
         """
         Returns a list of names of the effects saved for the device.
         """
         return list(self._effects.keys())
 
-    def restore_effects(self, effects: list):
+    def restore_effects(self, effects: list[str]) -> None:
         """
         Restors the given default/dynamic effects, to the saved effects of the device.
         """
         for effect in effects:
-            if effect not in self._device_effects.effects.keys():
+            if effect not in self._device_effects.effects:
                 raise DefaultEffectExecption
 
             self._effects[effect] = self._device_effects.effects[effect]
 
     def add_custom_effect(
         self, name: str, colour_scheme: str, colour: str, cycle_speed: int, mode: int
-    ):
+    ) -> None:
         """
         Adds a custom effect, to the saved effects of the device.
         """
@@ -254,13 +254,13 @@ class PyCololight:
 
         self._effects[name] = [custom_effect_hex]
 
-    def custom_effect_colour_schemes(self) -> list:
+    def custom_effect_colour_schemes(self) -> list[str]:
         """
         Returns a list of the available colour schemes for custom efects.
         """
         return self._device_effects.custom_effect_colour_schemes()
 
-    def custom_effect_colour_scheme_colours(self, colour_scheme) -> list:
+    def custom_effect_colour_scheme_colours(self, colour_scheme: str) -> list[str]:
         """
         Returns a list of the available colours for a given colour schemes for custom efects.
         """

pycololight-2.2.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "pycololight"
+version = "2.2.0"
+description = "A Python3 wrapper for interacting with LifeSmart Cololight"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.12"
+dependencies = []
+
+[[project.authors]]
+name = "BazaJayGee66"
+
+[project.urls]
+Repository = "https://github.com/BazaJayGee66/pycololight"
+
+[dependency-groups]
+dev = [
+    "mypy==2.4.1",
+    "pytest>=9,<10",
+    "pytest-cov>=7,<8",
+    "ruff==0.17.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+source-include = ["CHANGELOG.md"]
+
+[tool.pytest]
+testpaths = ["tests"]
+
+[tool.ruff.lint]
+extend-select = [
+    "I",
+    "UP",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["B018"]
+
+[tool.mypy]
+files = ["pycololight"]
+disallow_untyped_defs = true

pycololight-2.2.0/pyproject.toml.orig

@@ -0,0 +1,43 @@
+[project]
+name = "pycololight"
+version = "2.2.0"
+description = "A Python3 wrapper for interacting with LifeSmart Cololight"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "BazaJayGee66" }]
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/BazaJayGee66/pycololight"
+
+[dependency-groups]
+dev = [
+    "mypy==2.4.1",
+    "pytest>=9,<10",
+    "pytest-cov>=7,<8",
+    "ruff==0.17.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-root = ""
+source-include = ["CHANGELOG.md"]
+
+[tool.pytest]
+testpaths = ["tests"]
+
+[tool.ruff.lint]
+extend-select = ["I", "UP"]
+
+[tool.ruff.lint.per-file-ignores]
+# Reading PyCololight.state polls the device, so tests read it as a bare expression.
+"tests/*" = ["B018"]
+
+[tool.mypy]
+files = ["pycololight"]
+disallow_untyped_defs = true

pycololight-2.0.0/CHANGELOG.md

@@ -1,52 +0,0 @@
-# 2.0.0
-
-This release enables support for the cololight strip device.
-
-## New Features
-
-- Add support for the cololight strip device
-- Add dynamic effects for the cololight strip device
-- Add custom effects for the cololight strip device
-
-## Breaking Changes
-
-- A device (`hexagon` or `strip`) must now be passed when creating `PyCololight` object
-
-# 1.0.0
-
-## New Features
-
-- Add state to get light state (on/off) and brightness - Thanks [@pim12345](https://github.com/pim12345)
-
-## Fixes
-
-- Add missing exceptions
-- Add BrightnessException if brightness not between 0 and 100
-- Refactor for simpler code
-- Rename `include_default_effects` to `restore_default_effects`
-- Remove `count` property
-- Add type hints, and docstring
-
-# 0.0.2
-
-## New Features
-
-## Fixes
-
-- Refactor for simpler code
-
-# 0.0.1
-
-Initial Release
-
-## New Features
-
-- Turn On
-- Turn Off
-- Set brightness
-- Set colour
-- Set effect
-- Include/Exclude default effects
-- Add custom effect
-
-## Fixes

pycololight-2.0.0/pyproject.toml

@@ -1,22 +0,0 @@
-[tool.poetry]
-authors = ["BazaJayGee66"]
-description = "A Python3 wrapper for interacting with LifeSmart Cololight"
-include = ["CHANGELOG.md"]
-license = "MIT"
-name = "pycololight"
-readme = "README.md"
-repository = "https://github.com/BazaJayGee66/pycololight"
-version = "2.0.0"
-
-[tool.poetry.dependencies]
-python = "^3.8"
-
-[tool.poetry.dev-dependencies]
-black = "21.5b1"
-pylint = "2.8.2"
-pytest = "6.2.4"
-pytest-cov = "^2.12.1"
-
-[build-system]
-build-backend = "poetry.core.masonry.api"
-requires = ["poetry-core>=1.0.0"]

pycololight-2.0.0/setup.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-packages = \
-['pycololight']
-
-package_data = \
-{'': ['*']}
-
-setup_kwargs = {
-    'name': 'pycololight',
-    'version': '2.0.0',
-    'description': 'A Python3 wrapper for interacting with LifeSmart Cololight',
-    'long_description': '# pycololight\n\nA Python3 wrapper for interacting with LifeSmart Cololight.\n\nSupports the following cololight devices:\n\n- hexagon\n- strip\n\n## Usage\n\n```python\nfrom pycololight import PyCololight\n\n# Setup hexagon device\nlight = PyCololight(device="hexagon", host="1.1.1.1")\n\n# Setup strip device, and include dynamic effects\nlight = PyCololight(device="strip", host="1.1.1.1", dynamic_effects=True)\n\n# Turn on at 60% brightness\nlight.on = 60\n\n# Set brightness to 70%\nlight.brightness = 70\n\n# Set light colour\nlight.colour = (255, 127, 255)\n\n# Set effect\nlight.effect = "Sunrise"\n\n# Create custom effect\nlight.add_custom_effect(\n  name="custom effect",\n  colour_scheme="Shadow",\n  colour="Red, Yellow",\n  cycle_speed=11,\n  mode=1\n)\n\n# Turn off\nlight.on = 0\n```\n\nMapping of modes for custom effects can be found [here](https://github.com/BazaJayGee66/pycololight/blob/main/MODES.md)\n',
-    'author': 'BazaJayGee66',
-    'author_email': None,
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': 'https://github.com/BazaJayGee66/pycololight',
-    'packages': packages,
-    'package_data': package_data,
-    'python_requires': '>=3.8,<4.0',
-}
-
-
-setup(**setup_kwargs)