def tear_down():
conn = engine.connect()
conn.execute(Libration.__table__.delete())
conn.execute(TwoBodyLibration.__table__.delete())
conn.execute(TwoBodyResonance.__table__.delete())
conn.execute(ThreeBodyResonance.__table__.delete())
conn.execute(Planet.__table__.delete())
conn.execute(Asteroid.__table__.delete())
def delete(self, for_resonance_id):
if self._phase_storage == PhaseStorage.redis:
REDIS.delete(_get_rediskey_name(for_resonance_id))
elif self._phase_storage == PhaseStorage.db:
conn = engine.connect()
conn.execute("DELETE FROM %s WHERE resonance_id = %s;" % (TABLENAME, for_resonance_id))
elif self._phase_storage == PhaseStorage.file:
filepath = get_file_name(for_resonance_id)
if os.path.exists(filepath):
os.remove(filepath)
def __init__(self, planets: Tuple[str], is_recursive: bool, clear: bool,
clear_s3: bool, is_current: bool = False,
phase_storage: PhaseStorage = PhaseStorage.redis, is_verbose: bool = False):
self._is_verbose = is_verbose
self._clear_s3 = clear_s3
self._planets = planets
self._is_recursive = is_recursive
self._is_current = is_current
self._phase_storage = None if clear else phase_storage
self._clear = clear
conn = engine.connect()
table = Libration.__table__ if len(planets) == 2 else TwoBodyLibration.__table__
fix_id_sequence(table, conn)
def test_id_sequences_errors(line_data: List[str], next_line_data: List[str], planets: List[Tuple],
test_table: Table,
_constraint_fixture):
resonance_factory = get_resonance_factory(planets[0], line_data, 1)
build_resonance(resonance_factory)
conn = engine.connect()
conn.execute('ALTER SEQUENCE %s_id_seq RESTART WITH 1;' % test_table.name)
resonance_factory = get_resonance_factory(planets[1], next_line_data, 1)
build_resonance(resonance_factory)
for i, entry in enumerate(session.query(test_table).all()):
assert (i + 1) == entry.id
def load(self, resonance_id: int) -> List[float]:
phases = None
if self._phase_storage == PhaseStorage.redis:
phases = [
json.loads(x.decode('utf-8').replace('\'', '"'))['value']
for x in REDIS.lrange(_get_rediskey_name(resonance_id), 0, -1)
]
elif self._phase_storage == PhaseStorage.db:
conn = engine.connect()
result = conn.execute('SELECT value FROM %s WHERE resonance_id=%i' %
(TABLENAME, resonance_id))
phases = [x['value'] for x in result]
elif self._phase_storage == PhaseStorage.file:
with open(get_file_name(resonance_id)) as f:
phases = [json.loads(x.replace('\'', '"'))['value'] for x in f]
return phases
def clear_phases(start: int, stop: int, planets: Tuple[str]):
conn = engine.connect()
resonance_ids = []
redis_logged = False
for resonance in get_resonances(start, stop, False, planets):
try:
REDIS.delete('%s:%i' % (TABLENAME, resonance.id))
except ConnectionError:
redis_logged = _log_redis(redis_logged)
resonance_ids.append(str(resonance.id))
filename = get_file_name(resonance.id)
if os.path.exists(filename):
os.remove(filename)
conn.execute("DELETE FROM %s WHERE resonance_id = ANY('{%s}'::int[]);" %
(TABLENAME, ','.join(resonance_ids)))
def clear_resonance_finalizer(conn=None):
if not conn:
conn = engine.connect()
for table in TARGET_TABLES:
conn.execute(table.delete())
def fin():
conn = engine.connect()
for table in TARGET_TABLES:
conn.execute("ALTER SEQUENCE %s_id_seq RESTART WITH 1;" % table.name)
clear_resonance_finalizer(conn)
