pytriplesolar 0.1.0a1__py3-none-any.whl

pytriplesolar/__init__.py

@@ -0,0 +1,97 @@
+"""pytriplesolar: talk to a Triple Solar PVT heat pump over Modbus/TLS.
+
+Built on ``modbus-connection``: the library takes a ``ModbusUnit`` and never
+opens a connection itself.
+
+1. Pair once (pairing mode enabled in the My Triple Solar app) with
+   :func:`async_pair` to obtain :class:`Credentials`.
+2. Write them to disk with :meth:`Credentials.write_files` and build the
+   connection from :meth:`CredentialFiles.tls_params`.
+3. Wrap the unit in :class:`TripleSolarHeatPump` and poll it::
+
+       heat_pump = TripleSolarHeatPump(unit)
+       await heat_pump.async_update()
+       heat_pump.general.state
+       heat_pump.dhw.tank_temperature
+"""
+
+from .alerts import Alert
+from .components import (
+    DHW_PROFILE_INDEX,
+    Alerts,
+    Control,
+    DhwProfileSettings,
+    DomesticHotWater,
+    General,
+    HeatPumpModule,
+    Settings,
+    SpaceConditioningInput,
+    SpaceCooling,
+    SpaceHeating,
+    TripleSolarComponent,
+)
+from .const import (
+    CONTROL_KEEPALIVE_SECONDS,
+    DEFAULT_UNIT_ID,
+    MODBUS_TLS_PORT,
+    MODBUS_TLS_SERVICE_TYPE,
+    PAIRING_SERVICE_TYPE,
+    SIGNING_SERVICE_PORT,
+)
+from .credentials import CredentialFiles, Credentials, normalize_hostname
+from .device import SUBSYSTEMS, TripleSolarHeatPump
+from .enums import (
+    AlertType,
+    DhwState,
+    HeatPumpModuleState,
+    HeatPumpState,
+    Profile,
+    SpaceConditioningMode,
+    SpaceConditioningState,
+)
+from .exceptions import (
+    InvalidCredentialsError,
+    PairingError,
+    TripleSolarError,
+    TripleSolarValueError,
+)
+from .pairing import async_pair
+
+__all__ = [
+    "CONTROL_KEEPALIVE_SECONDS",
+    "DEFAULT_UNIT_ID",
+    "DHW_PROFILE_INDEX",
+    "MODBUS_TLS_PORT",
+    "MODBUS_TLS_SERVICE_TYPE",
+    "PAIRING_SERVICE_TYPE",
+    "SIGNING_SERVICE_PORT",
+    "SUBSYSTEMS",
+    "Alert",
+    "AlertType",
+    "Alerts",
+    "Control",
+    "CredentialFiles",
+    "Credentials",
+    "DhwProfileSettings",
+    "DhwState",
+    "DomesticHotWater",
+    "General",
+    "HeatPumpModule",
+    "HeatPumpModuleState",
+    "HeatPumpState",
+    "InvalidCredentialsError",
+    "PairingError",
+    "Profile",
+    "Settings",
+    "SpaceConditioningInput",
+    "SpaceConditioningMode",
+    "SpaceConditioningState",
+    "SpaceCooling",
+    "SpaceHeating",
+    "TripleSolarComponent",
+    "TripleSolarError",
+    "TripleSolarHeatPump",
+    "TripleSolarValueError",
+    "async_pair",
+    "normalize_hostname",
+]

pytriplesolar/alerts.py

@@ -0,0 +1,83 @@
+"""Decode the alert codes the heat pump reports.
+
+An alert is a 16-bit value packing, from least to most significant bit:
+
+* 5 bits: fault number within the component
+* 5 bits: component within the module
+* 4 bits: module
+* 2 bits: type (none / warning / fault / info)
+
+This mirrors the firmware's ``hw`` bit layout and ``faults.Fault.Code()``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .enums import AlertType
+
+_BITS_VALUE = 5
+_BITS_COMPONENT = 5
+_BITS_MODULE = 4
+_BITS_TYPE = 2
+
+_SHIFT_COMPONENT = _BITS_VALUE
+_SHIFT_MODULE = _SHIFT_COMPONENT + _BITS_COMPONENT
+_SHIFT_TYPE = _SHIFT_MODULE + _BITS_MODULE
+
+_MASK_VALUE = (1 << _BITS_VALUE) - 1
+_MASK_COMPONENT = (1 << _BITS_COMPONENT) - 1
+_MASK_MODULE = (1 << _BITS_MODULE) - 1
+_MASK_TYPE = (1 << _BITS_TYPE) - 1
+
+_PREFIX = {
+    AlertType.NONE: "O",
+    AlertType.WARNING: "W",
+    AlertType.FAULT: "F",
+    AlertType.INFO: "I",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class Alert:
+    """One active alert (notification, warning or fault)."""
+
+    raw: int
+    """The 16-bit value as reported."""
+
+    @property
+    def type(self) -> AlertType:
+        """Severity of the alert."""
+        return AlertType((self.raw >> _SHIFT_TYPE) & _MASK_TYPE)
+
+    @property
+    def module(self) -> int:
+        """Module number the alert belongs to."""
+        return (self.raw >> _SHIFT_MODULE) & _MASK_MODULE
+
+    @property
+    def component(self) -> int:
+        """Component number within the module."""
+        return (self.raw >> _SHIFT_COMPONENT) & _MASK_COMPONENT
+
+    @property
+    def number(self) -> int:
+        """Fault number within the component."""
+        return self.raw & _MASK_VALUE
+
+    @property
+    def code(self) -> str:
+        """Service code as shown by Triple Solar, e.g. ``F10203``."""
+        return (
+            f"{_PREFIX[self.type]}{self.module:01d}"
+            f"{self.component:02d}{self.number:02d}"
+        )
+
+    @property
+    def is_fault(self) -> bool:
+        """Whether the alert is a fault (rather than a warning or notice)."""
+        return self.type is AlertType.FAULT
+
+    def __str__(self) -> str:
+        """Return the service code."""
+        return self.code

pytriplesolar/components.py

@@ -0,0 +1,334 @@
+"""Typed register map of the Triple Solar PVT Heat Pump 5.0.
+
+Addresses, types and scaling mirror the controller firmware's Modbus server
+(status registers as input registers, settings and control as holding
+registers). Every temperature, percentage and frequency is a signed 16-bit
+value in tenths; powers are signed 16-bit watts.
+
+The firmware fails a whole block read with *server device failure* as soon as
+one value in it is unavailable (a sensor that is not fitted, a status value not
+yet published). :class:`TripleSolarComponent` falls back to reading such a
+component register by register, so the values that do exist still update and
+the missing ones read as ``None``.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from enum import IntEnum
+from typing import Any
+
+from modbus_connection import ServerDeviceFailureError
+from modbus_connection.model import (
+    Component,
+    RegisterSpace,
+    boolean,
+    enum,
+    gauge,
+    integer,
+    raw_register,
+    repeating_group,
+)
+
+from .alerts import Alert
+from .const import ALERT_SLOTS, CONTROL_KEEPALIVE_SECONDS
+from .enums import (
+    DhwState,
+    HeatPumpModuleState,
+    HeatPumpState,
+    Profile,
+    SpaceConditioningMode,
+    SpaceConditioningState,
+)
+from .exceptions import TripleSolarValueError
+
+_LOGGER = logging.getLogger(__name__)
+
+# -- write validators ----------------------------------------------------------
+
+
+def _bool(value: Any) -> bool:
+    """Accept only real booleans (the firmware rejects anything but 0/1)."""
+    if not isinstance(value, bool):
+        raise TripleSolarValueError(f"expected a bool, got {value!r}")
+    return value
+
+
+def _between(low: float, high: float) -> Callable[[Any], float]:
+    """Build a validator accepting ``low <= value <= high``."""
+
+    def validate(value: Any) -> float:
+        number = float(value)
+        if not low <= number <= high:
+            raise TripleSolarValueError(f"{number} is outside {low}..{high}")
+        return number
+
+    return validate
+
+
+def _member[E: IntEnum](enum_type: type[E]) -> Callable[[Any], E]:
+    """Build a validator accepting only members of ``enum_type``."""
+
+    def validate(value: Any) -> E:
+        try:
+            return enum_type(value)
+        except ValueError:
+            raise TripleSolarValueError(
+                f"{value!r} is not a valid {enum_type.__name__}"
+            ) from None
+
+    return validate
+
+
+# -- field helpers -------------------------------------------------------------
+
+
+def _tenths(
+    address: int,
+    unit: str,
+    *,
+    stride: int = 0,
+    writable: bool | Callable[[Any], Any] = False,
+) -> Any:
+    """A signed 16-bit value with one decimal (``value * 10`` on the wire)."""
+    return gauge(address, 0.1, signed=True, unit=unit, stride=stride, writable=writable)
+
+
+def _watts(address: int, *, stride: int = 0) -> Any:
+    """A signed 16-bit power in watts."""
+    return integer(address, signed=True, unit="W", stride=stride)
+
+
+# -- base component ------------------------------------------------------------
+
+
+class TripleSolarComponent(Component):
+    """A heat pump sub-system that tolerates individually missing values."""
+
+    register_space: RegisterSpace = "input"
+
+    async def async_update(self, *, notify: bool = True) -> None:
+        """Read this component, register by register if a block is refused.
+
+        Raises ``ServerDeviceFailureError`` only if not a single value could be
+        read. Any other ``ModbusError`` propagates unchanged.
+        """
+        try:
+            await super().async_update(notify=notify)
+        except ServerDeviceFailureError as err:
+            _LOGGER.debug(
+                "%s: block read refused (%s), reading per register",
+                type(self).__name__,
+                err,
+            )
+            if not await self._async_update_per_register():
+                raise
+            if notify:
+                self.notify()
+
+    async def _async_update_per_register(self) -> bool:
+        """Read each field on its own; return whether any value was available."""
+        unit = self.modbus_unit
+        read = (
+            unit.read_input_registers
+            if self.register_space == "input"
+            else unit.read_holding_registers
+        )
+        values: dict[str, Any] = {}
+        any_read = False
+        for name, resolved in self.resolved_fields.items():
+            try:
+                words = await read(resolved.address, resolved.count)
+            except ServerDeviceFailureError:
+                values[name] = None
+                continue
+            values[name] = resolved.field.decode(words)
+            any_read = True
+        if any_read:
+            # Same store the block read decodes into (see ReadPlan.execute).
+            self._values.update(values)
+        return any_read
+
+
+# -- status (input registers) --------------------------------------------------
+
+
+class General(TripleSolarComponent):
+    """Unit-wide status."""
+
+    state = enum(0x0000, HeatPumpState, signed=True)
+    """Overall heat pump state."""
+
+    rated_power = _watts(0x0016)
+    """Total rated power of this unit's own heat sources."""
+
+
+class _AlertSlot(TripleSolarComponent):
+    """One of the alert slots; 0 means the slot is empty."""
+
+    code = raw_register(0x0001)
+
+
+class Alerts(Component):
+    """Active alerts (notifications, warnings and faults)."""
+
+    register_space = "input"
+
+    slots = repeating_group(ALERT_SLOTS, _AlertSlot, stride=1)
+
+    @property
+    def active(self) -> list[Alert]:
+        """The alerts currently raised, in reported order."""
+        return [Alert(slot.code) for slot in self.slots if slot.code]
+
+    @property
+    def has_fault(self) -> bool:
+        """Whether any active alert is a fault."""
+        return any(alert.is_fault for alert in self.active)
+
+
+class DomesticHotWater(TripleSolarComponent):
+    """Domestic hot water (DHW) controller status."""
+
+    state = enum(0x0020, DhwState, signed=True)
+    has_demand = boolean(0x0021)
+    heat_pump_modulation = _tenths(0x0022, "%")
+    """Share of the available heat pump power used for DHW."""
+    tank_temperature = _tenths(0x0025, "°C")
+    tank_temperature_setpoint = _tenths(0x0026, "°C")
+    valve_enabled = boolean(0x0027)
+    """Whether the three-way valve is switched to the DHW tank."""
+    active_profile = enum(0x0028, Profile, signed=True)
+
+
+class SpaceHeating(TripleSolarComponent):
+    """Space heating controller status."""
+
+    state = enum(0x0040, SpaceConditioningState, signed=True)
+    has_demand = boolean(0x0041)
+    heat_pump_modulation = _tenths(0x0042, "%")
+    sink_supply_temperature = _tenths(0x0045, "°C")
+    sink_supply_temperature_setpoint = _tenths(0x0046, "°C")
+    active_profile = enum(0x004A, Profile, signed=True)
+
+
+class SpaceCooling(TripleSolarComponent):
+    """Space cooling controller status."""
+
+    state = enum(0x0060, SpaceConditioningState, signed=True)
+    has_demand = boolean(0x0061)
+    heat_pump_modulation = _tenths(0x0062, "%")
+    sink_supply_temperature = _tenths(0x0065, "°C")
+    sink_supply_temperature_setpoint = _tenths(0x0066, "°C")
+
+
+class SpaceConditioningInput(TripleSolarComponent):
+    """Inputs the space conditioning controllers act on (thermostat, outdoor)."""
+
+    room_temperature = _tenths(0x0120, "°C")
+    ambient_temperature = _tenths(0x0121, "°C")
+    relative_humidity = _tenths(0x0122, "%")
+    room_temperature_setpoint = _tenths(0x0123, "°C")
+    modulation_level = _tenths(0x0124, "%")
+    """Modulation level requested by the thermostat."""
+
+
+_HPM_STRIDE = 0x0400  # module 2 sits one module slot above module 1
+
+
+class HeatPumpModule(TripleSolarComponent):
+    """One heat pump (compressor) module; ``index`` is 1 or 2."""
+
+    state = enum(0x0400, HeatPumpModuleState, signed=True, stride=_HPM_STRIDE)
+    compressor_frequency = _tenths(0x0422, "Hz", stride=_HPM_STRIDE)
+    """Compressor frequency as reported by the inverter."""
+    source_pump_modulation = _tenths(0x0441, "%", stride=_HPM_STRIDE)
+    sink_pump_modulation = _tenths(0x0461, "%", stride=_HPM_STRIDE)
+    cooling_valve_enabled = boolean(0x04A1, stride=_HPM_STRIDE)
+    source_return_temperature = _tenths(0x04C0, "°C", stride=_HPM_STRIDE)
+    """Temperature of the flow from the source (PVT panels) into the module."""
+    source_supply_temperature = _tenths(0x04C1, "°C", stride=_HPM_STRIDE)
+    """Temperature of the flow from the module back to the source."""
+    sink_return_temperature = _tenths(0x0500, "°C", stride=_HPM_STRIDE)
+    """Temperature of the flow from the sink (house) into the module."""
+    sink_supply_temperature = _tenths(0x0501, "°C", stride=_HPM_STRIDE)
+    """Temperature of the flow from the module into the sink."""
+    electric_power = _watts(0x0680, stride=_HPM_STRIDE)
+    thermal_power = _watts(0x0681, stride=_HPM_STRIDE)
+    """Thermal power delivered to the sink."""
+    compressor_starts = integer(0x0683, signed=False, stride=_HPM_STRIDE)
+    """Compressor start count (16-bit, wraps at 65536)."""
+
+
+# -- settings and control (holding registers) ----------------------------------
+
+
+class Settings(TripleSolarComponent):
+    """Persistent operating settings (stored by the heat pump)."""
+
+    register_space = "holding"
+
+    space_heating_enabled = boolean(0x1101, writable=_bool)
+    space_heating_profile = enum(
+        0x1108, Profile, signed=True, writable=_member(Profile)
+    )
+    space_cooling_enabled = boolean(0x2101, writable=_bool)
+    space_cooling_profile = enum(
+        0x2107, Profile, signed=True, writable=_member(Profile)
+    )
+    dhw_enabled = boolean(0x3101, writable=_bool)
+    dhw_profile = enum(0x310A, Profile, signed=True, writable=_member(Profile))
+
+
+_DHW_PROFILE_STRIDE = 0x0100
+
+#: Index of each DHW profile's settings block, for :class:`DhwProfileSettings`.
+DHW_PROFILE_INDEX: dict[Profile, int] = {
+    Profile.ECO: 1,
+    Profile.NORMAL: 2,
+    Profile.COMFORT: 3,
+}
+
+
+class DhwProfileSettings(TripleSolarComponent):
+    """Tank settings of one DHW profile (see :data:`DHW_PROFILE_INDEX`)."""
+
+    register_space = "holding"
+
+    tank_temperature_setpoint = _tenths(
+        0x3601, "°C", stride=_DHW_PROFILE_STRIDE, writable=_between(10, 70)
+    )
+    tank_temperature_hysteresis_low = _tenths(
+        0x3602, "°C", stride=_DHW_PROFILE_STRIDE, writable=_between(0, 50)
+    )
+    """How far the tank may cool below the setpoint before reheating."""
+    modulation = _tenths(
+        0x3603, "%", stride=_DHW_PROFILE_STRIDE, writable=_between(20, 100)
+    )
+    """Heat pump modulation used to charge the tank."""
+
+
+class Control(TripleSolarComponent):
+    """External space conditioning control.
+
+    The heat pump keeps these values in memory only, and acts on them only
+    while a Modbus client has been active within the last
+    :data:`~pytriplesolar.const.CONTROL_KEEPALIVE_SECONDS` seconds (any
+    request counts). Poll faster than that to stay in control.
+    """
+
+    keepalive_seconds = CONTROL_KEEPALIVE_SECONDS
+
+    register_space = "holding"
+
+    mode = enum(
+        0xB101,
+        SpaceConditioningMode,
+        writable=_member(SpaceConditioningMode),
+    )
+    modulation_level = gauge(
+        0xB102, 0.1, signed=False, unit="%", writable=_between(0, 100)
+    )
+    power_budget = integer(0xB103, signed=False, unit="W", writable=_between(0, 0xFFFF))
+    """Electric power the heat pump may use."""

pytriplesolar/const.py

@@ -0,0 +1,31 @@
+"""Constants shared across pytriplesolar."""
+
+from __future__ import annotations
+
+from typing import Final
+
+#: Modbus/TLS port (IANA ``mbap-s``).
+MODBUS_TLS_PORT: Final = 802
+
+#: mDNS-SD service type of the secure Modbus server (Modbus/TLS).
+MODBUS_TLS_SERVICE_TYPE: Final = "_mbap-s._tcp.local."
+
+#: mDNS-SD service type of the single-use CSR signing service that the heat
+#: pump starts while pairing mode is enabled.
+PAIRING_SERVICE_TYPE: Final = "_ts-csr._tcp.local."
+
+#: Port of that signing service (firmware ``signingserver.DefaultPort``).
+SIGNING_SERVICE_PORT: Final = 6509
+
+#: The heat pump answers any unit id on Modbus/TCP; 1 is the conventional one.
+DEFAULT_UNIT_ID: Final = 1
+
+#: The heat pump only trusts the control registers while a client has talked
+#: to it within this many seconds. Poll at least this often to keep control.
+CONTROL_KEEPALIVE_SECONDS: Final = 30
+
+#: Number of alert slots in the input register map.
+ALERT_SLOTS: Final = 20
+
+#: Number of heat pump (compressor) modules a unit can hold.
+MAX_HEAT_PUMP_MODULES: Final = 2

pytriplesolar/credentials.py

@@ -0,0 +1,145 @@
+"""Client credentials for Modbus/TLS and how to hand them to a connection.
+
+Modbus/TLS on the heat pump uses mutual TLS: the heat pump only accepts
+clients holding a certificate signed by its own root CA, which a client
+obtains once by pairing (see :mod:`pytriplesolar.pairing`). The root CA is
+unique to the heat pump, so verifying the server against it pins the
+connection to that one device.
+"""
+
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Final, Self
+
+from cryptography import x509
+from cryptography.exceptions import InvalidSignature
+from cryptography.hazmat.primitives import serialization
+from modbus_connection import ModbusTlsParams
+
+from .const import MODBUS_TLS_PORT
+from .exceptions import InvalidCredentialsError
+
+ROOT_CA_FILENAME: Final = "root_ca.pem"
+CLIENT_CERT_FILENAME: Final = "client_cert.pem"
+CLIENT_KEY_FILENAME: Final = "client_key.pem"
+
+
+def normalize_hostname(hostname: str) -> str:
+    """Normalize an mDNS host name for comparison (lower case, no root dot)."""
+    return hostname.rstrip(".").lower()
+
+
+@dataclass(frozen=True, slots=True)
+class Credentials:
+    """Everything needed to talk Modbus/TLS to one paired heat pump."""
+
+    root_ca_pem: bytes
+    """The heat pump's root CA certificate (PEM)."""
+    client_cert_pem: bytes
+    """Client certificate signed by the root CA (PEM)."""
+    client_key_pem: bytes
+    """Private key of the client certificate (unencrypted PKCS#8 PEM)."""
+    device_hostname: str
+    """mDNS host name the heat pump was paired under, e.g. ``hpcb-a1b2c3.local``.
+
+    Stable per heat pump; use it to recognise the same unit in later mDNS
+    announcements.
+    """
+
+    def validate(self) -> None:
+        """Check the parts parse and belong together.
+
+        Raises ``InvalidCredentialsError`` otherwise.
+        """
+        try:
+            root = x509.load_pem_x509_certificate(self.root_ca_pem)
+            cert = x509.load_pem_x509_certificate(self.client_cert_pem)
+            key = serialization.load_pem_private_key(self.client_key_pem, None)
+        except (ValueError, TypeError) as err:
+            raise InvalidCredentialsError(f"Malformed credentials: {err}") from err
+        if cert.public_key() != key.public_key():
+            raise InvalidCredentialsError("Client key does not match certificate")
+        try:
+            cert.verify_directly_issued_by(root)
+        except (ValueError, TypeError, InvalidSignature) as err:
+            raise InvalidCredentialsError(
+                "Client certificate is not signed by the root CA"
+            ) from err
+        if not self.device_hostname:
+            raise InvalidCredentialsError("Missing device hostname")
+
+    def as_dict(self) -> dict[str, str]:
+        """JSON-serialisable form, for storing the credentials."""
+        return {
+            "root_ca": self.root_ca_pem.decode(),
+            "client_cert": self.client_cert_pem.decode(),
+            "client_key": self.client_key_pem.decode(),
+            "device_hostname": self.device_hostname,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        """Rebuild credentials stored with :meth:`as_dict`.
+
+        Raises ``InvalidCredentialsError`` if a part is missing or malformed.
+        """
+        try:
+            credentials = cls(
+                root_ca_pem=data["root_ca"].encode(),
+                client_cert_pem=data["client_cert"].encode(),
+                client_key_pem=data["client_key"].encode(),
+                device_hostname=data["device_hostname"],
+            )
+        except (KeyError, AttributeError) as err:
+            raise InvalidCredentialsError(f"Incomplete credentials: {err}") from err
+        credentials.validate()
+        return credentials
+
+    def write_files(self, directory: Path) -> CredentialFiles:
+        """Write the PEM files TLS needs into ``directory`` (blocking I/O).
+
+        Python's ``ssl`` only loads a client certificate from files, so the
+        connection needs them on disk. The private key is written owner-only.
+        """
+        directory.mkdir(parents=True, exist_ok=True)
+        files = CredentialFiles(
+            root_ca=directory / ROOT_CA_FILENAME,
+            client_cert=directory / CLIENT_CERT_FILENAME,
+            client_key=directory / CLIENT_KEY_FILENAME,
+        )
+        files.root_ca.write_bytes(self.root_ca_pem)
+        files.client_cert.write_bytes(self.client_cert_pem)
+        fd = os.open(files.client_key, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+        with os.fdopen(fd, "wb") as handle:
+            handle.write(self.client_key_pem)
+        os.chmod(files.client_key, 0o600)  # also tighten a pre-existing file
+        return files
+
+
+@dataclass(frozen=True, slots=True)
+class CredentialFiles:
+    """Paths of credentials written by :meth:`Credentials.write_files`."""
+
+    root_ca: Path
+    client_cert: Path
+    client_key: Path
+
+    def tls_params(self, host: str, port: int = MODBUS_TLS_PORT) -> ModbusTlsParams:
+        """Connection parameters for the heat pump at ``host``.
+
+        The server certificate is verified against the heat pump's own root
+        CA. Its host name is not checked: the heat pump is usually reached by
+        IP address, and the per-device root CA already pins the connection to
+        the paired unit.
+        """
+        return ModbusTlsParams(
+            host=host,
+            port=port,
+            verify=str(self.root_ca),
+            check_hostname=False,
+            client_cert=str(self.client_cert),
+            client_key=str(self.client_key),
+        )