victorusachev · May 25, 2021 07:30
diff --git a/dotted_version_conversions.py b/dotted_version_conversions.py
 """
 Implement the conversion of the dotted version string to an integer and reverse conversion.

 This approach can be used to compactly store large amounts of version data.
 """

 import struct
 from typing import List, Optional

 import pytest


 UNSIGNED_SHORT_FORMAT = 'H'  # 0 <= number <= 65535
 UNSIGNED_SHORT_MAX_NUMBER = 65_535


 def _int_to_bytes(number: int, signed=False) -> bytes:
    if not signed and number < 0:
        raise ValueError
    length = (8 + (number + (number < 0)).bit_length()) // 8
    _bytes = int.to_bytes(number, length=length, byteorder='big', signed=signed)
    return _bytes


 def _int_from_bytes(binary_data: bytes, signed=False) -> Optional[int]:
    return int.from_bytes(binary_data, byteorder='big', signed=signed)


 def _list_int_to_bytes(version_list: List[int]) -> bytes:
    try:
        version_bytes = struct.pack('<' + UNSIGNED_SHORT_FORMAT * len(version_list), *version_list)
    except struct.error as exc:
        raise ValueError from exc
    return version_bytes


 def _bytes_to_list_int(binary_data: bytes) -> List[int]:
    version_list = [x[0] for x in struct.iter_unpack('<' + UNSIGNED_SHORT_FORMAT, binary_data)]
    return version_list


 def _list_int_to_dotted(version_list: List[int]) -> str:
    dotted_version = '.'.join(map(str, version_list))
    return dotted_version


 def _dotted_to_list_int(dotted_version: str) -> List[int]:
    version_list = list(map(int, dotted_version.split('.')))
    return version_list


 def encode_version_to_number(dotted_version: Optional[str]) -> Optional[int]:
    if not dotted_version:
        return None

    version_list = _dotted_to_list_int(dotted_version)
    version_list = [min(x, UNSIGNED_SHORT_MAX_NUMBER) for x in version_list]
    version_list.insert(0, 1)  # an additional value is needed to keep the leading zero

    version_bytes = _list_int_to_bytes(version_list)
    version_int = _int_from_bytes(version_bytes)
    return version_int


 def decode_version_from_number(endcoded_version: Optional[int]) -> Optional[str]:
    if endcoded_version is None:
        return None

    version_bytes = _int_to_bytes(endcoded_version)
    version_list = _bytes_to_list_int(version_bytes)
    version_list.pop(0)  # an additional value is needed to keep the leading zero

    dotted_version = _list_int_to_dotted(version_list)
    return dotted_version


 @pytest.mark.parametrize(
    'version',
    [
        None,
        '0',
        '10',
        '65535',
        '0.1',
        '0.0.0',
        '0.1.0',
        '14.4.2',
        '87.0.4280.77',
        '14.0.3.4',
        '90.0.4430.212',
        '90.0.818.66',
        '0.1.2.3.65535.5',
    ]
 )
 def test_coding_versions(version: str) -> None:
    encoded_version = encode_version_to_number(version)
    decoded_version = decode_version_from_number(encoded_version)

    assert decoded_version == version
	"""
	Implement the conversion of the dotted version string to an integer and reverse conversion.

	This approach can be used to compactly store large amounts of version data.
	"""

	import struct
	from typing import List, Optional

	import pytest


	UNSIGNED_SHORT_FORMAT = 'H' # 0 <= number <= 65535
	UNSIGNED_SHORT_MAX_NUMBER = 65_535


	def _int_to_bytes(number: int, signed=False) -> bytes:
	if not signed and number < 0:
	raise ValueError
	length = (8 + (number + (number < 0)).bit_length()) // 8
	_bytes = int.to_bytes(number, length=length, byteorder='big', signed=signed)
	return _bytes


	def _int_from_bytes(binary_data: bytes, signed=False) -> Optional[int]:
	return int.from_bytes(binary_data, byteorder='big', signed=signed)


	def _list_int_to_bytes(version_list: List[int]) -> bytes:
	try:
	version_bytes = struct.pack('<' + UNSIGNED_SHORT_FORMAT * len(version_list), *version_list)
	except struct.error as exc:
	raise ValueError from exc
	return version_bytes


	def _bytes_to_list_int(binary_data: bytes) -> List[int]:
	version_list = [x[0] for x in struct.iter_unpack('<' + UNSIGNED_SHORT_FORMAT, binary_data)]
	return version_list


	def _list_int_to_dotted(version_list: List[int]) -> str:
	dotted_version = '.'.join(map(str, version_list))
	return dotted_version


	def _dotted_to_list_int(dotted_version: str) -> List[int]:
	version_list = list(map(int, dotted_version.split('.')))
	return version_list


	def encode_version_to_number(dotted_version: Optional[str]) -> Optional[int]:
	if not dotted_version:
	return None

	version_list = _dotted_to_list_int(dotted_version)
	version_list = [min(x, UNSIGNED_SHORT_MAX_NUMBER) for x in version_list]
	version_list.insert(0, 1) # an additional value is needed to keep the leading zero

	version_bytes = _list_int_to_bytes(version_list)
	version_int = _int_from_bytes(version_bytes)
	return version_int


	def decode_version_from_number(endcoded_version: Optional[int]) -> Optional[str]:
	if endcoded_version is None:
	return None

	version_bytes = _int_to_bytes(endcoded_version)
	version_list = _bytes_to_list_int(version_bytes)
	version_list.pop(0) # an additional value is needed to keep the leading zero

	dotted_version = _list_int_to_dotted(version_list)
	return dotted_version


	@pytest.mark.parametrize(
	'version',
	[
	None,
	'0',
	'10',
	'65535',
	'0.1',
	'0.0.0',
	'0.1.0',
	'14.4.2',
	'87.0.4280.77',
	'14.0.3.4',
	'90.0.4430.212',
	'90.0.818.66',
	'0.1.2.3.65535.5',
	]
	)
	def test_coding_versions(version: str) -> None:
	encoded_version = encode_version_to_number(version)
	decoded_version = decode_version_from_number(encoded_version)

	assert decoded_version == version