def get_next_dates_list(bgn_date_parm, max_date_parm, iteration_type,
how_many_iterations):
bgn_end_dates_list = []
date_time = bgn_date_parm
for i in range(0, how_many_iterations):
bgn_date_parm = date_time.strftime('%Y-%m-%d')
try:
if iteration_type == 'days':
date_time += timedelta(days=1)
end_date = (date_time + timedelta(days=1)).strftime('%Y-%m-%d')
elif iteration_type == 'weeks':
date_time += timedelta(weeks=1)
end_date = date_time.strftime('%Y-%m-%d')
elif iteration_type == 'months':
date_time += monthdelta(months=1)
end_date = date_time.strftime('%Y-%m-%d')
elif iteration_type == 'years':
date_time += monthdelta(months=12)
end_date = date_time.strftime('%Y-%m-%d')
else:
date_time += timedelta(days=1)
end_date = (date_time + timedelta(days=1)).strftime('%Y-%m-%d')
if datetime.strptime(end_date, '%Y-%m-%d') < max_date:
bgn_end_dates_list.append((bgn_date_parm, end_date))
else:
bgn_end_dates_list.append(
(bgn_date_parm, max_date.strftime('%Y-%m-%d')))
break
except Exception as e:
sys.stderr.write('Exception: %s' % e)
return bgn_end_dates_list
def getDateByCount(day_range):
end_date = datetime.datetime.today() - datetime.timedelta(days=1)
if day_range.endswith("D"):
day_range = day_range[0:len(day_range) - 1]
date = datetime.datetime.today() - datetime.timedelta(days=np.int(day_range))
debug_print("resolving date from ", day_range, "to", date.strftime('%Y-%m-%d'))
return date, end_date
elif day_range.endswith("M"):
day_range = day_range[0:len(day_range) - 1]
date = datetime.datetime.today() - monthdelta(np.int(day_range))
debug_print("resolving date from ", day_range, "to", date.strftime('%Y-%m-%d'))
return date, end_date
elif day_range.endswith("Y"):
day_range = day_range[0:len(day_range) - 1]
if day_range.isint():
day_range = 12 * np.int(day_range)
date = datetime.datetime.today() - monthdelta(day_range)
debug_print("resolving date from ", day_range, "to", date.strftime('%Y-%m-%d'))
return date, end_date
else:
begin,end = day_range.split(':')
begin_date = datetime.datetime.strptime(begin, '%Y%m%d')
end_date = datetime.datetime.strptime(end, '%Y%m%d')
return begin_date, end_date
def _scrape_all(self, number_of_months=2):
tids_to_url = self._get_tid_urls()
all_part_urls = []
old_data = pd.read_csv(self._portal_data_path)
if not number_of_months:
for i in range(self._different_in_months):
incremented_result = self._start_date_obj + monthdelta(i)
month = incremented_result.month
year = incremented_result.year
part_url = "&month={}:{}".format(month, year)
all_part_urls.append(part_url)
all_urls = (
"https://www.atmco-treasury.com/{url}{month_part}".format(
url=url, month_part=month_part)
for url in tids_to_url.values()
for month_part in all_part_urls)
else:
for i in range(number_of_months):
i *= -1
incremented_result = datetime.datetime.today().date(
) + monthdelta(i)
month = incremented_result.month
year = incremented_result.year
part_url = "&month={}:{}".format(month, year)
all_part_urls.append(part_url)
print(month, year)
old_data = old_data[old_data["DATE"].apply(
lambda x: not (int(x.split("/")[0]) == month and int(
x.split("/")[2]) == year))]
all_urls = (
"https://www.atmco-treasury.com/{url}{month_part}".format(
url=url, month_part=month_part)
for url in tids_to_url.values()
for month_part in all_part_urls)
threads = []
for url in all_urls:
t = threading.Thread(target=self._get_data, args=(url, ))
t.start()
threads.append(t)
for t in threads:
t.join()
headers = [
"TID", "CARRY_FORWARD", "CASH_ORDERS", "NUM_TRANS", "DATE",
"SETTLEMENTS", "CREDITS", "REBANK"
]
df = pd.DataFrame(self._scraper_container, columns=headers)
df = df[df["DATE"] != "0"]
df["DATE"] = df["DATE"].apply(lambda x: "{}/{}/{}".format(
x.split("/")[1],
x.split("/")[0],
x.split("/")[2]) if len(x.split("/")) == 3 else x)
old_data = old_data.append(df, ignore_index=True)
old_data.to_csv(self._portal_data_path, index=False)
def save(self, *args, **kwargs):
self.name = self.sheetbase.name + ': ' + self.date.strftime('%B %Y')
super(Sheets, self).save(*args, **kwargs)
if self.sheetbase.autoadd:
dt_now = datetime.datetime.now().date().replace(day=1)
dt_from = dt_now - monthdelta.monthdelta(3)
dt_to = dt_now + monthdelta.monthdelta(1)
related_sheets = [
s.pk
for s in Sheets.objects.filter(sheetbase=self.sheetbase,
date__range=(dt_from, dt_to))
]
qs = Activities.objects.filter(
user=self.user, sheet__in=related_sheets).values('category')
common_acts = qs.annotate(cnt=Count(Lower('name'))).values(
'name', 'category').filter(cnt__gte=3).annotate(
avg_val=Avg('origin_value'))
for act in common_acts:
cat = UserCategories.objects.get(pk=act['category'])
Activities(name=act['name'],
value=int(act['avg_val']),
category=cat,
user=self.user,
sheet=self).save()
def changelist_view(self, request, extra_context=None):
response = super().changelist_view(request,
extra_context=extra_context)
try:
cl = response.context_data['cl']
qs = cl.queryset
year = cl.get_filters_params().get("year", None)
except (AttributeError, KeyError):
return response
if year:
month_from = date(int(year), 1, 1)
else:
month_from = today().replace(
day=1) - monthdelta(BaseBookingAdmin.COLUMNS - 12)
month_list = [
month_from + monthdelta(i) for i in range(BaseBookingAdmin.COLUMNS)
]
# фильтр на диапазон дат из списка для отображения
qs = qs.filter(month__range=(month_list[0], month_list[-1]))
response.context_data['months'] = month_list
response.context_data['summary'] = qs.get_booking(month_list)
response.context_data['projects'] = sorted(
set(
qs.values_list('booking__project_member__project__short_name',
flat=True)))
return response
def handle(self, **options):
start_date = (options['start_date'] or '').strip()
if start_date:
start_date = dateutil.parser.parse(start_date)
start_date = date(start_date.year, start_date.month, start_date.day)
else:
start_date = date.today() - monthdelta(1)
end_date = (options['end_date'] or '').strip()
if end_date:
end_date = dateutil.parser.parse(end_date)
end_date = date(end_date.year, end_date.month, end_date.day)
else:
end_date = date.today()
segments = [_ for _ in options['segments'].split(',') if _.strip()]
while start_date <= end_date:
for segment in segments:
print 'Calculating for segment %s on start date %s.' % (segment, start_date)
models.Load.calculate(
year=start_date.year,
month=start_date.month,
zone=options['zone'],
segment=segment,
)
start_date += monthdelta(1)
def read_data(data_text, year, quarter=None, month=None, month_apart=0):
if ((quarter == None) == (month == None)):
raise ValueError('Need specify either quarter or month.')
if (quarter != None):
month = (quarter - 1) * 3 + 1
if month_apart < 0:
from_date = datetime.date(year, month,
1) + monthdelta.monthdelta(month_apart)
to_date = datetime.date(year, month, 1)
elif month_apart > 0:
from_date = datetime.date(year, month, 1)
to_date = datetime.date(year, month,
1) + monthdelta.monthdelta(month_apart)
conn = sqlite3.connect(data_text)
df = pd.read_sql_query(
"select * from main where date >= Datetime('" + str(from_date) +
" 00:00:00') and date < Datetime('" + str(to_date) +
" 00:00:00') ", conn)
df['date'] = pd.to_datetime(df['date'], errors='coerce')
conn.close()
return df
def timetable(request, classid):
today = datetime.date.today()
links = []
data = []
# url = 'http://140.115.236.11/NEXT2.ASP?YY='+str(today.timetuple()[0])+'&MM='+str(today.timetuple()[1])+'&Query_item=%AFZ%AF%C5&NEXT=%A4U%A4%40%A8B'
# res = requests.get(url)
# soup = BeautifulSoup(res.text)
# classlist = []
# souplist = soup.select('option')
# for i in souplist:
# classlist.append(i['value'])
classlist = getClassList()
for mdelta in range(-2, 3):
yy = str((today+monthdelta(mdelta)).timetuple()[0])
mm = str((today+monthdelta(mdelta)).timetuple()[1])
domdata = IiiclassTimetable.objects.filter(classid = classid, year = yy, month = mm).values('domdata')
# links.append(
# {
# 'month':mm,
# 'link':'http://140.115.236.11/query_tea.asp?STR='+classid+'&Query=%ACd%B8%DF&MM2='+mm+'&YY2='+yy+'&item2=%AFZ%AF%C5'
# }
# )
data.append(
{
'month':mm,
'domdata':domdata[0]['domdata']
})
return render(request, 'iiiclass_timetable.html', {'data': data, 'classlist':classlist})
def FullTextQuery(service, text_query, months_ago=0):
date_start = date.today() - monthdelta(months_ago)
date_end = date_start + monthdelta(1)
start_min = '%04d-%02d-01T00:00:00-03:00' % (date_start.year, date_start.month)
start_max = '%04d-%02d-01T00:00:00-03:00' % (date_end.year, date_end.month)
print "Periodo: %02d/%04d" % (date_start.month, date_start.year)
max_results = 200
return service.events().list(q=text_query, calendarId=calendar_id, timeMin=start_min, timeMax=start_max, maxResults=max_results).execute()
def save(self, *args, **kwargs):
"""Sync times on save."""
if self.next_period != self.period:
if timezone.now().date() in (self.last_billed, self.next_billing):
self.period = self.next_period
self.next_billing = self.last_billed + monthdelta(self.period)
self.next_billing = self.last_billed + monthdelta(self.period)
return super(Billing, self).save(*args, **kwargs)
def _get_month_end_datetime(self, month=0):
now = datetime.now()
now_replaced = now.replace(day=1, hour=23, minute=59, second=59)
if now.month >= month:
month_diff = 0 if not month else 12 - (14 - month)
return now_replaced - timedelta(days=1) - monthdelta(month_diff)
else:
return now_replaced - timedelta(
days=1) + monthdelta(month - now.month + 1) - monthdelta(12)
def _get_month_start_datetime(self, month=0):
now = datetime.now()
now_replaced = now.replace(day=1, hour=0, minute=0, second=0)
if now.month >= month:
month_diff = 0 if not month else 12 - (13 - month)
return now_replaced - monthdelta(month_diff)
else:
return now_replaced + monthdelta(month -
now.month) - monthdelta(12)
def calc_month_norma(month_list, stop_date=None):
'''
Рассчитать список норм времени (опционально - по сегоднящний день)
'''
stop_date = stop_date or month_list[-1] + monthdelta(1)
return [
workhours(min(m, stop_date),
min(m + monthdelta(1) - timedelta(days=1), stop_date))
for m in month_list
]
def get_last_day(first_day, period, custom_days):
if period == 0:
return (first_day + datetime.timedelta(custom_days-1))
elif period == 1:
return first_day
elif period == 2:
return (first_day + datetime.timedelta(7-1))
elif period == 3:
return (first_day + monthdelta(1) - datetime.timedelta(1))
elif period == 4:
return (first_day + monthdelta(12) - datetime.timedelta(1))
else: return None
def tvt_split(df):
"""Train-Validate-Test split of data for continous training
as defined in Bao et al., 2017."""
dict_dataframes = {}
train = df.index[0]
validate = df.index[0] + monthdelta(24)
test = df.index[0] + monthdelta(27)
test_end = df.index[0] + monthdelta(30)
df_train = pd.DataFrame(df[(df.index >= train) & (df.index <= validate)])
df_validate = pd.DataFrame(df[(df.index >= validate) & (df.index <= test)])
df_test = pd.DataFrame(df[(df.index >= test) & (df.index <= test_end)])
dict_dataframes = {1: df_train, 2: df_validate, 3: df_test}
return dict_dataframes
def get_long_historical_price(ticker, start_date, end_date, frequency='1d',display=True):
date1 = start_date
iteration_number = 1
dfall = {}
while date1 <= end_date:
if frequency == '1d':
month_delta = 3
else:
if frequency == '1wk':
month_delta = 12
else:
month_delta = 48
# Create 'date2' in a 60 day Window or less
date2 = date1 + monthdelta.monthdelta(month_delta)
date2 = datetime.date(date2.year, date2.month, 1)
date2 = date2 - datetime.timedelta(days = 1)
# Do not allow 'date2' to go beyond the 'End Date'
if date2 > end_date:
date2 = end_date
# print(f"Processing {date1} thru {date2}.")
try:
df = get_historical_price(ticker, date1, date2, frequency, display)
if len(df) > 0:
if iteration_number == 1:
dfall = df.copy()
else:
frames = [dfall, df]
dfall = pd.concat(frames)
iteration_number += 1
date1 = date1 + monthdelta.monthdelta(month_delta)
date1 = datetime.date(date1.year, date1.month, 1)
except:
date1 = date1 + monthdelta.monthdelta(month_delta)
date1 = datetime.date(date1.year, date1.month, 1)
return dfall
def test_monthly():
def day_suffixed_str(day):
suffix = 'th' if 11 <= day <= 13 else {
1: 'st',
2: 'nd',
3: 'rd'
}.get(day % 10, 'th')
return str(day) + suffix
today = dt.now().replace(hour=23, minute=59, second=0, microsecond=0)
yesterday = (dt.now() - timedelta(days=1)).replace(hour=23,
minute=59,
second=0,
microsecond=0)
s = TaskScheduler()
j = s.every(day_suffixed_str(today.day)).strict_date(True).at("23:59").do(
job, x="hello", y="world")
assert (j.next_timestamp == dt.timestamp(today))
# yesterday's date is scheduled to next month
j = s.every(day_suffixed_str(
yesterday.day)).strict_date(False).at("23:59").do(job,
x="hello",
y="world")
assert (j.next_timestamp == dt.timestamp(yesterday + monthdelta(1)))
# strict_date is False. So 31st will just be the last day of the month
j = s.every("31st").strict_date(False).at("23:59").do(job,
x="hello",
y="world")
eom = (dt.now() + monthdelta(1)).replace(
day=1, hour=23, minute=59, second=0, microsecond=0) - timedelta(days=1)
assert (j.next_timestamp == dt.timestamp(eom))
# strict_date is True. So next schedule will be when month has 31st
j = s.every("31st").strict_date(True).at("23:59").do(job,
x="hello",
y="world")
day = dt.now()
while ((day + monthdelta(1)).replace(day=1) - timedelta(days=1)).day != 31:
day += monthdelta(1)
assert (j.next_timestamp == dt.timestamp(
day.replace(day=31, hour=23, minute=59, second=0, microsecond=0)))
with pytest.raises(BadScheduleError):
# error because .strict_date() is not called
s.every("1st").at("23:59").do(job, x="hello", y="world")
assert len(s.jobs) == 4
def changelist_view(self, request, extra_context=None):
response = super().changelist_view(request,
extra_context=extra_context)
# pylint: disable=no-member
current_employee = Employee.objects.by_user(request.user)
current_id = current_employee.id if current_employee else None
# список разрешенных для просмотра
sub_list = [
employee.id for employee in current_employee.subordinates()
] if current_employee else []
# по себе смотреть можно всегда, если сотрудник - добавляем в список
if current_id:
sub_list.append(current_id)
try:
# извлечение данных запроса
cl = response.context_data['cl']
qs = cl.queryset
year = cl.get_filters_params().get("year", None)
# сотрудник из запроса
employee_id = cl.get_filters_params().get('employee', current_id)
employee_id = int(employee_id) if employee_id else None
# проверка прав на просмотр указанного в запросе сотрудникa
if not request.user.has_perm(
'pplan.view_all') and not employee_id in sub_list:
return response
# проверка месяца
if year:
month_from = date(int(year), 1, 1)
else:
month_from = today().replace(
day=1) - monthdelta(BaseBookingAdmin.COLUMNS - 12)
month_list = [
month_from + monthdelta(i)
for i in range(BaseBookingAdmin.COLUMNS)
]
except (AttributeError, KeyError, ValueError):
return response
response.context_data['months'] = month_list
response.context_data['member'] = Employee.objects.filter(
id=employee_id).first()
response.context_data['summary'], response.context_data[
'total'] = qs.get_booking(month_list, employee_id)
return response
def standards_report(year):
# расчет диапазонов дат для каждого месяца и квартала
m_ranges = ((m[1], date(year, m[0], 1),
date(year, m[0], 1) + monthdelta(1) - timedelta(days=1))
for m in MONTHS)
q_ranges = ((q[1], date(year, q[0], 1),
date(year, q[0], 1) + monthdelta(3) - timedelta(days=1))
for q in QUARTES)
y_range = (('Год', date(year, 1,
1), date(year + 1, 1, 1) - timedelta(days=1)), )
return ({
'name': r[0],
'stat': (days(r[1], r[2]), *workdayholidayhours(r[1], r[2]))
} for r in it.chain(m_ranges, q_ranges, y_range))
def get_timedelta_from_granularity(granularity: str):
datetime_interval = isodate.parse_duration(granularity)
if isinstance(datetime_interval, isodate.duration.Duration):
years, months = datetime_interval.years, datetime_interval.months
total_months = int(years * 12 + months)
datetime_interval = monthdelta(months=total_months)
return datetime_interval
def run():
mydate = "201603"
mylinedate = date(year=int(mydate[:4]), month=int(mydate[4:]), day=1)
line_chart_values = []
for i in range(12):
value_i = value_e = 0
i_date = mylinedate - monthdelta(i)
t = Transaction.objects.filter(date__year=i_date.year,
date__month=i_date.month,
family_id=748166,
category_id__type='i')
for entry in t:
value_i += entry.amount / 100
print("value_i", value_i)
t = Transaction.objects.filter(date__year=i_date.year,
date__month=i_date.month,
family_id=748166,
category_id__type='e')
for entry in t:
value_e += entry.amount / 100
print("value_e", value_i)
line_chart_values.append([i_date, value_e, value_i])
print("DONE")
for i in range(len(line_chart_values)):
print("line_chart_values", line_chart_values[i])
def trading_info(tstart, filebase):
# loads Public DVD TRADING LOAD data
year1, month1, day1 = tstart.strftime("%Y-%m-%d").split("-")
tstart_next = tstart + monthdelta.monthdelta(1)
year2, month2, day2 = tstart_next.strftime("%Y-%m-%d").split("-")
filename1 = "PUBLIC_DVD_TRADINGLOAD_{0}{1}010000.CSV".format(year1, month1)
filename2 = "PUBLIC_DVD_TRADINGLOAD_{0}{1}010000.CSV".format(year2, month2)
SA1 = pd.read_csv(filebase + filename1)
# Pivot table
SA1 = SA1.pivot_table(index="SETTLEMENTDATE",
columns="DUID",
values="TOTALCLEARED")
# correct date
SA1 = SA1.set_index(pd.DatetimeIndex(SA1.index))
SA1 = SA1.loc[SA1.index.sort_values()]
SA2 = pd.read_csv(filebase + filename2)
# Pivot table
SA2 = SA2.pivot_table(index="SETTLEMENTDATE",
columns="DUID",
values="TOTALCLEARED")
SA2 = SA2.set_index(pd.DatetimeIndex(SA2.index))
SA2 = SA2.loc[SA2.index.sort_values()]
return SA1, SA2, tstart, filename1, filename2
def _filterOrder(request, cleanData):
orders = Order.objects
operators = _getOperators()
if request.user not in operators:
orders = orders.filter(company__username=request.user)
elif cleanData.get('company', ''):
orders = orders.filter(company__name__icontains=cleanData['company'])
if cleanData.get('content', ''):
orders = orders.filter(content__icontains=cleanData['content'])
if cleanData.get('author', ''):
orders = orders.filter(author__username=cleanData['author'])
if cleanData.get('checkout', '') == 'on' and cleanData.get(
'non_checkout', '') == 'on':
orders = orders
elif cleanData.get('checkout', '') == 'on':
orders = orders.filter(checkout=True)
elif cleanData.get('non_checkout', '') == 'on':
orders = orders.filter(checkout=False)
monthNum = cleanData.get('month', '1')
try:
monthNum = int(monthNum)
except Exception as _e:
monthNum = 1
if monthNum > 0:
endDate = datetime.date.today()
startDate = endDate - monthdelta(monthNum)
orders = orders.filter(date__range=[startDate, endDate])
return orders, monthNum
def prepare_row(self, rid, forecast_start_date, predictions_mri,
predictions_dx):
forecast_start_date = self.format_date(forecast_start_date)
forecast_date = forecast_start_date
for i, (pred_vv,
pred_dx) in enumerate(zip(predictions_mri, predictions_dx)):
f_month = i + 1
# print 'fm', f_month
arow = []
arow.append(rid)
arow.append(f_month)
arow.append(
str(forecast_date.year) + '-' + str(forecast_date.month))
arow.append(pred_dx[0])
arow.append(pred_dx[1])
arow.append(pred_dx[2])
self.add_blank_cells(arow, 3)
arow.append(pred_vv)
self.add_blank_cells(arow, 3)
self.results.append(arow)
forecast_date = forecast_date + monthdelta.monthdelta(1)
def export_month(month):
for sensor in sensors:
start = datetime.strptime(month, '%Y-%m')
end = start + monthdelta(1)
name = "{}-{}".format(sensor, start.strftime("%Y-%m"))
print("exporting {}".format(name))
urllib.urlretrieve(url(sensor, start, end), "data/{}".format(name))
def get_description(self, date):
if not self.should_append_date():
return self.new_description
if self.should_append_next_month_date():
date += monthdelta(1)
return self.new_description + ' ' + date.strftime('%Y-%m')
def generate_next_row(self, ts):
"""
Takes time-series as an input and returns next raw, that is fed to the fitted model,
when predicting next value.
Parameters
----------
ts : pd.Series(values, timestamps)
Time-series to detect on
num_lags : int, default=14
Defines the number of lag features
granularity : str, default='day'
Defines timedelta of your series
Returns
---------
feature_matrix : pd.DataFrame
Pandas dataframe, which contains feature lags of
shape(1, num_lags)
"""
if not self.granularity:
raise ValueError('No granularity provided')
if self.granularity == 'hour':
delta = timedelta(hours=1)
if self.granularity == 'day':
delta = timedelta(days=1)
if self.granularity == 'month':
delta = monthdelta(1)
next_timestamp = pd.to_datetime(ts.index[-1]) + delta
lag_dict = {'lag_{}'.format(i): [ts.iloc[-i]] for i in range(1, self.num_lags + 1)}
lag_dict.update({'season_lag': ts.iloc[-self.num_lags]})
df = pd.DataFrame.from_dict(lag_dict)
df.index = [next_timestamp]
return df
def post(self, request, club_id):
repeat = request.POST.get('repeater')
group = get_object_or_404(Group, pk=request.POST.get('group'))
lesson = get_object_or_404(ClubLesson, pk=request.POST.get('lesson'))
date_start = datetime.datetime.strptime(request.POST.get('dateStart'),
'%d.%m.%Y %H:%M')
date_end = datetime.datetime.strptime(request.POST.get('dateEnd'),
'%d.%m.%Y %H:%M')
if date_start < date_end:
days = ((date_start + monthdelta(int(repeat))) - date_start).days
events = [
Schedule(
group=group,
lesson=lesson,
date_start=date_start + datetime.timedelta(days=i),
date_end=date_end + datetime.timedelta(days=i),
) for i in range(0, int(days), 7)
]
Schedule.objects.bulk_create(events)
messages.success(request, _('Событие успешно добавлено'))
return redirect(request.META.get('HTTP_REFERER'))
messages.error(request,
_('Дата начала не может быть больше даты завершения'),
'danger')
return redirect(request.META.get('HTTP_REFERER'))
def print_months_header(verbose):
""" Print the header to show the months
:param verbose:
"""
prev_month = datetime.now()
month_order = []
month_header_str = " "
# get the months, starting from now and working back (so we know what order to print them in)
for i in range(1, 13):
month_order.append(prev_month.strftime("%b"))
prev_month = prev_month + monthdelta.monthdelta(-1)
month_order.reverse()
for key in month_order:
if verbose:
month_header_str += " {} ".format(key)
else:
month_header_str += " {} ".format(key)
print(month_header_str, end="")
print("")
return len(month_header_str)
def _filterOrder(request, cleanData):
orders = Order.objects
operators = _getOperators()
if request.user not in operators:
orders = orders.filter(company__username=request.user)
elif cleanData.get('company', ''):
orders = orders.filter(company__name__icontains=cleanData['company'])
if cleanData.get('content', ''):
orders = orders.filter(content__icontains=cleanData['content'])
if cleanData.get('author', ''):
orders = orders.filter(author__username=cleanData['author'])
if cleanData.get('checkout', '') == 'on' and cleanData.get('non_checkout', '') == 'on':
orders = orders
elif cleanData.get('checkout', '') == 'on':
orders = orders.filter(checkout=True)
elif cleanData.get('non_checkout', '') == 'on':
orders = orders.filter(checkout=False)
monthNum = cleanData.get('month', '1')
try:
monthNum = int(monthNum)
except Exception as _e:
monthNum = 1
if monthNum > 0:
endDate = datetime.date.today()
startDate = endDate - monthdelta(monthNum)
orders = orders.filter(date__range=[startDate, endDate])
return orders, monthNum
def run():
mydate = "201603"
mylinedate = date(year=int(mydate[:4]),month=int(mydate[4:]),day=1)
line_chart_values=[]
for i in range(12):
value_i = value_e = 0
i_date = mylinedate - monthdelta(i)
t = Transaction.objects.filter(date__year=i_date.year,
date__month=i_date.month,
family_id=748166,
category_id__type='i')
for entry in t:
value_i += entry.amount/100
print("value_i",value_i)
t = Transaction.objects.filter(date__year=i_date.year,
date__month=i_date.month,
family_id=748166,
category_id__type='e')
for entry in t:
value_e += entry.amount/100
print("value_e",value_i)
line_chart_values.append([i_date,value_e,value_i])
print ("DONE")
for i in range(len(line_chart_values)):
print ("line_chart_values", line_chart_values[i])
def membership():
month = datetime.utcnow()
membership = []
for i in xrange(36):
membership.append((month.month,month.year,Payments(month.month, month.year).count()))
month += monthdelta(-1)
return [m for m in membership if not m[-1] == 0]
def get_exchange_rate():
r = r'Долар США.+?\n.+?\n.+?(?P<nbu>\d+?.\d+?)<'
url1 = 'https://bank.gov.ua/markets/exchangerates/?date='
url2 = '&period=daily'
date = datetime.datetime.strptime('2007-02-01', '%Y-%m-%d')
res = {}
dates = ''
month = monthdelta(1)
while dates != '01.06.2019':
date = date + month
dates = date.strftime('%d.%m.%Y')
print(dates)
request = urlopen(url1 + dates + url2)
c = list(
re.finditer(r,
str(request.read(), encoding='utf-8',
errors='ignore')))
try:
curs = float('.'.join(c[0].group('nbu').split(',')))
if curs > 500:
curs = curs / 100
except Exception:
curs = 0
res[date] = curs
res = pd.DataFrame.from_dict(res, orient='index', columns=['UAH/USD'])
res.index = res.index.to_period(freq='M')
res.to_csv('curs.csv')
def cook_choices(self):
SELECTOR_CHOICES = []
today = date.today()
for i in range(12):
SELECTOR_CHOICES.append((str(today.year) + str(today.month).zfill(2),
str(today.strftime('%B')) + ' ' + str(today.year)))
today = today - monthdelta(1)
return SELECTOR_CHOICES
def changelist_view(self, request, extra_context=None):
t = Timing('WorklogReport')
# выбранный диапазон месяцев
year = get_year_param(request)
month_list = [
date(year, 1 + i, 1) for i in range(BaseReportAdmin.COLUMNS)
]
stop_date = get_slice_param(request)
last_date = month_list[-1] + monthdelta(1)
if stop_date and stop_date > last_date:
# сброс параметра, если выбран набор данных в прошлом
stop_date = None
qs = self.get_queryset(request).filter(
startdate__range=(month_list[0], stop_date or last_date))
# загрузка и сохранение в request журнала работ за год
# (оптимизация для предотвращения необходимости повторной загрузки фрейма в фильтрах)
worklogframe = WorklogFrame().load(qs)
# ограничение набора данных только теми, по которым решал задачи пользователь
if not request.user.has_perm('jiradata.view_all'):
worklogframe = worklogframe.filter(author=request.user.username)
request.worklogframe = worklogframe
rows = worklogframe.rows()
# заполнение фильтров в базовом классе
response = super().changelist_view(request,
extra_context=extra_context)
try:
cl = response.context_data['cl']
qs = cl.queryset
except (AttributeError, KeyError):
return response
# фильтрация по выбранному сотруднику
user = get_user_param(request)
worklogframe = worklogframe.filter(author=user)
# список норм рабочего времени
month_norma = calc_month_norma(month_list, stop_date=stop_date)
seconds = t.step()
response.context_data['months'] = month_list
response.context_data['member'] = JiraUser.objects.filter(
user_name=user).first()
response.context_data['summary'], response.context_data[
'total'] = worklogframe.aggr_month_budget(month_list, month_norma)
response.context_data['norma'] = month_norma
response.context_data['slice'] = stop_date
response.context_data['year'] = year
response.context_data[
'stat'] = f'{rows} строк обработано за {seconds:.2} c'
return response
def stock_ticker():
'''receive user input through flask site'''
user_input = request.args.get('ticker').upper()
if user_input == '' :
user_input = 'AMZN'
'''Quandl API request'''
quandl = os.environ['Quandl_SECRET']
yesterday = date.today() - timedelta(days=1)
last_month = yesterday - monthdelta(1)
yesterday = yesterday.strftime('%Y-%m-%d')
last_month = last_month.strftime('%Y-%m-%d')
ticker = 'https://www.quandl.com/api/v3/datasets/WIKI/AAPL?trim_start=2018-02-15&trim_end=2018-03-23&api_key=PlaceKeyHere'
ticker = ticker.replace('AAPL', user_input)
ticker = ticker.replace('PlaceKeyHere', quandl)
ticker = ticker.replace('2018-02-15', last_month)
ticker = ticker.replace('2018-03-23', yesterday)
r = requests.get(ticker)
#create dictionary of API call:
d = r.json()
#these are the columns names:
# ['Date', 'Open', 'High', 'Low', 'Close', 'Volume', 'Ex-Dividend', 'Split Ratio', 'Adj. Open', 'Adj. High', 'Adj. Low', 'Adj. Close', 'Adj. Volume']
try:
columns = d['dataset']['column_names']
data = d['dataset']['data']
'''create pandas df'''
df = pd.DataFrame(data, columns=columns)
'''create bokeh figure'''
def datetime(x):
return np.array(x, dtype=np.datetime64)
p1 = figure(x_axis_type="datetime", title="Stock Closing Prices")
p1.grid.grid_line_alpha=0.3
p1.xaxis.axis_label = 'Date'
p1.yaxis.axis_label = 'Price'
p1.line(datetime(df['Date']), df['Close'], color='#A6CEE3', legend=user_input)
p1.legend.location = "top_left"
fname = 'user_input_stock_ticker.html'
# html = file_html(p1, CDN, fname)
script, div = components(p1)
html = script + div
except KeyError :
html = 'No such company.'
return html
def getMonth(month = 0, formatted = False):
try:
date = (dt.date.today() + md.monthdelta(month))
if formatted:
return date
else:
return date.strftime('%B %Y')
except Exception, e:
raiseError(log='getmonth', error=e)
return dt.date.today()
def add_months(date, months, date_format='%Y-%m'):
"""
add days to a date
:param date: string date
:param months: months to add
:param date_format: input and output date format
:return: new string date with months added
"""
dt = datetime.strptime(date, date_format) + monthdelta.monthdelta(months)
return dt.strftime(date_format)
def member_list():
month = datetime.utcnow()
members = {}
curr = hackhub.get_db().cursor()
for i in xrange(2):
for user in Payments(month.month, month.year).payments:
curr.execute("SELECT username, email FROM member WHERE username = ?", user)
res = curr.fetchone()
members[res[1]] = res[0]
month += monthdelta(-1)
return members
def report(self):
start_date = ForemanOptions.get_date_created()
today_date = datetime.now()
months = [start_date.strftime("%B %Y")]
categories = CaseType.get_case_types()
cases_opened = []
cases_closed = []
cases_archived = []
total_cases = []
cases_assigned_inv = []
active_tab = 0
for status in CaseStatus.all_statuses:
total_cases.append([start_date.strftime("%B %Y"), status,
Case.get_num_cases_opened_on_date(start_date, status, case_type=None, by_month=True)])
for category in categories:
cases_opened.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.OPEN, case_type=category,
by_month=True)])
cases_closed.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.CLOSED, case_type=category,
by_month=True)])
cases_archived.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.ARCHIVED, case_type=category,
by_month=True)])
for category in TaskCategory.get_categories():
for investigator in UserRoles.get_investigators():
cases_assigned_inv.append([investigator.fullname, category, Task.get_num_tasks_by_user(investigator,
category,
start_date)])
max_months = 11
while start_date.month != today_date.month and max_months != 0:
start_date = start_date + monthdelta(1)
months.append(start_date.strftime("%B %Y"))
for status in CaseStatus.all_statuses:
total_cases.append([start_date.strftime("%B %Y"), status,
Case.get_num_cases_opened_on_date(start_date, status, case_type=None, by_month=True)])
for category in categories:
cases_opened.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.OPEN, case_type=category,
by_month=True)])
cases_closed.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.CLOSED, case_type=category,
by_month=True)])
cases_archived.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.ARCHIVED,
case_type=category, by_month=True)])
max_months -= 1
return self.return_response('pages', 'report.html', cases_opened=cases_opened, cases_closed=cases_closed,
months=months, cases_archived=cases_archived, total_cases=total_cases,
active_tab=active_tab, cases_assigned_inv=cases_assigned_inv)
def set_date_range(self):
if self.series.date_is_start:
self.start_date_inclusive = self.date
q = Data.objects.filter(series=self.series, date__gt=self.date).order_by('date')
if q.exists():
self.end_date_inclusive = q[0].date - timedelta(days=1)
elif self.series.frequency == c.MONTHLY and self.start_date_inclusive.day == 1:
self.end_date_inclusive = self.start_date_inclusive + monthdelta(1) - timedelta(days=1)
#TODO:handle open end date for other frequencies?
else:
self.end_date_inclusive = self.date
q = Data.objects.filter(series=self.series, date__lt=self.date).order_by('-date')
if q.exists():
self.start_date_inclusive = q[0].date + timedelta(days=1)
def report(self):
self.check_permissions(self.current_user, 'Report', 'view')
start_date = ForemanOptions.get_date_created()
today_date = datetime.now()
months = [start_date.strftime("%B %Y")]
categories = CaseType.get_case_types()
cases_opened = []
cases_closed = []
cases_archived = []
total_cases = []
active_tab = 0
for status in CaseStatus.all_statuses:
total_cases.append([start_date.strftime("%B %Y"), status,
Case.get_num_cases_opened_on_date(start_date, status, case_type=None, by_month=True)])
for category in categories:
cases_opened.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.OPEN, case_type=category,
by_month=True)])
cases_closed.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.CLOSED, case_type=category,
by_month=True)])
cases_archived.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.ARCHIVED, case_type=category,
by_month=True)])
max_months = 11
while start_date.month != today_date.month and max_months != 0:
start_date = start_date + monthdelta(1)
months.append(start_date.strftime("%B %Y"))
for status in CaseStatus.all_statuses:
total_cases.append([start_date.strftime("%B %Y"), status,
Case.get_num_cases_opened_on_date(start_date, status, case_type=None, by_month=True)])
for category in categories:
cases_opened.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.OPEN, case_type=category,
by_month=True)])
cases_closed.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.CLOSED, case_type=category,
by_month=True)])
cases_archived.append([start_date.strftime("%B %Y"), category,
Case.get_num_cases_opened_on_date(start_date, CaseStatus.ARCHIVED,
case_type=category, by_month=True)])
max_months -= 1
return self.return_response('pages', 'report.html', cases_opened=cases_opened, cases_closed=cases_closed,
months=months, cases_archived=cases_archived, total_cases=total_cases,
active_tab=active_tab)
def lastmonth(request):
# today = datetime.date.today()
lastMonth = datetime.date.today() - monthdelta(1)
# thisMonth = today.month
tblUser = Spesa.objects.filter(dataspesa__month=lastMonth.month).order_by("-dataspesa")
importoSummed = (
Spesa.objects.filter(dataspesa__month=lastMonth.month)
.order_by("-dataspesa")
.aggregate(Sum("importo"))
.values()[0]
)
objNum = tblUser.count()
return render(
request,
"appspesemodulo/mychange_list.html",
{"tblUser": tblUser, "importoSummed": importoSummed, "objNum": objNum},
)
def getScheduleConfiguration(self, newsletterData):
"""TODO: Docstring for getScheduleConfiguration.
:returns: TODO
"""
use_newsletterDates = True
if use_newsletterDates:
date_from, date_to = self.getConfigurationDates(newsletterData)
else:
month_delta = int(self.cfg['FLIGHT_SEARCH']['month_delta'])
delay_data = datetime.timedelta(days=7)
date_from = datetime.datetime.now() + delay_data;
date_to = date_from + monthdelta(month_delta)
config = { }
config['date_from'] = date_from
config['date_to'] = date_to
return config
def _get_date_range():
timezone = pytz.timezone(session['timezone'])
now = timezone.localize(datetime.now())
if 'start_date' in request.args:
start_date = request.args.get('start_date')
start_date = dateutil.parser.parse(start_date)
start_date = start_date.date()
else:
start_date = now.date() - monthdelta(months=1)
if 'end_date' in request.args:
end_date = request.args.get('end_date')
end_date = dateutil.parser.parse(end_date)
end_date = end_date.date()
else:
end_date = now.date()
return start_date, end_date
def __getFlightDetails(self, date_from, date_to, oneWayIdxList):
for i, idx in enumerate(oneWayIdxList):
if date_to.year == date_from.year:
months = int(((date_to - date_from).days)/30) + 1
else:
months = int(((date_to - date_from).days)/30) + 2
for delta in range(months):
time = date_from + monthdelta(delta)
timeTableList = self.__getTimeTable(time, self.connections[idx]) #get timetable for given year-month
for flight in timeTableList:
if flight.date >= date_from and flight.date <= date_to: #datetime.datetime(2017,2,18):
if self.asyncMode:
self.__scheduleFlightDetails(flight)
else:
list = self.__fetchFlightDetails(flight)
self.__handleFlightDetails(list)
self.proceedList.append(self.connections[idx])
lm.debug("Status: {} of {} - ({}%)".format(i + 1, len(oneWayIdxList), (i+1)/len(oneWayIdxList)*100))
def ets(x, horizon, quantile, normalize=1.0):
"""
calls generic ets function to find the best forecast in the ets model family
:param x: input data. A pandas series with time in its index
:param horizon: number of poinst to predict
:param quantile: error quantile for the predictions
:param normalize: normalization constant to avoid dealing with ridiculous numbers
:return: nothing. the output is in pred_dict
"""
data = pos_data(x) / normalize # get contiguous positive time series
if len(data) <= horizon / 6:
print(x.name + ': not enough data: ' + str(len(data)) + ' no forecast')
return
fcast = hw.ets(data.values, horizon=horizon, quantile=quantile, max_seasons=0, opt_crit='lik', verbose=False)
y = fcast['df_out']
y['ylwr'][y['ylwr'] < 0] = 0 # set to 0 errors below 0
dt_dates = [datetime.datetime.strptime(data.index.min(), '%Y-%m') + monthdelta.monthdelta(i) for i in range(int(len(data) + horizon))]
dates = [d.strftime('%Y-%m') for d in dt_dates]
y.index = dates
print(x.name + ' ' + str(fcast['model']) + ' ' + str(fcast['params']) + ' rmse:' + str(fcast['rmse']) +
' data points: ' + str(len(data)) + ' season: ' + str(fcast['season']))
return y # y, yhat, yupr, ylwr
import solr
import urllib, urllib2
import json
import dateutil.parser
from datetime import timedelta
from monthdelta import monthdelta
from esgfpy.migrate.solr2solr import migrate
DEFAULT_QUERY = "*:*"
CORE_DATASETS = 'datasets'
CORE_FILES = 'files'
CORE_AGGREGATIONS = 'aggregations'
CORES = [CORE_DATASETS, CORE_FILES, CORE_AGGREGATIONS]
TIMEDELTA_MONTH = monthdelta(1)
TIMEDELTA_DAY = timedelta(days=1)
TIMEDELTA_HOUR = timedelta(hours=1)
MAX_DATASETS_PER_HOUR = 10000
class Harvester(object):
'''Class that harvests records from a source Solr server into a target Solr server.'''
def __init__(self, source_solr_base_url, target_solr_base_url):
self.source_solr_base_url = source_solr_base_url
self.target_solr_base_url = target_solr_base_url
logging.info("HARVESTING: %s --> %s" % (source_solr_base_url, target_solr_base_url))
def sync(self, query=DEFAULT_QUERY):
'''Main method to sync from the source Solr to the target Solr.'''
soup = BeautifulSoup(res.text)
classlist_from_crawler = []
souplist = soup.select('option')
for i in souplist:
classlist_from_crawler.append(i['value'])
print classlist_from_crawler
if (res.ok):
writeToDb_classlist()
# get timetables and write into database
for classid in classlist_from_crawler:
print classid
for mdelta in range(-2, 3):
yy = str((today+monthdelta(mdelta)).timetuple()[0])
mm = str((today+monthdelta(mdelta)).timetuple()[1])
url = 'http://140.115.236.11/query_tea.asp?STR='+classid+'&Query=%ACd%B8%DF&MM2='+mm+'&YY2='+yy+'&item2=%AFZ%AF%C5'
res = requests.get(url)
res.encoding = 'big5'
soup = BeautifulSoup(res.text)
domdata = soup.select('form')[0]
if (res.ok):
writeToDb_timetable()
# print classid + '_' + yy + '_' + mm
def get(self , request , format = None):
user = self.request.user
s = service.objects.get(user = user)
os = offering.objects.filter(service = s)
td = timezone.now() # today
# print td.month
# weeks starts on monday and ends on sunday
enddate = td - timedelta((td.weekday() + 1) % 7) # last week's sunday
startdate = enddate - timedelta(days=6) # last week's monday
cxo = order.objects.filter(offer__in = os , status='canceledByVendor' , end__range= [enddate , td]).count() # current weeks cancelled orders
cco = order.objects.filter(offer__in = os , status='completed' , end__range= [enddate , td]).count() # current weeks cancelled orders
acol = order.objects.filter(offer__in = os , status='complete' , end__range= [startdate , enddate]).order_by('-created') # all completed orders in last week
lastWeekEarnings = 0
for o in acol:
a , _ = getBookingAmount(o)
lastWeekEarnings += a
# for last to last week
enddate = enddate - timedelta(weeks=1) # last week's sunday
startdate = startdate - timedelta(weeks=1) # last week's monday
acol = order.objects.filter(offer__in = os , status='complete' , end__range= [startdate , enddate]).order_by('-created') # all completed orders in last week
last2LastWeekEarnings = 0
for o in acol:
a , _ = getBookingAmount(o)
last2LastWeekEarnings += a
monthWiseBookings = []
monthWiseRevenue = []
months = []
for i in range(0,12):
acol = order.objects.filter(offer__in = os , status='complete' , end__range= [enddate - monthdelta(1) , enddate]).order_by('-created') # all completed orders in last week
enddate = enddate - monthdelta(1)
months.append(enddate.strftime('%b'))
ta = 0
for o in acol:
a , _ = getBookingAmount(o)
ta += a
monthWiseRevenue.append(ta)
monthWiseBookings.append(acol.count())
print monthWiseRevenue
print monthWiseBookings
tco = order.objects.filter(offer__in = os , status='complete') # total completed orders so far
ipo = order.objects.filter(offer__in = os , status='inProgress') # inProgress orders
expectedThisWeek = 0
for o in ipo:
a , _ = getBookingAmount(o)
expectedThisWeek += a
totalRevenue = 0
for o in tco:
a , _ = getBookingAmount(o)
totalRevenue += a
content = {'last2LastWeekEarnings' : last2LastWeekEarnings ,
'lastWeekEarnings' : lastWeekEarnings ,
'completeLastWeek': acol.count(),
'totalCompletedOrders' : tco.count() ,
'inProgressOrders' : ipo.count() ,
'cancelledThisWeek' : cxo ,
'completeThisWeek' : cco ,
'expectedThisWeek' : expectedThisWeek,
'monthWiseBookings' : monthWiseBookings,
'monthWiseRevenue' : monthWiseRevenue,
'totalRevenue' : totalRevenue,
'months' : months}
return Response(content, status=status.HTTP_200_OK)
def get_month(self, year, month):
s = datetime.date(year, month, 1)
e = s + monthdelta.monthdelta(1) - datetime.timedelta(days=1)
return self.get_range_date(s.isoformat(), e.isoformat())
query1 = "SELECT * FROM %s WHERE ngram = ? AND SUBREDDIT = ?" %(tablename1,)
prepared1 = session.prepare(query1)
query2 = "SELECT * FROM %s WHERE ngram = ? and n = ?" %(tablename2,)
prepared2 = session.prepare(query2)
#Creating a list of time with start, end and step
def perdelta(start, end, delta):
curr = start
while curr < end:
yield curr
curr += delta
#Creating a list of time for our known time list
Xtime = [x for x in perdelta(date(2007, 10, 01), date(2016, 01, 01), monthdelta(1))]
XtimeUtc = [time.mktime(x.timetuple())*1000 for x in perdelta(date(2007, 10, 01), date(2016, 01, 01), monthdelta(1))]
@app.route('/')
@app.route("/index")
def index():
return render_template("index.html" )
def get_timeseries_data(ngram, subreddit):
bound = prepared1.bind((ngram, 'allsubreddit'))
res = session.execute(bound)
response_list = []
for val in res:
response_list.append(val)
def __init__(self, ntmo):
self.ntmo = ntmo
self.mtraffic = None
self.mtimeslot = None
self.mtime = None
self.last_conn_state = None
self.unity_panel = self.ntmo.sys_info["unity.panel"]
if self.unity_panel:
try:
import appindicator
except:
self.unity_panel = False
# Status Icon
self.statusIcon = gtk.StatusIcon()
## i18n
# self.i18n_APP_NAME = "ntm"
# self.i18n_DIR = "i18n/locale"
# print(_("i18n setup: done!")) # TEST
## Open xml
self.gtkb = gtk.Builder()
# self.gtkb.set_translation_domain("ntm") # i18n
self.gtkb.add_from_file("ntm_main.gui")
##
## Windows Menu
#self.butMenu = self.gtkb.get_object("button_menu")
#self.butMenu.connect('clicked', self.butMenu_hClicked)
## Menu
self.statusIconMenu = self.gtkb.get_object("menu_statusIcon")
menuItem = self.gtkb.get_object("menuitem_show_win")
menuItem.connect('activate', self.menuShowWin_hActivate)
menuItem.get_children()[0].set_label(_("Show Window"))
menuItem = self.gtkb.get_object("menuitem_report")
menuItem.connect('activate', self.menuReport_hActivate)
menuItem.get_children()[0].set_label(_("Report"))
menuItem = self.gtkb.get_object("menuitem_preferences")
menuItem.connect('activate', self.menuPreferences_hActivate)
menuItem.get_children()[0].set_label(_("Preferences"))
menuItem = self.gtkb.get_object("menuitem_info")
menuItem.connect('activate', self.menuInfo_hActivate)
menuItem.get_children()[0].set_label(_("Info & News"))
menuItem = self.gtkb.get_object("menuitem_about")
menuItem.connect('activate', self.menuAbout_hActivate)
menuItem.get_children()[0].set_label(_("About"))
menuItem = self.gtkb.get_object("menuitem_quit")
menuItem.connect('activate', self.menuQuit_hActivate)
menuItem.get_children()[0].set_label(_("Quit"))
# menuItem = self.gtkb.get_object("menuitem_test")
# menuItem.connect('activate', self.menuTest_hActivate)
##
## Status Icon
self.statusIcon.set_from_file(globaldef.NTM_ICON)
self.statusIcon.set_tooltip(_("Network Traffic Monitor\n-Left click: show the counters\n-Rigth click: show menu"))
self.statusIcon.connect('activate', self.tryIcon_hActivate)
self.statusIcon.connect('popup-menu', self.tryIcon_hPopup_menu, self.statusIconMenu)
##
## Main Window
self.mainWindow = self.gtkb.get_object("ntmMainWindow")
self.mainWindow.connect("delete_event", self.windowMain_hDelete)
self.mainWindow.set_icon_from_file(globaldef.NTM_ICON)
self.mainWindow.set_title(_(self.mainWindow.get_title()))
self.mainWindow.hide()
self.mainWindow_Show = False
(self.winposx, self.winposy) = self.mainWindow.get_position()
(self.winsizex, self.winsizey) = self.mainWindow.get_size()
self.status_bar = self.gtkb.get_object("statusbar")
##
## Report Windows
self.view_rep = webkit.WebView()
self.gtkb_report = gtk.Builder()
self.gtkb_report.add_from_file("report.gui")
self.report_date_dialog = self.gtkb_report.get_object("date_dialog")
self.report_date_dialog_calendar = self.gtkb_report.get_object("date_dialog_calendar")
self.report_date_dialog_title = self.gtkb_report.get_object("date_dialog_title")
self.report_window = gtk.Window()
icon = self.report_window.render_icon(gtk.STOCK_FILE, gtk.ICON_SIZE_BUTTON)
self.report_window.set_icon(icon)
self.report_window.resize(300, 400)
self.report_window.set_position(gtk.WIN_POS_CENTER)
self.report_window.set_title("NTM - Report")
vbox = gtk.VBox(False, 0)
self.report_top_bar = self.gtkb_report.get_object("top_bar")
vbox.pack_start(self.report_top_bar, False, False, 0)
vbox.pack_start(self.view_rep, True, True, 0)
self.report_window.add(vbox)
self.report_window.show_all()
self.report_window.hide()
self.report_window_Show = False
self.report_window.connect("delete_event", self.report_window_hDelete)
self.report_first_day = self.gtkb_report.get_object("from_button")
self.temp_report_first_day = datetime.date.today() - monthdelta(1)
self.report_first_day.set_label(self.temp_report_first_day.isoformat())
self.report_first_day.connect('clicked', self.report_first_day_hclicked)
self.report_last_day = self.gtkb_report.get_object("to_button")
self.temp_report_last_day = datetime.date.today()
self.report_last_day.set_label(self.temp_report_last_day.isoformat())
self.report_last_day.connect('clicked', self.report_last_day_hclicked)
self.report_all_days = self.gtkb_report.get_object("all_days")
report_update = self.gtkb_report.get_object("update")
report_update.connect('clicked', self.report_update_hClicked)
self.report_type = self.gtkb_report.get_object("report_type") # Combo Box
liststore = gtk.ListStore(gobject.TYPE_STRING)
entries = [_('Total'), _('Daily')] # , 'Days of Week']
for entry in entries: liststore.append([entry])
self.report_type.set_model(liststore)
cell = gtk.CellRendererText()
self.report_type.pack_start(cell, True)
self.report_type.add_attribute(cell, 'text', 0)
self.report_type.set_active(0)
# i18n
ntmtools.translate_control_text(self.gtkb_report.get_object("label1"))
ntmtools.translate_control_text(self.gtkb_report.get_object("label2"))
ntmtools.translate_control_label(self.gtkb_report.get_object("all_days"))
ntmtools.translate_control_text(self.gtkb_report.get_object("label3"))
ntmtools.translate_control_label(self.gtkb_report.get_object("update"))
ntmtools.translate_control_markup(self.gtkb_report.get_object("date_dialog_title"))
ntmtools.translate_control_label(self.gtkb_report.get_object("dateWindow_cancelButton"))
ntmtools.translate_control_label(self.gtkb_report.get_object("dateWindow_okButton"))
self.update_report()
##
## Window Preferences
self.windowPreferences = self.gtkb.get_object("preferencesWindow")
icon = self.windowPreferences.render_icon(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_BUTTON)
self.windowPreferences.set_icon(icon)
self.windowPreferences.connect("delete_event", self.windowPreferences_hDelete)
self.windowPreferences.hide()
self.windowPreferences_Show = False
# General
self.entry_interface = self.gtkb.get_object("preferencesEntry_interface")
self.spinButton_updateInterval = self.gtkb.get_object("preferencesSpinbutton_updateInterval")
self.spinButton_updateInterval.set_range(1, 999)
self.spinButton_updateInterval.set_increments(1, 10)
self.prefKeepAbove = self.gtkb.get_object("preferences_general_keepAbove")
self.preferences_opacity = self.gtkb.get_object("preferences_opacity")
self.preferences_opacity.set_range(0, 100)
self.preferences_opacity.set_increments(1, 10)
self.prefAutorun = self.gtkb.get_object("preferences_general_autorun")
self.preferences_online_check = self.gtkb.get_object("preferences_online_check")
liststore = gtk.ListStore(gobject.TYPE_STRING)
entries = ['NetworkManager', 'Ping Mode']
for entry in entries:
liststore.append([entry])
self.preferences_online_check.set_model(liststore)
cell = gtk.CellRendererText()
self.preferences_online_check.pack_start(cell, True)
self.preferences_online_check.add_attribute(cell, 'text', 0)
self.preferences_tray_activate_action = self.gtkb.get_object("preferences_tray_activate_action")
liststore = gtk.ListStore(gobject.TYPE_STRING)
entries = [_('Show Main Window'), _('Show Notify')]
for entry in entries: liststore.append([entry])
self.preferences_tray_activate_action.set_model(liststore)
cell = gtk.CellRendererText()
self.preferences_tray_activate_action.pack_start(cell, True)
self.preferences_tray_activate_action.add_attribute(cell, 'text', 0)
but_cancel = self.gtkb.get_object("preferences_delete_data")
but_cancel.connect('clicked', self.preferencesDeleteData_hClicked)
# Data
but = self.gtkb.get_object("preferences_data_import")
but.connect('clicked', self.preferencesDataImport_hClicked)
but = self.gtkb.get_object("preferences_data_export")
but.connect('clicked', self.preferencesDataExport_hClicked)
but = self.gtkb.get_object("preferences_data_selfile")
but.connect('clicked', self.preferencesDataSelfile_hClicked)
self.entry_data_file = self.gtkb.get_object("preferences_data_file")
# Bottom
but_cancel = self.gtkb.get_object("preferencesButton_cancel")
but_cancel.connect('clicked', self.preferencesButtonCancel_hClicked)
but_apply = self.gtkb.get_object("preferencesButton_apply")
but_apply.connect('clicked', self.preferencesButtonApply_hClicked)
##
self.notify_ok = pynotify.init ("summary-body")
self.aboutActive = False
self.quitActive = False
## i18n
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_01"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_02"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_general_keepAbove"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_03"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_general_autorun"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_04"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_05"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_06"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label1"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_1"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_data_import"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_data_export"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_data_selfile"))
ntmtools.translate_control_text(self.gtkb.get_object("label1"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_delete_data"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_data"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label2"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label3"))
ntmtools.translate_control_text(self.gtkb.get_object("label_time_page"))
ntmtools.translate_control_label(self.gtkb.get_object("preferencesButton_cancel"))
ntmtools.translate_control_label(self.gtkb.get_object("preferencesButton_apply"))
self.indIcontype = 0
if not self.unity_panel:
self.statusIcon.set_visible(True)
self.indIcontype = 1
else:
self.statusIcon.set_visible(False)
self.appind = appindicator.Indicator("ntm-ai","nk.ntm_off", appindicator.CATEGORY_APPLICATION_STATUS)
self.appind.set_status(appindicator.STATUS_ACTIVE)
self.appind.set_menu(self.statusIconMenu)
self.indIcontype = 2
# 'Pacific Heights': 'USA-SFO-PCI',
# 'Parkside': 'USA-SFO-PAS',
# 'Potrero Hill': 'USA-SFO-POT',
# 'Presidio Heights': 'USA-SFO-PRI',
# 'Russian Hill': 'USA-SFO-RUS',
# 'Seacliff': 'USA-SFO-SEA',
'South Of Market': 'USA-SFO-SOO',
# 'Twin Peaks': 'USA-SFO-TWI',
# 'Visitacion Valley': 'USA-SFO-VIS',
# 'Western Addition': 'USA-SFO-WEA',
# 'West Of Twin Peaks': 'USA-SFO-WEO'
}
HEADERS = ['timestamp','date','locality', 'locality_code', 'price_usd','posting_id']
START_DATE = datetime.date(2010, 6, 1)
MONTH_DELTA = monthdelta(1)
def main():
with open('rent_data-{0}.csv'.format(time()),'w+') as csvfile:
csv = DictWriter(csvfile, HEADERS)
for (name, code) in NEIGHBORHOODS.iteritems():
date = START_DATE
now = date.today()
while date < now:
prices, next_date = get_pricing_data(code, date, MONTH_DELTA)
print(json.dumps(prices, indent=4))
date = next_date
SEARCH_URL = 'http://search.3taps.com'
def handle(self, *args, **options):
if len(args) == 0:
raise CommandError('Unknown frequency value for sending digests')
frequency = args[0]
a = Alert.objects.get_or_create(pk=1, defaults={'how_many': 20})[0]
if not a.is_active:
logger.warning(u'[Alerts Cron] Cron triggered, but is is currently disabled. Nothing was sent.')
return False
limit = a.how_many
body = a.body
start = datetime.datetime.now()
end = datetime.datetime.now()
if frequency == 'daily':
start = start - datetime.timedelta(1)
elif frequency == 'weekly':
start = start - datetime.timedelta(7)
elif frequency == 'monthly':
start = start - monthdelta.monthdelta(1)
elif frequency == 'every_2_weeks':
start = start - datetime.timedelta(14)
else:
raise CommandError('Unknown value %s' % frequency)
start = int(start.strftime('%s'))
end = int(end.strftime('%s'))
alerts = UserAlert.objects.filter(frequency=frequency, is_paused=False).all()
if not alerts:
logger.info(u'[Alerts Cron] There are no alerts to send')
# clean template stored in /emails/alerts.html
# after all changes you need to regenerate alerts.html to alerts_inline.html via http://inliner.cm/
html_template = get_template('emails/alerts_inline.html')
for alert in alerts:
try:
search_for = sanitize_search_params(json.loads(alert.data))
search_for['start'] = start
search_for['end'] = end
# count will be the total of possible results
# i.e. it is possible for count > len(articles)
articles, count = get_filtered_news(search_for, limit)
if count == 0:
continue
languages = []
for language in search_for['languages']:
languages.append(languages_map.get(language))
search_for['languages'] = languages
subject = 'TobaccoWatcher Alert: {}'.format(alert.name)
text = body + '\n\n'
context = Context({
'alert': alert,
'SITE_URL': 'http://' + settings.HOSTNAME,
'base_body': a.body,
'articles': articles,
'total_articles': count,
'search_for': search_for
})
html_content = html_template.render(context)
for article in articles:
text = '%s-------\n\n%s\n\n%s\n\nSource: %s\n\n' % (text,
strip_tags(article['title']),
strip_tags(article['cleaned_content']),
article['url'])
msg = EmailMultiAlternatives(subject, text, settings.DEFAULT_FROM_EMAIL, [alert.user.email])
msg.attach_alternative(html_content, "text/html")
msg.send()
except Exception as e:
print e
logger.error(u'[Alerts Cron] Email could not be sent: {}'.format(e))
# century (1 Jan 1901 to 31 Dec 2000)?
#
# MORE INFO
# Return the day of the week as an integer, where Monday is 0 and Sunday is 6.
# >>> import datetime
# >>> datetime.datetime.today()
# datetime.datetime(2012, 3, 23, 23, 24, 55, 173504)
# >>> datetime.datetime.today().weekday()
import datetime
import monthdelta
date = datetime.date(1901, 1, 1)
sumsundays = 0
while date.year < 2001:
if date.weekday() == 6:
sumsundays += 1
date = date + monthdelta.monthdelta(+1)
print(sumsundays)
#
#
# Congratulations, the answer you gave to problem 19 is correct.
#
# You are the 94200th person to have solved this problem.
def __init__(self, ntmo):
self.ntmo = ntmo
self.mtraffic = None
self.mtimeslot = None
self.mtime = None
self.last_conn_state = None
self.unity_panel = self.ntmo.sys_info["unity.panel"]
if self.unity_panel:
try:
import appindicator
except:
self.unity_panel = False
# Status Icon
self.statusIcon = gtk.StatusIcon()
## Open xml
self.gtkb = gtk.Builder()
self.gtkb.add_from_file("ntm_main.gui")
##
## Menu
self.statusIconMenu = self.gtkb.get_object("menu_statusIcon")
menuItem = self.gtkb.get_object("menuitem_show_win")
menuItem.connect('activate', self.menu_show_win_h_activate)
menuItem.get_children()[0].set_label(_("Show Window"))
menuItem = self.gtkb.get_object("menuitem_report")
menuItem.connect('activate', self.menu_report_h_activate)
menuItem.get_children()[0].set_label(_("Report"))
menuItem = self.gtkb.get_object("menuitem_preferences")
menuItem.connect('activate', self.menu_preferences_h_activate)
menuItem.get_children()[0].set_label(_("Preferences"))
menuItem = self.gtkb.get_object("menuitem_info")
menuItem.connect('activate', self.menu_info_h_activate)
menuItem.get_children()[0].set_label(_("Info & News"))
menuItem = self.gtkb.get_object("menuitem_about")
menuItem.connect('activate', self.menu_about_h_activate)
menuItem.get_children()[0].set_label(_("About"))
menuItem = self.gtkb.get_object("menuitem_quit")
menuItem.connect('activate', self.menu_quit_h_activate)
menuItem.get_children()[0].set_label(_("Quit"))
# menuItem = self.gtkb.get_object("menuitem_test")
# menuItem.connect('activate', self.menuTest_hActivate)
##
## Status Icon
self.statusIcon.set_from_file(ntmo.trayicon_file)
self.statusIcon.set_tooltip(_("Network Traffic Monitor\n-Left click: show the counters\n-Right click: show menu"))
self.statusIcon.connect('activate', self.try_icon_h_activate)
self.statusIcon.connect('popup-menu', self.try_icon_h_popup_menu, self.statusIconMenu)
##
## Main Window
self.mainWindow = self.gtkb.get_object("ntmMainWindow")
self.mainWindow.hide()
self.mainWindow_Show = False
self.mainWindow.connect("delete_event", self.window_main_h_delete)
self.mainWindow.set_icon_from_file(globaldef.NTM_ICON)
self.mainWindow.set_title(_(self.mainWindow.get_title()))
(self.winposx, self.winposy) = self.mainWindow.get_position()
(self.winsizex, self.winsizey) = self.mainWindow.get_size()
self.ntmMainWindow_vbox = self.gtkb.get_object("ntmMainWindow_vbox")
self.nsb_conn_state_icon = self.gtkb.get_object("nsb_conn_state_icon")
#self.nsb_net_name = self.gtkb.get_object("nsb_net_name")
self.label_ping_time = self.gtkb.get_object("label_ping_time")
#self.status_bar = self.gtkb.get_object("statusbar")
#self.status_bar.push(self.status_bar.get_context_id("ntm"), " ")
#newlabel = gtk.Label("Test")
#sbc = self.status_bar.get_message_area().get_children()
#for i in sbc:
# if i is gtk.Label:
# i.set_markup("<small><b>Tr</b>:<small>123</small><b>Ts</b>:<small>345</small></small>")
#self.status_bar.get_message_area().remove(i)
#self.status_bar.get_message_area().add(newlabel)
#self.status_bar.get_message_area().pack_end(newlabel, expand=True, fill=True, padding=5)
# New Status Bar #
self.nsb_conn_state_icon = self.gtkb.get_object("nsb_conn_state_icon")
self.nsb_interface_name = self.gtkb.get_object("nsb_interface_name")
self.nsb_cauntry_icon = self.gtkb.get_object("nsb_cauntry_icon")
self.nsb_info = self.gtkb.get_object("nsb_info")
self.nsb_button_tools = self.gtkb.get_object("nsbt_button_tools")
self.nsb_button_tools.connect('toggled', self.nsb_button_tools_hToggled)
self.binf_viewport = self.gtkb.get_object("binf_viewport")
##
## Report Windows
self.view_rep = webkit.WebView()
self.gtkb_report = gtk.Builder()
self.gtkb_report.add_from_file("report.gui")
self.report_date_dialog = self.gtkb_report.get_object("date_dialog")
self.report_date_dialog_calendar = self.gtkb_report.get_object("date_dialog_calendar")
self.report_date_dialog_title = self.gtkb_report.get_object("date_dialog_title")
self.report_window = gtk.Window()
self.report_window.set_resizable(True)
#icon = self.report_window.render_icon(gtk.STOCK_INDEX, gtk.ICON_SIZE_DIALOG)
#self.report_window.set_icon(icon)
self.report_window.set_icon_from_file(globaldef.REPORT_ICON)
self.report_window.resize(300, 400)
self.report_window.set_position(gtk.WIN_POS_CENTER)
self.report_window.set_title("NTM - Report")
vbox = gtk.VBox(False, 0)
self.report_top_bar = self.gtkb_report.get_object("top_bar")
vbox.pack_start(self.report_top_bar, False, False, 0)
scroll_window = gtk.ScrolledWindow(None, None)
scroll_window.add(self.view_rep)
vbox.pack_start(scroll_window, True, True, 0)
self.report_window.add(vbox)
self.report_window_Show = False
self.report_window.connect("delete_event", self.report_window_h_delete)
self.report_first_day = self.gtkb_report.get_object("from_button")
self.temp_report_first_day = datetime.date.today() - monthdelta(1)
self.report_first_day.set_label(self.temp_report_first_day.isoformat())
self.report_first_day.connect('clicked', self.report_first_day_h_clicked)
self.report_last_day = self.gtkb_report.get_object("to_button")
self.temp_report_last_day = datetime.date.today()
self.report_last_day.set_label(self.temp_report_last_day.isoformat())
self.report_last_day.connect('clicked', self.report_last_day_h_clicked)
self.report_all_days = self.gtkb_report.get_object("all_days")
report_update = self.gtkb_report.get_object("update")
report_update.connect('clicked', self.report_update_h_clicked)
self.report_type = self.gtkb_report.get_object("report_type") # Combo Box
liststore = gtk.ListStore(gobject.TYPE_STRING)
entries = [_('Total'), _('Daily')] # , 'Days of Week']
for entry in entries: liststore.append([entry])
self.report_type.set_model(liststore)
cell = gtk.CellRendererText()
self.report_type.pack_start(cell, True)
self.report_type.add_attribute(cell, 'text', 0)
self.report_type.set_active(0)
# i18n
ntmtools.translate_control_text(self.gtkb_report.get_object("label1"))
ntmtools.translate_control_text(self.gtkb_report.get_object("label2"))
ntmtools.translate_control_label(self.gtkb_report.get_object("all_days"))
ntmtools.translate_control_text(self.gtkb_report.get_object("label3"))
ntmtools.translate_control_label(self.gtkb_report.get_object("update"))
ntmtools.translate_control_markup(self.gtkb_report.get_object("date_dialog_title"))
ntmtools.translate_control_label(self.gtkb_report.get_object("dateWindow_cancelButton"))
ntmtools.translate_control_label(self.gtkb_report.get_object("dateWindow_okButton"))
self.update_report()
##
## Window Preferences
self.windowPreferences = self.gtkb.get_object("preferencesWindow")
self.windowPreferences.hide()
self.windowPreferences_Show = False
icon = self.windowPreferences.render_icon(gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_DIALOG)
self.windowPreferences.set_icon(icon)
self.windowPreferences.connect("delete_event", self.window_preferences_h_delete)
# General
self.entry_interface = self.gtkb.get_object("preferencesEntry_interface")
but = self.gtkb.get_object("button_selint")
but.connect('clicked', self.preferences_sel_int_h_clicked)
self.spinButton_updateInterval = self.gtkb.get_object("preferencesSpinbutton_updateInterval")
self.spinButton_updateInterval.set_range(1, 999)
self.spinButton_updateInterval.set_increments(1, 10)
self.prefKeepAbove = self.gtkb.get_object("preferences_general_keepAbove")
self.preferences_opacity = self.gtkb.get_object("preferences_opacity")
self.preferences_opacity.set_range(0, 100)
self.preferences_opacity.set_increments(1, 10)
self.prefAutorun = self.gtkb.get_object("preferences_general_autorun")
self.preferences_online_check = self.gtkb.get_object("preferences_online_check")
liststore = gtk.ListStore(gobject.TYPE_STRING)
entries = ['NetworkManager', 'Ping Mode']
for entry in entries:
liststore.append([entry])
self.preferences_online_check.set_model(liststore)
cell = gtk.CellRendererText()
self.preferences_online_check.pack_start(cell, True)
self.preferences_online_check.add_attribute(cell, 'text', 0)
self.preferences_tray_activate_action = self.gtkb.get_object("preferences_tray_activate_action")
liststore = gtk.ListStore(gobject.TYPE_STRING)
entries = [_('Show Main Window'), _('Show Notify')]
for entry in entries: liststore.append([entry])
self.preferences_tray_activate_action.set_model(liststore)
cell = gtk.CellRendererText()
self.preferences_tray_activate_action.pack_start(cell, True)
self.preferences_tray_activate_action.add_attribute(cell, 'text', 0)
but_cancel = self.gtkb.get_object("preferences_delete_data")
but_cancel.connect('clicked', self.preferences_delete_data_h_clicked)
# Gui
self.filechooserbutton_online = self.gtkb.get_object("filechooserbutton_online")
self.filechooserbutton_online.set_filename(self.ntmo.trayicon_active_file)
self.filechooserbutton_offline = self.gtkb.get_object("filechooserbutton_offline")
self.filechooserbutton_offline.set_filename(self.ntmo.trayicon_file)
# Data
but = self.gtkb.get_object("preferences_data_import")
but.connect('clicked', self.preferences_data_import_h_clicked)
but = self.gtkb.get_object("preferences_data_export")
but.connect('clicked', self.preferences_data_export_h_clicked)
but = self.gtkb.get_object("preferences_data_selfile")
but.connect('clicked', self.preferences_data_sel_file_h_clicked)
self.entry_data_file = self.gtkb.get_object("preferences_data_file")
# Bottom
but_cancel = self.gtkb.get_object("preferencesButton_cancel")
but_cancel.connect('clicked', self.preferences_button_cancel_h_clicked)
but_apply = self.gtkb.get_object("preferencesButton_apply")
but_apply.connect('clicked', self.preferences_button_apply_h_clicked)
##
## Select Interface
self.gtkb_selint = gtk.Builder()
self.gtkb_selint.add_from_file("selinterface.gui")
self.selint_dialog = self.gtkb_selint.get_object("dialog_interfaces")
self.selint_dialog.resize(400, 200)
self.selint_dialog.connect("delete_event", self.selint_dialog_h_delete)
self.selint_dialog_alignmentTable = self.gtkb_selint.get_object("alignment_table")
self.selint_scrolledWinTab = self.make_device_table()
self.selint_dialog_alignmentTable.add(self.selint_scrolledWinTab)
self.selint_scrolledWinTab.show()
but = self.gtkb_selint.get_object("button_refresh")
but.connect('clicked', self.selint_button_refresh_h_clicked)
but = self.gtkb_selint.get_object("button_ok")
but.connect('clicked', self.selint_button_ok_h_clicked)
but = self.gtkb_selint.get_object("button_cancel")
but.connect('clicked', self.selint_button_cancel_h_clicked)
##
self.notify_ok = pynotify.init ("summary-body")
## Show Status Icon
self.statusIcon.set_visible(True)
##
self.aboutActive = False
self.quitActive = False
## i18n
ntmtools.translate_control_title(self.gtkb.get_object("preferencesWindow"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_01"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_02"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_general_keepAbove"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_03"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_general_autorun"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_04"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_2"))
ntmtools.translate_control_text(self.gtkb.get_object("label2"))
ntmtools.translate_control_text(self.gtkb.get_object("label3"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_05"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_06"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label1"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_1"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_data_import"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_data_export"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_data_selfile"))
ntmtools.translate_control_text(self.gtkb.get_object("label1"))
ntmtools.translate_control_label(self.gtkb.get_object("preferences_delete_data"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label_data"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label2"))
ntmtools.translate_control_text(self.gtkb.get_object("preferences_label3"))
ntmtools.translate_control_text(self.gtkb.get_object("label_time_page"))
ntmtools.translate_control_label(self.gtkb.get_object("preferencesButton_cancel"))
ntmtools.translate_control_label(self.gtkb.get_object("preferencesButton_apply"))
ntmtools.translate_control_title(self.gtkb_selint.get_object("dialog_interfaces"))
ntmtools.translate_control_text(self.gtkb_selint.get_object("label_table"))
ntmtools.translate_control_label(self.gtkb_selint.get_object("button_refresh"))
ntmtools.translate_control_label(self.gtkb_selint.get_object("button_ok"))
ntmtools.translate_control_label(self.gtkb_selint.get_object("button_cancel"))
# self.alarm_player = NKPlayer("./stf/ending.ogg")
self.indIcontype = 0
if not self.unity_panel:
self.statusIcon.set_visible(True)
self.indIcontype = 1
else:
self.statusIcon.set_visible(False)
self.appind = appindicator.Indicator("ntm-ai","nk.ntm_off", appindicator.CATEGORY_APPLICATION_STATUS)
self.appind.set_status(appindicator.STATUS_ACTIVE)
self.appind.set_menu(self.statusIconMenu)
self.indIcontype = 2
from datetime import date
from monthdelta import MonthDelta as monthdelta
start = date(1901, 1, 1)
end = date(2000, 12, 31)
curr = start
cnt = 0
while curr < end:
print curr
curr = curr + monthdelta(1)
if curr.isoweekday() == 7:
cnt += 1
print cnt
