PyPI - obis-parser - Versions diffs - 0.0.1__tar.gz → 0.0.2__tar.gz - Mend

obis-parser 0.0.1tar.gz → 0.0.2tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

{obis_parser-0.0.1 → obis_parser-0.0.2}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: obis-parser
-Version: 0.0.1
+Version: 0.0.2
 Summary: Dependency-free OBIS parser and measurement catalog for smart meters and energy gateways
 Project-URL: Homepage, https://github.com/jannickfahlbusch/obis-parser
 Project-URL: Repository, https://github.com/jannickfahlbusch/obis-parser
@@ -41,13 +41,14 @@ Extracts, parses, and normalizes OBIS (*Object Identification System*) codes (`A
 * **Zero External Dependencies:** Built entirely with standard library Python (`dataclasses`, `re`, `string`, `typing`).
 * **Universal Ingestion:** Auto-detects and parses:
   * Canonical strings: `1-0:1.8.0`, `1-0:1.8.0*255`, `1-1:1.7.0`
+  * Shorthand display strings: `1.8.0`, `16.7.0`, `81.7.4` (defaults to electricity A=1, channel B=0)
   * Bare COSEM 12-hex: `0100010800ff`, `0100100700ff`, `010001080000` (F=0)
   * COSEM logical names with meter suffixes: `0100010800ff.1lgz0067285558.sm`
   * Dot-separated hex: `01.00.01.08.00.FF`
 * **Single Domain Model (`OBIS`):** Everything is accessed directly on the `OBIS` instance (`.canonical`, `.name`, `.slug`, `.placeholders`, `.decode()`).
 * **Channel & Tariff Qualifiers:** Treats Channel ($B \neq 0$) and Tariff ($1 \le E < 255$) as name qualifiers on $(C, D)$ base measurements.
 * **4-Variant Localization Slugs:** Generates variant slugs (`base`, `_channel`, `_tariff`, `_channel_tariff`) with placeholder maps, ready for Home Assistant, Prometheus, or UI localization.
-* **Curated Catalog:** 31 standard German electricity registers (DIN EN 62056-6-1 / DIN 43863-3) with units, device classes, state classes, and icons.
+* **Curated Catalog:** 39 standard German electricity registers (DIN EN 62056-6-1 / DIN 43863-3) with units, device classes, state classes, and icons.
 ---
@@ -75,12 +76,12 @@ from obis_parser import OBIS
 # Parses strings, bare-hex, dot-hex, or COSEM logical names
 obis = OBIS.parse("0100010800ff")
 if obis:
-    print(obis.canonical)      # "1-0:1.8.0" (or str(obis))
-    print(obis.name)           # "Active energy import"
-    print(obis.slug)           # "active_energy_import"
-    print(obis.is_electricity) # True
-    print(obis.channel)        # 0
-    print(obis.tariff)         # 0
+    print(obis.canonical)  # "1-0:1.8.0" (or str(obis))
+    print(obis.name)  # "Active energy import"
+    print(obis.slug)  # "active_energy_import"
+    print(obis.is_electricity)  # True
+    print(obis.channel)  # 0
+    print(obis.tariff)  # 0
 ```
 ### 2. Multi-Meter Channels & Tariffs
@@ -89,10 +90,10 @@ if obis:
 # Multi-meter behind one gateway (Channel 1, Tariff 2)
 obis = OBIS.parse("1-1:1.8.2")
 if obis:
-    print(obis.canonical)    # "1-1:1.8.2"
-    print(obis.name)         # "Active energy import (Channel 1, Tariff 2)"
-    print(obis.slug)         # "active_energy_import_channel_tariff"
-    print(obis.placeholders) # {"channel": "1", "tariff": "2"}
+    print(obis.canonical)  # "1-1:1.8.2"
+    print(obis.name)  # "Active energy import (Channel 1, Tariff 2)"
+    print(obis.slug)  # "active_energy_import_channel_tariff"
+    print(obis.placeholders)  # {"channel": "1", "tariff": "2"}
 ```
 ### 3. Full Metadata Decode (`obis.decode()`)
@@ -101,18 +102,18 @@ if obis:
 obis = OBIS.parse("0100200700ff")  # Voltage L1 (32.7.0)
 if obis:
     m = obis.decode()
-    print(m.name)         # "Voltage L1"
-    print(m.unit)         # "V"
-    print(m.device_class) # "voltage"
+    print(m.name)  # "Voltage L1"
+    print(m.unit)  # "V"
+    print(m.device_class)  # "voltage"
     print(m.state_class)  # "measurement"
-    print(m.icon)         # "mdi:sine-wave"
+    print(m.icon)  # "mdi:sine-wave"
 ```
 ---
 ## Supported Registers (Catalog Overview)
-| (C, D) | Measurement | Slug | Unit | Device Class | State Class |
+| (C, D, E) | Measurement | Slug | Unit | Device Class | State Class |
 |---|---|---|---|---|---|
 | **(1, 8)** | Active energy import | `active_energy_import` | `kWh` | `energy` | `total_increasing` |
 | **(2, 8)** | Active energy export | `active_energy_export` | `kWh` | `energy` | `total_increasing` |
@@ -135,6 +136,11 @@ if obis:
 | **(11, 7)** | Current (neutral/total) | `current` | `A` | `current` | `measurement` |
 | **(13, 7)** | Power factor ($\cos \varphi$) | `power_factor` | `None` | `power_factor` | `measurement` |
 | **(14, 7)** | Frequency | `frequency` | `Hz` | `frequency` | `measurement` |
+| **(81, 7, 0)** | Phase angle | `phase_angle` | `°` | `None` | `measurement` |
+| **(81, 7, 1/2)** | Phase angle U(L2)/U(L3) to U(L1) | `phase_angle_u_l2..3_l1` | `°` | `None` | `measurement` |
+| **(81, 7, 4/15/26)** | Phase angle L1/L2/L3 (U to I) | `phase_angle_l1..3` | `°` | `None` | `measurement` |
+| **(0, 2, 0)** | Firmware version | `firmware_version` | `None` | `None` | `None` |
+| **(96, 1, 0)** | Meter identification / Serial | `meter_identification` | `None` | `None` | `None` |
 ---

{obis_parser-0.0.1 → obis_parser-0.0.2}/README.md RENAMED Viewed

@@ -15,13 +15,14 @@ Extracts, parses, and normalizes OBIS (*Object Identification System*) codes (`A
 * **Zero External Dependencies:** Built entirely with standard library Python (`dataclasses`, `re`, `string`, `typing`).
 * **Universal Ingestion:** Auto-detects and parses:
   * Canonical strings: `1-0:1.8.0`, `1-0:1.8.0*255`, `1-1:1.7.0`
+  * Shorthand display strings: `1.8.0`, `16.7.0`, `81.7.4` (defaults to electricity A=1, channel B=0)
   * Bare COSEM 12-hex: `0100010800ff`, `0100100700ff`, `010001080000` (F=0)
   * COSEM logical names with meter suffixes: `0100010800ff.1lgz0067285558.sm`
   * Dot-separated hex: `01.00.01.08.00.FF`
 * **Single Domain Model (`OBIS`):** Everything is accessed directly on the `OBIS` instance (`.canonical`, `.name`, `.slug`, `.placeholders`, `.decode()`).
 * **Channel & Tariff Qualifiers:** Treats Channel ($B \neq 0$) and Tariff ($1 \le E < 255$) as name qualifiers on $(C, D)$ base measurements.
 * **4-Variant Localization Slugs:** Generates variant slugs (`base`, `_channel`, `_tariff`, `_channel_tariff`) with placeholder maps, ready for Home Assistant, Prometheus, or UI localization.
-* **Curated Catalog:** 31 standard German electricity registers (DIN EN 62056-6-1 / DIN 43863-3) with units, device classes, state classes, and icons.
+* **Curated Catalog:** 39 standard German electricity registers (DIN EN 62056-6-1 / DIN 43863-3) with units, device classes, state classes, and icons.
 ---
@@ -49,12 +50,12 @@ from obis_parser import OBIS
 # Parses strings, bare-hex, dot-hex, or COSEM logical names
 obis = OBIS.parse("0100010800ff")
 if obis:
-    print(obis.canonical)      # "1-0:1.8.0" (or str(obis))
-    print(obis.name)           # "Active energy import"
-    print(obis.slug)           # "active_energy_import"
-    print(obis.is_electricity) # True
-    print(obis.channel)        # 0
-    print(obis.tariff)         # 0
+    print(obis.canonical)  # "1-0:1.8.0" (or str(obis))
+    print(obis.name)  # "Active energy import"
+    print(obis.slug)  # "active_energy_import"
+    print(obis.is_electricity)  # True
+    print(obis.channel)  # 0
+    print(obis.tariff)  # 0
 ```
 ### 2. Multi-Meter Channels & Tariffs
@@ -63,10 +64,10 @@ if obis:
 # Multi-meter behind one gateway (Channel 1, Tariff 2)
 obis = OBIS.parse("1-1:1.8.2")
 if obis:
-    print(obis.canonical)    # "1-1:1.8.2"
-    print(obis.name)         # "Active energy import (Channel 1, Tariff 2)"
-    print(obis.slug)         # "active_energy_import_channel_tariff"
-    print(obis.placeholders) # {"channel": "1", "tariff": "2"}
+    print(obis.canonical)  # "1-1:1.8.2"
+    print(obis.name)  # "Active energy import (Channel 1, Tariff 2)"
+    print(obis.slug)  # "active_energy_import_channel_tariff"
+    print(obis.placeholders)  # {"channel": "1", "tariff": "2"}
 ```
 ### 3. Full Metadata Decode (`obis.decode()`)
@@ -75,18 +76,18 @@ if obis:
 obis = OBIS.parse("0100200700ff")  # Voltage L1 (32.7.0)
 if obis:
     m = obis.decode()
-    print(m.name)         # "Voltage L1"
-    print(m.unit)         # "V"
-    print(m.device_class) # "voltage"
+    print(m.name)  # "Voltage L1"
+    print(m.unit)  # "V"
+    print(m.device_class)  # "voltage"
     print(m.state_class)  # "measurement"
-    print(m.icon)         # "mdi:sine-wave"
+    print(m.icon)  # "mdi:sine-wave"
 ```
 ---
 ## Supported Registers (Catalog Overview)
-| (C, D) | Measurement | Slug | Unit | Device Class | State Class |
+| (C, D, E) | Measurement | Slug | Unit | Device Class | State Class |
 |---|---|---|---|---|---|
 | **(1, 8)** | Active energy import | `active_energy_import` | `kWh` | `energy` | `total_increasing` |
 | **(2, 8)** | Active energy export | `active_energy_export` | `kWh` | `energy` | `total_increasing` |
@@ -109,6 +110,11 @@ if obis:
 | **(11, 7)** | Current (neutral/total) | `current` | `A` | `current` | `measurement` |
 | **(13, 7)** | Power factor ($\cos \varphi$) | `power_factor` | `None` | `power_factor` | `measurement` |
 | **(14, 7)** | Frequency | `frequency` | `Hz` | `frequency` | `measurement` |
+| **(81, 7, 0)** | Phase angle | `phase_angle` | `°` | `None` | `measurement` |
+| **(81, 7, 1/2)** | Phase angle U(L2)/U(L3) to U(L1) | `phase_angle_u_l2..3_l1` | `°` | `None` | `measurement` |
+| **(81, 7, 4/15/26)** | Phase angle L1/L2/L3 (U to I) | `phase_angle_l1..3` | `°` | `None` | `measurement` |
+| **(0, 2, 0)** | Firmware version | `firmware_version` | `None` | `None` | `None` |
+| **(96, 1, 0)** | Meter identification / Serial | `meter_identification` | `None` | `None` | `None` |
 ---

{obis_parser-0.0.1 → obis_parser-0.0.2}/obis_parser/_version.py RENAMED Viewed

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
-__version__ = version = '0.0.1'
-__version_tuple__ = version_tuple = (0, 0, 1)
+__version__ = version = '0.0.2'
+__version_tuple__ = version_tuple = (0, 0, 2)
 __commit_id__ = commit_id = None

{obis_parser-0.0.1 → obis_parser-0.0.2}/obis_parser/core.py RENAMED Viewed

@@ -2,7 +2,7 @@
 This module is dependency-free (standard library only) and provides:
 - Object-oriented `OBIS` domain class with `OBIS.parse()`, canonicalization, and metadata.
-- Full catalog of 31 German smart meter electricity registers (IEC 62056-6-1 / DIN 43863-3).
+- Full catalog of 39 German smart meter electricity registers (IEC 62056-6-1 / DIN 43863-3).
 - Resolved measurement metadata via `obis.decode()` with 4-variant localization slugs.
 """
@@ -15,6 +15,7 @@ from typing import Literal
 _HEXDIGITS = set(hexdigits)
 _OBIS_STRING_RE = re.compile(r"^(\d+)\s*-\s*(\d+)\s*:\s*(\d+)\s*\.\s*(\d+)\s*\.\s*(\d+)(?:\s*\*\s*(\d+))?$")
+_OBIS_SHORT_STRING_RE = re.compile(r"^(\d+)\s*\.\s*(\d+)\s*\.\s*(\d+)(?:\s*\*\s*(\d+))?$")
 _OBIS_DOT_HEX_RE = re.compile(
     r"^([0-9a-fA-F]{2})\.([0-9a-fA-F]{2})\.([0-9a-fA-F]{2})\."
     r"([0-9a-fA-F]{2})\.([0-9a-fA-F]{2})\.([0-9a-fA-F]{2})$"
@@ -57,10 +58,11 @@ ELECTRICITY_MEDIUM = 1
 #: F (billing period) values meaning "current period": absent, 0, or 255.
 _CURRENT_PERIOD_F = (0, 255)
-#: A measurement's identity: the (C, D) OBIS value groups — C is the physical
-#: quantity, D the measurement/processing type (IEC 62056-6-1). The channel (B)
-#: and tariff (E) fields are qualifiers and are NOT part of this key.
-type MeasurementKey = tuple[OBISPhysicalQuantity, OBISMeasurementType]
+#: A measurement's identity: either the (C, D) OBIS value groups or an exact (C, D, E)
+#: triplet for registers where E represents a specific phase/angle (e.g. phase angles 81.7.x).
+type MeasurementKey = (
+    tuple[OBISPhysicalQuantity, OBISMeasurementType] | tuple[OBISPhysicalQuantity, OBISMeasurementType, OBISTariff]
+)
 @dataclass(frozen=True)
@@ -97,6 +99,16 @@ class OBIS:
                 f=int(match.group(6)) if match.group(6) is not None else None,
             )
+        if match := _OBIS_SHORT_STRING_RE.match(code):
+            return cls(
+                a=ELECTRICITY_MEDIUM,
+                b=0,
+                c=int(match.group(1)),
+                d=int(match.group(2)),
+                e=int(match.group(3)),
+                f=int(match.group(4)) if match.group(4) is not None else None,
+            )
         if match := _OBIS_DOT_HEX_RE.match(code):
             return cls(
                 a=int(match.group(1), 16),
@@ -247,7 +259,7 @@ class OBISNameDescriptor:
 @dataclass(frozen=True)
 class OBISMeasurement:
-    """A fully-resolved OBIS measurement with values, units, and localized metadata."""
+    """A fully-resolved OBIS measurement descriptor with units, device classes, and localized metadata."""
     code: OBIS
     canonical: str
@@ -488,17 +500,52 @@ OBIS_CATALOG: dict[MeasurementKey, OBISMeasurementInfo] = {
         2,
     ),
     (14, 7): OBISMeasurementInfo("Frequency", "frequency", "frequency", "measurement", "Hz", "mdi:sine-wave", 2),
+    # Phase angles (C=81, D=7)
+    (81, 7, 0): OBISMeasurementInfo("Phase angle", "phase_angle", None, "measurement", "°", "mdi:angle-acute", 1),
+    (81, 7, 1): OBISMeasurementInfo(
+        "Phase angle U(L2)-U(L1)", "phase_angle_u_l2_l1", None, "measurement", "°", "mdi:angle-acute", 1
+    ),
+    (81, 7, 2): OBISMeasurementInfo(
+        "Phase angle U(L3)-U(L1)", "phase_angle_u_l3_l1", None, "measurement", "°", "mdi:angle-acute", 1
+    ),
+    (81, 7, 4): OBISMeasurementInfo("Phase angle L1", "phase_angle_l1", None, "measurement", "°", "mdi:angle-acute", 1),
+    (81, 7, 15): OBISMeasurementInfo(
+        "Phase angle L2", "phase_angle_l2", None, "measurement", "°", "mdi:angle-acute", 1
+    ),
+    (81, 7, 26): OBISMeasurementInfo(
+        "Phase angle L3", "phase_angle_l3", None, "measurement", "°", "mdi:angle-acute", 1
+    ),
+    # Device metadata & identification (exact E=0)
+    (0, 2, 0): OBISMeasurementInfo(
+        "Firmware version",
+        "firmware_version",
+        None,
+        None,
+        None,
+        "mdi:chip",
+    ),
+    (96, 1, 0): OBISMeasurementInfo(
+        "Meter identification",
+        "meter_identification",
+        None,
+        None,
+        None,
+        "mdi:identifier",
+    ),
 }
 def _get_obis_info(obis: OBIS) -> OBISMeasurementInfo | None:
-    """Look up measurement metadata from the catalog by (C, D)."""
+    """Look up measurement metadata from the catalog by (C, D, E) or (C, D)."""
     if not obis.is_electricity:
         return None
     if obis.f is not None and obis.f not in _CURRENT_PERIOD_F:
         return None
+    if info := OBIS_CATALOG.get((obis.c, obis.d, obis.e)):
+        return info
     return OBIS_CATALOG.get((obis.c, obis.d))
@@ -518,7 +565,8 @@ def _describe_obis(obis: OBIS, info: OBISMeasurementInfo | None) -> OBISNameDesc
         )
     has_channel = obis.b != 0
-    has_tariff = _has_tariff(obis.e)
+    is_exact_e = (obis.c, obis.d, obis.e) in OBIS_CATALOG
+    has_tariff = not is_exact_e and _has_tariff(obis.e)
     placeholders: dict[str, str] = {}
     fallback = info.name

obis_parser-0.0.2/tests/test_catalog.py ADDED Viewed

@@ -0,0 +1,81 @@
+"""Tests for the OBIS catalog and metadata lookup."""
+import pytest
+from obis_parser import (
+    OBIS,
+    OBIS_CATALOG,
+    OBISMeasurementInfo,
+)
+class TestCatalog:
+    def test_catalog_size_and_uniqueness(self) -> None:
+        """Verify catalog size and slug uniqueness."""
+        assert len(OBIS_CATALOG) == 39
+        slugs = [info.slug for info in OBIS_CATALOG.values()]
+        assert len(slugs) == len(set(slugs)), "All catalog slugs must be unique"
+        assert all(slug for slug in slugs), "Catalog slugs must not be empty"
+    def test_catalog_schema_invariants(self) -> None:
+        """Verify all catalog entries satisfy structural domain invariants."""
+        for key, info in OBIS_CATALOG.items():
+            assert isinstance(info, OBISMeasurementInfo)
+            assert info.name.strip(), f"Empty name for key {key}"
+            assert info.slug.strip(), f"Empty slug for key {key}"
+            assert info.icon.startswith("mdi:"), f"Invalid icon '{info.icon}' for key {key}"
+            assert info.translation_key == info.slug
+            d = key[1]
+            if d == 8:
+                assert info.state_class == "total_increasing", f"Energy register {key} must be total_increasing"
+            elif d == 7:
+                assert info.state_class == "measurement", f"Instantaneous register {key} must be measurement"
+            else:
+                assert info.state_class is None, f"Metadata register {key} must have state_class=None"
+            if info.suggested_display_precision is not None:
+                assert info.suggested_display_precision >= 0
+    @pytest.mark.parametrize(
+        "code",
+        [
+            "2-0:1.8.0",  # Medium != 1
+            "7-0:3.0.0",  # Gas
+            "1-0:1.8.0*1",  # Historic billing period
+            "1-0:81.7.99",  # Uncataloged phase angle E
+            "1-0:0.2.1",  # Uncataloged metadata E
+            "1-0:96.1.1",  # Uncataloged serial E
+        ],
+    )
+    def test_unmatched_codes_return_none(self, code: str) -> None:
+        """Non-electricity, historic periods, and uncataloged exact E return info=None."""
+        obis = OBIS.parse(code)
+        assert obis is not None
+        assert obis.info is None
+    @pytest.mark.parametrize(
+        ("code", "expected_slug"),
+        [
+            # Base (C, D) lookups ignore channel and tariff
+            ("1-0:1.8.0", "active_energy_import"),
+            ("1-1:1.8.0", "active_energy_import"),
+            ("1-0:1.8.1", "active_energy_import"),
+            ("1-2:1.8.3", "active_energy_import"),
+            # Current billing periods (F=None, 0, 255) resolve base info
+            ("1-0:1.8.0*0", "active_energy_import"),
+            ("1-0:1.8.0*255", "active_energy_import"),
+            # Exact (C, D, E) lookups for phase angles and device metadata
+            ("1-0:81.7.4", "phase_angle_l1"),
+            ("1-1:81.7.4", "phase_angle_l1"),
+            ("1-0:0.2.0", "firmware_version"),
+            ("1-0:96.1.0", "meter_identification"),
+        ],
+    )
+    def test_get_obis_info_lookup_resolution(self, code: str, expected_slug: str) -> None:
+        """info lookup resolves base (C, D) or exact (C, D, E) entries."""
+        obis = OBIS.parse(code)
+        assert obis is not None
+        info = obis.info
+        assert info is not None
+        assert info.slug == expected_slug

obis_parser-0.0.2/tests/test_decode.py ADDED Viewed

@@ -0,0 +1,218 @@
+"""Tests for OBIS.decode() and OBIS naming methods."""
+import pytest
+from obis_parser import (
+    OBIS,
+    OBISMeasurement,
+    OBISNameDescriptor,
+)
+class TestOBISNaming:
+    @pytest.mark.parametrize(
+        ("code", "expected"),
+        [
+            # Base register without modifiers
+            (
+                "1-0:1.8.0",
+                OBISNameDescriptor(
+                    slug="active_energy_import",
+                    placeholders={},
+                    fallback_name="Active energy import",
+                ),
+            ),
+            # Channel modifier on base register
+            (
+                "1-1:1.7.0",
+                OBISNameDescriptor(
+                    slug="active_power_import_channel",
+                    placeholders={"channel": "1"},
+                    fallback_name="Active power import (Channel 1)",
+                ),
+            ),
+            # Tariff modifier on base register
+            (
+                "1-0:1.8.2",
+                OBISNameDescriptor(
+                    slug="active_energy_import_tariff",
+                    placeholders={"tariff": "2"},
+                    fallback_name="Active energy import (Tariff 2)",
+                ),
+            ),
+            # Channel + tariff on base register
+            (
+                "1-3:1.8.4",
+                OBISNameDescriptor(
+                    slug="active_energy_import_channel_tariff",
+                    placeholders={"channel": "3", "tariff": "4"},
+                    fallback_name="Active energy import (Channel 3, Tariff 4)",
+                ),
+            ),
+            # Tariff E=255 means total/unspecified (no tariff suffix)
+            (
+                "1-0:1.8.255",
+                OBISNameDescriptor(
+                    slug="active_energy_import",
+                    placeholders={},
+                    fallback_name="Active energy import",
+                ),
+            ),
+            # Exact (C, D, E) phase angle registers
+            (
+                "1-0:81.7.0",
+                OBISNameDescriptor(
+                    slug="phase_angle",
+                    placeholders={},
+                    fallback_name="Phase angle",
+                ),
+            ),
+            (
+                "1-0:81.7.1",
+                OBISNameDescriptor(
+                    slug="phase_angle_u_l2_l1",
+                    placeholders={},
+                    fallback_name="Phase angle U(L2)-U(L1)",
+                ),
+            ),
+            (
+                "1-0:81.7.4",
+                OBISNameDescriptor(
+                    slug="phase_angle_l1",
+                    placeholders={},
+                    fallback_name="Phase angle L1",
+                ),
+            ),
+            # Channel on exact (C, D, E) register (must NOT generate tariff suffix!)
+            (
+                "1-1:81.7.4",
+                OBISNameDescriptor(
+                    slug="phase_angle_l1_channel",
+                    placeholders={"channel": "1"},
+                    fallback_name="Phase angle L1 (Channel 1)",
+                ),
+            ),
+            # Exact (C, D, E) device metadata registers
+            (
+                "1-0:0.2.0",
+                OBISNameDescriptor(
+                    slug="firmware_version",
+                    placeholders={},
+                    fallback_name="Firmware version",
+                ),
+            ),
+            (
+                "1-0:96.1.0",
+                OBISNameDescriptor(
+                    slug="meter_identification",
+                    placeholders={},
+                    fallback_name="Meter identification",
+                ),
+            ),
+        ],
+    )
+    def test_describe_and_naming_properties(
+        self,
+        code: str,
+        expected: OBISNameDescriptor,
+    ) -> None:
+        """Verify naming, slug variants, and placeholders across all qualifier patterns."""
+        obis = OBIS.parse(code)
+        assert obis is not None
+        assert obis.describe() == expected
+        assert obis.name == expected.fallback_name
+        assert obis.slug == expected.slug
+        assert obis.translation_key == expected.translation_key
+        assert obis.placeholders == expected.placeholders
+class TestOBISDecode:
+    def test_decode_direct_dataclass_comparison(self) -> None:
+        """Verify fully-resolved OBISMeasurement dataclass construction directly."""
+        obis_energy = OBIS(1, 0, 1, 8, 0)
+        assert obis_energy.decode() == OBISMeasurement(
+            code=obis_energy,
+            canonical="1-0:1.8.0",
+            slug="active_energy_import",
+            name="Active energy import",
+            unit="kWh",
+            device_class="energy",
+            state_class="total_increasing",
+            icon="mdi:home-import-outline",
+            suggested_display_precision=5,
+            placeholders={},
+            info=obis_energy.info,
+        )
+        obis_angle = OBIS(1, 0, 81, 7, 4)
+        assert obis_angle.decode() == OBISMeasurement(
+            code=obis_angle,
+            canonical="1-0:81.7.4",
+            slug="phase_angle_l1",
+            name="Phase angle L1",
+            unit="°",
+            device_class=None,
+            state_class="measurement",
+            icon="mdi:angle-acute",
+            suggested_display_precision=1,
+            placeholders={},
+            info=obis_angle.info,
+        )
+        obis_fw = OBIS(1, 0, 0, 2, 0)
+        assert obis_fw.decode() == OBISMeasurement(
+            code=obis_fw,
+            canonical="1-0:0.2.0",
+            slug="firmware_version",
+            name="Firmware version",
+            unit=None,
+            device_class=None,
+            state_class=None,
+            icon="mdi:chip",
+            suggested_display_precision=None,
+            placeholders={},
+            info=obis_fw.info,
+        )
+    @pytest.mark.parametrize(
+        ("short_code", "canonical_code"),
+        [
+            ("1.8.0", "1-0:1.8.0"),
+            ("1.8.2", "1-0:1.8.2"),
+            ("81.7.4", "1-0:81.7.4"),
+            ("0.2.0", "1-0:0.2.0"),
+            ("96.1.0", "1-0:96.1.0"),
+        ],
+    )
+    def test_decode_shorthand_matches_canonical(self, short_code: str, canonical_code: str) -> None:
+        """Decoded shorthand object must be identical to canonical decoded object."""
+        m_short = OBIS.parse(short_code)
+        m_canon = OBIS.parse(canonical_code)
+        assert m_short is not None
+        assert m_canon is not None
+        assert m_short.decode() == m_canon.decode()
+    @pytest.mark.parametrize(
+        ("code", "expected_canonical"),
+        [
+            ("1-0:99.99.99", "1-0:99.99.99"),
+            ("1-0:81.7.99", "1-0:81.7.99"),
+            ("1-0:0.2.1", "1-0:0.2.1"),
+            ("1-0:96.1.1", "1-0:96.1.1"),
+            ("1-0:1.8.0*1", "1-0:1.8.0*1"),
+            ("7-0:3.0.0", "7-0:3.0.0"),
+        ],
+    )
+    def test_decode_fallback_codes_as_unknown(self, code: str, expected_canonical: str) -> None:
+        """Uncataloged codes, historic periods, and non-electricity mediums decode as unknown_code."""
+        obis = OBIS.parse(code)
+        assert obis is not None
+        m = obis.decode()
+        assert m.canonical == expected_canonical
+        assert m.slug == "unknown_code"
+        assert m.translation_key == "unknown_code"
+        assert m.name == f"OBIS {expected_canonical}"
+        assert m.placeholders == {"code": expected_canonical}
+        assert m.info is None
+        assert m.unit is None
+        assert m.icon == "mdi:gauge"

obis_parser-0.0.2/tests/test_parsing.py ADDED Viewed

@@ -0,0 +1,148 @@
+"""Tests for OBIS code parsing and normalization."""
+import pytest
+from obis_parser import (
+    OBIS,
+    ParsedOBIS,
+)
+class TestParseObis:
+    @pytest.mark.parametrize(
+        ("raw", "expected"),
+        [
+            # Canonical standard notations
+            ("1-0:1.8.0", OBIS(1, 0, 1, 8, 0, None)),
+            ("1-0:1.8.0*255", OBIS(1, 0, 1, 8, 0, 255)),
+            ("1-0:1.8.0*0", OBIS(1, 0, 1, 8, 0, 0)),
+            ("1-0:1.8.0*1", OBIS(1, 0, 1, 8, 0, 1)),
+            ("1-1:16.7.0", OBIS(1, 1, 16, 7, 0, None)),
+            ("1-0:1.8.1", OBIS(1, 0, 1, 8, 1, None)),
+            ("1-2:1.8.3", OBIS(1, 2, 1, 8, 3, None)),
+            ("1-12:1.8.128*50", OBIS(1, 12, 1, 8, 128, 50)),
+            # Shorthand 3-group notation (defaults to A=1, B=0)
+            ("1.8.0", OBIS(1, 0, 1, 8, 0, None)),
+            ("1.8.0*255", OBIS(1, 0, 1, 8, 0, 255)),
+            ("1.8.0*1", OBIS(1, 0, 1, 8, 0, 1)),
+            ("1.8.1", OBIS(1, 0, 1, 8, 1, None)),
+            ("16.7.0", OBIS(1, 0, 16, 7, 0, None)),
+            ("81.7.4", OBIS(1, 0, 81, 7, 4, None)),
+            ("0.2.0", OBIS(1, 0, 0, 2, 0, None)),
+            ("96.1.0", OBIS(1, 0, 96, 1, 0, None)),
+            # Dot-separated hex
+            ("01.00.01.08.00.ff", OBIS(1, 0, 1, 8, 0, 255)),
+            ("01.00.01.08.00.FF", OBIS(1, 0, 1, 8, 0, 255)),
+            ("01.01.10.07.00.00", OBIS(1, 1, 16, 7, 0, 0)),
+            # Bare 12-char COSEM hex
+            ("0100010800ff", OBIS(1, 0, 1, 8, 0, 255)),
+            ("0100010800FF", OBIS(1, 0, 1, 8, 0, 255)),
+            ("010001080000", OBIS(1, 0, 1, 8, 0, 0)),
+            ("010051070fff", OBIS(1, 0, 81, 7, 15, 255)),
+            ("010051071aff", OBIS(1, 0, 81, 7, 26, 255)),
+            # Logical name with meter suffix
+            ("0100010800ff.1test000000001.sm", OBIS(1, 0, 1, 8, 0, 255)),
+            ("0100200700ff.1lgz0067285558.sm", OBIS(1, 0, 32, 7, 0, 255)),
+            # Whitespace handling
+            (" 1-0:1.8.0 ", OBIS(1, 0, 1, 8, 0, None)),
+            ("1-0:1.8.0 * 255", OBIS(1, 0, 1, 8, 0, 255)),
+            ("1 - 0 : 1 . 8 . 0", OBIS(1, 0, 1, 8, 0, None)),
+            (" 1.8.0 ", OBIS(1, 0, 1, 8, 0, None)),
+            ("1.8.0 * 255", OBIS(1, 0, 1, 8, 0, 255)),
+            ("1 . 8 . 0", OBIS(1, 0, 1, 8, 0, None)),
+            ("\t1.8.0\n", OBIS(1, 0, 1, 8, 0, None)),
+        ],
+    )
+    def test_valid_forms(self, raw: str, expected: OBIS) -> None:
+        assert OBIS.parse(raw) == expected
+        assert OBIS.from_string(raw) == expected
+    @pytest.mark.parametrize(
+        "raw",
+        [
+            "",
+            "   ",
+            "not-an-obis-code",
+            "1-0:1.8",
+            "1-0:1.8.0.0",
+            "1-0:1.8.0*",
+            "1-0:1.8.0*abc",
+            "1-0:1.8.0*1*2",
+            "1.8",
+            "1.8.0.0",
+            "1.8.0*",
+            "1.8.0*abc",
+            "1.8.0*1*2",
+            "-1.8.0",
+            "1.-8.0",
+            "1.8.-0",
+            ".1.8.0",
+            "1.8.0.",
+            "1:8:0",
+            "0100010800",
+            "0100010800ff11",
+            "0100010800gg",
+            "zzgg00010800ff",
+            "01.00.01.08.00",
+            "01.00.01.08.00.00.00",
+            "01.00.01.08.00.gg",
+            "0100010800.meter.sm",
+        ],
+    )
+    def test_invalid_returns_none(self, raw: str) -> None:
+        assert OBIS.parse(raw) is None
+        assert OBIS.from_string(raw) is None
+    def test_backwards_compat_alias(self) -> None:
+        assert ParsedOBIS is OBIS
+class TestOBISProperties:
+    @pytest.mark.parametrize(
+        ("obis", "expected_str"),
+        [
+            (OBIS(1, 0, 1, 8, 0, None), "1-0:1.8.0"),
+            (OBIS(1, 1, 16, 7, 0, None), "1-1:16.7.0"),
+            (OBIS(1, 0, 81, 7, 4, None), "1-0:81.7.4"),
+            (OBIS(1, 0, 1, 8, 0, 255), "1-0:1.8.0"),
+            (OBIS(1, 0, 1, 8, 0, 0), "1-0:1.8.0"),
+            (OBIS(1, 0, 1, 8, 0, 1), "1-0:1.8.0*1"),
+            (OBIS(1, 0, 81, 7, 4, 1), "1-0:81.7.4*1"),
+        ],
+    )
+    def test_string_representations_and_f_suppression(self, obis: OBIS, expected_str: str) -> None:
+        assert str(obis) == expected_str
+        assert obis.canonical == expected_str
+        assert obis.to_obis_string() == expected_str
+    def test_convenience_property_aliases(self) -> None:
+        """Verify property aliases mirror positional fields."""
+        obis = OBIS(1, 2, 3, 4, 5, 6)
+        assert obis.is_electricity is True
+        assert (
+            (
+                obis.medium,
+                obis.channel,
+                obis.physical_quantity,
+                obis.measurement_type,
+                obis.tariff,
+                obis.billing_period,
+            )
+            == (obis.a, obis.b, obis.c, obis.d, obis.e, obis.f)
+            == (1, 2, 3, 4, 5, 6)
+        )
+        gas = OBIS(7, 0, 3, 0, 0, None)
+        assert gas.is_electricity is False
+        assert gas.medium == gas.a == 7
+    def test_obis_dataclass_immutability_and_hashability(self) -> None:
+        """OBIS is a frozen dataclass and can be hashed/stored in sets."""
+        obis1 = OBIS(1, 0, 1, 8, 0)
+        obis2 = OBIS(1, 0, 1, 8, 0)
+        assert obis1 == obis2
+        assert hash(obis1) == hash(obis2)
+        assert len({obis1, obis2}) == 1
+        with pytest.raises(AttributeError):
+            obis1.a = 2  # type: ignore[misc]

obis_parser-0.0.1/tests/test_catalog.py DELETED Viewed

@@ -1,74 +0,0 @@
-"""Tests for the OBIS catalog and metadata lookup."""
-import pytest
-from obis_parser import (
-    OBIS,
-    OBIS_CATALOG,
-)
-class TestCatalog:
-    def test_catalog_size_and_uniqueness(self) -> None:
-        assert len(OBIS_CATALOG) == 31
-        slugs = [info.slug for info in OBIS_CATALOG.values()]
-        assert len(slugs) == len(set(slugs)), "All catalog slugs must be unique"
-        assert all(slug for slug in slugs), "Catalog slugs must not be empty"
-    @pytest.mark.parametrize(
-        ("code", "expected_cd", "expected_slug"),
-        [
-            ("1-0:1.8.0", (1, 8), "active_energy_import"),
-            ("1-0:2.8.0", (2, 8), "active_energy_export"),
-            ("1-0:16.7.0", (16, 7), "active_power_total"),
-            ("1-0:15.7.0", (15, 7), "absolute_active_power"),
-            ("1-0:32.7.0", (32, 7), "voltage_l1"),
-            ("1-0:52.7.0", (52, 7), "voltage_l2"),
-            ("1-0:72.7.0", (72, 7), "voltage_l3"),
-            ("1-0:31.7.0", (31, 7), "current_l1"),
-            ("1-0:21.7.0", (21, 7), "active_power_import_l1"),
-            ("1-0:22.7.0", (22, 7), "active_power_export_l1"),
-            ("1-0:13.7.0", (13, 7), "power_factor"),
-            ("1-0:14.7.0", (14, 7), "frequency"),
-            ("1-0:3.8.0", (3, 8), "reactive_energy_import"),
-            ("1-0:4.8.0", (4, 8), "reactive_energy_export"),
-            ("1-0:9.8.0", (9, 8), "apparent_energy"),
-        ],
-    )
-    def test_catalog_entries(self, code: str, expected_cd: tuple[int, int], expected_slug: str) -> None:
-        obis = OBIS.parse(code)
-        assert obis is not None
-        info = obis.info
-        assert info is not None
-        assert (obis.c, obis.d) == expected_cd
-        assert info.slug == expected_slug
-        assert info.translation_key == expected_slug
-    def test_non_electricity_has_no_catalog_match(self) -> None:
-        obis = OBIS.parse("2-0:1.8.0")
-        assert obis is not None
-        assert obis.info is None
-        obis_gas = OBIS.parse("7-0:3.0.0")
-        assert obis_gas is not None
-        assert obis_gas.info is None
-    def test_non_current_billing_period_has_no_catalog_match(self) -> None:
-        obis = OBIS.parse("1-0:1.8.0*1")
-        assert obis is not None
-        assert obis.info is None
-    @pytest.mark.parametrize(
-        ("code", "expected_cd"),
-        [
-            ("1-1:1.8.0", (1, 8)),  # Channel 1
-            ("1-0:1.8.1", (1, 8)),  # Tariff 1
-            ("1-2:1.8.3", (1, 8)),  # Channel 2, Tariff 3
-        ],
-    )
-    def test_get_obis_info_ignores_channel_and_tariff(self, code: str, expected_cd: tuple[int, int]) -> None:
-        obis = OBIS.parse(code)
-        assert obis is not None
-        info = obis.info
-        assert info is not None
-        assert (obis.c, obis.d) == expected_cd

obis_parser-0.0.1/tests/test_decode.py DELETED Viewed

@@ -1,88 +0,0 @@
-"""Tests for OBIS.decode() and OBIS naming methods."""
-from obis_parser import OBIS
-class TestOBISDecode:
-    def test_decode_basic_code(self) -> None:
-        obis = OBIS.parse("1-0:1.8.0")
-        assert obis is not None
-        m = obis.decode()
-        assert m.canonical == "1-0:1.8.0"
-        assert m.slug == "active_energy_import"
-        assert m.translation_key == "active_energy_import"
-        assert m.name == "Active energy import"
-        assert m.unit == "kWh"
-        assert m.device_class == "energy"
-        assert m.state_class == "total_increasing"
-        assert m.placeholders == {}
-        assert m.info is not None
-    def test_decode_with_channel(self) -> None:
-        obis = OBIS.parse("1-1:1.7.0")
-        assert obis is not None
-        m = obis.decode()
-        assert m.canonical == "1-1:1.7.0"
-        assert m.slug == "active_power_import_channel"
-        assert m.name == "Active power import (Channel 1)"
-        assert m.placeholders == {"channel": "1"}
-    def test_decode_with_tariff(self) -> None:
-        obis = OBIS.parse("1-0:1.8.2")
-        assert obis is not None
-        m = obis.decode()
-        assert m.canonical == "1-0:1.8.2"
-        assert m.slug == "active_energy_import_tariff"
-        assert m.name == "Active energy import (Tariff 2)"
-        assert m.placeholders == {"tariff": "2"}
-    def test_decode_with_channel_and_tariff(self) -> None:
-        obis = OBIS.parse("1-3:1.8.4")
-        assert obis is not None
-        m = obis.decode()
-        assert m.canonical == "1-3:1.8.4"
-        assert m.slug == "active_energy_import_channel_tariff"
-        assert m.name == "Active energy import (Channel 3, Tariff 4)"
-        assert m.placeholders == {"channel": "3", "tariff": "4"}
-    def test_decode_direct_instance(self) -> None:
-        obis = OBIS(1, 0, 16, 7, 0)
-        m = obis.decode()
-        assert m.canonical == "1-0:16.7.0"
-        assert m.slug == "active_power_total"
-    def test_decode_unknown_code(self) -> None:
-        obis = OBIS.parse("1-0:99.99.99")
-        assert obis is not None
-        m = obis.decode()
-        assert m.canonical == "1-0:99.99.99"
-        assert m.slug == "unknown_code"
-        assert m.name == "OBIS 1-0:99.99.99"
-        assert m.placeholders == {"code": "1-0:99.99.99"}
-        assert m.info is None
-        assert m.unit is None
-class TestOBISNaming:
-    def test_describe_and_properties(self) -> None:
-        obis = OBIS.parse("1-2:1.8.5")
-        assert obis is not None
-        # Object properties
-        assert obis.name == "Active energy import (Channel 2, Tariff 5)"
-        assert obis.slug == "active_energy_import_channel_tariff"
-        assert obis.translation_key == "active_energy_import_channel_tariff"
-        assert obis.placeholders == {"channel": "2", "tariff": "5"}
-        # describe() method
-        d = obis.describe()
-        assert d.slug == "active_energy_import_channel_tariff"
-        assert d.translation_key == "active_energy_import_channel_tariff"
-        assert d.placeholders == {"channel": "2", "tariff": "5"}
-        assert d.fallback_name == "Active energy import (Channel 2, Tariff 5)"
-    def test_name_property_simple(self) -> None:
-        obis = OBIS.parse("1-0:32.7.0")
-        assert obis is not None
-        assert obis.name == "Voltage L1"
-        assert obis.slug == "voltage_l1"

obis_parser-0.0.1/tests/test_parsing.py DELETED Viewed

@@ -1,97 +0,0 @@
-"""Tests for OBIS code parsing and normalization."""
-import pytest
-from obis_parser import (
-    OBIS,
-    ParsedOBIS,
-)
-class TestParseObis:
-    @pytest.mark.parametrize(
-        ("raw", "expected"),
-        [
-            ("1-0:1.8.0", OBIS(1, 0, 1, 8, 0, None)),
-            ("1-0:1.8.0*255", OBIS(1, 0, 1, 8, 0, 255)),
-            ("1-1:16.7.0", OBIS(1, 1, 16, 7, 0, None)),
-            ("1-0:1.8.1", OBIS(1, 0, 1, 8, 1, None)),
-            ("1-2:1.8.3", OBIS(1, 2, 1, 8, 3, None)),
-            ("01.00.01.08.00.ff", OBIS(1, 0, 1, 8, 0, 255)),
-            ("01.00.01.08.00.FF", OBIS(1, 0, 1, 8, 0, 255)),
-            ("0100010800ff", OBIS(1, 0, 1, 8, 0, 255)),
-            ("010001080000", OBIS(1, 0, 1, 8, 0, 0)),
-            # Logical name with meter suffix
-            ("0100010800ff.1test000000001.sm", OBIS(1, 0, 1, 8, 0, 255)),
-            ("0100200700ff.1lgz0067285558.sm", OBIS(1, 0, 32, 7, 0, 255)),
-            # Spaces
-            (" 1-0:1.8.0 ", OBIS(1, 0, 1, 8, 0, None)),
-            ("1-0:1.8.0 * 255", OBIS(1, 0, 1, 8, 0, 255)),
-        ],
-    )
-    def test_valid_forms(self, raw: str, expected: OBIS) -> None:
-        assert OBIS.parse(raw) == expected
-        assert OBIS.from_string(raw) == expected
-    @pytest.mark.parametrize(
-        "raw",
-        [
-            "",
-            "   ",
-            "not-an-obis-code",
-            "1-0:1.8",
-            "0100010800",
-            "zzgg00010800ff",
-        ],
-    )
-    def test_invalid_returns_none(self, raw: str) -> None:
-        assert OBIS.parse(raw) is None
-        assert OBIS.from_string(raw) is None
-    def test_backwards_compat_alias(self) -> None:
-        assert ParsedOBIS is OBIS
-class TestOBISProperties:
-    def test_string_representations(self) -> None:
-        obis = OBIS(1, 0, 1, 8, 0, None)
-        assert str(obis) == "1-0:1.8.0"
-        assert obis.canonical == "1-0:1.8.0"
-        assert obis.to_obis_string() == "1-0:1.8.0"
-    def test_f_suppression(self) -> None:
-        assert str(OBIS(1, 0, 1, 8, 0, 255)) == "1-0:1.8.0"
-        assert str(OBIS(1, 0, 1, 8, 0, 0)) == "1-0:1.8.0"
-        assert str(OBIS(1, 0, 1, 8, 0, 1)) == "1-0:1.8.0*1"
-    def test_convenience_properties(self) -> None:
-        obis = OBIS(1, 2, 1, 8, 3, 255)
-        assert obis.is_electricity is True
-        assert obis.medium == 1
-        assert obis.channel == 2
-        assert obis.physical_quantity == 1
-        assert obis.measurement_type == 8
-        assert obis.tariff == 3
-        assert obis.billing_period == 255
-        assert obis.info is not None
-    def test_non_electricity(self) -> None:
-        obis = OBIS(7, 0, 3, 0, 0, None)
-        assert obis.is_electricity is False
-        assert obis.medium == 7
-    @pytest.mark.parametrize(
-        "raw",
-        [
-            "1-0:1.8.0",
-            " 1-0:1.8.0*255 ",
-            "0100010800ff",
-            "010001080000",
-            "01.00.01.08.00.FF",
-            "0100010800ff.meter.sm",
-        ],
-    )
-    def test_canonical_property_on_parsed_forms(self, raw: str) -> None:
-        obis = OBIS.parse(raw)
-        assert obis is not None
-        assert obis.canonical == "1-0:1.8.0"