winpnp 0.0.2__tar.gz → 0.1.0__tar.gz

{winpnp-0.0.2 → winpnp-0.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: winpnp
-Version: 0.0.2
+Version: 0.1.0
 Summary: A package for interacting with Windows Plug and Play (PnP) entities
 Project-URL: Homepage, https://github.com/SuperPudding98/winpnp
 Project-URL: Issues, https://github.com/SuperPudding98/winpnp/issues

{winpnp-0.0.2 → winpnp-0.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "winpnp"
-version = "0.0.2"
+version = "0.1.0"
 authors = [
     { name = "Supper Pudding", email = "31290828+SuperPudding98@users.noreply.github.com" },
 ]

{winpnp-0.0.2 → winpnp-0.1.0}/src/winpnp/properties/keys/__init__.py

@@ -4,6 +4,7 @@ from winpnp.properties import kinds
 from winpnp.properties.pnp_property import PnpPropertyKey
 
 from . import (
+    bluetooth,
     dev_query,
     device,
     device_class,

{winpnp-0.0.2 → winpnp-0.1.0}/src/winpnp/properties/pnp_property.py

@@ -15,6 +15,7 @@ class PnpPropertyType(Generic[T]):
     """
 
     _DERIVED_DATA: ClassVar[dict[int, tuple[str, Callable[[bytes], Any]]]] = {}
+    _NAME_TO_ID: ClassVar[dict[str, int]] = {}
 
     type_id: int
     name: Optional[str] = field(compare=False)
@@ -48,6 +49,7 @@ class PnpPropertyType(Generic[T]):
             )
 
         PnpPropertyType._DERIVED_DATA[kind.type_id] = (kind.name, kind._decoder)
+        PnpPropertyType._NAME_TO_ID[kind.name] = kind.type_id
 
     @staticmethod
     def register_new(
@@ -62,6 +64,14 @@ class PnpPropertyType(Generic[T]):
         PnpPropertyType.register(kind)
         return kind
 
+    @staticmethod
+    def from_name(name: str) -> Optional["PnpPropertyType[U]"]:
+        type_id = PnpPropertyType._NAME_TO_ID.get(name)
+        if type_id is None:
+            return None
+
+        return PnpPropertyType(type_id)
+
     def decode(self, data: bytes) -> T:
         """
         Decodes raw bytes to the actual python type that this `PnpPropertyType` represents.
@@ -69,13 +79,16 @@ class PnpPropertyType(Generic[T]):
         return self._decoder(data)
 
 
-@dataclass(init=False)
+@dataclass(init=False, frozen=True)
 class PnpPropertyKey(Generic[T]):
     """
     A key that specifies a PnP property. This is an abstraction over the Windows DEVPROPKEY struct. Can be used as key for `__getitem__` of various winpnp classes.
     """
 
-    _NAMES: ClassVar[dict[tuple[UUID, int], str]] = {}
+    _DERIVED_DATA: ClassVar[
+        dict[tuple[UUID, int], tuple[str, Optional[tuple[PnpPropertyType[Any], ...]]]]
+    ] = {}
+    _NAME_TO_ID: ClassVar[dict[str, tuple[UUID, int]]] = {}
 
     category: UUID
     property_id: int
@@ -89,15 +102,25 @@ class PnpPropertyKey(Generic[T]):
         name: Optional[str] = None,
         allowed_types: Optional[Iterable[PnpPropertyType[T]]] = None,
     ) -> None:
-        self.category = category
-        self.property_id = property_id
-        self.name = (
-            name if name is not None else self._NAMES.get((category, property_id))
+        # Intentionally not setting allowed_types from derived data to allow creating a PnpPropertyKey with registered id but without type limitations
+        derived_name, _ = self._DERIVED_DATA.get((category, property_id), (None, None))
+
+        # Using object.__setattr__ because the class is frozen
+        object.__setattr__(self, "category", category)
+        object.__setattr__(self, "property_id", property_id)
+        object.__setattr__(
+            self,
+            "name",
+            name if name is not None else derived_name,
         )
-        self.allowed_types = (
-            {kind.type_id: kind for kind in allowed_types}
-            if allowed_types is not None
-            else None
+        object.__setattr__(
+            self,
+            "allowed_types",
+            (
+                {kind.type_id: kind for kind in allowed_types}
+                if allowed_types is not None
+                else None
+            ),
         )
 
     @staticmethod
@@ -109,12 +132,17 @@ class PnpPropertyKey(Generic[T]):
             raise ValueError(f"Cannot register {repr(key)} because it is unnamed.")
 
         _id = (key.category, key.property_id)
-        if _id in PnpPropertyKey._NAMES:
+        if _id in PnpPropertyKey._DERIVED_DATA:
             raise ValueError(
-                f"Cannot register {repr(key)} because its (category, property_id) pair is already registered with name {repr(PnpPropertyKey._NAMES[_id])}"
+                f"Cannot register {repr(key)} because its (category, property_id) pair is already registered with name {repr(PnpPropertyKey._DERIVED_DATA[_id][0])}"
             )
 
-        PnpPropertyKey._NAMES[_id] = key.name
+        allowed_types = (
+            tuple(key.allowed_types.values()) if key.allowed_types is not None else None
+        )
+
+        PnpPropertyKey._DERIVED_DATA[_id] = (key.name, allowed_types)
+        PnpPropertyKey._NAME_TO_ID[key.name] = _id
 
     @staticmethod
     def register_new(
@@ -130,6 +158,15 @@ class PnpPropertyKey(Generic[T]):
         PnpPropertyKey.register(key)
         return key
 
+    @staticmethod
+    def from_name(name: str) -> Optional["PnpPropertyKey[U]"]:
+        _id = PnpPropertyKey._NAME_TO_ID.get(name)
+        if _id is None:
+            return None
+
+        _, allowed_types = PnpPropertyKey._DERIVED_DATA.get(_id, (None, None))
+        return PnpPropertyKey(*_id, name, allowed_types)
+
 
 @dataclass()
 class PnpProperty(Generic[T]):

winpnp-0.1.0/tests/test_propery_key.py

@@ -0,0 +1,78 @@
+from typing import Any, Iterator, Optional
+from uuid import UUID
+
+from pytest_cases import fixture, parametrize_with_cases
+
+from winpnp.properties.pnp_property import PnpPropertyKey, PnpPropertyType
+
+TEST_KEY_NAME = "test_property_key"
+TEST_KEY_CATEGORY = UUID("{00000000-0000-0000-0000000000000000}")
+TEST_KEY_PROP_ID = 0
+TEST_TYPE_ID = 0xFFFFFFFF
+
+
+KeyTestParams = tuple[
+    Optional[PnpPropertyKey[Any]],
+    bool,
+    Optional[str],
+    Optional[dict[int, PnpPropertyType[Any]]],
+]
+
+
+@fixture(scope="function")  # type: ignore
+def registered_key() -> Iterator[PnpPropertyKey[None]]:
+    key = PnpPropertyKey.register_new(
+        TEST_KEY_CATEGORY,
+        TEST_KEY_PROP_ID,
+        TEST_KEY_NAME,
+        (PnpPropertyType(TEST_TYPE_ID),),
+    )
+    try:
+        yield key
+    finally:
+        del PnpPropertyKey._NAME_TO_ID[TEST_KEY_NAME]
+        del PnpPropertyKey._DERIVED_DATA[(TEST_KEY_CATEGORY, TEST_KEY_PROP_ID)]
+
+
+def case_lookup_not_registered_by_id() -> KeyTestParams:
+    return PnpPropertyKey(TEST_KEY_CATEGORY, TEST_KEY_PROP_ID), False, None, None
+
+
+def case_lookup_not_registered_by_name() -> KeyTestParams:
+    return PnpPropertyKey.from_name(TEST_KEY_NAME), True, None, None
+
+
+def case_lookup_registered_by_id(registered_key: PnpPropertyKey[None]) -> KeyTestParams:
+    return (
+        PnpPropertyKey(TEST_KEY_CATEGORY, TEST_KEY_PROP_ID),
+        False,
+        TEST_KEY_NAME,
+        None,
+    )
+
+
+def case_lookup_registered_by_name(
+    registered_key: PnpPropertyKey[None],
+) -> KeyTestParams:
+    return (
+        PnpPropertyKey.from_name(TEST_KEY_NAME),
+        False,
+        TEST_KEY_NAME,
+        {TEST_TYPE_ID: PnpPropertyType(TEST_TYPE_ID)},
+    )
+
+
+@parametrize_with_cases(
+    ("key", "should_be_none", "expected_name", "expected_allowed_types"), cases="."
+)
+def test_registration(
+    key: Optional[PnpPropertyKey[Any]],
+    should_be_none: bool,
+    expected_name: Optional[str],
+    expected_allowed_types: Optional[dict[int, PnpPropertyType[Any]]],
+) -> None:
+    assert (key is None) == should_be_none
+
+    if key is not None:
+        assert key.name == expected_name
+        assert key.allowed_types == expected_allowed_types

winpnp-0.1.0/tests/test_propery_type.py

@@ -0,0 +1,68 @@
+from typing import Any, Callable, Iterator, Optional
+
+from pytest_cases import fixture, parametrize_with_cases
+
+from winpnp.properties.decoding import decode_raw
+from winpnp.properties.pnp_property import PnpPropertyType
+
+TEST_TYPE_NAME = "test_property_type"
+TEST_TYPE_ID = 0xFFFFFFFF
+
+TypeTestParams = tuple[
+    Optional[PnpPropertyType[Any]], bool, Optional[str], Callable[[bytes], Any]
+]
+
+
+def _test_decoder(data: bytes) -> None:
+    return None
+
+
+@fixture(scope="function")  # type: ignore
+def registered_type() -> Iterator[PnpPropertyType[None]]:
+    kind = PnpPropertyType.register_new(TEST_TYPE_ID, TEST_TYPE_NAME, _test_decoder)
+    try:
+        yield kind
+    finally:
+        del PnpPropertyType._NAME_TO_ID[TEST_TYPE_NAME]
+        del PnpPropertyType._DERIVED_DATA[TEST_TYPE_ID]
+
+
+def case_lookup_not_registered_by_id() -> TypeTestParams:
+    return PnpPropertyType(TEST_TYPE_ID), False, None, decode_raw
+
+
+def case_lookup_not_registered_by_name() -> TypeTestParams:
+    return PnpPropertyType.from_name(TEST_TYPE_NAME), True, None, decode_raw
+
+
+def case_lookup_registered_by_id(
+    registered_type: PnpPropertyType[None],
+) -> TypeTestParams:
+    return PnpPropertyType(TEST_TYPE_ID), False, TEST_TYPE_NAME, _test_decoder
+
+
+def case_lookup_registered_by_name(
+    registered_type: PnpPropertyType[None],
+) -> TypeTestParams:
+    return (
+        PnpPropertyType.from_name(TEST_TYPE_NAME),
+        False,
+        TEST_TYPE_NAME,
+        _test_decoder,
+    )
+
+
+@parametrize_with_cases(
+    ("kind", "should_be_none", "expected_name", "expected_decoder"), cases="."
+)
+def test_registration(
+    kind: Optional[PnpPropertyType[Any]],
+    should_be_none: bool,
+    expected_name: Optional[str],
+    expected_decoder: Callable[[bytes], Any],
+) -> None:
+    assert (kind is None) == should_be_none
+
+    if kind is not None:
+        assert kind.name == expected_name
+        assert kind._decoder is expected_decoder