winpnp 0.0.1__py3-none-any.whl

winpnp/properties/kinds.py

@@ -0,0 +1,284 @@
+from more_itertools import one
+
+from winpnp._setupapi import DEVPROP_TYPE, DEVPROP_TYPEMOD
+
+from .decoding import (
+    decode_booleans,
+    decode_filetimes,
+    decode_floats,
+    decode_guids,
+    decode_integers,
+    decode_nt_statuses,
+    decode_property_keys,
+    decode_property_types,
+    decode_raw,
+    decode_string,
+    decode_strings,
+    decode_win32_errors,
+)
+from .pnp_property import PnpPropertyType
+
+NULL = PnpPropertyType.register_new(int(DEVPROP_TYPE.NULL), "NULL", lambda _: None)
+"""The property exists, but it has no value."""
+
+SBYTE = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.SBYTE), "SBYTE", lambda x: one(decode_integers(x, "b"))
+)
+"""8-bit signed integer"""
+
+SBYTE_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.SBYTE | DEVPROP_TYPEMOD.ARRAY),
+    "SBYTE_ARRAY",
+    lambda x: decode_integers(x, "b"),
+)
+"""Array of 8-bit signed integers"""
+
+BYTE = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.BYTE), "BYTE", lambda x: one(decode_integers(x, "B"))
+)
+"""8-bit unsigned integer"""
+
+BYTE_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.BYTE | DEVPROP_TYPEMOD.ARRAY),
+    "BYTE_ARRAY",
+    lambda x: decode_integers(x, "B"),
+)
+"""Array of 8-bit unsigned integers (used for custom binary data)"""
+
+INT16 = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.INT16), "INT16", lambda x: one(decode_integers(x, "h"))
+)
+"""16-bit signed integer"""
+
+INT16_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.INT16 | DEVPROP_TYPEMOD.ARRAY),
+    "INT16_ARRAY",
+    lambda x: decode_integers(x, "h"),
+)
+"""Array of 16-bit signed integers"""
+
+UINT16 = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.UINT16), "UINT16", lambda x: one(decode_integers(x, "H"))
+)
+"""16-bit unsigned integer"""
+
+UINT16_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.UINT16 | DEVPROP_TYPEMOD.ARRAY),
+    "UINT16_ARRAY",
+    lambda x: decode_integers(x, "H"),
+)
+"""Array of 16-bit unsigned integers"""
+
+INT32 = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.INT32), "INT32", lambda x: one(decode_integers(x, "l"))
+)
+"""32-bit signed integer"""
+
+INT32_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.INT32 | DEVPROP_TYPEMOD.ARRAY),
+    "INT32_ARRAY",
+    lambda x: decode_integers(x, "l"),
+)
+"""Array of 32-bit signed integers"""
+
+UINT32 = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.UINT32), "UINT32", lambda x: one(decode_integers(x, "L"))
+)
+"""32-bit unsigned integer"""
+
+UINT32_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.UINT32 | DEVPROP_TYPEMOD.ARRAY),
+    "UINT32_ARRAY",
+    lambda x: decode_integers(x, "L"),
+)
+"""Array of 32-bit unsigned integers"""
+
+INT64 = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.INT64), "INT64", lambda x: one(decode_integers(x, "q"))
+)
+"""64-bit signed integer"""
+
+INT64_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.INT64 | DEVPROP_TYPEMOD.ARRAY),
+    "INT64_ARRAY",
+    lambda x: decode_integers(x, "q"),
+)
+"""Array of 64-bit signed integers"""
+
+UINT64 = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.UINT64), "UINT64", lambda x: one(decode_integers(x, "Q"))
+)
+"""64-bit unsigned integer"""
+
+UINT64_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.UINT64 | DEVPROP_TYPEMOD.ARRAY),
+    "UINT64_ARRAY",
+    lambda x: decode_integers(x, "Q"),
+)
+"""Array of 64-bit unsigned integers"""
+
+FLOAT = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.FLOAT), "FLOAT", lambda x: one(decode_floats(x, "f"))
+)
+"""32-bit floating-point number"""
+
+FLOAT_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.FLOAT | DEVPROP_TYPEMOD.ARRAY),
+    "FLOAT_ARRAY",
+    lambda x: decode_floats(x, "f"),
+)
+"""Array of 32-bit floating-point numbers"""
+
+DOUBLE = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DOUBLE), "DOUBLE", lambda x: one(decode_floats(x, "d"))
+)
+"""64-bit floating-point number"""
+
+DOUBLE_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DOUBLE | DEVPROP_TYPEMOD.ARRAY),
+    "DOUBLE_ARRAY",
+    lambda x: decode_floats(x, "d"),
+)
+"""Array of 64-bit floating-point numbers"""
+
+DECIMAL = PnpPropertyType.register_new(int(DEVPROP_TYPE.DECIMAL), "DECIMAL", decode_raw)
+"""Windows DECIMAL structure. For now, decoded as raw bytes."""
+
+DECIMAL_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DECIMAL | DEVPROP_TYPEMOD.ARRAY),
+    "DECIMAL_ARRAY",
+    decode_raw,
+)
+"""Array of Windows DECIMAL structures. For now, decoded as raw bytes."""
+
+GUID = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.GUID), "GUID", lambda x: one(decode_guids(x))
+)
+"""128-bit unique identifier"""
+
+GUID_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.GUID | DEVPROP_TYPEMOD.ARRAY), "GUID_ARRAY", decode_guids
+)
+"""Array of 128-bit unique identifiers"""
+
+CURRENCY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.CURRENCY), "CURRENCY", decode_raw
+)
+"""Windows CURRENCY structure. For now, decoded as raw bytes."""
+
+CURRENCY_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.CURRENCY | DEVPROP_TYPEMOD.ARRAY),
+    "CURRENCY_ARRAY",
+    decode_raw,
+)
+"""Array of Windows CURRENCY structures. For now, decoded as raw bytes."""
+
+DATE = PnpPropertyType.register_new(int(DEVPROP_TYPE.DATE), "DATE", decode_raw)
+"""64-bit floating-point number (double) that specifies the number of days since December 31, 1899. For now, decoded as raw bytes."""
+
+DATE_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DATE | DEVPROP_TYPEMOD.ARRAY), "DATE_ARRAY", decode_raw
+)
+"""Array of doubles that specify the number of days since December 31, 1899. For now, decoded as raw bytes."""
+
+FILETIME = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.FILETIME), "FILETIME", lambda x: one(decode_filetimes(x))
+)
+"""Windows FILETIME structure."""
+
+FILETIME_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.FILETIME | DEVPROP_TYPEMOD.ARRAY),
+    "FILETIME_ARRAY",
+    decode_filetimes,
+)
+"""Array of Windows file time structures."""
+
+BOOLEAN = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.BOOLEAN), "BOOLEAN", lambda x: one(decode_booleans(x))
+)
+"""8-bit boolean"""
+
+BOOLEAN_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.BOOLEAN | DEVPROP_TYPEMOD.ARRAY), "BOOLEAN_ARRAY", decode_booleans
+)
+"""Array of 8-bit booleans"""
+
+STRING = PnpPropertyType.register_new(int(DEVPROP_TYPE.STRING), "STRING", decode_string)
+"""Null-terminated UTF-16-LE string."""
+
+STRING_LIST = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.STRING | DEVPROP_TYPEMOD.LIST), "STRING_LIST", decode_strings
+)
+"""Multi-string: sequence of null-terminated UTF-16-LE string, followed by an empty string."""
+
+SECURITY_DESCRIPTOR = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.SECURITY_DESCRIPTOR), "SECURITY_DESCRIPTOR", decode_raw
+)
+"""Self-relative binary security descriptor. For now, decoded as raw bytes."""
+
+SECURITY_DESCRIPTOR_STRING = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.SECURITY_DESCRIPTOR_STRING),
+    "SECURITY_DESCRIPTOR_STRING",
+    decode_string,
+)
+"""Null-terminated UTF-16-LE string that contains a security descriptor in the Security Descriptor Definition Language (SDDL) format."""
+
+SECURITY_DESCRIPTOR_STRING_LIST = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.SECURITY_DESCRIPTOR_STRING | DEVPROP_TYPEMOD.LIST),
+    "SECURITY_DESCRIPTOR_STRING_LIST",
+    decode_strings,
+)
+"""Multi-string of strings that contain a security descriptor in the Security Descriptor Definition Language (SDDL) format."""
+
+DEVPROPKEY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DEVPROPKEY), "DEVPROPKEY", lambda x: one(decode_property_keys(x))
+)
+"""Device property key."""
+
+DEVPROPKEY_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DEVPROPKEY | DEVPROP_TYPEMOD.ARRAY),
+    "DEVPROPKEY_ARRAY",
+    decode_property_keys,
+)
+"""Array of device property keys."""
+
+DEVPROPTYPE = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DEVPROPTYPE),
+    "DEVPROPTYPE",
+    lambda x: one(decode_property_types(x)),
+)
+"""Device property type."""
+
+DEVPROPTYPE_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.DEVPROPTYPE | DEVPROP_TYPEMOD.ARRAY),
+    "DEVPROPTYPE_ARRAY",
+    decode_property_types,
+)
+"""Array of device property types."""
+
+ERROR = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.ERROR), "ERROR", lambda x: one(decode_win32_errors(x))
+)
+"""32-bit Win32 system error code."""
+
+ERROR_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.ERROR | DEVPROP_TYPEMOD.ARRAY), "ERROR_ARRAY", decode_win32_errors
+)
+"""Array of 32-bit Win32 system error codes."""
+
+NTSTATUS = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.NTSTATUS), "NTSTATUS", lambda x: one(decode_nt_statuses(x))
+)
+"""32-bit NTSTATUS code."""
+
+NTSTATUS_ARRAY = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.NTSTATUS | DEVPROP_TYPEMOD.ARRAY),
+    "NTSTATUS_ARRAY",
+    decode_nt_statuses,
+)
+"""Array of 32-bit NTSTATUS codes."""
+
+STRING_INDIRECT = PnpPropertyType.register_new(
+    int(DEVPROP_TYPE.STRING_INDIRECT), "STRING_INDIRECT", decode_string
+)
+"""Null-terminated UTF-16-LE string that contains an indirect string reference."""

winpnp/properties/pnp_property.py

@@ -0,0 +1,141 @@
+from dataclasses import dataclass, field
+from typing import Any, Callable, ClassVar, Generic, Iterable, Optional, TypeVar
+from uuid import UUID
+
+from .decoding import decode_raw
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+
+@dataclass(init=False)
+class PnpPropertyType(Generic[T]):
+    """
+    Represents a type of PnP properties. This is an abstraction over the Windows DEVPROP_TYPE constants.
+    """
+
+    _DERIVED_DATA: ClassVar[dict[int, tuple[str, Callable[[bytes], Any]]]] = {}
+
+    type_id: int
+    name: Optional[str] = field(compare=False)
+    _decoder: Callable[[bytes], T] = field(repr=False, compare=False)
+
+    def __init__(
+        self,
+        type_id: int,
+        name: Optional[str] = None,
+        decoder: Optional[Callable[[bytes], T]] = None,
+    ) -> None:
+        derived_name, derived_decoder = self._DERIVED_DATA.get(
+            type_id, (None, decode_raw)
+        )
+
+        self.type_id = type_id
+        self.name = name if name is not None else derived_name
+        self._decoder = decoder if decoder is not None else derived_decoder
+
+    @staticmethod
+    def register(kind: "PnpPropertyType[U]") -> None:
+        """
+        Registers the name and decoder of the specified `PnpPropertyType` as the default name and decoder for other instances with the same `type_id`.
+        """
+        if kind.name is None:
+            raise ValueError(f"Cannot register {repr(kind)} because it is unnamed.")
+
+        if kind.type_id in PnpPropertyType._DERIVED_DATA:
+            raise ValueError(
+                f"Cannot register {repr(kind)} because its type_id is already registered with name {PnpPropertyType._DERIVED_DATA[kind.type_id][0]}"
+            )
+
+        PnpPropertyType._DERIVED_DATA[kind.type_id] = (kind.name, kind._decoder)
+
+    @staticmethod
+    def register_new(
+        type_id: int,
+        name: str,
+        decoder: Callable[[bytes], U],
+    ) -> "PnpPropertyType[U]":
+        """
+        Creates a new `PnpPropertyType`, registers it, and returns it.
+        """
+        kind = PnpPropertyType(type_id, name, decoder)
+        PnpPropertyType.register(kind)
+        return kind
+
+    def decode(self, data: bytes) -> T:
+        """
+        Decodes raw bytes to the actual python type that this `PnpPropertyType` represents.
+        """
+        return self._decoder(data)
+
+
+@dataclass(init=False)
+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]] = {}
+
+    category: UUID
+    property_id: int
+    name: Optional[str] = field(compare=False)
+    allowed_types: Optional[dict[int, PnpPropertyType[T]]] = field(compare=False)
+
+    def __init__(
+        self,
+        category: UUID,
+        property_id: int,
+        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))
+        )
+        self.allowed_types = (
+            {kind.type_id: kind for kind in allowed_types}
+            if allowed_types is not None
+            else None
+        )
+
+    @staticmethod
+    def register(key: "PnpPropertyKey[U]") -> None:
+        """
+        Registers the name and of the specified `PnpPropertyKey` as the default name for other instances with the same `(category, property_id) pair`.
+        """
+        if key.name is None:
+            raise ValueError(f"Cannot register {repr(key)} because it is unnamed.")
+
+        _id = (key.category, key.property_id)
+        if _id in PnpPropertyKey._NAMES:
+            raise ValueError(
+                f"Cannot register {repr(key)} because its (category, property_id) pair is already registered with name {repr(PnpPropertyKey._NAMES[_id])}"
+            )
+
+        PnpPropertyKey._NAMES[_id] = key.name
+
+    @staticmethod
+    def register_new(
+        category: UUID,
+        property_id: int,
+        name: str,
+        allowed_types: Optional[Iterable[PnpPropertyType[U]]] = None,
+    ) -> "PnpPropertyKey[U]":
+        """
+        Creates a new `PnpPropertyKey`, registers it, and returns it.
+        """
+        key = PnpPropertyKey(category, property_id, name, allowed_types)
+        PnpPropertyKey.register(key)
+        return key
+
+
+@dataclass()
+class PnpProperty(Generic[T]):
+    """
+    Holds the value and type of a PnP property.
+    """
+
+    value: T
+    kind: PnpPropertyType[T]

winpnp-0.0.1.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,23 @@
+winpnp/__init__.py,sha256=gvKkDfOakSAN-FStT7IlKk1UEZ7yO7LtXusSaQVkFD0,32
+winpnp/_setupapi.py,sha256=nBkStynINzUDZSf2qSHajsIe2On6b7JpEAna9x87uOQ,7183
+winpnp/info/__init__.py,sha256=zacQ9bQDNfWB1siz8T0C5MQGHJZ2DvJ4o6o_WhVj-QM,35
+winpnp/info/_pnp_property_mapping.py,sha256=tyaPAXd36g_Wvs_-5ClRWAacenRPU4lx7ng-10sd-7w,3747
+winpnp/info/device.py,sha256=GWWX-yaiFaVTKkOEZ7A0S9Q7viu_Rc3MLTplQib-A0I,6077
+winpnp/info/setup_class.py,sha256=PaXmW4m2ycSFH6i88Wcxgdhr7y-33LuSDU_9V1iM0ZQ,3792
+winpnp/properties/__init__.py,sha256=oqncCBWwr5EBZm2lHkRmds0fmWZ7G8stC0U_AS87JqY,41
+winpnp/properties/decoding.py,sha256=0a8kM24Q4AoJ6GvHF0GXitS5OHa5q-VX_TeXtQPF5ek,4149
+winpnp/properties/kinds.py,sha256=U6v-4kNeQabozUhsx39jQARO11S6sapdXxglcije6Jc,9314
+winpnp/properties/pnp_property.py,sha256=nfHAhh4fxqFFDLkO2QIWlHZObVYxPc98cWwx7KFBjeo,4746
+winpnp/properties/keys/__init__.py,sha256=UFNASfjn-h9isFvQAeXBeHa9IwIPuKSZPovac6WEyXY,409
+winpnp/properties/keys/bluetooth.py,sha256=SRhz3sks6EESA01LCX4O4BQwoIm33_PyUlUSl1izJBw,2140
+winpnp/properties/keys/dev_query.py,sha256=kwmXcUb7bEbhjXm4yTnL8lWJxcBej0ZUvjMmHB_Fj_0,280
+winpnp/properties/keys/device.py,sha256=h8pjY7-PwpkY1Up_BhjPrXxygm5UFyMp-tvd_R0DoFY,18384
+winpnp/properties/keys/device_class.py,sha256=CeXNv_3ncUNpPbUrU_UQO7-V4Cs4zFq8e6G0RfeOWYU,3490
+winpnp/properties/keys/device_container.py,sha256=1cxKFYiRfFTQ6d_OjL8tr3nIuwuCHVvXcgt9OpcZHbg,9440
+winpnp/properties/keys/device_interface.py,sha256=Fjaj8fJdtYKgcLsnolHBN4LorC1BRbCsV0gkys1VHtk,1333
+winpnp/properties/keys/device_interface_class.py,sha256=ci80vR0Ue8lba5XBIqg-8VVa5CxvJNzJ9sVi4yr3JlU,462
+winpnp/properties/keys/driver_package.py,sha256=YXMOA7PjsDEyu92tT7ppUpoY31UCMrRQmUqmrOGQLzU,1076
+winpnp-0.0.1.dist-info/METADATA,sha256=YocswzrS9NSjc0G7rrxkgBtoIzY7omEjnhPepj8j6mU,1902
+winpnp-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+winpnp-0.0.1.dist-info/licenses/LICENSE,sha256=kMhLdtRDEv5y1xkgn_gpWXxkNbjNeGdE0rIZoEWsx90,1070
+winpnp-0.0.1.dist-info/RECORD,,

winpnp-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

winpnp-0.0.1.dist-info/licenses/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.