Switch to python3
This commit is contained in:
parent
531041e89a
commit
9ba4b6a91a
5286 changed files with 677347 additions and 576888 deletions
457
Shared/lib/python3.4/site-packages/ox/format.py
Normal file
457
Shared/lib/python3.4/site-packages/ox/format.py
Normal file
|
|
@ -0,0 +1,457 @@
|
|||
# -*- coding: utf-8 -*-
|
||||
# vi:si:et:sw=4:sts=4:ts=4
|
||||
import math
|
||||
import re
|
||||
import string
|
||||
|
||||
|
||||
def toAZ(num):
|
||||
"""
|
||||
Converts an integer to bijective base 26 string using A-Z
|
||||
|
||||
>>> for i in range(1, 1000): assert fromAZ(toAZ(i)) == i
|
||||
|
||||
>>> toAZ(1)
|
||||
'A'
|
||||
|
||||
>>> toAZ(4461)
|
||||
'FOO'
|
||||
|
||||
>>> toAZ(1234567890)
|
||||
'CYWOQVJ'
|
||||
"""
|
||||
if num < 1: raise ValueError("must supply a positive integer")
|
||||
digits = string.ascii_uppercase
|
||||
az = ''
|
||||
while num != 0:
|
||||
num, r = divmod(num, 26)
|
||||
u, r = divmod(r - 1, 26)
|
||||
num += u
|
||||
az = digits[r] + az
|
||||
return az
|
||||
|
||||
def fromAZ(num):
|
||||
"""
|
||||
Converts a bijective base 26 string to an integer
|
||||
|
||||
>>> fromAZ('A')
|
||||
1
|
||||
>>> fromAZ('AA')
|
||||
27
|
||||
>>> fromAZ('AAA')
|
||||
703
|
||||
>>> fromAZ('FOO')
|
||||
4461
|
||||
"""
|
||||
num = num.replace('-','')
|
||||
digits = string.ascii_uppercase
|
||||
r = 0
|
||||
for exp, char in enumerate(reversed(num)):
|
||||
r = r + (pow(26, exp) * (digits.index(char) + 1))
|
||||
return r
|
||||
|
||||
def to26(q):
|
||||
"""
|
||||
Converts an integer to base 26
|
||||
|
||||
>>> for i in range(0, 1000): assert from26(to26(i)) == i
|
||||
|
||||
>>> to26(0)
|
||||
'A'
|
||||
|
||||
>>> to26(347485647)
|
||||
'BDGKMAP'
|
||||
"""
|
||||
if q < 0: raise ValueError("must supply a positive integer")
|
||||
base26 = string.ascii_uppercase
|
||||
converted = []
|
||||
while q != 0:
|
||||
q, r = divmod(q, 26)
|
||||
l = base26[r]
|
||||
converted.insert(0, l)
|
||||
return "".join(converted) or 'A'
|
||||
|
||||
def from26(q):
|
||||
"""
|
||||
Converts an base 26 string to an integer
|
||||
>>> from26('A')
|
||||
0
|
||||
"""
|
||||
base26 = string.ascii_uppercase
|
||||
q = q.replace('-','')
|
||||
r = 0
|
||||
for i in q:
|
||||
r = r * 26 + base26.index(i.upper())
|
||||
return r
|
||||
|
||||
def to32(q):
|
||||
"""
|
||||
Converts an integer to base 32
|
||||
We exclude 4 of the 26 letters: I L O U.
|
||||
http://www.crockford.com/wrmg/base32.html
|
||||
|
||||
>>> for i in range(0, 1000): assert from32(to32(i)) == i
|
||||
|
||||
>>> to32(0)
|
||||
'0'
|
||||
|
||||
>>> to32(347485647)
|
||||
'ABCDEF'
|
||||
|
||||
>>> to32(555306645)
|
||||
'GHJKMN'
|
||||
|
||||
>>> to32(800197332334559L)
|
||||
'PQRSTVWXYZ'
|
||||
|
||||
>>> to32(32)
|
||||
'10'
|
||||
|
||||
>>> to32(119292)
|
||||
'3MFW'
|
||||
|
||||
>>> to32(939387374)
|
||||
'VZVTFE'
|
||||
|
||||
>>> to32(-1)
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: must supply a positive integer
|
||||
"""
|
||||
|
||||
if q < 0: raise ValueError("must supply a positive integer")
|
||||
letters = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"
|
||||
converted = []
|
||||
while q != 0:
|
||||
q, r = divmod(q, 32)
|
||||
l = letters[r]
|
||||
converted.insert(0, l)
|
||||
return "".join(converted) or '0'
|
||||
|
||||
def from32(q):
|
||||
"""
|
||||
Converts an base 32 string to an integer
|
||||
We exclude 4 of the 26 letters: I L O U.
|
||||
http://www.crockford.com/wrmg/base32.html
|
||||
|
||||
>>> from32('A')
|
||||
10
|
||||
|
||||
>>> from32('i')
|
||||
1
|
||||
|
||||
>>> from32('Li1l')
|
||||
33825
|
||||
|
||||
>>> from32('10')
|
||||
32
|
||||
"""
|
||||
_32map = {
|
||||
'0': 0,
|
||||
'O': 0,
|
||||
'1': 1,
|
||||
'I': 1,
|
||||
'L': 1,
|
||||
'2': 2,
|
||||
'3': 3,
|
||||
'4': 4,
|
||||
'5': 5,
|
||||
'6': 6,
|
||||
'7': 7,
|
||||
'8': 8,
|
||||
'9': 9,
|
||||
'A': 10,
|
||||
'B': 11,
|
||||
'C': 12,
|
||||
'D': 13,
|
||||
'E': 14,
|
||||
'F': 15,
|
||||
'G': 16,
|
||||
'H': 17,
|
||||
'J': 18,
|
||||
'K': 19,
|
||||
'M': 20,
|
||||
'N': 21,
|
||||
'P': 22,
|
||||
'Q': 23,
|
||||
'R': 24,
|
||||
'S': 25,
|
||||
'T': 26,
|
||||
'V': 27,
|
||||
'W': 28,
|
||||
'X': 29,
|
||||
'Y': 30,
|
||||
'Z': 31,
|
||||
}
|
||||
base32 = ('0123456789' + string.ascii_uppercase)[:32]
|
||||
q = q.replace('-','')
|
||||
q = ''.join([base32[_32map[i.upper()]] for i in q])
|
||||
return int(q, 32)
|
||||
|
||||
def to36(q):
|
||||
"""
|
||||
Converts an integer to base 36 (a useful scheme for human-sayable IDs
|
||||
like 'fuck' (739172), 'shit' (1329077) or 'hitler' (1059538851)).
|
||||
|
||||
>>> to36(35)
|
||||
'z'
|
||||
>>> to36(119292)
|
||||
'2k1o'
|
||||
>>> int(to36(939387374), 36)
|
||||
939387374
|
||||
>>> to36(0)
|
||||
'0'
|
||||
>>> to36(-393)
|
||||
Traceback (most recent call last):
|
||||
...
|
||||
ValueError: must supply a positive integer
|
||||
"""
|
||||
if q < 0: raise ValueError("must supply a positive integer")
|
||||
letters = "0123456789abcdefghijklmnopqrstuvwxyz"
|
||||
converted = []
|
||||
while q != 0:
|
||||
q, r = divmod(q, 36)
|
||||
converted.insert(0, letters[r])
|
||||
return "".join(converted) or '0'
|
||||
|
||||
def from36(q):
|
||||
return int(q, 36)
|
||||
|
||||
def int_value(strValue, default=u''):
|
||||
"""
|
||||
>>> int_value('abc23')
|
||||
u'23'
|
||||
|
||||
>>> int_value(' abc23')
|
||||
u'23'
|
||||
|
||||
>>> int_value('ab')
|
||||
u''
|
||||
"""
|
||||
try:
|
||||
val = re.compile('(\d+)').findall(unicode(strValue).strip())[0]
|
||||
except:
|
||||
val = default
|
||||
return val
|
||||
|
||||
def float_value(strValue, default=u''):
|
||||
"""
|
||||
>>> float_value('abc23.4')
|
||||
u'23.4'
|
||||
|
||||
>>> float_value(' abc23.4')
|
||||
u'23.4'
|
||||
|
||||
>>> float_value('ab')
|
||||
u''
|
||||
"""
|
||||
try:
|
||||
val = re.compile('([\d.]+)').findall(unicode(strValue).strip())[0]
|
||||
except:
|
||||
val = default
|
||||
return val
|
||||
|
||||
def format_number(number, longName, shortName):
|
||||
"""
|
||||
Return the number in a human-readable format (23 KB, 23.4 MB, 23.42 GB)
|
||||
|
||||
>>> format_number(123, 'Byte', 'B')
|
||||
'123 Bytes'
|
||||
|
||||
>>> format_number(1234, 'Byte', 'B')
|
||||
'1 KB'
|
||||
|
||||
>>> format_number(1234567, 'Byte', 'B')
|
||||
'1.2 MB'
|
||||
|
||||
>>> format_number(1234567890, 'Byte', 'B')
|
||||
'1.15 GB'
|
||||
|
||||
>>> format_number(1234567890123456789, 'Byte', 'B')
|
||||
'1,096.5166 PB'
|
||||
|
||||
>>> format_number(-1234567890123456789, 'Byte', 'B')
|
||||
'-1,096.5166 PB'
|
||||
|
||||
"""
|
||||
if abs(number) < 1024:
|
||||
return '%s %s%s' % (format_thousands(number), longName, number != 1 and 's' or '')
|
||||
prefix = ['K', 'M', 'G', 'T', 'P']
|
||||
for i in range(5):
|
||||
if abs(number) < math.pow(1024, i + 2) or i == 4:
|
||||
n = number / math.pow(1024, i + 1)
|
||||
return '%s %s%s' % (format_thousands('%.*f' % (i, n)), prefix[i], shortName)
|
||||
|
||||
def format_thousands(number, separator = ','):
|
||||
"""
|
||||
Return the number with separators (1,000,000)
|
||||
|
||||
>>> format_thousands(1)
|
||||
'1'
|
||||
>>> format_thousands(1000)
|
||||
'1,000'
|
||||
>>> format_thousands(1000000)
|
||||
'1,000,000'
|
||||
"""
|
||||
string = str(number).split('.')
|
||||
l = []
|
||||
for i, character in enumerate(reversed(string[0])):
|
||||
if i and (not (i % 3)):
|
||||
l.insert(0, separator)
|
||||
l.insert(0, character)
|
||||
string[0] = ''.join(l)
|
||||
return '.'.join(string)
|
||||
|
||||
def format_bits(number):
|
||||
return format_number(number, 'bit', 'b')
|
||||
|
||||
def format_bytes(number):
|
||||
return format_number(number, 'byte', 'B')
|
||||
|
||||
def format_pixels(number):
|
||||
return format_number(number, 'pixel', 'px')
|
||||
|
||||
def format_currency(amount, currency="$"):
|
||||
if amount:
|
||||
temp = "%.2f" % amount
|
||||
profile=re.compile(r"(\d)(\d\d\d[.,])")
|
||||
while 1:
|
||||
temp, count = re.subn(profile,r"\1,\2",temp)
|
||||
if not count:
|
||||
break
|
||||
if temp.startswith('-'):
|
||||
return "-"+ currency + temp[1:-3]
|
||||
return currency + temp[:-3]
|
||||
else:
|
||||
return ""
|
||||
|
||||
def plural(amount, unit, plural='s'):
|
||||
'''
|
||||
>>> plural(1, 'unit')
|
||||
'1 unit'
|
||||
>>> plural(2, 'unit')
|
||||
'2 units'
|
||||
'''
|
||||
if abs(amount) != 1:
|
||||
if plural == 's':
|
||||
unit = unit + plural
|
||||
else: unit = plural
|
||||
return "%s %s" % (format_thousands(amount), unit)
|
||||
|
||||
def format_duration(ms, verbosity=0, years=True, hours=True, milliseconds=True):
|
||||
'''
|
||||
verbosity
|
||||
0: D:HH:MM:SS
|
||||
1: Dd Hh Mm Ss
|
||||
2: D days H hours M minutes S seconds
|
||||
years
|
||||
True: 366 days are 1 year 1 day
|
||||
False: 366 days are 366 days
|
||||
hours
|
||||
True: 30 seconds are 00:00:30
|
||||
False: 30 seconds are 00:30
|
||||
milliseconds
|
||||
True: always display milliseconds
|
||||
False: never display milliseconds
|
||||
>>> format_duration(1000 * 60 * 60 * 24 * 366)
|
||||
'1:001:00:00:00.000'
|
||||
>>> format_duration(1000 * 60 * 60 * 24 * 366, years=False)
|
||||
'366:00:00:00.000'
|
||||
>>> format_duration(1000 * 60 * 60 * 24 * 365 + 2003, verbosity=2)
|
||||
'1 year 2 seconds 3 milliseconds'
|
||||
>>> format_duration(1000 * 30, hours=False, milliseconds=False)
|
||||
'00:30'
|
||||
'''
|
||||
if not ms and ms != 0:
|
||||
return ''
|
||||
if years:
|
||||
y = int(ms / 31536000000)
|
||||
d = int(ms % 31536000000 / 86400000)
|
||||
else:
|
||||
d = int(ms / 86400000)
|
||||
h = int(ms % 86400000 / 3600000)
|
||||
m = int(ms % 3600000 / 60000)
|
||||
s = int(ms % 60000 / 1000)
|
||||
ms = ms % 1000
|
||||
if verbosity == 0:
|
||||
if years and y:
|
||||
duration = "%d:%03d:%02d:%02d:%02d" % (y, d, h, m, s)
|
||||
elif d:
|
||||
duration = "%d:%02d:%02d:%02d" % (d, h, m, s)
|
||||
elif hours or h:
|
||||
duration = "%02d:%02d:%02d" % (h, m, s)
|
||||
else:
|
||||
duration = "%02d:%02d" % (m, s)
|
||||
if milliseconds:
|
||||
duration += ".%03d" % ms
|
||||
else:
|
||||
if verbosity == 1:
|
||||
durations = ["%sd" % d, "%sh" % h, "%sm" % m, "%ss" % s]
|
||||
if years:
|
||||
durations.insert(0, "%sy" % y)
|
||||
if milliseconds:
|
||||
durations.append("%sms" % ms)
|
||||
else:
|
||||
durations = [plural(d, 'day'), plural(h,'hour'),
|
||||
plural(m, 'minute'), plural(s, 'second')]
|
||||
if years:
|
||||
durations.insert(0, plural(y, 'year'))
|
||||
if milliseconds:
|
||||
durations.append(plural(ms, 'millisecond'))
|
||||
durations = filter(lambda x: not x.startswith('0'), durations)
|
||||
duration = ' '.join(durations)
|
||||
return duration
|
||||
|
||||
def ms2runtime(ms, shortenLong=False):
|
||||
# deprecated - use format_duration
|
||||
'''
|
||||
>>> ms2runtime(5000)
|
||||
'5 seconds'
|
||||
>>> ms2runtime(500000)
|
||||
'8 minutes 20 seconds'
|
||||
>>> ms2runtime(50000000)
|
||||
'13 hours 53 minutes 20 seconds'
|
||||
>>> ms2runtime(50000000-20000)
|
||||
'13 hours 53 minutes'
|
||||
'''
|
||||
if shortenLong and ms > 1000 * 60 * 60 * 24 * 464:
|
||||
return format_duration(ms, verbosity=1, milliseconds=False)
|
||||
return format_duration(ms, verbosity=2, milliseconds=False)
|
||||
|
||||
def ms2playtime(ms, hours=False):
|
||||
# deprecated - use format_duration
|
||||
'''
|
||||
>>> ms2playtime(5000)
|
||||
'00:05'
|
||||
>>> ms2playtime(500000)
|
||||
'08:20'
|
||||
>>> ms2playtime(50000000)
|
||||
'13:53:20'
|
||||
'''
|
||||
return format_duration(ms, hours=False, years=False, milliseconds=False)
|
||||
|
||||
def ms2time(ms):
|
||||
# deprecated - use format_duration
|
||||
'''
|
||||
>>> ms2time(44592123)
|
||||
'12:23:12.123'
|
||||
'''
|
||||
return format_duration(ms, years=False)
|
||||
|
||||
def time2ms(timeString):
|
||||
'''
|
||||
>>> time2ms('12:23:12.123')
|
||||
44592123
|
||||
'''
|
||||
ms = 0.0
|
||||
p = timeString.split(':')
|
||||
for i in range(len(p)):
|
||||
_p = p[i]
|
||||
if _p.endswith('.'): _p =_p[:-1]
|
||||
ms = ms * 60 + float(_p)
|
||||
return int(ms * 1000)
|
||||
|
||||
def shift_time(offset, timeString):
|
||||
newTime = time2ms(timeString) + offset
|
||||
return ms2time(newTime)
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue