/usr/lib/python3/dist-packages/paste/util/datetimeutil.py is in python3-paste 2.0.3+dfsg-4ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 | # (c) 2005 Clark C. Evans and contributors
# This module is part of the Python Paste Project and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
# Some of this code was funded by: http://prometheusresearch.com
"""
Date, Time, and Timespan Parsing Utilities
This module contains parsing support to create "human friendly"
``datetime`` object parsing. The explicit goal of these routines is
to provide a multi-format date/time support not unlike that found in
Microsoft Excel. In most approaches, the input is very "strict" to
prevent errors -- however, this approach is much more liberal since we
are assuming the user-interface is parroting back the normalized value
and thus the user has immediate feedback if the data is not typed in
correctly.
``parse_date`` and ``normalize_date``
These functions take a value like '9 jan 2007' and returns either an
``date`` object, or an ISO 8601 formatted date value such
as '2007-01-09'. There is an option to provide an Oracle database
style output as well, ``09 JAN 2007``, but this is not the default.
This module always treats '/' delimiters as using US date order
(since the author's clients are US based), hence '1/9/2007' is
January 9th. Since this module treats the '-' as following
European order this supports both modes of data-entry; together
with immediate parroting back the result to the screen, the author
has found this approach to work well in pratice.
``parse_time`` and ``normalize_time``
These functions take a value like '1 pm' and returns either an
``time`` object, or an ISO 8601 formatted 24h clock time
such as '13:00'. There is an option to provide for US style time
values, '1:00 PM', however this is not the default.
``parse_datetime`` and ``normalize_datetime``
These functions take a value like '9 jan 2007 at 1 pm' and returns
either an ``datetime`` object, or an ISO 8601 formatted
return (without the T) such as '2007-01-09 13:00'. There is an
option to provide for Oracle / US style, '09 JAN 2007 @ 1:00 PM',
however this is not the default.
``parse_delta`` and ``normalize_delta``
These functions take a value like '1h 15m' and returns either an
``timedelta`` object, or an 2-decimal fixed-point
numerical value in hours, such as '1.25'. The rationale is to
support meeting or time-billing lengths, not to be an accurate
representation in mili-seconds. As such not all valid
``timedelta`` values will have a normalized representation.
"""
from datetime import timedelta, time, date
from time import localtime
__all__ = ['parse_timedelta', 'normalize_timedelta',
'parse_time', 'normalize_time',
'parse_date', 'normalize_date']
def _number(val):
try:
return int(val)
except:
return None
#
# timedelta
#
def parse_timedelta(val):
"""
returns a ``timedelta`` object, or None
"""
if not val:
return None
val = val.lower()
if "." in val:
val = float(val)
return timedelta(hours=int(val), minutes=60*(val % 1.0))
fHour = ("h" in val or ":" in val)
fMin = ("m" in val or ":" in val)
for noise in "minu:teshour()":
val = val.replace(noise, ' ')
val = val.strip()
val = val.split()
hr = 0.0
mi = 0
val.reverse()
if fHour:
hr = int(val.pop())
if fMin:
mi = int(val.pop())
if len(val) > 0 and not hr:
hr = int(val.pop())
return timedelta(hours=hr, minutes=mi)
def normalize_timedelta(val):
"""
produces a normalized string value of the timedelta
This module returns a normalized time span value consisting of the
number of hours in fractional form. For example '1h 15min' is
formatted as 01.25.
"""
if type(val) == str:
val = parse_timedelta(val)
if not val:
return ''
hr = val.seconds/3600
mn = (val.seconds % 3600)/60
return "%d.%02d" % (hr, mn * 100/60)
#
# time
#
def parse_time(val):
if not val:
return None
hr = mi = 0
val = val.lower()
amflag = (-1 != val.find('a')) # set if AM is found
pmflag = (-1 != val.find('p')) # set if PM is found
for noise in ":amp.":
val = val.replace(noise, ' ')
val = val.split()
if len(val) > 1:
hr = int(val[0])
mi = int(val[1])
else:
val = val[0]
if len(val) < 1:
pass
elif 'now' == val:
tm = localtime()
hr = tm[3]
mi = tm[4]
elif 'noon' == val:
hr = 12
elif len(val) < 3:
hr = int(val)
if not amflag and not pmflag and hr < 7:
hr += 12
elif len(val) < 5:
hr = int(val[:-2])
mi = int(val[-2:])
else:
hr = int(val[:1])
if amflag and hr >= 12:
hr = hr - 12
if pmflag and hr < 12:
hr = hr + 12
return time(hr, mi)
def normalize_time(value, ampm):
if not value:
return ''
if type(value) == str:
value = parse_time(value)
if not ampm:
return "%02d:%02d" % (value.hour, value.minute)
hr = value.hour
am = "AM"
if hr < 1 or hr > 23:
hr = 12
elif hr >= 12:
am = "PM"
if hr > 12:
hr = hr - 12
return "%02d:%02d %s" % (hr, value.minute, am)
#
# Date Processing
#
_one_day = timedelta(days=1)
_str2num = {'jan':1, 'feb':2, 'mar':3, 'apr':4, 'may':5, 'jun':6,
'jul':7, 'aug':8, 'sep':9, 'oct':10, 'nov':11, 'dec':12 }
def _month(val):
for (key, mon) in _str2num.items():
if key in val:
return mon
raise TypeError("unknown month '%s'" % val)
_days_in_month = {1: 31, 2: 28, 3: 31, 4: 30, 5: 31, 6: 30,
7: 31, 8: 31, 9: 30, 10: 31, 11: 30, 12: 31,
}
_num2str = {1: 'Jan', 2: 'Feb', 3: 'Mar', 4: 'Apr', 5: 'May', 6: 'Jun',
7: 'Jul', 8: 'Aug', 9: 'Sep', 10: 'Oct', 11: 'Nov', 12: 'Dec',
}
_wkdy = ("mon", "tue", "wed", "thu", "fri", "sat", "sun")
def parse_date(val):
if not(val):
return None
val = val.lower()
now = None
# optimized check for YYYY-MM-DD
strict = val.split("-")
if len(strict) == 3:
(y, m, d) = strict
if "+" in d:
d = d.split("+")[0]
if " " in d:
d = d.split(" ")[0]
try:
now = date(int(y), int(m), int(d))
val = "xxx" + val[10:]
except ValueError:
pass
# allow for 'now', 'mon', 'tue', etc.
if not now:
chk = val[:3]
if chk in ('now','tod'):
now = date.today()
elif chk in _wkdy:
now = date.today()
idx = list(_wkdy).index(chk) + 1
while now.isoweekday() != idx:
now += _one_day
# allow dates to be modified via + or - /w number of days, so
# that now+3 is three days from now
if now:
tail = val[3:].strip()
tail = tail.replace("+"," +").replace("-"," -")
for item in tail.split():
try:
days = int(item)
except ValueError:
pass
else:
now += timedelta(days=days)
return now
# ok, standard parsing
yr = mo = dy = None
for noise in ('/', '-', ',', '*'):
val = val.replace(noise, ' ')
for noise in _wkdy:
val = val.replace(noise, ' ')
out = []
last = False
ldig = False
for ch in val:
if ch.isdigit():
if last and not ldig:
out.append(' ')
last = ldig = True
else:
if ldig:
out.append(' ')
ldig = False
last = True
out.append(ch)
val = "".join(out).split()
if 3 == len(val):
a = _number(val[0])
b = _number(val[1])
c = _number(val[2])
if len(val[0]) == 4:
yr = a
if b: # 1999 6 23
mo = b
dy = c
else: # 1999 Jun 23
mo = _month(val[1])
dy = c
elif a is not None and a > 0:
yr = c
if len(val[2]) < 4:
raise TypeError("four digit year required")
if b: # 6 23 1999
dy = b
mo = a
else: # 23 Jun 1999
dy = a
mo = _month(val[1])
else: # Jun 23, 2000
dy = b
yr = c
if len(val[2]) < 4:
raise TypeError("four digit year required")
mo = _month(val[0])
elif 2 == len(val):
a = _number(val[0])
b = _number(val[1])
if a is not None and a > 999:
yr = a
dy = 1
if b is not None and b > 0: # 1999 6
mo = b
else: # 1999 Jun
mo = _month(val[1])
elif a is not None and a > 0:
if b is not None and b > 999: # 6 1999
mo = a
yr = b
dy = 1
elif b is not None and b > 0: # 6 23
mo = a
dy = b
else: # 23 Jun
dy = a
mo = _month(val[1])
else:
if b > 999: # Jun 2001
yr = b
dy = 1
else: # Jun 23
dy = b
mo = _month(val[0])
elif 1 == len(val):
val = val[0]
if not val.isdigit():
mo = _month(val)
if mo is not None:
dy = 1
else:
v = _number(val)
val = str(v)
if 8 == len(val): # 20010623
yr = _number(val[:4])
mo = _number(val[4:6])
dy = _number(val[6:])
elif len(val) in (3,4):
if v is not None and v > 1300: # 2004
yr = v
mo = 1
dy = 1
else: # 1202
mo = _number(val[:-2])
dy = _number(val[-2:])
elif v < 32:
dy = v
else:
raise TypeError("four digit year required")
tm = localtime()
if mo is None:
mo = tm[1]
if dy is None:
dy = tm[2]
if yr is None:
yr = tm[0]
return date(yr, mo, dy)
def normalize_date(val, iso8601=True):
if not val:
return ''
if type(val) == str:
val = parse_date(val)
if iso8601:
return "%4d-%02d-%02d" % (val.year, val.month, val.day)
return "%02d %s %4d" % (val.day, _num2str[val.month], val.year)
|