def __date_increment_function(self):
switcher = {
'day': lambda d: d + relativedelta(days = 1),
'week':lambda d: d + relativedelta(weeks = 1),
'month': lambda d: d + relativedelta(months = 1),
'year': lambda d: d + relativedelta(years = 1)
}
return switcher.get(self.quantum, switcher.get('month'))
def proc_day_of_week(d):
if expanded[4][0] != '*':
diff_day_of_week = nearest_diff_method(d.isoweekday() % 7, expanded[4], 7)
if diff_day_of_week != None and diff_day_of_week != 0:
if is_prev:
d += relativedelta(days=diff_day_of_week)
else:
d += relativedelta(days=diff_day_of_week, hour=0, minute=0, second=0)
return True, d
return False, d
def proc_hour(d):
if expanded[1][0] != '*':
diff_hour = nearest_diff_method(d.hour, expanded[1], 24)
if diff_hour != None and diff_hour != 0:
if is_prev:
d += relativedelta(hours = diff_hour)
else:
d += relativedelta(hours = diff_hour, minute=0, second=0)
return True, d
return False, d
def proc_second(d):
if len(expanded) == 6:
if expanded[5][0] != '*':
diff_sec = nearest_diff_method(d.second, expanded[5], 60)
if diff_sec != None and diff_sec != 0:
dst += relativedelta(seconds = diff_sec)
return True, d
else:
d += relativedelta(second = 0)
return False, d
def proc_minute(d):
if expanded[0][0] != '*':
diff_min = nearest_diff_method(d.minute, expanded[0], 60)
if diff_min != None and diff_min != 0:
if is_prev:
d += relativedelta(minutes=diff_min)
else:
d += relativedelta(minutes=diff_min, second=0)
return True, d
return False, d
def proc_second(d):
if len(expanded) == 6:
if expanded[5][0] != '*':
diff_sec = nearest_diff_method(d.second, expanded[5], 60)
if diff_sec != None and diff_sec != 0:
dst += relativedelta(seconds=diff_sec)
return True, d
else:
d += relativedelta(second=0)
return False, d
def proc_hour(d):
if expanded[1][0] != '*':
diff_hour = nearest_diff_method(d.hour, expanded[1], 24)
if diff_hour != None and diff_hour != 0:
if is_prev:
d += relativedelta(hours=diff_hour)
else:
d += relativedelta(hours=diff_hour, minute=0, second=0)
return True, d
return False, d
def proc_day_of_week(d):
if expanded[4][0] != '*':
diff_day_of_week = nearest_diff_method(d.isoweekday() % 7, expanded[4], 7)
if diff_day_of_week != None and diff_day_of_week != 0:
if is_prev:
d += relativedelta(days=diff_day_of_week)
else:
d += relativedelta(days=diff_day_of_week, hour=0, minute=0, second=0)
return True, d
return False, d
def proc_minute(d):
if expanded[0][0] != '*':
diff_min = nearest_diff_method(d.minute, expanded[0], 60)
if diff_min != None and diff_min != 0:
if is_prev:
d += relativedelta(minutes = diff_min)
else:
d += relativedelta(minutes = diff_min, second=0)
return True, d
return False, d
def proc_day_of_month(d):
if expanded[2][0] != '*':
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
diff_day = nearest_diff_method(d.day, expanded[2], days)
if diff_day != None and diff_day != 0:
if is_prev:
d += relativedelta(days=diff_day)
else:
d += relativedelta(days=diff_day, hour=0, minute=0, second=0)
return True, d
return False, d
def proc_day_of_month(d):
if expanded[2][0] != '*':
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
diff_day = nearest_diff_method(d.day, expanded[2], days)
if diff_day != None and diff_day != 0:
if is_prev:
d += relativedelta(days=diff_day)
else:
d += relativedelta(days=diff_day, hour=0, minute=0, second=0)
return True, d
return False, d
def relative_time(date):
delta = relativedelta.relativedelta(datetime.datetime.now(), date)
if delta.years == 1:
time = 'about 1 year ago'
elif delta.years > 1:
time = 'about %s years ago' % delta.years
elif delta.months == 1:
time = 'about 1 month ago'
elif delta.months > 1:
time = 'about %s months ago' % delta.months
elif delta.days == 1:
time = 'about 1 day ago'
elif delta.days > 1:
time = 'about %s days ago' % delta.days
elif delta.hours == 1:
time = 'about 1 hour ago'
elif delta.hours > 1:
time = 'about %s hours ago' % delta.hours
elif delta.minutes > 1:
time = '%s minutes ago' % delta.minutes
else:
time = 'recently'
return time
def _calculate_age(dob: str) -> str:
"""
Calculate someone's age given their date-of-birth.
Args:
dob: The date of birth, formatted as yyyy-mm-dd.
Returns:
str: A text description of the person's age.
"""
# Catch problems
try:
# Make sure the date-of-birth is formatted ok.
birth_date = datetime.datetime.strptime(dob, "%Y-%m-%d")
# Find today's date
today = datetime.datetime.today()
# Calculate difference
age = relativedelta(today, birth_date).years
return f" (aged {age})"
# Parse problem -- ignore it
except ValueError:
return ""
def __generate_dir(self, start_time, end_time, path='.'):
'''
生成该段时间内的文件夹，若文件夹已存在，则跳过
:param start_time: 开始时间
:param end_time: 结束时间
:return:
'''
# todo will generate mouth_list by start_time and end_times
# todo 处理20140701为201407
short_start_time = start_time[0:6]
short_end_time = end_time[0:6]
format_str = "%Y%m" # 这样就足够了
start_date = datetime.datetime.strptime(short_start_time, format_str)
end_date = datetime.datetime.strptime(short_end_time, format_str)
print start_date, end_date
# todo generate month name list
month_delta = relativedelta(months=1)
# todo 用dir name list 来生成文件夹，首先要判断文件夹是否存在，存在就跳过，也就是continue，若不存在就创建
month_list = []
while start_date <= end_date:
dir_name = start_date.strftime(format_str)
dir_path = os.path.join(path, dir_name)
if not self.__dir_exist(dir_path):
os.mkdir(dir_path)
month_list.append(dir_path)
start_date = start_date + month_delta
return month_list
def proc_month(d):
if expanded[3][0] != '*':
diff_month = nearest_diff_method(month, expanded[3], 12)
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
reset_day = days if is_prev else 1
if diff_month != None and diff_month != 0:
if is_prev:
d += relativedelta(months=diff_month)
else:
d += relativedelta(months=diff_month, day=reset_day,
hour=0, minute=0, second=0)
return True, d
return False, d
def proc_month(d):
if expanded[3][0] != '*':
diff_month = nearest_diff_method(month, expanded[3], 12)
days = DAYS[month - 1]
if month == 2 and self.is_leap(year) == True:
days += 1
reset_day = days if is_prev else 1
if diff_month != None and diff_month != 0:
if is_prev:
d += relativedelta(months=diff_month)
else:
d += relativedelta(months=diff_month, day=reset_day,
hour=0, minute=0, second=0)
return True, d
return False, d
def parse(self,
timestr,
default=None,
ignoretz=False,
tzinfos=None,
**kwargs):
if not default:
default = datetime.datetime.now().replace(hour=0,
minute=0,
second=0,
microsecond=0)
res = self._parse(timestr, **kwargs)
if res is None:
raise ValueError, "unknown string format"
repl = {}
for attr in [
"year", "month", "day", "hour", "minute", "second",
"microsecond"
]:
value = getattr(res, attr)
if value is not None:
repl[attr] = value
ret = default.replace(**repl)
if res.weekday is not None and not res.day:
ret = ret + relativedelta.relativedelta(weekday=res.weekday)
if not ignoretz:
if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
if callable(tzinfos):
tzdata = tzinfos(res.tzname, res.tzoffset)
else:
tzdata = tzinfos.get(res.tzname)
if isinstance(tzdata, datetime.tzinfo):
tzinfo = tzdata
elif isinstance(tzdata, basestring):
tzinfo = tz.tzstr(tzdata)
elif isinstance(tzdata, int):
tzinfo = tz.tzoffset(res.tzname, tzdata)
else:
raise ValueError, "offset must be tzinfo subclass, " \
"tz string, or int offset"
ret = ret.replace(tzinfo=tzinfo)
elif res.tzname and res.tzname in time.tzname:
ret = ret.replace(tzinfo=tz.tzlocal())
elif res.tzoffset == 0:
ret = ret.replace(tzinfo=tz.tzutc())
elif res.tzoffset:
ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
return ret
def get_history(self, symbol, months):
current_data = datetime.now()
start = datetime.now() - relativedelta(months=months)
start = start.strftime("%Y-%m-%d")
end = current_data.strftime("%Y-%m-%d")
request = '/v1/markets/history?symbol={0}&interval=daily&start={1}&end={2}'.format(
symbol, start, end)
self.connection.request('GET', request, None, self.headers)
try:
response = self.connection.getresponse()
return response
except client.HTTPException:
return 'Exception'
def relative_time(date):
delta = relativedelta.relativedelta(date.today(), date)
if delta.years == 1:
time = 'Il y a environ 1 an'
elif delta.years > 1:
time = 'Il y a environ %s ans' % delta.years
elif delta.months == 1:
time = 'Il y a environ 1 mois'
elif delta.months > 1:
time = 'Il y a environ %s mois' % delta.months
elif delta.days == 1:
time = "Hier"
elif delta.days > 1:
time = 'Il y a %s jours' % delta.days
else:
time = 'Aujourd\'hui'
return time
def relative_time(date):
delta = relativedelta.relativedelta(date.today(), date)
if delta.years == 1:
time = 'Il y a environ 1 an'
elif delta.years > 1:
time = 'Il y a environ %s ans' % delta.years
elif delta.months == 1:
time = 'Il y a environ 1 mois'
elif delta.months > 1:
time = 'Il y a environ %s mois' % delta.months
elif delta.days == 1:
time = "Hier"
elif delta.days > 1:
time = 'Il y a %s jours' % delta.days
else:
time = 'Aujourd\'hui'
return time
def parse(self, timestr, default=None,
ignoretz=False, tzinfos=None,
pastweekdays=False,
**kwargs):
if not default:
default = datetime.datetime.now().replace(hour=0, minute=0,
second=0, microsecond=0)
res = self._parse(timestr, **kwargs)
if res is None:
raise ValueError, "unknown string format"
repl = {}
for attr in ["year", "month", "day", "hour",
"minute", "second", "microsecond"]:
value = getattr(res, attr)
if value is not None:
repl[attr] = value
ret = default.replace(**repl)
if res.weekday is not None and not res.day:
wd = relativedelta.weekdays[res.weekday](pastweekdays and -1 or +1)
ret = ret+relativedelta.relativedelta(weekday=wd)
if not ignoretz:
if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
if callable(tzinfos):
tzdata = tzinfos(res.tzname, res.tzoffset)
else:
tzdata = tzinfos.get(res.tzname)
if isinstance(tzdata, datetime.tzinfo):
tzinfo = tzdata
elif isinstance(tzdata, basestring):
tzinfo = tz.tzstr(tzdata)
elif isinstance(tzdata, int):
tzinfo = tz.tzoffset(res.tzname, tzdata)
else:
raise ValueError, "offset must be tzinfo subclass, " \
"tz string, or int offset"
ret = ret.replace(tzinfo=tzinfo)
elif res.tzname and res.tzname in time.tzname:
ret = ret.replace(tzinfo=tz.tzlocal())
elif res.tzoffset == 0:
ret = ret.replace(tzinfo=tz.tzutc())
elif res.tzoffset:
ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
return ret
def __get_local_files(self, start_time, end_time, path='.'):
'''
:param start_time:
:param end_time:
:param path:
:return:
'''
short_start_time = start_time[0:6]
short_end_time = end_time[0:6]
month_format_str = "%Y%m" # 这样就足够了
start_date = datetime.datetime.strptime(short_start_time, month_format_str)
end_date = datetime.datetime.strptime(short_end_time, month_format_str)
month_delta = relativedelta(months=1)
# todo 用dir name list 来生成文件夹，首先要判断文件夹是否存在，存在就跳过，也就是continue，若不存在就创建
res_files = []
while start_date <= end_date:
# todo add
dir_name = start_date.strftime(month_format_str)
dir_path = os.path.join(path, dir_name)
format_str = "%Y%m%d"
for parent, directory, files in os.walk(dir_path):
for file_name in files:
print os.path.join(parent, file_name)
dat_last = file_name.split('.')
if len(dat_last) > 1 and dat_last[-1] == 'dat':
str_time = file_name.split('_')[-1].split('.')[0]
if datetime.datetime.strptime(start_time, format_str) <= datetime.datetime.strptime(str_time, format_str) <= datetime.datetime.strptime(end_time, format_str):
res_files.append(file_name)
else:
continue
start_date = start_date + month_delta
return res_files
def __init__(self, name, account, amount, date_start=datetime.now(), quantum="month", number_of_quants=1, end_date=datetime.now() + relativedelta(months = 1)):
self.account = account
self.amount = amount
self.date_from = date_start
self.name = name
self.date_to = end_date
self.quantum = quantum
self.number_of_quants = number_of_quants
self.transactions = self.__get_transactions()
def parse(self, timestr, default=None, ignoretz=False, tzinfos=None, fuzzyreturn=False, **kwargs):
if not default:
default = datetime.datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
res = self._parse(timestr, **kwargs)
if res is None:
raise ValueError, "unknown string format"
repl = {}
for attr in ["year", "month", "day", "hour", "minute", "second", "microsecond"]:
value = getattr(res, attr)
if value is not None:
repl[attr] = value
ret = default.replace(**repl)
if res.weekday is not None and not res.day:
ret = ret + relativedelta.relativedelta(weekday=res.weekday)
if not ignoretz:
if callable(tzinfos) or tzinfos and res.tzname in tzinfos:
if callable(tzinfos):
tzdata = tzinfos(res.tzname, res.tzoffset)
else:
tzdata = tzinfos.get(res.tzname)
if isinstance(tzdata, datetime.tzinfo):
tzinfo = tzdata
elif isinstance(tzdata, basestring):
tzinfo = tz.tzstr(tzdata)
elif isinstance(tzdata, int):
tzinfo = tz.tzoffset(res.tzname, tzdata)
else:
raise ValueError, "offset must be tzinfo subclass, " "tz string, or int offset"
ret = ret.replace(tzinfo=tzinfo)
elif res.tzname and res.tzname in time.tzname:
ret = ret.replace(tzinfo=tz.tzlocal())
elif res.tzoffset == 0:
ret = ret.replace(tzinfo=tz.tzutc())
elif res.tzoffset:
ret = ret.replace(tzinfo=tz.tzoffset(res.tzname, res.tzoffset))
if fuzzyreturn:
if not repl.has_key("month"):
# return a fuzzy answer: an object representing a whole year
return relativedelta.relativedelta(year=ret.year, years=+1)
elif not repl.has_key("day"):
# return a fuzzy answer: an object representing a whole month
return relativedelta.relativedelta(year=ret.year, month=ret.month, months=+1)
elif not repl.has_key("hour"):
# return a fuzzy answer: an object representing a whole day
return relativedelta.relativedelta(year=ret.year, month=ret.month, day=ret.day, days=+1)
elif not repl.has_key("minute"):
# return a fuzzy answer: an object representing a whole hour
return relativedelta.relativedelta(year=ret.year, month=ret.month, day=ret.day, hour=ret.hour, hours=+1)
elif not repl.has_key("second"):
# return a fuzzy answer: an object representing a whole minute
return relativedelta.relativedelta(
year=ret.year, month=ret.month, day=ret.day, hour=ret.hour, minute=ret.minute, minutes=+1
)
elif not repl.has_key("microsecond"):
# return a fuzzy answer: an object representing a whole second
return relativedelta.relativedelta(
year=ret.year,
month=ret.month,
day=ret.day,
hour=ret.hour,
minute=ret.minute,
second=ret.second,
seconds=+1,
)
return ret
def _set_month(self, value):
self._dt += relativedelta(months=value - self._dt.month)
def carbon_deadline_1():
return relativedelta(CARBON_DEADLINE_1, datetime.now(timezone.utc))
def run(options):
matrix = RGBMatrix(options=options)
canvas = matrix.CreateFrameCanvas()
f1 = graphics.Font()
f1.LoadFont(relpath("10x20.bdf"))
f2 = graphics.Font()
f2.LoadFont(relpath("6x13.bdf"))
f3 = graphics.Font()
f3.LoadFont(relpath("8x13.bdf"))
L1 = 15
L2 = 30
red = hex2color("#ff0000")
green = hex2color("#00ff00")
while not time.sleep(0.05):
canvas.Clear()
# Deadline
now = datetime.now(timezone.utc)
# Use relativedelta for leap-year awareness
deadline_delta = relativedelta(CARBON_DEADLINE_1, now)
years = deadline_delta.years
# Extract concrete days from the months & days provided by relativedelta
# @rubberduck: 1. Create a relativedelta object rdays containing Δ months & days
# 2. Create a concrete time object rdays in the future
# 3. Create a timedelta object representing that value - now
# 4. Extract its days
rdays = relativedelta(months=deadline_delta.months,
days=deadline_delta.days)
days = ((rdays + now) - now).days
hours = deadline_delta.hours
minutes = deadline_delta.minutes
seconds = deadline_delta.seconds
cs = deadline_delta.microseconds // 10000
deadline = [
[f1, red, 1, f"{years:1.0f}"],
[f3, red, 1, "YEAR " if years == 1 else "YEARS"],
[f1, red, 1, f"{days:03.0f}"],
[f3, red, 1, "DAY " if days == 1 else "DAYS"],
[f1, red, -2, f"{hours:02.0f}"],
[f1, red, -1, (":", " ")[cs < 50]],
[f1, red, -2, f"{minutes:02.0f}"],
[f1, red, -1, (":", " ")[cs < 50]],
[f1, red, 0, f"{seconds:02.0f}"],
]
x = 1
for font, color, space, string in deadline:
x += space + graphics.DrawText(canvas, font, x, L1, color, string)
# Lifeline
r1 = renewables_1()
lifeline = [
[f1, green, -2, f"{r1:.0f}"],
[f1, green, -2, f"."],
[f1, green, 3, f"{format(r1, '.9f').split('.')[1]}%"],
[f2, green, 0, "RENEWABLES"],
]
x = 1
for font, color, space, string in lifeline:
x += space + graphics.DrawText(canvas, font, x, L2, color, string)
canvas = matrix.SwapOnVSync(canvas)
tempfile = os.path.join(cache_dir, "data.html")
if not os.path.isdir(cache_dir):
os.makedirs(cache_dir)
# Handle quality
qualities = (104001, 104002, 104003, 104004)
__quality__ = qualities[int(__settings__.getSetting("quality"))]
# Handle dates
date_limit = {0: 3, 1: 6, 2: 12, 3: 0} # months to go back or forth
date_limit_nowshowing = int(__settings__.getSetting("date_limit_nowshowing"))
date_limit_comingsoon = int(__settings__.getSetting("date_limit_comingsoon"))
today = date.today()
__date_limit_nowshowing__ = today - relativedelta(
months=date_limit[date_limit_nowshowing])
__date_limit_comingsoon__ = today + relativedelta(
months=date_limit[date_limit_comingsoon])
if __settings__.getSetting("skiprerelease") == 'true':
__skiprerelease__ = True
else:
__skiprerelease__ = False
# Display release date
if __settings__.getSetting("displayreleasedate") == 'true':
__displayreleasedate__ = True
else:
__displayreleasedate__ = False
# Handle title
def _set_month(self, value):
self._dt += relativedelta(months = value - self._dt.month)
