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