def select(self,type='VAV',subtype = ['RM STPT DIAL','ROOM TEMP'], floor = 0,nexp='', pattern ='{i}',cond = 'cmax(x,7)',maxn = 10, dtfilter = ''):
env = self._genv()
env.init()
l = env.getSensorsByType(type)
lname = []
for it in l:
k = it.split(':')
if floor != 0:
fl = int(k[0].split('.')[1])
if fl != floor:
continue
if nexp != '':
sname = k[0].split('.')[3]
if not fnmatch.fnmatch(sname,nexp):
continue
if k[1] in subtype:
lname.append((it,env.getSensorId(it)))
ltemp = sorted(lname,key=itemgetter(0))[:maxn]
filt = ''
i = 0
f = Formatter()
l = "{{%s}}"
f.format(l)
ns = ''
exp = []
i,m =0,len(ltemp)
loopi=0
while i < m:
h = f.parse(pattern)
for a,b,c,d in h :
ns += a
if b is not None :
ns += '{' + str(eval(b)) + '}'
i = eval(b)
loopi = max(i,loopi)
if cond != '':
ns += '.apply(lambda x:' + cond + ')'
if loopi < m-1:
ns += '; '
i = loopi + 1
cs = self.getSeries(ltemp,dtfilter)
re = self.getExpression(ltemp,ns, cs)
series = []
for name ,c in re:
dataserie = defaultdict()
json_s = c[['stime','svalue']].to_json(orient='values')
dataserie['name']=name
dataserie['data']=json_s
series.append(dataserie)
return series
def strfdelta(tdelta,
fmt='{D:02}d {H:02}h {M:02}m {S:02}s',
inputtype='timedelta'):
# convert time to our format
if inputtype == 'timedelta':
remainder = int(tdelta.total_seconds())
elif inputtype in ['s', 'seconds']:
remainder = int(tdelta)
elif inputtype in ['m', 'minutes']:
remainder = int(tdelta) * 60
elif inputtype in ['h', 'hours']:
remainder = int(tdelta) * 3600
elif inputtype in ['d', 'days']:
remainder = int(tdelta) * 86400
elif inputtype in ['w', 'weeks']:
remainder = int(tdelta) * 604800
f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ('W', 'D', 'H', 'M', 'S')
constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
values[field], remainder = divmod(remainder, constants[field])
return f.format(fmt, **values)
class DescriptionMapMethod(MapMethod):
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.formatter = Formatter()
self.translator = Translator()
def map(self, *args, **kwargs):
try:
template = self.additional_args["template"]
locale = kwargs["raw_ad"].feed_in.locale
# We take all keywords (no positional) and we translate them and then we create a dict
# eg:
# template = "That is an example {SALARY}: $ {0} in {COMPANY}: {1}"
# locale = "es_ar"
# translated_words = {"SALARY": "Salario", "COMPANY": "Compañía"}
#
translated_words = {
parse[1]: self.translator.translate(locale, parse[1],
"addesc_label")
for parse in self.formatter.parse(template)
if type(parse[1]) == str and not parse[1].isdigit()
}
addesc = self.formatter.format(template, *args, **translated_words)
return {"addesc": addesc}
except KeyError:
type_id = kwargs["raw_ad"].feed_in.feed_type.id if kwargs.get(
"raw_ad", None) else ""
msg = "El parámetro 'template' no se encuentra definido para " + type_id
raise FeedMappingException(msg)
def format(self, format_string, *args, **kwargs):
def escape_envvar(matchobj):
value = (x for x in matchobj.groups() if x is not None).next()
return "${{%s}}" % value
format_string_ = re.sub(self.ENV_VAR_REGEX, escape_envvar, format_string)
return Formatter.format(self, format_string_, *args, **kwargs)
def get(self,
key: Text,
count: Optional[int]=None,
formatter: Formatter=None,
**params) -> Text:
"""
Get the appropriate translation given the specified parameters.
:param key: Translation key
:param count: Count for plurals
:param formatter: Optional string formatter to use
:param params: Params to be substituted
"""
if count is not None:
raise TranslationError('Count parameter is not supported yet')
try:
out = self.dict[key]
except KeyError:
raise MissingTranslationError('Translation "{}" does not exist'
.format(key))
try:
if not formatter:
out = out.format(**params)
else:
out = formatter.format(out, **params)
except KeyError as e:
raise MissingParamError(
'Parameter "{}" missing to translate "{}"'
.format(e.args[0], key)
)
return out
def format(self, format_string, *args, **kwargs):
def escape_envvar(matchobj):
value = (x for x in matchobj.groups() if x is not None).next()
return "${{%s}}" % value
format_string_ = re.sub(self.ENV_VAR_REGEX, escape_envvar,
format_string)
return Formatter.format(self, format_string_, *args, **kwargs)
def strfdelta(tdelta, fmt):
f = Formatter()
d = {}
lst = {'H': 3600, 'M': 60, 'S': 1}
k = map(lambda x: x[1], list(f.parse(fmt)))
rem = int(tdelta.total_seconds())
for i in ('H', 'M', 'S'):
if i in k and i in lst.keys():
d[i], rem = divmod(rem, lst[i])
return f.format(fmt, **d)
def strfdelta(tdelta, fmt):
""" Get a string from a timedelta.
"""
f, d = Formatter(), {}
l = {"D": 86400, "H": 3600, "M": 60, "S": 1}
k = list(map(lambda x: x[1], list(f.parse(fmt))))
rem = int(tdelta.total_seconds())
for i in ("D", "H", "M", "S"):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
class TableCell():
def __init__(self, content=None):
self.content = content
self.fmtr = Formatter()
def __repr__(self):
return self.display()
def display(self):
""" type dependent string formatting """
if isinstance(self.content, UFloat):
return "{}".format(self.fmtr.format("{0:.1uS}", self.content))
elif isinstance(self.content, int):
return "{}".format(self.fmtr.format("{0:.0f}", self.content))
elif isinstance(self.content, float):
return "{}".format(self.fmtr.format("{0:.3f}", self.content))
elif isinstance(self.content, basestring):
return self.content
elif self.content is None:
return "None"
else:
return str(self.content)
def strfdelta(tdelta, fmt):
""" Get a string from a timedelta.
"""
f, d = Formatter(), {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
k = list(map(lambda x: x[1], list(f.parse(fmt))))
rem = int(tdelta.total_seconds())
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
def strfdelta(tdelta, fmt):
""" Get a string from a timedelta.
"""
f, d = Formatter(), {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
k = list(map(lambda x: x[1], list(f.parse(fmt))))
rem = int(tdelta.total_seconds())
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
def getTimeFromTdelta(tdelta, fmt):
f = Formatter()
d = {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
k = map(lambda x: x[1], list(f.parse(fmt)))
rem = int(tdelta.total_seconds())
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
def strfdelta(tdelta,
fmt='{D:02}d {H:02}h {M:02}m {S:02}s',
inputtype='timedelta'):
"""Convert a datetime.timedelta object or a regular number to a custom-
formatted string, just like the stftime() method does for datetime.datetime
objects.
The fmt argument allows custom formatting to be specified. Fields can
include seconds, minutes, hours, days, and weeks. Each field is optional.
Some examples:
'{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
'{W}w {D}d {H}:{M:02}:{S:02}' --> '4w 5d 8:04:02'
'{D:2}d {H:2}:{M:02}:{S:02}' --> ' 5d 8:04:02'
'{H}h {S}s' --> '72h 800s'
The inputtype argument allows tdelta to be a regular number instead of the
default, which is a datetime.timedelta object. Valid inputtype strings:
's', 'seconds',
'm', 'minutes',
'h', 'hours',
'd', 'days',
'w', 'weeks'
:param tdelta: time (in datetime or integer)
:param fmt: the desired format
:param inputtype: type of input
:return: formatted time
"""
# Convert tdelta to integer seconds.
if inputtype == 'timedelta':
remainder = int(tdelta.total_seconds())
elif inputtype in ['s', 'seconds']:
remainder = int(tdelta)
elif inputtype in ['m', 'minutes']:
remainder = int(tdelta) * 60
elif inputtype in ['h', 'hours']:
remainder = int(tdelta) * 3600
elif inputtype in ['d', 'days']:
remainder = int(tdelta) * 86400
elif inputtype in ['w', 'weeks']:
remainder = int(tdelta) * 604800
f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ('W', 'D', 'H', 'M', 'S')
constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
values[field], remainder = divmod(remainder, constants[field])
return f.format(fmt, **values)
def strfdelta(tdelta: datetime.timedelta, fmt: str) -> str:
f = Formatter()
d = {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
k = list(map(lambda x: x[1], list(f.parse(fmt))))
rem = int(tdelta.total_seconds())
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
def getNews(message):
# format is "$news site [number]", where number is the number
# of articles to return, because discord has a character limit
# of 2000. You could make it send multiple messages but whatever.
split_message = message.content.split(' ')
if len(split_message) < 2 or len(split_message) > 3 or News.isHelp(
split_message[1]):
return News.getHelp()
site = split_message[1]
try:
n = 5
if len(split_message) == 3:
n = int(split_message[2])
articles = News.getNewsList(site)[:n]
except (UnknownSiteError, IndexError):
sites = '\n'.join(News.sites.keys())
result = '**Valid sites are:**\n\n' + sites
return result
except ValueError:
result = '**Pick a valid number of results to return**'
return result
if not articles:
return '**Sorry, there are no articles!**'
formatter = Formatter()
responses = []
for i, article in enumerate(articles):
title = article['title']
author = ''
if 'author' in article.keys():
author = ' by ' + article['author']
link = article['link']
response = formatter.format("{num}. {_title}{_author} (<{link}>)", num=i+1, \
_title=title, _author=author, \
link=link)
responses.append(response)
result = '\n'.join(responses)
return result
class SimpleBar(object):
"""A minimal progress bar widget for stdout.
Displays a custom message to sys.stdout, and updates it in-place on demand.
"""
def __init__(self, message_str=None, max_width=80):
"""Create a SimpleBar with an optional message string.
Args:
message_str(str): An optional format string that is displayed and formatted
in every update operation.
max_width(int): The maximum width of the progress bar, message and all.
"""
self.formatter = Formatter()
if message_str:
self.message_str = message_str
self.max_width = max_width
def update_args(self, *args):
"""Display the appropriately updated progress message.
Args:
args: Formatter-style arguments for the format string.
"""
self.__restart_line()
print self.__pad_string(self.formatter.format(self.message_str, *args),
self.max_width),
def update(self, string, *args):
"""Update progress message and display with appropriate updates.
Args:
string (str): The format string for the message to be displayed.
args (optional arguments): Formatter-style arguments for the format string.
"""
self.message_str = string
self.update_args(*args)
def __restart_line(self):
"""Move cursor to the start of the current line immediately.
"""
sys.stdout.write('\r')
sys.stdout.flush()
def __pad_string(self, s, length):
"""Pad a string with trailing spaces to the given length.
"""
return s.ljust(length)
class TableCell():
def __init__(self, content=None):
self.content = content
self.fmtr = Formatter()
def __repr__(self):
return self.display()
def display(self):
""" type dependent string formatting """
if isinstance(self.content, UFloat):
return "{}".format(self.fmtr.format("{0:.1uS}", self.content))
elif isinstance(self.content, int):
return "{}".format(self.fmtr.format("{0:.0f}", self.content))
elif isinstance(self.content, float):
return "{}".format(self.fmtr.format("{0:.3f}", self.content))
elif isinstance(self.content, basestring):
return self.content
elif self.content is None:
return "None"
else:
return str(self.content)
def strfdelta(tdelta,
fmt="{D:02}d {H:02}h {M:02}m {S:02}s",
inputtype="timedelta"):
"""Convert a datetime.timedelta object or a regular number to a custom-
formatted string, just like the stftime() method does for datetime.datetime
objects.
The fmt argument allows custom formatting to be specified. Fields can
include seconds, minutes, hours, days, and weeks. Each field is optional.
Some examples:
'{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
'{W}w {D}d {H}:{M:02}:{S:02}' --> '4w 5d 8:04:02'
'{D:2}d {H:2}:{M:02}:{S:02}' --> ' 5d 8:04:02'
'{H}h {S}s' --> '72h 800s'
The inputtype argument allows tdelta to be a regular number instead of the
default, which is a datetime.timedelta object. Valid inputtype strings:
's', 'seconds',
'm', 'minutes',
'h', 'hours',
'd', 'days',
'w', 'weeks'
Credits: https://stackoverflow.com/a/42320260/4233693
"""
# Convert tdelta to integer seconds.
if inputtype == "timedelta":
remainder = int(tdelta.total_seconds())
elif inputtype in ["s", "seconds"]:
remainder = int(tdelta)
elif inputtype in ["m", "minutes"]:
remainder = int(tdelta) * 60
elif inputtype in ["h", "hours"]:
remainder = int(tdelta) * 3600
elif inputtype in ["d", "days"]:
remainder = int(tdelta) * 86400
elif inputtype in ["w", "weeks"]:
remainder = int(tdelta) * 604800
f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ("W", "D", "H", "M", "S")
constants = {"W": 604800, "D": 86400, "H": 3600, "M": 60, "S": 1}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
values[field], remainder = divmod(remainder, constants[field])
return f.format(fmt, **values)
def strfdelta(tdelta, fmt):
""" string representation of timedelta object.
Code from: https://stackoverflow.com/a/17847006
"""
f = Formatter()
d = {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
k = map(lambda x: x[1], list(f.parse(fmt)))
rem = int(tdelta.total_seconds())
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
def get(self,
key: Text,
count: Optional[int] = None,
formatter: Formatter = None,
locale: Text = None,
params: Optional[Dict[Text, Any]] = None,
flags: Optional[Flags] = None) -> List[Text]:
"""
Get the appropriate translation given the specified parameters.
:param key: Translation key
:param count: Count for plurals
:param formatter: Optional string formatter to use
:param locale: Prefered locale to get the string from
:param params: Params to be substituted
:param flags: Flags to help choosing one version or the other
"""
if params is None:
params = {}
if count is not None:
raise TranslationError('Count parameter is not supported yet')
locale = self.choose_locale(locale)
try:
group: SentenceGroup = self.dict[locale][key]
except KeyError:
raise MissingTranslationError(
'Translation "{}" does not exist'.format(key))
try:
trans = group.render(flags or {})
out = []
for line in trans:
if not formatter:
out.append(line.format(**params))
else:
out.append(formatter.format(line, **params))
except KeyError as e:
raise MissingParamError(
'Parameter "{}" missing to translate "{}"'.format(
e.args[0], key))
else:
return out
def strfdelta(tdelta, fmt=None):
from string import Formatter
if not fmt:
# The standard, most human readable format.
fmt = "{D} days {H:02} hours {M:02} minutes {S:02} seconds"
if tdelta == timedelta():
return "0 minutes"
formatter = Formatter()
return_map = {}
div_by_map = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
keys = map(lambda x: x[1], list(formatter.parse(fmt)))
remainder = int(tdelta.total_seconds())
for unit in ('D', 'H', 'M', 'S'):
if unit in keys and unit in div_by_map.keys():
return_map[unit], remainder = divmod(remainder, div_by_map[unit])
return formatter.format(fmt, **return_map)
def strfdelta(tdelta, fmt=None):
from string import Formatter
if not fmt:
# The standard, most human readable format.
fmt = "{D} days {H:02} hours {M:02} minutes {S:02} seconds"
if tdelta == timedelta():
return "0 minutes"
formatter = Formatter()
return_map = {}
div_by_map = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
keys = map(lambda x: x[1], list(formatter.parse(fmt)))
remainder = int(tdelta.total_seconds())
for unit in ('D', 'H', 'M', 'S'):
if unit in keys and unit in div_by_map.keys():
return_map[unit], remainder = divmod(remainder, div_by_map[unit])
return formatter.format(fmt, **return_map)
def getNews(message):
# format is "$news site [number]", where number is the number
# of articles to return, because discord has a character limit
# of 2000. You could make it send multiple messages but whatever.
split_message = message.content.split(' ')
if len(split_message) < 2 or len(split_message) > 3:
return News.getHelp()
site = split_message[1]
try:
n = 5
if len(split_message) == 3:
n = int(split_message[2])
articles = News.getNewsList(site)[:n]
except (UnknownSiteError, IndexError):
result = '**Valid sites are:** \n\nbleepingcomputer\ndarkreading'
return result
except ValueError:
result = '**Pick a valid number of results to return**'
return result
if not articles:
return '**Sorry, there are no articles posted today!**'
formatter = Formatter()
responses = []
today = date.today()
for i, article in enumerate(articles):
date_ = date.fromtimestamp(mktime(article['published_parsed']))
if today > date_:
break
response = formatter.format("{num}. {title} by {author} ({link})", num=i+1, \
title=article['title'], author=article['author'], \
link=article['link'])
responses.append(response)
result = '\n'.join(responses)
return result
def strfdelta(tdelta, fmt='{D:02}d {H:02}h {M:02}m {S:02}s', inputtype='timedelta'):
"""Convert a datetime.timedelta object or a regular number to a custom-
formatted string, just like the stftime() method does for datetime.datetime
objects.
The fmt argument allows custom formatting to be specified. Fields can
include seconds, minutes, hours, days, and weeks. Each field is optional.
Some examples:
'{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
'{W}w {D}d {H}:{M:02}:{S:02}' --> '4w 5d 8:04:02'
'{D:2}d {H:2}:{M:02}:{S:02}' --> ' 5d 8:04:02'
'{H}h {S}s' --> '72h 800s'
The inputtype argument allows tdelta to be a regular number instead of the
default, which is a datetime.timedelta object. Valid inputtype strings:
's', 'seconds',
'm', 'minutes',
'h', 'hours',
'd', 'days',
'w', 'weeks'
"""
# Convert tdelta to integer seconds.
if inputtype == 'timedelta':
remainder = int(tdelta.total_seconds())
elif inputtype in ['s', 'seconds']:
remainder = int(tdelta)
elif inputtype in ['m', 'minutes']:
remainder = int(tdelta)*60
elif inputtype in ['h', 'hours']:
remainder = int(tdelta)*3600
elif inputtype in ['d', 'days']:
remainder = int(tdelta)*86400
elif inputtype in ['w', 'weeks']:
remainder = int(tdelta)*604800
f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ('W', 'D', 'H', 'M', 'S')
constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
values[field], remainder = divmod(remainder, constants[field])
return f.format(fmt, **values)
def strfdelta(tdelta, fmt):
f = Formatter()
d = {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
k = map(lambda x: x[1], list(f.parse(fmt)))
rem = int(tdelta.total_seconds())
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(fmt, **d)
# Oddly, this did not work for me as written,
# I had to change map( lambda x: x[1], list(f.parse(fmt)))
# to list(map( lambda x: x[1], list(f.parse(fmt))))
def strfdelta(tsec,
format_str="P",
format_no_day="PT{H}H{M}M{S}S",
format_zero="PT0S"):
"""Formatting the time duration.
Duration ISO8601 format (PnYnMnDTnHnMnS): http://en.wikipedia.org/wiki/ISO_8601
Choosing the format P[nD]TnHnMnS where days is the total number of days (if not 0), 0 values may be omitted,
0 duration is PT0S
:param tsec: float, number of seconds
:param format_str: Format string, ISO 8601 is "P{D}DT{H}H{M}M{S}S". Default is a format string "P": will
use ISO 8601 but skip elements that have 0 value, e.g. P1H7S instead of P1H0M7S
:param format_no_day: Format string, ISO 8601, default "PT{H}H{M}M{S}S"
:param format_zero: format for when tsec is 0 or None, default "PT0S"
:return: Formatted time duration
"""
if not tsec:
# 0 or None
return format_zero
f = Formatter()
d = {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
rem = long(tsec)
if format_str == "P":
# variable format
if 0 < tsec < 86400:
format_str = "PT"
for i in ('D', 'H', 'M', 'S'):
if i in l.keys():
d[i], rem = divmod(rem, l[i])
if d[i] != 0:
format_str = "%s{%s}%s" % (format_str, i, i)
else:
if 0 < tsec < 86400:
format_str = format_no_day
k = map(lambda x: x[1], list(f.parse(format_str)))
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(format_str, **d)
def strfdelta(timedelta, fmt=STATS_TIMEDELTA_STR):
"""
Format a timedelta object in the given format.
"""
f = Formatter()
d = {}
lst = {"D": 86400, "H": 3600, "M": 60, "S": 1}
k = map(lambda x: x[1], list(f.parse(fmt)))
remainder = int(timedelta.total_seconds())
for i in ("D", "H", "M", "S"):
if i in k and i in lst.keys():
d[i], remainder = divmod(remainder, lst[i])
for key, value in d.items():
if value < 10 and "D" not in key:
d[key] = "0" + str(value)
return f.format(fmt, **d)
def strfdelta(tsec, format_str="P", format_no_day="PT{H}H{M}M{S}S", format_zero="PT0S"):
"""Formatting the time duration.
Duration ISO8601 format (PnYnMnDTnHnMnS): http://en.wikipedia.org/wiki/ISO_8601
Choosing the format P[nD]TnHnMnS where days is the total number of days (if not 0), 0 values may be omitted,
0 duration is PT0S
:param tsec: float, number of seconds
:param format_str: Format string, ISO 8601 is "P{D}DT{H}H{M}M{S}S". Default is a format string "P": will
use ISO 8601 but skip elements that have 0 value, e.g. P1H7S instead of P1H0M7S
:param format_no_day: Format string, ISO 8601, default "PT{H}H{M}M{S}S"
:param format_zero: format for when tsec is 0 or None, default "PT0S"
:return: Formatted time duration
"""
if not tsec:
# 0 or None
return format_zero
f = Formatter()
d = {}
l = {'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
rem = long(tsec)
if format_str == "P":
# variable format
if 0 < tsec < 86400:
format_str = "PT"
for i in ('D', 'H', 'M', 'S'):
if i in l.keys():
d[i], rem = divmod(rem, l[i])
if d[i] != 0:
format_str = "%s{%s}%s" % (format_str, i, i)
else:
if 0 < tsec < 86400:
format_str = format_no_day
k = map(lambda x: x[1], list(f.parse(format_str)))
for i in ('D', 'H', 'M', 'S'):
if i in k and i in l.keys():
d[i], rem = divmod(rem, l[i])
return f.format(format_str, **d)
def format(self, format_string, *args, **kwargs):
def escape_envvar(matchobj):
value = (x for x in matchobj.groups() if x is not None).next()
return "${{%s}}" % value
format_string_ = re.sub(self.ENV_VAR_REGEX, escape_envvar, format_string)
# for recursive formatting, where a field has a value we want to expand,
# add kwargs to namespace, so format_field can use them...
if kwargs:
prev_namespace = self.namespace
self.namespace = dict(prev_namespace)
self.namespace.update(kwargs)
else:
prev_namespace = None
try:
return Formatter.format(self, format_string_, *args, **kwargs)
finally:
if prev_namespace is not None:
self.namespace = prev_namespace
def format(self, format_string, *args, **kwargs):
def escape_envvar(matchobj):
value = (x for x in matchobj.groups() if x is not None).next()
return "${{%s}}" % value
format_string_ = re.sub(self.ENV_VAR_REGEX, escape_envvar, format_string)
# for recursive formatting, where a field has a value we want to expand,
# add kwargs to namespace, so format_field can use them...
if kwargs:
prev_namespace = self.namespace
self.namespace = dict(prev_namespace)
self.namespace.update(kwargs)
else:
prev_namespace = None
try:
return Formatter.format(self, format_string_, *args, **kwargs)
finally:
if prev_namespace is not None:
self.namespace = prev_namespace
def _tags_to_metric(self, tags):
"""
formats metric name and removes used items from tags
retruns tuple (new_metric_name, tags)
"""
f = Formatter()
#get keys from metric name
parsed = f.parse(self.name)
keymap = dict()
for tup in parsed:
if (tup[1]):
keymap[tup[1]] = True
if not keymap:
return (self.name, tags)
#create new metric string
metric = f.format(self.name, **tags)
#remove used tags
for i in keymap.keys():
del tags[i]
return (metric, tags)
def test_formatter(self):
"""
js_shell 'j.tools.memusagetest.test_formatter()'
"""
from string import Formatter
formatter = Formatter()
args = {"name": "MYNAME", "val": "AVAL", "n": 1.9998929}
# res = formatter.format(C,**args)
C = "{name!s:>10} {val} {n:<10.2f}" # floating point rounded to 2 decimals
# python doc: string.Formatter
j.tools.timer.start("formatter")
nritems = 100000
for i in range(nritems):
if "{" in C:
C2 = formatter.format(C, **args)
j.tools.timer.stop(nritems)
def compute_one_task(self, itask, task):
"""
Run the algorithm once, using the parameters specified by `task`,
which is the `itask` iteration
Parameters
----------
itask : int
the integer index of this task
task : tuple
a tuple of values representing this task value
"""
# if you are the pool's root, write out the temporary parameter file
this_config = None
if self.workers.subcomm.rank == 0:
# initialize a temporary file
with tempfile.NamedTemporaryFile(delete=False) as ff:
this_config = ff.name
logger.debug("creating temporary file: %s" %this_config)
# key/values for this task
if len(self.task_dims) == 1:
possible_kwargs = {self.task_dims[0] : task}
else:
possible_kwargs = dict(zip(self.task_dims, task))
# any extra key/value pairs for this tasks
if self.extras is not None:
for k in self.extras:
possible_kwargs[k] = self.extras[k][itask]
# use custom formatter that only formats the possible keys, ignoring other
# occurences of curly brackets
formatter = Formatter()
formatter.parse = lambda l: SafeStringParse(formatter, l, list(possible_kwargs))
kwargs = [kw for _, kw, _, _ in formatter.parse(self.template) if kw]
# do the string formatting if the key is present in template
valid = {k:possible_kwargs[k] for k in possible_kwargs if k in kwargs}
ff.write(formatter.format(self.template, **valid).encode())
# bcast the file name to all in the worker pool
this_config = self.workers.subcomm.bcast(this_config, root=0)
# configuration file passed via -c
params, extra = ReadConfigFile(open(this_config, 'r').read(), self.algorithm_class.schema)
# output is required
output = getattr(extra, 'output', None)
if output is None:
raise ValueError("argument `output` is required in config file")
# initialize the algorithm and run
alg = self.algorithm_class(**vars(params))
result = alg.run()
alg.save(output, result)
# remove temporary files
if self.workers.subcomm.rank == 0:
if os.path.exists(this_config):
logger.debug("removing temporary file: %s" %this_config)
os.remove(this_config)
return 0
class CpuUsage(IntervalModule, ColorRangeModule):
"""
Shows CPU usage.
The first output will be inacurate.
Linux only
Requires the PyPI package 'colour'.
.. rubric:: Available formatters
* `{usage}` — usage average of all cores
* `{usage_cpu*}` — usage of one specific core. replace "*" by core number starting at 0
* `{usage_all}` — usage of all cores separate. usess natsort when available(relevant for more than 10 cores)
"""
format = "{usage:02}%"
format_all = "{core}:{usage:02}%"
exclude_average = False
interval = 1
color = None
dynamic_color = False
upper_limit = 100
settings = (
("format", "format string."),
("format_all", ("format string used for {usage_all} per core. "
"Available formaters are {core} and {usage}. ")),
("exclude_average", ("If True usage average of all cores will "
"not be in format_all.")),
("color", "HTML color code #RRGGBB"),
("dynamic_color", "Set color dynamically based on CPU usage. Note: this overrides color_up"),
("start_color", "Hex or English name for start of color range, eg '#00FF00' or 'green'"),
("end_color", "Hex or English name for end of color range, eg '#FF0000' or 'red'")
)
def init(self):
self.prev_total = defaultdict(int)
self.prev_busy = defaultdict(int)
self.formatter = Formatter()
self.key = re.findall('usage_cpu\d+', self.format)
if len(self.key) == 1:
self.key = self.key[0]
else:
self.key = 'usage_cpu'
if not self.color:
self.color = '#FFFFFF'
if not self.dynamic_color:
self.start_color = self.color
self.end_color = self.color
self.colors = self.get_hex_color_range(self.start_color, self.end_color, int(self.upper_limit))
def get_cpu_timings(self):
"""
reads and parses /proc/stat
returns dictionary with all available cores including global average
"""
timings = {}
with open('/proc/stat', 'r') as file_obj:
for line in file_obj:
if 'cpu' in line:
line = line.strip().split()
timings[line[0]] = [int(x) for x in line[1:]]
return timings
def calculate_usage(self, cpu, total, busy):
"""
calculates usage
"""
diff_total = total - self.prev_total[cpu]
diff_busy = busy - self.prev_busy[cpu]
self.prev_total[cpu] = total
self.prev_busy[cpu] = busy
if diff_total == 0:
return 0
else:
return int(diff_busy / diff_total * 100)
def gen_format_all(self, usage):
"""
generates string for format all
"""
format_string = " "
core_strings = []
for core, usage in usage.items():
if core == 'usage_cpu' and self.exclude_average:
continue
elif core == 'usage':
continue
core = core.replace('usage_', '')
string = self.formatter.format(format_string=self.format_all,
core=core,
usage=usage)
core_strings.append(string)
core_strings = sorted(core_strings)
return format_string.join(core_strings)
def get_usage(self):
"""
parses /proc/stat and calcualtes total and busy time
(more specific USER_HZ see man 5 proc for further informations )
"""
usage = {}
for cpu, timings in self.get_cpu_timings().items():
cpu_total = sum(timings)
del timings[3:5]
cpu_busy = sum(timings)
cpu_usage = self.calculate_usage(cpu, cpu_total, cpu_busy)
usage['usage_' + cpu] = cpu_usage
# for backward compatibility
usage['usage'] = usage['usage_cpu']
return usage
def run(self):
usage = self.get_usage()
usage['usage_all'] = self.gen_format_all(usage)
color = self.get_gradient(usage[self.key], self.colors, int(self.upper_limit))
self.data = usage
self.output = {
"full_text": self.format.format_map(usage),
"color": color
}
def format(self, format_string, *args, **kwargs):
self.caller = sys._getframe(self.level)
return Formatter.format(self, format_string, *args, **kwargs)
class CpuUsage(IntervalModule):
"""
Shows CPU usage.
The first output will be inacurate.
Linux only
.. rubric:: Available formatters
* `{usage}` — usage average of all cores
* `{usage_cpu*}` — usage of one specific core. replace "*" by core number starting at 0
* `{usage_all}` — usage of all cores separate. usess natsort when available(relevant for more than 10 cores)
"""
format = "{usage:02}%"
format_all = "{core}:{usage:02}%"
exclude_average = False
interval = 1
color = None
settings = (
("format", "format string."),
("format_all", ("format string used for {usage_all} per core. "
"Available formaters are {core} and {usage}. ")),
("exclude_average", ("If True usage average of all cores will "
"not be in format_all.")),
("color", "HTML color code #RRGGBB")
)
def init(self):
self.prev_total = defaultdict(int)
self.prev_busy = defaultdict(int)
self.formatter = Formatter()
def get_cpu_timings(self):
"""
reads and parses /proc/stat
returns dictionary with all available cores including global average
"""
timings = {}
with open('/proc/stat', 'r') as file_obj:
for line in file_obj:
if 'cpu' in line:
line = line.strip().split()
timings[line[0]] = [int(x) for x in line[1:]]
return timings
def calculate_usage(self, cpu, total, busy):
"""
calculates usage
"""
diff_total = total - self.prev_total[cpu]
diff_busy = busy - self.prev_busy[cpu]
self.prev_total[cpu] = total
self.prev_busy[cpu] = busy
if diff_total == 0:
return 0
else:
return int(diff_busy / diff_total * 100)
def gen_format_all(self, usage):
"""
generates string for format all
"""
format_string = " "
core_strings = []
for core, usage in usage.items():
if core == 'usage_cpu' and self.exclude_average:
continue
elif core == 'usage':
continue
core = core.replace('usage_', '')
string = self.formatter.format(format_string=self.format_all,
core=core,
usage=usage)
core_strings.append(string)
core_strings = sorted(core_strings)
return format_string.join(core_strings)
def get_usage(self):
"""
parses /proc/stat and calcualtes total and busy time
(more specific USER_HZ see man 5 proc for further informations )
"""
usage = {}
for cpu, timings in self.get_cpu_timings().items():
cpu_total = sum(timings)
del timings[3:5]
cpu_busy = sum(timings)
cpu_usage = self.calculate_usage(cpu, cpu_total, cpu_busy)
usage['usage_' + cpu] = cpu_usage
return usage
def run(self):
usage = self.get_usage()
usage['usage_all'] = self.gen_format_all(usage)
# for backward compatibility
usage['usage'] = usage['usage_cpu']
self.data = usage
self.output = {
"full_text": self.format.format_map(usage),
"color": self.color
}
def getImgTiles(xargs):
#pdb.set_trace()
in_dirs = ['gt', 'img']
in_datapath = os.path.abspath(xargs.indir)
if (xargs.train):
out_dirs = ['trainannot', 'train']
if (xargs.valid):
out_dirs = ['validannot', 'valid']
out_datapath = os.path.abspath(xargs.outdir + '/' + str(xargs.ph) + 'x' +
str(xargs.pw))
stride = xargs.step
ph = xargs.ph
pw = xargs.pw
fmt = Formatter()
for i_dir, o_dir in zip(in_dirs, out_dirs):
in_dir = os.path.join(in_datapath, i_dir)
out_dir = os.path.join(out_datapath, o_dir)
try:
os.stat(out_dir)
except:
os.makedirs(out_dir)
onlyfiles = sorted(
[f for f in listdir(in_dir) if isfile(join(in_dir, f))])
#pdb.set_trace()
for fil in onlyfiles:
print(" ====== Processing: %s ======" % fil)
in_fileName = os.path.join(in_dir, fil)
res = cv2.imread(in_fileName)
img = cv2.resize(res,
None,
fx=xargs.scale,
fy=xargs.scale,
interpolation=cv2.INTER_CUBIC)
if (xargs.gray):
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
if (img.shape[0] < ph or img.shape[1] < pw):
print("dimensions of file %s are smaller" % (in_fileName))
continue
if (i_dir == 'img' and len(img.shape) == 2):
img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
hstride = float(stride)
wstride = (pw * float(stride) / ph)
h_strides = int(np.ceil((img.shape[0] - ph) / hstride))
w_strides = int(np.ceil((img.shape[1] - pw) / wstride))
hrange = range(0, h_strides * int(hstride), int(hstride))
wrange = range(0, w_strides * int(wstride), int(wstride))
# collect patches_ta
patch_idx = 1
fname, ext = fil.split('.')
for h in hrange:
for w in wrange:
# print(h, w, img.shape[2], img.shape[3])
if (len(img.shape) > 2):
patch_ta = img[h:h + ph, w:w + pw, :]
else:
patch_ta = img[h:h + ph, w:w + pw]
#print("file %s: idx:%d" % (fil,patch_idx))
#pdb.set_trace()
out_fileName = os.path.join(
out_dir, fname + '_' + fmt.format("%04d" % patch_idx) +
'.' + ext)
cv2.imwrite(out_fileName, patch_ta)
patch_idx += 1
# Column boundary patches
if (len(img.shape) > 2):
patch_ta = img[h:h + ph, -pw:, :]
else:
patch_ta = img[h:h + ph, -pw:]
out_fileName = os.path.join(
out_dir,
fname + '_' + fmt.format("%04d" % patch_idx) + '.' + ext)
cv2.imwrite(out_fileName, patch_ta)
patch_idx += 1
# Row boundary patches
for w in wrange:
# print(h, w, img.shape[2], img.shape[3])
if (len(img.shape) > 2):
patch_ta = img[-ph:, w:w + pw, :]
else:
patch_ta = img[-ph:, w:w + pw]
out_fileName = os.path.join(
out_dir,
fname + '_' + fmt.format("%04d" % patch_idx) + '.' + ext)
cv2.imwrite(out_fileName, patch_ta)
patch_idx += 1
if (len(img.shape) > 2):
patch_ta = img[-ph:, -pw:, :]
else:
patch_ta = img[-ph:, -pw:]
out_fileName = os.path.join(
out_dir,
fname + '_' + fmt.format("%04d" % patch_idx) + '.' + ext)
cv2.imwrite(out_fileName, patch_ta)
patch_idx += 1
class CpuUsage(IntervalModule):
"""
Shows CPU usage.
The first output will be inacurate.
Linux only
.. rubric:: Available formatters
* `{usage}` — usage average of all cores
* `{usage_cpu*}` — usage of one specific core. replace "*" by core number starting at 0
* `{usage_all}` — usage of all cores separate. usess natsort when available(relevant for more than 10 cores)
"""
format = "{usage:02}%"
format_all = "{core}:{usage:02}%"
exclude_average = False
interval = 1
color = None
settings = (("format", "format string."),
("format_all",
("format string used for {usage_all} per core. "
"Available formaters are {core} and {usage}. ")),
("exclude_average", ("If True usage average of all cores will "
"not be in format_all.")),
("color", "HTML color code #RRGGBB"))
def init(self):
self.prev_total = defaultdict(int)
self.prev_busy = defaultdict(int)
self.formatter = Formatter()
def get_cpu_timings(self):
"""
reads and parses /proc/stat
returns dictionary with all available cores including global average
"""
timings = {}
with open('/proc/stat', 'r') as file_obj:
for line in file_obj:
if 'cpu' in line:
line = line.strip().split()
timings[line[0]] = [int(x) for x in line[1:]]
return timings
def calculate_usage(self, cpu, total, busy):
"""
calculates usage
"""
diff_total = total - self.prev_total[cpu]
diff_busy = busy - self.prev_busy[cpu]
self.prev_total[cpu] = total
self.prev_busy[cpu] = busy
if diff_total == 0:
return 0
else:
return int(diff_busy / diff_total * 100)
def gen_format_all(self, usage):
"""
generates string for format all
"""
format_string = " "
core_strings = []
for core, usage in usage.items():
if core == 'usage_cpu' and self.exclude_average:
continue
elif core == 'usage':
continue
core = core.replace('usage_', '')
string = self.formatter.format(format_string=self.format_all,
core=core,
usage=usage)
core_strings.append(string)
core_strings = sorted(core_strings)
return format_string.join(core_strings)
def get_usage(self):
"""
parses /proc/stat and calcualtes total and busy time
(more specific USER_HZ see man 5 proc for further informations )
"""
usage = {}
for cpu, timings in self.get_cpu_timings().items():
cpu_total = sum(timings)
del timings[3:5]
cpu_busy = sum(timings)
cpu_usage = self.calculate_usage(cpu, cpu_total, cpu_busy)
usage['usage_' + cpu] = cpu_usage
# for backward compatibility
usage['usage'] = usage['usage_cpu']
return usage
def run(self):
usage = self.get_usage()
usage['usage_all'] = self.gen_format_all(usage)
self.data = usage
self.output = {
"full_text": self.format.format_map(usage),
"color": self.color
}
def strfdelta(tdelta: Union[datetime.timedelta, int, float, str],
fmt='{D:02}d {H:02}h {M:02}m {S:02}s',
inputtype='timedelta'):
"""
Convert a ``datetime.timedelta`` object or a regular number to a custom-
formatted string, just like the ``strftime()`` method does for
``datetime.datetime`` objects.
The ``fmt`` argument allows custom formatting to be specified. Fields can
include ``seconds``, ``minutes``, ``hours``, ``days``, and ``weeks``. Each
field is optional.
Some examples:
.. code-block:: none
'{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
'{W}w {D}d {H}:{M:02}:{S:02}' --> '4w 5d 8:04:02'
'{D:2}d {H:2}:{M:02}:{S:02}' --> ' 5d 8:04:02'
'{H}h {S}s' --> '72h 800s'
The ``inputtype`` argument allows ``tdelta`` to be a regular number,
instead of the default behaviour of treating it as a ``datetime.timedelta``
object. Valid ``inputtype`` strings:
.. code-block:: none
'timedelta', # treats input as a datetime.timedelta
's', 'seconds',
'm', 'minutes',
'h', 'hours',
'd', 'days',
'w', 'weeks'
Modified from
https://stackoverflow.com/questions/538666/python-format-timedelta-to-string
""" # noqa
# Convert tdelta to integer seconds.
if inputtype == 'timedelta':
remainder = int(tdelta.total_seconds())
elif inputtype in ['s', 'seconds']:
remainder = int(tdelta)
elif inputtype in ['m', 'minutes']:
remainder = int(tdelta) * 60
elif inputtype in ['h', 'hours']:
remainder = int(tdelta) * 3600
elif inputtype in ['d', 'days']:
remainder = int(tdelta) * 86400
elif inputtype in ['w', 'weeks']:
remainder = int(tdelta) * 604800
else:
raise ValueError(f"Bad inputtype: {inputtype}")
f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ('W', 'D', 'H', 'M', 'S')
constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
values[field], remainder = divmod(remainder, constants[field])
return f.format(fmt, **values)
def write_output_file(document_tokens, mae_file_name):
print("========== Write " + mae_file_name)
with codecs.open(mae_file_name, WRITING_MODE,
CODEC) as file_handler:
'''
<?xml version="1.0" encoding="UTF-8" ?>
<PartML>
<TEXT><![CDATA[
...
]]></TEXT>
<TAGS>
<SELECTOR id="s1" start="278" end="282" text="fill" comment="" pos="VERB" />
<SELECTOR id="s2" start="297" end="303" text="search" comment="" pos="ADJ" />
...
<NOUN id="n1" start="287" end="291" text="void" comment="" />
<NOUN id="n2" start="304" end="309" text="giant" comment="" />
...
<QLINK id="q0" fromID="s1" fromText="fill" toID="n1" toText="void" comment="" qType="" qType2="" gramRel="" />
<QLINK id="q1" fromID="n2" fromText="giant" toID="s2" toText="search" comment="" qType="" qType2="" gramRel="" />
...
</TAGS>
</PartML>
'''
text = ''
length = 1
relation_included = ['dobj', 'iobj', 'nsubjpass']
verb_nouns = []
verb_alphabet = Alphabet()
noun_alphabet = Alphabet()
for sentence_tokens in document_tokens:
for token_structure in sentence_tokens:
token = token_structure.token
token_structure.start = length
token_structure.end = length + len(token)
if token_structure.rel in relation_included:
# Add into alphabets
head_rel_index = int(token_structure.head) - 1
# print(sentence_tokens[head_rel_index])
# print(token_structure)
verb_alphabet.add(sentence_tokens[head_rel_index])
sentence_tokens[
head_rel_index].id = verb_alphabet.get_index(
sentence_tokens[head_rel_index])
noun_alphabet.add(token_structure)
token_structure.id = noun_alphabet.get_index(
token_structure)
verb_nouns.append(
(sentence_tokens[head_rel_index].id,
token_structure.id, token_structure.rel))
text += token + ' '
length += len(token) + 1
text += '\n'
length += 1
file_handler.write('<?xml version="1.0" encoding="UTF-8" ?>')
file_handler.write('\n')
file_handler.write('<PartML>')
file_handler.write('\n')
file_handler.write('<TEXT><![CDATA[')
file_handler.write('\n')
file_handler.write(text)
file_handler.write(']]></TEXT>')
file_handler.write('\n')
file_handler.write('<TAGS>')
file_handler.write('\n')
formatter = Formatter()
for verb_structure_index in range(verb_alphabet.size()):
verb_structure = verb_alphabet.get_label(
verb_structure_index)
file_handler.write(
formatter.format(
'<SELECTOR id="s{0.id}" start="{0.start}" end="{0.end}" text="{0.token}" comment="" pos="{0.POS}" />',
verb_structure))
file_handler.write('\n')
for noun_structure_index in range(noun_alphabet.size()):
noun_structure = noun_alphabet.get_label(
noun_structure_index)
file_handler.write(
formatter.format(
'<NOUN id="n{0.id}" start="{0.start}" end="{0.end}" text="{0.token}" comment="" />',
noun_structure))
file_handler.write('\n')
for index in range(len(verb_nouns)):
verb_structure_index, noun_structure_index, rel = verb_nouns[
index]
verb_structure = verb_alphabet.get_label(
verb_structure_index)
noun_structure = noun_alphabet.get_label(
noun_structure_index)
file_handler.write(
formatter.format(
'<QLINK id="q{0}" fromID="s{1.id}" fromText="{1.token}" toID="n{2.id}" toText="{2.token}" comment="" qType="{3}" qType2="" gramRel="{4}" />',
index, verb_structure, noun_structure, 'FORMAL',
rel))
file_handler.write('\n')
file_handler.write('</TAGS>')
file_handler.write('\n')
file_handler.write('</PartML>')
file_handler.write('\n')
import string
# string module constants
print(string.ascii_letters)
print(string.ascii_lowercase)
print(string.ascii_uppercase)
print(string.digits)
print(string.hexdigits)
print(string.whitespace) # ' \t\n\r\x0b\x0c'
print(string.punctuation)
s = ' Welcome TO \n\n JournalDev '
print(string.capwords(s))
from string import Formatter
formatter = Formatter()
print(formatter.format('{website}', website='JournalDev'))
print(formatter.format('{} {website}', 'Welcome to', website='JournalDev'))
print('{} {website}'.format('Welcome to', website='JournalDev'))
from string import Template
t = Template('$name is the $title of $company')
s = t.substitute(name='Pankaj', title='Founder', company='JournalDev.')
print(s)
def format(self, format_string, *args, **kwargs):
self.caller = sys._getframe(self.level)
return Formatter.format(self, format_string, *args, **kwargs)
def strfdelta(tdelta,
fmt='{D:02}d {H:02}h {M:02}m {S:02}s',
input_type='timedelta'):
"""
Convert a datetime.timedelta object or a regular number to a custom-formatted string.
This function works like the strftime() method works for datetime.datetime
objects.
The fmt argument allows custom formatting to be specified. Fields can
include seconds, minutes, hours, days, and weeks. Each field is optional.
Arguments:
tdelta (datetime.timedelta, int): time delta object containing the duration or an integer
to go with the input_type.
fmt (str): Expected format of the time delta. place holders can only be one of the following.
1. D to extract days from time delta
2. H to extract hours from time delta
3. M to extract months from time delta
4. S to extract seconds from timedelta
input_type (str): The input_type argument allows tdelta to be a regular number instead of the
default, which is a datetime.timedelta object.
Valid input_type strings:
1. 's', 'seconds',
2. 'm', 'minutes',
3. 'h', 'hours',
4. 'd', 'days',
5. 'w', 'weeks'
Returns:
(str): timedelta object interpolated into a string following the given format.
Examples:
'{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
'{W}w {D}d {H}:{M:02}:{S:02}' --> '4w 5d 8:04:02'
'{D:2}d {H:2}:{M:02}:{S:02}' --> ' 5d 8:04:02'
'{H}h {S}s' --> '72h 800s'
"""
# Convert tdelta to integer seconds.
if input_type == 'timedelta':
remainder = int(tdelta.total_seconds())
elif input_type in ['s', 'seconds']:
remainder = int(tdelta)
elif input_type in ['m', 'minutes']:
remainder = int(tdelta) * 60
elif input_type in ['h', 'hours']:
remainder = int(tdelta) * 3600
elif input_type in ['d', 'days']:
remainder = int(tdelta) * 86400
elif input_type in ['w', 'weeks']:
remainder = int(tdelta) * 604800
else:
raise ValueError(
'input_type is not valid. Valid input_type strings are: "timedelta", "s", "m", "h", "d", "w"'
)
f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ('W', 'D', 'H', 'M', 'S')
constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
values[field], remainder = divmod(remainder, constants[field])
return f.format(fmt, **values)
