iotfiy 1.0.0__py3-none-any.whl

iotfiy/__init__.py

@@ -0,0 +1,7 @@
+"""IOTFIY - MQTT gateway client for Raspberry Pi (3 / 4 / 5)."""
+
+from .ref import Ref
+from .client import IOTFIYManager, IOTFIY
+
+__all__ = ["IOTFIY", "IOTFIYManager", "Ref"]
+__version__ = "1.0.0"

iotfiy/client.py

@@ -0,0 +1,367 @@
+"""IOTFIY manager - Arduino IOTFIYManager API for Raspberry Pi."""
+
+from __future__ import annotations
+
+import json
+import socket
+import time
+from typing import List, Optional
+
+import paho.mqtt.client as mqtt
+
+from .device_config import DeviceConfig
+from .receive import Receive
+from .ref import Ref
+from .send import Send
+
+
+class IOTFIYManager:
+    MAX_SENDS = 10
+    MAX_RECEIVES = 10
+
+    def __init__(self):
+        self._sends: List[Send] = []
+        self._receives: List[Receive] = []
+        self._config = DeviceConfig()
+        self._lwt_enabled = False
+        self._client: Optional[mqtt.Client] = None
+
+    def config_obj(self) -> DeviceConfig:
+        """Access underlying DeviceConfig (Arduino: config())."""
+        return self._config
+
+    def enable_lwt(self, enabled: bool = True) -> None:
+        self._lwt_enabled = enabled
+        state = "ENABLED (offline on disconnect)" if enabled else "disabled"
+        print(f"MQTT LWT {state}")
+
+    def config(
+        self,
+        ssid: str,
+        password: str,
+        mqtt_server: str,
+        mqtt_client_id: str,
+        device_id: str,
+        mqtt_port: int = 1883,
+        mqtt_username: str = "",
+        mqtt_password: str = "",
+    ) -> None:
+        """Same signature as Arduino IOTFIY.config(...).
+
+        On Raspberry Pi, WiFi is normally managed by the OS. ``ssid`` /
+        ``password`` are kept for API compatibility; MQTT settings are required.
+        """
+        self._config.ssid(ssid).password(password).server(mqtt_server).port(
+            mqtt_port
+        ).client_id(mqtt_client_id).device_id(device_id).mqtt_username(
+            mqtt_username
+        ).mqtt_password(mqtt_password)
+
+    def begin(self) -> None:
+        if not self._config.is_valid():
+            raise ValueError(
+                "IOTFIY config incomplete - set mqtt_server, client_id, device_id"
+            )
+
+        # paho-mqtt 2.x uses CallbackAPIVersion; 1.x does not.
+        try:
+            self._client = mqtt.Client(
+                mqtt.CallbackAPIVersion.VERSION1,
+                client_id=self._config.get_mqtt_client_id,
+            )
+        except (AttributeError, TypeError):
+            self._client = mqtt.Client(client_id=self._config.get_mqtt_client_id)
+
+        self._client.on_message = self._on_message
+        self._client.on_disconnect = self._on_disconnect
+
+        if self._config.get_mqtt_username:
+            self._client.username_pw_set(
+                self._config.get_mqtt_username,
+                self._config.get_mqtt_password,
+            )
+
+        if self._lwt_enabled:
+            will_payload = json.dumps(
+                {
+                    "status": "offline",
+                    "deviceId": self._config.get_device_id,
+                }
+            )
+            self._client.will_set(
+                self._config.get_status_topic(),
+                payload=will_payload,
+                qos=1,
+                retain=True,
+            )
+
+        self._bind_client_to_capabilities()
+
+    def register_all_capabilities(self) -> None:
+        start = {
+            "deviceId": self._config.get_device_id,
+            "event": "capabilities_registration_start",
+            "total_controls": len(self._receives),
+            "total_sensors": len(self._sends),
+        }
+        self._publish(self._config.get_status_topic(), start, retain=False)
+
+        for receive in self._receives:
+            receive.register_capability()
+        for send in self._sends:
+            send.register_capability()
+
+        end = {
+            "deviceId": self._config.get_device_id,
+            "event": "capabilities_registration_complete",
+            "controls_registered": len(self._receives),
+            "sensors_registered": len(self._sends),
+        }
+        self._publish(self._config.get_status_topic(), end, retain=False)
+
+    def launch(self) -> None:
+        for send in self._sends:
+            send.publish_data()
+
+    def publish_string_output(self, name: str, pin: str, value: str) -> bool:
+        if not self.is_mqtt_connected():
+            return False
+
+        cap = {
+            "deviceId": self._config.get_device_id,
+            "type": "capabilities_output",
+            "outputName": name,
+            "output": {"type": "string", "pin": pin},
+        }
+        cap_topic = (
+            f"devices/{self._config.get_device_id}/capabilities_output/{name}"
+        )
+        self._publish(cap_topic, cap, retain=True)
+
+        data = {
+            "type": "output",
+            "deviceId": self._config.get_device_id,
+            "data": {name: value, pin: value},
+        }
+        print(f"String output {pin}={value}")
+        return self._publish(self._config.get_data_topic(), data, retain=False)
+
+    def reconnect_mqtt(self) -> bool:
+        if self._client is None:
+            self.begin()
+
+        assert self._client is not None
+        if self._client.is_connected():
+            return True
+
+        for attempt in range(1, 6):
+            print(f"MQTT connection attempt {attempt}... ", end="", flush=True)
+            try:
+                self._client.connect(
+                    self._config.get_mqtt_server,
+                    self._config.get_mqtt_port,
+                    keepalive=60,
+                )
+                # Give the network stack a moment, then poll until connected.
+                deadline = time.time() + 8
+                while time.time() < deadline and not self._client.is_connected():
+                    self._client.loop(timeout=0.2)
+
+                if self._client.is_connected():
+                    print("connected!")
+                    if self._lwt_enabled:
+                        print(f"LWT registered on {self._config.get_status_topic()}")
+
+                    self._client.subscribe(self._config.get_commands_topic())
+                    status = {
+                        "status": "online",
+                        "deviceId": self._config.get_device_id,
+                    }
+                    self._publish(
+                        self._config.get_status_topic(), status, retain=True
+                    )
+                    self.register_all_capabilities()
+                    return True
+
+                print("failed (timeout)")
+            except Exception as exc:
+                print(f"failed ({exc})")
+
+            if attempt < 5:
+                time.sleep(5)
+
+        return False
+
+    def check_and_reconnect_wifi(self) -> bool:
+        """On Pi, verify network path to the MQTT broker (OS manages Wi-Fi)."""
+        host = self._config.get_mqtt_server
+        port = self._config.get_mqtt_port
+        if not host:
+            print("WiFi/network check failed: MQTT server not configured")
+            return False
+
+        try:
+            with socket.create_connection((host, port), timeout=3):
+                return True
+        except OSError:
+            print("Network unreachable to MQTT broker. Will retry...")
+            return False
+
+    def is_mqtt_connected(self) -> bool:
+        return bool(self._client and self._client.is_connected())
+
+    def process_mqtt_messages(self) -> None:
+        if self._client is not None:
+            self._client.loop(timeout=0.05)
+
+    def write(
+        self,
+        name: str,
+        type_: str,
+        pin: str,
+        data_source: Ref,
+        min_value: Optional[float] = None,
+        max_value: Optional[float] = None,
+    ) -> Optional[Send]:
+        if len(self._sends) >= self.MAX_SENDS:
+            return None
+        if not isinstance(data_source, Ref):
+            raise TypeError("write() expects an iotfiy.Ref for data_source")
+
+        send = Send(
+            name,
+            type_,
+            pin,
+            data_source,
+            self._client,
+            self._config,
+            min_value,
+            max_value,
+        )
+        # Client may be created later in begin(); keep reference alive.
+        self._sends.append(send)
+        self._bind_client_to_capabilities()
+        return send
+
+    def read(
+        self,
+        name: str,
+        type_: str,
+        pin: str,
+        entry_point: Ref,
+        min_value: Optional[float] = None,
+        max_value: Optional[float] = None,
+    ) -> Optional[Receive]:
+        if len(self._receives) >= self.MAX_RECEIVES:
+            return None
+        if not isinstance(entry_point, Ref):
+            raise TypeError("read() expects an iotfiy.Ref for entry_point")
+
+        receive = Receive(
+            name,
+            type_,
+            pin,
+            entry_point,
+            self._client,
+            self._config,
+            min_value,
+            max_value,
+        )
+        self._receives.append(receive)
+        self._bind_client_to_capabilities()
+        return receive
+
+    def _bind_client_to_capabilities(self) -> None:
+        if self._client is None:
+            return
+        for send in self._sends:
+            send._client = self._client
+        for receive in self._receives:
+            receive._client = self._client
+
+    def _publish(self, topic: str, payload: dict, retain: bool) -> bool:
+        if not self.is_mqtt_connected():
+            return False
+        assert self._client is not None
+        try:
+            info = self._client.publish(topic, json.dumps(payload), retain=retain)
+            return info.rc == 0
+        except Exception as exc:
+            print(f"MQTT publish error: {exc}")
+            return False
+
+    def _on_disconnect(self, client, userdata, rc):
+        if rc != 0:
+            print(f"Unexpected MQTT disconnect (rc={rc})")
+
+    def _on_message(self, client, userdata, msg):
+        try:
+            message = msg.payload.decode("utf-8", errors="replace")
+        except Exception:
+            return
+
+        print(f"Message arrived [{msg.topic}] {message}")
+
+        try:
+            doc = json.loads(message)
+        except json.JSONDecodeError as exc:
+            print(f"JSON parse failed: {exc}")
+            return
+
+        if msg.topic != self._config.get_commands_topic():
+            return
+
+        value = None
+        control_name = None
+        pin_name = None
+
+        if isinstance(doc, dict) and "data" in doc and "type" in doc:
+            data = doc.get("data") or {}
+            value = data.get("value")
+            control_name = data.get("control")
+            pin_name = data.get("pin")
+        elif isinstance(doc, dict):
+            value = doc.get("value")
+            control_name = doc.get("control")
+            pin_name = doc.get("pin")
+
+        target: Optional[Receive] = None
+        if control_name:
+            for receive in self._receives:
+                if receive.get_name() == control_name:
+                    target = receive
+                    break
+        elif pin_name:
+            for receive in self._receives:
+                if receive.get_pin() == pin_name:
+                    target = receive
+                    break
+
+        if target is not None:
+            result = {}
+            success = target.handle_command(value, result)
+            response = {
+                "status": "success" if success else "error",
+                "control": target.get_name(),
+                "result": result,
+            }
+            self._publish(
+                self._config.get_command_response_topic(), response, retain=False
+            )
+        else:
+            print("ERROR: No matching control or pin found")
+            error = {
+                "status": "error",
+                "message": "No matching control or pin found",
+            }
+            if control_name:
+                error["control"] = control_name
+            if pin_name:
+                error["pin"] = pin_name
+            self._publish(
+                self._config.get_command_response_topic(), error, retain=False
+            )
+
+
+# Global instance (Arduino: extern IOTFIYManager IOTFIY)
+IOTFIY = IOTFIYManager()

iotfiy/device_config.py

@@ -0,0 +1,96 @@
+"""Device / MQTT configuration (mirrors Arduino DeviceConfig)."""
+
+
+class DeviceConfig:
+    def __init__(self):
+        self._ssid = ""
+        self._password = ""
+        self._mqtt_server = ""
+        self._mqtt_port = 1883
+        self._mqtt_client_id = ""
+        self._mqtt_username = ""
+        self._mqtt_password = ""
+        self._device_id = ""
+
+    def ssid(self, value: str):
+        self._ssid = value or ""
+        return self
+
+    def password(self, value: str):
+        self._password = value or ""
+        return self
+
+    def server(self, value: str):
+        self._mqtt_server = value or ""
+        return self
+
+    def port(self, value: int):
+        self._mqtt_port = int(value)
+        return self
+
+    def client_id(self, value: str):
+        self._mqtt_client_id = value or ""
+        return self
+
+    def device_id(self, value: str):
+        self._device_id = value or ""
+        return self
+
+    def mqtt_username(self, value: str):
+        self._mqtt_username = value or ""
+        return self
+
+    def mqtt_password(self, value: str):
+        self._mqtt_password = value or ""
+        return self
+
+    @property
+    def get_ssid(self) -> str:
+        return self._ssid
+
+    @property
+    def get_password(self) -> str:
+        return self._password
+
+    @property
+    def get_mqtt_server(self) -> str:
+        return self._mqtt_server
+
+    @property
+    def get_mqtt_port(self) -> int:
+        return self._mqtt_port
+
+    @property
+    def get_mqtt_client_id(self) -> str:
+        return self._mqtt_client_id
+
+    @property
+    def get_device_id(self) -> str:
+        return self._device_id
+
+    @property
+    def get_mqtt_username(self) -> str:
+        return self._mqtt_username
+
+    @property
+    def get_mqtt_password(self) -> str:
+        return self._mqtt_password
+
+    def get_data_topic(self) -> str:
+        return f"devices/{self._device_id}/data"
+
+    def get_status_topic(self) -> str:
+        return f"devices/{self._device_id}/status"
+
+    def get_commands_topic(self) -> str:
+        return f"devices/{self._device_id}/commands"
+
+    def get_command_response_topic(self) -> str:
+        return f"devices/{self._device_id}/command-response"
+
+    def is_valid(self) -> bool:
+        return bool(
+            self._mqtt_server
+            and self._mqtt_client_id
+            and self._device_id
+        )

iotfiy/receive.py

@@ -0,0 +1,124 @@
+"""Control capability (mirrors Arduino Receive)."""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import TYPE_CHECKING, Any, Optional
+
+from .ref import Ref
+
+if TYPE_CHECKING:
+    from .device_config import DeviceConfig
+
+
+class Receive:
+    def __init__(
+        self,
+        name: str,
+        type_: str,
+        pin: str,
+        entry_point: Ref,
+        client: Any,
+        config: DeviceConfig,
+        min_value: Optional[float] = None,
+        max_value: Optional[float] = None,
+    ):
+        self._client = client
+        self._config = config
+        self.name = name
+        self.type = type_
+        self.pin = pin
+        self.entry_point = entry_point
+        self.has_range = min_value is not None and max_value is not None
+        self.min = float(min_value) if min_value is not None else 0.0
+        self.max = float(max_value) if max_value is not None else 0.0
+        self.is_registered = False
+        self.default_delay = 0.05
+
+    def get_name(self) -> str:
+        return self.name
+
+    def get_type(self) -> str:
+        return self.type
+
+    def get_pin(self) -> str:
+        return self.pin
+
+    def register_capability(self) -> bool:
+        control = {"type": self.type, "pin": self.pin}
+        if self.type in ("float", "integer") and self.has_range:
+            control["min"] = self.min
+            control["max"] = self.max
+
+        payload = {
+            "deviceId": self._config.get_device_id,
+            "type": "capabilities_control",
+            "controlName": self.name,
+            "control": control,
+        }
+        topic = f"devices/{self._config.get_device_id}/capabilities_control/{self.name}"
+        published = self._publish(topic, payload, retain=True)
+        print(f"{self.name} control published: {'SUCCESS' if published else 'FAILED'}")
+        if published:
+            self.is_registered = True
+        time.sleep(self.default_delay)
+        return published
+
+    def handle_command(self, value: Any, result: dict) -> bool:
+        if self.type == "float":
+            float_value = float(value)
+            if self.has_range:
+                float_value = max(self.min, min(self.max, float_value))
+            self.entry_point.value = float_value
+            result["newState"] = float_value
+            print(
+                f"[RX] pin={self.pin} name={self.name} value={float_value} "
+                f"<- backend"
+            )
+            return True
+
+        if self.type == "integer":
+            int_value = int(value)
+            if self.has_range:
+                int_value = int(max(self.min, min(self.max, int_value)))
+            self.entry_point.value = int_value
+            result["newState"] = int_value
+            print(
+                f"[RX] pin={self.pin} name={self.name} value={int_value} "
+                f"<- backend"
+            )
+            return True
+
+        if self.type == "boolean":
+            str_value = str(value).strip().lower()
+            bool_value = 1.0 if str_value in ("on", "true", "1") else 0.0
+            self.entry_point.value = bool_value
+            result["newState"] = str(value)
+            print(
+                f"[RX] pin={self.pin} name={self.name} value={str_value} "
+                f"(truth={bool_value}) <- backend"
+            )
+            return True
+
+        if self.type == "string":
+            str_value = str(value)
+            self.entry_point.value = str_value
+            result["newState"] = str_value
+            print(
+                f"[RX] pin={self.pin} name={self.name} value={str_value} "
+                f"<- backend"
+            )
+            return True
+
+        return False
+
+    def _publish(self, topic: str, payload: dict, retain: bool) -> bool:
+        if self._client is None or not self._client.is_connected():
+            return False
+        try:
+            info = self._client.publish(topic, json.dumps(payload), retain=retain)
+            return info.rc == 0
+        except Exception as exc:
+            print(f"Receive publish error: {exc}")
+            return False

iotfiy/ref.py

@@ -0,0 +1,21 @@
+"""Mutable value holder (Arduino float* / String* equivalent)."""
+
+
+class Ref:
+    """Hold a value that write()/read() can update in place.
+
+    Example::
+
+        sensor = Ref(0.0)
+        IOTFIY.write("SensorValue", "float", "A0", sensor)
+        sensor.value = 42.5
+        IOTFIY.launch()
+    """
+
+    __slots__ = ("value",)
+
+    def __init__(self, value=0.0):
+        self.value = value
+
+    def __repr__(self):
+        return f"Ref({self.value!r})"

iotfiy/send.py

@@ -0,0 +1,102 @@
+"""Output / sensor capability (mirrors Arduino Send)."""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import TYPE_CHECKING, Any, Optional
+
+from .ref import Ref
+
+if TYPE_CHECKING:
+    from .device_config import DeviceConfig
+
+
+class Send:
+    def __init__(
+        self,
+        name: str,
+        type_: str,
+        pin: str,
+        exit_point: Ref,
+        client: Any,
+        config: DeviceConfig,
+        min_value: Optional[float] = None,
+        max_value: Optional[float] = None,
+    ):
+        self._client = client
+        self._config = config
+        self.name = name
+        self.type = type_
+        self.pin = pin
+        self.exit_point = exit_point
+        self.has_range = min_value is not None and max_value is not None
+        self.min = float(min_value) if min_value is not None else 0.0
+        self.max = float(max_value) if max_value is not None else 0.0
+        self.is_registered = False
+        self.default_delay = 0.05
+
+    def get_name(self) -> str:
+        return self.name
+
+    def get_type(self) -> str:
+        return self.type
+
+    def get_pin(self) -> str:
+        return self.pin
+
+    def get_current_value(self) -> float:
+        return float(self.exit_point.value)
+
+    def set_delay(self, ms: int) -> None:
+        self.default_delay = max(0, ms) / 1000.0
+
+    def register_capability(self) -> bool:
+        payload = {
+            "deviceId": self._config.get_device_id,
+            "type": "capabilities_output",
+            "outputName": self.name,
+            "output": {"type": self.type, "pin": self.pin},
+        }
+        topic = f"devices/{self._config.get_device_id}/capabilities_output/{self.name}"
+        published = self._publish(topic, payload, retain=True)
+        print(f"{self.name} output published: {'SUCCESS' if published else 'FAILED'}")
+        if published:
+            self.is_registered = True
+        time.sleep(self.default_delay)
+        return published
+
+    def publish_data(self) -> bool:
+        value = float(self.exit_point.value)
+        if self.has_range:
+            value = max(self.min, min(self.max, value))
+
+        if not self.is_registered:
+            self.register_capability()
+
+        data = {self.name: value}
+        if self.pin:
+            data[self.pin] = value
+
+        payload = {
+            "type": "output",
+            "deviceId": self._config.get_device_id,
+            "data": data,
+        }
+        published = self._publish(self._config.get_data_topic(), payload, retain=False)
+        status = "OK" if published else "FAIL"
+        print(
+            f"[TX] pin={self.pin} name={self.name} value={value} "
+            f"-> backend {status}"
+        )
+        return published
+
+    def _publish(self, topic: str, payload: dict, retain: bool) -> bool:
+        if self._client is None or not self._client.is_connected():
+            return False
+        try:
+            info = self._client.publish(topic, json.dumps(payload), retain=retain)
+            return info.rc == 0
+        except Exception as exc:
+            print(f"Send publish error: {exc}")
+            return False

iotfiy-1.0.0.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: iotfiy
+Version: 1.0.0
+Summary: IOTFIY MQTT gateway client for Raspberry Pi 3/4/5
+Author-email: Iotfiy Solutions <iotfiy.solution@gmail.com>
+Keywords: iot,mqtt,raspberry-pi,iotfiy
+Requires-Python: >=3.9
+Requires-Dist: paho-mqtt>=1.6.1
+Provides-Extra: gpio
+Requires-Dist: gpiozero; extra == "gpio"

iotfiy-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+iotfiy/__init__.py,sha256=FYm_DMp2GUmntEfHegdXUnZL8wd1z9nQxQTrS6Pw8VM,204
+iotfiy/client.py,sha256=nAdt67Jhjbymr513dupNSPIWejZxwOUZepjuOd_64i8,12224
+iotfiy/device_config.py,sha256=pqHENRKWy5uMhPBL3b9xd6tpsSdhOGdYJKGuy7Vg244,2442
+iotfiy/receive.py,sha256=k9ZiZmUZiBkIiHokEykffruCAYRuWzD_PjhzZitE5m4,4180
+iotfiy/ref.py,sha256=tfl7ptNrJbqTq4qdXVnQ2HYvSGdrSu-sIY993PxoHpA,476
+iotfiy/send.py,sha256=NHgmgT-8OHgTRMJzoEpJ8ABaP5BScBvJgWlZvT2zIRg,3212
+iotfiy-1.0.0.dist-info/METADATA,sha256=4iGl-GiraD0c7nuSIVtX7Bh3IMomIZESA6fslNRZvww,334
+iotfiy-1.0.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+iotfiy-1.0.0.dist-info/top_level.txt,sha256=8-lQBy51P3eE9qiLhXWM4SyipsUTvkZANDMFUtIWFN8,7
+iotfiy-1.0.0.dist-info/RECORD,,

iotfiy-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

iotfiy-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+iotfiy