def test(test_file_path, model_path):
preprocessor = PreProcessor()
test_data = preprocessor.get_test(test_file_path, GRAMMAR_FILE,
PRIMITIVE_TYPES)
print('load model from [%s]' % model_path, )
params = torch.load(model_path, map_location=lambda storage, loc: storage)
transition_system = params['transition_system']
vocab = params['vocab']
parser = TranxParser(vocab, transition_system)
parser.load_state_dict(params['state_dict'])
parser.cuda()
parser.eval()
evaluator = ConalaEvaluator(transition_system)
eval_results, decode_results = evaluation.evaluate(
test_data,
parser,
evaluator,
BEAM_SIZE,
verbose=True,
return_decode_result=True)
print(eval_results)
pickle.dump(decode_results, open(SAVE_DECODE_TO, 'wb'))
def __init__(self,
L_layer_count,
k_hash_functions_per_layer,
w_parameter=0.20):
self.preprocessor = PreProcessor(
) # initialize the preprocessor instance
self.data_dict = dict(
) # declaring a dicitonary where key is image id and value is list of features. The values will be indexed.
self.L_layer_count = L_layer_count # the number of layers
self.k_hash_functions_per_layer = k_hash_functions_per_layer # number of hash functions per layer
self.feature_count = 0 # feature_count, will be given a value in init_data(). Used to generate the random projections.
self.image_ids = list(
) # The list of image IDs from the data_dict maintained separately. Ordering isn't a problem as in Python 3.7, dictionaries are ordered in terms of insertion.
self.data_matrix = [] # The data matrix of features alone
self.init_data(
) # Initializes the image IDs, data matrix and also the feature count as it is dependent on input data
self.w_parameter = w_parameter # w in (1)
self.hash_tables = list() # The list of hash tables or layers
print("Initializing the hash tables...")
for value in range(
self.L_layer_count
): # create L hash tables with k hash functions per layer
self.hash_tables.append(
HashTable(self.k_hash_functions_per_layer, self.feature_count,
self.w_parameter))
self.fill_all_hashtables(
) # Index all the data points in all the layers
def __init__(self, *args, **kwargs):
super(AbstractTestContract, self).__init__(*args, **kwargs)
self.pp = PreProcessor()
self.s = t.state()
self.s.block.number = HOMESTEAD_BLOCK
# t.gas_limit = 4712388
t.gas_limit = 2000000
def ncd_loop(doInit, dlThreadNum):
ndutil.setTimezone()
#read config
cnfManager = CnfManager()
cnfManager.load('./ndc.cnf')
cnfData = cnfManager.getCnfData()
#check dirs
ndutil.enableDir(cnfData['dirWorking'])
ndutil.enableDir(cnfData['dirStore'])
#ndlcom
logger = Logger('nDroid-Crawler', cnfData['ndlComHost'], cnfData['ndlComPort'])
logger.logger('Initiating')
dbManager = DbManager(cnfData['dbHost'], cnfData['dbUser'], cnfData['dbPass'], cnfData['dbName'])
if doInit:
dbManager.create_table()
os.system('rm -f %s/*' % cnfData['dirWorking'])
os.system('rm -f %s/*' % cnfData['dirStore'])
#logger.logger('Customizing Spiders')
#spiderGenerator = SpiderGenerator('template', 'spider/spiders')
#for spider in cnfData['spiders']:
# spiderGenerator.gen_spider(spider, cnfData[spider]['startPage'], cnfData[spider]['stopPage'])
rpQueue = Queue()
pdQueue = Queue()
dpQueue = Queue()
pdLock = threading.Lock()
rpcMonitor = RpcMonitor(logger, cnfData['rpcPort'], cnfData['rpcAuth'], 'RpcMonitor')
rpcMonitor.setGlobalInfo(ndutil.getCurrentTimeStr(), 'Standalone', dlThreadNum)
rpcMonitor.setDownloadTotal(pdQueue.qsize())
rpcMonitor.setPdQueueSize(pdQueue.qsize())
botScheduler = BotScheduler(logger, rpcMonitor, cnfData['spiders'], cnfData['spiderCnfs'], 'BotScheduler')
receiver = Receiver(logger, rpcMonitor, rpQueue, cnfData['receiverPort'], 'Receiver')
preProcessor = PreProcessor(logger, rpcMonitor, rpQueue, pdQueue, pdLock, dbManager, 'PreProcessor')
downloader = Downloader([logger, rpcMonitor, pdQueue, dpQueue, pdLock, dlThreadNum, cnfData['dirWorking']], 'Downloader')
processor = Processor(logger, rpcMonitor, dpQueue, pdLock, pdQueue, dbManager, cnfData['dirWorking'], cnfData['dirStore'], 'Processor')
logger.logger('Starting Threads')
rpcMonitor.start()
botScheduler.start()
receiver.start()
preProcessor.start()
downloader.start()
processor.start()
processor.join()
downloader.join()
preProcessor.join()
receiver.join()
botScheduler.join()
rpcMonitor.join()
def check_review_preprocess():
data = pd.read_csv('test_data/test_revs.csv')
preprocess = PreProcessor()
preprocessed_revs = preprocess.preprocess_review_list(data['text'])
if len(preprocessed_revs) > 0:
print('Testing passed - Preprocessing is Successfully !')
else:
print('Preprocessing has failed')
def predict_comment(self):
with open('selected_words.txt', 'r', encoding='UTF-8') as fd:
selected_words = json.loads(fd.read())
model = models.load_model("toxic_comment_model.h5")
pprocess = PreProcessor()
token = pprocess.tokenize(self.input_comment)
tf = pprocess.term_frequency(token, selected_words)
data = np.expand_dims(np.asarray(tf).astype('float32'), axis=0)
score = float(model.predict(data)) # 클린 댓글 일수록 낮은 숫자
return score
def tokenize_reviews(self, all_reviews):
all_review_tokens = []
preprocessing = PreProcessor()
for review_text in all_reviews:
# remove symbols
review_text = preprocessing.remove_symbols(review_text)
# clean review
tokens = preprocessing.clean_review(review_text)
# collect all the tokens
all_review_tokens.append(tokens)
return all_review_tokens
def __init__(self, db, ldamodel, topic_classifier, severity_classifier,
sentiment_classifier, config):
super().__init__()
self.__db = db
self.__preprocessor = PreProcessor(db)
self.__analyzer = Analyzer(db, ldamodel, topic_classifier,
severity_classifier, sentiment_classifier,
config)
self.__dataviewer = Dataviewer(db, config)
self.__ldamodel = ldamodel
self.__config = config
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
self.multisig_abi = self.s.abi_contract(
self.pp.process('MultiSigWalletWithDailyLimit.sol', contract_dir='solidity/', add_dev_code=True),
language='solidity',
constructor_parameters=([accounts[0]], 1, 0),
contract_name="MultiSigWalletWithDailyLimit"
).translator
def __init__(self, input_file):
"""
Initializes Transformer class and instantiates all the pipeline
step classes
:param input_file: input XML file, downloaded from NAIS
:type input_file: str
"""
self.reader = EDRReader(input_file)
self.preprocessor = PreProcessor(tokenize_words)
self.beneficiary_categorizer = HasBeneficiaryOwnershipRecord()
self.parser = HeuristicBasedParser()
def aspect_common_details(self, threshold):
pp = PreProcessor()
for aspect, aspect_detail in self.reviews_per_aspect.items():
reviews = aspect_detail.review_list
reviews = [pp.preprocess_review(review, False) for review in reviews]
generate_mentions = MentionsGenerator()
common_mentions = generate_mentions.get_common_mentions(reviews, threshold)
aspect_detail.common_mentions = common_mentions
generate_common_terms = CommonTermsGenerator()
common_term_details = generate_common_terms.get_common_term_details(reviews, threshold)
aspect_detail.common_term_details = common_term_details
def __init__(self):
conf_path_nn = '/src/nn/conf/nn.yaml'
with open(conf_path_nn, 'r') as fd:
self.conf = yaml.safe_load(fd)
self.batch_size = self.conf['testing']['batch_size']
self.checkpoint_path = self.conf['misc']['checkpoint_path']
self.logger = Logger
self.preProcessor = PreProcessor(Logger)
self.nn = Nn(Logger, conf_path_nn, testing=True)
self.sess = tf.compat.v1.Session()
self.start()
def compare_test_to_db(test_query):
preprocessor = PreProcessor()
facts = []
with open('facts.txt', 'r') as fact_file:
fact_data = fact_file.read().split("\n")
for data in fact_data:
fact = Fact(data, preprocessor.preprocess(data), FactType.TRUTH)
facts.append(fact)
text_comp = TextComparator()
# text_comp.train_model(facts)
file_name = "test"
# text_comp.save_model(file_name)
text_comp.load_model(file_name)
test_fact = Fact(test_query, preprocessor.preprocess(
test_query), FactType.TRUTH)
return text_comp.match_fact(test_fact, facts, topn=3)
def __init__(self):
conf_path_cnn = '/src/cnn/conf/cnn.yaml'
with open(conf_path_cnn, 'r') as fd:
self.conf = yaml.safe_load(fd)
# load configuration
self.num_epochs = self.conf['training']['epochs']
self.batch_size = self.conf['training']['batch_size']
self.checkpoint_path = self.conf['misc']['checkpoint_path']
self.logger = Logger
self.preProcessor = PreProcessor(Logger)
self.cnn = Cnn(Logger, conf_path_cnn)
self.sess = tf.compat.v1.Session()
self.start()
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_daily_limit_overflow
"""
HOMESTEAD_BLOCK = 1150000
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
def test(self):
# Create wallet
required_accounts = 2
daily_limit = 2000
wa_1 = 1
wa_2 = 2
constructor_parameters = ([accounts[wa_1], accounts[wa_2]],
required_accounts, daily_limit)
self.multisig_wallet = self.s.abi_contract(
self.pp.process('MultiSigWalletWithDailyLimit.sol',
contract_dir='solidity/',
add_dev_code=True),
language='solidity',
constructor_parameters=constructor_parameters,
contract_name="MultiSigWalletWithDailyLimit")
# Send money to wallet contract
deposit = 10000
self.s.send(keys[wa_1], self.multisig_wallet.address, deposit)
self.assertEqual(
self.s.block.get_balance(self.multisig_wallet.address), deposit)
self.assertEqual(self.multisig_wallet.dailyLimit(), daily_limit)
# Withdraw daily limit
value = 2000
tx_1 = self.multisig_wallet.submitTransaction(accounts[wa_1],
value,
"",
sender=keys[wa_2])
# Transaction succeeds
self.assertTrue(self.multisig_wallet.transactions(tx_1)[3])
# Try to overflow spentToday to reset it to 0.
tx_2 = self.multisig_wallet.submitTransaction(accounts[wa_1],
2**256 - value,
"",
sender=keys[wa_2])
# Transaction cannot complete and spentToday is still == 2000.
self.assertFalse(self.multisig_wallet.transactions(tx_2)[3])
self.assertEqual(self.multisig_wallet.spentToday(), daily_limit)
# User tries to withdraw daily limit again on same day. It fails as daily limit was withdrawn already.
tx_3 = self.multisig_wallet.submitTransaction(accounts[wa_1],
value,
"",
sender=keys[wa_2])
self.assertFalse(self.multisig_wallet.transactions(tx_3)[3])
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_owner_replacement
"""
HOMESTEAD_BLOCK = 1150000
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
def test(self):
# Create wallet
required_accounts = 2
wa_1 = 1
wa_2 = 2
constructor_parameters = ([accounts[wa_1],
accounts[wa_2]], required_accounts)
self.multisig_wallet = self.s.abi_contract(
self.pp.process('MultiSigWallet.sol',
contract_dir='solidity/',
add_dev_code=True),
language='solidity',
constructor_parameters=constructor_parameters)
self.assertTrue(self.multisig_wallet.isOwner(accounts[wa_1]))
self.assertTrue(self.multisig_wallet.isOwner(accounts[wa_2]))
# Create ABIs
multisig_abi = self.multisig_wallet.translator
# Exchange owner wa_2 with wa_3
wa_3 = 3
exchange_owner_data = multisig_abi.encode(
'replaceOwner', [accounts[wa_2], accounts[wa_3]])
# Only a wallet owner (in this case wa_1) can do this. Owner confirms transaction at the same time.
transaction_id = self.multisig_wallet.submitTransaction(
self.multisig_wallet.address,
0,
exchange_owner_data,
sender=keys[wa_1])
# Other owner wa_2 confirms and executes transaction at the same time as min sig are available
self.assertFalse(self.multisig_wallet.transactions(transaction_id)[3])
self.assertEqual(
self.multisig_wallet.getOwners(),
[accounts[wa_1].encode('hex'), accounts[wa_2].encode('hex')])
self.multisig_wallet.confirmTransaction(transaction_id,
sender=keys[wa_2])
# Transaction was executed
self.assertTrue(self.multisig_wallet.transactions(transaction_id)[3])
# Owner was switched
self.assertFalse(self.multisig_wallet.isOwner(accounts[wa_2]))
self.assertTrue(self.multisig_wallet.isOwner(accounts[wa_3]))
self.assertEqual(
self.multisig_wallet.getOwners(),
[accounts[wa_1].encode('hex'), accounts[wa_3].encode('hex')])
def classify(text):
text = PreProcessor.clean_text(text)
data = np.array([text])
data = tokenizer.texts_to_sequences(data)
data = tf.keras.preprocessing.sequence.pad_sequences(data, maxlen=MAX_DOCUMENT_LENGTH)
y_predicted = np.argmax(classifier.predict(data), axis=1)
topic = news_classes.class_map[str(y_predicted[0]+1)]
return topic
def __init__(self, protocol, host, port, add_dev_code, verify_code,
contract_dir, gas, gas_price, private_key):
self.pp = PreProcessor()
self.s = t.state()
self.s.block.number = 1150000 # Homestead
t.gas_limit = int(gas)
self.json_rpc = EthJsonRpc(protocol=protocol, host=host, port=port)
if private_key:
self.user_address = '0x' + privtoaddr(
private_key.decode('hex')).encode('hex')
else:
self.user_address = self.json_rpc.eth_coinbase()["result"]
self.add_dev_code = add_dev_code == 'true'
self.verify_code = verify_code == 'true'
self.contract_dir = contract_dir
self.gas = int(gas)
self.gas_price = int(gas_price)
self.private_key = private_key
self.contract_addresses = {}
self.contract_abis = {}
def is_review_in_aspect(self, aspect, review):
pp = PreProcessor()
review = pp.preprocess_review(review, False)
tokens = word_tokenize(review)
# use pos tag to find all NN and NNS
tagged_words = pos_tag(tokens)
is_noun = lambda pos: pos[:2] == 'NN'
is_nouns = lambda pos: pos[:2] == 'NNS'
nouns = [word for (word, pos) in tagged_words if is_noun(pos) or is_nouns(pos)]
asb = AspectSynonymBank()
aspect_syn = asb.get_synonyms_for_aspect(aspect)
match = [word for word in nouns if word in aspect_syn]
if len(match) > 0:
return True
return False
def __init__(self, read_count=5000, seg_length=.05):
'''
INPUTS: read_count = total number of songs to be read;
seg_length = length of song segments that song will be split into (in seconds)
'''
'''
band_type controls how frequencies are binned, can have
logarithmic (nonlinear) or linear spacing
'''
self.band_type = "log"
'''limit the number of files that are read'''
self.files_read_count = read_count
''' total number of frequency bins'''
self.freq_bin_total = 15
'''
song is splitted into chunks of length segment_length (.05 seconds default)
and then Fourier transform is performed on each of these chunks
'''
self.segment_length = seg_length
'''read in song class labels'''
prepro = PreProcessor()
self.labels = prepro.getSongLabels()
def main(train_file, test_file):
# FILE_NAME = argv[0]
pprocess = PreProcessor()
train_data = pprocess.load_data(train_file)
test_data = pprocess.load_data(test_file)
labeled_train_df = pprocess.determine_pos_neg_label(train_data)
labeled_test_df = pprocess.determine_pos_neg_label(test_data)
selected_words = pprocess.preprocess_data(labeled_train_df)
train_model(pprocess, labeled_train_df, labeled_test_df, selected_words)
def __init__(self, de_context, preprocessor=PreProcessor()):
"""
Parameters
----------
de_context: DeContext
_preprocessor: PreProcessor
Attributes
----------
_train_data_location: str
training data location including schema
_valid_data_location: str
training data location including schema
_preprocessor: PreProcessor
_dp_queue: Queue
data pointer queue
_data_queue: Queue
data queue, which holds mini-batch data
_m_queue: Queue
message queue
_n_epoch: int
_batch_size: int
batch size
read_workers: List of Process
read_workers read data from _dp_queue
N_READ_WORKERS: int
N_SHUFFLE: int
"""
# Attributes
self._train_data_location = de_context.data_config.train_data_location
self._valid_data_location = de_context.data_config.valid_data_location
self._preprocessor = preprocessor
self._n_epoch = de_context.global_config.n_epoch
self._batch_size = de_context.global_config.batch_size
self._dp_queue = Queue(0)
self._data_queue = Queue(0)
self._m_queue = Queue()
self.read_workers = []
# Put data pointers
self._put_all_data_pointers()
# Create and run workers
self._create_and_run_read_workers()
# Set signal handler
signal.signal(signal.SIGINT, self._signal_handler)
signal.signal(signal.SIGTERM, self._signal_handler)
class DNDFileEventHandler(PatternMatchingEventHandler):
patterns = ["*.json"]
def __init__(self, db, ldamodel, topic_classifier, severity_classifier,
sentiment_classifier, config):
super().__init__()
self.__db = db
self.__preprocessor = PreProcessor(db)
self.__analyzer = Analyzer(db, ldamodel, topic_classifier,
severity_classifier, sentiment_classifier,
config)
self.__dataviewer = Dataviewer(db, config)
self.__ldamodel = ldamodel
self.__config = config
def on_modified(self, event):
self.process(event.src_path)
def on_created(self, event):
self.process(event.src_path)
def process(self, filepath):
# print(f'event type: {event.event_type} path : {event.src_path}')
file_name = os.path.basename(filepath)
with open(filepath, 'r') as myfile:
data = myfile.read()
obj = json.loads(data)
upproc_docid = self.__db.insert_unprocessed(file_name, obj)
#self.__ldamodel.run_unseendata(str(obj['title']))
#PRE-PROCESSING
#print('Started Pre-Processsing .......')
preproc_docid = self.__preprocessor.preprocess(upproc_docid)
#print('Completed Pre-Processsing .......')
# ANALYZE
print('Started Analyzing .......')
is_analyzed = self.__analyzer.analyze(preproc_docid, upproc_docid)
print('Completed Analyzing .......')
if is_analyzed == True and self.__config['Settings'][
'batch-runner'] == 0:
topic_to_watch = self.__config['Settings']['topic-to-watch']
# UPDATE VIEWER
print('Started Graph .......')
self.__dataviewer.plot(topic_to_watch)
print('Completed Graph .......')
class Train:
def __init__(self):
conf_path_nn = '/src/nn/conf/nn.yaml'
with open(conf_path_nn, 'r') as fd:
self.conf = yaml.safe_load(fd)
# load configuration
self.num_epochs = self.conf['training']['epochs']
self.batch_size = self.conf['training']['batch_size']
self.checkpoint_path = self.conf['misc']['checkpoint_path']
self.logger = Logger
self.preProcessor = PreProcessor(Logger)
self.nn = Nn(Logger, conf_path_nn)
self.sess = tf.compat.v1.Session()
self.start()
def start(self):
train_x, val_x, test_x, train_y, val_y, test_y = self.preProcessor.get_data()
self.sess.run(tf.compat.v1.global_variables_initializer())
self.sess.run(tf.compat.v1.local_variables_initializer())
saver = tf.compat.v1.train.Saver()
num_iterations = int(len(train_x) / self.batch_size)
self.logger.info('training...')
for epoch in range(self.num_epochs):
for iter_ in range(num_iterations):
batch_x = train_x[iter_ * self.batch_size:(iter_ + 1) * self.batch_size, :]
batch_y = train_y[iter_ * self.batch_size:(iter_ + 1) * self.batch_size, :]
self.sess.run(self.nn.training, feed_dict={self.nn.layer_input: batch_x, self.nn.ground_truth: batch_y})
# train loss
_, loss_train, acc_train = self.nn.analyze_epoch(self.sess, train_x, train_y)
# val loss
_, loss_val, acc_val = self.nn.analyze_epoch(self.sess, val_x, val_y)
self.logger.info('epoch: {0}/{1}, loss_train: {2}, acc_train: {3}, loss_val: {4}, acc_val: {5}'
.format(epoch + 1, self.num_epochs, loss_train, acc_train, loss_val, acc_val))
# save model
saved_path = saver.save(self.sess, '{0}model.ckpt'.format(self.checkpoint_path))
self.logger.info('model saved in {0}'.format(saved_path))
self.sess.close()
def __init__(self, read_count=5000, seg_length=.05):
'''
INPUTS: read_count = total number of songs to be read;
seg_length = length of song segments that song will be split into (in seconds)
'''
'''
band_type controls how frequencies are binned, can have
logarithmic (nonlinear) or linear spacing
'''
self.band_type = "log"
'''limit the number of files that are read'''
self.files_read_count = read_count
''' total number of frequency bins'''
self.freq_bin_total = 15
'''
song is splitted into chunks of length segment_length (.05 seconds default)
and then Fourier transform is performed on each of these chunks
'''
self.segment_length = seg_length
'''read in song class labels'''
prepro = PreProcessor()
self.labels = prepro.getSongLabels()
def generate_summary(self, review):
pp = PreProcessor()
formatted_text = pp.preprocess_review(review, True)
sentences = sent_tokenize(review)
word_frequencies = {}
for word in word_tokenize(formatted_text):
stop_words = set(stopwords.words('english'))
if word not in stop_words:
if word not in word_frequencies.keys():
word_frequencies[word] = 1
else:
word_frequencies[word] += 1
maximum_frequency = max(word_frequencies.values())
for word in word_frequencies.keys():
word_frequencies[word] = (word_frequencies[word] /
maximum_frequency)
sentence_scores = {}
for sent in sentences:
for word in word_tokenize(sent.lower()):
if word in word_frequencies.keys():
if len(sent.split(' ')) < 80:
if sent not in sentence_scores.keys():
sentence_scores[sent] = word_frequencies[word]
else:
sentence_scores[sent] += word_frequencies[word]
sent_summary = heapq.nlargest(2,
sentence_scores,
key=sentence_scores.get)
summarized = ' '.join(sent_summary)
return summarized
def __init__(self, train_test_dir, vocab, test_ground_truth_path):
self.model = PreProcessor(train_test_dir, vocab)
self.train_test_dir = train_test_dir
self.test_ground_truth_path = test_ground_truth_path
# { Class(int) : Prior Probability of class (double) }
self.prior = {}
# { (Class(int) , Feature (string)) : Conditional Probability (double) }
self.condProb = {}
# list of (Feature(string),CCE(double))
self.featureCCE = []
"""
def main():
r0 = CXXParser("ctpapi/a.cpp").parse()
r1 = PreProcessor(r0).process()
r1.dict_classes.clear()
constants = r0.variables
constants.update(r1.const_macros)
constants = {k: v for k, v in constants.items() if not k.startswith('_')}
functions = r0.functions
classes = r1.classes
# make all api "final" to improve performance
for c in classes.values():
type = c.name[-3:]
if type == "Api":
for ms in c.functions.values():
for m in ms:
if m.is_virtual:
m.is_pure_virtual = False
m.is_final = True
elif type == 'Spi':
for ms in c.functions.values():
for m in ms:
m.is_virtual = True
# m.is_pure_virtual = True
m.is_final = False
options = GeneratorOptions(
typedefs=r0.typedefs,
constants=constants,
functions=functions,
classes=classes,
dict_classes=r1.dict_classes,
enums=r0.enums,
)
saved_files = Generator(options=options).generate()
output_dir = "./generated_files"
# clear output dir
if not os.path.exists(output_dir):
os.mkdir(output_dir)
clear_dir(output_dir)
for name, data in saved_files.items():
with open(f"{output_dir}/{name}", "wt") as f:
f.write(data)
def main():
fpath = argv[1]
with open(fpath, 'r') as f:
data = f.read()
auto_process_libs = [
'math',
'os.path',
]
auto_import_libs = [
*auto_process_libs,
'os',
]
options = Options(
debug=True,
imports=auto_import_libs,
eval_mod=auto_process_libs,
)
data = PreProcessor(options=options).preprocess(data)
data = Transpiler(options=options).transpile(data)
tree = parse(data)
tree = Generator(options=options).generate(tree)
tree = Optimizer(options=options).optimize(tree)
tree = Inliner(options=options).inline(tree)
tree = Importer( options=options).clean_imports(tree)
tree = UnusedRemover(options=options).remove_unused(tree)
code = Unparser.unparse(tree)
code = Minifier(options=options).minify(code)
log(dump(tree))
log(code.replace('\n', '\\n\n'))
path_parts = fpath.split('.')
out_path = join(getcwd(), 'dist',
''.join(path_parts[:-1])[1:] + '.py')
out_dir = dirname(out_path)
if not exists(out_dir):
mkdir(out_dir)
with open(out_path, 'w') as f:
f.write(code)
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_daily_limit_dos
"""
HOMESTEAD_BLOCK = 1150000
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
def test(self):
# Create wallet
required_accounts = 2
daily_limit = 2000
wa_1 = 1
wa_2 = 2
constructor_parameters = (
[accounts[wa_1], accounts[wa_2]],
required_accounts,
daily_limit
)
self.multisig_wallet = self.s.abi_contract(
self.pp.process('MultiSigWalletWithDailyLimit.sol', contract_dir='solidity/', add_dev_code=True),
language='solidity',
constructor_parameters=constructor_parameters,
contract_name="MultiSigWalletWithDailyLimit"
)
self.fail_account = self.s.abi_contract('contract FailAccount { function () {} }', language='solidity')
# Send money to wallet contract
deposit = 10000
self.s.send(keys[wa_1], self.multisig_wallet.address, deposit)
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit)
self.assertEqual(self.multisig_wallet.dailyLimit(), daily_limit)
# Withdraw daily limit
value = 2000
tx_1 = self.multisig_wallet.submitTransaction(self.fail_account.address, value, "", sender=keys[wa_2])
# Transaction fails and spentToday remains 0
self.assertFalse(self.multisig_wallet.transactions(tx_1)[3])
self.assertEqual(self.multisig_wallet.spentToday(), 0)
class Test:
def __init__(self):
conf_path_nn = '/src/nn/conf/nn.yaml'
with open(conf_path_nn, 'r') as fd:
self.conf = yaml.safe_load(fd)
self.batch_size = self.conf['testing']['batch_size']
self.checkpoint_path = self.conf['misc']['checkpoint_path']
self.logger = Logger
self.preProcessor = PreProcessor(Logger)
self.nn = Nn(Logger, conf_path_nn, testing=True)
self.sess = tf.compat.v1.Session()
self.start()
def start(self):
train_x, val_x, test_x, train_y, val_y, test_y = self.preProcessor.get_data(
)
self.logger.info('testing...')
# restore model
self.sess = tf.compat.v1.Session()
saver = tf.compat.v1.train.Saver()
model_path = self.conf['testing']['model']
saver.restore(self.sess, model_path)
self.logger.info('{0} restored'.format(model_path))
# test
self.sess.run(tf.compat.v1.local_variables_initializer())
pred_y, loss, acc = self.nn.analyze_epoch(self.sess, test_x, test_y)
self.logger.info('test_loss: {0}, test_acc: {1}'.format(loss, acc))
self.sess.close()
return pred_y
if __name__ == "__main__":
parser = argparse.ArgumentParser(\
description='Demo script for "inlier" detection benchmark')
parser.add_argument("-t", "--training-data", dest="training_data",
help="csv file of the training set")
parser.add_argument('-s', "--test-data", dest="test_data",
help='Csv file of the test data')
args = parser.parse_args()
pp = PreProcessor(args.training_data, args.test_data)
# idx = pp.index(["roisize","n2_avg"])
nu = 0.01
x, y = estimate_gamma(pp.traindata, nu)
idx = y[y <= 0.25].size - 1
print ' best gamma:', x[idx], 'with SV frac', y[idx]
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(x, y, 'ro', label='estimate')
# ax.semilogx()
ax.grid()
dy = np.diff(Y[:, 0])[0]
return Z.sum()*dx*dy
if __name__ == "__main__":
parser = argparse.ArgumentParser(\
description='Demo script for "inlier" detection benchmark')
parser.add_argument("-t", "--training-data", dest="training_data",
help="csv file of the training set")
parser.add_argument('-s', "--test-data", dest="test_data",
help='Csv file of the test data')
args = parser.parse_args()
pp = PreProcessor(args.training_data, args.test_data)
idx = pp.index(["roisize","n2_avg"])
traindata = pp.traindata[:, idx]
testdata = pp.testdata[:, idx]
cov0 = np.cov(pp.traindata.T)
corr0 = np.corrcoef(pp.traindata.T)
det0 = la.det(corr0)
fig = plt.figure()
axes = fig.add_subplot(1,1,1)
axes.matshow(cov0, cmap=cm.Greens)
axes.set_title("covariance of training data")
pca = PCA(pp.traindata, minfrac=0.01)
cov0pca = np.cov(pca.project(pp.traindata).T)
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_multisig_wallet_with_daily_limit
"""
HOMESTEAD_BLOCK = 1150000
TWENTY_FOUR_HOURS = 86400 # 24h
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
def test(self):
# Create wallet
required_accounts = 2
daily_limit = 3000
wa_1 = 1
wa_2 = 2
wa_3 = 3
constructor_parameters = (
[accounts[wa_1], accounts[wa_2], accounts[wa_3]],
required_accounts,
daily_limit
)
gas = self.s.block.gas_used
self.multisig_wallet = self.s.abi_contract(
self.pp.process('MultiSigWalletWithDailyLimit.sol', contract_dir='solidity/', add_dev_code=True),
language='solidity',
constructor_parameters=constructor_parameters,
contract_name="MultiSigWalletWithDailyLimit"
)
self.assertLess(self.s.block.gas_used - gas, 2000000)
print "Deployment costs: {}".format(self.s.block.gas_used - gas)
# Create ABIs
multisig_abi = self.multisig_wallet.translator
# Send money to wallet contract
deposit = 10000
self.s.send(keys[wa_1], self.multisig_wallet.address, deposit)
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit)
self.assertEqual(self.multisig_wallet.dailyLimit(), daily_limit)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit)
# Withdraw daily limit
value_1 = 2000
wa_1_balance = self.s.block.get_balance(accounts[wa_1])
self.multisig_wallet.submitTransaction(accounts[wa_1], value_1, "", sender=keys[wa_2])
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit - value_1)
self.assertEqual(self.s.block.get_balance(accounts[wa_1]), wa_1_balance + value_1)
# Update daily limit
daily_limit_updated = 2000
update_daily_limit = multisig_abi.encode("changeDailyLimit", [daily_limit_updated])
transaction_id = self.multisig_wallet.submitTransaction(self.multisig_wallet.address, 0,
update_daily_limit, sender=keys[wa_1])
self.multisig_wallet.confirmTransaction(transaction_id, sender=keys[wa_2])
self.assertEqual(self.multisig_wallet.dailyLimit(), daily_limit_updated)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), 0)
self.s.block.timestamp += self.TWENTY_FOUR_HOURS + 1
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated)
# Withdraw daily limit
value_2 = 1000
wa_1_balance = self.s.block.get_balance(accounts[wa_1])
self.multisig_wallet.submitTransaction(accounts[wa_1], value_2, "", sender=keys[wa_2])
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit - value_1 - value_2)
self.assertEqual(self.s.block.get_balance(accounts[wa_1]), wa_1_balance + value_2)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated - value_2)
self.multisig_wallet.submitTransaction(accounts[wa_1], value_2, "", sender=keys[wa_2])
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit - value_1 - value_2*2)
self.assertEqual(self.s.block.get_balance(accounts[wa_1]), wa_1_balance + value_2*2)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated - value_2*2)
# Third time fails, because daily limit was reached
transaction_id = self.multisig_wallet.submitTransaction(accounts[wa_1], value_2, "", sender=keys[wa_2])
self.assertFalse(self.multisig_wallet.transactions(transaction_id)[3])
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit - value_1 - value_2*2)
self.assertEqual(self.s.block.get_balance(accounts[wa_1]), wa_1_balance + value_2*2)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), 0)
# Let one day pass
self.s.block.timestamp += self.TWENTY_FOUR_HOURS + 1
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated)
# Execute transaction should work now but fails, because it is triggered from a non owner address
self.assertRaises(TransactionFailed, self.multisig_wallet.executeTransaction, transaction_id, sender=keys[9])
# Execute transaction also fails if the sender is a wallet owner but didn't confirm the transaction first
self.assertRaises(TransactionFailed, self.multisig_wallet.executeTransaction, transaction_id, sender=keys[wa_1])
# But it works with the right sender
self.multisig_wallet.executeTransaction(transaction_id, sender=keys[wa_2])
self.assertTrue(self.multisig_wallet.transactions(transaction_id)[3])
# Let one day pass
self.s.block.timestamp += self.TWENTY_FOUR_HOURS + 1
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated)
# User wants to withdraw more than the daily limit. Withdraw is unsuccessful.
value_3 = 3000
wa_1_balance = self.s.block.get_balance(accounts[wa_1])
self.multisig_wallet.submitTransaction(accounts[wa_1], value_3, "", sender=keys[wa_2])
# Wallet and user balance remain the same.
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit - value_1 - value_2*3)
self.assertEqual(self.s.block.get_balance(accounts[wa_1]), wa_1_balance)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated)
# Daily withdraw is possible again
self.multisig_wallet.submitTransaction(accounts[wa_1], value_2, "", sender=keys[wa_2])
# Wallet balance decreases and user balance increases.
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), deposit - value_1 - value_2*4)
self.assertEqual(self.s.block.get_balance(accounts[wa_1]), wa_1_balance + value_2)
self.assertEqual(self.multisig_wallet.calcMaxWithdraw(), daily_limit_updated - value_2)
# Try to execute a transaction tha does not exist fails
transaction_id = 999
self.assertRaises(TransactionFailed, self.multisig_wallet.executeTransaction, transaction_id, sender=keys[wa_1])
import pandas as pd
import os, sys
import config
from preprocessor import PreProcessor
csvname = 'df_data.csv'
df_data = pd.read_csv(os.path.join('tmp2', csvname), index_col=0)
print('df_data')
csvname = 'attributes.csv'
df_attr = pd.read_csv(os.path.join('../data', csvname))
preproc = PreProcessor(config)
df_attr = preproc.clean_text(df_attr)
print(df_attr)
with open('data.text','wt') as f:
for col in ['q','t','d']:
f.write(' '.join(df_data[col].tolist()))
f.write(' ')
f.write(' '.join(df_attr['value'].tolist()))
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_execution_after_requirements_changed
"""
HOMESTEAD_BLOCK = 1150000
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
def test(self):
# Create wallet
required_accounts = 2
wa_1 = 1
wa_2 = 2
wa_3 = 3
constructor_parameters = (
[accounts[wa_1], accounts[wa_2], accounts[wa_3]],
required_accounts
)
self.multisig_wallet = self.s.abi_contract(
self.pp.process('MultiSigWallet.sol', contract_dir='solidity/', add_dev_code=True),
language='solidity',
constructor_parameters=constructor_parameters
)
# Create ABIs
multisig_abi = self.multisig_wallet.translator
# Send money to wallet contract
deposit = 1000
self.s.send(keys[wa_1], self.multisig_wallet.address, deposit)
self.assertEqual(self.s.block.get_balance(self.multisig_wallet.address), 1000)
# Add owner wa_4
wa_4 = 4
add_owner_data = multisig_abi.encode('addOwner', [accounts[wa_4]])
# Only a wallet owner (in this case wa_1) can do this. Owner confirms transaction at the same time.
transaction_id = self.multisig_wallet.submitTransaction(self.multisig_wallet.address, 0, add_owner_data,
sender=keys[wa_1])
# There is one pending transaction
exclude_pending = False
include_pending = True
exclude_executed = False
include_executed = True
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 1, include_pending, exclude_executed), [transaction_id])
# Update required to 1
new_required = 1
update_requirement_data = multisig_abi.encode('changeRequirement', [new_required])
# Submit successfully
transaction_id_2 = self.multisig_wallet.submitTransaction(self.multisig_wallet.address, 0,
update_requirement_data, sender=keys[wa_1])
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 2, include_pending, exclude_executed),
[transaction_id, transaction_id_2])
# Confirm change requirement transaction
self.multisig_wallet.confirmTransaction(transaction_id_2, sender=keys[wa_2])
self.assertEqual(self.multisig_wallet.required(), new_required)
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 1, exclude_pending, include_executed),
[transaction_id_2])
# Execution fails, because sender is not wallet owner
self.assertRaises(TransactionFailed, self.multisig_wallet.executeTransaction, transaction_id, sender=keys[9])
# Because the # required confirmations changed to 1, the addOwner transaction can be executed now
self.multisig_wallet.executeTransaction(transaction_id, sender=keys[wa_1])
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 2, exclude_pending, include_executed),
[transaction_id, transaction_id_2])
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_multisig_wallet_with_daily_limit_factory
"""
HOMESTEAD_BLOCK = 1150000
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
self.multisig_abi = self.s.abi_contract(
self.pp.process('MultiSigWalletWithDailyLimit.sol', contract_dir='solidity/', add_dev_code=True),
language='solidity',
constructor_parameters=([accounts[0]], 1, 0),
contract_name="MultiSigWalletWithDailyLimit"
).translator
def multisig_transaction(self, contract_address, func_name, params=(), sender=0):
result = self.multisig_abi.decode(
func_name,
self.s.send(
keys[sender], contract_address, 0, self.multisig_abi.encode(func_name, params)
)
)
return result[0] if len(result) == 1 else result
def test(self):
# Create factory
gas = self.s.block.gas_used
self.multisig_wallet_factory = self.s.abi_contract(
self.pp.process('MultiSigWalletWithDailyLimitFactory.sol', contract_dir='solidity/', add_dev_code=True),
language='solidity',
contract_name="MultiSigWalletWithDailyLimitFactory"
)
self.assertLess(self.s.block.gas_used - gas, 2500000)
print "Deployment costs: {}".format(self.s.block.gas_used - gas)
# Create wallet
required_accounts = 2
daily_limit = 1000
wa_1 = 1
wa_2 = 2
wa_3 = 3
multisig_wallet_address = self.multisig_wallet_factory.create([accounts[wa_1], accounts[wa_2], accounts[wa_3]],
required_accounts,
daily_limit)
wallet_count = self.multisig_wallet_factory.getInstantiationCount(accounts[0])
multisig_wallet_address_confirmation = self.multisig_wallet_factory.instantiations(accounts[0], wallet_count-1)
self.assertEqual(multisig_wallet_address, multisig_wallet_address_confirmation)
self.assertTrue(self.multisig_wallet_factory.isInstantiation(multisig_wallet_address))
# Send money to wallet contract
deposit = 10000
self.s.send(keys[wa_1], multisig_wallet_address, deposit)
self.assertEqual(self.s.block.get_balance(multisig_wallet_address), deposit)
self.assertEqual(self.multisig_transaction(multisig_wallet_address, "dailyLimit"), daily_limit)
self.assertEqual(self.multisig_transaction(multisig_wallet_address, "calcMaxWithdraw"), daily_limit)
# Update daily limit
daily_limit_updated = 2000
update_daily_limit = self.multisig_abi.encode("changeDailyLimit", [daily_limit_updated])
transaction_id = self.multisig_transaction(multisig_wallet_address,
"submitTransaction",
(multisig_wallet_address, 0, update_daily_limit),
wa_1)
self.multisig_transaction(multisig_wallet_address,
"confirmTransaction",
(transaction_id, ),
wa_2)
self.assertEqual(self.multisig_transaction(multisig_wallet_address, "dailyLimit"), daily_limit_updated)
self.assertEqual(self.multisig_transaction(multisig_wallet_address, "calcMaxWithdraw"), daily_limit_updated)
class BernoulliNaiveBayes:
MAX_CLASS = 40
def __init__(self, train_test_dir, vocab, test_ground_truth_path):
self.model = PreProcessor(train_test_dir, vocab)
self.train_test_dir = train_test_dir
self.test_ground_truth_path = test_ground_truth_path
# { Class(int) : Prior Probability of class (double) }
self.prior = {}
# { (Class(int) , Feature (string)) : Conditional Probability (double) }
self.condProb = {}
# list of (Feature(string),CCE(double))
self.featureCCE = []
"""
######## the variable following for extra part
# { Class(int) : Prior Probability of class (double) }
self.priorBi = {}
# list of bigram tuple (feature1(string),feature2(string))
self.biFeat = []
# { (Class(int), Feature (tuple)) : multinomial Prob(double) }
self.MulProb = {}
"""
# Define Train function
def train(self):
for c in self.model.classes:
self.prior[c] = len(self.model.trainFileNames[c]) * 1.0 / self.model.N
counter = {}
for feature in self.model.feature:
counter[feature] = 0
for filename in self.model.trainFileNames[c]:
words = set()
with open(filename, 'r') as file:
for line in file:
for word in self.model.word_tokenize(line):
words.add(word)
for feature in self.model.feature:
if feature in words:
counter[feature] += 1
for feature in self.model.feature:
self.condProb[(c, feature)] = (counter[feature] * 1.0 + 1) / (len(self.model.trainFileNames[c]) + 2)
# For Debugging
def printCondProb(self):
for c in self.model.classes:
print "class " + str(c) + " : " + str(self.prior[c])
for feature in self.model.feature:
print feature + " : " + str(self.condProb[(c, feature)])
# Define Test function
# Return a list of test result as a int list
def test(self, testfilename):
maxProb = float("-Inf")
c_star = 0
words = set()
with open(testfilename, 'r') as file:
for line in file:
for word in self.model.word_tokenize(line):
words.add(word)
for c in self.model.classes:
probability = log(2, self.prior[c])
for feature in self.model.feature:
if feature in words:
probability += log(self.condProb[(c, feature)], 2)
else:
probability += log(1-self.condProb[(c, feature)], 2)
if probability > maxProb:
c_star = c
maxProb = probability
return c_star
def testAll(self):
testFileNames = glob(self.train_test_dir + "/*sample*")
testFileNames.sort()
testResult = []
actualResult = []
for testFileName in testFileNames:
testResult.append(self.test(testFileName))
problemNum = self.getProblemNumber()
with open(self.test_ground_truth_path, 'r') as actualFile:
for line in actualFile.readlines():
if len(line) > 10 and line.startswith("problem" + problemNum):
actualResult.append(int(line[-3 : -1]))
self.printAccuracy(actualResult,testResult)
self.model.printConfMat(actualResult, testResult)
self.rankFeature()
print "Top 20 features:"
self.printTop20()
def printAccuracy(self,actualResult,testResult):
accuracyNum = 0
for i in range(len(testResult)):
if actualResult[i] == testResult[i]:
accuracyNum += 1
accuracy = accuracyNum * 1.0 / len(actualResult)
print accuracy
def getProblemNumber(self):
files = glob(self.train_test_dir + "/*")
paths = files[0].split("/")
return paths[-1][0]
def rankFeature(self):
for feature in self.model.feature:
CCE = 0
for c in self.model.classes:
CCE -= self.prior[c] * self.condProb[(c,feature)] * log(self.condProb[(c,feature)],2)
self.featureCCE.append((feature,CCE))
def printTop20(self):
sortedCCE = sorted(self.featureCCE, key=lambda item:item[1])[::-1]
for i in range(20):
feature = sortedCCE[i][0]
CCE = sortedCCE[i][1]
print feature +" " + str(CCE)
def featureFreq(self):
words = {}
featureTimes = []
for c in self.model.classes:
for filename in self.model.trainFileNames[c]:
with open(filename, 'r') as file:
for line in file:
for word in self.model.word_tokenize(line):
words[word] = words.get(word, 0) + 1
for feature in self.model.feature:
words[feature] = words.get(feature,0)
featureTimes.append((feature,words[feature]))
self.featFreq = sorted(featureTimes, key=lambda item:item[1])[::-1]
def resetFeatures(self,Num):
features = []
if Num > len(self.featFreq):
Num = len(self.featFreq)
for i in range(Num):
features.append(self.featFreq[i][0])
return features
def featureCurve(self):
self.featureFreq()
# print self.featFreq
Num = 0
while Num <= 420:
Num += 10
self.model.feature = self.resetFeatures(Num)
print "select " + str(len(self.model.feature)) + " features"
self.train()
testFileNames = glob(self.train_test_dir + "/*sample*")
testFileNames.sort()
testResult = []
actualResult = []
for testFileName in testFileNames:
testResult.append(self.test(testFileName))
problemNum = self.getProblemNumber()
with open(self.test_ground_truth_path, 'r') as actualFile:
for line in actualFile.readlines():
if len(line) > 10 and line.startswith("problem" + problemNum):
actualResult.append(int(line[-3 : -1]))
self.printAccuracy(actualResult,testResult)
class TestContract(TestCase):
"""
run test with python -m unittest tests.test_execution_after_requirements_changed
"""
HOMESTEAD_BLOCK = 1150000
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()
def test(self):
# Create wallet
required_accounts = 2
wa_1 = 1
wa_2 = 2
wa_3 = 3
constructor_parameters = ([
accounts[wa_1], accounts[wa_2], accounts[wa_3]
], required_accounts)
self.multisig_wallet = self.s.abi_contract(
self.pp.process('MultiSigWallet.sol',
contract_dir='solidity/',
add_dev_code=True),
language='solidity',
constructor_parameters=constructor_parameters)
# Create ABIs
multisig_abi = self.multisig_wallet.translator
# Send money to wallet contract
deposit = 1000
self.s.send(keys[wa_1], self.multisig_wallet.address, deposit)
self.assertEqual(
self.s.block.get_balance(self.multisig_wallet.address), 1000)
# Add owner wa_4
wa_4 = 4
add_owner_data = multisig_abi.encode('addOwner', [accounts[wa_4]])
# Only a wallet owner (in this case wa_1) can do this. Owner confirms transaction at the same time.
transaction_id = self.multisig_wallet.submitTransaction(
self.multisig_wallet.address, 0, add_owner_data, sender=keys[wa_1])
# There is one pending transaction
exclude_pending = False
include_pending = True
exclude_executed = False
include_executed = True
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 1, include_pending,
exclude_executed),
[transaction_id])
# Update required to 1
new_required = 1
update_requirement_data = multisig_abi.encode('changeRequirement',
[new_required])
# Submit successfully
transaction_id_2 = self.multisig_wallet.submitTransaction(
self.multisig_wallet.address,
0,
update_requirement_data,
sender=keys[wa_1])
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 2, include_pending,
exclude_executed),
[transaction_id, transaction_id_2])
# Confirm change requirement transaction
self.multisig_wallet.confirmTransaction(transaction_id_2,
sender=keys[wa_2])
self.assertEqual(self.multisig_wallet.required(), new_required)
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 1, exclude_pending,
include_executed),
[transaction_id_2])
# Execution fails, because sender is not wallet owner
self.assertRaises(TransactionFailed,
self.multisig_wallet.executeTransaction,
transaction_id,
sender=keys[9])
# Because the # required confirmations changed to 1, the addOwner transaction can be executed now
self.multisig_wallet.executeTransaction(transaction_id,
sender=keys[wa_1])
self.assertEqual(
self.multisig_wallet.getTransactionIds(0, 2, exclude_pending,
include_executed),
[transaction_id, transaction_id_2])
def __init__(self, *args, **kwargs):
super(TestContract, self).__init__(*args, **kwargs)
self.s = t.state()
self.s.block.number = self.HOMESTEAD_BLOCK
t.gas_limit = 4712388
self.pp = PreProcessor()