winpnp 0.0.1__tar.gz

winpnp-0.0.1/.gitignore

@@ -0,0 +1,177 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Private files that should only be local
+.private/

winpnp-0.0.1/.vscode/settings.json

@@ -0,0 +1,28 @@
+{
+    "cSpell.words": [
+        "ALLCLASSES",
+        "DEVINFO",
+        "DEVPROP",
+        "DEVPROPKEY",
+        "DEVPROPTYPE",
+        "DICLASSPROP",
+        "DIGCF",
+        "filetimes",
+        "fmtid",
+        "guids",
+        "HDEVINFO",
+        "HTREE",
+        "itertools",
+        "ntdll",
+        "NTSTATUS",
+        "Pnp",
+        "pytest",
+        "setupapi",
+        "setupdi",
+        "SYSTEMTIME",
+        "typecode",
+        "TYPEMOD",
+        "winerror",
+        "winpnp"
+    ]
+}

winpnp-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Super Pudding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

winpnp-0.0.1/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: winpnp
+Version: 0.0.1
+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
+Author-email: Supper Pudding <31290828+SuperPudding98@users.noreply.github.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: Windows device,device manager,pnp,setupapi,setupdi
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: System :: Hardware
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: more-itertools<11,>=10.2.0
+Provides-Extra: deploy
+Requires-Dist: build<2,>=1.2.2; extra == 'deploy'
+Requires-Dist: twine<7,>=6.1.0; extra == 'deploy'
+Provides-Extra: dev
+Requires-Dist: pytest-cases<4,>=3.8.6; extra == 'dev'
+Requires-Dist: pytest<9,>=8.2.1; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# winpnp
+
+This is a package for interacting with Windows Plug and Play (PnP) entities (devices, setup classes, etc.)
+
+It can be used to query properties of PnP devices using the `winpnp.info.device.DeviceInfo` class,<br/>
+and to query properties of PnP setup classes using the `winpnp.info.setup_class.SetupClassInfo` class.<br/>
+Instances of these classes can be used as mappings, with keys of type `winpnp.properties.pnp_property.PnpPropertyKey`.<br/>
+For your convenience, commonly used property keys are defined in `winpnp.properties.keys`.
+
+Here is an example usage:
+```python
+from winpnp.info.device import DeviceInfo
+from winpnp.properties.keys.device import INSTANCE_ID
+
+with DeviceInfo.of_instance_id("HTREE\\ROOT\\0") as device:
+    instance_id = device[INSTANCE_ID]
+
+instance_id
+```
+Output: `PnpProperty(value='HTREE\\ROOT\\0', kind=PnpPropertyType(type_id=18, name='STRING'))`

winpnp-0.0.1/README.md

@@ -0,0 +1,20 @@
+# winpnp
+
+This is a package for interacting with Windows Plug and Play (PnP) entities (devices, setup classes, etc.)
+
+It can be used to query properties of PnP devices using the `winpnp.info.device.DeviceInfo` class,<br/>
+and to query properties of PnP setup classes using the `winpnp.info.setup_class.SetupClassInfo` class.<br/>
+Instances of these classes can be used as mappings, with keys of type `winpnp.properties.pnp_property.PnpPropertyKey`.<br/>
+For your convenience, commonly used property keys are defined in `winpnp.properties.keys`.
+
+Here is an example usage:
+```python
+from winpnp.info.device import DeviceInfo
+from winpnp.properties.keys.device import INSTANCE_ID
+
+with DeviceInfo.of_instance_id("HTREE\\ROOT\\0") as device:
+    instance_id = device[INSTANCE_ID]
+
+instance_id
+```
+Output: `PnpProperty(value='HTREE\\ROOT\\0', kind=PnpPropertyType(type_id=18, name='STRING'))`

winpnp-0.0.1/deploy/build_wheel.bat

@@ -0,0 +1 @@
+py -3 -m build

winpnp-0.0.1/deploy/upload_to_pypi.bat

@@ -0,0 +1 @@
+py -3 -m twine upload dist/*

winpnp-0.0.1/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "winpnp"
+version = "0.0.1"
+authors = [
+    { name = "Supper Pudding", email = "31290828+SuperPudding98@users.noreply.github.com" },
+]
+description = "A package for interacting with Windows Plug and Play (PnP) entities"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+requires-python = ">=3.9"
+keywords = ["pnp", "setupapi", "setupdi", "Windows device", "device manager"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: Microsoft :: Windows",
+    "Environment :: Win32 (MS Windows)",
+    "Topic :: System :: Hardware",
+    "Typing :: Typed",
+]
+
+dependencies = ["more-itertools>=10.2.0,<11"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.2.1,<9", "pytest-cases>=3.8.6,<4"]
+deploy = ["build>=1.2.2,<2", "twine>=6.1.0,<7"]
+
+[project.urls]
+Homepage = "https://github.com/SuperPudding98/winpnp"
+Issues = "https://github.com/SuperPudding98/winpnp/issues"

winpnp-0.0.1/src/winpnp/__init__.py

@@ -0,0 +1 @@
+from . import info, properties

winpnp-0.0.1/src/winpnp/_setupapi.py

@@ -0,0 +1,208 @@
+from ctypes import (
+    POINTER,
+    Structure,
+    c_bool,
+    c_ubyte,
+    c_uint16,
+    c_uint32,
+    c_void_p,
+    c_wchar_p,
+    windll,
+)
+from enum import IntFlag
+from uuid import UUID
+
+INVALID_HANDLE_VALUE = -1
+
+HDEVINFO = c_void_p
+
+
+class DIGCF(IntFlag):
+    DEFAULT = 0x00000001
+    PRESENT = 0x00000002
+    ALLCLASSES = 0x00000004
+    PROFILE = 0x00000008
+    DEVICEINTERFACE = 0x00000010
+
+
+class DICLASSPROP(IntFlag):
+    INSTALLER = 0x00000001
+    INTERFACE = 0x00000002
+
+
+class GUID(Structure):
+    _fields_ = (
+        ("Data1", c_uint32),
+        ("Data2", c_uint16),
+        ("Data3", c_uint16),
+        ("Data4", c_ubyte * 8),
+    )
+
+    def __str__(self) -> str:
+        return str(self.to_uuid())
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({{{str(self.to_uuid())}}})"
+
+    @classmethod
+    def from_uuid(cls, guid: UUID) -> "GUID":
+        return cls.from_buffer_copy(guid.bytes_le)
+
+    def to_uuid(self) -> UUID:
+        return UUID(bytes_le=bytes(self))
+
+
+class SP_DEVINFO_DATA(Structure):
+    _fields_ = (
+        ("cbSize", c_uint32),
+        ("ClassGuid", GUID),
+        ("DevInst", c_uint32),
+        ("Reserved", c_void_p),
+    )
+
+
+class DEVPROPKEY(Structure):
+    _fields_ = (
+        ("fmtid", GUID),
+        ("pid", c_uint32),
+    )
+
+
+class DEVPROP_TYPEMOD(IntFlag):
+    NONE = 0x00000000
+    ARRAY = 0x00001000  # array of fixed-sized data elements
+    LIST = 0x00002000  # list of variable-sized data elements
+
+
+class DEVPROP_TYPE(IntFlag):
+    EMPTY = 0x00000000  # nothing, no property data
+    NULL = 0x00000001  # null property data
+    SBYTE = 0x00000002  # 8-bit signed int (SBYTE)
+    BYTE = 0x00000003  # 8-bit unsigned int (BYTE)
+    INT16 = 0x00000004  # 16-bit signed int (SHORT)
+    UINT16 = 0x00000005  # 16-bit unsigned int (USHORT)
+    INT32 = 0x00000006  # 32-bit signed int (LONG)
+    UINT32 = 0x00000007  # 32-bit unsigned int (ULONG)
+    INT64 = 0x00000008  # 64-bit signed int (LONG64)
+    UINT64 = 0x00000009  # 64-bit unsigned int (ULONG64)
+    FLOAT = 0x0000000A  # 32-bit floating-point (FLOAT)
+    DOUBLE = 0x0000000B  # 64-bit floating-point (DOUBLE)
+    DECIMAL = 0x0000000C  # 128-bit data (DECIMAL)
+    GUID = 0x0000000D  # 128-bit unique identifier (GUID)
+    CURRENCY = 0x0000000E  # 64 bit signed int currency value (CURRENCY)
+    DATE = 0x0000000F  # date (DATE)
+    FILETIME = 0x00000010  # file time (FILETIME)
+    BOOLEAN = 0x00000011  # 8-bit boolean (DEVPROP_BOOLEAN)
+    STRING = 0x00000012  # null-terminated string
+    STRING_LIST = STRING | DEVPROP_TYPEMOD.LIST  # multi-sz string list
+    SECURITY_DESCRIPTOR = 0x00000013  # self-relative binary SECURITY_DESCRIPTOR
+    SECURITY_DESCRIPTOR_STRING = 0x00000014  # security descriptor string (SDDL format)
+    DEVPROPKEY = 0x00000015  # device property key (DEVPROPKEY)
+    DEVPROPTYPE = 0x00000016  # device property type (DEVPROPTYPE)
+    BINARY = BYTE | DEVPROP_TYPEMOD.ARRAY  # custom binary data
+    ERROR = 0x00000017  # 32-bit Win32 system error code
+    NTSTATUS = 0x00000018  # 32-bit NTSTATUS code
+    STRING_INDIRECT = 0x00000019  # string resource (@[path\]<dllname>,-<strId>)
+
+
+SetupDiCreateDeviceInfoList = windll.setupapi.SetupDiCreateDeviceInfoList
+SetupDiCreateDeviceInfoList.restype = HDEVINFO
+SetupDiCreateDeviceInfoList.argtypes = (
+    POINTER(GUID),  # [in, optional] ClassGuid
+    c_void_p,  # [in, optional] hwndParent
+)
+
+SetupDiDestroyDeviceInfoList = windll.setupapi.SetupDiDestroyDeviceInfoList
+SetupDiDestroyDeviceInfoList.restype = c_bool
+SetupDiDestroyDeviceInfoList.argtypes = (HDEVINFO,)  # [in] DeviceInfoSet
+
+SetupDiGetClassDevsW = windll.setupapi.SetupDiGetClassDevsW
+SetupDiGetClassDevsW.restype = HDEVINFO
+SetupDiGetClassDevsW.argtypes = (
+    POINTER(GUID),  # [in, optional] ClassGuid
+    c_wchar_p,  # [in, optional] Enumerator
+    c_void_p,  # [in, optional] hwndParent
+    c_uint32,  # [in] Flags
+)
+
+SetupDiEnumDeviceInfo = windll.setupapi.SetupDiEnumDeviceInfo
+SetupDiEnumDeviceInfo.restype = c_bool
+SetupDiEnumDeviceInfo.argtypes = (
+    HDEVINFO,  # [in] DeviceInfoSet
+    c_uint32,  # [in] MemberIndex
+    POINTER(SP_DEVINFO_DATA),  # [out] DeviceInfoData
+)
+
+SetupDiOpenDeviceInfoW = windll.setupapi.SetupDiOpenDeviceInfoW
+SetupDiOpenDeviceInfoW.restype = c_bool
+SetupDiOpenDeviceInfoW.argtypes = (
+    HDEVINFO,  # [in] DeviceInfoSet
+    c_wchar_p,  # [in] DeviceInstanceId
+    c_void_p,  # [in, optional] hwndParent
+    c_uint32,  # [in] OpenFlags
+    POINTER(SP_DEVINFO_DATA),  # [out, optional] DeviceInfoData
+)
+
+SetupDiGetDevicePropertyW = windll.setupapi.SetupDiGetDevicePropertyW
+SetupDiGetDevicePropertyW.restype = c_bool
+SetupDiGetDevicePropertyW.argtypes = (
+    HDEVINFO,  # [in] DeviceInfoSet
+    POINTER(SP_DEVINFO_DATA),  # [in] DeviceInfoData
+    POINTER(DEVPROPKEY),  # [in] PropertyKey
+    POINTER(c_uint32),  # [out] PropertyType
+    POINTER(c_ubyte),  # [out, optional] PropertyBuffer
+    c_uint32,  # [in] PropertyBufferSize
+    POINTER(c_uint32),  # [out, optional] RequiredSize
+    c_uint32,  # [in] Flags
+)
+
+SetupDiGetDevicePropertyKeys = windll.setupapi.SetupDiGetDevicePropertyKeys
+SetupDiGetDevicePropertyKeys.restype = c_bool
+SetupDiGetDevicePropertyKeys.argtypes = (
+    HDEVINFO,  # [in] DeviceInfoSet
+    POINTER(SP_DEVINFO_DATA),  # [in] DeviceInfoData
+    POINTER(DEVPROPKEY),  # [out, optional] PropertyKeyArray
+    c_uint32,  # [in] PropertyKeyCount
+    POINTER(c_uint32),  # [out, optional] RequiredPropertyKeyCount
+    c_uint32,  # [in] Flags
+)
+
+SetupDiBuildClassInfoList = windll.setupapi.SetupDiBuildClassInfoList
+SetupDiBuildClassInfoList.restype = c_bool
+SetupDiBuildClassInfoList.argtypes = (
+    c_uint32,  # [in] Flags
+    POINTER(GUID),  # [out, optional] ClassGuidList
+    c_uint32,  # [in] ClassGuidListSize
+    POINTER(c_uint32),  # [out] RequiredSize
+)
+
+SetupDiClassGuidsFromNameW = windll.setupapi.SetupDiClassGuidsFromNameW
+SetupDiClassGuidsFromNameW.restype = c_bool
+SetupDiClassGuidsFromNameW.argtypes = (
+    c_wchar_p,  # [in] ClassName,
+    POINTER(GUID),  # [out] ClassGuidList,
+    c_uint32,  # [in]  ClassGuidListSize,
+    POINTER(c_uint32),  # [out] RequiredSize
+)
+
+SetupDiGetClassPropertyW = windll.setupapi.SetupDiGetClassPropertyW
+SetupDiGetClassPropertyW.restype = c_bool
+SetupDiGetClassPropertyW.argtypes = (
+    POINTER(GUID),  # [in] ClassGuid,
+    POINTER(DEVPROPKEY),  # [in] PropertyKey,
+    POINTER(c_uint32),  # [out] PropertyType,
+    POINTER(c_ubyte),  # [out] PropertyBuffer,
+    c_uint32,  # [in] PropertyBufferSize,
+    POINTER(c_uint32),  # [out, optional] RequiredSize,
+    c_uint32,  # [in] Flags
+)
+
+SetupDiGetClassPropertyKeys = windll.setupapi.SetupDiGetClassPropertyKeys
+SetupDiGetClassPropertyKeys.restype = c_bool
+SetupDiGetClassPropertyKeys.argtypes = (
+    POINTER(GUID),  # [in] ClassGuid,
+    POINTER(DEVPROPKEY),  # [out, optional] PropertyKeyArray,
+    c_uint32,  # [in] PropertyKeyCount,
+    POINTER(c_uint32),  # [out, optional] RequiredPropertyKeyCount,
+    c_uint32,  # [in] Flags
+)

winpnp-0.0.1/src/winpnp/info/__init__.py

@@ -0,0 +1 @@
+from . import device, setup_class

winpnp-0.0.1/src/winpnp/info/_pnp_property_mapping.py

@@ -0,0 +1,126 @@
+from collections.abc import Mapping
+from ctypes import (
+    POINTER,
+    GetLastError,
+    WinError,
+    byref,
+    c_ubyte,
+    c_uint32,
+    cast,
+    create_string_buffer,
+)
+from typing import Any, Iterator, Protocol, TypeVar
+
+from winerror import ERROR_INSUFFICIENT_BUFFER, ERROR_NOT_FOUND
+
+from winpnp._setupapi import DEVPROPKEY, GUID
+from winpnp.properties.pnp_property import PnpProperty, PnpPropertyKey, PnpPropertyType
+
+T = TypeVar("T")
+
+
+class QueryValueFunc(Protocol):
+    def __call__(
+        self,
+        PropertyKey,
+        PropertyType,
+        PropertyBuffer,
+        PropertyBufferSize,
+        RequiredSize,
+    ) -> bool: ...
+
+
+class QueryKeysFunc(Protocol):
+    def __call__(
+        self, PropertyKeyArray, PropertyKeyCount, RequiredPropertyKeyCount
+    ) -> bool: ...
+
+
+class PnpPropertyMapping(Mapping[PnpPropertyKey[T], PnpProperty[T]]):
+    def __init__(
+        self,
+        description: str,
+        query_value_func: QueryValueFunc,
+        query_keys_func: QueryKeysFunc,
+    ) -> None:
+        super().__init__()
+
+        self.description = description
+        self.query_value = query_value_func
+        self.query_keys = query_keys_func
+
+    def __getitem__(self, key: PnpPropertyKey[T]) -> PnpProperty[T]:
+        if not isinstance(key, PnpPropertyKey):
+            raise KeyError(key)
+
+        win_prop_key = DEVPROPKEY(GUID.from_uuid(key.category), key.property_id)
+        type_id = c_uint32()
+        required_size = c_uint32()
+
+        if self.query_value(
+            byref(win_prop_key),
+            byref(type_id),
+            None,
+            0,
+            byref(required_size),
+        ):
+            return self.__build_property(key, PnpPropertyType(type_id.value), b"")
+
+        error = GetLastError()
+        if error == ERROR_NOT_FOUND:
+            raise KeyError(key)
+        if error != ERROR_INSUFFICIENT_BUFFER:
+            raise WinError(error)
+
+        value_buffer = create_string_buffer(required_size.value)
+        if not self.query_value(
+            byref(win_prop_key),
+            byref(type_id),
+            cast(value_buffer, POINTER(c_ubyte)),
+            required_size,
+            None,
+        ):
+            raise WinError()
+
+        return self.__build_property(
+            key, PnpPropertyType(type_id.value), value_buffer.raw
+        )
+
+    def __len__(self) -> int:
+        required_count = c_uint32()
+        if self.query_keys(None, 0, byref(required_count)):
+            return 0
+
+        error = GetLastError()
+        if error != ERROR_INSUFFICIENT_BUFFER:
+            raise WinError(error)
+
+        return required_count.value
+
+    def __iter__(self) -> Iterator[PnpPropertyKey[T]]:
+        keys = (DEVPROPKEY * len(self))()
+        if not self.query_keys(keys, len(keys), None):
+            raise WinError()
+
+        for key in keys:
+            yield PnpPropertyKey(key.fmtid.to_uuid(), key.pid)
+
+    def __build_property(
+        self,
+        key: PnpPropertyKey[T],
+        actual_type: PnpPropertyType[Any],
+        data: bytes,
+    ) -> PnpProperty[T]:
+        if (
+            key.allowed_types is not None
+            and actual_type.type_id not in key.allowed_types
+        ):
+            raise ValueError(
+                f"Property {key} of {self.description} has type {actual_type}, which is not expected."
+            )
+
+        if key.allowed_types is not None:
+            # Prefer key from allowed_types over original actual_type in case the one from allowed_types has a custom decoder
+            actual_type = key.allowed_types[actual_type.type_id]
+
+        return PnpProperty(actual_type.decode(data), actual_type)