rf-protocols 2.0.0__tar.gz → 2.1.0__tar.gz

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-protocols
-Version: 2.0.0
+Version: 2.1.0
 Summary: Library to decode and encode radio frequency signals.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/home-assistant-libs/rf-protocols
@@ -11,6 +11,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: prek; extra == "dev"
 Dynamic: license-file
 

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name         = "rf-protocols"
-version      = "2.0.0"
+version      = "2.1.0"
 license      = "MIT"
 description  = "Library to decode and encode radio frequency signals."
 readme       = "README.md"
@@ -46,4 +46,7 @@ max-complexity = 25
 typeCheckingMode = "standard"
 
 [project.optional-dependencies]
-dev = ["pytest", "prek"]
+dev = ["pytest", "pytest-asyncio", "prek"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/rf_protocols/__init__.py

@@ -2,6 +2,7 @@
 
 from .commands import ModulationType, OOKCommand, RadioFrequencyCommand
 from .loader import CodeCollection, get_codes
+from .parser import parse_sub_content
 
 __all__ = [
     "CodeCollection",
@@ -9,4 +10,5 @@ __all__ = [
     "OOKCommand",
     "RadioFrequencyCommand",
     "get_codes",
+    "parse_sub_content",
 ]

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/rf_protocols/loader.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
+import asyncio
 from pathlib import Path
-from typing import Any
 
-from .commands import OOKCommand, RadioFrequencyCommand
+from .commands import RadioFrequencyCommand
+from .parser import parse_sub_content
 
 _DEFAULT_BASE_DIR = Path(__file__).parent / "codes"
 
@@ -34,10 +35,22 @@ class CodeCollection:
         sub_file = self._codes_dir / f"{name.lower()}.sub"
         if not sub_file.is_file():
             raise KeyError(f"No command {name!r} in {self._codes_dir}")
-        cmd = _parse_sub_content(sub_file.read_text())
+        cmd = parse_sub_content(sub_file.read_text())
         self._cache[name] = cmd
         return cmd
 
+    async def async_load_command(self, name: str) -> RadioFrequencyCommand:
+        """Async variant of :meth:`load_command`.
+
+        Returns the cached command synchronously when available; otherwise
+        reads and parses the ``.sub`` file in the default executor.
+        """
+        if (cached := self._cache.get(name)) is not None:
+            return cached
+        return await asyncio.get_running_loop().run_in_executor(
+            None, self.load_command, name
+        )
+
     def __repr__(self) -> str:
         """Return a concise representation."""
         return f"CodeCollection({self._codes_dir})"
@@ -57,48 +70,3 @@ def get_codes(name: str, base_dir: Path | str | None = None) -> CodeCollection:
     if not codes_dir.is_dir():
         raise FileNotFoundError(f"No codes directory at {codes_dir}")
     return CodeCollection(codes_dir)
-
-
-def _parse_sub_content(content: str) -> RadioFrequencyCommand:
-    """Parse a Flipper ``.sub`` file into a :class:`RadioFrequencyCommand`."""
-    fields: dict[str, str] = {}
-    raw_parts: list[str] = []
-    for raw_line in content.splitlines():
-        line = raw_line.strip()
-        if not line:
-            continue
-        key, sep, value = line.partition(":")
-        if not sep:
-            continue
-        key = key.strip()
-        value = value.strip()
-        if key == "RAW_Data":
-            raw_parts.append(value)
-        else:
-            fields[key] = value
-
-    protocol = fields.get("Protocol", "")
-    if protocol != "RAW":
-        raise ValueError(f"Unsupported Protocol {protocol!r}; only RAW is supported")
-
-    preset = fields.get("Preset", "")
-    if "Ook" not in preset:
-        raise ValueError(
-            f"Unsupported Preset {preset!r}; only OOK presets are supported"
-        )
-
-    if "Frequency" not in fields:
-        raise ValueError("Missing Frequency field")
-    if not raw_parts:
-        raise ValueError("Missing RAW_Data field")
-
-    timings = [int(v) for part in raw_parts for v in part.split()]
-    if len(timings) % 2 != 0:
-        raise ValueError("RAW_Data must contain an even number of values")
-
-    kwargs: dict[str, Any] = {
-        "frequency": int(fields["Frequency"]),
-        "timings": timings,
-        "repeat_count": int(fields.get("Repeat", "0")),
-    }
-    return OOKCommand(**kwargs)

rf_protocols-2.1.0/rf_protocols/parser.py

@@ -0,0 +1,52 @@
+"""Parse Flipper ``.sub`` file contents into :class:`RadioFrequencyCommand`."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .commands import OOKCommand, RadioFrequencyCommand
+
+
+def parse_sub_content(content: str) -> RadioFrequencyCommand:
+    """Parse a Flipper ``.sub`` file into a :class:`RadioFrequencyCommand`."""
+    fields: dict[str, str] = {}
+    raw_parts: list[str] = []
+    for raw_line in content.splitlines():
+        line = raw_line.strip()
+        if not line:
+            continue
+        key, sep, value = line.partition(":")
+        if not sep:
+            continue
+        key = key.strip()
+        value = value.strip()
+        if key == "RAW_Data":
+            raw_parts.append(value)
+        else:
+            fields[key] = value
+
+    protocol = fields.get("Protocol", "")
+    if protocol != "RAW":
+        raise ValueError(f"Unsupported Protocol {protocol!r}; only RAW is supported")
+
+    preset = fields.get("Preset", "")
+    if "Ook" not in preset:
+        raise ValueError(
+            f"Unsupported Preset {preset!r}; only OOK presets are supported"
+        )
+
+    if "Frequency" not in fields:
+        raise ValueError("Missing Frequency field")
+    if not raw_parts:
+        raise ValueError("Missing RAW_Data field")
+
+    timings = [int(v) for part in raw_parts for v in part.split()]
+    if len(timings) % 2 != 0:
+        raise ValueError("RAW_Data must contain an even number of values")
+
+    kwargs: dict[str, Any] = {
+        "frequency": int(fields["Frequency"]),
+        "timings": timings,
+        "repeat_count": int(fields.get("Repeat", "0")),
+    }
+    return OOKCommand(**kwargs)

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/rf_protocols.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rf-protocols
-Version: 2.0.0
+Version: 2.1.0
 Summary: Library to decode and encode radio frequency signals.
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/home-assistant-libs/rf-protocols
@@ -11,6 +11,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
 Requires-Dist: prek; extra == "dev"
 Dynamic: license-file
 

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/rf_protocols.egg-info/SOURCES.txt

@@ -4,6 +4,7 @@ pyproject.toml
 rf_protocols/__init__.py
 rf_protocols/commands.py
 rf_protocols/loader.py
+rf_protocols/parser.py
 rf_protocols.egg-info/PKG-INFO
 rf_protocols.egg-info/SOURCES.txt
 rf_protocols.egg-info/dependency_links.txt
@@ -12,4 +13,5 @@ rf_protocols.egg-info/top_level.txt
 rf_protocols/codes/honeywell/string_lights/turn_off.sub
 rf_protocols/codes/honeywell/string_lights/turn_on.sub
 tests/test_commands.py
-tests/test_loader.py
+tests/test_loader.py
+tests/test_parser.py

{rf_protocols-2.0.0 → rf_protocols-2.1.0}/rf_protocols.egg-info/requires.txt

@@ -1,4 +1,5 @@
 
 [dev]
 pytest
+pytest-asyncio
 prek

rf_protocols-2.1.0/tests/test_loader.py

@@ -0,0 +1,111 @@
+"""Tests for the .sub file loader."""
+
+import asyncio
+from pathlib import Path
+
+import pytest
+
+import rf_protocols
+from rf_protocols import CodeCollection, ModulationType, OOKCommand, get_codes
+
+_BUNDLED_CODES_ROOT = Path(rf_protocols.__file__).parent / "codes"
+_BUNDLED_SUB_FILES = sorted(_BUNDLED_CODES_ROOT.rglob("*.sub"))
+_HONEYWELL_ROOT = _BUNDLED_CODES_ROOT / "honeywell"
+
+
+def test_bundled_sub_files_exist() -> None:
+    """At least one bundled .sub file ships with the package."""
+    assert _BUNDLED_SUB_FILES, f"No .sub files found under {_BUNDLED_CODES_ROOT}"
+
+
+@pytest.mark.parametrize(
+    "sub_file",
+    _BUNDLED_SUB_FILES,
+    ids=[str(p.relative_to(_BUNDLED_CODES_ROOT)) for p in _BUNDLED_SUB_FILES],
+)
+def test_bundled_sub_file_parses(sub_file: Path) -> None:
+    """Every bundled .sub file parses into a valid OOK command."""
+    device_dir = sub_file.parent.relative_to(_BUNDLED_CODES_ROOT)
+    codes = get_codes(str(device_dir))
+    cmd = codes.load_command(sub_file.stem.upper())
+    assert isinstance(cmd, OOKCommand)
+    assert cmd.frequency > 0
+    assert cmd.modulation == ModulationType.OOK
+    assert cmd.timings
+    assert len(cmd.timings) % 2 == 0
+
+
+def test_get_codes_bundled_honeywell() -> None:
+    """Bundled Honeywell string lights codes can be discovered and loaded."""
+    codes = get_codes("honeywell/string_lights")
+    assert isinstance(codes, CodeCollection)
+    cmd = codes.load_command("TURN_ON")
+    assert isinstance(cmd, OOKCommand)
+    assert cmd.frequency == 433_920_000
+    assert cmd.repeat_count == 50
+    assert cmd.timings[:2] == [2000, -550]
+
+
+def test_load_command_caches_results() -> None:
+    """Repeated load_command calls return the same instance."""
+    codes = get_codes("honeywell/string_lights")
+    assert codes.load_command("TURN_ON") is codes.load_command("TURN_ON")
+
+
+def test_load_command_unknown_name() -> None:
+    """Requesting an unknown command name raises KeyError."""
+    codes = get_codes("honeywell/string_lights")
+    with pytest.raises(KeyError, match="NOPE"):
+        codes.load_command("NOPE")
+
+
+def test_load_command_base_dir_override() -> None:
+    """Passing base_dir loads codes from an alternate location."""
+    codes = get_codes("string_lights", base_dir=_HONEYWELL_ROOT)
+    cmd = codes.load_command("TURN_ON")
+    assert isinstance(cmd, OOKCommand)
+    assert cmd.frequency == 433_920_000
+    assert cmd.repeat_count == 50
+
+
+def test_load_command_base_dir_accepts_str() -> None:
+    """base_dir accepts a str as well as a Path."""
+    codes = get_codes("string_lights", base_dir=str(_HONEYWELL_ROOT))
+    assert isinstance(codes.load_command("TURN_ON"), OOKCommand)
+
+
+def test_get_codes_missing_directory(tmp_path: Path) -> None:
+    """get_codes raises FileNotFoundError when the directory is missing."""
+    with pytest.raises(FileNotFoundError):
+        get_codes("nope", base_dir=tmp_path)
+
+
+def test_get_codes_rejects_path_escape() -> None:
+    """Paths that resolve outside of base_dir are rejected."""
+    with pytest.raises(ValueError, match="outside"):
+        get_codes("../honeywell", base_dir=_HONEYWELL_ROOT / "string_lights")
+
+
+async def test_async_load_command_loads_from_disk() -> None:
+    """async_load_command parses the command from disk."""
+    codes = get_codes("honeywell/string_lights")
+    cmd = await codes.async_load_command("TURN_ON")
+    assert isinstance(cmd, OOKCommand)
+    assert cmd.repeat_count == 50
+
+
+async def test_async_load_command_returns_cached_without_executor(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Cached commands bypass the executor entirely."""
+    codes = get_codes("honeywell/string_lights")
+    first = codes.load_command("TURN_ON")
+
+    def _boom(*_args: object, **_kwargs: object) -> None:
+        raise AssertionError("executor must not be used for cached commands")
+
+    monkeypatch.setattr(
+        asyncio.AbstractEventLoop, "run_in_executor", _boom, raising=True
+    )
+    second = await codes.async_load_command("TURN_ON")
+    assert first is second

rf_protocols-2.1.0/tests/test_parser.py

@@ -0,0 +1,63 @@
+"""Tests for :func:`parse_sub_content`."""
+
+import pytest
+
+from rf_protocols import OOKCommand, parse_sub_content
+
+_SAMPLE_SUB = """\
+Filetype: Flipper SubGhz RAW File
+Version: 1
+Frequency: 433920000
+Preset: FuriHalSubGhzPresetOok650Async
+Protocol: RAW
+Repeat: 7
+RAW_Data: 2000 -550 450 -1000
+"""
+
+
+def test_parse_sub_content_parses_sample() -> None:
+    """A well-formed .sub payload parses into an OOKCommand."""
+    cmd = parse_sub_content(_SAMPLE_SUB)
+    assert isinstance(cmd, OOKCommand)
+    assert cmd.frequency == 433_920_000
+    assert cmd.repeat_count == 7
+    assert cmd.timings == [2000, -550, 450, -1000]
+
+
+def test_parse_sub_content_rejects_non_raw_protocol() -> None:
+    """Non-RAW protocols are rejected."""
+    with pytest.raises(ValueError, match="Protocol"):
+        parse_sub_content(_SAMPLE_SUB.replace("Protocol: RAW", "Protocol: Princeton"))
+
+
+def test_parse_sub_content_rejects_non_ook_preset() -> None:
+    """Non-OOK presets are rejected."""
+    with pytest.raises(ValueError, match="Preset"):
+        parse_sub_content(
+            _SAMPLE_SUB.replace(
+                "FuriHalSubGhzPresetOok650Async", "FuriHalSubGhzPreset2FSKDev238Async"
+            )
+        )
+
+
+def test_parse_sub_content_multiline_raw_data() -> None:
+    """Multiple RAW_Data lines are concatenated."""
+    content = (
+        "Filetype: Flipper SubGhz RAW File\n"
+        "Version: 1\n"
+        "Frequency: 433920000\n"
+        "Preset: FuriHalSubGhzPresetOok650Async\n"
+        "Protocol: RAW\n"
+        "RAW_Data: 2000 -550\n"
+        "RAW_Data: 450 -1000\n"
+    )
+    cmd = parse_sub_content(content)
+    assert isinstance(cmd, OOKCommand)
+    assert cmd.timings == [2000, -550, 450, -1000]
+    assert cmd.repeat_count == 0
+
+
+def test_parse_sub_content_rejects_odd_raw_data() -> None:
+    """Odd-length RAW_Data is rejected."""
+    with pytest.raises(ValueError, match="even number"):
+        parse_sub_content(_SAMPLE_SUB.replace("2000 -550 450 -1000", "2000 -550 450"))

rf_protocols-2.0.0/tests/test_loader.py

@@ -1,166 +0,0 @@
-"""Tests for the .sub file loader."""
-
-from pathlib import Path
-
-import pytest
-
-import rf_protocols
-from rf_protocols import CodeCollection, ModulationType, OOKCommand, get_codes
-
-_BUNDLED_CODES_ROOT = Path(rf_protocols.__file__).parent / "codes"
-_BUNDLED_SUB_FILES = sorted(_BUNDLED_CODES_ROOT.rglob("*.sub"))
-
-_SAMPLE_SUB = """\
-Filetype: Flipper SubGhz RAW File
-Version: 1
-Frequency: 433920000
-Preset: FuriHalSubGhzPresetOok650Async
-Protocol: RAW
-Repeat: 7
-RAW_Data: 2000 -550 450 -1000
-"""
-
-
-def _write_sub(path: Path, content: str = _SAMPLE_SUB) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content)
-
-
-def test_bundled_sub_files_exist() -> None:
-    """At least one bundled .sub file ships with the package."""
-    assert _BUNDLED_SUB_FILES, f"No .sub files found under {_BUNDLED_CODES_ROOT}"
-
-
-@pytest.mark.parametrize(
-    "sub_file",
-    _BUNDLED_SUB_FILES,
-    ids=[str(p.relative_to(_BUNDLED_CODES_ROOT)) for p in _BUNDLED_SUB_FILES],
-)
-def test_bundled_sub_file_parses(sub_file: Path) -> None:
-    """Every bundled .sub file parses into a valid OOK command."""
-    device_dir = sub_file.parent.relative_to(_BUNDLED_CODES_ROOT)
-    codes = get_codes(str(device_dir))
-    cmd = codes.load_command(sub_file.stem.upper())
-    assert isinstance(cmd, OOKCommand)
-    assert cmd.frequency > 0
-    assert cmd.modulation == ModulationType.OOK
-    assert cmd.timings
-    assert len(cmd.timings) % 2 == 0
-
-
-def test_get_codes_bundled_honeywell() -> None:
-    """Bundled Honeywell string lights codes can be discovered and loaded."""
-    codes = get_codes("honeywell/string_lights")
-    assert isinstance(codes, CodeCollection)
-    cmd = codes.load_command("TURN_ON")
-    assert isinstance(cmd, OOKCommand)
-    assert cmd.frequency == 433_920_000
-    assert cmd.repeat_count == 50
-    assert cmd.timings[:2] == [2000, -550]
-
-
-def test_load_command_caches_results(tmp_path: Path) -> None:
-    """Repeated load_command calls return the same instance without re-reading."""
-    sub_path = tmp_path / "vendor" / "device" / "power.sub"
-    _write_sub(sub_path)
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    first = codes.load_command("POWER")
-    sub_path.unlink()
-    second = codes.load_command("POWER")
-    assert first is second
-
-
-def test_load_command_unknown_name(tmp_path: Path) -> None:
-    """Requesting an unknown command name raises KeyError."""
-    _write_sub(tmp_path / "vendor" / "device" / "power.sub")
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    with pytest.raises(KeyError, match="NOPE"):
-        codes.load_command("NOPE")
-
-
-def test_load_command_base_dir_override(tmp_path: Path) -> None:
-    """Passing base_dir loads codes from an alternate location."""
-    _write_sub(tmp_path / "vendor" / "device" / "power.sub")
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    cmd = codes.load_command("POWER")
-    assert isinstance(cmd, OOKCommand)
-    assert cmd.frequency == 433_920_000
-    assert cmd.repeat_count == 7
-    assert cmd.timings == [2000, -550, 450, -1000]
-
-
-def test_load_command_base_dir_accepts_str(tmp_path: Path) -> None:
-    """base_dir accepts a str as well as a Path."""
-    _write_sub(tmp_path / "vendor" / "device" / "power.sub")
-    codes = get_codes("vendor/device", base_dir=str(tmp_path))
-    assert isinstance(codes.load_command("POWER"), OOKCommand)
-
-
-def test_get_codes_missing_directory(tmp_path: Path) -> None:
-    """get_codes raises FileNotFoundError when the directory is missing."""
-    with pytest.raises(FileNotFoundError):
-        get_codes("nope", base_dir=tmp_path)
-
-
-def test_load_command_rejects_non_raw_protocol(tmp_path: Path) -> None:
-    """Non-RAW protocols are rejected on load_command."""
-    _write_sub(
-        tmp_path / "vendor" / "device" / "power.sub",
-        _SAMPLE_SUB.replace("Protocol: RAW", "Protocol: Princeton"),
-    )
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    with pytest.raises(ValueError, match="Protocol"):
-        codes.load_command("POWER")
-
-
-def test_load_command_rejects_non_ook_preset(tmp_path: Path) -> None:
-    """Non-OOK presets are rejected on load_command."""
-    _write_sub(
-        tmp_path / "vendor" / "device" / "power.sub",
-        _SAMPLE_SUB.replace(
-            "FuriHalSubGhzPresetOok650Async", "FuriHalSubGhzPreset2FSKDev238Async"
-        ),
-    )
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    with pytest.raises(ValueError, match="Preset"):
-        codes.load_command("POWER")
-
-
-def test_get_codes_rejects_path_escape(tmp_path: Path) -> None:
-    """Paths that resolve outside of base_dir are rejected."""
-    (tmp_path / "inside").mkdir()
-    outside = tmp_path.parent / "outside_codes"
-    outside.mkdir(exist_ok=True)
-    _write_sub(outside / "power.sub")
-    with pytest.raises(ValueError, match="outside"):
-        get_codes("../outside_codes", base_dir=tmp_path / "inside")
-
-
-def test_load_command_multiline_raw_data(tmp_path: Path) -> None:
-    """Multiple RAW_Data lines are concatenated."""
-    content = (
-        "Filetype: Flipper SubGhz RAW File\n"
-        "Version: 1\n"
-        "Frequency: 433920000\n"
-        "Preset: FuriHalSubGhzPresetOok650Async\n"
-        "Protocol: RAW\n"
-        "RAW_Data: 2000 -550\n"
-        "RAW_Data: 450 -1000\n"
-    )
-    _write_sub(tmp_path / "vendor" / "device" / "power.sub", content)
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    cmd = codes.load_command("POWER")
-    assert isinstance(cmd, OOKCommand)
-    assert cmd.timings == [2000, -550, 450, -1000]
-    assert cmd.repeat_count == 0
-
-
-def test_load_command_rejects_odd_raw_data(tmp_path: Path) -> None:
-    """Odd-length RAW_Data is rejected on load_command."""
-    _write_sub(
-        tmp_path / "vendor" / "device" / "power.sub",
-        _SAMPLE_SUB.replace("2000 -550 450 -1000", "2000 -550 450"),
-    )
-    codes = get_codes("vendor/device", base_dir=tmp_path)
-    with pytest.raises(ValueError, match="even number"):
-        codes.load_command("POWER")