content
stringlengths
7
928k
avg_line_length
float64
3.5
33.8k
max_line_length
int64
6
139k
alphanum_fraction
float64
0.08
0.96
licenses
sequence
repository_name
stringlengths
7
104
path
stringlengths
4
230
size
int64
7
928k
lang
stringclasses
1 value
# Copyright 2020 gRPC authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """The Python AsyncIO implementation of the GRPC helloworld.Greeter server.""" import logging import asyncio import grpc import helloworld_pb2 import helloworld_pb2_grpc class Greeter(helloworld_pb2_grpc.GreeterServicer): async def SayHello( self, request: helloworld_pb2.HelloRequest, context: grpc.aio.ServicerContext) -> helloworld_pb2.HelloReply: return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name) async def serve() -> None: server = grpc.aio.server() helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server) listen_addr = '[::]:50051' server.add_insecure_port(listen_addr) logging.info("Starting server on %s", listen_addr) await server.start() try: await server.wait_for_termination() except KeyboardInterrupt: # Shuts down the server with 0 seconds of grace period. During the # grace period, the server won't accept new connections and allow # existing RPCs to continue within the grace period. await server.stop(0) if __name__ == '__main__': logging.basicConfig(level=logging.INFO) asyncio.run(serve())
34.215686
78
0.731805
[ "Apache-2.0" ]
1261385937/grpc
examples/python/helloworld/async_greeter_server.py
1,745
Python
import scipy.sparse as sp import numpy as np import torch import time import os from configparser import ConfigParser import sys sys.path.append('/home/shiyan/project/gcn_for_prediction_of_protein_interactions/') from src.util.load_data import load_data, sparse_to_tuple, mask_test_edges, preprocess_graph from src.util.loss import arga_loss_function, varga_loss_function from src.util.metrics import get_roc_score from src.util import define_optimizer from src.graph_nheads_att_gan.model import NHGATModelGAN DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu') class Train(): def __init__(self): pass def train_model(self, config_path): if os.path.exists(config_path) and (os.path.split(config_path)[1].split('.')[0] == 'config') and ( os.path.splitext(config_path)[1].split('.')[1] == 'cfg'): # load config file config = ConfigParser() config.read(config_path) section = config.sections()[0] # data catalog path data_catalog = config.get(section, "data_catalog") # train file path train_file_name = config.get(section, "train_file_name") # model save/load path model_path = config.get(section, "model_path") # model param config hidden_dim1 = config.getint(section, "hidden_dim1") hidden_dim2 = config.getint(section, "hidden_dim2") hidden_dim3 = config.getint(section, 'hidden_dim3') num_heads = config.getint(section, 'num_heads') dropout = config.getfloat(section, "dropout") vae_bool = config.getboolean(section, 'vae_bool') alpha = config.getfloat(section, 'alpha') lr = config.getfloat(section, "lr") lr_decay = config.getfloat(section, 'lr_decay') weight_decay = config.getfloat(section, "weight_decay") gamma = config.getfloat(section, "gamma") momentum = config.getfloat(section, "momentum") eps = config.getfloat(section, "eps") clip = config.getfloat(section, "clip") epochs = config.getint(section, "epochs") optimizer_name = config.get(section, "optimizer") # 加载相关数据 adj = load_data(os.path.join(data_catalog, train_file_name)) num_nodes = adj.shape[0] num_edges = adj.sum() features = sparse_to_tuple(sp.identity(num_nodes)) num_features = features[2][1] # 去除对角线元素 # 下边的右部分为:返回adj_orig的对角元素(一维),并增加一维,抽出adj_orig的对角元素并构建只有这些对角元素的对角矩阵 adj_orig = adj - sp.dia_matrix((adj.diagonal()[np.newaxis, :], [0]), shape=adj.shape) adj_orig.eliminate_zeros() adj_train, train_edges, val_edges, val_edges_false, test_edges, test_edges_false = mask_test_edges(adj_orig) adj = adj_train # 返回D^{-0.5}SD^{-0.5}的coords, data, shape,其中S=A+I adj_norm = preprocess_graph(adj) adj_label = adj_train + sp.eye(adj_train.shape[0]) # adj_label = sparse_to_tuple(adj_label) adj_label = torch.FloatTensor(adj_label.toarray()).to(DEVICE) ''' 注意,adj的每个元素非1即0。pos_weight是用于训练的邻接矩阵中负样本边(既不存在的边)和正样本边的倍数(即比值),这个数值在二分类交叉熵损失函数中用到, 如果正样本边所占的比例和负样本边所占比例失衡,比如正样本边很多,负样本边很少,那么在求loss的时候可以提供weight参数,将正样本边的weight设置小一点,负样本边的weight设置大一点, 此时能够很好的平衡两类在loss中的占比,任务效果可以得到进一步提升。参考:https://www.zhihu.com/question/383567632 负样本边的weight都为1,正样本边的weight都为pos_weight ''' pos_weight = float(adj.shape[0] * adj.shape[0] - num_edges) / num_edges norm = adj.shape[0] * adj.shape[0] / float((adj.shape[0] * adj.shape[0] - adj.sum()) * 2) # create model print('create model ...') model = NHGATModelGAN(num_features, hidden_dim1=hidden_dim1, hidden_dim2=hidden_dim2, hidden_dim3=hidden_dim3, num_heads=num_heads, dropout=dropout, alpha=alpha, vae_bool=vae_bool) # define optimizer if optimizer_name == 'adam': optimizer = define_optimizer.define_optimizer_adam(model, lr=lr, weight_decay=weight_decay) elif optimizer_name == 'adamw': optimizer = define_optimizer.define_optimizer_adamw(model, lr=lr, weight_decay=weight_decay) elif optimizer_name == 'sgd': optimizer = define_optimizer.define_optimizer_sgd(model, lr=lr, momentum=momentum, weight_decay=weight_decay) elif optimizer_name == 'adagrad': optimizer = define_optimizer.define_optimizer_adagrad(model, lr=lr, lr_decay=lr_decay, weight_decay=weight_decay) elif optimizer_name == 'rmsprop': optimizer = define_optimizer.define_optimizer_rmsprop(model, lr=lr, weight_decay=weight_decay, momentum=momentum) elif optimizer_name == 'adadelta': optimizer = define_optimizer.define_optimizer_adadelta(model, lr=lr, weight_decay=weight_decay) else: raise NameError('No define optimization function name!') model = model.to(DEVICE) # 稀疏张量被表示为一对致密张量:一维张量和二维张量的索引。可以通过提供这两个张量来构造稀疏张量 adj_norm = torch.sparse.FloatTensor(torch.LongTensor(adj_norm[0].T), torch.FloatTensor(adj_norm[1]), torch.Size(adj_norm[2])) features = torch.sparse.FloatTensor(torch.LongTensor(features[0].T), torch.FloatTensor(features[1]), torch.Size(features[2])).to_dense() adj_norm = adj_norm.to(DEVICE) features = features.to(DEVICE) norm = torch.FloatTensor(np.array(norm)).to(DEVICE) pos_weight = torch.tensor(pos_weight).to(DEVICE) num_nodes = torch.tensor(num_nodes).to(DEVICE) print('start training...') best_valid_roc_score = float('-inf') hidden_emb = None model.train() for epoch in range(epochs): t = time.time() optimizer.zero_grad() # 解码后的邻接矩阵,判别器 recovered, dis_real, dis_fake, mu, logvar = model(features, adj_norm) if vae_bool: loss = varga_loss_function(preds=recovered, labels=adj_label, mu=mu, logvar=logvar, dis_real=dis_real, dis_fake=dis_fake, n_nodes=num_nodes, norm=norm, pos_weight=pos_weight) else: loss = arga_loss_function(preds=recovered, labels=adj_label, dis_real=dis_real, dis_fake=dis_fake, norm=norm, pos_weight=pos_weight) loss.backward() torch.nn.utils.clip_grad_norm_(model.parameters(), clip) cur_loss = loss.item() optimizer.step() hidden_emb = mu.data.cpu().numpy() # 评估验证集,val set roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, val_edges, val_edges_false) # 保存最好的roc score if roc_score > best_valid_roc_score: best_valid_roc_score = roc_score # 不需要保存整个model,只需保存hidden_emb,因为后面的解码是用hidden_emb内积的形式作推断 np.save(model_path, hidden_emb) print("Epoch:", '%04d' % (epoch + 1), "train_loss = ", "{:.5f}".format(cur_loss), "val_roc_score = ", "{:.5f}".format(roc_score), "average_precision_score = ", "{:.5f}".format(ap_score), "time=", "{:.5f}".format(time.time() - t) ) print("Optimization Finished!") # 评估测试集,test set roc_score, ap_score = get_roc_score(hidden_emb, adj_orig, test_edges, test_edges_false) print('test roc score: {}'.format(roc_score)) print('test ap score: {}'.format(ap_score)) else: raise FileNotFoundError('File config.cfg not found : ' + config_path) if __name__ == '__main__': config_path = os.path.join(os.getcwd(), 'config.cfg') train = Train() train.train_model(config_path)
47.351351
192
0.574543
[ "Apache-2.0" ]
jiangnanboy/gcn_for_prediction_of_protein_interactions
src/graph_nheads_att_gan/train.py
9,490
Python
# Copyright 2019 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Tests for backend_context.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import operator try: # python version >= 3.3 from unittest import mock except ImportError: import mock # pylint: disable=unused-import import tensorflow as tf from google.protobuf import text_format from tensorboard import context from tensorboard.backend.event_processing import data_provider from tensorboard.backend.event_processing import event_accumulator from tensorboard.backend.event_processing import plugin_event_multiplexer from tensorboard.compat.proto import summary_pb2 from tensorboard.plugins import base_plugin from tensorboard.plugins.hparams import api_pb2 from tensorboard.plugins.hparams import backend_context from tensorboard.plugins.hparams import metadata from tensorboard.plugins.hparams import plugin_data_pb2 from tensorboard.plugins.scalar import metadata as scalars_metadata DATA_TYPE_EXPERIMENT = "experiment" DATA_TYPE_SESSION_START_INFO = "session_start_info" DATA_TYPE_SESSION_END_INFO = "session_end_info" class BackendContextTest(tf.test.TestCase): # Make assertProtoEquals print all the diff. maxDiff = None # pylint: disable=invalid-name def setUp(self): self._mock_tb_context = base_plugin.TBContext() # TODO(#3425): Remove mocking or switch to mocking data provider # APIs directly. self._mock_multiplexer = mock.create_autospec( plugin_event_multiplexer.EventMultiplexer ) self._mock_tb_context.multiplexer = self._mock_multiplexer self._mock_multiplexer.PluginRunToTagToContent.side_effect = ( self._mock_plugin_run_to_tag_to_content ) self._mock_multiplexer.AllSummaryMetadata.side_effect = ( self._mock_all_summary_metadata ) self._mock_multiplexer.SummaryMetadata.side_effect = ( self._mock_summary_metadata ) self._mock_tb_context.data_provider = data_provider.MultiplexerDataProvider( self._mock_multiplexer, "/path/to/logs" ) self.session_1_start_info_ = "" self.session_2_start_info_ = "" self.session_3_start_info_ = "" def _mock_all_summary_metadata(self): result = {} hparams_content = { "exp/session_1": { metadata.SESSION_START_INFO_TAG: self._serialized_plugin_data( DATA_TYPE_SESSION_START_INFO, self.session_1_start_info_ ), }, "exp/session_2": { metadata.SESSION_START_INFO_TAG: self._serialized_plugin_data( DATA_TYPE_SESSION_START_INFO, self.session_2_start_info_ ), }, "exp/session_3": { metadata.SESSION_START_INFO_TAG: self._serialized_plugin_data( DATA_TYPE_SESSION_START_INFO, self.session_3_start_info_ ), }, } scalars_content = { "exp/session_1": {"loss": b"", "accuracy": b""}, "exp/session_1/eval": {"loss": b"",}, "exp/session_1/train": {"loss": b"",}, "exp/session_2": {"loss": b"", "accuracy": b"",}, "exp/session_2/eval": {"loss": b"",}, "exp/session_2/train": {"loss": b"",}, "exp/session_3": {"loss": b"", "accuracy": b"",}, "exp/session_3/eval": {"loss": b"",}, "exp/session_3xyz/": {"loss2": b"",}, } for (run, tag_to_content) in hparams_content.items(): result.setdefault(run, {}) for (tag, content) in tag_to_content.items(): m = summary_pb2.SummaryMetadata() m.data_class = summary_pb2.DATA_CLASS_TENSOR m.plugin_data.plugin_name = metadata.PLUGIN_NAME m.plugin_data.content = content result[run][tag] = m for (run, tag_to_content) in scalars_content.items(): result.setdefault(run, {}) for (tag, content) in tag_to_content.items(): m = summary_pb2.SummaryMetadata() m.data_class = summary_pb2.DATA_CLASS_SCALAR m.plugin_data.plugin_name = scalars_metadata.PLUGIN_NAME m.plugin_data.content = content result[run][tag] = m return result def _mock_plugin_run_to_tag_to_content(self, plugin_name): result = {} for ( run, tag_to_metadata, ) in self._mock_multiplexer.AllSummaryMetadata().items(): for (tag, metadata) in tag_to_metadata.items(): if metadata.plugin_data.plugin_name != plugin_name: continue result.setdefault(run, {}) result[run][tag] = metadata.plugin_data.content return result def _mock_summary_metadata(self, run, tag): return self._mock_multiplexer.AllSummaryMetadata()[run][tag] def test_experiment_with_experiment_tag(self): experiment = """ description: 'Test experiment' metric_infos: [ { name: { tag: 'current_temp' } } ] """ run = "exp" tag = metadata.EXPERIMENT_TAG m = summary_pb2.SummaryMetadata() m.data_class = summary_pb2.DATA_CLASS_TENSOR m.plugin_data.plugin_name = metadata.PLUGIN_NAME m.plugin_data.content = self._serialized_plugin_data( DATA_TYPE_EXPERIMENT, experiment ) self._mock_multiplexer.AllSummaryMetadata.side_effect = None self._mock_multiplexer.AllSummaryMetadata.return_value = {run: {tag: m}} ctxt = backend_context.Context(self._mock_tb_context) request_ctx = context.RequestContext() self.assertProtoEquals( experiment, ctxt.experiment_from_metadata( request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123") ), ) def test_experiment_without_experiment_tag(self): self.session_1_start_info_ = """ hparams: [ {key: 'batch_size' value: {number_value: 100}}, {key: 'lr' value: {number_value: 0.01}}, {key: 'model_type' value: {string_value: 'CNN'}} ] """ self.session_2_start_info_ = """ hparams:[ {key: 'batch_size' value: {number_value: 200}}, {key: 'lr' value: {number_value: 0.02}}, {key: 'model_type' value: {string_value: 'LATTICE'}} ] """ self.session_3_start_info_ = """ hparams:[ {key: 'batch_size' value: {number_value: 300}}, {key: 'lr' value: {number_value: 0.05}}, {key: 'model_type' value: {string_value: 'CNN'}} ] """ expected_exp = """ hparam_infos: { name: 'batch_size' type: DATA_TYPE_FLOAT64 }, hparam_infos: { name: 'lr' type: DATA_TYPE_FLOAT64 }, hparam_infos: { name: 'model_type' type: DATA_TYPE_STRING domain_discrete: { values: [{string_value: 'CNN'}, {string_value: 'LATTICE'}] } } metric_infos: { name: {group: '', tag: 'accuracy'} } metric_infos: { name: {group: '', tag: 'loss'} } metric_infos: { name: {group: 'eval', tag: 'loss'} } metric_infos: { name: {group: 'train', tag: 'loss'} } """ ctxt = backend_context.Context(self._mock_tb_context) request_ctx = context.RequestContext() actual_exp = ctxt.experiment_from_metadata( request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123") ) _canonicalize_experiment(actual_exp) self.assertProtoEquals(expected_exp, actual_exp) def test_experiment_without_experiment_tag_different_hparam_types(self): self.session_1_start_info_ = """ hparams:[ {key: 'batch_size' value: {number_value: 100}}, {key: 'lr' value: {string_value: '0.01'}} ] """ self.session_2_start_info_ = """ hparams:[ {key: 'lr' value: {number_value: 0.02}}, {key: 'model_type' value: {string_value: 'LATTICE'}} ] """ self.session_3_start_info_ = """ hparams:[ {key: 'batch_size' value: {bool_value: true}}, {key: 'model_type' value: {string_value: 'CNN'}} ] """ expected_exp = """ hparam_infos: { name: 'batch_size' type: DATA_TYPE_STRING domain_discrete: { values: [{string_value: '100.0'}, {string_value: 'true'}] } } hparam_infos: { name: 'lr' type: DATA_TYPE_STRING domain_discrete: { values: [{string_value: '0.01'}, {string_value: '0.02'}] } } hparam_infos: { name: 'model_type' type: DATA_TYPE_STRING domain_discrete: { values: [{string_value: 'CNN'}, {string_value: 'LATTICE'}] } } metric_infos: { name: {group: '', tag: 'accuracy'} } metric_infos: { name: {group: '', tag: 'loss'} } metric_infos: { name: {group: 'eval', tag: 'loss'} } metric_infos: { name: {group: 'train', tag: 'loss'} } """ ctxt = backend_context.Context(self._mock_tb_context) request_ctx = context.RequestContext() actual_exp = ctxt.experiment_from_metadata( request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123") ) _canonicalize_experiment(actual_exp) self.assertProtoEquals(expected_exp, actual_exp) def test_experiment_without_experiment_tag_many_distinct_values(self): self.session_1_start_info_ = """ hparams:[ {key: 'batch_size' value: {number_value: 100}}, {key: 'lr' value: {string_value: '0.01'}} ] """ self.session_2_start_info_ = """ hparams:[ {key: 'lr' value: {number_value: 0.02}}, {key: 'model_type' value: {string_value: 'CNN'}} ] """ self.session_3_start_info_ = """ hparams:[ {key: 'batch_size' value: {bool_value: true}}, {key: 'model_type' value: {string_value: 'CNN'}} ] """ expected_exp = """ hparam_infos: { name: 'batch_size' type: DATA_TYPE_STRING } hparam_infos: { name: 'lr' type: DATA_TYPE_STRING } hparam_infos: { name: 'model_type' type: DATA_TYPE_STRING domain_discrete: { values: [{string_value: 'CNN'}] } } metric_infos: { name: {group: '', tag: 'accuracy'} } metric_infos: { name: {group: '', tag: 'loss'} } metric_infos: { name: {group: 'eval', tag: 'loss'} } metric_infos: { name: {group: 'train', tag: 'loss'} } """ ctxt = backend_context.Context( self._mock_tb_context, max_domain_discrete_len=1 ) request_ctx = context.RequestContext() actual_exp = ctxt.experiment_from_metadata( request_ctx, "123", ctxt.hparams_metadata(request_ctx, "123"), ) _canonicalize_experiment(actual_exp) self.assertProtoEquals(expected_exp, actual_exp) def _serialized_plugin_data(self, data_oneof_field, text_protobuffer): oneof_type_dict = { DATA_TYPE_EXPERIMENT: api_pb2.Experiment, DATA_TYPE_SESSION_START_INFO: plugin_data_pb2.SessionStartInfo, DATA_TYPE_SESSION_END_INFO: plugin_data_pb2.SessionEndInfo, } protobuffer = text_format.Merge( text_protobuffer, oneof_type_dict[data_oneof_field]() ) plugin_data = plugin_data_pb2.HParamsPluginData() getattr(plugin_data, data_oneof_field).CopyFrom(protobuffer) return metadata.create_summary_metadata(plugin_data).plugin_data.content def _canonicalize_experiment(exp): """Sorts the repeated fields of an Experiment message.""" exp.hparam_infos.sort(key=operator.attrgetter("name")) exp.metric_infos.sort(key=operator.attrgetter("name.group", "name.tag")) for hparam_info in exp.hparam_infos: if hparam_info.HasField("domain_discrete"): hparam_info.domain_discrete.values.sort( key=operator.attrgetter("string_value") ) if __name__ == "__main__": tf.test.main()
37.452128
84
0.569805
[ "Apache-2.0" ]
aryaman4/tensorboard
tensorboard/plugins/hparams/backend_context_test.py
14,082
Python
#!/usr/bin/env python2 # Copyright (c) 2014-2015 The Bitcoin Core developers # Distributed under the MIT software license, see the accompanying # file COPYING or http://www.opensource.org/licenses/mit-license.php. from test_framework.test_framework import BitcoinTestFramework from test_framework.util import * # Create one-input, one-output, no-fee transaction: class RawTransactionsTest(BitcoinTestFramework): def setup_chain(self): print("Initializing test directory "+self.options.tmpdir) initialize_chain_clean(self.options.tmpdir, 4) def setup_network(self, split=False): self.nodes = start_nodes(4, self.options.tmpdir) connect_nodes_bi(self.nodes,0,1) connect_nodes_bi(self.nodes,1,2) connect_nodes_bi(self.nodes,0,2) connect_nodes_bi(self.nodes,0,3) self.is_network_split=False self.sync_all() def run_test(self): print "Mining blocks..." min_relay_tx_fee = self.nodes[0].getnetworkinfo()['relayfee'] # This test is not meant to test fee estimation and we'd like # to be sure all txs are sent at a consistent desired feerate for node in self.nodes: node.settxfee(min_relay_tx_fee) # if the fee's positive delta is higher than this value tests will fail, # neg. delta always fail the tests. # The size of the signature of every input may be at most 2 bytes larger # than a minimum sized signature. # = 2 bytes * minRelayTxFeePerByte feeTolerance = 2 * min_relay_tx_fee/1000 self.nodes[2].generate(1) self.sync_all() self.nodes[0].generate(121) self.sync_all() watchonly_address = self.nodes[0].getnewaddress() watchonly_pubkey = self.nodes[0].validateaddress(watchonly_address)["pubkey"] watchonly_amount = Decimal(2000) self.nodes[3].importpubkey(watchonly_pubkey, "", True) watchonly_txid = self.nodes[0].sendtoaddress(watchonly_address, watchonly_amount) self.nodes[0].sendtoaddress(self.nodes[3].getnewaddress(), watchonly_amount / 10) self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 15) self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 10) self.nodes[0].sendtoaddress(self.nodes[2].getnewaddress(), 50) self.sync_all() self.nodes[0].generate(1) self.sync_all() ############### # simple test # ############### inputs = [ ] outputs = { self.nodes[0].getnewaddress() : 10 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) assert(len(dec_tx['vin']) > 0) #test if we have enought inputs ############################## # simple test with two coins # ############################## inputs = [ ] outputs = { self.nodes[0].getnewaddress() : 22 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) assert(len(dec_tx['vin']) > 0) #test if we have enough inputs ############################## # simple test with two coins # ############################## inputs = [ ] outputs = { self.nodes[0].getnewaddress() : 26 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) assert(len(dec_tx['vin']) > 0) assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '') ################################ # simple test with two outputs # ################################ inputs = [ ] outputs = { self.nodes[0].getnewaddress() : 26, self.nodes[1].getnewaddress() : 25 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) totalOut = 0 for out in dec_tx['vout']: totalOut += out['value'] assert(len(dec_tx['vin']) > 0) assert_equal(dec_tx['vin'][0]['scriptSig']['hex'], '') ######################################################################### # test a fundrawtransaction with a VIN greater than the required amount # ######################################################################### utx = False listunspent = self.nodes[2].listunspent() for aUtx in listunspent: if aUtx['amount'] == 50: utx = aUtx break assert(utx!=False) inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}] outputs = { self.nodes[0].getnewaddress() : 10 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) assert_equal(utx['txid'], dec_tx['vin'][0]['txid']) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) totalOut = 0 for out in dec_tx['vout']: totalOut += out['value'] assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee ##################################################################### # test a fundrawtransaction with which will not get a change output # ##################################################################### utx = False listunspent = self.nodes[2].listunspent() for aUtx in listunspent: if aUtx['amount'] == 50: utx = aUtx break assert(utx!=False) inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}] outputs = { self.nodes[0].getnewaddress() : Decimal(50) - fee - feeTolerance } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) assert_equal(utx['txid'], dec_tx['vin'][0]['txid']) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) totalOut = 0 for out in dec_tx['vout']: totalOut += out['value'] assert_equal(rawtxfund['changepos'], -1) assert_equal(fee + totalOut, utx['amount']) #compare vin total and totalout+fee ######################################################################### # test a fundrawtransaction with a VIN smaller than the required amount # ######################################################################### utx = False listunspent = self.nodes[2].listunspent() for aUtx in listunspent: if aUtx['amount'] == 10: utx = aUtx break assert(utx!=False) inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']}] outputs = { self.nodes[0].getnewaddress() : 10 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) # 4-byte version + 1-byte vin count + 36-byte prevout then script_len rawtx = rawtx[:82] + "0100" + rawtx[84:] dec_tx = self.nodes[2].decoderawtransaction(rawtx) assert_equal(utx['txid'], dec_tx['vin'][0]['txid']) assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex']) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) totalOut = 0 matchingOuts = 0 for i, out in enumerate(dec_tx['vout']): totalOut += out['value'] if out['scriptPubKey']['addresses'][0] in outputs: matchingOuts+=1 else: assert_equal(i, rawtxfund['changepos']) assert_equal(utx['txid'], dec_tx['vin'][0]['txid']) assert_equal("00", dec_tx['vin'][0]['scriptSig']['hex']) assert_equal(matchingOuts, 1) assert_equal(len(dec_tx['vout']), 2) ########################################### # test a fundrawtransaction with two VINs # ########################################### utx = False utx2 = False listunspent = self.nodes[2].listunspent() for aUtx in listunspent: if aUtx['amount'] == 10: utx = aUtx if aUtx['amount'] == 50: utx2 = aUtx assert(utx!=False) inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ] outputs = { self.nodes[0].getnewaddress() : 60 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) assert_equal(utx['txid'], dec_tx['vin'][0]['txid']) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) totalOut = 0 matchingOuts = 0 for out in dec_tx['vout']: totalOut += out['value'] if out['scriptPubKey']['addresses'][0] in outputs: matchingOuts+=1 assert_equal(matchingOuts, 1) assert_equal(len(dec_tx['vout']), 2) matchingIns = 0 for vinOut in dec_tx['vin']: for vinIn in inputs: if vinIn['txid'] == vinOut['txid']: matchingIns+=1 assert_equal(matchingIns, 2) #we now must see two vins identical to vins given as params ######################################################### # test a fundrawtransaction with two VINs and two vOUTs # ######################################################### utx = False utx2 = False listunspent = self.nodes[2].listunspent() for aUtx in listunspent: if aUtx['amount'] == 10: utx = aUtx if aUtx['amount'] == 50: utx2 = aUtx assert(utx!=False) inputs = [ {'txid' : utx['txid'], 'vout' : utx['vout']},{'txid' : utx2['txid'], 'vout' : utx2['vout']} ] outputs = { self.nodes[0].getnewaddress() : 60, self.nodes[0].getnewaddress() : 10 } rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) assert_equal(utx['txid'], dec_tx['vin'][0]['txid']) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) fee = rawtxfund['fee'] dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) totalOut = 0 matchingOuts = 0 for out in dec_tx['vout']: totalOut += out['value'] if out['scriptPubKey']['addresses'][0] in outputs: matchingOuts+=1 assert_equal(matchingOuts, 2) assert_equal(len(dec_tx['vout']), 3) ############################################## # test a fundrawtransaction with invalid vin # ############################################## listunspent = self.nodes[2].listunspent() inputs = [ {'txid' : "1c7f966dab21119bac53213a2bc7532bff1fa844c124fd750a7d0b1332440bd1", 'vout' : 0} ] #invalid vin! outputs = { self.nodes[0].getnewaddress() : 10} rawtx = self.nodes[2].createrawtransaction(inputs, outputs) dec_tx = self.nodes[2].decoderawtransaction(rawtx) try: rawtxfund = self.nodes[2].fundrawtransaction(rawtx) raise AssertionError("Spent more than available") except JSONRPCException as e: assert("Insufficient" in e.error['message']) ############################################################ #compare fee of a standard pubkeyhash transaction inputs = [] outputs = {self.nodes[1].getnewaddress():11} rawTx = self.nodes[0].createrawtransaction(inputs, outputs) fundedTx = self.nodes[0].fundrawtransaction(rawTx) #create same transaction over sendtoaddress txId = self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 11) signedFee = self.nodes[0].getrawmempool(True)[txId]['fee'] #compare fee feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee) assert(feeDelta >= 0 and feeDelta <= feeTolerance) ############################################################ ############################################################ #compare fee of a standard pubkeyhash transaction with multiple outputs inputs = [] outputs = {self.nodes[1].getnewaddress():11,self.nodes[1].getnewaddress():12,self.nodes[1].getnewaddress():1,self.nodes[1].getnewaddress():13,self.nodes[1].getnewaddress():2,self.nodes[1].getnewaddress():3} rawTx = self.nodes[0].createrawtransaction(inputs, outputs) fundedTx = self.nodes[0].fundrawtransaction(rawTx) #create same transaction over sendtoaddress txId = self.nodes[0].sendmany("", outputs) signedFee = self.nodes[0].getrawmempool(True)[txId]['fee'] #compare fee feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee) assert(feeDelta >= 0 and feeDelta <= feeTolerance) ############################################################ ############################################################ #compare fee of a 2of2 multisig p2sh transaction # create 2of2 addr addr1 = self.nodes[1].getnewaddress() addr2 = self.nodes[1].getnewaddress() addr1Obj = self.nodes[1].validateaddress(addr1) addr2Obj = self.nodes[1].validateaddress(addr2) mSigObj = self.nodes[1].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']]) inputs = [] outputs = {mSigObj:11} rawTx = self.nodes[0].createrawtransaction(inputs, outputs) fundedTx = self.nodes[0].fundrawtransaction(rawTx) #create same transaction over sendtoaddress txId = self.nodes[0].sendtoaddress(mSigObj, 11) signedFee = self.nodes[0].getrawmempool(True)[txId]['fee'] #compare fee feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee) assert(feeDelta >= 0 and feeDelta <= feeTolerance) ############################################################ ############################################################ #compare fee of a standard pubkeyhash transaction # create 4of5 addr addr1 = self.nodes[1].getnewaddress() addr2 = self.nodes[1].getnewaddress() addr3 = self.nodes[1].getnewaddress() addr4 = self.nodes[1].getnewaddress() addr5 = self.nodes[1].getnewaddress() addr1Obj = self.nodes[1].validateaddress(addr1) addr2Obj = self.nodes[1].validateaddress(addr2) addr3Obj = self.nodes[1].validateaddress(addr3) addr4Obj = self.nodes[1].validateaddress(addr4) addr5Obj = self.nodes[1].validateaddress(addr5) mSigObj = self.nodes[1].addmultisigaddress(4, [addr1Obj['pubkey'], addr2Obj['pubkey'], addr3Obj['pubkey'], addr4Obj['pubkey'], addr5Obj['pubkey']]) inputs = [] outputs = {mSigObj:11} rawTx = self.nodes[0].createrawtransaction(inputs, outputs) fundedTx = self.nodes[0].fundrawtransaction(rawTx) #create same transaction over sendtoaddress txId = self.nodes[0].sendtoaddress(mSigObj, 11) signedFee = self.nodes[0].getrawmempool(True)[txId]['fee'] #compare fee feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee) assert(feeDelta >= 0 and feeDelta <= feeTolerance) ############################################################ ############################################################ # spend a 2of2 multisig transaction over fundraw # create 2of2 addr addr1 = self.nodes[2].getnewaddress() addr2 = self.nodes[2].getnewaddress() addr1Obj = self.nodes[2].validateaddress(addr1) addr2Obj = self.nodes[2].validateaddress(addr2) mSigObj = self.nodes[2].addmultisigaddress(2, [addr1Obj['pubkey'], addr2Obj['pubkey']]) # send 12 ESMA to msig addr txId = self.nodes[0].sendtoaddress(mSigObj, 12) self.sync_all() self.nodes[1].generate(1) self.sync_all() oldBalance = self.nodes[1].getbalance() inputs = [] outputs = {self.nodes[1].getnewaddress():11} rawTx = self.nodes[2].createrawtransaction(inputs, outputs) fundedTx = self.nodes[2].fundrawtransaction(rawTx) signedTx = self.nodes[2].signrawtransaction(fundedTx['hex']) txId = self.nodes[2].sendrawtransaction(signedTx['hex']) self.sync_all() self.nodes[1].generate(1) self.sync_all() # make sure funds are received at node1 assert_equal(oldBalance+Decimal('11.0000000'), self.nodes[1].getbalance()) ############################################################ # locked wallet test self.nodes[1].encryptwallet("test") self.nodes.pop(1) stop_nodes(self.nodes) wait_bitcoinds() self.nodes = start_nodes(4, self.options.tmpdir) # This test is not meant to test fee estimation and we'd like # to be sure all txs are sent at a consistent desired feerate for node in self.nodes: node.settxfee(min_relay_tx_fee) connect_nodes_bi(self.nodes,0,1) connect_nodes_bi(self.nodes,1,2) connect_nodes_bi(self.nodes,0,2) connect_nodes_bi(self.nodes,0,3) self.is_network_split=False self.sync_all() try: self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), 12) raise AssertionError("Wallet unlocked without passphrase") except JSONRPCException as e: assert('walletpassphrase' in e.error['message']) oldBalance = self.nodes[0].getbalance() inputs = [] outputs = {self.nodes[0].getnewaddress():11} rawTx = self.nodes[1].createrawtransaction(inputs, outputs) fundedTx = self.nodes[1].fundrawtransaction(rawTx) #now we need to unlock self.nodes[1].walletpassphrase("test", 100) signedTx = self.nodes[1].signrawtransaction(fundedTx['hex']) txId = self.nodes[1].sendrawtransaction(signedTx['hex']) self.sync_all() self.nodes[1].generate(1) self.sync_all() # make sure funds are received at node1 assert_equal(oldBalance+Decimal('511.0000000'), self.nodes[0].getbalance()) ############################################### # multiple (~19) inputs tx test | Compare fee # ############################################### #empty node1, send some small coins from node0 to node1 self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True) self.sync_all() self.nodes[0].generate(1) self.sync_all() for i in range(0,20): self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01) self.sync_all() self.nodes[0].generate(1) self.sync_all() #fund a tx with ~20 small inputs inputs = [] outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04} rawTx = self.nodes[1].createrawtransaction(inputs, outputs) fundedTx = self.nodes[1].fundrawtransaction(rawTx) #create same transaction over sendtoaddress txId = self.nodes[1].sendmany("", outputs) signedFee = self.nodes[1].getrawmempool(True)[txId]['fee'] #compare fee feeDelta = Decimal(fundedTx['fee']) - Decimal(signedFee) assert(feeDelta >= 0 and feeDelta <= feeTolerance*19) #~19 inputs ############################################# # multiple (~19) inputs tx test | sign/send # ############################################# #again, empty node1, send some small coins from node0 to node1 self.nodes[1].sendtoaddress(self.nodes[0].getnewaddress(), self.nodes[1].getbalance(), "", "", True) self.sync_all() self.nodes[0].generate(1) self.sync_all() for i in range(0,20): self.nodes[0].sendtoaddress(self.nodes[1].getnewaddress(), 0.01) self.sync_all() self.nodes[0].generate(1) self.sync_all() #fund a tx with ~20 small inputs oldBalance = self.nodes[0].getbalance() inputs = [] outputs = {self.nodes[0].getnewaddress():0.15,self.nodes[0].getnewaddress():0.04} rawTx = self.nodes[1].createrawtransaction(inputs, outputs) fundedTx = self.nodes[1].fundrawtransaction(rawTx) fundedAndSignedTx = self.nodes[1].signrawtransaction(fundedTx['hex']) txId = self.nodes[1].sendrawtransaction(fundedAndSignedTx['hex']) self.sync_all() self.nodes[0].generate(1) self.sync_all() assert_equal(oldBalance+Decimal('500.19000000'), self.nodes[0].getbalance()) #0.19+block reward ##################################################### # test fundrawtransaction with OP_RETURN and no vin # ##################################################### rawtx = "0100000000010000000000000000066a047465737400000000" dec_tx = self.nodes[2].decoderawtransaction(rawtx) assert_equal(len(dec_tx['vin']), 0) assert_equal(len(dec_tx['vout']), 1) rawtxfund = self.nodes[2].fundrawtransaction(rawtx) dec_tx = self.nodes[2].decoderawtransaction(rawtxfund['hex']) assert_greater_than(len(dec_tx['vin']), 0) # at least one vin assert_equal(len(dec_tx['vout']), 2) # one change output added ################################################## # test a fundrawtransaction using only watchonly # ################################################## inputs = [] outputs = {self.nodes[2].getnewaddress() : watchonly_amount / 2} rawtx = self.nodes[3].createrawtransaction(inputs, outputs) result = self.nodes[3].fundrawtransaction(rawtx, True) res_dec = self.nodes[0].decoderawtransaction(result["hex"]) assert_equal(len(res_dec["vin"]), 1) assert_equal(res_dec["vin"][0]["txid"], watchonly_txid) assert("fee" in result.keys()) assert_greater_than(result["changepos"], -1) ############################################################### # test fundrawtransaction using the entirety of watched funds # ############################################################### inputs = [] outputs = {self.nodes[2].getnewaddress() : watchonly_amount} rawtx = self.nodes[3].createrawtransaction(inputs, outputs) result = self.nodes[3].fundrawtransaction(rawtx, True) res_dec = self.nodes[0].decoderawtransaction(result["hex"]) assert_equal(len(res_dec["vin"]), 2) assert(res_dec["vin"][0]["txid"] == watchonly_txid or res_dec["vin"][1]["txid"] == watchonly_txid) assert_greater_than(result["fee"], 0) assert_greater_than(result["changepos"], -1) assert_equal(result["fee"] + res_dec["vout"][result["changepos"]]["value"], watchonly_amount / 10) signedtx = self.nodes[3].signrawtransaction(result["hex"]) assert(not signedtx["complete"]) signedtx = self.nodes[0].signrawtransaction(signedtx["hex"]) assert(signedtx["complete"]) self.nodes[0].sendrawtransaction(signedtx["hex"]) if __name__ == '__main__': RawTransactionsTest().main()
40.438017
214
0.556019
[ "MIT" ]
alik918/esmacoin
qa/rpc-tests/fundrawtransaction.py
24,465
Python
# Copyright (c) 2017, John Skinner import unittest import numpy as np import arvet.database.tests.database_connection as dbconn from arvet.config.path_manager import PathManager import arvet.batch_analysis.task as task class MockTask(task.Task): def run_task(self, path_manager: PathManager): pass def get_unique_name(self) -> str: return "mock_task_{0}".format(self.pk) class TestTaskDatabase(unittest.TestCase): @classmethod def setUpClass(cls): dbconn.connect_to_test_db() def setUp(self): # Remove the collection as the start of the test, so that we're sure it's empty task.Task._mongometa.collection.drop() @classmethod def tearDownClass(cls): # Clean up after ourselves by dropping the collection for this model task.Task._mongometa.collection.drop() def test_stores_and_loads_simple(self): obj = MockTask(state=task.JobState.UNSTARTED) obj.save() # Load all the entities all_entities = list(task.Task.objects.all()) self.assertGreaterEqual(len(all_entities), 1) self.assertEqual(all_entities[0], obj) all_entities[0].delete() def test_stores_and_loads_all_params(self): obj = MockTask( state=task.JobState.RUNNING, node_id='test-hpc', job_id=15, num_cpus=3, num_gpus=150, memory_requirements='4KB', expected_duration='100:00:00' ) obj.save() # Load all the entities all_entities = list(task.Task.objects.all()) self.assertGreaterEqual(len(all_entities), 1) self.assertEqual(all_entities[0], obj) all_entities[0].delete() def test_stores_and_loads_after_change_state(self): obj = MockTask( state=task.JobState.RUNNING, node_id='test-hpc', job_id=15, num_cpus=3, num_gpus=150, memory_requirements='4KB', expected_duration='100:00:00' ) obj.save() all_entities = list(task.Task.objects.all()) self.assertGreaterEqual(len(all_entities), 1) self.assertEqual(all_entities[0], obj) obj.mark_job_failed() obj.save() all_entities = list(task.Task.objects.all()) self.assertGreaterEqual(len(all_entities), 1) self.assertEqual(all_entities[0], obj) obj.mark_job_started('test_node', 143) obj.save() all_entities = list(task.Task.objects.all()) self.assertGreaterEqual(len(all_entities), 1) self.assertEqual(all_entities[0], obj) obj.mark_job_complete() obj.save() all_entities = list(task.Task.objects.all()) self.assertGreaterEqual(len(all_entities), 1) self.assertEqual(all_entities[0], obj) class TestTask(unittest.TestCase): def test_mark_job_started_changes_unstarted_to_running(self): subject = MockTask(state=task.JobState.UNSTARTED) self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_running) subject.mark_job_started('test', 12) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) def test_mark_job_started_doesnt_affect_already_running_jobs(self): subject = MockTask(state=task.JobState.RUNNING, node_id='external', job_id=3) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) self.assertFalse(subject.is_finished) subject.mark_job_started('test', 12) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) self.assertFalse(subject.is_finished) self.assertEqual('external', subject.node_id) self.assertEqual(3, subject.job_id) def test_mark_job_started_doesnt_affect_finished_jobs(self): subject = MockTask(state=task.JobState.DONE) self.assertFalse(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) subject.mark_job_started('test', 12) self.assertFalse(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) def test_mark_job_failed_changes_running_to_unstarted(self): subject = MockTask(state=task.JobState.RUNNING, node_id='test', job_id=5) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) subject.mark_job_failed() self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) def test_mark_job_failed_increases_failed_count(self): subject = MockTask(state=task.JobState.RUNNING, node_id='test', job_id=5, failure_count=4) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) subject.mark_job_failed() self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertEqual(5, subject.failure_count) def test_mark_job_failed_doesnt_affect_unstarted_jobs(self): subject = MockTask(state=task.JobState.UNSTARTED) self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_finished) subject.mark_job_failed() self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_finished) self.assertEqual(0, subject.failure_count) def test_mark_job_failed_doesnt_affect_finished_jobs(self): subject = MockTask(state=task.JobState.DONE) self.assertFalse(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) subject.mark_job_failed() self.assertFalse(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) def test_mark_job_complete_changes_running_to_finished(self): subject = MockTask(state=task.JobState.RUNNING, node_id='test', job_id=5) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) subject.mark_job_complete() self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) def test_mark_job_complete_doesnt_affect_unstarted_jobs(self): subject = MockTask(state=task.JobState.UNSTARTED) self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertFalse(subject.is_finished) subject.mark_job_complete() self.assertTrue(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertFalse(subject.is_finished) def test_mark_job_complete_doesnt_affect_finished_jobs(self): subject = MockTask(state=task.JobState.DONE) self.assertFalse(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) subject.mark_job_complete() self.assertFalse(subject.is_unstarted) self.assertFalse(subject.is_running) self.assertTrue(subject.is_finished) self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) def test_change_job_id_doesnt_affect_state(self): subject = MockTask(state=task.JobState.RUNNING) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) self.assertFalse(subject.is_finished) subject.change_job_id('test', 12) self.assertFalse(subject.is_unstarted) self.assertTrue(subject.is_running) self.assertFalse(subject.is_finished) def test_change_job_id_changes_job_info(self): subject = MockTask(state=task.JobState.RUNNING, node_id='external', job_id=3) self.assertEqual('external', subject.node_id) self.assertEqual(3, subject.job_id) subject.change_job_id('test', 12) self.assertEqual('test', subject.node_id) self.assertEqual(12, subject.job_id) def test_change_job_id_doesnt_affect_unstarted_jobs(self): subject = MockTask(state=task.JobState.UNSTARTED) self.assertTrue(subject.is_unstarted) subject.change_job_id('test', 12) self.assertTrue(subject.is_unstarted) self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) def test_change_job_id_doesnt_affect_finished_jobs(self): subject = MockTask(state=task.JobState.DONE, node_id='external', job_id=3) self.assertTrue(subject.is_finished) self.assertEqual('external', subject.node_id) self.assertEqual(3, subject.job_id) subject.change_job_id('test', 12) self.assertTrue(subject.is_finished) self.assertEqual('external', subject.node_id) self.assertEqual(3, subject.job_id) def test_state_remains_consistent(self): random = np.random.RandomState(144135) subject = MockTask(state=task.JobState.UNSTARTED) for idx in range(50): change = random.randint(0, 4 if idx > 30 else 3) if idx > 30 and change == 3: subject.mark_job_complete() elif change == 2: subject.change_job_id('external', random.randint(0, 1000)) elif change == 1: subject.mark_job_started('test', random.randint(0, 1000)) else: subject.mark_job_failed() # Make sure that the node id and job id match the state if subject.is_unstarted or subject.is_finished: self.assertIsNone(subject.node_id) self.assertIsNone(subject.job_id) else: self.assertIsNotNone(subject.node_id) self.assertIsNotNone(subject.job_id)
38.830769
98
0.682448
[ "BSD-2-Clause" ]
jskinn/arvet
arvet/batch_analysis/tests/test_task.py
10,096
Python
from datetime import datetime import uuid from django.db import models import django.forms as forms import django_filters.fields as filter_fields from apps.ineedstudent.models import Hospital from .filters import StudentJobRequirementsFilter from .models import * # noqa: F401, F403 from .models import COUNTRY_CODE_CHOICES class LocationFilterModel(models.Model): plz = models.CharField(max_length=5, null=True) distance = models.IntegerField(default=0) countrycode = models.CharField(max_length=2, choices=COUNTRY_CODE_CHOICES, default="DE",) uuid = models.CharField(max_length=100, blank=True, unique=True, default=uuid.uuid4) class StudentListFilterModel(models.Model): hospital = models.ForeignKey(Hospital, on_delete=models.CASCADE) location = LocationFilterModel uuid = models.CharField(max_length=100, blank=True, unique=True, default=uuid.uuid4) registration_date = models.DateTimeField(default=datetime.now, blank=True, null=True) name = models.CharField(max_length=100) jrf = StudentJobRequirementsFilter() for f_name, jr_filter in jrf.base_filters.items(): if type(jr_filter.field) == forms.NullBooleanField: StudentListFilterModel.add_to_class( f_name, models.NullBooleanField(default=None, null=True) ) elif type(jr_filter.field) == forms.DecimalField: StudentListFilterModel.add_to_class(f_name, models.IntegerField(default=0)) elif type(jr_filter.field) == filter_fields.ChoiceField: StudentListFilterModel.add_to_class( f_name, models.IntegerField(default=0, choices=jr_filter.field.choices) ) elif type(jr_filter.field) == forms.DateField: StudentListFilterModel.add_to_class( f_name, models.DateField(null=True, default=datetime.now) ) else: raise ValueError( "I do not know what to do with field type '%s' for '%s'" % (type(jr_filter.field), f_name) )
34.666667
93
0.730263
[ "MIT" ]
match4healthcare/match4healthcare
backend/apps/iamstudent/models_persistent_filter.py
1,976
Python
# coding: utf-8 """ vautoscaling Generated by: https://github.com/swagger-api/swagger-codegen.git """ import pprint import re # noqa: F401 import six from ncloud_vautoscaling.model.process import Process # noqa: F401,E501 class ResumeProcessesResponse(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'request_id': 'str', 'return_code': 'str', 'return_message': 'str', 'total_rows': 'int', 'process_list': 'list[Process]' } attribute_map = { 'request_id': 'requestId', 'return_code': 'returnCode', 'return_message': 'returnMessage', 'total_rows': 'totalRows', 'process_list': 'processList' } def __init__(self, request_id=None, return_code=None, return_message=None, total_rows=None, process_list=None): # noqa: E501 """ResumeProcessesResponse - a model defined in Swagger""" # noqa: E501 self._request_id = None self._return_code = None self._return_message = None self._total_rows = None self._process_list = None self.discriminator = None if request_id is not None: self.request_id = request_id if return_code is not None: self.return_code = return_code if return_message is not None: self.return_message = return_message if total_rows is not None: self.total_rows = total_rows if process_list is not None: self.process_list = process_list @property def request_id(self): """Gets the request_id of this ResumeProcessesResponse. # noqa: E501 :return: The request_id of this ResumeProcessesResponse. # noqa: E501 :rtype: str """ return self._request_id @request_id.setter def request_id(self, request_id): """Sets the request_id of this ResumeProcessesResponse. :param request_id: The request_id of this ResumeProcessesResponse. # noqa: E501 :type: str """ self._request_id = request_id @property def return_code(self): """Gets the return_code of this ResumeProcessesResponse. # noqa: E501 :return: The return_code of this ResumeProcessesResponse. # noqa: E501 :rtype: str """ return self._return_code @return_code.setter def return_code(self, return_code): """Sets the return_code of this ResumeProcessesResponse. :param return_code: The return_code of this ResumeProcessesResponse. # noqa: E501 :type: str """ self._return_code = return_code @property def return_message(self): """Gets the return_message of this ResumeProcessesResponse. # noqa: E501 :return: The return_message of this ResumeProcessesResponse. # noqa: E501 :rtype: str """ return self._return_message @return_message.setter def return_message(self, return_message): """Sets the return_message of this ResumeProcessesResponse. :param return_message: The return_message of this ResumeProcessesResponse. # noqa: E501 :type: str """ self._return_message = return_message @property def total_rows(self): """Gets the total_rows of this ResumeProcessesResponse. # noqa: E501 :return: The total_rows of this ResumeProcessesResponse. # noqa: E501 :rtype: int """ return self._total_rows @total_rows.setter def total_rows(self, total_rows): """Sets the total_rows of this ResumeProcessesResponse. :param total_rows: The total_rows of this ResumeProcessesResponse. # noqa: E501 :type: int """ self._total_rows = total_rows @property def process_list(self): """Gets the process_list of this ResumeProcessesResponse. # noqa: E501 :return: The process_list of this ResumeProcessesResponse. # noqa: E501 :rtype: list[Process] """ return self._process_list @process_list.setter def process_list(self, process_list): """Sets the process_list of this ResumeProcessesResponse. :param process_list: The process_list of this ResumeProcessesResponse. # noqa: E501 :type: list[Process] """ self._process_list = process_list def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, ResumeProcessesResponse): return False return self.__dict__ == other.__dict__ def __ne__(self, other): """Returns true if both objects are not equal""" return not self == other
28.453704
129
0.607062
[ "MIT" ]
NaverCloudPlatform/ncloud-sdk-python
lib/services/vautoscaling/ncloud_vautoscaling/model/resume_processes_response.py
6,146
Python
#!/usr/bin/env python3 # Copyright 2015 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. from . import css_checker from os import path as os_path import re from sys import path as sys_path import unittest _HERE = os_path.dirname(os_path.abspath(__file__)) sys_path.append(os_path.join(_HERE, '..', '..')) from PRESUBMIT_test_mocks import MockInputApi, MockOutputApi, MockFile class CssCheckerTest(unittest.TestCase): def setUp(self): super(CssCheckerTest, self).setUp() self.input_api = MockInputApi() self.checker = css_checker.CSSChecker(self.input_api, MockOutputApi()) def _create_file(self, contents, filename): self.input_api.files.append(MockFile(filename, contents.splitlines())) def VerifyContentIsValid(self, contents, filename='fake.css'): self._create_file(contents, filename) results = self.checker.RunChecks() self.assertEqual(len(results), 0) def VerifyContentsProducesOutput(self, contents, output, filename='fake.css'): self._create_file(contents, filename) results = self.checker.RunChecks() self.assertEqual(len(results), 1) self.assertEqual(results[0].message, filename + ':\n' + output.strip()) def testCssAlphaWithAtBlock(self): self.VerifyContentsProducesOutput(""" <include src="../shared/css/cr/ui/overlay.css"> <include src="chrome://resources/totally-cool.css" /> /* A hopefully safely ignored comment and @media statement. /**/ @media print { div { display: block; color: red; } } .rule { z-index: 5; <if expr="not is macosx"> background-image: url(chrome://resources/BLAH); /* TODO(dbeam): Fix this. */ background-color: rgb(235, 239, 249); </if> <if expr="is_macosx"> background-color: white; background-image: url(chrome://resources/BLAH2); </if> color: black; } <if expr="is_macosx"> .language-options-right { visibility: hidden; opacity: 1; /* TODO(dbeam): Fix this. */ } </if> @media (prefers-color-scheme: dark) { a[href] { z-index: 3; color: blue; } }""", """ - Alphabetize properties and list vendor specific (i.e. -webkit) above standard. display: block; color: red; z-index: 5; color: black; z-index: 3; color: blue;""") def testCssStringWithAt(self): self.VerifyContentIsValid(""" #logo { background-image: url(images/google_logo.png@2x); } body.alternate-logo #logo { -webkit-mask-image: url(images/google_logo.png@2x); background: none; } div { margin-inline-start: 5px; } .stuff1 { } .stuff2 { } """) def testCssAlphaWithNonStandard(self): self.VerifyContentsProducesOutput(""" div { /* A hopefully safely ignored comment and @media statement. /**/ color: red; -webkit-margin-before-collapse: discard; }""", """ - Alphabetize properties and list vendor specific (i.e. -webkit) above standard. color: red; -webkit-margin-before-collapse: discard;""") def testCssAlphaWithLongerDashedProps(self): self.VerifyContentsProducesOutput(""" div { border-inline-start: 5px; /* A hopefully removed comment. */ border: 5px solid red; }""", """ - Alphabetize properties and list vendor specific (i.e. -webkit) above standard. border-inline-start: 5px; border: 5px solid red;""") def testCssAlphaWithVariables(self): self.VerifyContentIsValid(""" #id { --zzyxx-xylophone: 3px; --aardvark-animal: var(--zzyxz-xylophone); } """) def testCssBracesHaveSpaceBeforeAndNothingAfter(self): self.VerifyContentsProducesOutput(""" /* Hello! */div/* Comment here*/{ display: block; } blah /* hey! */ { rule: value; } .mixed-in { display: none; } .this.is { /* allowed */ rule: value; }""", """ - Start braces ({) end a selector, have a space before them and no rules after. div{ {""") def testMixins(self): self.VerifyContentsProducesOutput( """ .mixed-in { --css-mixin: { color: red; } }""", """ - Avoid using CSS mixins. Use CSS shadow parts, CSS variables, or common CSS \ classes instead. --css-mixin: {""") def testCssClassesUseDashes(self): self.VerifyContentsProducesOutput(""" .className, .ClassName, .class-name /* We should not catch this. */, .class_name, [i18n-values*='.innerHTML:'] { display: block; }""", """ - Classes use .dash-form. .className, .ClassName, .class_name,""") def testCssCloseBraceOnNewLine(self): self.VerifyContentsProducesOutput(""" @-webkit-keyframe blah { from { height: rotate(-10turn); } 100% { height: 500px; } } #id { /* $i18n{*} and $i18nRaw{*} should be ignored. */ rule: $i18n{someValue}; rule2: $i18nRaw{someValue}; } #rule { rule: value; }""", """ - Always put a rule closing brace (}) on a new line. rule: value; }""") def testCssColonsHaveSpaceAfter(self): self.VerifyContentsProducesOutput(""" div:not(.class):not([attr=5]), /* We should not catch this. */ div:not(.class):not([attr]) /* Nor this. */ { background: url(data:image/jpeg,asdfasdfsadf); /* Ignore this. */ background: -webkit-linear-gradient(left, red, 80% blah blee blar); color: red; display:block; }""", """ - Colons (:) should have a space after them. display:block; - Don't use data URIs in source files. Use grit instead. background: url(data:image/jpeg,asdfasdfsadf);""") def testCssFavorSingleQuotes(self): self.VerifyContentsProducesOutput(""" html[dir="rtl"] body, html[dir=ltr] body /* TODO(dbeam): Require '' around rtl in future? */ { font-family: "Open Sans"; <if expr="is_macosx"> blah: blee; </if> }""", """ - Use single quotes (') instead of double quotes (") in strings. html[dir="rtl"] body, font-family: "Open Sans";""") def testCssHexCouldBeShorter(self): self.VerifyContentsProducesOutput(""" #abc, #abc-, #abc-ghij, #abcdef-, #abcdef-ghij, #aaaaaa, #bbaacc { background-color: #336699; /* Ignore short hex rule if not gray. */ color: #999999; color: #666; }""", """ - Use abbreviated hex (#rgb) when in form #rrggbb. color: #999999; (replace with #999) - Use rgb() over #hex when not a shade of gray (like #333). background-color: #336699; (replace with rgb(51, 102, 153))""") def testCssUseMillisecondsForSmallTimes(self): self.VerifyContentsProducesOutput(""" .transition-0s /* This is gross but may happen. */ { transform: one 0.2s; transform: two .1s; transform: tree 1s; transform: four 300ms; }""", """ - Use milliseconds for time measurements under 1 second. transform: one 0.2s; (replace with 200ms) transform: two .1s; (replace with 100ms)""") def testCssNoDataUrisInSourceFiles(self): self.VerifyContentsProducesOutput(""" img { background: url( data:image/jpeg,4\/\/350|\/|3|2 ); }""", """ - Don't use data URIs in source files. Use grit instead. background: url( data:image/jpeg,4\/\/350|\/|3|2 );""") def testCssNoMixinShims(self): self.VerifyContentsProducesOutput(""" :host { --good-property: red; --not-okay-mixin_-_not-okay-property: green; }""", """ - Don't override custom properties created by Polymer's mixin shim. Set \ mixins or documented custom properties directly. --not-okay-mixin_-_not-okay-property: green;""") def testCssNoQuotesInUrl(self): self.VerifyContentsProducesOutput(""" img { background: url('chrome://resources/images/blah.jpg'); background: url("../../folder/hello.png"); }""", """ - Use single quotes (') instead of double quotes (") in strings. background: url("../../folder/hello.png"); - Don't use quotes in url(). background: url('chrome://resources/images/blah.jpg'); background: url("../../folder/hello.png");""") def testCssOneRulePerLine(self): self.VerifyContentsProducesOutput(""" a:not([hidden]):not(.custom-appearance):not([version=1]):first-of-type, a:not([hidden]):not(.custom-appearance):not([version=1]):first-of-type ~ input[type='checkbox']:not([hidden]), div { background: url(chrome://resources/BLAH); rule: value; /* rule: value; */ rule: value; rule: value; } """, """ - One rule per line (what not to do: color: red; margin: 0;). rule: value; rule: value;""") def testCssOneSelectorPerLine(self): self.VerifyContentsProducesOutput( """ a, div,a, div,/* Hello! */ span, #id.class([dir=rtl]):not(.class):any(a, b, d), div :is(:not(a), #b, .c) { rule: value; } a, div,a { some-other: rule here; }""", """ - One selector per line (what not to do: a, b {}). div,a, div, span, div,a {""") def testCssPseudoElementDoubleColon(self): self.VerifyContentsProducesOutput(""" a:href, br::after, ::-webkit-scrollbar-thumb, a:not([empty]):hover:focus:active, /* shouldn't catch here and above */ abbr:after, .tree-label:empty:after, b:before, :-WebKit-ScrollBar { rule: value; }""", """ - Pseudo-elements should use double colon (i.e. ::after). :after (should be ::after) :after (should be ::after) :before (should be ::before) :-WebKit-ScrollBar (should be ::-WebKit-ScrollBar) """) def testCssRgbIfNotGray(self): self.VerifyContentsProducesOutput( """ #abc, #aaa, #aabbcc { background: -webkit-linear-gradient(left, from(#abc), to(#def)); color: #bad; color: #bada55; }""", """ - Use rgb() over #hex when not a shade of gray (like #333). background: -webkit-linear-gradient(left, from(#abc), to(#def)); """ """(replace with rgb(170, 187, 204), rgb(221, 238, 255)) color: #bad; (replace with rgb(187, 170, 221)) color: #bada55; (replace with rgb(186, 218, 85))""") def testPrefixedLogicalAxis(self): self.VerifyContentsProducesOutput(""" .test { -webkit-logical-height: 50%; -webkit-logical-width: 50%; -webkit-max-logical-height: 200px; -webkit-max-logical-width: 200px; -webkit-min-logical-height: 100px; -webkit-min-logical-width: 100px; } """, """ - Unprefix logical axis property. -webkit-logical-height: 50%; (replace with block-size) -webkit-logical-width: 50%; (replace with inline-size) -webkit-max-logical-height: 200px; (replace with max-block-size) -webkit-max-logical-width: 200px; (replace with max-inline-size) -webkit-min-logical-height: 100px; (replace with min-block-size) -webkit-min-logical-width: 100px; (replace with min-inline-size)""") def testPrefixedLogicalSide(self): self.VerifyContentsProducesOutput(""" .test { -webkit-border-after: 1px solid blue; -webkit-border-after-color: green; -webkit-border-after-style: dotted; -webkit-border-after-width: 10px; -webkit-border-before: 2px solid blue; -webkit-border-before-color: green; -webkit-border-before-style: dotted; -webkit-border-before-width: 20px; -webkit-border-end: 3px solid blue; -webkit-border-end-color: green; -webkit-border-end-style: dotted; -webkit-border-end-width: 30px; -webkit-border-start: 4px solid blue; -webkit-border-start-color: green; -webkit-border-start-style: dotted; -webkit-border-start-width: 40px; -webkit-margin-after: 1px; -webkit-margin-after-collapse: discard; -webkit-margin-before: 2px; -webkit-margin-before-collapse: discard; -webkit-margin-end: 3px; -webkit-margin-end-collapse: discard; -webkit-margin-start: 4px; -webkit-margin-start-collapse: discard; -webkit-padding-after: 1px; -webkit-padding-before: 2px; -webkit-padding-end: 3px; -webkit-padding-start: 4px; } """, """ - Unprefix logical side property. -webkit-border-after: 1px solid blue; (replace with border-block-end) -webkit-border-after-color: green; (replace with border-block-end-color) -webkit-border-after-style: dotted; (replace with border-block-end-style) -webkit-border-after-width: 10px; (replace with border-block-end-width) -webkit-border-before: 2px solid blue; (replace with border-block-start) -webkit-border-before-color: green; (replace with border-block-start-color) -webkit-border-before-style: dotted; (replace with border-block-start-style) -webkit-border-before-width: 20px; (replace with border-block-start-width) -webkit-border-end: 3px solid blue; (replace with border-inline-end) -webkit-border-end-color: green; (replace with border-inline-end-color) -webkit-border-end-style: dotted; (replace with border-inline-end-style) -webkit-border-end-width: 30px; (replace with border-inline-end-width) -webkit-border-start: 4px solid blue; (replace with border-inline-start) -webkit-border-start-color: green; (replace with border-inline-start-color) -webkit-border-start-style: dotted; (replace with border-inline-start-style) -webkit-border-start-width: 40px; (replace with border-inline-start-width) -webkit-margin-after: 1px; (replace with margin-block-end) -webkit-margin-before: 2px; (replace with margin-block-start) -webkit-margin-end: 3px; (replace with margin-inline-end) -webkit-margin-start: 4px; (replace with margin-inline-start) -webkit-padding-after: 1px; (replace with padding-block-end) -webkit-padding-before: 2px; (replace with padding-block-start) -webkit-padding-end: 3px; (replace with padding-inline-end) -webkit-padding-start: 4px; (replace with padding-inline-start)""") def testStartEndInsteadOfLeftRight(self): self.VerifyContentsProducesOutput(""" .inline-node { --var-is-ignored-left: 10px; --var-is-ignored-right: 10px; border-left-color: black; border-right: 1px solid blue; /* csschecker-disable-line left-right */ margin-right: 5px; padding-left: 10px; /* csschecker-disable-line some-other-thing */ text-align: right; }""", """ - Use -start/end instead of -left/right (https://goo.gl/gQYY7z, add /* csschecker-disable-line left-right */ to suppress) border-left-color: black; (replace with border-inline-start-color) margin-right: 5px; (replace with margin-inline-end) padding-left: 10px; (replace with padding-inline-start) text-align: right; (replace with text-align: end) """) def testCssZeroWidthLengths(self): self.VerifyContentsProducesOutput(""" @-webkit-keyframe anim { 0% { /* Ignore key frames */ width: 0px; } 10% { width: 10px; } 50% { background-image: url(blah.svg); } 100% { width: 100px; } } #logo { background-image: url(images/google_logo.png@2x); } body.alternate-logo #logo { -webkit-mask-image: url(images/google_logo.png@2x); } /* http://crbug.com/359682 */ #spinner-container #spinner { -webkit-animation-duration: 1.0s; background-image: url(images/google_logo0.svg); } .media-button.play > .state0.active, .media-button[state='0'] > .state0.normal /* blah */, /* blee */ .media-button[state='0']:not(.disabled):hover > .state0.hover { -webkit-animation: anim 0s; -webkit-animation-duration: anim 0ms; -webkit-transform: scale(0%); background-position-x: 0em; background-position-y: 0ex; border-width: 0em; color: hsl(0, 0%, 85%); /* Shouldn't trigger error. */ opacity: .0; opacity: 0.0; opacity: 0.; } @page { border-width: 0mm; height: 0cm; width: 0in; }""", """ - Use "0" for zero-width lengths (i.e. 0px -> 0) width: 0px; -webkit-transform: scale(0%); background-position-x: 0em; background-position-y: 0ex; border-width: 0em; opacity: .0; opacity: 0.0; opacity: 0.; border-width: 0mm; height: 0cm; width: 0in; """) def testInlineStyleInHtml(self): self.VerifyContentsProducesOutput("""<!doctype html> <html> <head> <!-- Don't warn about problems outside of style tags html, body { margin: 0; height: 100%; } --> <style> body { flex-direction:column; } </style> </head> </html>""", """ - Colons (:) should have a space after them. flex-direction:column; """, filename='test.html') def testInlineStyleInHtmlWithIncludes(self): self.VerifyContentsProducesOutput("""<!doctype html> <html> <style include="fake-shared-css other-shared-css"> body { flex-direction:column; } </style> </head> </html>""", """ - Colons (:) should have a space after them. flex-direction:column; """, filename='test.html') def testInlineStyleInHtmlWithTagsInComments(self): self.VerifyContentsProducesOutput("""<!doctype html> <html> <style> body { /* You better ignore the <tag> in this comment! */ flex-direction:column; } </style> </head> </html>""", """ - Colons (:) should have a space after them. flex-direction:column; """, filename='test.html') def testRemoveAtBlocks(self): self.assertEqual(self.checker.RemoveAtBlocks(""" @media (prefers-color-scheme: dark) { .magic { color: #000; } }"""), """ .magic { color: #000; }""") self.assertEqual(self.checker.RemoveAtBlocks(""" @media (prefers-color-scheme: dark) { .magic { --mixin-definition: { color: red; }; } }"""), """ .magic { --mixin-definition: { color: red; }; }""") self.assertEqual(self.checker.RemoveAtBlocks(""" @keyframes jiggle { from { left: 0; } 50% { left: 100%; } to { left: 10%; } }"""), """ from { left: 0; } 50% { left: 100%; } to { left: 10%; }""") self.assertEqual(self.checker.RemoveAtBlocks(""" @media print { .rule1 { color: black; } .rule2 { margin: 1in; } }"""), """ .rule1 { color: black; } .rule2 { margin: 1in; }""") self.assertEqual(self.checker.RemoveAtBlocks(""" @media (prefers-color-scheme: dark) { .rule1 { color: gray; } .rule2 { margin: .5in; } @keyframe dark-fade { 0% { background: black; } 100% { background: darkgray; } } }"""), """ .rule1 { color: gray; } .rule2 { margin: .5in; } 0% { background: black; } 100% { background: darkgray; }""") self.assertEqual(self.checker.RemoveAtBlocks(""" @-webkit-keyframe anim { 0% { /* Ignore key frames */ width: 0px; } 10% { width: 10px; } 50% { background-image: url(blah.svg); } 100% { width: 100px; } }"""), """ 0% { /* Ignore key frames */ width: 0px; } 10% { width: 10px; } 50% { background-image: url(blah.svg); } 100% { width: 100px; }""") if __name__ == '__main__': unittest.main()
27.007418
121
0.658683
[ "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause" ]
Alan-love/chromium
tools/web_dev_style/css_checker_test.py
18,203
Python
from typing import Dict, List, Optional from db.sql.dal.general import sanitize from db.sql.utils import query_to_dicts class Region: admin: str admin_id: str region_type: str country: str country_id: str admin1: Optional[str] admin1_id: Optional[str] admin2: Optional[str] admin2_id: Optional[str] admin3: Optional[str] admin3_id: Optional[str] region_coordinate: Optional[str] alias: Optional[str] COUNTRY = 'Q6256' ADMIN1 = 'Q10864048' ADMIN2 = 'Q13220204' ADMIN3 = 'Q13221722' def __init__(self, **kwargs): self.admin = kwargs['admin'] self.admin_id = kwargs['admin_id'] self.region_type = kwargs['region_type'] self.country = kwargs['country'] self.country_id = kwargs['country_id'] self.admin1 = kwargs.get('admin1') self.admin1_id = kwargs.get('admin1_id') self.admin2 = kwargs.get('admin2') self.admin2_id = kwargs.get('admin2_id') self.admin3 = kwargs.get('admin3') self.admin3_id = kwargs.get('admin3_id') self.region_coordinate = kwargs.get('region_coordinate') self.alias = kwargs.get('alias') # country, admin1 and admin2 queries return both admin and country,admin1,admin2 fields. # admin3 queries do not, so we need to feel these fields ourselves if self.region_type == Region.ADMIN3: self.admin3_id, self.admin_3 = self.admin_id, self.admin def __getitem__(self, key: str) -> str: return getattr(self, key) def query_country_qnodes(countries: List[str]) -> Dict[str, Optional[str]]: # Translates countries to Q-nodes. Returns a dictionary of each input country and its QNode (None if not found) # We look for countries in a case-insensitive fashion. if not countries: return {} regions = query_countries(countries) result_dict: Dict[str, Optional[str]] = {region.country: region.country_id for region in regions} # The result dictionary contains all the countries we have found, we need to add those we did not find found_countries = set([country.lower() for country in result_dict.keys()]) for country in countries: if country.lower() not in found_countries: result_dict[country] = None return result_dict def list_to_where(field: str, elements: List[str], lower=False) -> Optional[str]: if not elements: return None if lower: elements = [element.lower() for element in elements] field = f"LOWER({field})" santized = [sanitize(element) for element in elements] quoted = [f"'{element}'" for element in santized] joined = ', '.join(quoted) return f"{field} IN ({joined})" def region_where_clause(region_field: str, region_list: List[str], region_id_field: str, region_id_list: List[str], alias_field: Optional[str] = None) -> str: if not region_list and not region_id_list: return "1=1" region_where = list_to_where(region_field, region_list, lower=True) or "0=1" if alias_field: alias_where = list_to_where(alias_field, region_list, lower=True) or "0=1" else: alias_where = "0=1" region_id_where = list_to_where(region_id_field, region_id_list) or "0=1" return f'({region_where} OR {region_id_where} OR {alias_where})' def _query_regions(query: str) -> List[Region]: dicts = query_to_dicts(query) return [Region(**d) for d in dicts] def query_countries(countries: List[str] = [], country_ids: List[str] = []) -> List[Region]: """ Returns a list of countries: If countries or country_ids are not empty, only those countries are returned (all of those in both lists) Otherwise, all countries are returned """ where = region_where_clause('s_country_label.text', countries, 'e_country.node1', country_ids) query = f''' SELECT e_country.node1 AS admin_id, s_country_label.text AS admin, 'Q6256' AS region_type, e_country.node1 AS country_id, s_country_label.text AS country, NULL as admin1_id, NULL as admin1, NULL as admin2_id, NULL as admin2, NULL as admin3_id, NULL as admin3 FROM edges e_country JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id) ON (e_country.node1=e_country_label.node1 AND e_country_label.label='label') WHERE e_country.label='P31' AND e_country.node2='Q6256' AND {where} ORDER BY country ''' return _query_regions(query) def query_admin1s(country: Optional[str] = None, country_id: Optional[str] = None, admin1s: List[str] = [], admin1_ids: List[str] = []) -> List[Region]: """ Returns a list of admin1s. If country or country_id is specified, return the admin1s only of that country. If admin1s or admin1_ids are provided, only those admins are returned. If all arguments are empty, all admin1s in the system are returned. """ if country and country_id: raise ValueError('Only one of country, country_id may be specified') if country_id: country_where = f"e_country.node2='{country_id}'" elif country: # We are certain country is not None here, but need an `elif` because mypy isn't certain country_where = f"LOWER(s_country_label.text)='{country.lower()}'" else: country_where = "1=1" admin1_where = region_where_clause('s_admin1_label.text', admin1s, 'e_admin1.node1', admin1_ids) query = f''' SELECT e_admin1.node1 AS admin_id, s_admin1_label.text AS admin, 'Q10864048' AS region_type, e_country.node2 AS country_id, s_country_label.text AS country, e_admin1.node1 as admin1_id, s_admin1_label.text as admin1, NULL as admin2_id, NULL as admin2, NULL as admin3_id, NULL as admin3 FROM edges e_admin1 JOIN edges e_admin1_label JOIN strings s_admin1_label ON (e_admin1_label.id=s_admin1_label.edge_id) ON (e_admin1.node1=e_admin1_label.node1 AND e_admin1_label.label='label') JOIN edges e_country ON (e_country.node1=e_admin1.node1 AND e_country.label='P17') JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id) ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label') WHERE e_admin1.label='P31' AND e_admin1.node2='Q10864048' AND {country_where} AND {admin1_where} ORDER BY admin1 ''' return _query_regions(query) def query_admin2s(admin1: Optional[str] = None, admin1_id: Optional[str] = None, admin2s: List[str] = [], admin2_ids: List[str] = []) -> List[Region]: """ Returns a list of admin2s. If admin1 or admin1_id is specified, return the admin2s only of that admin1. If admin2s or admin2_ids are provided, only those admins are returned. If all arguments are empty, all admin2s in the system are returned. """ if admin1 and admin1_id: raise ValueError('Only one of admin1, admin1_id may be specified') if admin1_id: admin1_where = f"e_admin1.node2='{admin1_id}'" elif admin1: admin1_where = f"LOWER(s_admin1_label.text)=LOWER('{admin1}')" else: admin1_where = "1=1" admin2_where = region_where_clause('s_admin2_label.text', admin2s, 'e_admin2.node1', admin2_ids) query = f''' SELECT e_admin2.node1 AS admin_id, s_admin2_label.text AS admin, 'Q13220204' AS region_type, e_country.node2 AS country_id, s_country_label.text AS country, e_admin1.node2 AS admin1_id, s_admin1_label.text AS admin1, e_admin2.node1 AS admin2_id, s_admin2_label.text AS admin2, NULL as admin3_id, NULL as admin3 FROM edges e_admin2 JOIN edges e_admin2_label JOIN strings s_admin2_label ON (e_admin2_label.id=s_admin2_label.edge_id) ON (e_admin2.node1=e_admin2_label.node1 AND e_admin2_label.label='label') JOIN edges e_admin1 ON (e_admin1.node1=e_admin2.node1 AND e_admin1.label='P2006190001') JOIN edges e_admin1_label JOIN strings s_admin1_label ON (e_admin1_label.id=s_admin1_label.edge_id) ON (e_admin1.node2=e_admin1_label.node1 AND e_admin1_label.label='label') JOIN edges e_country ON (e_country.node1=e_admin1.node2 AND e_country.label='P17') JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id) ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label') WHERE e_admin2.label='P31' AND e_admin2.node2='Q13220204' AND {admin1_where} AND {admin2_where} ORDER BY admin2 ''' return _query_regions(query) def query_admin3s(admin2: Optional[str] = None, admin2_id: Optional[str] = None, admin3s: List[str] = [], admin3_ids: List[str] = [], debug=False) -> List[Region]: """ Returns a list of admin3s. If admin2 or admin2_id is specified, return the admin3s only of that admin2. If admin3s or admin3_ids are provided, only those admins are returned. If all arguments are empty, all admin3s in the system are returned. """ if admin2 and admin2_id: raise ValueError('Only one of admin2, admin2_id may be specified') if admin2_id: admin2_where = f"e_admin2.node2='{admin2_id}'" elif admin2: admin2_where = f"LOWER(s_admin2_label.text)=LOWER('{admin2}')" else: admin2_where = "1=1" admin3_where = region_where_clause('s_admin3_label.text', admin3s, 'e_admin3.node1', admin3_ids) query = f''' SELECT e_admin3.node1 AS admin_id, s_admin3_label.text AS admin, 'Q13221722' AS region_type, e_country.node2 AS country_id, s_country_label.text AS country, e_admin1.node2 AS admin1_id, s_admin1_label.text AS admin1, e_admin2.node2 AS admin2_id, s_admin2_label.text AS admin2, e_admin2.node1 AS admin3_id, s_admin3_label.text AS admin3 FROM edges e_admin3 JOIN edges e_admin3_label JOIN strings s_admin3_label ON (e_admin3_label.id=s_admin3_label.edge_id) ON (e_admin3.node1=e_admin3_label.node1 AND e_admin3_label.label='label') JOIN edges e_admin2 ON (e_admin2.node1=e_admin3.node1 AND e_admin2.label='P2006190002') JOIN edges e_admin2_label JOIN strings s_admin2_label ON (e_admin2_label.id=s_admin2_label.edge_id) ON (e_admin2.node2=e_admin2_label.node1 AND e_admin2_label.label='label') JOIN edges e_admin1 ON (e_admin1.node1=e_admin2.node1 AND e_admin1.label='P2006190001') JOIN edges e_admin1_label JOIN strings s_admin1_label ON (e_admin1_label.id=s_admin1_label.edge_id) ON (e_admin1.node2=e_admin1_label.node1 AND e_admin1_label.label='label') JOIN edges e_country ON (e_country.node1=e_admin1.node2 AND e_country.label='P17') JOIN edges e_country_label JOIN strings s_country_label ON (e_country_label.id=s_country_label.edge_id) ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label') WHERE e_admin3.label='P31' AND e_admin3.node2='Q13221722' AND {admin2_where} AND {admin3_where} ORDER BY admin3 ''' if debug: print(query) return _query_regions(query) def query_admins(admins: List[str] = [], admin_ids: List[str] = [], debug=False) -> List[Region]: where = region_where_clause('s_region_label.text', admins, 'e_region.node1', admin_ids, 's_region_alias.text') query = f''' SELECT e_region.node1 AS admin_id, s_region_label.text AS admin, e_region.node2 AS region_type, e_country.node2 AS country_id, s_country_label.text AS country, e_admin1.node2 AS admin1_id, s_admin1_label.text AS admin1, e_admin2.node2 AS admin2_id, s_admin2_label.text AS admin2, 'POINT(' || c_coordinate.longitude || ' ' || c_coordinate.latitude || ')' as region_coordinate, s_region_alias.text AS alias FROM edges e_region JOIN edges e_region_label ON (e_region_label.node1=e_region.node1 AND e_region_label.label='label') JOIN strings s_region_label ON (e_region_label.id=s_region_label.edge_id) JOIN edges e_country JOIN edges e_country_label JOIN strings s_country_label ON (s_country_label.edge_id=e_country_label.id) ON (e_country.node2=e_country_label.node1 AND e_country_label.label='label') ON (e_region.node1=e_country.node1 AND e_country.label='P17') LEFT JOIN edges e_admin1 JOIN edges e_admin1_label JOIN strings s_admin1_label ON (s_admin1_label.edge_id=e_admin1_label.id) ON (e_admin1.node2=e_admin1_label.node1 AND e_admin1_label.label='label') ON (e_region.node1=e_admin1.node1 AND e_admin1.label='P2006190001') LEFT JOIN edges e_admin2 JOIN edges e_admin2_label JOIN strings s_admin2_label ON (s_admin2_label.edge_id=e_admin2_label.id) ON (e_admin2.node2=e_admin2_label.node1 AND e_admin2_label.label='label') ON (e_region.node1=e_admin2.node1 AND e_admin2.label='P2006190002') LEFT JOIN edges e_coordinate JOIN coordinates c_coordinate ON (c_coordinate.edge_id=e_coordinate.id) ON (e_region.node1=e_coordinate.node1 AND e_coordinate.label='P625') LEFT JOIN edges e_region_alias JOIN strings s_region_alias ON (s_region_alias.edge_id=e_region_alias.id) ON (e_region.node1=e_region_alias.node1 AND e_region_alias.label='alias') WHERE e_region.label='P31' AND e_region.node2 IN ('Q6256', 'Q10864048', 'Q13220204', 'Q13221722') AND {where} ''' if debug: print(query) return _query_regions(query)
44.449686
115
0.678882
[ "MIT" ]
Otamio/datamart-api
db/sql/dal/regions.py
14,135
Python
# -*- coding: utf-8 -*- import json import csv import scrapy import re from locations.items import GeojsonPointItem COOKIES = { "bm_sz": "04B124C1C96D68082A9F61BAAAF0B6D5~YAAQdjsvF22E8Xl6AQAACr1VfAxPEt+enarZyrOZrBaNvyuX71lK5QPuDR/FgDEWBZVMRhjiIf000W7Z1PiAjxobrz2Y5LcYMH3CvUNvpdS3MjVLUMGwMEBCf9L5nD5Gs9ho2YL8T7Tz7lYvpolvaOlJnKrHyhCFxxk/uyBZ2G/0QrGKLwSaCQShDsz7ink=", "_abck": "440E40C406E69413DCCC08ABAA3E9022~-1~YAAQdjsvF26E8Xl6AQAACr1VfAYznoJdJhX7TNIZW1Rfh6qRhzquXg+L1TWoaL7nZUjXlNls2iPIKFQrCdrWqY/CNXW+mHyXibInMflIXJi5VVB/Swq53kABYJDuXYSlCunYvJAzMSr1q12NOYswz134Y8HRNzVWhkb2jMS5whmHxS/v0vniIvS1TQtKjEQlMGzQYmN41CmLX0JobipQhDtUB4VyNwztb2DCAZiqDX8BLwWg7h/DtPd4158qU69hNhayFTgWmD76/MiR8/T536tMmcoRyWLl4fEtP/XUmKOcksuZO7dbfNxXBffTxIXPYwf1eO77LNuZTCQq5kfsGZLJX8ODju2KSjnIF1vdnyHAe98FDIm+hw==~-1~-1~-1" } HEADERS = { 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9', 'accept-encoding': 'gzip, deflate, br', 'cache-control': 'max-age=0', 'referer': 'https://www.aldi.co.uk/store-finder', 'sec-ch-ua': '" Not;A Brand";v="99", "Google Chrome";v="91", "Chromium";v="91"', 'sec-ch-ua-mobile': '?0', 'sec-fetch-dest': 'document', 'sec-fetch-mode': 'navigate', 'sec-fetch-site': 'same-origin', 'sec-fetch-user': '?1', 'upgrade-insecure-requests': '1', 'user-agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/63.0.3239.84 Safari/537.36', } class AldiUKSpider(scrapy.Spider): name = "aldi_uk" item_attributes = {'brand': "Aldi"} allowed_domains = ['aldi.co.uk'] download_delay = 0.5 custom_settings = { 'USER_AGENT': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.86 Safari/537.36', } def start_requests(self): url = 'https://www.aldi.co.uk/sitemap/store-en_gb-gbp' yield scrapy.http.FormRequest( url=url, method='GET', dont_filter=True, cookies=COOKIES, headers=HEADERS, callback=self.parse ) def parse(self, response): response.selector.remove_namespaces() store_urls = response.xpath('//url/loc/text()').extract() for store_url in store_urls: yield scrapy.http.FormRequest( url=store_url, method='GET', dont_filter=True, cookies=COOKIES, headers=HEADERS, callback=self.parse_store ) def parse_store(self, response): store_js = response.xpath('//script[@type="text/javascript"]/text()').extract_first() json_data = re.search('gtmData =(.+?);', store_js).group(1) data = json.loads(json_data) geojson_data = response.xpath('//script[@class="js-store-finder-initial-state"][@type="application/json"]/text()').extract_first() geodata = json.loads(geojson_data) properties = { 'name': data['seoData']['name'], 'ref': data['seoData']['name'], 'addr_full': data['seoData']['address']['streetAddress'], 'city': data['seoData']['address']['addressLocality'], 'postcode': data['seoData']['address']['postalCode'], 'country': data['seoData']['address']['addressCountry'], 'website': response.request.url, 'opening_hours': str(data['seoData']['openingHours']).replace('[','').replace(']','').replace("'",''), 'lat': geodata['store']['latlng']['lat'], 'lon': geodata['store']['latlng']['lng'], } yield GeojsonPointItem(**properties)
42.988636
436
0.636532
[ "MIT" ]
ChrisSoderberg/alltheplaces
locations/spiders/aldi_uk.py
3,783
Python
import argparse import logging from pprint import pformat from . import guide from . import settings log = logging.getLogger(__name__) def cli(settingsobject=None): parser = argparse.ArgumentParser(description='Create a CSS/LESS/SASS style guide.') if not settingsobject: parser.add_argument('-f', '--settingsfile', dest='settingsfile', default='vitalstyles.json', help='Path to settings file. Defaults to "vitalstyles.json".') parser.add_argument('-l', '--loglevel', dest='loglevel', default='INFO', choices=['DEBUG', 'INFO', 'ERROR'], help='Loglevel.') args = parser.parse_args() loglevel = getattr(logging, args.loglevel) logging.basicConfig( format='[%(name)s] %(levelname)s: %(message)s', level=loglevel ) if loglevel > logging.DEBUG: markdownlogger = logging.getLogger('MARKDOWN') markdownlogger.setLevel(logging.WARNING) if not settingsobject: settingsobject = settings.Settings(args.settingsfile) logging.debug('Creating vitalstyles styleguide with the following settings:\n%s', pformat(settingsobject.settings)) guide.Guide(settingsobject).render() if __name__ == '__main__': cli()
29.880952
87
0.67012
[ "BSD-3-Clause" ]
appressoas/vitalstyles
vitalstyles/cli.py
1,255
Python
class Player(): def __init__(self): print("PLYR FAK SUM BODIE")
15.4
35
0.597403
[ "MIT" ]
reecebenson/DADSA-Tennis-PartA
.history/classes/Player_20171106170937.py
77
Python
#!/usr/bin/env python # vim: set sts=4 sw=4 et: import time import xmlrpc.client from . import players from . import rpc from .common import GameState, CardSet, GameError, RuleError, ProtocolError, simple_decorator from .events import EventList, CardPlayedEvent, MessageEvent, TrickPlayedEvent, TurnEvent, StateChangedEvent @simple_decorator def error2fault(func): """ Catch known exceptions and translate them to XML-RPC faults. """ def catcher(*args): try: return func(*args) except GameError as error: raise xmlrpc.client.Fault(GameError.rpc_code, str(error)) except RuleError as error: raise xmlrpc.client.Fault(RuleError.rpc_code, str(error)) except ProtocolError as error: raise xmlrpc.client.Fault(ProtocolError.rpc_code, str(error)) return catcher @simple_decorator def fault2error(func): """ Catch known XML-RPC faults and translate them to custom exceptions. """ def catcher(*args): try: return func(*args) except xmlrpc.client.Fault as error: error_classes = (GameError, RuleError, ProtocolError) for klass in error_classes: if error.faultCode == klass.rpc_code: raise klass(error.faultString) raise error return catcher class XMLRPCCliPlayer(players.CliPlayer): """ XML-RPC command line interface human player. """ def __init__(self, player_name): players.CliPlayer.__init__(self, player_name) self.game_state = GameState() self.hand = None def handle_event(self, event): if isinstance(event, CardPlayedEvent): self.card_played(event.player, event.card, event.game_state) elif isinstance(event, MessageEvent): self.send_message(event.sender, event.message) elif isinstance(event, TrickPlayedEvent): self.trick_played(event.player, event.game_state) elif isinstance(event, TurnEvent): self.game_state.update(event.game_state) state = self.controller.get_state(self.id) self.hand = state['hand'] self.game_state.update(state['game_state']) elif isinstance(event, StateChangedEvent): self.game_state.update(event.game_state) else: print("unknown event: %s" % event) def wait_for_turn(self): """ Wait for this player's turn. """ while True: time.sleep(0.5) if self.controller is not None: events = self.controller.get_events(self.id) for event in events: self.handle_event(event) if self.game_state.turn_id == self.id: break class XMLRPCProxyController(): """ Client-side proxy object for the server/GameController. """ def __init__(self, server_uri): super(XMLRPCProxyController, self).__init__() if not server_uri.startswith('http://') and \ not server_uri.startswith('https://'): server_uri = 'http://' + server_uri self.server = xmlrpc.client.ServerProxy(server_uri) self.game_id = None self.akey = None @fault2error def play_card(self, _player, card): self.server.game.play_card(self.akey, self.game_id, rpc.rpc_encode(card)) @fault2error def get_events(self, _player_id): return rpc.rpc_decode(EventList, self.server.get_events(self.akey)) @fault2error def get_state(self, _player_id): state = self.server.game.get_state(self.akey, self.game_id) state['game_state'] = rpc.rpc_decode(GameState, state['game_state']) state['hand'] = rpc.rpc_decode(CardSet, state['hand']) return state @fault2error def player_quit(self, _player_id): self.server.player.quit(self.akey) @fault2error def register_player(self, player): player.controller = self plr_data = self.server.player.register(rpc.rpc_encode(player)) player.id = plr_data['id'] self.akey = plr_data['akey'] @fault2error def start_game_with_bots(self): return self.server.game.start_with_bots(self.akey, self.game_id) @fault2error def create_game(self): self.game_id = self.server.game.create(self.akey) return self.game_id
31.621429
108
0.63813
[ "BSD-3-Clause" ]
jait/tupelo
tupelo/xmlrpc.py
4,427
Python
import time import numpy as np import tensorflow as tf import layers as L import vat FLAGS = tf.app.flags.FLAGS tf.app.flags.DEFINE_string('device', '/gpu:0', "device") tf.app.flags.DEFINE_string('dataset', 'cifar10', "{cifar10, svhn}") tf.app.flags.DEFINE_string('log_dir', "", "log_dir") tf.app.flags.DEFINE_integer('seed', 1, "initial random seed") tf.app.flags.DEFINE_bool('validation', False, "") tf.app.flags.DEFINE_integer('batch_size', 32, "the number of examples in a batch") tf.app.flags.DEFINE_integer('ul_batch_size', 128, "the number of unlabeled examples in a batch") tf.app.flags.DEFINE_integer('eval_batch_size', 100, "the number of eval examples in a batch") tf.app.flags.DEFINE_integer('eval_freq', 5, "") tf.app.flags.DEFINE_integer('num_epochs', 120, "the number of epochs for training") tf.app.flags.DEFINE_integer('epoch_decay_start', 80, "epoch of starting learning rate decay") tf.app.flags.DEFINE_integer('num_iter_per_epoch', 400, "the number of updates per epoch") tf.app.flags.DEFINE_float('learning_rate', 0.001, "initial leanring rate") tf.app.flags.DEFINE_float('mom1', 0.9, "initial momentum rate") tf.app.flags.DEFINE_float('mom2', 0.5, "momentum rate after epoch_decay_start") tf.app.flags.DEFINE_string('method', 'vat', "{vat, vatent, baseline}") if FLAGS.dataset == 'cifar10': from cifar10 import inputs, unlabeled_inputs elif FLAGS.dataset == 'svhn': from svhn import inputs, unlabeled_inputs else: raise NotImplementedError NUM_EVAL_EXAMPLES = 5000 def build_training_graph(x, y, ul_x, ul_u, lr, mom): global_step = tf.get_variable( name="global_step", shape=[], dtype=tf.float32, initializer=tf.constant_initializer(0.0), trainable=False, ) logit = vat.forward(x) nll_loss = L.ce_loss(logit, y) with tf.variable_scope(tf.get_variable_scope(), reuse=True): if FLAGS.method == 'vat': ul_logit = vat.forward(ul_x, is_training=True, update_batch_stats=False) vat_loss, ul_u_updated = vat.virtual_adversarial_loss(ul_x, ul_u, ul_logit) additional_loss = vat_loss elif FLAGS.method == 'vatent': ul_logit = vat.forward(ul_x, is_training=True, update_batch_stats=False) vat_loss, ul_u_updated = vat.virtual_adversarial_loss(ul_x, ul_u, ul_logit) ent_loss = L.entropy_y_x(ul_logit) additional_loss = vat_loss + ent_loss elif FLAGS.method == 'baseline': additional_loss = 0 else: raise NotImplementedError loss = nll_loss + additional_loss opt = tf.train.AdamOptimizer(learning_rate=lr, beta1=mom) tvars = tf.trainable_variables() grads_and_vars = opt.compute_gradients(loss, tvars) train_op = opt.apply_gradients(grads_and_vars, global_step=global_step) return loss, train_op, global_step, ul_u_updated def build_eval_graph(x, y, ul_x, ul_u): losses = {} logit = vat.forward(x, is_training=False, update_batch_stats=False) nll_loss = L.ce_loss(logit, y) losses['NLL'] = nll_loss acc = L.accuracy(logit, y) losses['Acc'] = acc scope = tf.get_variable_scope() scope.reuse_variables() # at_loss = vat.adversarial_loss(x, y, nll_loss, is_training=False) # losses['AT_loss'] = at_loss ul_logit = vat.forward(ul_x, is_training=False, update_batch_stats=False) vat_loss = vat.virtual_adversarial_loss(ul_x, ul_u, ul_logit, is_training=False) losses['VAT_loss'] = vat_loss return losses def main(_): print(FLAGS.epsilon, FLAGS.top_bn) np.random.seed(seed=FLAGS.seed) tf.set_random_seed(np.random.randint(1234)) with tf.Graph().as_default() as g: with tf.device("/cpu:0"): images, labels = inputs(batch_size=FLAGS.batch_size, train=True, validation=FLAGS.validation, shuffle=True) ul_images = tf.placeholder(shape=images.shape, dtype=tf.float32) '''unlabeled_inputs(batch_size=FLAGS.ul_batch_size, validation=FLAGS.validation, shuffle=True)''' images_eval_train, labels_eval_train = inputs(batch_size=FLAGS.eval_batch_size, train=True, validation=FLAGS.validation, shuffle=True) ul_images_eval_train = unlabeled_inputs(batch_size=FLAGS.eval_batch_size, validation=FLAGS.validation, shuffle=True) images_eval_test, labels_eval_test = inputs(batch_size=FLAGS.eval_batch_size, train=False, validation=FLAGS.validation, shuffle=True) def placeholder_like(x, name=None): return tf.placeholder(shape=x.shape, dtype=tf.float32, name=name) def random_sphere(shape): n = tf.random_normal(shape=shape, dtype=tf.float32) n = tf.reshape(n, shape=(int(shape[0]), -1)) n = tf.nn.l2_normalize(n, dim=1) n = tf.reshape(n, shape) return n def random_sphere_numpy(shape): n = np.random.normal(size=shape) proj_shape = tuple([n.shape[0]] + [1 for _ in range(len(shape) - 1)]) return n / np.linalg.norm(n.reshape((n.shape[0], -1)), axis=1).reshape(proj_shape) print(ul_images.shape) # ul_u = random_sphere(ul_images.shape) # ul_u_eval_train = random_sphere(ul_images_eval_train.shape) # ul_u_eval_test = random_sphere(images_eval_test.shape) ul_u = placeholder_like(ul_images, "ul_u") ul_u_eval_train = placeholder_like(ul_images_eval_train, "ul_u_eval_train") ul_u_eval_test = placeholder_like(images_eval_test, "ul_u_eval_test") with tf.device(FLAGS.device): lr = tf.placeholder(tf.float32, shape=[], name="learning_rate") mom = tf.placeholder(tf.float32, shape=[], name="momentum") with tf.variable_scope("CNN") as scope: # Build training graph loss, train_op, global_step, ul_u_updated = build_training_graph( images, labels, ul_images, ul_u, lr, mom) scope.reuse_variables() # Build eval graph losses_eval_train = build_eval_graph(images_eval_train, labels_eval_train, ul_images_eval_train, ul_u_eval_train) losses_eval_test = build_eval_graph(images_eval_test, labels_eval_test, images_eval_test, ul_u_eval_test) init_op = tf.global_variables_initializer() if not FLAGS.log_dir: logdir = None writer_train = None writer_test = None else: logdir = FLAGS.log_dir writer_train = tf.summary.FileWriter(FLAGS.log_dir + "/train", g) writer_test = tf.summary.FileWriter(FLAGS.log_dir + "/test", g) saver = tf.train.Saver(tf.global_variables()) sv = tf.train.Supervisor( is_chief=True, logdir=logdir, init_op=init_op, init_feed_dict={lr: FLAGS.learning_rate, mom: FLAGS.mom1}, saver=saver, global_step=global_step, summary_op=None, summary_writer=None, save_model_secs=150, recovery_wait_secs=0) ul_images_np = np.load("train_images.npy").reshape((-1, 32, 32, 3)) print("TRUNCATING UL DATA") ul_images_np = ul_images_np[:FLAGS.batch_size] ul_u_np = random_sphere_numpy(ul_images_np.shape) print(ul_images_np.shape, ul_u_np.shape) print("Training...") with sv.managed_session() as sess: for ep in range(FLAGS.num_epochs): if sv.should_stop(): break if ep < FLAGS.epoch_decay_start: feed_dict = {lr: FLAGS.learning_rate, mom: FLAGS.mom1} else: decayed_lr = ((FLAGS.num_epochs - ep) / float( FLAGS.num_epochs - FLAGS.epoch_decay_start)) * FLAGS.learning_rate feed_dict = {lr: decayed_lr, mom: FLAGS.mom2} sum_loss = 0 start = time.time() for i in range(FLAGS.num_iter_per_epoch): picked = range(FLAGS.batch_size) # np.random.choice(len(ul_images_np), size=FLAGS.batch_size, replace=False) feed_dict[ul_images] = ul_images_np[picked] feed_dict[ul_u] = ul_u_np[picked] ul_u_updated_np, _, batch_loss, _ = sess.run([ul_u_updated, train_op, loss, global_step], feed_dict=feed_dict) delta = ul_u_updated_np - ul_u_np[picked] # print("pos", ul_u_updated_np.reshape((FLAGS.batch_size, -1))[0, :4]) # print("delta", np.linalg.norm(delta.reshape((FLAGS.batch_size, -1)), axis=1)[:4]) print(np.linalg.norm(ul_u_updated_np - ul_u_np[picked]), ul_u_updated_np.reshape((FLAGS.batch_size, -1))[0, :3]) ul_u_np[picked] = ul_u_updated_np sum_loss += batch_loss end = time.time() print("Epoch:", ep, "CE_loss_train:", sum_loss / FLAGS.num_iter_per_epoch, "elapsed_time:", end - start) if (ep + 1) % FLAGS.eval_freq == 0 or ep + 1 == FLAGS.num_epochs: # Eval on training data act_values_dict = {} feed_dict = {ul_u_eval_train: random_sphere_numpy(ul_u_eval_train.shape)} for key, _ in losses_eval_train.iteritems(): act_values_dict[key] = 0 n_iter_per_epoch = NUM_EVAL_EXAMPLES / FLAGS.eval_batch_size for i in range(n_iter_per_epoch): values = losses_eval_train.values() act_values = sess.run(values, feed_dict=feed_dict) for key, value in zip(act_values_dict.keys(), act_values): act_values_dict[key] += value summary = tf.Summary() current_global_step = sess.run(global_step) for key, value in act_values_dict.iteritems(): print("train-" + key, value / n_iter_per_epoch) summary.value.add(tag=key, simple_value=value / n_iter_per_epoch) if writer_train is not None: writer_train.add_summary(summary, current_global_step) # Eval on test data act_values_dict = {} print("HOW COME THIS DOES NOT DEPEND ON ul_images_eval_train? SOMETHING'S WRONG HERE.") feed_dict = {ul_u_eval_test: random_sphere_numpy(ul_u_eval_test.shape)} for key, _ in losses_eval_test.iteritems(): act_values_dict[key] = 0 n_iter_per_epoch = NUM_EVAL_EXAMPLES / FLAGS.eval_batch_size for i in range(n_iter_per_epoch): values = losses_eval_test.values() act_values = sess.run(values, feed_dict=feed_dict) for key, value in zip(act_values_dict.keys(), act_values): act_values_dict[key] += value summary = tf.Summary() current_global_step = sess.run(global_step) for key, value in act_values_dict.iteritems(): print("test-" + key, value / n_iter_per_epoch) summary.value.add(tag=key, simple_value=value / n_iter_per_epoch) if writer_test is not None: writer_test.add_summary(summary, current_global_step) saver.save(sess, sv.save_path, global_step=global_step) sv.stop() if __name__ == "__main__": tf.app.run()
47.778626
132
0.582202
[ "MIT" ]
danielvarga/vat_tf
train_semisup.py
12,518
Python
""" File: Milestone1.py Name: 黃科諺 ----------------------- This file tests the milestone 1 for our babyname.py project """ import sys def add_data_for_name(name_data, year, rank, name): name_info = {year: rank} if name in name_data: if year in name_data[name]: exist_rank = int(name_data[name][year]) if int(rank) < exist_rank: name_data[name][year] = rank else: name_data[name][year] = rank else: name_data[name] = name_info # ------------- DO NOT EDIT THE CODE BELOW THIS LINE ---------------- # def test1(): name_data = {'Kylie': {'2010': '57'}, 'Nick': {'2010': '37'}} add_data_for_name(name_data, '2010', '208', 'Kate') print('--------------------test1----------------------') print(str(name_data)) print('-----------------------------------------------') def test2(): name_data = {'Kylie': {'2010': '57'}, 'Nick': {'2010': '37'}} add_data_for_name(name_data, '2000', '104', 'Kylie') print('--------------------test2----------------------') print(str(name_data)) print('-----------------------------------------------') def test3(): name_data = {'Kylie': {'2010': '57'}, 'Sammy': {'1980': '451', '1990': '200'}, 'Kate': {'2000': '100'}} add_data_for_name(name_data, '1990', '900', 'Sammy') add_data_for_name(name_data, '2010', '400', 'Kylie') add_data_for_name(name_data, '2000', '20', 'Kate') print('-------------------test3-----------------------') print(str(name_data)) print('-----------------------------------------------') def test4(): name_data = {'Kylie': {'2010': '57'}, 'Nick': {'2010': '37'}} add_data_for_name(name_data, '2010', '208', 'Kate') add_data_for_name(name_data, '2000', '108', 'Kate') add_data_for_name(name_data, '1990', '200', 'Sammy') add_data_for_name(name_data, '1990', '90', 'Sammy') add_data_for_name(name_data, '2000', '104', 'Kylie') print('--------------------test4----------------------') print(str(name_data)) print('-----------------------------------------------') def main(): args = sys.argv[1:] if len(args) == 1 and args[0] == 'test1': test1() elif len(args) == 1 and args[0] == 'test2': test2() elif len(args) == 1 and args[0] == 'test3': test3() elif len(args) == 1 and args[0] == 'test4': test4() if __name__ == "__main__": main()
31.307692
107
0.47502
[ "MIT" ]
kenhuang1204/stanCode_projects
stanCode_projects/name_searching_system/milestone1.py
2,448
Python
from __future__ import absolute_import from __future__ import division from __future__ import print_function from compas.utilities import await_callback from compas_fab.backends.interfaces import AddCollisionMesh from compas_fab.backends.ros.messages import ApplyPlanningSceneRequest from compas_fab.backends.ros.messages import ApplyPlanningSceneResponse from compas_fab.backends.ros.messages import CollisionObject from compas_fab.backends.ros.messages import PlanningScene from compas_fab.backends.ros.messages import PlanningSceneWorld from compas_fab.backends.ros.service_description import ServiceDescription __all__ = [ 'MoveItAddCollisionMesh', ] class MoveItAddCollisionMesh(AddCollisionMesh): """Callable to add a collision mesh to the planning scene.""" APPLY_PLANNING_SCENE = ServiceDescription('/apply_planning_scene', 'ApplyPlanningScene', ApplyPlanningSceneRequest, ApplyPlanningSceneResponse, ) def __init__(self, ros_client): self.ros_client = ros_client def add_collision_mesh(self, collision_mesh, options=None): """Add a collision mesh to the planning scene. Parameters ---------- collision_mesh : :class:`compas_fab.robots.CollisionMesh` Object containing the collision mesh to be added. options : dict, optional Unused parameter. Returns ------- ``None`` """ kwargs = {} kwargs['collision_mesh'] = collision_mesh kwargs['errback_name'] = 'errback' return await_callback(self.add_collision_mesh_async, **kwargs) def add_collision_mesh_async(self, callback, errback, collision_mesh): co = CollisionObject.from_collision_mesh(collision_mesh) co.operation = CollisionObject.ADD world = PlanningSceneWorld(collision_objects=[co]) scene = PlanningScene(world=world, is_diff=True) request = scene.to_request(self.ros_client.ros_distro) self.APPLY_PLANNING_SCENE(self.ros_client, request, callback, errback)
38.362069
78
0.681798
[ "MIT" ]
gramaziokohler/compas_fab
src/compas_fab/backends/ros/backend_features/move_it_add_collision_mesh.py
2,225
Python
""" libquantum example 3: 03_sweep_linear.py Construct classic linear chirp and illustrate CWT and STFT TRFs. """ import os from pathlib import Path import numpy as np import scipy.io.wavfile import matplotlib.pyplot as plt from libquantum import atoms, entropy, scales, spectra, utils, synthetics import libquantum.plot_templates.plot_time_frequency_reps as pltq if __name__ == "__main__": """ Exercises with classic linear sweep Option of exporting to wav """ # Do you want to export a wav file? True or False do_save_wave = False # If True, saves to home directory home_dir: str = str(Path.home()) # Or can specify a preferred wav file directory # home_dir: str = "/Users/mgarces/Documents/DATA_API_M/synthetics" output_wav_directory = os.path.join(home_dir, "wav") EVENT_NAME = "redshift_linear_sweep" print("Event Name: " + EVENT_NAME) wav_filename = EVENT_NAME order_number_input = 3 station_id_str = 'Synth' run_time_epoch_s = utils.datetime_now_epoch_s() # Chirp type is_redshift = True sig_wf_sample_rate_hz = 8000. sig_frequency_hz_start = 40. sig_frequency_hz_end = 400. sig_duration_s = 13.19675 head_s = 0.5 # sig_wf_sample_rate_hz = 8000. # sig_frequency_hz_start = 40. # sig_frequency_hz_end = 400. # sig_duration_s = 13.19675 # head_s = 0.5 # Blueshift sweep sig_wf_blu, sig_wf_epoch_s = synthetics.chirp_linear_in_noise(snr_bits=12., sample_rate_hz=sig_wf_sample_rate_hz, duration_s=sig_duration_s, frequency_start_hz=sig_frequency_hz_start, frequency_end_hz=sig_frequency_hz_end, intro_s=head_s, outro_s=head_s) sig_wf_red = np.flipud(sig_wf_blu) # Choose origin and red/blue shift sig_wf_epoch_s += run_time_epoch_s sig_wf = np.copy(sig_wf_red) # Antialias filter synthetic synthetics.antialias_halfNyquist(synth=sig_wf) # Export to wav directory if do_save_wave: wav_sample_rate_hz = 8000. export_filename = os.path.join(output_wav_directory, wav_filename + "_8kz.wav") synth_wav = 0.9 * np.real(sig_wf) / np.max(np.abs((np.real(sig_wf)))) scipy.io.wavfile.write(export_filename, int(wav_sample_rate_hz), synth_wav) # Frame to mic start and end and plot event_reference_time_epoch_s = sig_wf_epoch_s[0] max_time_s, min_frequency_hz = scales.from_duration(band_order_Nth=order_number_input, sig_duration_s=sig_duration_s) print('\nRequest Order N=', order_number_input) print('Lowest frequency in hz that can support this order for this signal duration is ', min_frequency_hz) print('Scale with signal duration and to Nyquist, default G2 base re F1') # Select plot frequencies fmin = np.ceil(min_frequency_hz) fmax = sig_wf_sample_rate_hz/2. # TFR SECTION # Compute complex wavelet transform (cwt) from signal duration if is_redshift: mic_cwt, mic_cwt_bits, mic_cwt_time_s, mic_cwt_frequency_hz = \ atoms.cwt_chirp_from_sig(sig_wf=sig_wf, frequency_sample_rate_hz=sig_wf_sample_rate_hz, band_order_Nth=order_number_input, dictionary_type="tone", index_shift=-1) else: mic_cwt, mic_cwt_bits, mic_cwt_time_s, mic_cwt_frequency_hz = \ atoms.cwt_chirp_from_sig(sig_wf=sig_wf, frequency_sample_rate_hz=sig_wf_sample_rate_hz, band_order_Nth=order_number_input, dictionary_type="tone") mic_cwt_snr, mic_cwt_snr_bits, mic_cwt_snr_entropy = entropy.snr_mean_max(tfr_coeff_complex=mic_cwt) pltq.plot_wf_mesh_mesh_vert(redvox_id=station_id_str, wf_panel_2_sig=sig_wf, wf_panel_2_time=sig_wf_epoch_s, mesh_time=mic_cwt_time_s, mesh_frequency=mic_cwt_frequency_hz, mesh_panel_1_trf=mic_cwt_bits, mesh_panel_1_colormap_scaling="range", mesh_panel_0_tfr=mic_cwt_snr_entropy, wf_panel_2_units="Norm", mesh_panel_1_cbar_units="bits", mesh_panel_0_cbar_units="eSNR bits", start_time_epoch=event_reference_time_epoch_s, figure_title="CWT for " + EVENT_NAME, frequency_hz_ymin=fmin, frequency_hz_ymax=fmax) # Compute short term Fourier transform (STFT) from segmented signal duration mic_stft, mic_stft_bits, mic_stft_time_s, mic_stft_frequency_hz = \ spectra.stft_from_sig(sig_wf=sig_wf, frequency_sample_rate_hz=sig_wf_sample_rate_hz, band_order_Nth=order_number_input) mic_stft_snr, mic_stft_snr_bits, mic_stft_snr_entropy = entropy.snr_mean_max(tfr_coeff_complex=mic_stft) # Log frequency is the default, for linear use frequency_scaling="linear", pltq.plot_wf_mesh_mesh_vert(frequency_scaling="log", redvox_id=station_id_str, wf_panel_2_sig=sig_wf, wf_panel_2_time=sig_wf_epoch_s, mesh_time=mic_stft_time_s, mesh_frequency=mic_stft_frequency_hz, mesh_panel_1_trf=mic_stft_bits, mesh_panel_1_colormap_scaling="range", mesh_panel_0_tfr=mic_stft_snr_entropy, wf_panel_2_units="Norm", mesh_panel_1_cbar_units="bits", mesh_panel_0_cbar_units="eSNR bits", figure_title="STFT for " + EVENT_NAME, frequency_hz_ymin=fmin, frequency_hz_ymax=fmax) plt.show()
44.13245
110
0.579232
[ "Apache-2.0" ]
RedVoxInc/libquantum
examples/03_sweep_linear.py
6,664
Python
import hashlib from fastecdsa import keys, curve, ecdsa from hashlib import sha256 from uuid import uuid4 class Transaction: def __init__(self, from_address, to_address, amount): self.from_address = from_address self.to_address = to_address self.amount = amount self.id = str(uuid4()).replace('-', '') self.signature = None def calculate_hash(self): return sha256((str(self.from_address) + str(self.to_address) + str(self.amount) + self.id).encode()).hexdigest() def sign_tx(self, priv_key): hash_tx = self.calculate_hash() self.signature = ecdsa.sign(hash_tx, priv_key, hashfunc=sha256) def is_valid(self): if self.signature is None: return True if len(self.signature) == 0 and self.to_address is None: return False hash_tx = self.calculate_hash() pubkey = keys.get_public_keys_from_sig(self.signature, hash_tx, curve=curve.P256, hashfunc=sha256) valid = ecdsa.verify(self.signature, hash_tx, pubkey[0], hashfunc=sha256) return valid def serialize(self): return { 'id': self.id, 'from_address': self.from_address, 'to_address': self.to_address, 'amount': self.amount }
30.928571
120
0.635874
[ "MIT" ]
ephremdeme/voting
blockchain/Transaction.py
1,299
Python
# -*- coding: utf-8 -*- from app.libs.utils import data_decode import socket, socketserver, threading import traceback class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler): ip = "" port = 0 timeOut = 100 def __init__(self, request, client_address, server): from app.service.device import Device self.socket = None self.addr = None self.cloud_id = None self.device = Device() self.sign = None self.device_id = None self.timestamp = None super().__init__(request, client_address, server) def setup(self): self.ip = self.client_address[0].strip() self.port = self.client_address[1] self.request.settimeout(self.timeOut) self.addr = self.ip + str(self.port) self.socket = self.request print(self.ip) def handle(self): try: while True: try: # time.sleep(1) data = self.request.recv(1024) except socket.timeout: print(self.ip + ":" + str(self.port) + "接收超时") break if data: data = data_decode(data) self.device.parse_data(data, self) else: break except Exception as e: with open("err_log.log", "a+") as f: f.write(traceback.format_exc()+'\r\r') print(self.client_address, "连接断开") finally: self.request.close() def finish(self): if self.cloud_id is None: print(self.ip + ":" + str(self.port) + "断开连接!") else: get_instance().remove_client(self.cloud_id) print(self.ip + ":" + str(self.port) + self.cloud_id + "断开连接!") class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): pass class TCPServer: instance = None @staticmethod def get_instance(): print("start") if TCPServer.instance is None: TCPServer.instance = TCPServer() return TCPServer.instance def __init__(self): self.clients = {} self.server = None try: self.server = ThreadedTCPServer(("0.0.0.0", 5002), ThreadedTCPRequestHandler) server_thread = threading.Thread(target=self.server.serve_forever) server_thread.daemon = True server_thread.start() # server_thread.join() except (KeyboardInterrupt, SystemExit, Exception) as e: print(e) print("end") self.server.shutdown() self.server.close() def add_client(self, cloud, sock): self.clients[cloud] = sock print("this is clients", self.clients) def remove_client(self, cloud): if cloud in self.clients: print("删除设备" + cloud) from app.service.device import Device Device.offline_alarm(self.clients[cloud]) self.clients.pop(cloud) def get_instance(): return TCPServer.get_instance()
30.126214
89
0.565259
[ "Apache-2.0" ]
mohansd/cyx-xElec-server
app/service/socketservice.py
3,147
Python
from django.conf.urls import patterns, url from django.contrib.contenttypes.models import ContentType from kitsune.questions.feeds import ( QuestionsFeed, AnswersFeed, TaggedQuestionsFeed) from kitsune.questions.models import Question, Answer from kitsune.flagit import views as flagit_views urlpatterns = patterns( 'kitsune.questions.views', url(r'^$', 'product_list', name='questions.home'), url(r'^/answer-preview-async$', 'answer_preview_async', name='questions.answer_preview_async'), url(r'^/dashboard/metrics$', 'metrics', name='questions.metrics'), url(r'^/dashboard/metrics/(?P<locale_code>[^/]+)$', 'metrics', name='questions.locale_metrics'), # AAQ url(r'^/new$', 'aaq', name='questions.aaq_step1'), url(r'^/new/confirm$', 'aaq_confirm', name='questions.aaq_confirm'), url(r'^/new/(?P<product_key>[\w\-]+)$', 'aaq_step2', name='questions.aaq_step2'), url(r'^/new/(?P<product_key>[\w\-]+)/(?P<category_key>[\w\-]+)$', 'aaq_step3', name='questions.aaq_step3'), url(r'^/new/(?P<product_key>[\w\-]+)/(?P<category_key>[\w\-]+)/search$', 'aaq_step4', name='questions.aaq_step4'), url(r'^/new/(?P<product_key>[\w\-]+)/(?P<category_key>[\w\-]+)/form$', 'aaq_step5', name='questions.aaq_step5'), # AAQ flow for Marketplace url(r'^/marketplace$', 'marketplace', name='questions.marketplace_aaq'), url(r'^/marketplace/success$', 'marketplace_success', name='questions.marketplace_aaq_success'), url(r'^/marketplace/refund$', 'marketplace_refund', name='questions.marketplace_refund'), url(r'^/marketplace/developer-request$', 'marketplace_developer_request', name='questions.marketplace_developer_request'), url(r'^/marketplace/(?P<category_slug>[\w\-]+)$', 'marketplace_category', name='questions.marketplace_aaq_category'), # TODO: Factor out `/(?P<question_id>\d+)` below url(r'^/(?P<question_id>\d+)$', 'question_details', name='questions.details'), url(r'^/(?P<question_id>\d+)/edit$', 'edit_question', name='questions.edit_question'), url(r'^/(?P<question_id>\d+)/edit-details$', 'edit_details', name='questions.edit_details'), url(r'^/(?P<question_id>\d+)/reply$', 'reply', name='questions.reply'), url(r'^/(?P<question_id>\d+)/delete$', 'delete_question', name='questions.delete'), url(r'^/(?P<question_id>\d+)/lock$', 'lock_question', name='questions.lock'), url(r'^/(?P<question_id>\d+)/archive$', 'archive_question', name='questions.archive'), url(r'^/(?P<question_id>\d+)/delete/(?P<answer_id>\d+)$', 'delete_answer', name='questions.delete_answer'), url(r'^/(?P<question_id>\d+)/edit/(?P<answer_id>\d+)$', 'edit_answer', name='questions.edit_answer'), url(r'^/(?P<question_id>\d+)/solve/(?P<answer_id>\d+)$', 'solve', name='questions.solve'), url(r'^/(?P<question_id>\d+)/unsolve/(?P<answer_id>\d+)$', 'unsolve', name='questions.unsolve'), url(r'^/(?P<question_id>\d+)/vote$', 'question_vote', name='questions.vote'), url(r'^/(?P<question_id>\d+)/vote/(?P<answer_id>\d+)$', 'answer_vote', name='questions.answer_vote'), url(r'^/(?P<question_id>\d+)/add-tag$', 'add_tag', name='questions.add_tag'), url(r'^/(?P<question_id>\d+)/remove-tag$', 'remove_tag', name='questions.remove_tag'), url(r'^/(?P<question_id>\d+)/add-tag-async$', 'add_tag_async', name='questions.add_tag_async'), url(r'^/(?P<question_id>\d+)/remove-tag-async$', 'remove_tag_async', name='questions.remove_tag_async'), # Feeds # Note: this needs to be above questions.list because "feed" # matches the product slug regex. url(r'^/feed$', QuestionsFeed(), name='questions.feed'), url(r'^/(?P<question_id>\d+)/feed$', AnswersFeed(), name='questions.answers.feed'), url(r'^/tagged/(?P<tag_slug>[\w\-]+)/feed$', TaggedQuestionsFeed(), name='questions.tagged_feed'), # Mark as spam url(r'^/mark_spam$', 'mark_spam', name='questions.mark_spam'), url(r'^/unmark_spam$', 'unmark_spam', name='questions.unmark_spam'), # Question lists url(r'^/(?P<product_slug>[\w+\-\,]+)$', 'question_list', name='questions.list'), # Flag content ("Report this post") url(r'^/(?P<object_id>\d+)/flag$', flagit_views.flag, {'content_type': ContentType.objects.get_for_model(Question).id}, name='questions.flag'), url(r'^/(?P<question_id>\d+)/flag/(?P<object_id>\d+)$', flagit_views.flag, {'content_type': ContentType.objects.get_for_model(Answer).id}, name='questions.answer_flag'), # Subcribe by email url(r'^/(?P<question_id>\d+)/watch$', 'watch_question', name='questions.watch'), url(r'^/(?P<question_id>\d+)/unwatch$', 'unwatch_question', name='questions.unwatch'), url(r'^/confirm/(?P<watch_id>\d+)/(?P<secret>\w+)$', 'activate_watch', name='questions.activate_watch'), url(r'^/unsubscribe/(?P<watch_id>\d+)/(?P<secret>\w+)$', 'unsubscribe_watch', name='questions.unsubscribe'), )
45.778761
78
0.626329
[ "BSD-3-Clause" ]
983834572/kitsune
kitsune/questions/urls.py
5,173
Python
# -*- coding: utf-8 -*- # -*- coding: utf8 -*- """Autogenerated file - DO NOT EDIT If you spot a bug, please report it on the mailing list and/or change the generator.""" from nipype.interfaces.base import ( CommandLine, CommandLineInputSpec, SEMLikeCommandLine, TraitedSpec, File, Directory, traits, isdefined, InputMultiPath, OutputMultiPath, ) import os class ExtractSkeletonInputSpec(CommandLineInputSpec): InputImageFileName = File(position=-2, desc="Input image", exists=True, argstr="%s") OutputImageFileName = traits.Either( traits.Bool, File(), position=-1, hash_files=False, desc="Skeleton of the input image", argstr="%s", ) type = traits.Enum( "1D", "2D", desc="Type of skeleton to create", argstr="--type %s" ) dontPrune = traits.Bool( desc="Return the full skeleton, not just the maximal skeleton", argstr="--dontPrune ", ) numPoints = traits.Int( desc="Number of points used to represent the skeleton", argstr="--numPoints %d" ) pointsFile = traits.Str( desc="Name of the file to store the coordinates of the central (1D) skeleton points", argstr="--pointsFile %s", ) class ExtractSkeletonOutputSpec(TraitedSpec): OutputImageFileName = File( position=-1, desc="Skeleton of the input image", exists=True ) class ExtractSkeleton(SEMLikeCommandLine): """title: Extract Skeleton category: Filtering description: Extract the skeleton of a binary object. The skeleton can be limited to being a 1D curve or allowed to be a full 2D manifold. The branches of the skeleton can be pruned so that only the maximal center skeleton is returned. version: 0.1.0.$Revision: 2104 $(alpha) documentation-url: http://wiki.slicer.org/slicerWiki/index.php/Documentation/4.1/Modules/ExtractSkeleton contributor: Pierre Seroul (UNC), Martin Styner (UNC), Guido Gerig (UNC), Stephen Aylward (Kitware) acknowledgements: The original implementation of this method was provided by ETH Zurich, Image Analysis Laboratory of Profs Olaf Kuebler, Gabor Szekely and Guido Gerig. Martin Styner at UNC, Chapel Hill made enhancements. Wrapping for Slicer was provided by Pierre Seroul and Stephen Aylward at Kitware, Inc. """ input_spec = ExtractSkeletonInputSpec output_spec = ExtractSkeletonOutputSpec _cmd = "ExtractSkeleton " _outputs_filenames = {"OutputImageFileName": "OutputImageFileName.nii"}
33.986486
310
0.702584
[ "Apache-2.0" ]
AnnaD15/nipype
nipype/interfaces/slicer/filtering/extractskeleton.py
2,515
Python
import subprocess import time import os TEST_TYPE = os.getenv("TEST_TYPE", "bdd") def before_scenario(context, scenario): if f"{TEST_TYPE}" == "bdd": proc = subprocess.Popen(["make", "start"]) time.sleep(4) context.proc = proc context.root_url = "http://localhost:5000" else: context.root_url = os.getenv("ROOT_ENDPOINT") def after_scenario(context, scenario): if f"{TEST_TYPE}" == "bdd": proc = context.proc proc.terminate()
21.73913
53
0.622
[ "MIT" ]
abhisheksr01/zero-2-hero-python-flask-microservice
features/environment.py
500
Python
class Solution: def coinChange(self, coins, amount): """ :type coins: List[int] :type amount: int :rtype: int """ # max value taken as amount+1 because in worst case, it can be amount - when denoms of only 1 res = [amount+1]*(amount+1) res[0] = 0 for i in range(1, amount+1): for j in coins: if j <= i: res[i] = min(res[i], res[i-j] + 1) if res[amount] > amount: return -1 else: return res[amount]
27.238095
101
0.461538
[ "MIT" ]
vedantc6/LCode
Session1_2018/coinChange.py
572
Python
import xml.etree.ElementTree as ET from .exceptions import UnpopulatedPropertyError from .property_decorators import property_not_nullable, property_is_boolean from .tag_item import TagItem from ..datetime_helpers import parse_datetime import copy class FlowItem(object): def __init__(self, project_id, name=None): self._webpage_url = None self._created_at = None self._id = None self._initial_tags = set() self._project_name = None self._updated_at = None self.name = name self.owner_id = None self.project_id = project_id self.tags = set() self.description = None self._connections = None self._permissions = None @property def connections(self): if self._connections is None: error = 'Flow item must be populated with connections first.' raise UnpopulatedPropertyError(error) return self._connections() @property def permissions(self): if self._permissions is None: error = "Project item must be populated with permissions first." raise UnpopulatedPropertyError(error) return self._permissions() @property def webpage_url(self): return self._webpage_url @property def created_at(self): return self._created_at @property def id(self): return self._id @property def project_id(self): return self._project_id @project_id.setter @property_not_nullable def project_id(self, value): self._project_id = value @property def description(self): return self._description @description.setter def description(self, value): self._description = value @property def project_name(self): return self._project_name @property def flow_type(self): return self._flow_type @property def updated_at(self): return self._updated_at def _set_connections(self, connections): self._connections = connections def _set_permissions(self, permissions): self._permissions = permissions def _parse_common_elements(self, flow_xml, ns): if not isinstance(flow_xml, ET.Element): flow_xml = ET.fromstring(flow_xml).find('.//t:flow', namespaces=ns) if flow_xml is not None: (_, _, _, _, _, updated_at, _, project_id, project_name, owner_id) = self._parse_element(flow_xml, ns) self._set_values(None, None, None, None, None, updated_at, None, project_id, project_name, owner_id) return self def _set_values(self, id, name, description, webpage_url, created_at, updated_at, tags, project_id, project_name, owner_id): if id is not None: self._id = id if name: self.name = name if description: self.description = description if webpage_url: self._webpage_url = webpage_url if created_at: self._created_at = created_at if updated_at: self._updated_at = updated_at if tags: self.tags = tags self._initial_tags = copy.copy(tags) if project_id: self.project_id = project_id if project_name: self._project_name = project_name if owner_id: self.owner_id = owner_id @classmethod def from_response(cls, resp, ns): all_flow_items = list() parsed_response = ET.fromstring(resp) all_flow_xml = parsed_response.findall('.//t:flow', namespaces=ns) for flow_xml in all_flow_xml: (id_, name, description, webpage_url, created_at, updated_at, tags, project_id, project_name, owner_id) = cls._parse_element(flow_xml, ns) flow_item = cls(project_id) flow_item._set_values(id_, name, description, webpage_url, created_at, updated_at, tags, None, project_name, owner_id) all_flow_items.append(flow_item) return all_flow_items @staticmethod def _parse_element(flow_xml, ns): id_ = flow_xml.get('id', None) name = flow_xml.get('name', None) description = flow_xml.get('description', None) webpage_url = flow_xml.get('webpageUrl', None) created_at = parse_datetime(flow_xml.get('createdAt', None)) updated_at = parse_datetime(flow_xml.get('updatedAt', None)) tags = None tags_elem = flow_xml.find('.//t:tags', namespaces=ns) if tags_elem is not None: tags = TagItem.from_xml_element(tags_elem, ns) project_id = None project_name = None project_elem = flow_xml.find('.//t:project', namespaces=ns) if project_elem is not None: project_id = project_elem.get('id', None) project_name = project_elem.get('name', None) owner_id = None owner_elem = flow_xml.find('.//t:owner', namespaces=ns) if owner_elem is not None: owner_id = owner_elem.get('id', None) return (id_, name, description, webpage_url, created_at, updated_at, tags, project_id, project_name, owner_id)
32.484663
114
0.628706
[ "CC0-1.0", "MIT" ]
BenevolentHighPriestess/server-client-python
tableauserverclient/models/flow_item.py
5,295
Python
from interpolate import interpolate_doc foo = """ hello world """ bar = "foo bar\nbaz" class Foo: # cf matplotlib's kwdoc. __kw__ = "the kw of foo" @interpolate_doc def func(): """ this is a docstring {interpolate_example.foo} {bar} {Foo!K} """ try: @interpolate_doc def bad_doc(): """ fields {must} be preceded by whitespace """ except ValueError: print("error correctly caught")
12.756757
47
0.576271
[ "MIT" ]
anntzer/structured-docstrings
interpolate_example.py
472
Python
import discord from discord.ext import commands # Set slash commands=True when constructing your bot to enable all slash commands # if your bot is only for a couple of servers, you can use the parameter # `slash_command_guilds=[list, of, guild, ids]` to specify this, # then the commands will be much faster to upload. bot = commands.Bot("!", intents=discord.Intents(guilds=True, messages=True), slash_commands=True) @bot.event async def on_ready(): print(f"Logged in as {bot.user} (ID: {bot.user.id})") print("------") @bot.command() # You can use commands.Option to define descriptions for your options, and converters will still work fine. async def ping( ctx: commands.Context, emoji: bool = commands.Option(description="whether to use an emoji when responding") ): # This command can be used with slash commands or message commands if emoji: await ctx.send("\U0001f3d3") else: await ctx.send("Pong!") @bot.command(message_command=False) async def only_slash(ctx: commands.Context): # This command can only be used with slash commands await ctx.send("Hello from slash commands!") @bot.command(slash_command=False) async def only_message(ctx: commands.Context): # This command can only be used with a message await ctx.send("Hello from message commands!") bot.run("token")
31.97619
111
0.724497
[ "MIT" ]
Astrea49/enhanced-discord.py
examples/slash_commands.py
1,343
Python
from io import BytesIO from typing import Tuple, Sequence import attr from PIL import Image from ebl.changelog import Changelog from ebl.ebl_ai_client import EblAiClient from ebl.files.application.file_repository import FileRepository from ebl.fragmentarium.application.annotations_repository import AnnotationsRepository from ebl.fragmentarium.application.annotations_schema import AnnotationsSchema from ebl.fragmentarium.application.cropped_sign_image import CroppedSign from ebl.fragmentarium.application.cropped_sign_images_repository import ( CroppedSignImage, CroppedSignImagesRepository, ) from ebl.fragmentarium.application.fragment_repository import FragmentRepository from ebl.fragmentarium.domain.annotation import ( Annotations, AnnotationValueType, ) from ebl.transliteration.domain.line_label import LineLabel from ebl.transliteration.domain.museum_number import MuseumNumber from ebl.users.domain.user import User @attr.attrs(auto_attribs=True, frozen=True) class AnnotationsService: _ebl_ai_client: EblAiClient _annotations_repository: AnnotationsRepository _photo_repository: FileRepository _changelog: Changelog _fragments_repository: FragmentRepository _photos_repository: FileRepository _cropped_sign_images_repository: CroppedSignImagesRepository def generate_annotations( self, number: MuseumNumber, threshold: float = 0.3 ) -> Annotations: fragment_image = self._photo_repository.query_by_file_name(f"{number}.jpg") return self._ebl_ai_client.generate_annotations( number, fragment_image, threshold ) def find(self, number: MuseumNumber) -> Annotations: return self._annotations_repository.query_by_museum_number(number) def _label_by_line_number( self, line_number_to_match: int, labels: Sequence[LineLabel] ) -> str: matching_label = None for label in labels: label_line_number = label.line_number if label_line_number and label_line_number.is_matching_number( line_number_to_match ): matching_label = label return matching_label.formatted_label if matching_label else "" def _cropped_image_from_annotations_helper( self, annotations: Annotations, image: Image.Image, script: str, labels: Sequence[LineLabel], ) -> Tuple[Annotations, Sequence[CroppedSignImage]]: cropped_sign_images = [] updated_cropped_annotations = [] for annotation in annotations.annotations: label = ( self._label_by_line_number(annotation.data.path[0], labels) if annotation.data.type != AnnotationValueType.BLANK else "" ) cropped_image = annotation.crop_image(image) cropped_sign_image = CroppedSignImage.create(cropped_image) cropped_sign_images.append(cropped_sign_image) updated_cropped_annotation = attr.evolve( annotation, cropped_sign=CroppedSign( cropped_sign_image.image_id, script, label, ), ) updated_cropped_annotations.append(updated_cropped_annotation) return ( attr.evolve(annotations, annotations=updated_cropped_annotations), cropped_sign_images, ) def _cropped_image_from_annotations( self, annotations: Annotations ) -> Tuple[Annotations, Sequence[CroppedSignImage]]: fragment = self._fragments_repository.query_by_museum_number( annotations.fragment_number ) fragment_image = self._photos_repository.query_by_file_name( f"{annotations.fragment_number}.jpg" ) image_bytes = fragment_image.read() image = Image.open(BytesIO(image_bytes), mode="r") return self._cropped_image_from_annotations_helper( annotations, image, fragment.script, fragment.text.labels ) def update(self, annotations: Annotations, user: User) -> Annotations: old_annotations = self._annotations_repository.query_by_museum_number( annotations.fragment_number ) _id = str(annotations.fragment_number) schema = AnnotationsSchema() ( annotations_with_image_ids, cropped_sign_images, ) = self._cropped_image_from_annotations(annotations) self._annotations_repository.create_or_update(annotations_with_image_ids) self._cropped_sign_images_repository.create_many(cropped_sign_images) self._changelog.create( "annotations", user.profile, {"_id": _id, **schema.dump(old_annotations)}, {"_id": _id, **schema.dump(annotations_with_image_ids)}, ) return annotations_with_image_ids
37.755725
86
0.697736
[ "MIT" ]
ElectronicBabylonianLiterature/dictionary
ebl/fragmentarium/application/annotations_service.py
4,946
Python
def number_of_occurrences(s, xs): return xs.count(s)
28
33
0.732143
[ "MIT" ]
anubhab-code/Competitive-Programming
CodeWars/7 Kyu/Number Of Occurrences.py
56
Python
#Python program to get the size of an object in bytes import sys Object = input("Enter any object: ") print(f'The size of the object {Object} is {sys.getsizeof(Object)} bytes')
29.666667
74
0.735955
[ "MIT" ]
CodedLadiesInnovateTech/-python-challenge-solutions
GodwillOnyewuchi/Phase 1/Python Basic 2/day 9 task/task 9.py
178
Python
from .chain import * from .element import *
14.666667
22
0.727273
[ "MIT" ]
ArcletProject/Edoves
arclet/edoves/main/message/__init__.py
44
Python
from importlib import import_module, reload import pytest import sys from unittest.mock import patch from rest_framework import status from django.contrib.auth.models import Permission, Group from django.conf import settings from django.urls import clear_url_caches from django.urls import reverse from .factories import UserFactory from groups.models import GroupInfo from users.models import UserProfile BLANK_CHOICE = ('', '---------') USER_DETAILS = { 'username': 'test', 'email': '[email protected]', 'first_name': 'Foo', 'last_name': 'Bar', } USER_DETAILS_CREATE = USER_DETAILS.copy() USER_DETAILS_CREATE.update(password1='pass', password2='pass') USER_DETAILS_CHANGING = { 'username': 'johnsmith', 'email': '[email protected]', 'first_name': 'John', 'last_name': 'Smith', } @pytest.mark.django_db def test_create_user_view_get(admin_client): url = reverse('wagtailusers_users:add') response = admin_client.get(url) assert response.status_code == status.HTTP_200_OK @pytest.mark.django_db def test_create_user_view(admin_client): url = reverse('wagtailusers_users:add') response = admin_client.post(url, data=USER_DETAILS_CREATE) assert response.context['message'] == 'User test created.' assert response.status_code == status.HTTP_302_FOUND assert response.url == reverse('wagtailusers_users:index') @pytest.mark.django_db def test_create_user_view_invalid_form(admin_client): url = reverse('wagtailusers_users:add') post_data = USER_DETAILS.copy() post_data.update(email='This is not an email address') response = admin_client.post(url, post_data) message = response.context['message'] assert message == 'The user could not be created due to errors.' assert response.status_code == status.HTTP_200_OK @pytest.mark.django_db def test_get_edit_user_view(admin_client): user = UserFactory(**USER_DETAILS) url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) response = admin_client.get(url) assert response.status_code == status.HTTP_200_OK assert response.context['can_delete'] is True @pytest.mark.django_db def test_edit_user_view(team_leaders_group, admin_client): user = UserFactory(**USER_DETAILS) url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) # We'll add the user to a group, as well as changing their details post_data = USER_DETAILS_CHANGING.copy() post_data['groups'] = [team_leaders_group.pk] response = admin_client.post(url, data=post_data) assert response.context['message'] == 'User johnsmith updated.' assert response.status_code == status.HTTP_302_FOUND assert response.url == reverse('wagtailusers_users:index') # The user's details should have changed to reflect the posted values user.refresh_from_db() for field_name, changed_value in USER_DETAILS_CHANGING.items(): assert getattr(user, field_name) == changed_value # And they should have been added to a group group_ids = set(user.groups.values_list('id', flat=True)) assert group_ids == {team_leaders_group.pk} @pytest.mark.django_db def test_edit_user_view_invalid_form(admin_client, approved_user): url = reverse('wagtailusers_users:edit', kwargs={'pk': approved_user.pk}) post_data = USER_DETAILS.copy() post_data.update(email='This is not an email address') response = admin_client.post(url, post_data) message = response.context['message'] assert message == 'The user could not be saved due to errors.' assert response.status_code == status.HTTP_200_OK @pytest.mark.django_db def test_edit_user_view_cannot_change_personal_details_when_sso_enforced( admin_client ): # Set this flag to True and repeat previous test settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True user = UserFactory(**USER_DETAILS) # Post changes to the view url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) admin_client.post(url, data=USER_DETAILS_CHANGING) # The users details should remain unchanged, because the # personal detail fields should all be disabled user.refresh_from_db() for field_name, original_value in USER_DETAILS.items(): assert getattr(user, field_name) == original_value # Change this back to avoid cross-test pollution settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False reload_urlconf() @pytest.mark.django_db def test_edit_user_view_preserves_ability_to_update_is_active(admin_client): # Set this flag to True and actions if previous test settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True # Create an 'inactive' user to test with user = UserFactory(**USER_DETAILS) user.is_active = False user.save() # Post using the same details + 'is_active=on' post_data = USER_DETAILS.copy() post_data.update(is_active='on') url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) admin_client.post(url, data=post_data) # The change to 'is_active' should have been applied, because that field # is not disabled along with the personal detail ones user.refresh_from_db() assert user.is_active is True # Reset flag to avoid cross-test pollution settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False reload_urlconf() @pytest.mark.django_db def test_edit_user_view_warns_administrator_if_user_is_awaiting_approval( admin_client, user_awaiting_approval ): # This flag must be set for the warning to show settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True user = user_awaiting_approval url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) response = admin_client.get(url) message = response.context['message'] assert "This user is awaiting approval" in message assert "requested to be added to the 'Moderators' group" in message # Reset flag to avoid cross-test pollution settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False reload_urlconf() @pytest.mark.django_db def test_edit_user_view_marks_user_as_approved_if_added_to_group( admin_client, admin_user, user_awaiting_approval ): # This flag must be set for the warning to show settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True user = user_awaiting_approval profile = user_awaiting_approval.userprofile url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) group = Group.objects.get(pk=profile.self_assigned_group_id) group.permissions.add(Permission.objects.get(codename='access_admin')) with patch('users.views.notify_user_of_access_request_approval', autospec=True) as mocked_method: response = admin_client.post(url, { 'username': user.username, 'first_name': user.first_name, 'last_name': user.last_name, 'email': user.email, 'is_active': True, 'groups': [group.pk], }) # Ensure the post was successful assert response.context['message'] == 'User %s updated.' % user.username assert response.status_code == status.HTTP_302_FOUND assert response.url == reverse('wagtailusers_users:index') # The UserProfile should have been updated profile.refresh_from_db() assert profile.assignment_status == UserProfile.STATUS_APPROVED assert profile.approved_by_id == admin_user.id assert profile.approved_at is not None # A notification should have been triggered for the user expected_call_args = dict( request=response.wsgi_request, user_email=user.email, user_name=user.first_name, reviewer_name=admin_user.get_full_name(), ) mocked_method.assert_called_with(**expected_call_args) # Reset flag to avoid cross-test pollution settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False reload_urlconf() @pytest.mark.django_db def test_edit_user_view_does_not_mark_user_as_approved_if_not_added_to_a_group(admin_client, groups_with_info): user = UserFactory(username='some-user') profile = user.userprofile profile.assignment_status = UserProfile.STATUS_AWAITING_APPROVAL profile.self_assigned_group_id = groups_with_info[0].id profile.save() url = reverse('wagtailusers_users:edit', kwargs={'pk': user.pk}) with patch( 'users.views.notify_user_of_access_request_approval' ) as mocked_method: response = admin_client.post(url, { 'username': user.username, 'first_name': user.first_name, 'last_name': user.last_name, 'email': user.email, 'is_active': True, }) # Ensure the post was successful assert response.context['message'] == 'User %s updated.' % user.username assert response.status_code == status.HTTP_302_FOUND assert response.url == reverse('wagtailusers_users:index') # The UserProfile should NOT have been updated profile.refresh_from_db() assert profile.assignment_status == UserProfile.STATUS_AWAITING_APPROVAL assert profile.approved_by_id is None assert profile.approved_at is None # no notification should have been triggered mocked_method.assert_not_called() def reload_urlconf(urlconf=None): clear_url_caches() if urlconf is None: urlconf = settings.ROOT_URLCONF if urlconf in sys.modules: reload(sys.modules[urlconf]) else: import_module(urlconf) @pytest.mark.django_db def test_force_staff_sso(client): """Test that URLs and redirects are in place.""" settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = True settings.AUTHBROKER_CLIENT_ID = 'debug' settings.AUTHBROKER_CLIENT_SECRET = 'debug' settings.AUTHBROKER_URL = 'https://test.com' reload_urlconf() assert reverse('authbroker_client:login') == '/auth/login/' assert reverse('authbroker_client:callback') == '/auth/callback/' response = client.get('/admin/login/') assert response.status_code == 302 assert response.url == '/auth/login/' settings.FEATURE_FLAGS['ENFORCE_STAFF_SSO_ON'] = False reload_urlconf() @pytest.mark.parametrize('assignment_status, expected_status_code', ( (UserProfile.STATUS_CREATED, 200), (UserProfile.STATUS_AWAITING_APPROVAL, 302), (UserProfile.STATUS_APPROVED, 302) )) @pytest.mark.django_db def test_ssorequestaccessview_responds_based_on_assignment_status( admin_client, admin_user, assignment_status, expected_status_code ): url = reverse('sso:request_access') profile = admin_user.userprofile profile.assignment_status = assignment_status profile.save() response = admin_client.get(url) assert response.status_code == expected_status_code @pytest.mark.django_db def test_ssorequestaccessview_shows_unlimited_visibilty_groups_only( admin_client, groups_with_info ): url = reverse('sso:request_access') # Visbility is set to 'unrestricted' for all groups in `groups_with_info`, # so choices should reflect that by default expected_choices = tuple( (g.id, g.info.name_singular) for g in groups_with_info ) # Confirm the choices in the form are as expected response = admin_client.get(url) group_field = response.context['form']['self_assigned_group'].field actual_choices = tuple(group_field.choices) assert actual_choices == expected_choices # Change the visibility of groups and try again GroupInfo.objects.all().update( visibility=GroupInfo.VISIBILITY_MANAGERS_ONLY) # Choices should be empty now response = admin_client.get(url) group_field = response.context['form']['self_assigned_group'].field assert tuple(group_field.choices) == () @pytest.mark.django_db def test_ssorequestaccessview_with_no_team_leaders_group(admin_client): # If no 'team leaders group' has been designated, the 'team_leaders' # field should only have a 'blank' option url = reverse('sso:request_access') response = admin_client.get(url) team_leader_field = response.context['form']['team_leader'].field assert tuple(team_leader_field.choices) == (BLANK_CHOICE,) @pytest.mark.django_db def test_ssorequestaccessview_with_team_leaders_group_but_no_members( admin_client, team_leaders_group ): # If the designated 'team leaders group' has no members, the 'team_leaders' # field should only have a 'blank' option url = reverse('sso:request_access') response = admin_client.get(url) team_leader_field = response.context['form']['team_leader'].field assert team_leaders_group.user_set.all().exists() is False assert tuple(team_leader_field.choices) == (BLANK_CHOICE,) @pytest.mark.django_db def test_ssorequestaccessview_with_team_leaders( admin_client, team_leaders_group, team_leaders ): url = reverse('sso:request_access') # When team leaders are defined, they will appear as choices # for the 'team_leaders' field expected_choices = [BLANK_CHOICE] expected_choices.extend(list( (tl.id, "{} <{}>".format(tl.get_full_name(), tl.email)) for tl in team_leaders )) # Confirm the choices in the form are as expected response = admin_client.get(url) team_leader_field = response.context['form']['team_leader'].field actual_choices = list(team_leader_field.choices) assert actual_choices == expected_choices @pytest.mark.django_db def test_ssorequestaccessview_fails_validation_if_form_incomplete( admin_client, groups_with_info, team_leaders ): url = reverse('sso:request_access') response = admin_client.post(url, data={}) # Should still be on the same view assert response.status_code == 200 # Both form fields should have errors assert 'self_assigned_group' in response.context['form'].errors assert 'team_leader' in response.context['form'].errors @pytest.mark.django_db def test_ssorequestaccessview_post_with_complete_data( admin_client, admin_user, groups_with_info, team_leaders ): group = groups_with_info[0] team_leader = team_leaders[0] with patch( 'users.views.notify_team_leader_of_pending_access_request', autospec=True ) as mocked_method: response = admin_client.post( reverse('sso:request_access'), data={ 'self_assigned_group': group.id, 'team_leader': team_leader.id, } ) # Should be redirected to the success url success_url = reverse('sso:request_access_success') assert response.url == success_url # The UserProfile for `admin_user` should have been updated profile = admin_user.userprofile assert profile.self_assigned_group_id == group.id assert profile.team_leader_id == team_leader.id assert profile.assignment_status == UserProfile.STATUS_AWAITING_APPROVAL # noqa # A notification should have been triggered for the user expected_call_args = dict( request=response.wsgi_request, team_leader_email=team_leader.email, team_leader_name=team_leader.first_name, user_id=admin_user.id, user_name=admin_user.get_full_name(), user_email=admin_user.email, user_role=group.info.name_singular, ) mocked_method.assert_called_with(**expected_call_args) @pytest.mark.django_db @pytest.mark.parametrize('url', ( reverse('sso:request_access'), reverse('sso:request_access_success'), )) def test_ssorequestaccess_views_only_available_to_authenticated_users( client, admin_client, url ): # When not authenticated, the user is redirected to the login page response = client.get(url) assert response.status_code == 302 assert response.url.startswith(settings.LOGIN_URL) # When authenticated, things work fine response = admin_client.get(url) assert response.status_code == 200
34.45
111
0.730927
[ "MIT" ]
uktrade/directory-cms
tests/users/test_views.py
15,847
Python
# -*- coding: utf-8 -*- # !/usr/bin/env python """ ------------------------------------------------- File Name: DbClient.py Description : DB工厂类 Author : JHao date: 2016/12/2 ------------------------------------------------- Change Activity: 2016/12/02: DB工厂类 2020/07/03: 取消raw_proxy储存 ------------------------------------------------- """ __author__ = 'JHao' import os import sys from util.six import urlparse, withMetaclass from util.singleton import Singleton sys.path.append(os.path.dirname(os.path.abspath(__file__))) class DbClient(withMetaclass(Singleton)): """ DbClient DB工厂类 提供get/put/update/pop/delete/exists/getAll/clean/getCount/changeTable方法 抽象方法定义: get(): 随机返回一个proxy; put(proxy): 存入一个proxy; pop(): 顺序返回并删除一个proxy; update(proxy): 更新指定proxy信息; delete(proxy): 删除指定proxy; exists(proxy): 判断指定proxy是否存在; getAll(): 返回所有代理; clean(): 清除所有proxy信息; getCount(): 返回proxy统计信息; changeTable(name): 切换操作对象 所有方法需要相应类去具体实现: ssdb: ssdbClient.py redis: redisClient.py mongodb: mongodbClient.py """ def __init__(self, db_conn): """ init :return: """ self.parseDbConn(db_conn) self.__initDbClient() @classmethod def parseDbConn(cls, db_conn): db_conf = urlparse(db_conn) cls.db_type = db_conf.scheme.upper().strip() cls.db_host = db_conf.hostname cls.db_port = db_conf.port cls.db_user = db_conf.username cls.db_pwd = db_conf.password cls.db_name = db_conf.path[1:] return cls def __initDbClient(self): """ init DB Client :return: """ __type = None if "SSDB" == self.db_type: __type = "ssdbClient" elif "REDIS" == self.db_type: __type = "redisClient" elif "POSTGRESQL" == self.db_type: __type = "postgresqlClient" else: pass assert __type, 'type error, Not support DB type: {}'.format(self.db_type) self.client = getattr(__import__(__type), "%sClient" % self.db_type.title())(host=self.db_host, port=self.db_port, username=self.db_user, password=self.db_pwd, db=self.db_name) def get(self, **kwargs): return self.client.get(**kwargs) def put(self, key, **kwargs): return self.client.put(key, **kwargs) def update(self, key, value, **kwargs): return self.client.update(key, value, **kwargs) def delete(self, key, **kwargs): return self.client.delete(key, **kwargs) def exists(self, key, **kwargs): return self.client.exists(key, **kwargs) def pop(self, **kwargs): return self.client.pop(**kwargs) def getAll(self): return self.client.getAll() def clear(self): return self.client.clear() def changeTable(self, name): self.client.changeTable(name) def getCount(self): return self.client.getCount() def test(self): return self.client.test()
28.487805
107
0.50742
[ "MIT" ]
dota2heqiuzhi/proxy_pool
db/dbClient.py
3,708
Python
# coding: utf-8 """ Kubernetes No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) OpenAPI spec version: v1.13.1 Generated by: https://github.com/swagger-api/swagger-codegen.git """ from __future__ import absolute_import import os import sys import unittest import kubernetes.client from kubernetes.client.rest import ApiException from kubernetes.client.models.v1alpha1_priority_class import V1alpha1PriorityClass class TestV1alpha1PriorityClass(unittest.TestCase): """ V1alpha1PriorityClass unit test stubs """ def setUp(self): pass def tearDown(self): pass def testV1alpha1PriorityClass(self): """ Test V1alpha1PriorityClass """ # FIXME: construct object with mandatory attributes with example values #model = kubernetes.client.models.v1alpha1_priority_class.V1alpha1PriorityClass() pass if __name__ == '__main__': unittest.main()
22.266667
105
0.720559
[ "Apache-2.0" ]
MiaoRachelYu/python
kubernetes/test/test_v1alpha1_priority_class.py
1,002
Python
"""Forms related to import operations.""" from __future__ import unicode_literals from django import forms from django.utils.translation import ugettext_lazy class ImportDataForm(forms.Form): """Base form to import objects.""" sourcefile = forms.FileField(label=ugettext_lazy("Select a file")) sepchar = forms.CharField( label=ugettext_lazy("Separator"), max_length=1, required=False, widget=forms.TextInput(attrs={"class": "form-control"}) ) continue_if_exists = forms.BooleanField( label=ugettext_lazy("Continue on error"), required=False, help_text=ugettext_lazy("Don't treat duplicated objects as error") ) def __init__(self, *args, **kwargs): super(ImportDataForm, self).__init__(*args, **kwargs) self.fields["sepchar"].widget.attrs = {"class": "col-md-1 form-control"} def clean_sepchar(self): if self.cleaned_data["sepchar"] == "": return ";" return self.cleaned_data["sepchar"] class ImportIdentitiesForm(ImportDataForm): """A form to import identities.""" crypt_password = forms.BooleanField( label=ugettext_lazy("Crypt passwords"), required=False, help_text=ugettext_lazy( "Check this option if passwords contained in your file " "are not crypted" ) )
29.521739
80
0.662003
[ "ISC" ]
antoniotrento/modoboa
modoboa/admin/forms/import_.py
1,358
Python

Dataset Card for "the-stack-smol-python"

More Information needed

Downloads last month
39