def test_rmf_state_snapshot(self):
"""Test snapshot of RMFState class"""
session = make_session()
s = src.io._RMFState(session)
d = s.take_snapshot(session, None)
news = src.io._RMFState.restore_snapshot(session, d)
self.assertIsInstance(news, src.io._RMFState)
def test_rmf_drawing_snapshot(self):
"""Test snapshot of RMFDrawing class"""
session = make_session()
s = src.io._RMFDrawing(session)
d = s.take_snapshot(session, None)
news = src.io._RMFDrawing.restore_snapshot(session, d)
self.assertIsInstance(news, src.io._RMFDrawing)
def test_read_geometry(self):
"""Test open_rmf handling of RMF geometry"""
def make_rmf_file(fname):
r = RMF.create_rmf_file(fname)
r.add_frame("root", RMF.FRAME)
rn = r.get_root_node()
sf = RMF.SegmentFactory(r)
s = sf.get(rn.add_child("test segment", RMF.GEOMETRY))
s.set_coordinates_list([RMF.Vector3(0, 0, 0),
RMF.Vector3(5, 5, 5)])
s = sf.get(rn.add_child("test segment2", RMF.GEOMETRY))
s.set_coordinates_list([RMF.Vector3(0, 0, 0),
RMF.Vector3(5, 5, 5)])
# Segments are ignored unless they contain two points
s = sf.get(rn.add_child("test segment2", RMF.GEOMETRY))
s.set_coordinates_list([RMF.Vector3(0, 0, 0), RMF.Vector3(5, 5, 5),
RMF.Vector3(10, 10, 10)])
# Lines with zero length are ignored
s = sf.get(rn.add_child("null segment", RMF.GEOMETRY))
s.set_coordinates_list([RMF.Vector3(0, 0, 0),
RMF.Vector3(0, 0, 0)])
with utils.temporary_file(suffix='.rmf') as fname:
make_rmf_file(fname)
mock_session = make_session()
structures, status = src.io.open_rmf(mock_session, fname)
# Two shapes should have been added
shapes = structures[0]._drawing._drawing._shapes
self.assertEqual(len(shapes), 2)
def main(args):
env_name = "CartPole"
ep_len = args.ep_len
seed = args.seed
U.set_seed(seed)
env = CartPoleEnv(max_ep_len=ep_len, seed=seed + 1000)
obs_dim = 4
act_dim = 2
sess = U.make_session()
sess.__enter__()
'''load evaluation policy'''
q_net = Q_network(obs_dim,
act_dim,
seed=args.seed + 2000,
default_tau=args.tau)
U.initialize_all_vars()
q_net.load_model('./CartPole_Model/Model')
value_true = U.eval_policy_cartpole(env,
q_net,
ep_num=150,
gamma=args.gamma)
log_name = 'log.pickle'
logger = ope_log_class(path='./log/OnPolicy/{}'.format(args.tau),
name=log_name,
tau=args.tau,
env_name=env_name,
value_true=value_true)
logger.dump()
def __init__(self, d, layer_sizes, clip_norm=None):
self.sess = make_session()
self.clip_norm = clip_norm
dataset, (_, _), (self.x_test, self.y_test) = prepare_mnist_dataset(
batch_size=128, train_sample_size=6000, test_sample_size=1000)
self.iterator = dataset.make_initializable_iterator()
self.batch_input, self.batch_label = self.iterator.get_next()
self.hidden_layers = layer_sizes
self.n_layers = len(self.hidden_layers) + 1 # plus the output layer
self.shape_per_layer = [(28 * 28, self.hidden_layers[0])] + [
(self.hidden_layers[i], self.hidden_layers[i + 1])
for i in range(len(self.hidden_layers) - 1)
] + [(self.hidden_layers[-1], 10)]
logging.info(f"shape per layer: {self.shape_per_layer}")
self.d = d
self.D = np.sum((h + 1) * w for h, w in self.shape_per_layer)
logging.info(f"Experiment config: d={d} D={self.D}")
self.loss, self.accuracy = self.build_network(self.batch_input,
self.batch_label)
for t in tf.trainable_variables():
print(t)
np.random.seed(int(time.time()))
def __init__(self,
layer_sizes: list,
output_filename: str = DEFAULT_OUTPUT_FILENAME):
self.output_filename = output_filename
self.sess = make_session()
dataset, (_, _), (self.x_test, self.y_test) = prepare_mnist_dataset(
) # train_sample_size=6000, test_sample_size=1000)
self.iterator = dataset.make_initializable_iterator()
self.batch_input, self.batch_label = self.iterator.get_next()
self.layer_sizes = layer_sizes
self.num_layers = len(layer_sizes) + 1 # plus the output layer
self.loss_ph, self.accuracy_ph = create_mnist_model(
self.batch_input,
self.batch_label,
layer_sizes=layer_sizes,
dropout_keep_prob=0.9)
self._vars_by_layer = [
self._vars(f'mnist_dense_nn/mlp/mlp_l{i}')
for i in range(self.num_layers)
]
self._init_values_by_layer = None
np.random.seed(int(time.time()))
def test_rmf_software_provenance(self):
"""Test _RMFSoftwareProvenance class"""
class MockSoftwareProvenance:
def get_location(self):
return self.location
def get_name(self):
return self.software_name
def get_version(self):
return self.version
prov = MockSoftwareProvenance()
prov.location = 'foo'
prov.software_name = 'bar'
prov.version = 'baz'
rmf_node = MockRMFNode("r1", 1)
p = src.io._RMFSoftwareProvenance(rmf_node, prov)
mock_session = make_session()
s = p.take_snapshot(mock_session, None)
newp = src.io._RMFSoftwareProvenance.restore_snapshot(mock_session, s)
self.assertIsInstance(newp, src.io._RMFSoftwareProvenance)
self.assertEqual(newp.location, 'foo')
self.assertEqual(newp.software_name, 'bar')
self.assertEqual(newp.version, 'baz')
def test_load_provenance(self):
"""Test loading provenance"""
def get_first_tree(stack):
for w in stack.widget(2).children():
if isinstance(w, QTreeView):
self.assertIsInstance(w.model(),
src.tool._RMFProvenanceModel)
return w
raise ValueError("could not find tree")
def get_buttons(stack):
for w in stack.widget(2).children():
if isinstance(w, QPushButton):
yield w
root = make_node("root", 0)
mock_session = make_session()
m1 = src.io._RMFModel(mock_session, 'test')
m1.rmf_hierarchy = root
m1.rmf_features = []
p1 = make_provenance("f1", 4)
p2 = make_provenance("f2", 5)
p3 = make_provenance("f3", 6)
p1.hierarchy_node = root
p2.hierarchy_node = root
m1.rmf_provenance = [p1, p2, p3]
mock_session.models.add((m1, ))
r = src.tool.RMFViewer(mock_session, "RMF Viewer")
tree1 = get_first_tree(r.model_stack.widget(0))
tree1.selectAll()
r._load_button_clicked(tree1, m1)
load_button, = list(get_buttons(r.model_stack.widget(0)))
load_button.click()
def test_read_traj(self):
"""Test readtraj with a simple coarse-grained RMF file"""
path = os.path.join(INDIR, 'simple.rmf3')
mock_session = make_session()
mock_session.logger = MockLogger()
structures, status = src.io.open_rmf(mock_session, path)
state = structures[0].child_models()[0]
src.cmd.readtraj(mock_session, state)
def test_open_rmf_atomic(self):
"""Test open_rmf with a simple atomic RMF file"""
path = os.path.join(INDIR, 'simple_atomic.rmf3')
mock_session = make_session()
structures, status = src.io.open_rmf(mock_session, path)
state, = structures[0].child_models()
self.assertTrue(state._atomic)
state.apply_auto_styling()
def _save_in_db(self, model, **kwargs):
row = model(**kwargs)
with make_session() as session:
session.add(row)
session.flush()
session.commit()
id = row.id
return id
def main():
with make_session() as session:
username = prompt('Enter username: '******'Enter password: '))
user = UserModel(name=username,
password=bcrypt.hashpw(password, bcrypt.gensalt()))
session.add(user)
session.commit()
session.close()
def test_bundle_api_open_new(self):
"""Test open file via BundleAPI (new mechanism)"""
class MockOpenManager:
pass
mock_mgr = MockOpenManager()
bundle_api = src.bundle_api
path = os.path.join(INDIR, 'simple.rmf3')
mock_session = make_session()
oinfo = bundle_api.run_provider(mock_session, "RMF", mock_mgr)
structures, status = oinfo.open(mock_session, path, path)
def main(n_units=1, old_n_units=None, loss_type='mse', max_epochs=500, n_train_samples=4000):
assert old_n_units is None or old_n_units < n_units
logging.info(f"n_units:{n_units} max_epochs:{max_epochs}")
sess = make_session()
lr = 0.001
batch_size = 128
epoch, step, train_loss, train_acc, eval_loss, eval_acc = report_performance(
sess, n_units, old_n_units, max_epochs, loss_type, lr, batch_size, n_train_samples)
print(n_units, epoch, step, train_loss, train_acc, eval_loss, eval_acc)
def login():
log.info("User is logging in")
scope = ['identify', 'guilds']
discord = utils.make_session(scope=scope)
authorization_url, state = discord.authorization_url(
data_info.AUTHORIZATION_BASE_URL,
access_type="offline"
)
session['oauth2_state'] = state
return redirect(authorization_url)
def test_provenance(self):
"""Test open_rmf handling of RMF provenance"""
def make_rmf_file(fname):
r = RMF.create_rmf_file(fname)
r.add_frame("root", RMF.FRAME)
rn = r.get_root_node()
strucpf = RMF.StructureProvenanceFactory(r)
samplepf = RMF.SampleProvenanceFactory(r)
scriptpf = RMF.ScriptProvenanceFactory(r)
softwarepf = RMF.SoftwareProvenanceFactory(r)
n = rn.add_child("struc", RMF.PROVENANCE)
p = strucpf.get(n)
p.set_chain('A')
p.set_residue_offset(42)
p.set_filename('xyz')
n = n.add_child("sample", RMF.PROVENANCE)
p = samplepf.get(n)
p.set_frames(100)
p.set_iterations(10)
p.set_method('Monte Carlo')
p.set_replicas(8)
n = n.add_child("script", RMF.PROVENANCE)
p = scriptpf.get(n)
p.set_filename('abc')
n = rn.add_child("software", RMF.PROVENANCE)
p = softwarepf.get(n)
p.set_location('testurl')
p.set_name('testsoftware')
p.set_version('1.2.3')
n = rn.add_child("misc", RMF.PROVENANCE)
with utils.temporary_file(suffix='.rmf') as fname:
make_rmf_file(fname)
mock_session = make_session()
structures, status = src.io.open_rmf(mock_session, fname)
p1, p2, p3 = structures[0].rmf_provenance
self.assertEqual(p1.name, 'Chain A from xyz')
self.assertEqual(
p2.name,
'Using software testsoftware version 1.2.3 from testurl')
self.assertEqual(p3.name, 'misc')
self.assertIsNone(p2.previous)
prev = p1.previous
self.assertEqual(
prev.name, 'Sampling using Monte Carlo making 100 frames')
prev = prev.previous
self.assertIn('Using script', prev.name)
self.assertIsNone(prev.previous)
self.assertIsInstance(p3, src.io._RMFProvenance)
def login():
data_info.last_path = request.referrer
log.info("User is logging in")
scope = ['identify', 'guilds','email'] #email is for discourse rank purpose.
discord = utils.make_session(scope=scope)
authorization_url, state = discord.authorization_url(
data_info.AUTHORIZATION_BASE_URL,
access_type="offline"
)
session['oauth2_state'] = state
return redirect(authorization_url)
def test_hierarchy_node_snapshot(self):
"""Test take/restore snapshot of RMFHierarchyNode"""
rmf_node = MockRMFNode("r1", 1)
n = src.io._RMFHierarchyNode(rmf_node)
mock_session = make_session()
s = n.take_snapshot(mock_session, None)
newn = src.io._RMFHierarchyNode.restore_snapshot(mock_session, s)
self.assertIsInstance(newn, src.io._RMFHierarchyNode)
self.assertEqual(newn.name, "r1")
self.assertEqual(newn.rmf_index, 1)
self.assertEqual(newn.children, [])
def test_rmf_xlms_provenance(self):
"""Test _RMFXLMSRestraintProvenance class"""
rmf_node = MockRMFNode("r1", 1)
p = src.io._RMFXLMSRestraintProvenance(rmf_node, 'foo')
mock_session = make_session()
s = p.take_snapshot(mock_session, None)
newp = src.io._RMFXLMSRestraintProvenance.restore_snapshot(
mock_session, s)
self.assertIsInstance(newp, src.io._RMFXLMSRestraintProvenance)
self.assertEqual(newp.filename, 'foo')
def test_button_clicks(self):
"""Test clicking on select/show/hide buttons"""
def get_first_tree(stack):
for w in stack.widget(1).children():
if isinstance(w, QTreeView):
self.assertIsInstance(w.model(),
src.tool._RMFHierarchyModel)
return w
raise ValueError("could not find tree")
def get_buttons(stack):
for w in stack.widget(1).children():
if isinstance(w, QPushButton):
yield w
class TestChimeraObj:
def __init__(self, deleted=False):
self.deleted = deleted
root = make_node("root", 0, resolution=10)
child1 = make_node("child1", 1)
child1.chimera_obj = TestChimeraObj()
child2 = make_node("child2", 2)
grandchild = make_node("grandchild", 3)
child2.add_children([grandchild])
delchild = make_node("child3", 3)
delchild.chimera_obj = TestChimeraObj(deleted=True)
root.add_children((child1, child2, delchild))
mock_session = make_session()
m1 = Model(mock_session, 'test')
m1.rmf_hierarchy = root
m1.rmf_features = [make_node("f1", 4), make_node("f2", 5)]
m1.rmf_provenance = []
m1._rmf_resolutions = set((1, 10))
m1._selected_rmf_resolutions = set((1, 10, None))
mock_session.models.add((m1, ))
r = src.tool.RMFViewer(mock_session, "RMF Viewer")
tree1 = get_first_tree(r.model_stack.widget(0))
buttons = list(get_buttons(r.model_stack.widget(0)))
# Show, View, Hide, Select
self.assertEqual(len(buttons), 5)
# Call "clicked" methods directly
r._select_button_clicked(tree1)
tree1.selectAll()
r._show_button_clicked(tree1)
r._show_only_button_clicked(tree1)
r._hide_button_clicked(tree1)
r._view_button_clicked(tree1)
# Call indirectly via clicking each button
for b in buttons:
b.click()
def test_alternatives(self):
"""Test readtraj handling of RMF alternatives"""
def make_rmf_file(fname):
r = RMF.create_rmf_file(fname)
r.add_frame("root", RMF.FRAME)
rn = r.get_root_node()
af = RMF.AlternativesFactory(r)
pf = RMF.ParticleFactory(r)
gf = RMF.GaussianParticleFactory(r)
n = rn.add_child("topp1", RMF.REPRESENTATION)
p = n.add_child("p1", RMF.REPRESENTATION)
b = pf.get(p)
b.set_mass(1)
b.set_radius(4)
b.set_coordinates(RMF.Vector3(4., 5., 6.))
a = af.get(n)
root = r.add_node("topp2", RMF.REPRESENTATION)
p = root.add_child("p2", RMF.REPRESENTATION)
b = pf.get(p)
b.set_mass(1)
b.set_radius(4)
b.set_coordinates(RMF.Vector3(4., 5., 6.))
a.add_alternative(root, RMF.PARTICLE)
root = r.add_node("topg1", RMF.REPRESENTATION)
g = root.add_child("g1", RMF.REPRESENTATION)
b = gf.get(g)
b.set_variances(RMF.Vector3(1., 1., 1.))
b.set_mass(1.)
b = pf.get(g)
b.set_radius(4)
b.set_coordinates(RMF.Vector3(4., 5., 6.))
a.add_alternative(root, RMF.GAUSSIAN_PARTICLE)
r.add_frame("f1", RMF.FRAME)
r.add_frame("f2", RMF.FRAME)
r.add_frame("f3", RMF.FRAME)
r.add_frame("f4", RMF.FRAME)
r.add_frame("f5", RMF.FRAME)
with utils.temporary_file(suffix='.rmf') as fname:
make_rmf_file(fname)
mock_session = make_session()
mock_session.logger = MockLogger()
structures, status = src.io.open_rmf(mock_session, fname)
state = structures[0].child_models()[0]
# Just one frame to start with
self.assertEqual(list(state.coordset_ids), [1])
src.cmd.readtraj(mock_session, state, first=2, step=2)
# Two frames (f2, f4) should have been read
self.assertEqual(list(state.coordset_ids), [1, 3, 5])
def test_bundle_api_make_tool(self):
"""Test open of tool via BundleAPI"""
bundle_api = src.bundle_api
mock_session = make_session()
m1 = Model(mock_session, 'test')
mock_session.models.add((m1, ))
bi = MockBundleInfo()
ti = MockToolInfo("RMF Viewer")
bundle_api.start_tool(mock_session, bi, ti)
ti = MockToolInfo("Bad tool")
self.assertRaises(ValueError, bundle_api.start_tool, mock_session, bi,
ti)
def test_read_features(self):
"""Test open_rmf handling of RMF features"""
def make_rmf_file(fname):
r = RMF.create_rmf_file(fname)
r.add_frame("root", RMF.FRAME)
rn = r.get_root_node()
rf = RMF.RepresentationFactory(r)
bf = RMF.BallFactory(r)
n1 = rn.add_child("ball1", RMF.GEOMETRY)
b1 = bf.get(n1)
b1.set_radius(6)
b1.set_coordinates(RMF.Vector3(1., 2., 3.))
n2 = rn.add_child("ball2", RMF.GEOMETRY)
b2 = bf.get(n2)
b2.set_radius(6)
b2.set_coordinates(RMF.Vector3(4., 5., 6.))
n3 = rn.add_child("ball3", RMF.GEOMETRY)
b3 = bf.get(n3)
b3.set_radius(6)
b3.set_coordinates(RMF.Vector3(7., 8., 9.))
n = rn.add_child("feat 1", RMF.FEATURE)
f = rf.get(n)
f.set_representation([n1.get_id(), n2.get_id()])
childf = rf.get(n.add_child("child feat", RMF.FEATURE))
childf.set_representation([n1.get_id(), n2.get_id()])
f = rf.get(rn.add_child("feat 2", RMF.FEATURE))
f.set_representation([n2.get_id(), n3.get_id()])
# 3-particle feature (should be ignored)
f = rf.get(rn.add_child("feat 3", RMF.FEATURE))
f.set_representation([n1.get_id(), n2.get_id(), n3.get_id()])
with utils.temporary_file(suffix='.rmf') as fname:
make_rmf_file(fname)
mock_session = make_session()
structures, status = src.io.open_rmf(mock_session, fname)
# Three features (and one child) should have been added
features = structures[0].rmf_features
self.assertEqual(len(features), 3)
self.assertIsInstance(features[0].chimera_obj, Pseudobond)
self.assertIsInstance(features[1].chimera_obj, Pseudobond)
self.assertIsInstance(features[2].chimera_obj, Atoms)
child_feat, = features[0].children
self.assertIsInstance(child_feat.chimera_obj, Pseudobond)
def main():
args = get_args()
env = make_atari_env(args.env, args.seed)
benchmark_env = make_atari_env(args.env, args.seed + 1)
optimizer = tf.train.AdamOptimizer(learning_rate=args.lr, epsilon=1e-4)
exploration_schedule = utils.PiecewiseSchedule(
[
(0, 1.0),
(args.prepopulate, 1.0),
(args.prepopulate + args.explore_time, args.final_eps),
],
outside_value=args.final_eps,
)
if not args.legacy:
assert args.train_freq == 4 # Training frequency is undefined for DQN(lambda)
replay_memory = make_replay_memory(args.return_est, args.mem_size,
args.history_len, args.discount,
args.cache_size, args.block_size,
args.priority)
else:
assert args.cache_size == 80000 # Cache-related args are undefined for legacy DQN
assert args.priority == 0.0
assert args.block_size == 100
replay_memory = make_legacy_replay_memory(args.return_est,
args.mem_size,
args.history_len,
args.discount)
with utils.make_session(args.seed) as session:
dqn.learn(
session,
env,
benchmark_env,
atari_cnn,
replay_memory,
optimizer,
exploration_schedule,
args.timesteps,
args.batch_size,
args.prepopulate,
args.update_freq,
train_freq=args.train_freq,
grad_clip=args.grad_clip,
log_every_n_steps=1000,
)
env.close()
def test_rmf_script_provenance(self):
"""Test _RMFScriptProvenance class"""
class MockScriptProvenance:
def get_filename(self):
return self.filename
prov = MockScriptProvenance()
prov.filename = 'foo'
rmf_node = MockRMFNode("r1", 1)
p = src.io._RMFScriptProvenance(rmf_node, prov)
mock_session = make_session()
s = p.take_snapshot(mock_session, None)
newp = src.io._RMFScriptProvenance.restore_snapshot(mock_session, s)
self.assertIsInstance(newp, src.io._RMFScriptProvenance)
self.assertEqual(newp.filename, 'foo')
def test_rmf_viewer_snapshot(self):
"""Test snapshot of RMFViewer tool"""
mock_session = make_session()
m1 = Model(mock_session, 'test')
m1.rmf_hierarchy = None
m1.rmf_features = []
m1.rmf_provenance = []
m1._rmf_resolutions = set((1.0, 10.0))
m1._selected_rmf_resolutions = set((1.0, None))
mock_session.models.add((m1, ))
r = src.tool.RMFViewer(mock_session, "RMF Viewer")
s = r.take_snapshot(mock_session, None)
newr = src.tool.RMFViewer.restore_snapshot(mock_session, s)
self.assertIsInstance(newr, src.tool.RMFViewer)
def test_em2d_provenance(self):
"""Test open_rmf handling of RMF EM2D restraint provenance"""
def make_rmf_file(fname):
r = RMF.create_rmf_file(fname)
imp_restraint_cat = r.get_category("IMP restraint")
rsr_typek = r.get_key(imp_restraint_cat, "type", RMF.StringTag())
rsr_pixelsizek = r.get_key(imp_restraint_cat, "pixel size",
RMF.FloatTag())
imp_restraint_fn_cat = r.get_category("IMP restraint files")
rsr_imagefilesk = r.get_key(imp_restraint_fn_cat, "image files",
RMF.StringsTag())
r.add_frame("root", RMF.FRAME)
rn = r.get_root_node()
represf = RMF.RepresentationFactory(r)
particlef = RMF.ParticleFactory(r)
pn = rn.add_child("p1", RMF.REPRESENTATION)
p = particlef.get(pn)
p.set_mass(12.)
p.set_radius(1.)
p.set_coordinates(RMF.Vector3(1, 2, 3))
n = rn.add_child("nofname", RMF.FEATURE)
p = represf.get(n)
p.set_representation([pn])
n.set_value(rsr_typek, "IMP.em2d.PCAFitRestraint")
n = rn.add_child("emr", RMF.FEATURE)
p = represf.get(n)
p.set_representation([pn])
n.set_value(rsr_typek, "IMP.em2d.PCAFitRestraint")
n.set_value(rsr_pixelsizek, 1.0)
n.set_value(rsr_imagefilesk, ["abc", "def"])
with utils.temporary_file(suffix='.rmf') as fname:
make_rmf_file(fname)
mock_session = make_session()
structures, status = src.io.open_rmf(mock_session, fname)
p1, p2 = structures[0].rmf_provenance
self.assertIsInstance(p1, src.io._RMFEM2DRestraintProvenance)
self.assertEqual(p1.name, 'EM class average from abc')
self.assertAlmostEqual(p1.pixel_size, 1.0, delta=1e-6)
self.assertIsInstance(p2, src.io._RMFEM2DRestraintProvenance)
self.assertEqual(p2.name, 'EM class average from def')
self.assertAlmostEqual(p2.pixel_size, 1.0, delta=1e-6)
def test_rmf_em2d_restraint_provenance(self):
"""Test _RMFEM2DRestraintProvenance class"""
rmf_node = MockRMFNode("r1", 1)
with utils.temporary_directory() as tmpdir:
pgm = os.path.join(tmpdir, 'test.pgm2')
with open(pgm, 'w'):
pass
p = src.io._RMFEM2DRestraintProvenance(rmf_node, pgm, 4.0)
self.assertEqual(
p.name, 'EM class average from test.pgm2')
mock_session = make_session()
mock_session.logger = MockLogger()
model = src.io._RMFModel(mock_session, 'fname')
# Should be a noop since pgm2 isn't a known map format
p.load(mock_session, model)
def test_feature_snapshot(self):
"""Test take/restore snapshot of RMFFeature"""
rmf_node = MockRMFNode("r1", 1)
n = src.io._RMFFeature(rmf_node)
rmf_node = MockRMFNode("r2", 2)
child = src.io._RMFFeature(rmf_node)
n.add_child(child)
mock_session = make_session()
s = n.take_snapshot(mock_session, None)
newn = src.io._RMFFeature.restore_snapshot(mock_session, s)
self.assertIsInstance(newn, src.io._RMFFeature)
self.assertEqual(newn.name, "r1")
self.assertEqual(newn.rmf_index, 1)
self.assertEqual(newn.children, [child])
def test_resolution_clicked(self):
"""Test clicking on resolution checkboxes"""
def get_first_tree(stack):
for w in stack.widget(1).children():
if isinstance(w, QTreeView):
self.assertIsInstance(w.model(),
src.tool._RMFHierarchyModel)
return w
raise ValueError("could not find tree")
def get_buttons(stack):
for w in stack.widget(1).children():
if isinstance(w, QCheckBox):
yield w
class TestChimeraObj:
pass
root = make_node("root", 0)
child1 = make_node("child1", 1, resolution=1)
child2 = make_node("child2", 2, resolution=10)
root.add_children((child1, child2))
mock_session = make_session()
m1 = Model(mock_session, 'test')
m1.rmf_hierarchy = root
m1.rmf_features = [make_node("f1", 4), make_node("f2", 5)]
m1.rmf_provenance = []
m1._rmf_resolutions = set((1, 10))
m1._selected_rmf_resolutions = set((1, None))
mock_session.models.add((m1, ))
r = src.tool.RMFViewer(mock_session, "RMF Viewer")
tree1 = get_first_tree(r.model_stack.widget(0))
res1b, res10b = list(get_buttons(r.model_stack.widget(0)))
# Call "clicked" methods directly
# Show/hide resolution 10
cb = QCheckBox('foo')
cb.setChecked(True)
r._resolution_button_clicked(cb, tree1, 10)
cb = QCheckBox('bar')
cb.setChecked(False)
r._resolution_button_clicked(cb, tree1, 10)
tree1.selectAll()
# Call indirectly via clicking each button
for b in res1b, res10b:
b.click()
def test_save_snapshot_chimera_obj(self):
"""Test save_snapshot of Chimera objects"""
self.assertIsNone(src.io._save_snapshot_chimera_obj(None))
self.assertRaises(TypeError, src.io._save_snapshot_chimera_obj,
'non-chimera object')
session = make_session()
state = src.io._RMFState(session)
state2 = src.io._RMFState(session)
residue = state.new_residue('ALA', 'A', 1)
atom1 = state.new_atom('C', 'C')
residue.add_atom(atom1)
atom2 = state.new_atom('N', 'N')
residue.add_atom(atom2)
st2_residue = state2.new_residue('ALA', 'A', 1)
st2_atom1 = state2.new_atom('C', 'C')
st2_residue.add_atom(st2_atom1)
d = src.io._save_snapshot_chimera_obj(atom1)
self.assertEqual(d['type'], 'Atom')
# single structure
atoms = Atoms((atom1, atom2))
d = src.io._save_snapshot_chimera_obj(atoms)
self.assertEqual(d['type'], 'Atoms')
self.assertIn('single_structure', d)
# list of zero atoms
atoms = Atoms()
d = src.io._save_snapshot_chimera_obj(atoms)
self.assertEqual(d['type'], 'Atoms')
self.assertIn('single_structure', d)
# multiple structures
atoms = Atoms((atom1, st2_atom1))
d = src.io._save_snapshot_chimera_obj(atoms)
self.assertEqual(d['type'], 'Atoms')
self.assertIn('structures', d)
bond = state.new_bond(atom1, atom2)
d = src.io._save_snapshot_chimera_obj(bond)
self.assertEqual(d['type'], 'Bond')
pbond = state._add_pseudobond((atom1, atom2))
d = src.io._save_snapshot_chimera_obj(pbond)
self.assertEqual(d['type'], 'Pseudobond')
def main(keyword, dst_dir):
if not all([keyword, dst_dir]):
raise NoInputGivenException(
'Keyword or destination folder is not given.')
session = make_session()
search_results = search(session, keyword)
highest_download_count_link = get_highest_download_count_link(
search_results)
subtitle_info_url = highest_download_count_link['url']
url, data = get_subtitle_url_and_post_data(session, subtitle_info_url)
filename = get_filename_from_url(url)
download_subtitle(session, url, data, dst_dir, filename)
status = 'OK'
print(STATUS_MSG.format(keyword=keyword, status=status, filename=filename))
def confirm_login():
log.info("Checking login....")
# Check for state and for 0 errors
state = session.get('oauth2_state')
if not state or request.values.get('error'):
return redirect(url_for('index'))
# Fetch token
discord = utils.make_session(state=state)
discord_token = discord.fetch_token(
data_info.TOKEN_URL,
client_secret=data_info.OAUTH2_CLIENT_SECRET,
authorization_response=request.url)
if not discord_token:
log.info("Not clear, returning")
return redirect(url_for('index'))
# Fetch the user
user = utils.get_user(discord_token)
# Generate api_key from user_id
serializer = JSONWebSignatureSerializer(app.config['SECRET_KEY'])
api_key = str(serializer.dumps({'user_id': user['id']}))
# Store api_key
db.set('user:{}:api_key'.format(user['id']), api_key)
# Store token
db.set('user:{}:discord_token'.format(user['id']), json.dumps(discord_token))
# Store api_token in client session
api_token = {
'api_key': api_key,
'user_id': user['id']
}
session.permanent = True
session['api_token'] = api_token
log.info("Clear, redirect...")
if data_info.last_path:
return redirect(data_info.last_path)
return redirect(url_for('after_login'))
# -*- coding:utf-8 -*-
from urllib.parse import parse_qsl
import simplejson
from utils import make_session
SESSION = make_session()
SESSION.headers['Referer'] = 'http://map.naver.com/'
def make_url(keyword):
base_url = ('http://map.naver.com/search2/'
'local.nhn?sm=hty&isFirstSearch=true&'
'query=%EC%98%81%EB%93%B1%ED%8F%AC%EC%97%AD&menu=location')
url = []
for k, v in parse_qsl(base_url):
if k == 'query':
v = keyword
url.append('{0}={1}&'.format(k, v))
url = ''.join(url)[:-1]
return url
def get_json(keyword):
url = make_url(keyword)
return SESSION.get(url).json()
def main(keyword):
def save_session(username):
session = make_session()
db.update('auth_user', where="username='******'" % clean_input(username), session=session)
return session
