def json_msg_reserve_day_schedule(request, pk):
day_schedule = get_object_or_404(DaySchedule, pk=pk)
reserve_obj_dict = {}
reserve_obj_dict['reserveFor'] = 'cours'
reserve_obj_dict['day'] = day_schedule.day_name.name
reserve_obj_dict['parentPath'] = '#/courses/' + str(
day_schedule.schedule.course.id)
reserve_obj_dict['hourStart'] = utils.get_hour(day_schedule.hour_start)
reserve_obj_dict['hourEnd'] = utils.get_hour(day_schedule.hour_end)
reserve_obj_dict['peoples'] = unicode(day_schedule.schedule.course.teacher)
reserve_obj_dict['title'] = unicode(day_schedule.schedule.course.course_name) +\
', ' + unicode(day_schedule.schedule.name)
reservation_header = "Demande de réservation pour %s"\
%(reserve_obj_dict['reserveFor'])
reservation_header += " <strong>%s</strong>" % (reserve_obj_dict['title'])
reservation_header += " avec %s" % (reserve_obj_dict['peoples'])
reservation_header += " le %s" % (reserve_obj_dict['day'])
reservation_header += " de %s" % (reserve_obj_dict['hourStart'])
reservation_header += " à %s." % (reserve_obj_dict['hourEnd'])
# Create the client Object
reserve_obj_dict['client'] = {}
reserve_obj_dict['client']['selections'] = []
reserve_obj_dict['client']['reservationHeader'] = reservation_header
if request.method == 'GET':
reserve_obj_dict['dayStart'] = utils.get_day(day_schedule.day_start)
reserve_obj_dict['dayEnd'] = utils.get_day(day_schedule.day_end)
reserve_obj_dict['dayRange'] = utils.get_day_range_dict(
day_schedule.day_start, day_schedule.day_end,
day_schedule.day_name.name)
q_testing_days = TestingDay.objects.filter(day_schedule=day_schedule)
reserve_obj_dict['testingDays'] = utils.get_testing_days(
q_testing_days)
elif request.method == 'POST':
errors = utils.send_reserve_day_mail(request.body, reservation_header)
if errors:
errors_obj = {"errors": errors}
return HttpResponse(json.dumps(errors_obj),\
content_type="application/json")
#return HttpResponseBadRequest(json.dumps(errors),\
#content_type="application/json")
reserve_obj_dict = {}
return HttpResponse(json.dumps(reserve_obj_dict),\
content_type="application/json")
def get_avg_coll_rate():
"""
Function to get average number of collisions on hourly/daily/monthly/yearly basis as specified
:return:
"""
result = 0
if num_coll_time[0] == utils.HOUR:
for i in range(0, 24):
key = utils.get_key(utils.TIME, city, utils.HOUR, i)
result = result + int(r.get(key) if r.exists(key) else 0)
result = result / 24
elif num_coll_time[0] == utils.DAY:
for i in range(0, 7):
key = utils.get_key(utils.TIME, city, utils.DAY, utils.get_day(i))
result = result + int(r.get(key) if r.exists(key) else 0)
result = result / 7
elif num_coll_time[0] == utils.MONTH:
for i in range(1, 13):
key = utils.get_key(utils.TIME, city, utils.MONTH,
utils.get_month(i))
result = result + int(r.get(key) if r.exists(key) else 0)
result = result / 12
elif num_coll_time[0] == utils.YEAR:
for i in range(utils.START_YEAR, utils.CURRENT_YEAR + 1):
key = utils.get_key(utils.TIME, city, utils.YEAR, i)
result = result + int(r.get(key) if r.exists(key) else 0)
result = result / (utils.CURRENT_YEAR - utils.START_YEAR + 1)
else:
raise ValueError('Invalid type of duration: ', avg_coll_rate_type)
return result
def _set_initial_data(self, datetime, from_zone, to_zone):
self._datetime = get_date_time(datetime)
self._set_unset_daily_fare()
self._set_unset_weekly_fare()
self._from_zone = from_zone
self._to_zone = to_zone
self._day = get_day(self._datetime)
self._time = get_time(self._datetime)
self._week = get_week_number(self._datetime)
def process_datetime(date_str, time_str):
dt = dateutil.parser.isoparse(date_str).replace(hour = int(time_str.split(':')[0]),
minute = int(time_str.split(':')[1]))
timezone = pytz.timezone('US/Eastern')
dt = timezone.localize(dt).astimezone(pytz.utc)
dt_year = dt.year
dt_month = dt.month
dt_day = dt.weekday()
dt_hour = dt.hour
if dt_year and isinstance(dt_year, int) and dt_month >=0 and isinstance(dt_month, int) and dt_day >= 0 and isinstance(dt_day, int) and dt_hour >= 0 and isinstance(dt_hour, int):
dt_month = utils.get_month(dt_month)
dt_day = utils.get_day(dt_day)
return [dt_year,dt_month,dt_day,dt_hour]
def udf_entity_hash(id, id_value, apply_dt, dbg=False):
if id_value is None or id is None: return 'null'
id_value = udf_distinct_v(id_value)
if len(apply_dt) == 10: apply_dt = '%s 00:00:00' % apply_dt
ft_v = []
for x in id_value:
event_time = utils.timestamp_datetime(x.get('eventoccurtime'))
date_diff = utils.get_day(apply_dt, event_time)
if (event_time < apply_dt) and (date_diff <= 720):
ft_v.append(x)
if len(ft_v) == 0: return 'null'
e_cnts = []
for e in [
'accountmobile', 'idnumber', 'deviceid', 'accountemail', 'qqnumber'
]:
cnt = len(set([x[e] for x in ft_v if x.get(e, '') != '']))
e_cnts.append(min(cnt, 9))
return '%s_%s_%s' % (id, apply_dt, ''.join([str(x) for x in e_cnts]))
def day_conferences_fct(self, obj):
day_conference_lst = []
day_conferences = DayConference.objects.filter(conference=obj)
for day_conference in day_conferences:
day_conference_dict = {}
day_conference_dict['id'] = day_conference.id
day_conference_dict['day'] = cal_utils.get_day(day_conference.day)
day_conference_dict['hour_start'] = cal_utils.get_hour(
day_conference.hour_start)
day_conference_dict['hour_end'] = cal_utils.get_hour(
day_conference.hour_end)
day_conference_dict['duration'] = cal_utils.get_duration(
day_conference.hour_start, day_conference.hour_end)
day_conference_dict['is_full'] = day_conference.is_full
day_conference_lst.append(day_conference_dict)
return day_conference_lst
def _get_day_conference_html_content(day_conference):
from django.template.loader import get_template
from django.template import Context
from calendar_activities.serializers import ConferenceNestedChildsSerializer
ser = ConferenceNestedChildsSerializer()
speakers_str = ser.get_speakers_str(day_conference.conference)
template_data = {}
template_data['reserveFor'] = 'attelier/conférence'
template_data['peoples'] = speakers_str
template_data['day'] = utils.get_day(day_conference.day)
template_data['hourStart'] = utils.get_hour(day_conference.hour_start)
template_data['hourEnd'] = utils.get_hour(day_conference.hour_end)
template_data['title'] = day_conference.conference.title
htmly = get_template('calendar_activities/reserve_day_html_msg.html')
d = Context(template_data)
html_content = htmly.render(d)
return unicode(html_content)
def get_num_coll_time():
"""
Function to get number of collisions in specified duration (can be specified hour/day/month/year)
:return:
"""
result = 0
if num_coll_time[0] == utils.HOUR:
result = r.get(
utils.get_key(utils.TIME, city, utils.HOUR, int(num_coll_time[1])))
elif num_coll_time[0] == utils.DAY:
result = r.get(
utils.get_key(utils.TIME, city, utils.DAY,
utils.get_day(int(num_coll_time[1]))))
elif num_coll_time[0] == utils.MONTH:
result = r.get(
utils.get_key(utils.TIME, city, utils.MONTH,
utils.get_month(int(num_coll_time[1]))))
elif num_coll_time[0] == utils.YEAR:
result = r.get(
utils.get_key(utils.TIME, city, utils.HOUR, int(num_coll_time[1])))
else:
raise ValueError('Invalid type of duration: ', num_coll_time[0])
return result
def _set_unset_daily_fare(self):
if self._week == get_week_number(
self._datetime) and self._day != get_day(self._datetime):
self.daily_fare = 0
def __init__(self, time_str, open_id, gbid):
self.time_str = time_str
self.timestamp = utils.get_time_stamp(time_str)
self.day = utils.get_day(time_str)
self.account = open_id
self.gbid = gbid
import os
import pandas as pd
import calendar
root_path = os.path.dirname(os.path.realpath(__file__)) + '/../'
sys.path.append(root_path + 'scripts/')
import utils
if len(sys.argv) < 4:
print("usage: ./dump_glassnode.py date endpoint metric")
quit()
dt = sys.argv[1]
endpoint = sys.argv[2]
metric = sys.argv[3]
yy = int(utils.get_year(dt))
mm = int(utils.get_month(dt))
dd = int(utils.get_day(dt))
sd = datetime.datetime(yy, mm, dd, 0, 0)
ed = sd + datetime.timedelta(1)
print(dt)
sd = calendar.timegm(sd.timetuple())
ed = calendar.timegm(ed.timetuple())
rics = pd.read_csv(root_path + '/data/compo/crypto/ftx.txt')
rics = list(rics.ric.unique())
#rics = ['btc', 'eth']
data_path = root_path + 'data/glassnode/{}/{}/'.format(endpoint, metric)
os.makedirs(data_path, 0o777, exist_ok=True)
df = pd.DataFrame()
for ric in rics:
print(ric)
sd = datetime.datetime.strptime(sd, '%Y%m%d')
ed = datetime.datetime.strptime(ed, '%Y%m%d')
rics = pd.read_csv(root_path + '/data/compo/crypto/{}.txt'.format(idx))
rics = list(rics.ric.unique())
#rics = ['BTC']
funding_path = root_path + 'data/funding/{}/'.format(idx)
os.makedirs(funding_path, 0o777, exist_ok=True)
s = Session()
ts = int(time.time() * 1000)
for d in [sd + datetime.timedelta(x) for x in range((ed - sd).days + 1)]:
d = d.strftime('%Y%m%d')
df = pd.DataFrame()
st = datetime.datetime(int(utils.get_year(d)), int(utils.get_month(d)),
int(utils.get_day(d)), 0, 0)
et = datetime.datetime(int(utils.get_year(d)), int(utils.get_month(d)),
int(utils.get_day(d)), 23, 59)
print('{} {}'.format(st, et))
st = calendar.timegm(st.timetuple())
et = calendar.timegm(et.timetuple())
for ric in rics:
print(ric)
request = Request(
'GET',
'https://ftx.com/api/funding_rates?start_time={}&end_time={}&future={}-PERP'
.format(st, et, ric))
prepared = request.prepare()
signature_payload = f'{ts}{prepared.method}{prepared.path_url}'.encode(
)
signature = hmac.new(
import os
import pandas as pd
import calendar
root_path = os.path.dirname(os.path.realpath(__file__)) + '/../../'
sys.path.append(root_path + 'scripts/')
import utils
if len(sys.argv) < 3:
print("usage: ./dump_erd_crypto.py date idx")
quit()
sd = sys.argv[1]
ed = sys.argv[2]
idx = sys.argv[3]
sd = datetime.datetime(int(utils.get_year(sd)), int(utils.get_month(sd)),
int(utils.get_day(sd)), 0, 0)
ed = datetime.datetime(int(utils.get_year(ed)), int(utils.get_month(ed)),
int(utils.get_day(ed)), 0, 0)
print('{} {}'.format(sd, ed))
sd = calendar.timegm(sd.timetuple())
ed = calendar.timegm(ed.timetuple())
#sd = int(time.mktime(sd.timetuple()))
#ed = int(time.mktime(ed.timetuple()))
rics = pd.read_csv(root_path + '/data/compo/crypto/{}.txt'.format(idx))
rics = list(rics.ric.unique())
erd_path = root_path + 'data/erd/{}/'.format(idx)
s = Session()
ts = int(time.time() * 1000)
df = pd.DataFrame()
for ric in rics: