def __string_to_int(self, address: str) -> int:
"""
Parse `address` as string to an integer and do some simple checks.
Returns the integer representation of `address` if all checks are valid:
* string matches against the regular expression
* main, middle and sub are inside its range
In any other case, we raise an `CouldNotParseAddress` exception.
"""
match = self.ADDRESS_RE.match(address)
if not match:
raise CouldNotParseAddress(address)
main = int(match.group("main"))
middle = (int(match.group("middle"))
if match.group("middle") is not None else None)
sub = int(match.group("sub"))
if main > self.MAX_MAIN:
raise CouldNotParseAddress(address)
if middle is not None:
if middle > self.MAX_MIDDLE:
raise CouldNotParseAddress(address)
if sub > self.MAX_SUB_LONG:
raise CouldNotParseAddress(address)
else:
if sub > self.MAX_SUB_SHORT:
raise CouldNotParseAddress(address)
return ((main << 11) + (middle << 8) + sub if middle is not None else
(main << 11) + sub)
def __init__(
self,
address: GroupAddressableType,
levels: GroupAddressType = GroupAddressType.LONG,
) -> None:
"""Initialize Address class."""
super().__init__()
self.levels = levels
if isinstance(address, GroupAddress):
self.raw = address.raw
elif isinstance(address, str):
if address.isdigit():
self.raw = int(address)
else:
self.raw = self.__string_to_int(address)
elif isinstance(address, tuple) and len(address) == 2:
self.raw = address_tuple_to_int(address)
elif isinstance(address, int):
self.raw = address
elif address is None:
self.raw = 0
else:
raise CouldNotParseAddress(address)
if self.raw > 65535:
raise CouldNotParseAddress(address)
def _set_str_group_level2(self, parts):
main = int(parts[0])
sub = int(parts[1])
if main > self.MAX_LEVEL2_1:
raise CouldNotParseAddress(parts)
if sub > self.MAX_LEVEL2_2:
raise CouldNotParseAddress(parts)
self.raw = (main << 11) + sub
self.address_format = AddressFormat.LEVEL2
def _set_str_group_level3(self, parts):
main = int(parts[0])
middle = int(parts[1])
sub = int(parts[2])
if main > self.MAX_LEVEL3_1:
raise CouldNotParseAddress(parts)
if middle > self.MAX_LEVEL3_2:
raise CouldNotParseAddress(parts)
if sub > self.MAX_LEVEL3_3:
raise CouldNotParseAddress(parts)
self.raw = (main << 11) + (middle << 8) + sub
self.address_format = AddressFormat.LEVEL3
def _set_str_group(self, address):
parts = address.split("/")
if any(not part.isdigit() for part in parts):
raise CouldNotParseAddress(address)
if len(parts) == 1:
self._set_str_group_free(parts)
elif len(parts) == 2:
self._set_str_group_level2(parts)
elif len(parts) == 3:
self._set_str_group_level3(parts)
else:
raise CouldNotParseAddress(address)
def __init__(self, address):
"""Initialize Address class."""
super(PhysicalAddress, self).__init__()
if isinstance(address, str):
self.raw = self.__string_to_int(address)
elif isinstance(address, tuple) and len(address) == 2:
self.raw = address_tuple_to_int(address)
elif isinstance(address, int):
self.raw = address
elif address is None:
self.raw = 0
else:
raise CouldNotParseAddress(address)
if isinstance(self.raw, int) and self.raw > 65535:
raise CouldNotParseAddress(address)
def _set_str_physical(self, address):
parts = address.split(".")
if any(not part.isdigit() for part in parts):
raise CouldNotParseAddress(address)
if len(parts) != 3:
raise CouldNotParseAddress(address)
main = int(parts[0])
middle = int(parts[1])
sub = int(parts[2])
if main > self.MAX_PYHSICAL_1:
raise CouldNotParseAddress(address)
if middle > self.MAX_PYHSICAL_2:
raise CouldNotParseAddress(address)
if sub > self.MAX_PYHSICAL_3:
raise CouldNotParseAddress(address)
self.raw = (main << 12) + (middle << 8) + sub
self.address_format = AddressFormat.LEVEL3
def _set_tuple(self, address):
if len(address) != 2 \
or any(not isinstance(byte, int) for byte in address) \
or any(byte < 0 for byte in address) \
or any(byte > 255 for byte in address):
raise CouldNotParseAddress(address)
self._set_int(address[0] * 256 + address[1])
def __init__(self, address: str | InternalGroupAddress) -> None:
"""Initialize InternalGroupAddress class."""
self.address: str
if isinstance(address, InternalGroupAddress):
self.address = address.address
return
if not isinstance(address, str):
raise CouldNotParseAddress(address)
prefix_length = 1
if len(address) < 2 or not address[0].lower() == "i":
raise CouldNotParseAddress(address)
if address[1] in "-_":
prefix_length = 2
self.address = address[prefix_length:].strip()
if not self.address:
raise CouldNotParseAddress(address)
def __string_to_int(self, address: str) -> int:
"""
Parse `address` as string to an integer and do some simple checks.
Returns the integer representation of `address` if all checks are valid:
* string matches against the regular expression
* area, main and line are inside its range
In any other case, we raise an `CouldNotParseAddress` exception.
"""
match = self.ADDRESS_RE.match(address)
if not match:
raise CouldNotParseAddress(address)
area = int(match.group("area"))
main = int(match.group("main"))
line = int(match.group("line"))
if area > self.MAX_AREA or main > self.MAX_MAIN or line > self.MAX_LINE:
raise CouldNotParseAddress(address)
return (area << 12) + (main << 8) + line
def __init__(self, address, levels=GroupAddressType.LONG):
"""Initialize Address class."""
super(GroupAddress, self).__init__()
self.levels = levels
if isinstance(address, str) and not address.isdigit():
self.raw = self.__string_to_int(address)
elif isinstance(address, str) and address.isdigit():
self.raw = int(address)
elif isinstance(address, tuple) and len(address) == 2:
self.raw = address_tuple_to_int(address)
elif isinstance(address, int):
self.raw = address
elif address is None:
self.raw = 0
else:
raise CouldNotParseAddress(address)
if isinstance(self.raw, int) and self.raw > 65535:
raise CouldNotParseAddress(address)
def __init__(self, address: IndividualAddressableType) -> None:
"""Initialize IndividualAddress class."""
super().__init__()
if isinstance(address, IndividualAddress):
self.raw = address.raw
elif isinstance(address, str):
if address.isdigit():
self.raw = int(address)
else:
self.raw = self.__string_to_int(address)
elif isinstance(address, tuple) and len(address) == 2:
self.raw = address_tuple_to_int(address)
elif isinstance(address, int):
self.raw = address
elif address is None:
self.raw = 0
else:
raise CouldNotParseAddress(address)
if self.raw > 65535:
raise CouldNotParseAddress(address)
def __init__(self, address: Union[object, str, int, tuple]) -> None:
"""Initialize Address class."""
super().__init__()
if isinstance(address, PhysicalAddress):
self.raw: int = address.raw
elif isinstance(address, str):
if address.isdigit():
self.raw: int = int(address) # type: ignore
else:
self.raw: int = self.__string_to_int(address) # type: ignore
elif isinstance(address, tuple) and len(address) == 2:
self.raw: int = address_tuple_to_int(address) # type: ignore
elif isinstance(address, int):
self.raw: int = address # type: ignore
elif address is None:
self.raw: int = 0 # type: ignore
else:
raise CouldNotParseAddress(address)
if self.raw > 65535:
raise CouldNotParseAddress(address)
def address_tuple_to_int(address: tuple[int, int]) -> int:
"""
Convert the tuple `address` to an integer.
Valid values inside the `address` tuple are:
* Positive Numbers between 0 and 255 (binary)
"""
if (any(not isinstance(byte, int) for byte in address)
or any(byte < 0 for byte in address)
or any(byte > 255 for byte in address)):
raise CouldNotParseAddress(address)
return int(address[0] * 256 + address[1])
def test_could_not_parse_address_exception(self):
"""Test string representation of CouldNotParseAddress exception."""
exception = CouldNotParseAddress(address='1/2/1000')
self.assertEqual(str(exception),
'<CouldNotParseAddress address="1/2/1000" />')
def _set_int(self, raw):
if not isinstance(raw, int):
raise CouldNotParseAddress(raw)
if raw > 65535:
raise CouldNotParseAddress(raw)
self.raw = raw
CouldNotParseTelegram,
DeviceIllegalValue,
XKNXException,
)
@pytest.mark.parametrize(
"base,equal,diff",
[
(
ConversionError("desc1"),
ConversionError("desc1"),
ConversionError("desc2"),
),
(
CouldNotParseAddress(123),
CouldNotParseAddress(123),
CouldNotParseAddress(321),
),
(
CouldNotParseKNXIP("desc1"),
CouldNotParseKNXIP("desc1"),
CouldNotParseKNXIP("desc2"),
),
(
CouldNotParseTelegram("desc", arg1=1, arg2=2),
CouldNotParseTelegram("desc", arg1=1, arg2=2),
CouldNotParseTelegram("desc", arg1=2, arg2=1),
),
(
DeviceIllegalValue("value1", "desc"),
