harmonized-telemetry-format 0.0.2a1__tar.gz

harmonized_telemetry_format-0.0.2a1/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: harmonized-telemetry-format
+Version: 0.0.2a1
+Summary: Core library for reading and writing the Harmonized Telemetry Format (HTF).
+Author-email: Max Schlosser <schlosse@hs-mittweida.de>
+Project-URL: Homepage, https://github.com/Schloool/harmonized-telemetry-format
+Project-URL: Bug Tracker, https://github.com/Schloool/harmonized-telemetry-format/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Harmonized Telemetry Format (HTF)
+
+Detailed description coming soon.
+
+Exemplary HTF file content:
+```htf
+[static_metadata;s]12.51
+[dim_metadata;index;delta]2;0.08;4;0.484
+(channel;s;50;135)0=12.27;1=12.42;...
+(empty_channel;m;50;135)0=;
+```

harmonized_telemetry_format-0.0.2a1/README.md

@@ -0,0 +1,11 @@
+# Harmonized Telemetry Format (HTF)
+
+Detailed description coming soon.
+
+Exemplary HTF file content:
+```htf
+[static_metadata;s]12.51
+[dim_metadata;index;delta]2;0.08;4;0.484
+(channel;s;50;135)0=12.27;1=12.42;...
+(empty_channel;m;50;135)0=;
+```

harmonized_telemetry_format-0.0.2a1/harmonized_telemetry_format.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: harmonized-telemetry-format
+Version: 0.0.2a1
+Summary: Core library for reading and writing the Harmonized Telemetry Format (HTF).
+Author-email: Max Schlosser <schlosse@hs-mittweida.de>
+Project-URL: Homepage, https://github.com/Schloool/harmonized-telemetry-format
+Project-URL: Bug Tracker, https://github.com/Schloool/harmonized-telemetry-format/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# Harmonized Telemetry Format (HTF)
+
+Detailed description coming soon.
+
+Exemplary HTF file content:
+```htf
+[static_metadata;s]12.51
+[dim_metadata;index;delta]2;0.08;4;0.484
+(channel;s;50;135)0=12.27;1=12.42;...
+(empty_channel;m;50;135)0=;
+```

harmonized_telemetry_format-0.0.2a1/harmonized_telemetry_format.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+harmonized_telemetry_format.egg-info/PKG-INFO
+harmonized_telemetry_format.egg-info/SOURCES.txt
+harmonized_telemetry_format.egg-info/dependency_links.txt
+harmonized_telemetry_format.egg-info/top_level.txt
+htf_core/__init__.py
+htf_core/models.py
+htf_core/reader.py
+htf_core/writer.py
+tests/test_reader.py
+tests/test_writer.py

harmonized_telemetry_format-0.0.2a1/harmonized_telemetry_format.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

harmonized_telemetry_format-0.0.2a1/harmonized_telemetry_format.egg-info/top_level.txt

@@ -0,0 +1 @@
+htf_core

harmonized_telemetry_format-0.0.2a1/htf_core/models.py

@@ -0,0 +1,39 @@
+from typing import Optional
+
+
+class HarmonizedTelemetryChannel:
+    """A telemetry channel used within a recording."""
+
+    def __init__(self, name: str, unit: Optional[str], frequency: Optional[int],
+                 total_values: int, values: list[tuple[int, object]]):
+        self.name = name
+        self.unit = unit
+        self.frequency = frequency
+        self.total_values = total_values
+        self.values = values
+
+
+class HarmonizedMetadataEntry:
+    """
+    Unified class for both static metadata (single record, n=1) and dimensional aggregations (n>=1).
+    Maps directly to the HTF line structure: [name;property_1;property_2;...]value1_1;value1_2;value2_1;value2_2;...
+    """
+
+    # TODO: Values are wrong
+    def __init__(self, name: str, column_names: list[str], column_values: dict[str, list[object]]):
+        self.name = name
+        self.column_names = column_names
+        self.column_values = column_values
+        self._n = len(column_names)
+
+    @property
+    def is_static(self) -> bool:
+        """Helper to quickly identify single-record static metadata."""
+        return self._n == 1 and len(self.column_values) == 1
+
+
+class HarmonizedTelemetryRecording:
+    """Representation of a complete telemetry recording with metadata and channels."""
+    def __init__(self, metadata: Optional[list[HarmonizedMetadataEntry]], channels: list[HarmonizedTelemetryChannel]):
+        self.metadata = metadata
+        self.channels = channels

harmonized_telemetry_format-0.0.2a1/htf_core/reader.py

@@ -0,0 +1,115 @@
+import ast
+import re
+from io import TextIOWrapper
+
+from htf_core.models import HarmonizedTelemetryRecording, HarmonizedMetadataEntry, HarmonizedTelemetryChannel
+
+
+METADATA_REGEX = re.compile(
+    r"^\[(?P<preamble_content>[^]]+)]"
+    r"(?P<data_content>.*)$"
+)
+
+CHANNEL_REGEX = re.compile(
+    r"^\("
+    r"(?P<name>[^;]+);"
+    r"(?P<unit>[^;]+);"
+    r"(?P<frequency>[^;]*);"
+    r"(?P<value_count>[^)]+)\)"
+    r"(?P<data_content>.*)$"
+)
+
+
+class HtfReader:
+    def __init__(self, entries: list[str]):
+        self.entries = entries
+
+    @classmethod
+    def from_str(cls, text: str):
+        content = text.split("\n")
+        return cls(content)
+
+    @classmethod
+    def from_file(cls, file: TextIOWrapper):
+        content = file.readlines()
+        return cls(content)
+
+    def read(self) -> HarmonizedTelemetryRecording:
+        metadata_entries = []
+        telemetry_channels = []
+        for entry in self.entries:
+            metadata_match = METADATA_REGEX.match(entry)
+            if metadata_match:
+                metadata_entries.append(self.read_metadata_entry(entry))
+                continue
+
+            channel_match = CHANNEL_REGEX.match(entry)
+            if channel_match:
+                telemetry_channels.append(self.read_telemetry_channel(entry))
+                continue
+
+            raise ValueError(f"Entry does not match metadata or channel format: {entry}")
+        return HarmonizedTelemetryRecording(
+            metadata=metadata_entries if len(metadata_entries) > 0 else None,
+            channels=telemetry_channels
+        )
+
+    @staticmethod
+    def read_metadata_entry(line: str) -> HarmonizedMetadataEntry:
+        match = METADATA_REGEX.match(line)
+        if not match:
+            raise ValueError(f"Line does not match metadata format: {line}")
+
+        preamble_content = match.group("preamble_content")
+        data_content = match.group("data_content")
+
+        parts = preamble_content.split(";")
+        name = parts[0]
+        column_names = parts[1:]
+
+        column_values = {col_name: [] for col_name in column_names}
+        data_values = data_content.split(";")
+        for i, value in enumerate(data_values):
+            col_name = column_names[i % len(column_names)]
+            column_values[col_name].append(value)
+
+        return HarmonizedMetadataEntry(
+            name=name,
+            column_names=column_names,
+            column_values=column_values,
+        )
+
+    @staticmethod
+    def read_telemetry_channel(line: str) -> HarmonizedTelemetryChannel:
+        match = CHANNEL_REGEX.match(line)
+        if not match:
+            raise ValueError(f"Line does not match channel format: {line}")
+
+        name = match.group("name")
+        unit = match.group("unit")
+        frequency_str = match.group("frequency")
+        frequency = int(frequency_str) if frequency_str else None
+        total_values = int(match.group("value_count"))
+        data_content = match.group("data_content")
+
+        values = []
+        if data_content:
+            value_pairs = data_content.split(";")
+            for pair in value_pairs:
+                index_str, value_str = pair.split("=", 1)
+                index = int(index_str)
+                value = ast.literal_eval(value_str) if value_str else None
+
+                # Omit duplicate consecutive values
+                if index > 0 and value == values[-1][1]:
+                    continue
+
+                values.append((index, value))
+
+        return HarmonizedTelemetryChannel(
+            name=name,
+            unit=unit,
+            frequency=frequency,
+            total_values=total_values,
+            values=values
+        )

harmonized_telemetry_format-0.0.2a1/htf_core/writer.py

@@ -0,0 +1,58 @@
+from htf_core.models import HarmonizedTelemetryRecording, HarmonizedMetadataEntry, HarmonizedTelemetryChannel
+
+
+class HtfWriter:
+    def __init__(self, recording: HarmonizedTelemetryRecording):
+        self.recording = recording
+
+    def serialize(self) -> str:
+        lines = []
+        if self.recording.metadata:
+            for entry in self.recording.metadata:
+                lines.append(self.compose_metadata_entry(entry))
+
+        for channel in self.recording.channels:
+            lines.append(self.compose_channel(channel))
+
+        return "\n".join(lines)
+
+    @staticmethod
+    def compose_metadata_entry(entry: HarmonizedMetadataEntry) -> str:
+        headers = ";".join(entry.column_names)
+        preamble = f"[{entry.name};{headers}]"
+
+        if not entry.column_names:
+            raise "No column names provided"
+
+        first_column_key = entry.column_names[0]
+        num_rows = len(entry.column_values.get(first_column_key, []))
+
+        row_data_list = []
+
+        for data_index in range(num_rows):
+            current_row_values = []
+
+            for col_name in entry.column_names:
+                column_list = entry.column_values.get(col_name, [])
+
+                if data_index < len(column_list):
+                    current_row_values.append(str(column_list[data_index]))
+
+            row_data_list.append(";".join(current_row_values))
+
+        data = ";".join(row_data_list)
+
+        return f"{preamble}{data}"
+
+    @staticmethod
+    def compose_channel(channel: HarmonizedTelemetryChannel) -> str:
+        frequency = channel.frequency if channel.frequency is not None else ""
+        preamble = f"({channel.name};{channel.unit};{frequency};{channel.total_values})"
+
+        # Create index-value pairs, omitting repeating values
+        value_pairs = [f"{index}={value}"
+                       for index, value in channel.values
+                       if index == 0 or value != channel.values[index - 1]]
+
+        values = ";".join(value_pairs)
+        return f"{preamble}{values}"

harmonized_telemetry_format-0.0.2a1/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=61.0.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "harmonized-telemetry-format"
+version = "0.0.2a1"
+authors = [
+    { name="Max Schlosser", email="schlosse@hs-mittweida.de" },
+]
+description = "Core library for reading and writing the Harmonized Telemetry Format (HTF)."
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = []
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Utilities",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/Schloool/harmonized-telemetry-format"
+"Bug Tracker" = "https://github.com/Schloool/harmonized-telemetry-format/issues"
+
+[tool.setuptools]
+packages = ["htf_core"]

harmonized_telemetry_format-0.0.2a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

harmonized_telemetry_format-0.0.2a1/tests/test_reader.py

@@ -0,0 +1,83 @@
+from unittest import TestCase
+
+from htf_core.reader import HtfReader
+
+
+class Test(TestCase):
+    def test_reads_complete_recording(self):
+        entries = [
+            "[Metadata;Property1;Property2]Value1;Value2",
+            "(ChannelName;Unit;10;3)0=100;1=200;2=300"
+        ]
+        reader = HtfReader(entries=entries)
+
+        recording = reader.read()
+
+        self.assertIsNotNone(recording.metadata)
+        self.assertEqual(len(recording.metadata), 1)
+        self.assertEqual(len(recording.channels), 1)
+
+    def test_parses_valid_metadata(self):
+        valid_metadata_line = "[Metadata;Property1;Property2]Value1;Value2"
+        reader = HtfReader(entries=[valid_metadata_line])
+
+        metadata_entry = reader.read_metadata_entry(valid_metadata_line)
+
+        self.assertEqual(metadata_entry.name, "Metadata")
+        self.assertEqual(metadata_entry.column_names, ["Property1", "Property2"])
+        self.assertEqual(metadata_entry.column_values, {
+            "Property1": ["Value1"],
+            "Property2": ["Value2"]
+        })
+
+    def test_parses_valid_channel(self):
+        valid_channel_line = "(ChannelName;Unit;10;5)0=100;1=200;2=300"
+        reader = HtfReader(entries=[valid_channel_line])
+
+        channel = reader.read_telemetry_channel(valid_channel_line)
+
+        self.assertEqual(channel.name, "ChannelName")
+        self.assertEqual(channel.unit, "Unit")
+        self.assertEqual(channel.frequency, 10)
+        self.assertEqual(channel.total_values, 5)
+        self.assertEqual(channel.values, [(0, 100), (1, 200), (2, 300)])
+
+    def test_emits_duplicate_channel_values(self):
+        valid_channel_line = "(ChannelName;Unit;;5)0=100;1=100;2=200;3=200;4=300"
+        reader = HtfReader(entries=[valid_channel_line])
+
+        channel = reader.read_telemetry_channel(valid_channel_line)
+
+        self.assertIsNone(channel.frequency)
+        self.assertEqual(channel.total_values, 5)
+        self.assertEqual(channel.values, [(0, 100), (2, 200), (4, 300)])
+
+    def test_sets_none_values_for_missing_frequency(self):
+        channel_line = "(ChannelName;Unit;;3)0=100;1=200;2=300"
+        reader = HtfReader(entries=[channel_line])
+
+        channel = reader.read_telemetry_channel(channel_line)
+
+        self.assertIsNone(channel.frequency)
+
+    def test_sets_none_values_for_missing_channel_values(self):
+        channel_line = "(ChannelName;Unit;;3)0="
+        reader = HtfReader(entries=[channel_line])
+
+        channel = reader.read_telemetry_channel(channel_line)
+
+        self.assertEqual(channel.values, [(0, None)])
+
+    def test_throws_on_invalid_metadata(self):
+        invalid_metadata_line = "[InvalidMetadata;Data;Data"
+        reader = HtfReader(entries=[invalid_metadata_line])
+
+        with self.assertRaises(ValueError):
+            reader.read_metadata_entry(invalid_metadata_line)
+
+    def test_throws_on_invalid_channel(self):
+        invalid_channel_line = "(InvalidChannel;Unit;Frequency;TotalValues"
+        reader = HtfReader(entries=[invalid_channel_line])
+
+        with self.assertRaises(ValueError):
+            reader.read_telemetry_channel(invalid_channel_line)

harmonized_telemetry_format-0.0.2a1/tests/test_writer.py

@@ -0,0 +1,31 @@
+from unittest import TestCase
+
+from htf_core.models import HarmonizedMetadataEntry
+from htf_core.writer import HtfWriter
+
+
+class Test(TestCase):
+    def test_compose_static_metadata_entry(self):
+        entry = HarmonizedMetadataEntry(
+            name="Static",
+            column_names=["Property1"],
+            column_values={"Property1": [1]}
+        )
+
+        text = HtfWriter.compose_metadata_entry(entry)
+
+        self.assertEqual(text, "[Static;Property1]1")
+
+    def test_compose_dimensional_metadata_entry(self):
+        entry = HarmonizedMetadataEntry(
+            name="Dimensions",
+            column_names=["Dim1", "Dim2"],
+            column_values={
+                "Dim1": [10, 20],
+                "Dim2": ["A", "B"]
+            }
+        )
+
+        text = HtfWriter.compose_metadata_entry(entry)
+
+        self.assertEqual(text, "[Dimensions;Dim1;Dim2]10;A;20;B")