1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
"""Provide a model for inclusion and provisioning."""
from __future__ import annotations
from dataclasses import dataclass
from typing import Any, TypedDict
from ...const import Protocols, ProvisioningEntryStatus, QRCodeVersion, SecurityClass
class InclusionGrantDataType(TypedDict):
"""Representation of an inclusion grant data dict type."""
# https://github.com/zwave-js/node-zwave-js/blob/master/packages/zwave-js/src/lib/controller/Inclusion.ts#L48-L56
securityClasses: list[int]
clientSideAuth: bool
@dataclass
class InclusionGrant:
"""Representation of an inclusion grant."""
security_classes: list[SecurityClass]
client_side_auth: bool
def to_dict(self) -> InclusionGrantDataType:
"""Return InclusionGrantDataType dict from self."""
return {
"securityClasses": [sec_cls.value for sec_cls in self.security_classes],
"clientSideAuth": self.client_side_auth,
}
@classmethod
def from_dict(cls, data: InclusionGrantDataType) -> InclusionGrant:
"""Return InclusionGrant from InclusionGrantDataType dict."""
return cls(
security_classes=[
SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
],
client_side_auth=data["clientSideAuth"],
)
@dataclass
class ProvisioningEntry:
"""Class to represent the base fields of a provisioning entry."""
dsk: str
security_classes: list[SecurityClass]
requested_security_classes: list[SecurityClass] | None = None
status: ProvisioningEntryStatus = ProvisioningEntryStatus.ACTIVE
protocol: Protocols | None = None
additional_properties: dict[str, Any] | None = None
def to_dict(self) -> dict[str, Any]:
"""Return PlannedProvisioning data dict from self."""
data = {
"dsk": self.dsk,
"securityClasses": [sec_cls.value for sec_cls in self.security_classes],
"status": self.status.value,
**(self.additional_properties or {}),
}
if self.requested_security_classes:
data["requestedSecurityClasses"] = [
sec_cls.value for sec_cls in self.requested_security_classes
]
if self.protocol is not None:
data["protocol"] = self.protocol.value
return data
@classmethod
def from_dict(cls, data: dict[str, Any]) -> ProvisioningEntry:
"""Return ProvisioningEntry from data dict."""
cls_instance = cls(
dsk=data["dsk"],
security_classes=[
SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
],
)
if additional_properties := {
k: v
for k, v in data.items()
if k not in ("dsk", "securityClasses", "requestedSecurityClasses", "status")
}:
cls_instance.additional_properties = additional_properties
if "requestedSecurityClasses" in data:
cls_instance.requested_security_classes = [
SecurityClass(sec_cls) for sec_cls in data["requestedSecurityClasses"]
]
if "status" in data:
cls_instance.status = ProvisioningEntryStatus(data["status"])
if "protocol" in data:
cls_instance.protocol = Protocols(data["protocol"])
return cls_instance
@dataclass
class QRProvisioningInformationMixin:
"""Mixin class to represent the base fields of a QR provisioning information."""
version: QRCodeVersion
generic_device_class: int
specific_device_class: int
installer_icon_type: int
manufacturer_id: int
product_type: int
product_id: int
application_version: str
max_inclusion_request_interval: int | None
uuid: str | None
supported_protocols: list[Protocols] | None
@dataclass
class QRProvisioningInformation(ProvisioningEntry, QRProvisioningInformationMixin):
"""Representation of provisioning information retrieved from a QR code."""
def to_dict(self) -> dict[str, Any]:
"""Return QRProvisioningInformation data dict from self."""
data = {
"version": self.version.value,
"securityClasses": [sec_cls.value for sec_cls in self.security_classes],
"dsk": self.dsk,
"status": self.status.value,
"genericDeviceClass": self.generic_device_class,
"specificDeviceClass": self.specific_device_class,
"installerIconType": self.installer_icon_type,
"manufacturerId": self.manufacturer_id,
"productType": self.product_type,
"productId": self.product_id,
"applicationVersion": self.application_version,
**(self.additional_properties or {}),
}
if self.requested_security_classes:
data["requestedSecurityClasses"] = [
sec_cls.value for sec_cls in self.requested_security_classes
]
if self.max_inclusion_request_interval is not None:
data["maxInclusionRequestInterval"] = self.max_inclusion_request_interval
if self.uuid is not None:
data["uuid"] = self.uuid
if self.supported_protocols is not None:
data["supportedProtocols"] = [
protocol.value for protocol in self.supported_protocols
]
return data
@classmethod
def from_dict(cls, data: dict[str, Any]) -> QRProvisioningInformation:
"""Return QRProvisioningInformation from data dict."""
supported_protocols: list[Protocols] | None = None
if "supportedProtocols" in data:
supported_protocols = [
Protocols(supported_protocol)
for supported_protocol in data["supportedProtocols"]
]
cls_instance = cls(
version=QRCodeVersion(data["version"]),
security_classes=[
SecurityClass(sec_cls) for sec_cls in data["securityClasses"]
],
dsk=data["dsk"],
generic_device_class=data["genericDeviceClass"],
specific_device_class=data["specificDeviceClass"],
installer_icon_type=data["installerIconType"],
manufacturer_id=data["manufacturerId"],
product_type=data["productType"],
product_id=data["productId"],
application_version=data["applicationVersion"],
max_inclusion_request_interval=data.get("maxInclusionRequestInterval"),
uuid=data.get("uuid"),
supported_protocols=supported_protocols,
)
if additional_properties := {
k: v
for k, v in data.items()
if k
not in (
"version",
"securityClasses",
"requestedSecurityClasses",
"dsk",
"genericDeviceClass",
"specificDeviceClass",
"installerIconType",
"manufacturerId",
"productType",
"productId",
"applicationVersion",
"maxInclusionRequestInterval",
"uuid",
"supportedProtocols",
"status",
)
}:
cls_instance.additional_properties = additional_properties
if "requestedSecurityClasses" in data:
cls_instance.requested_security_classes = [
SecurityClass(sec_cls) for sec_cls in data["requestedSecurityClasses"]
]
if "status" in data:
cls_instance.status = ProvisioningEntryStatus(data["status"])
return cls_instance
|
