wayfinderak/ASB_submission_bot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated Guid to create random unique Guid if no arguments

Browse Source 
Also updated doc string for Guid class.
This commit is contained in:
Dustin Pianalto 2018-05-21 00:45:50 -08:00
parent 43d868e20f
commit 8875dfdef6
1 changed files with 93 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

154
exts/imports/guid.py
View File

@ -31,37 +31,73 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
"""
from struct import Struct, pack
from struct import Struct, pack, unpack
from math import log
from secrets import randbelow
import uuid
from datetime import datetime
import os
# Constants for masking bytes
MAXINT64 = 0xFFFFFFFFFFFFFFFF
MAXINT32 = 0xFFFFFFFF
MAXINT16 = 0xFFFF
MAXINT8 = 0xFF
# Host Machine's MAC Address
MAC_ADDR = uuid.getnode()
# Geeksbot Epoch Jan 01 2018 in seconds since Jan 01 1970
GEPOCH = datetime(2018, 1, 1).timestamp()
class Guid:
"""
A Global Unique Identifier (Guid) based on the one provided in C#'s System package
"""This function does something.
The Guid is stored as a tuple of length 11 for easy processing and comparisons
Args:
:param guid_tuple: (Optional) A tuple of length 11 containing
the different parts of the Guid
Returns:
Guid object
Raises:
RuntimeError
Example Usage:
>>> g = Guid.from_int(1234567899876534, 23456754325675)
>>> g
<Guid hash=3721039026>
>>> print(g)
'3d1f8cb6-62d5-0004-ab58-827355150000'
If initiated without any arguments a unique, semi-random Guid will be
produced using a random number, host computer's mac address, python
process id, and the current time in the following format:
######## - #### - #### - #### - ############
^ ^ ^ ^ ^
Random MAC address PID Current Time
masked to the last In microseconds
4 bytes (last 2 of since Jan 01 2018
manufacture ID and 1514797200 seconds
all of serial num) After Unix Epoch.
>>> g = Guid()
>>> print(g)
93da0643-375a-5496-f92e-060b44965042
You can create a Guid object several different ways and there are
constructor methods for the most common use cases.
Guid.from_bytes(bytes_obj) Takes a bytes object of length 16
Guid.from_int(int, int) Takes 1 or 2 integers (see help for size restrictions)
Guid.from_string(str) Takes the string representation in the
format returned by Guid.to_string()
Guid.empty() Takes no arguments and returns an empty (all 0s) Guid
Attributes:
guid (tuple): A tuple containing the guid
"""
def __init__(self, guid_tuple: tuple=()):
"""
Initialize the Guid
Arguments:
Union[int, str, bytes, short(int will be masked to short)]:
The arguments can be in any of the following formats:
(bytes(len 16))
(int(len <= 4), short, short, bytes(len 8))
(int(len <= 8), int(len <= 8))
(int(len <= 16))
(str) - str must be formatted 00000000-0000-0000-0000-000000000000
"""
if bool(guid_tuple):
if len(guid_tuple) == 11:
if all(isinstance(t, int) for t in guid_tuple):
@ -69,17 +105,27 @@ class Guid:
guid = s.pack(guid_tuple[0],
guid_tuple[1] & MAXINT16,
guid_tuple[2] & MAXINT16,
*guid_tuple[3])
*guid_tuple[3:])
self.guid = s.unpack(guid)
else:
raise RuntimeError('Every item in tuple must be an integer')
else:
raise RuntimeError('Tuple must be length 11 to create the guid')
else:
self.guid = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
# Generate semi random unique Guid
time_now = int((datetime.utcnow().timestamp() - GEPOCH) * 1000000)
rand_int = randbelow(0xFFFFFFFF)
packed_guid = pack('2I4H',
rand_int,
MAC_ADDR & MAXINT32,
os.getpid() & MAXINT16,
(time_now >> 32) & MAXINT16,
(time_now >> 16) & MAXINT16,
time_now & MAXINT16)
self.guid = unpack('I2H8B', packed_guid)
@classmethod
def from_tuple(cls, guid_bytes: bytes):
def from_bytes(cls, guid_bytes: bytes):
s = Struct('I2H8B')
if len(guid_bytes) == 16:
guid = s.pack((int(guid_bytes[3]) << 24)
@ -99,14 +145,16 @@ class Guid:
@classmethod
def from_int(cls, guid_int1: int, guid_int2: int=0):
if cls.bytes_needed(guid_int1) <= 16 and guid_int2 == 0:
b = pack('QQ', guid_int1 >> 64, guid_int1 & MAXINT64)
elif cls.bytes_needed(guid_int1) <= 4 and cls.bytes_needed(guid_int2) <= 4:
if cls._bytes_needed(guid_int1) <= 4 and cls._bytes_needed(guid_int2) <= 4 and guid_int2 != 0:
int1, int2 = (guid_int1 << 32), (guid_int2 & 0xFFFFFFFF)
guid_int = int1 | int2
b = pack('Q8x', guid_int)
elif cls.bytes_needed(guid_int1) <= 8 and cls.bytes_needed(guid_int2) <= 8:
elif cls._bytes_needed(guid_int1) <= 8 and cls._bytes_needed(guid_int2) <= 8 and guid_int2 != 0:
b = pack('QQ', guid_int1, guid_int2)
elif cls._bytes_needed(guid_int1) <= 8 and guid_int2 == 0:
b = pack('QQ', guid_int1 >> 32, guid_int1 & MAXINT32)
elif cls._bytes_needed(guid_int1) <= 16 and guid_int2 == 0:
b = pack('QQ', guid_int1 >> 64, guid_int1 & MAXINT64)
else:
raise RuntimeError('Integer is to large')
guid = ((int(b[3]) << 24) | (int(b[2]) << 16) | (int(b[1]) << 8) | b[0],
@ -114,7 +162,7 @@ class Guid:
((int(b[7]) << 8) | b[6]),
*b[8:16]
)
return cls(s.unpack(guid))
return cls(guid)
@classmethod
def from_string(cls, string: str):
@ -139,20 +187,24 @@ class Guid:
raise TypeError('String is not formatted properly must be in format '
'00000000-0000-0000-0000-000000000000')
@classmethod
def empty(cls):
return cls((0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
def to_string(self):
output = ''
output += self.hexs_to_chars(self.guid[0] >> 24, self.guid[0] >> 16)
output += self.hexs_to_chars(self.guid[0] >> 8, self.guid[0])
output += self._hexs_to_chars(self.guid[0] >> 24, self.guid[0] >> 16)
output += self._hexs_to_chars(self.guid[0] >> 8, self.guid[0])
output += '-'
output += self.hexs_to_chars(self.guid[1] >> 8, self.guid[1])
output += self._hexs_to_chars(self.guid[1] >> 8, self.guid[1])
output += '-'
output += self.hexs_to_chars(self.guid[2] >> 8, self.guid[2])
output += self._hexs_to_chars(self.guid[2] >> 8, self.guid[2])
output += '-'
output += self.hexs_to_chars(self.guid[3], self.guid[4])
output += self._hexs_to_chars(self.guid[3], self.guid[4])
output += '-'
output += self.hexs_to_chars(self.guid[5], self.guid[6])
output += self.hexs_to_chars(self.guid[7], self.guid[8])
output += self.hexs_to_chars(self.guid[9], self.guid[10])
output += self._hexs_to_chars(self.guid[5], self.guid[6])
output += self._hexs_to_chars(self.guid[7], self.guid[8])
output += self._hexs_to_chars(self.guid[9], self.guid[10])
return output
def to_byte_array(self):
@ -175,18 +227,18 @@ class Guid:
b[15] = self.guid[10] & MAXINT8
return b
def hexs_to_chars(self, _a, _b):
out = f'{self.hex_to_char(_a>>4)}{self.hex_to_char(_a)}{self.hex_to_char(_b>>4)}{self.hex_to_char(_b)}'
def _hexs_to_chars(self, _a: int, _b: int) -> str:
out = f'{self._hex_to_char(_a>>4)}{self._hex_to_char(_a)}{self._hex_to_char(_b>>4)}{self._hex_to_char(_b)}'
return out
@staticmethod
def bytes_needed(a):
def _bytes_needed(a: int) -> int:
if a == 0:
return 1
return int(log(a, 256)) + 1
@staticmethod
def hex_to_char(a: int):
def _hex_to_char(a: int) -> str:
a = a & 0xf
out = chr(a - 10 + 0x61 if a > 9 else a + 0x30)
return out
@ -196,31 +248,9 @@ class Guid:
return t[0] ^ ((int(t[1]) << 16) | int(t[2])) ^ ((int(t[5]) << 24) | t[10])
def __eq__(self, other):
if other is None or not isinstance(other, Guid):
if self.__class__ == other.__class__:
return self.guid == getattr(other, 'guid', None)
return False
if other.guid[0] != self.guid[0]:
return False
if other.guid[1] != self.guid[1]:
return False
if other.guid[2] != self.guid[2]:
return False
if other.guid[3] != self.guid[3]:
return False
if other.guid[4] != self.guid[4]:
return False
if other.guid[5] != self.guid[5]:
return False
if other.guid[6] != self.guid[6]:
return False
if other.guid[7] != self.guid[7]:
return False
if other.guid[8] != self.guid[8]:
return False
if other.guid[9] != self.guid[9]:
return False
if other.guid[10] != self.guid[10]:
return False
return True
def __bool__(self):
return not (self.guid == (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))