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
|
"""Support files for podman API implementation."""
import datetime
import re
import threading
__all__ = [
'cached_property',
'datetime_parse',
'datetime_format',
]
class cached_property(object):
"""cached_property() - computed once per instance, cached as attribute.
Maybe this will make a future version of python.
"""
def __init__(self, func):
"""Construct context manager."""
self.func = func
self.__doc__ = func.__doc__
self.lock = threading.RLock()
def __get__(self, instance, cls=None):
"""Retrieve previous value, or call func()."""
if instance is None:
return self
attrname = self.func.__name__
try:
cache = instance.__dict__
except AttributeError: # objects with __slots__ have no __dict__
msg = ("No '__dict__' attribute on {}"
" instance to cache {} property.").format(
repr(type(instance).__name__), repr(attrname))
raise TypeError(msg) from None
with self.lock:
# check if another thread filled cache while we awaited lock
if attrname not in cache:
cache[attrname] = self.func(instance)
return cache[attrname]
def datetime_parse(string):
"""Convert timestamp to datetime.
Because date/time parsing in python is still pedantically stupid,
we rip the input string apart throwing out the stop characters etc;
then rebuild a string strptime() can parse. Igit!
- Python >3.7 will address colons in the UTC offset.
- There is no ETA on microseconds > 6 digits.
- And giving an offset and timezone name...
# match: 2018-05-08T14:12:53.797795191-07:00
# match: 2018-05-08T18:24:52.753227-07:00
# match: 2018-05-08 14:12:53.797795191 -0700 MST
# match: 2018-05-09T10:45:57.576002 (python isoformat())
Some people, when confronted with a problem, think “I know,
I'll use regular expressions.” Now they have two problems.
-- Jamie Zawinski
"""
ts = re.compile(r'^(\d+)-(\d+)-(\d+)'
r'[ T]?(\d+):(\d+):(\d+).(\d+)'
r' *([-+][\d:]{4,5})? *')
x = ts.match(string)
if x is None:
raise ValueError('Unable to parse {}'.format(string))
# converting everything to int() not worth the readablity hit
igit_proof = '{}T{}.{}{}'.format(
'-'.join(x.group(1, 2, 3)),
':'.join(x.group(4, 5, 6)),
x.group(7)[0:6],
x.group(8).replace(':', '') if x.group(8) else '',
)
format = '%Y-%m-%dT%H:%M:%S.%f'
if x.group(8):
format += '%z'
return datetime.datetime.strptime(igit_proof, format)
def datetime_format(dt):
"""Format datetime in consistent style."""
if isinstance(dt, str):
return datetime_parse(dt).isoformat()
elif isinstance(dt, datetime.datetime):
return dt.isoformat()
else:
raise ValueError('Unable to format {}. Type {} not supported.'.format(
dt, type(dt)))
|
