pqopen-lib 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

pqopen/powersystem.py

@@ -676,6 +676,14 @@ class PowerSystem(object):
                             self._last_known_freq = self.nominal_frequency
                 self._calculation_mode = "FALLBACK"
         elif self._calculation_mode == "FALLBACK":
+            remaining_virtual_zc = []
+            last_rel_zc = self._zero_crossings[-1] - start_acq_sidx 
+            zc_gap = zero_crossings[0] - last_rel_zc
+            num_zc_to_fill = int(zc_gap / (self._samplerate/self._last_known_freq)) + 1
+            virtual_zc_interval = int(zc_gap / num_zc_to_fill)
+            remaining_virtual_zc = [last_rel_zc + i*virtual_zc_interval for i in range(1,num_zc_to_fill)]
+            logger.debug("Finishing Fallback: Added virtual zero crossing: idx=" + ",".join([f"{virtual_zc:.1f}" for virtual_zc in remaining_virtual_zc]))
+            zero_crossings = remaining_virtual_zc + zero_crossings
             self._calculation_mode = "NORMAL"
         else:
             self._calculation_mode = "NORMAL"
@@ -698,6 +706,21 @@ class PowerSystem(object):
             output_values[ch_name] = ch_data
         return output_values
     
+    def get_channel_info(self) -> dict:
+        channel_info = {}
+        for phase in self._phases:
+            for calc_interval, interval_group in phase._calc_channels.items():
+                for derived_type, phys_group in interval_group.items():
+                    for phys_type, channel in phys_group.items():
+                        channel_info[channel.name] = {
+                            "unit": channel.unit,
+                            "phys_type": phys_type,
+                            "derived_type": derived_type,
+                            "calc_interval": calc_interval,
+                            "phase": phase.name
+                        }
+        return channel_info
+    
     def __del__(self):
         if self._features["energy_channels"]:
             w_pos_value = float(self._calc_channels["multi_period"]["energy"]["w_pos"].last_sample_value)

pqopen/storagecontroller.py

@@ -57,11 +57,13 @@ import numpy as np
 from pqopen.helper import floor_timestamp, JsonDecimalLimiter
 from pqopen.eventdetector import Event
 from daqopen.channelbuffer import DataChannelBuffer, AcqBuffer
+from daqopen.daqinfo import DaqInfo
 from pathlib import Path
 from typing import List, Dict
 import logging
 import json
 import gzip
+import time
 import paho.mqtt.client as mqtt
 
 
@@ -91,7 +93,7 @@ class StorageEndpoint(object):
         """
         Writes aggregated data to the storage endpoint.
 
-        Args:
+        Parameters:
             data: The aggregated data to store.
             timestamp_us: The timestamp in microseconds for the aggregated data.
             interval_seconds: The aggregation interval in seconds.
@@ -101,6 +103,17 @@ class StorageEndpoint(object):
     def write_event(self, event: Event):
         pass
 
+    def write_measurement_config(self, m_config: dict, daq_info: DaqInfo, channe_info: dict, **kwargs):
+        """
+        Writes measurement config to the storage endpoint.
+
+        Parameters:
+            m_config: The measurement config to store.
+            daq_info: The daq info to store.
+            channel_info: The channel's specific infos
+        """
+        pass
+
 class StoragePlan(object):
     """Defines a plan for storing data with specified intervals and channels."""
 
@@ -190,6 +203,9 @@ class StoragePlan(object):
         if self._store_events_enabled:
             self.storage_endpoint.write_event(event, **self._additional_config)
 
+    def store_measurement_config(self, m_config: dict, daq_info: DaqInfo, channel_info: dict):
+        self.storage_endpoint.write_measurement_config(m_config, daq_info, channel_info, **self._additional_config)
+
 class StorageController(object):
     """Manages multiple storage plans and processes data for storage."""
 
@@ -304,7 +320,10 @@ class StorageController(object):
                                          available_channels: dict, 
                                          measurement_id: str, 
                                          device_id: str,
-                                         start_timestamp_us: int):
+                                         start_timestamp_us: int,
+                                         m_config: dict | None = None,
+                                         daq_info: DaqInfo | None = None,
+                                         channel_info: dict| None = None):
         """
         Setup endpoints and storage plans from config
 
@@ -319,7 +338,7 @@ class StorageController(object):
         Raises:
             NotImplementedError: If a not implemented endpoint will be configured
         """
-        self._configured_eps = {}
+        self._configured_eps: dict[str, StorageEndpoint] = {}
         for ep_type, ep_config in endpoints.items():
             if ep_type == "csv":
                 csv_storage_endpoint = CsvStorageEndpoint("csv", measurement_id, ep_config.get("data_dir", "/tmp/"))
@@ -375,8 +394,11 @@ class StorageController(object):
                     else:      
                         logger.warning(f"Channel {channel} not available for storing")
             self.add_storage_plan(storage_plan)
-
-            
+            # Initially store the measurement config if configured
+            if sp_config.get("store_config", False) and m_config and daq_info and channel_info:
+                storage_plan.store_measurement_config(m_config=m_config,
+                                                      daq_info=daq_info,
+                                                      channel_info=channel_info)
 
 class TestStorageEndpoint(StorageEndpoint):
     """A implementation of StorageEndpoint for testing purposes."""
@@ -499,6 +521,27 @@ class MqttStorageEndpoint(StorageEndpoint):
             self._client.publish(topic_prefix + f"/{self._device_id:s}/event/json",
                             json_item.encode('utf-8'), qos=2)
             
+    def write_measurement_config(self, m_config: dict, daq_info: DaqInfo, channel_info: dict, **kwargs):
+        """
+        Write measurement config
+        """
+        m_config_object = {
+            "type": "m_config",
+            "measurement_uuid": self.measurement_id,
+            "timestamp": time.time(),
+            "m_config": m_config,
+            "daq_info": daq_info.to_dict(),
+            "channel_info": channel_info
+        }
+        json_item = json.dumps(m_config_object)
+        topic_prefix = kwargs.get("mqtt_topic_prefix", self._topic_prefix)
+        if self._compression:
+            self._client.publish(topic_prefix + f"/{self._device_id:s}/m_config/gjson",
+                            gzip.compress(json_item.encode('utf-8')), qos=2)
+        else:
+            self._client.publish(topic_prefix + f"/{self._device_id:s}/m_config/json",
+                            json_item.encode('utf-8'), qos=2)
+            
 class HomeAssistantStorageEndpoint(StorageEndpoint):
     """Represents a MQTT endpoint (MQTT) for HomeAssistant."""
     def __init__(self, 

{pqopen_lib-0.8.4.dist-info → pqopen_lib-0.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pqopen-lib
-Version: 0.8.4
+Version: 0.8.5
 Summary: A power quality processing library for calculating parameters from waveform data
 Project-URL: Homepage, https://github.com/DaqOpen/pqopen-lib
 Project-URL: Issues, https://github.com/DaqOpen/pqopen-lib/issues

{pqopen_lib-0.8.4.dist-info → pqopen_lib-0.8.5.dist-info}/RECORD

@@ -3,10 +3,10 @@ pqopen/auxcalc.py,sha256=P11Nu9pgJRoPYZDjLk-mXI6Ha02LoTH5bS9FdFTvC9M,2733
 pqopen/eventdetector.py,sha256=NKZU7GbeorZdkYu3ET4lhMaeynw70GhIGO2p1xH4aTA,11962
 pqopen/helper.py,sha256=0msrm6i1v8jj2Z5X8F7wDEW0KD5i91RBNZwPJC05YrA,2533
 pqopen/powerquality.py,sha256=dRVCedWa1QJKHgdiYoIIdvhH_p40cwpgeUePO5u1j28,15953
-pqopen/powersystem.py,sha256=BDB-Xf-xe3UYVBUyX2gjKXnWpeZWTQTaLDSGCvtmGZ4,49256
-pqopen/storagecontroller.py,sha256=AhVaPgIh4CBKKMJm9Ja0dOjVd4dLppWprxeeg3vrmAk,31266
+pqopen/powersystem.py,sha256=1Dux78f20rN8qeu0qqSjzr_hK6lP01O6zOW-h9Udk-8,50595
+pqopen/storagecontroller.py,sha256=8JkeRX3HDWGFR40wO1ejxctQp53eMgEtsJMbOl7ea1Y,33468
 pqopen/zcd.py,sha256=olJZsHRd1CjU65vysc2emR5wFGMkayIWdUEDNE8jfIc,6253
-pqopen_lib-0.8.4.dist-info/METADATA,sha256=hC1fidnpdel5XKb8T5zDJ6H3zidLNtTTJuhnYnKAVQE,4787
-pqopen_lib-0.8.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-pqopen_lib-0.8.4.dist-info/licenses/LICENSE,sha256=yhYwu9dioytbAvNQa0UBwaBVcALqiOoBViEs4HLW6aU,1064
-pqopen_lib-0.8.4.dist-info/RECORD,,
+pqopen_lib-0.8.5.dist-info/METADATA,sha256=rhdRRPk0xDqkCyWg5YBICo6CmZWruJVm5mJDh8rgry4,4787
+pqopen_lib-0.8.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+pqopen_lib-0.8.5.dist-info/licenses/LICENSE,sha256=yhYwu9dioytbAvNQa0UBwaBVcALqiOoBViEs4HLW6aU,1064
+pqopen_lib-0.8.5.dist-info/RECORD,,