proconip 2.1.2__tar.gz → 2.2.1__tar.gz

{proconip-2.1.2 → proconip-2.2.1}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [2.2.1](https://github.com/ylabonte/proconip-pypi/compare/v2.2.0...v2.2.1) (2026-10-08)
+
+
+### Bug Fixes
+
+* support aiohttp 3.14 without deprecation warnings; test against it ([#94](https://github.com/ylabonte/proconip-pypi/issues/94), [#97](https://github.com/ylabonte/proconip-pypi/issues/97)) ([#98](https://github.com/ylabonte/proconip-pypi/issues/98)) ([87dcc3d](https://github.com/ylabonte/proconip-pypi/commit/87dcc3d01ab2d5cae7fb826638086665f2076c7c))
+
+## [2.2.0](https://github.com/ylabonte/proconip-pypi/compare/v2.1.2...v2.2.0) (2026-06-14)
+
+
+### Features
+
+* add digital input triggering via WEBIO ([#93](https://github.com/ylabonte/proconip-pypi/issues/93)) ([8c35420](https://github.com/ylabonte/proconip-pypi/commit/8c354202ded3bbe389d6a53c0059b78d14337b97))
+
 ## [2.1.2](https://github.com/ylabonte/proconip-pypi/compare/v2.1.1...v2.1.2) (2026-06-14)
 
 

{proconip-2.1.2 → proconip-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: proconip
-Version: 2.1.2
+Version: 2.2.1
 Summary: Async Python library for interacting with the ProCon.IP pool controller.
 Project-URL: Homepage, https://github.com/ylabonte/proconip-pypi
 Project-URL: Documentation, https://ylabonte.github.io/proconip-pypi/
@@ -176,8 +176,8 @@ async def manual_dosage_example():
     client_session = aiohttp.ClientSession()
     config = ConfigObject("http://192.168.2.3", "admin", "admin")
     dosage_control = DosageControl(client_session, config)
-    await dosage_control.async_chlorine_dosage(3600) # start for 1 hour
-    await dosage_control.async_ph_minus_dosage(60) # start for 1 minute
+    await dosage_control.async_chlorine_dosage(3600)  # start for 1 hour
+    await dosage_control.async_ph_minus_dosage(60)  # start for 1 minute
     await client_session.close()
 
 
@@ -201,13 +201,12 @@ async def dmx_example():
         print(f"{channel.name} before: {channel.value}")
         dmx_data.set(channel.index, (channel.value + 128) % 256)
         print(f"{channel.name} after: {dmx_data.get_value(channel.index)}")
-      
+
     await dmx_control.async_set(dmx_data)
     await client_session.close()
 
 
 asyncio.run(dmx_example())
-
 ```
 
 ## A brief description of the ProCon.IP pool controller

{proconip-2.1.2 → proconip-2.2.1}/README.md

@@ -148,8 +148,8 @@ async def manual_dosage_example():
     client_session = aiohttp.ClientSession()
     config = ConfigObject("http://192.168.2.3", "admin", "admin")
     dosage_control = DosageControl(client_session, config)
-    await dosage_control.async_chlorine_dosage(3600) # start for 1 hour
-    await dosage_control.async_ph_minus_dosage(60) # start for 1 minute
+    await dosage_control.async_chlorine_dosage(3600)  # start for 1 hour
+    await dosage_control.async_ph_minus_dosage(60)  # start for 1 minute
     await client_session.close()
 
 
@@ -173,13 +173,12 @@ async def dmx_example():
         print(f"{channel.name} before: {channel.value}")
         dmx_data.set(channel.index, (channel.value + 128) % 256)
         print(f"{channel.name} after: {dmx_data.get_value(channel.index)}")
-      
+
     await dmx_control.async_set(dmx_data)
     await client_session.close()
 
 
 asyncio.run(dmx_example())
-
 ```
 
 ## A brief description of the ProCon.IP pool controller

{proconip-2.1.2 → proconip-2.2.1}/pyproject.toml

@@ -37,15 +37,11 @@ test = [
     "pytest",
     "pytest-asyncio",
     "pytest-cov",
-    "aioresponses",
-    # aioresponses 0.7.8 can't build mocked responses against aiohttp 3.14+
-    # (ClientResponse gained a required `stream_writer` kwarg), which breaks
-    # the whole test_api suite. Pin tests to the 3.13.x line HA Core ships.
-    # TODO: lift this cap once a compatible aioresponses release lands.
-    "aiohttp<3.14",
 ]
 docs = [
-    "mkdocs",
+    # MkDocs 2.0 drops the plugin system and the theming that Material and
+    # mkdocstrings rely on, with no migration path — stay on 1.x.
+    "mkdocs<2",
     "mkdocs-material",
     "mkdocstrings[python]",
     "mkdocs-include-markdown-plugin",

{proconip-2.1.2 → proconip-2.2.1}/src/proconip/__init__.py

@@ -11,8 +11,10 @@ except ImportError:  # pragma: no cover
         __version__ = "0.0.0.dev0"
 
 from .api import (
+    DIGITAL_INPUT_COUNT,
     BadCredentialsException,
     BadStatusCodeException,
+    DigitalInputControl,
     DmxControl,
     DosageControl,
     GetState,
@@ -30,6 +32,7 @@ from .api import (
     async_start_dosage,
     async_switch_off,
     async_switch_on,
+    async_trigger_digital_input,
 )
 from .definitions import (
     CATEGORY_ANALOG,
@@ -45,6 +48,7 @@ from .definitions import (
     BadRelayException,
     ConfigObject,
     DataObject,
+    DigitalInput,
     DmxChannelData,
     DosageTarget,
     GetDmxData,
@@ -67,12 +71,14 @@ __all__ = [
     # data classes
     "DataObject",
     "Relay",
+    "DigitalInput",
     "GetStateData",
     "DmxChannelData",
     "GetDmxData",
     # enums
     "DosageTarget",
     # constants
+    "DIGITAL_INPUT_COUNT",
     "EXTERNAL_RELAY_ID_OFFSET",
     "CATEGORY_TIME",
     "CATEGORY_ANALOG",
@@ -88,6 +94,7 @@ __all__ = [
     "RelaySwitch",
     "DosageControl",
     "DmxControl",
+    "DigitalInputControl",
     # free async functions
     "async_get_raw_data",
     "async_get_raw_state",
@@ -100,4 +107,5 @@ __all__ = [
     "async_get_raw_dmx",
     "async_get_dmx",
     "async_set_dmx",
+    "async_trigger_digital_input",
 ]

{proconip-2.1.2 → proconip-2.2.1}/src/proconip/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.1.2'
-__version_tuple__ = version_tuple = (2, 1, 2)
+__version__ = version = '2.2.1'
+__version_tuple__ = version_tuple = (2, 2, 1)
 
 __commit_id__ = commit_id = None

{proconip-2.1.2 → proconip-2.2.1}/src/proconip/api.py

@@ -26,10 +26,11 @@ subclasses so callers can handle them uniformly.
 """
 
 import asyncio
+import base64
+import contextlib
 import socket
 
 from aiohttp import (
-    BasicAuth,
     ClientError,
     ClientResponse,
     ClientSession,
@@ -83,6 +84,18 @@ class TimeoutException(ProconipApiException):
     """
 
 
+def _auth_headers(config: ConfigObject) -> dict[str, str]:
+    """Build the HTTP Basic ``Authorization`` header for the controller credentials.
+
+    Built by hand rather than via ``aiohttp.BasicAuth`` / ``auth=``, which
+    aiohttp 3.14 deprecates (removal in 4.0), while its replacement
+    ``aiohttp.encode_basic_auth`` doesn't exist on older supported versions.
+    Credentials are latin-1 encoded, matching ``BasicAuth``'s default.
+    """
+    credentials = f"{config.username}:{config.password}".encode("latin1")
+    return {"Authorization": "Basic " + base64.b64encode(credentials).decode("ascii")}
+
+
 async def _handle_response(response: ClientResponse) -> str:
     """Validate the response and return its body, mapping HTTP errors to typed exceptions."""
     if response.status in (401, 403):
@@ -129,10 +142,9 @@ async def async_get_raw_data(
         ProconipApiException: For DNS failures, connection resets, and other
             network-level errors.
     """
-    auth = BasicAuth(config.username, config.password)
     try:
         async with asyncio.timeout(timeout):
-            async with client_session.get(url, auth=auth) as response:
+            async with client_session.get(url, headers=_auth_headers(config)) as response:
                 return await _handle_response(response)
     except TimeoutError as exc:
         raise TimeoutException("API request timed out") from exc
@@ -299,15 +311,16 @@ async def async_post_usrcfg_cgi(
         ProconipApiException: For network-level errors.
     """
     url = URL(config.base_url).with_path(API_PATH_USRCFG)
-    auth = BasicAuth(config.username, config.password)
-    headers = {"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"}
+    headers = {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        **_auth_headers(config),
+    }
     try:
         async with asyncio.timeout(timeout):
             async with client_session.post(
                 url=url,
                 headers=headers,
                 data=payload,
-                auth=auth,
             ) as response:
                 return await _handle_response(response)
     except TimeoutError as exc:
@@ -894,3 +907,148 @@ class DmxControl:
             dmx_states=data,
             timeout=self.timeout if timeout is None else timeout,
         )
+
+
+DIGITAL_INPUT_COUNT = 4
+DIGITAL_INPUT_PULSE_SECONDS = 0.6
+
+
+async def async_trigger_digital_input(
+    client_session: ClientSession,
+    config: ConfigObject,
+    digital_input_id: int,
+    timeout: float = 10.0,
+    hold_seconds: float = DIGITAL_INPUT_PULSE_SECONDS,
+) -> str:
+    """Trigger (momentarily pulse) a digital input via the WEBIO ``IO`` field.
+
+    The controller's web UI exposes each digital input as a push button: it
+    sets the input's bit, waits, then clears it. This sends the same two
+    `/usrcfg.cgi` writes — ``IO=<mask>&WEBIO=1`` (press) then, after
+    ``hold_seconds``, ``IO=0&WEBIO=1`` (release) — where
+    ``mask = 1 << digital_input_id``. The hold mirrors the web UI (~600ms) so
+    the controller reliably registers the pulse.
+
+    Unlike relay switching, no `GetStateData` snapshot is needed: the ``IO``
+    field is written directly rather than read-modify-written.
+
+    Because the pulse is two separate writes, the release is not fully
+    guaranteed. If the hold is **cancelled** (e.g. the caller's task is shut
+    down), a best-effort release is attempted before the cancellation
+    propagates. If the **release POST itself fails** (timeout / network blip),
+    that error propagates and the input is left asserted HIGH until the next
+    write.
+
+    Args:
+        client_session: An open `aiohttp.ClientSession`.
+        config: Controller configuration including base URL and credentials.
+        digital_input_id: Zero-based digital input index (0–3).
+        timeout: Per-request timeout in seconds, applied to each of the two
+            POSTs.
+        hold_seconds: Seconds to hold the input HIGH between the press and
+            release POSTs. Defaults to the web UI's ~600ms.
+
+    Returns:
+        The raw response body returned by the release POST.
+
+    Raises:
+        ValueError: If ``digital_input_id`` is not in 0–3.
+        BadCredentialsException: On HTTP 401 or 403.
+        BadStatusCodeException: On any other 4xx or 5xx response.
+        TimeoutException: If an exchange exceeds ``timeout`` seconds.
+        ProconipApiException: For network-level errors.
+    """
+    if not 0 <= digital_input_id < DIGITAL_INPUT_COUNT:
+        raise ValueError(
+            f"digital_input_id must be in 0..{DIGITAL_INPUT_COUNT - 1}, got {digital_input_id}"
+        )
+    mask = 1 << digital_input_id
+    await async_post_usrcfg_cgi(
+        client_session=client_session,
+        config=config,
+        payload=f"IO={mask}&WEBIO=1",
+        timeout=timeout,
+    )
+    try:
+        await asyncio.sleep(hold_seconds)
+    except asyncio.CancelledError:
+        # Best-effort release so a cancelled hold doesn't leave the input
+        # asserted HIGH. Networking inside a cancellation is awkward, so this
+        # is a best effort, not a guarantee.
+        with contextlib.suppress(Exception):
+            await async_post_usrcfg_cgi(
+                client_session=client_session,
+                config=config,
+                payload="IO=0&WEBIO=1",
+                timeout=timeout,
+            )
+        raise
+    return await async_post_usrcfg_cgi(
+        client_session=client_session,
+        config=config,
+        payload="IO=0&WEBIO=1",
+        timeout=timeout,
+    )
+
+
+class DigitalInputControl:
+    """Convenience wrapper that binds a session and config for triggering inputs.
+
+    Construct once with your `aiohttp.ClientSession` and `ConfigObject`, then
+    pulse digital inputs by zero-based id (0–3) without repeating those
+    arguments each time.
+
+    The constructor also binds a default `timeout` for every call made via this
+    wrapper. Each method then accepts an optional per-call `timeout` that
+    overrides the bound default when supplied.
+
+    Example:
+        ```python
+        dic = DigitalInputControl(session, config)
+        await dic.async_trigger(0)  # pulse the first digital input
+        ```
+    """
+
+    def __init__(
+        self,
+        client_session: ClientSession,
+        config: ConfigObject,
+        timeout: float = 10.0,
+    ):
+        """Bind the session, config, and default per-request timeout.
+
+        Args:
+            client_session: An open `aiohttp.ClientSession`.
+            config: Controller configuration.
+            timeout: Default per-request timeout in seconds, used when a method
+                is called without its own ``timeout`` argument.
+        """
+        self.client_session = client_session
+        self.config = config
+        self.timeout = timeout
+
+    async def async_trigger(
+        self,
+        digital_input_id: int,
+        timeout: float | None = None,
+        hold_seconds: float = DIGITAL_INPUT_PULSE_SECONDS,
+    ) -> str:
+        """Trigger the digital input identified by ``digital_input_id``.
+
+        Args:
+            digital_input_id: Zero-based digital input index (0–3).
+            timeout: Override for this call only. If ``None``, the timeout
+                bound in `__init__` is used.
+            hold_seconds: Seconds to hold the input HIGH between press and
+                release. Defaults to the web UI's ~600ms.
+
+        See `async_trigger_digital_input` (the free function) for the full
+        description of behavior and raised exceptions.
+        """
+        return await async_trigger_digital_input(
+            client_session=self.client_session,
+            config=self.config,
+            digital_input_id=digital_input_id,
+            timeout=self.timeout if timeout is None else timeout,
+            hold_seconds=hold_seconds,
+        )

{proconip-2.1.2 → proconip-2.2.1}/src/proconip/definitions.py

@@ -409,6 +409,48 @@ class Relay(DataObject):
         return 1 << self._category_id
 
 
+class DigitalInput(DataObject):
+    """Typed view of a single digital input (CSV columns 24–27).
+
+    Construct one by passing the `DataObject` you got from
+    `GetStateData.digital_input_objects`; the column, name, calibration, and
+    raw value are copied across so the physical value is computed exactly once.
+    ``GetStateData.digital_inputs()`` is a shorthand that does this for you.
+
+    The wrapper exists so digital inputs can be *triggered* (not just read):
+    `get_bit_mask` yields the bit used in the controller's WEBIO ``IO`` field.
+    """
+
+    def __init__(self, data_object: DataObject):
+        """Wrap an existing digital-input `DataObject`.
+
+        Args:
+            data_object: A `DataObject` produced by parsing a `/GetState.csv`
+                response. It should be in the digital_input category, but no
+                check is enforced — passing another object yields a
+                `DigitalInput` whose `get_bit_mask` is meaningless.
+        """
+        super().__init__(
+            data_object.column,
+            data_object.name,
+            data_object.unit,
+            data_object.offset,
+            data_object.gain,
+            data_object.raw_value,  # pass raw value so offset+gain are applied exactly once
+        )
+
+    def get_bit_mask(self) -> int:
+        """Bit for this input in the WEBIO ``IO`` field (``1 << category_id``).
+
+        The four digital inputs occupy bits 0–3, so this returns 1, 2, 4, or 8.
+        To *trigger* an input, pass its ``category_id`` to
+        `async_trigger_digital_input` (which derives the same mask itself); use
+        this method when assembling an ``IO`` payload for a manual
+        `async_post_usrcfg_cgi` write.
+        """
+        return 1 << self._category_id
+
+
 class GetStateData:
     """Parsed representation of a single `/GetState.csv` response.
 
@@ -543,7 +585,13 @@ class GetStateData:
     @property
     def config_other_enable(self) -> int:
         """Misc configuration flags. Use the `is_*_enabled` methods to query
-        individual bits (TCP/IP boost, SD card, DMX, …)."""
+        individual bits (TCP/IP boost, SD card, DMX, …).
+
+        Not every "Sonstiges" checkbox is mirrored here on current firmware:
+        on 1.7.6, bits 0 (TCP/IP boost), 1 (SD card) and 5 (high bus load)
+        were observed as 0 although those options were enabled, while bit 2
+        (DMX) tracked its checkbox exactly. Bits 3, 4, 6, 7 and 8 are
+        unverified on hardware."""
         return self._config_other_enable
 
     @property
@@ -707,15 +755,28 @@ class GetStateData:
         return NTP_FAULT_STATE[0]
 
     def is_tcpip_boost_enabled(self) -> bool:
-        """True if TCP/IP boost is enabled in the controller config (bit 0)."""
+        """True if bit 0 (TCP/IP boost) of `config_other_enable` is set.
+
+        Unreliable on current firmware: 1.7.6 was observed reporting this bit
+        as 0 while TCP/IP boost was enabled, so ``False`` doesn't prove the
+        feature is off.
+        """
         return self._config_other_enable & 1 == 1
 
     def is_sd_card_enabled(self) -> bool:
-        """True if SD card logging is enabled in the controller config (bit 1)."""
+        """True if bit 1 (SD card) of `config_other_enable` is set.
+
+        Unreliable on current firmware: 1.7.6 was observed reporting this bit
+        as 0 while the SD card was enabled, so ``False`` doesn't prove the
+        feature is off.
+        """
         return self._config_other_enable & 2 == 2
 
     def is_dmx_enabled(self) -> bool:
-        """True if DMX output is enabled in the controller config (bit 2)."""
+        """True if DMX output is enabled in the controller config (bit 2).
+
+        Verified on firmware 1.7.6: the bit follows the "DMX512 aktiv" checkbox.
+        """
         return self._config_other_enable & 4 == 4
 
     def is_avatar_enabled(self) -> bool:
@@ -732,7 +793,12 @@ class GetStateData:
         return self._config_other_enable & 16 == 16
 
     def is_high_bus_load_enabled(self) -> bool:
-        """True if high bus load mode is enabled in the controller config (bit 5)."""
+        """True if bit 5 (high bus load, 1-Wire) of `config_other_enable` is set.
+
+        Unreliable on current firmware: 1.7.6 was observed reporting this bit
+        as 0 while high bus load was enabled, so ``False`` doesn't prove the
+        feature is off.
+        """
         return self._config_other_enable & 32 == 32
 
     def is_flow_sensor_enabled(self) -> bool:
@@ -822,6 +888,14 @@ class GetStateData:
         """The four digital inputs (columns 24–27), in column order."""
         return self._digital_input_objects
 
+    def digital_inputs(self) -> list[DigitalInput]:
+        """The four digital inputs as `DigitalInput` instances.
+
+        Equivalent to wrapping each entry in `digital_input_objects` with
+        `DigitalInput(...)`. Use these to get `get_bit_mask()` for triggering.
+        """
+        return [DigitalInput(obj) for obj in self._digital_input_objects]
+
     @property
     def external_relay_objects(self) -> list[DataObject]:
         """The eight external relays (columns 28–35), in column order.