winpnp 0.0.1__py3-none-any.whl

winpnp/__init__.py

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

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/info/__init__.py

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

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)

winpnp/info/device.py

@@ -0,0 +1,171 @@
+from collections.abc import Mapping
+from contextlib import contextmanager
+from ctypes import GetLastError, WinError, byref, create_unicode_buffer, sizeof
+from typing import Any, Iterable, Iterator, TypeVar
+
+from winerror import ERROR_NO_MORE_ITEMS
+
+from winpnp._setupapi import (
+    DIGCF,
+    HDEVINFO,
+    INVALID_HANDLE_VALUE,
+    SP_DEVINFO_DATA,
+    SetupDiCreateDeviceInfoList,
+    SetupDiDestroyDeviceInfoList,
+    SetupDiEnumDeviceInfo,
+    SetupDiGetClassDevsW,
+    SetupDiGetDevicePropertyKeys,
+    SetupDiGetDevicePropertyW,
+    SetupDiOpenDeviceInfoW,
+)
+from winpnp.properties import keys
+from winpnp.properties.pnp_property import PnpProperty, PnpPropertyKey
+
+from ._pnp_property_mapping import PnpPropertyMapping
+
+T = TypeVar("T")
+
+
+class DeviceInfo(Mapping[PnpPropertyKey[Any], PnpProperty[Any]]):
+    """
+    Represents information about a single PnP device node.
+
+    This class should not be instantiated directly. Instead, use one of the factory methods: `of_instance_id`, `of_all_devices`, `of_present_devices`:
+
+    Can be used as a `Mapping`, with `PnpPropertyKey`s as keys and `PnpProperty` as values.
+
+    For example:
+    >>> 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
+    PnpProperty(value='HTREE\\ROOT\\0', kind=PnpPropertyType(type_id=18, name='STRING'))
+    """
+
+    __init_token = object()
+
+    def __init__(self, handle: HDEVINFO, data: SP_DEVINFO_DATA, *, _token=None) -> None:
+        """
+        This function should not be called directly, instead use one of the factory methods: `of_instance_id`, `of_all_devices`, `of_present_devices`.
+        """
+        if _token is not self.__init_token:
+            raise TypeError(
+                f"{type(self).__name__} should not be instantiated directly. You should use one of the factory methods: `of_instance_id`, `of_all_devices`, `of_present_devices`"
+            )
+
+        super().__init__()
+
+        self._handle = handle
+        self._data = data
+
+        self._properties: PnpPropertyMapping[Any] = PnpPropertyMapping(
+            description="<uninitialized DeviceInfo>",
+            query_value_func=lambda PropertyKey, PropertyType, PropertyBuffer, PropertyBufferSize, RequiredSize: SetupDiGetDevicePropertyW(
+                self._handle,
+                byref(self._data),
+                PropertyKey,
+                PropertyType,
+                PropertyBuffer,
+                PropertyBufferSize,
+                RequiredSize,
+                0,
+            ),
+            query_keys_func=lambda PropertyKeyArray, PropertyKeyCount, RequiredPropertyKeyCount: SetupDiGetDevicePropertyKeys(
+                self._handle,
+                byref(self._data),
+                PropertyKeyArray,
+                PropertyKeyCount,
+                RequiredPropertyKeyCount,
+                0,
+            ),
+        )
+
+        self._instance_id: str = self._properties[keys.device.INSTANCE_ID].value
+        # Update description now that instance_id is known
+        self._properties.description = repr(self)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}(instance_id={repr(self._instance_id)})"
+
+    def __getitem__(self, key: PnpPropertyKey[T]) -> PnpProperty[T]:
+        return self._properties[key]
+
+    def __len__(self) -> int:
+        return len(self._properties)
+
+    def __iter__(self) -> Iterator[PnpPropertyKey[Any]]:
+        return iter(self._properties)
+
+    @classmethod
+    def __enumerate_device_info_set(cls, handle: HDEVINFO) -> Iterator["DeviceInfo"]:
+        index = 0
+        data = SP_DEVINFO_DATA()
+        data.cbSize = sizeof(data)
+
+        while SetupDiEnumDeviceInfo(handle, index, byref(data)):
+            yield cls(
+                handle, SP_DEVINFO_DATA.from_buffer_copy(data), _token=cls.__init_token
+            )
+            index += 1
+
+        error = GetLastError()
+        if error != ERROR_NO_MORE_ITEMS:
+            raise WinError(error)
+
+    @classmethod
+    @contextmanager
+    def __create_using_SetupDiGetClassDevsW(
+        cls, flags: DIGCF
+    ) -> Iterator[Iterable["DeviceInfo"]]:
+        handle: HDEVINFO = SetupDiGetClassDevsW(None, None, None, flags)
+        if handle == INVALID_HANDLE_VALUE:
+            raise WinError()
+
+        try:
+            yield cls.__enumerate_device_info_set(handle)
+        finally:
+            SetupDiDestroyDeviceInfoList(handle)
+
+    @classmethod
+    @contextmanager
+    def of_instance_id(cls, instance_id: str) -> Iterator["DeviceInfo"]:
+        """
+        Opens information of the device with the specified instance id.
+        """
+        handle: HDEVINFO = SetupDiCreateDeviceInfoList(None, None)
+        if handle == INVALID_HANDLE_VALUE:
+            raise WinError()
+
+        try:
+            data = SP_DEVINFO_DATA()
+            data.cbSize = sizeof(data)
+            if not SetupDiOpenDeviceInfoW(
+                handle, create_unicode_buffer(instance_id), None, 0, byref(data)
+            ):
+                raise WinError()
+
+            yield cls(handle, data, _token=cls.__init_token)
+        finally:
+            SetupDiDestroyDeviceInfoList(handle)
+
+    @classmethod
+    @contextmanager
+    def of_all_devices(cls) -> Iterator[Iterable["DeviceInfo"]]:
+        """
+        Opens information of all devices known to Windows, including ones that are no longer present.
+        """
+        with cls.__create_using_SetupDiGetClassDevsW(DIGCF.ALLCLASSES) as devices:
+            yield devices
+
+    @classmethod
+    @contextmanager
+    def of_present_devices(cls) -> Iterator[Iterable["DeviceInfo"]]:
+        """
+        Opens information of all devices that are currently present.
+        """
+        with cls.__create_using_SetupDiGetClassDevsW(
+            DIGCF.ALLCLASSES | DIGCF.PRESENT
+        ) as devices:
+            yield devices

winpnp/info/setup_class.py

@@ -0,0 +1,110 @@
+from collections.abc import Mapping
+from ctypes import WinError, byref, c_uint32, create_unicode_buffer
+from typing import Any, Iterator, TypeVar
+from uuid import UUID
+
+from winpnp._setupapi import (
+    DICLASSPROP,
+    GUID,
+    SetupDiBuildClassInfoList,
+    SetupDiClassGuidsFromNameW,
+    SetupDiGetClassPropertyKeys,
+    SetupDiGetClassPropertyW,
+)
+from winpnp.properties import keys
+from winpnp.properties.pnp_property import PnpProperty, PnpPropertyKey
+
+from ._pnp_property_mapping import PnpPropertyMapping
+
+T = TypeVar("T")
+
+
+class SetupClassInfo(Mapping[PnpPropertyKey[Any], PnpProperty[Any]]):
+    """
+    Represents information about a single PnP setup class.
+
+    Can be used as a `Mapping`, with `PnpPropertyKey`s as keys and `PnpProperty` as values.
+
+    For example:
+    >>> from uuid import UUID
+    >>> from winpnp.properties.keys.device_class import CLASS_NAME
+    ...
+    >>> SetupClassInfo(UUID("36fc9e60-c465-11cf-8056-444553540000"))[CLASS_NAME]
+    PnpProperty(value='USB', kind=PnpPropertyType(type_id=18, name='STRING'))
+    """
+
+    def __init__(self, guid: UUID) -> None:
+        super().__init__()
+
+        self._guid = guid
+
+        self._properties: PnpPropertyMapping[Any] = PnpPropertyMapping(
+            description="<uninitialized SetupClassInfo>",
+            query_value_func=lambda PropertyKey, PropertyType, PropertyBuffer, PropertyBufferSize, RequiredSize: SetupDiGetClassPropertyW(
+                byref(GUID.from_uuid(self._guid)),
+                PropertyKey,
+                PropertyType,
+                PropertyBuffer,
+                PropertyBufferSize,
+                RequiredSize,
+                DICLASSPROP.INSTALLER,
+            ),
+            query_keys_func=lambda PropertyKeyArray, PropertyKeyCount, RequiredPropertyKeyCount: SetupDiGetClassPropertyKeys(
+                byref(GUID.from_uuid(self._guid)),
+                PropertyKeyArray,
+                PropertyKeyCount,
+                RequiredPropertyKeyCount,
+                DICLASSPROP.INSTALLER,
+            ),
+        )
+
+        self._name: str = self._properties[keys.device_class.CLASS_NAME].value
+        # Update description now that instance_id is known
+        self._properties.description = repr(self)
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(guid={repr(self._guid)}, name={repr(self._name)})"
+        )
+
+    def __getitem__(self, key: PnpPropertyKey[T]) -> PnpProperty[T]:
+        return self._properties[key]
+
+    def __len__(self) -> int:
+        return len(self._properties)
+
+    def __iter__(self) -> Iterator[PnpPropertyKey]:
+        return iter(self._properties)
+
+    @property
+    def guid(self) -> UUID:
+        return self._guid
+
+    @classmethod
+    def of_class_name(cls, name: str) -> Iterator["SetupClassInfo"]:
+        name_buffer = create_unicode_buffer(name)
+        required_size = c_uint32()
+        if SetupDiClassGuidsFromNameW(name_buffer, None, 0, byref(required_size)):
+            return
+
+        guids = (GUID * required_size.value)()
+        if not SetupDiClassGuidsFromNameW(
+            name_buffer, guids, required_size, byref(required_size)
+        ):
+            raise WinError()
+
+        for guid in guids:
+            yield cls(guid.to_uuid())
+
+    @classmethod
+    def of_all_classes(cls) -> Iterator["SetupClassInfo"]:
+        required_size = c_uint32()
+        if SetupDiBuildClassInfoList(0, None, 0, byref(required_size)):
+            return
+
+        guids = (GUID * required_size.value)()
+        if not SetupDiBuildClassInfoList(0, guids, required_size, byref(required_size)):
+            raise WinError()
+
+        for guid in guids:
+            yield cls(guid.to_uuid())

winpnp/properties/__init__.py

@@ -0,0 +1 @@
+from . import keys, kinds, pnp_property