def test_round_trip_annotations():
"""Test that annotations can make the round trip from a simple dictionary to the synapse format and back"""
a = dict(foo=1234, zoo=[123.1, 456.2, 789.3], species='Moose',
birthdays=[Datetime(1969, 4, 28), Datetime(1973, 12, 8), Datetime(2008, 1, 3), Datetime(2013, 3, 15)])
sa = to_synapse_annotations(a)
a2 = from_synapse_annotations(sa)
a = a2
def test_timestamp_mismatch(is_java, con):
if not is_java:
mst = pytz.timezone("America/Edmonton")
con.run("SET SESSION TIME ZONE 'America/Edmonton'")
try:
con.run("CREATE TEMPORARY TABLE TestTz "
"(f1 timestamp with time zone, "
"f2 timestamp without time zone)")
con.run(
"INSERT INTO TestTz (f1, f2) VALUES (:v1, :v2)",
# insert timestamp into timestamptz field (v1)
v1=Datetime(2001, 2, 3, 4, 5, 6, 170000),
# insert timestamptz into timestamp field (v2)
v2=mst.localize(Datetime(2001, 2, 3, 4, 5, 6, 170000)))
retval = con.run("SELECT f1, f2 FROM TestTz")
# when inserting a timestamp into a timestamptz field,
# postgresql assumes that it is in local time. So the value
# that comes out will be the server's local time interpretation
# of v1. We've set the server's TZ to MST, the time should
# be...
f1 = retval[0][0]
assert f1 == Datetime(2001, 2, 3, 11, 5, 6, 170000, Timezone.utc)
# inserting the timestamptz into a timestamp field, pg8000
# converts the value into UTC, and then the PG server converts
# it into local time for insertion into the field. When we
# query for it, we get the same time back, like the tz was
# dropped.
f2 = retval[0][1]
assert f2 == Datetime(2001, 2, 3, 4, 5, 6, 170000)
finally:
con.run("SET SESSION TIME ZONE DEFAULT")
def test_executemany(db_table):
with db_table.cursor() as cursor:
cursor.executemany("INSERT INTO t1 (f1, f2, f3) VALUES (%s, %s, %s)",
((1, 1, "Avast ye!"), (2, 1, None)))
cursor.executemany("select %s",
((Datetime(2014, 5, 7, tzinfo=Timezone.utc), ),
(Datetime(2014, 5, 7), )))
def test_executemany(db_table):
cursor = db_table.cursor()
cursor.executemany(
"INSERT INTO t1 (f1, f2, f3) VALUES (%s, %s, %s)",
((1, 1, "Avast ye!"), (2, 1, None)),
)
cursor.executemany(
"select CAST(%s AS TIMESTAMP)",
((Datetime(2014, 5, 7, tzinfo=Timezone.utc),), (Datetime(2014, 5, 7),)),
)
def test_more_annotations():
"""Test long, float and data annotations"""
a = dict(foo=1234, zoo=[123.1, 456.2, 789.3], species='Platypus', birthdays=[Datetime(1969,4,28), Datetime(1973,12,8), Datetime(2008,1,3)])
sa = to_synapse_annotations(a)
# print sa
assert sa['longAnnotations']['foo'] == [1234]
assert sa['doubleAnnotations']['zoo'] == [123.1, 456.2, 789.3]
assert sa['stringAnnotations']['species'] == ['Platypus']
## this part of the test is kinda fragile. It it breaks again, it should be removed
bdays = [utils.from_unix_epoch_time(t) for t in sa['dateAnnotations']['birthdays']]
assert all([t in bdays for t in [Datetime(1969,4,28), Datetime(1973,12,8), Datetime(2008,1,3)]])
def test_more_annotations():
"""Test long, float and data annotations"""
a = Annotations(
'syn123', '7bdb83e9-a50a-46e4-987a-4962559f090f', {
'foo':
1234,
'zoo': [123.1, 456.2, 789.3],
'species':
'Platypus',
'birthdays': [
Datetime(1969, 4, 28),
Datetime(1973, 12, 8),
Datetime(2008, 1, 3)
],
'test_boolean':
True,
'test_mo_booleans': [False, True, True, False]
})
sa = to_synapse_annotations(a)
expected = {
'id': 'syn123',
'etag': '7bdb83e9-a50a-46e4-987a-4962559f090f',
'annotations': {
'foo': {
'value': ['1234'],
'type': 'LONG'
},
'zoo': {
'value': ['123.1', '456.2', '789.3'],
'type': 'DOUBLE'
},
'species': {
'value': ['Platypus'],
'type': 'STRING'
},
'birthdays': {
'value': ['-21427200000', '124156800000', '1199318400000'],
'type': 'TIMESTAMP_MS'
},
'test_boolean': {
'value': ['true'],
'type': 'STRING'
},
'test_mo_booleans': {
'value': ['false', 'true', 'true', 'false'],
'type': 'STRING'
}
}
}
assert expected == sa
def testExecutemany(self):
try:
cursor = self.db.cursor()
cursor.executemany(
"INSERT INTO t1 (f1, f2, f3) VALUES (%s, %s, %s)",
((1, 1, 'Avast ye!'), (2, 1, None)))
cursor.executemany(
"select %s",
(
(Datetime(2014, 5, 7, tzinfo=Timezone.utc), ),
(Datetime(2014, 5, 7),)))
finally:
cursor.close()
self.db.commit()
def create_ical_download(open_day, end_day, data):
semester_open_day = Datetime.strptime(open_day,
"%Y-%m-%d").strftime("%Y%m%d")
semester_end_day = (Datetime.strptime(end_day, "%Y-%m-%d") +
timedelta(1)).strftime("%Y%m%d")
# Add header of iCalendar
cal = Calendar()
cal.add('PRODID', '-//Google Inc//Google Calendar 70.9054//EN')
cal.add('VERSION', '2.0')
cal.add('TZID', 'Asia/Bangkok')
cal.add('X-LIC-LOCATION', 'Asia/Bangkok')
cal.add('TZOFFSETFROM', timedelta(hours=7))
cal.add('TZOFFSETTO', timedelta(hours=7))
cal.add('TZNAME', 'ICT')
cal.add('DTSTART', Datetime(1970, 1, 1))
subjects = getSubject(semester_open_day, semester_end_day, data)
for subject in subjects:
event = Event()
event['summary'] = subject['subject']
event['dtstart'] = subject['date_start'] + subject['time_start']
event['dtend'] = subject['date_start'] + subject['time_end']
event[
'rrule'] = 'FREQ=WEEKLY;UNTIL=' + semester_end_day + ';BYDAY=' + subject[
'day_of_week']
event['description'] = subject['description']
event['location'] = subject['location']
cal.add_component(event)
return display(cal.to_ical())
def do_get(sess):
base_name = []
if 'scenario_id' in request.values:
scenario_id = req_int('scenario_id')
scenario_props = None
else:
year = req_int("finish_year")
month = req_int("finish_month")
months = req_int("months")
start_date = Datetime(year, month, 1) - \
relativedelta(months=months - 1)
scenario_props = {
'scenario_start': start_date,
'scenario_duration': months
}
scenario_id = None
base_name.append('monthly_duration')
site_id = req_int('site_id') if 'site_id' in request.values else None
supply_id = req_int('supply_id') if 'supply_id' in request.values else None
if 'compression' in request.values:
compression = req_bool('compression')
else:
compression = True
user = g.user
threading.Thread(target=content,
args=(scenario_props, scenario_id, base_name, site_id,
supply_id, user, compression)).start()
return chellow_redirect("/downloads", 303)
def test_dumps():
book = OrderedDict(
(('title', 'A Hero of Our Time'), ('read_date',
Datetime(2017,
7,
16,
14,
5,
tzinfo=Timezone.utc)),
('would_recommend', True), ('description', None),
('number_of_novellas', 5), ('price', Decimal('7.99')),
('weight', 6.88), ('key', bytearray(b'kshhgrl')),
('tags', ['russian', 'novel', '19th centuary'])))
ion_str = """{
'description': null,
'key': {{ a3NoaGdybA== }},
'number_of_novellas': 5,
'price': 7.99,
'read_date': 2017-07-16T14:05:00Z,
'tags': [
"russian",
"novel",
"19th centuary"],
'title': "A Hero of Our Time",
'weight': 6.88,
'would_recommend': true}"""
assert dumps(book) == ion_str
class SSD():
__tablename__ = 'ssd'
id = Column(Integer, primary_key=True)
model = Column('model', String(32))
maker = Column('model', String(20))
capacity = Column('capacity', Integer, default=1)
created_on = Column('created_on', Datetime, default=Datetime.now(tz=timezone('America/Montreal')))
class Gpu():
__tablename__ = 'gpu'
id = Column(Integer, primary_key=True)
model = Column('model', String(32))
ram = Column('ram', String(10), default=1)
maker = Column('maker', String(20))
created_on = Column('created_on', Datetime, default=Datetime.now(tz=timezone('America/Montreal')))
def quantize(self, duration, snap_out=False, timezone='UTC'):
"""Returns a quanitzed interval."""
# Convert seconds to timedelta, if appropriate.
duration = _seconds_or_timedelta(duration)
timezone = pytz.timezone(timezone)
if duration <= timedelta(seconds=0):
raise ValueError('cannot quantize by non-positive timedelta')
epoch = timezone.localize(Datetime(1970, 1, 1))
seconds = int(duration.total_seconds())
start_seconds = int(
(self.start.datetime(naive=False) - epoch).total_seconds()
)
end_seconds = int(
(self.end.datetime(naive=False) - epoch).total_seconds()
)
if start_seconds % seconds and not snap_out:
start_seconds += seconds
if end_seconds % seconds and snap_out:
end_seconds += seconds
start_seconds -= start_seconds % seconds
end_seconds -= end_seconds % seconds
if start_seconds > end_seconds:
start_seconds = end_seconds
return MayaInterval(
start=MayaDT.from_datetime(epoch).add(seconds=start_seconds),
end=MayaDT.from_datetime(epoch).add(seconds=end_seconds),
)
class Memory():
__tablename__ = 'memory'
id = Column(Integer, primary_key=True)
model = Column('model', String(32), unique=True)
frequency = Column('frequency', Integer, default=2133)
maker = Column('maker', String(20))
created_on = Column('created_on', Datetime, default=Datetime.now(tz=timezone('America/Montreal')))
def __dt_to_epoch(dt):
"""Converts a datetime into an epoch."""
# Assume UTC if no datetime is provided.
if dt.tzinfo is None:
dt = dt.replace(tzinfo=pytz.utc)
epoch_start = Datetime(*MayaDT.__EPOCH_START, tzinfo=pytz.timezone('UTC'))
return (dt - epoch_start).total_seconds()
def test_timestamp_tz_roundtrip(is_java, cursor):
if not is_java:
mst = pytz.timezone("America/Edmonton")
v1 = mst.localize(Datetime(2001, 2, 3, 4, 5, 6, 170000))
cursor.execute("SELECT cast(%s as timestamptz)", (v1,))
v2 = cursor.fetchall()[0][0]
assert v2.tzinfo is not None
assert v1 == v2
class Cpu():
__tablename__ = 'cpu'
id = Column(Integer, primary_key=True)
model = Column('model', String(32), unique=True)
frequency = Column('frequency', Float, default=2.0)
nb_cores = Colum('nb_cores', Integer, default=1)
maker = Column('maker', String(20))
created_on = Column('created_on', Datetime, default=Datetime.now(tz=timezone('America/Montreal')))
class Motherboard():
__tablename__ = 'motherboard'
id = Column(Integer, primary_key=True)
model = Column('model', String(32))
pcie_qty = Column('pcie_qty', Integer, default=1)
sata_qty = Column('sata_qty', Integer, default=1)
fans_qty = Column('fans_qty', Integer, default=1)
created_on = Column('created_on', Datetime, default=Datetime.now(tz=timezone('America/Montreal')))
def test_idempotent_annotations():
"""test that to_synapse_annotations won't mess up a dictionary that's already in the synapse format"""
a = dict(species='Moose', n=42, birthday=Datetime(1969, 4, 28))
sa = to_synapse_annotations(a)
a2 = dict()
a2.update(sa)
sa2 = to_synapse_annotations(a2)
assert_equals(sa, sa2)
def test_timestamp_tz_roundtrip(is_java, con):
if not is_java:
mst = pytz.timezone("America/Edmonton")
v1 = mst.localize(Datetime(2001, 2, 3, 4, 5, 6, 170000))
retval = con.run("SELECT cast(:v as timestamptz)", v=v1)
v2 = retval[0][0]
assert v2.tzinfo is not None
assert v1 == v2
def test_mixed_annotations():
"""test that to_synapse_annotations will coerce a list of mixed types to strings"""
a = dict(foo=[1, 'a', Datetime(1969, 4, 28, 11, 47)])
sa = to_synapse_annotations(a)
a2 = from_synapse_annotations(sa)
assert a2['foo'][0] == '1'
assert a2['foo'][1] == 'a'
assert a2['foo'][2].find('1969') > -1
def test_timestamp_tz_out(con):
retval = con.run("SELECT '2001-02-03 04:05:06.17 America/Edmonton'"
"::timestamp with time zone")
dt = retval[0][0]
assert dt.tzinfo is not None, "no tzinfo returned"
assert dt.astimezone(Timezone.utc) == Datetime(
2001, 2, 3, 11, 5, 6, 170000, Timezone.utc), \
"retrieved value match failed"
def testTimestampTzOut(self):
self.cursor.execute("SELECT '2001-02-03 04:05:06.17 America/Edmonton'"
"::timestamp with time zone")
retval = self.cursor.fetchall()
dt = retval[0][0]
self.assertEqual(dt.tzinfo is not None, True, "no tzinfo returned")
self.assertEqual(dt.astimezone(Timezone.utc),
Datetime(2001, 2, 3, 11, 5, 6, 170000, Timezone.utc),
"retrieved value match failed")
def Timestamp(year, month, day, hour, minute, second):
"""Construct an object holding a timestamp value.
This function is part of the `DBAPI 2.0 specification
<http://www.python.org/dev/peps/pep-0249/>`_.
:rtype: :class:`datetime.datetime`
"""
return Datetime(year, month, day, hour, minute, second)
def test_more_annotations():
"""Test long, float and data annotations"""
a = dict(foo=1234,
zoo=[123.1, 456.2, 789.3],
species='Platypus',
birthdays=[Datetime(1969, 4, 28), Datetime(1973, 12, 8), Datetime(2008, 1, 3)],
test_boolean=True,
test_mo_booleans=[False, True, True, False])
sa = to_synapse_annotations(a)
assert_equals(sa['longAnnotations']['foo'], [1234])
assert_equals(sa['doubleAnnotations']['zoo'], [123.1, 456.2, 789.3])
assert_equals(sa['stringAnnotations']['species'], ['Platypus'])
assert_equals(sa['stringAnnotations']['test_boolean'], ['true'])
assert_equals(sa['stringAnnotations']['test_mo_booleans'], ['false', 'true', 'true', 'false'])
# this part of the test is kinda fragile. It it breaks again, it should be removed
bdays = [utils.from_unix_epoch_time(t) for t in sa['dateAnnotations']['birthdays']]
assert_true(all([t in bdays for t in [Datetime(1969, 4, 28), Datetime(1973, 12, 8), Datetime(2008, 1, 3)]]))
def testTimestampTzRoundtrip(self):
if not IS_JYTHON:
mst = pytz.timezone("America/Edmonton")
v1 = mst.localize(Datetime(2001, 2, 3, 4, 5, 6, 170000))
self.cursor.execute("SELECT %s as f1", (v1, ))
retval = self.cursor.fetchall()
v2 = retval[0][0]
self.assertNotEqual(v2.tzinfo, None)
self.assertEqual(v1, v2)
def test_idempotent_annotations():
"""test that to_synapse_annotations won't mess up a dictionary that's already in the synapse format"""
a = Annotations('syn123', '7bdb83e9-a50a-46e4-987a-4962559f090f',
{'species': 'Moose', 'n': 42, 'birthday': Datetime(1969, 4, 28), 'fact': True})
sa = to_synapse_annotations(a)
a2 = {}
a2.update(sa)
sa2 = to_synapse_annotations(a2)
assert sa == sa2
def get_initialization_data(taxpayer, logger=None, process_params=None):
try:
initialization_data_backup = taxpayer['data'][
'initialization'] if 'data' in taxpayer and 'initialization' in taxpayer[
'data'] else {}
new_initialization_data = dict(initialization_data_backup)
year = None
month = None
for year in initialization_data_backup:
months_of_this_year_to_initialize = new_initialization_data[year]
if len(months_of_this_year_to_initialize) > 0:
month = months_of_this_year_to_initialize.pop()
new_initialization_data[
year] = months_of_this_year_to_initialize
break
else:
del new_initialization_data[year]
year = None
if 'year' in process_params:
year = process_params['year']
month = process_params['month']
if year is None and month is None:
initialization_data = {
'initialized': True,
'new_initialization_data': new_initialization_data
} # End of initialization_data
else:
begin_date = Datetime(int(year), int(month), 1)
end_date = Datetime(int(year), int(month),
_Utilities.get_month_days(month))
initialization_data = {
'initialized': False,
'new_initialization_data': new_initialization_data,
'year': year,
'month': month,
'begin_date': begin_date,
'end_date': end_date
} # End of initialization_data
return initialization_data
except Exception as e:
if logger is not None:
logger.critical(e.message)
already_handled_exception = Already_Handled_Exception(e.message)
raise already_handled_exception
def test_round_trip_annotations():
"""Test that annotations can make the round trip from a simple dictionary to the synapse format and back"""
a = Annotations(
'syn123', '7bdb83e9-a50a-46e4-987a-4962559f090f', {
'foo': [1234],
'zoo': [123.1, 456.2, 789.3],
'species': ['Moose'],
'birthdays': [
Datetime(1969, 4, 28),
Datetime(1973, 12, 8),
Datetime(2008, 1, 3),
Datetime(2013, 3, 15)
]
})
sa = to_synapse_annotations(a)
a2 = from_synapse_annotations(sa)
assert a == a2
assert a.id == a2.id
assert a.etag == a2.etag
def test__convert_to_annotations_list():
"""Test long, float and data annotations"""
a = {'foo': 1234,
'zoo': [123.1, 456.2, 789.3],
'species': 'Platypus',
'birthdays': [Datetime(1969, 4, 28), Datetime(1973, 12, 8), Datetime(2008, 1, 3)],
'test_boolean': True,
'test_mo_booleans': [False, True, True, False]}
actual_annos = _convert_to_annotations_list(a)
expected_annos = {'foo': {'value': ['1234'],
'type': 'LONG'},
'zoo': {'value': ['123.1', '456.2', '789.3'],
'type': 'DOUBLE'},
'species': {'value': ['Platypus'],
'type': 'STRING'},
'birthdays': {'value': ['-21427200000', '124156800000', '1199318400000'],
'type': 'TIMESTAMP_MS'},
'test_boolean': {'value': ['true'],
'type': 'BOOLEAN'},
'test_mo_booleans': {'value': ['false', 'true', 'true', 'false'],
'type': 'BOOLEAN'}}
assert expected_annos == actual_annos
a_with_single_value = {'foo': 1234,
'zoo': 123.1,
'species': 'Platypus',
'birthdays': Datetime(1969, 4, 28),
'test_boolean': True}
actual_annos = _convert_to_annotations_list(a_with_single_value)
expected_annos = {'foo': {'value': ['1234'],
'type': 'LONG'},
'zoo': {'value': ['123.1'],
'type': 'DOUBLE'},
'species': {'value': ['Platypus'],
'type': 'STRING'},
'birthdays': {'value': ['-21427200000'],
'type': 'TIMESTAMP_MS'},
'test_boolean': {'value': ['true'],
'type': 'BOOLEAN'}}
assert expected_annos == actual_annos
