juham-watermeter 0.0.4__py3-none-any.whl → 0.0.6__py3-none-any.whl

juham_watermeter/watermeter_ts.py

@@ -1,100 +1,100 @@
-"""Water meter time series recorder
-
-"""
-
-import json
-
-from typing import Any
-from typing_extensions import override
-from masterpiece.mqtt import MqttMsg
-
-from juham_core.timeutils import epoc2utc
-from juham_core import JuhamTs
-
-
-class WaterMeterTs(JuhamTs):
-    """Watermeter timeseries recorder. Listens the watermeter MQTT topic
-    and writes the measurements to timeseries database.
-
-    """
-
-    _WATERMETER: str = "watermeter_ts"
-    _WATERMETER_ATTRS: list[str] = [
-        "topic",
-    ]
-
-    topic = "watermeter"  # topic to listen
-
-    def __init__(self, name="watermeter_ts") -> None:
-        """Watermeter recorder, for listening watermeter MQTT topic and saving
-        measurements to timeseries database.
-
-        Args:
-            name (str, optional): name of the object.
-        """
-        super().__init__(name)
-        self.watermeter_topic: str = self.make_topic_name(self.topic)
-
-    @override
-    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
-        super().on_connect(client, userdata, flags, rc)
-        if rc == 0:
-            self.subscribe(self.watermeter_topic)
-
-    @override
-    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
-        if msg.topic == self.watermeter_topic:
-            em = json.loads(msg.payload.decode())
-            self.record(em)
-        else:
-            super().on_message(client, userdata, msg)
-
-    def record(self, info: dict[str, float]) -> None:
-        """Writes system info to the time series database
-
-        Args:
-            ts (float): utc time
-            em (dict): water meter message
-        """
-
-        try:
-            if "leak_suspected" in info:
-                self.write_point(
-                    "watermeter",
-                    {"sensor": info["sensor"], "location": info["location"]},
-                    {
-                        "leak_suspected": info["leak_suspected"],
-                        "ts": info["ts"],
-                    },
-                    epoc2utc(info["ts"]),
-                )
-            elif "active_lpm" in info:
-                self.write_point(
-                    "watermeter",
-                    {"sensor": info["sensor"], "location": info["location"]},
-                    {
-                        "total_liter": info["total_liter"],
-                        "active_lpm": info["active_lpm"],
-                        "ts": info["ts"],
-                    },
-                    epoc2utc(info["ts"]),
-                )
-        except Exception as e:
-            self.error(f"Writing memory to influx failed {str(e)}")
-
-    @override
-    def to_dict(self) -> dict[str, Any]:
-        data = super().to_dict()  # Call super class method
-        watermeter_data = {}
-        for attr in self._WATERMETER_ATTRS:
-            watermeter_data[attr] = getattr(self, attr)
-        data[self._WATERMETER] = watermeter_data
-        return data
-
-    @override
-    def from_dict(self, data: dict[str, Any]) -> None:
-        super().from_dict(data)  # Call super class method
-        if self._WATERMETER in data:
-            watermeter_data = data[self._WATERMETER]
-            for attr in self._WATERMETER_ATTRS:
-                setattr(self, attr, watermeter_data.get(attr, None))
+"""Water meter time series recorder
+
+"""
+
+import json
+
+from typing import Any
+from typing_extensions import override
+from masterpiece.mqtt import MqttMsg
+
+from juham_core.timeutils import epoc2utc
+from juham_core import JuhamTs
+
+
+class WaterMeterTs(JuhamTs):
+    """Watermeter timeseries recorder. Listens the watermeter MQTT topic
+    and writes the measurements to timeseries database.
+
+    """
+
+    _WATERMETER: str = "watermeter_ts"
+    _WATERMETER_ATTRS: list[str] = [
+        "topic",
+    ]
+
+    topic = "watermeter"  # topic to listen
+
+    def __init__(self, name="watermeter_ts") -> None:
+        """Watermeter recorder, for listening watermeter MQTT topic and saving
+        measurements to timeseries database.
+
+        Args:
+            name (str, optional): name of the object.
+        """
+        super().__init__(name)
+        self.watermeter_topic: str = self.make_topic_name(self.topic)
+
+    @override
+    def on_connect(self, client: object, userdata: Any, flags: int, rc: int) -> None:
+        super().on_connect(client, userdata, flags, rc)
+        if rc == 0:
+            self.subscribe(self.watermeter_topic)
+
+    @override
+    def on_message(self, client: object, userdata: Any, msg: MqttMsg) -> None:
+        if msg.topic == self.watermeter_topic:
+            em = json.loads(msg.payload.decode())
+            self.record(em)
+        else:
+            super().on_message(client, userdata, msg)
+
+    def record(self, info: dict[str, float]) -> None:
+        """Writes system info to the time series database
+
+        Args:
+            ts (float): utc time
+            em (dict): water meter message
+        """
+
+        try:
+            if "leak_suspected" in info:
+                self.write_point(
+                    "watermeter",
+                    {"sensor": info["sensor"], "location": info["location"]},
+                    {
+                        "leak_suspected": info["leak_suspected"],
+                        "ts": info["ts"],
+                    },
+                    epoc2utc(info["ts"]),
+                )
+            elif "active_lpm" in info:
+                self.write_point(
+                    "watermeter",
+                    {"sensor": info["sensor"], "location": info["location"]},
+                    {
+                        "total_liter": info["total_liter"],
+                        "active_lpm": info["active_lpm"],
+                        "ts": info["ts"],
+                    },
+                    epoc2utc(info["ts"]),
+                )
+        except Exception as e:
+            self.error(f"Writing memory to influx failed {str(e)}")
+
+    @override
+    def to_dict(self) -> dict[str, Any]:
+        data = super().to_dict()  # Call super class method
+        watermeter_data = {}
+        for attr in self._WATERMETER_ATTRS:
+            watermeter_data[attr] = getattr(self, attr)
+        data[self._WATERMETER] = watermeter_data
+        return data
+
+    @override
+    def from_dict(self, data: dict[str, Any]) -> None:
+        super().from_dict(data)  # Call super class method
+        if self._WATERMETER in data:
+            watermeter_data = data[self._WATERMETER]
+            for attr in self._WATERMETER_ATTRS:
+                setattr(self, attr, watermeter_data.get(attr, None))

juham_watermeter/webcamera.py

@@ -1,174 +1,172 @@
-"""Web camera with basic image processing features.
-
-"""
-
-import cv2
-import numpy as np
-from typing import Any, Optional
-from typing_extensions import override
-from masterpiece.mqtt import Mqtt
-from masterpiece import MasterPieceThread
-from juham_core import JuhamThread
-from juham_core.timeutils import timestamp
-
-
-class WebCameraThread(MasterPieceThread):
-    """Asynchronous thread for capturing and processing images of web camera."""
-
-    # class attributes
-    _interval: float = 60  # seconds
-    _location = "unknown"
-    _camera: int = 0  # e.g. 0 built-in, 1 external camera
-    _expected_image_size: int = 640 * 480
-
-    def __init__(self, client: Optional[Mqtt] = None):
-        """Construct with the given mqtt client.  Initializes minimal 1x1 image
-        with timestamp 0.0, which are updated to actual image size and timestamp
-        with each captured image, for sub classes to process.
-
-        Args:
-            client (object, optional): MQTT client. Defaults to None.
-        """
-        super().__init__(client)
-        self.mqtt_client: Optional[Mqtt] = client
-        self.image: np.ndarray = np.zeros((1, 1, 3), dtype=np.uint8)
-        self.image_timestamp: float = 0.0
-
-    def init(
-        self,
-        interval: float,
-        location: str,
-        camera: int,
-    ) -> None:
-        """Initialize the  data acquisition thread
-
-        Args:
-            interval (float): update interval in seconds
-            location (str): geographic location
-            camera(int) : ordinal specifying the camera to be used (0, 1)
-
-        """
-        self._interval = interval
-        self._location = location
-        self._camera = camera
-
-    def capture_image(self) -> np.ndarray:
-        """
-        Captures an image from the webcam and returns the image as a numpy array.
-
-        Returns:
-            np.ndarray: The captured image in the form of a NumPy array.
-        """
-        # Initialize the webcam (0 for the built-in camera or 1 for the USB webcam)
-        cap = cv2.VideoCapture(self._camera)
-
-        # Check if the webcam is opened correctly
-        if not cap.isOpened():
-            print("CANNOT ACCESS THE CAMERA")
-            self.error(f"Could not access the camera {self._camera}.")
-            return np.zeros(
-                (1, 1, 3), dtype=np.uint8
-            )  # Return an empty array if the camera isn't accessible
-
-        # Capture a frame
-        try:
-            ret, frame = cap.read()
-
-            if not ret:
-                print("WTF, Camera failed again")
-                self.error("Could not capture image.")
-                frame = np.zeros(
-                    (1, 1, 3), dtype=np.uint8
-                )  # Return 1x1 array if capture failed
-        finally:
-            cap.release()
-            print("Camera released")
-        return frame  # Return the captured image
-
-    def process_image(self, image: np.ndarray) -> np.ndarray:
-        """
-        Processes the captured image by converting it to grayscale and applying thresholding.
-
-        Args:
-            image (np.ndarray): The input image to process.
-
-        Returns:
-            np.ndarray: The processed image after grayscale conversion and thresholding.
-        """
-        if image.size < self._expected_image_size:  # Check if the image is empty
-            self.error("Received an empty image for processing.")
-            return image
-
-        # Convert the image to grayscale
-        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
-        return gray
-
-    def enhance_contrast(self, image: np.ndarray) -> np.ndarray:
-        """
-        Enhances the contrast of a grayscale image while suppressing noise.
-
-        Args:
-            image (np.ndarray): The input grayscale image.
-
-        Returns:
-            np.ndarray: The contrast-enhanced image with reduced noise amplification.
-        """
-        if image.ndim != 2:  # Ensure the image is grayscale
-            self.error("Contrast enhancement requires a grayscale image.")
-            return image
-
-        # Apply a slight Gaussian blur to reduce noise before enhancing contrast
-        blurred = cv2.GaussianBlur(image, (3, 3), 0)
-
-        # Apply CLAHE with conservative parameters to avoid over-enhancement
-        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-        contrast_enhanced = clahe.apply(blurred)
-
-        return contrast_enhanced
-
-    @override
-    def update_interval(self) -> float:
-        return self._interval
-
-    @override
-    def update(self) -> bool:
-        self.image = self.capture_image()
-        self.image_timestamp = timestamp()
-        return self.image.size == self._expected_image_size
-
-
-class WebCamera(JuhamThread):
-    """Base class for web camera."""
-
-    _WEBCAMERA: str = "webcamera"
-    _WEBCAMERA_ATTRS: list[str] = ["location", "camera"]
-
-    _workerThreadId: str = WebCameraThread.get_class_id()
-    update_interval: float = 60
-    location = "home"
-    camera: int = 0
-
-    def __init__(self, name="webcam") -> None:
-        """Constructs system status automation object for acquiring and publishing
-        system info e.g. available memory and CPU loads.
-
-        Args:
-            name (str, optional): name of the object.
-        """
-        super().__init__(name)
-        self.worker: Optional[WebCameraThread] = None
-
-    def to_dict(self) -> dict[str, Any]:
-        data = super().to_dict()  # Call parent class method
-        webcam_data = {}
-        for attr in self._WEBCAMERA_ATTRS:
-            webcam_data[attr] = getattr(self, attr)
-        data[self._WEBCAMERA] = webcam_data
-        return data
-
-    def from_dict(self, data: dict[str, Any]) -> None:
-        super().from_dict(data)  # Call parent class method
-        if self._WEBCAMERA in data:
-            webcam_data = data[self._WEBCAMERA]
-            for attr in self._WEBCAMERA_ATTRS:
-                setattr(self, attr, webcam_data.get(attr, None))
+"""Web camera with basic image processing features.
+
+"""
+
+import cv2
+import numpy as np
+from typing import Any, Optional
+from typing_extensions import override
+from masterpiece.mqtt import Mqtt
+from masterpiece import MasterPieceThread
+from juham_core import JuhamThread
+from juham_core.timeutils import timestamp
+
+
+class WebCameraThread(MasterPieceThread):
+    """Asynchronous thread for capturing and processing images of web camera."""
+
+    # class attributes
+    _interval: float = 60  # seconds
+    _location = "unknown"
+    _camera: int = 0  # e.g. 0 built-in, 1 external camera
+    _expected_image_size: int = 640 * 480
+
+    def __init__(self, client: Optional[Mqtt] = None):
+        """Construct with the given mqtt client.  Initializes minimal 1x1 image
+        with timestamp 0.0, which are updated to actual image size and timestamp
+        with each captured image, for sub classes to process.
+
+        Args:
+            client (object, optional): MQTT client. Defaults to None.
+        """
+        super().__init__(client)
+        self.mqtt_client: Optional[Mqtt] = client
+        self.image: np.ndarray = np.zeros((1, 1, 3), dtype=np.uint8)
+        self.image_timestamp: float = 0.0
+
+    def init(
+        self,
+        interval: float,
+        location: str,
+        camera: int,
+    ) -> None:
+        """Initialize the  data acquisition thread
+
+        Args:
+            interval (float): update interval in seconds
+            location (str): geographic location
+            camera(int) : ordinal specifying the camera to be used (0, 1)
+
+        """
+        self._interval = interval
+        self._location = location
+        self._camera = camera
+
+    def capture_image(self) -> np.ndarray:
+        """
+        Captures an image from the webcam and returns the image as a numpy array.
+
+        Returns:
+            np.ndarray: The captured image in the form of a NumPy array.
+        """
+        # Initialize the webcam (0 for the built-in camera or 1 for the USB webcam)
+        cap = cv2.VideoCapture(self._camera)
+
+        # Check if the webcam is opened correctly
+        if not cap.isOpened():
+            print("CANNOT ACCESS THE CAMERA")
+            self.error(f"Could not access the camera {self._camera}.")
+            return np.zeros(
+                (1, 1, 3), dtype=np.uint8
+            )  # Return an empty array if the camera isn't accessible
+
+        # Capture a frame
+        try:
+            ret, frame = cap.read()
+            if not ret:
+                print("WTF, Camera failed")
+                self.error("Could not capture image.")
+                frame = np.zeros(
+                    (1, 1, 3), dtype=np.uint8
+                )  # Return 1x1 array if capture failed
+        finally:
+            cap.release()
+        return frame  # Return the captured image
+
+    def process_image(self, image: np.ndarray) -> np.ndarray:
+        """
+        Processes the captured image by converting it to grayscale and applying thresholding.
+
+        Args:
+            image (np.ndarray): The input image to process.
+
+        Returns:
+            np.ndarray: The processed image after grayscale conversion and thresholding.
+        """
+        if image.size < self._expected_image_size:  # Check if the image is empty
+            self.error("Received an empty image for processing.")
+            return image
+
+        # Convert the image to grayscale
+        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        return gray
+
+    def enhance_contrast(self, image: np.ndarray) -> np.ndarray:
+        """
+        Enhances the contrast of a grayscale image while suppressing noise.
+
+        Args:
+            image (np.ndarray): The input grayscale image.
+
+        Returns:
+            np.ndarray: The contrast-enhanced image with reduced noise amplification.
+        """
+        if image.ndim != 2:  # Ensure the image is grayscale
+            self.error("Contrast enhancement requires a grayscale image.")
+            return image
+
+        # Apply a slight Gaussian blur to reduce noise before enhancing contrast
+        blurred = cv2.GaussianBlur(image, (3, 3), 0)
+
+        # Apply CLAHE with conservative parameters to avoid over-enhancement
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        contrast_enhanced = clahe.apply(blurred)
+
+        return contrast_enhanced
+
+    @override
+    def update_interval(self) -> float:
+        return self._interval
+
+    @override
+    def update(self) -> bool:
+        self.image = self.capture_image()
+        self.image_timestamp = timestamp()
+        return self.image.size == self._expected_image_size
+
+
+class WebCamera(JuhamThread):
+    """Base class for web camera."""
+
+    _WEBCAMERA: str = "webcamera"
+    _WEBCAMERA_ATTRS: list[str] = ["location", "camera"]
+
+    _workerThreadId: str = WebCameraThread.get_class_id()
+    update_interval: float = 60
+    location = "home"
+    camera: int = 0
+
+    def __init__(self, name="webcam") -> None:
+        """Constructs system status automation object for acquiring and publishing
+        system info e.g. available memory and CPU loads.
+
+        Args:
+            name (str, optional): name of the object.
+        """
+        super().__init__(name)
+        self.worker: Optional[WebCameraThread] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        data = super().to_dict()  # Call parent class method
+        webcam_data = {}
+        for attr in self._WEBCAMERA_ATTRS:
+            webcam_data[attr] = getattr(self, attr)
+        data[self._WEBCAMERA] = webcam_data
+        return data
+
+    def from_dict(self, data: dict[str, Any]) -> None:
+        super().from_dict(data)  # Call parent class method
+        if self._WEBCAMERA in data:
+            webcam_data = data[self._WEBCAMERA]
+            for attr in self._WEBCAMERA_ATTRS:
+                setattr(self, attr, webcam_data.get(attr, None))

{juham_watermeter-0.0.4.dist-info → juham_watermeter-0.0.6.dist-info}/LICENSE.rst

@@ -1,22 +1,22 @@
-MIT License
-===========
-
-Copyright (c) 2024, Juha Meskanen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-
+MIT License
+===========
+
+Copyright (c) 2024, Juha Meskanen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+