source
stringlengths 3
86
| python
stringlengths 75
1.04M
|
|---|---|
video2ws.py
|
from threading import Thread
from tornado.ioloop import IOLoop
from tornado.web import Application
from tornado.websocket import WebSocketHandler
import cv2
RES = (176, 144)
FPS = 50
class VideoToWs(WebSocketHandler):
def open(self):
print('Connection opened.')
Thread(target=self.pub_video).start()
def pub_video(self):
while True:
self.pub_frame()
cv2.waitKey(1000 / FPS)
def pub_frame(self):
success, img = self.video_cap.read()
if success:
img = cv2.resize(img, RES)
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
message = img.tobytes()
self.ioloop.add_callback(lambda: self.write_message(message, binary=True))
def check_origin(self, origin):
return True
def main():
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--ws-port', type=int, default=9393)
args = parser.parse_args()
loop = IOLoop()
VideoToWs.ioloop = loop
cap = cv2.VideoCapture(0)
VideoToWs.video_cap = cap
app = Application([
(r'/', VideoToWs)
])
app.listen(args.ws_port)
loop.start()
if __name__ == '__main__':
main()
|
test_ca.py
|
import numpy as np
import threading
from pycrazyswarm import *
import time
import scipy as sp
# 飞控常数
TAKEOFFTIME = 2.0
RADII = 0.7
HOVERTIME = 3.0
CATIME = 1.0
# cf是否避障标志位
cf_flag = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0}
# 航点类
class Waypoint:
def __init__(self, agent, x, y, z, arrival, duration):
self.agent = agent
self.x = x
self.y = y
self.z = z
self.arrival = arrival
self.duration = duration
def __lt__(self, other):
return self.arrival < other.arrival
def __repr__(self):
return "Ag {} at {} s. [{}, {}, {}]".format(self.agent, self.arrival, self.x, self.y, self.z)
# 载入数据
def load_waypoint(filepath):
# load csv file
data = np.loadtxt(filepath, skiprows=1, delimiter=',')
data[data[:, 0].argsort()]
# convert to internal data structure
waypoints = []
lastAgent = None
for row in data:
if lastAgent is None or lastAgent != row[0]:
lastTime = 0.0
waypoints.append(Waypoint(int(row[0]), row[1], row[2], row[3], row[4], row[4] - lastTime))
lastTime = row[4]
lastAgent = int(row[0])
# sort waypoints by arrival time
waypoints.sort()
return waypoints
# 第一版
# def obstacle_avoidance(cfs, tello, radii):
# while(1):
# for cf in cfs:
# dist = np.sqrt((cf.state.pos.x - tello.state.pos.x)**2 + (cf.state.pos.y - tello.state.pos.y)**2
# + (cf.state.pos.z - tello.state.pos.z)**2)
# if dist < radii:
# pos = [cf.state.pos.x, cf.state.pos.y, cf.state.pos.z + 1.0]
# cf.goTo(pos, 0, 1.0)
# 避障线程函数
# 不能在避障过程中继续检测
def collision_avoidance(cf_ca, tello_ca, radii_ca):
while(1):
dist = np.sqrt((cf_ca.state.pos.x - tello_ca.state.pos.x)**2 + (cf_ca.state.pos.y - tello_ca.state.pos.y)**2
+ (cf_ca.state.pos.z - tello_ca.state.pos.z)**2)
if dist < radii_ca:
cf_flag[cf_ca.id] = 1
dz = 1 if tello_ca.state.pos.z <= cf_ca.state.pos.z else -1
pos_ca = [cf_ca.state.pos.x, cf_ca.state.pos.y, cf_ca.state.pos.z + 1.0*dz]
cf_ca.goTo(pos_ca, 0, CATIME)
# timeHelper.sleep(CATIME)
time.sleep(CATIME)
dx = 1 if tello_ca.state.pos.x <= cf_ca.state.pos.x else -1
dy = 1 if tello_ca.state.pos.y <= cf_ca.state.pos.y else -1
pos_ca = [cf_ca.state.pos.x + 1.0*dx, cf_ca.state.pos.y + 1.0*dy, cf_ca.state.pos.z]
# cf_ca.goTo(pos_ca, 0, CATIME)
# timeHelper.sleep(CATIME)
# timeHelper.sleep(HOVERTIME)
time.sleep(HOVERTIME)
cf_flag[cf_ca.id] = 0
if __name__ == "__main__":
# load data
waypoints = load_waypoint("waypoints6_high.csv")
# load cf
swarm = Crazyswarm()
timeHelper = swarm.timeHelper
allcfs = swarm.allcfs
cfs = allcfs.crazyflies
cf1, cf2, cf3, cf4, cf5, cf6, cf7 = allcfs.crazyflies
cf7.setLEDColor(1, 0.5, 0.5)
# collision avoidance
thread_ca_cf1 = threading.Thread(target=collision_avoidance, args=(cf1, cf7, RADII))
thread_ca_cf2 = threading.Thread(target=collision_avoidance, args=(cf2, cf7, RADII))
thread_ca_cf3 = threading.Thread(target=collision_avoidance, args=(cf3, cf7, RADII))
thread_ca_cf4 = threading.Thread(target=collision_avoidance, args=(cf4, cf7, RADII))
thread_ca_cf5 = threading.Thread(target=collision_avoidance, args=(cf5, cf7, RADII))
thread_ca_cf6 = threading.Thread(target=collision_avoidance, args=(cf6, cf7, RADII))
thread_ca_cf1.start()
thread_ca_cf2.start()
thread_ca_cf3.start()
thread_ca_cf4.start()
thread_ca_cf5.start()
thread_ca_cf6.start()
# thread_ca.join()
# patrol
allcfs.takeoff(targetHeight=1.0, duration=TAKEOFFTIME)
timeHelper.sleep(TAKEOFFTIME)
lastTime = 0.0
while(1):
for waypoint in waypoints:
cf = allcfs.crazyfliesById[waypoint.agent]
if cf_flag[cf.id] == 1:
waypoint.arrival = waypoint.arrival + 10.0
continue
if waypoint.arrival == 0:
pos = [waypoint.x, waypoint.y, waypoint.z]
cf.goTo(pos, 0, 2.0)
elif waypoint.duration > 0:
timeHelper.sleep(waypoint.arrival - lastTime)
lastTime = waypoint.arrival
pos = [waypoint.x, waypoint.y, waypoint.z]
cf.goTo(pos, 0, waypoint.duration)
waypoint.arrival = waypoint.arrival + 10.0
# land
allcfs.land(targetHeight=0.02, duration=2.0)
timeHelper.sleep(2.0)
|
startServer.py
|
"""
MIT License
Copyright (c) 2021 Meme Studios
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sellcopies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
"""
from flask import Flask, redirect
from threading import Thread
#app = Flask('')
def urlparse(url) -> str:
url = str(url)
url.replace(" ", "+")
url.replace("`", "%60")
url.replace("@", "%40")
url.replace("#", "%23")
url.replace("$", "%24")
url.replace("%", "%25")
url.replace("^", "%5E")
url.replace("&", "%26")
url.replace("+", "%2B")
url.replace("=", "%3D")
url.replace("|", "%7C")
url.replace("\\", "%5C")
url.replace("[", "%5B")
url.replace("]", "%5D")
url.replace("{", "%7B")
url.replace("}", "%7D")
url.replace(":", "%3A")
url.replace(";", "%3B")
url.replace("'", "%27")
url.replace(",", "%2C")
url.replace("/", "%2F")
url.replace("?", "%3F")
return url
def commandSignature(command):
clean_prefix = "f."
if not command.signature and not command.parent:
return f'"{clean_prefix}{command.name}"'
if command.signature and not command.parent:
return f'"{clean_prefix}{command.name} {command.signature}"'
if not command.signature and command.parent:
return f'"{clean_prefix}{command.parent} {command.name}"'
else:
return f'"{clean_prefix}{command.parent} {command.name} {command.signature}"'
msInvite = "https://discord.gg/3c5kc8M"
class FifiServer(Flask):
def __init__(self, bot):
super().__init__('Fifi OwO')
self.bot = bot
#self.app = app
self.route("/")(self.main)
self.route("/status")(self.status)
self.route("/redirect")(self._redirect)
#self.route("/status")(self.status)
self.route("/stats")(self.status)
self.route("/commands")(self.commands)
self.route("/command")(self.commands)
self.route("/guild")(self.guildInvite)
self.route("/server")(self.guildInvite)
self.route("/suport")(self.guildInvite)
self.route("/invite")(self.botInvite)
self.route("/invites")(self.botInvite)
def _redirect(self, url):
url = urlparse(url)
return redirect(url)
def botInvite():
return f"Fifi and any other bots that are part of Fifi is not open for other servers right now. If you we're expecting to have the guild invite, <a href={msInvite}>Click Here</a>!"
def guildInvite(self):
return redirect(f"{msInvite}")
#@app.route("/")
def main(self):
name = "M.S. Lounge" #self.bot.get_guild(720991608425807932).name
return f"Bot is online! View this bot in <a href='{msInvite}'>{str(name)}</a>"
#@app.route("/status")
def status(self):
return redirect("https://status.fifi.ayomerdeka.com")
def commands(self):
s = "Note:<br>Arguments with <> means that the argument is required.<br>Arguments with [] means that the argument is optional.<br>DO NOT USE THESE WHEN TYPING COMMANDS<br><br>"
for command in self.bot.commands:
s += f"""
Command {command.name}: <br>- Syntax: {commandSignature(command)}<br>- Aliases: {' | '.join(command.aliases)[:-3]}<br>
"""
if command.cog is None:
s += "- Cog: No Category/None"
else:
s += f"- Cog: {command.cog.qualified_name}"
s += "<br>"
if command._buckets._cooldown is None:
s += "- Cooldown: None"
else:
s += f"""
- Cooldown: <br> - Rate (How long the cooldown lasts in seconds): {command._buckets._cooldown.rate} <br> - Per (How many commands can be triggered before the cooldown hits): {command._buckets._cooldown.per} <br> - Type: Each {str(command._buckets._cooldown.type).lower().replace('commands', '').replace('buckettype', '').replace('.', '').title()}
"""
s += "<br><br>"
return s
def start(self):
server = Thread(target=self.run)
server.start()
def run(self):
super().run(host="0.0.0.0", port=8080)
|
overlap.py
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import random
import math
import json
import threading
import numpy as np
import tensorflow as tf
from . import util
from . import coref_ops
from . import conll
from . import metrics
from . import optimization
from .bert import tokenization
from .bert import modeling
from .pytorch_to_tf import load_from_pytorch_checkpoint
class CorefModel(object):
def __init__(self, config):
self.config = config
self.subtoken_maps = {}
self.max_segment_len = config['max_segment_len']
self.max_span_width = config["max_span_width"]
self.genres = { g:i for i,g in enumerate(config["genres"]) }
self.eval_data = None # Load eval data lazily.
self.bert_config = modeling.BertConfig.from_json_file(config["bert_config_file"])
self.sep = 102
self.cls = 101
self.tokenizer = tokenization.FullTokenizer(
vocab_file=config['vocab_file'], do_lower_case=False)
input_props = []
input_props.append((tf.int32, [None, None])) # input_ids.
input_props.append((tf.int32, [None, None])) # input_mask
input_props.append((tf.int32, [None, None])) # input_ids.
input_props.append((tf.int32, [None, None])) # input_mask
input_props.append((tf.int32, [None])) # Text lengths.
input_props.append((tf.int32, [None, None])) # Speaker IDs.
input_props.append((tf.int32, [])) # Genre.
input_props.append((tf.bool, [])) # Is training.
input_props.append((tf.int32, [None])) # Gold starts.
input_props.append((tf.int32, [None])) # Gold ends.
input_props.append((tf.int32, [None])) # Cluster ids.
input_props.append((tf.int32, [None])) # Sentence Map
self.queue_input_tensors = [tf.placeholder(dtype, shape) for dtype, shape in input_props]
dtypes, shapes = zip(*input_props)
queue = tf.PaddingFIFOQueue(capacity=10, dtypes=dtypes, shapes=shapes)
self.enqueue_op = queue.enqueue(self.queue_input_tensors)
self.input_tensors = queue.dequeue()
self.predictions, self.loss = self.get_predictions_and_loss(*self.input_tensors)
# bert stuff
tvars = tf.trainable_variables()
assignment_map, initialized_variable_names = modeling.get_assignment_map_from_checkpoint(tvars, config['tf_checkpoint'])
init_from_checkpoint = tf.train.init_from_checkpoint if config['init_checkpoint'].endswith('ckpt') else load_from_pytorch_checkpoint
init_from_checkpoint(config['init_checkpoint'], assignment_map)
print("**** Trainable Variables ****")
for var in tvars:
init_string = ""
if var.name in initialized_variable_names:
init_string = ", *INIT_FROM_CKPT*"
# tf.logging.info(" name = %s, shape = %s%s", var.name, var.shape,
# init_string)
print(" name = %s, shape = %s%s" % (var.name, var.shape, init_string))
num_train_steps = int(
self.config['num_docs'] * self.config['num_epochs'])
num_warmup_steps = int(num_train_steps * 0.1)
self.global_step = tf.train.get_or_create_global_step()
self.train_op = optimization.create_custom_optimizer(tvars,
self.loss, self.config['bert_learning_rate'], self.config['task_learning_rate'],
num_train_steps, num_warmup_steps, False, self.global_step, freeze=-1)
def start_enqueue_thread(self, session):
with open(self.config["train_path"]) as f:
train_examples = [json.loads(jsonline) for jsonline in f.readlines()]
def _enqueue_loop():
while True:
random.shuffle(train_examples)
if self.config['single_example']:
for example in train_examples:
tensorized_example = self.tensorize_example(example, is_training=True)
feed_dict = dict(zip(self.queue_input_tensors, tensorized_example))
session.run(self.enqueue_op, feed_dict=feed_dict)
else:
examples = []
for example in train_examples:
tensorized = self.tensorize_example(example, is_training=True)
if type(tensorized) is not list:
tensorized = [tensorized]
examples += tensorized
random.shuffle(examples)
print('num examples', len(examples))
for example in examples:
feed_dict = dict(zip(self.queue_input_tensors, example))
session.run(self.enqueue_op, feed_dict=feed_dict)
enqueue_thread = threading.Thread(target=_enqueue_loop)
enqueue_thread.daemon = True
enqueue_thread.start()
def restore(self, session):
# Don't try to restore unused variables from the TF-Hub ELMo module.
vars_to_restore = [v for v in tf.global_variables() ]
saver = tf.train.Saver(vars_to_restore)
checkpoint_path = os.path.join(self.config["log_dir"], "model.max.ckpt")
print("Restoring from {}".format(checkpoint_path))
session.run(tf.global_variables_initializer())
saver.restore(session, checkpoint_path)
def tensorize_mentions(self, mentions):
if len(mentions) > 0:
starts, ends = zip(*mentions)
else:
starts, ends = [], []
return np.array(starts), np.array(ends)
def tensorize_span_labels(self, tuples, label_dict):
if len(tuples) > 0:
starts, ends, labels = zip(*tuples)
else:
starts, ends, labels = [], [], []
return np.array(starts), np.array(ends), np.array([label_dict[c] for c in labels])
def get_speaker_dict(self, speakers):
speaker_dict = {'UNK': 0, '[SPL]': 1}
for s in speakers:
if s not in speaker_dict and len(speaker_dict) < self.config['max_num_speakers']:
speaker_dict[s] = len(speaker_dict)
return speaker_dict
def tensorize_example(self, example, is_training):
clusters = example["clusters"]
gold_mentions = sorted(tuple(m) for m in util.flatten(clusters))
gold_mention_map = {m:i for i,m in enumerate(gold_mentions)}
cluster_ids = np.zeros(len(gold_mentions))
for cluster_id, cluster in enumerate(clusters):
for mention in cluster:
cluster_ids[gold_mention_map[tuple(mention)]] = cluster_id + 1
sentences = example["sentences"]
num_words = sum(len(s) for s in sentences)
speakers = example["speakers"]
# assert num_words == len(speakers), (num_words, len(speakers))
speaker_dict = self.get_speaker_dict(util.flatten(speakers))
sentence_map = example['sentence_map']
max_sentence_length = self.max_segment_len #270 #max(len(s) for s in sentences)
text_len = np.array([len(s) for s in sentences])
input_ids, input_mask, speaker_ids, prev_overlap = [], [], [], []
overlap_ids, overlap_mask = [], []
half = self.max_segment_len // 2
prev_tokens_per_seg = []
for i, (sentence, speaker) in enumerate(zip(sentences, speakers)):
prev_tokens_per_seg += [len(prev_overlap)]
overlap_words = ['[CLS]'] + prev_overlap + sentence[:half] + ['[SEP]']
prev_overlap = sentence[half:]
sentence = ['[CLS]'] + sentence + ['[SEP]']
sent_input_ids = self.tokenizer.convert_tokens_to_ids(sentence)
sent_input_mask = [1] * len(sent_input_ids)
sent_speaker_ids = [speaker_dict.get(s, 0) for s in ['##'] + speaker + ['##']]
while len(sent_input_ids) < max_sentence_length:
sent_input_ids.append(0)
sent_input_mask.append(0)
sent_speaker_ids.append(0)
overlap_input_ids = self.tokenizer.convert_tokens_to_ids(overlap_words)
overlap_input_mask = [1] * len(overlap_input_ids)
while len(overlap_input_ids) < max_sentence_length:
overlap_input_ids.append(0)
overlap_input_mask.append(0)
input_ids.append(sent_input_ids)
speaker_ids.append(sent_speaker_ids)
input_mask.append(sent_input_mask)
overlap_ids.append(overlap_input_ids)
overlap_mask.append(overlap_input_mask)
overlap_words = ['[CLS]'] + prev_overlap + ['[SEP]']
overlap_input_ids = self.tokenizer.convert_tokens_to_ids(overlap_words)
overlap_input_mask = [1] * len(overlap_input_ids)
prev_tokens_per_seg += [len(prev_overlap)]
while len(overlap_input_ids) < max_sentence_length:
overlap_input_ids.append(0)
overlap_input_mask.append(0)
overlap_ids.append(overlap_input_ids)
overlap_mask.append(overlap_input_mask)
input_ids = np.array(input_ids)
input_mask = np.array(input_mask)
speaker_ids = np.array(speaker_ids)
overlap_ids = np.array(overlap_ids)
overlap_mask = np.array(overlap_mask)
assert num_words == (np.sum(input_mask) - 2*np.shape(input_mask)[0]), (num_words, np.sum(input_mask))
assert num_words == (np.sum(overlap_mask) - 2*np.shape(overlap_mask)[0]), (num_words, np.sum(overlap_mask), np.shape(overlap_mask))
doc_key = example["doc_key"]
self.subtoken_maps[doc_key] = example["subtoken_map"]
genre = self.genres[doc_key[:2]]
gold_starts, gold_ends = self.tensorize_mentions(gold_mentions)
example_tensors = (input_ids, input_mask, overlap_ids, overlap_mask, text_len, speaker_ids, genre, is_training, gold_starts, gold_ends, cluster_ids, sentence_map)
if is_training and len(sentences) > self.config["max_training_sentences"]:
return self.truncate_example(* (example_tensors + (prev_tokens_per_seg, )))
else:
return example_tensors
def truncate_example(self, input_ids, input_mask, overlap_ids, overlap_mask, text_len, speaker_ids, genre, is_training, gold_starts, gold_ends, cluster_ids, sentence_map, prev_tokens_per_seg, sentence_offset=None):
max_training_sentences = self.config["max_training_sentences"]
num_sentences = input_ids.shape[0]
assert num_sentences > max_training_sentences
sentence_offset = random.randint(0, num_sentences - max_training_sentences) if sentence_offset is None else sentence_offset
word_offset = text_len[:sentence_offset].sum()
num_words = text_len[sentence_offset:sentence_offset + max_training_sentences].sum()
input_ids = input_ids[sentence_offset:sentence_offset + max_training_sentences, :]
input_mask = input_mask[sentence_offset:sentence_offset + max_training_sentences, :]
overlap_ids = overlap_ids[sentence_offset:sentence_offset + max_training_sentences + 1, :]
overlap_mask = overlap_mask[sentence_offset:sentence_offset + max_training_sentences + 1, :]
overlap_ids[-1, 1 + prev_tokens_per_seg[sentence_offset + max_training_sentences]] = self.sep
overlap_ids[-1, 2 + prev_tokens_per_seg[sentence_offset + max_training_sentences]:] = 0
overlap_mask[-1, 2 + prev_tokens_per_seg[sentence_offset + max_training_sentences]:] = 0
overlap_mask[0, 1: 1 + prev_tokens_per_seg[sentence_offset ]] = 0
assert num_words == overlap_mask.sum() - 2 * np.shape(overlap_ids)[0], (num_words, overlap_mask.sum(), text_len)
speaker_ids = speaker_ids[sentence_offset:sentence_offset + max_training_sentences, :]
text_len = text_len[sentence_offset:sentence_offset + max_training_sentences]
sentence_map = sentence_map[word_offset: word_offset + num_words]
gold_spans = np.logical_and(gold_ends >= word_offset, gold_starts < word_offset + num_words)
gold_starts = gold_starts[gold_spans] - word_offset
gold_ends = gold_ends[gold_spans] - word_offset
cluster_ids = cluster_ids[gold_spans]
return input_ids, input_mask, overlap_ids, overlap_mask, text_len, speaker_ids, genre, is_training, gold_starts, gold_ends, cluster_ids, sentence_map
def get_candidate_labels(self, candidate_starts, candidate_ends, labeled_starts, labeled_ends, labels):
same_start = tf.equal(tf.expand_dims(labeled_starts, 1), tf.expand_dims(candidate_starts, 0)) # [num_labeled, num_candidates]
same_end = tf.equal(tf.expand_dims(labeled_ends, 1), tf.expand_dims(candidate_ends, 0)) # [num_labeled, num_candidates]
same_span = tf.logical_and(same_start, same_end) # [num_labeled, num_candidates]
candidate_labels = tf.matmul(tf.expand_dims(labels, 0), tf.to_int32(same_span)) # [1, num_candidates]
candidate_labels = tf.squeeze(candidate_labels, 0) # [num_candidates]
return candidate_labels
def get_dropout(self, dropout_rate, is_training):
return 1 - (tf.to_float(is_training) * dropout_rate)
def coarse_to_fine_pruning(self, top_span_emb, top_span_mention_scores, c):
k = util.shape(top_span_emb, 0)
top_span_range = tf.range(k) # [k]
antecedent_offsets = tf.expand_dims(top_span_range, 1) - tf.expand_dims(top_span_range, 0) # [k, k]
antecedents_mask = antecedent_offsets >= 1 # [k, k]
fast_antecedent_scores = tf.expand_dims(top_span_mention_scores, 1) + tf.expand_dims(top_span_mention_scores, 0) # [k, k]
fast_antecedent_scores += tf.log(tf.to_float(antecedents_mask)) # [k, k]
fast_antecedent_scores += self.get_fast_antecedent_scores(top_span_emb) # [k, k]
if self.config['use_prior']:
antecedent_distance_buckets = self.bucket_distance(antecedent_offsets) # [k, c]
distance_scores = util.projection(tf.nn.dropout(tf.get_variable("antecedent_distance_emb", [10, self.config["feature_size"]]), self.dropout), 1, initializer=tf.truncated_normal_initializer(stddev=0.02)) #[10, 1]
antecedent_distance_scores = tf.gather(tf.squeeze(distance_scores, 1), antecedent_distance_buckets) # [k, c]
fast_antecedent_scores += antecedent_distance_scores
_, top_antecedents = tf.nn.top_k(fast_antecedent_scores, c, sorted=False) # [k, c]
top_antecedents_mask = util.batch_gather(antecedents_mask, top_antecedents) # [k, c]
top_fast_antecedent_scores = util.batch_gather(fast_antecedent_scores, top_antecedents) # [k, c]
top_antecedent_offsets = util.batch_gather(antecedent_offsets, top_antecedents) # [k, c]
return top_antecedents, top_antecedents_mask, top_fast_antecedent_scores, top_antecedent_offsets
def combine_passes(self, original_doc, input_ids, input_mask, overlap_doc, overlap_ids, overlap_mask):
overlap_mask, input_mask = tf.equal(overlap_mask, 1), tf.equal(input_mask, 1)
org_content_mask = tf.logical_and(input_mask, tf.logical_and(tf.not_equal(input_ids, self.cls), tf.not_equal(input_ids, self.sep)))
overlap_content_mask = tf.logical_and(overlap_mask, tf.logical_and(tf.not_equal(overlap_ids, self.cls), tf.not_equal(overlap_ids, self.sep)))
flat_org_doc = self.flatten_emb_by_sentence(original_doc, org_content_mask)
flat_overlap_doc = self.flatten_emb_by_sentence(overlap_doc, overlap_content_mask)
with tf.variable_scope("combo"):
f = tf.sigmoid(util.projection(tf.concat([flat_org_doc, flat_overlap_doc], -1), util.shape(flat_org_doc, -1))) # [n, emb]
combo = f * flat_org_doc + (1 - f) * flat_overlap_doc
return combo, org_content_mask
def get_predictions_and_loss(self, input_ids, input_mask, overlap_ids, overlap_mask, text_len, speaker_ids, genre, is_training, gold_starts, gold_ends, cluster_ids, sentence_map):
model = modeling.BertModel(
config=self.bert_config,
is_training=is_training,
input_ids=input_ids,
input_mask=input_mask,
use_one_hot_embeddings=False,
scope='bert')
original_doc = model.get_sequence_output()
model = modeling.BertModel(
config=self.bert_config,
is_training=is_training,
input_ids=overlap_ids,
input_mask=overlap_mask,
use_one_hot_embeddings=False,
scope='bert')
overlap_doc = model.get_sequence_output()
self.dropout = self.get_dropout(self.config["dropout_rate"], is_training)
num_sentences = tf.shape(input_ids)[0]
max_sentence_length = tf.shape(input_mask)[1] - 2
mention_doc, org_content_mask = self.combine_passes(original_doc, input_ids, input_mask, overlap_doc, overlap_ids, overlap_mask)
num_words = util.shape(mention_doc, 0)
antecedent_doc = mention_doc
# mask out cross-sentence candidates
flattened_sentence_indices = sentence_map
candidate_starts = tf.tile(tf.expand_dims(tf.range(num_words), 1), [1, self.max_span_width]) # [num_words, max_span_width]
candidate_ends = candidate_starts + tf.expand_dims(tf.range(self.max_span_width), 0) # [num_words, max_span_width]
candidate_start_sentence_indices = tf.gather(flattened_sentence_indices, candidate_starts) # [num_words, max_span_width]
candidate_end_sentence_indices = tf.gather(flattened_sentence_indices, tf.minimum(candidate_ends, num_words - 1)) # [num_words, max_span_width]
candidate_mask = tf.logical_and(candidate_ends < num_words, tf.equal(candidate_start_sentence_indices, candidate_end_sentence_indices)) # [num_words, max_span_width]
flattened_candidate_mask = tf.reshape(candidate_mask, [-1]) # [num_words * max_span_width]
candidate_starts = tf.boolean_mask(tf.reshape(candidate_starts, [-1]), flattened_candidate_mask) # [num_candidates]
candidate_ends = tf.boolean_mask(tf.reshape(candidate_ends, [-1]), flattened_candidate_mask) # [num_candidates]
candidate_sentence_indices = tf.boolean_mask(tf.reshape(candidate_start_sentence_indices, [-1]), flattened_candidate_mask) # [num_candidates]
candidate_cluster_ids = self.get_candidate_labels(candidate_starts, candidate_ends, gold_starts, gold_ends, cluster_ids) # [num_candidates]
candidate_span_emb = self.get_span_emb(mention_doc, mention_doc, candidate_starts, candidate_ends) # [num_candidates, emb]
candidate_mention_scores = self.get_mention_scores(candidate_span_emb, candidate_starts, candidate_ends)
candidate_mention_scores = tf.squeeze(candidate_mention_scores, 1) # [k]
# beam size
k = tf.minimum(3900, tf.to_int32(tf.floor(tf.to_float(num_words) * self.config["top_span_ratio"])))
c = tf.minimum(self.config["max_top_antecedents"], k)
# pull from beam
top_span_indices = coref_ops.extract_spans(tf.expand_dims(candidate_mention_scores, 0),
tf.expand_dims(candidate_starts, 0),
tf.expand_dims(candidate_ends, 0),
tf.expand_dims(k, 0),
num_words,
True) # [1, k]
top_span_indices.set_shape([1, None])
top_span_indices = tf.squeeze(top_span_indices, 0) # [k]
top_span_starts = tf.gather(candidate_starts, top_span_indices) # [k]
top_span_ends = tf.gather(candidate_ends, top_span_indices) # [k]
# don't need this
top_span_emb = tf.gather(candidate_span_emb, top_span_indices) # [k, emb]
top_span_cluster_ids = tf.gather(candidate_cluster_ids, top_span_indices) # [k]
top_span_mention_scores = tf.gather(candidate_mention_scores, top_span_indices) # [k]
genre_emb = tf.gather(tf.get_variable("genre_embeddings", [len(self.genres), self.config["feature_size"]]), genre) # [emb]
if self.config['use_metadata']:
speaker_ids = self.flatten_emb_by_sentence(speaker_ids, org_content_mask)
top_span_speaker_ids = tf.gather(speaker_ids, top_span_starts) # [k]i
else:
top_span_speaker_ids = None
# antecedent scores -- change this
dummy_scores = tf.zeros([k, 1]) # [k, 1]
top_antecedents, top_antecedents_mask, top_fast_antecedent_scores, top_antecedent_offsets = self.coarse_to_fine_pruning(top_span_emb, top_span_mention_scores, c)
num_segs, seg_len = util.shape(org_content_mask, 0), util.shape(org_content_mask, 1)
word_segments = tf.reshape(tf.tile(tf.expand_dims(tf.range(0, num_segs), 1), [1, seg_len]), [-1])
flat_word_segments = tf.boolean_mask(word_segments, tf.reshape(org_content_mask, [-1]))
mention_segments = tf.expand_dims(tf.gather(flat_word_segments, top_span_starts), 1) # [k, 1]
antecedent_segments = tf.gather(flat_word_segments, tf.gather(top_span_starts, top_antecedents)) #[k, c]
segment_distance = tf.clip_by_value(mention_segments - antecedent_segments, 0, self.config['max_training_sentences'] - 1) if self.config['use_segment_distance'] else None #[k, c]
if self.config['fine_grained']:
for i in range(self.config["coref_depth"]):
with tf.variable_scope("coref_layer", reuse=(i > 0)):
top_antecedent_emb = tf.gather(top_span_emb, top_antecedents) # [k, c, emb]
top_antecedent_scores = top_fast_antecedent_scores + self.get_slow_antecedent_scores(top_span_emb, top_antecedents, top_antecedent_emb, top_antecedent_offsets, top_span_speaker_ids, genre_emb, segment_distance) # [k, c]
top_antecedent_weights = tf.nn.softmax(tf.concat([dummy_scores, top_antecedent_scores], 1)) # [k, c + 1]
top_antecedent_emb = tf.concat([tf.expand_dims(top_span_emb, 1), top_antecedent_emb], 1) # [k, c + 1, emb]
attended_span_emb = tf.reduce_sum(tf.expand_dims(top_antecedent_weights, 2) * top_antecedent_emb, 1) # [k, emb]
with tf.variable_scope("f"):
f = tf.sigmoid(util.projection(tf.concat([top_span_emb, attended_span_emb], 1), util.shape(top_span_emb, -1))) # [k, emb]
top_span_emb = f * attended_span_emb + (1 - f) * top_span_emb # [k, emb]
else:
top_antecedent_scores = top_fast_antecedent_scores
top_antecedent_scores = tf.concat([dummy_scores, top_antecedent_scores], 1) # [k, c + 1]
# top_antecedent_scores = tf.Print(top_antecedent_scores, [tf.shape(context_outputs), tf.shape(candidate_ends), top_antecedent_scores, tf.shape(top_antecedent_scores)], 'top_antecedent_scores')
top_antecedent_cluster_ids = tf.gather(top_span_cluster_ids, top_antecedents) # [k, c]
# top_antecedents_mask = tf.Print(top_antecedents_mask, [top_antecedents_mask, tf.reduce_sum(tf.to_int32(top_antecedents_mask))], 'top ante amsk')
top_antecedent_cluster_ids += tf.to_int32(tf.log(tf.to_float(top_antecedents_mask))) # [k, c]
same_cluster_indicator = tf.equal(top_antecedent_cluster_ids, tf.expand_dims(top_span_cluster_ids, 1)) # [k, c]
non_dummy_indicator = tf.expand_dims(top_span_cluster_ids > 0, 1) # [k, 1]
pairwise_labels = tf.logical_and(same_cluster_indicator, non_dummy_indicator) # [k, c]
dummy_labels = tf.logical_not(tf.reduce_any(pairwise_labels, 1, keepdims=True)) # [k, 1]
top_antecedent_labels = tf.concat([dummy_labels, pairwise_labels], 1) # [k, c + 1]
loss = self.softmax_loss(top_antecedent_scores, top_antecedent_labels) # [k]
loss = tf.reduce_sum(loss) # []
return [candidate_starts, candidate_ends, candidate_mention_scores, top_span_starts, top_span_ends, top_antecedents, top_antecedent_scores], loss
def get_span_emb(self, head_emb, context_outputs, span_starts, span_ends):
span_emb_list = []
span_start_emb = tf.gather(context_outputs, span_starts) # [k, emb]
span_emb_list.append(span_start_emb)
span_end_emb = tf.gather(context_outputs, span_ends) # [k, emb]
span_emb_list.append(span_end_emb)
span_width = 1 + span_ends - span_starts # [k]
if self.config["use_features"]:
span_width_index = span_width - 1 # [k]
span_width_emb = tf.gather(tf.get_variable("span_width_embeddings", [self.config["max_span_width"], self.config["feature_size"]]), span_width_index) # [k, emb]
span_width_emb = tf.nn.dropout(span_width_emb, self.dropout)
span_emb_list.append(span_width_emb)
if self.config["model_heads"]:
mention_word_scores = self.get_masked_mention_word_scores(context_outputs, span_starts, span_ends)
head_attn_reps = tf.matmul(mention_word_scores, context_outputs) # [K, T]
span_emb_list.append(head_attn_reps)
span_emb = tf.concat(span_emb_list, 1) # [k, emb]
return span_emb # [k, emb]
def get_mention_scores(self, span_emb, span_starts, span_ends):
with tf.variable_scope("mention_scores"):
span_scores = util.ffnn(span_emb, self.config["ffnn_depth"], self.config["ffnn_size"], 1, self.dropout) # [k, 1]
if self.config['use_prior']:
span_width_emb = tf.get_variable("span_width_prior_embeddings", [self.config["max_span_width"], self.config["feature_size"]]) # [W, emb]
span_width_index = span_ends - span_starts # [NC]
with tf.variable_scope("width_scores"):
width_scores = util.ffnn(span_width_emb, self.config["ffnn_depth"], self.config["ffnn_size"], 1, self.dropout) # [W, 1]
width_scores = tf.gather(width_scores, span_width_index)
span_scores += width_scores
return span_scores
def get_width_scores(self, doc, starts, ends):
distance = ends - starts
span_start_emb = tf.gather(doc, starts)
hidden = util.shape(doc, 1)
with tf.variable_scope('span_width'):
span_width_emb = tf.gather(tf.get_variable("start_width_embeddings", [self.config["max_span_width"], hidden], initializer=tf.truncated_normal_initializer(stddev=0.02)), distance) # [W, emb]
scores = tf.reduce_sum(span_start_emb * span_width_emb, axis=1)
return scores
def get_masked_mention_word_scores(self, encoded_doc, span_starts, span_ends):
num_words = util.shape(encoded_doc, 0) # T
num_c = util.shape(span_starts, 0) # NC
doc_range = tf.tile(tf.expand_dims(tf.range(0, num_words), 0), [num_c, 1]) # [K, T]
mention_mask = tf.logical_and(doc_range >= tf.expand_dims(span_starts, 1), doc_range <= tf.expand_dims(span_ends, 1)) #[K, T]
with tf.variable_scope("mention_word_attn"):
word_attn = tf.squeeze(util.projection(encoded_doc, 1, initializer=tf.truncated_normal_initializer(stddev=0.02)), 1)
mention_word_attn = tf.nn.softmax(tf.log(tf.to_float(mention_mask)) + tf.expand_dims(word_attn, 0))
return mention_word_attn
def softmax_loss(self, antecedent_scores, antecedent_labels):
gold_scores = antecedent_scores + tf.log(tf.to_float(antecedent_labels)) # [k, max_ant + 1]
marginalized_gold_scores = tf.reduce_logsumexp(gold_scores, [1]) # [k]
log_norm = tf.reduce_logsumexp(antecedent_scores, [1]) # [k]
return log_norm - marginalized_gold_scores # [k]
def bucket_distance(self, distances):
"""
Places the given values (designed for distances) into 10 semi-logscale buckets:
[0, 1, 2, 3, 4, 5-7, 8-15, 16-31, 32-63, 64+].
"""
logspace_idx = tf.to_int32(tf.floor(tf.log(tf.to_float(distances))/math.log(2))) + 3
use_identity = tf.to_int32(distances <= 4)
combined_idx = use_identity * distances + (1 - use_identity) * logspace_idx
return tf.clip_by_value(combined_idx, 0, 9)
def get_slow_antecedent_scores(self, top_span_emb, top_antecedents, top_antecedent_emb, top_antecedent_offsets, top_span_speaker_ids, genre_emb, segment_distance=None):
k = util.shape(top_span_emb, 0)
c = util.shape(top_antecedents, 1)
feature_emb_list = []
if self.config["use_metadata"]:
top_antecedent_speaker_ids = tf.gather(top_span_speaker_ids, top_antecedents) # [k, c]
same_speaker = tf.equal(tf.expand_dims(top_span_speaker_ids, 1), top_antecedent_speaker_ids) # [k, c]
speaker_pair_emb = tf.gather(tf.get_variable("same_speaker_emb", [2, self.config["feature_size"]]), tf.to_int32(same_speaker)) # [k, c, emb]
feature_emb_list.append(speaker_pair_emb)
tiled_genre_emb = tf.tile(tf.expand_dims(tf.expand_dims(genre_emb, 0), 0), [k, c, 1]) # [k, c, emb]
feature_emb_list.append(tiled_genre_emb)
if self.config["use_features"]:
antecedent_distance_buckets = self.bucket_distance(top_antecedent_offsets) # [k, c]
antecedent_distance_emb = tf.gather(tf.get_variable("antecedent_distance_emb", [10, self.config["feature_size"]]), antecedent_distance_buckets) # [k, c]
feature_emb_list.append(antecedent_distance_emb)
if segment_distance is not None:
with tf.variable_scope('segment_distance', reuse=tf.AUTO_REUSE):
segment_distance_emb = tf.gather(tf.get_variable("segment_distance_embeddings", [self.config['max_training_sentences'], self.config["feature_size"]]), segment_distance) # [k, emb]
span_width_emb = tf.nn.dropout(segment_distance_emb, self.dropout)
feature_emb_list.append(segment_distance_emb)
feature_emb = tf.concat(feature_emb_list, 2) # [k, c, emb]
feature_emb = tf.nn.dropout(feature_emb, self.dropout) # [k, c, emb]
target_emb = tf.expand_dims(top_span_emb, 1) # [k, 1, emb]
similarity_emb = top_antecedent_emb * target_emb # [k, c, emb]
target_emb = tf.tile(target_emb, [1, c, 1]) # [k, c, emb]
pair_emb = tf.concat([target_emb, top_antecedent_emb, similarity_emb, feature_emb], 2) # [k, c, emb]
with tf.variable_scope("slow_antecedent_scores"):
slow_antecedent_scores = util.ffnn(pair_emb, self.config["ffnn_depth"], self.config["ffnn_size"], 1, self.dropout) # [k, c, 1]
slow_antecedent_scores = tf.squeeze(slow_antecedent_scores, 2) # [k, c]
return slow_antecedent_scores # [k, c]
def get_fast_antecedent_scores(self, top_span_emb):
with tf.variable_scope("src_projection"):
source_top_span_emb = tf.nn.dropout(util.projection(top_span_emb, util.shape(top_span_emb, -1)), self.dropout) # [k, emb]
target_top_span_emb = tf.nn.dropout(top_span_emb, self.dropout) # [k, emb]
return tf.matmul(source_top_span_emb, target_top_span_emb, transpose_b=True) # [k, k]
def flatten_emb_by_sentence(self, emb, text_len_mask):
num_sentences = tf.shape(emb)[0]
max_sentence_length = tf.shape(emb)[1]
emb_rank = len(emb.get_shape())
if emb_rank == 2:
flattened_emb = tf.reshape(emb, [num_sentences * max_sentence_length])
elif emb_rank == 3:
flattened_emb = tf.reshape(emb, [num_sentences * max_sentence_length, util.shape(emb, 2)])
else:
raise ValueError("Unsupported rank: {}".format(emb_rank))
return tf.boolean_mask(flattened_emb, tf.reshape(text_len_mask, [num_sentences * max_sentence_length]))
def get_predicted_antecedents(self, antecedents, antecedent_scores):
predicted_antecedents = []
for i, index in enumerate(np.argmax(antecedent_scores, axis=1) - 1):
if index < 0:
predicted_antecedents.append(-1)
else:
predicted_antecedents.append(antecedents[i, index])
return predicted_antecedents
def get_predicted_clusters(self, top_span_starts, top_span_ends, predicted_antecedents):
mention_to_predicted = {}
predicted_clusters = []
for i, predicted_index in enumerate(predicted_antecedents):
if predicted_index < 0:
continue
assert i > predicted_index, (i, predicted_index)
predicted_antecedent = (int(top_span_starts[predicted_index]), int(top_span_ends[predicted_index]))
if predicted_antecedent in mention_to_predicted:
predicted_cluster = mention_to_predicted[predicted_antecedent]
else:
predicted_cluster = len(predicted_clusters)
predicted_clusters.append([predicted_antecedent])
mention_to_predicted[predicted_antecedent] = predicted_cluster
mention = (int(top_span_starts[i]), int(top_span_ends[i]))
predicted_clusters[predicted_cluster].append(mention)
mention_to_predicted[mention] = predicted_cluster
predicted_clusters = [tuple(pc) for pc in predicted_clusters]
mention_to_predicted = { m:predicted_clusters[i] for m,i in mention_to_predicted.items() }
return predicted_clusters, mention_to_predicted
def evaluate_coref(self, top_span_starts, top_span_ends, predicted_antecedents, gold_clusters, evaluator):
gold_clusters = [tuple(tuple(m) for m in gc) for gc in gold_clusters]
mention_to_gold = {}
for gc in gold_clusters:
for mention in gc:
mention_to_gold[mention] = gc
predicted_clusters, mention_to_predicted = self.get_predicted_clusters(top_span_starts, top_span_ends, predicted_antecedents)
evaluator.update(predicted_clusters, gold_clusters, mention_to_predicted, mention_to_gold)
return predicted_clusters
def load_eval_data(self):
if self.eval_data is None:
def load_line(line):
example = json.loads(line)
return self.tensorize_example(example, is_training=False), example
with open(self.config["eval_path"]) as f:
self.eval_data = [load_line(l) for l in f.readlines()]
num_words = sum(tensorized_example[2].sum() for tensorized_example, _ in self.eval_data)
print("Loaded {} eval examples.".format(len(self.eval_data)))
def evaluate(self, session, global_step=None, official_stdout=False, keys=None, eval_mode=False):
self.load_eval_data()
coref_predictions = {}
coref_evaluator = metrics.CorefEvaluator()
losses = []
doc_keys = []
num_evaluated= 0
for example_num, (tensorized_example, example) in enumerate(self.eval_data):
_, _, _, _, _, _, _, _, gold_starts, gold_ends, _, _ = tensorized_example
feed_dict = {i:t for i,t in zip(self.input_tensors, tensorized_example)}
# if tensorized_example[0].shape[0] <= 9:
# if keys is not None and example['doc_key'] in keys:
# print('Skipping...', example['doc_key'], tensorized_example[0].shape)
# continue
doc_keys.append(example['doc_key'])
loss, (candidate_starts, candidate_ends, candidate_mention_scores, top_span_starts, top_span_ends, top_antecedents, top_antecedent_scores) = session.run([self.loss, self.predictions], feed_dict=feed_dict)
# losses.append(session.run(self.loss, feed_dict=feed_dict))
losses.append(loss)
predicted_antecedents = self.get_predicted_antecedents(top_antecedents, top_antecedent_scores)
coref_predictions[example["doc_key"]] = self.evaluate_coref(top_span_starts, top_span_ends, predicted_antecedents, example["clusters"], coref_evaluator)
if example_num % 10 == 0:
print("Evaluated {}/{} examples.".format(example_num + 1, len(self.eval_data)))
summary_dict = {}
# with open('doc_keys_512.txt', 'w') as f:
# for key in doc_keys:
# f.write(key + '\n')
if eval_mode:
conll_results = conll.evaluate_conll(self.config["conll_eval_path"], coref_predictions, self.subtoken_maps, official_stdout )
average_f1 = sum(results["f"] for results in conll_results.values()) / len(conll_results)
summary_dict["Average F1 (conll)"] = average_f1
print("Average F1 (conll): {:.2f}%".format(average_f1))
p,r,f = coref_evaluator.get_prf()
summary_dict["Average F1 (py)"] = f
print("Average F1 (py): {:.2f}% on {} docs".format(f * 100, len(doc_keys)))
summary_dict["Average precision (py)"] = p
print("Average precision (py): {:.2f}%".format(p * 100))
summary_dict["Average recall (py)"] = r
print("Average recall (py): {:.2f}%".format(r * 100))
return util.make_summary(summary_dict), f
|
multipose.py
|
import os
import socket
import threading
import re
import atexit
from math import pi
import requests
bl_info = {
"name": "Multipose Blender Plugin",
"blender": (2, 80, 0),
"category": "Import-Export",
}
import bpy
x = []
HOST = '0.0.0.0'
PORT = 65432
_is_running = True
basepath = "./mocAPP_cache_blender/"
model_path = "/models"
char = [
("empty", "Only Skeleton", ""),
("woman.fbx", "Woman (CC 4.0, Denys Almaral)", ""),
("man.fbx", "Man (CC 4.0, Denys Almaral)", ""),
("trump.fbx", "Donald Trump (CC 4.0, Denys Almaral)", ""),
("doctor.fbx", "Doctor Male (CC 4.0, Denys Almaral)", ""),
("police.fbx", "Police Female (CC 4.0, Denys Almaral)", "")
]
def get_files():
try:
return os.listdir(basepath)
except Exception as e:
return []
def ShowMessageBox(message = "", title = "Message Box", icon = 'INFO'):
def draw(self, context):
self.layout.label(text=message)
bpy.context.window_manager.popup_menu(draw, title = title, icon = icon)
def get_files_list(scene, context):
return [(val, val, "", idx) for idx, val in enumerate(get_files())]
def get_url_for_name(name):
return
class ImportLastBVHOperator(bpy.types.Operator):
"""Imports last BVH File sent by MocAPP"""
bl_idname = "object.import_last_bvh"
bl_label = "Multipose - Load recorded character"
recording = bpy.props.EnumProperty(items=get_files_list, name="Recorded Animation", description="Choose your animation that should be loaded.")
clear_scene = bpy.props.BoolProperty(name="Clear scene", description="Warning! Clears all elements in scene.", default=True)
character = bpy.props.EnumProperty(items=char, name="Character", description="Leave empty if you only need the bare skeleton", default="woman.fbx")
setup_light = bpy.props.BoolProperty(name="Setup light", default=True)
setup_camera = bpy.props.BoolProperty(name="Setup camera", default=True)
adjust_to = bpy.props.BoolProperty(name="Update scene fps", default=True)
update_scene_length = bpy.props.BoolProperty(name="Update scene length", default=True)
use_cycles = bpy.props.BoolProperty(name="Use Cycles Render System (RECOMMENDED)", default=True)
def invoke(self, context, event):
if len(get_files()) == 0:
ShowMessageBox(message="No files - Send some files to blender via mocAPP!", title="No motion capturing files")
return {'FINISHED'}
wm = context.window_manager
return wm.invoke_props_dialog(self)
def execute(self, context):
# delete scene (if necessary)
if self.clear_scene:
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete(use_global=False)
# build scene
if self.setup_light:
bpy.ops.object.light_add(type='POINT', location=(-2, 2, 1.8))
bpy.context.selected_objects[0].name = "Fill Light"
bpy.context.selected_objects[0].data.name = "Fill Light"
# set energy
bpy.context.selected_objects[0].data.energy = 100
bpy.ops.object.light_add(type='POINT', location=(2, 2, 1.8))
bpy.context.selected_objects[0].name = "Key Light"
bpy.context.selected_objects[0].data.name = "Key Light"
bpy.context.selected_objects[0].data.energy = 200
bpy.ops.object.light_add(type='POINT', location=(2, -2, 1.8), radius=4.0)
bpy.context.selected_objects[0].name = "Back Light"
bpy.context.selected_objects[0].data.name = "Back Light"
bpy.context.selected_objects[0].data.energy = 70
# make it softer
bpy.context.selected_objects[0].data.shadow_soft_size = 3.0
if self.setup_camera:
bpy.ops.object.camera_add(enter_editmode=False, align='WORLD', location=(0, 7, 2), rotation=(pi*6/13 , 0, pi))
print("-----")
print(self.recording)
print("-----")
bpy.ops.import_anim.bvh(filepath=basepath + self.recording, update_scene_fps=self.adjust_to, update_scene_duration=self.update_scene_length)
# scale down
bpy.ops.transform.resize(value=(.1, .1, .1))
skel = bpy.context.selected_objects[0]
print(skel)
if self.character != "empty":
# put the character into rest position
bpy.context.object.data.pose_position = 'REST'
bpy.ops.import_scene.fbx( filepath = os.path.join(model_path, self.character))
model = bpy.context.selected_objects[0]
model.select_set(True)
skel.select_set(True)
bpy.context.view_layer.objects.active = skel
bpy.ops.object.parent_set(type="ARMATURE_AUTO")
bpy.context.object.data.pose_position = 'POSE'
bpy.context.scene.render.engine = 'CYCLES'
ShowMessageBox(message="Imported character %s" % self.recording, title="Success!")
return {'FINISHED'}
class MessageBoxOperator(bpy.types.Operator):
bl_idname = "ui.show_message_box"
bl_label = "Minimal Operator"
def execute(self, context):
#this is where I send the message
self.report({'INFO'}, "This is a test")
return {'FINISHED'}
def menu_function(self, context):
self.layout.operator(ImportLastBVHOperator.bl_idname)
def register():
bpy.utils.register_class(ImportLastBVHOperator)
bpy.utils.register_class(MessageBoxOperator)
bpy.types.VIEW3D_MT_object.append(menu_function)
def unregister():
bpy.utils.unregister_class(ImportLastBVHOperator)
bpy.utils.unregister_class(MessageBoxOperator)
def get_unique_name(original_name):
short_form = original_name.split(".bvh")[0]
new_name = short_form
i = 1
print(x)
while(next((True for ob in get_files() if ob.split(".bvh")[0] == new_name), False)):
print("Name exists already")
new_name = short_form + " v%d" % i
i+=1
return new_name + ".bvh"
def get_bvh(url, token):
r = requests.get(url)
d = r.headers['content-disposition']
fname = get_unique_name(re.findall("filename=(.+)", d)[0].replace('"', ''))
print(fname)
fpath = os.path.join(basepath, fname)
#x.append({"path":fpath, "name":get_unique_name(fname)})
if not os.path.exists(basepath):
os.makedirs(basepath)
try:
open(fpath, 'wb').write(r.content)
except FileExistsError as e:
print(e)
pass
def run_server():
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
print("Starting a server on", HOST, PORT)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((HOST, PORT))
s.listen()
while _is_running:
conn, addr = s.accept()
with conn:
url = None
token = None
conn.send(b'\x00')
while True:
try:
data = conn.recv(1024)
dc = data.decode()
if "url=" and "token=" in dc:
url = dc.split("url=")[1].split("\n")[0]
token = dc.split("token=")[1].split("\n")[0]
if url is not None and token is not None:
get_bvh(url, token)
url = None
token = None
if not data:
break
conn.sendall(data)
except ConnectionResetError:
break
def stop_server():
print("Stopping the socket.")
_is_running = False
# run a server thread.
t = threading.Thread(target=run_server)
t.daemon = True
t.start()
atexit.register(stop_server)
|
daemon.py
|
#!/usr/bin/env python3
from xdg.BaseDirectory import xdg_config_home
from PIL import Image, ImageDraw
from threading import Thread
from i3expo.debounce import Debounce
from i3expo.geometry import Geometry, Dimension
import os
os.environ['PYGAME_HIDE_SUPPORT_PROMPT'] = "hide"
import logging
import math
import argparse
import time
import traceback
import sys
import signal
import copy
import i3ipc
import pygame
import ctypes
import configparser
global_updates_running = True
global_knowledge = {'active': -1}
i3 = i3ipc.Connection()
screenshot_lib = '/usr/share/i3expo/prtscn.so'
grab = ctypes.CDLL(screenshot_lib)
parser = argparse.ArgumentParser(
description="Display an overview of all open workspaces")
parser.add_argument("-v", "--verbose",
help="Print more program data", action='store_true')
parser.add_argument("-i", "--interval",
help="Update interval in seconds (default: 1s)")
parser.add_argument("-d", "--dedicated",
help="Launch on a dedicated workspace", action="store_true")
args = parser.parse_args()
loop_interval = 100.0
config = None
config_path = os.path.join(xdg_config_home, "i3expo", "config")
update_debounced = None
def signal_quit(signal, frame):
logging.info("Shutting down...")
pygame.display.quit()
pygame.quit()
i3.main_quit()
sys.exit(0)
def signal_reload(signal, frame):
global loop_interval
logging.info("Reloading config")
read_config()
loop_interval = config.getfloat('Daemon', 'forced_update_interval')
def signal_show(signal, frame):
global global_updates_running
logging.info("Showing UI")
if not global_updates_running:
global_updates_running = True
elif should_show_ui():
global_updates_running = False
update_debounced.reset()
source = i3.get_tree().find_focused().workspace().name
if args.dedicated:
i3.command('workspace i3expod-temporary-workspace')
ui_thread = Thread(target=show_ui, args=[source])
ui_thread.daemon = True
ui_thread.start()
def should_show_ui():
return len(global_knowledge) - 1 > 1
def get_color(raw):
return pygame.Color(raw)
def read_config():
global config
converters = {'color': get_color}
pygame.display.init()
disp_info = pygame.display.Info()
defaults = {
'Capture': {
'screenshot_width': disp_info.current_w,
'screenshot_height': disp_info.current_h,
'screenshot_offset_x': 0,
'screenshot_offset_y': 0,
'screenshot_delay': 0.2
},
'UI': {
'window_width': disp_info.current_w,
'window_height': disp_info.current_h,
'bgcolor': 'gray20',
'frame_active_color': '#5a6da4',
'frame_inactive_color': '#93afb3',
'frame_missing_color': '#ffe6d0',
'tile_missing_color': 'gray40',
'grid_x': 3,
'workspaces': 9,
'padding_percent_x': 5,
'padding_percent_y': 5,
'spacing_percent_x': 4,
'spacing_percent_y': 4,
'frame_width_px': 3,
'names_show': True,
'names_font': 'verdana', # list with pygame.font.get_fonts()
'names_fontsize': 25,
'names_color': 'white',
'highlight_percentage': 20
},
'Daemon': {
'forced_update_interval': 10.0,
'debounce_period': 1.0,
}
}
pygame.display.quit()
config = configparser.ConfigParser(
converters=converters
)
config.read_dict(defaults)
root_dir = os.path.dirname(config_path)
if not os.path.exists(root_dir):
os.makedirs(root_dir)
if os.path.exists(config_path):
config.read(config_path)
else:
with open(config_path, 'w') as f:
config.write(f)
def grab_screen():
logging.debug("Grabbing screen")
x1 = config.getint('Capture', 'screenshot_offset_x')
y1 = config.getint('Capture', 'screenshot_offset_y')
x2 = config.getint('Capture', 'screenshot_width')
y2 = config.getint('Capture', 'screenshot_height')
w, h = x2-x1, y2-y1
size = w * h
objlength = size * 3
grab.getScreen.argtypes = []
result = (ctypes.c_ubyte*objlength)()
grab.getScreen(x1, y1, w, h, result)
return (w, h, result)
def process_image(raw_img):
pil = Image.frombuffer(
'RGB', (raw_img[0], raw_img[1]), raw_img[2], 'raw', 'RGB', 0, 1)
return pygame.image.fromstring(pil.tobytes(), pil.size, pil.mode)
def update_workspace(workspace):
# logging.debug("Update workspace %s", workspace.num)
if workspace.num not in global_knowledge.keys():
global_knowledge[workspace.num] = {
'name': None,
'screenshot': None,
'windows': {},
'last_update': 0,
'state': 0
}
global_knowledge[workspace.num]['name'] = workspace.name
global_knowledge['active'] = workspace.num
def init_knowledge():
for workspace in i3.get_tree().workspaces():
update_workspace(workspace)
def on_workspace(i3, e):
global global_updates_running, loop_interval
# global_updates_running = True
update_state(i3, rate_limit_period=loop_interval, force=True)
def tree_hash(workspace):
state = 0
for con in workspace.leaves():
f = 31 if con.focused else 0 # so focus change can be detected
state += con.id % (con.rect.x + con.rect.y + con.rect.width + con.rect.height + f)
logging.debug("Tree hash for workspace %s: %s", workspace.num, state)
return state
def tree_has_changed(workspace):
state = tree_hash(workspace)
if global_knowledge[workspace.num]['state'] == state:
return False
else:
global_knowledge[workspace.num]['state'] = state
return True
def should_update(rate_limit_period, current_workspace, force):
if not global_updates_running:
return False
elif rate_limit_period is not None and time.time() - global_knowledge[current_workspace.num]['last_update'] <= rate_limit_period:
return False
elif force:
update_debounced.reset()
tree_has_changed(current_workspace)
return True
elif not tree_has_changed(current_workspace):
return False
return True
def update_state(i3, e=None, rate_limit_period=None, force=False):
# Prevent screenshoft from being takes too fast and capturing
# the still unchanged workspace instead of the new one
time.sleep(config.getfloat('Capture', 'screenshot_delay'))
global last_update
root = i3.get_tree()
current_workspace = root.find_focused().workspace()
update_workspace(current_workspace)
if should_update(rate_limit_period, current_workspace, force):
logging.debug("Update state for workspace %s", current_workspace.num)
workspaces = [w.num for w in root.workspaces()]
deleted = []
for num in global_knowledge:
if type(num) is int and num not in workspaces:
deleted.append(num)
for num in deleted:
del global_knowledge[num]
global_knowledge[current_workspace.num]['screenshot'] = grab_screen()
global_knowledge[current_workspace.num]['last_update'] = time.time()
def get_hovered_frame(mpos, frames):
for frame in frames:
if mpos[0] > frame['ul'].x \
and mpos[0] < frame['br'].x \
and mpos[1] > frame['ul'].y \
and mpos[1] < frame['br'].y:
return frame['ws_num']
return None
def show_ui(source):
global global_updates_running
try:
window_width = config.getint('UI', 'window_width')
window_height = config.getint('UI', 'window_height')
pygame.display.init()
pygame.font.init()
screen = pygame.display.set_mode(
(window_width, window_height), pygame.FULLSCREEN)
pygame.display.set_caption('i3expo')
geometry = init_geometry(screen)
tiles = init_tiles(screen)
draw_tiles(screen, tiles, geometry)
pygame.display.flip()
input_loop(screen, source, tiles, geometry.grid.x)
except Exception:
logging.exception("Failed to show UI")
finally:
logging.info("Closing UI")
pygame.display.quit()
pygame.display.init() # Allows for faster launching
global_updates_running = True
def input_loop(screen, source, tiles, columns):
running = True
use_mouse = True
selected_id = 0
while running:
if global_updates_running:
logging.info("Global updates is running")
break
if not pygame.display.get_init():
logging.info("Display is not initialised")
break
jump = False
kbdmove = (0, 0)
for event in pygame.event.get():
if event.type == pygame.QUIT:
logging.info("Received pygame.QUIT")
running = False
elif event.type == pygame.MOUSEMOTION:
use_mouse = True
elif event.type == pygame.KEYDOWN:
use_mouse = False
if event.key == pygame.K_UP or event.key == pygame.K_k:
kbdmove = (0, -1)
if event.key == pygame.K_DOWN or event.key == pygame.K_j:
kbdmove = (0, 1)
if event.key == pygame.K_LEFT or event.key == pygame.K_h:
kbdmove = (-1, 0)
if event.key == pygame.K_RIGHT or event.key == pygame.K_l:
kbdmove = (1, 0)
if event.key == pygame.K_RETURN:
jump = True
if event.key == pygame.K_ESCAPE:
logging.debug("ESCAPE key pressed")
running = False
pygame.event.clear()
break
elif event.type == pygame.MOUSEBUTTONUP:
use_mouse = True
if event.button == 1:
jump = True
pygame.event.clear()
break
if use_mouse:
mpos = pygame.mouse.get_pos()
active_frame = get_hovered_frame(mpos, tiles)
logging.debug("Mouse selected: %s", active_frame)
elif kbdmove != (0, 0):
if kbdmove[0] != 0:
selected_id += kbdmove[0]
elif kbdmove[1] != 0:
selected_id += kbdmove[1] * columns
if selected_id >= len(tiles):
selected_id -= len(tiles)
elif selected_id < 0:
selected_id += len(tiles)
active_frame = tiles[selected_id]['ws_num']
logging.debug("Keyboard selected: %s", active_frame)
if jump:
if active_frame in global_knowledge.keys():
logging.info('Switching to workspace %s', active_frame)
i3.command(f'workspace number {active_frame}')
break
elif not running and args.dedicated:
logging.info('Exiting expo and switching to workspace %s', source)
i3.command('workspace ' + source)
for tile in tiles:
if tile['active'] and not tile['ws_num'] == active_frame:
screen.blit(tile['mouseoff'], (tile['ul'].x, tile['ul'].y))
tile['active'] = False
if not tile['active'] and tile['ws_num'] == active_frame:
screen.blit(tile['mouseon'], (tile['ul'].x, tile['ul'].y))
tile['active'] = True
pygame.display.update()
pygame.time.wait(25)
def init_geometry(screen):
g = Geometry()
workspaces = config.getint('UI', 'workspaces')
max_grid_x = config.getint('UI', 'grid_x')
padding_x = config.getint('UI', 'padding_percent_x')
padding_y = config.getint('UI', 'padding_percent_y')
spacing_x = config.getint('UI', 'spacing_percent_x')
spacing_y = config.getint('UI', 'spacing_percent_y')
frame_width = config.getint('UI', 'frame_width_px')
g.total.x = screen.get_width()
g.total.y = screen.get_height()
logging.debug('total_x=%s total_y=%s', g.total.x, g.total.y)
n_workspaces = min(workspaces, len(global_knowledge) - 1)
g.grid.x = min(max_grid_x, n_workspaces)
g.grid.y = math.ceil(n_workspaces / max_grid_x)
logging.debug('grid_x=%s grid_y=%s', g.grid.x, g.grid.y)
g.pad.x = round(g.total.x * padding_x / 100)
g.pad.y = round(g.total.y * padding_y / 100)
logging.debug('pad_x=%s pad_y=%s', g.pad.x, g.pad.y)
g.space.x = round(g.total.x * spacing_x / 100)
g.space.y = round(g.total.y * spacing_y / 100)
logging.debug('space_x=%s space_y=%s', g.space.x, g.space.y)
g.outer.x = round(
(g.total.x - 2 * g.pad.x - g.space.x * (g.grid.x - 1)) / g.grid.x)
g.outer.y = round(
(g.total.y - 2 * g.pad.y - g.space.y * (g.grid.y - 1)) / g.grid.y)
logging.debug('shot_outer_x=%s shot_outer_y=%s', g.outer.x, g.outer.y)
g.offset.x = g.outer.x + g.space.x
g.offset.y = g.outer.y + g.space.y
logging.debug('offset_delta_x=%s offset_delta_y=%s',
g.offset.x, g.offset.y)
g.inner.x = g.outer.x - 2 * frame_width
g.inner.y = g.outer.y - 2 * frame_width
g.pad.x = max(g.pad.x, (g.total.x - g.space.x *
(g.grid.x - 1) - g.outer.x * g.grid.x) / 2)
g.pad.y = max(g.pad.y, (g.total.y - g.space.y *
(g.grid.y - 1) - g.outer.y * g.grid.y) / 2)
g.frame = frame_width
return g
def autosize_image(g, image):
result = Dimension()
offset = Dimension()
image_size = image.get_rect().size
image_dim = Dimension(image_size[0], image_size[1])
ratio = g.inner / image_dim
if ratio.x < ratio.y:
result.set(g.inner.x, round(ratio.x * image_dim.y))
offset.set(0, round((g.inner.y - result.y) / 2))
else:
result.set(round(ratio.y * image_dim.x), g.inner.y)
offset.set(round((g.inner.x - result.x) / 2), 0)
resized = pygame.transform.smoothscale(image, (result.x, result.y))
return (resized, result, offset)
def draw_tiles(screen, tiles, g):
highlight_percentage = config.getint('UI', 'highlight_percentage')
bgcolor = config.getcolor('UI', 'bgcolor')
screen.fill(bgcolor)
for idx, t in enumerate(tiles):
x = math.floor(idx % g.grid.x)
y = math.floor(idx / g.grid.x)
origin = Dimension(
g.pad.x + g.offset.x * x,
g.pad.y + g.offset.y * y
)
result = Dimension()
offset = Dimension()
if t['screenshot']:
t['img'] = process_image(t['screenshot'])
(image, result, offset) = autosize_image(g, t['img'])
t['ul'] = origin + g.frame + offset
t['br'] = origin + g.frame + offset + result
screen.fill(t['frame'],
(
origin.x + offset.x,
origin.y + offset.y,
result.x + g.frame * 2,
result.y + g.frame * 2,
))
if t['tile']:
screen.fill(t['tile'],
(
origin.x + g.frame + offset.x,
origin.y + g.frame + offset.y,
result.x,
result.y,
))
screen.blit(image, (origin.x + g.frame + offset.x,
origin.y + g.frame + offset.y))
mouseoff = screen.subsurface(
(origin.x + g.frame + offset.x, origin.y +
g.frame + offset.y, result.x, result.y)
).copy()
lightmask = pygame.Surface((result.x, result.y), pygame.SRCALPHA, 32)
lightmask.convert_alpha()
lightmask.fill((255, 255, 255, 255 * highlight_percentage / 100))
mouseon = mouseoff.copy()
mouseon.blit(lightmask, (0, 0))
t['mouseon'] = mouseon.copy()
t['mouseoff'] = mouseoff.copy()
draw_name(screen, t['ws_num'], origin, offset, result, g.frame)
def init_tiles(screen):
logging.debug("Workspace data: %s", global_knowledge)
frame_active_color = config.getcolor('UI', 'frame_active_color')
frame_inactive_color = config.getcolor('UI', 'frame_inactive_color')
frame_missing_color = config.getcolor('UI', 'frame_missing_color')
tile_missing_color = config.getcolor('UI', 'tile_missing_color')
missing_tile = draw_missing_tile(screen)
workspace_ids = [w for w in global_knowledge if w != 'active']
tiles = []
for i in range(len(workspace_ids)):
index = workspace_ids[i]
t = {
'active': False,
'mouseoff': None,
'mouseon': None,
'ul': None,
'br': None,
'frame': None,
'tile': None,
'screenshot': None,
'ws_num': index
}
if global_knowledge[index]['screenshot'] != None:
t['screenshot'] = global_knowledge[index]['screenshot']
if global_knowledge['active'] == index:
t['frame'] = frame_active_color
else:
t['frame'] = frame_inactive_color
else:
t['tile'] = tile_missing_color
t['frame'] = frame_missing_color
t['img'] = missing_tile
tiles.append(t)
return sorted(tiles, key=lambda k: k['ws_num'])
def draw_name(screen, index, origin, offset, result, frame):
names_show = config.get('UI', 'names_show')
names_font = config.get('UI', 'names_font')
names_fontsize = config.getint('UI', 'names_fontsize')
names_color = config.getcolor('UI', 'names_color')
defined_name = False
try:
defined_name = config.get('Workspaces', f'workspace_{index}')
except:
pass
if names_show and (index in global_knowledge.keys() or defined_name):
if not defined_name:
name = global_knowledge[index]['name']
else:
name = defined_name
font = pygame.font.SysFont(names_font, names_fontsize)
name = font.render(name, True, names_color)
name_width = name.get_rect().size[0]
screen.blit(name, (
origin.x + frame + offset.x +
round((result.x - name_width) / 2),
origin.y + frame + offset.y +
result.y + round(result.y * 0.05)
))
def draw_missing_tile(screen):
missing_x = screen.get_width() * 0.3
missing_y = screen.get_height() * 0.3
missing = pygame.Surface((missing_x, missing_y), pygame.SRCALPHA, 32)
missing = missing.convert_alpha()
qm = pygame.font.SysFont(
'sans-serif', int(missing_x * 0.5)).render('?', True, (150, 150, 150)) # RGB
qm_size = qm.get_rect().size
origin_x = round((missing_x - qm_size[0])/2)
origin_y = round((missing_y - qm_size[1])/2)
missing.blit(qm, (origin_x, origin_y))
return missing
def save_pid():
pid = os.getpid()
uid = os.getuid()
logging.info("Registering process PID=%s", pid)
with open(f"/var/run/user/{uid}/i3expo.pid", "w") as f:
f.write(f"{pid}")
def setup_logging():
logLevel = logging.INFO
if args.verbose:
logLevel = logging.DEBUG
logging.basicConfig(
format='[%(levelname)s] %(asctime)s: %(message)s', level=logLevel)
def main():
global update_debounced
try:
setup_logging()
save_pid()
signal.signal(signal.SIGINT, signal_quit)
signal.signal(signal.SIGTERM, signal_quit)
signal.signal(signal.SIGHUP, signal_reload)
signal.signal(signal.SIGUSR1, signal_show)
read_config()
update_debounced = Debounce(config.getfloat(
'Daemon', 'debounce_period'), update_state)
init_knowledge()
update_state(i3, force=True)
# i3.on('workspace', workspace_event)
# i3.on('window::new', update_debounced)
# i3.on('window::close', update_debounced)
i3.on('window::move', update_debounced)
i3.on('window::floating', update_debounced)
i3.on('window::fullscreen_mode', update_debounced)
i3.on('window::focus', update_debounced)
i3.on('workspace', on_workspace)
logging.info("Starting main threads")
i3_thread = Thread(target=i3.main)
i3_thread.daemon = True
i3_thread.start()
loop_interval = config.getfloat('Daemon', 'forced_update_interval')
while True:
time.sleep(loop_interval)
update_state(i3, rate_limit_period=loop_interval, force=True)
except SystemExit:
pass
except:
logging.exception("An unknown exception has ocurred")
if __name__ == '__main__':
main()
|
test_ai2thor_wrapper.py
|
"""
Tests related to the ai2thor environment wrapper.
"""
import random
import threading
import time
import unittest
import warnings
import ai2thor.controller
from gym_ai2thor.envs.ai2thor_env import AI2ThorEnv
class TestAI2ThorEnv(unittest.TestCase):
"""
General environment generation tests
"""
def test_environments_runs(self):
"""
Checks to see if the environment still runs and nothing breaks. Useful for continuous
deployment and keeping master stable. Also, we check how much time 10 steps takes within
the environment. Final assert checks if max_episode_length is equal to the number of steps
taken and no off-by-one errors.
Prints the execution time at the end of the test for performance check.
"""
num_steps = 10
env = AI2ThorEnv()
start = time.time()
all_step_times = []
env.reset()
for step_num in range(num_steps):
start_of_step = time.time()
action = env.action_space.sample()
state, reward, done, _ = env.step(action)
time_for_step = time.time() - start_of_step
print('Step: {}. env.task.step_num: {}. Time taken for step: {:.3f}'.
format(step_num, env.task.step_num, time_for_step))
all_step_times.append(time_for_step)
if done:
break
print('Time taken altogether: {}\nAverage time taken per step: {:.3f}'.format(
time.time() - start, sum(all_step_times) / len(all_step_times)))
self.assertTrue(len(all_step_times) == num_steps)
env.close()
def test_all_task_init(self):
"""
Test that the creation of all tasks still works by taking a few random steps after
resetting environment
"""
param_list = [
{
'pickup_objects': [
'Mug',
'Apple'
],
'task': {
'task_name': 'PickUpTask',
'target_objects': {'Mug': 1, 'Apple': 5}
}
}
]
for params in param_list:
env = AI2ThorEnv(config_dict=params)
state = env.reset()
for i in range(5):
action = env.action_space.sample()
state, reward, done, _ = env.step(action)
env.close()
def test_cup_task_and_interaction_actions(self):
"""
Check if picking up and putting down cup works and agent receives reward of 2 for doing it
twice. For putting the cup down, the agent places it in the microwave and then picks it up
again. Also this implicitly checks there is no random initialisation and that the same
actions in the same environment will achieve the same reward each time.
"""
# actions_to_look_at_cup = ['RotateRight', 'RotateRight', 'MoveAhead', 'MoveAhead',
# 'RotateRight', 'MoveAhead', 'MoveAhead', 'RotateLeft', 'MoveAhead', 'MoveAhead',
# 'MoveAhead', 'RotateLeft', 'LookDown', 'PickupObject', 'PutObject', 'LookUp',
# 'MoveRight', 'OpenObject', 'PutObject', 'PickupObject', 'CloseObject']
actions_to_look_at_cup = ['MoveAhead', 'MoveBack', 'RotateRight', 'RotateLeft', 'LookUp', 'LookDown', 'Stop']
env = AI2ThorEnv(config_dict={'scene_id': 'FloorPlan28',
'gridSize': 0.25,
'acceptable_receptacles': [
'Microwave' # the used receptacle below
],
'target_objects': {'Mug': 1}})
movement_penalty = len(actions_to_look_at_cup) * env.task.movement_reward
for episode in range(2): # twice to make sure no random initialisation
env.reset()
rewards = []
for action_str in actions_to_look_at_cup:
action = env.action_names.index(action_str)
state, reward, done, _ = env.step(action)
rewards.append(reward)
if done:
break
# self.assertAlmostEqual(sum(rewards), 2 + movement_penalty)
env.close()
def test_config_override(self):
"""
Check if reading both a config file and a config dict at the same time works and that the
correct warning occurs for overwriting. Afterwards, check if scene_id was correctly
changed from overwriting
"""
with warnings.catch_warnings(record=True) as warning_objs:
env = AI2ThorEnv(config_dict={'scene_id': 'FloorPlan27'})
# checking if correct warning appears (there could be multiple depending on user)
self.assertTrue([w for w in warning_objs if
'Key: scene_id already in config file' in w.message.args[0]])
self.assertTrue(env.scene_id == 'FloorPlan27')
env.close()
@staticmethod
def test_simple_example():
"""
Taken from here: http://ai2thor.allenai.org/tutorials/examples
"""
controller = ai2thor.controller.Controller()
controller.start()
# Kitchens: FloorPlan1 - FloorPlan30
# Living rooms: FloorPlan201 - FloorPlan230
# Bedrooms: FloorPlan301 - FloorPlan330
# Bathrooms: FloorPLan401 - FloorPlan430
controller.reset('FloorPlan28')
controller.step(dict(action='Initialize', gridSize=0.25))
event = controller.step(dict(action='MoveAhead'))
# Numpy Array - shape (width, height, channels), channels are in RGB order
event.frame
# Numpy Array in BGR order suitable for use with OpenCV
event.cv2img
# current metadata dictionary that includes the state of the scene
event.metadata
@staticmethod
def test_calling_complex_actions():
"""
Examples of how to interact with environment internals e.g. picking up, placing and
opening objects.
Taken from here: http://ai2thor.allenai.org/tutorials/examples
"""
controller = ai2thor.controller.Controller()
controller.start()
controller.reset('FloorPlan28')
controller.step(dict(action='Initialize', gridSize=0.25))
controller.step(dict(action='Teleport', x=-1.25, y=1.00, z=-1.5))
controller.step(dict(action='LookDown'))
event = controller.step(dict(action='Rotate', rotation=90))
# In FloorPlan28, the agent should now be looking at a mug
for obj in event.metadata['objects']:
if obj['visible'] and obj['pickupable'] and obj['objectType'] == 'Mug':
event = controller.step(dict(action='PickupObject', objectId=obj['objectId']),
raise_for_failure=True)
mug_object_id = obj['objectId']
break
# the agent now has the Mug in its inventory
# to put it into the Microwave, we need to open the microwave first
event = controller.step(dict(action='LookUp'))
for obj in event.metadata['objects']:
if obj['visible'] and obj['openable'] and obj['objectType'] == 'Microwave':
event = controller.step(dict(action='OpenObject', objectId=obj['objectId']),
raise_for_failure=True)
receptacle_object_id = obj['objectId']
break
event = controller.step(dict(action='MoveRight'), raise_for_failure=True)
event = controller.step(dict(action='PutObject',
receptacleObjectId=receptacle_object_id,
objectId=mug_object_id),
raise_for_failure=True)
# close the microwave
event = controller.step(dict(
action='CloseObject',
objectId=receptacle_object_id), raise_for_failure=True)
@staticmethod
def test_multithreaded():
"""
Stress test and also shows how multi-threading can be used to greatly speed up processing,
specially to support the rendering of class, object and depth images.
Adapted from here: http://ai2thor.allenai.org/tutorials/examples
Extra analysis done on adding unity information. Important for training models to know.
~67 FPS with 1 thread no extra info
~61 FPS with 1 thread added class info
~18 FPS with 1 thread added Object info on top
~17 FPS with 1 thread added Depth info on top
~70 FPS with 2 threads and no depth, class and object image
~15 FPS with 2 threads and all three of those
Good examples of how to multi-thread are below
"""
thread_count = 1
def run(thread_num):
"""
Runs 5 iterations of 10 steps of the environment with the different rendering options
:param thread_num: (int) Number of threads to launch
"""
env = ai2thor.controller.Controller()
env.start()
render_depth_image, render_class_image, render_object_image = False, False, False
# 50 is an arbritary number
for i in range(5):
t_start = time.time()
env.reset('FloorPlan1')
# env.step({'action': 'Initialize', 'gridSize': 0.25})
# Compare the performance with all the extra added information
# Big take away is that Object instance information makes it much slower
if i == 2:
render_class_image = True
print('Thread num: {}. Added Class info'.format(thread_num))
elif i == 3:
render_object_image = True
print('Thread num: {}. Added Object info'.format(thread_num))
elif i == 4:
render_depth_image = True
print('Thread num: {}. Added Depth info'.format(thread_num))
env.step(dict(action='Initialize',
gridSize=0.25,
renderDepthImage=render_depth_image,
renderClassImage=render_class_image,
renderObjectImage=render_object_image))
print('Thread num: {}. init time: {}'.format(thread_num, time.time() - t_start))
t_start_total = time.time()
for _ in range(10):
env.step({'action': 'MoveAhead'})
env.step({'action': 'RotateRight'})
total_time = time.time() - t_start_total
print('Thread num: {}. Total time for 10 steps: {}. {:.2f} fps'.
format(thread_num, total_time, 50 / total_time))
threads = [threading.Thread(target=run, args=(thread_num, ))
for thread_num in range(thread_count)]
for thread in threads:
thread.daemon = True
thread.start()
time.sleep(1)
for thread in threads:
# calling join() in a loop/timeout to allow for Python 2.7
# to be interrupted with SIGINT
while thread.isAlive():
thread.join(1)
print('done')
if __name__ == '__main__':
unittest.main()
|
test_omega_ithx.py
|
import os
import time
import socket
import threading
from datetime import datetime
from msl.loadlib.utils import get_available_port
from msl.equipment import EquipmentRecord, ConnectionRecord
from msl.equipment.resources.omega import iTHX
def simulate_omega_iserver(address, port, term):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((address, port))
s.listen(10)
conn, _ = s.accept()
while True:
data = bytearray()
while not data.endswith(term):
data.extend(conn.recv(32))
d = data.decode().rstrip()
if d == 'SHUTDOWN':
break
elif d in ['*SRTC', '*SRTC2', '*SRTF', '*SRTF2']:
# temperature
conn.sendall(b'020.0' + term)
elif d in ['*SRH', '*SRH2']:
# humidity
conn.sendall(b'040.0' + term)
elif d in ['*SRD', '*SRDF', '*SRDC', '*SRDC2', '*SRDF', '*SRDF2']:
# dewpoint
conn.sendall(b'010.0' + term)
elif d in ['*SRB', '*SRBF']:
# temperature and humidity
conn.sendall(b'020.0' + term + b',' + b'040.0' + term)
else:
conn.sendall(b'unhandled request' + term)
break
conn.close()
s.close()
def test_temperature_humidity_dewpoint():
address = '127.0.0.1'
port = get_available_port()
term = b'\r'
t = 20.0
h = 40.0
d = 10.0
records = [
EquipmentRecord(
manufacturer='OMEGA',
model='iTHX-W3',
connection=ConnectionRecord(
address='TCP::{}::{}'.format(address, port),
backend='MSL',
properties=dict(
termination=term,
timeout=2
),
)
),
# iTHX-W and iTHX-2 do not support the *SRB and *SRBF commands for
# fetching both the temperature and humidity with a single write command
EquipmentRecord(
manufacturer='OMEGA',
model='iTHX-2',
connection=ConnectionRecord(
address='TCP::{}::{}'.format(address, port),
backend='MSL',
properties=dict(
termination=term,
timeout=2
),
)
),
]
for index, record in enumerate(records):
thread = threading.Thread(target=simulate_omega_iserver, args=(address, port, term))
thread.daemon = True
thread.start()
time.sleep(1)
dev = record.connect(demo=False)
assert isinstance(dev, iTHX)
assert dev.temperature() == t
assert dev.temperature(probe=1) == t
assert dev.temperature(probe=2) == t
assert dev.temperature(probe=1, nbytes=6) == t
assert dev.temperature(probe=2, nbytes=6) == t
assert dev.humidity() == h
assert dev.humidity(probe=1) == h
assert dev.humidity(probe=2) == h
assert dev.humidity(probe=1, nbytes=6) == h
assert dev.humidity(probe=2, nbytes=6) == h
assert dev.dewpoint() == d
assert dev.dewpoint(probe=1) == d
assert dev.dewpoint(probe=2) == d
assert dev.dewpoint(probe=1, nbytes=6) == d
assert dev.dewpoint(probe=2, nbytes=6) == d
assert dev.temperature_humidity() == (t, h)
assert dev.temperature_humidity(probe=1) == (t, h)
assert dev.temperature_humidity(probe=2) == (t, h)
assert dev.temperature_humidity(probe=1, nbytes=12) == (t, h)
assert dev.temperature_humidity(probe=1, nbytes=13) == (t, h)
assert dev.temperature_humidity(probe=2, nbytes=12) == (t, h)
assert dev.temperature_humidity(probe=2, nbytes=13) == (t, h)
assert dev.temperature_humidity_dewpoint() == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=1) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=2) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=1, nbytes=18) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=1, nbytes=19) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=1, nbytes=20) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=2, nbytes=18) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=2, nbytes=19) == (t, h, d)
assert dev.temperature_humidity_dewpoint(probe=2, nbytes=20) == (t, h, d)
dev.write('SHUTDOWN')
dev.disconnect()
thread.join()
def test_database():
db_files = os.path.normpath(os.path.join(os.path.dirname(__file__), os.pardir, 'db_files'))
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'), as_datetime=False)
assert data == [
(1, '2021-09-10T16:03:36', 19.5, 57.5, 10.8),
(2, '2021-09-10T16:03:37', 19.5, 57.5, 10.8),
(3, '2021-09-10T16:03:38', 19.5, 57.5, 10.8),
(4, '2021-09-10T16:03:39', 19.5, 57.5, 10.8),
(5, '2021-09-10T16:03:40', 19.5, 57.5, 10.8),
(6, '2021-09-10T16:03:41', 19.5, 57.5, 10.8),
(7, '2021-09-10T16:03:42', 19.5, 57.5, 10.8),
(8, '2021-09-10T16:03:43', 19.5, 57.5, 10.8),
(9, '2021-09-10T16:03:44', 19.5, 57.5, 10.8),
(10, '2021-09-10T16:03:45', 19.5, 57.5, 10.8)
]
data = iTHX.data(os.path.join(db_files, 'iTHX-2probe.sqlite3'), as_datetime=False)
assert data == [
(1, '2021-09-10T16:01:52', 20.43, 56.23, 11.42, 19.28, 61.53, 11.7),
(2, '2021-09-10T16:01:53', 20.43, 56.23, 11.41, 19.26, 61.55, 11.69),
(3, '2021-09-10T16:01:54', 20.43, 56.23, 11.42, 19.28, 61.53, 11.69),
(4, '2021-09-10T16:01:55', 20.43, 56.23, 11.42, 19.28, 61.53, 11.69),
(5, '2021-09-10T16:01:56', 20.42, 56.23, 11.41, 19.27, 61.53, 11.69),
(6, '2021-09-10T16:01:57', 20.43, 56.23, 11.42, 19.27, 61.53, 11.69),
(7, '2021-09-10T16:01:58', 20.43, 56.23, 11.42, 19.28, 61.56, 11.71),
(8, '2021-09-10T16:01:59', 20.43, 56.23, 11.42, 19.27, 61.53, 11.69),
(9, '2021-09-10T16:02:00', 20.42, 56.23, 11.41, 19.27, 61.53, 11.69),
(10, '2021-09-10T16:02:01', 20.42, 56.23, 11.41, 19.28, 61.53, 11.7)
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'), as_datetime=True)
assert data[0] == (1, datetime(2021, 9, 10, 16, 3, 36), 19.5, 57.5, 10.8)
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
select='pid,temperature,dewpoint')
assert data == [(i, 19.5, 10.8) for i in range(1, 11)]
data = iTHX.data(os.path.join(db_files, 'iTHX-2probe.sqlite3'),
select=['temperature1', 'dewpoint2'])
assert data == [
(20.43, 11.7),
(20.43, 11.69),
(20.43, 11.69),
(20.43, 11.69),
(20.42, 11.69),
(20.43, 11.69),
(20.43, 11.71),
(20.43, 11.69),
(20.42, 11.69),
(20.42, 11.7)
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
start='2021-09-10T16:03:39', as_datetime=False)
assert data == [
(4, '2021-09-10T16:03:39', 19.5, 57.5, 10.8),
(5, '2021-09-10T16:03:40', 19.5, 57.5, 10.8),
(6, '2021-09-10T16:03:41', 19.5, 57.5, 10.8),
(7, '2021-09-10T16:03:42', 19.5, 57.5, 10.8),
(8, '2021-09-10T16:03:43', 19.5, 57.5, 10.8),
(9, '2021-09-10T16:03:44', 19.5, 57.5, 10.8),
(10, '2021-09-10T16:03:45', 19.5, 57.5, 10.8)
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
start=datetime(2021, month=9, day=10, hour=16, minute=3, second=41), as_datetime=False)
assert data == [
(6, '2021-09-10T16:03:41', 19.5, 57.5, 10.8),
(7, '2021-09-10T16:03:42', 19.5, 57.5, 10.8),
(8, '2021-09-10T16:03:43', 19.5, 57.5, 10.8),
(9, '2021-09-10T16:03:44', 19.5, 57.5, 10.8),
(10, '2021-09-10T16:03:45', 19.5, 57.5, 10.8)
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
end='2021-09-10T16:03:38', as_datetime=False)
assert data == [
(1, '2021-09-10T16:03:36', 19.5, 57.5, 10.8),
(2, '2021-09-10T16:03:37', 19.5, 57.5, 10.8),
(3, '2021-09-10T16:03:38', 19.5, 57.5, 10.8),
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
end=datetime(2021, month=9, day=10, hour=16, minute=3, second=36), as_datetime=False)
assert data == [
(1, '2021-09-10T16:03:36', 19.5, 57.5, 10.8),
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
start='2021-09-10T16:03:39', end='2021-09-10T16:03:41', as_datetime=False)
assert data == [
(4, '2021-09-10T16:03:39', 19.5, 57.5, 10.8),
(5, '2021-09-10T16:03:40', 19.5, 57.5, 10.8),
(6, '2021-09-10T16:03:41', 19.5, 57.5, 10.8),
]
data = iTHX.data(os.path.join(db_files, 'iTHX-1probe.sqlite3'),
start='2020-09-10', end='2020-01-01')
assert data == []
|
common.py
|
# Copyright (c) 2015 Ansible, Inc.
# All Rights Reserved.
# Python
from datetime import timedelta
import json
import yaml
import logging
import os
import subprocess
import re
import stat
import urllib.parse
import threading
import contextlib
import tempfile
from functools import reduce, wraps
# Django
from django.core.exceptions import ObjectDoesNotExist, FieldDoesNotExist
from django.utils.dateparse import parse_datetime
from django.utils.translation import gettext_lazy as _
from django.utils.functional import cached_property
from django.db import connection, transaction, ProgrammingError
from django.db.models.fields.related import ForeignObjectRel, ManyToManyField
from django.db.models.fields.related_descriptors import ForwardManyToOneDescriptor, ManyToManyDescriptor
from django.db.models.query import QuerySet
from django.db.models import Q
from django.db import connection as django_connection
from django.core.cache import cache as django_cache
# Django REST Framework
from rest_framework.exceptions import ParseError
from django.utils.encoding import smart_str
from django.utils.text import slugify
from django.utils.timezone import now
from django.apps import apps
# AWX
from awx.conf.license import get_license
logger = logging.getLogger('awx.main.utils')
__all__ = [
'get_object_or_400',
'camelcase_to_underscore',
'underscore_to_camelcase',
'memoize',
'memoize_delete',
'get_awx_http_client_headers',
'get_awx_version',
'update_scm_url',
'get_type_for_model',
'get_model_for_type',
'copy_model_by_class',
'copy_m2m_relationships',
'prefetch_page_capabilities',
'to_python_boolean',
'datetime_hook',
'ignore_inventory_computed_fields',
'ignore_inventory_group_removal',
'_inventory_updates',
'get_pk_from_dict',
'getattrd',
'getattr_dne',
'NoDefaultProvided',
'get_current_apps',
'set_current_apps',
'extract_ansible_vars',
'get_search_fields',
'model_to_dict',
'NullablePromptPseudoField',
'model_instance_diff',
'parse_yaml_or_json',
'RequireDebugTrueOrTest',
'has_model_field_prefetched',
'set_environ',
'IllegalArgumentError',
'get_custom_venv_choices',
'get_external_account',
'task_manager_bulk_reschedule',
'schedule_task_manager',
'classproperty',
'create_temporary_fifo',
'truncate_stdout',
'deepmerge',
'get_event_partition_epoch',
'cleanup_new_process',
]
def get_object_or_400(klass, *args, **kwargs):
"""
Return a single object from the given model or queryset based on the query
params, otherwise raise an exception that will return in a 400 response.
"""
from django.shortcuts import _get_queryset
queryset = _get_queryset(klass)
try:
return queryset.get(*args, **kwargs)
except queryset.model.DoesNotExist as e:
raise ParseError(*e.args)
except queryset.model.MultipleObjectsReturned as e:
raise ParseError(*e.args)
def to_python_boolean(value, allow_none=False):
value = str(value)
if value.lower() in ('true', '1', 't'):
return True
elif value.lower() in ('false', '0', 'f'):
return False
elif allow_none and value.lower() in ('none', 'null'):
return None
else:
raise ValueError(_(u'Unable to convert "%s" to boolean') % value)
def datetime_hook(d):
new_d = {}
for key, value in d.items():
try:
new_d[key] = parse_datetime(value)
except TypeError:
new_d[key] = value
return new_d
def camelcase_to_underscore(s):
"""
Convert CamelCase names to lowercase_with_underscore.
"""
s = re.sub(r'(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', '_\\1', s)
return s.lower().strip('_')
def underscore_to_camelcase(s):
"""
Convert lowercase_with_underscore names to CamelCase.
"""
return ''.join(x.capitalize() or '_' for x in s.split('_'))
class RequireDebugTrueOrTest(logging.Filter):
"""
Logging filter to output when in DEBUG mode or running tests.
"""
def filter(self, record):
from django.conf import settings
return settings.DEBUG or settings.IS_TESTING()
class IllegalArgumentError(ValueError):
pass
def get_memoize_cache():
from django.core.cache import cache
return cache
def memoize(ttl=60, cache_key=None, track_function=False, cache=None):
"""
Decorator to wrap a function and cache its result.
"""
if cache_key and track_function:
raise IllegalArgumentError("Can not specify cache_key when track_function is True")
cache = cache or get_memoize_cache()
def memoize_decorator(f):
@wraps(f)
def _memoizer(*args, **kwargs):
if track_function:
cache_dict_key = slugify('%r %r' % (args, kwargs))
key = slugify("%s" % f.__name__)
cache_dict = cache.get(key) or dict()
if cache_dict_key not in cache_dict:
value = f(*args, **kwargs)
cache_dict[cache_dict_key] = value
cache.set(key, cache_dict, ttl)
else:
value = cache_dict[cache_dict_key]
else:
key = cache_key or slugify('%s %r %r' % (f.__name__, args, kwargs))
value = cache.get(key)
if value is None:
value = f(*args, **kwargs)
cache.set(key, value, ttl)
return value
return _memoizer
return memoize_decorator
def memoize_delete(function_name):
cache = get_memoize_cache()
return cache.delete(function_name)
@memoize(ttl=3600 * 24) # in practice, we only need this to load once at process startup time
def get_event_partition_epoch():
from django.db.migrations.recorder import MigrationRecorder
return MigrationRecorder.Migration.objects.filter(app='main', name='0144_event_partitions').first().applied
def get_awx_version():
"""
Return AWX version as reported by setuptools.
"""
from awx import __version__
try:
import pkg_resources
return pkg_resources.require('awx')[0].version
except Exception:
return __version__
def get_awx_http_client_headers():
license = get_license().get('license_type', 'UNLICENSED')
headers = {
'Content-Type': 'application/json',
'User-Agent': '{} {} ({})'.format('AWX' if license == 'open' else 'Red Hat Ansible Automation Platform', get_awx_version(), license),
}
return headers
def update_scm_url(scm_type, url, username=True, password=True, check_special_cases=True, scp_format=False):
"""
Update the given SCM URL to add/replace/remove the username/password. When
username/password is True, preserve existing username/password, when
False (None, '', etc.), remove any existing username/password, otherwise
replace username/password. Also validates the given URL.
"""
# Handle all of the URL formats supported by the SCM systems:
# git: https://www.kernel.org/pub/software/scm/git/docs/git-clone.html#URLS
# svn: http://svnbook.red-bean.com/en/1.7/svn-book.html#svn.advanced.reposurls
if scm_type not in ('git', 'svn', 'insights', 'archive'):
raise ValueError(_('Unsupported SCM type "%s"') % str(scm_type))
if not url.strip():
return ''
parts = urllib.parse.urlsplit(url)
try:
parts.port
except ValueError:
raise ValueError(_('Invalid %s URL') % scm_type)
if parts.scheme == 'git+ssh' and not scp_format:
raise ValueError(_('Unsupported %s URL') % scm_type)
if '://' not in url:
# Handle SCP-style URLs for git (e.g. [user@]host.xz:path/to/repo.git/).
if scm_type == 'git' and ':' in url:
if '@' in url:
userpass, hostpath = url.split('@', 1)
else:
userpass, hostpath = '', url
if hostpath.count(':') > 1:
raise ValueError(_('Invalid %s URL') % scm_type)
host, path = hostpath.split(':', 1)
# if not path.startswith('/') and not path.startswith('~/'):
# path = '~/%s' % path
# if path.startswith('/'):
# path = path.lstrip('/')
hostpath = '/'.join([host, path])
modified_url = '@'.join(filter(None, [userpass, hostpath]))
# git+ssh scheme identifies URLs that should be converted back to
# SCP style before passed to git module.
parts = urllib.parse.urlsplit('git+ssh://%s' % modified_url)
# Handle local paths specified without file scheme (e.g. /path/to/foo).
# Only supported by git.
elif scm_type == 'git':
if not url.startswith('/'):
parts = urllib.parse.urlsplit('file:///%s' % url)
else:
parts = urllib.parse.urlsplit('file://%s' % url)
else:
raise ValueError(_('Invalid %s URL') % scm_type)
# Validate that scheme is valid for given scm_type.
scm_type_schemes = {
'git': ('ssh', 'git', 'git+ssh', 'http', 'https', 'ftp', 'ftps', 'file'),
'svn': ('http', 'https', 'svn', 'svn+ssh', 'file'),
'insights': ('http', 'https'),
'archive': ('http', 'https'),
}
if parts.scheme not in scm_type_schemes.get(scm_type, ()):
raise ValueError(_('Unsupported %s URL') % scm_type)
if parts.scheme == 'file' and parts.netloc not in ('', 'localhost'):
raise ValueError(_('Unsupported host "%s" for file:// URL') % (parts.netloc))
elif parts.scheme != 'file' and not parts.netloc:
raise ValueError(_('Host is required for %s URL') % parts.scheme)
if username is True:
netloc_username = parts.username or ''
elif username:
netloc_username = username
else:
netloc_username = ''
if password is True:
netloc_password = parts.password or ''
elif password:
netloc_password = password
else:
netloc_password = ''
# Special handling for github/bitbucket SSH URLs.
if check_special_cases:
special_git_hosts = ('github.com', 'bitbucket.org', 'altssh.bitbucket.org')
if scm_type == 'git' and parts.scheme.endswith('ssh') and parts.hostname in special_git_hosts and netloc_username != 'git':
raise ValueError(_('Username must be "git" for SSH access to %s.') % parts.hostname)
if scm_type == 'git' and parts.scheme.endswith('ssh') and parts.hostname in special_git_hosts and netloc_password:
# raise ValueError('Password not allowed for SSH access to %s.' % parts.hostname)
netloc_password = ''
if netloc_username and parts.scheme != 'file' and scm_type not in ("insights", "archive"):
netloc = u':'.join([urllib.parse.quote(x, safe='') for x in (netloc_username, netloc_password) if x])
else:
netloc = u''
netloc = u'@'.join(filter(None, [netloc, parts.hostname]))
if parts.port:
netloc = u':'.join([netloc, str(parts.port)])
new_url = urllib.parse.urlunsplit([parts.scheme, netloc, parts.path, parts.query, parts.fragment])
if scp_format and parts.scheme == 'git+ssh':
new_url = new_url.replace('git+ssh://', '', 1).replace('/', ':', 1)
return new_url
def get_allowed_fields(obj, serializer_mapping):
if serializer_mapping is not None and obj.__class__ in serializer_mapping:
serializer_actual = serializer_mapping[obj.__class__]()
allowed_fields = [x for x in serializer_actual.fields if not serializer_actual.fields[x].read_only] + ['id']
else:
allowed_fields = [x.name for x in obj._meta.fields]
ACTIVITY_STREAM_FIELD_EXCLUSIONS = {'user': ['last_login'], 'oauth2accesstoken': ['last_used'], 'oauth2application': ['client_secret']}
model_name = obj._meta.model_name
fields_excluded = ACTIVITY_STREAM_FIELD_EXCLUSIONS.get(model_name, [])
# see definition of from_db for CredentialType
# injection logic of any managed types are incompatible with activity stream
if model_name == 'credentialtype' and obj.managed and obj.namespace:
fields_excluded.extend(['inputs', 'injectors'])
if fields_excluded:
allowed_fields = [f for f in allowed_fields if f not in fields_excluded]
return allowed_fields
def _convert_model_field_for_display(obj, field_name, password_fields=None):
# NOTE: Careful modifying the value of field_val, as it could modify
# underlying model object field value also.
try:
field_val = getattr(obj, field_name, None)
except ObjectDoesNotExist:
return '<missing {}>-{}'.format(obj._meta.verbose_name, getattr(obj, '{}_id'.format(field_name)))
if password_fields is None:
password_fields = set(getattr(type(obj), 'PASSWORD_FIELDS', [])) | set(['password'])
if field_name in password_fields or (isinstance(field_val, str) and field_val.startswith('$encrypted$')):
return u'hidden'
if hasattr(obj, 'display_%s' % field_name):
field_val = getattr(obj, 'display_%s' % field_name)()
if isinstance(field_val, (list, dict)):
try:
field_val = json.dumps(field_val, ensure_ascii=False)
except Exception:
pass
if type(field_val) not in (bool, int, type(None)):
field_val = smart_str(field_val)
return field_val
def model_instance_diff(old, new, serializer_mapping=None):
"""
Calculate the differences between two model instances. One of the instances may be None (i.e., a newly
created model or deleted model). This will cause all fields with a value to have changed (from None).
serializer_mapping are used to determine read-only fields.
When provided, read-only fields will not be included in the resulting dictionary
"""
from django.db.models import Model
if not (old is None or isinstance(old, Model)):
raise TypeError('The supplied old instance is not a valid model instance.')
if not (new is None or isinstance(new, Model)):
raise TypeError('The supplied new instance is not a valid model instance.')
old_password_fields = set(getattr(type(old), 'PASSWORD_FIELDS', [])) | set(['password'])
new_password_fields = set(getattr(type(new), 'PASSWORD_FIELDS', [])) | set(['password'])
diff = {}
allowed_fields = get_allowed_fields(new, serializer_mapping)
for field in allowed_fields:
old_value = getattr(old, field, None)
new_value = getattr(new, field, None)
if old_value != new_value:
diff[field] = (
_convert_model_field_for_display(old, field, password_fields=old_password_fields),
_convert_model_field_for_display(new, field, password_fields=new_password_fields),
)
if len(diff) == 0:
diff = None
return diff
def model_to_dict(obj, serializer_mapping=None):
"""
Serialize a model instance to a dictionary as best as possible
serializer_mapping are used to determine read-only fields.
When provided, read-only fields will not be included in the resulting dictionary
"""
password_fields = set(getattr(type(obj), 'PASSWORD_FIELDS', [])) | set(['password'])
attr_d = {}
allowed_fields = get_allowed_fields(obj, serializer_mapping)
for field_name in allowed_fields:
attr_d[field_name] = _convert_model_field_for_display(obj, field_name, password_fields=password_fields)
return attr_d
class CharPromptDescriptor:
"""Class used for identifying nullable launch config fields from class
ex. Schedule.limit
"""
def __init__(self, field):
self.field = field
class NullablePromptPseudoField:
"""
Interface for pseudo-property stored in `char_prompts` dict
Used in LaunchTimeConfig and submodels, defined here to avoid circular imports
"""
def __init__(self, field_name):
self.field_name = field_name
@cached_property
def field_descriptor(self):
return CharPromptDescriptor(self)
def __get__(self, instance, type=None):
if instance is None:
# for inspection on class itself
return self.field_descriptor
return instance.char_prompts.get(self.field_name, None)
def __set__(self, instance, value):
if value in (None, {}):
instance.char_prompts.pop(self.field_name, None)
else:
instance.char_prompts[self.field_name] = value
def copy_model_by_class(obj1, Class2, fields, kwargs):
"""
Creates a new unsaved object of type Class2 using the fields from obj1
values in kwargs can override obj1
"""
create_kwargs = {}
for field_name in fields:
descriptor = getattr(Class2, field_name)
if isinstance(descriptor, ForwardManyToOneDescriptor): # ForeignKey
# Foreign keys can be specified as field_name or field_name_id.
id_field_name = '%s_id' % field_name
if field_name in kwargs:
value = kwargs[field_name]
elif id_field_name in kwargs:
value = kwargs[id_field_name]
else:
value = getattr(obj1, id_field_name)
if hasattr(value, 'id'):
value = value.id
create_kwargs[id_field_name] = value
elif isinstance(descriptor, CharPromptDescriptor):
# difficult case of copying one launch config to another launch config
new_val = None
if field_name in kwargs:
new_val = kwargs[field_name]
elif hasattr(obj1, 'char_prompts'):
if field_name in obj1.char_prompts:
new_val = obj1.char_prompts[field_name]
elif hasattr(obj1, field_name):
# extremely rare case where a template spawns a launch config - sliced jobs
new_val = getattr(obj1, field_name)
if new_val is not None:
create_kwargs.setdefault('char_prompts', {})
create_kwargs['char_prompts'][field_name] = new_val
elif isinstance(descriptor, ManyToManyDescriptor):
continue # not copied in this method
elif field_name in kwargs:
if field_name == 'extra_vars' and isinstance(kwargs[field_name], dict):
create_kwargs[field_name] = json.dumps(kwargs['extra_vars'])
elif not isinstance(Class2._meta.get_field(field_name), (ForeignObjectRel, ManyToManyField)):
create_kwargs[field_name] = kwargs[field_name]
elif hasattr(obj1, field_name):
create_kwargs[field_name] = getattr(obj1, field_name)
# Apply class-specific extra processing for origination of unified jobs
if hasattr(obj1, '_update_unified_job_kwargs') and obj1.__class__ != Class2:
new_kwargs = obj1._update_unified_job_kwargs(create_kwargs, kwargs)
else:
new_kwargs = create_kwargs
return Class2(**new_kwargs)
def copy_m2m_relationships(obj1, obj2, fields, kwargs=None):
"""
In-place operation.
Given two saved objects, copies related objects from obj1
to obj2 to field of same name, if field occurs in `fields`
"""
for field_name in fields:
if hasattr(obj1, field_name):
try:
field_obj = obj1._meta.get_field(field_name)
except FieldDoesNotExist:
continue
if isinstance(field_obj, ManyToManyField):
# Many to Many can be specified as field_name
src_field_value = getattr(obj1, field_name)
if kwargs and field_name in kwargs:
override_field_val = kwargs[field_name]
if isinstance(override_field_val, (set, list, QuerySet)):
getattr(obj2, field_name).add(*override_field_val)
continue
if override_field_val.__class__.__name__ == 'ManyRelatedManager':
src_field_value = override_field_val
dest_field = getattr(obj2, field_name)
dest_field.add(*list(src_field_value.all().values_list('id', flat=True)))
def get_type_for_model(model):
"""
Return type name for a given model class.
"""
opts = model._meta.concrete_model._meta
return camelcase_to_underscore(opts.object_name)
def get_model_for_type(type_name):
"""
Return model class for a given type name.
"""
model_str = underscore_to_camelcase(type_name)
if model_str == 'User':
use_app = 'auth'
else:
use_app = 'main'
return apps.get_model(use_app, model_str)
def get_capacity_type(uj):
'''Used for UnifiedJob.capacity_type property, static method will work for partial objects'''
model_name = uj._meta.concrete_model._meta.model_name
if model_name in ('job', 'inventoryupdate', 'adhoccommand', 'jobtemplate', 'inventorysource'):
return 'execution'
elif model_name == 'workflowjob':
return None
elif model_name.startswith('unified'):
raise RuntimeError(f'Capacity type is undefined for {model_name} model')
elif model_name in ('projectupdate', 'systemjob', 'project', 'systemjobtemplate'):
return 'control'
raise RuntimeError(f'Capacity type does not apply to {model_name} model')
def prefetch_page_capabilities(model, page, prefetch_list, user):
"""
Given a `page` list of objects, a nested dictionary of user_capabilities
are returned by id, ex.
{
4: {'edit': True, 'start': True},
6: {'edit': False, 'start': False}
}
Each capability is produced for all items in the page in a single query
Examples of prefetch language:
prefetch_list = ['admin', 'execute']
--> prefetch the admin (edit) and execute (start) permissions for
items in list for current user
prefetch_list = ['inventory.admin']
--> prefetch the related inventory FK permissions for current user,
and put it into the object's cache
prefetch_list = [{'copy': ['inventory.admin', 'project.admin']}]
--> prefetch logical combination of admin permission to inventory AND
project, put into cache dictionary as "copy"
"""
page_ids = [obj.id for obj in page]
mapping = {}
for obj in page:
mapping[obj.id] = {}
for prefetch_entry in prefetch_list:
display_method = None
if type(prefetch_entry) is dict:
display_method = list(prefetch_entry.keys())[0]
paths = prefetch_entry[display_method]
else:
paths = prefetch_entry
if type(paths) is not list:
paths = [paths]
# Build the query for accessible_objects according the user & role(s)
filter_args = []
for role_path in paths:
if '.' in role_path:
res_path = '__'.join(role_path.split('.')[:-1])
role_type = role_path.split('.')[-1]
parent_model = model
for subpath in role_path.split('.')[:-1]:
parent_model = parent_model._meta.get_field(subpath).related_model
filter_args.append(
Q(Q(**{'%s__pk__in' % res_path: parent_model.accessible_pk_qs(user, '%s_role' % role_type)}) | Q(**{'%s__isnull' % res_path: True}))
)
else:
role_type = role_path
filter_args.append(Q(**{'pk__in': model.accessible_pk_qs(user, '%s_role' % role_type)}))
if display_method is None:
# Role name translation to UI names for methods
display_method = role_type
if role_type == 'admin':
display_method = 'edit'
elif role_type in ['execute', 'update']:
display_method = 'start'
# Union that query with the list of items on page
filter_args.append(Q(pk__in=page_ids))
ids_with_role = set(model.objects.filter(*filter_args).values_list('pk', flat=True))
# Save data item-by-item
for obj in page:
mapping[obj.pk][display_method] = bool(obj.pk in ids_with_role)
return mapping
def validate_vars_type(vars_obj):
if not isinstance(vars_obj, dict):
vars_type = type(vars_obj)
if hasattr(vars_type, '__name__'):
data_type = vars_type.__name__
else:
data_type = str(vars_type)
raise AssertionError(_('Input type `{data_type}` is not a dictionary').format(data_type=data_type))
def parse_yaml_or_json(vars_str, silent_failure=True):
"""
Attempt to parse a string of variables.
First, with JSON parser, if that fails, then with PyYAML.
If both attempts fail, return an empty dictionary if `silent_failure`
is True, re-raise combination error if `silent_failure` if False.
"""
if isinstance(vars_str, dict):
return vars_str
elif isinstance(vars_str, str) and vars_str == '""':
return {}
try:
vars_dict = json.loads(vars_str)
validate_vars_type(vars_dict)
except (ValueError, TypeError, AssertionError) as json_err:
try:
vars_dict = yaml.safe_load(vars_str)
# Can be None if '---'
if vars_dict is None:
vars_dict = {}
validate_vars_type(vars_dict)
if not silent_failure:
# is valid YAML, check that it is compatible with JSON
try:
json.dumps(vars_dict)
except (ValueError, TypeError, AssertionError) as json_err2:
raise ParseError(_('Variables not compatible with JSON standard (error: {json_error})').format(json_error=str(json_err2)))
except (yaml.YAMLError, TypeError, AttributeError, AssertionError) as yaml_err:
if silent_failure:
return {}
raise ParseError(
_('Cannot parse as JSON (error: {json_error}) or ' 'YAML (error: {yaml_error}).').format(json_error=str(json_err), yaml_error=str(yaml_err))
)
return vars_dict
def convert_cpu_str_to_decimal_cpu(cpu_str):
"""Convert a string indicating cpu units to decimal.
Useful for dealing with cpu setting that may be expressed in units compatible with
kubernetes.
See https://kubernetes.io/docs/tasks/configure-pod-container/assign-cpu-resource/#cpu-units
"""
cpu = cpu_str
millicores = False
if cpu_str[-1] == 'm':
cpu = cpu_str[:-1]
millicores = True
try:
cpu = float(cpu)
except ValueError:
cpu = 1.0
millicores = False
logger.warning(f"Could not convert SYSTEM_TASK_ABS_CPU {cpu_str} to a decimal number, falling back to default of 1 cpu")
if millicores:
cpu = cpu / 1000
# Per kubernetes docs, fractional CPU less than .1 are not allowed
return max(0.1, round(cpu, 1))
def get_corrected_cpu(cpu_count): # formerlly get_cpu_capacity
"""Some environments will do a correction to the reported CPU number
because the given OpenShift value is a lie
"""
from django.conf import settings
settings_abscpu = getattr(settings, 'SYSTEM_TASK_ABS_CPU', None)
env_abscpu = os.getenv('SYSTEM_TASK_ABS_CPU', None)
if env_abscpu is not None:
return convert_cpu_str_to_decimal_cpu(env_abscpu)
elif settings_abscpu is not None:
return convert_cpu_str_to_decimal_cpu(settings_abscpu)
return cpu_count # no correction
def get_cpu_effective_capacity(cpu_count):
from django.conf import settings
cpu_count = get_corrected_cpu(cpu_count)
settings_forkcpu = getattr(settings, 'SYSTEM_TASK_FORKS_CPU', None)
env_forkcpu = os.getenv('SYSTEM_TASK_FORKS_CPU', None)
if env_forkcpu:
forkcpu = int(env_forkcpu)
elif settings_forkcpu:
forkcpu = int(settings_forkcpu)
else:
forkcpu = 4
return max(1, int(cpu_count * forkcpu))
def convert_mem_str_to_bytes(mem_str):
"""Convert string with suffix indicating units to memory in bytes (base 2)
Useful for dealing with memory setting that may be expressed in units compatible with
kubernetes.
See https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/#meaning-of-memory
"""
# If there is no suffix, the memory sourced from the request is in bytes
if mem_str.isdigit():
return int(mem_str)
conversions = {
'Ei': lambda x: x * 2**60,
'E': lambda x: x * 10**18,
'Pi': lambda x: x * 2**50,
'P': lambda x: x * 10**15,
'Ti': lambda x: x * 2**40,
'T': lambda x: x * 10**12,
'Gi': lambda x: x * 2**30,
'G': lambda x: x * 10**9,
'Mi': lambda x: x * 2**20,
'M': lambda x: x * 10**6,
'Ki': lambda x: x * 2**10,
'K': lambda x: x * 10**3,
}
mem = 0
mem_unit = None
for i, char in enumerate(mem_str):
if not char.isdigit():
mem_unit = mem_str[i:]
mem = int(mem_str[:i])
break
if not mem_unit or mem_unit not in conversions.keys():
error = f"Unsupported value for SYSTEM_TASK_ABS_MEM: {mem_str}, memory must be expressed in bytes or with known suffix: {conversions.keys()}. Falling back to 1 byte"
logger.warning(error)
return 1
return max(1, conversions[mem_unit](mem))
def get_corrected_memory(memory):
from django.conf import settings
settings_absmem = getattr(settings, 'SYSTEM_TASK_ABS_MEM', None)
env_absmem = os.getenv('SYSTEM_TASK_ABS_MEM', None)
# Runner returns memory in bytes
# so we convert memory from settings to bytes as well.
if env_absmem is not None:
return convert_mem_str_to_bytes(env_absmem)
elif settings_absmem is not None:
return convert_mem_str_to_bytes(settings_absmem)
return memory
def get_mem_effective_capacity(mem_bytes):
from django.conf import settings
mem_bytes = get_corrected_memory(mem_bytes)
settings_mem_mb_per_fork = getattr(settings, 'SYSTEM_TASK_FORKS_MEM', None)
env_mem_mb_per_fork = os.getenv('SYSTEM_TASK_FORKS_MEM', None)
if env_mem_mb_per_fork:
mem_mb_per_fork = int(env_mem_mb_per_fork)
elif settings_mem_mb_per_fork:
mem_mb_per_fork = int(settings_mem_mb_per_fork)
else:
mem_mb_per_fork = 100
# Per docs, deduct 2GB of memory from the available memory
# to cover memory consumption of background tasks when redis/web etc are colocated with
# the other control processes
memory_penalty_bytes = 2147483648
if settings.IS_K8S:
# In k8s, this is dealt with differently because
# redis and the web containers have their own memory allocation
memory_penalty_bytes = 0
# convert memory to megabytes because our setting of how much memory we
# should allocate per fork is in megabytes
mem_mb = (mem_bytes - memory_penalty_bytes) // 2**20
max_forks_based_on_memory = mem_mb // mem_mb_per_fork
return max(1, max_forks_based_on_memory)
_inventory_updates = threading.local()
_task_manager = threading.local()
@contextlib.contextmanager
def ignore_inventory_computed_fields():
"""
Context manager to ignore updating inventory computed fields.
"""
try:
previous_value = getattr(_inventory_updates, 'is_updating', False)
_inventory_updates.is_updating = True
yield
finally:
_inventory_updates.is_updating = previous_value
def _schedule_task_manager():
from awx.main.scheduler.tasks import run_task_manager
from django.db import connection
# runs right away if not in transaction
connection.on_commit(lambda: run_task_manager.delay())
@contextlib.contextmanager
def task_manager_bulk_reschedule():
"""Context manager to avoid submitting task multiple times."""
try:
previous_flag = getattr(_task_manager, 'bulk_reschedule', False)
previous_value = getattr(_task_manager, 'needs_scheduling', False)
_task_manager.bulk_reschedule = True
_task_manager.needs_scheduling = False
yield
finally:
_task_manager.bulk_reschedule = previous_flag
if _task_manager.needs_scheduling:
_schedule_task_manager()
_task_manager.needs_scheduling = previous_value
def schedule_task_manager():
if getattr(_task_manager, 'bulk_reschedule', False):
_task_manager.needs_scheduling = True
return
_schedule_task_manager()
@contextlib.contextmanager
def ignore_inventory_group_removal():
"""
Context manager to ignore moving groups/hosts when group is deleted.
"""
try:
previous_value = getattr(_inventory_updates, 'is_removing', False)
_inventory_updates.is_removing = True
yield
finally:
_inventory_updates.is_removing = previous_value
@contextlib.contextmanager
def set_environ(**environ):
"""
Temporarily set the process environment variables.
>>> with set_environ(FOO='BAR'):
... assert os.environ['FOO'] == 'BAR'
"""
old_environ = os.environ.copy()
try:
os.environ.update(environ)
yield
finally:
os.environ.clear()
os.environ.update(old_environ)
def get_pk_from_dict(_dict, key):
"""
Helper for obtaining a pk from user data dict or None if not present.
"""
try:
val = _dict[key]
if isinstance(val, object) and hasattr(val, 'id'):
return val.id # return id if given model object
return int(val)
except (TypeError, KeyError, ValueError):
return None
class NoDefaultProvided(object):
pass
def getattrd(obj, name, default=NoDefaultProvided):
"""
Same as getattr(), but allows dot notation lookup
Discussed in:
http://stackoverflow.com/questions/11975781
"""
try:
return reduce(getattr, name.split("."), obj)
except AttributeError:
if default != NoDefaultProvided:
return default
raise
def getattr_dne(obj, name, notfound=ObjectDoesNotExist):
try:
return getattr(obj, name)
except notfound:
return None
current_apps = apps
def set_current_apps(apps):
global current_apps
current_apps = apps
def get_current_apps():
global current_apps
return current_apps
def get_custom_venv_choices():
from django.conf import settings
all_venv_paths = settings.CUSTOM_VENV_PATHS + [settings.BASE_VENV_PATH]
custom_venv_choices = []
for venv_path in all_venv_paths:
if os.path.exists(venv_path):
for d in os.listdir(venv_path):
if venv_path == settings.BASE_VENV_PATH and d == 'awx':
continue
if os.path.exists(os.path.join(venv_path, d, 'bin', 'pip')):
custom_venv_choices.append(os.path.join(venv_path, d))
return custom_venv_choices
def get_custom_venv_pip_freeze(venv_path):
pip_path = os.path.join(venv_path, 'bin', 'pip')
try:
freeze_data = subprocess.run([pip_path, "freeze"], capture_output=True)
pip_data = (freeze_data.stdout).decode('UTF-8')
return pip_data
except Exception:
logger.exception("Encountered an error while trying to run 'pip freeze' for custom virtual environments:")
def is_ansible_variable(key):
return key.startswith('ansible_')
def extract_ansible_vars(extra_vars):
extra_vars = parse_yaml_or_json(extra_vars)
ansible_vars = set([])
for key in list(extra_vars.keys()):
if is_ansible_variable(key):
extra_vars.pop(key)
ansible_vars.add(key)
return (extra_vars, ansible_vars)
def get_search_fields(model):
fields = []
for field in model._meta.fields:
if field.name in ('username', 'first_name', 'last_name', 'email', 'name', 'description'):
fields.append(field.name)
return fields
def has_model_field_prefetched(model_obj, field_name):
# NOTE: Update this function if django internal implementation changes.
return getattr(getattr(model_obj, field_name, None), 'prefetch_cache_name', '') in getattr(model_obj, '_prefetched_objects_cache', {})
def get_external_account(user):
from django.conf import settings
account_type = None
if getattr(settings, 'AUTH_LDAP_SERVER_URI', None):
try:
if user.pk and user.profile.ldap_dn and not user.has_usable_password():
account_type = "ldap"
except AttributeError:
pass
if (
getattr(settings, 'SOCIAL_AUTH_GOOGLE_OAUTH2_KEY', None)
or getattr(settings, 'SOCIAL_AUTH_GITHUB_KEY', None)
or getattr(settings, 'SOCIAL_AUTH_GITHUB_ORG_KEY', None)
or getattr(settings, 'SOCIAL_AUTH_GITHUB_TEAM_KEY', None)
or getattr(settings, 'SOCIAL_AUTH_SAML_ENABLED_IDPS', None)
) and user.social_auth.all():
account_type = "social"
if (getattr(settings, 'RADIUS_SERVER', None) or getattr(settings, 'TACACSPLUS_HOST', None)) and user.enterprise_auth.all():
account_type = "enterprise"
return account_type
class classproperty:
def __init__(self, fget=None, fset=None, fdel=None, doc=None):
self.fget = fget
self.fset = fset
self.fdel = fdel
if doc is None and fget is not None:
doc = fget.__doc__
self.__doc__ = doc
def __get__(self, instance, ownerclass):
return self.fget(ownerclass)
def create_temporary_fifo(data):
"""Open fifo named pipe in a new thread using a temporary file path. The
thread blocks until data is read from the pipe.
Returns the path to the fifo.
:param data(bytes): Data to write to the pipe.
"""
path = os.path.join(tempfile.mkdtemp(), next(tempfile._get_candidate_names()))
os.mkfifo(path, stat.S_IRUSR | stat.S_IWUSR)
threading.Thread(target=lambda p, d: open(p, 'wb').write(d), args=(path, data)).start()
return path
def truncate_stdout(stdout, size):
from awx.main.constants import ANSI_SGR_PATTERN
if size <= 0 or len(stdout) <= size:
return stdout
stdout = stdout[: (size - 1)] + u'\u2026'
set_count, reset_count = 0, 0
for m in ANSI_SGR_PATTERN.finditer(stdout):
if m.group() == u'\u001b[0m':
reset_count += 1
else:
set_count += 1
return stdout + u'\u001b[0m' * (set_count - reset_count)
def deepmerge(a, b):
"""
Merge dict structures and return the result.
>>> a = {'first': {'all_rows': {'pass': 'dog', 'number': '1'}}}
>>> b = {'first': {'all_rows': {'fail': 'cat', 'number': '5'}}}
>>> import pprint; pprint.pprint(deepmerge(a, b))
{'first': {'all_rows': {'fail': 'cat', 'number': '5', 'pass': 'dog'}}}
"""
if isinstance(a, dict) and isinstance(b, dict):
return dict([(k, deepmerge(a.get(k), b.get(k))) for k in set(a.keys()).union(b.keys())])
elif b is None:
return a
else:
return b
def create_partition(tblname, start=None):
"""Creates new partition table for events. By default it covers the current hour."""
if start is None:
start = now()
start = start.replace(microsecond=0, second=0, minute=0)
end = start + timedelta(hours=1)
start_timestamp = str(start)
end_timestamp = str(end)
partition_label = start.strftime('%Y%m%d_%H')
try:
with transaction.atomic():
with connection.cursor() as cursor:
cursor.execute(
f'CREATE TABLE IF NOT EXISTS {tblname}_{partition_label} '
f'PARTITION OF {tblname} '
f'FOR VALUES FROM (\'{start_timestamp}\') to (\'{end_timestamp}\');'
)
except ProgrammingError as e:
logger.debug(f'Caught known error due to existing partition: {e}')
def cleanup_new_process(func):
"""
Cleanup django connection, cache connection, before executing new thread or processes entry point, func.
"""
@wraps(func)
def wrapper_cleanup_new_process(*args, **kwargs):
from awx.conf.settings import SettingsWrapper # noqa
django_connection.close()
django_cache.close()
SettingsWrapper.initialize()
return func(*args, **kwargs)
return wrapper_cleanup_new_process
|
Lending.py
|
# coding=utf-8
from decimal import Decimal
import sched
import time
import threading
Config = None
api = None
log = None
Data = None
MaxToLend = None
Analysis = None
SATOSHI = Decimal(10) ** -8
cancel_at_round_turn = 0
sleep_time_active = 0
sleep_time_inactive = 0
sleep_time = 0
min_daily_rate = 0
max_daily_rate = 0
spread_lend = 0
gap_bottom_default = 0
gap_top_default = 0
xday_threshold = 0
xday_spread = 0
xdays = 0
min_loan_size = 0
min_loan_sizes = {}
end_date = None
coin_cfg = {}
dry_run = 0
transferable_currencies = []
currencies_to_analyse = []
keep_stuck_orders = True
hide_coins = True
coin_cfg_alerted = {}
max_active_alerted = {}
notify_conf = {}
loans_provided = {}
gap_mode_default = ""
scheduler = None
exchange = None
frrasmin = False
frrdelta = 0.0
# limit of orders to request
loanOrdersRequestLimit = {}
defaultLoanOrdersRequestLimit = 400
increaseLoanOrdersRequestLimit = 100
currentCancelRoundTurn = 0
def init(cfg, api1, log1, data, maxtolend, dry_run1, analysis, notify_conf1):
global Config, api, log, Data, MaxToLend, Analysis, notify_conf
Config = cfg
api = api1
log = log1
Data = data
MaxToLend = maxtolend
Analysis = analysis
notify_conf = notify_conf1
global sleep_time, cancel_at_round_turn, sleep_time_active, sleep_time_inactive, min_daily_rate, max_daily_rate, spread_lend, \
gap_bottom_default, gap_top_default, xday_threshold, xday_spread, xdays, min_loan_size, end_date, coin_cfg, \
min_loan_sizes, dry_run, transferable_currencies, keep_stuck_orders, hide_coins, scheduler, gap_mode_default, \
exchange, analysis_method, currencies_to_analyse, all_currencies, frrasmin, frrdelta
exchange = Config.get_exchange()
cancel_at_round_turn = float(Config.get("BOT", "cancelatroundturn", None, 1, 3600))
sleep_time_active = float(Config.get("BOT", "sleeptimeactive", None, 1, 3600))
sleep_time_inactive = float(Config.get("BOT", "sleeptimeinactive", None, 1, 3600))
exchangeMax = 7 if exchange == 'BITFINEX' else 5
min_daily_rate = Decimal(Config.get("BOT", "mindailyrate", None, 0.003, exchangeMax)) / 100
max_daily_rate = Decimal(Config.get("BOT", "maxdailyrate", None, 0.003, exchangeMax)) / 100
spread_lend = int(Config.get("BOT", "spreadlend", None, 1, 20))
gap_mode_default = Config.get_gap_mode("BOT", "gapMode")
gap_bottom_default = Decimal(Config.get("BOT", "gapbottom", None, 0))
gap_top_default = Decimal(Config.get("BOT", "gaptop", None, gap_bottom_default))
xday_threshold = float(Config.get("BOT", "xdaythreshold", None, 0.003, 5)) / 100
xday_spread = float(Config.get('BOT', 'xdayspread', 0, 0, 10))
maxPeriod = 30 if exchange == 'BITFINEX' else 60
xdays = str(Config.get("BOT", "xdays", None, 2, maxPeriod))
min_loan_size = Decimal(Config.get("BOT", 'minloansize', None, 0.01))
end_date = Config.get('BOT', 'endDate')
coin_cfg = Config.get_coin_cfg()
min_loan_sizes = Config.get_min_loan_sizes()
dry_run = dry_run1
transferable_currencies = Config.get_currencies_list('transferableCurrencies')
all_currencies = Config.get_all_currencies()
currencies_to_analyse = Config.get_currencies_list('analyseCurrencies', 'MarketAnalysis')
keep_stuck_orders = Config.getboolean('BOT', "keepstuckorders", True)
hide_coins = Config.getboolean('BOT', 'hideCoins', True)
frrasmin = Config.getboolean('BOT', 'frrasmin', False)
frrdelta = Decimal(Config.get('BOT', 'frrdelta', 0.0000))
analysis_method = Config.get('Daily_min', 'method', 'percentile')
if analysis_method not in ['percentile', 'MACD']:
raise ValueError("analysis_method: \"{0}\" is not valid, must be percentile or MACD".format(analysis_method))
sleep_time = sleep_time_active # Start with active mode
# create the scheduler thread
scheduler = sched.scheduler(time.time, time.sleep)
if notify_conf['notify_summary_minutes']:
# Wait 10 seconds before firing the first summary notifcation, then use the config time value for future updates
scheduler.enter(10, 1, notify_summary, (notify_conf['notify_summary_minutes'] * 60, ))
if notify_conf['notify_new_loans']:
scheduler.enter(20, 1, notify_new_loans, (60, ))
if not scheduler.empty():
t = threading.Thread(target=scheduler.run)
t.start()
def get_sleep_time():
return sleep_time
def set_sleep_time(usable):
global sleep_time
if usable == 0: # After loop, if no currencies had enough to lend, use inactive sleep time.
sleep_time = sleep_time_inactive
else: # Else, use active sleep time.
sleep_time = sleep_time_active
def notify_summary(sleep_time):
try:
log.notify(Data.stringify_total_lent(*Data.get_total_lent()), notify_conf)
except Exception as ex:
ex.message = ex.message if ex.message else str(ex)
print("Error during summary notification: {0}".format(ex.message))
scheduler.enter(sleep_time, 1, notify_summary, (sleep_time, ))
def notify_new_loans(sleep_time):
global loans_provided
try:
new_provided = api.return_active_loans()['provided']
if loans_provided:
# function to return a set of ids from the api result
# get_id_set = lambda loans: set([x['id'] for x in loans])
def get_id_set(loans):
return set([x['id'] for x in loans])
loans_amount = {}
loans_info = {}
for loan_id in get_id_set(new_provided) - get_id_set(loans_provided):
loan = [x for x in new_provided if x['id'] == loan_id][0]
# combine loans with the same rate
k = 'c' + loan['currency'] + 'r' + loan['rate'] + 'd' + str(loan['duration'])
loans_amount[k] = float(loan['amount']) + (loans_amount[k] if k in loans_amount else 0)
loans_info[k] = loan
# send notifications with the grouped info
for k, amount in loans_amount.iteritems():
loan = loans_info[k]
t = "{0} {1} loan filled for {2} days at a rate of {3:.4f}%"
text = t.format(amount, loan['currency'], loan['duration'], float(loan['rate']) * 100)
log.notify(text, notify_conf)
loans_provided = new_provided
except Exception as ex:
ex.message = ex.message if ex.message else str(ex)
print("Error during new loans notification: {0}".format(ex.message))
scheduler.enter(sleep_time, 1, notify_new_loans, (sleep_time, ))
def get_min_loan_size(currency):
if currency not in min_loan_sizes:
return min_loan_size
return Decimal(min_loan_sizes[currency])
def create_lend_offer(currency, amt, rate):
days = '2'
if float(rate) > 0.0001:
rate = float(rate) - 0.000001 # lend offer just bellow the competing one
amt = "%.8f" % Decimal(amt)
if xday_threshold > 0:
if float(rate) >= xday_threshold:
days = xdays
elif xday_spread and xday_spread > 0:
xday_threshold_min = xday_threshold / xday_spread
if float(rate) > xday_threshold_min:
m = (float(xdays) - 2) / (xday_threshold - xday_threshold_min)
days = str(int(round(m * (float(rate) - xday_threshold_min) + 2)))
if Config.has_option('BOT', 'endDate'):
days_remaining = int(Data.get_max_duration(end_date, "order"))
if int(days_remaining) <= 2:
print "endDate reached. Bot can no longer lend.\nExiting..."
log.log("The end date has almost been reached and the bot can no longer lend. Exiting.")
log.refreshStatus(Data.stringify_total_lent(*Data.get_total_lent()), Data.get_max_duration(
end_date, "status"))
log.persistStatus()
exit(0)
if int(days) > days_remaining:
days = str(days_remaining)
if not dry_run:
msg = api.create_loan_offer(currency, amt, days, 0, rate)
if days == xdays and notify_conf['notify_xday_threshold']:
text = "{0} {1} loan placed for {2} days at a rate of {3:.4f}%".format(amt, currency, days, rate * 100)
log.notify(text, notify_conf)
log.offer(amt, currency, rate, days, msg)
def cancel_all():
loan_offers = api.return_open_loan_offers()
available_balances = api.return_available_account_balances('lending')
for CUR in loan_offers:
if CUR in coin_cfg and coin_cfg[CUR]['maxactive'] == 0:
# don't cancel disabled coin
continue
if keep_stuck_orders:
lending_balances = available_balances['lending']
if isinstance(lending_balances, dict) and CUR in lending_balances:
cur_sum = float(available_balances['lending'][CUR])
else:
cur_sum = 0
for offer in loan_offers[CUR]:
cur_sum += float(offer['amount'])
else:
cur_sum = float(get_min_loan_size(CUR)) + 1
if cur_sum >= float(get_min_loan_size(CUR)):
for offer in loan_offers[CUR]:
if not dry_run:
try:
msg = api.cancel_loan_offer(CUR, offer['id'])
log.cancelOrder(CUR, msg)
except Exception as ex:
ex.message = ex.message if ex.message else str(ex)
log.log("Error canceling loan offer: {0}".format(ex.message))
else:
print "Not enough " + CUR + " to lend if bot canceled open orders. Not cancelling."
def lend_all():
global sleep_time # We need global var to edit sleeptime
if gap_mode_default == "rawbtc":
ticker = api.return_ticker() # Only call ticker once for all orders
else:
ticker = False
for cur1 in coin_cfg:
if "rawbtc" in cur1:
ticker = api.return_ticker()
break
global currentCancelRoundTurn
currentCancelRoundTurn = currentCancelRoundTurn + 1
if currentCancelRoundTurn > cancel_at_round_turn:
cancel_all()
currentCancelRoundTurn = 1
total_lent = Data.get_total_lent()[0]
lending_balances = api.return_available_account_balances("lending")['lending']
if dry_run: # just fake some numbers, if dryrun (testing)
lending_balances = Data.get_on_order_balances()
# Fill the (maxToLend) balances on the botlog.json for display it on the web
for cur in sorted(total_lent):
if len(lending_balances) == 0 or cur not in lending_balances:
MaxToLend.amount_to_lend(total_lent[cur], cur, 0, 0)
usable_currencies = 0
try:
for cur in lending_balances:
if cur in all_currencies:
usable_currencies += lend_cur(cur, total_lent, lending_balances, ticker)
except StopIteration: # Restart lending if we stop to raise the request limit.
lend_all()
set_sleep_time(usable_currencies)
def get_frr_or_min_daily_rate(cur):
"""
Checks the Flash Return Rate of cur against the min daily rate and returns the better of the two. If not using
bitfinex then it will always return the min daily rate for the currency.
:param cur: The currency which to check
:return: The better of the two rates (FRR and min daily rate)
"""
if cur in coin_cfg:
min_daily_rate = Decimal(coin_cfg[cur]['minrate'])
frrasmin = coin_cfg[cur]['frrasmin']
frrdelta = Decimal(coin_cfg[cur]['frrdelta']) / 100
else:
min_daily_rate = Decimal(Config.get("BOT", "mindailyrate", None, 0.003, 5)) / 100
frrasmin = Config.getboolean('BOT', 'frrasmin', False)
frrdelta = Decimal(Config.get('BOT', 'frrdelta', 0.0000))
if exchange == 'BITFINEX' and frrasmin:
frr_rate = Decimal(api.get_frr(cur)) + frrdelta
if frr_rate > min_daily_rate:
log.log("Using FRR as mindailyrate {0}% for {1}".format(frr_rate * 100, cur))
return frr_rate
return min_daily_rate
def get_min_daily_rate(cur):
cur_min_daily_rate = get_frr_or_min_daily_rate(cur)
if cur in coin_cfg:
if coin_cfg[cur]['maxactive'] == 0:
if cur not in max_active_alerted: # Only alert once per coin.
max_active_alerted[cur] = True
log.log('maxactive amount for ' + cur + ' set to 0, won\'t lend.')
return False
if cur not in coin_cfg_alerted: # Only alert once per coin.
coin_cfg_alerted[cur] = True
log.log('Using custom mindailyrate ' + str(cur_min_daily_rate * 100) + '% for ' + cur)
if Analysis and cur in currencies_to_analyse:
recommended_min = Analysis.get_rate_suggestion(cur, method=analysis_method)
if cur_min_daily_rate < recommended_min:
log.log("Using {0} as mindailyrate {1}% for {2}".format(analysis_method, recommended_min * 100, cur))
cur_min_daily_rate = recommended_min
return Decimal(cur_min_daily_rate)
def construct_order_book(active_cur):
# make sure we have a request limit for this currency
if active_cur not in loanOrdersRequestLimit:
loanOrdersRequestLimit[active_cur] = defaultLoanOrdersRequestLimit
loans = api.return_loan_orders(active_cur, loanOrdersRequestLimit[active_cur])
if len(loans) == 0:
return False
rate_book = []
volume_book = []
for offer in loans['offers']:
rate_book.append(offer['rate'])
volume_book.append(offer['amount'])
return {'rates': rate_book, 'volumes': volume_book}
def get_gap_rate(active_cur, gap, order_book, cur_total_balance, raw=False):
if raw:
gap_expected = gap
else:
gap_expected = gap * cur_total_balance / Decimal(100.0)
gap_sum = 0
i = 0
while gap_sum < gap_expected:
if i == len(order_book['volumes']) - 1 and len(order_book['volumes']) == loanOrdersRequestLimit[active_cur]:
loanOrdersRequestLimit[active_cur] += increaseLoanOrdersRequestLimit
log.log(active_cur + ': Not enough offers in response, adjusting request limit to ' + str(
loanOrdersRequestLimit[active_cur]))
raise StopIteration
elif i == len(order_book['volumes']) - 1:
return max_daily_rate
gap_sum += float(order_book['volumes'][i])
i += 1
return Decimal(order_book['rates'][i])
def get_cur_spread(spread, cur_active_bal, active_cur):
cur_spread_lend = int(spread) # Checks if active_bal can't be spread that many times, and may go down to 1.
cur_min_loan_size = get_min_loan_size(active_cur)
while cur_active_bal < (cur_spread_lend * cur_min_loan_size):
cur_spread_lend -= 1
return int(cur_spread_lend)
def construct_orders(cur, cur_active_bal, cur_total_balance, ticker):
cur_spread = get_cur_spread(spread_lend, cur_active_bal, cur)
top_rate, bottom_rate = get_gap_mode_rates(cur, cur_active_bal, cur_total_balance, ticker)
gap_diff = top_rate - bottom_rate
if cur_spread == 1:
rate_step = 0
else:
rate_step = gap_diff / (cur_spread - 1)
order_rates = []
i = 0
while i < cur_spread:
new_rate = bottom_rate + (rate_step * i)
order_rates.append(new_rate)
i += 1
# Condensing and logic'ing time
for rate in order_rates:
if rate > max_daily_rate:
order_rates.remove(rate)
order_rates.append(max_daily_rate)
new_order_rates = sorted(list(set(order_rates)))
new_order_amounts = []
i = 0
while i < len(new_order_rates):
new_amount = Data.truncate(cur_active_bal / len(new_order_rates), 8)
new_order_amounts.append(Decimal(new_amount))
i += 1
remainder = cur_active_bal - sum(new_order_amounts)
if remainder > 0: # If truncating causes remainder, add that to first order.
new_order_amounts[0] += remainder
return {'amounts': new_order_amounts, 'rates': new_order_rates}
def get_gap_mode_rates(cur, cur_active_bal, cur_total_balance, ticker):
global gap_mode_default, gap_bottom_default, gap_top_default # To be able to change them later if needed.
gap_mode, gap_bottom, gap_top = gap_mode_default, gap_bottom_default, gap_top_default
use_gap_cfg = False
order_book = construct_order_book(cur)
if cur in coin_cfg: # Get custom values specific to coin
cfg = coin_cfg[cur]
if cfg.get('gapmode', False) and cfg.get('gapbottom', False) and cfg.get('gaptop', False):
# Only overwrite default if all three are set
use_gap_cfg = True
gap_mode = cfg['gapmode']
gap_bottom = cfg['gapbottom']
gap_top = cfg['gaptop']
if gap_mode == "rawbtc":
btc_value = 1
if cur != 'BTC':
for coin in ticker:
if coin == 'BTC_' + str(cur).upper():
btc_value = Decimal(ticker[coin]['last'])
break
bottom_depth = gap_bottom / btc_value # Converts from BTC to altcoin's value
bottom_rate = get_gap_rate(cur, bottom_depth, order_book, cur_total_balance, True)
top_depth = gap_top / btc_value
top_rate = get_gap_rate(cur, top_depth, order_book, cur_total_balance, True)
elif gap_mode == "raw": # Value stays in altcoin
bottom_rate = get_gap_rate(cur, gap_bottom, order_book, cur_total_balance, True)
top_rate = get_gap_rate(cur, gap_top, order_book, cur_total_balance, True)
elif gap_mode == "relative":
bottom_rate = get_gap_rate(cur, gap_bottom, order_book, cur_total_balance)
top_rate = get_gap_rate(cur, gap_top, order_book, cur_total_balance)
else:
if use_gap_cfg:
print "WARN: Invalid setting for gapMode for [%s], using defaults..." % cur
coin_cfg[cur]['gapmode'] = "rawbtc"
coin_cfg[cur]['gapbottom'] = 10
coin_cfg[cur]['gaptop'] = 100
else:
print "WARN: Invalid setting for gapMode, using defaults..."
gap_mode_default = "relative"
gap_bottom_default = 10
gap_top_default = 200
return get_gap_mode_rates(cur, cur_active_bal, cur_total_balance, ticker) # Start over with new defaults
return [Decimal(top_rate), Decimal(bottom_rate)]
def lend_cur(active_cur, total_lent, lending_balances, ticker):
active_cur_total_balance = Decimal(lending_balances[active_cur])
if active_cur in total_lent:
active_cur_total_balance += Decimal(total_lent[active_cur])
# min daily rate can be changed per currency
cur_min_daily_rate = get_min_daily_rate(active_cur)
# log total coin
log.updateStatusValue(active_cur, "totalCoins", (Decimal(active_cur_total_balance)))
order_book = construct_order_book(active_cur)
if not order_book or len(order_book['rates']) == 0 or not cur_min_daily_rate:
return 0
active_bal = MaxToLend.amount_to_lend(active_cur_total_balance, active_cur, Decimal(lending_balances[active_cur]),
Decimal(order_book['rates'][0]))
if float(active_bal) >= get_min_loan_size(active_cur): # Make sure sleeptimer is set to active if any cur can lend.
currency_usable = 1
else:
return 0 # Return early to end function.
orders = construct_orders(active_cur, active_bal, active_cur_total_balance, ticker) # Build all potential orders
i = 0
while i < len(orders['amounts']): # Iterate through prepped orders and create them if they work
below_min = Decimal(orders['rates'][i]) < Decimal(cur_min_daily_rate)
if hide_coins and below_min:
log.log("Not lending {:s} due to rate below {:.4f}% (actual: {:.4f}%)"
.format(active_cur, (cur_min_daily_rate * 100), (orders['rates'][i] * 100)))
return 0
elif below_min:
rate = str(cur_min_daily_rate)
else:
rate = orders['rates'][i]
try:
create_lend_offer(active_cur, orders['amounts'][i], rate)
except Exception as msg:
if "Amount must be at least " in str(msg):
import re
results = re.findall('[-+]?([0-9]*\.[0-9]+|[0-9]+)', str(msg))
for result in results:
if result:
min_loan_sizes[active_cur] = float(result)
log.log(active_cur + "'s min_loan_size has been increased to the detected min: " + result)
return lend_cur(active_cur, total_lent, lending_balances, ticker) # Redo cur with new min.
else:
raise msg
i += 1 # Finally, move to next order.
return currency_usable
def transfer_balances():
# Transfers all balances on the included list to Lending.
if len(transferable_currencies) > 0:
exchange_balances = api.return_balances() # This grabs only exchange balances.
for coin in transferable_currencies:
if coin in exchange_balances and Decimal(
exchange_balances[coin]) > 0:
msg = api.transfer_balance(coin, exchange_balances[coin], 'exchange', 'lending')
log.log(log.digestApiMsg(msg))
log.notify(log.digestApiMsg(msg), notify_conf)
if coin not in exchange_balances:
print "WARN: Incorrect coin entered for transferCurrencies: " + coin
transferable_currencies.remove(coin)
|
reactivebebop.py
|
import numpy
import threading
import time
import roslib
try:
roslib.load_manifest('TFG-Bebop-YOLO')
except:
pass
import rospy
from std_msgs.msg import Empty
from std_msgs.msg import Bool
from geometry_msgs.msg import Twist
from bebop_msgs.msg import CommonCommonStateBatteryStateChanged as Battery
import termios
import sys, tty
#-- Lectura inmediata por teclado
def getch():
def _getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
return _getch()
class ReactiveBebop:
def print_help(self, h_type):
if h_type==0: # Ayuda para menu
print('\n\n\n\
[0] Modo manual \n\
[1] Seleccionar target video principal (solo funciona en modo automatico)\n\
[2] Seleccionar target video secundario \n\
[3] Seleccionar velocidad [0.0 - 1.0]\n\
[4] Empezar/Parar grabacion\n\
[5] Mostrar % bateria\n\
[p] Parada de emergencia\n\
[q] Salir del programa\n\
[h] Help\n\
\n\n\n')
elif h_type==1: # Ayuda para movimiento
print('\n\n\n\
[ ] Despega\n\
[l] Aterrizar\n\
[w] Avanza\n\
[a] Desplaza izda\n\
[s] Retrocede\n\
[d] Desplaza dcha\n\
[8] Asciende\n\
[4] Gira izda\n\
[6] Gira dcha\n\
[2] Desciende\n\
[5] Para\n\
[e] Exit. Modo auto\n\
[p] Parada de emergencia\n\
[h] Help\n\
\n\n\n')
def __init__(self, res, target=None, tracks=[], current_track=None):
self.target = target #id_track
self.tracks = tracks
self.current_track = current_track
self.cam_tracks = []
self.current_cam_track = None
self.min_x = 0.4*res[0]
self.max_x = 0.6*res[0]
self.min_y = 0.4*res[1]
self.max_y = 0.6*res[1]
self.auto = True
self.t_menu = True
self.vel_av = 0.1
self.vel_giro = 0.07
self.min_height = 60.0
self.max_height = 80.0
self.record = False
self.show_battery = False
self.battery = 'unknown'
self.aux=0
#-- Topics
self.takeoff_pub = rospy.Publisher('/bebop/takeoff',Empty, queue_size=10)
self.land_pub = rospy.Publisher('/bebop/land', Empty, queue_size=10)
self.reset_pub = rospy.Publisher('/bebop/reset', Empty, queue_size=10)
self.move_pub = rospy.Publisher('/bebop/cmd_vel', Twist, queue_size=10)
self.video_pub = rospy.Publisher('/bebop/record', Bool, queue_size=10)
self.battery_sub = rospy.Subscriber('/bebop/states/common/CommonState/BatteryStateChanged',Battery,self.battery_callback)
def battery_callback(self, data):
if not self.show_battery:
self.battery = str(data).split(' ')[-1]
def update_tracks(self, confirmed_tracks):
self.tracks=confirmed_tracks
def update_cam_tracks(self, confirmed_tracks):
self.cam_tracks=confirmed_tracks
if self.current_cam_track<>None:
if self.current_cam_track.state<>2:
self.move([' '])
self.current_cam_track=None
def update_target(self, target):
self.target=target
def move(self, moves=[]):
msg=Twist()
msg.linear.z = 0
msg.angular.z = 0
msg.linear.x = 0
msg.linear.y = 0
for move in moves:
if move==' ': # despegar
self.takeoff_pub.publish(Empty())
#print('move: '+move)
elif move=='l': # aterrizar
self.land_pub.publish(Empty())
#print('move: '+move)
elif move=='w': # avanzar
msg.linear.x = self.vel_av
#print('move: '+move)
elif move=='a': # desplazar a la izda
msg.linear.y = self.vel_av
#print('move: '+move)
elif move=='s': # retroceder
msg.linear.x = -self.vel_av
#print('move: '+move)
elif move=='d': # desplazar a la derecha
msg.linear.y = -self.vel_av
#print('move: '+move)
elif move=='8': # ascender
msg.linear.z = self.vel_giro
#print('move: '+move)
elif move=='4': # rotar izda
msg.angular.z = self.vel_giro
#print('move: '+move)
elif move=='6': # rotar dcha
msg.angular.z = -self.vel_giro
#print('move: '+move)
elif move=='2': # descender
msg.linear.z = -self.vel_giro
#print('move: '+move)
elif move=='5': # para
msg.linear.z = 0
#print('move: '+move)
msg.angular.z = 0
msg.linear.x = 0
msg.linear.y = 0
elif move=='e': # cambiar de modo
self.auto=True
#print('move: '+move)
self.print_help(0)
elif move=='p': # parada de emergencia
self.reset_pub.publish(Empty())
#print('move: '+move)
elif move=='h': # ayuda
self.print_help(1)
#print('move: '+move)
# Si no mandamos un mensaje cada 0.1s
# el dron detecta que hay un error
# y se mantiene estatico
if moves:
self.move_pub.publish(msg)
def follow_target(self):
#time.sleep(3) # Damos tiempo a que carguen el resto de hebras
it=0
while(self.auto):
moves=[]
if self.current_track != None:
if self.current_track.state == 2:
minx, miny, maxx, maxy = self.current_track.to_tlbr()
centroid = (int(minx+maxx/2),int(miny+maxy/2))
h = maxy-miny
w = maxx-minx
if centroid[0] < self.min_x:
moves.append('4')
elif centroid[0] > self.max_x:
moves.append('6')
"""
if centroid[1] < self.min_y:
moves.append('8')
elif centroid[1] > self.max_y:
moves.append('2')
"""
if h < self.min_height:
moves.append('w')
elif h > self.max_height:
moves.append('s')
if not moves:
moves.append('5')
else: #Si hemos perdido el track
if it==1:
it=-1
moves.append('w')
else:
moves.append('4')
it+=1
self.move(moves)
def menu(self, option):
print(option)
if option=='0': # modo manual
self.auto = False
try:
if self.follow_thread.is_alive():
self.follow_thread.join()
except: pass
c=''
self.print_help(1) # Imprime ayuda movimiento
while(c!='e'):
c=getch()
try:
self.move([c]) # Realiza movimiento
except:
print('Tecla no valida')
self.move('h')
elif option=='1': # Seleccion de target
ids = [t.track_id for t in self.tracks]
print('\'-1\'Exit.\n Select target: ')
try:
new_target = input()
except:
new_target = -2
while( (not new_target in ids) and new_target != -1):
print('Bad Target. Select one of this: ')
ids = [t.track_id for t in self.tracks]
print(ids)
print('\'-1\'Exit.\n Select target: ')
try:
new_target = input()
except:
new_target = -2
if new_target != -1:
self.auto = True
try:
self.follow_thread = threading.Thread(target=self.follow_target, args=())
self.follow_thread.daemon=True
self.follow_thread.start()
except:
pass
self.target = new_target
self.current_track = [tr for tr in self.tracks if tr.track_id==new_target][0]
print('Target Updated')
elif option=='2': # Seleccion de target
if self.cam_tracks!=[]:
ids = [t.track_id for t in self.cam_tracks]
print('\'-1\'Exit.\n Select target: ')
try:
new_target = input()
except:
new_target = -2
while( (not new_target in ids) and new_target != -1):
print('Bad Target. Select one of this: ')
ids = [t.track_id for t in self.cam_tracks]
print(ids)
print('\'-1\'Exit.\n Select target: ')
try:
new_target = input()
except:
new_target = -2
if new_target != -1:
self.current_cam_track = [tr for tr in self.cam_tracks if tr.track_id==new_target][0]
print('Target Updated')
else:
print('No hay video secundario o bien no se han detectado tracks en el\n')
elif option=='3': # Seleccion de velocidad
print('Velocidad actual de giro: '+str(self.vel_giro)+'\nIndique nueva velocidad [0.0 - 1.0]: ')
try:
v = input()
if v>=0 and v<=1:
self.vel_giro = v
print('Velocidad actualizada')
else:
print('Velocidad fuera de los limites')
except:
print('Error en la entrada de velocidad')
print('Velocidad lineal actual: '+str(self.vel_av)+'\nIndique nueva velocidad [0.0 - 1.0]: ')
try:
v = input()
if v>=0 and v<=1:
self.vel_av = v
print('Velocidad actualizada')
else:
print('Velocidad fuera de los limites')
except:
print('Error en la entrada de velocidad')
elif option=='4': # Empezar/Parar grabacion
if not self.record:
self.record = True
self.video_pub.publish(True)
print('Ha comenzado la grabacion\n')
else:
self.record = False
self.video_pub.publish(False)
print('Se ha detenido la grabacion\n')
elif option=='5': # Mostrar % bateria
self.show_battery = True
print('Bateria: '+self.battery+'%')
self.show_battery = False
elif option=='p': # Parada de emergencia
self.move([option])
if self.follow_thread.is_alive():
self.follow_thread.join(0.0)
elif option=='h': # Parada de emergencia
self.print_help(0)
def show_menu(self):
self.print_help(0)
def select_menu(self):
while self.menu:
option = getch()
if (option=='0' or option=='1' or option=='2'
or option=='3' or option=='4' or option=='5' or option=='p'
or option=='h'):
self.menu(option)
if option=='q': break
def menu_alive(self):
return self.menu_thread.is_alive()
def start(self):
self.menu_thread = threading.Thread(target=self.select_menu, args=())
self.menu_thread.daemon=True
self.menu_thread.start()
def stop(self):
self.auto=False
try:
if self.follow_thread.is_alive():
self.follow_thread.join()
except:
pass
self.t_menu=False
if self.menu_thread.is_alive():
self.menu_thread.join()
|
test_async.py
|
# -*- coding: utf-8 -*-
import unittest
import subprocess
import threading
import trytond.tests.test_tryton
from trytond.tests.test_tryton import activate_module, with_transaction
from trytond.pool import Pool
class Command(object):
"""
Wrapper around subprocess to execute on a different thread and use the
threads timeout capability to effect a timeout.
"""
def __init__(self, cmd):
self.cmd = cmd
self.process = None
def run(self, timeout=30):
def target():
print('Thread started')
self.process = subprocess.Popen(self.cmd, shell=True)
self.process.communicate()
print('Thread finished')
thread = threading.Thread(target=target)
thread.start()
thread.join(timeout)
if thread.is_alive():
print('Terminating process')
self.process.terminate()
thread.join()
print(self.process.returncode)
class TestAsync(unittest.TestCase):
'''
Test Async
'''
def setUp(self):
"""
Set up data used in the tests.
this method is called before each test function execution.
"""
activate_module('async')
@with_transaction()
def test0005_test_apply_async(self):
"""Test apply async method.
"""
View = Pool().get('ir.ui.view')
Async = Pool().get('async.async')
expected = View.search_read([])
result = Async.apply_async(
method='search_read', model=View.__name__,
args=[[]],
)
# Will be pending because there is no worker running
self.assertEqual(result.status, 'PENDING')
# Now launch the worker and kill it after 15 seconds
command = Command('celery -l info -A trytond_async.tasks worker')
command.run(15)
# Now the task should be done. So check status and the
# returned value to make sure its what we need.
self.assertEqual(result.status, 'SUCCESS')
self.assertEqual(result.result, expected)
@with_transaction()
def test0006_test_apply_async_ar(self):
"""Test apply async method. But move around active records.
"""
View = Pool().get('ir.ui.view')
Async = Pool().get('async.async')
expected = View.search([])
result = Async.apply_async(
method='search', model=View.__name__,
args=[[]],
)
# Will be pending because there is no worker running
self.assertEqual(result.status, 'PENDING')
# Now launch the worker and kill it after 15 seconds
command = Command('celery -l info -A trytond_async.tasks worker')
command.run(15)
# Now the task should be done. So check status and the
# returned value to make sure its what we need.
self.assertEqual(result.status, 'SUCCESS')
self.assertEqual(result.result, expected)
def suite():
"""
Define suite
"""
test_suite = trytond.tests.test_tryton.suite()
test_suite.addTests(
unittest.TestLoader().loadTestsFromTestCase(TestAsync)
)
return test_suite
if __name__ == '__main__':
unittest.TextTestRunner(verbosity=2).run(suite())
|
variable_scope_test.py
|
# Copyright 2015 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 variable store."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import gc
import threading
import numpy
from tensorflow.python.eager import context
from tensorflow.python.eager import function
from tensorflow.python.eager import wrap_function
from tensorflow.python.framework import constant_op
from tensorflow.python.framework import dtypes
from tensorflow.python.framework import errors
from tensorflow.python.framework import ops
from tensorflow.python.framework import test_util
from tensorflow.python.layers import core as core_layers
from tensorflow.python.ops import array_ops
from tensorflow.python.ops import control_flow_ops
from tensorflow.python.ops import init_ops
from tensorflow.python.ops import math_ops
from tensorflow.python.ops import resource_variable_ops
from tensorflow.python.ops import state_ops
from tensorflow.python.ops import variable_scope
from tensorflow.python.ops import variables as variables_lib
from tensorflow.python.platform import test
from tensorflow.python.util import compat
from tensorflow.python.util import tf_inspect
def run_inside_wrap_function_in_eager_mode(graph_function):
"""Decorator to execute the same graph code in eager and graph modes.
In graph mode, we just execute the graph_function passed as argument. In eager
mode, we wrap the function using wrap_function and then execute the wrapped
result.
Args:
graph_function: python function containing graph code to be wrapped
Returns:
decorated function
"""
def wrap_and_execute(self):
if context.executing_eagerly():
wrapped = wrap_function.wrap_function(graph_function, [self])
# use the wrapped graph function
wrapped()
else:
# use the original function
graph_function(self)
return wrap_and_execute
class VariableScopeTest(test.TestCase):
def tearDown(self):
gc.collect()
# This will only contain uncollectable garbage, i.e. reference cycles
# involving objects with __del__ defined.
self.assertEqual(0, len(gc.garbage))
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testGetVar(self):
vs = variable_scope._get_default_variable_store()
v = vs.get_variable("v", [1])
v1 = vs.get_variable("v", [1])
self.assertIs(v, v1)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testResource(self):
vs = variable_scope._get_default_variable_store()
v1 = vs.get_variable("v", [1], use_resource=True)
self.assertTrue(isinstance(v1, resource_variable_ops.ResourceVariable))
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testNameExists(self):
vs = variable_scope._get_default_variable_store()
# No check by default, so we can both create and get existing names.
v = vs.get_variable("v", [1])
v1 = vs.get_variable("v", [1])
self.assertIs(v, v1)
# When reuse is False, we fail when variables are already there.
vs.get_variable("w", [1], reuse=False) # That's ok.
with self.assertRaises(ValueError):
vs.get_variable("v", [1], reuse=False) # That fails.
# When reuse is True, we fail when variables are new.
vs.get_variable("v", [1], reuse=True) # That's ok.
with self.assertRaises(ValueError):
vs.get_variable("u", [1], reuse=True) # That fails.
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testNamelessStore(self):
vs = variable_scope._get_default_variable_store()
vs.get_variable("v1", [2])
vs.get_variable("v2", [2])
expected_names = ["%s:0" % name for name in ["v1", "v2"]]
self.assertEqual(
set(expected_names), set([v.name for v in vs._vars.values()]))
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# TypeError: Expected tf.group() expected Tensor arguments not 'None' with
# type '<type 'NoneType'>'
@test_util.run_in_graph_and_eager_modes
def testVarScopeInitializer(self):
init = init_ops.constant_initializer(0.3)
with variable_scope.variable_scope("tower0") as tower:
with variable_scope.variable_scope("foo", initializer=init):
v = variable_scope.get_variable("v", [])
self.evaluate(variables_lib.variables_initializer([v]))
self.assertAllClose(self.evaluate(v.value()), 0.3)
with variable_scope.variable_scope(tower, initializer=init):
w = variable_scope.get_variable("w", [])
self.evaluate(variables_lib.variables_initializer([w]))
self.assertAllClose(self.evaluate(w.value()), 0.3)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeConstraint(self):
constraint = lambda x: 0. * x
with variable_scope.variable_scope("tower1") as tower:
with variable_scope.variable_scope("foo", constraint=constraint):
v = variable_scope.get_variable("v", [])
self.assertEqual(v.constraint, constraint)
with variable_scope.variable_scope(tower, constraint=constraint):
w = variable_scope.get_variable("w", [])
self.assertEqual(w.constraint, constraint)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeNestingError(self):
with variable_scope.variable_scope("aa"):
scope = variable_scope.variable_scope("bb")
scope.__enter__()
with variable_scope.variable_scope("cc"):
with self.assertRaises(RuntimeError):
scope.__exit__(None, None, None)
scope.__exit__(None, None, None)
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# TypeError: Fetch argument <tf.Variable 'string:0' shape=() dtype=string>
# has invalid type <class '...ResourceVariable'>, must be a string or Tensor.
# (Can not convert a ResourceVariable into a Tensor or Operation.)
@test_util.run_deprecated_v1
def testStringDefaultInitializer(self):
with self.cached_session():
v = variable_scope.get_variable("string", shape=[], dtype=dtypes.string)
variables_lib.global_variables_initializer().run()
self.assertAllEqual(compat.as_bytes(self.evaluate(v)), b"")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeDType(self):
with variable_scope.variable_scope("tower2") as tower:
with variable_scope.variable_scope("foo", dtype=dtypes.float16):
v = variable_scope.get_variable("v", [])
self.assertEqual(v.dtype.base_dtype, dtypes.float16)
with variable_scope.variable_scope(tower, dtype=dtypes.float16):
w = variable_scope.get_variable("w", [])
self.assertEqual(w.dtype.base_dtype, dtypes.float16)
def testGetVariableInGraphNestedUnderEagerContext(self):
with context.eager_mode():
@function.defun
def f():
v = variable_scope.get_variable("should_be_resource", [])
self.assertEqual(type(v), resource_variable_ops.ResourceVariable)
f()
def testEagerVariableStore(self):
with context.eager_mode():
store = variable_scope.EagerVariableStore()
with store.as_default():
v = variable_scope.get_variable("v", shape=(), trainable=True)
w = variable_scope.get_variable("w", shape=(), trainable=False)
self.assertTrue(v in store.variables())
self.assertTrue(w in store.variables())
self.assertTrue(v in store.trainable_variables())
self.assertFalse(w in store.trainable_variables())
self.assertFalse(v in store.non_trainable_variables())
self.assertTrue(w in store.non_trainable_variables())
# Test copying.
new_store = store.copy()
with new_store.as_default():
new_v = variable_scope.get_variable("v")
new_w = variable_scope.get_variable("w")
self.assertEqual(new_v.numpy(), v.numpy())
self.assertEqual(new_w.numpy(), w.numpy())
self.assertTrue(new_v in new_store.variables())
self.assertTrue(new_w in new_store.variables())
self.assertTrue(new_v in new_store.trainable_variables())
self.assertFalse(new_w in new_store.trainable_variables())
self.assertFalse(new_v in new_store.non_trainable_variables())
self.assertTrue(new_w in new_store.non_trainable_variables())
# Check that variables are separate instances.
for v in store.variables():
v.assign(-1)
for v in new_store.variables():
v.assign(1)
for v in store.variables():
self.assertEqual(v.numpy(), -1)
for v in new_store.variables():
self.assertEqual(v.numpy(), 1)
def testEagerVariableStoreWithEagerDefun(self):
with context.eager_mode():
@function.defun
def f():
x = constant_op.constant([[2.0]])
d1 = core_layers.Dense(
1, name="my_dense", kernel_initializer=init_ops.ones_initializer())
_ = d1(x) # create variables
self.assertEqual(len(d1.variables), 2)
v1, v2 = d1.variables
d2 = core_layers.Dense(
1,
name="my_dense",
kernel_initializer=init_ops.ones_initializer(),
_reuse=True)
_ = d2(x)
self.assertEqual(len(d2.variables), 2)
v3, v4 = d2.variables
self.assertIs(v1, v3)
self.assertIs(v2, v4)
f()
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_in_graph_and_eager_modes
def testEagerVariablesStoreAddsToCollections(self):
store = variable_scope.EagerVariableStore()
with store.as_default():
trainable = variable_scope.get_variable("v1", [], trainable=True)
not_trainable = variable_scope.get_variable("v2", [], trainable=False)
concat = variable_scope.get_variable(
"v3", [], collections=[ops.GraphKeys.CONCATENATED_VARIABLES])
self.assertEqual(
ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES),
[trainable, not_trainable])
self.assertEqual(
ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES),
[trainable, concat])
self.assertEqual(
ops.get_collection(ops.GraphKeys.CONCATENATED_VARIABLES), [concat])
def testEagerVariablesOutsideStoreNotAddedToCollections(self):
with context.eager_mode():
variable_scope.get_variable("v1", [], trainable=True)
variable_scope.get_variable("v2", [], trainable=False)
self.assertFalse(ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES))
self.assertFalse(ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES))
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# TypeError: Expected tf.group() expected Tensor arguments not 'None' with
# type '<type 'NoneType'>'.
@test_util.run_in_graph_and_eager_modes
def testInitFromNonTensorValue(self):
v = variable_scope.get_variable("v4", initializer=4, dtype=dtypes.int32)
self.evaluate(variables_lib.variables_initializer([v]))
self.assertAllClose(self.evaluate(v.value()), 4)
w = variable_scope.get_variable(
"w4", initializer=numpy.array([1, 2, 3]), dtype=dtypes.int64)
self.evaluate(variables_lib.variables_initializer([w]))
self.assertAllClose(self.evaluate(w.value()), [1, 2, 3])
# A quirk to be revisited?
error = ValueError if context.executing_eagerly() else TypeError
with self.assertRaises(error):
variable_scope.get_variable("x4", initializer={})
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# InvalidArgumentError=: You must feed a value for placeholder tensor
# 'ReadVariableOp/resource' with dtype resource
@test_util.run_in_graph_and_eager_modes
def testInitFromNonInitializer(self):
# Test various dtypes with zeros initializer as following:
types = [
dtypes.int8, dtypes.uint8, dtypes.int16, dtypes.uint16, dtypes.int32,
dtypes.int64, dtypes.bool
]
# Use different variable_name to distinguish various dtypes
for (i, dtype) in enumerate(types):
x = variable_scope.get_variable(
name="xx%d" % i, shape=(3, 4), dtype=dtype)
y = variable_scope.get_variable(
name="yy%d" % i,
shape=(3, 4),
dtype=dtype,
initializer=init_ops.zeros_initializer(dtype=dtype))
self.evaluate(variables_lib.global_variables_initializer())
self.assertAllEqual(self.evaluate(x.value()), self.evaluate(y.value()))
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# InvalidArgumentError: /job:moo/replica:0/task:0/device:CPU:0 unknown device.
@test_util.run_deprecated_v1
def testVarScopeCachingDevice(self):
with self.cached_session():
caching_device = "/job:moo"
with variable_scope.variable_scope("tower"):
with variable_scope.variable_scope(
"caching", caching_device=caching_device):
v = variable_scope.get_variable("v", [])
self.assertTrue(v.value().device.startswith(caching_device))
with variable_scope.variable_scope("child"):
v2 = variable_scope.get_variable("v", [])
self.assertTrue(v2.value().device.startswith(caching_device))
with variable_scope.variable_scope("not_cached", caching_device=""):
v2_not_cached = variable_scope.get_variable("v", [])
self.assertFalse(
v2_not_cached.value().device.startswith(caching_device))
with variable_scope.variable_scope(
"not_cached_identity_device",
caching_device=lambda op: op.device):
v2_identity_device = variable_scope.get_variable("v", [])
self.assertFalse(
v2_identity_device.value().device.startswith(caching_device))
with variable_scope.variable_scope("we_will_do_it_live") as vs_live:
vs_live.set_caching_device("/job:live")
v_live = variable_scope.get_variable("v", [])
self.assertTrue(v_live.value().device.startswith("/job:live"))
v_tower = variable_scope.get_variable("v", [])
self.assertFalse(v_tower.value().device.startswith(caching_device))
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# AttributeError: Tensor.name is meaningless when eager execution is enabled.
@test_util.run_in_graph_and_eager_modes
def testVarScopeRegularizer(self):
init = init_ops.constant_initializer(0.3)
def regularizer1(v):
return math_ops.reduce_mean(v) + 0.1
def regularizer2(v):
return math_ops.reduce_mean(v) + 0.2
with variable_scope.variable_scope(
"tower3", regularizer=regularizer1) as tower:
with variable_scope.variable_scope("foo", initializer=init):
v = variable_scope.get_variable("v", [])
self.evaluate(variables_lib.variables_initializer([v]))
losses = ops.get_collection(ops.GraphKeys.REGULARIZATION_LOSSES)
self.assertEqual(1, len(losses))
self.assertAllClose(self.evaluate(losses[0]), 0.4)
with variable_scope.variable_scope(tower, initializer=init) as vs:
u = variable_scope.get_variable("u", [])
vs.set_regularizer(regularizer2)
w = variable_scope.get_variable("w", [])
# Next 3 variable not regularized to test disabling regularization.
x = variable_scope.get_variable(
"x", [], regularizer=variable_scope.no_regularizer)
with variable_scope.variable_scope(
"baz", regularizer=variable_scope.no_regularizer):
y = variable_scope.get_variable("y", [])
vs.set_regularizer(variable_scope.no_regularizer)
z = variable_scope.get_variable("z", [])
# Check results.
losses = ops.get_collection(ops.GraphKeys.REGULARIZATION_LOSSES)
self.assertEqual(3, len(losses))
self.evaluate(variables_lib.variables_initializer([u, w, x, y, z]))
self.assertAllClose(self.evaluate(losses[0]), 0.4)
self.assertAllClose(self.evaluate(losses[1]), 0.4)
self.assertAllClose(self.evaluate(losses[2]), 0.5)
with variable_scope.variable_scope("foo", reuse=True):
# reuse=True is for now only supported when eager execution is disabled.
if not context.executing_eagerly():
v = variable_scope.get_variable("v",
[]) # "v" is already there, reused
losses = ops.get_collection(ops.GraphKeys.REGULARIZATION_LOSSES)
self.assertEqual(3, len(losses)) # No new loss added.
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# ValueError: Tensor-typed variable initializers must either be wrapped in an
# init_scope or callable...
@test_util.run_in_graph_and_eager_modes
def testInitializeFromValue(self):
init = constant_op.constant(0.1)
w = variable_scope.get_variable("v", initializer=init)
self.evaluate(variables_lib.variables_initializer([w]))
self.assertAllClose(self.evaluate(w.value()), 0.1)
with self.assertRaisesRegexp(ValueError, "shape"):
# We disallow explicit shape specification when initializer is constant.
variable_scope.get_variable("u", [1], initializer=init)
with variable_scope.variable_scope("foo", initializer=init):
# Constant initializer can be passed through scopes if needed.
v = variable_scope.get_variable("v")
self.evaluate(variables_lib.variables_initializer([v]))
self.assertAllClose(self.evaluate(v.value()), 0.1)
# Check that non-float32 initializer creates a non-float32 variable.
init = constant_op.constant(1, dtype=dtypes.int32)
t = variable_scope.get_variable("t", initializer=init)
self.assertEqual(t.dtype.base_dtype, dtypes.int32)
# Raise error if `initializer` dtype and `dtype` are not identical.
with self.assertRaisesRegexp(ValueError, "don't match"):
variable_scope.get_variable("s", initializer=init, dtype=dtypes.float64)
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# TypeError: Fetch argument <tf.Variable 'v0:0' shape=(1,) dtype=float32> has
# invalid type <class '...ops.resource_variable_ops.ResourceVariable'>, must
# be a string or Tensor. (Can not convert a ResourceVariable into a Tensor or
# Operation.)
@test_util.run_deprecated_v1
def testControlDeps(self):
with self.cached_session() as sess:
v0 = variable_scope.get_variable(
"v0", [1], initializer=init_ops.constant_initializer(0))
with ops.control_dependencies([v0.value()]):
v1 = variable_scope.get_variable(
"v1", [1], initializer=init_ops.constant_initializer(1))
add = v1 + v0
# v0 should be uninitialized.
with self.assertRaisesRegexp(errors.OpError, "uninitialized"):
self.evaluate(v0)
# We should be able to initialize and run v1 without initializing
# v0, even if the variable was created with a control dep on v0.
self.evaluate(v1.initializer)
self.assertEqual(1, self.evaluate(v1))
# v0 should still be uninitialized.
with self.assertRaisesRegexp(errors.OpError, "uninitialized"):
self.evaluate(v0)
with self.assertRaisesRegexp(errors.OpError, "uninitialized"):
self.evaluate(add)
# If we initialize v0 we should be able to run 'add'.
self.evaluate(v0.initializer)
self.evaluate(add)
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# AssertionError: True is not false (last assertFalse)
@test_util.run_deprecated_v1
def testEnableResourceVariables(self):
old = variable_scope._DEFAULT_USE_RESOURCE
try:
variable_scope.enable_resource_variables()
self.assertTrue(isinstance(variables_lib.VariableV1(1.0),
resource_variable_ops.ResourceVariable))
variable_scope.disable_resource_variables()
self.assertFalse(isinstance(variables_lib.VariableV1(1.0),
resource_variable_ops.ResourceVariable))
finally:
variable_scope._DEFAULT_USE_RESOURCE = old
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# TypeError: Fetch argument None has invalid type <type 'NoneType'>
@test_util.run_deprecated_v1
def testControlFlow(self):
with self.cached_session() as sess:
v0 = variable_scope.get_variable(
"v0", [], initializer=init_ops.constant_initializer(0))
var_dict = {}
# Call get_variable in each of the cond clauses.
def var_in_then_clause():
v1 = variable_scope.get_variable(
"v1", [1], initializer=init_ops.constant_initializer(1))
var_dict["v1"] = v1
return v1 + v0
def var_in_else_clause():
v2 = variable_scope.get_variable(
"v2", [1], initializer=init_ops.constant_initializer(2))
var_dict["v2"] = v2
return v2 + v0
add = control_flow_ops.cond(
math_ops.less(v0, 10), var_in_then_clause, var_in_else_clause)
v1 = var_dict["v1"]
v2 = var_dict["v2"]
# We should be able to initialize and run v1 and v2 without initializing
# v0, even if the variable was created with a control dep on v0.
self.evaluate(v1.initializer)
self.assertEqual([1], self.evaluate(v1))
self.evaluate(v2.initializer)
self.assertEqual([2], self.evaluate(v2))
# v0 should still be uninitialized.
with self.assertRaisesRegexp(errors.OpError, "uninitialized"):
self.evaluate(v0)
# We should not be able to run 'add' yet.
with self.assertRaisesRegexp(errors.OpError, "uninitialized"):
self.evaluate(add)
# If we initialize v0 we should be able to run 'add'.
self.evaluate(v0.initializer)
self.evaluate(add)
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# TypeError: Expected tf.group() expected Tensor arguments not 'None' with
# type '<type 'NoneType'>'.
@test_util.run_in_graph_and_eager_modes
def testGetVariableScope(self):
# Test the get_variable_scope() function and setting properties of result.
init = init_ops.constant_initializer(0.3)
with variable_scope.variable_scope("bar"):
new_init1 = variable_scope.get_variable_scope().initializer
self.assertEqual(new_init1, None)
# Check that we can set initializer like this.
variable_scope.get_variable_scope().set_initializer(init)
v = variable_scope.get_variable("v", [])
self.evaluate(variables_lib.variables_initializer([v]))
self.assertAllClose(self.evaluate(v.value()), 0.3)
if not context.executing_eagerly():
# Check that we can set reuse.
variable_scope.get_variable_scope().reuse_variables()
with self.assertRaises(ValueError): # Fail, w does not exist yet.
variable_scope.get_variable("w", [1])
# Check that the set initializer goes away.
new_init = variable_scope.get_variable_scope().initializer
self.assertEqual(new_init, None)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScope(self):
with variable_scope.variable_scope("tower4") as tower:
self.assertEqual(tower.name, "tower4")
with ops.name_scope("scope") as sc:
self.assertEqual(sc, "tower4/scope/")
with variable_scope.variable_scope("tower5"):
with variable_scope.variable_scope("bar") as bar:
self.assertEqual(bar.name, "tower5/bar")
with ops.name_scope("scope") as sc:
self.assertEqual(sc, "tower5/bar/scope/")
with variable_scope.variable_scope("tower6"):
with variable_scope.variable_scope(tower, reuse=True) as tower_shared:
self.assertEqual(tower_shared.name, "tower4")
with ops.name_scope("scope") as sc:
self.assertEqual(sc, "tower6/tower4/scope/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeNameScope(self):
with ops.name_scope("testVarScopeNameScope1"):
with variable_scope.variable_scope("tower") as tower:
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "testVarScopeNameScope1/tower/scope2/")
if not context.executing_eagerly():
with variable_scope.variable_scope(
tower): # Re-entering acts like another "tower".
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "testVarScopeNameScope1/tower_1/scope2/")
with variable_scope.variable_scope(
"tower"): # Re-entering by string acts the same.
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "testVarScopeNameScope1/tower_2/scope2/")
with ops.name_scope("testVarScopeNameScope2"):
with variable_scope.variable_scope("tower"):
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "testVarScopeNameScope2/tower/scope2/")
if not context.executing_eagerly():
with variable_scope.variable_scope(tower):
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "testVarScopeNameScope2/tower_1/scope2/")
root_var_scope = variable_scope.get_variable_scope()
with ops.name_scope("testVarScopeNameScope3"):
with variable_scope.variable_scope(root_var_scope):
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "testVarScopeNameScope3/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeOriginalNameScope(self):
with self.cached_session():
with ops.name_scope("scope1"):
with variable_scope.variable_scope("tower") as tower:
self.assertEqual(tower.original_name_scope, "scope1/tower/")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "scope1/tower/scope2/")
with ops.name_scope("scope2"):
with variable_scope.variable_scope(tower) as tower1:
# Re-entering preserves original name scope.
self.assertEqual(tower1.original_name_scope, "scope1/tower/")
with ops.name_scope("foo") as sc2:
self.assertEqual(sc2, "scope2/tower/foo/")
# Test re-entering original name scope.
with ops.name_scope(tower.original_name_scope):
with ops.name_scope("bar") as sc3:
self.assertEqual(sc3, "scope1/tower/bar/")
with ops.name_scope("scope2"):
with variable_scope.variable_scope(tower):
with ops.name_scope(tower.original_name_scope):
with ops.name_scope("bar") as sc3:
self.assertEqual(sc3, "scope1/tower/bar_1/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeObjectReuse(self):
with self.cached_session():
vs = None
with variable_scope.variable_scope("jump", reuse=True) as scope:
vs = scope
with variable_scope.variable_scope(vs) as jump:
self.assertTrue(jump.reuse)
with variable_scope.variable_scope(vs, reuse=True) as jump_reuse:
self.assertTrue(jump_reuse.reuse)
with variable_scope.variable_scope(vs, reuse=False) as jump_no_reuse:
self.assertTrue(jump_no_reuse.reuse) # Inherited, cannot be undone.
with variable_scope.variable_scope("jump", reuse=False) as scope:
vs = scope
with variable_scope.variable_scope(vs) as jump:
self.assertFalse(jump.reuse)
with variable_scope.variable_scope(vs, reuse=True) as jump_reuse:
self.assertTrue(jump_reuse.reuse)
with variable_scope.variable_scope(vs, reuse=False) as jump_no_reuse:
self.assertFalse(jump_no_reuse.reuse)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeGetOrCreateReuse(self):
with self.cached_session():
def test_value(value):
x = constant_op.constant(value)
with variable_scope.variable_scope(
"testVarScopeGetOrCreateReuse_bar",
reuse=variable_scope.AUTO_REUSE):
_ = state_ops.assign(variable_scope.get_variable("var", []), x)
with variable_scope.variable_scope(
"testVarScopeGetOrCreateReuse_bar",
reuse=variable_scope.AUTO_REUSE):
_ = variable_scope.get_variable("var", [])
self.assertEqual(value, self.evaluate(x))
test_value(42.) # Variable is created.
test_value(13.) # Variable is reused hereafter.
test_value(17.)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScope(self):
with self.cached_session():
with ops.name_scope("testVarOpScope1"):
with variable_scope.variable_scope("tower", "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "tower/w:0")
with ops.name_scope("testVarOpScope2") as sc2:
self.assertEqual(sc2, "testVarOpScope1/tower/testVarOpScope2/")
with variable_scope.variable_scope("tower", "default", []):
with self.assertRaises(ValueError):
variable_scope.get_variable("w", [])
with ops.name_scope("testVarOpScope2") as sc2:
self.assertEqual(sc2, "testVarOpScope1/tower_1/testVarOpScope2/")
with ops.name_scope("testVarOpScope2"):
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "default/w:0")
with ops.name_scope("testVarOpScope2") as sc2:
self.assertEqual(sc2, "testVarOpScope2/default/testVarOpScope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "default_1/w:0")
with ops.name_scope("testVarOpScope2") as sc2:
self.assertEqual(sc2, "testVarOpScope2/default_1/testVarOpScope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeUniqueNamesInterleavedSubstringScopes(self):
with self.cached_session():
with variable_scope.variable_scope(None, "defaultScope1"):
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name,
"defaultScope1/layer/w:0")
with variable_scope.variable_scope(None, "defaultScope1"):
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name,
"defaultScope1_1/layer/w:0")
with variable_scope.variable_scope(None, "defaultScope"):
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name,
"defaultScope/layer/w:0")
with variable_scope.variable_scope(None, "defaultScope1"):
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name,
"defaultScope1_2/layer/w:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeUniqueNamesWithJump(self):
with self.cached_session():
with variable_scope.variable_scope("default") as default:
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name, "default/layer/w:0")
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name,
"default/layer_1/w:0")
with variable_scope.variable_scope(default):
pass
# No matter the jump in the middle, unique numbering continues.
with variable_scope.variable_scope(None, "layer"):
self.assertEqual(
variable_scope.get_variable("w", []).name,
"default/layer_2/w:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeReuse(self):
with self.cached_session():
with variable_scope.variable_scope("outer") as outer:
with variable_scope.variable_scope("tower", "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/tower/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/tower/scope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/default/scope2/")
with variable_scope.variable_scope(outer, reuse=True) as outer:
with variable_scope.variable_scope("tower", "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/tower/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/tower/scope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/default/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeGetVar(self):
with self.cached_session():
with variable_scope.variable_scope("root"):
with variable_scope.variable_scope("towerA") as tower_a:
va = variable_scope.get_variable("v", [1])
self.assertEqual(va.name, "root/towerA/v:0")
with variable_scope.variable_scope(tower_a, reuse=True):
va2 = variable_scope.get_variable("v", [1])
self.assertIs(va2, va)
with variable_scope.variable_scope("towerB"):
vb = variable_scope.get_variable("v", [1])
self.assertEqual(vb.name, "root/towerB/v:0")
with self.assertRaises(ValueError):
with variable_scope.variable_scope("towerA"):
va2 = variable_scope.get_variable("v", [1])
with variable_scope.variable_scope("towerA", reuse=True):
va2 = variable_scope.get_variable("v", [1])
self.assertIs(va2, va)
with variable_scope.variable_scope("foo"):
with variable_scope.variable_scope("bar"):
v = variable_scope.get_variable("v", [1])
self.assertEqual(v.name, "root/foo/bar/v:0")
with variable_scope.variable_scope(tower_a, reuse=True):
va3 = variable_scope.get_variable("v", [1])
self.assertIs(va, va3)
with self.assertRaises(ValueError):
with variable_scope.variable_scope(tower_a, reuse=True):
with variable_scope.variable_scope("baz"):
variable_scope.get_variable("v", [1])
with self.assertRaises(ValueError) as exc:
with variable_scope.variable_scope(tower_a, reuse=True):
variable_scope.get_variable("v", [2]) # Different shape.
self.assertEqual("shape" in str(exc.exception), True)
with self.assertRaises(ValueError) as exc:
with variable_scope.variable_scope(tower_a, reuse=True):
variable_scope.get_variable("v", [1], dtype=dtypes.int32)
self.assertEqual("dtype" in str(exc.exception), True)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeOuterScope(self):
with self.cached_session():
with variable_scope.variable_scope("outer") as outer:
pass
with variable_scope.variable_scope(outer):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/scope2/")
with variable_scope.variable_scope("default"):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/default/scope2/")
with variable_scope.variable_scope(outer, reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_2/scope2/")
with variable_scope.variable_scope("default", reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_2/default/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarScopeNestedOuterScope(self):
with self.cached_session():
with variable_scope.variable_scope("outer") as outer:
with variable_scope.variable_scope(outer):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/outer/scope2/")
with variable_scope.variable_scope("default"):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/default/scope2/")
with variable_scope.variable_scope(outer, reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/outer_1/scope2/")
with variable_scope.variable_scope("default", reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/default_1/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeReuseParam(self):
with self.cached_session():
with variable_scope.variable_scope("outer") as outer:
with variable_scope.variable_scope("tower", "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/tower/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/tower/scope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/default/scope2/")
with variable_scope.variable_scope(outer) as outer:
with variable_scope.variable_scope("tower", "default", reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/tower/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/tower/scope2/")
outer.reuse_variables()
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/default/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeReuseError(self):
with self.cached_session():
with self.assertRaises(ValueError):
with variable_scope.variable_scope(None, "default", reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/tower/w:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeOuterScope(self):
with self.cached_session():
with variable_scope.variable_scope("outer") as outer:
pass
with variable_scope.variable_scope(outer, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/scope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/default/scope2/")
with variable_scope.variable_scope(outer, "default", reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_2/scope2/")
outer.reuse_variables()
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_2/default/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVarOpScopeNestedOuterScope(self):
with self.cached_session():
with variable_scope.variable_scope("outer") as outer:
with variable_scope.variable_scope(outer, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/outer/scope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer/default/scope2/")
with variable_scope.variable_scope(outer, "default", reuse=True):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/scope2/")
with variable_scope.variable_scope(None, "default", []):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
with ops.name_scope("scope2") as sc2:
self.assertEqual(sc2, "outer_1/default/scope2/")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testBasicWhenAuxiliaryNameScopeIsFalse(self):
with self.cached_session():
with variable_scope.variable_scope(
"scope", auxiliary_name_scope=False) as scope:
self.assertEqual(scope.original_name_scope, "")
self.assertEqual(
variable_scope.get_variable("w", []).name, "scope/w:0")
self.assertEqual(constant_op.constant([], name="c").name, "c:0")
with variable_scope.variable_scope(scope, auxiliary_name_scope=False):
self.assertEqual(scope.original_name_scope, "")
self.assertEqual(
variable_scope.get_variable("w1", []).name, "scope/w1:0")
self.assertEqual(constant_op.constant([], name="c1").name, "c1:0")
# Recheck: new name scope is NOT created before
with ops.name_scope("scope"):
self.assertEqual(constant_op.constant([], name="c").name, "scope/c:0")
with variable_scope.variable_scope("outer"):
with variable_scope.variable_scope(
"inner", auxiliary_name_scope=False) as inner:
self.assertEqual(inner.original_name_scope, "outer/")
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/inner/w:0")
self.assertEqual(
constant_op.constant([], name="c").name, "outer/c:0")
with variable_scope.variable_scope(
inner, auxiliary_name_scope=False) as inner1:
self.assertEqual(inner1.original_name_scope, "outer/")
self.assertEqual(
variable_scope.get_variable("w1", []).name, "outer/inner/w1:0")
self.assertEqual(
constant_op.constant([], name="c1").name, "outer/c1:0")
# Recheck: new name scope is NOT created before
with ops.name_scope("inner"):
self.assertEqual(
constant_op.constant([], name="c").name, "outer/inner/c:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testCreatedByDefaultNameWhenAuxiliaryNameScopeIsFalse(self):
with self.cached_session():
with variable_scope.variable_scope(
None, default_name="default", auxiliary_name_scope=False) as scope:
self.assertEqual(scope.original_name_scope, "")
self.assertEqual(
variable_scope.get_variable("w", []).name, "default/w:0")
self.assertEqual(constant_op.constant([], name="c").name, "c:0")
# Recheck: new name scope is NOT created before
with ops.name_scope("default"):
self.assertEqual(
constant_op.constant([], name="c").name, "default/c:0")
with variable_scope.variable_scope("outer"):
with variable_scope.variable_scope(
None, default_name="default",
auxiliary_name_scope=False) as inner:
self.assertEqual(inner.original_name_scope, "outer/")
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/default/w:0")
self.assertEqual(
constant_op.constant([], name="c").name, "outer/c:0")
# Recheck: new name scope is NOT created before
with ops.name_scope("default"):
self.assertEqual(
constant_op.constant([], name="c").name, "outer/default/c:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testReenterRootScopeWhenAuxiliaryNameScopeIsFalse(self):
with self.cached_session():
root_scope = variable_scope.get_variable_scope()
with variable_scope.variable_scope(
root_scope, auxiliary_name_scope=False) as scope:
self.assertEqual(scope.original_name_scope, "")
self.assertEqual(variable_scope.get_variable("w", []).name, "w:0")
self.assertEqual(constant_op.constant([], name="c").name, "c:0")
with variable_scope.variable_scope("outer"):
with variable_scope.variable_scope(
root_scope, auxiliary_name_scope=False) as inner:
self.assertEqual(inner.original_name_scope, "")
self.assertEqual(variable_scope.get_variable("w1", []).name, "w1:0")
self.assertEqual(
constant_op.constant([], name="c1").name, "outer/c1:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testAuxiliaryNameScopeIsInvalid(self):
with self.cached_session():
with self.assertRaisesRegexp(TypeError, "auxiliary_name_scope"):
with variable_scope.variable_scope(
None, default_name="scope", auxiliary_name_scope="invalid"):
pass
with self.assertRaisesRegexp(TypeError, "auxiliary_name_scope"):
with variable_scope.variable_scope(
"scope", auxiliary_name_scope="invalid"):
pass
with variable_scope.variable_scope("scope") as scope:
pass
with self.assertRaisesRegexp(TypeError, "auxiliary_name_scope"):
with variable_scope.variable_scope(
scope, auxiliary_name_scope="invalid"):
pass
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testReuseScopeWithoutNameScopeCollision(self):
# Github issue: #13429
with self.cached_session():
with variable_scope.variable_scope("outer"):
with variable_scope.variable_scope("inner") as inner:
pass
with variable_scope.variable_scope(
inner, auxiliary_name_scope=False) as scope:
with ops.name_scope(scope.original_name_scope):
self.assertEqual(
variable_scope.get_variable("w", []).name, "outer/inner/w:0")
self.assertEqual(
constant_op.constant([], name="c").name, "outer/inner/c:0")
with ops.name_scope("inner"):
self.assertEqual(
constant_op.constant([], name="c").name, "inner/c:0")
with variable_scope.variable_scope("another"):
with variable_scope.variable_scope(
inner, auxiliary_name_scope=False) as scope1:
with ops.name_scope(scope1.original_name_scope):
self.assertEqual(
variable_scope.get_variable("w1", []).name,
"outer/inner/w1:0")
self.assertEqual(
constant_op.constant([], name="c1").name, "outer/inner/c1:0")
with ops.name_scope("inner"):
self.assertEqual(
constant_op.constant([], name="c").name, "another/inner/c:0")
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
# (different assertions failing after wrapping, in both execution modes)
@test_util.run_in_graph_and_eager_modes
def testGetLocalVar(self):
# Check that local variable respects naming.
with variable_scope.variable_scope("outer") as outer:
with variable_scope.variable_scope(outer, "default", []):
local_var = variable_scope.get_local_variable(
"w", [], collections=["foo"])
self.assertEqual(local_var.name, "outer/w:0")
if not context.executing_eagerly():
# Since variable is local, it should be in the local variable collection
# but not the trainable collection.
self.assertIn(local_var,
ops.get_collection(ops.GraphKeys.LOCAL_VARIABLES))
self.assertIn(local_var, ops.get_collection("foo"))
self.assertNotIn(local_var,
ops.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES))
# Check that local variable respects `reuse`.
with variable_scope.variable_scope(outer, "default", reuse=True):
self.assertEqual(
variable_scope.get_local_variable("w", []).name, "outer/w:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testSignatureGetVarVsGetLocalVar(self):
"""get_{local,}variable() must take the same list of args."""
arg_names = tf_inspect.getargspec(variable_scope.get_variable)[0]
local_arg_names = tf_inspect.getargspec(
variable_scope.get_local_variable)[0]
self.assertEqual(arg_names, local_arg_names)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testGetVarWithDevice(self):
g = ops.Graph()
varname_type = []
def device_func(op):
if op.type in ["Variable", "VariableV2", "VarHandleOp"]:
varname_type.append((op.name, op.get_attr("dtype")))
return test_util.gpu_device_name()
with g.as_default():
with ops.device(device_func):
_ = variable_scope.get_variable("x", (100, 200))
_ = variable_scope.get_variable(
"y", dtype=dtypes.int64, initializer=numpy.arange(73))
self.assertEqual(varname_type[0], ("x", dtypes.float32))
self.assertEqual(varname_type[1], ("y", dtypes.int64))
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testGetCollection(self):
with self.cached_session():
_ = variable_scope.get_variable("testGetCollection_a", [])
_ = variable_scope.get_variable(
"testGetCollection_b", [], trainable=False)
with variable_scope.variable_scope("testGetCollection_foo_") as scope1:
_ = variable_scope.get_variable("testGetCollection_a", [])
_ = variable_scope.get_variable(
"testGetCollection_b", [], trainable=False)
self.assertEqual([
v.name
for v in scope1.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES)
], ["testGetCollection_foo_/testGetCollection_a:0"])
self.assertEqual([
v.name
for v in scope1.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
], [
"testGetCollection_foo_/testGetCollection_a:0",
"testGetCollection_foo_/testGetCollection_b:0"
])
with variable_scope.variable_scope("testGetCollection_foo") as scope2:
_ = variable_scope.get_variable("testGetCollection_a", [])
_ = variable_scope.get_variable(
"testGetCollection_b", [], trainable=False)
self.assertEqual([
v.name
for v in scope2.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES)
], ["testGetCollection_foo/testGetCollection_a:0"])
self.assertEqual([
v.name
for v in scope2.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
], [
"testGetCollection_foo/testGetCollection_a:0",
"testGetCollection_foo/testGetCollection_b:0"
])
scope = variable_scope.get_variable_scope()
self.assertEqual([
v.name for v in scope.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
], [
"testGetCollection_a:0", "testGetCollection_b:0",
"testGetCollection_foo_/testGetCollection_a:0",
"testGetCollection_foo_/testGetCollection_b:0",
"testGetCollection_foo/testGetCollection_a:0",
"testGetCollection_foo/testGetCollection_b:0"
])
self.assertEqual([
v.name
for v in scope.get_collection(ops.GraphKeys.TRAINABLE_VARIABLES)
], [
"testGetCollection_a:0",
"testGetCollection_foo_/testGetCollection_a:0",
"testGetCollection_foo/testGetCollection_a:0"
])
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testGetTrainableVariablesWithGetVariable(self):
with self.cached_session():
_ = variable_scope.get_variable("testGetTrainableVariables_a", [])
with variable_scope.variable_scope(
"testGetTrainableVariables_foo") as scope:
_ = variable_scope.get_variable("testGetTrainableVariables_b", [])
_ = variable_scope.get_variable(
"testGetTrainableVariables_c", [], trainable=False)
# sync `ON_READ` sets trainable=False
_ = variable_scope.get_variable(
"testGetTrainableVariables_d", [],
synchronization=variable_scope.VariableSynchronization.ON_READ)
self.assertEqual(
[v.name for v in scope.trainable_variables()],
["testGetTrainableVariables_foo/testGetTrainableVariables_b:0"])
_ = variable_scope.get_variable(
"testGetTrainableVariables_e", [],
synchronization=variable_scope.VariableSynchronization.ON_READ,
trainable=True)
self.assertEqual([v.name for v in scope.trainable_variables()], [
"testGetTrainableVariables_foo/testGetTrainableVariables_b:0",
"testGetTrainableVariables_foo/testGetTrainableVariables_e:0",
])
# All other sync values sets trainable=True
_ = variable_scope.get_variable(
"testGetTrainableVariables_f", [],
synchronization=variable_scope.VariableSynchronization.ON_WRITE)
self.assertEqual([v.name for v in scope.trainable_variables()], [
"testGetTrainableVariables_foo/testGetTrainableVariables_b:0",
"testGetTrainableVariables_foo/testGetTrainableVariables_e:0",
"testGetTrainableVariables_foo/testGetTrainableVariables_f:0",
])
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testGetTrainableVariablesWithVariable(self):
with self.cached_session():
_ = variable_scope.variable(1.0, name="testGetTrainableVariables_a")
with variable_scope.variable_scope(
"testGetTrainableVariables_foo") as scope:
_ = variable_scope.variable(1.0, name="testGetTrainableVariables_b")
_ = variable_scope.variable(
1.0, name="testGetTrainableVariables_c", trainable=False)
# sync `ON_READ` sets trainable=False
_ = variable_scope.variable(
1.0,
name="testGetTrainableVariables_d",
synchronization=variable_scope.VariableSynchronization.ON_READ)
self.assertEqual(
[v.name for v in scope.trainable_variables()],
["testGetTrainableVariables_foo/testGetTrainableVariables_b:0"])
_ = variable_scope.variable(
1.0,
name="testGetTrainableVariables_e",
synchronization=variable_scope.VariableSynchronization.ON_READ,
trainable=True)
self.assertEqual([v.name for v in scope.trainable_variables()], [
"testGetTrainableVariables_foo/testGetTrainableVariables_b:0",
"testGetTrainableVariables_foo/testGetTrainableVariables_e:0",
])
# All other sync values sets trainable=True
_ = variable_scope.variable(
1.0,
name="testGetTrainableVariables_f",
synchronization=variable_scope.VariableSynchronization.ON_WRITE)
self.assertEqual([v.name for v in scope.trainable_variables()], [
"testGetTrainableVariables_foo/testGetTrainableVariables_b:0",
"testGetTrainableVariables_foo/testGetTrainableVariables_e:0",
"testGetTrainableVariables_foo/testGetTrainableVariables_f:0",
])
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testGetGlobalVariables(self):
with self.cached_session():
_ = variable_scope.get_variable("testGetGlobalVariables_a", [])
with variable_scope.variable_scope("testGetGlobalVariables_foo") as scope:
_ = variable_scope.get_variable("testGetGlobalVariables_b", [])
self.assertEqual(
[v.name for v in scope.global_variables()],
["testGetGlobalVariables_foo/"
"testGetGlobalVariables_b:0"])
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testGetLocalVariables(self):
with self.cached_session():
_ = variable_scope.get_variable(
"a", [], collections=[ops.GraphKeys.LOCAL_VARIABLES])
with variable_scope.variable_scope("foo") as scope:
_ = variable_scope.get_variable(
"b", [], collections=[ops.GraphKeys.LOCAL_VARIABLES])
_ = variable_scope.get_variable("c", [])
self.assertEqual([v.name for v in scope.local_variables()], ["foo/b:0"])
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testGetVariableWithRefDtype(self):
v = variable_scope.get_variable("v", shape=[3, 4], dtype=dtypes.float32)
# Ensure it is possible to do get_variable with a _ref dtype passed in.
_ = variable_scope.get_variable("w", shape=[5, 6], dtype=v.dtype)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testGetVariableWithInitializerWhichTakesNoArgs(self):
v = variable_scope.get_variable("foo", initializer=lambda: [2])
self.assertEqual(v.name, "foo:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testGetVariableWithInitializerWhichTakesOptionalArgs(self):
v = variable_scope.get_variable("foo", initializer=lambda x=True: [2])
self.assertEqual(v.name, "foo:0")
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testGetVariableWithInitializerWhichTakesUnprovidedArgsAndNoShape(self):
with self.assertRaisesRegexp(
ValueError,
"The initializer passed is not valid. It should be a callable with no "
"arguments and the shape should not be provided or an instance of "
"`tf.keras.initializers.*' and `shape` should be fully defined."):
variable_scope.get_variable("foo", initializer=lambda x: [2])
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testTwoGraphs(self):
def f():
g1 = ops.Graph()
g2 = ops.Graph()
with g1.as_default():
with g2.as_default():
with variable_scope.variable_scope("_"):
pass
self.assertRaisesRegexp(ValueError, "'_' is not a valid scope name", f)
def axis0_into1_partitioner(shape=None, **unused_kwargs):
part = [1] * len(shape)
return part
def axis0_into2_partitioner(shape=None, **unused_kwargs):
part = [1] * len(shape)
part[0] = 2
return part
def axis0_into3_partitioner(shape=None, **unused_kwargs):
part = [1] * len(shape)
part[0] = 3
return part
class VariableScopeWithPartitioningTest(test.TestCase):
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testResultNameMatchesRequested(self):
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner):
v = variable_scope.get_variable("name0", shape=(3, 1, 1))
self.assertEqual(v.name, "scope0/name0")
v_concat = v.as_tensor()
self.assertEqual(v_concat.name, "scope0/name0:0")
variables = ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
self.assertIn("scope0/name0/part_0:0", [x.name for x in variables])
self.assertIn("scope0/name0/part_1:0", [x.name for x in variables])
self.assertNotIn("scope0/name0/part_2:0", [x.name for x in variables])
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testBreaksIfPartitioningChanges(self):
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner):
variable_scope.get_variable("name0", shape=(3, 1, 1))
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into3_partitioner, reuse=True):
with self.assertRaisesRegexp(
ValueError,
"Trying to reuse partitioned variable .* but specified partitions "
".* and found partitions .*"):
variable_scope.get_variable("name0", shape=(3, 1, 1))
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into1_partitioner, reuse=True):
with self.assertRaisesRegexp(
ValueError,
"Trying to reuse partitioned variable .* but specified partitions "
".* and found partitions .*"):
variable_scope.get_variable("name0", shape=(3, 1, 1))
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testReturnsExistingConcatenatedValueIfReuse(self):
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner):
v_concat = variable_scope.get_variable("name0", shape=(3, 1, 1))
variable_scope.get_variable_scope().reuse_variables()
v_concat_2 = variable_scope.get_variable("name0", shape=(3, 1, 1))
self.assertEqual(v_concat, v_concat_2)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testAllowsReuseWithoutPartitioner(self):
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner):
v = variable_scope.get_variable("name0", shape=(3, 1, 1))
with variable_scope.variable_scope("scope0", reuse=True):
v_reused = variable_scope.get_variable("name0")
self.assertIs(v, v_reused)
def testNoReuseInEagerByDefault(self):
with context.eager_mode():
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner):
v1 = variable_scope.get_variable("name0", shape=(3, 1, 1))
v2 = variable_scope.get_variable("name0", shape=(3, 1, 1))
self.assertIsNot(v1, v2)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testPropagatePartitionerOnReopening(self):
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner) as vs:
self.assertEqual(axis0_into2_partitioner, vs.partitioner)
with variable_scope.variable_scope(vs) as vs1:
self.assertEqual(axis0_into2_partitioner, vs1.partitioner)
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# obtaining different results in the eager case compared to the graph one
@test_util.run_deprecated_v1
def testScalarIgnoresPartitioner(self):
with variable_scope.variable_scope(
"scope0", partitioner=axis0_into2_partitioner):
v = variable_scope.get_variable("name0", shape=())
self.assertEqual(v.name, "scope0/name0:0")
variables = ops.get_collection(ops.GraphKeys.GLOBAL_VARIABLES)
self.assertIn("scope0/name0:0", [x.name for x in variables])
def _testPartitionConcatenatesAlongCorrectAxis(self, use_resource):
def _part_axis_0(**unused_kwargs):
return (2, 1, 1)
def _part_axis_1(**unused_kwargs):
return (1, 2, 1)
with variable_scope.variable_scope("root", use_resource=use_resource):
v0 = variable_scope.get_variable(
"n0", shape=(2, 2, 2), partitioner=_part_axis_0)
v1 = variable_scope.get_variable(
"n1", shape=(2, 2, 2), partitioner=_part_axis_1)
self.assertEqual(v0.get_shape(), (2, 2, 2))
self.assertEqual(v1.get_shape(), (2, 2, 2))
n0_0 = list(v0)[0]
n0_1 = list(v0)[1]
self.assertEqual(n0_0.get_shape(), (1, 2, 2))
self.assertEqual(n0_1.get_shape(), (1, 2, 2))
n1_0 = list(v1)[0]
n1_1 = list(v1)[1]
self.assertEqual(n1_0.get_shape(), (2, 1, 2))
self.assertEqual(n1_1.get_shape(), (2, 1, 2))
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testPartitionConcatenatesAlongCorrectAxis(self):
self._testPartitionConcatenatesAlongCorrectAxis(use_resource=False)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testPartitionConcatenatesAlongCorrectAxisResource(self):
self._testPartitionConcatenatesAlongCorrectAxis(use_resource=True)
def testPartitionConcatenatesAlongCorrectAxisResourceInEager(self):
with context.eager_mode():
self._testPartitionConcatenatesAlongCorrectAxis(use_resource=True)
class VariableScopeWithCustomGetterTest(test.TestCase):
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testNonCallableGetterFails(self):
with self.assertRaisesRegexp(ValueError,
r"custom_getter .* not callable:"):
with variable_scope.variable_scope("scope0", custom_getter=3):
variable_scope.get_variable("name0")
with self.assertRaisesRegexp(ValueError,
r"custom_getter .* not callable:"):
variable_scope.get_variable("name0", custom_getter=3)
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testNoSideEffectsWithIdentityCustomGetter(self):
called = [0]
def custom_getter(getter, *args, **kwargs):
called[0] += 1
return getter(*args, **kwargs)
with variable_scope.variable_scope(
"scope", custom_getter=custom_getter) as scope:
v = variable_scope.get_variable("v", [1])
with variable_scope.variable_scope(scope, reuse=True):
v2 = variable_scope.get_variable("v", [1])
with variable_scope.variable_scope("new_scope") as new_scope:
v3 = variable_scope.get_variable("v3", [1])
with variable_scope.variable_scope(
new_scope, reuse=True, custom_getter=custom_getter):
v4 = variable_scope.get_variable("v3", [1])
self.assertIs(v, v2)
self.assertIs(v3, v4)
self.assertEqual(3, called[0]) # skipped one in the first new_scope
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testSynchronizationAndAggregationWithCustomGetter(self):
called = [0]
synchronization = variable_scope.VariableSynchronization.AUTO
aggregation = variable_scope.VariableAggregation.NONE
def custom_getter(getter, *args, **kwargs):
called[0] += 1
# Verify synchronization and aggregation kwargs are as expected.
self.assertEqual(kwargs["synchronization"], synchronization)
self.assertEqual(kwargs["aggregation"], aggregation)
return getter(*args, **kwargs)
with variable_scope.variable_scope("scope", custom_getter=custom_getter):
variable_scope.get_variable("v", [1])
self.assertEqual(1, called[0])
with variable_scope.variable_scope("scope", custom_getter=custom_getter):
synchronization = variable_scope.VariableSynchronization.ON_READ
aggregation = variable_scope.VariableAggregation.MEAN
variable_scope.get_variable(
"v1", [1], synchronization=synchronization, aggregation=aggregation)
self.assertEqual(2, called[0])
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testCustomGetterWithReuse(self):
# Custom getter can choose to behave differently on reused variables.
def custom_getter(getter, *args, **kwargs):
var = getter(*args, **kwargs)
if kwargs["reuse"]:
# This can be used, e.g., for changing the caching device if needed.
return array_ops.identity(var, name="reused")
else:
return array_ops.identity(var, name="not_reused")
with variable_scope.variable_scope(
"scope", custom_getter=custom_getter) as scope:
v = variable_scope.get_variable("v", [1])
with variable_scope.variable_scope(scope, reuse=True):
v2 = variable_scope.get_variable("v", [1])
self.assertEqual(v.name, "not_reused:0")
self.assertEqual(v2.name, "reused:0")
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# ValueError: Fetch argument <tf.Tensor 'custom_getter/add:0' shape=(1, 2, 3)
# dtype=float32> cannot be interpreted as a Tensor. (Tensor
# Tensor("custom_getter/add:0", shape=(1, 2, 3), dtype=float32) is not an
# element of this graph.)
@test_util.run_deprecated_v1
def testGetterThatCreatesTwoVariablesAndSumsThem(self):
def custom_getter(getter, name, *args, **kwargs):
g_0 = getter("%s/0" % name, *args, **kwargs)
g_1 = getter("%s/1" % name, *args, **kwargs)
with ops.name_scope("custom_getter"):
return g_0 + g_1
with variable_scope.variable_scope("scope", custom_getter=custom_getter):
v = variable_scope.get_variable("v", [1, 2, 3])
self.assertEqual([1, 2, 3], v.get_shape())
true_vars = variables_lib.trainable_variables()
self.assertEqual(2, len(true_vars))
self.assertEqual("scope/v/0:0", true_vars[0].name)
self.assertEqual("scope/v/1:0", true_vars[1].name)
self.assertEqual("custom_getter/add:0", v.name)
with self.cached_session() as sess:
variables_lib.global_variables_initializer().run()
np_vars, np_v = self.evaluate([true_vars, v])
self.assertAllClose(np_v, sum(np_vars))
# TODO(mihaimaruseac): Not converted to use wrap_function because of
# ValueError: Fetch argument <tf.Tensor 'sum_getter_2/add:0' shape=(1, 2, 3)
# dtype=float32> cannot be interpreted as a Tensor. (Tensor
# Tensor("sum_getter_2/add:0", shape=(1, 2, 3), dtype=float32) is not an
# element of this graph.)
@test_util.run_deprecated_v1
def testNestedCustomGetters(self):
def sum_getter(getter, name, *args, **kwargs):
g_0 = getter("%s/sum_0" % name, *args, **kwargs)
g_1 = getter("%s/sum_1" % name, *args, **kwargs)
with ops.name_scope("sum_getter"):
return g_0 + g_1
def prod_getter(getter, name, *args, **kwargs):
g_0 = getter("%s/prod_0" % name, *args, **kwargs)
g_1 = getter("%s/prod_1" % name, *args, **kwargs)
with ops.name_scope("prod_getter"):
return g_0 * g_1
with variable_scope.variable_scope("prod_scope", custom_getter=prod_getter):
with variable_scope.variable_scope("sum_scope", custom_getter=sum_getter):
with variable_scope.variable_scope(
"inner_sum_scope", custom_getter=sum_getter):
# take sums of sums of products
v = variable_scope.get_variable("v", [1, 2, 3])
self.assertEqual([1, 2, 3], v.get_shape())
true_vars = variables_lib.trainable_variables()
self.assertEqual(8, len(true_vars))
template = (
"prod_scope/sum_scope/inner_sum_scope/v/sum_%d/sum_%d/prod_%d:0")
self.assertEqual(template % (0, 0, 0), true_vars[0].name)
self.assertEqual(template % (0, 0, 1), true_vars[1].name)
self.assertEqual(template % (0, 1, 0), true_vars[2].name)
self.assertEqual(template % (0, 1, 1), true_vars[3].name)
self.assertEqual(template % (1, 0, 0), true_vars[4].name)
self.assertEqual(template % (1, 0, 1), true_vars[5].name)
self.assertEqual(template % (1, 1, 0), true_vars[6].name)
self.assertEqual(template % (1, 1, 1), true_vars[7].name)
with self.cached_session() as sess:
variables_lib.global_variables_initializer().run()
np_vars, np_v = self.evaluate([true_vars, v])
# take products of sums of products
self.assertAllClose(
np_v, (((np_vars[0] * np_vars[1]) + (np_vars[2] * np_vars[3])) + (
(np_vars[4] * np_vars[5]) + (np_vars[6] * np_vars[7]))))
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVariableCreator(self):
variable_names = []
def creator_a(next_creator, **kwargs):
variable_names.append(kwargs.get("name", ""))
return next_creator(**kwargs)
def creator_b(next_creator, **kwargs):
kwargs["name"] = "forced_name"
return next_creator(**kwargs)
with variable_scope.variable_creator_scope(creator_a):
with variable_scope.variable_creator_scope(creator_b):
variable_scope.variable(1.0, name="one_name")
self.assertEqual(variable_names[0], "forced_name")
called = [False]
def creater_c(next_creator, **kwargs):
called[0] = True
self.assertEqual(kwargs["synchronization"],
variable_scope.VariableSynchronization.ON_WRITE)
self.assertEqual(kwargs["aggregation"],
variable_scope.VariableAggregation.MEAN)
return next_creator(**kwargs)
with variable_scope.variable_creator_scope(creater_c):
variable_scope.get_variable(
"v", [],
synchronization=variable_scope.VariableSynchronization.ON_WRITE,
aggregation=variable_scope.VariableAggregation.MEAN)
self.assertTrue(called[0])
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testVariableCreatorNestingError(self):
def creator(next_creator, **kwargs):
return next_creator(**kwargs)
# Save the state so we can clean up at the end.
graph = ops.get_default_graph()
old_creator_stack = graph._variable_creator_stack
try:
scope = variable_scope.variable_creator_scope(creator)
scope.__enter__()
with variable_scope.variable_creator_scope(creator):
with self.assertRaises(RuntimeError):
scope.__exit__(None, None, None)
finally:
graph._variable_creator_stack = old_creator_stack
class PartitionInfoTest(test.TestCase):
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testConstructorChecks(self):
# Invalid arg types.
with self.assertRaises(TypeError):
variable_scope._PartitionInfo(full_shape=None, var_offset=[0, 1])
with self.assertRaises(TypeError):
variable_scope._PartitionInfo(full_shape=[0, 1], var_offset=None)
with self.assertRaises(TypeError):
variable_scope._PartitionInfo(full_shape="foo", var_offset=[0, 1])
with self.assertRaises(TypeError):
variable_scope._PartitionInfo(full_shape=[0, 1], var_offset="foo")
# full_shape and var_offset must have same length.
with self.assertRaises(ValueError):
variable_scope._PartitionInfo(full_shape=[0, 1], var_offset=[0])
# Offset must always be less than shape.
with self.assertRaises(ValueError):
variable_scope._PartitionInfo(full_shape=[1, 1], var_offset=[0, 1])
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testSingleOffset(self):
partition_info = variable_scope._PartitionInfo(
full_shape=[9, 3], var_offset=[4, 0])
self.assertEqual(4, partition_info.single_offset([1, 3]))
# Tests when the variable isn't partitioned at all.
partition_info = variable_scope._PartitionInfo(
full_shape=[9, 3], var_offset=[0, 0])
self.assertEqual(0, partition_info.single_offset([9, 3]))
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testSingleSliceDim(self):
partition_info = variable_scope._PartitionInfo(
full_shape=[9, 3], var_offset=[4, 0])
# Invalid shape.
with self.assertRaises(TypeError):
partition_info.single_slice_dim(None)
# Rank of shape differs from full_shape.
with self.assertRaises(ValueError):
partition_info.single_slice_dim([1, 2, 3])
# Shape is too large given var_offset (4+6 > 9).
with self.assertRaises(ValueError):
partition_info.single_slice_dim([6, 3])
# Multiple possible slice dim from shape.
with self.assertRaises(ValueError):
partition_info.single_slice_dim([1, 1])
partition_info = variable_scope._PartitionInfo(
full_shape=[9, 3], var_offset=[0, 0])
self.assertEqual(1, partition_info.single_slice_dim([9, 2]))
partition_info = variable_scope._PartitionInfo(
full_shape=[9, 3], var_offset=[4, 0])
self.assertEqual(0, partition_info.single_slice_dim([2, 3]))
class VariableScopeMultithreadedTest(test.TestCase):
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testTwoThreadsDisjointScopeEntry(self):
def thread_fn(i, graph):
with graph.as_default():
with variable_scope.variable_scope("foo"):
if i == 0:
v = variable_scope.get_variable("v", [])
self.assertEquals("foo/v:0", v.name)
else:
# Any thread after the first one should fail to create variable
# with the same name.
with self.assertRaises(ValueError):
variable_scope.get_variable("v", [])
graph = ops.get_default_graph()
threads = [
threading.Thread(target=thread_fn, args=(
i,
graph,
)) for i in range(2)
]
threads[0].start()
# Allow thread 0 to finish before starting thread 1.
threads[0].join()
threads[1].start()
threads[1].join()
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testTwoThreadsNestedScopeEntry(self):
def thread_fn(i, graph, run_event, pause_event):
with graph.as_default():
with variable_scope.variable_scope("foo"):
if i == 0:
v = variable_scope.get_variable("v", [])
self.assertEquals("foo/v:0", v.name)
else:
# Any thread after the first one should fail to create variable
# with the same name.
with self.assertRaises(ValueError):
variable_scope.get_variable("v", [])
pause_event.set()
run_event.wait()
graph = ops.get_default_graph()
run_events = [threading.Event() for _ in range(2)]
pause_events = [threading.Event() for _ in range(2)]
threads = [
threading.Thread(
target=thread_fn, args=(i, graph, run_events[i], pause_events[i]))
for i in range(2)
]
# Start first thread.
threads[0].start()
pause_events[0].wait()
# Start next thread once the first thread has paused.
threads[1].start()
pause_events[1].wait()
# Resume both threads.
run_events[0].set()
run_events[1].set()
threads[0].join()
threads[1].join()
@test_util.run_in_graph_and_eager_modes
@run_inside_wrap_function_in_eager_mode
def testReenterMainScope(self):
def thread_fn(graph, main_thread_scope):
with graph.as_default():
# Variable created with main scope will have prefix "main".
with variable_scope.variable_scope(main_thread_scope):
with variable_scope.variable_scope("foo"):
v = variable_scope.get_variable("v", [])
self.assertEquals("main/foo/v:0", v.name)
# Variable created outside main scope will not have prefix "main".
with variable_scope.variable_scope("bar"):
v = variable_scope.get_variable("v", [])
self.assertEquals("bar/v:0", v.name)
graph = ops.get_default_graph()
with variable_scope.variable_scope("main") as main_thread_scope:
thread = threading.Thread(
target=thread_fn, args=(graph, main_thread_scope))
thread.start()
thread.join()
if __name__ == "__main__":
test.main()
|
threaded_crawler.py
|
# coding:utf8
import time
import threading
import urlparse
from downloader import Downloader
SLEEP_TIME = 1
def threaded_crawler(seed_url, delay=5, cache=None, scrape_callback=None, user_agent='wswp', proxies=None,
num_retries=1, max_threads=10, timeout=60):
"""Crawl this website in multiple threads
"""
# the queue of URL's that still need to be crawled
# crawl_queue = Queue.deque([seed_url])
crawl_queue = [seed_url]
# the URL's that have been seen
seen = set([seed_url])
D = Downloader(cache=cache, delay=delay, user_agent=user_agent, proxies=proxies, num_retries=num_retries,
timeout=timeout)
def process_queue():
while True:
try:
url = crawl_queue.pop()
except IndexError:
# crawl queue is empty
break
else:
html = D(url)
if scrape_callback:
try:
links = scrape_callback(url, html) or []
except Exception as e:
print 'Error in callback for: {}: {}'.format(url, e)
else:
for link in links:
link = normalize(seed_url, link)
# check whether already crawled this link
if link not in seen:
seen.add(link)
# add this new link to queue
crawl_queue.append(link)
# wait for all download threads to finish
threads = []
while threads or crawl_queue:
# the crawl is still active
for thread in threads:
if not thread.is_alive():
# remove the stopped threads
threads.remove(thread)
while len(threads) < max_threads and crawl_queue:
# can start some more threads
thread = threading.Thread(target=process_queue)
thread.setDaemon(True) # set daemon so main thread can exit when receives ctrl-c
thread.start()
threads.append(thread)
# all threads have been processed
# sleep temporarily so CPU can focus execution on other threads
time.sleep(SLEEP_TIME)
def normalize(seed_url, link):
"""Normalize this URL by removing hash and adding domain
"""
link, _ = urlparse.urldefrag(link) # remove hash to avoid duplicates
return urlparse.urljoin(seed_url, link)
|
support.py
|
"""
Assorted utilities for use in tests.
"""
import cmath
import contextlib
import enum
import errno
import gc
import math
import platform
import os
import shutil
import subprocess
import sys
import tempfile
import time
import io
import ctypes
import multiprocessing as mp
import warnings
import traceback
from contextlib import contextmanager
import numpy as np
from numba import testing
from numba.core import errors, typing, utils, config, cpu
from numba.core.compiler import compile_extra, compile_isolated, Flags, DEFAULT_FLAGS
import unittest
from numba.core.runtime import rtsys
from numba.np import numpy_support
try:
import scipy
except ImportError:
scipy = None
enable_pyobj_flags = Flags()
enable_pyobj_flags.set("enable_pyobject")
force_pyobj_flags = Flags()
force_pyobj_flags.set("force_pyobject")
no_pyobj_flags = Flags()
nrt_flags = Flags()
nrt_flags.set("nrt")
tag = testing.make_tag_decorator(['important', 'long_running'])
_32bit = sys.maxsize <= 2 ** 32
is_parfors_unsupported = _32bit
skip_parfors_unsupported = unittest.skipIf(
is_parfors_unsupported,
'parfors not supported',
)
skip_py38_or_later = unittest.skipIf(
utils.PYVERSION >= (3, 8),
"unsupported on py3.8 or later"
)
skip_tryexcept_unsupported = unittest.skipIf(
utils.PYVERSION < (3, 7),
"try-except unsupported on py3.6 or earlier"
)
skip_tryexcept_supported = unittest.skipIf(
utils.PYVERSION >= (3, 7),
"try-except supported on py3.7 or later"
)
_msg = "SciPy needed for test"
skip_unless_scipy = unittest.skipIf(scipy is None, _msg)
_lnx_reason = 'linux only test'
linux_only = unittest.skipIf(not sys.platform.startswith('linux'), _lnx_reason)
_is_armv7l = platform.machine() == 'armv7l'
disabled_test = unittest.skipIf(True, 'Test disabled')
# See issue #4563, PPC64LE LLVM bug
skip_ppc64le_issue4563 = unittest.skipIf(platform.machine() == 'ppc64le',
("Hits: 'Parameter area must exist "
"to pass an argument in memory'"))
try:
import scipy.linalg.cython_lapack
has_lapack = True
except ImportError:
has_lapack = False
needs_lapack = unittest.skipUnless(has_lapack,
"LAPACK needs SciPy 1.0+")
try:
import scipy.linalg.cython_blas
has_blas = True
except ImportError:
has_blas = False
needs_blas = unittest.skipUnless(has_blas, "BLAS needs SciPy 1.0+")
class CompilationCache(object):
"""
A cache of compilation results for various signatures and flags.
This can make tests significantly faster (or less slow).
"""
def __init__(self):
self.typingctx = typing.Context()
self.targetctx = cpu.CPUContext(self.typingctx)
self.cr_cache = {}
def compile(self, func, args, return_type=None, flags=DEFAULT_FLAGS):
"""
Compile the function or retrieve an already compiled result
from the cache.
"""
from numba.core.registry import cpu_target
cache_key = (func, args, return_type, flags)
if cache_key in self.cr_cache:
cr = self.cr_cache[cache_key]
else:
# Register the contexts in case for nested @jit or @overload calls
# (same as compile_isolated())
with cpu_target.nested_context(self.typingctx, self.targetctx):
cr = compile_extra(self.typingctx, self.targetctx, func,
args, return_type, flags, locals={})
self.cr_cache[cache_key] = cr
return cr
class TestCase(unittest.TestCase):
longMessage = True
# A random state yielding the same random numbers for any test case.
# Use as `self.random.<method name>`
@utils.cached_property
def random(self):
return np.random.RandomState(42)
def reset_module_warnings(self, module):
"""
Reset the warnings registry of a module. This can be necessary
as the warnings module is buggy in that regard.
See http://bugs.python.org/issue4180
"""
if isinstance(module, str):
module = sys.modules[module]
try:
del module.__warningregistry__
except AttributeError:
pass
@contextlib.contextmanager
def assertTypingError(self):
"""
A context manager that asserts the enclosed code block fails
compiling in nopython mode.
"""
_accepted_errors = (errors.LoweringError, errors.TypingError,
TypeError, NotImplementedError)
with self.assertRaises(_accepted_errors) as cm:
yield cm
@contextlib.contextmanager
def assertRefCount(self, *objects):
"""
A context manager that asserts the given objects have the
same reference counts before and after executing the
enclosed block.
"""
old_refcounts = [sys.getrefcount(x) for x in objects]
yield
new_refcounts = [sys.getrefcount(x) for x in objects]
for old, new, obj in zip(old_refcounts, new_refcounts, objects):
if old != new:
self.fail("Refcount changed from %d to %d for object: %r"
% (old, new, obj))
@contextlib.contextmanager
def assertNoNRTLeak(self):
"""
A context manager that asserts no NRT leak was created during
the execution of the enclosed block.
"""
old = rtsys.get_allocation_stats()
yield
new = rtsys.get_allocation_stats()
total_alloc = new.alloc - old.alloc
total_free = new.free - old.free
total_mi_alloc = new.mi_alloc - old.mi_alloc
total_mi_free = new.mi_free - old.mi_free
self.assertEqual(total_alloc, total_free,
"number of data allocs != number of data frees")
self.assertEqual(total_mi_alloc, total_mi_free,
"number of meminfo allocs != number of meminfo frees")
_bool_types = (bool, np.bool_)
_exact_typesets = [_bool_types, (int,), (str,), (np.integer,),
(bytes, np.bytes_)]
_approx_typesets = [(float,), (complex,), (np.inexact)]
_sequence_typesets = [(tuple, list)]
_float_types = (float, np.floating)
_complex_types = (complex, np.complexfloating)
def _detect_family(self, numeric_object):
"""
This function returns a string description of the type family
that the object in question belongs to. Possible return values
are: "exact", "complex", "approximate", "sequence", and "unknown"
"""
if isinstance(numeric_object, np.ndarray):
return "ndarray"
if isinstance(numeric_object, enum.Enum):
return "enum"
for tp in self._sequence_typesets:
if isinstance(numeric_object, tp):
return "sequence"
for tp in self._exact_typesets:
if isinstance(numeric_object, tp):
return "exact"
for tp in self._complex_types:
if isinstance(numeric_object, tp):
return "complex"
for tp in self._approx_typesets:
if isinstance(numeric_object, tp):
return "approximate"
return "unknown"
def _fix_dtype(self, dtype):
"""
Fix the given *dtype* for comparison.
"""
# Under 64-bit Windows, Numpy may return either int32 or int64
# arrays depending on the function.
if (sys.platform == 'win32' and sys.maxsize > 2**32 and
dtype == np.dtype('int32')):
return np.dtype('int64')
else:
return dtype
def _fix_strides(self, arr):
"""
Return the strides of the given array, fixed for comparison.
Strides for 0- or 1-sized dimensions are ignored.
"""
if arr.size == 0:
return [0] * arr.ndim
else:
return [stride / arr.itemsize
for (stride, shape) in zip(arr.strides, arr.shape)
if shape > 1]
def assertStridesEqual(self, first, second):
"""
Test that two arrays have the same shape and strides.
"""
self.assertEqual(first.shape, second.shape, "shapes differ")
self.assertEqual(first.itemsize, second.itemsize, "itemsizes differ")
self.assertEqual(self._fix_strides(first), self._fix_strides(second),
"strides differ")
def assertPreciseEqual(self, first, second, prec='exact', ulps=1,
msg=None, ignore_sign_on_zero=False,
abs_tol=None
):
"""
Versatile equality testing function with more built-in checks than
standard assertEqual().
For arrays, test that layout, dtype, shape are identical, and
recursively call assertPreciseEqual() on the contents.
For other sequences, recursively call assertPreciseEqual() on
the contents.
For scalars, test that two scalars or have similar types and are
equal up to a computed precision.
If the scalars are instances of exact types or if *prec* is
'exact', they are compared exactly.
If the scalars are instances of inexact types (float, complex)
and *prec* is not 'exact', then the number of significant bits
is computed according to the value of *prec*: 53 bits if *prec*
is 'double', 24 bits if *prec* is single. This number of bits
can be lowered by raising the *ulps* value.
ignore_sign_on_zero can be set to True if zeros are to be considered
equal regardless of their sign bit.
abs_tol if this is set to a float value its value is used in the
following. If, however, this is set to the string "eps" then machine
precision of the type(first) is used in the following instead. This
kwarg is used to check if the absolute difference in value between first
and second is less than the value set, if so the numbers being compared
are considered equal. (This is to handle small numbers typically of
magnitude less than machine precision).
Any value of *prec* other than 'exact', 'single' or 'double'
will raise an error.
"""
try:
self._assertPreciseEqual(first, second, prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
except AssertionError as exc:
failure_msg = str(exc)
# Fall off of the 'except' scope to avoid Python 3 exception
# chaining.
else:
return
# Decorate the failure message with more information
self.fail("when comparing %s and %s: %s" % (first, second, failure_msg))
def _assertPreciseEqual(self, first, second, prec='exact', ulps=1,
msg=None, ignore_sign_on_zero=False,
abs_tol=None):
"""Recursive workhorse for assertPreciseEqual()."""
def _assertNumberEqual(first, second, delta=None):
if (delta is None or first == second == 0.0
or math.isinf(first) or math.isinf(second)):
self.assertEqual(first, second, msg=msg)
# For signed zeros
if not ignore_sign_on_zero:
try:
if math.copysign(1, first) != math.copysign(1, second):
self.fail(
self._formatMessage(msg,
"%s != %s" %
(first, second)))
except TypeError:
pass
else:
self.assertAlmostEqual(first, second, delta=delta, msg=msg)
first_family = self._detect_family(first)
second_family = self._detect_family(second)
assertion_message = "Type Family mismatch. (%s != %s)" % (first_family,
second_family)
if msg:
assertion_message += ': %s' % (msg,)
self.assertEqual(first_family, second_family, msg=assertion_message)
# We now know they are in the same comparison family
compare_family = first_family
# For recognized sequences, recurse
if compare_family == "ndarray":
dtype = self._fix_dtype(first.dtype)
self.assertEqual(dtype, self._fix_dtype(second.dtype))
self.assertEqual(first.ndim, second.ndim,
"different number of dimensions")
self.assertEqual(first.shape, second.shape,
"different shapes")
self.assertEqual(first.flags.writeable, second.flags.writeable,
"different mutability")
# itemsize is already checked by the dtype test above
self.assertEqual(self._fix_strides(first),
self._fix_strides(second), "different strides")
if first.dtype != dtype:
first = first.astype(dtype)
if second.dtype != dtype:
second = second.astype(dtype)
for a, b in zip(first.flat, second.flat):
self._assertPreciseEqual(a, b, prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
return
elif compare_family == "sequence":
self.assertEqual(len(first), len(second), msg=msg)
for a, b in zip(first, second):
self._assertPreciseEqual(a, b, prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
return
elif compare_family == "exact":
exact_comparison = True
elif compare_family in ["complex", "approximate"]:
exact_comparison = False
elif compare_family == "enum":
self.assertIs(first.__class__, second.__class__)
self._assertPreciseEqual(first.value, second.value,
prec, ulps, msg,
ignore_sign_on_zero, abs_tol)
return
elif compare_family == "unknown":
# Assume these are non-numeric types: we will fall back
# on regular unittest comparison.
self.assertIs(first.__class__, second.__class__)
exact_comparison = True
else:
assert 0, "unexpected family"
# If a Numpy scalar, check the dtype is exactly the same too
# (required for datetime64 and timedelta64).
if hasattr(first, 'dtype') and hasattr(second, 'dtype'):
self.assertEqual(first.dtype, second.dtype)
# Mixing bools and non-bools should always fail
if (isinstance(first, self._bool_types) !=
isinstance(second, self._bool_types)):
assertion_message = ("Mismatching return types (%s vs. %s)"
% (first.__class__, second.__class__))
if msg:
assertion_message += ': %s' % (msg,)
self.fail(assertion_message)
try:
if cmath.isnan(first) and cmath.isnan(second):
# The NaNs will compare unequal, skip regular comparison
return
except TypeError:
# Not floats.
pass
# if absolute comparison is set, use it
if abs_tol is not None:
if abs_tol == "eps":
rtol = np.finfo(type(first)).eps
elif isinstance(abs_tol, float):
rtol = abs_tol
else:
raise ValueError("abs_tol is not \"eps\" or a float, found %s"
% abs_tol)
if abs(first - second) < rtol:
return
exact_comparison = exact_comparison or prec == 'exact'
if not exact_comparison and prec != 'exact':
if prec == 'single':
bits = 24
elif prec == 'double':
bits = 53
else:
raise ValueError("unsupported precision %r" % (prec,))
k = 2 ** (ulps - bits - 1)
delta = k * (abs(first) + abs(second))
else:
delta = None
if isinstance(first, self._complex_types):
_assertNumberEqual(first.real, second.real, delta)
_assertNumberEqual(first.imag, second.imag, delta)
elif isinstance(first, (np.timedelta64, np.datetime64)):
# Since Np 1.16 NaT == NaT is False, so special comparison needed
if numpy_support.numpy_version >= (1, 16) and np.isnat(first):
self.assertEqual(np.isnat(first), np.isnat(second))
else:
_assertNumberEqual(first, second, delta)
else:
_assertNumberEqual(first, second, delta)
def run_nullary_func(self, pyfunc, flags):
"""
Compile the 0-argument *pyfunc* with the given *flags*, and check
it returns the same result as the pure Python function.
The got and expected results are returned.
"""
cr = compile_isolated(pyfunc, (), flags=flags)
cfunc = cr.entry_point
expected = pyfunc()
got = cfunc()
self.assertPreciseEqual(got, expected)
return got, expected
class SerialMixin(object):
"""Mixin to mark test for serial execution.
"""
_numba_parallel_test_ = False
# Various helpers
@contextlib.contextmanager
def override_config(name, value):
"""
Return a context manager that temporarily sets Numba config variable
*name* to *value*. *name* must be the name of an existing variable
in numba.config.
"""
old_value = getattr(config, name)
setattr(config, name, value)
try:
yield
finally:
setattr(config, name, old_value)
@contextlib.contextmanager
def override_env_config(name, value):
"""
Return a context manager that temporarily sets an Numba config environment
*name* to *value*.
"""
old = os.environ.get(name)
os.environ[name] = value
config.reload_config()
try:
yield
finally:
if old is None:
# If it wasn't set originally, delete the environ var
del os.environ[name]
else:
# Otherwise, restore to the old value
os.environ[name] = old
# Always reload config
config.reload_config()
def compile_function(name, code, globs):
"""
Given a *code* string, compile it with globals *globs* and return
the function named *name*.
"""
co = compile(code.rstrip(), "<string>", "single")
ns = {}
eval(co, globs, ns)
return ns[name]
def tweak_code(func, codestring=None, consts=None):
"""
Tweak the code object of the given function by replacing its
*codestring* (a bytes object) and *consts* tuple, optionally.
"""
co = func.__code__
tp = type(co)
if codestring is None:
codestring = co.co_code
if consts is None:
consts = co.co_consts
if utils.PYVERSION >= (3, 8):
new_code = tp(co.co_argcount, co.co_posonlyargcount,
co.co_kwonlyargcount, co.co_nlocals,
co.co_stacksize, co.co_flags, codestring,
consts, co.co_names, co.co_varnames,
co.co_filename, co.co_name, co.co_firstlineno,
co.co_lnotab)
else:
new_code = tp(co.co_argcount, co.co_kwonlyargcount, co.co_nlocals,
co.co_stacksize, co.co_flags, codestring,
consts, co.co_names, co.co_varnames,
co.co_filename, co.co_name, co.co_firstlineno,
co.co_lnotab)
func.__code__ = new_code
_trashcan_dir = 'numba-tests'
if os.name == 'nt':
# Under Windows, gettempdir() points to the user-local temp dir
_trashcan_dir = os.path.join(tempfile.gettempdir(), _trashcan_dir)
else:
# Mix the UID into the directory name to allow different users to
# run the test suite without permission errors (issue #1586)
_trashcan_dir = os.path.join(tempfile.gettempdir(),
"%s.%s" % (_trashcan_dir, os.getuid()))
# Stale temporary directories are deleted after they are older than this value.
# The test suite probably won't ever take longer than this...
_trashcan_timeout = 24 * 3600 # 1 day
def _create_trashcan_dir():
try:
os.mkdir(_trashcan_dir)
except OSError as e:
if e.errno != errno.EEXIST:
raise
def _purge_trashcan_dir():
freshness_threshold = time.time() - _trashcan_timeout
for fn in sorted(os.listdir(_trashcan_dir)):
fn = os.path.join(_trashcan_dir, fn)
try:
st = os.stat(fn)
if st.st_mtime < freshness_threshold:
shutil.rmtree(fn, ignore_errors=True)
except OSError as e:
# In parallel testing, several processes can attempt to
# remove the same entry at once, ignore.
pass
def _create_trashcan_subdir(prefix):
_purge_trashcan_dir()
path = tempfile.mkdtemp(prefix=prefix + '-', dir=_trashcan_dir)
return path
def temp_directory(prefix):
"""
Create a temporary directory with the given *prefix* that will survive
at least as long as this process invocation. The temporary directory
will be eventually deleted when it becomes stale enough.
This is necessary because a DLL file can't be deleted while in use
under Windows.
An interesting side-effect is to be able to inspect the test files
shortly after a test suite run.
"""
_create_trashcan_dir()
return _create_trashcan_subdir(prefix)
def import_dynamic(modname):
"""
Import and return a module of the given name. Care is taken to
avoid issues due to Python's internal directory caching.
"""
import importlib
importlib.invalidate_caches()
__import__(modname)
return sys.modules[modname]
# From CPython
@contextlib.contextmanager
def captured_output(stream_name):
"""Return a context manager used by captured_stdout/stdin/stderr
that temporarily replaces the sys stream *stream_name* with a StringIO."""
orig_stdout = getattr(sys, stream_name)
setattr(sys, stream_name, io.StringIO())
try:
yield getattr(sys, stream_name)
finally:
setattr(sys, stream_name, orig_stdout)
def captured_stdout():
"""Capture the output of sys.stdout:
with captured_stdout() as stdout:
print("hello")
self.assertEqual(stdout.getvalue(), "hello\n")
"""
return captured_output("stdout")
def captured_stderr():
"""Capture the output of sys.stderr:
with captured_stderr() as stderr:
print("hello", file=sys.stderr)
self.assertEqual(stderr.getvalue(), "hello\n")
"""
return captured_output("stderr")
@contextlib.contextmanager
def capture_cache_log():
with captured_stdout() as out:
with override_config('DEBUG_CACHE', True):
yield out
class MemoryLeak(object):
__enable_leak_check = True
def memory_leak_setup(self):
# Clean up any NRT-backed objects hanging in a dead reference cycle
gc.collect()
self.__init_stats = rtsys.get_allocation_stats()
def memory_leak_teardown(self):
if self.__enable_leak_check:
self.assert_no_memory_leak()
def assert_no_memory_leak(self):
old = self.__init_stats
new = rtsys.get_allocation_stats()
total_alloc = new.alloc - old.alloc
total_free = new.free - old.free
total_mi_alloc = new.mi_alloc - old.mi_alloc
total_mi_free = new.mi_free - old.mi_free
self.assertEqual(total_alloc, total_free)
self.assertEqual(total_mi_alloc, total_mi_free)
def disable_leak_check(self):
# For per-test use when MemoryLeakMixin is injected into a TestCase
self.__enable_leak_check = False
class MemoryLeakMixin(MemoryLeak):
def setUp(self):
super(MemoryLeakMixin, self).setUp()
self.memory_leak_setup()
def tearDown(self):
super(MemoryLeakMixin, self).tearDown()
gc.collect()
self.memory_leak_teardown()
@contextlib.contextmanager
def forbid_codegen():
"""
Forbid LLVM code generation during the execution of the context
manager's enclosed block.
If code generation is invoked, a RuntimeError is raised.
"""
from numba.core import codegen
patchpoints = ['CodeLibrary._finalize_final_module']
old = {}
def fail(*args, **kwargs):
raise RuntimeError("codegen forbidden by test case")
try:
# XXX use the mock library instead?
for name in patchpoints:
parts = name.split('.')
obj = codegen
for attrname in parts[:-1]:
obj = getattr(obj, attrname)
attrname = parts[-1]
value = getattr(obj, attrname)
assert callable(value), ("%r should be callable" % name)
old[obj, attrname] = value
setattr(obj, attrname, fail)
yield
finally:
for (obj, attrname), value in old.items():
setattr(obj, attrname, value)
# For details about redirection of file-descriptor, read
# https://eli.thegreenplace.net/2015/redirecting-all-kinds-of-stdout-in-python/
@contextlib.contextmanager
def redirect_fd(fd):
"""
Temporarily redirect *fd* to a pipe's write end and return a file object
wrapping the pipe's read end.
"""
from numba import _helperlib
libnumba = ctypes.CDLL(_helperlib.__file__)
libnumba._numba_flush_stdout()
save = os.dup(fd)
r, w = os.pipe()
try:
os.dup2(w, fd)
yield io.open(r, "r")
finally:
libnumba._numba_flush_stdout()
os.close(w)
os.dup2(save, fd)
os.close(save)
def redirect_c_stdout():
"""Redirect C stdout
"""
fd = sys.__stdout__.fileno()
return redirect_fd(fd)
def run_in_new_process_caching(func, cache_dir_prefix=__name__, verbose=True):
"""Spawn a new process to run `func` with a temporary cache directory.
The childprocess's stdout and stderr will be captured and redirected to
the current process's stdout and stderr.
Returns
-------
ret : dict
exitcode: 0 for success. 1 for exception-raised.
stdout: str
stderr: str
"""
cache_dir = temp_directory(cache_dir_prefix)
return run_in_new_process_in_cache_dir(func, cache_dir, verbose=verbose)
def run_in_new_process_in_cache_dir(func, cache_dir, verbose=True):
"""Spawn a new process to run `func` with a temporary cache directory.
The childprocess's stdout and stderr will be captured and redirected to
the current process's stdout and stderr.
Similar to ``run_in_new_process_caching()`` but the ``cache_dir`` is a
directory path instead of a name prefix for the directory path.
Returns
-------
ret : dict
exitcode: 0 for success. 1 for exception-raised.
stdout: str
stderr: str
"""
ctx = mp.get_context('spawn')
qout = ctx.Queue()
with override_env_config('NUMBA_CACHE_DIR', cache_dir):
proc = ctx.Process(target=_remote_runner, args=[func, qout])
proc.start()
proc.join()
stdout = qout.get_nowait()
stderr = qout.get_nowait()
if verbose and stdout.strip():
print()
print('STDOUT'.center(80, '-'))
print(stdout)
if verbose and stderr.strip():
print(file=sys.stderr)
print('STDERR'.center(80, '-'), file=sys.stderr)
print(stderr, file=sys.stderr)
return {
'exitcode': proc.exitcode,
'stdout': stdout,
'stderr': stderr,
}
def _remote_runner(fn, qout):
"""Used by `run_in_new_process_caching()`
"""
with captured_stderr() as stderr:
with captured_stdout() as stdout:
try:
fn()
except Exception:
traceback.print_exc()
exitcode = 1
else:
exitcode = 0
qout.put(stdout.getvalue())
qout.put(stderr.getvalue())
sys.exit(exitcode)
class CheckWarningsMixin(object):
@contextlib.contextmanager
def check_warnings(self, messages, category=RuntimeWarning):
with warnings.catch_warnings(record=True) as catch:
warnings.simplefilter("always")
yield
found = 0
for w in catch:
for m in messages:
if m in str(w.message):
self.assertEqual(w.category, category)
found += 1
self.assertEqual(found, len(messages))
|
distributed.py
|
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""Distributed helpers."""
import multiprocessing
import os
import signal
import threading
import traceback
import torch
from xcom.core.config import cfg
def is_master_proc():
"""Determines if the current process is the master process.
Master process is responsible for logging, writing and loading checkpoints. In
the multi GPU setting, we assign the master role to the rank 0 process. When
training using a single GPU, there is a single process which is considered master.
"""
return cfg.NUM_GPUS == 1 or torch.distributed.get_rank() == 0
def init_process_group(proc_rank, world_size):
"""Initializes the default process group."""
# Set the GPU to use
torch.cuda.set_device(proc_rank)
# Initialize the process group
torch.distributed.init_process_group(
backend=cfg.DIST_BACKEND,
init_method="tcp://{}:{}".format(cfg.HOST, cfg.PORT),
world_size=world_size,
rank=proc_rank,
)
def destroy_process_group():
"""Destroys the default process group."""
torch.distributed.destroy_process_group()
def scaled_all_reduce(tensors):
"""Performs the scaled all_reduce operation on the provided tensors.
The input tensors are modified in-place. Currently supports only the sum
reduction operator. The reduced values are scaled by the inverse size of the
process group (equivalent to cfg.NUM_GPUS).
"""
# There is no need for reduction in the single-proc case
if cfg.NUM_GPUS == 1:
return tensors
# Queue the reductions
reductions = []
for tensor in tensors:
reduction = torch.distributed.all_reduce(tensor, async_op=True)
reductions.append(reduction)
# Wait for reductions to finish
for reduction in reductions:
reduction.wait()
# Scale the results
for tensor in tensors:
tensor.mul_(1.0 / cfg.NUM_GPUS)
return tensors
class ChildException(Exception):
"""Wraps an exception from a child process."""
def __init__(self, child_trace):
super(ChildException, self).__init__(child_trace)
class ErrorHandler(object):
"""Multiprocessing error handler (based on fairseq's).
Listens for errors in child processes and propagates the tracebacks to the parent.
"""
def __init__(self, error_queue):
# Shared error queue
self.error_queue = error_queue
# Children processes sharing the error queue
self.children_pids = []
# Start a thread listening to errors
self.error_listener = threading.Thread(target=self.listen, daemon=True)
self.error_listener.start()
# Register the signal handler
signal.signal(signal.SIGUSR1, self.signal_handler)
def add_child(self, pid):
"""Registers a child process."""
self.children_pids.append(pid)
def listen(self):
"""Listens for errors in the error queue."""
# Wait until there is an error in the queue
child_trace = self.error_queue.get()
# Put the error back for the signal handler
self.error_queue.put(child_trace)
# Invoke the signal handler
os.kill(os.getpid(), signal.SIGUSR1)
def signal_handler(self, _sig_num, _stack_frame):
"""Signal handler."""
# Kill children processes
for pid in self.children_pids:
os.kill(pid, signal.SIGINT)
# Propagate the error from the child process
raise ChildException(self.error_queue.get())
def run(proc_rank, world_size, error_queue, fun, fun_args, fun_kwargs):
"""Runs a function from a child process."""
try:
# Initialize the process group
init_process_group(proc_rank, world_size)
# Run the function
fun(*fun_args, **fun_kwargs)
except KeyboardInterrupt:
# Killed by the parent process
pass
except Exception:
# Propagate exception to the parent process
error_queue.put(traceback.format_exc())
finally:
# Destroy the process group
destroy_process_group()
def multi_proc_run(num_proc, fun, fun_args=(), fun_kwargs=None):
"""Runs a function in a multi-proc setting (unless num_proc == 1)."""
# There is no need for multi-proc in the single-proc case
fun_kwargs = fun_kwargs if fun_kwargs else {}
if num_proc == 1:
fun(*fun_args, **fun_kwargs)
return
# Handle errors from training subprocesses
error_queue = multiprocessing.SimpleQueue()
error_handler = ErrorHandler(error_queue)
# Run each training subprocess
ps = []
for i in range(num_proc):
p_i = multiprocessing.Process(
target=run, args=(i, num_proc, error_queue, fun, fun_args, fun_kwargs)
)
ps.append(p_i)
p_i.start()
error_handler.add_child(p_i.pid)
# Wait for each subprocess to finish
for p in ps:
p.join()
|
test_dbapi.py
|
# pysqlite2/test/dbapi.py: tests for DB-API compliance
#
# Copyright (C) 2004-2010 Gerhard Häring <[email protected]>
#
# This file is part of pysqlite.
#
# This software is provided 'as-is', without any express or implied
# warranty. In no event will the authors be held liable for any damages
# arising from the use of this software.
#
# Permission is granted to anyone to use this software for any purpose,
# including commercial applications, and to alter it and redistribute it
# freely, subject to the following restrictions:
#
# 1. The origin of this software must not be misrepresented; you must not
# claim that you wrote the original software. If you use this software
# in a product, an acknowledgment in the product documentation would be
# appreciated but is not required.
# 2. Altered source versions must be plainly marked as such, and must not be
# misrepresented as being the original software.
# 3. This notice may not be removed or altered from any source distribution.
import contextlib
import sqlite3 as sqlite
import subprocess
import sys
import threading
import unittest
from test.support import (
SHORT_TIMEOUT,
check_disallow_instantiation,
threading_helper,
)
from test.support.os_helper import TESTFN, unlink, temp_dir
# Helper for tests using TESTFN
@contextlib.contextmanager
def managed_connect(*args, in_mem=False, **kwargs):
cx = sqlite.connect(*args, **kwargs)
try:
yield cx
finally:
cx.close()
if not in_mem:
unlink(TESTFN)
# Helper for temporary memory databases
def memory_database(*args, **kwargs):
cx = sqlite.connect(":memory:", *args, **kwargs)
return contextlib.closing(cx)
# Temporarily limit a database connection parameter
@contextlib.contextmanager
def cx_limit(cx, category=sqlite.SQLITE_LIMIT_SQL_LENGTH, limit=128):
try:
_prev = cx.setlimit(category, limit)
yield limit
finally:
cx.setlimit(category, _prev)
class ModuleTests(unittest.TestCase):
def test_api_level(self):
self.assertEqual(sqlite.apilevel, "2.0",
"apilevel is %s, should be 2.0" % sqlite.apilevel)
def test_thread_safety(self):
self.assertIn(sqlite.threadsafety, {0, 1, 3},
"threadsafety is %d, should be 0, 1 or 3" %
sqlite.threadsafety)
def test_param_style(self):
self.assertEqual(sqlite.paramstyle, "qmark",
"paramstyle is '%s', should be 'qmark'" %
sqlite.paramstyle)
def test_warning(self):
self.assertTrue(issubclass(sqlite.Warning, Exception),
"Warning is not a subclass of Exception")
def test_error(self):
self.assertTrue(issubclass(sqlite.Error, Exception),
"Error is not a subclass of Exception")
def test_interface_error(self):
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
"InterfaceError is not a subclass of Error")
def test_database_error(self):
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
"DatabaseError is not a subclass of Error")
def test_data_error(self):
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
"DataError is not a subclass of DatabaseError")
def test_operational_error(self):
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
"OperationalError is not a subclass of DatabaseError")
def test_integrity_error(self):
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
"IntegrityError is not a subclass of DatabaseError")
def test_internal_error(self):
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
"InternalError is not a subclass of DatabaseError")
def test_programming_error(self):
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
"ProgrammingError is not a subclass of DatabaseError")
def test_not_supported_error(self):
self.assertTrue(issubclass(sqlite.NotSupportedError,
sqlite.DatabaseError),
"NotSupportedError is not a subclass of DatabaseError")
def test_module_constants(self):
consts = [
"SQLITE_ABORT",
"SQLITE_ALTER_TABLE",
"SQLITE_ANALYZE",
"SQLITE_ATTACH",
"SQLITE_AUTH",
"SQLITE_BUSY",
"SQLITE_CANTOPEN",
"SQLITE_CONSTRAINT",
"SQLITE_CORRUPT",
"SQLITE_CREATE_INDEX",
"SQLITE_CREATE_TABLE",
"SQLITE_CREATE_TEMP_INDEX",
"SQLITE_CREATE_TEMP_TABLE",
"SQLITE_CREATE_TEMP_TRIGGER",
"SQLITE_CREATE_TEMP_VIEW",
"SQLITE_CREATE_TRIGGER",
"SQLITE_CREATE_VIEW",
"SQLITE_CREATE_VTABLE",
"SQLITE_DELETE",
"SQLITE_DENY",
"SQLITE_DETACH",
"SQLITE_DONE",
"SQLITE_DROP_INDEX",
"SQLITE_DROP_TABLE",
"SQLITE_DROP_TEMP_INDEX",
"SQLITE_DROP_TEMP_TABLE",
"SQLITE_DROP_TEMP_TRIGGER",
"SQLITE_DROP_TEMP_VIEW",
"SQLITE_DROP_TRIGGER",
"SQLITE_DROP_VIEW",
"SQLITE_DROP_VTABLE",
"SQLITE_EMPTY",
"SQLITE_ERROR",
"SQLITE_FORMAT",
"SQLITE_FULL",
"SQLITE_FUNCTION",
"SQLITE_IGNORE",
"SQLITE_INSERT",
"SQLITE_INTERNAL",
"SQLITE_INTERRUPT",
"SQLITE_IOERR",
"SQLITE_LOCKED",
"SQLITE_MISMATCH",
"SQLITE_MISUSE",
"SQLITE_NOLFS",
"SQLITE_NOMEM",
"SQLITE_NOTADB",
"SQLITE_NOTFOUND",
"SQLITE_OK",
"SQLITE_PERM",
"SQLITE_PRAGMA",
"SQLITE_PROTOCOL",
"SQLITE_RANGE",
"SQLITE_READ",
"SQLITE_READONLY",
"SQLITE_REINDEX",
"SQLITE_ROW",
"SQLITE_SAVEPOINT",
"SQLITE_SCHEMA",
"SQLITE_SELECT",
"SQLITE_TOOBIG",
"SQLITE_TRANSACTION",
"SQLITE_UPDATE",
# Run-time limit categories
"SQLITE_LIMIT_LENGTH",
"SQLITE_LIMIT_SQL_LENGTH",
"SQLITE_LIMIT_COLUMN",
"SQLITE_LIMIT_EXPR_DEPTH",
"SQLITE_LIMIT_COMPOUND_SELECT",
"SQLITE_LIMIT_VDBE_OP",
"SQLITE_LIMIT_FUNCTION_ARG",
"SQLITE_LIMIT_ATTACHED",
"SQLITE_LIMIT_LIKE_PATTERN_LENGTH",
"SQLITE_LIMIT_VARIABLE_NUMBER",
"SQLITE_LIMIT_TRIGGER_DEPTH",
]
if sqlite.sqlite_version_info >= (3, 7, 17):
consts += ["SQLITE_NOTICE", "SQLITE_WARNING"]
if sqlite.sqlite_version_info >= (3, 8, 3):
consts.append("SQLITE_RECURSIVE")
if sqlite.sqlite_version_info >= (3, 8, 7):
consts.append("SQLITE_LIMIT_WORKER_THREADS")
consts += ["PARSE_DECLTYPES", "PARSE_COLNAMES"]
# Extended result codes
consts += [
"SQLITE_ABORT_ROLLBACK",
"SQLITE_BUSY_RECOVERY",
"SQLITE_CANTOPEN_FULLPATH",
"SQLITE_CANTOPEN_ISDIR",
"SQLITE_CANTOPEN_NOTEMPDIR",
"SQLITE_CORRUPT_VTAB",
"SQLITE_IOERR_ACCESS",
"SQLITE_IOERR_BLOCKED",
"SQLITE_IOERR_CHECKRESERVEDLOCK",
"SQLITE_IOERR_CLOSE",
"SQLITE_IOERR_DELETE",
"SQLITE_IOERR_DELETE_NOENT",
"SQLITE_IOERR_DIR_CLOSE",
"SQLITE_IOERR_DIR_FSYNC",
"SQLITE_IOERR_FSTAT",
"SQLITE_IOERR_FSYNC",
"SQLITE_IOERR_LOCK",
"SQLITE_IOERR_NOMEM",
"SQLITE_IOERR_RDLOCK",
"SQLITE_IOERR_READ",
"SQLITE_IOERR_SEEK",
"SQLITE_IOERR_SHMLOCK",
"SQLITE_IOERR_SHMMAP",
"SQLITE_IOERR_SHMOPEN",
"SQLITE_IOERR_SHMSIZE",
"SQLITE_IOERR_SHORT_READ",
"SQLITE_IOERR_TRUNCATE",
"SQLITE_IOERR_UNLOCK",
"SQLITE_IOERR_WRITE",
"SQLITE_LOCKED_SHAREDCACHE",
"SQLITE_READONLY_CANTLOCK",
"SQLITE_READONLY_RECOVERY",
]
if sqlite.version_info >= (3, 7, 16):
consts += [
"SQLITE_CONSTRAINT_CHECK",
"SQLITE_CONSTRAINT_COMMITHOOK",
"SQLITE_CONSTRAINT_FOREIGNKEY",
"SQLITE_CONSTRAINT_FUNCTION",
"SQLITE_CONSTRAINT_NOTNULL",
"SQLITE_CONSTRAINT_PRIMARYKEY",
"SQLITE_CONSTRAINT_TRIGGER",
"SQLITE_CONSTRAINT_UNIQUE",
"SQLITE_CONSTRAINT_VTAB",
"SQLITE_READONLY_ROLLBACK",
]
if sqlite.version_info >= (3, 7, 17):
consts += [
"SQLITE_IOERR_MMAP",
"SQLITE_NOTICE_RECOVER_ROLLBACK",
"SQLITE_NOTICE_RECOVER_WAL",
]
if sqlite.version_info >= (3, 8, 0):
consts += [
"SQLITE_BUSY_SNAPSHOT",
"SQLITE_IOERR_GETTEMPPATH",
"SQLITE_WARNING_AUTOINDEX",
]
if sqlite.version_info >= (3, 8, 1):
consts += ["SQLITE_CANTOPEN_CONVPATH", "SQLITE_IOERR_CONVPATH"]
if sqlite.version_info >= (3, 8, 2):
consts.append("SQLITE_CONSTRAINT_ROWID")
if sqlite.version_info >= (3, 8, 3):
consts.append("SQLITE_READONLY_DBMOVED")
if sqlite.version_info >= (3, 8, 7):
consts.append("SQLITE_AUTH_USER")
if sqlite.version_info >= (3, 9, 0):
consts.append("SQLITE_IOERR_VNODE")
if sqlite.version_info >= (3, 10, 0):
consts.append("SQLITE_IOERR_AUTH")
if sqlite.version_info >= (3, 14, 1):
consts.append("SQLITE_OK_LOAD_PERMANENTLY")
if sqlite.version_info >= (3, 21, 0):
consts += [
"SQLITE_IOERR_BEGIN_ATOMIC",
"SQLITE_IOERR_COMMIT_ATOMIC",
"SQLITE_IOERR_ROLLBACK_ATOMIC",
]
if sqlite.version_info >= (3, 22, 0):
consts += [
"SQLITE_ERROR_MISSING_COLLSEQ",
"SQLITE_ERROR_RETRY",
"SQLITE_READONLY_CANTINIT",
"SQLITE_READONLY_DIRECTORY",
]
if sqlite.version_info >= (3, 24, 0):
consts += ["SQLITE_CORRUPT_SEQUENCE", "SQLITE_LOCKED_VTAB"]
if sqlite.version_info >= (3, 25, 0):
consts += ["SQLITE_CANTOPEN_DIRTYWAL", "SQLITE_ERROR_SNAPSHOT"]
if sqlite.version_info >= (3, 31, 0):
consts += [
"SQLITE_CANTOPEN_SYMLINK",
"SQLITE_CONSTRAINT_PINNED",
"SQLITE_OK_SYMLINK",
]
if sqlite.version_info >= (3, 32, 0):
consts += [
"SQLITE_BUSY_TIMEOUT",
"SQLITE_CORRUPT_INDEX",
"SQLITE_IOERR_DATA",
]
if sqlite.version_info >= (3, 34, 0):
const.append("SQLITE_IOERR_CORRUPTFS")
for const in consts:
with self.subTest(const=const):
self.assertTrue(hasattr(sqlite, const))
def test_error_code_on_exception(self):
err_msg = "unable to open database file"
if sys.platform.startswith("win"):
err_code = sqlite.SQLITE_CANTOPEN_ISDIR
else:
err_code = sqlite.SQLITE_CANTOPEN
with temp_dir() as db:
with self.assertRaisesRegex(sqlite.Error, err_msg) as cm:
sqlite.connect(db)
e = cm.exception
self.assertEqual(e.sqlite_errorcode, err_code)
self.assertTrue(e.sqlite_errorname.startswith("SQLITE_CANTOPEN"))
@unittest.skipIf(sqlite.sqlite_version_info <= (3, 7, 16),
"Requires SQLite 3.7.16 or newer")
def test_extended_error_code_on_exception(self):
with managed_connect(":memory:", in_mem=True) as con:
with con:
con.execute("create table t(t integer check(t > 0))")
errmsg = "constraint failed"
with self.assertRaisesRegex(sqlite.IntegrityError, errmsg) as cm:
con.execute("insert into t values(-1)")
exc = cm.exception
self.assertEqual(exc.sqlite_errorcode,
sqlite.SQLITE_CONSTRAINT_CHECK)
self.assertEqual(exc.sqlite_errorname, "SQLITE_CONSTRAINT_CHECK")
# sqlite3_enable_shared_cache() is deprecated on macOS and calling it may raise
# OperationalError on some buildbots.
@unittest.skipIf(sys.platform == "darwin", "shared cache is deprecated on macOS")
def test_shared_cache_deprecated(self):
for enable in (True, False):
with self.assertWarns(DeprecationWarning) as cm:
sqlite.enable_shared_cache(enable)
self.assertIn("dbapi.py", cm.filename)
def test_disallow_instantiation(self):
cx = sqlite.connect(":memory:")
check_disallow_instantiation(self, type(cx("select 1")))
def test_complete_statement(self):
self.assertFalse(sqlite.complete_statement("select t"))
self.assertTrue(sqlite.complete_statement("create table t(t);"))
class ConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
cu = self.cx.cursor()
cu.execute("create table test(id integer primary key, name text)")
cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cx.close()
def test_commit(self):
self.cx.commit()
def test_commit_after_no_changes(self):
"""
A commit should also work when no changes were made to the database.
"""
self.cx.commit()
self.cx.commit()
def test_rollback(self):
self.cx.rollback()
def test_rollback_after_no_changes(self):
"""
A rollback should also work when no changes were made to the database.
"""
self.cx.rollback()
self.cx.rollback()
def test_cursor(self):
cu = self.cx.cursor()
def test_failed_open(self):
YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db"
with self.assertRaises(sqlite.OperationalError):
con = sqlite.connect(YOU_CANNOT_OPEN_THIS)
def test_close(self):
self.cx.close()
def test_use_after_close(self):
sql = "select 1"
cu = self.cx.cursor()
res = cu.execute(sql)
self.cx.close()
self.assertRaises(sqlite.ProgrammingError, res.fetchall)
self.assertRaises(sqlite.ProgrammingError, cu.execute, sql)
self.assertRaises(sqlite.ProgrammingError, cu.executemany, sql, [])
self.assertRaises(sqlite.ProgrammingError, cu.executescript, sql)
self.assertRaises(sqlite.ProgrammingError, self.cx.execute, sql)
self.assertRaises(sqlite.ProgrammingError,
self.cx.executemany, sql, [])
self.assertRaises(sqlite.ProgrammingError, self.cx.executescript, sql)
self.assertRaises(sqlite.ProgrammingError,
self.cx.create_function, "t", 1, lambda x: x)
self.assertRaises(sqlite.ProgrammingError, self.cx.cursor)
with self.assertRaises(sqlite.ProgrammingError):
with self.cx:
pass
def test_exceptions(self):
# Optional DB-API extension.
self.assertEqual(self.cx.Warning, sqlite.Warning)
self.assertEqual(self.cx.Error, sqlite.Error)
self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError)
self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError)
self.assertEqual(self.cx.DataError, sqlite.DataError)
self.assertEqual(self.cx.OperationalError, sqlite.OperationalError)
self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError)
self.assertEqual(self.cx.InternalError, sqlite.InternalError)
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
def test_in_transaction(self):
# Can't use db from setUp because we want to test initial state.
cx = sqlite.connect(":memory:")
cu = cx.cursor()
self.assertEqual(cx.in_transaction, False)
cu.execute("create table transactiontest(id integer primary key, name text)")
self.assertEqual(cx.in_transaction, False)
cu.execute("insert into transactiontest(name) values (?)", ("foo",))
self.assertEqual(cx.in_transaction, True)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, True)
cx.commit()
self.assertEqual(cx.in_transaction, False)
cu.execute("select name from transactiontest where name=?", ["foo"])
row = cu.fetchone()
self.assertEqual(cx.in_transaction, False)
def test_in_transaction_ro(self):
with self.assertRaises(AttributeError):
self.cx.in_transaction = True
def test_connection_exceptions(self):
exceptions = [
"DataError",
"DatabaseError",
"Error",
"IntegrityError",
"InterfaceError",
"NotSupportedError",
"OperationalError",
"ProgrammingError",
"Warning",
]
for exc in exceptions:
with self.subTest(exc=exc):
self.assertTrue(hasattr(self.cx, exc))
self.assertIs(getattr(sqlite, exc), getattr(self.cx, exc))
def test_interrupt_on_closed_db(self):
cx = sqlite.connect(":memory:")
cx.close()
with self.assertRaises(sqlite.ProgrammingError):
cx.interrupt()
def test_interrupt(self):
self.assertIsNone(self.cx.interrupt())
def test_drop_unused_refs(self):
for n in range(500):
cu = self.cx.execute(f"select {n}")
self.assertEqual(cu.fetchone()[0], n)
def test_connection_limits(self):
category = sqlite.SQLITE_LIMIT_SQL_LENGTH
saved_limit = self.cx.getlimit(category)
try:
new_limit = 10
prev_limit = self.cx.setlimit(category, new_limit)
self.assertEqual(saved_limit, prev_limit)
self.assertEqual(self.cx.getlimit(category), new_limit)
msg = "query string is too large"
self.assertRaisesRegex(sqlite.DataError, msg,
self.cx.execute, "select 1 as '16'")
finally: # restore saved limit
self.cx.setlimit(category, saved_limit)
def test_connection_bad_limit_category(self):
msg = "'category' is out of bounds"
cat = 1111
self.assertRaisesRegex(sqlite.ProgrammingError, msg,
self.cx.getlimit, cat)
self.assertRaisesRegex(sqlite.ProgrammingError, msg,
self.cx.setlimit, cat, 0)
def test_connection_init_bad_isolation_level(self):
msg = (
"isolation_level string must be '', 'DEFERRED', 'IMMEDIATE', or "
"'EXCLUSIVE'"
)
levels = (
"BOGUS",
" ",
"DEFERRE",
"IMMEDIAT",
"EXCLUSIV",
"DEFERREDS",
"IMMEDIATES",
"EXCLUSIVES",
)
for level in levels:
with self.subTest(level=level):
with self.assertRaisesRegex(ValueError, msg):
memory_database(isolation_level=level)
with memory_database() as cx:
with self.assertRaisesRegex(ValueError, msg):
cx.isolation_level = level
# Check that the default level is not changed
self.assertEqual(cx.isolation_level, "")
def test_connection_init_good_isolation_levels(self):
for level in ("", "DEFERRED", "IMMEDIATE", "EXCLUSIVE", None):
with self.subTest(level=level):
with memory_database(isolation_level=level) as cx:
self.assertEqual(cx.isolation_level, level)
with memory_database() as cx:
self.assertEqual(cx.isolation_level, "")
cx.isolation_level = level
self.assertEqual(cx.isolation_level, level)
def test_connection_reinit(self):
db = ":memory:"
cx = sqlite.connect(db)
cx.text_factory = bytes
cx.row_factory = sqlite.Row
cu = cx.cursor()
cu.execute("create table foo (bar)")
cu.executemany("insert into foo (bar) values (?)",
((str(v),) for v in range(4)))
cu.execute("select bar from foo")
rows = [r for r in cu.fetchmany(2)]
self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
self.assertEqual([r[0] for r in rows], [b"0", b"1"])
cx.__init__(db)
cx.execute("create table foo (bar)")
cx.executemany("insert into foo (bar) values (?)",
((v,) for v in ("a", "b", "c", "d")))
# This uses the old database, old row factory, but new text factory
rows = [r for r in cu.fetchall()]
self.assertTrue(all(isinstance(r, sqlite.Row) for r in rows))
self.assertEqual([r[0] for r in rows], ["2", "3"])
def test_connection_bad_reinit(self):
cx = sqlite.connect(":memory:")
with cx:
cx.execute("create table t(t)")
with temp_dir() as db:
self.assertRaisesRegex(sqlite.OperationalError,
"unable to open database file",
cx.__init__, db)
self.assertRaisesRegex(sqlite.ProgrammingError,
"Base Connection.__init__ not called",
cx.executemany, "insert into t values(?)",
((v,) for v in range(3)))
class UninitialisedConnectionTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.Connection.__new__(sqlite.Connection)
def test_uninit_operations(self):
funcs = (
lambda: self.cx.isolation_level,
lambda: self.cx.total_changes,
lambda: self.cx.in_transaction,
lambda: self.cx.iterdump(),
lambda: self.cx.cursor(),
lambda: self.cx.close(),
)
for func in funcs:
with self.subTest(func=func):
self.assertRaisesRegex(sqlite.ProgrammingError,
"Base Connection.__init__ not called",
func)
class OpenTests(unittest.TestCase):
_sql = "create table test(id integer)"
def test_open_with_path_like_object(self):
""" Checks that we can successfully connect to a database using an object that
is PathLike, i.e. has __fspath__(). """
class Path:
def __fspath__(self):
return TESTFN
path = Path()
with managed_connect(path) as cx:
cx.execute(self._sql)
def test_open_uri(self):
with managed_connect(TESTFN) as cx:
cx.execute(self._sql)
with managed_connect(f"file:{TESTFN}", uri=True) as cx:
cx.execute(self._sql)
with self.assertRaises(sqlite.OperationalError):
with managed_connect(f"file:{TESTFN}?mode=ro", uri=True) as cx:
cx.execute(self._sql)
def test_database_keyword(self):
with sqlite.connect(database=":memory:") as cx:
self.assertEqual(type(cx), sqlite.Connection)
class CursorTests(unittest.TestCase):
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute(
"create table test(id integer primary key, name text, "
"income number, unique_test text unique)"
)
self.cu.execute("insert into test(name) values (?)", ("foo",))
def tearDown(self):
self.cu.close()
self.cx.close()
def test_execute_no_args(self):
self.cu.execute("delete from test")
def test_execute_illegal_sql(self):
with self.assertRaises(sqlite.OperationalError):
self.cu.execute("select asdf")
def test_execute_too_much_sql(self):
with self.assertRaises(sqlite.Warning):
self.cu.execute("select 5+4; select 4+5")
def test_execute_too_much_sql2(self):
self.cu.execute("select 5+4; -- foo bar")
def test_execute_too_much_sql3(self):
self.cu.execute("""
select 5+4;
/*
foo
*/
""")
def test_execute_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.execute(42)
def test_execute_arg_int(self):
self.cu.execute("insert into test(id) values (?)", (42,))
def test_execute_arg_float(self):
self.cu.execute("insert into test(income) values (?)", (2500.32,))
def test_execute_arg_string(self):
self.cu.execute("insert into test(name) values (?)", ("Hugo",))
def test_execute_arg_string_with_zero_byte(self):
self.cu.execute("insert into test(name) values (?)", ("Hu\x00go",))
self.cu.execute("select name from test where id=?", (self.cu.lastrowid,))
row = self.cu.fetchone()
self.assertEqual(row[0], "Hu\x00go")
def test_execute_non_iterable(self):
with self.assertRaises(ValueError) as cm:
self.cu.execute("insert into test(id) values (?)", 42)
self.assertEqual(str(cm.exception), 'parameters are of unsupported type')
def test_execute_wrong_no_of_args1(self):
# too many parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)", (17, "Egon"))
def test_execute_wrong_no_of_args2(self):
# too little parameters
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_wrong_no_of_args3(self):
# no parameters, parameters are needed
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("insert into test(id) values (?)")
def test_execute_param_list(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", ["foo"])
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence(self):
class L:
def __len__(self):
return 1
def __getitem__(self, x):
assert x == 0
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", L())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_param_sequence_bad_len(self):
# Issue41662: Error in __len__() was overridden with ProgrammingError.
class L:
def __len__(self):
1/0
def __getitem__(slf, x):
raise AssertionError
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(ZeroDivisionError):
self.cu.execute("select name from test where name=?", L())
def test_execute_too_many_params(self):
category = sqlite.SQLITE_LIMIT_VARIABLE_NUMBER
msg = "too many SQL variables"
with cx_limit(self.cx, category=category, limit=1):
self.cu.execute("select * from test where id=?", (1,))
with self.assertRaisesRegex(sqlite.OperationalError, msg):
self.cu.execute("select * from test where id!=? and id!=?",
(1, 2))
def test_execute_dict_mapping(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", {"name": "foo"})
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_mapping(self):
class D(dict):
def __missing__(self, key):
return "foo"
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", D())
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
def test_execute_dict_mapping_too_little_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"})
def test_execute_dict_mapping_no_args(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=:name")
def test_execute_dict_mapping_unnamed(self):
self.cu.execute("insert into test(name) values ('foo')")
with self.assertRaises(sqlite.ProgrammingError):
self.cu.execute("select name from test where name=?", {"name": "foo"})
def test_close(self):
self.cu.close()
def test_rowcount_execute(self):
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("update test set name='bar'")
self.assertEqual(self.cu.rowcount, 2)
def test_rowcount_select(self):
"""
pysqlite does not know the rowcount of SELECT statements, because we
don't fetch all rows after executing the select statement. The rowcount
has thus to be -1.
"""
self.cu.execute("select 5 union select 6")
self.assertEqual(self.cu.rowcount, -1)
def test_rowcount_executemany(self):
self.cu.execute("delete from test")
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
self.assertEqual(self.cu.rowcount, 3)
def test_total_changes(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.assertLess(2, self.cx.total_changes, msg='total changes reported wrong value')
# Checks for executemany:
# Sequences are required by the DB-API, iterators
# enhancements in pysqlite.
def test_execute_many_sequence(self):
self.cu.executemany("insert into test(income) values (?)", [(x,) for x in range(100, 110)])
def test_execute_many_iterator(self):
class MyIter:
def __init__(self):
self.value = 5
def __iter__(self):
return self
def __next__(self):
if self.value == 10:
raise StopIteration
else:
self.value += 1
return (self.value,)
self.cu.executemany("insert into test(income) values (?)", MyIter())
def test_execute_many_generator(self):
def mygen():
for i in range(5):
yield (i,)
self.cu.executemany("insert into test(income) values (?)", mygen())
def test_execute_many_wrong_sql_arg(self):
with self.assertRaises(TypeError):
self.cu.executemany(42, [(3,)])
def test_execute_many_select(self):
with self.assertRaises(sqlite.ProgrammingError):
self.cu.executemany("select ?", [(3,)])
def test_execute_many_not_iterable(self):
with self.assertRaises(TypeError):
self.cu.executemany("insert into test(income) values (?)", 42)
def test_fetch_iter(self):
# Optional DB-API extension.
self.cu.execute("delete from test")
self.cu.execute("insert into test(id) values (?)", (5,))
self.cu.execute("insert into test(id) values (?)", (6,))
self.cu.execute("select id from test order by id")
lst = []
for row in self.cu:
lst.append(row[0])
self.assertEqual(lst[0], 5)
self.assertEqual(lst[1], 6)
def test_fetchone(self):
self.cu.execute("select name from test")
row = self.cu.fetchone()
self.assertEqual(row[0], "foo")
row = self.cu.fetchone()
self.assertEqual(row, None)
def test_fetchone_no_statement(self):
cur = self.cx.cursor()
row = cur.fetchone()
self.assertEqual(row, None)
def test_array_size(self):
# must default to 1
self.assertEqual(self.cu.arraysize, 1)
# now set to 2
self.cu.arraysize = 2
# now make the query return 3 rows
self.cu.execute("delete from test")
self.cu.execute("insert into test(name) values ('A')")
self.cu.execute("insert into test(name) values ('B')")
self.cu.execute("insert into test(name) values ('C')")
self.cu.execute("select name from test")
res = self.cu.fetchmany()
self.assertEqual(len(res), 2)
def test_fetchmany(self):
self.cu.execute("select name from test")
res = self.cu.fetchmany(100)
self.assertEqual(len(res), 1)
res = self.cu.fetchmany(100)
self.assertEqual(res, [])
def test_fetchmany_kw_arg(self):
"""Checks if fetchmany works with keyword arguments"""
self.cu.execute("select name from test")
res = self.cu.fetchmany(size=100)
self.assertEqual(len(res), 1)
def test_fetchall(self):
self.cu.execute("select name from test")
res = self.cu.fetchall()
self.assertEqual(len(res), 1)
res = self.cu.fetchall()
self.assertEqual(res, [])
def test_setinputsizes(self):
self.cu.setinputsizes([3, 4, 5])
def test_setoutputsize(self):
self.cu.setoutputsize(5, 0)
def test_setoutputsize_no_column(self):
self.cu.setoutputsize(42)
def test_cursor_connection(self):
# Optional DB-API extension.
self.assertEqual(self.cu.connection, self.cx)
def test_wrong_cursor_callable(self):
with self.assertRaises(TypeError):
def f(): pass
cur = self.cx.cursor(f)
def test_cursor_wrong_class(self):
class Foo: pass
foo = Foo()
with self.assertRaises(TypeError):
cur = sqlite.Cursor(foo)
def test_last_row_id_on_replace(self):
"""
INSERT OR REPLACE and REPLACE INTO should produce the same behavior.
"""
sql = '{} INTO test(id, unique_test) VALUES (?, ?)'
for statement in ('INSERT OR REPLACE', 'REPLACE'):
with self.subTest(statement=statement):
self.cu.execute(sql.format(statement), (1, 'foo'))
self.assertEqual(self.cu.lastrowid, 1)
def test_last_row_id_on_ignore(self):
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
self.cu.execute(
"insert or ignore into test(unique_test) values (?)",
('test',))
self.assertEqual(self.cu.lastrowid, 2)
def test_last_row_id_insert_o_r(self):
results = []
for statement in ('FAIL', 'ABORT', 'ROLLBACK'):
sql = 'INSERT OR {} INTO test(unique_test) VALUES (?)'
with self.subTest(statement='INSERT OR {}'.format(statement)):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute(sql.format(statement), (statement,))
results.append((statement, self.cu.lastrowid))
expected = [
('FAIL', 2), ('FAIL', 2),
('ABORT', 3), ('ABORT', 3),
('ROLLBACK', 4), ('ROLLBACK', 4),
]
self.assertEqual(results, expected)
def test_column_count(self):
# Check that column count is updated correctly for cached statements
select = "select * from test"
res = self.cu.execute(select)
old_count = len(res.description)
# Add a new column and execute the cached select query again
self.cu.execute("alter table test add newcol")
res = self.cu.execute(select)
new_count = len(res.description)
self.assertEqual(new_count - old_count, 1)
def test_same_query_in_multiple_cursors(self):
cursors = [self.cx.execute("select 1") for _ in range(3)]
for cu in cursors:
self.assertEqual(cu.fetchall(), [(1,)])
class ThreadTests(unittest.TestCase):
def setUp(self):
self.con = sqlite.connect(":memory:")
self.cur = self.con.cursor()
self.cur.execute("create table test(name text)")
def tearDown(self):
self.cur.close()
self.con.close()
@threading_helper.reap_threads
def _run_test(self, fn, *args, **kwds):
def run(err):
try:
fn(*args, **kwds)
err.append("did not raise ProgrammingError")
except sqlite.ProgrammingError:
pass
except:
err.append("raised wrong exception")
err = []
t = threading.Thread(target=run, kwargs={"err": err})
t.start()
t.join()
if err:
self.fail("\n".join(err))
def test_check_connection_thread(self):
fns = [
lambda: self.con.cursor(),
lambda: self.con.commit(),
lambda: self.con.rollback(),
lambda: self.con.close(),
lambda: self.con.set_trace_callback(None),
lambda: self.con.set_authorizer(None),
lambda: self.con.create_collation("foo", None),
lambda: self.con.setlimit(sqlite.SQLITE_LIMIT_LENGTH, -1),
lambda: self.con.getlimit(sqlite.SQLITE_LIMIT_LENGTH),
]
for fn in fns:
with self.subTest(fn=fn):
self._run_test(fn)
def test_check_cursor_thread(self):
fns = [
lambda: self.cur.execute("insert into test(name) values('a')"),
lambda: self.cur.close(),
lambda: self.cur.execute("select name from test"),
lambda: self.cur.fetchone(),
]
for fn in fns:
with self.subTest(fn=fn):
self._run_test(fn)
@threading_helper.reap_threads
def test_dont_check_same_thread(self):
def run(con, err):
try:
con.execute("select 1")
except sqlite.Error:
err.append("multi-threading not allowed")
con = sqlite.connect(":memory:", check_same_thread=False)
err = []
t = threading.Thread(target=run, kwargs={"con": con, "err": err})
t.start()
t.join()
self.assertEqual(len(err), 0, "\n".join(err))
class ConstructorTests(unittest.TestCase):
def test_date(self):
d = sqlite.Date(2004, 10, 28)
def test_time(self):
t = sqlite.Time(12, 39, 35)
def test_timestamp(self):
ts = sqlite.Timestamp(2004, 10, 28, 12, 39, 35)
def test_date_from_ticks(self):
d = sqlite.DateFromTicks(42)
def test_time_from_ticks(self):
t = sqlite.TimeFromTicks(42)
def test_timestamp_from_ticks(self):
ts = sqlite.TimestampFromTicks(42)
def test_binary(self):
b = sqlite.Binary(b"\0'")
class ExtensionTests(unittest.TestCase):
def test_script_string_sql(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.executescript("""
-- bla bla
/* a stupid comment */
create table a(i);
insert into a(i) values (5);
""")
cur.execute("select i from a")
res = cur.fetchone()[0]
self.assertEqual(res, 5)
def test_script_syntax_error(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(x); asdf; create table test2(x)")
def test_script_error_normal(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(sqlite.OperationalError):
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
def test_cursor_executescript_as_bytes(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(TypeError):
cur.executescript(b"create table test(foo); insert into test(foo) values (5);")
def test_cursor_executescript_with_null_characters(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(ValueError):
cur.executescript("""
create table a(i);\0
insert into a(i) values (5);
""")
def test_cursor_executescript_with_surrogates(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
with self.assertRaises(UnicodeEncodeError):
cur.executescript("""
create table a(s);
insert into a(s) values ('\ud8ff');
""")
def test_cursor_executescript_too_large_script(self):
msg = "query string is too large"
with memory_database() as cx, cx_limit(cx) as lim:
cx.executescript("select 'almost too large'".ljust(lim))
with self.assertRaisesRegex(sqlite.DataError, msg):
cx.executescript("select 'too large'".ljust(lim+1))
def test_cursor_executescript_tx_control(self):
con = sqlite.connect(":memory:")
con.execute("begin")
self.assertTrue(con.in_transaction)
con.executescript("select 1")
self.assertFalse(con.in_transaction)
def test_connection_execute(self):
con = sqlite.connect(":memory:")
result = con.execute("select 5").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.execute")
def test_connection_executemany(self):
con = sqlite.connect(":memory:")
con.execute("create table test(foo)")
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
result = con.execute("select foo from test order by foo").fetchall()
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def test_connection_executescript(self):
con = sqlite.connect(":memory:")
con.executescript("create table test(foo); insert into test(foo) values (5);")
result = con.execute("select foo from test").fetchone()[0]
self.assertEqual(result, 5, "Basic test of Connection.executescript")
class ClosedConTests(unittest.TestCase):
def test_closed_con_cursor(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur = con.cursor()
def test_closed_con_commit(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.commit()
def test_closed_con_rollback(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con.rollback()
def test_closed_cur_execute(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
con.close()
with self.assertRaises(sqlite.ProgrammingError):
cur.execute("select 4")
def test_closed_create_function(self):
con = sqlite.connect(":memory:")
con.close()
def f(x): return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_function("foo", 1, f)
def test_closed_create_aggregate(self):
con = sqlite.connect(":memory:")
con.close()
class Agg:
def __init__(self):
pass
def step(self, x):
pass
def finalize(self):
return 17
with self.assertRaises(sqlite.ProgrammingError):
con.create_aggregate("foo", 1, Agg)
def test_closed_set_authorizer(self):
con = sqlite.connect(":memory:")
con.close()
def authorizer(*args):
return sqlite.DENY
with self.assertRaises(sqlite.ProgrammingError):
con.set_authorizer(authorizer)
def test_closed_set_progress_callback(self):
con = sqlite.connect(":memory:")
con.close()
def progress(): pass
with self.assertRaises(sqlite.ProgrammingError):
con.set_progress_handler(progress, 100)
def test_closed_call(self):
con = sqlite.connect(":memory:")
con.close()
with self.assertRaises(sqlite.ProgrammingError):
con()
class ClosedCurTests(unittest.TestCase):
def test_closed(self):
con = sqlite.connect(":memory:")
cur = con.cursor()
cur.close()
for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"):
if method_name in ("execute", "executescript"):
params = ("select 4 union select 5",)
elif method_name == "executemany":
params = ("insert into foo(bar) values (?)", [(3,), (4,)])
else:
params = []
with self.assertRaises(sqlite.ProgrammingError):
method = getattr(cur, method_name)
method(*params)
class SqliteOnConflictTests(unittest.TestCase):
"""
Tests for SQLite's "insert on conflict" feature.
See https://www.sqlite.org/lang_conflict.html for details.
"""
def setUp(self):
self.cx = sqlite.connect(":memory:")
self.cu = self.cx.cursor()
self.cu.execute("""
CREATE TABLE test(
id INTEGER PRIMARY KEY, name TEXT, unique_name TEXT UNIQUE
);
""")
def tearDown(self):
self.cu.close()
self.cx.close()
def test_on_conflict_rollback_with_explicit_transaction(self):
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
# Use connection to commit.
self.cx.commit()
self.cu.execute("SELECT name, unique_name from test")
# Transaction should have rolled back and nothing should be in table.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_with_explicit_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cx.isolation_level = None # autocommit mode
self.cu = self.cx.cursor()
# Start an explicit transaction.
self.cu.execute("BEGIN")
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
self.cx.commit()
self.cu.execute("SELECT name, unique_name FROM test")
# Expect the first two inserts to work, third to do nothing.
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_rollback_without_transaction(self):
# Start of implicit transaction
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ROLLBACK INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT name, unique_name FROM test")
# Implicit transaction is rolled back on error.
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_abort_raises_without_transactions(self):
# Abort cancels the current sql statement but doesn't change anything
# about the current transaction.
self.cu.execute("INSERT INTO test(name) VALUES ('abort_test')")
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR ABORT INTO test(unique_name) VALUES ('foo')")
# Make sure all other values were inserted.
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('abort_test', None), (None, 'foo',)])
def test_on_conflict_fail(self):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
with self.assertRaises(sqlite.IntegrityError):
self.cu.execute("INSERT OR FAIL INTO test(unique_name) VALUES ('foo')")
self.assertEqual(self.cu.fetchall(), [])
def test_on_conflict_ignore(self):
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
# Nothing should happen.
self.cu.execute("INSERT OR IGNORE INTO test(unique_name) VALUES ('foo')")
self.cu.execute("SELECT unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('foo',)])
def test_on_conflict_replace(self):
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Data!', 'foo')")
# There shouldn't be an IntegrityError exception.
self.cu.execute("INSERT OR REPLACE INTO test(name, unique_name) VALUES ('Very different data!', 'foo')")
self.cu.execute("SELECT name, unique_name FROM test")
self.assertEqual(self.cu.fetchall(), [('Very different data!', 'foo')])
class MultiprocessTests(unittest.TestCase):
CONNECTION_TIMEOUT = SHORT_TIMEOUT / 1000. # Defaults to 30 ms
def tearDown(self):
unlink(TESTFN)
def test_ctx_mgr_rollback_if_commit_failed(self):
# bpo-27334: ctx manager does not rollback if commit fails
SCRIPT = f"""if 1:
import sqlite3
def wait():
print("started")
assert "database is locked" in input()
cx = sqlite3.connect("{TESTFN}", timeout={self.CONNECTION_TIMEOUT})
cx.create_function("wait", 0, wait)
with cx:
cx.execute("create table t(t)")
try:
# execute two transactions; both will try to lock the db
cx.executescript('''
-- start a transaction and wait for parent
begin transaction;
select * from t;
select wait();
rollback;
-- start a new transaction; would fail if parent holds lock
begin transaction;
select * from t;
rollback;
''')
finally:
cx.close()
"""
# spawn child process
proc = subprocess.Popen(
[sys.executable, "-c", SCRIPT],
encoding="utf-8",
bufsize=0,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
)
self.addCleanup(proc.communicate)
# wait for child process to start
self.assertEqual("started", proc.stdout.readline().strip())
cx = sqlite.connect(TESTFN, timeout=self.CONNECTION_TIMEOUT)
try: # context manager should correctly release the db lock
with cx:
cx.execute("insert into t values('test')")
except sqlite.OperationalError as exc:
proc.stdin.write(str(exc))
else:
proc.stdin.write("no error")
finally:
cx.close()
# terminate child process
self.assertIsNone(proc.returncode)
try:
proc.communicate(input="end", timeout=SHORT_TIMEOUT)
except subprocess.TimeoutExpired:
proc.kill()
proc.communicate()
raise
self.assertEqual(proc.returncode, 0)
if __name__ == "__main__":
unittest.main()
|
daemon.py
|
from time import sleep, perf_counter
from threading import Thread
import sys
start = perf_counter()
def show(name):
print(f'Starting {name} ...')
sleep(3)
print(f'Finishing {name} ...')
t1 = Thread(target=show, args=('One',))
t2 = Thread(target=show, args=('Two',))
t1.setDaemon(True)
t1.start()
t2.start()
print(t1.isDaemon())
end = perf_counter()
print(round(end - start))
sys.exit()
|
redis.py
|
import redis
import os, time, multiprocess, logging, sys
import json
from compute import Config_ini
from compute.log import Log
from compute.file import get_algo_local_dir, get_population_dir
def get_logger(logger_name, log_file, level=logging.INFO):
l = logging.getLogger(logger_name)
formatter = logging.Formatter('%(message)s')
fileHandler = logging.FileHandler(log_file, mode='a')
fileHandler.setFormatter(formatter)
l.setLevel(level)
l.addHandler(fileHandler)
return logging.getLogger(logger_name)
class RedisLog(object):
MSG_TYPE = ['LOG', 'WRITE_FILE']
def __init__(self, name, db_ip, db_port):
pool = redis.ConnectionPool(host=db_ip, port=int(db_port), socket_connect_timeout=1)
r = redis.Redis(connection_pool=pool, db=1)
connection_flag = True
try:
r.ping()
except Exception as e:
connection_flag = False
Log.info('Connect redis error, please exit manually,ip:%s db_port:%s errors:%s' % (db_ip, db_port, str(e)))
sys.exit()
if connection_flag:
Log.info('Connect redis successfully...')
self.r = r
self.name = name
def info(self, info):
self._writedb('LOG', info)
def write_file(self, fdir, fname, data):
content = {'fdir': fdir, 'fname': fname, 'data': data}
self._writedb('WRITE_FILE', content)
def _writedb(self, msg_type, content):
assert msg_type in self.MSG_TYPE
v = {'name': self.name, 'type': msg_type, 'content': content}
v = json.dumps(v).encode('utf-8')
self.r.rpush('RUN', v)
def _readdb(self):
info = self.r.lpop('RUN')
if info is None:
return None
# print(info)
info = json.loads(info.decode('utf-8'))
return info
@staticmethod
def run_dispatch_service():
Log.info('Start to read message from Redis')
db_ip = Config_ini.log_server
db_port = Config_ini.log_server_port
alg_local_dir = get_algo_local_dir()
population_dir = get_population_dir()
def proc_func():
rdb = RedisLog('', db_ip, db_port)
log_dict = {}
log_dir = os.path.join(alg_local_dir, 'log')
if not os.path.exists(log_dir):
os.makedirs(log_dir)
while True:
data = rdb._readdb()
if data is not None:
name, dtype, content = data['name'], data['type'], data['content']
Log.info('Redis is reading: name:%s, type:%s, content:%s' % (name, dtype, content))
if dtype == 'LOG':
# create logger.
if name not in log_dict:
log_file = os.path.join(log_dir, name)
logger = get_logger(name, log_file)
log_dict[name] = logger
logger = log_dict[name]
logger.info(content)
# print(content)
elif dtype == 'WRITE_FILE':
fdir, fname, fdata = content['fdir'], content['fname'], content['data']
if fdir == 'CACHE' or fdir == 'RESULTS':
fdir = population_dir
if not os.path.exists(fdir):
os.makedirs(fdir)
with open(os.path.join(fdir, fname), 'a+') as f:
f.write(fdata)
f.flush()
else:
assert 0
time.sleep(1)
proc = multiprocess.Process(target=proc_func)
proc.start()
|
adaderana.py
|
import tweepy
import os
import time
import threading
from elasticsearch import Elasticsearch, helpers
from datetime import datetime
from dotenv import load_dotenv
load_dotenv()
consumer_key = os.getenv('consumer_key')
consumer_secret = os.getenv('consumer_secret')
access_key = os.getenv('access_key')
access_secret = os.getenv('access_secret')
es = Elasticsearch([{'host': 'localhost', 'port': 9200}])
es.indices.create(index='twitter_index', ignore=400)
def get_all_tweets(screen_name):
# authorize twitter, initialize tweepy
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_key, access_secret)
api = tweepy.API(auth)
# initialize a list to hold all the tweepy Tweets
alltweets = []
# make initial request for most recent tweets (200 is the maximum allowed count)
new_tweets = api.user_timeline(screen_name=screen_name, count=200)
# save most recent tweets
alltweets.extend(new_tweets)
# save the id of the oldest tweet less one
oldest = alltweets[-1].id - 1
# keep grabbing tweets until there are no tweets left to grab
while len(new_tweets) > 0:
#print
#"getting tweets before %s" % (oldest)
# all subsiquent requests use the max_id param to prevent duplicates
new_tweets = api.user_timeline(screen_name=screen_name, count=200, max_id=oldest)
# save most recent tweets
alltweets.extend(new_tweets)
# update the id of the oldest tweet less one
oldest = alltweets[-1].id - 1
#print
#"...%s tweets downloaded so far" % (len(alltweets))
outtweets = [{'ID': tweet.id_str, 'Text': tweet.text, 'Date': tweet.created_at, 'author': tweet.user.screen_name} for tweet in alltweets]
def save_es(outtweets, es): # Peps8 convention
data = [ # Please without s in data
{
"_index": "twitter_index",
"_type": "adaderana",
"_id": index,
"_source": ID
}
for index, ID in enumerate(outtweets)
]
helpers.bulk(es, data)
save_es(outtweets, es)
print('Run at:')
print(datetime.now())
print("\n")
if __name__ == '__main__':
# pass in the username of the account want to download
get_all_tweets("adaderana")
if __name__ == "__main__":
time.sleep(60)
while True:
thr = threading.Thread(target=get_all_tweets("adaderana"))
thr.start()
time.sleep(3600) # do work every one hour
|
multiprocess.py
|
# 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.
from collections import namedtuple
import logging
from multiprocessing import Process, Manager as MPManager
try:
import queue # python 3
except ImportError:
import Queue as queue # python 2
import time
from ..common import KafkaError
from .base import (
Consumer,
AUTO_COMMIT_MSG_COUNT, AUTO_COMMIT_INTERVAL,
NO_MESSAGES_WAIT_TIME_SECONDS,
FULL_QUEUE_WAIT_TIME_SECONDS,
MAX_BACKOFF_SECONDS,
)
from .simple import SimpleConsumer
log = logging.getLogger(__name__)
Events = namedtuple("Events", ["start", "pause", "exit"])
def _mp_consume(client, group, topic, queue, size, events, **consumer_options):
"""
A child process worker which consumes messages based on the
notifications given by the controller process
NOTE: Ideally, this should have been a method inside the Consumer
class. However, multiprocessing module has issues in windows. The
functionality breaks unless this function is kept outside of a class
"""
# Initial interval for retries in seconds.
interval = 1
while not events.exit.is_set():
try:
# Make the child processes open separate socket connections
client.reinit()
# We will start consumers without auto-commit. Auto-commit will be
# done by the master controller process.
consumer = SimpleConsumer(client, group, topic,
auto_commit=False,
auto_commit_every_n=None,
auto_commit_every_t=None,
**consumer_options)
# Ensure that the consumer provides the partition information
consumer.provide_partition_info()
while True:
# Wait till the controller indicates us to start consumption
events.start.wait()
# If we are asked to quit, do so
if events.exit.is_set():
break
# Consume messages and add them to the queue. If the controller
# indicates a specific number of messages, follow that advice
count = 0
message = consumer.get_message()
if message:
while True:
try:
queue.put(message, timeout=FULL_QUEUE_WAIT_TIME_SECONDS)
break
except queue.Full:
if events.exit.is_set():
break
count += 1
# We have reached the required size. The controller might have
# more than what he needs. Wait for a while.
# Without this logic, it is possible that we run into a big
# loop consuming all available messages before the controller
# can reset the 'start' event
if count == size.value:
events.pause.wait()
else:
# In case we did not receive any message, give up the CPU for
# a while before we try again
time.sleep(NO_MESSAGES_WAIT_TIME_SECONDS)
consumer.stop()
except KafkaError as e:
# Retry with exponential backoff
log.error(
"Problem communicating with Kafka (%s), retrying in %d seconds..." % (e, interval))
time.sleep(interval)
interval = interval * 2 if interval * 2 < MAX_BACKOFF_SECONDS else MAX_BACKOFF_SECONDS
class MultiProcessConsumer(Consumer):
"""
A consumer implementation that consumes partitions for a topic in
parallel using multiple processes
Arguments:
client: a connected KafkaClient
group: a name for this consumer, used for offset storage and must be unique
If you are connecting to a server that does not support offset
commit/fetch (any prior to 0.8.1.1), then you *must* set this to None
topic: the topic to consume
Keyword Arguments:
partitions: An optional list of partitions to consume the data from
auto_commit: default True. Whether or not to auto commit the offsets
auto_commit_every_n: default 100. How many messages to consume
before a commit
auto_commit_every_t: default 5000. How much time (in milliseconds) to
wait before commit
num_procs: Number of processes to start for consuming messages.
The available partitions will be divided among these processes
partitions_per_proc: Number of partitions to be allocated per process
(overrides num_procs)
Auto commit details:
If both auto_commit_every_n and auto_commit_every_t are set, they will
reset one another when one is triggered. These triggers simply call the
commit method on this class. A manual call to commit will also reset
these triggers
"""
def __init__(self, client, group, topic,
partitions=None,
auto_commit=True,
auto_commit_every_n=AUTO_COMMIT_MSG_COUNT,
auto_commit_every_t=AUTO_COMMIT_INTERVAL,
num_procs=1,
partitions_per_proc=0,
**simple_consumer_options):
# Initiate the base consumer class
super(MultiProcessConsumer, self).__init__(
client, group, topic,
partitions=partitions,
auto_commit=auto_commit,
auto_commit_every_n=auto_commit_every_n,
auto_commit_every_t=auto_commit_every_t)
# Variables for managing and controlling the data flow from
# consumer child process to master
manager = MPManager()
self.queue = manager.Queue(1024) # Child consumers dump messages into this
self.events = Events(
start=manager.Event(), # Indicates the consumers to start fetch
exit=manager.Event(), # Requests the consumers to shutdown
pause=manager.Event()) # Requests the consumers to pause fetch
self.size = manager.Value('i', 0) # Indicator of number of messages to fetch
# dict.keys() returns a view in py3 + it's not a thread-safe operation
# http://blog.labix.org/2008/06/27/watch-out-for-listdictkeys-in-python-3
# It's safer to copy dict as it only runs during the init.
partitions = list(self.offsets.copy().keys())
# By default, start one consumer process for all partitions
# The logic below ensures that
# * we do not cross the num_procs limit
# * we have an even distribution of partitions among processes
if partitions_per_proc:
num_procs = len(partitions) / partitions_per_proc
if num_procs * partitions_per_proc < len(partitions):
num_procs += 1
# The final set of chunks
chunks = [partitions[proc::num_procs] for proc in range(num_procs)]
self.procs = []
for chunk in chunks:
options = {'partitions': list(chunk)}
if simple_consumer_options:
simple_consumer_options.pop('partitions', None)
options.update(simple_consumer_options)
args = (client.copy(), self.group, self.topic, self.queue,
self.size, self.events)
proc = Process(target=_mp_consume, args=args, kwargs=options)
proc.daemon = True
proc.start()
self.procs.append(proc)
def __repr__(self):
return '<MultiProcessConsumer group=%s, topic=%s, consumers=%d>' % \
(self.group, self.topic, len(self.procs))
def stop(self):
# Set exit and start off all waiting consumers
self.events.exit.set()
self.events.pause.set()
self.events.start.set()
for proc in self.procs:
proc.join()
proc.terminate()
super(MultiProcessConsumer, self).stop()
def __iter__(self):
"""
Iterator to consume the messages available on this consumer
"""
# Trigger the consumer procs to start off.
# We will iterate till there are no more messages available
self.size.value = 0
self.events.pause.set()
while True:
self.events.start.set()
try:
# We will block for a small while so that the consumers get
# a chance to run and put some messages in the queue
# TODO: This is a hack and will make the consumer block for
# at least one second. Need to find a better way of doing this
partition, message = self.queue.get(block=True, timeout=1)
except queue.Empty:
break
# Count, check and commit messages if necessary
self.offsets[partition] = message.offset + 1
self.events.start.clear()
self.count_since_commit += 1
self._auto_commit()
yield message
self.events.start.clear()
def get_messages(self, count=1, block=True, timeout=10):
"""
Fetch the specified number of messages
Keyword Arguments:
count: Indicates the maximum number of messages to be fetched
block: If True, the API will block till all messages are fetched.
If block is a positive integer the API will block until that
many messages are fetched.
timeout: When blocking is requested the function will block for
the specified time (in seconds) until count messages is
fetched. If None, it will block forever.
"""
messages = []
# Give a size hint to the consumers. Each consumer process will fetch
# a maximum of "count" messages. This will fetch more messages than
# necessary, but these will not be committed to kafka. Also, the extra
# messages can be provided in subsequent runs
self.size.value = count
self.events.pause.clear()
if timeout is not None:
max_time = time.time() + timeout
new_offsets = {}
while count > 0 and (timeout is None or timeout > 0):
# Trigger consumption only if the queue is empty
# By doing this, we will ensure that consumers do not
# go into overdrive and keep consuming thousands of
# messages when the user might need only a few
if self.queue.empty():
self.events.start.set()
block_next_call = block is True or block > len(messages)
try:
partition, message = self.queue.get(block_next_call,
timeout)
except queue.Empty:
break
_msg = (partition, message) if self.partition_info else message
messages.append(_msg)
new_offsets[partition] = message.offset + 1
count -= 1
if timeout is not None:
timeout = max_time - time.time()
self.size.value = 0
self.events.start.clear()
self.events.pause.set()
# Update and commit offsets if necessary
self.offsets.update(new_offsets)
self.count_since_commit += len(messages)
self._auto_commit()
return messages
|
run.py
|
from __future__ import print_function
import js2py
from js2py.base import PyJsException, PyExceptionToJs
from js2py.internals import seval
from js2py.internals.simplex import JsException
import os, sys, re, traceback, threading, ctypes, time, six
from distutils.version import LooseVersion
from node_eval import NodeJsError, node_eval_js
import codecs
import json
import traceback
TEST_TIMEOUT = 2
INCLUDE_PATH = 'includes/'
TEST_PATH = 'test_cases/language'
FAILING = []
# choose which JS runtime to test. Js2Py has 2 independent runtimes. Translation based (translator) and the vm interpreter based.
RUNTIME_TO_TEST = 'vm'
if RUNTIME_TO_TEST == 'translator':
JS_EVALUATOR = js2py.eval_js
PY_JS_EXCEPTION = PyJsException
MESSAGE_FROM_PY_JS_EXCEPTION = lambda x: PyExceptionToJs(x).get('message').to_python()
elif RUNTIME_TO_TEST == 'vm':
JS_EVALUATOR = seval.eval_js_vm
PY_JS_EXCEPTION = PyJsException
MESSAGE_FROM_PY_JS_EXCEPTION = lambda x: str(x)
elif RUNTIME_TO_TEST == 'node':
JS_EVALUATOR = node_eval_js
PY_JS_EXCEPTION = NodeJsError
MESSAGE_FROM_PY_JS_EXCEPTION = lambda x: str(x)
else:
raise RuntimeError("Js2Py has currently only 2 runtimes available - 'translator' and the 'vm' - RUNTIME_TO_TEST must be one of these.")
def load(path):
with codecs.open(path, "r", "utf-8") as f:
return f.read()
def terminate_thread(thread):
"""Terminates a python thread from another thread.
:param thread: a threading.Thread instance
"""
if not thread.isAlive():
return
exc = ctypes.py_object(SystemExit)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(
ctypes.c_long(thread.ident), exc)
if res == 0:
raise ValueError("nonexistent thread id")
elif res > 1:
# """if it returns a number greater than one, you're in trouble,
# and you should call it again with exc=NULL to revert the effect"""
ctypes.pythonapi.PyThreadState_SetAsyncExc(thread.ident, None)
raise SystemError("PyThreadState_SetAsyncExc failed")
INIT = load(os.path.join(INCLUDE_PATH, 'init.js'))
with open("node_failed.txt") as f:
NODE_FAILED = set(f.readlines())
class FestCase:
description = None
includes = None
author = None
es5id = None
negative = None
info = None
flags = []
CATEGORY_REQUIRES_SPLIT = {'flags', 'includes'}
def __init__(self, path):
self.path = path
self.full_path = os.path.abspath(self.path)
self.clear_name = '/'.join(self.full_path.split(os.sep)[-3-('prototype' in self.full_path):-1])
self.raw = load(self.path)
self._parse_test_info()
self.init = INIT
if self.includes:
for include in self.includes:
self.init += load(os.path.join(INCLUDE_PATH, include))
if 'onlyStrict' in self.flags or '"use strict"' in self.raw or "'use strict'" in self.raw:
self.strict_only = True
else:
self.strict_only = False
self.node_failed = self.es5id in NODE_FAILED
self.code = self.init + self.raw
def _parse_test_info(self):
self.raw_info = re.search(r'/\*---(.+)---\*/', self.raw, re.DOTALL).groups()[0].strip()
category = None
category_content = None
for line in self.raw_info.splitlines() + ['END:']:
if line.startswith(' '):
if category is None:
raise RuntimeError('Could not parse test case info! %s' % self.path)
category_content += '\n' + line.lstrip()
elif line == 'onlyStrict':
self.strict_only = True
else:
if category is not None:
content = category_content.strip()
content = content if not category in self.CATEGORY_REQUIRES_SPLIT else self._content_split(content)
setattr(self, category, content)
start_index = line.index(':')
category = line[:start_index]
category_content = line[start_index+1:].lstrip(' >\n')
def _content_split(self, content):
res = []
for c in content.splitlines():
cand = c.strip('[] -')
if cand:
if ', ' in cand:
for e in cand.split(','):
res.append(e.strip())
else:
res.append(cand)
return res
def run(self):
# labels: 'PASSED', 'FAILED', 'CRASHED', 'NOT_IMPLEMENTED', 'NO_FAIL'
errors = True
crashed = True
label = None
try:
JS_EVALUATOR(self.code)
errors = False
crashed = False
except NotImplementedError:
tb = sys.exc_info()[-1]
stk = traceback.extract_tb(tb)
fname = stk[-1][2]
passed = False
reason = 'Not implemented - "%s"' % fname
full_error = traceback.format_exc()
label = 'NOT_IMPLEMENTED'
except PY_JS_EXCEPTION as e:
crashed = False
full_error = traceback.format_exc()
if self.negative:
passed = True
else:
passed = False
reason = MESSAGE_FROM_PY_JS_EXCEPTION(e)
label = 'FAILED'
except SyntaxError as e:
full_error = traceback.format_exc()
if self.negative=='SyntaxError':
passed = True
else:
passed = False
reason = 'Could not parse'
label = 'CRASHED'
except:
full_error = traceback.format_exc()
passed = False
reason = 'UNKNOWN - URGENT, FIX NOW!\n' + traceback.format_exc()[-2000:]+'\n\n'
label = 'CRASHED'
if not errors:
if self.negative:
passed = False
reason = "???"
label = "NO_FAIL"
full_error = ''
else:
passed = True
if passed:
label = "PASSED"
reason = ''
full_error = ''
if not passed:
FAILING.append(self.es5id)
self.passed, self.label, self.reason, self.full_error = passed, label, reason, full_error
return passed, label, reason, full_error
def print_result(self):
#if self.label == "CRASHED": return
print(self.clear_name, self.es5id, self.label, self.reason, '\nFile "%s", line 1'%self.full_path if self.label!='PASSED' else '')
if self.label == "CRASHED": print(self.code) or exit()
def list_path(path, folders=False):
res = []
for f in os.listdir(path):
full = os.path.join(path, f)
is_file = os.path.isfile(full)
if (folders and not is_file) or (not folders and is_file):
res.append(full)
if folders:
return sorted(res)
else:
try:
return sorted(res, key=LooseVersion)
except:
return sorted(res) # python 3... why cant they fix this
def fest_all(path):
files = list_path(path)
folders = list_path(path, folders=True)
for f in files:
if not f.endswith('.js'):
continue
try:
test = FestCase(f)
if test.strict_only:
continue
if test.node_failed:
continue
thread = threading.Thread(target=test.run)
timeout_time = time.time() + TEST_TIMEOUT
thread.start()
while thread.is_alive() and time.time()<timeout_time:
time.sleep(0.001)
if thread.is_alive():
terminate_thread(thread)
test.passed = False
test.full_error = 'TERMINATED'
test.label = 'TIMEOUT'
test.reason = '?'
test.print_result()
except:
print(traceback.format_exc())
print(f)
for folder in folders:
fest_all(folder)
fest_all(TEST_PATH)
with open('failed.txt', 'w') as f:
f.write('\n'.join(filter(lambda x: x, FAILING)))
|
job_server.py
|
"""
JobServer: class for job farming using amuse communication channels
usage:
start jobserver
jobserver=JobServer(hosts=<list of hostnames> [ ,channel_type="mpi", preamble="<commands>", retry_jobs=True/ False] )
submit job
job=jobserver.submit_job(somework, (args,))
wait for one result (encounters all):
jobserver.wait()
job=jobserver.last_finished_job
wait for all to finish, loop over all:
jobserver.waitall()
for job in jobserver.finished_jobs:
print job.result
it is essential that the function which are to be executed remotely are pickleable, i.e. they must not be
derived from the main module. Easy way to achieve this is to import them from a seperate file.
2 issues to be fixed:
- blocking startup of hosts may prevent threads shutting down, leading to freeze at end of script
(so manual kill necessary)
- thread function _startup contains references to JobServer, hence del jobserver will actually not be called
until the situation of issue 1 is resolved (so the warning given there is useless)
"""
from amuse.rfi.core import *
import cPickle as pickle
from amuse.rfi.async_request import AsyncRequestsPool
import inspect
from collections import deque
import threading
from time import sleep
import warnings
import base64
def dump_and_encode(x):
return base64.b64encode(pickle.dumps(x)).decode()
def decode_and_load(x):
return pickle.loads(base64.b64decode(x.encode()))
class RemoteCodeException(Exception):
def __init__(self,ex=None):
self.ex=ex
def __str__(self):
return "["+self.ex.__class__.__name__+"] "+str(self.ex)
class RemoteCodeImplementation(object):
def __init__(self):
self.scope={}
self.scope['dump_and_encode']=dump_and_encode
self.scope['decode_and_load']=decode_and_load
def _exec(self,arg):
try:
exec arg in self.scope
return dump_and_encode(None)
except Exception as ex:
return dump_and_encode(RemoteCodeException(ex))
def _eval(self,arg,argout):
try:
self.scope.update(dict(arg=arg))
exec "argout="+arg in self.scope
argout.value=eval("dump_and_encode(argout)",self.scope)
return dump_and_encode(None)
except Exception as ex:
argout.value=dump_and_encode("")
return dump_and_encode(RemoteCodeException(ex))
def _assign(self,lhs,argin):
try:
self.scope.update(dict(argin=argin))
exec lhs+"=decode_and_load(argin)" in self.scope
return dump_and_encode(None)
except Exception as ex:
return dump_and_encode(RemoteCodeException(ex))
def _func(self,func,argin,kwargin,argout):
try:
self.scope.update(dict(func=func,argin=argin,kwargin=kwargin))
exec "func=decode_and_load(func)" in self.scope
exec "arg=decode_and_load(argin)" in self.scope
exec "kwarg=decode_and_load(kwargin)" in self.scope
exec "result=func(*arg,**kwarg)" in self.scope
argout.value=eval("dump_and_encode(result)",self.scope)
return dump_and_encode(None)
except Exception as ex:
argout.value=dump_and_encode(None)
return dump_and_encode(RemoteCodeException(ex))
class RemoteCodeInterface(PythonCodeInterface):
def __init__(self, **options):
PythonCodeInterface.__init__(self, RemoteCodeImplementation, **options)
@legacy_function
def _func():
function = LegacyFunctionSpecification()
function.addParameter('func', dtype='string', direction=function.IN)
function.addParameter('argin', dtype='string', direction=function.IN)
function.addParameter('kwargin', dtype='string', direction=function.IN)
function.addParameter('argout', dtype='string', direction=function.OUT)
function.result_type = 'string'
return function
@legacy_function
def _exec():
function = LegacyFunctionSpecification()
function.addParameter('arg', dtype='string', direction=function.IN)
function.result_type = 'string'
return function
@legacy_function
def _eval():
function = LegacyFunctionSpecification()
function.addParameter('arg', dtype='string', direction=function.IN)
function.addParameter('argout', dtype='string', direction=function.OUT)
function.result_type = 'string'
return function
@legacy_function
def _assign():
function = LegacyFunctionSpecification()
function.addParameter('lhs', dtype='string', direction=function.IN)
function.addParameter('argin', dtype='string', direction=function.IN)
function.result_type = 'string'
return function
def execute(self,express):
err=decode_and_load( self._exec(express) )
if err:
raise err
def assign(self,lhs,arg):
err=decode_and_load( self._assign(lhs, dump_and_encode(arg)) )
if err:
raise err
def evaluate(self,express):
result,err=self._eval(express)
err=decode_and_load( err)
if err :
raise err
return decode_and_load(result)
def func(self,f,*args,**kwargs):
result,err=self._func( dump_and_encode(f),
dump_and_encode(args),
dump_and_encode(kwargs) )
err=decode_and_load( err)
if err :
raise err
return decode_and_load(result)
def async_func(self,f,*args,**kwargs):
request=self._func.asynchronous(dump_and_encode(f),
dump_and_encode(args),
dump_and_encode(kwargs) )
def f(x):
result,err=x()
err=decode_and_load( err)
if err :
raise err
return decode_and_load(result)
request.add_result_handler( f )
return request
class Job(object):
def __init__(self, f, args, kwargs,retries=0):
self.f=f
self.args=args
self.kwargs=kwargs
self.result=None
self.request=None
self.err=None
self.retries=retries
class JobServer(object):
def __init__(self,hosts=[],channel_type="mpi",preamble=None, retry_jobs=True,
no_wait=True,verbose=True,max_retries=2, use_threading=False):
self.hosts=[]
self.job_list=deque()
self.idle_codes=[]
self.retry_jobs=retry_jobs
self.max_retries=max_retries
self._finished_jobs=deque()
self.preamble=preamble
self.pool=AsyncRequestsPool()
self.number_available_codes=0
self.number_starting_codes=0
self.no_wait=no_wait
self.last_finished_job=None
self.use_threading=use_threading
self.verbose=verbose
if self.verbose:
print "AMUSE JobServer launching"
self.add_hosts(hosts=hosts,channel_type=channel_type)
def no_hosts(self):
if self.number_available_codes==0 and self.number_starting_codes==0:
return True
return False
def add_hosts(self,hosts=[],channel_type="mpi"):
self.hosts.append(hosts)
if self.verbose:
print "JobServer: connecting %i hosts"%len(hosts)
if not self.use_threading:
for host in hosts:
self.number_starting_codes+=1
self._startup( channel_type=channel_type,hostname=host,label=host,
copy_worker_code=True,redirection="none" )
else:
threads=[]
for host in hosts:
kwargs=dict( channel_type=channel_type,hostname=host,label=host,
copy_worker_code=True,redirection="none" )
threads.append( threading.Thread(target=self._startup,kwargs=kwargs) )
for thread in threads:
self.number_starting_codes+=1
thread.daemon=True
thread.start()
if not self.no_wait:
if self.verbose:
print "... waiting"
for thread in threads:
thread.join()
else:
if self.verbose:
print "... waiting for first available host"
while self.number_available_codes==0 and self.number_starting_codes>0:
sleep(0.1)
if self.no_wait:
if self.verbose:
print "JobServer: launched"
else:
if self.verbose:
print "JobServer: launched with", len(self.idle_codes),"hosts"
def _startup(self, *args,**kwargs):
try:
code=RemoteCodeInterface(*args,**kwargs)
except Exception as ex:
self.number_starting_codes-=1
print "JobServer: startup failed on", kwargs['hostname'] or "default"
print ex
else:
if self.preamble is not None:
code.execute(self.preamble)
self.number_available_codes+=1
self.number_starting_codes-=1
if self.no_wait:
if self.number_available_codes & (self.number_available_codes-1) ==0:
if self.verbose:
print "JobServer: hosts now available:",self.number_available_codes
if self.number_starting_codes==0:
if self.verbose:
print "JobServer: hosts in total:", self.number_available_codes
if self.job_list:
self._add_job(self.job_list.popleft(), code)
else:
self.idle_codes.append(code)
def exec_(self,arg):
while self.number_starting_codes>0:
sleep(0.1)
self.waitall()
for code in self.idle_codes:
code.execute(arg)
def submit_job(self,f,args=(),kwargs={}):
if len(self.pool)==0 and not self.job_list:
if self.verbose:
print "JobServer: submitting first job on queue"
job=Job(f,args,kwargs)
self.job_list.append( job)
if self.idle_codes:
self._add_job(self.job_list.popleft(), self.idle_codes.pop())
return job
def wait(self):
if self._finished_jobs:
self.last_finished_job=self._finished_jobs.popleft()
return True
elif len(self.pool)==0 and not self.job_list:
if self.verbose:
print "JobServer: no more jobs on queue or running"
return False
else:
while len(self.pool)==0 and self.job_list:
if self.number_available_codes>0:
raise Exception("JobServer: this should not happen")
if self.number_starting_codes==0:
raise Exception("JobServer: no codes available")
self.pool.wait()
self.last_finished_job=self._finished_jobs.popleft()
return True
def waitall(self):
while len(self.pool)==0 and self.job_list:
if self.number_available_codes>0:
raise Exception("JobServer: this should not happen")
if self.number_starting_codes==0:
raise Exception("JobServer: no codes available")
while len(self.pool)>0 or self.job_list:
self.pool.wait()
self.last_finished_job=self._finished_jobs[-1]
@property
def finished_jobs(self):
while self._finished_jobs:
yield self._finished_jobs.popleft()
def _finalize_job(self,request,job,code):
try:
job.result=request.result()
job.err=None
except Exception as ex:
job.result=None
job.err=ex
if job.err and not isinstance(job.err,RemoteCodeException):
del code
self.number_available_codes-=1
if self.retry_jobs and job.retries<self.max_retries:
retry=Job(job.f,job.args,job.kwargs,job.retries+1)
self.job_list.append(retry)
else:
self.idle_codes.append(code)
if self.job_list and self.idle_codes:
self._add_job( self.job_list.popleft(), self.idle_codes.pop())
if not self.job_list:
if self.verbose:
print "JobServer: last job dispatched"
self._finished_jobs.append(job)
def _add_job(self,job,code):
job.request=code.async_func(job.f,*job.args,**job.kwargs)
self.pool.add_request(job.request,self._finalize_job, [job,code])
def __del__(self):
if not self.no_hosts():
self.waitall()
if self.job_list:
warnings.warn("JobServer: Warning: shutting down with unfinished jobs")
for code in self.idle_codes:
code.stop()
if self.number_starting_codes>0:
warnings.warn("JobServer: Warning: some hosts startup threads possibly blocking")
|
02_cartpole_rainbow_main.py
|
#!/usr/bin/env python3
# https://github.com/higgsfield/RL-Adventure
import time
import torch
import torch.multiprocessing as mp
from torch import optim
import os
from codes.f_utils.common_utils import make_gym_env
from config.names import PROJECT_HOME
print(torch.__version__)
from common.fast_rl import actions, experience, value_based_model, rl_agent, replay_buffer
from common.fast_rl.common import statistics, utils
from config.parameters import PARAMETERS as params
MODEL_SAVE_DIR = os.path.join(PROJECT_HOME, "out", "model_save_files")
if not os.path.exists(MODEL_SAVE_DIR):
os.makedirs(MODEL_SAVE_DIR)
os.environ['KMP_DUPLICATE_LIB_OK'] = 'True'
if torch.cuda.is_available():
device = torch.device("cuda" if params.CUDA else "cpu")
else:
device = torch.device("cpu")
def play_func(exp_queue, env, net):
action_selector = actions.ArgmaxActionSelector()
agent = rl_agent.DQNAgent(net, action_selector, device=device)
experience_source = experience.ExperienceSourceFirstLast(env, agent, gamma=params.GAMMA, steps_count=params.N_STEP)
exp_source_iter = iter(experience_source)
if params.DRAW_VIZ:
stat = statistics.StatisticsForValueBasedRL(method="nature_dqn")
else:
stat = None
step_idx = 0
next_save_frame_idx = params.MODEL_SAVE_STEP_PERIOD
with utils.RewardTracker(params=params, frame=False, stat=stat) as reward_tracker:
while step_idx < params.MAX_GLOBAL_STEP:
step_idx += 1
exp = next(exp_source_iter)
# print(exp)
exp_queue.put(exp)
episode_rewards = experience_source.pop_episode_reward_lst()
if episode_rewards:
solved, mean_episode_reward = reward_tracker.set_episode_reward(
episode_rewards[0], step_idx, 0.0
)
if step_idx >= next_save_frame_idx:
rl_agent.save_model(
MODEL_SAVE_DIR, params.ENVIRONMENT_ID.value, net.__name__, net, step_idx, mean_episode_reward
)
next_save_frame_idx += params.MODEL_SAVE_STEP_PERIOD
if solved:
rl_agent.save_model(
MODEL_SAVE_DIR, params.ENVIRONMENT_ID.value, net.__name__, net, step_idx, mean_episode_reward
)
break
exp_queue.put(None)
def main():
mp.set_start_method('spawn')
env = make_gym_env(params.ENVIRONMENT_ID.value, seed=params.SEED)
net = value_based_model.RainbowDQNMLP(
obs_size=4,
hidden_size_1=128, hidden_size_2=128,
n_actions=2
).to(device)
print(net)
target_net = rl_agent.TargetNet(net)
buffer = replay_buffer.PrioReplayBuffer(experience_source=None, buffer_size=params.REPLAY_BUFFER_SIZE)
optimizer = optim.Adam(net.parameters(), lr=params.LEARNING_RATE)
exp_queue = mp.Queue(maxsize=params.TRAIN_STEP_FREQ * 2)
play_proc = mp.Process(target=play_func, args=(exp_queue, env, net))
play_proc.start()
time.sleep(0.5)
if params.DRAW_VIZ:
stat_for_value_optimization = statistics.StatisticsForValueBasedOptimization()
else:
stat_for_value_optimization = None
step_idx = 0
while play_proc.is_alive():
step_idx += params.TRAIN_STEP_FREQ
for _ in range(params.TRAIN_STEP_FREQ):
exp = exp_queue.get()
if exp is None:
play_proc.join()
break
buffer._add(exp)
if len(buffer) < params.MIN_REPLAY_SIZE_FOR_TRAIN:
if params.DRAW_VIZ and step_idx % 100 == 0:
stat_for_value_optimization.draw_optimization_performance(step_idx, 0.0)
continue
optimizer.zero_grad()
batch, batch_indices, batch_weights = buffer.sample(params.BATCH_SIZE)
loss_v, sample_prios = value_based_model.calc_loss_per_double_dqn(
buffer=buffer.buffer,
batch=batch,
batch_indices=batch_indices,
batch_weights=batch_weights,
net=net,
tgt_net=target_net,
params=params, cuda=params.CUDA, cuda_async=True
)
loss_v.backward()
optimizer.step()
buffer.update_priorities(batch_indices, sample_prios)
buffer.update_beta(step_idx)
# net.noisy_linear_1.reset_parameters()
# net.noisy_linear_2.reset_parameters()
# target_net.model.noisy_linear_1.reset_parameters()
# target_net.model.noisy_linear_2.reset_parameters()
if params.DRAW_VIZ and step_idx % 100 == 0:
stat_for_value_optimization.draw_optimization_performance(step_idx, loss_v.item())
if step_idx % params.TARGET_NET_SYNC_STEP_PERIOD < params.TRAIN_STEP_FREQ:
target_net.sync()
if __name__ == "__main__":
main()
|
site_tests.py
|
# -*- coding: utf-8 -*-
"""Tests for the site module."""
#
# (C) Pywikibot team, 2008-2019
#
# Distributed under the terms of the MIT license.
#
from __future__ import absolute_import, division, unicode_literals
import os
import pickle
import random
import re
import sys
import time
try:
from collections.abc import Iterable, Mapping
except ImportError: # Python 2.7
from collections import Iterable, Mapping
from datetime import datetime
import threading
import pywikibot
from pywikibot import async_request, config, page_put_queue
from pywikibot.comms import http
from pywikibot.data import api
from pywikibot.exceptions import HiddenKeyError
from pywikibot.tools import (
PY2,
StringTypes as basestring,
suppress_warnings,
UnicodeType as unicode,
)
from tests import patch, unittest_print, MagicMock
from tests.aspects import (
unittest, TestCase, DeprecationTestCase,
TestCaseBase,
DefaultSiteTestCase,
DefaultDrySiteTestCase,
WikimediaDefaultSiteTestCase,
WikidataTestCase,
DefaultWikidataClientTestCase,
AlteredDefaultSiteTestCase,
)
from tests.basepage_tests import BasePageLoadRevisionsCachingTestBase
from tests.utils import allowed_failure, allowed_failure_if, entered_loop
if not PY2:
long = int # Must be global: T159700
class TokenTestBase(TestCaseBase):
"""Verify token exists before running tests."""
def setUp(self):
"""Skip test if user does not have token and clear site wallet."""
super(TokenTestBase, self).setUp()
mysite = self.get_site()
ttype = self.token_type
try:
token = mysite.tokens[ttype]
except pywikibot.Error as error_msg:
self.assertRegex(
unicode(error_msg),
"Action '[a-z]+' is not allowed for user .* on .* wiki.")
self.assertNotIn(self.token_type, self.site.tokens)
self.skipTest(error_msg)
self.token = token
self._orig_wallet = self.site.tokens
self.site.tokens = pywikibot.site.TokenWallet(self.site)
def tearDown(self):
"""Restore site tokens."""
self.site.tokens = self._orig_wallet
super(TokenTestBase, self).tearDown()
class TestSiteObjectDeprecatedFunctions(DefaultSiteTestCase,
DeprecationTestCase):
"""Test cases for Site deprecated methods on a live wiki."""
cached = True
def test_capitalization(self):
"""Test that the case method is mirroring the siteinfo."""
self.assertEqual(self.site.case(), self.site.siteinfo['case'])
self.assertOneDeprecationParts('pywikibot.site.APISite.case',
'siteinfo or Namespace instance')
self.assertIs(self.site.nocapitalize,
self.site.siteinfo['case'] == 'case-sensitive')
self.assertOneDeprecationParts(
'pywikibot.site.BaseSite.nocapitalize',
"APISite.siteinfo['case'] or Namespace.case == 'case-sensitive'")
def test_live_version(self):
"""Test live_version."""
mysite = self.get_site()
ver = mysite.live_version()
self.assertIsInstance(ver, tuple)
self.assertTrue(all(isinstance(ver[i], int) for i in (0, 1)))
self.assertIsInstance(ver[2], basestring)
self.assertOneDeprecation()
def test_getcurrenttime(self):
"""Test live_version."""
self.assertEqual(self.site.getcurrenttime(), self.site.server_time())
self.assertOneDeprecation()
def test_siteinfo_normal_call(self):
"""Test calling the Siteinfo without setting dump."""
if self.site.mw_version < '1.16':
self.skipTest('requires v1.16+')
old = self.site.siteinfo('general')
self.assertIn('time', old)
self.assertEqual(old, self.site.siteinfo['general'])
self.assertEqual(self.site.siteinfo('general'), old)
# Siteinfo always returns copies so it's not possible to directly
# check if they are the same dict or if they have been rerequested
# unless the content also changes so force that the content changes
self.assertNotIn('DUMMY', old)
self.site.siteinfo._cache['general'][0]['DUMMY'] = 42
old = self.site.siteinfo('general')
self.assertIn('DUMMY', old)
self.assertNotEqual(self.site.siteinfo('general', force=True), old)
self.assertOneDeprecationParts('Calling siteinfo',
'itself as a dictionary',
4)
def test_siteinfo_dump(self):
"""Test calling the Siteinfo with dump=True."""
self.assertIn('statistics',
self.site.siteinfo('statistics', dump=True))
self.assertOneDeprecationParts('Calling siteinfo',
'itself as a dictionary')
def test_language_method(self):
"""Test if the language method returns the same as lang property."""
self.assertEqual(self.site.language(), self.site.lang)
self.assertOneDeprecation()
def test_allpages_filterredir_True(self):
"""Test that filterredir set to 'only' is deprecated to True."""
for page in self.site.allpages(filterredir='only', total=1):
self.assertTrue(page.isRedirectPage())
self.assertOneDeprecation()
def test_allpages_filterredir_False(self):
"""Test if filterredir's bool is False it's deprecated to False."""
for page in self.site.allpages(filterredir='', total=1):
self.assertFalse(page.isRedirectPage())
self.assertOneDeprecation()
def test_ns_index(self):
"""Test ns_index."""
self.assertEqual(self.site.ns_index('MediaWiki'), 8)
self.assertOneDeprecation()
def test_namespace_shortcuts(self):
"""Test namespace shortcuts."""
self.assertEqual(self.site.image_namespace(), self.site.namespace(6))
self.assertEqual(self.site.mediawiki_namespace(),
self.site.namespace(8))
self.assertEqual(self.site.template_namespace(),
self.site.namespace(10))
self.assertEqual(self.site.category_namespace(),
self.site.namespace(14))
self.assertEqual(self.site.category_namespaces(),
list(self.site.namespace(14, all=True)))
class TestSiteDryDeprecatedFunctions(DefaultDrySiteTestCase,
DeprecationTestCase):
"""Test cases for Site deprecated methods without a user."""
def test_namespaces_callable(self):
"""Test that namespaces is callable and returns itself."""
site = self.get_site()
self.assertIs(site.namespaces(), site.namespaces)
self.assertOneDeprecationParts('Calling the namespaces property',
'it directly')
def test_messages_star(self):
"""Test that fetching all messages is deprecated."""
# Load all messages and check that '*' is not a valid key.
self.assertEqual(self.site.mediawiki_messages('*'),
{'*': 'dummy entry'})
self.assertOneDeprecationParts('mediawiki_messages("*")',
'specific messages')
self.assertEqual(self.site.mediawiki_messages(['hello']),
{'hello': 'world'})
self.assertNoDeprecation()
class TestBaseSiteProperties(TestCase):
"""Test properties for BaseSite."""
sites = {
'enwikinews': {
'family': 'wikinews',
'code': 'en',
'result': ('/doc',),
},
'enwikibooks': {
'family': 'wikibooks',
'code': 'en',
'result': ('/doc',),
},
'enwikiquote': {
'family': 'wikiquote',
'code': 'en',
'result': ('/doc',),
},
'enwiktionary': {
'family': 'wiktionary',
'code': 'en',
'result': ('/doc',),
},
'enws': {
'family': 'wikisource',
'code': 'en',
'result': ('/doc',),
},
'dews': {
'family': 'wikisource',
'code': 'de',
'result': ('/Doku', '/Meta'),
},
'commons': {
'family': 'commons',
'code': 'commons',
'result': ('/doc', ),
},
'wikidata': {
'family': 'wikidata',
'code': 'wikidata',
'result': ('/doc', ),
},
}
dry = True
def test_properties(self, key):
"""Test cases for BaseSite properties."""
mysite = self.get_site(key)
self.assertEqual(mysite.doc_subpage, self.sites[key]['result'])
class TestSiteObject(DefaultSiteTestCase):
"""Test cases for Site methods."""
cached = True
def test_pickle_ability(self):
"""Test pickle ability."""
mysite = self.get_site()
mysite_str = pickle.dumps(mysite, protocol=config.pickle_protocol)
mysite_pickled = pickle.loads(mysite_str)
self.assertEqual(mysite, mysite_pickled)
def test_repr(self):
"""Test __repr__."""
code = self.site.family.obsolete.get(self.code) or self.code
expect = 'Site("{0}", "{1}")'.format(code, self.family)
self.assertStringMethod(str.endswith, repr(self.site), expect)
def test_base_methods(self):
"""Test cases for BaseSite methods."""
mysite = self.get_site()
code = self.site.family.obsolete.get(self.code) or self.code
self.assertEqual(mysite.family.name, self.family)
self.assertEqual(mysite.code, code)
self.assertIsInstance(mysite.lang, basestring)
self.assertEqual(mysite, pywikibot.Site(self.code, self.family))
self.assertIsInstance(mysite.user(), (basestring, type(None)))
self.assertEqual(mysite.sitename(), '%s:%s' % (self.family, code))
self.assertIsInstance(mysite.linktrail(), basestring)
self.assertIsInstance(mysite.redirect(), basestring)
try:
dabcat = mysite.disambcategory()
except pywikibot.Error as e:
try:
self.assertIn('No disambiguation category name found', str(e))
except AssertionError:
self.assertIn(
'No {repo} qualifier found for disambiguation category '
'name in {fam}_family file'.format(
repo=mysite.data_repository().family.name,
fam=mysite.family.name),
str(e))
else:
self.assertIsInstance(dabcat, pywikibot.Category)
foo = unicode(pywikibot.Link('foo', source=mysite))
if self.site.namespaces[0].case == 'case-sensitive':
self.assertEqual(foo, '[[foo]]')
else:
self.assertEqual(foo, '[[Foo]]')
self.assertFalse(mysite.isInterwikiLink('foo'))
self.assertIsInstance(mysite.redirectRegex().pattern, basestring)
self.assertIsInstance(mysite.category_on_one_line(), bool)
self.assertTrue(mysite.sametitle('Template:Test', 'Template:Test'))
self.assertTrue(mysite.sametitle('Template: Test', 'Template: Test'))
self.assertTrue(mysite.sametitle('Test name', 'Test name'))
self.assertFalse(mysite.sametitle('Test name', 'Test Name'))
# User, MediaWiki (both since 1.16) and Special are always
# first-letter (== only first non-namespace letter is case insensitive)
# See also: https://www.mediawiki.org/wiki/Manual:$wgCapitalLinks
self.assertTrue(mysite.sametitle('Special:Always', 'Special:always'))
if mysite.mw_version >= '1.16':
self.assertTrue(mysite.sametitle('User:Always', 'User:always'))
self.assertTrue(mysite.sametitle('MediaWiki:Always',
'MediaWiki:always'))
def test_constructors(self):
"""Test cases for site constructors."""
test_list = [
['enwiki', ('en', 'wikipedia')],
['eswikisource', ('es', 'wikisource')],
['dewikinews', ('de', 'wikinews')],
['ukwikivoyage', ('uk', 'wikivoyage')],
['metawiki', ('meta', 'meta')],
['commonswiki', ('commons', 'commons')],
['wikidatawiki', ('wikidata', 'wikidata')],
['testwikidatawiki', ('test', 'wikidata')],
['testwiki', ('test', 'wikipedia')], # see T225729, T228300
['test2wiki', ('test2', 'wikipedia')], # see T225729
['sourceswiki', ('mul', 'wikisource')], # see T226960
]
if isinstance(self.site.family, pywikibot.family.WikimediaFamily):
site = self.site
else:
site = None
for dbname, site_tuple in test_list:
with self.subTest(dbname=dbname):
self.assertEqual(
pywikibot.site.APISite.fromDBName(dbname, site),
pywikibot.Site(*site_tuple))
def test_language_methods(self):
"""Test cases for languages() and related methods."""
mysite = self.get_site()
langs = mysite.languages()
self.assertIsInstance(langs, list)
self.assertIn(mysite.code, langs)
self.assertIsInstance(mysite.obsolete, bool)
ipf = mysite.interwiki_putfirst()
if ipf: # Not all languages use this
self.assertIsInstance(ipf, list)
else:
self.assertIsNone(ipf)
for item in mysite.validLanguageLinks():
self.assertIn(item, langs)
self.assertIsNone(self.site.namespaces.lookup_name(item))
def test_mamespace_methods(self):
"""Test cases for methods manipulating namespace names."""
mysite = self.get_site()
ns = mysite.namespaces
self.assertIsInstance(ns, Mapping)
self.assertTrue(all(x in ns for x in range(0, 16)))
# built-in namespaces always present
self.assertIsInstance(mysite.ns_normalize('project'), basestring)
self.assertTrue(all(isinstance(key, int)
for key in ns))
self.assertTrue(all(isinstance(val, Iterable)
for val in ns.values()))
self.assertTrue(all(isinstance(name, basestring)
for val in ns.values()
for name in val))
self.assertTrue(all(isinstance(mysite.namespace(key), basestring)
for key in ns))
self.assertTrue(all(isinstance(mysite.namespace(key, True), Iterable)
for key in ns))
self.assertTrue(all(isinstance(item, basestring)
for key in ns
for item in mysite.namespace(key, True)))
def test_user_attributes_return_types(self):
"""Test returned types of user attributes."""
mysite = self.get_site()
self.assertIsInstance(mysite.logged_in(), bool)
self.assertIsInstance(mysite.logged_in(True), bool)
self.assertIsInstance(mysite.userinfo, dict)
def test_messages(self):
"""Test MediaWiki: messages."""
mysite = self.get_site()
for msg in ('about', 'aboutpage', 'aboutsite', 'accesskey-n-portal'):
self.assertTrue(mysite.has_mediawiki_message(msg))
self.assertIsInstance(mysite.mediawiki_message(msg), basestring)
self.assertFalse(mysite.has_mediawiki_message('nosuchmessage'))
self.assertRaises(KeyError, mysite.mediawiki_message, 'nosuchmessage')
msg = ('about', 'aboutpage')
about_msgs = self.site.mediawiki_messages(msg)
self.assertIsInstance(mysite.mediawiki_messages(msg), dict)
self.assertTrue(mysite.mediawiki_messages(msg))
self.assertLength(about_msgs, 2)
self.assertIn(msg[0], about_msgs)
# mediawiki_messages must be given a list; using a string will split it
self.assertRaises(KeyError, self.site.mediawiki_messages, 'about')
msg = ('nosuchmessage1', 'about', 'aboutpage', 'nosuchmessage')
self.assertFalse(mysite.has_all_mediawiki_messages(msg))
self.assertRaises(KeyError, mysite.mediawiki_messages, msg)
self.assertIsInstance(mysite.server_time(), pywikibot.Timestamp)
ts = mysite.getcurrenttimestamp()
self.assertIsInstance(ts, basestring)
self.assertRegex(ts, r'(19|20)\d\d[0-1]\d[0-3]\d[0-2]\d[0-5]\d[0-5]\d')
self.assertIsInstance(mysite.months_names, list)
self.assertLength(mysite.months_names, 12)
self.assertTrue(all(isinstance(month, tuple)
for month in mysite.months_names))
for month in mysite.months_names:
self.assertLength(month, 2)
self.assertEqual(mysite.list_to_text(('pywikibot',)), 'pywikibot')
def test_english_specific_methods(self):
"""Test Site methods using English specific inputs and outputs."""
mysite = self.get_site()
if mysite.lang != 'en':
self.skipTest(
'English-specific tests not valid on {}'.format(mysite))
self.assertEqual(mysite.months_names[4], ('May', 'May'))
self.assertEqual(mysite.list_to_text(('Pride', 'Prejudice')),
'Pride and Prejudice')
self.assertEqual(mysite.list_to_text(('This', 'that', 'the other')),
'This, that and the other')
def test_page_methods(self):
"""Test ApiSite methods for getting page-specific info."""
mysite = self.get_site()
mainpage = self.get_mainpage()
with suppress_warnings('pywikibot.site.APISite.page_exists',
DeprecationWarning):
self.assertIsInstance(mysite.page_exists(mainpage), bool)
self.assertIsInstance(mysite.page_restrictions(mainpage), dict)
self.assertIsInstance(mysite.page_can_be_edited(mainpage), bool)
self.assertIsInstance(mysite.page_isredirect(mainpage), bool)
if mysite.page_isredirect(mainpage):
self.assertIsInstance(mysite.getredirtarget(mainpage),
pywikibot.Page)
else:
self.assertRaises(pywikibot.IsNotRedirectPage,
mysite.getredirtarget, mainpage)
a = list(mysite.preloadpages([mainpage]))
self.assertLength(a, int(mainpage.exists()))
if a:
self.assertEqual(a[0], mainpage)
class TestSiteGenerators(DefaultSiteTestCase):
"""Test cases for Site methods."""
cached = True
def setUp(self):
"""Initialize self.site and self.mainpage."""
super(TestSiteGenerators, self).setUp()
self.site = self.get_site()
self.mainpage = self.get_mainpage()
def test_generator_namespace(self):
"""Test site._generator with namespaces."""
site = self.get_site()
gen = site._generator(pywikibot.data.api.PageGenerator,
type_arg='backlinks',
namespaces=None)
self.assertNotIn('gblnamespace', gen.request)
gen = site._generator(pywikibot.data.api.PageGenerator,
type_arg='backlinks',
namespaces=1)
self.assertEqual(gen.request['gblnamespace'], [1])
def test_pagereferences(self):
"""Test Site.pagereferences."""
# pagereferences includes both backlinks and embeddedin
backlinks = set(self.site.pagebacklinks(self.mainpage, namespaces=[0]))
embedded = set(self.site.page_embeddedin(self.mainpage,
namespaces=[0]))
refs = set(self.site.pagereferences(self.mainpage, namespaces=[0]))
self.assertLessEqual(backlinks, refs)
self.assertLessEqual(embedded, refs)
self.assertEqual(refs, backlinks | embedded)
def test_backlinks(self):
"""Test Site.pagebacklinks."""
backlinks_ns_0 = set(self.site.pagebacklinks(
self.mainpage, namespaces=[0]))
backlinks_ns_0_2 = set(self.site.pagebacklinks(
self.mainpage, namespaces=[0, 2]))
# only non-redirects:
filtered = set(self.site.pagebacklinks(
self.mainpage, namespaces=0, filter_redirects=False))
# only redirects:
redirs = set(self.site.pagebacklinks(
self.mainpage, namespaces=0, filter_redirects=True))
# including links to redirect pages (but not the redirects):
indirect = set(
self.site.pagebacklinks(self.mainpage, namespaces=[0],
follow_redirects=True,
filter_redirects=False))
for bl in backlinks_ns_0:
self.assertIsInstance(bl, pywikibot.Page)
self.assertEqual(filtered & redirs, set())
self.assertEqual(indirect & redirs, set())
self.assertLessEqual(filtered, indirect)
self.assertLessEqual(filtered, backlinks_ns_0)
self.assertLessEqual(redirs, backlinks_ns_0)
self.assertLessEqual(backlinks_ns_0, backlinks_ns_0_2)
def test_embeddedin(self):
"""Test Site.page_embeddedin."""
embedded_ns_0 = set(self.site.page_embeddedin(
self.mainpage, namespaces=[0]))
embedded_ns_0_2 = set(self.site.page_embeddedin(
self.mainpage, namespaces=[0, 2]))
redirs = set(self.site.page_embeddedin(
self.mainpage, filter_redirects=True, namespaces=[0]))
no_redirs = set(self.site.page_embeddedin(
self.mainpage, filter_redirects=False, namespaces=[0]))
for ei in embedded_ns_0:
self.assertIsInstance(ei, pywikibot.Page)
self.assertLessEqual(redirs, embedded_ns_0)
self.assertLessEqual(no_redirs, embedded_ns_0)
self.assertLessEqual(embedded_ns_0, embedded_ns_0_2)
def test_pagecategories(self):
"""Test Site.pagecategories."""
for cat in self.site.pagecategories(self.mainpage):
self.assertIsInstance(cat, pywikibot.Category)
def test_categorymembers(self):
"""Test Site.categorymembers."""
cats = list(self.site.pagecategories(self.mainpage))
if len(cats) == 0:
self.skipTest('Main page is not in any categories.')
else:
for cm in self.site.categorymembers(cats[0]):
self.assertIsInstance(cm, pywikibot.Page)
def test_pageimages(self):
"""Test Site.pageimages."""
for im in self.site.pageimages(self.mainpage):
self.assertIsInstance(im, pywikibot.FilePage)
def test_pagetemplates(self):
"""Test Site.pagetemplates."""
tl_gen = self.site.pagetemplates(self.mainpage)
expected_params = {
'titles': [self.mainpage.title()],
'prop': ['info', 'imageinfo', 'categoryinfo'],
'inprop': ['protection'],
'iilimit': ['max'],
'iiprop': ['timestamp', 'user', 'comment', 'url', 'size',
'sha1', 'metadata'],
'generator': ['templates'], 'action': ['query'],
'indexpageids': [True]}
if self.site.mw_version >= '1.21':
expected_params['continue'] = [True]
self.assertEqual(tl_gen.request._params, expected_params)
tl_gen = self.site.pagetemplates(self.mainpage, namespaces=[10])
expected_params['gtlnamespace'] = [10]
self.assertEqual(tl_gen.request._params, expected_params)
for te in tl_gen:
self.assertIsInstance(te, pywikibot.Page)
self.assertEqual(te.namespace(), 10)
def test_pagelanglinks(self):
"""Test Site.pagelanglinks."""
for ll in self.site.pagelanglinks(self.mainpage):
self.assertIsInstance(ll, pywikibot.Link)
def test_page_extlinks(self):
"""Test Site.extlinks."""
for el in self.site.page_extlinks(self.mainpage):
self.assertIsInstance(el, basestring)
def test_pagelinks(self):
"""Test Site.pagelinks."""
links_gen = self.site.pagelinks(self.mainpage)
gen_params = links_gen.request._params.copy()
expected_params = {
'redirects': [False],
'prop': ['info', 'imageinfo', 'categoryinfo'],
'inprop': ['protection'],
'iilimit': ['max'],
'iiprop': ['timestamp', 'user', 'comment', 'url', 'size',
'sha1', 'metadata'], 'generator': ['links'],
'action': ['query'], 'indexpageids': [True]}
if 'pageids' in gen_params:
expected_params['pageids'] = [str(self.mainpage.pageid)]
else:
expected_params['titles'] = [self.mainpage.title()]
if self.site.mw_version >= '1.21':
expected_params['continue'] = [True]
self.assertEqual(gen_params, expected_params)
links_gen = self.site.pagelinks(self.mainpage, namespaces=[0, 1])
gen_params = links_gen.request._params.copy()
expected_params['gplnamespace'] = [0, 1]
self.assertEqual(gen_params, expected_params)
self.assertPagesInNamespaces(links_gen, {0, 1})
for target in self.site.preloadpages(
self.site.pagelinks(self.mainpage, follow_redirects=True,
total=5)):
self.assertIsInstance(target, pywikibot.Page)
self.assertFalse(target.isRedirectPage())
def test_allpages(self):
"""Test the site.allpages() method."""
mysite = self.get_site()
fwd = list(mysite.allpages(total=10))
self.assertLessEqual(len(fwd), 10)
for page in fwd:
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
rev = list(mysite.allpages(reverse=True, start='Aa', total=12))
self.assertLessEqual(len(rev), 12)
for page in rev:
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
self.assertLessEqual(page.title(), 'Aa')
for page in mysite.allpages(start='Py', total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
self.assertGreaterEqual(page.title(), 'Py')
for page in mysite.allpages(prefix='Pre', total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
self.assertTrue(page.title().startswith('Pre'))
for page in mysite.allpages(namespace=1, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 1)
for page in mysite.allpages(filterredir=True, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
self.assertTrue(page.isRedirectPage())
for page in mysite.allpages(filterredir=False, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
self.assertFalse(page.isRedirectPage())
def test_allpages_langlinks_enabled(self):
"""Test allpages with langlinks enabled."""
mysite = self.get_site()
if mysite.family.name in ('wpbeta', 'wsbeta'):
self.skipTest('Test fails on betawikis; T199085')
for page in mysite.allpages(
filterlanglinks=True, total=3, namespace=4):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 4)
self.assertNotEqual(page.langlinks(), [])
def test_allpages_langlinks_disabled(self):
"""Test allpages with langlinks disabled."""
mysite = self.get_site()
for page in mysite.allpages(filterlanglinks=False, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertEqual(page.namespace(), 0)
self.assertEqual(page.langlinks(), [])
def test_allpages_pagesize(self):
"""Test allpages with page maxsize parameter."""
mysite = self.get_site()
for page in mysite.allpages(minsize=100, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertGreaterEqual(len(page.text.encode(mysite.encoding())),
100)
for page in mysite.allpages(maxsize=200, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
if (len(page.text.encode(mysite.encoding())) > 200
and mysite.data_repository() == mysite):
unittest_print(
'{}.text is > 200 bytes while raw JSON is <= 200'
.format(page))
continue
self.assertLessEqual(len(page.text.encode(mysite.encoding())), 200)
def test_allpages_protection(self):
"""Test allpages with protect_type parameter."""
mysite = self.get_site()
for page in mysite.allpages(protect_type='edit', total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertIn('edit', page._protection)
for page in mysite.allpages(protect_type='edit',
protect_level='sysop', total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
self.assertIn('edit', page._protection)
self.assertIn('sysop', page._protection['edit'])
def test_all_links(self):
"""Test the site.alllinks() method."""
if self.site.family.name == 'wsbeta':
self.skipTest('Test fails on betawiki; T69931')
mysite = self.get_site()
fwd = list(mysite.alllinks(total=10))
self.assertLessEqual(len(fwd), 10)
self.assertTrue(all(isinstance(link, pywikibot.Page) for link in fwd))
uniq = list(mysite.alllinks(total=10, unique=True))
self.assertTrue(all(link in uniq for link in fwd))
for page in mysite.alllinks(start='Link', total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertEqual(page.namespace(), 0)
self.assertGreaterEqual(page.title(), 'Link')
for page in mysite.alllinks(prefix='Fix', total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertEqual(page.namespace(), 0)
self.assertTrue(page.title().startswith('Fix'))
for page in mysite.alllinks(namespace=1, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertEqual(page.namespace(), 1)
for page in mysite.alllinks(start='From', namespace=4, fromids=True,
total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertGreaterEqual(page.title(with_ns=False), 'From')
self.assertTrue(hasattr(page, '_fromid'))
errgen = mysite.alllinks(unique=True, fromids=True)
self.assertRaises(pywikibot.Error, next, errgen)
def test_all_categories(self):
"""Test the site.allcategories() method."""
mysite = self.get_site()
ac = list(mysite.allcategories(total=10))
self.assertLessEqual(len(ac), 10)
self.assertTrue(all(isinstance(cat, pywikibot.Category)
for cat in ac))
for cat in mysite.allcategories(total=5, start='Abc'):
self.assertIsInstance(cat, pywikibot.Category)
self.assertGreaterEqual(cat.title(with_ns=False), 'Abc')
for cat in mysite.allcategories(total=5, prefix='Def'):
self.assertIsInstance(cat, pywikibot.Category)
self.assertTrue(cat.title(with_ns=False).startswith('Def'))
# Bug T17985 - reverse and start combined; fixed in v 1.14
for cat in mysite.allcategories(total=5, start='Hij', reverse=True):
self.assertIsInstance(cat, pywikibot.Category)
self.assertLessEqual(cat.title(with_ns=False), 'Hij')
def test_all_images(self):
"""Test the site.allimages() method."""
mysite = self.get_site()
ai = list(mysite.allimages(total=10))
self.assertLessEqual(len(ai), 10)
self.assertTrue(all(isinstance(image, pywikibot.FilePage)
for image in ai))
for impage in mysite.allimages(start='Ba', total=5):
self.assertIsInstance(impage, pywikibot.FilePage)
self.assertTrue(impage.exists())
self.assertGreaterEqual(impage.title(with_ns=False), 'Ba')
# Bug T17985 - reverse and start combined; fixed in v 1.14
for impage in mysite.allimages(start='Da', reverse=True, total=5):
self.assertIsInstance(impage, pywikibot.FilePage)
self.assertTrue(impage.exists())
self.assertLessEqual(impage.title(with_ns=False), 'Da')
for impage in mysite.allimages(prefix='Ch', total=5):
self.assertIsInstance(impage, pywikibot.FilePage)
self.assertTrue(impage.exists())
self.assertTrue(impage.title(with_ns=False).startswith('Ch'))
for impage in mysite.allimages(minsize=100, total=5):
self.assertIsInstance(impage, pywikibot.FilePage)
self.assertTrue(impage.exists())
self.assertGreaterEqual(impage.latest_file_info['size'], 100)
for impage in mysite.allimages(maxsize=2000, total=5):
self.assertIsInstance(impage, pywikibot.FilePage)
self.assertTrue(impage.exists())
self.assertLessEqual(impage.latest_file_info['size'], 2000)
def test_newfiles(self):
"""Test the site.newfiles() method."""
my_site = self.get_site()
with suppress_warnings(category=DeprecationWarning):
gen = my_site.newfiles(total=10)
the_list = list(gen)
self.assertLessEqual(len(the_list), 10)
self.assertTrue(all(isinstance(tup, tuple) and len(tup) == 4
for tup in the_list))
self.assertTrue(all(isinstance(tup[0], pywikibot.FilePage)
for tup in the_list))
self.assertTrue(all(isinstance(tup[1], pywikibot.Timestamp)
for tup in the_list))
self.assertTrue(all(isinstance(tup[2], unicode) for tup in the_list))
self.assertTrue(all(isinstance(tup[3], unicode) for tup in the_list))
def test_querypage(self):
"""Test the site.querypage() method."""
mysite = self.get_site()
pages = list(mysite.querypage('Longpages', total=10))
self.assertTrue(all(isinstance(p, pywikibot.Page) for p in pages))
self.assertRaises(AssertionError, mysite.querypage, 'LongpageX')
def test_longpages(self):
"""Test the site.longpages() method."""
mysite = self.get_site()
longpages = list(mysite.longpages(total=10))
# Make sure each object returned by site.longpages() is
# a tuple of a Page object and an int
self.assertTrue(all(isinstance(tup, tuple) and len(tup) == 2
for tup in longpages))
self.assertTrue(all(isinstance(tup[0], pywikibot.Page)
for tup in longpages))
self.assertTrue(all(isinstance(tup[1], int) for tup in longpages))
def test_shortpages(self):
"""Test the site.shortpages() method."""
mysite = self.get_site()
shortpages = list(mysite.shortpages(total=10))
# Make sure each object returned by site.shortpages() is
# a tuple of a Page object and an int
self.assertTrue(all(isinstance(tup, tuple) and len(tup) == 2
for tup in shortpages))
self.assertTrue(all(isinstance(tup[0], pywikibot.Page)
for tup in shortpages))
self.assertTrue(all(isinstance(tup[1], int) for tup in shortpages))
def test_ancientpages(self):
"""Test the site.ancientpages() method."""
mysite = self.get_site()
ancientpages = list(mysite.ancientpages(total=10))
# Make sure each object returned by site.ancientpages() is
# a tuple of a Page object and a Timestamp object
self.assertTrue(all(isinstance(tup, tuple) and len(tup) == 2
for tup in ancientpages))
self.assertTrue(all(isinstance(tup[0], pywikibot.Page)
for tup in ancientpages))
self.assertTrue(all(isinstance(tup[1], pywikibot.Timestamp)
for tup in ancientpages))
def test_unwatchedpages(self):
"""Test the site.unwatchedpages() method."""
mysite = self.get_site()
try:
unwatchedpages = list(mysite.unwatchedpages(total=10))
except api.APIError as error:
if error.code in ('specialpage-cantexecute',
'gqpspecialpage-cantexecute'):
# User must have correct permissions to use
# Special:UnwatchedPages
self.skipTest(error)
raise
# Make sure each object returned by site.unwatchedpages() is a
# Page object
self.assertTrue(all(isinstance(p, pywikibot.Page)
for p in unwatchedpages))
def test_blocks(self):
"""Test the site.blocks() method."""
mysite = self.get_site()
props = ('id', 'by', 'timestamp', 'expiry', 'reason')
with self.subTest(total=10, reverse=False):
bl = list(mysite.blocks(total=10))
self.assertLessEqual(len(bl), 10)
for block in bl:
self.assertIsInstance(block, dict)
for prop in props:
self.assertIn(prop, block)
# timestamps should be in descending order
timestamps = [block['timestamp'] for block in bl]
for t in range(1, len(timestamps)):
self.assertLessEqual(timestamps[t], timestamps[t - 1])
with self.subTest(total=10, reverse=True):
b2 = list(mysite.blocks(total=10, reverse=True))
self.assertLessEqual(len(b2), 10)
for block in b2:
self.assertIsInstance(block, dict)
for prop in props:
self.assertIn(prop, block)
# timestamps should be in ascending order
timestamps = [block['timestamp'] for block in b2]
for t in range(1, len(timestamps)):
self.assertGreaterEqual(timestamps[t], timestamps[t - 1])
ip = '80.100.22.71'
with self.subTest(users=ip):
for block in mysite.blocks(users=ip, total=5):
self.assertIsInstance(block, dict)
self.assertEqual(block['user'], ip)
low = pywikibot.Timestamp.fromISOformat('2008-08-03T00:00:01Z')
high = pywikibot.Timestamp.fromISOformat('2008-08-03T23:59:59Z')
with self.subTest(starttime=low):
for block in mysite.blocks(starttime=low, total=5):
self.assertIsInstance(block, dict)
for prop in props:
self.assertIn(prop, block)
with self.subTest(endtime=high):
for block in mysite.blocks(endtime=high, total=5):
self.assertIsInstance(block, dict)
for prop in props:
self.assertIn(prop, block)
with self.subTest(starttime=high, endtime=low, reverse=False):
for block in mysite.blocks(starttime=high, endtime=low, total=5):
self.assertIsInstance(block, dict)
for prop in props:
self.assertIn(prop, block)
with self.subTest(starttime=low, endtime=high, reverse=True):
for block in mysite.blocks(starttime=low, endtime=high,
reverse=True, total=5):
self.assertIsInstance(block, dict)
for prop in props:
self.assertIn(prop, block)
# starttime earlier than endtime
with self.subTest(starttime=low, endtime=high, reverse=False):
self.assertRaises(AssertionError, mysite.blocks, total=5,
starttime=low, endtime=high)
# reverse: endtime earlier than starttime
with self.subTest(starttime=high, endtime=low, reverse=True):
self.assertRaises(AssertionError, mysite.blocks, total=5,
starttime=high, endtime=low, reverse=True)
def test_exturl_usage(self):
"""Test the site.exturlusage() method."""
mysite = self.get_site()
url = 'www.google.com'
eu = list(mysite.exturlusage(url, total=10))
self.assertLessEqual(len(eu), 10)
self.assertTrue(all(isinstance(link, pywikibot.Page)
for link in eu))
for link in mysite.exturlusage(url, namespaces=[2, 3], total=5):
self.assertIsInstance(link, pywikibot.Page)
self.assertIn(link.namespace(), (2, 3))
def test_lock_page(self):
"""Test the site.lock_page() and site.unlock_page() method."""
site = self.get_site()
p1 = pywikibot.Page(site, 'Foo')
site.lock_page(page=p1, block=True)
self.assertRaises(pywikibot.site.PageInUse, site.lock_page, page=p1,
block=False)
site.unlock_page(page=p1)
# verify it's unlocked
site.lock_page(page=p1, block=False)
site.unlock_page(page=p1)
def test_protectedpages_create(self):
"""Test that protectedpages returns protected page titles."""
if self.site.mw_version < '1.15':
self.skipTest('requires v1.15+')
pages = list(self.get_site().protectedpages(type='create', total=10))
# Do not check for the existence of pages as they might exist (T205883)
self.assertLessEqual(len(pages), 10)
def test_protectedpages_edit(self):
"""Test that protectedpages returns protected pages."""
site = self.get_site()
pages = list(site.protectedpages(type='edit', total=10))
for page in pages:
self.assertTrue(page.exists())
self.assertIn('edit', page.protection())
self.assertLessEqual(len(pages), 10)
def test_protectedpages_edit_level(self):
"""Test protectedpages protection level."""
site = self.get_site()
levels = set()
all_levels = site.protection_levels().difference([''])
for level in all_levels:
if list(site.protectedpages(type='edit', level=level, total=1)):
levels.add(level)
if not levels:
self.skipTest(
'The site "{0}" has no protected pages in main namespace.'
.format(site))
# select one level which won't yield all pages from above
level = next(iter(levels))
if len(levels) == 1:
# if only one level found, then use any other except that
level = next(iter(all_levels.difference([level])))
invalid_levels = all_levels.difference([level])
pages = list(site.protectedpages(type='edit', level=level, total=10))
for page in pages:
self.assertTrue(page.exists())
self.assertIn('edit', page.protection())
self.assertEqual(page.protection()['edit'][0], level)
self.assertNotIn(page.protection()['edit'][0], invalid_levels)
self.assertLessEqual(len(pages), 10)
def test_pages_with_property(self):
"""Test pages_with_property method."""
if self.site.mw_version < '1.21':
self.skipTest('requires v1.21+')
mysite = self.get_site()
pnames = mysite.get_property_names()
for item in ('defaultsort', 'disambiguation', 'displaytitle',
'hiddencat', 'invalid_property'):
if item in pnames:
for page in mysite.pages_with_property(item, total=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertTrue(page.exists())
if item == 'disambiguation':
self.assertTrue(page.isDisambig)
else:
with self.assertRaises(NotImplementedError):
mysite.pages_with_property(item)
self.fail(
'NotImplementedError not raised for {0}'.format(item))
def test_unconnected(self):
"""Test site.unconnected_pages method."""
if not self.site.data_repository():
self.skipTest('Site is not using a Wikibase repository')
upgen = self.site.unconnected_pages(total=3)
self.assertDictEqual(
upgen.request._params, {
'gqppage': ['UnconnectedPages'],
'prop': ['info', 'imageinfo', 'categoryinfo'],
'inprop': ['protection'],
'iilimit': ['max'],
'iiprop': ['timestamp', 'user', 'comment', 'url', 'size',
'sha1', 'metadata'],
'generator': ['querypage'], 'action': ['query'],
'indexpageids': [True], 'continue': [True]})
self.assertLessEqual(len(tuple(upgen)), 3)
def test_assert_valid_iter_params(self):
"""Test site.assert_valid_iter_params method."""
func = self.site.assert_valid_iter_params
# reverse=False, is_ts=False
self.assertIsNone(func('m', 1, 2, False, False))
self.assertRaises(AssertionError, func, 'm', 2, 1, False, False)
# reverse=False, is_ts=True
self.assertIsNone(func('m', 2, 1, False, True))
self.assertRaises(AssertionError, func, 'm', 1, 2, False, True)
# reverse=True, is_ts=False
self.assertIsNone(func('m', 2, 1, True, False))
self.assertRaises(AssertionError, func, 'm', 1, 2, True, False)
# reverse=True, is_ts=True
self.assertIsNone(func('m', 1, 2, True, True))
self.assertRaises(AssertionError, func, 'm', 2, 1, True, True)
class TestThreadsLockingPage(DefaultSiteTestCase):
"""Test cases for lock/unlock a page within threads."""
cached = True
def worker(self):
"""Lock a page, wait few seconds and unlock the page."""
page = pywikibot.Page(self.site, 'Foo')
page.site.lock_page(page=page, block=True)
wait = random.randint(1, 25) / 10
time.sleep(wait)
page.site.unlock_page(page=page)
def test_lock_page(self):
"""Test the site.lock_page() and site.unlock_page() method."""
# Start few threads
threads = []
for i in range(5):
thread = threading.Thread(target=self.worker)
thread.setDaemon(True)
thread.start()
threads.append(thread)
for thread in threads:
thread.join(15) # maximum wait time for all threads
with self.subTest(name=thread.getName()):
# Check whether a timeout happened.
# In that case is_alive() is True
self.assertFalse(thread.is_alive(),
'test page is still locked')
class TestSiteGeneratorsUsers(DefaultSiteTestCase):
"""Test cases for Site methods with users."""
cached = True
def setUp(self):
"""Initialize self.site and self.mainpage."""
super(TestSiteGeneratorsUsers, self).setUp()
self.site = self.get_site()
self.mainpage = self.get_mainpage()
def test_botusers(self):
"""Test the site.botusers() method."""
mysite = self.get_site()
bu = list(mysite.botusers(total=10))
self.assertLessEqual(len(bu), 10)
for botuser in bu:
self.assertIsInstance(botuser, dict)
self.assertIn('name', botuser)
self.assertIn('userid', botuser)
self.assertIn('editcount', botuser)
self.assertIn('registration', botuser)
self.assertIn('bot', botuser['groups'])
def test_allusers(self):
"""Test the site.allusers() method."""
mysite = self.get_site()
au = list(mysite.allusers(total=10))
self.assertLessEqual(len(au), 10)
for user in au:
self.assertIsInstance(user, dict)
self.assertIn('name', user)
self.assertIn('editcount', user)
self.assertIn('registration', user)
self.assertIn('user', user['groups'])
def test_allusers_with_start(self):
"""Test the site.allusers(start=..) method."""
mysite = self.get_site()
for user in mysite.allusers(start='B', total=5):
self.assertIsInstance(user, dict)
self.assertIn('name', user)
self.assertGreaterEqual(user['name'], 'B')
self.assertIn('editcount', user)
self.assertIn('registration', user)
def test_allusers_with_prefix(self):
"""Test the site.allusers(prefix=..) method."""
mysite = self.get_site()
for user in mysite.allusers(prefix='C', total=5):
self.assertIsInstance(user, dict)
self.assertIn('name', user)
self.assertTrue(user['name'].startswith('C'))
self.assertIn('editcount', user)
self.assertIn('registration', user)
def _test_allusers_with_group(self):
"""Test the site.allusers(group=..) method."""
mysite = self.get_site()
for user in mysite.allusers(prefix='D', group='bot', total=5):
self.assertIsInstance(user, dict)
self.assertIn('name', user)
self.assertTrue(user['name'].startswith('D'))
self.assertIn('editcount', user)
self.assertIn('registration', user)
self.assertIn('groups' in user)
self.assertIn('sysop' in user['groups'])
class TestLinterPages(DefaultSiteTestCase):
"""Test linter_pages methods."""
def setUp(self):
"""Skip tests if Linter extension is missing."""
super(TestLinterPages, self).setUp()
if not self.site.has_extension('Linter'):
self.skipTest(
'The site {0} does not use Linter extension'.format(self.site))
def test_linter_pages(self):
"""Test the deprecated site.logpages() method."""
le = list(self.site.linter_pages(
lint_categories='obsolete-tag|missing-end-tag', total=5))
self.assertLessEqual(len(le), 5)
for entry in le:
self.assertIsInstance(entry, pywikibot.Page)
self.assertIn(entry._lintinfo['category'],
['obsolete-tag', 'missing-end-tag'])
class TestImageUsage(DefaultSiteTestCase):
"""Test cases for Site.imageusage method."""
cached = True
@property
def imagepage(self):
"""Find an image which is used on the main page.
If there are no images included in main page it'll skip all tests.
Note: This is not implemented as setUpClass which would be invoked
while initialising all tests, to reduce chance of an error preventing
all tests from running.
"""
if hasattr(self.__class__, '_image_page'):
return self.__class__._image_page
mysite = self.get_site()
page = pywikibot.Page(mysite, mysite.siteinfo['mainpage'])
try:
imagepage = next(iter(page.imagelinks())) # 1st image of page
except StopIteration:
raise unittest.SkipTest(
'No images on the main page of site {0!r}'.format(mysite))
pywikibot.output('site_tests.TestImageUsage found {} on {}'
.format(imagepage, page))
self.__class__._image_page = imagepage
return imagepage
def test_image_usage(self):
"""Test the site.imageusage() method."""
mysite = self.get_site()
imagepage = self.imagepage
iu = list(mysite.imageusage(imagepage, total=10))
self.assertLessEqual(len(iu), 10)
self.assertTrue(all(isinstance(link, pywikibot.Page)
for link in iu))
def test_image_usage_in_namespaces(self):
"""Test the site.imageusage() method with namespaces."""
mysite = self.get_site()
imagepage = self.imagepage
for using in mysite.imageusage(imagepage, namespaces=[3, 4], total=5):
self.assertIsInstance(using, pywikibot.Page)
self.assertIn(imagepage, list(using.imagelinks()))
@allowed_failure_if(os.environ.get('TRAVIS', 'false') == 'true')
def test_image_usage_in_redirects(self):
"""Test the site.imageusage() method on redirects only."""
mysite = self.get_site()
imagepage = self.imagepage
for using in mysite.imageusage(imagepage, filterredir=True, total=5):
self.assertIsInstance(using, pywikibot.Page)
self.assertTrue(using.isRedirectPage())
def test_image_usage_no_redirect_filter(self):
"""Test the site.imageusage() method with redirects."""
mysite = self.get_site()
imagepage = self.imagepage
for using in mysite.imageusage(imagepage, filterredir=False, total=5):
self.assertIsInstance(using, pywikibot.Page)
if using.isRedirectPage():
unittest_print(
'{0} is a redirect, although just non-redirects were '
'searched. See also T75120'.format(using))
self.assertFalse(using.isRedirectPage())
class SiteUserTestCase(DefaultSiteTestCase):
"""Test site method using a user."""
user = True
def test_methods(self):
"""Test user related methods."""
mysite = self.get_site()
self.assertIsInstance(mysite.is_blocked(), bool)
self.assertIsInstance(mysite.messages(), bool)
self.assertIsInstance(mysite.has_right('edit'), bool)
self.assertFalse(mysite.has_right('nonexistent_right'))
self.assertIsInstance(mysite.has_group('bots'), bool)
self.assertFalse(mysite.has_group('nonexistent_group'))
for grp in ('user', 'autoconfirmed', 'bot', 'sysop', 'nosuchgroup'):
self.assertIsInstance(mysite.has_group(grp), bool)
for rgt in ('read', 'edit', 'move', 'delete', 'rollback', 'block',
'nosuchright'):
self.assertIsInstance(mysite.has_right(rgt), bool)
def test_logevents(self):
"""Test the site.logevents() method."""
mysite = self.get_site()
for entry in mysite.logevents(user=mysite.user(), total=3):
self.assertEqual(entry.user(), mysite.user())
class TestLogEvents(DefaultSiteTestCase):
"""Test logevents methods."""
def test_logevents(self):
"""Test logevents method."""
mysite = self.get_site()
le = list(mysite.logevents(total=10))
self.assertLessEqual(len(le), 10)
self.assertTrue(all(isinstance(entry, pywikibot.logentries.LogEntry)
for entry in le))
for typ in ('block', 'protect', 'rights', 'delete', 'upload',
'move', 'import', 'patrol', 'merge'):
for entry in mysite.logevents(logtype=typ, total=3):
self.assertEqual(entry.type(), typ)
def test_logevents_mainpage(self):
"""Test logevents method on the main page."""
mysite = self.get_site()
mainpage = self.get_mainpage()
for entry in mysite.logevents(page=mainpage, total=3):
self.assertEqual(entry.page().title(), mainpage.title())
self.assertEqual(entry.page(), mainpage)
def test_logevents_timestamp(self):
"""Test logevents method."""
mysite = self.get_site()
for entry in mysite.logevents(
start=pywikibot.Timestamp.fromISOformat(
'2008-09-01T00:00:01Z'), total=5):
self.assertIsInstance(entry, pywikibot.logentries.LogEntry)
self.assertLessEqual(str(entry.timestamp()),
'2008-09-01T00:00:01Z')
for entry in mysite.logevents(
end=pywikibot.Timestamp.fromISOformat('2008-09-02T23:59:59Z'),
total=5):
self.assertIsInstance(entry, pywikibot.logentries.LogEntry)
self.assertGreaterEqual(str(entry.timestamp()),
'2008-09-02T23:59:59Z')
for entry in mysite.logevents(
start=pywikibot.Timestamp.fromISOformat(
'2008-02-02T00:00:01Z'),
end=pywikibot.Timestamp.fromISOformat('2008-02-02T23:59:59Z'),
reverse=True, total=5):
self.assertIsInstance(entry, pywikibot.logentries.LogEntry)
self.assertTrue(
'2008-02-02T00:00:01Z' <= str(entry.timestamp())
<= '2008-02-02T23:59:59Z')
for entry in mysite.logevents(
start=pywikibot.Timestamp.fromISOformat(
'2008-02-03T23:59:59Z'),
end=pywikibot.Timestamp.fromISOformat('2008-02-03T00:00:01Z'),
total=5):
self.assertIsInstance(entry, pywikibot.logentries.LogEntry)
self.assertTrue(
'2008-02-03T00:00:01Z' <= str(entry.timestamp())
<= '2008-02-03T23:59:59Z')
# starttime earlier than endtime
self.assertRaises(AssertionError, mysite.logevents,
start=pywikibot.Timestamp.fromISOformat(
'2008-02-03T00:00:01Z'),
end=pywikibot.Timestamp.fromISOformat(
'2008-02-03T23:59:59Z'), total=5)
# reverse: endtime earlier than starttime
self.assertRaises(AssertionError, mysite.logevents,
start=pywikibot.Timestamp.fromISOformat(
'2008-02-03T23:59:59Z'),
end=pywikibot.Timestamp.fromISOformat(
'2008-02-03T00:00:01Z'),
reverse=True, total=5)
class TestLogPages(DefaultSiteTestCase, DeprecationTestCase):
"""Test logpages methods."""
def test_logpages(self):
"""Test the deprecated site.logpages() method."""
le = list(self.site.logpages(number=10))
self.assertOneDeprecation()
self.assertLessEqual(len(le), 10)
for entry in le:
self.assertIsInstance(entry, tuple)
if not isinstance(entry[0], int): # autoblock removal entry
self.assertIsInstance(entry[0], pywikibot.Page)
self.assertIsInstance(entry[1], basestring)
self.assertIsInstance(
entry[2], long if PY2 and entry[2] > sys.maxint else int)
self.assertIsInstance(entry[3], basestring)
def test_list_namespace(self):
"""Test the deprecated site.logpages() when namespace is a list."""
if self.site.mw_version <= '1.19.24': # T217664
self.skipTest(
'logevents does not support namespace parameter with MediaWiki'
' {}.'.format(self.site.mw_version))
le = list(self.site.logpages(namespace=[2, 3], number=10))
for entry in le:
if isinstance(entry[0], int): # autoblock removal entry
continue
try:
self.assertIn(entry[0].namespace(), [2, 3])
except HiddenKeyError as e:
self.skipTest(
'Log entry {entry} is hidden:\n{entry.data}\n{error!r}'
.format(entry=entry, error=e))
def test_logpages_dump(self):
"""Test the deprecated site.logpages() method using dump mode."""
le = list(self.site.logpages(number=10, dump=True))
self.assertOneDeprecation()
self.assertLessEqual(len(le), 10)
for entry in le:
self.assertIsInstance(entry, dict)
self.assertIn('title', entry)
class TestRecentChanges(DefaultSiteTestCase):
"""Test recentchanges method."""
@classmethod
def setUpClass(cls):
"""Test up test class."""
super(TestRecentChanges, cls).setUpClass()
mysite = cls.get_site()
try:
# 1st image on main page
imagepage = next(iter(mysite.allimages()))
except StopIteration:
unittest_print('No images on site {0!r}'.format(mysite))
imagepage = None
cls.imagepage = imagepage
def test_basic(self):
"""Test the site.recentchanges() method."""
mysite = self.site
rc = list(mysite.recentchanges(total=10))
self.assertLessEqual(len(rc), 10)
self.assertTrue(all(isinstance(change, dict)
for change in rc))
def test_time_range(self):
"""Test the site.recentchanges() method with start/end."""
mysite = self.site
for change in mysite.recentchanges(
start=pywikibot.Timestamp.fromISOformat(
'2008-10-01T01:02:03Z'),
total=5):
self.assertIsInstance(change, dict)
self.assertLessEqual(change['timestamp'], '2008-10-01T01:02:03Z')
for change in mysite.recentchanges(
end=pywikibot.Timestamp.fromISOformat('2008-04-01T02:03:04Z'),
total=5):
self.assertIsInstance(change, dict)
self.assertGreaterEqual(change['timestamp'],
'2008-10-01T02:03:04Z')
for change in mysite.recentchanges(
start=pywikibot.Timestamp.fromISOformat(
'2008-10-01T03:05:07Z'),
total=5, reverse=True):
self.assertIsInstance(change, dict)
self.assertGreaterEqual(change['timestamp'],
'2008-10-01T03:05:07Z')
for change in mysite.recentchanges(
end=pywikibot.Timestamp.fromISOformat('2008-10-01T04:06:08Z'),
total=5, reverse=True):
self.assertIsInstance(change, dict)
self.assertLessEqual(change['timestamp'], '2008-10-01T04:06:08Z')
for change in mysite.recentchanges(
start=pywikibot.Timestamp.fromISOformat(
'2008-10-03T11:59:59Z'),
end=pywikibot.Timestamp.fromISOformat('2008-10-03T00:00:01Z'),
total=5):
self.assertIsInstance(change, dict)
self.assertTrue(
'2008-10-03T00:00:01Z' <= change['timestamp']
<= '2008-10-03T11:59:59Z')
for change in mysite.recentchanges(
start=pywikibot.Timestamp.fromISOformat(
'2008-10-05T06:00:01Z'),
end=pywikibot.Timestamp.fromISOformat('2008-10-05T23:59:59Z'),
reverse=True, total=5):
self.assertIsInstance(change, dict)
self.assertTrue(
'2008-10-05T06:00:01Z' <= change['timestamp']
<= '2008-10-05T23:59:59Z')
# start earlier than end
self.assertRaises(AssertionError, mysite.recentchanges,
start='2008-02-03T00:00:01Z',
end='2008-02-03T23:59:59Z', total=5)
# reverse: end earlier than start
self.assertRaises(AssertionError, mysite.recentchanges,
start=pywikibot.Timestamp.fromISOformat(
'2008-02-03T23:59:59Z'),
end=pywikibot.Timestamp.fromISOformat(
'2008-02-03T00:00:01Z'),
reverse=True, total=5)
def test_ns_file(self):
"""Test the site.recentchanges() method with File: and File talk:."""
if self.site.code == 'wikidata':
self.skipTest(
'MediaWiki bug frequently occurring on Wikidata. T101502')
mysite = self.site
for change in mysite.recentchanges(namespaces=[6, 7], total=5):
self.assertIsInstance(change, dict)
self.assertIn('title', change)
self.assertIn('ns', change)
title = change['title']
self.assertIn(':', title)
prefix = title[:title.index(':')]
self.assertIn(self.site.namespaces.lookup_name(prefix).id, [6, 7])
self.assertIn(change['ns'], [6, 7])
def test_pagelist(self):
"""Test the site.recentchanges() with pagelist deprecated MW 1.14."""
mysite = self.site
mainpage = self.get_mainpage()
imagepage = self.imagepage
if mysite.mw_version <= '1.14':
pagelist = [mainpage]
if imagepage:
pagelist += [imagepage]
titlelist = {page.title() for page in pagelist}
for change in mysite.recentchanges(pagelist=pagelist,
total=5):
self.assertIsInstance(change, dict)
self.assertIn('title', change)
self.assertIn(change['title'], titlelist)
def test_changetype(self):
"""Test the site.recentchanges() with changetype."""
mysite = self.site
for typ in ('edit', 'new', 'log'):
for change in mysite.recentchanges(changetype=typ, total=5):
self.assertIsInstance(change, dict)
self.assertIn('type', change)
self.assertEqual(change['type'], typ)
def test_flags(self):
"""Test the site.recentchanges() with boolean flags."""
mysite = self.site
for change in mysite.recentchanges(minor=True, total=5):
self.assertIsInstance(change, dict)
self.assertIn('minor', change)
for change in mysite.recentchanges(minor=False, total=5):
self.assertIsInstance(change, dict)
self.assertNotIn('minor', change)
for change in mysite.recentchanges(bot=True, total=5):
self.assertIsInstance(change, dict)
self.assertIn('bot', change)
for change in mysite.recentchanges(bot=False, total=5):
self.assertIsInstance(change, dict)
self.assertNotIn('bot', change)
for change in mysite.recentchanges(anon=True, total=5):
self.assertIsInstance(change, dict)
for change in mysite.recentchanges(anon=False, total=5):
self.assertIsInstance(change, dict)
for change in mysite.recentchanges(redirect=True, total=5):
self.assertIsInstance(change, dict)
self.assertIn('redirect', change)
for change in mysite.recentchanges(redirect=False, total=5):
self.assertIsInstance(change, dict)
self.assertNotIn('redirect', change)
def test_tag_filter(self):
"""Test the site.recentchanges() with tag filter."""
mysite = self.site
for tag in ('visualeditor', 'mobile edit'):
for change in mysite.recentchanges(tag=tag, total=5):
self.assertIsInstance(change, dict)
self.assertIn('tags', change)
self.assertIsInstance(change['tags'], list)
self.assertIn(tag, change['tags'])
class TestUserRecentChanges(DefaultSiteTestCase):
"""Test recentchanges method requiring a user."""
user = True
def test_patrolled(self):
"""Test the site.recentchanges() with patrolled boolean flags."""
mysite = self.site
for change in mysite.recentchanges(patrolled=True, total=5):
self.assertIsInstance(change, dict)
if mysite.has_right('patrol'):
self.assertIn('patrolled', change)
for change in mysite.recentchanges(patrolled=False, total=5):
self.assertIsInstance(change, dict)
if mysite.has_right('patrol'):
self.assertNotIn('patrolled', change)
class TestUserWatchedPages(DefaultSiteTestCase):
"""Test user watched pages."""
user = True
def test_watched_pages(self):
"""Test the site.watched_pages() method."""
gen = self.site.watched_pages(total=5, force=False)
self.assertIsInstance(gen.request, api.CachedRequest)
for page in gen:
self.assertIsInstance(page, pywikibot.Page)
# repeat to use the cache
gen = self.site.watched_pages(total=5, force=False)
self.assertIsInstance(gen.request, api.CachedRequest)
for page in gen:
self.assertIsInstance(page, pywikibot.Page)
def test_watched_pages_uncached(self):
"""Test the site.watched_pages() method uncached."""
gen = self.site.watched_pages(total=5, force=True)
self.assertIsInstance(gen.request, api.Request)
self.assertFalse(issubclass(gen.request_class, api.CachedRequest))
for page in gen:
self.assertIsInstance(page, pywikibot.Page)
class SearchTestCase(DefaultSiteTestCase):
"""Test search method."""
def test_search(self):
"""Test the site.search() method."""
mysite = self.site
try:
se = list(mysite.search('wiki', total=100, namespaces=0))
self.assertLessEqual(len(se), 100)
self.assertTrue(all(isinstance(hit, pywikibot.Page)
for hit in se))
self.assertTrue(all(hit.namespace() == 0 for hit in se))
for hit in mysite.search('common', namespaces=4, total=5):
self.assertIsInstance(hit, pywikibot.Page)
self.assertEqual(hit.namespace(), 4)
for hit in mysite.search('word', namespaces=[5, 6, 7], total=5):
self.assertIsInstance(hit, pywikibot.Page)
self.assertIn(hit.namespace(), [5, 6, 7])
for hit in mysite.search('another', namespaces='8|9|10', total=5):
self.assertIsInstance(hit, pywikibot.Page)
self.assertIn(hit.namespace(), [8, 9, 10])
for hit in mysite.search('wiki', namespaces=0, total=10,
get_redirects=True):
self.assertIsInstance(hit, pywikibot.Page)
self.assertEqual(hit.namespace(), 0)
except pywikibot.data.api.APIError as e:
if e.code == 'gsrsearch-error' and 'timed out' in e.info:
self.skipTest('gsrsearch returned timeout on site: {!r}'
.format(e))
raise
@suppress_warnings("where='title' is deprecated", DeprecationWarning)
def test_search_where_title(self):
"""Test site.search() method with 'where' parameter set to title."""
search_gen = self.site.search(
'wiki', namespaces=0, total=10, get_redirects=True, where='title')
expected_params = {
'prop': ['info', 'imageinfo', 'categoryinfo'],
'inprop': ['protection'],
'iiprop': [
'timestamp', 'user', 'comment', 'url', 'size', 'sha1',
'metadata'],
'iilimit': ['max'], 'generator': ['search'], 'action': ['query'],
'indexpageids': [True], 'continue': [True], 'gsrnamespace': [0]}
if self.site.has_extension('CirrusSearch'):
expected_params.update({
'gsrsearch': ['intitle:wiki'], 'gsrwhat': [None]})
else:
expected_params.update({
'gsrsearch': ['wiki'], 'gsrwhat': ['title']})
self.assertEqual(search_gen.request._params, expected_params)
try:
for hit in search_gen:
self.assertIsInstance(hit, pywikibot.Page)
self.assertEqual(hit.namespace(), 0)
except pywikibot.data.api.APIError as e:
if e.code in ('search-title-disabled', 'gsrsearch-title-disabled'):
self.skipTest(
'Title search disabled on site: {0}'.format(self.site))
raise
class TestUserContribsAsUser(DefaultSiteTestCase):
"""Test site method site.usercontribs() with bot user."""
user = True
def test_basic(self):
"""Test the site.usercontribs() method."""
mysite = self.get_site()
uc = list(mysite.usercontribs(user=mysite.user(), total=10))
self.assertLessEqual(len(uc), 10)
self.assertTrue(all(isinstance(contrib, dict)
for contrib in uc))
self.assertTrue(
all('user' in contrib and contrib['user'] == mysite.user()
for contrib in uc))
def test_namespaces(self):
"""Test the site.usercontribs() method using namespaces."""
mysite = self.get_site()
for contrib in mysite.usercontribs(user=mysite.user(),
namespaces=14, total=5):
self.assertIsInstance(contrib, dict)
self.assertIn('title', contrib)
self.assertTrue(contrib['title'].startswith(mysite.namespace(14)))
for contrib in mysite.usercontribs(user=mysite.user(),
namespaces=[10, 11], total=5):
self.assertIsInstance(contrib, dict)
self.assertIn('title', contrib)
self.assertIn(contrib['ns'], (10, 11))
def test_show_minor(self):
"""Test the site.usercontribs() method using showMinor."""
mysite = self.get_site()
for contrib in mysite.usercontribs(user=mysite.user(),
minor=True, total=5):
self.assertIsInstance(contrib, dict)
self.assertIn('minor', contrib)
for contrib in mysite.usercontribs(user=mysite.user(),
minor=False, total=5):
self.assertIsInstance(contrib, dict)
self.assertNotIn('minor', contrib)
class TestUserContribsWithoutUser(DefaultSiteTestCase):
"""Test site method site.usercontribs() without bot user."""
def test_user_prefix(self):
"""Test the site.usercontribs() method with userprefix."""
mysite = self.get_site()
for contrib in mysite.usercontribs(userprefix='John', total=5):
self.assertIsInstance(contrib, dict)
for key in ('user', 'title', 'ns', 'pageid', 'revid'):
self.assertIn(key, contrib)
self.assertTrue(contrib['user'].startswith('John'))
def test_user_prefix_range(self):
"""Test the site.usercontribs() method."""
mysite = self.get_site()
start = '2008-10-06T01:02:03Z'
for contrib in mysite.usercontribs(
userprefix='Jane',
start=pywikibot.Timestamp.fromISOformat(start),
total=5):
self.assertLessEqual(contrib['timestamp'], start)
end = '2008-10-07T02:03:04Z'
for contrib in mysite.usercontribs(
userprefix='Jane',
end=pywikibot.Timestamp.fromISOformat(end),
total=5):
self.assertGreaterEqual(contrib['timestamp'], end)
start = '2008-10-10T11:59:59Z'
end = '2008-10-10T00:00:01Z'
for contrib in mysite.usercontribs(
userprefix='Timshiel',
start=pywikibot.Timestamp.fromISOformat(start),
end=pywikibot.Timestamp.fromISOformat(end),
total=5):
self.assertTrue(end <= contrib['timestamp'] <= start)
def test_user_prefix_reverse(self):
"""Test the site.usercontribs() method with range reversed."""
mysite = self.get_site()
start = '2008-10-08T03:05:07Z'
for contrib in mysite.usercontribs(
userprefix='Brion',
start=pywikibot.Timestamp.fromISOformat(start),
total=5, reverse=True):
self.assertGreaterEqual(contrib['timestamp'], start)
for contrib in mysite.usercontribs(
userprefix='Brion',
end=pywikibot.Timestamp.fromISOformat('2008-10-09T04:06:08Z'),
total=5, reverse=True):
self.assertLessEqual(contrib['timestamp'], '2008-10-09T04:06:08Z')
start = '2008-10-11T06:00:01Z'
end = '2008-10-11T23:59:59Z'
for contrib in mysite.usercontribs(
userprefix='Tim symond',
start=pywikibot.Timestamp.fromISOformat(start),
end=pywikibot.Timestamp.fromISOformat(end),
reverse=True, total=5):
self.assertTrue(start <= contrib['timestamp'] <= end)
def test_invalid_range(self):
"""Test the site.usercontribs() method with invalid parameters."""
mysite = self.get_site()
# start earlier than end
self.assertRaises(AssertionError, mysite.usercontribs,
userprefix='Jim',
start='2008-10-03T00:00:01Z',
end='2008-10-03T23:59:59Z', total=5)
# reverse: end earlier than start
self.assertRaises(AssertionError, mysite.usercontribs,
userprefix='Jim',
start='2008-10-03T23:59:59Z',
end='2008-10-03T00:00:01Z', reverse=True, total=5)
class SiteWatchlistRevsTestCase(DefaultSiteTestCase):
"""Test site method watchlist_revs()."""
user = True
def test_watchlist_revs(self):
"""Test the site.watchlist_revs() method."""
mysite = self.get_site()
wl = list(mysite.watchlist_revs(total=10))
self.assertLessEqual(len(wl), 10)
self.assertTrue(all(isinstance(rev, dict)
for rev in wl))
for rev in mysite.watchlist_revs(start='2008-10-11T01:02:03Z',
total=5):
self.assertIsInstance(rev, dict)
self.assertLessEqual(rev['timestamp'], '2008-10-11T01:02:03Z')
for rev in mysite.watchlist_revs(end='2008-04-01T02:03:04Z',
total=5):
self.assertIsInstance(rev, dict)
self.assertGreaterEqual(rev['timestamp'], '2008-10-11T02:03:04Z')
for rev in mysite.watchlist_revs(start='2008-10-11T03:05:07Z',
total=5, reverse=True):
self.assertIsInstance(rev, dict)
self.assertGreaterEqual(rev['timestamp'], '2008-10-11T03:05:07Z')
for rev in mysite.watchlist_revs(end='2008-10-11T04:06:08Z',
total=5, reverse=True):
self.assertIsInstance(rev, dict)
self.assertLessEqual(rev['timestamp'], '2008-10-11T04:06:08Z')
for rev in mysite.watchlist_revs(start='2008-10-13T11:59:59Z',
end='2008-10-13T00:00:01Z',
total=5):
self.assertIsInstance(rev, dict)
self.assertTrue(
'2008-10-13T00:00:01Z' <= rev['timestamp']
<= '2008-10-13T11:59:59Z')
for rev in mysite.watchlist_revs(start='2008-10-15T06:00:01Z',
end='2008-10-15T23:59:59Z',
reverse=True, total=5):
self.assertIsInstance(rev, dict)
self.assertTrue(
'2008-10-15T06:00:01Z' <= rev['timestamp']
<= '2008-10-15T23:59:59Z')
# start earlier than end
self.assertRaises(AssertionError, mysite.watchlist_revs,
start='2008-09-03T00:00:01Z',
end='2008-09-03T23:59:59Z', total=5)
# reverse: end earlier than start
self.assertRaises(AssertionError, mysite.watchlist_revs,
start='2008-09-03T23:59:59Z',
end='2008-09-03T00:00:01Z', reverse=True, total=5)
for rev in mysite.watchlist_revs(namespaces=[6, 7], total=5):
self.assertIsInstance(rev, dict)
self.assertIn('title', rev)
self.assertIn('ns', rev)
title = rev['title']
self.assertIn(':', title)
prefix = title[:title.index(':')]
self.assertIn(self.site.namespaces.lookup_name(prefix).id, [6, 7])
self.assertIn(rev['ns'], [6, 7])
for rev in mysite.watchlist_revs(minor=True, total=5):
self.assertIsInstance(rev, dict)
self.assertIn('minor', rev)
for rev in mysite.watchlist_revs(minor=False, total=5):
self.assertIsInstance(rev, dict)
self.assertNotIn('minor', rev)
for rev in mysite.watchlist_revs(bot=True, total=5):
self.assertIsInstance(rev, dict)
self.assertIn('bot', rev)
for rev in mysite.watchlist_revs(bot=False, total=5):
self.assertIsInstance(rev, dict)
self.assertNotIn('bot', rev)
for rev in mysite.watchlist_revs(anon=True, total=5):
self.assertIsInstance(rev, dict)
for rev in mysite.watchlist_revs(anon=False, total=5):
self.assertIsInstance(rev, dict)
class SiteSysopTestCase(DefaultSiteTestCase):
"""Test site method using a sysop account."""
sysop = True
def test_methods(self):
"""Test sysop related methods."""
mysite = self.get_site()
self.assertIsInstance(mysite.is_blocked(True), bool)
self.assertIsInstance(mysite.has_right('edit', True), bool)
self.assertFalse(mysite.has_right('nonexistent_right', True))
self.assertIsInstance(mysite.has_group('bots', True), bool)
self.assertFalse(mysite.has_group('nonexistent_group', True))
def test_deletedrevs(self):
"""Test the site.deletedrevs() method."""
mysite = self.get_site()
mainpage = self.get_mainpage()
gen = mysite.deletedrevs(total=10, titles=mainpage)
for dr in gen:
break
else:
self.skipTest(
'{0} contains no deleted revisions.'.format(mainpage))
self.assertLessEqual(len(dr['revisions']), 10)
self.assertTrue(all(isinstance(rev, dict) for rev in dr['revisions']))
with self.subTest(start='2008-10-11T01:02:03Z', reverse=False):
for item in mysite.deletedrevs(start='2008-10-11T01:02:03Z',
titles=mainpage, total=5):
for rev in item['revisions']:
self.assertIsInstance(rev, dict)
self.assertLessEqual(rev['timestamp'],
'2008-10-11T01:02:03Z')
with self.subTest(end='2008-04-01T02:03:04Z', reverse=False):
for item in mysite.deletedrevs(end='2008-04-01T02:03:04Z',
titles=mainpage, total=5):
for rev in item['revisions']:
self.assertIsInstance(rev, dict)
self.assertGreaterEqual(rev['timestamp'],
'2008-10-11T02:03:04Z')
with self.subTest(start='2008-10-11T03:05:07Z', reverse=True):
for item in mysite.deletedrevs(start='2008-10-11T03:05:07Z',
titles=mainpage, total=5,
reverse=True):
for rev in item['revisions']:
self.assertIsInstance(rev, dict)
self.assertGreaterEqual(rev['timestamp'],
'2008-10-11T03:05:07Z')
with self.subTest(end='2008-10-11T04:06:08Z', reverse=True):
for item in mysite.deletedrevs(end='2008-10-11T04:06:08Z',
titles=mainpage, total=5,
reverse=True):
for rev in item['revisions']:
self.assertIsInstance(rev, dict)
self.assertLessEqual(rev['timestamp'],
'2008-10-11T04:06:08Z')
with self.subTest(start='2008-10-13T11:59:59Z',
end='2008-10-13T00:00:01Z',
reverse=False):
for item in mysite.deletedrevs(start='2008-10-13T11:59:59Z',
end='2008-10-13T00:00:01Z',
titles=mainpage, total=5):
for rev in item['revisions']:
self.assertIsInstance(rev, dict)
self.assertLessEqual(rev['timestamp'],
'2008-10-13T11:59:59Z')
self.assertGreaterEqual(rev['timestamp'],
'2008-10-13T00:00:01Z')
with self.subTest(start='2008-10-15T06:00:01Z',
end='2008-10-15T23:59:59Z',
reverse=True):
for item in mysite.deletedrevs(start='2008-10-15T06:00:01Z',
end='2008-10-15T23:59:59Z',
titles=mainpage, total=5,
reverse=True):
for rev in item['revisions']:
self.assertIsInstance(rev, dict)
self.assertLessEqual(rev['timestamp'],
'2008-10-15T23:59:59Z')
self.assertGreaterEqual(rev['timestamp'],
'2008-10-15T06:00:01Z')
# start earlier than end
with self.subTest(start='2008-09-03T00:00:01Z',
end='2008-09-03T23:59:59Z',
reverse=False):
with self.assertRaises(AssertionError):
gen = mysite.deletedrevs(titles=mainpage,
start='2008-09-03T00:00:01Z',
end='2008-09-03T23:59:59Z', total=5)
next(gen)
# reverse: end earlier than start
with self.subTest(start='2008-09-03T23:59:59Z',
end='2008-09-03T00:00:01Z',
reverse=True):
with self.assertRaises(AssertionError):
gen = mysite.deletedrevs(titles=mainpage,
start='2008-09-03T23:59:59Z',
end='2008-09-03T00:00:01Z', total=5,
reverse=True)
next(gen)
class TestSiteSysopWrite(TestCase):
"""Test site sysop methods that require writing."""
family = 'test'
code = 'test'
write = True
sysop = True
def test_protect(self):
"""Test the site.protect() method."""
site = self.get_site()
p1 = pywikibot.Page(site, 'User:Unicodesnowman/ProtectTest')
r = site.protect(protections={'edit': 'sysop',
'move': 'autoconfirmed'},
page=p1,
reason='Pywikibot unit test')
self.assertIsNone(r)
self.assertEqual(site.page_restrictions(page=p1),
{'edit': ('sysop', 'infinity'),
'move': ('autoconfirmed', 'infinity')})
expiry = pywikibot.Timestamp.fromISOformat('2050-01-01T00:00:00Z')
site.protect(protections={'edit': 'sysop', 'move': 'autoconfirmed'},
page=p1,
expiry=expiry,
reason='Pywikibot unit test')
self.assertEqual(site.page_restrictions(page=p1),
{'edit': ('sysop', '2050-01-01T00:00:00Z'),
'move': ('autoconfirmed', '2050-01-01T00:00:00Z')})
site.protect(protections={'edit': '', 'move': ''},
page=p1,
reason='Pywikibot unit test')
self.assertEqual(site.page_restrictions(page=p1), {})
def test_protect_alt(self):
"""Test the site.protect() method, works around T78522."""
site = self.get_site()
p1 = pywikibot.Page(site, 'User:Unicodesnowman/ProtectTest')
r = site.protect(protections={'edit': 'sysop',
'move': 'autoconfirmed'},
page=p1,
reason='Pywikibot unit test')
self.assertIsNone(r)
self.assertEqual(site.page_restrictions(page=p1),
{'edit': ('sysop', 'infinity'),
'move': ('autoconfirmed', 'infinity')})
p1 = pywikibot.Page(site, 'User:Unicodesnowman/ProtectTest')
expiry = pywikibot.Timestamp.fromISOformat('2050-01-01T00:00:00Z')
site.protect(protections={'edit': 'sysop', 'move': 'autoconfirmed'},
page=p1,
expiry=expiry,
reason='Pywikibot unit test')
self.assertEqual(site.page_restrictions(page=p1),
{'edit': ('sysop', '2050-01-01T00:00:00Z'),
'move': ('autoconfirmed', '2050-01-01T00:00:00Z')})
p1 = pywikibot.Page(site, 'User:Unicodesnowman/ProtectTest')
site.protect(protections={'edit': '', 'move': ''},
page=p1,
reason='Pywikibot unit test')
self.assertEqual(site.page_restrictions(page=p1), {})
def test_protect_exception(self):
"""Test that site.protect() throws an exception for invalid args."""
site = self.get_site()
p1 = pywikibot.Page(site, 'User:Unicodesnowman/ProtectTest')
self.assertRaises(AssertionError, site.protect,
protections={'anInvalidValue': 'sysop'},
page=p1, reason='Pywikibot unit test')
self.assertRaises(AssertionError, site.protect,
protections={'edit': 'anInvalidValue'},
page=p1, reason='Pywikibot unit test')
def test_delete(self):
"""Test the site.deletepage() and site.undelete_page() methods."""
site = self.get_site()
p = pywikibot.Page(site, 'User:Unicodesnowman/DeleteTestSite')
# Verify state
if not p.exists():
site.undelete_page(p, 'pywikibot unit tests')
site.deletepage(p, reason='pywikibot unit tests')
self.assertRaises(pywikibot.NoPage, p.get, force=True)
site.undelete_page(p, 'pywikibot unit tests',
revisions=['2014-12-21T06:07:47Z',
'2014-12-21T06:07:31Z'])
revs = list(p.revisions())
self.assertLength(revs, 2)
self.assertEqual(revs[0].revid, 219995)
self.assertEqual(revs[1].revid, 219994)
site.deletepage(p, reason='pywikibot unit tests')
site.undelete_page(p, 'pywikibot unit tests')
revs = list(p.revisions())
self.assertGreater(len(revs), 2)
class TestUsernameInUsers(DefaultSiteTestCase):
"""Test that the user account can be found in users list."""
user = True
cached = True
def test_username_in_users(self):
"""Test the site.users() method with bot username."""
mysite = self.get_site()
us = list(mysite.users(mysite.user()))
self.assertLength(us, 1)
self.assertIsInstance(us[0], dict)
class TestUserList(DefaultSiteTestCase):
"""Test usernames Jimbo Wales, Brion VIBBER and Tim Starling."""
cached = True
def test_users(self):
"""Test the site.users() method with preset usernames."""
mysite = self.site
cnt = 0
for user in mysite.users(
['Jimbo Wales', 'Brion VIBBER', 'Tim Starling']):
self.assertIsInstance(user, dict)
self.assertTrue(user['name']
in ['Jimbo Wales', 'Brion VIBBER', 'Tim Starling'])
cnt += 1
if not cnt:
self.skipTest('Test usernames not found')
class PatrolTestCase(TokenTestBase, TestCase):
"""Test patrol method."""
family = 'test'
code = 'test'
user = True
token_type = 'patrol'
write = True
def test_patrol(self):
"""Test the site.patrol() method."""
mysite = self.get_site()
rc = list(mysite.recentchanges(total=1))
if not rc:
self.skipTest('no recent changes to patrol')
rc = rc[0]
# site.patrol() needs params
self.assertRaises(pywikibot.Error, lambda x: list(x), mysite.patrol())
try:
result = list(mysite.patrol(rcid=rc['rcid']))
except api.APIError as error:
if error.code == 'permissiondenied':
self.skipTest(error)
raise
if hasattr(mysite, '_patroldisabled') and mysite._patroldisabled:
self.skipTest('Patrolling is disabled on {} wiki.'.format(mysite))
result = result[0]
self.assertIsInstance(result, dict)
params = {'rcid': 0}
if mysite.mw_version >= '1.22':
params['revid'] = [0, 1]
try:
# no such rcid, revid or too old revid
list(mysite.patrol(**params))
except api.APIError as error:
if error.code == 'badtoken':
self.skipTest(error)
except pywikibot.Error:
# expected result
pass
class SiteRandomTestCase(DefaultSiteTestCase):
"""Test random methods of a site."""
def test_unlimited_small_step(self):
"""Test site.randompages() continuation.
Note that uniqueness is not guaranteed if multiple requests are
performed, so we also don't test this here.
"""
mysite = self.get_site()
pages = []
rngen = mysite.randompages(total=None)
rngen.set_query_increment = 5
for rndpage in rngen:
self.assertIsInstance(rndpage, pywikibot.Page)
pages.append(rndpage)
if len(pages) == 11:
break
self.assertLength(pages, 11)
def test_limit_10(self):
"""Test site.randompages() with limit."""
mysite = self.get_site()
rn = list(mysite.randompages(total=10))
self.assertLessEqual(len(rn), 10)
self.assertTrue(all(isinstance(a_page, pywikibot.Page)
for a_page in rn))
self.assertFalse(all(a_page.isRedirectPage() for a_page in rn))
def test_redirects(self):
"""Test site.randompages() with redirects."""
mysite = self.get_site()
for rndpage in mysite.randompages(total=5, redirects=True):
self.assertIsInstance(rndpage, pywikibot.Page)
self.assertTrue(rndpage.isRedirectPage())
def test_all(self):
"""Test site.randompages() with both types."""
mysite = self.get_site()
for rndpage in mysite.randompages(total=5, redirects=None):
self.assertIsInstance(rndpage, pywikibot.Page)
def test_namespaces(self):
"""Test site.randompages() with namespaces."""
mysite = self.get_site()
for rndpage in mysite.randompages(total=5, namespaces=[6, 7]):
self.assertIsInstance(rndpage, pywikibot.Page)
self.assertIn(rndpage.namespace(), [6, 7])
class TestSiteTokens(DefaultSiteTestCase):
"""Test cases for tokens in Site methods.
Versions of sites are simulated if actual versions are higher than
needed by the test case.
Test is skipped if site version is not compatible.
"""
user = True
def setUp(self):
"""Store version."""
super(TestSiteTokens, self).setUp()
self.mysite = self.get_site()
self._version = self.mysite.mw_version
self.orig_version = self.mysite.version
def tearDown(self):
"""Restore version."""
super(TestSiteTokens, self).tearDown()
self.mysite.version = self.orig_version
def _test_tokens(self, version, test_version, additional_token):
"""Test tokens."""
if version and self._version < version:
raise unittest.SkipTest(
'Site {} version {} is too low for this tests.'
.format(self.mysite, self._version))
if version and self._version < test_version:
raise unittest.SkipTest(
'Site {} version {} is too low for this tests.'
.format(self.mysite, self._version))
self.mysite.version = lambda: test_version
for ttype in ('edit', 'move', additional_token):
tokentype = self.mysite.validate_tokens([ttype])
try:
token = self.mysite.tokens[ttype]
except pywikibot.Error as error_msg:
if tokentype:
self.assertRegex(
unicode(error_msg),
"Action '[a-z]+' is not allowed "
'for user .* on .* wiki.')
# test __contains__
self.assertNotIn(tokentype[0], self.mysite.tokens)
else:
self.assertRegex(
unicode(error_msg),
"Requested token '[a-z]+' is invalid on .* wiki.")
else:
self.assertIsInstance(token, basestring)
self.assertEqual(token, self.mysite.tokens[ttype])
# test __contains__
self.assertIn(tokentype[0], self.mysite.tokens)
def test_patrol_tokens_in_mw_116(self):
"""Test ability to get patrol token on MW 1.16 wiki."""
self._test_tokens('1.14', '1.16', 'patrol')
def test_tokens_in_mw_119(self):
"""Test ability to get page tokens."""
self._test_tokens(None, '1.19', 'delete')
def test_patrol_tokens_in_mw_119(self):
"""Test ability to get patrol token on MW 1.19 wiki."""
self._test_tokens('1.14', '1.19', 'patrol')
def test_tokens_in_mw_120_124wmf18(self):
"""Test ability to get page tokens."""
self._test_tokens('1.20', '1.21', 'deleteglobalaccount')
def test_patrol_tokens_in_mw_120(self):
"""Test ability to get patrol token."""
self._test_tokens('1.14', '1.20', 'patrol')
def test_tokens_in_mw_124wmf19(self):
"""Test ability to get page tokens."""
self._test_tokens('1.24wmf19', '1.24wmf20', 'deleteglobalaccount')
def testInvalidToken(self):
"""Test invalid token."""
self.assertRaises(pywikibot.Error, lambda t: self.mysite.tokens[t],
'invalidtype')
class TestDeprecatedEditTokenFunctions(TokenTestBase,
DefaultSiteTestCase,
DeprecationTestCase):
"""Test cases for Site edit token deprecated methods."""
cached = True
user = True
token_type = 'edit'
def test_token(self):
"""Test ability to get page tokens using site.tokens."""
token = self.token
mysite = self.get_site()
mainpage = self.get_mainpage()
ttype = 'edit'
self.assertEqual(token, mysite.token(mainpage, ttype))
self.assertOneDeprecationParts('pywikibot.site.APISite.token',
"the 'tokens' property")
def test_getToken(self):
"""Test ability to get page tokens using site.getToken."""
self.mysite = self.site
self.assertEqual(self.mysite.getToken(), self.mysite.tokens['edit'])
self.assertOneDeprecationParts('pywikibot.site.APISite.getToken',
"the 'tokens' property")
class TestDeprecatedPatrolToken(DefaultSiteTestCase, DeprecationTestCase):
"""Test cases for Site patrol token deprecated methods."""
cached = True
user = True
def test_getPatrolToken(self):
"""Test site.getPatrolToken."""
self.mysite = self.site
try:
self.assertEqual(self.mysite.getPatrolToken(),
self.mysite.tokens['patrol'])
self.assertOneDeprecation()
except pywikibot.Error as error_msg:
self.assertRegex(
unicode(error_msg),
"Action '[a-z]+' is not allowed for user .* on .* wiki.")
# test __contains__
self.assertNotIn('patrol', self.mysite.tokens)
class TestSiteExtensions(WikimediaDefaultSiteTestCase):
"""Test cases for Site extensions."""
cached = True
def test_extensions(self):
"""Test Extensions."""
mysite = self.get_site()
# test automatically getting extensions cache
if 'extensions' in mysite.siteinfo:
del mysite.siteinfo._cache['extensions']
self.assertTrue(mysite.has_extension('Disambiguator'))
# test case-sensitivity
self.assertFalse(mysite.has_extension('disambiguator'))
self.assertFalse(mysite.has_extension('ThisExtensionDoesNotExist'))
class TestSiteAPILimits(TestCase):
"""Test cases for Site method that use API limits."""
family = 'wikipedia'
code = 'en'
cached = True
def test_api_limits_with_site_methods(self):
"""Test step/total parameters for different sitemethods."""
mysite = self.get_site()
mypage = pywikibot.Page(mysite, 'Albert Einstein')
mycat = pywikibot.Page(mysite, 'Category:1879 births')
gen = mysite.pagecategories(mypage, total=12)
gen.set_query_increment = 5
cats = [c for c in gen]
self.assertLength(cats, 12)
gen = mysite.categorymembers(mycat, total=12)
gen.set_query_increment = 5
cat_members = [cm for cm in gen]
self.assertLength(cat_members, 12)
gen = mysite.pageimages(mypage, total=5)
gen.set_query_increment = 3
images = [im for im in gen]
self.assertLength(images, 5)
gen = mysite.pagetemplates(mypage, total=5)
gen.set_query_increment = 3
templates = [tl for tl in gen]
self.assertLength(templates, 5)
mysite.loadrevisions(mypage, step=5, total=12)
self.assertLength(mypage._revisions, 12)
class TestSiteInfo(DefaultSiteTestCase):
"""Test cases for Site metadata and capabilities."""
cached = True
def test_siteinfo(self):
"""Test the siteinfo property."""
# general enteries
mysite = self.get_site()
self.assertIsInstance(mysite.siteinfo['timeoffset'], (int, float))
self.assertTrue(-12 * 60 <= mysite.siteinfo['timeoffset'] <= +14 * 60)
self.assertEqual(mysite.siteinfo['timeoffset'] % 15, 0)
self.assertRegex(mysite.siteinfo['timezone'],
'([A-Z]{3,4}|[A-Z][a-z]+/[A-Z][a-z]+)')
self.assertIn(mysite.siteinfo['case'], ['first-letter',
'case-sensitive'])
def test_siteinfo_boolean(self):
"""Test conversion of boolean properties from empty strings."""
mysite = self.get_site()
self.assertIsInstance(mysite.siteinfo['titleconversion'], bool)
self.assertIsInstance(mysite.namespaces[0].subpages, bool)
self.assertIsInstance(mysite.namespaces[0].content, bool)
def test_siteinfo_v1_16(self):
"""Test v.16+ siteinfo values."""
if self.site.mw_version < '1.16':
self.skipTest('requires v1.16+')
mysite = self.get_site()
self.assertIsInstance(
datetime.strptime(mysite.siteinfo['time'], '%Y-%m-%dT%H:%M:%SZ'),
datetime)
self.assertEqual(re.findall(r'\$1', mysite.siteinfo['articlepath']),
['$1'])
def test_properties_with_defaults(self):
"""Test the siteinfo properties with defaults."""
# This does not test that the defaults work correct,
# unless the default site is a version needing these defaults
# 'fileextensions' introduced in v1.15:
self.assertIsInstance(self.site.siteinfo.get('fileextensions'), list)
self.assertIn('fileextensions', self.site.siteinfo)
fileextensions = self.site.siteinfo.get('fileextensions')
self.assertIn({'ext': 'png'}, fileextensions)
# 'restrictions' introduced in v1.23:
mysite = self.site
self.assertIsInstance(mysite.siteinfo.get('restrictions'), dict)
self.assertIn('restrictions', mysite.siteinfo)
restrictions = self.site.siteinfo.get('restrictions')
self.assertIn('cascadinglevels', restrictions)
def test_no_cache(self):
"""Test siteinfo caching can be disabled."""
if 'fileextensions' in self.site.siteinfo._cache:
del self.site.siteinfo._cache['fileextensions']
self.site.siteinfo.get('fileextensions', cache=False)
self.assertNotIn('fileextensions', self.site.siteinfo)
def test_not_exists(self):
"""Test accessing a property not in siteinfo."""
not_exists = 'this-property-does-not-exist'
mysite = self.site
self.assertRaises(KeyError, mysite.siteinfo.__getitem__, not_exists)
self.assertNotIn(not_exists, mysite.siteinfo)
self.assertIsEmpty(mysite.siteinfo.get(not_exists))
self.assertFalse(entered_loop(mysite.siteinfo.get(not_exists)))
if PY2:
self.assertFalse(
entered_loop(mysite.siteinfo.get(not_exists).iteritems()))
self.assertFalse(
entered_loop(mysite.siteinfo.get(not_exists).itervalues()))
self.assertFalse(
entered_loop(mysite.siteinfo.get(not_exists).iterkeys()))
self.assertFalse(
entered_loop(mysite.siteinfo.get(not_exists).items()))
self.assertFalse(
entered_loop(mysite.siteinfo.get(not_exists).values()))
self.assertFalse(entered_loop(mysite.siteinfo.get(not_exists).keys()))
class TestSiteinfoDry(DefaultDrySiteTestCase):
"""Test Siteinfo in dry mode."""
def test_siteinfo_timestamps(self):
"""Test that cache has the timestamp of CachedRequest."""
site = self.get_site()
request_mock = MagicMock()
request_mock.submit = lambda: {'query': {'_prop': '_value'}}
request_mock._cachetime = '_cache_time'
with patch.object(site, '_request', return_value=request_mock):
siteinfo = pywikibot.site.Siteinfo(site)
result = siteinfo._get_siteinfo('_prop', False)
self.assertEqual(result, {'_prop': ('_value', '_cache_time')})
class TestSiteinfoAsync(DefaultSiteTestCase):
"""Test asynchronous siteinfo fetch."""
def test_async_request(self):
"""Test async request."""
self.assertTrue(page_put_queue.empty())
self.assertNotIn('statistics', self.site.siteinfo)
async_request(self.site.siteinfo.get, 'statistics')
page_put_queue.join()
self.assertIn('statistics', self.site.siteinfo)
class TestSiteLoadRevisionsCaching(BasePageLoadRevisionsCachingTestBase,
DefaultSiteTestCase):
"""Test site.loadrevisions() caching."""
def setUp(self):
"""Setup tests."""
self._page = self.get_mainpage(force=True)
super(TestSiteLoadRevisionsCaching, self).setUp()
def test_page_text(self):
"""Test site.loadrevisions() with Page.text."""
self._test_page_text()
class TestSiteLoadRevisions(TestCase):
"""Test cases for Site.loadrevision() method."""
family = 'wikipedia'
code = 'en'
cached = True
# Implemented without setUpClass(cls) and global variables as objects
# were not completely disposed and recreated but retained 'memory'
def setUp(self):
"""Setup tests."""
super(TestSiteLoadRevisions, self).setUp()
self.mysite = self.get_site()
self.mainpage = pywikibot.Page(pywikibot.Link('Main Page',
self.mysite))
def test_loadrevisions_basic(self):
"""Test the site.loadrevisions() method."""
# Load revisions without content
self.mysite.loadrevisions(self.mainpage, total=15)
self.mysite.loadrevisions(self.mainpage)
self.assertFalse(hasattr(self.mainpage, '_text'))
self.assertLength(self.mainpage._revisions, 15)
self.assertIn(self.mainpage._revid, self.mainpage._revisions)
self.assertIsNone(self.mainpage._revisions[self.mainpage._revid].text)
# The revision content will be loaded by .text
self.assertIsNotNone(self.mainpage.text)
def test_loadrevisions_content(self):
"""Test the site.loadrevisions() method with content=True."""
self.mysite.loadrevisions(self.mainpage, content=True, total=5)
self.assertFalse(hasattr(self.mainpage, '_text'))
self.assertIn(self.mainpage._revid, self.mainpage._revisions)
self.assertIsNotNone(
self.mainpage._revisions[self.mainpage._revid].text)
self.assertTrue(self.mainpage._revisions[self.mainpage._revid].text)
self.assertIsNotNone(self.mainpage.text)
def test_loadrevisions_revids(self):
"""Test the site.loadrevisions() method, listing based on revid."""
# revids as list of int
self.mysite.loadrevisions(self.mainpage, revids=[139992, 139993])
self.assertTrue(all(rev in self.mainpage._revisions
for rev in [139992, 139993]))
# revids as list of str
self.mysite.loadrevisions(self.mainpage, revids=['139994', '139995'])
self.assertTrue(all(rev in self.mainpage._revisions
for rev in [139994, 139995]))
# revids as int
self.mysite.loadrevisions(self.mainpage, revids=140000)
self.assertIn(140000, self.mainpage._revisions)
# revids as str
self.mysite.loadrevisions(self.mainpage, revids='140001')
self.assertIn(140001, self.mainpage._revisions)
# revids belonging to a different page raises Exception
self.assertRaises(pywikibot.Error, self.mysite.loadrevisions,
self.mainpage, revids=130000)
def test_loadrevisions_querycontinue(self):
"""Test the site.loadrevisions() method with query-continue."""
self.mysite.loadrevisions(self.mainpage, step=5, total=12)
self.assertLength(self.mainpage._revisions, 12)
def test_loadrevisions_revdir(self):
"""Test the site.loadrevisions() method with rvdir=True."""
self.mysite.loadrevisions(self.mainpage, rvdir=True, total=15)
self.assertLength(self.mainpage._revisions, 15)
def test_loadrevisions_timestamp(self):
"""Test the site.loadrevisions() method, listing based on timestamp."""
self.mysite.loadrevisions(self.mainpage, rvdir=True, total=15)
self.assertLength(self.mainpage._revisions, 15)
revs = self.mainpage._revisions
timestamps = [str(revs[rev].timestamp) for rev in revs]
self.assertTrue(all(ts < '2002-01-31T00:00:00Z' for ts in timestamps))
# Retrieve oldest revisions; listing based on timestamp.
# Raises "loadrevisions: starttime > endtime with rvdir=True"
self.assertRaises(ValueError, self.mysite.loadrevisions,
self.mainpage, rvdir=True,
starttime='2002-02-01T00:00:00Z',
endtime='2002-01-01T00:00:00Z')
# Retrieve newest revisions; listing based on timestamp.
# Raises "loadrevisions: endtime > starttime with rvdir=False"
self.assertRaises(ValueError, self.mysite.loadrevisions,
self.mainpage, rvdir=False,
starttime='2002-01-01T00:00:00Z',
endtime='2002-02-01T00:00:00Z')
def test_loadrevisions_rev_id(self):
"""Test the site.loadrevisions() method, listing based on rev_id."""
self.mysite.loadrevisions(self.mainpage, rvdir=True, total=15)
self.assertLength(self.mainpage._revisions, 15)
revs = self.mainpage._revisions
self.assertTrue(all(139900 <= rev <= 140100 for rev in revs))
# Retrieve oldest revisions; listing based on revid.
# Raises "loadrevisions: startid > endid with rvdir=True"
self.assertRaises(ValueError, self.mysite.loadrevisions,
self.mainpage, rvdir=True,
startid='200000', endid='100000')
# Retrieve newest revisions; listing based on revid.
# Raises "loadrevisions: endid > startid with rvdir=False
self.assertRaises(ValueError, self.mysite.loadrevisions,
self.mainpage, rvdir=False,
startid='100000', endid='200000')
def test_loadrevisions_user(self):
"""Test the site.loadrevisions() method, filtering by user."""
# Only list revisions made by this user.
self.mainpage._revisions = {}
self.mysite.loadrevisions(self.mainpage, rvdir=True,
user='Magnus Manske')
revs = self.mainpage._revisions
self.assertTrue(all(revs[rev].user == 'Magnus Manske' for rev in revs))
def test_loadrevisions_excludeuser(self):
"""Test the site.loadrevisions() method, excluding user."""
# Do not list revisions made by this user.
self.mainpage._revisions = {}
self.mysite.loadrevisions(self.mainpage, rvdir=True,
excludeuser='Magnus Manske')
revs = self.mainpage._revisions
self.assertFalse(any(revs[rev].user == 'Magnus Manske'
for rev in revs))
# TODO test other optional arguments
class TestSiteLoadRevisionsSysop(DefaultSiteTestCase):
"""Test cases for Site.loadrevision() method."""
sysop = True
def test_rollback(self):
"""Test the site.loadrevisions() method with rollback."""
mainpage = self.get_mainpage()
self.site.loadrevisions(mainpage, total=12, rollback=True, sysop=True)
self.assertIsNotEmpty(mainpage._revisions)
self.assertLessEqual(len(mainpage._revisions), 12)
self.assertTrue(all(rev.rollbacktoken is not None
for rev in mainpage._revisions.values()))
class TestBacklinks(TestCase):
"""Test for backlinks (issue T194233)."""
family = 'wikipedia'
code = 'en'
cached = True
def setUp(self):
"""Setup tests."""
super(TestBacklinks, self).setUp()
self.page = pywikibot.Page(self.site, 'File:BoA – Woman.png')
self.backlinks = list(self.page.backlinks(follow_redirects=False,
filter_redirects=True,
total=5))
self.references = list(self.page.getReferences(follow_redirects=True,
filter_redirects=True,
total=5))
self.nofollow = list(self.page.getReferences(follow_redirects=False,
filter_redirects=True,
total=5))
def test_backlinks_redirects_length(self):
"""Test backlinks redirects length."""
self.assertLength(self.backlinks, 1)
self.assertLength(self.references, 1)
self.assertLength(self.nofollow, 1)
def test_backlinks_redirects_status(self):
"""Test backlinks redirects statur."""
for page in self.backlinks:
self.assertTrue(page.isRedirectPage())
for page in self.references:
self.assertTrue(page.isRedirectPage())
for page in self.nofollow:
self.assertTrue(page.isRedirectPage())
def test_backlinks_redirects_pageid(self):
"""Test backlinks redirects pageid."""
for page in self.backlinks:
self.assertEqual(page.pageid, 58874049)
for page in self.references:
self.assertEqual(page.pageid, 58874049)
for page in self.nofollow:
self.assertEqual(page.pageid, 58874049)
class TestCommonsSite(TestCase):
"""Test cases for Site methods on Commons."""
family = 'commons'
code = 'commons'
cached = True
def test_interwiki_forward(self):
"""Test interwiki forward."""
self.site = self.get_site()
self.mainpage = pywikibot.Page(pywikibot.Link('Main Page', self.site))
# test pagelanglinks on commons,
# which forwards interwikis to wikipedia
ll = next(self.site.pagelanglinks(self.mainpage))
self.assertIsInstance(ll, pywikibot.Link)
self.assertEqual(ll.site.family.name, 'wikipedia')
class TestFileArchive(DeprecationTestCase):
"""Test filearchive on Commons."""
family = 'commons'
code = 'commons'
cached = True
def test_filearchive(self):
"""Test filearchive method."""
gen = self.site.filearchive(total=10)
self.assertNotIn('fafrom', str(gen.request))
self.assertNotIn('fato', str(gen.request))
fa = list(gen)
self.assertLessEqual(len(fa), 10)
for item in fa:
self.assertIsInstance(item, dict)
self.assertIn('id', item)
self.assertIn('name', item)
self.assertIn('ns', item)
self.assertIn('title', item)
self.assertIn('timestamp', item)
self.assertEqual(item['ns'], 6)
self.assertEqual('File:' + item['name'].replace('_', ' '),
item['title'])
def test_filearchive_limit(self):
"""Test deprecated limit parameter."""
fa = list(self.site.filearchive(limit=10))
self.assertOneDeprecation()
self.assertLessEqual(len(fa), 10)
def test_filearchive_prefix(self):
"""Test prefix parameter."""
gen = self.site.filearchive(prefix='py')
self.assertIn('faprefix=py', str(gen.request))
for item in gen:
self.assertTrue(item['name'].startswith('Py'))
def test_filearchive_prop(self):
"""Test properties."""
gen = self.site.filearchive(prop=['sha1', 'size', 'user'], total=1)
self.assertIn('faprop=sha1|size|user', str(gen.request))
item = next(iter(gen))
self.assertIn('sha1', item)
self.assertIn('size', item)
self.assertIn('user', item)
def test_filearchive_reverse(self):
"""Test reverse parameter."""
gen1 = self.site.filearchive(total=1)
gen2 = self.site.filearchive(reverse=True, total=1)
self.assertNotIn('fadir=', str(gen1.request))
self.assertIn('fadir=descending', str(gen2.request))
fa1 = next(iter(gen1))
fa2 = next(iter(gen2))
self.assertLess(fa1['name'], fa2['name'])
def test_filearchive_start(self):
"""Test start/end parameters."""
gen = self.site.filearchive(start='py', end='wiki', total=1)
self.assertIn('fafrom=py', str(gen.request))
self.assertIn('fato=wiki', str(gen.request))
item = next(iter(gen))
self.assertGreaterEqual(item['name'], 'Py')
def test_filearchive_sha1(self):
"""Test sha1 parameter."""
sha1 = '0d5a00aa774100408e60da09f5fb21f253b366f1'
gen = self.site.filearchive(sha1=sha1, prop='sha1', total=1)
self.assertIn('fasha1=' + sha1, str(gen.request))
item = next(iter(gen))
self.assertEqual(item['sha1'], sha1)
class TestWiktionarySite(TestCase):
"""Test Site Object on English Wiktionary."""
family = 'wiktionary'
code = 'en'
cached = True
def test_namespace_case(self):
"""Test namespace case."""
site = self.get_site()
main_namespace = site.namespaces[0]
self.assertEqual(main_namespace.case, 'case-sensitive')
user_namespace = site.namespaces[2]
self.assertEqual(user_namespace.case, 'first-letter')
class TestNonEnglishWikipediaSite(TestCase):
"""Test Site Object on Nynorsk Wikipedia."""
family = 'wikipedia'
code = 'nn'
cached = True
def test_namespace_aliases(self):
"""Test namespace aliases."""
site = self.get_site()
namespaces = site.namespaces
image_namespace = namespaces[6]
self.assertEqual(image_namespace.custom_name, 'Fil')
self.assertEqual(image_namespace.canonical_name, 'File')
self.assertEqual(str(image_namespace), ':File:')
self.assertEqual(image_namespace.custom_prefix(), ':Fil:')
self.assertEqual(image_namespace.canonical_prefix(), ':File:')
self.assertEqual(sorted(image_namespace.aliases), ['Bilde', 'Image'])
self.assertLength(image_namespace, 4)
self.assertIsEmpty(namespaces[1].aliases)
self.assertLength(namespaces[4].aliases, 1)
self.assertEqual(namespaces[4].aliases[0], 'WP')
self.assertIn('WP', namespaces[4])
class TestUploadEnabledSite(TestCase):
"""Test Site.is_uploaddisabled."""
sites = {
'wikidatatest': {
'family': 'wikidata',
'code': 'test',
'enabled': False,
},
'wikipediatest': {
'family': 'wikipedia',
'code': 'test',
'enabled': True,
}
}
user = True
def test_is_uploaddisabled(self, key):
"""Test is_uploaddisabled()."""
site = self.get_site(key)
if self.sites[key]['enabled']:
self.assertFalse(site.is_uploaddisabled())
else:
self.assertTrue(site.is_uploaddisabled())
class TestLoadPagesFromPageids(DefaultSiteTestCase):
"""Test site.load_pages_from_pageids()."""
cached = True
def setUp(self):
"""Setup tests."""
super(TestLoadPagesFromPageids, self).setUp()
self.site = self.get_site()
mainpage = self.get_mainpage()
self.links = [
page for page in self.site.pagelinks(mainpage, total=10)
if page.exists()]
def test_load_from_pageids_iterable_of_str(self):
"""Test basic loading with pageids."""
pageids = [str(page.pageid) for page in self.links]
gen = self.site.load_pages_from_pageids(pageids)
count = 0
for count, page in enumerate(gen, start=1):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertTrue(page.exists())
self.assertTrue(hasattr(page, '_pageid'))
self.assertIn(page, self.links)
self.assertEqual(count, len(self.links))
def test_load_from_pageids_iterable_of_int(self):
"""Test basic loading with pageids."""
pageids = [page.pageid for page in self.links]
gen = self.site.load_pages_from_pageids(pageids)
count = 0
for count, page in enumerate(gen, start=1):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertTrue(page.exists())
self.assertTrue(hasattr(page, '_pageid'))
self.assertIn(page, self.links)
self.assertEqual(count, len(self.links))
def test_load_from_pageids_iterable_in_order(self):
"""Test loading with pageids is ordered."""
pageids = [page.pageid for page in self.links]
gen = self.site.load_pages_from_pageids(pageids)
for page in gen:
link = self.links.pop(0)
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertTrue(page.exists())
self.assertTrue(hasattr(page, '_pageid'))
self.assertEqual(page, link)
def test_load_from_pageids_iterable_with_duplicate(self):
"""Test loading with duplicate pageids."""
pageids = [page.pageid for page in self.links]
pageids = pageids + pageids
gen = self.site.load_pages_from_pageids(pageids)
count = 0
for count, page in enumerate(gen, start=1):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertTrue(page.exists())
self.assertTrue(hasattr(page, '_pageid'))
self.assertIn(page, self.links)
self.assertEqual(count, len(self.links))
def test_load_from_pageids_comma_separated(self):
"""Test loading from comma-separated pageids."""
pageids = ', '.join(str(page.pageid) for page in self.links)
gen = self.site.load_pages_from_pageids(pageids)
count = 0
for count, page in enumerate(gen, start=1):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertTrue(page.exists())
self.assertTrue(hasattr(page, '_pageid'))
self.assertIn(page, self.links)
self.assertEqual(count, len(self.links))
def test_load_from_pageids_pipe_separated(self):
"""Test loading from comma-separated pageids."""
pageids = '|'.join(str(page.pageid) for page in self.links)
gen = self.site.load_pages_from_pageids(pageids)
count = 0
for count, page in enumerate(gen, start=1):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertTrue(page.exists())
self.assertTrue(hasattr(page, '_pageid'))
self.assertIn(page, self.links)
self.assertEqual(count, len(self.links))
class TestPagePreloading(DefaultSiteTestCase):
"""Test site.preloadpages()."""
def test_order(self):
"""Test outcome is following same order of input."""
mainpage = self.get_mainpage()
links = [page for page in self.site.pagelinks(mainpage, total=20)
if page.exists()]
pages = list(self.site.preloadpages(links, groupsize=5))
self.assertEqual(pages, links)
def test_duplicates(self):
"""Test outcome is following same order of input."""
mainpage = self.get_mainpage()
links = [page for page in self.site.pagelinks(mainpage, total=20)
if page.exists()]
dupl_links = links + links[::-1]
pages = list(self.site.preloadpages(dupl_links, groupsize=40))
self.assertEqual(pages, links)
def test_pageids(self):
"""Test basic preloading with pageids."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = mysite.pagelinks(mainpage, total=10)
# preloadpages will send the page ids,
# as they have already been loaded by pagelinks
for page in mysite.preloadpages(links):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertTrue(hasattr(page, '_revid'))
self.assertLength(page._revisions, 1)
self.assertIn(page._revid, page._revisions)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
if count >= 5:
break
def test_titles(self):
"""Test basic preloading with titles."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = mysite.pagelinks(mainpage, total=10)
# remove the pageids that have already been loaded above by pagelinks
# so that preloadpages will use the titles instead
for page in links:
if hasattr(page, '_pageid'):
self.assertEqual(page.pageid, page._pageid)
del page._pageid
for page in mysite.preloadpages(links):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
if count >= 5:
break
def test_preload_continuation(self):
"""Test preloading continuation works."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = mysite.pagelinks(mainpage, total=10)
for page in mysite.preloadpages(links, groupsize=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
if count >= 6:
break
def test_preload_high_groupsize(self):
"""Test preloading continuation with groupsize greater than total."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
# Determine if there are enough links on the main page,
# for the test to be useful.
link_count = len(list(mysite.pagelinks(mainpage, total=10)))
if link_count < 2:
self.skipTest('insufficient links on main page')
# get a fresh generator; we now know how many results it will have,
# if it is less than 10.
links = mysite.pagelinks(mainpage, total=10)
for page in mysite.preloadpages(links, groupsize=50):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
self.assertEqual(count, link_count)
def test_preload_low_groupsize(self):
"""Test preloading continuation with groupsize greater than total."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
# Determine if there are enough links on the main page,
# for the test to be useful.
link_count = len(list(mysite.pagelinks(mainpage, total=10)))
if link_count < 2:
self.skipTest('insufficient links on main page')
# get a fresh generator; we now know how many results it will have,
# if it is less than 10.
links = mysite.pagelinks(mainpage, total=10)
for page in mysite.preloadpages(links, groupsize=5):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
self.assertEqual(count, link_count)
def test_preload_unexpected_titles_using_pageids(self):
"""Test sending pageids with unnormalized titles, causing warnings."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = list(mysite.pagelinks(mainpage, total=10))
if len(links) < 2:
self.skipTest('insufficient links on main page')
# change the title of the page, to test sametitle().
# preloadpages will send the page ids, as they have already been loaded
# by pagelinks, and preloadpages should complain the returned titles
# do not match any title in the pagelist.
# However, APISite.sametitle now correctly links them.
for page in links:
page._link._text += ' '
gen = mysite.preloadpages(links, groupsize=5)
for page in gen:
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
if count > 5:
break
def test_preload_unexpected_titles_using_titles(self):
"""Test sending unnormalized titles, causing warnings."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = list(mysite.pagelinks(mainpage, total=10))
if len(links) < 2:
self.skipTest('insufficient links on main page')
# change the title of the page _and_ delete the pageids.
# preloadpages can only send the titles, and preloadpages should
# complain the returned titles do not match any title in the pagelist.
# However, APISite.sametitle now correctly links them.
for page in links:
page._link._text += ' '
del page._pageid
gen = mysite.preloadpages(links, groupsize=5)
for page in gen:
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
count += 1
if count > 5:
break
def test_preload_invalid_titles_without_pageids(self):
"""Test sending invalid titles. No warnings issued, but it should."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = list(mysite.pagelinks(mainpage, total=10))
if len(links) < 2:
self.skipTest('insufficient links on main page')
for page in links:
page._link._text += ' foobar'
del page._pageid
gen = mysite.preloadpages(links, groupsize=5)
for page in gen:
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
self.assertFalse(page.exists())
count += 1
if count > 5:
break
@allowed_failure
def test_preload_langlinks_normal(self):
"""Test preloading continuation works."""
# FIXME: test fails
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = mysite.pagelinks(mainpage, total=10)
for page in mysite.preloadpages(links, groupsize=5, langlinks=True):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
self.assertTrue(hasattr(page, '_langlinks'))
count += 1
if count >= 6:
break
@patch.object(pywikibot, 'output')
def test_preload_langlinks_count(self, output_mock):
"""Test preloading continuation works."""
mysite = self.get_site()
mainpage = self.get_mainpage()
links = list(mysite.pagelinks(mainpage, total=20))
pages = list(mysite.preloadpages(links, groupsize=5, langlinks=True))
self.assertLength(links, pages)
for page in pages:
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
if pages:
self.assertRegex(
output_mock.call_args[0][0], r'Retrieving \d pages from ')
def _test_preload_langlinks_long(self):
"""Test preloading continuation works."""
# FIXME: test fails. It is disabled as it takes more
# than 10 minutes on travis for English Wikipedia
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
links = mainpage.backlinks(total=100)
for page in mysite.preloadpages(links, groupsize=50,
langlinks=True):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
self.assertTrue(hasattr(page, '_langlinks'))
count += 1
self.assertLength(links, count)
@allowed_failure
def test_preload_templates(self):
"""Test preloading templates works."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
# Use backlinks, as any backlink has at least one link
links = mysite.pagelinks(mainpage, total=10)
for page in mysite.preloadpages(links, templates=True):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
self.assertTrue(hasattr(page, '_templates'))
count += 1
if count >= 6:
break
def test_preload_templates_and_langlinks(self):
"""Test preloading templates and langlinks works."""
mysite = self.get_site()
mainpage = self.get_mainpage()
count = 0
# Use backlinks, as any backlink has at least one link
links = mysite.pagebacklinks(mainpage, total=10)
# Screen pages before test;
# it is not guaranteed that all pages will have both.
links = [l for l in links if (l.langlinks() and l.templates())]
# Skip test if no valid pages are found.
if not links:
self.skipTest('No valid pages found to carry out test.')
for page in mysite.preloadpages(links, langlinks=True, templates=True):
with self.subTest(page=page):
self.assertIsInstance(page, pywikibot.Page)
self.assertIsInstance(page.exists(), bool)
if page.exists():
self.assertLength(page._revisions, 1)
self.assertIsNotNone(page._revisions[page._revid].text)
self.assertFalse(hasattr(page, '_pageprops'))
self.assertTrue(hasattr(page, '_templates'))
self.assertTrue(hasattr(page, '_langlinks'))
count += 1
if count >= 6:
break
class TestDataSitePreloading(WikidataTestCase):
"""Test DataSite.preload_entities for repo pages."""
def test_item(self):
"""Test that ItemPage preloading works for Item objects."""
datasite = self.get_repo()
items = [pywikibot.ItemPage(datasite, 'q' + str(num))
for num in range(1, 6)]
seen = []
for item in datasite.preload_entities(items):
self.assertIsInstance(item, pywikibot.ItemPage)
self.assertTrue(hasattr(item, '_content'))
self.assertNotIn(item, seen)
seen.append(item)
self.assertLength(seen, 5)
def test_item_as_page(self):
"""Test that ItemPage preloading works for Page objects."""
site = self.get_site()
datasite = self.get_repo()
pages = [pywikibot.Page(site, 'q' + str(num))
for num in range(1, 6)]
seen = []
for item in datasite.preload_entities(pages):
self.assertIsInstance(item, pywikibot.ItemPage)
self.assertTrue(hasattr(item, '_content'))
self.assertNotIn(item, seen)
seen.append(item)
self.assertLength(seen, 5)
def test_property(self):
"""Test that preloading works for properties."""
datasite = self.get_repo()
page = pywikibot.Page(datasite, 'P6')
property_page = next(datasite.preload_entities([page]))
self.assertIsInstance(property_page, pywikibot.PropertyPage)
self.assertTrue(hasattr(property_page, '_content'))
class TestDataSiteClientPreloading(DefaultWikidataClientTestCase):
"""Test DataSite.preload_entities for client pages."""
def test_non_item(self):
"""Test that ItemPage preloading works with Page generator."""
mainpage = self.get_mainpage()
datasite = self.get_repo()
item = next(datasite.preload_entities([mainpage]))
self.assertIsInstance(item, pywikibot.ItemPage)
self.assertTrue(hasattr(item, '_content'))
self.assertEqual(item.id, 'Q5296')
class TestDataSiteSearchEntities(WikidataTestCase):
"""Test DataSite.search_entities."""
def test_general(self):
"""Test basic search_entities functionality."""
datasite = self.get_repo()
pages = list(datasite.search_entities('abc', 'en', total=50))
self.assertIsNotEmpty(pages)
self.assertLessEqual(len(pages), 50)
pages = list(datasite.search_entities('alphabet', 'en',
type='property', total=50))
self.assertIsNotEmpty(pages)
self.assertLessEqual(len(pages), 50)
def test_continue(self):
"""Test that continue parameter in search_entities works."""
datasite = self.get_repo()
kwargs = {'total': 50}
pages = datasite.search_entities('Rembrandt', 'en', **kwargs)
kwargs['continue'] = 1
pages_continue = datasite.search_entities('Rembrandt', 'en', **kwargs)
self.assertNotEqual(list(pages), list(pages_continue))
def test_language_lists(self):
"""Test that languages returned by paraminfo and MW are the same."""
site = self.get_site()
lang_codes = site._paraminfo.parameter('wbsearchentities',
'language')['type']
lang_codes2 = [lang['code']
for lang in site._siteinfo.get('languages')]
self.assertEqual(lang_codes, lang_codes2)
def test_invalid_language(self):
"""Test behavior of search_entities with invalid language provided."""
datasite = self.get_repo()
self.assertRaises(ValueError, datasite.search_entities, 'abc',
'invalidlanguage')
class TestSametitleSite(TestCase):
"""Test APISite.sametitle on sites with known behaviour."""
sites = {
'enwp': {
'family': 'wikipedia',
'code': 'en',
},
'dewp': {
'family': 'wikipedia',
'code': 'de',
},
'enwt': {
'family': 'wiktionary',
'code': 'en',
}
}
def test_enwp(self):
"""Test sametitle for enwp."""
self.assertTrue(self.get_site('enwp').sametitle('Foo', 'foo'))
self.assertFalse(self.get_site('enwp').sametitle(
'Template:Test template', 'Template:Test Template'))
def test_dewp(self):
"""Test sametitle for dewp."""
site = self.get_site('dewp')
self.assertTrue(site.sametitle('Foo', 'foo'))
self.assertTrue(site.sametitle('Benutzer:Foo', 'User:Foo'))
self.assertTrue(site.sametitle('Benutzerin:Foo', 'User:Foo'))
self.assertTrue(site.sametitle('Benutzerin:Foo', 'Benutzer:Foo'))
def test_enwt(self):
"""Test sametitle for enwt."""
self.assertFalse(self.get_site('enwt').sametitle('Foo', 'foo'))
def test_general(self, code):
"""Test sametitle."""
site = self.get_site(code)
self.assertTrue(site.sametitle('File:Foo', 'Image:Foo'))
self.assertTrue(site.sametitle(':Foo', 'Foo'))
self.assertFalse(site.sametitle('User:Foo', 'Foo'))
self.assertFalse(site.sametitle('User:Foo', 'Project:Foo'))
self.assertTrue(site.sametitle('Namespace:', 'Namespace:'))
self.assertFalse(site.sametitle('Invalid:Foo', 'Foo'))
self.assertFalse(site.sametitle('Invalid1:Foo', 'Invalid2:Foo'))
self.assertFalse(site.sametitle('Invalid:Foo', ':Foo'))
self.assertFalse(site.sametitle('Invalid:Foo', 'Invalid:foo'))
class TestObsoleteSite(DefaultSiteTestCase):
"""Test 'closed' and obsolete code sites."""
def test_locked_site(self):
"""Test Wikimedia closed/locked site."""
with suppress_warnings('Interwiki removal mh is in wikipedia codes'):
site = pywikibot.Site('mh', 'wikipedia')
self.assertIsInstance(site, pywikibot.site.ClosedSite)
self.assertEqual(site.code, 'mh')
self.assertIsInstance(site.obsolete, bool)
self.assertTrue(site.obsolete)
self.assertEqual(site.hostname(), 'mh.wikipedia.org')
r = http.fetch(uri='http://mh.wikipedia.org/w/api.php',
default_error_handling=False)
self.assertEqual(r.status, 200)
self.assertEqual(site.siteinfo['lang'], 'mh')
def test_removed_site(self):
"""Test Wikimedia offline site."""
site = pywikibot.Site('ru-sib', 'wikipedia')
self.assertIsInstance(site, pywikibot.site.RemovedSite)
self.assertEqual(site.code, 'ru-sib')
self.assertIsInstance(site.obsolete, bool)
self.assertTrue(site.obsolete)
self.assertRaises(KeyError, site.hostname)
# See also http_tests, which tests that ru-sib.wikipedia.org is offline
def test_alias_code_site(self):
"""Test Wikimedia site with an alias code."""
with suppress_warnings(
'Site wikipedia:ja instantiated using different code "jp"'):
site = pywikibot.Site('jp', 'wikipedia')
self.assertIsInstance(site.obsolete, bool)
self.assertEqual(site.code, 'ja')
self.assertFalse(site.obsolete)
self.assertEqual(site.hostname(), 'ja.wikipedia.org')
self.assertEqual(site.ssl_hostname(), 'ja.wikipedia.org')
class TestSingleCodeFamilySite(AlteredDefaultSiteTestCase):
"""Test single code family sites."""
sites = {
'omegawiki': {
'family': 'omegawiki',
'code': 'omegawiki',
},
}
def test_omega(self):
"""Test www.omegawiki.org."""
url = 'www.omegawiki.org'
site = self.get_site('omegawiki')
self.assertEqual(site.hostname(), url)
self.assertEqual(site.code, 'omegawiki')
self.assertIsInstance(site.namespaces, Mapping)
self.assertFalse(site.obsolete)
self.assertEqual(site.family.hostname('en'), url)
self.assertEqual(site.family.hostname('omega'), url)
self.assertEqual(site.family.hostname('omegawiki'), url)
class TestSubdomainFamilySite(TestCase):
"""Test subdomain family site."""
code = 'en'
family = 'lyricwiki'
def test_lyrics(self):
"""Test lyrics.fandom.com."""
url = 'lyrics.fandom.com'
site = self.site
self.assertEqual(site.hostname(), url)
self.assertEqual(site.code, 'en')
self.assertIsInstance(site.namespaces, Mapping)
self.assertFalse(site.obsolete)
self.assertEqual(site.family.hostname('en'), url)
self.assertRaises(KeyError, site.family.hostname, 'lyrics')
self.assertRaises(KeyError, site.family.hostname, 'lyricwiki')
self.assertRaises(pywikibot.UnknownSite, pywikibot.Site,
'lyricwiki', 'lyricwiki')
self.assertRaises(pywikibot.UnknownSite, pywikibot.Site,
'de', 'lyricwiki')
class TestProductionAndTestSite(AlteredDefaultSiteTestCase):
"""Test site without other production sites in its family."""
sites = {
'commons': {
'family': 'commons',
'code': 'commons',
},
'beta': {
'family': 'commons',
'code': 'beta',
},
'wikidata': {
'family': 'wikidata',
'code': 'wikidata',
},
'wikidatatest': {
'family': 'wikidata',
'code': 'test',
},
}
def test_commons(self):
"""Test Wikimedia Commons."""
site = self.get_site('commons')
self.assertEqual(site.hostname(), 'commons.wikimedia.org')
self.assertEqual(site.code, 'commons')
self.assertIsInstance(site.namespaces, Mapping)
self.assertFalse(site.obsolete)
self.assertRaises(KeyError, site.family.hostname, 'en')
pywikibot.config.family = 'commons'
pywikibot.config.mylang = 'de'
site2 = pywikibot.Site('beta')
self.assertEqual(site2.hostname(),
'commons.wikimedia.beta.wmflabs.org')
self.assertEqual(site2.code, 'beta')
self.assertFalse(site2.obsolete)
self.assertRaises(pywikibot.UnknownSite,
pywikibot.Site)
def test_wikidata(self):
"""Test Wikidata family, with sites for test and production."""
site = self.get_site('wikidata')
self.assertEqual(site.hostname(), 'www.wikidata.org')
self.assertEqual(site.code, 'wikidata')
self.assertIsInstance(site.namespaces, Mapping)
self.assertFalse(site.obsolete)
self.assertRaises(KeyError, site.family.hostname, 'en')
pywikibot.config.family = 'wikidata'
pywikibot.config.mylang = 'en'
site2 = pywikibot.Site('test')
self.assertEqual(site2.hostname(), 'test.wikidata.org')
self.assertEqual(site2.code, 'test')
# Languages can't be used due to T71255
self.assertRaises(pywikibot.UnknownSite,
pywikibot.Site, 'en', 'wikidata')
class TestSiteProofreadinfo(DefaultSiteTestCase):
"""Test proofreadinfo information."""
sites = {
'en-ws': {
'family': 'wikisource',
'code': 'en',
},
'en-wp': {
'family': 'wikipedia',
'code': 'en',
},
}
cached = True
def test_cache_proofreadinfo_on_site_with_proofreadpage(self):
"""Test Site._cache_proofreadinfo()."""
site = self.get_site('en-ws')
ql_res = {0: 'Without text', 1: 'Not proofread', 2: 'Problematic',
3: 'Proofread', 4: 'Validated'}
site._cache_proofreadinfo()
self.assertEqual(site.namespaces[106], site.proofread_index_ns)
self.assertEqual(site.namespaces[104], site.proofread_page_ns)
self.assertEqual(site.proofread_levels, ql_res)
self.assertEqual(site.namespaces[106], site.proofread_index_ns)
del site._proofread_page_ns # Check that property reloads.
self.assertEqual(site.namespaces[104], site.proofread_page_ns)
def test_cache_proofreadinfo_on_site_without_proofreadpage(self):
"""Test Site._cache_proofreadinfo()."""
site = self.get_site('en-wp')
self.assertRaises(pywikibot.UnknownExtension,
site._cache_proofreadinfo)
self.assertRaises(pywikibot.UnknownExtension,
lambda x: x.proofread_index_ns, site)
self.assertRaises(pywikibot.UnknownExtension,
lambda x: x.proofread_page_ns, site)
self.assertRaises(pywikibot.UnknownExtension,
lambda x: x.proofread_levels, site)
class TestPropertyNames(DefaultSiteTestCase):
"""Test Special:PagesWithProp method."""
sites = {
'en-ws': {
'family': 'wikisource',
'code': 'en',
},
'de-wp': {
'family': 'wikipedia',
'code': 'de',
},
}
cached = True
def test_get_property_names(self, key):
"""Test get_property_names method."""
mysite = self.get_site(key)
pnames = mysite.get_property_names()
self.assertIsInstance(pnames, list)
for item in ('defaultsort', 'disambiguation', 'displaytitle',
'forcetoc', 'graph_specs', 'hiddencat', 'newsectionlink',
'noeditsection', 'noexternallanglinks', 'nogallery',
'noindex', 'nonewsectionlink', 'notoc', 'score',
'templatedata', 'wikibase-badge-Q17437796',
'wikibase_item'):
self.assertIn(item, pnames)
class TestPageFromWikibase(DefaultSiteTestCase):
"""Test page_from_repository method."""
sites = {
'it-wb': {
'family': 'wikibooks',
'code': 'it',
'result': 'Hello world',
},
'de-wp': {
'family': 'wikipedia',
'code': 'de',
'result': 'Hallo-Welt-Programm',
},
'en-wp': {
'family': 'wikipedia',
'code': 'en',
'result': '"Hello, World!" program',
},
}
ITEM = 'Q131303'
def test_page_from_repository(self, key):
"""Validate page_from_repository."""
site = self.get_site(key)
page = site.page_from_repository(self.ITEM)
self.assertIsInstance(page, pywikibot.Page)
self.assertEqual(page.title(), self.sites[key]['result'])
def test_page_from_repository_none(self):
"""Validate page_from_repository return NoneType."""
site = pywikibot.Site('pdc', 'wikipedia')
page = site.page_from_repository(self.ITEM)
self.assertIsNone(page)
class TestCategoryFromWikibase(DefaultSiteTestCase):
"""Test page_from_repository method."""
sites = {
'it-ws': {
'family': 'wikisource',
'code': 'it',
'result': 'Categoria:2016',
},
'de-wp': {
'family': 'wikipedia',
'code': 'de',
'result': 'Kategorie:2016',
},
'en-wp': {
'family': 'wikipedia',
'code': 'en',
'result': 'Category:2016',
},
}
ITEM = 'Q6939656'
def test_page_from_repository(self, key):
"""Validate page_from_repository."""
site = self.get_site(key)
page = site.page_from_repository(self.ITEM)
self.assertIsInstance(page, pywikibot.Category)
self.assertEqual(page.title(), self.sites[key]['result'])
def test_page_from_repository_none(self):
"""Validate page_from_repository return NoneType."""
site = pywikibot.Site('pdc', 'wikipedia')
page = site.page_from_repository(self.ITEM)
self.assertIsNone(page)
class TestLoginLogout(DefaultSiteTestCase):
"""Test for login and logout methods."""
user = True
def test_login_logout(self):
"""Validate login and logout methods by toggling the state."""
site = self.get_site()
loginstatus = pywikibot.site.LoginStatus
self.assertTrue(site.logged_in())
self.assertIn(site._loginstatus, (loginstatus.IN_PROGRESS,
loginstatus.AS_USER))
self.assertIn('_userinfo', site.__dict__.keys())
self.assertIsNone(site.login())
if site.is_oauth_token_available():
self.assertRaisesRegexp(api.APIError, 'cannotlogout.*OAuth',
site.logout)
self.assertTrue(site.logged_in())
self.assertIn(site._loginstatus, (loginstatus.IN_PROGRESS,
loginstatus.AS_USER))
self.assertIn('_userinfo', site.__dict__.keys())
else:
site.logout()
self.assertFalse(site.logged_in())
self.assertEqual(site._loginstatus, loginstatus.NOT_LOGGED_IN)
self.assertNotIn('_userinfo', site.__dict__.keys())
self.assertIsNone(site.user())
if __name__ == '__main__': # pragma: no cover
try:
unittest.main()
except SystemExit:
pass
|
1_2_threading_condiction.py
|
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@Time : 2021-4-6
@Author : EvilRecluse
@Contact : https://github.com/RecluseXU
@Desc :
条件变量总是与某种类型的锁对象相关联，锁对象可以通过传入获得，或者在缺省的情况下自动创建。
当多个条件变量需要共享同一个锁时，传入一个锁很有用。锁是条件对象的一部分，你不必单独地跟踪它。
class threading.Condition(lock=None)
实现条件变量对象的类。一个条件变量对象允许一个或多个线程在被其它线程所通知之前进行等待。
如果给出了非 None 的 lock 参数，则它必须为 Lock 或者 RLock 对象，并且它将被用作底层锁。
否则，将会创建新的 RLock 对象，并将其用作底层锁。
acquire(*args)
请求底层锁。此方法调用底层锁的相应方法，返回值是底层锁相应方法的返回值。
release()
释放底层锁。此方法调用底层锁的相应方法。没有返回值。
wait(timeout=None)
等待直到被通知或发生超时。如果线程在调用此方法时没有获得锁，将会引发异常。
这个方法释放底层锁，然后阻塞，直到在另外一个线程中调用同一个条件变量的 notify() 或 notify_all() 唤醒它，或者直到可选的超时发生。一旦被唤醒或者超时，它重新获得锁并返回。
当提供了 timeout 参数且不是 None 时，它应该是一个浮点数，代表操作的超时时间，以秒为单位（可以为小数）。
wait_for(predicate, timeout=None)
等待，直到条件计算为真。 predicate 应该是一个可调用对象而且它的返回值为一个布尔值
notify(n=1)
唤醒n个正在等待这个条件的线程。如果线程在调用这个方法时没有获得锁，会引发异常。
notify_all()
唤醒所有正在等待这个条件的线程。 如果线程在调用这个方法时没有获得锁，会引发异常。
生产者与消费者模型 例子
'''
# here put the import lib
import threading
import time
def produce(condiction, good_produce):
for i in range(4):
with condiction:
print(threading.get_ident(), '生产')
good_produce()
condiction.notify(2)
time.sleep(1)
def consume(condiction, good_is_valid, good_consume):
with condiction:
print(threading.get_ident(), '正在等待消费')
condiction.wait_for(good_is_valid)
good_consume()
print(threading.get_ident(), '消费')
class Good:
good = 0
def have_good(self):
return self.good > 0
def produce_good(self):
self.good += 2
def consume_good(self):
self.good -= 1
if __name__ == '__main__':
good = Good()
condiction = threading.Condition()
consumes = []
consumes = [
threading.Thread(target=consume, args=[condiction, good.have_good, good.consume_good])
for i in range(8)
]
for consume in consumes:
consume.start()
produce = threading.Thread(target=produce, args=[condiction, good.produce_good])
produce.start()
|
runner.py
|
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import sys
import os.path
import optparse
import time
import threading
import Queue
from multiprocessing import Process
from nps.core import PacketSimulator, PacketSniff
from nps.parser import XmlTestCaseParser
from nps.network_entity import NetworkEntity
from nps.accessibility import AccessibilityManager, MacAddressHelper
from nps.file_log import *
def process_main(network_entity, ):
recv_queue_lock = threading.Lock()
# create queue for packet receive.
# send/recv의 복잡한 구조를 피하기 위해 recv thread를 별도로 만들었고,
# scapy sniff으로 전달 받은 패킷들을 직접 처리하지 않고 queue에 포함시킨다.
recv_queue = Queue.Queue()
sniff = PacketSniff()
recv_thread = threading.Thread(target=sniff.register,
args=(recv_queue, recv_queue_lock, network_entity))
# packet simulator thread에서 send/recv에 대한 모든 처리를 한다.
# send는 tc를 parsing항 얻은 packet 정보를 활용하여 전송하고,
# recv는 sniff에서 넣어준 recv queue를 활용한다.
simulator = PacketSimulator(network_entity, recv_queue, recv_queue_lock)
simulation_thread = threading.Thread(target=simulator.start)
recv_thread.start()
time.sleep(1)
simulation_thread.start()
simulation_thread.join()
# XXX:sniff function of recv_thread does not terminate.
# to terminate sniff, use the stop_filter of the sniff function.
# need an idea of stop_filter implementation.
#
#recv_thread.join()
def main():
parser = optparse.OptionParser('%prog -d <TC directory> -f <TC file name>')
parser.add_option('-d', dest='tc_directory', type='string', help='Test case directory')
parser.add_option('-f', dest='tc_filename', type='string', help='Test case filename')
(options, args) = parser.parse_args()
if len(sys.argv) <= 1:
parser.print_help()
exit(0)
if options.tc_directory is None:
# default value local directory
options.tc_directory = "."
if options.tc_filename is None:
print("Need test case filename.")
exit(-1)
full_tc_filename = options.tc_directory + '/' + options.tc_filename
if os.path.exists(full_tc_filename) == False:
print("%s file is not exist." % full_tc_filename)
exit(-1)
mac_addr_helper = MacAddressHelper()
accessibility_manager = AccessibilityManager()
parser = XmlTestCaseParser(options.tc_directory,
mac_addr_helper, accessibility_manager)
server = NetworkEntity("server")
client = NetworkEntity("client")
parser.analyze_tc_file(options.tc_filename, client, server)
server_process = None
if server.is_empty_packet_list() == False:
server_iface = server.get_interface_name()
server_start_time = write_report_init(server_iface, options.tc_filename)
server_process = Process(target=process_main, args=(server, ))
server_process.start()
time.sleep(1)
client_process = None
if client.is_empty_packet_list() == False:
client_iface = client.get_interface_name()
client_start_time = write_report_init(client_iface, options.tc_filename)
client_process = Process(target=process_main, args=(client, ))
client_process.start()
if client_process is not None:
client_process.join()
write_report_close(client_iface, client_start_time)
if server_process is not None:
server_process.join()
write_report_close(server_iface, server_start_time)
if __name__ == '__main__':
main()
|
video_monitor.py
|
import threading
import compare_audio
import compare_screenshots
import eye_tracker
import datetime
import sqlite3
has_youtube = 0
def set_youtube(yt):
global has_youtube
# print("Has youtube", yt)
has_youtube = yt
def run_eye_tracker(kill_flag, db_path):
threading.Thread(name="eye tracker thread", target=eye_tracker.timed_runs, args=(kill_flag, db_path,)).start()
def run_video_monitor(db_path):
global face_detected, has_youtube
if has_youtube:
audio_playing = compare_audio.main()
video_playing = compare_screenshots.main()
face_detected = eye_tracker.FACE
print("audio - " + str(audio_playing) + " | video - " + str(video_playing) + " | face - " + str(face_detected))
if audio_playing and video_playing and face_detected:
d = datetime.datetime.now()
date_d = str(d).split(" ")[0]
time_t = (str(d).split(" ")[1]).split(".")[0]
conn = sqlite3.connect(db_path)
c = conn.cursor()
query = "INSERT INTO video_monitor(d, t) VALUES('" + date_d + "','" + time_t + "')"
c.execute(query)
conn.commit()
return
|
10_rms_wait_die_gui.py
|
from functools import reduce
from sys import *
import numpy as np
import random as r
import ping_code as pc
import socket
import struct
import subprocess as sp
import threading
from threading import Thread
import ast
import time
import datetime as dt
import os
import getpass as gp
import psutil
from drawnow import *
from matplotlib import pyplot as plt
from netifaces import interfaces, ifaddresses, AF_INET
import paho.mqtt.client as mqtt
import smtplib
import config
hosts = {} # {hostname: ip}
_tasks = {'t1': {'wcet': 3, 'period': 20, 'deadline': 15},
't2': {'wcet': 1, 'period': 5, 'deadline': 4},
't3': {'wcet': 2, 'period': 10, 'deadline': 8},
't4': {'wcet': 1, 'period': 10, 'deadline': 9},
't5': {'wcet': 3, 'period': 15, 'deadline': 12}
}
# mat = {'p0': ['cpu', 'mem', 'storage']}
_need = {
't1': [7, 4, 3],
't2': [1, 2, 2],
't3': [6, 0, 0],
't4': [0, 1, 1],
't5': [4, 3, 1]
}
allocation = {
't1': [0, 1, 0],
't2': [2, 0, 0],
't3': [3, 0, 2],
't4': [2, 1, 1],
't5': [0, 0, 2]
}
test = []
_time = []
color_code = ['orange', 'brown', 'purple', 'pink', 'blue']
style = ['g--^', 'r:o', 'b-.s', 'm--*', 'k-.>', 'c-.s']
mec_waiting_time = {} # {ip : [moving (waiting time + rtt)]}
offload_register = {} # {task: host_ip} to keep track of tasks sent to mec for offload
reoffload_list = [[], {}]
discovering = 0
mec_rtt = {} # {ip: [RTT]}
thread_record = [] # keeps track of threads
prev_t = 0 # variable for cpu util
_cpu = [] # cpu plot list
_off_mec = 0 # used to keep a count of tasks offloaded from local mec to another mec
_off_cloud = 0 # used to keep a count of tasks offloaded to cloud
_loc = 0 # used to keep a count of tasks executed locally
_inward_mec = 0 # used to keep a count of tasks offloaded from another mec to local mec
deadlock = [1] # keeps count of how many deadlock is resolved
_pos = 0
received_task_queue = [] # [[(task_list,wait_time), host_ip], ....]
_port_ = 64000
cloud_register = {} # ={client_id:client_ip} keeps address of task offloaded to cloud
cloud_port = 63000
memory = []
stop = 0
t_track = 1
shared_resource_lock = threading.Lock()
fig = plt.figure()
ax1 = fig.add_subplot(231)
ax2 = fig.add_subplot(232)
ax3 = fig.add_subplot(233)
ax4 = fig.add_subplot(234)
ax5 = fig.add_subplot(235)
ax6 = fig.add_subplot(236)
def discovering_group():
global sock1
multicast_group = '224.3.29.71'
server_address = ('', 10000)
# Create the socket
sock1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Bind to the server address
sock1.bind(server_address)
# Tell the operating system to add the socket to the multicast group
# on all interfaces.
group = socket.inet_aton(multicast_group)
mreq = struct.pack('4sL', group, socket.INADDR_ANY)
sock1.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
def offloading_group():
global sock2
multicast_group = '224.5.5.55'
server_address = ('', 20000)
# Create the socket
sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Bind to the server address
sock2.bind(server_address)
# Tell the operating system to add the socket to the multicast group
# on all interfaces.
group = socket.inet_aton(multicast_group)
mreq = struct.pack('4sL', group, socket.INADDR_ANY)
sock2.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
def _mov_avg(a1):
ma1 = [] # moving average list
avg1 = 0 # moving average pointwise
count = 0
for i in range(len(a1)):
count += 1
avg1 = ((count-1)*avg1+a1[i])/count
ma1.append(round(avg1, 4)) # cumulative average formula
# μ_n=((n-1) μ_(n-1) + x_n)/n
return ma1
def percent(value, total):
if value > 0:
return round((value/total)*100, 2)
else:
return 0
def plot_offloaded_remote():
keys = ['O-Out', 'Cloud', 'Local', 'O-In']
total = _off_mec + _off_cloud + _loc + _inward_mec
val = [percent(_off_mec, total),
percent(_off_cloud, total),
percent(_loc, total),
percent(_inward_mec, total)]
cols = ['r', 'g', 'b', 'm']
ypos = ([0, 1, 2, 3])
'''
explode = []
for i in val:
if i == max(val):
explode.append(0.1)
else:
explode.append(0)
ax2.pie(val, labels=keys, autopct='%.3f%%', wedgeprops=dict(width=0.5),
startangle=-40, shadow=True, explode=explode, colors=cols)
'''
values = [_off_mec, _off_cloud, _loc, _inward_mec]
for i in values:
j = values.index(i)
ax2.text(j-0.1, values[j], '{}%'.format(val[j]), rotation=0,
ha="center", va="center", bbox=dict(boxstyle="round", ec=(1., 0.5, 0.5), fc=(1., 0.8, 0.8), ))
ax2.set_xticks(ypos)
ax2.set_xticklabels(keys)
ax2.bar(ypos, values, align='center', color=cols, alpha=0.3)
ax2.set_title('Local/Remote Execution Report')
plt.subplot(ax2)
# color=color_code[list(hosts.values()).index(i)]
def plot_deadlock():
# cols = ['r']
text = str(deadlock[-1] - 1) + " Deadlock Resolved"
'''
wedges, texts, autotexts = ax5.pie(deadlock, shadow=True, autopct=text,
textprops=dict(rotation_mode='anchor', color="w", ha='left'), colors=cols)
plt.setp(autotexts, size=9, weight="bold")
'''
ax5.text(0.5, 0.6, text, rotation=0, size=10,
ha="center", va="center", bbox=dict(boxstyle="round", ec=(0., 0., 0.), fc=(0.7, 0.9, 1.)))
ax5.text(0.5, 0.45, '{} Tasks Received'.format(_loc+_inward_mec), rotation=0, size=10,
ha="center", va="center", bbox=dict(boxstyle="round", ec=(0., 0., 0.), fc=(0.98, 0.96, 0.59), ))
# ax5.set_title("Deadlock Resolved Counter")
ax5.set_axis_off()
plt.subplot(ax5)
def plot_memory():
global memory
memory.append(round(algo.memory_percent(), 4))
ax6.grid(True)
ax6.plot(list(range(len(_mov_avg(memory)))), _mov_avg(memory), linewidth=2, label='Memory', color='m')
# ax6.set_title('Moving Memory Utilization')
ax6.set_ylabel('Moving Memory')
ax6.set_xlabel('Time (seconds)')
ax6.fill_between(list(range(len(_mov_avg(memory)))), _mov_avg(memory), 0, alpha=0.5, color='m')
ax6.legend()
plt.subplot(ax6)
def plot_wait_time():
ax1.grid(True)
for i in mec_waiting_time:
mv = _mov_avg(mec_waiting_time[i])
pt = mv[0:len(mv):int((len(mv) / 7)) + 1]
if pt[-1] != mv[-1]:
pt.append(mv[-1])
ptx = [mv.index(i) for i in pt]
ax1.plot(ptx,
pt,
style[list(hosts.values()).index(i)],
linewidth=2,
label=i)
ax1.set_title('Waiting Time Queue')
ax1.set_ylabel('Moving Wait + RTT')
# ax2.set_xlabel('Time (seconds)')
ax1.legend()
plt.subplot(ax1)
def get_mec_rtts():
for i in mec_rtt:
mec_rtt[i].append(get_rtt(i))
def plot_rtts():
get_mec_rtts()
ax3.grid(True)
for i in mec_rtt:
mv = _mov_avg(mec_rtt[i])
pt = mv[0:len(mv):int((len(mv) / 7)) + 1]
if pt[-1] != mv[-1]:
pt.append(mv[-1])
ptx = [mv.index(i) for i in pt]
ax3.plot(ptx,
pt,
style[list(hosts.values()).index(i)],
linewidth=2,
label=i)
ax3.set_title('RTT Utilization over Time')
# ax3.set_ylabel('Moving RTT')
# ax3.set_xlabel('Time (seconds)')
ax3.legend()
plt.subplot(ax3)
def plot_cpu():
global prev_t
# get cpu
next_t = psutil.cpu_percent(percpu=False)
delta = abs(prev_t - next_t)
prev_t = next_t
_cpu.append(round(delta, 4))
# plot graph
ax4.grid(True)
ax4.plot(list(range(len(_mov_avg(_cpu)))), _mov_avg(_cpu), linewidth=2, label='CPU')
# ax4.set_title('Moving CPU Utilization')
ax4.set_ylabel('Moving CPU')
ax4.set_xlabel('Time (seconds)')
ax4.fill_between(list(range(len(_mov_avg(_cpu)))), _mov_avg(_cpu), 0, alpha=0.5)
ax4.legend()
plt.subplot(ax4)
def plot_graphs():
plot_offloaded_remote()
plot_wait_time()
plot_rtts()
plot_cpu()
plot_deadlock()
plot_memory()
fig.suptitle('MEC Performance During Deadlock Experiment')
def show_graphs():
drawnow(plot_graphs)
def ip_address():
try:
# cmd = ['ifconfig eth1 | grep inet | cut -d ":" -f 2 | cut -d " " -f 1']
cmd = ['ifconfig ens4 | grep inet | head -n 1 | cut -d "t" -f 2 | cut -d " " -f 2']
address = str(sp.check_output(cmd, shell=True), 'utf-8')[0:-1]
if len(address.strip().split('.')) == 4:
return address.strip()
else:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
except Exception as e:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("8.8.8.8", 80))
return s.getsockname()[0]
def host_ip_set():
global ip_set
ip_set = set()
for ifaceName in interfaces():
addresses = [i['addr'] for i in ifaddresses(ifaceName).setdefault(AF_INET, [{'addr': 'No IP addr'}])]
ip_set.add(', '.join(addresses))
def get_rtt(host):
rtt = pc.verbose_ping(host)
return round(rtt, 4)
def get_time():
_time_ = []
d = str(dt.datetime.utcnow()).split()
_time_ += d[0].split('-')
g = d[1].split('.')
_time_ += g[0].split(':')
_time_.append(g[1])
return _time_
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def _lcm(a, b):
return int(a * b / gcd(a, b))
def lcm(_list):
return reduce(_lcm, _list)
def gosh_dist(_range):
return ((23 ** r.randrange(1, 1331)) % r.randrange(1, 1777)) % _range
def on_connect(connect_client, userdata, flags, rc):
# print("Connected with Code :" +str(rc))
# Subscribe Topic from here
connect_client.subscribe(node_id)
# Callback Function on Receiving the Subscribed Topic/Message
def on_message(message_client, userdata, msg):
data = str(msg.payload, 'utf-8')
if data[0] == 'c':
data = data[2:]
received_task = ast.literal_eval(data)
# send_client({received_task: get_time()}, cloud_register[received_task.split('.')[2]])
_client.publish(received_task.split('.')[2], str({received_task: get_time()}))
elif data[0] == 't': # receive from client
received_task = ast.literal_eval(data[2:])
received_task_queue.append(received_task)
else:
print('data: ', data)
def connect_to_broker():
global _client
global broker_ip
username = 'mec'
password = 'password'
broker_ip = hosts['speaker']
broker_port_no = 1883
_client = mqtt.Client()
_client.on_connect = on_connect
_client.on_message = on_message
_client.username_pw_set(username, password)
_client.connect(broker_ip, broker_port_no, 60)
_client.loop_forever()
def load_tasks():
global tasks
period_list = [tasks[i]['period'] for i in tasks]
lcm_period = lcm(period_list)
# insert idle task
tasks['idle'] = {'wcet': lcm_period, 'period': lcm_period + 1}
return lcm_period
def scheduler(_lcm_): # RMS algorithm
queue = list(tasks.keys()) # initialize task queue
schedule = []
rms = []
curr = '' # current task
prev = '' # previous task
tmp = {}
for task in tasks.keys():
tmp[task] = {} # temporary data for each task
tmp[task]['deadline'] = tasks[task]['period']
tmp[task]['executed'] = 0
# start scheduling...
# proceed by one timestamp to handle preemption
for _time_ in range(_lcm_):
# insert new tasks into the queue
for t in tmp.keys():
if _time_ == tmp[t]['deadline']:
if tasks[t]['wcet'] > tmp[t]['executed']:
# print('Scheduling Failed at %d' % time)
exit(1)
else:
tmp[t]['deadline'] += tasks[t]['period']
tmp[t]['executed'] = 0
queue.append(t)
# select next task to be scheduled
_min_ = _lcm_ * 2
for task in queue:
if tmp[task]['deadline'] < _min_:
_min_ = tmp[task]['deadline']
curr = task
tmp[curr]['executed'] += 1
# print(time, queue, curr)
# dequeue the execution-completed task
if tmp[curr]['executed'] == tasks[curr]['wcet']:
for i in range(len(queue)):
if curr == queue[i]:
del queue[i]
break
# record to the schedule trace
if prev != curr:
if prev in queue and prev != 'idle': # previous task is preempted..
s = schedule.pop()
schedule.append([s[0], s[1], '*'])
rms.append(s[1])
schedule.append([_time_, curr])
if curr != 'idle':
rms.append(curr)
prev = curr
return rms
# generate execution sequence with wait_die
def wait_die(processes, avail, n_need, allocat):
global deadlock
offload = []
# To store execution sequence
exec_seq = []
# Make a copy of available resources
work = [0] * len(processes)
# While all processes are not finished
# or system is not in safe state.
while 'w' or 0 in work:
if 0 in work:
ind = work.index(0)
i = processes[ind]
elif 'w' in work:
# print('wk: ', work)
ind = work.index('w')
i = processes[ind]
else:
break
# print('comparing| process: ', i, n_need[i], 'work: ', avail)
if not (False in list(np.greater_equal(avail, n_need[i]))):
exec_seq.append(i)
avail = np.add(avail, allocat[i])
work[ind] = 1
# print('added: ', exec_seq)
else:
a = list(set(processes) - set(exec_seq) - set(offload))
n = {}
for j in a:
n[j] = sum(allocat[j])
_max = max(n, key=n.get)
# print('work: ', work, 'need: ', n_need[_max])
if processes.index(_max) > processes.index(i): # if true, i is older
# if process is already waiting then offload process
if work[ind] == 'w':
offload.append(i)
avail = np.array(avail) + np.array(allocat[i])
work[processes.index(i)] = 1
# print('offload reentry: ', i, offload)
else:
# wait put process to waiting
work[processes.index(i)] = 'w'
# print('waiting: ', i)
else:
# abort i
offload.append(i)
avail = np.array(avail) + np.array(allocat[i])
work[processes.index(i)] = 1
# print('offload: ', i)
if len(offload) > 0:
print('offloading tasks: ', offload)
cooperative_mec(offload)
deadlock[0] += 1
print('Execution seq: ', exec_seq)
return exec_seq
def get_exec_seq(pro):
# Number of processes
p = len(pro)
processes = ['{}_{}'.format(pro[i], i) for i in range(p)]
# Available instances of resources
avail = [6, 5, 5]
n_need = {i: _need[i[:2]] for i in processes}
# print('need', n_need)
# Resources allocated to processes
allot = {i: allocation[i[:2]] for i in processes}
# return execution sequence
return wait_die(processes, avail, n_need, allot)
def calc_wait_time(list_seq):
pre = 0
time_dic = {}
for i in list_seq:
j = i.split('_')[0] # i = 't5_3_3', j = 't5_3'
time_dic[i] = round(t_time[j][0] + pre, 3)
pre += t_time[j][0]
# waiting time = total waiting time ÷ 2 average waiting time might be too tight
w_send = round(time_dic[list(time_dic.keys())[-1]]/2, 3)
send_message('wt {} {}'.format(ip_address(), str(w_send))) # Broadcasting waiting time to cooperative MECs
return time_dic
def compare_local_mec(list_seq):
time_compare_dict = {i: t_time[i.split('_')[0]][1] > list_seq[i] for i in list_seq}
print('local vs MEC comparison: ', time_compare_dict)
execute_mec = []
execute_locally = []
for i in time_compare_dict:
if time_compare_dict[i]:
execute_locally.append(i)
else:
execute_mec.append(i)
return execute_mec, execute_locally
def calculate_mov_avg(ma1, a1):
if ma1 in mec_waiting_time:
_count = len(mec_waiting_time[ma1])
avg1 = mec_waiting_time[ma1][-1]
else:
_count = 0
avg1 = 0
_count += 1
avg1 = ((_count - 1) * avg1 + a1) / _count
# ma1.append(avg1) #cumulative average formula
# μ_n=((n-1) μ_(n-1) + x_n)/n
return round(avg1, 4)
def send_message(mg):
_multicast_group = ('224.3.29.71', 10000)
try:
# Send data to the multicast group
if mg == 'hello':
smg = mg + ' ' + str([get_hostname(), ip_address()])
sock1.sendto(str.encode(smg), _multicast_group)
print('\nHello message sent')
else:
sock1.sendto(str.encode(mg), _multicast_group)
except Exception as e:
print(e)
def get_hostname():
cmd = ['cat /etc/hostname']
hostname = str(sp.check_output(cmd, shell=True), 'utf-8')[0:-1]
return hostname
def receive_message():
global hosts
while True:
if stop == 1:
print('Stopped : receive_message')
break
else:
data, address = sock1.recvfrom(1024)
_d = data.decode()
if _d[:5] == 'hello':
_data = ast.literal_eval(_d[6:])
hosts[_data[0]] = _data[1]
# print('received: ', hosts)
if _data[1] != host_ip:
mec_rtt[_data[1]] = []
elif (data.decode()[:6] == 'update') and (discovering == 0):
hosts = ast.literal_eval(data.decode()[7:])
elif _d[:2] == 'wt':
split_data = _d.split()
if split_data[1] != host_ip:
# calcuate moving average of mec wait time => w_time = wait time + rtt
w_time = calculate_mov_avg(split_data[1], float(split_data[2]) + get_rtt(address[0]))
if split_data[1] in mec_waiting_time:
mec_waiting_time[split_data[1]].append(w_time)
else:
mec_waiting_time[split_data[1]] = [w_time]
def mec_comparison():
# returns min average waiting for all mecs
if len(mec_waiting_time) == 0:
return 0
min_mec = {i: mec_waiting_time[i][-1] for i in mec_waiting_time}
min_wt = min(min_mec, key=min_mec.get)
return min_wt
def cooperative_mec(mec_list):
global _off_cloud
global _off_mec
for i in mec_list:
_host = mec_comparison()
if _host == 0:
# send_cloud([i.split('_')[0], t_time[i.split('_')[0]][0]]) # [task_id,exec_time]
_client.publish(cloud_ip, str([i.split('_')[0], t_time[i.split('_')[0]][0]]))
_off_cloud += 1
# cloud_register[i.split('_')[0].split('.')[2]] = send_back_host
print('\n=========SENDING {} TO CLOUD==========='.format(i))
else:
j = i.split('_')[0]
_max = np.array([6, 5, 5])
send = 'false'
if not (False in list(np.greater_equal(_max, _need[j[:2]]))):
send = 'true'
# CHECK IF THE MINIMUM MEC WAIT TIME IS LESS THAN LATENCY
if mec_waiting_time[_host][-1] < t_time[j][1] and send == 'true':
send_offloaded_task_mec('{} {} {}'.format('ex', mec_id(_host), [j, t_time[j][0]]))
_off_mec += 1
# SENDS TASK TO MEC FOR EXECUTION
mec_waiting_time[_host].append(
round(mec_waiting_time[_host][-1] + (t_time[j][0]) / 2, 3)) # adds a new average waiting time
print('\n======SENDING {} TO MEC {}========='.format(i, _host))
else:
_client.publish(cloud_ip, str([j, t_time[j][0]]))
_off_cloud += 1
# send_cloud([j, t_time[j][0]]) # # [task_id,exec_time]
# cloud_register[j.split('.')[2]] = send_back_host
print('\n=========SENDING {} TO CLOUD==========='.format(i))
def execute_re_offloaded_task(offloaded_task):
exec_list = get_exec_seq(offloaded_task[0])
for i in exec_list:
j = i.split('_')[0]
time.sleep(offloaded_task[1][j]/2)
# print('j task: ', j)
send_offloaded_task_mec('{} {}'.format(j.split('.')[1], i.split('*')[0]))
def execute(local):
print('\nExecuting :', local)
# send = []
for i in local:
j = i.split('_')[0]
time.sleep(t_time[j][0]/2)
print('#' * ((local.index(i) + 1) * 3), ' Executed: ', i)
if j.split('.')[1] != node_id:
send_offloaded_task_mec('{} {}'.format(j.split('.')[1], j))
# send.append(j)
elif j.split('.')[1] == node_id:
# send_client({j: get_time()}, send_back_host)
_client.publish(j.split('.')[2], str({j: get_time()}))
print('============== EXECUTION DONE ===============')
# return send
def receive_offloaded_task_mec(): # run as a thread
global _inward_mec
global t_track
while True:
if stop == 1:
print('Stopped: receive_offloaded_task_mec()')
break
else:
data, address = sock2.recvfrom(1024)
if len(data.decode()) > 0:
da = data.decode().split(' ')
if (address[0] not in ip_set) and da[0] == node_id: # send back to client
# send_client({da[1]: get_time()}, offload_register[da[1]]) # send back to client
_client.publish(da[1].split('.')[2], str({da[1]: get_time()}))
elif (address[0] not in ip_set) and da[0] == 'ex' and da[1] == node_id:
_received = ast.literal_eval(da[2] + da[3])
shared_resource_lock.acquire()
task = _received[0] + '*{}'.format(t_track)
reoffload_list[0].append(task)
reoffload_list[1][task] = _received[1]
shared_resource_lock.release()
t_track += 1
_inward_mec += 1
def call_execute_re_offload():
global reoffload_list
while True:
if stop == 1:
print('Stopped: call_executed_re_offload()')
break
else:
if len(reoffload_list[0]) == 1:
t = reoffload_list[0][-1]
time.sleep(reoffload_list[1][t]/2)
shared_resource_lock.acquire()
reoffload_list[0].remove(t)
del reoffload_list[1][t]
shared_resource_lock.release()
send_offloaded_task_mec('{} {}'.format(t.split('.')[1], t.split('*')[0]))
elif len(reoffload_list[0]) > 1:
o = reoffload_list.copy()
execute_re_offloaded_task(o)
for i in o[0]:
shared_resource_lock.acquire()
reoffload_list[0].remove(i)
del reoffload_list[1][i]
shared_resource_lock.release()
time.sleep(1)
def send_offloaded_task_mec(msg):
_multicast_group = ('224.5.5.55', 20000)
try:
sock2.sendto(str.encode(msg), _multicast_group)
except Exception as e:
print(e)
def send_email(msg):
try:
server = smtplib.SMTP_SSL('smtp.gmail.com')
server.ehlo()
server.login(config.email_address, config.password)
subject = 'Deadlock results rms+wait_die {}'.format(get_hostname())
# msg = 'Attendance done for {}'.format(_timer)
_message = 'Subject: {}\n\n{}\n\n SENT BY RIHANNA \n\n'.format(subject, msg)
server.sendmail(config.email_address, config.send_email, _message)
server.quit()
print("Email sent!")
except Exception as e:
print(e)
def mec_id(client_ip):
_id = client_ip.split('.')[-1]
if len(_id) == 1:
return '00' + _id
elif len(_id) == 2:
return '0' + _id
else:
return _id
def run_me():
global discovering
global hosts
initialization()
while True:
if len(hosts) == mec_no:
print('MEC Details: ', hosts)
del hosts[get_hostname()]
discovering = 1
break
time.sleep(2)
start_loop()
def save_and_abort():
global stop
_id_ = get_hostname()[-1]
result = f"wt{_id_}_10_{mec_no} = {mec_waiting_time} " \
f"\nrtt{_id_}_10_{mec_no} = {mec_rtt} \ncpu{_id_}_10_{mec_no} = {_cpu} " \
f"\noff_mec{_id_}_10_{mec_no} = {_off_mec} " \
f"\noff_cloud{_id_}_10_{mec_no} = {_off_cloud} " \
f"\ninward_mec{_id_}_10_{mec_no} = {_inward_mec}" \
f"\nloc{_id_}_10_{mec_no} = {_loc} " \
f"\ndeadlock{_id_}_10_{mec_no} = {deadlock} \nmemory{_id_}_10_{mec_no} = {memory}"
list_result = [
f"wt{_id_}_10_{mec_no} = {mec_waiting_time} ",
f"\nrtt{_id_}_10_{mec_no} = {mec_rtt} \ncpu{_id_}_10_{mec_no} = {_cpu} ",
f"\no_mec{_id_}_10_{mec_no} = {_off_mec} \no_cloud{_id_}_10_{mec_no} = {_off_cloud} ",
f"\ninward_mec{_id_}_10_{mec_no} = {_inward_mec}",
f"\nloc{_id_}_10_{mec_no} = {_loc} ",
f"\ndeadlock{_id_}_10_{mec_no} = {deadlock} \nmemory{_id_}_10_{mec_no} = {memory}"
]
for i in list_result:
cmd = 'echo "{}" >> data.py'.format(i)
os.system(cmd)
os.system('echo "{}" >> /home/mec/result/data.py'.format(i))
send_email(result)
stop += 1
'''
for i in thread_record:
i.join()
'''
_client.loop_stop()
time.sleep(1)
print('done')
os.system('kill -9 {}'.format(os.getpid()))
def start_loop():
global _loc
global tasks
global t_time
global stop
global node_id
print('\n============* WELCOME TO THE DEADLOCK EMULATION PROGRAM *=============\n')
node_id = mec_id(ip_address())
# print('node id: ', node_id)
_threads_ = [receive_offloaded_task_mec, call_execute_re_offload, connect_to_broker]
for i in _threads_:
thread_record.append(Thread(target=i))
Thread(target=i).daemon = True
Thread(target=i).start()
x = gp.getpass('Press any key to Start...').lower()
if x != 'exit':
print('========= Waiting for tasks ==========')
_time_ = dt.datetime.now()
while True:
try:
if len(received_task_queue) > 0:
info = received_task_queue.pop(0)
tasks, t_time = info
print('EDF List of Processes: ', tasks, '\n')
print('\n========= Running Deadlock Algorithm ===========')
a = load_tasks()
list_seq = get_exec_seq(scheduler(a))
if len(list_seq) > 0: # do only when there is a task in safe sequence
wait_list = calc_wait_time(list_seq)
print('\nWaiting Time List: ', wait_list)
compare_result = compare_local_mec(wait_list)
print('\nExecute Locally: ', compare_result[1])
_loc += len(compare_result[1]) # total number of tasks to be executed locally
print('\nExecute in MEC: ', compare_result[0])
if len(compare_result[0]) > 0:
print('\nSending to cooperative platform')
cooperative_mec(compare_result[0])
execute(compare_result[1])
show_graphs()
_time_ = dt.datetime.now()
else:
send_message(str('wt {} 0.0'.format(ip_address())))
time.sleep(.5)
now = dt.datetime.now()
delta = now - _time_
if delta > dt.timedelta(minutes=3):
print('terminating programme 3 mins elapsed')
save_and_abort()
break
except KeyboardInterrupt:
print('\nProgramme Terminated')
save_and_abort()
break
def initialization():
global mec_no
global host_ip
global cloud_ip
host_ip = ip_address()
try:
mec_no = int(input('Number of MECs: ').strip())
cloud_ip = input('Cloud Server IP: ').strip()
print('\nCompiling MEC Details')
h1 = Thread(target=receive_message)
h2 = Thread(target=receive_offloaded_task_mec)
thread_record.append(h1)
thread_record.append(h2)
h1.daemon = True
h2.daemon = True
h1.start()
h2.start()
while True:
b = input('Send Hello Message (Y/N): ').strip().lower()
if b == 'y':
send_message('hello')
break
else:
print('\nPlease Type "y" to send Hello message\n')
except KeyboardInterrupt:
print('\nProgramme Terminated')
exit(0)
def main():
global algo
os.system('clear')
print('mec ip: ', ip_address())
algo = psutil.Process()
discovering_group()
offloading_group()
host_ip_set()
run_me()
if __name__ == "__main__":
main()
|
widgets.py
|
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 11 19:55:12 2020
@author: Timothe
"""
import sys, os#, time
import numpy as np
from matplotlib.backends.qt_compat import QtCore, QtWidgets
from matplotlib.backends.backend_qt5agg import (FigureCanvas, NavigationToolbar2QT as NavigationToolbar)
from matplotlib.figure import Figure
from mpl_toolkits.mplot3d import Axes3D
import matplotlib
matplotlib.use('Qt5Agg')
from PyQt5.QtWidgets import QSlider, QPushButton, QLineEdit, QLabel, QGroupBox, QGridLayout, QCheckBox, QComboBox, QMenu, QSpinBox, QApplication, QStyleFactory, QFrame , QMainWindow
from PyQt5 import QtWidgets as QrealWidgets
from PyQt5.QtCore import Qt , Signal, QThread, pyqtSignal
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath("__filename__"))))
from LibrairieVSDAna.ReadVSDfile import GetVSD_Data, GetVSD_FileList
from LibrairieVSDAna.masks import CreateEmptyMask, UpdateMask, MaskIN, MaskOUT, MaskCompatibility
from LibrairieVSDAna.VSDprocessing import ProcessDataExternal
from LibUtils import image, optimization, database_IO, plots
import sqlalchemy as sql
import scipy.ndimage as scp
class SuperSlider(QrealWidgets.QWidget):
ValueChange = Signal()
MouseReleased = Signal()
def __init__(self, parent=None, **kwargs):
super(SuperSlider, self).__init__()
l = QGridLayout(self)
self.Slider = QSlider(Qt.Horizontal, self)
self.Readout = QLabel("-")
self.LeftButton = QPushButton("<")
self.RightButton = QPushButton(">")
self.Readout.setMaximumWidth(30)
self.LeftButton.setMaximumWidth(20)
self.RightButton.setMaximumWidth(20)
if 'minimum' in kwargs :
minimum = kwargs.get('minimum')
self.Slider.setMinimum(minimum)
if 'maximum' in kwargs :
maximum = kwargs.get('maximum')
if maximum < minimum :
raise ValueError("Min slider value is higher than max slider value")
else :
self.Slider.setMaximum(maximum)
if 'start' in kwargs :
start = kwargs.get('start')
if start >= minimum and start <= maximum:
self.Slider.setValue(start)
else :
self.Slider.setValue(self.Slider.minimum())
else :
self.Slider.setValue(self.Slider.minimum())
self.Readout.setText(str(self.Slider.value()))
self.Slider.sliderReleased.connect(self.MouseReleased_emiter)
self.Slider.valueChanged.connect(self.ValueChanged_emiter)
self.LeftButton.pressed.connect(self.MoveLeft)
self.RightButton.pressed.connect(self.MoveRight)
l.addWidget(self.Slider,0,0,1,8)
l.addWidget(self.Readout,0,8,1,1)
l.addWidget(self.LeftButton,0,9,1,1)
l.addWidget(self.RightButton,0,10,1,1)
self.setMaximumHeight(50)
self.setLayout(l)
def MoveLeft(self):
if self.Slider.value()-1 >= self.Slider.minimum():
self.Slider.setValue(self.Slider.value()-1)
self.MouseReleased_emiter()
def MoveRight(self):
if self.Slider.value()+1 <= self.Slider.maximum():
self.Slider.setValue(self.Slider.value()+1)
self.MouseReleased_emiter()
def MouseReleased_emiter(self):
''' Punch the bag '''
self.MouseReleased.emit()
def ValueChanged_emiter(self):
self.Readout.setText(str(self.Slider.value()))
''' Punch the bag '''
self.ValueChange.emit()
def SetValueAndEmit(self,value):
self.Slider.setValue(value)
#self.ValueChange.emit()
class CanvasHandle(FigureCanvas):
"""Ultimately, this is a QWidget (as well as a FigureCanvasAgg, etc.)."""
def __init__(self, parent=None, width=5, height=4, dpi=100, *args, **kwargs):
self.fig = Figure(figsize=(width, height), dpi=dpi)
self.axes = self.fig.add_subplot(111)
self.fig.subplots_adjust(left=0.03,right=0.97,
bottom=0.03,top=0.97,
hspace=0.2,wspace=0.2)
FigureCanvas.__init__(self, self.fig)
self.setParent(parent)
FigureCanvas.setSizePolicy(self,QtWidgets.QSizePolicy.Expanding,QtWidgets.QSizePolicy.Expanding)
FigureCanvas.updateGeometry(self)
self.rc = {"axes.spines.left" : False,
"axes.spines.right" : False,
"axes.spines.bottom" : False,
"axes.spines.top" : False,
"xtick.bottom" : False,
"xtick.labelbottom" : False,
"ytick.labelleft" : False,
"ytick.left" : False}
class DynamicCanvas(CanvasHandle):
"""A canvas that updates itself every second with a new plot."""
def __init__(self, *args, **kwargs):
CanvasHandle.__init__(self, *args, **kwargs)
self.timer = QtCore.QTimer(self)
self.timer.timeout.connect(self.update_figure)
self.cbar = False
self.EnforceType = False
self.cbarON = False
self.Spines = False
def Enforce(self,Type):
if Type == '3D' :
self.fig.clf()
self.cbar = False
self.axes = self.fig.add_subplot(111, projection = '3d')
else :
self.fig.clf()
self.cbar = False
self.axes = self.fig.add_subplot(111)
self.EnforceType = Type
def StartTimer(self, millis = 1000):
self.timer.start(millis)
def StopTimer(self):
self.timer.stop()
def identifyDtype(self,item):
if type(item) == dict:
dtype = 'multi'
else :
if type(item) == np.ndarray or type(item) == np.ma.core.MaskedArray:
Shape = np.shape(item)
if len(Shape) == 1:
dtype = '1Dy'
else :
if len(Shape) == 2 and np.min(Shape) == 1:
dtype = '1Dy'
elif len(Shape) == 2 and np.min(Shape) == 2:
dtype = '1Dxy'
elif len(Shape) == 2 and np.min(Shape) > 2:
dtype = '2Dgrey'
elif len(Shape) == 3 and np.min(Shape) == 3:
dtype = '2Dcolor'
elif len(Shape) > 3 :
dtype = '3D'
else :
dtype = 'pass'
elif type(item) == list :
dtype = '1Dy'
elif type(item) == tuple and len(item) == 2:
dtype = '1Dxy'
else :
dtype = 'pass'
raise ValueError("Datatype {} with shape {} not understood".format(type(item),np.shape(item)))
if dtype != 'pass' and self.EnforceType is not False :
dtype = self.EnforceType
return dtype
def activateColorBar(self,Bool):
self.cbarON = Bool
def formatDatatype(self,item,dtype,**kwargs):
if dtype == '1Dy':
if type(item) == list:
X = np.arange(len(item))
else :
X = np.arange(np.shape(item)[0])
self.write1Dfigure(X,item,**kwargs)
elif dtype == '1Dxy':
if type(item) == tuple:
X = item[0]
Y = item[1]
else :
X = item[:,0]
Y = item[:,1]
self.write1Dfigure(X,Y,**kwargs)
elif dtype == '2Dgrey' or dtype == '2Dcolor':
self.write2Dfigure(item,**kwargs)
elif dtype == '3D':
X, Y = np.meshgrid(np.arange(0,np.shape(item)[1]), np.arange(0,np.shape(item)[0]))
Z = item
self.write3Dfigure(X, Y, Z,**kwargs)
else :
pass
def write1Dfigure(self,X,Y,**kwargs):
if 'vmin' in kwargs:
kwargs.get('vmin')
kwargs.get('vmin')
self.axes.plot(X,Y, **kwargs)
self.axes.set_aspect('auto')
self.draw()
def write2Dfigure(self,frame,**kwargs):
supLines = kwargs.get("Lines",None)
cmap = kwargs.get("cmap", None)
if cmap == "geo":
cmap = plots.cmap_GEO()
if self.cbarON :
if self.cbar :
self.cbar.remove()
im = self.axes.imshow(frame, **kwargs)
self.cbar = self.fig.colorbar(im, ax = self.axes )
else :
if self.cbar :
self.fig.clf()
self.axes = self.fig.add_subplot(111)
self.cbar = False
self.axes.imshow(frame, **kwargs)
if supLines is not None :
for index, row in supLines.iterrows():
linekwargs = row.to_dict()
linekwargs.pop("x",None)
linekwargs.pop("y",None)
stop = linekwargs.pop("stop",None)
start = linekwargs.pop("start",None)
self.axes.plot( row["x"][start:stop] , row["y"][start:stop] , **linekwargs )
self.axes.set_aspect('equal')
if not self.Spines :
self.axes.axis("off")
# self.axes.spines['right'].set_visible(False)
# self.axes.spines['top'].set_visible(False)
# self.axes.spines['left'].set_visible(False)
# self.axes.spines['bottom'].set_visible(False)
# self.axes.tick_params(axis = 'both', which = 'both,',left=False, bottom=False, labelleft = False, labelbottom=False)
self.draw()
def write3Dfigure(self,X, Y, Z,**kwargs):
if 'Zmin' in kwargs :
Zmin = kwargs.get('Zmin')
kwargs.pop('Zmin')
else : Zmin = False
if 'Zmax' in kwargs :
Zmax = kwargs.get('Zmax')
kwargs.pop('Zmax')
else : Zmax = False
if self.cbarON :
if self.cbar :
self.cbar.remove()
surf = self.axes.plot_surface(X, Y, Z, **kwargs)
self.cbar = self.fig.colorbar(surf, ax = self.axes, shrink=0.5, aspect=5)
else :
if self.cbar :
self.fig.clf()
self.axes = self.fig.add_subplot(111, projection = '3d')
self.cbar = False
surf = self.axes.plot_surface(X, Y, Z, **kwargs)
if self.Spines :
if Zmin and Zmax:
self.axes.set_zlim(Zmin,Zmax)
else :
self.axes.axis("off")
self.draw()
def update_figure(self, Data, **kwargs):
self.axes.cla()
dtype = self.identifyDtype(Data)
if dtype == 'multi' :
for key in Data:
Value = Data[key]
sitem = Value[0]
sdtype = Value[1]
sdkwargs = Value[2]
self.formatDatatype(sitem,sdtype,sdkwargs)
else :
self.formatDatatype(Data,dtype,**kwargs)
class TestApp(QtWidgets.QWidget):
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
self.setWindowTitle("application main window")
self.file_menu = QtWidgets.QMenu('&File', self)
self.file_menu.addAction('&Quit', self.fileQuit,
QtCore.Qt.CTRL + QtCore.Qt.Key_Q)
#self.menuBar().addMenu(self.file_menu)
# self.help_menu = QtWidgets.QMenu('&Help', self)
# self.menuBar().addSeparator()
# self.menuBar().addMenu(self.help_menu)
# self.help_menu.addAction('&About', self.about)
self.canvas = DynamicCanvas(self)
self.canvas.update_figure( np.random.random((50,50)) )
#self.setCentralWidget(self.canvas)
#self.addToolBar(NavigationToolbar(self.canvas, self))
self.runButton1 = QtWidgets.QPushButton('End')
self.process = QtCore.QProcess(self)
self.process.readyRead.connect(self.dataReady)
self.runButton1.clicked.connect(self.process.kill)
l = QtWidgets.QGridLayout(self)
self.SupSlider = SuperSlider( minimum = -100, maximum = 100, start = 0)
l.addWidget(self.canvas,0,0,1,1)
l.addWidget(self.SupSlider,1,0,1,1)
l.setSpacing(2)
l.setContentsMargins(2,2,2,2)
self.setLayout(l)
QApplication.setStyle(QStyleFactory.create('Fusion'))
def fileQuit(self):
self.close()
def closeEvent(self, ce):
self.fileQuit()
def about(self):
QtWidgets.QMessageBox.about(self, "About", "tg")
import threading
class LoadVideo(threading.Thread):
#LoadIntermediateFrame = pyqtSignal()
#LoadFullFile = pyqtSignal()
def __init__(self):
super(LoadVideo, self).__init__()
self.qApp = QtWidgets.QApplication(sys.argv)
self.aw = TestApp()
self.data = None
self.daemon = True
self.start()
def run(self):
pass
#self.aw.show()
#self.qApp.exec()
#self.qApp = QtWidgets.QApplication(sys.argv)
#self.aw = TestApp()
#self.aw.setWindowTitle("%s" % sys.argv[0])
#sys.exit(self.qApp.exec())
#self.LoadFullFile.emit()
class data_update_checker(QThread):
pass
class interactive_plot():
def __init__(data = None, **kwargs):
self.data = data
run = kwargs.get("run",True)
self.thread = None
self.appname = kwargs.get(appname,None)
if run :
self.run
def run(self,**kwargs):
try :
if self.data is None :
raise ValueError("Can't start GUI without setting data. Either specify data in arguments to interactive_plot or use add_data method before calling run")
if self.thread is not None and kwargs.get(exit,False):
self.thread.stop()
self.thread.join()
#del self.thread
self.thread = None
kwargs.pop("exit",None)
if self.thread is None or not self.thread.is_alive() :
#del self.thread
self.thread = QappThread(self.data, appname = self.appname)
else :
print("The application is still running. If you want to quit it, use kwarg exit = True when calling run")
except Exception as e:
print(e)
def add_data(self,data,**kwargs):
pass
class QappThread(threading.Thread):
def __init__(data, **kwargs ):
appname = kwargs.get(appname,None)
kwargs.pop("appname",None)
if appname is None :
self.application = "TestApp"
else :
self.application = appname
self.kwargs = kwargs
self.data = data
self.returned = None
def run(self):
super(LoadVideo, self).__init__()
#self.app = QtWidgets.QApplication(sys.argv)
self.dialog = eval( self.application+"(self.data,**self.kwargs)" )
self.daemon = True
self.dialog.show()
#self.dialog.exec()
self.returned = dialog.Save()
def TestRun():
global aw
qApp = QtWidgets.QApplication(sys.argv)
aw = TestApp()
aw.show()
sys.exit(qApp.exec_())
if __name__ == "__main__":
#thrd = threading.Thread(target=TestRun)
thrd = LoadVideo()
#thrd.daemon = True
#thrd.start()
#global aw
#aw.canvas.update_figure( np.random.random((100,100)) )
# progname = os.path.basename(sys.argv[0])
# qApp = QtWidgets.QApplication(sys.argv)
# aw = TestApp()
# aw.setWindowTitle("%s" % progname)
# aw.show()
# sys.exit(qApp.exec_())
|
multi_process_runner_test.py
|
# 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 `multi_process_runner`."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import ctypes
import json
import os
import sys
import threading
import time
import unittest
from absl import logging
from tensorflow.python.distribute import multi_process_runner
from tensorflow.python.distribute import multi_worker_test_base
from tensorflow.python.eager import test
def proc_func_that_adds_task_type_in_return_data():
return multi_worker_test_base.get_task_type()
def proc_func_that_errors():
raise ValueError('This is an error.')
def proc_func_that_does_nothing():
pass
def proc_func_that_adds_simple_return_data():
return 'dummy_data'
def proc_func_that_returns_args_and_kwargs(*args, **kwargs):
return list(args) + list(kwargs.items())
def proc_func_with_barrier():
return multi_process_runner.barrier()
def proc_func_that_returns_pid():
return os.getpid()
V = None
def proc_func_that_sets_global(val):
global V
old_val = V
V = val
return old_val
class MultiProcessRunnerTest(test.TestCase):
def _worker_idx(self):
config_task = json.loads(os.environ['TF_CONFIG'])['task']
return config_task['index']
def test_multi_process_runner(self):
mpr_result = multi_process_runner.run(
proc_func_that_adds_task_type_in_return_data,
multi_worker_test_base.create_cluster_spec(
num_workers=2, num_ps=3, has_eval=1))
job_count_dict = {'worker': 2, 'ps': 3, 'evaluator': 1}
for data in mpr_result.return_value:
job_count_dict[data] -= 1
self.assertEqual(job_count_dict['worker'], 0)
self.assertEqual(job_count_dict['ps'], 0)
self.assertEqual(job_count_dict['evaluator'], 0)
def test_multi_process_runner_error_propagates_from_subprocesses(self):
runner = multi_process_runner.MultiProcessRunner(
proc_func_that_errors,
multi_worker_test_base.create_cluster_spec(num_workers=1, num_ps=1),
max_run_time=20)
runner.start()
with self.assertRaisesRegex(ValueError, 'This is an error.'):
runner.join()
def test_multi_process_runner_queue_emptied_between_runs(self):
cluster_spec = multi_worker_test_base.create_cluster_spec(num_workers=2)
return_value = multi_process_runner.run(
proc_func_that_adds_simple_return_data, cluster_spec).return_value
self.assertTrue(return_value)
self.assertEqual(return_value[0], 'dummy_data')
self.assertEqual(return_value[1], 'dummy_data')
return_value = multi_process_runner.run(proc_func_that_does_nothing,
cluster_spec).return_value
self.assertFalse(return_value)
def test_multi_process_runner_args_passed_correctly(self):
return_value = multi_process_runner.run(
proc_func_that_returns_args_and_kwargs,
multi_worker_test_base.create_cluster_spec(num_workers=1),
args=('a', 'b'),
kwargs={
'c_k': 'c_v'
}).return_value
self.assertEqual(return_value[0][0], 'a')
self.assertEqual(return_value[0][1], 'b')
self.assertEqual(return_value[0][2], ('c_k', 'c_v'))
def test_stdout_captured(self):
def simple_print_func():
print('This is something printed.', flush=True)
return 'This is returned data.'
mpr_result = multi_process_runner.run(
simple_print_func,
multi_worker_test_base.create_cluster_spec(num_workers=2),
list_stdout=True)
std_stream_results = mpr_result.stdout
return_value = mpr_result.return_value
self.assertIn('[worker-0]: This is something printed.\n',
std_stream_results)
self.assertIn('[worker-1]: This is something printed.\n',
std_stream_results)
self.assertIn('This is returned data.', return_value)
def test_termination(self):
def proc_func():
for i in range(0, 10):
print(
'index {}, iteration {}'.format(self._worker_idx(), i), flush=True)
time.sleep(5)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(num_workers=2),
list_stdout=True)
mpr.start()
time.sleep(5)
mpr.terminate('worker', 0)
std_stream_results = mpr.join().stdout
# Worker 0 is terminated in the middle, so it should not have iteration 9
# printed.
self.assertIn('[worker-0]: index 0, iteration 0\n', std_stream_results)
self.assertNotIn('[worker-0]: index 0, iteration 9\n',
std_stream_results)
self.assertIn('[worker-1]: index 1, iteration 0\n', std_stream_results)
self.assertIn('[worker-1]: index 1, iteration 9\n', std_stream_results)
def test_termination_and_start_single_process(self):
def proc_func():
for i in range(0, 10):
print(
'index {}, iteration {}'.format(self._worker_idx(), i), flush=True)
time.sleep(1)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(num_workers=2),
list_stdout=True)
mpr.start()
time.sleep(3)
mpr.terminate('worker', 0)
mpr.start_single_process('worker', 0)
std_stream_results = mpr.join().stdout
# Worker 0 is terminated in the middle, but a new worker 0 is added, so it
# should still have iteration 9 printed. Moreover, iteration 0 of worker 0
# should happen twice.
self.assertLen(
[s for s in std_stream_results if 'index 0, iteration 0' in s], 2)
self.assertIn('[worker-0]: index 0, iteration 9\n', std_stream_results)
self.assertIn('[worker-1]: index 1, iteration 0\n', std_stream_results)
self.assertIn('[worker-1]: index 1, iteration 9\n', std_stream_results)
def test_streaming(self):
def proc_func():
for i in range(5):
logging.info('(logging) %s-%d, i: %d',
multi_worker_test_base.get_task_type(), self._worker_idx(),
i)
print(
'(print) {}-{}, i: {}'.format(
multi_worker_test_base.get_task_type(), self._worker_idx(), i),
flush=True)
time.sleep(1)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=2, num_ps=2, has_eval=True),
list_stdout=True)
mpr._dependence_on_chief = False
mpr.start()
mpr.start_single_process('worker', 2)
mpr.start_single_process('ps', 2)
mpr_result = mpr.join()
list_to_assert = mpr_result.stdout
for job in ['chief', 'evaluator']:
for iteration in range(5):
self.assertTrue(
any('(logging) {}-0, i: {}'.format(job, iteration) in line
for line in list_to_assert))
self.assertTrue(
any('(print) {}-0, i: {}'.format(job, iteration) in line
for line in list_to_assert))
for job in ['worker', 'ps']:
for iteration in range(5):
for task in range(3):
self.assertTrue(
any('(logging) {}-{}, i: {}'.format(job, task, iteration) in line
for line in list_to_assert))
self.assertTrue(
any('(print) {}-{}, i: {}'.format(job, task, iteration) in line
for line in list_to_assert))
task = 3
self.assertFalse(
any('(logging) {}-{}, i: {}'.format(job, task, iteration) in line
for line in list_to_assert))
self.assertFalse(
any('(print) {}-{}, i: {}'.format(job, task, iteration) in line
for line in list_to_assert))
def test_start_in_process_as(self):
def proc_func():
for i in range(5):
logging.info('%s-%d, i: %d', multi_worker_test_base.get_task_type(),
self._worker_idx(), i)
time.sleep(1)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=1),
list_stdout=True)
def eval_func():
time.sleep(1)
mpr.start_single_process(task_type='evaluator', task_id=0)
eval_thread = threading.Thread(target=eval_func)
eval_thread.start()
mpr.start_in_process_as(as_task_type='chief', as_task_id=0)
eval_thread.join()
list_to_assert = mpr.join().stdout
for job in ['worker', 'evaluator']:
for iteration in range(5):
self.assertTrue(
any('{}-0, i: {}'.format(job, iteration) in line
for line in list_to_assert))
def test_terminate_all_does_not_ignore_error(self):
mpr = multi_process_runner.MultiProcessRunner(
proc_func_that_errors,
multi_worker_test_base.create_cluster_spec(num_workers=2),
list_stdout=True)
mpr.start()
time.sleep(60)
mpr.terminate_all()
with self.assertRaisesRegex(ValueError, 'This is an error.'):
mpr.join()
def test_barrier(self):
multi_process_runner.run(
proc_func_with_barrier,
cluster_spec=multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=1),
)
def test_barrier_called_in_main_process(self):
with self.assertRaises(ValueError):
multi_process_runner.barrier()
def test_stdout_available_when_timeout(self):
def proc_func():
logging.info('something printed')
time.sleep(10000) # Intentionally make the test timeout.
with self.assertRaises(multi_process_runner.SubprocessTimeoutError) as cm:
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(num_workers=1),
list_stdout=True)
mpr.start()
mpr.join(timeout=60)
mpr.terminate_all()
list_to_assert = cm.exception.mpr_result.stdout
self.assertTrue(
any('something printed' in line for line in list_to_assert))
def test_seg_fault_raises_error(self):
def proc_func_expected_to_seg_fault():
ctypes.string_at(0) # Intentionally made seg fault.
with self.assertRaises(
multi_process_runner.UnexpectedSubprocessExitError) as cm:
multi_process_runner.run(
proc_func_expected_to_seg_fault,
multi_worker_test_base.create_cluster_spec(num_workers=1),
list_stdout=True)
self.assertIn('Subprocess worker-0 exited with exit code',
str(cm.exception))
list_to_assert = cm.exception.mpr_result.stdout
self.assertTrue(any('SIGSEGV' in line for line in list_to_assert))
def test_seg_fault_in_chief_raises_error(self):
def proc_func_expected_to_seg_fault():
if multi_worker_test_base.get_task_type() == 'worker':
time.sleep(10000)
ctypes.string_at(0) # Intentionally made seg fault.
with self.assertRaises(
multi_process_runner.UnexpectedSubprocessExitError) as cm:
multi_process_runner.run(
proc_func_expected_to_seg_fault,
multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=1),
list_stdout=True)
self.assertIn('Subprocess chief-0 exited with exit code',
str(cm.exception))
list_to_assert = cm.exception.mpr_result.stdout
self.assertTrue(any('SIGSEGV' in line for line in list_to_assert))
def test_exit_code_is_reported_by_chief_subprocess(self):
def proc_func_expected_to_exit_with_20():
if multi_worker_test_base.get_task_type() == 'worker':
time.sleep(10000)
sys.exit(20)
mpr = multi_process_runner.MultiProcessRunner(
proc_func_expected_to_exit_with_20,
multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=1))
mpr.start()
with self.assertRaisesRegex(
multi_process_runner.UnexpectedSubprocessExitError,
'Subprocess chief-0 exited with exit code 20'):
mpr.join()
def test_exit_code_is_reported_by_subprocess(self):
def proc_func_expected_to_exit_with_10():
sys.exit(10)
mpr = multi_process_runner.MultiProcessRunner(
proc_func_expected_to_exit_with_10,
multi_worker_test_base.create_cluster_spec(num_workers=1))
mpr.start()
with self.assertRaisesRegex(
multi_process_runner.UnexpectedSubprocessExitError,
'Subprocess worker-0 exited with exit code 10'):
mpr.join()
def test_auto_restart(self):
def proc_func(counter):
counter.value += 1
if counter.value == 1:
raise ValueError
manager = multi_process_runner.manager()
counter = manager.Value(int, 0)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(num_workers=1),
args=(counter,),
auto_restart=True)
mpr.start()
mpr.join()
self.assertEqual(counter.value, 2)
def test_auto_restart_and_timeout(self):
def proc_func():
time.sleep(1)
raise ValueError
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(num_workers=1),
auto_restart=True)
mpr.start()
with self.assertRaises(ValueError):
mpr.join(timeout=10)
def test_auto_restart_and_chief(self):
# If the chief has exited with zero exit code, auto restart should stop
# restarting other tasks even if they fail.
def proc_func():
time.sleep(1)
if multi_worker_test_base.get_task_type() != 'chief':
raise ValueError
manager = multi_process_runner.manager()
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=1),
auto_restart=True)
mpr.start()
with self.assertRaises(ValueError):
mpr.join(timeout=10)
def test_auto_restart_failure_immediate_after_restart(self):
# Test the case when worker-0 fails immediately after worker-1 restarts.
def proc_func():
time.sleep(5)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(
has_chief=False, num_workers=2),
auto_restart=True)
mpr.start()
pid = mpr.get_process_id('worker', 1)
mpr.terminate('worker', 1)
while mpr.get_process_id('worker', 1) == pid:
time.sleep(0.1)
mpr.terminate('worker', 0)
mpr.join(timeout=20)
def test_auto_restart_terminate(self):
# Tasks terminated by the user should also be restarted.
def proc_func(counter):
counter.value += 1
if counter.value == 1:
time.sleep(100)
manager = multi_process_runner.manager()
counter = manager.Value(int, 0)
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(
has_chief=False, num_workers=1),
args=(counter,),
auto_restart=True)
mpr.start()
time.sleep(3)
mpr.terminate('worker', 0)
mpr.join(timeout=20)
self.assertEqual(counter.value, 2)
def test_error_reporting_overrides_timeout_reporting(self):
def proc_func():
if self._worker_idx() == 1:
time.sleep(10000)
raise ValueError('Worker 0 errored')
mpr = multi_process_runner.MultiProcessRunner(
proc_func,
multi_worker_test_base.create_cluster_spec(num_workers=2))
mpr.start()
with self.assertRaisesRegex(
ValueError,
'Worker 0 errored'):
mpr.join(timeout=20)
class MultiProcessPoolRunnerTest(test.TestCase):
def test_same_process_across_runs(self):
cluster_spec = multi_worker_test_base.create_cluster_spec(num_workers=2)
runner = multi_process_runner.MultiProcessPoolRunner(cluster_spec)
pid = runner.run(proc_func_that_returns_pid)
for _ in range(3):
self.assertAllEqual(runner.run(proc_func_that_returns_pid), pid)
def test_exceptions_in_sub_process(self):
cluster_spec = multi_worker_test_base.create_cluster_spec(num_workers=2)
runner = multi_process_runner.MultiProcessPoolRunner(cluster_spec)
pid = runner.run(proc_func_that_returns_pid)
with self.assertRaisesRegex(ValueError, 'This is an error.'):
runner.run(proc_func_that_errors)
self.assertAllEqual(runner.run(proc_func_that_returns_pid), pid)
def test_tf_config(self):
cluster_spec = multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=2)
runner = multi_process_runner.MultiProcessPoolRunner(cluster_spec)
result = runner.run(proc_func_that_adds_task_type_in_return_data)
job_count_dict = {'worker': 2, 'chief': 1}
for data in result:
job_count_dict[data] -= 1
self.assertEqual(job_count_dict['worker'], 0)
self.assertEqual(job_count_dict['chief'], 0)
@unittest.expectedFailure
def test_exception_in_main_process(self):
# When there's an exception in the main process, __del__() is not called.
# This test is to verify MultiProcessPoolRunner can cope with __del__() not
# being called.
cluster_spec = multi_worker_test_base.create_cluster_spec(
has_chief=True, num_workers=2)
runner = multi_process_runner.MultiProcessPoolRunner(cluster_spec)
runner.run(proc_func_that_returns_pid)
raise ValueError('failure')
def test_initializer(self):
cluster_spec = multi_worker_test_base.create_cluster_spec(num_workers=2)
runner = multi_process_runner.MultiProcessPoolRunner(
cluster_spec, initializer=lambda: proc_func_that_sets_global(1))
result = runner.run(proc_func_that_sets_global, args=(2,))
self.assertAllEqual(result, [1, 1])
if __name__ == '__main__':
multi_process_runner.test_main()
|
local_planner.py
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#change
import numpy as np
import rospy
import tf
import math
from nav_msgs.msg import Path
from geometry_msgs.msg import PoseStamped, Twist
from sensor_msgs.msg import LaserScan
from dwa import DWAPlanner
from threading import Lock, Thread
from pynput import keyboard
import time
def limitVal(minV, maxV, v):
if v < minV:
return minV
if v > maxV:
return maxV
return v
class LocalPlanner:
def __init__(self):
self.arrive = 0.2 # standard for arrival self.arrive = 0.1
self.x = 0.0
self.y = 0.0
self.yaw = 0.0
self.vx = 0.0
self.vw = 0.0
# init plan_config for once
self.dwa = DWAPlanner()
self.max_speed = 0.2 # [m/s]
# self.predict_time = 2 # [s]
# self.threshold = self.max_speed * self.predict_time
self.threshold = 1
self.laser_lock = Lock()
self.lock = Lock()
self.path = Path()
self.tf = tf.TransformListener()
# get path & initPlaning
self.path_sub = rospy.Subscriber('/course_agv/global_path', Path,
self.pathCallback)
# Real
# self.vel_pub = rospy.Publisher('/webService/cmd_vel',
# Twist,
# queue_size=1)
# Sim
self.vel_pub = rospy.Publisher('/webService/cmd_vel',
Twist,
queue_size=1)
# mid_goal pub
self.midpose_pub = rospy.Publisher('/course_agv/mid_goal',
PoseStamped,
queue_size=1)
# get laser & update obstacle
self.laser_sub = rospy.Subscriber('/scan', LaserScan,
self.laserCallback)
# 仿真
# self.laser_sub = rospy.Subscriber('/course_agv/laser/scan', LaserScan,
# self.laserCallback)
self.planner_thread = None
self.listener = keyboard.Listener(on_press=self.on_press)
# self.listener.start()
def on_press(self, key):
if key == keyboard.Key.up:
self.vx = 0.2
self.vw = 0.0
elif key == keyboard.Key.down:
self.vx = -0.2
self.vw = 0.0
elif key == keyboard.Key.left:
self.vx = 0.0
self.vw = 1
elif key == keyboard.Key.right:
self.vx = 0.0
self.vw = -1
elif key == keyboard.Key.space:
self.vx = 0.0
self.vw = 0
# print("v, w: ", self.vx, self.vw)
self.publishVel(zero=False)
# update pose & update goal
# self.plan_goal (in the robot frame)
# self.goal_dis (distance from the final goal)
def updateGlobalPose(self):
try:
# Real
self.tf.waitForTransform("/map", "/ekf_location", rospy.Time(),
rospy.Duration(4.0))
(self.trans, self.rot) = self.tf.lookupTransform('/map', '/ekf_location', rospy.Time(0))
# Sim
# self.tf.waitForTransform("/map", "/robot_base", rospy.Time(),
# rospy.Duration(4.0))
# (self.trans, self.rot) = self.tf.lookupTransform('/map', '/robot_base', rospy.Time(0))
except (tf.LookupException, tf.ConnectivityException,
tf.ExtrapolationException):
print("get tf error!")
euler = tf.transformations.euler_from_quaternion(self.rot)
roll, pitch, yaw = euler[0], euler[1], euler[2]
self.x = self.trans[0]
self.y = self.trans[1]
self.yaw = yaw
# get nearest path node
ind = self.goal_index
# self.goal_index = len(self.path.poses) - 1
while ind < len(self.path.poses):
p = self.path.poses[ind].pose.position
dis = math.hypot(p.x - self.x, p.y - self.y)
if dis < self.threshold:
self.goal_index = ind
ind += 1
goal = self.path.poses[self.goal_index]
self.midpose_pub.publish(goal)
# Real
lgoal = self.tf.transformPose("/ekf_location", goal)
# Sim
# lgoal = self.tf.transformPose("/robot_base", goal)
self.plan_goal = np.array(
[lgoal.pose.position.x, lgoal.pose.position.y])
self.goal_dis = math.hypot(
self.x - self.path.poses[-1].pose.position.x,
self.y - self.path.poses[-1].pose.position.y)
# get obstacle (in robot frame)
def laserCallback(self, msg):
# print("get laser msg!!!!",msg)
self.laser_lock.acquire()
# preprocess
# print("i am here!")
self.ob = [[100, 100]]
angle_min = msg.angle_min
angle_increment = msg.angle_increment
for i in range(len(msg.ranges)):
a = angle_min + angle_increment * i
r = msg.ranges[i]
if r > 0.04 and r < self.threshold:
self.ob.append([math.cos(a) * r, math.sin(a) * r])
self.laser_lock.release()
# update ob
def updateObstacle(self):
self.laser_lock.acquire()
self.plan_ob = []
self.plan_ob = np.array(self.ob)
self.laser_lock.release()
# get path & initPlaning
def pathCallback(self, msg):
# print("get path msg!!!!!",msg)
self.path = msg
self.lock.acquire()
self.initPlanning()
self.lock.release()
# if self.planner_thread == None:
# self.planner_thread = Thread(target=self.planThreadFunc)
# self.planner_thread.start()
# pass
self.planThreadFunc()
def initPlanning(self):
self.goal_index = 0
self.vx = 0.0
self.vw = 0.0
self.dis = 99999
self.updateGlobalPose()
cx = []
cy = []
for pose in self.path.poses:
cx.append(pose.pose.position.x)
cy.append(pose.pose.position.y)
# self.goal = np.array([cx[0], cy[0]])
self.plan_cx, self.plan_cy = np.array(cx), np.array(cy)
self.plan_goal = np.array([cx[-1], cy[-1]])
#self.plan_x = np.array([self.x, self.y, self.yaw, self.vx, self.vw])
self.plan_x = np.array([0.0, 0.0, 0.0, self.vx, self.vw])
def planThreadFunc(self):
print("running planning thread!!")
while True:
self.lock.acquire()
self.planOnce()
self.lock.release()
if self.goal_dis < self.arrive:
print("arrive goal!")
# print(self.goal_dis)
# print(self.arrive)
break
time.sleep(0.01)
# time.sleep(10)
print("exit planning thread!!")
self.lock.acquire()
self.publishVel(True)
self.lock.release()
# self.planning_thread = None
pass
def planOnce(self):
self.updateGlobalPose()
# Update plan_x [x(m), y(m), yaw(rad), v(m/s), omega(rad/s)]
self.plan_x = np.array([0.0, 0.0, 0.0, self.vx, self.vw])
# 仿真(上帝视角可以得知坐标和偏角)
# self.plan_x = [self.x, self.y, self.yaw, self.vx, self.vw]
# Update obstacle
self.updateObstacle()
# print self.plan_x
# print self.plan_goal
# print self.plan_ob
u = self.dwa.plan(self.plan_x, self.plan_goal, self.plan_ob)
alpha = 0.5
self.vx = u[0] * alpha + self.vx * (1 - alpha)
self.vw = u[1] * alpha + self.vw * (1 - alpha)
self.vx = max(min(u[0], self.max_speed), -self.max_speed)
self.vw = max(min(u[1], 5), -5)
print("v, w: ", self.vx, self.vw)
# self.vx, self.vw = 0, 0
# print("mdbg; ",u)
self.publishVel(zero=False)
pass
# send v,w
def publishVel(self, zero=False):
if zero:
self.vx = 0
self.vw = 0
cmd = Twist()
cmd.linear.x = self.vx
cmd.angular.z = self.vw
self.vel_pub.publish(cmd)
def main():
rospy.init_node('path_Planning')
lp = LocalPlanner()
rospy.spin()
if __name__ == '__main__':
main()
|
run.py
|
# export PYTHONPATH=/usr/local/lib/python2.7/site-packages:$PYTHONPATH
import os
from flask import Flask, request, redirect, url_for, render_template, send_file, jsonify
from werkzeug.utils import secure_filename
import subprocess
import SimpleHTTPServer
import SocketServer
import webbrowser
from threading import Thread
UPLOAD_FOLDER = 'uploads/images/'
ALLOWED_EXTENSIONS = set(['png', 'jpg', 'jpeg'])
app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
def allowed_file(filename):
return '.' in filename and \
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
print 'starting uploading'
# delete
old_files = os.listdir(app.config['UPLOAD_FOLDER'])
for file in old_files:
lower_name = file.lower()
if lower_name.endswith(".jpg") or lower_name.endswith('png') or lower_name.endswith('jpeg'):
os.remove(os.path.join(app.config['UPLOAD_FOLDER'], file))
# check if the post request has the file part
if 'file' not in request.files:
response = jsonify(message='No file part')
response.status_code = 422
return response
uploaded_files = request.files.getlist('file')
print len(uploaded_files)
if len(uploaded_files) == 0:
return jsonify(message='no files uploaded')
# save new
for file in uploaded_files:
if file and file.filename != '' and allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
print 'saved ' + file.filename
sfm_and_serve('uploads')
return "Done"
return render_template('index.html')
def sfm_and_serve(dir):
subprocess.call(['bin/opensfm_run_all', dir])
thread = Thread(target=viz_server, args=(dir,))
thread.start()
thread.join(30)
print 'viz thread finished'
def viz_server(dir):
PORT = 8000
Handler = SimpleHTTPServer.SimpleHTTPRequestHandler
httpd = SocketServer.TCPServer(("", PORT), Handler)
print "serving at port", PORT
print 'http://localhost:8000/viewer/reconstruction.html#file=/' + dir + '/reconstruction.meshed.json'
httpd.serve_forever()
webbrowser.open_new_tab('http://localhost:8000/viewer/reconstruction.html#file=/' + dir + '/reconstruction.meshed.json')
|
test_pubsub.py
|
# -*- coding: utf-8 -*-
# python std lib
from __future__ import unicode_literals
import threading
import time
# rediscluster imports
from rediscluster.client import RedisCluster
# 3rd party imports
import pytest
# import redis
from redis import Redis
from redis.exceptions import ConnectionError
from redis._compat import basestring, unichr
from .conftest import _get_client
from .conftest import skip_if_server_version_lt, skip_if_redis_py_version_lt
def wait_for_message(pubsub, timeout=0.5, ignore_subscribe_messages=False):
now = time.time()
timeout = now + timeout
while now < timeout:
message = pubsub.get_message(
ignore_subscribe_messages=ignore_subscribe_messages)
if message is not None:
return message
time.sleep(0.01)
now = time.time()
return None
def make_message(type, channel, data, pattern=None):
return {
'type': type,
'pattern': pattern and pattern.encode('utf-8') or None,
'channel': channel and channel.encode('utf-8') or None,
'data': data.encode('utf-8') if isinstance(data, basestring) else data
}
def make_subscribe_test_data(pubsub, type):
if type == 'channel':
return {
'p': pubsub,
'sub_type': 'subscribe',
'unsub_type': 'unsubscribe',
'sub_func': pubsub.subscribe,
'unsub_func': pubsub.unsubscribe,
'keys': ['foo', 'bar', 'uni' + unichr(4456) + 'code']
}
elif type == 'pattern':
return {
'p': pubsub,
'sub_type': 'psubscribe',
'unsub_type': 'punsubscribe',
'sub_func': pubsub.psubscribe,
'unsub_func': pubsub.punsubscribe,
'keys': ['f*', 'b*', 'uni' + unichr(4456) + '*']
}
assert False, 'invalid subscribe type: {0}'.format(type)
class TestPubSubSubscribeUnsubscribe(object):
def _test_subscribe_unsubscribe(self, p, sub_type, unsub_type, sub_func, unsub_func, keys):
for key in keys:
assert sub_func(key) is None
# should be a message for each channel/pattern we just subscribed to
for i, key in enumerate(keys):
assert wait_for_message(p) == make_message(sub_type, key, i + 1)
for key in keys:
assert unsub_func(key) is None
# should be a message for each channel/pattern we just unsubscribed
# from
for i, key in enumerate(keys):
i = len(keys) - 1 - i
assert wait_for_message(p) == make_message(unsub_type, key, i)
def test_channel_subscribe_unsubscribe(self, r):
kwargs = make_subscribe_test_data(r.pubsub(), 'channel')
self._test_subscribe_unsubscribe(**kwargs)
def test_pattern_subscribe_unsubscribe(self, r):
kwargs = make_subscribe_test_data(r.pubsub(), 'pattern')
self._test_subscribe_unsubscribe(**kwargs)
def _test_resubscribe_on_reconnection(self, p, sub_type, sub_func, keys, *args, **kwargs):
for key in keys:
assert sub_func(key) is None
# should be a message for each channel/pattern we just subscribed to
for i, key in enumerate(keys):
assert wait_for_message(p) == make_message(sub_type, key, i + 1)
# manually disconnect
p.connection.disconnect()
# calling get_message again reconnects and resubscribes
# note, we may not re-subscribe to channels in exactly the same order
# so we have to do some extra checks to make sure we got them all
messages = []
for i, _ in enumerate(keys):
messages.append(wait_for_message(p))
unique_channels = set()
assert len(messages) == len(keys)
for i, message in enumerate(messages):
assert message['type'] == sub_type
assert message['data'] == i + 1
assert isinstance(message['channel'], bytes)
channel = message['channel'].decode('utf-8')
unique_channels.add(channel)
assert len(unique_channels) == len(keys)
for channel in unique_channels:
assert channel in keys
def test_resubscribe_to_channels_on_reconnection(self, r):
kwargs = make_subscribe_test_data(r.pubsub(), 'channel')
self._test_resubscribe_on_reconnection(**kwargs)
def test_resubscribe_to_patterns_on_reconnection(self, r):
kwargs = make_subscribe_test_data(r.pubsub(), 'pattern')
self._test_resubscribe_on_reconnection(**kwargs)
def _test_subscribed_property(self, p, sub_type, unsub_type, sub_func, unsub_func, keys):
assert p.subscribed is False
sub_func(keys[0])
# we're now subscribed even though we haven't processed the
# reply from the server just yet
assert p.subscribed is True
assert wait_for_message(p) == make_message(sub_type, keys[0], 1)
# we're still subscribed
assert p.subscribed is True
# unsubscribe from all channels
unsub_func()
# we're still technically subscribed until we process the
# response messages from the server
assert p.subscribed is True
assert wait_for_message(p) == make_message(unsub_type, keys[0], 0)
# now we're no longer subscribed as no more messages can be delivered
# to any channels we were listening to
assert p.subscribed is False
# subscribing again flips the flag back
sub_func(keys[0])
assert p.subscribed is True
assert wait_for_message(p) == make_message(sub_type, keys[0], 1)
# unsubscribe again
unsub_func()
assert p.subscribed is True
# subscribe to another channel before reading the unsubscribe response
sub_func(keys[1])
assert p.subscribed is True
# read the unsubscribe for key1
assert wait_for_message(p) == make_message(unsub_type, keys[0], 0)
# we're still subscribed to key2, so subscribed should still be True
assert p.subscribed is True
# read the key2 subscribe message
assert wait_for_message(p) == make_message(sub_type, keys[1], 1)
unsub_func()
# haven't read the message yet, so we're still subscribed
assert p.subscribed is True
assert wait_for_message(p) == make_message(unsub_type, keys[1], 0)
# now we're finally unsubscribed
assert p.subscribed is False
def test_subscribe_property_with_channels(self, r):
kwargs = make_subscribe_test_data(r.pubsub(), 'channel')
self._test_subscribed_property(**kwargs)
def test_subscribe_property_with_patterns(self, r):
kwargs = make_subscribe_test_data(r.pubsub(), 'pattern')
self._test_subscribed_property(**kwargs)
def test_ignore_all_subscribe_messages(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
checks = (
(p.subscribe, 'foo'),
(p.unsubscribe, 'foo'),
# (p.psubscribe, 'f*'),
# (p.punsubscribe, 'f*'),
)
assert p.subscribed is False
for func, channel in checks:
assert func(channel) is None
assert p.subscribed is True
assert wait_for_message(p) is None
assert p.subscribed is False
def test_ignore_individual_subscribe_messages(self, r):
p = r.pubsub()
checks = (
(p.subscribe, 'foo'),
(p.unsubscribe, 'foo'),
# (p.psubscribe, 'f*'),
# (p.punsubscribe, 'f*'),
)
assert p.subscribed is False
for func, channel in checks:
assert func(channel) is None
assert p.subscribed is True
message = wait_for_message(p, ignore_subscribe_messages=True)
assert message is None
assert p.subscribed is False
class TestPubSubMessages(object):
"""
Bug: Currently in cluster mode publish command will behave different then in
standard/non cluster mode. See (docs/Pubsub.md) for details.
Currently Redis instances will be used to test pubsub because they
are easier to work with.
"""
def get_strict_redis_node(self, port, host="127.0.0.1"):
return Redis(port=port, host=host)
def setup_method(self, *args):
self.message = None
def message_handler(self, message):
self.message = message
def test_published_message_to_channel(self):
node = self.get_strict_redis_node(7000)
p = node.pubsub(ignore_subscribe_messages=True)
p.subscribe('foo')
assert node.publish('foo', 'test message') == 1
message = wait_for_message(p)
assert isinstance(message, dict)
assert message == make_message('message', 'foo', 'test message')
# Cleanup pubsub connections
p.close()
@pytest.mark.xfail(reason="This test is buggy and fails randomly")
def test_publish_message_to_channel_other_server(self):
"""
Test that pubsub still works across the cluster on different nodes
"""
node_subscriber = self.get_strict_redis_node(7000)
p = node_subscriber.pubsub(ignore_subscribe_messages=True)
p.subscribe('foo')
node_sender = self.get_strict_redis_node(7001)
# This should return 0 because of no connected clients to this server.
assert node_sender.publish('foo', 'test message') == 0
message = wait_for_message(p)
assert isinstance(message, dict)
assert message == make_message('message', 'foo', 'test message')
# Cleanup pubsub connections
p.close()
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_published_message_to_pattern(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.subscribe('foo')
p.psubscribe('f*')
# 1 to pattern, 1 to channel
assert r.publish('foo', 'test message') == 2
message1 = wait_for_message(p)
message2 = wait_for_message(p)
assert isinstance(message1, dict)
assert isinstance(message2, dict)
expected = [
make_message('message', 'foo', 'test message'),
make_message('pmessage', 'foo', 'test message', pattern='f*')
]
assert message1 in expected
assert message2 in expected
assert message1 != message2
def test_channel_message_handler(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.subscribe(foo=self.message_handler)
assert r.publish('foo', 'test message') == 1
assert wait_for_message(p) is None
assert self.message == make_message('message', 'foo', 'test message')
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_pattern_message_handler(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.psubscribe(**{'f*': self.message_handler})
assert r.publish('foo', 'test message') == 1
assert wait_for_message(p) is None
assert self.message == make_message('pmessage', 'foo', 'test message',
pattern='f*')
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_unicode_channel_message_handler(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
channel = 'uni' + unichr(4456) + 'code'
channels = {channel: self.message_handler}
print(channels)
p.subscribe(**channels)
assert r.publish(channel, 'test message') == 1
assert wait_for_message(p) is None
assert self.message == make_message('message', channel, 'test message')
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_unicode_pattern_message_handler(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
pattern = 'uni' + unichr(4456) + '*'
channel = 'uni' + unichr(4456) + 'code'
p.psubscribe(**{pattern: self.message_handler})
assert r.publish(channel, 'test message') == 1
assert wait_for_message(p) is None
assert self.message == make_message('pmessage', channel,
'test message', pattern=pattern)
class TestPubSubAutoDecoding(object):
"These tests only validate that we get unicode values back"
channel = 'uni' + unichr(4456) + 'code'
pattern = 'uni' + unichr(4456) + '*'
data = 'abc' + unichr(4458) + '123'
def make_message(self, type, channel, data, pattern=None):
return {
'type': type,
'channel': channel,
'pattern': pattern,
'data': data
}
def setup_method(self, *args):
self.message = None
def message_handler(self, message):
self.message = message
def test_channel_subscribe_unsubscribe(self, o):
p = o.pubsub()
p.subscribe(self.channel)
assert wait_for_message(p) == self.make_message('subscribe',
self.channel, 1)
p.unsubscribe(self.channel)
assert wait_for_message(p) == self.make_message('unsubscribe',
self.channel, 0)
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_pattern_subscribe_unsubscribe(self, o):
p = o.pubsub()
p.psubscribe(self.pattern)
assert wait_for_message(p) == self.make_message('psubscribe',
self.pattern, 1)
p.punsubscribe(self.pattern)
assert wait_for_message(p) == self.make_message('punsubscribe',
self.pattern, 0)
def test_channel_publish(self, o):
p = o.pubsub(ignore_subscribe_messages=True)
p.subscribe(self.channel)
o.publish(self.channel, self.data)
assert wait_for_message(p) == self.make_message('message',
self.channel,
self.data)
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_pattern_publish(self, o):
p = o.pubsub(ignore_subscribe_messages=True)
p.psubscribe(self.pattern)
o.publish(self.channel, self.data)
assert wait_for_message(p) == self.make_message('pmessage',
self.channel,
self.data,
pattern=self.pattern)
def test_channel_message_handler(self, o):
p = o.pubsub(ignore_subscribe_messages=True)
p.subscribe(**{self.channel: self.message_handler})
o.publish(self.channel, self.data)
assert wait_for_message(p) is None
assert self.message == self.make_message('message', self.channel,
self.data)
# test that we reconnected to the correct channel
p.connection.disconnect()
assert wait_for_message(p) is None # should reconnect
new_data = self.data + 'new data'
o.publish(self.channel, new_data)
assert wait_for_message(p) is None
assert self.message == self.make_message('message', self.channel,
new_data)
@pytest.mark.xfail(reason="Pattern pubsub do not work currently")
def test_pattern_message_handler(self, o):
p = o.pubsub(ignore_subscribe_messages=True)
p.psubscribe(**{self.pattern: self.message_handler})
o.publish(self.channel, self.data)
assert wait_for_message(p) is None
assert self.message == self.make_message('pmessage', self.channel,
self.data,
pattern=self.pattern)
# test that we reconnected to the correct pattern
p.connection.disconnect()
assert wait_for_message(p) is None # should reconnect
new_data = self.data + 'new data'
o.publish(self.channel, new_data)
assert wait_for_message(p) is None
assert self.message == self.make_message('pmessage', self.channel,
new_data,
pattern=self.pattern)
class TestPubSubRedisDown(object):
def test_channel_subscribe(self, r):
r = Redis(host='localhost', port=6390)
p = r.pubsub()
with pytest.raises(ConnectionError):
p.subscribe('foo')
def test_pubsub_thread_publish():
"""
This test will never fail but it will still show and be viable to use
and to test the threading capability of the connectionpool and the publish
mechanism.
"""
startup_nodes = [{"host": "127.0.0.1", "port": "7000"}]
r = RedisCluster(
startup_nodes=startup_nodes,
decode_responses=True,
max_connections=16,
max_connections_per_node=16,
)
def t_run(rc):
for i in range(0, 50):
rc.publish('foo', 'bar')
rc.publish('bar', 'foo')
rc.publish('asd', 'dsa')
rc.publish('dsa', 'asd')
rc.publish('qwe', 'bar')
rc.publish('ewq', 'foo')
rc.publish('wer', 'dsa')
rc.publish('rew', 'asd')
# Use this for debugging
# print(rc.connection_pool._available_connections)
# print(rc.connection_pool._in_use_connections)
# print(rc.connection_pool._created_connections)
try:
threads = []
for i in range(10):
t = threading.Thread(target=t_run, args=(r,))
threads.append(t)
t.start()
except Exception:
print("Error: unable to start thread")
class TestPubSubPubSubSubcommands(object):
@skip_if_server_version_lt('2.8.0')
@pytest.mark.xfail(reason="Pubsub is not fully supported in cluster mode")
def test_pubsub_channels(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.subscribe('foo', 'bar', 'baz', 'quux')
channels = sorted(r.pubsub_channels())
assert channels == [b'bar', b'baz', b'foo', b'quux']
@skip_if_server_version_lt('2.8.0')
@pytest.mark.xfail(reason="Pubsub is not fully supported in cluster mode")
def test_pubsub_numsub(self, r):
p1 = r.pubsub(ignore_subscribe_messages=True)
p1.subscribe('foo', 'bar', 'baz')
p2 = r.pubsub(ignore_subscribe_messages=True)
p2.subscribe('bar', 'baz')
p3 = r.pubsub(ignore_subscribe_messages=True)
p3.subscribe('baz')
channels = [(b'foo', 1), (b'bar', 2), (b'baz', 3)]
assert channels == r.pubsub_numsub('foo', 'bar', 'baz')
@skip_if_server_version_lt('2.8.0')
@pytest.mark.xfail(reason="Pubsub is not fully supported in cluster mode")
def test_pubsub_numpat(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.psubscribe('*oo', '*ar', 'b*z')
assert r.pubsub_numpat() == 3
class TestPubSubPings(object):
@skip_if_server_version_lt('3.0.0')
@pytest.mark.xfail(reason="Pubsub is not fully supported in cluster mode")
def test_send_pubsub_ping(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.subscribe('foo')
p.ping()
assert wait_for_message(p) == make_message(type='pong', channel=None,
data='',
pattern=None)
@skip_if_server_version_lt('3.0.0')
@pytest.mark.xfail(reason="Pattern pubsub is not fully supported in cluster mode")
def test_send_pubsub_ping_message(self, r):
p = r.pubsub(ignore_subscribe_messages=True)
p.subscribe('foo')
p.ping(message='hello world')
assert wait_for_message(p) == make_message(type='pong', channel=None,
data='hello world',
pattern=None)
|
_threadedselect.py
|
# -*- test-case-name: twisted.test.test_internet -*-
#
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
from __future__ import generators
"""
Threaded select reactor
Maintainer: Bob Ippolito
The threadedselectreactor is a specialized reactor for integrating with
arbitrary foreign event loop, such as those you find in GUI toolkits.
There are three things you'll need to do to use this reactor.
Install the reactor at the beginning of your program, before importing
the rest of Twisted::
| from twisted.internet import _threadedselect
| _threadedselect.install()
Interleave this reactor with your foreign event loop, at some point after
your event loop is initialized::
| from twisted.internet import reactor
| reactor.interleave(foreignEventLoopWakerFunction)
| self.addSystemEventTrigger('after', 'shutdown', foreignEventLoopStop)
Instead of shutting down the foreign event loop directly, shut down the
reactor::
| from twisted.internet import reactor
| reactor.stop()
In order for Twisted to do its work in the main thread (the thread that
interleave is called from), a waker function is necessary. The waker function
will be called from a "background" thread with one argument: func.
The waker function's purpose is to call func() from the main thread.
Many GUI toolkits ship with appropriate waker functions.
Some examples of this are wxPython's wx.callAfter (may be wxCallAfter in
older versions of wxPython) or PyObjC's PyObjCTools.AppHelper.callAfter.
These would be used in place of "foreignEventLoopWakerFunction" in the above
example.
The other integration point at which the foreign event loop and this reactor
must integrate is shutdown. In order to ensure clean shutdown of Twisted,
you must allow for Twisted to come to a complete stop before quitting the
application. Typically, you will do this by setting up an after shutdown
trigger to stop your foreign event loop, and call reactor.stop() where you
would normally have initiated the shutdown procedure for the foreign event
loop. Shutdown functions that could be used in place of
"foreignEventloopStop" would be the ExitMainLoop method of the wxApp instance
with wxPython, or the PyObjCTools.AppHelper.stopEventLoop function.
"""
from threading import Thread
from Queue import Queue, Empty
from time import sleep
import sys
from zope.interface import implements
from twisted.internet.interfaces import IReactorFDSet
from twisted.internet import error
from twisted.internet import posixbase
from twisted.internet.posixbase import _NO_FILENO, _NO_FILEDESC
from twisted.python import log, failure, threadable
from twisted.persisted import styles
from twisted.python.runtime import platformType
import select
from errno import EINTR, EBADF
from twisted.internet.selectreactor import _select
def dictRemove(dct, value):
try:
del dct[value]
except KeyError:
pass
def raiseException(e):
raise e
class ThreadedSelectReactor(posixbase.PosixReactorBase):
"""A threaded select() based reactor - runs on all POSIX platforms and on
Win32.
"""
implements(IReactorFDSet)
def __init__(self):
threadable.init(1)
self.reads = {}
self.writes = {}
self.toThreadQueue = Queue()
self.toMainThread = Queue()
self.workerThread = None
self.mainWaker = None
posixbase.PosixReactorBase.__init__(self)
self.addSystemEventTrigger('after', 'shutdown', self._mainLoopShutdown)
def wakeUp(self):
# we want to wake up from any thread
self.waker.wakeUp()
def callLater(self, *args, **kw):
tple = posixbase.PosixReactorBase.callLater(self, *args, **kw)
self.wakeUp()
return tple
def _sendToMain(self, msg, *args):
#print >>sys.stderr, 'sendToMain', msg, args
self.toMainThread.put((msg, args))
if self.mainWaker is not None:
self.mainWaker()
def _sendToThread(self, fn, *args):
#print >>sys.stderr, 'sendToThread', fn, args
self.toThreadQueue.put((fn, args))
def _preenDescriptorsInThread(self):
log.msg("Malformed file descriptor found. Preening lists.")
readers = self.reads.keys()
writers = self.writes.keys()
self.reads.clear()
self.writes.clear()
for selDict, selList in ((self.reads, readers), (self.writes, writers)):
for selectable in selList:
try:
select.select([selectable], [selectable], [selectable], 0)
except:
log.msg("bad descriptor %s" % selectable)
else:
selDict[selectable] = 1
def _workerInThread(self):
try:
while 1:
fn, args = self.toThreadQueue.get()
#print >>sys.stderr, "worker got", fn, args
fn(*args)
except SystemExit:
pass # exception indicates this thread should exit
except:
f = failure.Failure()
self._sendToMain('Failure', f)
#print >>sys.stderr, "worker finished"
def _doSelectInThread(self, timeout):
"""Run one iteration of the I/O monitor loop.
This will run all selectables who had input or output readiness
waiting for them.
"""
reads = self.reads
writes = self.writes
while 1:
try:
r, w, ignored = _select(reads.keys(),
writes.keys(),
[], timeout)
break
except ValueError, ve:
# Possibly a file descriptor has gone negative?
log.err()
self._preenDescriptorsInThread()
except TypeError, te:
# Something *totally* invalid (object w/o fileno, non-integral
# result) was passed
log.err()
self._preenDescriptorsInThread()
except (select.error, IOError), se:
# select(2) encountered an error
if se.args[0] in (0, 2):
# windows does this if it got an empty list
if (not reads) and (not writes):
return
else:
raise
elif se.args[0] == EINTR:
return
elif se.args[0] == EBADF:
self._preenDescriptorsInThread()
else:
# OK, I really don't know what's going on. Blow up.
raise
self._sendToMain('Notify', r, w)
def _process_Notify(self, r, w):
#print >>sys.stderr, "_process_Notify"
reads = self.reads
writes = self.writes
_drdw = self._doReadOrWrite
_logrun = log.callWithLogger
for selectables, method, dct in ((r, "doRead", reads), (w, "doWrite", writes)):
for selectable in selectables:
# if this was disconnected in another thread, kill it.
if selectable not in dct:
continue
# This for pausing input when we're not ready for more.
_logrun(selectable, _drdw, selectable, method, dct)
#print >>sys.stderr, "done _process_Notify"
def _process_Failure(self, f):
f.raiseException()
_doIterationInThread = _doSelectInThread
def ensureWorkerThread(self):
if self.workerThread is None or not self.workerThread.isAlive():
self.workerThread = Thread(target=self._workerInThread)
self.workerThread.start()
def doThreadIteration(self, timeout):
self._sendToThread(self._doIterationInThread, timeout)
self.ensureWorkerThread()
#print >>sys.stderr, 'getting...'
msg, args = self.toMainThread.get()
#print >>sys.stderr, 'got', msg, args
getattr(self, '_process_' + msg)(*args)
doIteration = doThreadIteration
def _interleave(self):
while self.running:
#print >>sys.stderr, "runUntilCurrent"
self.runUntilCurrent()
t2 = self.timeout()
t = self.running and t2
self._sendToThread(self._doIterationInThread, t)
#print >>sys.stderr, "yielding"
yield None
#print >>sys.stderr, "fetching"
msg, args = self.toMainThread.get_nowait()
getattr(self, '_process_' + msg)(*args)
def interleave(self, waker, *args, **kw):
"""
interleave(waker) interleaves this reactor with the
current application by moving the blocking parts of
the reactor (select() in this case) to a separate
thread. This is typically useful for integration with
GUI applications which have their own event loop
already running.
See the module docstring for more information.
"""
self.startRunning(*args, **kw)
loop = self._interleave()
def mainWaker(waker=waker, loop=loop):
#print >>sys.stderr, "mainWaker()"
waker(loop.next)
self.mainWaker = mainWaker
loop.next()
self.ensureWorkerThread()
def _mainLoopShutdown(self):
self.mainWaker = None
if self.workerThread is not None:
#print >>sys.stderr, 'getting...'
self._sendToThread(raiseException, SystemExit)
self.wakeUp()
try:
while 1:
msg, args = self.toMainThread.get_nowait()
#print >>sys.stderr, "ignored:", (msg, args)
except Empty:
pass
self.workerThread.join()
self.workerThread = None
try:
while 1:
fn, args = self.toThreadQueue.get_nowait()
if fn is self._doIterationInThread:
log.msg('Iteration is still in the thread queue!')
elif fn is raiseException and args[0] is SystemExit:
pass
else:
fn(*args)
except Empty:
pass
def _doReadOrWrite(self, selectable, method, dict):
try:
why = getattr(selectable, method)()
handfn = getattr(selectable, 'fileno', None)
if not handfn:
why = _NO_FILENO
elif handfn() == -1:
why = _NO_FILEDESC
except:
why = sys.exc_info()[1]
log.err()
if why:
self._disconnectSelectable(selectable, why, method == "doRead")
def addReader(self, reader):
"""Add a FileDescriptor for notification of data available to read.
"""
self._sendToThread(self.reads.__setitem__, reader, 1)
self.wakeUp()
def addWriter(self, writer):
"""Add a FileDescriptor for notification of data available to write.
"""
self._sendToThread(self.writes.__setitem__, writer, 1)
self.wakeUp()
def removeReader(self, reader):
"""Remove a Selectable for notification of data available to read.
"""
self._sendToThread(dictRemove, self.reads, reader)
def removeWriter(self, writer):
"""Remove a Selectable for notification of data available to write.
"""
self._sendToThread(dictRemove, self.writes, writer)
def removeAll(self):
return self._removeAll(self.reads, self.writes)
def getReaders(self):
return self.reads.keys()
def getWriters(self):
return self.writes.keys()
def stop(self):
"""
Extend the base stop implementation to also wake up the select thread so
that C{runUntilCurrent} notices the reactor should stop.
"""
posixbase.PosixReactorBase.stop(self)
self.wakeUp()
def run(self, installSignalHandlers=1):
self.startRunning(installSignalHandlers=installSignalHandlers)
self.mainLoop()
def mainLoop(self):
q = Queue()
self.interleave(q.put)
while self.running:
try:
q.get()()
except StopIteration:
break
def install():
"""Configure the twisted mainloop to be run using the select() reactor.
"""
reactor = ThreadedSelectReactor()
from twisted.internet.main import installReactor
installReactor(reactor)
return reactor
__all__ = ['install']
|
ssh.py
|
# -*- coding: utf-8 -*- #
# Copyright 2018 Google LLC. 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.
"""cloud-shell ssh command."""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import datetime
import threading
from googlecloudsdk.calliope import base
from googlecloudsdk.command_lib.cloud_shell import util
from googlecloudsdk.command_lib.util.ssh import ssh
from googlecloudsdk.core import log
from googlecloudsdk.core import properties
import six
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class SshAlpha(base.Command):
"""Allows you to establish an interactive SSH session with Cloud Shell."""
detailed_help = {
'DESCRIPTION':
"""\
*{command}* lets you remotely log in to Cloud Shell. If your Cloud Shell
is not currently running, this will cause it to be started before
establishing the SSH session.
""",
'EXAMPLES':
"""\
To SSH into your Cloud Shell, run:
$ {command}
To run a remote command in your Cloud Shell, run:
$ {command} --command=ls
""",
}
@staticmethod
def Args(parser):
util.ParseCommonArgs(parser)
parser.add_argument(
'--command',
help="""\
A command to run in Cloud Shell.
Runs the command in Cloud Shell and then exits.
""")
parser.add_argument(
'--dry-run',
help="""\
If provided, prints the command that would be run to standard out
instead of executing it.
""",
action='store_true')
parser.add_argument(
'--ssh-flag',
help='Additional flags to be passed to *ssh(1)*.',
action='append')
def Run(self, args):
command_list = args.command.split(' ') if args.command else ['bash -l']
project = properties.VALUES.core.project.Get()
connection_info = util.PrepareEnvironment(args)
command = ssh.SSHCommand(
remote=ssh.Remote(host=connection_info.host, user=connection_info.user),
port=six.text_type(connection_info.port),
identity_file=connection_info.key,
remote_command=(['DEVSHELL_PROJECT_ID=' + project]
if project else []) + command_list,
extra_flags=args.ssh_flag,
tty=not args.command,
options={'StrictHostKeyChecking': 'no'},
)
if args.dry_run:
elems = command.Build(connection_info.ssh_env)
log.Print(' '.join([six.moves.shlex_quote(elem) for elem in elems]))
else:
self.done = threading.Event()
thread = threading.Thread(target=self.Reauthorize, args=())
thread.daemon = True
thread.start()
command.Run(connection_info.ssh_env)
self.done.set()
def Reauthorize(self):
while not self.done.is_set():
self.done.wait(
(util.MIN_CREDS_EXPIRY - datetime.timedelta(minutes=2)).seconds)
util.AuthorizeEnvironment()
|
threads_thread_pool.py
|
"""
"An example of a threaded application" section example
showing how to implement simple thread pool.
"""
import time
from queue import Queue, Empty
from threading import Thread
from gmaps import Geocoding
THREAD_POOL_SIZE = 4
api = Geocoding()
PLACES = (
'Reykjavik', 'Vien', 'Zadar', 'Venice',
'Wrocław', 'Bolognia', 'Berlin', 'Słubice',
'New York', 'Dehli',
)
def fetch_place(place):
geocoded = api.geocode(place)[0]
print("{:>25s}, {:6.2f}, {:6.2f}".format(
geocoded['formatted_address'],
geocoded['geometry']['location']['lat'],
geocoded['geometry']['location']['lng'],
))
def worker(work_queue):
while not work_queue.empty():
try:
item = work_queue.get(block=False)
except Empty:
break
else:
fetch_place(item)
work_queue.task_done()
def main():
work_queue = Queue()
for place in PLACES:
work_queue.put(place)
threads = [
Thread(target=worker, args=(work_queue,))
for _ in range(THREAD_POOL_SIZE)
]
for thread in threads:
thread.start()
work_queue.join()
while threads:
threads.pop().join()
if __name__ == "__main__":
started = time.time()
main()
elapsed = time.time() - started
print()
print("time elapsed: {:.2f}s".format(elapsed))
|
ingress.py
|
"""A 'backdoor' shell for running servers (very much like Twisted manhole).
Once installed, you can 'telnet <host> <port>' and run Python commands on your
server environment. This is very helpful in debugging servers.
This one uses only modules found in the standard library.
"""
__author__ = 'Miki Tebeka <[email protected]>'
__version__ = '0.4.0'
from contextlib import redirect_stdout, redirect_stderr
import socketserver
from threading import Thread
from traceback import format_exc
import socket
EOF = chr(4)
DEFAULT_ADDRESS = ('localhost', 9998)
QUIT = 'quit()'
class PyHandler(socketserver.StreamRequestHandler):
password = None
env = {}
prompt = '>>> '
def handle(self):
env = self.env.copy()
welcome = 'Welcome to ingress (type "{}" to exit)\n'.format(QUIT)
self.write(welcome)
if not self.login():
return
while True:
try:
self.write(self.prompt)
expr = self.rfile.readline().rstrip()
if expr == EOF:
return
expr = expr.decode('utf-8')
if expr == QUIT:
self.request.close()
return
with redirect_stdout(self), redirect_stderr(self):
try:
value = eval(expr, globals(), env) # nosec
out = format(value) + '\n'
self.write(out)
except Exception:
exec(expr, env) # nosec
except (EOFError, SystemExit, socket.error):
return
except Exception:
error = format_exc()
import sys
print(error, file=sys.stderr)
self.write(error)
def finish(self):
try:
super().finish()
except socket.error:
pass
def login(self):
if not self.password:
return True
for i in range(3):
self.write('Password: ')
password = self.rfile.readline().strip().decode('utf-8')
if password == self.password:
return True
self.write('Bad password\n')
return False
def write(self, obj):
if isinstance(obj, str):
obj = obj.encode('utf-8')
self.wfile.write(obj)
class ThreadedServer(socketserver.ThreadingTCPServer):
daemon_threads = True
allow_reuse_address = True
def install(address=DEFAULT_ADDRESS, env=None, password=None):
"""Install TCP handler on address
Parameters
----------
address : tuple
Address to listen on (host, port)
env : dict
Environment to use when evaulation expression (default to globals)
password : str
Login password
"""
class Handler(PyHandler):
pass
Handler.env = {} if env is None else env
Handler.password = password
server = ThreadedServer(address, Handler)
thr = Thread(target=server.serve_forever, daemon=True)
thr.start()
return thr
|
master_feed.py
|
from multiprocessing import Process
import feed, algo
import glob, time, copy
waitTime = 1800
def buildList():
print("Built the list.")
returnList = []
with open("stocks", "r") as f:
for i in f:
returnList.append(i.rstrip())
return returnList
def main():
print("Starting feed programs")
stocks = copy.copy(buildList())
print(stocks)
for stock in stocks:
print(stock)
client = stocks.index(stock) + 10
print(client)
print("Starting feed for {}".format(stock))
p = Process(target=feed.main, args=(stock, client))
p.start()
print("Feed started. Client {}".format(client))
print("Feed programs started")
if __name__ == '__main__':
main()
|
udp.py
|
import collections
from typing import Dict, Tuple
import threading
import socket
import struct
import binascii
from time import time
import enum
import attr
PROTOCOL_VERSION = 1001
_battery_table = {
# CHARGING 1-11
# dying
(True, 1): 0x01,
(True, 2): 0x01,
# low
(True, 3): 0x02,
(True, 4): 0x02,
# medium
(True, 5): 0x03,
(True, 6): 0x03,
# high
(True, 7): 0x04,
(True, 8): 0x04,
(True, 9): 0x04,
# full
(True, 10): 0x05,
(True, 11): 0x05,
# NORMAL 1-8
(False, 1): 0x01, # dying
(False, 2): 0x02, # low
# medium
(False, 3): 0x03,
(False, 4): 0x03,
# high
(False, 5): 0x04,
(False, 6): 0x04,
# full
(False, 7): 0x05,
(False, 8): 0x05,
}
class MessageType(enum.Enum):
version = b'\x00\x00\x10\x00'
ports = b'\x01\x00\x10\x00'
data = b'\x02\x00\x10\x00'
SERVER_MAGIC = b'DSUS'
CLIENT_MAGIC = b'DSUC'
_HEADER = SERVER_MAGIC + struct.pack('<H', PROTOCOL_VERSION)
@attr.s(auto_attribs=True)
class Message:
message_type: MessageType
data: bytes
def serialize(self) -> bytes:
header = bytearray(_HEADER)
# add data length (message type is part of it):
header += struct.pack('<H', len(self.data) + 4)
# server ID:
payload = bytearray(b'\xff' * 4)
# message type:
payload += self.message_type.value
# add the data
payload += self.data
# calculate the crc32
crc = struct.pack('<I', binascii.crc32(header + b'\x00' * 4 + payload) & 0xffffffff)
# add it
payload = header + crc + payload
return payload
TAddress = Tuple[str, int]
@attr.s(auto_attribs=True)
class ControllerData:
clients: Dict[TAddress, float] = attr.ib(init=False, factory=dict)
mac: bytes = attr.ib(init=False, default=bytes(6))
@attr.s(auto_attribs=True)
class UDPServer:
host: str = ''
port: int = 26760
controllers: Dict[int, ControllerData] = attr.ib(init=False,
factory=lambda: collections.defaultdict(ControllerData))
counter: int = attr.ib(init=False, default=0)
_per_client_send_lock: Dict[TAddress, threading.Lock] = attr.ib(init=False,
factory=lambda: collections.defaultdict(threading.Lock))
def __attrs_post_init__(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.bind((self.host, self.port))
self.thread = threading.Thread(target=self._worker)
self.thread.daemon = True
def _res_ports(self, pad_id: int) -> Message:
return Message(MessageType.ports, bytes([
pad_id, # pad id
0x02, # state (connected)
0x02, # model (full gyro)
0x01, # connection type (usb)
*self.controllers[pad_id].mac, # 6 bytes mac address
0xef, # battery (charged)
0x00, # fixed zero on ports response.
]))
def _req_ports(self, message: bytes, address: TAddress):
requests_count = struct.unpack("<i", message[20:24])[0]
for i in range(requests_count):
index = message[24 + i]
if index in self.controllers:
with self._per_client_send_lock[address]:
self.sock.sendto(self._res_ports(index).serialize(), address)
def _req_data(self, message: bytes, address: TAddress):
flags = message[20]
pad_id = message[21]
if flags == 0:
# register for all controllers
for pad_id, controller_data in self.controllers.items():
controller_data.clients[address] = time()
elif flags == 1:
controller_data = self.controllers.get(pad_id)
if controller_data is not None:
if address not in controller_data.clients:
print('[udp] Client {0[0]}:{0[1]} connected to {1}'.format(address, pad_id))
controller_data.clients[address] = time()
# elif flags == 2: # TODO: implement mac based connect
else:
print(f'[udp] Client {address} requested {flags=} {pad_id=}, ignoring')
def _res_data(self, pad_id: int, message: Message):
now = time()
controller_data = self.controllers[pad_id]
for address in list(controller_data.clients):
if now - controller_data.clients.get(address, 5) < 5:
with self._per_client_send_lock[address]:
self.sock.sendto(message.serialize(), address)
else:
print('[udp] Client {0[0]}:{0[1]} disconnected from {1}'.format(address, pad_id))
del controller_data.clients[address]
def _handle_request(self, request):
message, address = request
# client_id = message[12:16]
msg_type = MessageType(message[16:20])
if msg_type == MessageType.version:
return
elif msg_type == MessageType.ports:
self._req_ports(message, address)
elif msg_type == MessageType.data:
self._req_data(message, address)
else:
print(f'[udp] Unknown message type from {message[12:16]}: {message[16:20]}')
def device_for_pad(self, pad_id: int, device):
self.controllers[pad_id].mac = binascii.unhexlify(device.device_addr.replace(':', ''))
def report_for_pad(self, pad_id: int, report, remap: bool = False):
if report.plug_usb:
connection_type = 0x01 # usb
else:
connection_type = 0x02 # bluetooth
battery = _battery_table.get((bool(report.plug_usb), report.battery), 0)
data = [
pad_id, # pad id
0x02, # state (connected)
0x02, # model (generic)
connection_type,
*self.controllers[pad_id].mac, # 6 bytes mac address
battery, # battery (charged)
0x01 # is active (true)
]
data.extend(bytes(struct.pack('<I', self.counter)))
self.counter += 1
buttons1 = 0x00
buttons1 |= report.button_share
buttons1 |= report.button_l3 << 1
buttons1 |= report.button_r3 << 2
buttons1 |= report.button_options << 3
buttons1 |= report.dpad_up << 4
buttons1 |= report.dpad_right << 5
buttons1 |= report.dpad_down << 6
buttons1 |= report.dpad_left << 7
buttons2 = 0x00
buttons2 |= report.button_l2
buttons2 |= report.button_r2 << 1
buttons2 |= report.button_l1 << 2
buttons2 |= report.button_r1 << 3
if remap:
buttons2 |= report.button_triangle << 7
buttons2 |= report.button_circle << 6
buttons2 |= report.button_cross << 5
buttons2 |= report.button_square << 4
else:
buttons2 |= report.button_triangle << 4
buttons2 |= report.button_circle << 5
buttons2 |= report.button_cross << 6
buttons2 |= report.button_square << 7
data.extend([
buttons1, buttons2,
report.button_ps * 0xFF,
report.button_trackpad * 0xFF,
report.left_analog_x,
255 - report.left_analog_y,
report.right_analog_x,
255 - report.right_analog_y,
report.dpad_left * 0xFF,
report.dpad_down * 0xFF,
report.dpad_right * 0xFF,
report.dpad_up * 0xFF,
report.button_square * 0xFF,
report.button_cross * 0xFF,
report.button_circle * 0xFF,
report.button_triangle * 0xFF,
report.button_r1 * 0xFF,
report.button_l1 * 0xFF,
report.r2_analog,
report.l2_analog,
report.trackpad_touch0_active * 0xFF,
report.trackpad_touch0_id,
report.trackpad_touch0_x >> 8,
report.trackpad_touch0_x & 255,
report.trackpad_touch0_y >> 8,
report.trackpad_touch0_y & 255,
report.trackpad_touch1_active * 0xFF,
report.trackpad_touch1_id,
report.trackpad_touch1_x >> 8,
report.trackpad_touch1_x & 255,
report.trackpad_touch1_y >> 8,
report.trackpad_touch1_y & 255,
])
data.extend(bytes(struct.pack('<Q', int(time() * 10 ** 6))))
sensors = [
report.orientation_roll / 8192,
- report.orientation_yaw / 8192,
- report.orientation_pitch / 8192,
report.motion_y / 16,
- report.motion_x / 16,
- report.motion_z / 16,
]
for sensor in sensors:
data.extend(bytes(struct.pack('<f', float(sensor))))
self._res_data(pad_id, Message(MessageType.data, bytes(data)))
def _worker(self):
while True:
self._handle_request(self.sock.recvfrom(1024))
def start(self):
self.thread.start()
|
runtests_log_handler.py
|
# -*- coding: utf-8 -*-
'''
:codeauthor: Pedro Algarvio ([email protected])
:copyright: Copyright 2016 by the SaltStack Team, see AUTHORS for more details.
:license: Apache 2.0, see LICENSE for more details.
pytestsalt.salt.log_handlers.pytest_log_handler
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Salt External Logging Handler
'''
# Import python libs
from __future__ import absolute_import
import errno
import socket
import logging
import threading
from multiprocessing import Queue
# Import Salt libs
import salt.utils.msgpack
from salt.ext import six
from salt.utils.platform import is_darwin
import salt.log.setup
log = logging.getLogger(__name__)
__virtualname__ = 'runtests_log_handler'
def __virtual__():
if 'runtests_log_port' not in __opts__:
return False, "'runtests_log_port' not in options"
if six.PY3:
return False, "runtests external logging handler is temporarily disabled for Python 3 tests"
return True
def setup_handlers():
port = __opts__['runtests_log_port']
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
sock.connect(('localhost', port))
except socket.error as exc:
if exc.errno == errno.ECONNREFUSED:
log.warning('Failed to connect to log server')
return
finally:
try:
sock.shutdown(socket.SHUT_RDWR)
except OSError:
pass
sock.close()
# One million log messages is more than enough to queue.
# Above that value, if `process_queue` can't process fast enough,
# start dropping. This will contain a memory leak in case `process_queue`
# can't process fast enough of in case it can't deliver the log records at all.
if is_darwin():
queue_size = 32767
else:
queue_size = 10000000
queue = Queue(queue_size)
handler = salt.log.setup.QueueHandler(queue)
level = salt.log.setup.LOG_LEVELS[(__opts__.get('runtests_log_level') or 'error').lower()]
handler.setLevel(level)
process_queue_thread = threading.Thread(target=process_queue, args=(port, queue))
process_queue_thread.daemon = True
process_queue_thread.start()
return handler
def process_queue(port, queue):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
try:
sock.connect(('localhost', port))
except socket.error as exc:
if exc.errno == errno.ECONNREFUSED:
sock.shutdown(socket.SHUT_RDWR)
sock.close()
log.warning('Failed to connect to log server')
return
while True:
try:
record = queue.get()
if record is None:
# A sentinel to stop processing the queue
break
# Just log everything, filtering will happen on the main process
# logging handlers
sock.sendall(salt.utils.msgpack.dumps(record.__dict__, encoding='utf-8'))
except (IOError, EOFError, KeyboardInterrupt, SystemExit):
try:
sock.shutdown(socket.SHUT_RDWR)
sock.close()
except (OSError, socket.error):
pass
break
except socket.error as exc:
if exc.errno == errno.EPIPE:
# Broken pipe
try:
sock.shutdown(socket.SHUT_RDWR)
sock.close()
except (OSError, socket.error):
pass
break
log.exception(exc)
except Exception as exc: # pylint: disable=broad-except
log.warning(
'An exception occurred in the pytest salt logging '
'queue thread: %s',
exc,
exc_info_on_loglevel=logging.DEBUG
)
|
poster.py
|
import os
import sys
import time
import signal
import multiprocessing
from datetime import datetime
PROJECT_PATH = os.path.abspath(os.path.dirname(__file__))
sys.path.append(os.path.join(PROJECT_PATH, '..', '..'))
from pygithub3 import Github
import src.todoMelvin
from src.todoMelvin import settings, createGithubObject
from src.todoLogging import WarningLevels, log
from src.db.todoRepos import RepoQueues, Repo
from src.workers.workerStatus import WorkerStatus
redis = src.db.todoRedis.connect()
gh = createGithubObject()
def runWorker(status):
#This causes this thread to ignore interrupt signals so theya re only handled by parent
signal.signal(signal.SIGINT, signal.SIG_IGN)
#Loop will be closed externally
while status.value != WorkerStatus.Dead:
try:
postCount = redis.llen(RepoQueues.Posting)
except:
log(WarningLevels.Fatal, "Posting Worker unable to reach Redis")
break
if postCount > 0:
repoKey = redis.lpop(RepoQueues.Posting)
repo = Repo()
repo.loadFromKey(repoKey)
#sanity check our loaded key
assert repo.key() == repoKey, "Bad repo saved in posting Queue! Key %s not found!"%(repoKey)
for todo in repo.Todos:
if len(todo.issueURL) == 0:
repo.lastTodoPosted = todo.key(repo)
repo.lastTodoPostDate = datetime.now().strftime("%m/%d/%Y %H:%M:%S")
#Generate the issue
data = src.todoIssueGenerator.buildIssue(todo, repo)
#post the damn issue and save the url
issue = None
if settings.debug.lower() == 'true':
issue = gh.issues.create(data, 'p4r4digm', 'todo-helper') #post to our todo-helper
else:
issue = gh.issues.create(data, repo.userName, repo.repoName)
pass
todo.issueURL = issue.url
#put todo in todo graveyard
redis.rpush(RepoQueues.TodoGY, todo.key(repo))
repo.save()
log(WarningLevels.Info, "Issue posted to Github!")
break
#throw repo into graveyard
redis.rpush(RepoQueues.RepoGY, repo.key())
else:
sleepTime = float(settings.posterSleepTime)
log(WarningLevels.Debug, "Posting Worker going to sleep...")
#Set to sleeping for faster shutdown
status.value = WorkerStatus.Sleeping
time.sleep(sleepTime)
status.value = WorkerStatus.Working
def main(argv):
src.todoLogging.logSender = "POS%s"%(argv)
log(WarningLevels.Info, "Starting Posting Worker.")
#async global status value that is shared with processes
status = multiprocessing.Value('i', WorkerStatus.Working)
try:
#Start the function and wait for it to end
process = multiprocessing.Process(target = runWorker, args = (status, ))
process.start()
process.join()
except KeyboardInterrupt, SystemExit:
if status.value == WorkerStatus.Sleeping:
log(WarningLevels.Info, "Shutdown signal received while asleep. Posting worker shutting down.")
process.terminate()
process.join()
else:
log(WarningLevels.Info, "Shutdown signal received. Allow Poster to finish current operation.")
status.value = WorkerStatus.Dead
process.join()
log(WarningLevels.Info, "Posting Worker has shut down.")
if __name__ == "__main__":
if len(sys.argv) > 1:
main(sys.argv[1])
else:
main("0")
|
display_functions.py
|
import os
import random
from threading import Thread
from modules.audio import speaker
from modules.conditions import conversation
from modules.models import models
from modules.utils import support
env = models.env
def brightness(phrase: str):
"""Pre-process to check the phrase received and call the appropriate brightness function as necessary.
Args:
phrase: Takes the phrase spoken as an argument.
"""
if not env.macos:
support.missing_windows_features()
return
phrase = phrase.lower()
speaker.speak(text=random.choice(conversation.acknowledgement))
if 'set' in phrase:
level = support.extract_nos(input_=phrase, method=int)
if level is None:
level = 50
Thread(target=set_brightness, args=[level]).start()
elif 'decrease' in phrase or 'reduce' in phrase or 'lower' in phrase or \
'dark' in phrase or 'dim' in phrase:
Thread(target=decrease_brightness).start()
elif 'increase' in phrase or 'bright' in phrase or 'max' in phrase or \
'brighten' in phrase or 'light up' in phrase:
Thread(target=increase_brightness).start()
def increase_brightness() -> None:
"""Increases the brightness to maximum in macOS."""
for _ in range(32):
os.system("""osascript -e 'tell application "System Events"' -e 'key code 144' -e ' end tell'""")
def decrease_brightness() -> None:
"""Decreases the brightness to bare minimum in macOS."""
for _ in range(32):
os.system("""osascript -e 'tell application "System Events"' -e 'key code 145' -e ' end tell'""")
def set_brightness(level: int) -> None:
"""Set brightness to a custom level.
- | Since Jarvis uses in-built apple script, the only way to achieve this is to set the brightness to absolute
| minimum/maximum and increase/decrease the required % from there.
Args:
level: Percentage of brightness to be set.
"""
level = round((32 * int(level)) / 100)
for _ in range(32):
os.system("""osascript -e 'tell application "System Events"' -e 'key code 145' -e ' end tell'""")
for _ in range(level):
os.system("""osascript -e 'tell application "System Events"' -e 'key code 144' -e ' end tell'""")
|
SerialClient.py
|
#!/usr/bin/env python
#####################################################################
# Software License Agreement (BSD License)
#
# Copyright (c) 2011, Willow Garage, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following
# disclaimer in the documentation and/or other materials provided
# with the distribution.
# * Neither the name of Willow Garage, Inc. nor the names of its
# contributors may be used to endorse or promote products derived
# from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
__author__ = "[email protected] (Michael Ferguson)"
import imp
import threading
import sys
import multiprocessing
import StringIO
import errno
import signal
import socket
import struct
import time
from Queue import Queue
from serial import Serial, SerialException, SerialTimeoutException
import roslib
import rospy
from std_msgs.msg import Time
from rosserial_msgs.msg import TopicInfo, Log
from rosserial_msgs.srv import RequestParamRequest, RequestParamResponse
import diagnostic_msgs.msg
ERROR_MISMATCHED_PROTOCOL = "Mismatched protocol version in packet: lost sync or rosserial_python is from different ros release than the rosserial client"
ERROR_NO_SYNC = "no sync with device"
ERROR_PACKET_FAILED = "Packet Failed : Failed to read msg data"
def load_pkg_module(package, directory):
# check if its in the python path
path = sys.path
try:
imp.find_module(package)
except ImportError:
roslib.load_manifest(package)
try:
m = __import__(package + '.' + directory)
except ImportError:
rospy.logerr("Cannot import package : %s" % package)
rospy.logerr("sys.path was " + str(path))
return None
return m
def load_message(package, message):
m = load_pkg_module(package, 'msg')
m2 = getattr(m, 'msg')
return getattr(m2, message)
def load_service(package, service):
s = load_pkg_module(package, 'srv')
s = getattr(s, 'srv')
srv = getattr(s, service)
mreq = getattr(s, service+"Request")
mres = getattr(s, service+"Response")
return srv, mreq, mres
class Publisher:
"""
Publisher forwards messages from the serial device to ROS.
"""
def __init__(self, topic_info):
""" Create a new publisher. """
self.topic = topic_info.topic_name
# find message type
package, message = topic_info.message_type.split('/')
self.message = load_message(package, message)
if self.message._md5sum == topic_info.md5sum:
self.publisher = rospy.Publisher(self.topic, self.message, queue_size=10)
else:
raise Exception('Checksum does not match: ' +
self.message._md5sum + ',' + topic_info.md5sum)
def handlePacket(self, data):
""" Forward message to ROS network. """
m = self.message()
m.deserialize(data)
self.publisher.publish(m)
class Subscriber:
"""
Subscriber forwards messages from ROS to the serial device.
"""
def __init__(self, topic_info, parent):
self.topic = topic_info.topic_name
self.id = topic_info.topic_id
self.parent = parent
# find message type
package, message = topic_info.message_type.split('/')
self.message = load_message(package, message)
if self.message._md5sum == topic_info.md5sum:
self.subscriber = rospy.Subscriber(self.topic, self.message, self.callback)
else:
raise Exception('Checksum does not match: ' +
self.message._md5sum + ',' + topic_info.md5sum)
def callback(self, msg):
""" Forward message to serial device. """
data_buffer = StringIO.StringIO()
msg.serialize(data_buffer)
self.parent.send(self.id, data_buffer.getvalue())
def unregister(self):
rospy.loginfo("Removing subscriber: %s", self.topic)
self.subscriber.unregister()
class ServiceServer:
"""
ServiceServer responds to requests from ROS.
"""
def __init__(self, topic_info, parent):
self.topic = topic_info.topic_name
self.parent = parent
# find message type
package, service = topic_info.message_type.split('/')
s = load_pkg_module(package, 'srv')
s = getattr(s, 'srv')
self.mreq = getattr(s, service+"Request")
self.mres = getattr(s, service+"Response")
srv = getattr(s, service)
self.service = rospy.Service(self.topic, srv, self.callback)
# response message
self.data = None
def unregister(self):
rospy.loginfo("Removing service: %s", self.topic)
self.service.shutdown()
def callback(self, req):
""" Forward request to serial device. """
data_buffer = StringIO.StringIO()
req.serialize(data_buffer)
self.response = None
if self.parent.send(self.id, data_buffer.getvalue()) >= 0:
while self.response is None:
pass
return self.response
def handlePacket(self, data):
""" Forward response to ROS network. """
r = self.mres()
r.deserialize(data)
self.response = r
class ServiceClient:
"""
ServiceServer responds to requests from ROS.
"""
def __init__(self, topic_info, parent):
self.topic = topic_info.topic_name
self.parent = parent
# find message type
package, service = topic_info.message_type.split('/')
s = load_pkg_module(package, 'srv')
s = getattr(s, 'srv')
self.mreq = getattr(s, service+"Request")
self.mres = getattr(s, service+"Response")
srv = getattr(s, service)
rospy.loginfo("Starting service client, waiting for service '" + self.topic + "'")
rospy.wait_for_service(self.topic)
self.proxy = rospy.ServiceProxy(self.topic, srv)
def handlePacket(self, data):
""" Forward request to ROS network. """
req = self.mreq()
req.deserialize(data)
# call service proxy
resp = self.proxy(req)
# serialize and publish
data_buffer = StringIO.StringIO()
resp.serialize(data_buffer)
self.parent.send(self.id, data_buffer.getvalue())
class RosSerialServer:
"""
RosSerialServer waits for a socket connection then passes itself, forked as a
new process, to SerialClient which uses it as a serial port. It continues to listen
for additional connections. Each forked process is a new ros node, and proxies ros
operations (e.g. publish/subscribe) from its connection to the rest of ros.
"""
def __init__(self, tcp_portnum, fork_server=False):
print "Fork_server is: ", fork_server
self.tcp_portnum = tcp_portnum
self.fork_server = fork_server
def listen(self):
self.serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.serversocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# bind the socket to a public host, and a well-known port
self.serversocket.bind(("", self.tcp_portnum)) # become a server socket
self.serversocket.listen(1)
while True:
# accept connections
print "waiting for socket connection"
(clientsocket, address) = self.serversocket.accept()
# now do something with the clientsocket
rospy.loginfo("Established a socket connection from %s on port %s" % (address))
self.socket = clientsocket
self.isConnected = True
if self.fork_server: # if configured to launch server in a separate process
rospy.loginfo("Forking a socket server process")
process = multiprocessing.Process(target=self.startSocketServer, args=(address))
process.daemon = True
process.start()
rospy.loginfo("launched startSocketServer")
else:
rospy.loginfo("calling startSerialClient")
self.startSerialClient()
rospy.loginfo("startSerialClient() exited")
def startSerialClient(self):
client = SerialClient(self)
try:
client.run()
except KeyboardInterrupt:
pass
except RuntimeError:
rospy.loginfo("RuntimeError exception caught")
self.isConnected = False
except socket.error:
rospy.loginfo("socket.error exception caught")
self.isConnected = False
finally:
self.socket.close()
for sub in client.subscribers.values():
sub.unregister()
for srv in client.services.values():
srv.unregister()
# pass
def startSocketServer(self, port, address):
rospy.loginfo("starting ROS Serial Python Node serial_node-%r" % (address,))
rospy.init_node("serial_node_%r" % (address,))
self.startSerialClient()
def flushInput(self):
pass
def flushOutput(self):
pass
def write(self, data):
if not self.isConnected:
return
length = len(data)
totalsent = 0
while totalsent < length:
sent = self.socket.send(data[totalsent:])
if sent == 0:
raise RuntimeError("RosSerialServer.write() socket connection broken")
totalsent = totalsent + sent
def read(self, rqsted_length):
self.msg = ''
if not self.isConnected:
return self.msg
while len(self.msg) < rqsted_length:
chunk = self.socket.recv(rqsted_length - len(self.msg))
if chunk == '':
raise RuntimeError("RosSerialServer.read() socket connection broken")
self.msg = self.msg + chunk
return self.msg
def inWaiting(self):
try: # the caller checks just for <1, so we'll peek at just one byte
chunk = self.socket.recv(1, socket.MSG_DONTWAIT | socket.MSG_PEEK)
if chunk == '':
raise RuntimeError("RosSerialServer.inWaiting() socket connection broken")
return len(chunk)
except socket.error, e:
if e.args[0] == errno.EWOULDBLOCK:
return 0
raise
class SerialClient(object):
"""
ServiceServer responds to requests from the serial device.
"""
def __init__(self, port=None, baud=57600, timeout=5.0, fix_pyserial_for_test=False):
""" Initialize node, connect to bus, attempt to negotiate topics. """
self.read_lock = threading.RLock()
self.write_lock = threading.RLock()
self.write_queue = Queue()
self.write_thread = None
self.lastsync = rospy.Time(0)
self.lastsync_lost = rospy.Time(0)
self.lastsync_success = rospy.Time(0)
self.last_read = rospy.Time(0)
self.last_write = rospy.Time(0)
self.timeout = timeout
self.synced = False
self.fix_pyserial_for_test = fix_pyserial_for_test
self.pub_diagnostics = rospy.Publisher(
'/diagnostics', diagnostic_msgs.msg.DiagnosticArray, queue_size=10)
if port is None:
# no port specified, listen for any new port?
pass
elif hasattr(port, 'read'):
# assume its a filelike object
self.port = port
else:
# open a specific port
while not rospy.is_shutdown():
try:
if self.fix_pyserial_for_test:
# see https://github.com/pyserial/pyserial/issues/59
self.port = Serial(port, baud, timeout=self.timeout,
write_timeout=10, rtscts=True, dsrdtr=True)
else:
self.port = Serial(port, baud, timeout=self.timeout, write_timeout=10)
break
except SerialException as e:
rospy.logerr("Error opening serial: %s", e)
time.sleep(3)
if rospy.is_shutdown():
return
time.sleep(0.1) # Wait for ready (patch for Uno)
# hydro introduces protocol ver2 which must match node_handle.h
# The protocol version is sent as the 2nd sync byte emitted by each end
self.protocol_ver1 = '\xff'
self.protocol_ver2 = '\xfe'
self.protocol_ver = self.protocol_ver2
self.publishers = dict() # id:Publishers
self.subscribers = dict() # topic:Subscriber
self.services = dict() # topic:Service
self.buffer_out = -1
self.buffer_in = -1
self.callbacks = dict()
# endpoints for creating new pubs/subs
self.callbacks[TopicInfo.ID_PUBLISHER] = self.setupPublisher
self.callbacks[TopicInfo.ID_SUBSCRIBER] = self.setupSubscriber
# service client/servers have 2 creation endpoints (a publisher and a subscriber)
self.callbacks[TopicInfo.ID_SERVICE_SERVER +
TopicInfo.ID_PUBLISHER] = self.setupServiceServerPublisher
self.callbacks[TopicInfo.ID_SERVICE_SERVER +
TopicInfo.ID_SUBSCRIBER] = self.setupServiceServerSubscriber
self.callbacks[TopicInfo.ID_SERVICE_CLIENT +
TopicInfo.ID_PUBLISHER] = self.setupServiceClientPublisher
self.callbacks[TopicInfo.ID_SERVICE_CLIENT +
TopicInfo.ID_SUBSCRIBER] = self.setupServiceClientSubscriber
# custom endpoints
self.callbacks[TopicInfo.ID_PARAMETER_REQUEST] = self.handleParameterRequest
self.callbacks[TopicInfo.ID_LOG] = self.handleLoggingRequest
self.callbacks[TopicInfo.ID_TIME] = self.handleTimeRequest
rospy.sleep(2.0)
self.requestTopics()
self.lastsync = rospy.Time.now()
signal.signal(signal.SIGINT, self.txStopRequest)
def requestTopics(self):
""" Determine topics to subscribe/publish. """
rospy.loginfo('Requesting topics...')
# TODO remove if possible
if not self.fix_pyserial_for_test:
with self.read_lock:
self.port.flushInput()
# request topic sync
self.write_queue.put("\xff" + self.protocol_ver + "\x00\x00\xff\x00\x00\xff")
def txStopRequest(self, signal, frame):
""" send stop tx request to arduino when receive SIGINT(Ctrl-c)"""
if not self.fix_pyserial_for_test:
with self.read_lock:
self.port.flushInput()
self.write_queue.put("\xff" + self.protocol_ver + "\x00\x00\xff\x0b\x00\xf4")
# tx_stop_request is x0b
rospy.loginfo("Send tx stop request")
sys.exit(0)
def tryRead(self, length):
try:
read_start = time.time()
bytes_remaining = length
result = bytearray()
while bytes_remaining != 0 and time.time() - read_start < self.timeout:
with self.read_lock:
received = self.port.read(bytes_remaining)
if len(received) != 0:
self.last_read = rospy.Time.now()
result.extend(received)
bytes_remaining -= len(received)
if bytes_remaining != 0:
raise IOError("Returned short (expected %d bytes, received %d instead)." %
(length, length - bytes_remaining))
return bytes(result)
except Exception as e:
raise IOError("Serial Port read failure: %s" % e)
def run(self):
""" Forward recieved messages to appropriate publisher. """
# Launch write thread.
if self.write_thread is None:
self.write_thread = threading.Thread(target=self.processWriteQueue)
self.write_thread.daemon = True
self.write_thread.start()
# Handle reading.
data = ''
read_step = None
while not rospy.is_shutdown():
if (rospy.Time.now() - self.lastsync).to_sec() > (self.timeout * 3):
if self.synced:
rospy.logerr("Lost sync with device, restarting...")
else:
rospy.logerr(
"Unable to sync with device; possible link problem or link software version mismatch such as hydro rosserial_python with groovy Arduino")
self.lastsync_lost = rospy.Time.now()
self.sendDiagnostics(diagnostic_msgs.msg.DiagnosticStatus.ERROR, ERROR_NO_SYNC)
self.requestTopics()
self.lastsync = rospy.Time.now()
# This try-block is here because we make multiple calls to read(). Any one of them can throw
# an IOError if there's a serial problem or timeout. In that scenario, a single handler at the
# bottom attempts to reconfigure the topics.
try:
with self.read_lock:
if self.port.inWaiting() < 1:
time.sleep(0.001)
continue
# Find sync flag.
flag = [0, 0]
read_step = 'syncflag'
flag[0] = self.tryRead(1)
if (flag[0] != '\xff'):
continue
# Find protocol version.
read_step = 'protocol'
flag[1] = self.tryRead(1)
if flag[1] != self.protocol_ver:
self.sendDiagnostics(
diagnostic_msgs.msg.DiagnosticStatus.ERROR, ERROR_MISMATCHED_PROTOCOL)
rospy.logerr(
"Mismatched protocol version in packet (%s): lost sync or rosserial_python is from different ros release than the rosserial client" % repr(flag[1]))
protocol_ver_msgs = {
'\xff': 'Rev 0 (rosserial 0.4 and earlier)', '\xfe': 'Rev 1 (rosserial 0.5+)', '\xfd': 'Some future rosserial version'}
if flag[1] in protocol_ver_msgs:
found_ver_msg = 'Protocol version of client is ' + \
protocol_ver_msgs[flag[1]]
else:
found_ver_msg = "Protocol version of client is unrecognized"
rospy.loginfo("%s, expected %s" %
(found_ver_msg, protocol_ver_msgs[self.protocol_ver]))
continue
# Read message length.
read_step = 'message length'
msg_len_bytes = self.tryRead(2)
msg_length, = struct.unpack("<h", msg_len_bytes)
# Read message length checksum.
read_step = 'message length checksum'
msg_len_chk = self.tryRead(1)
msg_len_checksum = sum(map(ord, msg_len_bytes)) + ord(msg_len_chk)
# Validate message length checksum.
if msg_len_checksum % 256 != 255:
rospy.loginfo("wrong checksum for msg length, length %d" % (msg_length))
rospy.loginfo("chk is %d" % ord(msg_len_chk))
continue
# Read topic id (2 bytes)
read_step = 'topic id'
topic_id_header = self.tryRead(2)
topic_id, = struct.unpack("<h", topic_id_header)
# Read serialized message data.
read_step = 'data'
try:
msg = self.tryRead(msg_length)
except IOError:
self.sendDiagnostics(
diagnostic_msgs.msg.DiagnosticStatus.ERROR, ERROR_PACKET_FAILED)
rospy.loginfo("Packet Failed : Failed to read msg data")
rospy.loginfo("expected msg length is %d", msg_length)
raise
# Reada checksum for topic id and msg
read_step = 'data checksum'
chk = self.tryRead(1)
checksum = sum(map(ord, topic_id_header)) + sum(map(ord, msg)) + ord(chk)
# Validate checksum.
if checksum % 256 == 255:
self.synced = True
self.lastsync_success = rospy.Time.now()
try:
self.callbacks[topic_id](msg)
except KeyError:
rospy.logerr("Tried to publish before configured, topic id %d" % topic_id)
self.requestTopics()
rospy.sleep(0.001)
else:
rospy.loginfo("wrong checksum for topic id and msg")
except IOError as exc:
rospy.logwarn('Last read step: %s' % read_step)
rospy.logwarn('Run loop error: %s' % exc)
# One of the read calls had an issue. Just to be safe, request that the client
# reinitialize their topics.
with self.read_lock:
self.port.flushInput()
with self.write_lock:
self.port.flushOutput()
self.requestTopics()
def setPublishSize(self, bytes):
if self.buffer_out < 0:
self.buffer_out = bytes
rospy.loginfo("Note: publish buffer size is %d bytes" % self.buffer_out)
def setSubscribeSize(self, bytes):
if self.buffer_in < 0:
self.buffer_in = bytes
rospy.loginfo("Note: subscribe buffer size is %d bytes" % self.buffer_in)
def setupPublisher(self, data):
""" Register a new publisher. """
try:
msg = TopicInfo()
msg.deserialize(data)
pub = Publisher(msg)
self.publishers[msg.topic_id] = pub
self.callbacks[msg.topic_id] = pub.handlePacket
self.setPublishSize(msg.buffer_size)
rospy.loginfo("Setup publisher on %s [%s]" % (msg.topic_name, msg.message_type))
except Exception as e:
rospy.logerr("Creation of publisher failed: %s", e)
def setupSubscriber(self, data):
""" Register a new subscriber. """
try:
msg = TopicInfo()
msg.deserialize(data)
if not msg.topic_name in self.subscribers.keys():
sub = Subscriber(msg, self)
self.subscribers[msg.topic_name] = sub
self.setSubscribeSize(msg.buffer_size)
rospy.loginfo("Setup subscriber on %s [%s]" % (msg.topic_name, msg.message_type))
elif msg.message_type != self.subscribers[msg.topic_name].message._type:
old_message_type = self.subscribers[msg.topic_name].message._type
self.subscribers[msg.topic_name].unregister()
sub = Subscriber(msg, self)
self.subscribers[msg.topic_name] = sub
self.setSubscribeSize(msg.buffer_size)
rospy.loginfo("Change the message type of subscriber on %s from [%s] to [%s]" % (
msg.topic_name, old_message_type, msg.message_type))
except Exception as e:
rospy.logerr("Creation of subscriber failed: %s", e)
def setupServiceServerPublisher(self, data):
""" Register a new service server. """
try:
msg = TopicInfo()
msg.deserialize(data)
self.setPublishSize(msg.buffer_size)
try:
srv = self.services[msg.topic_name]
except KeyError:
srv = ServiceServer(msg, self)
rospy.loginfo("Setup service server on %s [%s]" %
(msg.topic_name, msg.message_type))
self.services[msg.topic_name] = srv
if srv.mres._md5sum == msg.md5sum:
self.callbacks[msg.topic_id] = srv.handlePacket
else:
raise Exception('Checksum does not match: ' + srv.mres._md5sum + ',' + msg.md5sum)
except Exception as e:
rospy.logerr("Creation of service server failed: %s", e)
def setupServiceServerSubscriber(self, data):
""" Register a new service server. """
try:
msg = TopicInfo()
msg.deserialize(data)
self.setSubscribeSize(msg.buffer_size)
try:
srv = self.services[msg.topic_name]
except KeyError:
srv = ServiceServer(msg, self)
rospy.loginfo("Setup service server on %s [%s]" %
(msg.topic_name, msg.message_type))
self.services[msg.topic_name] = srv
if srv.mreq._md5sum == msg.md5sum:
srv.id = msg.topic_id
else:
raise Exception('Checksum does not match: ' + srv.mreq._md5sum + ',' + msg.md5sum)
except Exception as e:
rospy.logerr("Creation of service server failed: %s", e)
def setupServiceClientPublisher(self, data):
""" Register a new service client. """
try:
msg = TopicInfo()
msg.deserialize(data)
self.setPublishSize(msg.buffer_size)
try:
srv = self.services[msg.topic_name]
except KeyError:
srv = ServiceClient(msg, self)
rospy.loginfo("Setup service client on %s [%s]" %
(msg.topic_name, msg.message_type))
self.services[msg.topic_name] = srv
if srv.mreq._md5sum == msg.md5sum:
self.callbacks[msg.topic_id] = srv.handlePacket
else:
raise Exception('Checksum does not match: ' + srv.mreq._md5sum + ',' + msg.md5sum)
except Exception as e:
rospy.logerr("Creation of service client failed: %s", e)
def setupServiceClientSubscriber(self, data):
""" Register a new service client. """
try:
msg = TopicInfo()
msg.deserialize(data)
self.setSubscribeSize(msg.buffer_size)
try:
srv = self.services[msg.topic_name]
except KeyError:
srv = ServiceClient(msg, self)
rospy.loginfo("Setup service client on %s [%s]" %
(msg.topic_name, msg.message_type))
self.services[msg.topic_name] = srv
if srv.mres._md5sum == msg.md5sum:
srv.id = msg.topic_id
else:
raise Exception('Checksum does not match: ' + srv.mres._md5sum + ',' + msg.md5sum)
except Exception as e:
rospy.logerr("Creation of service client failed: %s", e)
def handleTimeRequest(self, data):
""" Respond to device with system time. """
t = Time()
t.data = rospy.Time.now()
data_buffer = StringIO.StringIO()
t.serialize(data_buffer)
self.send(TopicInfo.ID_TIME, data_buffer.getvalue())
self.lastsync = rospy.Time.now()
def handleParameterRequest(self, data):
""" Send parameters to device. Supports only simple datatypes and arrays of such. """
req = RequestParamRequest()
req.deserialize(data)
resp = RequestParamResponse()
try:
param = rospy.get_param(req.name)
except KeyError:
rospy.logerr("Parameter %s does not exist" % req.name)
return
if param is None:
rospy.logerr("Parameter %s does not exist" % req.name)
return
if isinstance(param, dict):
rospy.logerr("Cannot send param %s because it is a dictionary" % req.name)
return
if not isinstance(param, list):
param = [param]
# check to make sure that all parameters in list are same type
t = type(param[0])
for p in param:
if t != type(p):
rospy.logerr('All Paramers in the list %s must be of the same type' % req.name)
return
if t == int or t == bool:
resp.ints = param
if t == float:
resp.floats = param
if t == str:
resp.strings = param
data_buffer = StringIO.StringIO()
resp.serialize(data_buffer)
self.send(TopicInfo.ID_PARAMETER_REQUEST, data_buffer.getvalue())
def handleLoggingRequest(self, data):
""" Forward logging information from serial device into ROS. """
msg = Log()
msg.deserialize(data)
if msg.level == Log.ROSDEBUG:
rospy.logdebug(msg.msg)
elif msg.level == Log.INFO:
rospy.loginfo(msg.msg)
elif msg.level == Log.WARN:
rospy.logwarn(msg.msg)
elif msg.level == Log.ERROR:
rospy.logerr(msg.msg)
elif msg.level == Log.FATAL:
rospy.logfatal(msg.msg)
def send(self, topic, msg):
"""
Queues data to be written to the serial port.
"""
self.write_queue.put((topic, msg))
def _write(self, data):
"""
Writes raw data over the serial port. Assumes the data is formatting as a packet. http://wiki.ros.org/rosserial/Overview/Protocol
"""
with self.write_lock:
self.port.write(data)
self.last_write = rospy.Time.now()
def _send(self, topic, msg):
"""
Send a message on a particular topic to the device.
"""
length = len(msg)
if self.buffer_in > 0 and length > self.buffer_in:
rospy.logerr("Message from ROS network dropped: message larger than buffer.\n%s" % msg)
return -1
else:
# modified frame : header(2 bytes) + msg_len(2 bytes) + msg_len_chk(1 byte) + topic_id(2 bytes) + msg(x bytes) + msg_topic_id_chk(1 byte)
# second byte of header is protocol version
msg_len_checksum = 255 - (((length & 255) + (length >> 8)) % 256)
msg_checksum = 255 - (((topic & 255) + (topic >> 8) + sum([ord(x) for x in msg])) % 256)
data = "\xff" + self.protocol_ver + \
chr(length & 255) + chr(length >> 8) + \
chr(msg_len_checksum) + chr(topic & 255) + chr(topic >> 8)
data = data + msg + chr(msg_checksum)
self._write(data)
return length
def processWriteQueue(self):
"""
Main loop for the thread that processes outgoing data to write to the serial port.
"""
while not rospy.is_shutdown():
if self.write_queue.empty():
time.sleep(0.01)
else:
data = self.write_queue.get()
while True:
try:
if isinstance(data, tuple):
topic, msg = data
self._send(topic, msg)
elif isinstance(data, basestring):
self._write(data)
else:
rospy.logerr("Trying to write invalid data type: %s" % type(data))
break
except SerialTimeoutException as exc:
rospy.logerr('Write timeout: %s' % exc)
time.sleep(1)
def sendDiagnostics(self, level, msg_text):
msg = diagnostic_msgs.msg.DiagnosticArray()
status = diagnostic_msgs.msg.DiagnosticStatus()
status.name = "rosserial_python"
msg.header.stamp = rospy.Time.now()
msg.status.append(status)
status.message = msg_text
status.level = level
status.values.append(diagnostic_msgs.msg.KeyValue())
status.values[0].key = "last sync"
if self.lastsync.to_sec() > 0:
status.values[0].value = time.ctime(self.lastsync.to_sec())
else:
status.values[0].value = "never"
status.values.append(diagnostic_msgs.msg.KeyValue())
status.values[1].key = "last sync lost"
status.values[1].value = time.ctime(self.lastsync_lost.to_sec())
self.pub_diagnostics.publish(msg)
|
keepkey.py
|
from binascii import hexlify, unhexlify
import traceback
import sys
from typing import NamedTuple, Any, Optional, Dict, Union, List, Tuple, TYPE_CHECKING
from electrum.util import bfh, bh2u, UserCancelled, UserFacingException
from electrum.bip32 import BIP32Node
from electrum import constants
from electrum.i18n import _
from electrum.transaction import Transaction, PartialTransaction, PartialTxInput, PartialTxOutput
from electrum.keystore import Hardware_KeyStore
from electrum.plugin import Device, runs_in_hwd_thread
from electrum.base_wizard import ScriptTypeNotSupported
from ..hw_wallet import HW_PluginBase
from ..hw_wallet.plugin import (is_any_tx_output_on_change_branch, trezor_validate_op_return_output_and_get_data,
get_xpubs_and_der_suffixes_from_txinout)
if TYPE_CHECKING:
import usb1
from .client import KeepKeyClient
# TREZOR initialization methods
TIM_NEW, TIM_RECOVER, TIM_MNEMONIC, TIM_PRIVKEY = range(0, 4)
class KeepKey_KeyStore(Hardware_KeyStore):
hw_type = 'keepkey'
device = 'KeepKey'
plugin: 'KeepKeyPlugin'
def get_client(self, force_pair=True):
return self.plugin.get_client(self, force_pair)
def decrypt_message(self, sequence, message, password):
raise UserFacingException(_('Encryption and decryption are not implemented by {}').format(self.device))
@runs_in_hwd_thread
def sign_message(self, sequence, message, password):
client = self.get_client()
address_path = self.get_derivation_prefix() + "/%d/%d"%sequence
address_n = client.expand_path(address_path)
msg_sig = client.sign_message(self.plugin.get_coin_name(), address_n, message)
return msg_sig.signature
@runs_in_hwd_thread
def sign_transaction(self, tx, password):
if tx.is_complete():
return
# previous transactions used as inputs
prev_tx = {}
for txin in tx.inputs():
tx_hash = txin.prevout.txid.hex()
if txin.utxo is None and not txin.is_segwit():
raise UserFacingException(_('Missing previous tx for legacy input.'))
prev_tx[tx_hash] = txin.utxo
self.plugin.sign_transaction(self, tx, prev_tx)
class KeepKeyPlugin(HW_PluginBase):
# Derived classes provide:
#
# class-static variables: client_class, firmware_URL, handler_class,
# libraries_available, libraries_URL, minimum_firmware,
# wallet_class, ckd_public, types, HidTransport
firmware_URL = 'https://www.keepkey.com'
libraries_URL = 'https://github.com/keepkey/python-keepkey'
minimum_firmware = (1, 0, 0)
keystore_class = KeepKey_KeyStore
SUPPORTED_XTYPES = ('standard', 'p2wpkh-p2sh', 'p2wpkh', 'p2wsh-p2sh', 'p2wsh')
MAX_LABEL_LEN = 32
def __init__(self, parent, config, name):
HW_PluginBase.__init__(self, parent, config, name)
try:
from . import client
import keepkeylib
import keepkeylib.ckd_public
import keepkeylib.transport_hid
import keepkeylib.transport_webusb
self.client_class = client.KeepKeyClient
self.ckd_public = keepkeylib.ckd_public
self.types = keepkeylib.client.types
self.DEVICE_IDS = (keepkeylib.transport_hid.DEVICE_IDS +
keepkeylib.transport_webusb.DEVICE_IDS)
# only "register" hid device id:
self.device_manager().register_devices(keepkeylib.transport_hid.DEVICE_IDS, plugin=self)
# for webusb transport, use custom enumerate function:
self.device_manager().register_enumerate_func(self.enumerate)
self.libraries_available = True
except ImportError:
self.libraries_available = False
@runs_in_hwd_thread
def enumerate(self):
from keepkeylib.transport_webusb import WebUsbTransport
results = []
for dev in WebUsbTransport.enumerate():
path = self._dev_to_str(dev)
results.append(Device(path=path,
interface_number=-1,
id_=path,
product_key=(dev.getVendorID(), dev.getProductID()),
usage_page=0,
transport_ui_string=f"webusb:{path}"))
return results
@staticmethod
def _dev_to_str(dev: "usb1.USBDevice") -> str:
return ":".join(str(x) for x in ["%03i" % (dev.getBusNumber(),)] + dev.getPortNumberList())
@runs_in_hwd_thread
def hid_transport(self, pair):
from keepkeylib.transport_hid import HidTransport
return HidTransport(pair)
@runs_in_hwd_thread
def webusb_transport(self, device):
from keepkeylib.transport_webusb import WebUsbTransport
for dev in WebUsbTransport.enumerate():
if device.path == self._dev_to_str(dev):
return WebUsbTransport(dev)
@runs_in_hwd_thread
def _try_hid(self, device):
self.logger.info("Trying to connect over USB...")
if device.interface_number == 1:
pair = [None, device.path]
else:
pair = [device.path, None]
try:
return self.hid_transport(pair)
except BaseException as e:
# see fdb810ba622dc7dbe1259cbafb5b28e19d2ab114
# raise
self.logger.info(f"cannot connect at {device.path} {e}")
return None
@runs_in_hwd_thread
def _try_webusb(self, device):
self.logger.info("Trying to connect over WebUSB...")
try:
return self.webusb_transport(device)
except BaseException as e:
self.logger.info(f"cannot connect at {device.path} {e}")
return None
@runs_in_hwd_thread
def create_client(self, device, handler):
if device.product_key[1] == 2:
transport = self._try_webusb(device)
else:
transport = self._try_hid(device)
if not transport:
self.logger.info("cannot connect to device")
return
self.logger.info(f"connected to device at {device.path}")
client = self.client_class(transport, handler, self)
# Try a ping for device sanity
try:
client.ping('t')
except BaseException as e:
self.logger.info(f"ping failed {e}")
return None
if not client.atleast_version(*self.minimum_firmware):
msg = (_('Outdated {} firmware for device labelled {}. Please '
'download the updated firmware from {}')
.format(self.device, client.label(), self.firmware_URL))
self.logger.info(msg)
if handler:
handler.show_error(msg)
else:
raise UserFacingException(msg)
return None
return client
@runs_in_hwd_thread
def get_client(self, keystore, force_pair=True, *,
devices=None, allow_user_interaction=True) -> Optional['KeepKeyClient']:
client = super().get_client(keystore, force_pair,
devices=devices,
allow_user_interaction=allow_user_interaction)
# returns the client for a given keystore. can use xpub
if client:
client.used()
return client
def get_coin_name(self):
return "Testnet" if constants.net.TESTNET else "Dogecoin"
def initialize_device(self, device_id, wizard, handler):
# Initialization method
msg = _("Choose how you want to initialize your {}.\n\n"
"The first two methods are secure as no secret information "
"is entered into your computer.\n\n"
"For the last two methods you input secrets on your keyboard "
"and upload them to your {}, and so you should "
"only do those on a computer you know to be trustworthy "
"and free of malware."
).format(self.device, self.device)
choices = [
# Must be short as QT doesn't word-wrap radio button text
(TIM_NEW, _("Let the device generate a completely new seed randomly")),
(TIM_RECOVER, _("Recover from a seed you have previously written down")),
(TIM_MNEMONIC, _("Upload a BIP39 mnemonic to generate the seed")),
(TIM_PRIVKEY, _("Upload a master private key"))
]
def f(method):
import threading
settings = self.request_trezor_init_settings(wizard, method, self.device)
t = threading.Thread(target=self._initialize_device_safe, args=(settings, method, device_id, wizard, handler))
t.setDaemon(True)
t.start()
exit_code = wizard.loop.exec_()
if exit_code != 0:
# this method (initialize_device) was called with the expectation
# of leaving the device in an initialized state when finishing.
# signal that this is not the case:
raise UserCancelled()
wizard.choice_dialog(title=_('Initialize Device'), message=msg, choices=choices, run_next=f)
def _initialize_device_safe(self, settings, method, device_id, wizard, handler):
exit_code = 0
try:
self._initialize_device(settings, method, device_id, wizard, handler)
except UserCancelled:
exit_code = 1
except BaseException as e:
self.logger.exception('')
handler.show_error(repr(e))
exit_code = 1
finally:
wizard.loop.exit(exit_code)
@runs_in_hwd_thread
def _initialize_device(self, settings, method, device_id, wizard, handler):
item, label, pin_protection, passphrase_protection = settings
language = 'english'
devmgr = self.device_manager()
client = devmgr.client_by_id(device_id)
if not client:
raise Exception(_("The device was disconnected."))
if method == TIM_NEW:
strength = 64 * (item + 2) # 128, 192 or 256
client.reset_device(True, strength, passphrase_protection,
pin_protection, label, language)
elif method == TIM_RECOVER:
word_count = 6 * (item + 2) # 12, 18 or 24
client.step = 0
client.recovery_device(word_count, passphrase_protection,
pin_protection, label, language)
elif method == TIM_MNEMONIC:
pin = pin_protection # It's the pin, not a boolean
client.load_device_by_mnemonic(str(item), pin,
passphrase_protection,
label, language)
else:
pin = pin_protection # It's the pin, not a boolean
client.load_device_by_xprv(item, pin, passphrase_protection,
label, language)
def _make_node_path(self, xpub, address_n):
bip32node = BIP32Node.from_xkey(xpub)
node = self.types.HDNodeType(
depth=bip32node.depth,
fingerprint=int.from_bytes(bip32node.fingerprint, 'big'),
child_num=int.from_bytes(bip32node.child_number, 'big'),
chain_code=bip32node.chaincode,
public_key=bip32node.eckey.get_public_key_bytes(compressed=True),
)
return self.types.HDNodePathType(node=node, address_n=address_n)
def setup_device(self, device_info, wizard, purpose):
device_id = device_info.device.id_
client = self.scan_and_create_client_for_device(device_id=device_id, wizard=wizard)
if not device_info.initialized:
self.initialize_device(device_id, wizard, client.handler)
wizard.run_task_without_blocking_gui(
task=lambda: client.get_xpub("m", 'standard'))
client.used()
return client
def get_xpub(self, device_id, derivation, xtype, wizard):
if xtype not in self.SUPPORTED_XTYPES:
raise ScriptTypeNotSupported(_('This type of script is not supported with {}.').format(self.device))
client = self.scan_and_create_client_for_device(device_id=device_id, wizard=wizard)
xpub = client.get_xpub(derivation, xtype)
client.used()
return xpub
def get_keepkey_input_script_type(self, electrum_txin_type: str):
if electrum_txin_type in ('p2wpkh', 'p2wsh'):
return self.types.SPENDWITNESS
if electrum_txin_type in ('p2wpkh-p2sh', 'p2wsh-p2sh'):
return self.types.SPENDP2SHWITNESS
if electrum_txin_type in ('p2pkh',):
return self.types.SPENDADDRESS
if electrum_txin_type in ('p2sh',):
return self.types.SPENDMULTISIG
raise ValueError('unexpected txin type: {}'.format(electrum_txin_type))
def get_keepkey_output_script_type(self, electrum_txin_type: str):
if electrum_txin_type in ('p2wpkh', 'p2wsh'):
return self.types.PAYTOWITNESS
if electrum_txin_type in ('p2wpkh-p2sh', 'p2wsh-p2sh'):
return self.types.PAYTOP2SHWITNESS
if electrum_txin_type in ('p2pkh',):
return self.types.PAYTOADDRESS
if electrum_txin_type in ('p2sh',):
return self.types.PAYTOMULTISIG
raise ValueError('unexpected txin type: {}'.format(electrum_txin_type))
@runs_in_hwd_thread
def sign_transaction(self, keystore, tx: PartialTransaction, prev_tx):
self.prev_tx = prev_tx
client = self.get_client(keystore)
inputs = self.tx_inputs(tx, for_sig=True, keystore=keystore)
outputs = self.tx_outputs(tx, keystore=keystore)
signatures = client.sign_tx(self.get_coin_name(), inputs, outputs,
lock_time=tx.locktime, version=tx.version)[0]
signatures = [(bh2u(x) + '01') for x in signatures]
tx.update_signatures(signatures)
@runs_in_hwd_thread
def show_address(self, wallet, address, keystore=None):
if keystore is None:
keystore = wallet.get_keystore()
if not self.show_address_helper(wallet, address, keystore):
return
client = self.get_client(keystore)
if not client.atleast_version(1, 3):
keystore.handler.show_error(_("Your device firmware is too old"))
return
deriv_suffix = wallet.get_address_index(address)
derivation = keystore.get_derivation_prefix()
address_path = "%s/%d/%d"%(derivation, *deriv_suffix)
address_n = client.expand_path(address_path)
script_type = self.get_keepkey_input_script_type(wallet.txin_type)
# prepare multisig, if available:
xpubs = wallet.get_master_public_keys()
if len(xpubs) > 1:
pubkeys = wallet.get_public_keys(address)
# sort xpubs using the order of pubkeys
sorted_pairs = sorted(zip(pubkeys, xpubs))
multisig = self._make_multisig(
wallet.m,
[(xpub, deriv_suffix) for pubkey, xpub in sorted_pairs])
else:
multisig = None
client.get_address(self.get_coin_name(), address_n, True, multisig=multisig, script_type=script_type)
def tx_inputs(self, tx: Transaction, *, for_sig=False, keystore: 'KeepKey_KeyStore' = None):
inputs = []
for txin in tx.inputs():
txinputtype = self.types.TxInputType()
if txin.is_coinbase_input():
prev_hash = b"\x00"*32
prev_index = 0xffffffff # signed int -1
else:
if for_sig:
assert isinstance(tx, PartialTransaction)
assert isinstance(txin, PartialTxInput)
assert keystore
if len(txin.pubkeys) > 1:
xpubs_and_deriv_suffixes = get_xpubs_and_der_suffixes_from_txinout(tx, txin)
multisig = self._make_multisig(txin.num_sig, xpubs_and_deriv_suffixes)
else:
multisig = None
script_type = self.get_keepkey_input_script_type(txin.script_type)
txinputtype = self.types.TxInputType(
script_type=script_type,
multisig=multisig)
my_pubkey, full_path = keystore.find_my_pubkey_in_txinout(txin)
if full_path:
txinputtype.address_n.extend(full_path)
prev_hash = txin.prevout.txid
prev_index = txin.prevout.out_idx
if txin.value_sats() is not None:
txinputtype.amount = txin.value_sats()
txinputtype.prev_hash = prev_hash
txinputtype.prev_index = prev_index
if txin.script_sig is not None:
txinputtype.script_sig = txin.script_sig
txinputtype.sequence = txin.nsequence
inputs.append(txinputtype)
return inputs
def _make_multisig(self, m, xpubs):
if len(xpubs) == 1:
return None
pubkeys = [self._make_node_path(xpub, deriv) for xpub, deriv in xpubs]
return self.types.MultisigRedeemScriptType(
pubkeys=pubkeys,
signatures=[b''] * len(pubkeys),
m=m)
def tx_outputs(self, tx: PartialTransaction, *, keystore: 'KeepKey_KeyStore'):
def create_output_by_derivation():
script_type = self.get_keepkey_output_script_type(txout.script_type)
if len(txout.pubkeys) > 1:
xpubs_and_deriv_suffixes = get_xpubs_and_der_suffixes_from_txinout(tx, txout)
multisig = self._make_multisig(txout.num_sig, xpubs_and_deriv_suffixes)
else:
multisig = None
my_pubkey, full_path = keystore.find_my_pubkey_in_txinout(txout)
assert full_path
txoutputtype = self.types.TxOutputType(
multisig=multisig,
amount=txout.value,
address_n=full_path,
script_type=script_type)
return txoutputtype
def create_output_by_address():
txoutputtype = self.types.TxOutputType()
txoutputtype.amount = txout.value
if address:
txoutputtype.script_type = self.types.PAYTOADDRESS
txoutputtype.address = address
else:
txoutputtype.script_type = self.types.PAYTOOPRETURN
txoutputtype.op_return_data = trezor_validate_op_return_output_and_get_data(txout)
return txoutputtype
outputs = []
has_change = False
any_output_on_change_branch = is_any_tx_output_on_change_branch(tx)
for txout in tx.outputs():
address = txout.address
use_create_by_derivation = False
if txout.is_mine and not has_change:
# prioritise hiding outputs on the 'change' branch from user
# because no more than one change address allowed
if txout.is_change == any_output_on_change_branch:
use_create_by_derivation = True
has_change = True
if use_create_by_derivation:
txoutputtype = create_output_by_derivation()
else:
txoutputtype = create_output_by_address()
outputs.append(txoutputtype)
return outputs
def electrum_tx_to_txtype(self, tx: Optional[Transaction]):
t = self.types.TransactionType()
if tx is None:
# probably for segwit input and we don't need this prev txn
return t
tx.deserialize()
t.version = tx.version
t.lock_time = tx.locktime
inputs = self.tx_inputs(tx)
t.inputs.extend(inputs)
for out in tx.outputs():
o = t.bin_outputs.add()
o.amount = out.value
o.script_pubkey = out.scriptpubkey
return t
# This function is called from the TREZOR libraries (via tx_api)
def get_tx(self, tx_hash):
tx = self.prev_tx[tx_hash]
return self.electrum_tx_to_txtype(tx)
|
pixiv_crawler.py
|
# -*- coding: utf-8 -*-
"""
-------------------------------------------------
File Name： pixiv_crawler
Description :
Author : zdf's desktop
date： 2020/5/28
-------------------------------------------------
Change Activity:
2020/5/28:21:14
-------------------------------------------------
"""
# -*- encoding: utf-8 -*-
from urllib import request
import threading
import queue
import re
import os
import shutil
import pymongo
class pixiv:
def __init__(self):
self.folder = 'Pixiv'
self.web_coding = 'utf-8'
self.root = os.path.dirname(os.path.abspath(__file__))
self.DefaultHeader = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0",
"Accept": "*/*",
"Accept-Language": "zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3",
"Accept-Encoding": "",
"Connection": "keep-alive",
}
self.data_low = []
self.num = 0
def _http(self, url, headers, Obj=False):
res = request.urlopen(request.Request(url, headers=headers, method='GET'))
if Obj:
return res
else:
return res.read().decode(self.web_coding, "ignore")
def data_image(self, url_id):
_header = self.DefaultHeader.copy()
_header["Referer"] = "https://www.pixiv.net/member_illust.php?mode=medium&illust_id={}".format(url_id)
_url_data = "https://www.pixiv.net/touch/ajax/illust/details?illust_id={}".format(url_id)
_data_details = self._http(_url_data, _header)
data_url = self.sort_data(re.findall('"url_big":"[^"]*"', _data_details))
data_uid = str(str(str(re.findall('"user_id":"[^"]*"', _data_details)[0]).split(':', 1)[-1]).strip('"'))
return data_url, _header, data_uid
def sort_data(self, data):
_data = []
for item in data:
if item not in _data:
_data.append(item)
return [str(str(item).replace('\\', '').split(':', 1)[-1]).strip('"') for item in _data]
def get_item(self, UserID=None):
if not UserID:
UserID = 'https://www.pixiv.net/ranking.php?mode=monthly'
if '://' in str(UserID):
Mode_ID = False
else:
Mode_ID = True
if Mode_ID:
_url = "https://www.pixiv.net/ajax/user/{}/profile/all".format(str(UserID))
page = self._http(_url, self.DefaultHeader, True)
if page.code != 200:
raise Exception("Pixiv Page:", page.code)
_data = re.findall('"[0-9]+":null', page.read().decode(self.web_coding, "ignore"))
self.data_low = [str(str(item).split(":")[0]).strip('"') for item in _data if ':null' in str(item)]
else:
page = self._http(UserID, self.DefaultHeader, True)
if page.code != 200:
raise Exception("Pixiv Page:", page.code)
_data = re.findall('data-src="[^"]*"', page.read().decode(self.web_coding, "ignore"))
self.data_low = [str(str(str(str(str(item).split("=", 1)[-1]).strip('"')).rsplit('/', 1)[-1]).split('_')[0])
for item in _data if '/img-master/img/' in str(item)]
self.fliter_item()
def fliter_item(self):
folder = os.path.join(self.root, self.folder)
if not os.path.exists(folder):
return None
_split = "_"
_exist = {}.fromkeys([str(str(item).split(_split)[1]) for item in os.listdir(folder) if _split in item]).keys()
print("Exist Item:", len(_exist))
for _item in self.data_low.copy():
if _item in _exist:
self.data_low.remove(_item)
def get_data_by_item(self, item):
data = self.data_image(item)
for data_url in data[0]:
image = self._http(data_url, data[1], True)
if image.code != 200:
raise Exception("Pixiv Image: [{} | {}]".format(image.code, data[0]))
self.write(str("{}_{}").format(str(data[2]), str(str(data_url).rsplit('/', 1)[-1])), image.read())
def get_data(self, data_list=None):
if not data_list:
data_list = self.data_low
for item in data_list:
self.get_data_by_item(item)
print("\nTotal Image: ", self.num)
def write(self, name, data):
folder = os.path.join(self.root, self.folder)
if not os.path.exists(folder):
os.mkdir(folder)
file = os.path.join(folder, str(name))
fp = open(file, 'wb')
fp.write(data)
fp.close()
self.num += 1
print("Pixiv Image: [ OK | {} ]".format(file))
def add_queue(self, _queue, data_list=None):
for item in data_list:
_item = str(item).strip()
if item and _item:
_queue.put(_item)
def multi_data(self, data_list=None, max=25):
if not data_list:
data_list = self.data_low
print("New Item:", len(data_list))
_threads = []
_queue = queue.Queue(maxsize=max)
task_main = threading.Thread(target=self.add_queue, args=(_queue, data_list))
task_main.setName("TaskMain")
task_main.setDaemon(True)
task_main.start()
while _queue.qsize() > 0:
if len(_threads) >= max:
for _item in _threads.copy():
if not _item.is_alive():
_threads.remove(_item)
continue
item = _queue.get()
task = threading.Thread(target=self.get_data_by_item, args=(item,))
task.setDaemon(True)
task.start()
_threads.append(task)
for _task in _threads:
_task.join()
print("\nTotal Image: ", self.num)
def insert_into_daily_collection(self):
client = pymongo.MongoClient(host='localhost', port=27017)
db = client['test_db']
collection = db['pixiv_daily_pics']
# collection.delete_many({})
images_url = []
for filename in os.listdir(os.path.join(self.root, self.folder)):
if filename.endswith(".jpg") or filename.endswith(".png"):
# filename = filename.replace('.', "_")
temp = {
'filename': filename,
'diff': filename[-6:-4:],
'likes': 0,
}
# print(temp)
images_url.append(temp)
# print(images_url)
for url in images_url:
# print(url["filename"])
if collection.find_one({"filename": url["filename"]}):
print("found a exist file!", url["filename"])
else:
collection.insert(url)
client.close()
def copy_image_file(self):
src = os.path.join(self.root, self.folder)
dst = os.path.join(self.root, "static")
dst = os.path.join(dst, "images")
dst = os.path.join(dst, "Pixiv")
# print("src=", src, "dst=", dst)
shutil.rmtree(dst)
shutil.copytree(src, dst)
def remove_old_pics(self):
client = pymongo.MongoClient(host='localhost', port=27017)
db = client['test_db']
collection = db['pixiv_daily_pics']
query = collection.find({"likes": {"$lt": 1}})
delete_list = []
for val in query:
delete_list.append(val["filename"])
# print(delete_list)
dst = os.path.join(self.root, "static")
dst = os.path.join(dst, "images")
dst = os.path.join(dst, "Pixiv")
count = 0
for filename in delete_list:
if os.path.isfile(os.path.join(dst, filename)):
count += 1
print("file removed:", os.path.join(dst, filename))
# using the absolute path, not the relative
os.remove(os.path.join(dst, filename))
else:
pass
print("removing ", count, " files")
collection.delete_many({"likes": {"$lt": 1}})
client.close()
if __name__ == '__main__':
try:
task = os.sys.argv[1]
except:
task = None
p = pixiv()
p.get_item(task)
p.multi_data(max=25)
p.remove_old_pics()
p.insert_into_daily_collection()
p.copy_image_file()
|
tft_display.py
|
import Adafruit_GPIO.SPI as SPI
import ST7789 as TFT # https://github.com/solinnovay/Python_ST7789
import urllib.request
from io import BytesIO
from PIL import Image
from collections import OrderedDict
import threading
no_cover_image_path = 'img/no_cover.png'
class ImageLookup(OrderedDict):
"""
A lookup table to store images.
Implements the LRU algorithm to limit the number of stored data.
Code from an official Python documentation.
"""
def __init__(self, max_size, *args, **kwds):
self.maxsize = max_size
super().__init__(*args, **kwds)
def __getitem__(self, key):
value = super().__getitem__(key)
self.move_to_end(key)
return value
def __setitem__(self, key, value):
super().__setitem__(key, value)
if len(self) > self.maxsize:
oldest = next(iter(self))
del self[oldest]
class TftDisplay:
# TODO: Add welcome image
def __init__(self, image_url_source, new_song_event, rst_pin=26, dc_pin=6, blk_pin=13):
# Initialize TFT display
# rst_pin, blk_pin, dc_pin - As GPIO number (int)
spi = SPI.SpiDev(0, 0, max_speed_hz=40000000)
self.width = 240
self.height = 240
self.display = TFT.ST7789(spi=spi, mode=0b11, rst=rst_pin, dc=dc_pin, led=blk_pin)
self.display.begin()
self.display.clear()
self.image_lookup = ImageLookup(20)
self.image_url_source = image_url_source
self.event = new_song_event
self.display_thread = threading.Thread(target=self.display_thread_function)
print("TftDisplay: Display initialized")
def start_display_thread(self):
self.display_thread.start()
def display_thread_function(self):
while True:
self.event.wait()
self.event.clear()
print('TftDisplay: Displaying new image')
album_cover_url = self.image_url_source()
if album_cover_url is None or album_cover_url == '':
self.open_and_display_image(no_cover_image_path)
else:
self.download_and_display_image(album_cover_url)
def download_and_display_image(self, image_url):
image = self._download_image(image_url)
print('TFTDisplay: URL ' + image_url)
# image = Image.Image.convert(image, Image.MODES.RGB)
self._display_image(image)
def open_and_display_image(self, path):
image = self._open_image(path)
self._display_image(image)
def _open_image(self, path):
image = self.image_lookup.get(path)
if image is None:
print('TFTDisplay: Accessing local image')
image = Image.open(path)
image.thumbnail((240, 240), Image.ANTIALIAS)
self.image_lookup[path] = image
return image
def _display_image(self, image):
# TODO: Blend pause symbol into image?
self.display.display(image)
print("TftDisplay: Image displayed")
def _download_image(self, url):
image = self.image_lookup.get(url)
if image is not None: # Image was found in the lookup table
print('TFTDisplay: Image was found in the lookup table')
else:
fd = urllib.request.urlopen(url)
image_file = BytesIO(fd.read())
# Open the image
image = Image.open(image_file)
image.thumbnail((240, 240), Image.ANTIALIAS)
self.image_lookup[url] = image
print("TFTFisplay: Image downloaded")
return image
if __name__ == '__main__':
url = 'https://avatars3.githubusercontent.com/u/34516276?s=88&v=4'
tft_display = TftDisplay(26, 6, 13)
# tft_display.display_image(a)
tft_display.download_and_display_image(url)
|
test017.py
|
import webview
import threading
"""
This example demonstrates creating a save file dialog.
"""
def save_file_dialog():
import time
time.sleep(5)
print(webview.create_file_dialog(webview.SAVE_DIALOG,
directory="/",
save_filename='test.file'))
if __name__ == '__main__':
t = threading.Thread(target=save_file_dialog)
t.start()
webview.create_window("Save file dialog", "http://www.baidu.com")
|
trezor.py
|
import traceback
import sys
from typing import NamedTuple, Any
from electrum_mona.util import bfh, bh2u, versiontuple, UserCancelled, UserFacingException
from electrum_mona.bitcoin import TYPE_ADDRESS, TYPE_SCRIPT
from electrum_mona.bip32 import BIP32Node, convert_bip32_path_to_list_of_uint32 as parse_path
from electrum_mona import constants
from electrum_mona.i18n import _
from electrum_mona.plugin import Device
from electrum_mona.transaction import deserialize, Transaction
from electrum_mona.keystore import Hardware_KeyStore, is_xpubkey, parse_xpubkey
from electrum_mona.base_wizard import ScriptTypeNotSupported, HWD_SETUP_NEW_WALLET
from electrum_mona.logging import get_logger
from ..hw_wallet import HW_PluginBase
from ..hw_wallet.plugin import (is_any_tx_output_on_change_branch, trezor_validate_op_return_output_and_get_data,
LibraryFoundButUnusable, OutdatedHwFirmwareException)
_logger = get_logger(__name__)
try:
import trezorlib
import trezorlib.transport
from trezorlib.transport.bridge import BridgeTransport, call_bridge
from .clientbase import TrezorClientBase
from trezorlib.messages import (
RecoveryDeviceType, HDNodeType, HDNodePathType,
InputScriptType, OutputScriptType, MultisigRedeemScriptType,
TxInputType, TxOutputType, TxOutputBinType, TransactionType, SignTx)
RECOVERY_TYPE_SCRAMBLED_WORDS = RecoveryDeviceType.ScrambledWords
RECOVERY_TYPE_MATRIX = RecoveryDeviceType.Matrix
TREZORLIB = True
except Exception as e:
_logger.exception('error importing trezorlib')
TREZORLIB = False
RECOVERY_TYPE_SCRAMBLED_WORDS, RECOVERY_TYPE_MATRIX = range(2)
# Trezor initialization methods
TIM_NEW, TIM_RECOVER = range(2)
TREZOR_PRODUCT_KEY = 'Trezor'
class TrezorKeyStore(Hardware_KeyStore):
hw_type = 'trezor'
device = TREZOR_PRODUCT_KEY
def get_derivation(self):
return self.derivation
def get_client(self, force_pair=True):
return self.plugin.get_client(self, force_pair)
def decrypt_message(self, sequence, message, password):
raise UserFacingException(_('Encryption and decryption are not implemented by {}').format(self.device))
def sign_message(self, sequence, message, password):
client = self.get_client()
address_path = self.get_derivation() + "/%d/%d"%sequence
msg_sig = client.sign_message(address_path, message)
return msg_sig.signature
def sign_transaction(self, tx, password):
if tx.is_complete():
return
# previous transactions used as inputs
prev_tx = {}
# path of the xpubs that are involved
xpub_path = {}
for txin in tx.inputs():
pubkeys, x_pubkeys = tx.get_sorted_pubkeys(txin)
tx_hash = txin['prevout_hash']
if txin.get('prev_tx') is None and not Transaction.is_segwit_input(txin):
raise UserFacingException(_('Offline signing with {} is not supported for legacy inputs.').format(self.device))
prev_tx[tx_hash] = txin['prev_tx']
for x_pubkey in x_pubkeys:
if not is_xpubkey(x_pubkey):
continue
xpub, s = parse_xpubkey(x_pubkey)
if xpub == self.get_master_public_key():
xpub_path[xpub] = self.get_derivation()
self.plugin.sign_transaction(self, tx, prev_tx, xpub_path)
class TrezorInitSettings(NamedTuple):
word_count: int
label: str
pin_enabled: bool
passphrase_enabled: bool
recovery_type: Any = None
no_backup: bool = False
class TrezorPlugin(HW_PluginBase):
# Derived classes provide:
#
# class-static variables: client_class, firmware_URL, handler_class,
# libraries_available, libraries_URL, minimum_firmware,
# wallet_class, types
firmware_URL = 'https://wallet.trezor.io'
libraries_URL = 'https://github.com/trezor/python-trezor'
minimum_firmware = (1, 6, 0)
keystore_class = TrezorKeyStore
minimum_library = (0, 11, 0)
maximum_library = (0, 12)
SUPPORTED_XTYPES = ('standard', 'p2wpkh-p2sh', 'p2wpkh', 'p2wsh-p2sh', 'p2wsh')
DEVICE_IDS = (TREZOR_PRODUCT_KEY,)
MAX_LABEL_LEN = 32
def __init__(self, parent, config, name):
super().__init__(parent, config, name)
self.libraries_available = self.check_libraries_available()
if not self.libraries_available:
return
self.device_manager().register_enumerate_func(self.enumerate)
def get_library_version(self):
import trezorlib
try:
version = trezorlib.__version__
except Exception:
version = 'unknown'
if TREZORLIB:
return version
else:
raise LibraryFoundButUnusable(library_version=version)
def enumerate(self):
# If there is a bridge, prefer that.
# On Windows, the bridge runs as Admin (and Electrum usually does not),
# so the bridge has better chances of finding devices. see #5420
# This also avoids duplicate entries.
try:
call_bridge("enumerate")
except Exception:
devices = trezorlib.transport.enumerate_devices()
else:
devices = BridgeTransport.enumerate()
return [Device(path=d.get_path(),
interface_number=-1,
id_=d.get_path(),
product_key=TREZOR_PRODUCT_KEY,
usage_page=0,
transport_ui_string=d.get_path())
for d in devices]
def create_client(self, device, handler):
try:
self.logger.info(f"connecting to device at {device.path}")
transport = trezorlib.transport.get_transport(device.path)
except BaseException as e:
self.logger.info(f"cannot connect at {device.path} {e}")
return None
if not transport:
self.logger.info(f"cannot connect at {device.path}")
return
self.logger.info(f"connected to device at {device.path}")
# note that this call can still raise!
return TrezorClientBase(transport, handler, self)
def get_client(self, keystore, force_pair=True):
devmgr = self.device_manager()
handler = keystore.handler
with devmgr.hid_lock:
client = devmgr.client_for_keystore(self, handler, keystore, force_pair)
# returns the client for a given keystore. can use xpub
if client:
client.used()
return client
def get_coin_name(self):
return "Testnet" if constants.net.TESTNET else "Monacoin"
def initialize_device(self, device_id, wizard, handler):
# Initialization method
msg = _("Choose how you want to initialize your {}.\n\n"
"The first two methods are secure as no secret information "
"is entered into your computer.\n\n"
"For the last two methods you input secrets on your keyboard "
"and upload them to your {}, and so you should "
"only do those on a computer you know to be trustworthy "
"and free of malware."
).format(self.device, self.device)
choices = [
# Must be short as QT doesn't word-wrap radio button text
(TIM_NEW, _("Let the device generate a completely new seed randomly")),
(TIM_RECOVER, _("Recover from a seed you have previously written down")),
]
def f(method):
import threading
settings = self.request_trezor_init_settings(wizard, method, device_id)
t = threading.Thread(target=self._initialize_device_safe, args=(settings, method, device_id, wizard, handler))
t.setDaemon(True)
t.start()
exit_code = wizard.loop.exec_()
if exit_code != 0:
# this method (initialize_device) was called with the expectation
# of leaving the device in an initialized state when finishing.
# signal that this is not the case:
raise UserCancelled()
wizard.choice_dialog(title=_('Initialize Device'), message=msg, choices=choices, run_next=f)
def _initialize_device_safe(self, settings, method, device_id, wizard, handler):
exit_code = 0
try:
self._initialize_device(settings, method, device_id, wizard, handler)
except UserCancelled:
exit_code = 1
except BaseException as e:
self.logger.exception('')
handler.show_error(repr(e))
exit_code = 1
finally:
wizard.loop.exit(exit_code)
def _initialize_device(self, settings: TrezorInitSettings, method, device_id, wizard, handler):
if method == TIM_RECOVER and settings.recovery_type == RECOVERY_TYPE_SCRAMBLED_WORDS:
handler.show_error(_(
"You will be asked to enter 24 words regardless of your "
"seed's actual length. If you enter a word incorrectly or "
"misspell it, you cannot change it or go back - you will need "
"to start again from the beginning.\n\nSo please enter "
"the words carefully!"),
blocking=True)
devmgr = self.device_manager()
client = devmgr.client_by_id(device_id)
if not client:
raise Exception(_("The device was disconnected."))
if method == TIM_NEW:
strength_from_word_count = {12: 128, 18: 192, 24: 256}
client.reset_device(
strength=strength_from_word_count[settings.word_count],
passphrase_protection=settings.passphrase_enabled,
pin_protection=settings.pin_enabled,
label=settings.label,
no_backup=settings.no_backup)
elif method == TIM_RECOVER:
client.recover_device(
recovery_type=settings.recovery_type,
word_count=settings.word_count,
passphrase_protection=settings.passphrase_enabled,
pin_protection=settings.pin_enabled,
label=settings.label)
if settings.recovery_type == RECOVERY_TYPE_MATRIX:
handler.close_matrix_dialog()
else:
raise RuntimeError("Unsupported recovery method")
def _make_node_path(self, xpub, address_n):
bip32node = BIP32Node.from_xkey(xpub)
node = HDNodeType(
depth=bip32node.depth,
fingerprint=int.from_bytes(bip32node.fingerprint, 'big'),
child_num=int.from_bytes(bip32node.child_number, 'big'),
chain_code=bip32node.chaincode,
public_key=bip32node.eckey.get_public_key_bytes(compressed=True),
)
return HDNodePathType(node=node, address_n=address_n)
def setup_device(self, device_info, wizard, purpose):
devmgr = self.device_manager()
device_id = device_info.device.id_
client = devmgr.client_by_id(device_id)
if client is None:
raise UserFacingException(_('Failed to create a client for this device.') + '\n' +
_('Make sure it is in the correct state.'))
if not client.is_uptodate():
msg = (_('Outdated {} firmware for device labelled {}. Please '
'download the updated firmware from {}')
.format(self.device, client.label(), self.firmware_URL))
raise OutdatedHwFirmwareException(msg)
# fixme: we should use: client.handler = wizard
client.handler = self.create_handler(wizard)
if not device_info.initialized:
self.initialize_device(device_id, wizard, client.handler)
is_creating_wallet = purpose == HWD_SETUP_NEW_WALLET
client.get_xpub('m', 'standard', creating=is_creating_wallet)
client.used()
def get_xpub(self, device_id, derivation, xtype, wizard):
if xtype not in self.SUPPORTED_XTYPES:
raise ScriptTypeNotSupported(_('This type of script is not supported with {}.').format(self.device))
devmgr = self.device_manager()
client = devmgr.client_by_id(device_id)
client.handler = wizard
xpub = client.get_xpub(derivation, xtype)
client.used()
return xpub
def get_trezor_input_script_type(self, electrum_txin_type: str):
if electrum_txin_type in ('p2wpkh', 'p2wsh'):
return InputScriptType.SPENDWITNESS
if electrum_txin_type in ('p2wpkh-p2sh', 'p2wsh-p2sh'):
return InputScriptType.SPENDP2SHWITNESS
if electrum_txin_type in ('p2pkh', ):
return InputScriptType.SPENDADDRESS
if electrum_txin_type in ('p2sh', ):
return InputScriptType.SPENDMULTISIG
raise ValueError('unexpected txin type: {}'.format(electrum_txin_type))
def get_trezor_output_script_type(self, electrum_txin_type: str):
if electrum_txin_type in ('p2wpkh', 'p2wsh'):
return OutputScriptType.PAYTOWITNESS
if electrum_txin_type in ('p2wpkh-p2sh', 'p2wsh-p2sh'):
return OutputScriptType.PAYTOP2SHWITNESS
if electrum_txin_type in ('p2pkh', ):
return OutputScriptType.PAYTOADDRESS
if electrum_txin_type in ('p2sh', ):
return OutputScriptType.PAYTOMULTISIG
raise ValueError('unexpected txin type: {}'.format(electrum_txin_type))
def sign_transaction(self, keystore, tx, prev_tx, xpub_path):
prev_tx = { bfh(txhash): self.electrum_tx_to_txtype(tx, xpub_path) for txhash, tx in prev_tx.items() }
client = self.get_client(keystore)
inputs = self.tx_inputs(tx, xpub_path, True)
outputs = self.tx_outputs(keystore.get_derivation(), tx)
details = SignTx(lock_time=tx.locktime, version=tx.version)
signatures, _ = client.sign_tx(self.get_coin_name(), inputs, outputs, details=details, prev_txes=prev_tx)
signatures = [(bh2u(x) + '01') for x in signatures]
tx.update_signatures(signatures)
def show_address(self, wallet, address, keystore=None):
if keystore is None:
keystore = wallet.get_keystore()
if not self.show_address_helper(wallet, address, keystore):
return
deriv_suffix = wallet.get_address_index(address)
derivation = keystore.derivation
address_path = "%s/%d/%d"%(derivation, *deriv_suffix)
script_type = self.get_trezor_input_script_type(wallet.txin_type)
# prepare multisig, if available:
xpubs = wallet.get_master_public_keys()
if len(xpubs) > 1:
pubkeys = wallet.get_public_keys(address)
# sort xpubs using the order of pubkeys
sorted_pairs = sorted(zip(pubkeys, xpubs))
multisig = self._make_multisig(
wallet.m,
[(xpub, deriv_suffix) for _, xpub in sorted_pairs])
else:
multisig = None
client = self.get_client(keystore)
client.show_address(address_path, script_type, multisig)
def tx_inputs(self, tx, xpub_path, for_sig=False):
inputs = []
for txin in tx.inputs():
txinputtype = TxInputType()
if txin['type'] == 'coinbase':
prev_hash = b"\x00"*32
prev_index = 0xffffffff # signed int -1
else:
if for_sig:
x_pubkeys = txin['x_pubkeys']
xpubs = [parse_xpubkey(x) for x in x_pubkeys]
multisig = self._make_multisig(txin.get('num_sig'), xpubs, txin.get('signatures'))
script_type = self.get_trezor_input_script_type(txin['type'])
txinputtype = TxInputType(
script_type=script_type,
multisig=multisig)
# find which key is mine
for xpub, deriv in xpubs:
if xpub in xpub_path:
xpub_n = parse_path(xpub_path[xpub])
txinputtype.address_n = xpub_n + deriv
break
prev_hash = bfh(txin['prevout_hash'])
prev_index = txin['prevout_n']
if 'value' in txin:
txinputtype.amount = txin['value']
txinputtype.prev_hash = prev_hash
txinputtype.prev_index = prev_index
if txin.get('scriptSig') is not None:
script_sig = bfh(txin['scriptSig'])
txinputtype.script_sig = script_sig
txinputtype.sequence = txin.get('sequence', 0xffffffff - 1)
inputs.append(txinputtype)
return inputs
def _make_multisig(self, m, xpubs, signatures=None):
if len(xpubs) == 1:
return None
pubkeys = [self._make_node_path(xpub, deriv) for xpub, deriv in xpubs]
if signatures is None:
signatures = [b''] * len(pubkeys)
elif len(signatures) != len(pubkeys):
raise RuntimeError('Mismatched number of signatures')
else:
signatures = [bfh(x)[:-1] if x else b'' for x in signatures]
return MultisigRedeemScriptType(
pubkeys=pubkeys,
signatures=signatures,
m=m)
def tx_outputs(self, derivation, tx: Transaction):
def create_output_by_derivation():
script_type = self.get_trezor_output_script_type(info.script_type)
deriv = parse_path("/%d/%d" % index)
multisig = self._make_multisig(m, [(xpub, deriv) for xpub in xpubs])
txoutputtype = TxOutputType(
multisig=multisig,
amount=amount,
address_n=parse_path(derivation + "/%d/%d" % index),
script_type=script_type)
return txoutputtype
def create_output_by_address():
txoutputtype = TxOutputType()
txoutputtype.amount = amount
if _type == TYPE_SCRIPT:
txoutputtype.script_type = OutputScriptType.PAYTOOPRETURN
txoutputtype.op_return_data = trezor_validate_op_return_output_and_get_data(o)
elif _type == TYPE_ADDRESS:
txoutputtype.script_type = OutputScriptType.PAYTOADDRESS
txoutputtype.address = address
return txoutputtype
outputs = []
has_change = False
any_output_on_change_branch = is_any_tx_output_on_change_branch(tx)
for o in tx.outputs():
_type, address, amount = o.type, o.address, o.value
use_create_by_derivation = False
info = tx.output_info.get(address)
if info is not None and not has_change:
index, xpubs, m = info.address_index, info.sorted_xpubs, info.num_sig
# prioritise hiding outputs on the 'change' branch from user
# because no more than one change address allowed
# note: ^ restriction can be removed once we require fw
# that has https://github.com/trezor/trezor-mcu/pull/306
if info.is_change == any_output_on_change_branch:
use_create_by_derivation = True
has_change = True
if use_create_by_derivation:
txoutputtype = create_output_by_derivation()
else:
txoutputtype = create_output_by_address()
outputs.append(txoutputtype)
return outputs
def electrum_tx_to_txtype(self, tx, xpub_path):
t = TransactionType()
if tx is None:
# probably for segwit input and we don't need this prev txn
return t
d = deserialize(tx.raw)
t.version = d['version']
t.lock_time = d['lockTime']
t.inputs = self.tx_inputs(tx, xpub_path)
t.bin_outputs = [
TxOutputBinType(amount=vout['value'], script_pubkey=bfh(vout['scriptPubKey']))
for vout in d['outputs']
]
return t
|
thread_join.py
|
import threading
import time
def our_thread(i):
print("Thread {} Started".format(i))
time.sleep(i * 2)
print("Thread {} Finished".format(i))
def main():
thread = threading.Thread(target=our_thread, args=(1,))
thread.start()
print("Is thread 1 Finished?")
thread2 = threading.Thread(target=our_thread, args=(2,))
thread2.start()
thread2.join()
print("Thread 2 definitely finished")
if __name__ == '__main__':
main()
|
WebSocketServer.py
|
import errno
import socket
import threading
import hashlib
import base64
import logging
from .DataFrameFormat import *
from .ServerException import *
class WebSocketServer:
_SEC_KEY = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
_HANDKSHAKE_RESP = (
"HTTP/1.1 101 Switching Protocols\r\n"
"Upgrade: websocket\r\n"
"Connection: Upgrade\r\n"
"Sec-WebSocket-Accept: %s\r\n\r\n"
)
_LOGS_FILE = "ws.log"
_LOG_IN = "[IN] "
_LOG_OUT = "[OUT]"
def __init__(self, ip='', port=80, on_data_receive=None, on_connection_open=None, on_connection_close=None, on_server_destruct=None, on_error=None, DEBUG=False):
self.server = None
self.ip = ip
self.port = port
self.alive = True
self.clients = {} # Dictionary of active clients, remove when the connection is closed.
self.on_data_receive = on_data_receive if on_data_receive is not None else self._default_func
self.on_connection_open = on_connection_open if on_connection_open is not None else self._default_func
self.on_connection_close = on_connection_close if on_connection_close is not None else self._default_func
self.on_server_destruct = on_server_destruct if on_server_destruct is not None else self._default_func
self.on_error = on_error if on_error is not None else self._default_func
self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.DEBUG = DEBUG
# Initialize log file format.
logging.basicConfig(
filename=WebSocketServer._LOGS_FILE,
filemode='w',
format='%(levelname)s:%(threadName)s\n\t%(message)s',
level=logging.DEBUG if DEBUG else logging.INFO
)
def _default_func(self, *args, **kwargs):
"""Default function if the user does not define one.
"""
pass
def serve_forever(self, timeout=None):
"""Just like serve_once but forever.
"""
self.server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server.bind((self.ip, self.port))
self.server.listen(5)
if timeout:
# with timeout server loop becomes interruptable
self.server.settimeout(timeout)
while self.alive:
self.serve_once(serve_forever=True)
def serve_once(self, serve_forever=False):
"""Listen for incoming connections and start a new thread if a client is received.
"""
if not serve_forever:
self.server.bind((self.ip, self.port))
self.server.listen(5)
logging.info("Server is ready to accept")
try:
client, address = self.server.accept()
except socket.timeout:
return
except OSError as msg:
logging.error(msg)
return
self.clients[address] = client
logging.info("{} CONNECTION: {}".format(WebSocketServer._LOG_IN, client.getsockname()))
if serve_forever:
client_thread = threading.Thread(target=self._manage_client, args=(client,), daemon=True)
client_thread.start()
else:
self._manage_client(client)
def _manage_client(self, client):
"""This function is run on a separate thread for each client. It will complete the opening handshake
and then listen for incoming messages executing the users defined functions. The thread will close
when this function returns.
:param client: The client to control
"""
upgrade_req = client.recv(2048)
valid, ack = self._opening_handshake(client, upgrade_req)
if valid:
client.send(ack)
else:
self.on_error(WebSocketInvalidHandshake("Invalid Handshake", client))
self.on_connection_open(client)
address = client.getpeername()
while address in self.clients:
self._recv(client)
def recv(self, client):
"""Receive data from the client. This function will not call the user defined on_data_receive
but will instead return the data. If a the next message from the client is not data (for example a close
request) that message will be handled and none will be returned. This thread will be blocked until a
message is received.
:param client: The client to receive a message from.
:returns: The message sent by the client.
"""
return self._recv(client, user=True)
def _recv(self, client, user=False):
"""Receive a message from the client. Will block this thread until a message is received.
:param client: The client to receive a message from.
"""
try:
address = client.getpeername()
data = client.recv(2048)
except ConnectionError:
self.close_client(address, hard_close=True)
return None
except OSError as exc:
# Socket is not connected.
if exc.errno == errno.ENOTCONN:
self.close_client(address, hard_close=True)
return None
else:
raise
try:
valid, data = self._decode_data_frame(data)
except:
valid = None
if valid == FrameType.TEXT:
logging.info("{} {}: {} - '{}'".format(WebSocketServer._LOG_IN, valid.name, client.getsockname(), data))
if user:
return data
else:
self.on_data_receive(client, data)
elif valid == FrameType.CLOSE:
logging.info("{} {}: {}".format(WebSocketServer._LOG_IN, valid.name, client.getsockname()))
# Server sent closing message client connection has already closed
if not self.clients[address]:
self.close_client(address)
elif valid == FrameType.PING:
logging.info("{} {}: {}".format(WebSocketServer._LOG_IN, valid.name, client.getsockname()))
self._pong(client, data)
elif valid == FrameType.PONG:
logging.info("{} {}: {}".format(WebSocketServer._LOG_IN, valid.name, client.getsockname()))
else:
# Received Invalid Data Frame
logging.critical("Received Invalid Data Frame")
self.close_client(address, hard_close=True)
def send(self, client, data, data_type=FrameType.TEXT):
"""Send a string of data to the client.
:param data: The data to send.
:param client: The Client to send the data too.
:param data_type: The FrameType -- assumed to be a utf-8 encoded String if left out.
"""
data = WebSocketServer._encode_data_frame(data_type, data)
client.send(data)
def send_all(self, client, data, echo=False):
"""Send a string of data to all clients.
:param data: A string of data formatted as ASCII
:param client: The client initiating the data transfer.
:param echo: A boolean that indicates whether 'client'
should receive an echo of the message they are initiating.
"""
for endpoint in self.clients.values():
if endpoint != client or echo:
self.send(endpoint, data)
def _opening_handshake(self, client, data):
"""Derives handshake response to a client upgrade request.
:param client: The client to complete the handshake with.
:param data: The raw data included in the upgrade request -- assumes
the input data is encoded in a utf-8 format.
:returns (valid, response): A tuple containing a boolean flag
indicating if the request was valid, and a String containing
the handshake response (encoded in utf-8 format) or None if
the upgrade request was invalid.
"""
resp = (False, None)
tokens = data.decode().split("\r\n")
upgrade_set = ["Upgrade: WebSocket", "Upgrade: websocket", "upgrade: websocket"]
label_set = ["Sec-WebSocket-Key", "sec-websocket-key"]
if not bool(set(upgrade_set).intersection(tokens)):
return resp
for token in tokens[1:]:
label, value = token.split(": ", 1)
if label in label_set:
digest = WebSocketServer._digest(value)
resp = (True, (WebSocketServer._HANDKSHAKE_RESP %
(digest)).encode())
break
return resp
@staticmethod
def _digest(sec_key):
"""Derives the Sec-Accept key from the client's Sec-Key.
:param sec_key: A String representing the Sec-Key provided in an upgrade request.
:returns: A utf-8 encoding of the Sec-Accept key.
"""
raw = sec_key + WebSocketServer._SEC_KEY
return base64.b64encode(hashlib.sha1(raw.encode("ascii")).digest()).decode("utf-8")
@staticmethod
def _decode_data_frame(data):
"""Decodes a data frame formatted as per RFC 6455.
:param data: The incoming byte string.
:returns: A tuple of (FrameType, String) where the FrameType will be None
if the data could not be understood.
"""
fin = (data[FIN[LOW]]&FIN[BIT_MASK])>>FIN[OFFSET]
opcode = (data[OPCODE[LOW]]&OPCODE[BIT_MASK])>>OPCODE[OFFSET]
# Check that the payload is valid.
frame_type = [f_type for f_type in FrameType if opcode == f_type]
if not frame_type:
return (None, None)
else:
frame_type = frame_type[0]
mask_key_low = PAYLOAD_LEN[HIGH]+1
payload_len = (data[PAYLOAD_LEN[LOW]]&PAYLOAD_LEN[BIT_MASK])>>PAYLOAD_LEN[OFFSET]
if payload_len == 126:
# Read the next 16 bits.
mask_key_low = PAYLOAD_LEN_EXT_126[HIGH]+1
payload_len = int.from_bytes(data[PAYLOAD_LEN_EXT_126[LOW] : PAYLOAD_LEN_EXT_126[HIGH]+1],'big')
elif payload_len == 127:
# Read the next 64 bits.
mask_key_low = PAYLOAD_LEN_EXT_127[HIGH]+1
payload_len = int.from_bytes(data[PAYLOAD_LEN_EXT_127[LOW] : PAYLOAD_LEN_EXT_127[HIGH]+1],'big')
mask = (data[MASK[LOW]]&MASK[BIT_MASK])>>MASK[OFFSET]
mask_key_high = mask_key_low + MASK_KEY[LEN] if mask else mask_key_low
mask_key = payload = None
if mask: # Need to unmask the payload data.
mask_key = data[mask_key_low: mask_key_high]
encrypted = data[mask_key_high: mask_key_high+payload_len]
payload = bytearray(encrypted[i]^mask_key[i%4] for i in range(len(encrypted)))
else:
payload = data[mask_key_high: mask_key_high+payload_len]
return (frame_type, bytes(payload).decode() if frame_type != FrameType.CLOSE else None)
@staticmethod
def _encode_data_frame(frame_type, data):
"""Formats data into a data frame as per RFC 6455.
:param frame_type: FrameType indicating the type of data being sent.
:param data: The data to be formatted.
:returns: The formatted data frame.
"""
data = data.encode() if data else None
fin = 1 # No fragmentation support yet.
mask = 0 # Server never masks data.
opcode = frame_type.value
# Create the data frame one byte at a time.
frame = bytearray()
frame.append((fin<<FIN[OFFSET])^opcode)
payload_len = len(data) if data else 0
if payload_len < 126:
frame.append((mask<<MASK[OFFSET])^payload_len)
elif payload_len < 65535 : # Can the length fit in 16 bits?
frame.append((mask<<MASK[OFFSET])^126)
for i in range(PAYLOAD_LEN_EXT_126[LEN]-1,-1,-1):
frame.append((payload_len>>(i*8))&255)
else:
frame.append((mask<<MASK[OFFSET])^127)
for i in range(PAYLOAD_LEN_EXT_127[LEN]-1,-1,-1):
frame.append((payload_len>>(i*8))&255)
if payload_len > 0:
frame.extend(data)
return bytes(frame)
def _initiate_close(self, client, status_code=None, app_data=None):
"""Sends the first Closing frame to the client.
:param client: The Client connection to close.
:param status_code: A 16 bit optional status code.
:param app_data: A utf-8 encoded String to include with the close frame.
"""
# Concatenate the status_code and app_data into one byte string if provided.
payload_bytes = []
if status_code is not None:
status_bytes = bytearray([status_code & 255, (status_code >> 8) & 255])
payload_bytes.append(bytes(status_bytes))
if app_data is not None:
payload_bytes.append(app_data.encode())
self.send(client, b''.join(payload_bytes) if len(payload_bytes) > 0 else None, FrameType.CLOSE)
def _respond_to_close(self, client):
"""Acknowledge the closing of a client connection -- for now, just send an empty
close frame (i.e. same as initiating a close frame with no app_data). Later, this
will be updated to echo the status_code from the client's close frame.
:param client: The Client who requested the connection close.
"""
self._initiate_close(client)
def close_client(self, address, status_code=None, app_data=None, hard_close=False):
"""Close the connection with a client.
:param address: The client address to close the connection with.
:param status_code: A 16 bit optional status code.
:param app_data: A utf-8 encoded String to include with the close frame.
:param hard_close: A boolean which indicates whether the client needs to be closed hard or soft.
"""
self.on_connection_close(self.clients[address])
if not hard_close:
self._initiate_close(self.clients[address], status_code=status_code, app_data=app_data)
self.clients[address].close()
self.clients.pop(address, None)
def close_server(self, status_code=None, app_data=None):
"""Close the connection with each client and then close the underlying tcp socket of the server.
:param status_code: A 16 bit optional status code to send to all of the clients.
:param app_data: A utf-8 encoded String to include with the close frame.
"""
for address in list(self.clients.keys()):
self.close_client(address, status_code=status_code, app_data=app_data)
self.on_server_destruct()
self.server.close()
self.alive = False
def ping(self, client):
"""Send a Ping frame.
:param client: The Client to ping."""
self.send(client, None, FrameType.PING)
def _pong(self, client, data):
"""Send a Pong frame back to a client.
:param client: The Client who send the Ping.
"""
self.send(client, data, FrameType.PONG)
|
flow2npy.py
|
import cv2
import os
import numpy as np
import json
import glob
import multiprocessing as mp
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('thread_num', type=int)
parser.add_argument('--video_info_path', type=str,
default='anet_annotations/video_info_train_val.json')
parser.add_argument('--flow_frame_path', type=str,
default='datasets/activitynet/flow/frame_train_val_112')
parser.add_argument('--flow_npy_path', type=str,
default='datasets/activitynet/flow/train_val_npy_112')
parser.add_argument('--max_frame_num', type=int, default=768)
args = parser.parse_args()
thread_num = args.thread_num
video_info_path = args.video_info_path
flow_frame_path = args.flow_frame_path
flow_npy_path = args.flow_npy_path
max_frame_num = args.max_frame_num
def load_json(file):
"""
:param file: json file path
:return: data of json
"""
with open(file) as json_file:
data = json.load(json_file)
return data
if not os.path.exists(flow_npy_path):
os.makedirs(flow_npy_path)
json_data = load_json(video_info_path)
video_list = sorted(list(json_data.keys()))
def sub_processor(pid, video_list):
for video_name in video_list:
tmp = []
print(video_name)
flow_x_files = sorted(glob.glob(os.path.join(flow_frame_path, video_name, 'flow_x_*.jpg')))
flow_y_files = sorted(glob.glob(os.path.join(flow_frame_path, video_name, 'flow_y_*.jpg')))
assert len(flow_x_files) > 0
assert len(flow_x_files) == len(flow_y_files)
frame_num = json_data[video_name]['frame_num']
fps = json_data[video_name]['fps']
output_file = os.path.join(flow_npy_path, video_name + '.npy')
while len(flow_x_files) < frame_num:
flow_x_files.append(flow_x_files[-1])
flow_y_files.append(flow_y_files[-1])
for flow_x, flow_y in zip(flow_x_files, flow_y_files):
flow_x = cv2.imread(flow_x)[:, :, 0]
flow_y = cv2.imread(flow_y)[:, :, 0]
img = np.stack([flow_x, flow_y], -1)
tmp.append(img)
tmp = np.stack(tmp, 0)
if max_frame_num is not None:
tmp = tmp[:max_frame_num]
np.save(output_file, tmp)
processes = []
video_num = len(video_list)
per_process_video_num = video_num // thread_num
for i in range(thread_num):
if i == thread_num - 1:
sub_files = video_list[i * per_process_video_num:]
else:
sub_files = video_list[i * per_process_video_num: (i + 1) * per_process_video_num]
p = mp.Process(target=sub_processor, args=(i, sub_files))
p.start()
processes.append(p)
for p in processes:
p.join()
|
miner.py
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
## Copyright (c) 2017, The HongbaoBlockchain Project (www.hongbaoblockchain.org)
'''
Main miner worker, RPC client
'''
import sys, psutil
import json, socket, struct
import errno
import threading, time, urlparse, random, platform
from multiprocessing import Process, Event, cpu_count
#from threading import Timer
from libs import cpu_has_aes_in_supported, cryptolite_hash, cryptonite_hash
import settings
from utils.logger import log, LEVEL_DEBUG, LEVEL_ERROR, LEVEL_INFO, LEVEL_PROTOCOL
POOL_ERROR_MSGS = ["Unauthenticated", "Timeout", "Invalid job id"]
HAS_AES_NI = cpu_has_aes_in_supported() # mark if CPU has AES-NI supported
CPU_COUNT = cpu_count()
MAX_INT = 0xffffffff
# Convert from/to binary and hexidecimal strings
# (could be replaced with .encode('hex') and .decode('hex'))
from binascii import hexlify, unhexlify
NETWORK_ERROR_MSG = "Network error! Reconnecting..."
def human_readable_hashrate(hashrate):
'''Returns a human readable representation of hashrate.'''
if hashrate < 1000:
return '%.2f H/s' % hashrate
if hashrate < 10000000:
return '%.2f kH/s' % (hashrate / 1000)
if hashrate < 10000000000:
return '%.2f mH/s' % (hashrate / 1000000)
return '%.2f gH/s' % (hashrate / 1000000000)
""" decode 256-bit target value """
def decode_target_value(target_hex):
target_bin = unhexlify(target_hex)
target_bin = target_bin[::-1] # byte-swap and dword-swap
target_bin_str = hexlify(target_bin)
target = long(target_bin_str, 16)
difficulty = float(MAX_INT)/target if target > 0 else 0. # difficulty
return (target, difficulty)
class SimpleJsonRpcClient(threading.Thread):
'''Simple JSON-RPC client.
To use this class:
1) Create a sub-class
2) Override handle_reply(self, request, reply)
3) Call connect(socket)
Use self.send(method, params) to send JSON-RPC commands to the server.
A new thread is created for listening to the connection; so calls to handle_reply
are synchronized. It is safe to call send from withing handle_reply.
'''
class ClientException(Exception): pass
class RequestReplyException(Exception):
def __init__(self, message, reply, request = None):
Exception.__init__(self, message)
self._reply = reply
self._request = request
request = property(lambda s: s._request)
reply = property(lambda s: s._reply)
class RequestReplyWarning(RequestReplyException):
'''Sub-classes can raise this to inform the user of JSON-RPC server issues.'''
pass
def __init__(self):
threading.Thread.__init__(self)
self._socket = None
self._lock = threading.RLock()
self._rpc_thread = None
self._message_id = 1
self._requests = dict()
self.exit = Event()
def _handle_incoming_rpc(self):
data = ""
while not self.exit.is_set():
try:
# Get the next line if we have one, otherwise, read and block
if '\n' in data:
(line, data) = data.split('\n', 1)
else:
chunk = self._socket.recv(1024)
if chunk: data += chunk
continue
# except IOError as e:
# if e.errno == 10053: # Error: An established connection was aborted by the software in your host machine
# pass
# time.sleep(1)
# data = ""
# continue
except Exception, e:
#print >> sys.stderr, e
time.sleep(1)
data = ""
continue
log('JSON-RPC Server > ' + line, LEVEL_PROTOCOL, self._pool_id)
# Parse the JSON
try:
reply = json.loads(line)
except Exception, e:
log("JSON-RPC Error: Failed to parse JSON %r (skipping)" % line, LEVEL_ERROR, self._pool_id)
continue
try:
request = None
with self._lock:
if 'id' in reply and reply['id'] in self._requests:
request = self._requests[reply['id']]
self.handle_reply(request = request, reply = reply)
except self.RequestReplyWarning, e:
output = e.message
if e.request:
output += '\n ' + e.request
output += '\n ' + e.reply
log(output, LEVEL_ERROR)
def handle_reply(self, request, reply):
# Override this method in sub-classes to handle a message from the server
raise self.RequestReplyWarning('Override this method')
def send(self, method, params):
'''Sends a message to the JSON-RPC server'''
if not self._socket:
#raise self.ClientException('Not connected')
return
if method == 'ping':
with self._lock:
self._socket.send('\r') # just to keep alive
log('Ping sent', LEVEL_DEBUG, self._pool_id)
return
request = dict(id = self._message_id, method = method, params = params)
if settings.OPT_REPLY_WITH_RPC2_EXPLICIT:
request['jsonrpc'] = '2.0'
message = json.dumps(request)
with self._lock:
self._requests[self._message_id] = request
self._message_id += 1
self._socket.send(message + '\n')
log('JSON-RPC Server < ' + message, LEVEL_PROTOCOL, self._pool_id)
return request
def connect(self, socket):
'''Connects to a remove JSON-RPC server'''
self._socket = socket
if not self._rpc_thread:
self._rpc_thread = threading.Thread(target = self._handle_incoming_rpc)
self._rpc_thread.daemon = True
self._rpc_thread.start()
def shutdown(self):
log("RPC shutdown initiated", LEVEL_DEBUG)
self.exit.set()
class MinerRPC(SimpleJsonRpcClient):
class MinerRPCWarning(SimpleJsonRpcClient.RequestReplyWarning):
def __init__(self, message, reply, request = None):
SimpleJsonRpcClient.RequestReplyWarning.__init__(self, 'Mining Sate Error: ' + message, reply, request)
class MinerRPCAuthenticationException(SimpleJsonRpcClient.RequestReplyException): pass
def __init__(self, pool_info, work_submit_queue, g_work, work_report):
SimpleJsonRpcClient.__init__(self)
self._pool_info = pool_info
self._pool_id = pool_info['id']
self._url = pool_info['url']
self._username = pool_info['username']
self._password = pool_info['password']
self._work_submit_queue = work_submit_queue
self._g_work = g_work
self._work_report = work_report
self._login_id = None
self._thr_list = None
self._cur_stratum_diff = 0.
if 'work_accepted' in work_report:
self._work_accepted = work_report['work_accepted']
else:
self._work_accepted = 0
if 'work_submited' in work_report:
self._work_submited = work_report['work_submited']
else:
self._work_submited = 0
self._my_sock = None
self._last_check_idle_time = time.time()
url = property(lambda s: s._url)
username = property(lambda s: s._username)
password = property(lambda s: s._password)
login_id = property(lambda s: s._login_id)
def set_thread_list(self, thr_list):
self._thr_list = thr_list
# Overridden from SimpleJsonRpcClient
def handle_reply(self, request, reply):
""" Handle login result"""
if request and request.get("method") == "login":
error = reply.get("error")
if error is not None:
self._pool_info['error'] = error.get('message')
log("Error %d: %s" % (error.get('code'), error.get('message')), LEVEL_ERROR, self._pool_id)
# relogin after 10 seconds
if self._wait(10):
self._login()
return
result = reply.get("result")
if result and result.get("status") == "OK":
job_params = result.get("job")
if job_params:
self._login_id = result.get("id")
""" handle job here """
self._set_new_job(job_params)
elif request and request.get("method") == "submit":
self._work_submited += 1
self._work_report['work_submited'] = self._work_submited
if reply.get("error") is not None:
error = reply.get("error")
log("rejected: %s, %d/%d, NO!!!" % (error.get("message"),
self._work_accepted, self._work_submited), LEVEL_ERROR, self._pool_id)
if error.get("message") in POOL_ERROR_MSGS:
#self._login()
self.try_connect()
elif reply.get("result") is not None:
res = reply.get("result")
if res.get("status") == "OK":
self._work_accepted += 1
accepted_percentage = self._work_accepted*100./self._work_submited
# hash_rates = self._pool_info['hash_report'] if 'hash_report' in self._pool_info else {}
# if len(hash_rates) > 0:
# hash_rates = dict(hash_rates)
# _total_hash_rate = reduce(lambda x, y: x+y, [hash_rates[k] for k in hash_rates])
# else:
# _total_hash_rate = 0.0
_total_hash_rate = 0.0
if 'total_hashrate' in self._pool_info:
_total_hash_rate = self._pool_info['total_hashrate']
log("accepted %d/%d (%.2f%%), %s, YES!" % (self._work_accepted, self._work_submited,
accepted_percentage, human_readable_hashrate(_total_hash_rate)), LEVEL_INFO, self._pool_id)
self._work_report['work_accepted'] = self._work_accepted
elif reply.get("error") is not None:
error = reply.get("error")
if error.get("message") in POOL_ERROR_MSGS:
#self._login()
self.try_connect()
log("Error %d: %s" % (error.get('code'), error.get('message')), LEVEL_ERROR, self._pool_id)
#self.MinerRPCWarning(error.get("message"), reply)
elif reply.get("method") == "job":
job_params = reply.get("params")
""" handle job here """
if job_params:
self._set_new_job(job_params)
def _set_new_job(self, job_params):
job_id = job_params.get("job_id")
try:
target_hex = job_params.get("target")
target, difficulty = decode_target_value(target_hex)
assert(target > 0 and difficulty > 0)
except:
log("Invalid stratum target: %s" % target_hex, LEVEL_ERROR, self._pool_id)
return
blob_hex = job_params.get("blob")
try:
blob_bin = unhexlify(blob_hex)
nonce = long( hexlify(blob_bin[39:43]), 16)
assert(len(blob_bin) == 76)
assert(nonce >= 0)
except:
log("Invalid stratum blob: %s" % blob_hex, LEVEL_ERROR, self._pool_id)
return
self._g_work['login_id'] = self._login_id
self._g_work['target'] = target
self._g_work['blob_bin'] = blob_bin
self._g_work['nonce'] = nonce
self._g_work['num_thrs'] = len(self._thr_list)
self._g_work['job_id'] = job_id
self._g_work['is_cryptolite'] = self._pool_info['algo'] == "Cryptonight-Light"
log('New job recv: target="%s" blob="%s"' % (target_hex, blob_hex), LEVEL_INFO, self._pool_id)
if difficulty != self._cur_stratum_diff:
self._cur_stratum_diff = difficulty
self._work_report['difficulty'] = difficulty
log("Stratum difficulty set to %.f" % difficulty, LEVEL_INFO, self._pool_id)
def run(self):
self.try_connect()
start = time.time()
while not self.exit.is_set():
if not self._work_submit_queue.empty():
work_submit = self._work_submit_queue.get()
try:
self.send(method=work_submit['method'], params=work_submit['params'])
start = time.time() + settings.OPT_PING_INTERVAL # to delay sending 'ping' by interval setting
except socket.error:
self.try_connect()
continue
elif settings.OPT_SEND_PING:
""" 'ping' stratum server periodically to detect disconnection """
elapsed = time.time() - start
if elapsed >= settings.OPT_PING_INTERVAL:
try:
self.send(method='ping', params=None)
except socket.error:
self.try_connect()
continue
finally:
start = time.time()
""" relogin after 1 minute idle, i.e. receiving no new jobs for a long time,
may be due to some pool's error other than network error """
if time.time() - self._last_check_idle_time >= 60:
if 'error' in self._pool_info and self._pool_info['error'] == NETWORK_ERROR_MSG:
self._last_check_idle_time = time.time()
continue
hash_rates = self._pool_info['hash_report'] if 'hash_report' in self._pool_info else None
if hash_rates is not None and len(hash_rates) > 0: # it means mining is already on
total_hash_rate = reduce(lambda x, y: x+y, [hash_rates[k] for k in dict(hash_rates)])
# but mining is now idle
if total_hash_rate == 0.:
self._login()
self._last_check_idle_time = time.time()
time.sleep(.1)
""" try to close socket before exit """
try:
self._my_sock.close()
except:
pass
def try_connect(self):
url = urlparse.urlparse(self.url)
hostname = url.hostname
try:
port = int(url.port)
except:
self._pool_info['error'] = "Invalid pool port"
log("Invalid pool port!", LEVEL_ERROR)
return
if not hostname:
self._pool_info['error'] = "Invalid pool URL"
log("Invalid pool URL", LEVEL_ERROR)
return
while not self.exit.is_set():
if not self._my_sock:
log('Connecting to RPC server [%s:%d]...' % (hostname, port), LEVEL_INFO, self._pool_id)
self._my_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._sock_keep_alive()
else:
log(NETWORK_ERROR_MSG, LEVEL_ERROR, self._pool_id)
self._pool_info['error'] = NETWORK_ERROR_MSG
# (try to) stop all mining jobs by setting global job_id as None
self._g_work['job_id'] = None
# and clear submit works remain in queue if any
while not self._work_submit_queue.empty():
_ = self._work_submit_queue.get()
try:
self._my_sock.close()
except:
pass
else:
self._my_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._sock_keep_alive()
try:
self._my_sock.connect((hostname, port))
self.connect(self._my_sock)
except socket.error:
# wait 10 seconds
self._wait(10)
else:
self._login()
if 'error' in self._pool_info:
self._pool_info['error'] = None
break
def _sock_keep_alive(self):
after_idle_sec = 1
interval_sec= 3
my_os = platform.system()
try:
if my_os == "Windows":
self._my_sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, after_idle_sec*1000, interval_sec*1000))
elif my_os == "Linux":
self._my_sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
self._my_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, after_idle_sec)
self._my_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, interval_sec)
elif my_os == "Darwin":
TCP_KEEPALIVE = 0x10
self._my_sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
self._my_sock.setsockopt(socket.IPPROTO_TCP, TCP_KEEPALIVE, interval_sec)
except:
pass
def _login(self):
# (re)login
log('Logging in ...', LEVEL_INFO, self._pool_id)
params = dict(login=self._username, agent="%s/%d.%s"
%(settings.USER_AGENT, settings.VERSION[0], settings.VERSION[1]))
params['pass'] = self._password
try:
self.send(method='login', params = params)
except socket.error:
self.try_connect()
else:
# mark 'check idle time' to avoid multiple logins
self._last_check_idle_time = time.time()
def _wait(self, seconds=1):
""" wait without blocking UI
"""
for _ in range(seconds*10):
if self.exit.is_set(): return False
time.sleep(.1)
return True
class MinerWork(Process):
def __init__(self, thr_id, work_submit_queue, g_work, hash_report, cpu_priority_level):
Process.__init__(self)
self._cur_job_id = None
self._hash_rate = 0.0
self._thr_id = thr_id
self._work_submit_queue = work_submit_queue
self._g_work = g_work
self._hash_report_queue = hash_report
self.exit = Event()
_p = psutil.Process(self.pid)
_cpu_affinity = [CPU_COUNT - (thr_id % CPU_COUNT) - 1]
if sys.platform == "win32":
_p.cpu_affinity(_cpu_affinity)
#_p.nice(cpu_priority_level)
def run(self):
_total_hashes = 0
blob_bin = None
nonce = 1
max_nonce = target = login_id = 0
#end_nonce = MAX_INT - 0x20
end_nonce = 0
is_cryptolite = 0 # (if) is cryptonight-lite algo
# max_int32 = 2**32 # =4294967296
while not self.exit.is_set():
if not 'job_id' in self._g_work or self._g_work['job_id'] is None:
self._hash_rate = 0.
self._shareHashRate()
time.sleep(.1)
continue
if self._g_work['job_id'] != self._cur_job_id:
self._cur_job_id = self._g_work['job_id']
nonce = self._g_work['nonce']
blob_bin = self._g_work['blob_bin']
target = self._g_work['target']
login_id = self._g_work['login_id']
is_cryptolite = self._g_work['is_cryptolite']
end_nonce = MAX_INT /self._g_work['num_thrs']*(self._thr_id + 1) - 0x20
nonce += MAX_INT/self._g_work['num_thrs']*self._thr_id
""" randomize nonce start"""
if settings.OPT_RANDOMIZE:
offset = int(settings.OPT_SCANTIME*self._hash_rate) if self._hash_rate > 0 else 64*settings.OPT_SCANTIME
nonce += random.randint(0, MAX_INT/self._g_work['num_thrs'] - offset)
if nonce > MAX_INT - 0x20:
nonce = end_nonce
max64 = int(settings.OPT_SCANTIME*self._hash_rate) if self._hash_rate > 0 else 64
if nonce + max64 > end_nonce:
max_nonce = end_nonce
else:
max_nonce = nonce + max64
if max_nonce > MAX_INT:
max_nonce = MAX_INT
""" start _hash scan """
total_hashes_done = 0
_hashes_done = 0
start = _start = time.time()
while nonce <= max_nonce and not self.exit.is_set():
nonce_bin = struct.pack("<I", nonce)
blob_bin = blob_bin[:39] + nonce_bin + blob_bin[43:]
if is_cryptolite:
_hash = cryptolite_hash(blob_bin, HAS_AES_NI)
else:
_hash = cryptonite_hash(blob_bin, HAS_AES_NI)
nonce += 1
_hashes_done += 1
total_hashes_done += 1
""" calculate _hash rate"""
if _hashes_done >= self._hash_rate/2:
# if _hashes_done >= 10:
elapsed = time.time() - _start
if elapsed > 0:
self._hash_rate = _hashes_done/elapsed
""" share _hash rate """
self._shareHashRate()
log('CPU #%d: %.2f H/s' % (self._thr_id, self._hash_rate), LEVEL_DEBUG)
_start = time.time()
_hashes_done = 0
if struct.unpack("<I", _hash[28:])[0] < target:
""" Yes, hash found! """
params = dict(id=login_id, job_id = self._cur_job_id,
nonce=hexlify(nonce_bin), result=hexlify(_hash))
self._work_submit_queue.put({'method': 'submit', 'params': params})
break
""" if there is a new work, break scan """
if self._g_work['job_id'] != self._cur_job_id:
break
elapsed = time.time() - start
self._hash_rate = total_hashes_done/elapsed if elapsed > 0 else 0.
""" share _hash rate """
self._shareHashRate()
log('CPU #%d: %.2f H/s' % (self._thr_id, self._hash_rate), LEVEL_DEBUG)
""" if idle: """
if total_hashes_done == 0:
time.sleep(.1)
## Set hash_rate to 0.0 before exit
self._hash_rate = 0.
self._shareHashRate()
def _shareHashRate(self):
self._hash_report_queue.update({'%d' % self._thr_id: self._hash_rate})
def shutdown(self):
log("Miner thread# %d shutdown initiated" % self._thr_id, LEVEL_DEBUG)
self.exit.set()
def set_cpu_priority(self, cpu_priority_level):
_p = psutil.Process(self.pid)
_p.nice(cpu_priority_level)
def show_priority(self):
_p = psutil.Process(self.pid)
print "PID", _p.pid, "Priority", _p.nice()
|
train_sampling.py
|
"""Training GCMC model on the MovieLens data set by mini-batch sampling.
The script loads the full graph in CPU and samples subgraphs for computing
gradients on the training device. The script also supports multi-GPU for
further acceleration.
"""
import os, time
import argparse
import logging
import random
import string
import traceback
import numpy as np
import torch as th
import torch.nn as nn
import torch.multiprocessing as mp
from torch.utils.data import DataLoader
from torch.multiprocessing import Queue
from torch.nn.parallel import DistributedDataParallel
from _thread import start_new_thread
from functools import wraps
from data import MovieLens
from model import GCMCLayer, DenseBiDecoder
from utils import get_activation, get_optimizer, torch_total_param_num, torch_net_info, MetricLogger
import dgl
class GCMCSampler:
"""Neighbor sampler in GCMC mini-batch training."""
def __init__(self, dataset, segment='train'):
self.dataset = dataset
if segment == 'train':
self.truths = dataset.train_truths
self.labels = dataset.train_labels
self.enc_graph = dataset.train_enc_graph
self.dec_graph = dataset.train_dec_graph
elif segment == 'valid':
self.truths = dataset.valid_truths
self.labels = None
self.enc_graph = dataset.valid_enc_graph
self.dec_graph = dataset.valid_dec_graph
elif segment == 'test':
self.truths = dataset.test_truths
self.labels = None
self.enc_graph = dataset.test_enc_graph
self.dec_graph = dataset.test_dec_graph
else:
assert False, "Unknow dataset {}".format(segment)
def sample_blocks(self, seeds):
"""Sample subgraphs from the entire graph.
The input ``seeds`` represents the edges to compute prediction for. The sampling
algorithm works as follows:
1. Get the head and tail nodes of the provided seed edges.
2. For each head and tail node, extract the entire in-coming neighborhood.
3. Copy the node features/embeddings from the full graph to the sampled subgraphs.
"""
dataset = self.dataset
enc_graph = self.enc_graph
dec_graph = self.dec_graph
edge_ids = th.stack(seeds)
# generate frontiers for user and item
possible_rating_values = dataset.possible_rating_values
true_relation_ratings = self.truths[edge_ids]
true_relation_labels = None if self.labels is None else self.labels[edge_ids]
# 1. Get the head and tail nodes from both the decoder and encoder graphs.
head_id, tail_id = dec_graph.find_edges(edge_ids)
utype, _, vtype = enc_graph.canonical_etypes[0]
subg = []
true_rel_ratings = []
true_rel_labels = []
for possible_rating_value in possible_rating_values:
idx_loc = (true_relation_ratings == possible_rating_value)
head = head_id[idx_loc]
tail = tail_id[idx_loc]
true_rel_ratings.append(true_relation_ratings[idx_loc])
if self.labels is not None:
true_rel_labels.append(true_relation_labels[idx_loc])
subg.append(dgl.bipartite((head, tail),
utype=utype,
etype=str(possible_rating_value),
vtype=vtype,
num_nodes=(enc_graph.number_of_nodes(utype),
enc_graph.number_of_nodes(vtype))))
# Convert the encoder subgraph to a more compact one by removing nodes that covered
# by the seed edges.
g = dgl.hetero_from_relations(subg)
g = dgl.compact_graphs(g)
# 2. For each head and tail node, extract the entire in-coming neighborhood.
seed_nodes = {}
for ntype in g.ntypes:
seed_nodes[ntype] = g.nodes[ntype].data[dgl.NID]
frontier = dgl.in_subgraph(enc_graph, seed_nodes)
frontier = dgl.to_block(frontier, seed_nodes)
# 3. Copy the node features/embeddings from the full graph to the sampled subgraphs.
frontier.dstnodes['user'].data['ci'] = \
enc_graph.nodes['user'].data['ci'][frontier.dstnodes['user'].data[dgl.NID]]
frontier.srcnodes['movie'].data['cj'] = \
enc_graph.nodes['movie'].data['cj'][frontier.srcnodes['movie'].data[dgl.NID]]
frontier.srcnodes['user'].data['cj'] = \
enc_graph.nodes['user'].data['cj'][frontier.srcnodes['user'].data[dgl.NID]]
frontier.dstnodes['movie'].data['ci'] = \
enc_graph.nodes['movie'].data['ci'][frontier.dstnodes['movie'].data[dgl.NID]]
# handle features
head_feat = frontier.srcnodes['user'].data[dgl.NID].long() \
if dataset.user_feature is None else \
dataset.user_feature[frontier.srcnodes['user'].data[dgl.NID]]
tail_feat = frontier.srcnodes['movie'].data[dgl.NID].long()\
if dataset.movie_feature is None else \
dataset.movie_feature[frontier.srcnodes['movie'].data[dgl.NID]]
true_rel_labels = None if self.labels is None else th.cat(true_rel_labels, dim=0)
true_rel_ratings = th.cat(true_rel_ratings, dim=0)
return (g, frontier, head_feat, tail_feat, true_rel_labels, true_rel_ratings)
class Net(nn.Module):
def __init__(self, args, dev_id):
super(Net, self).__init__()
self._act = get_activation(args.model_activation)
self.encoder = GCMCLayer(args.rating_vals,
args.src_in_units,
args.dst_in_units,
args.gcn_agg_units,
args.gcn_out_units,
args.gcn_dropout,
args.gcn_agg_accum,
agg_act=self._act,
share_user_item_param=args.share_param,
device=dev_id)
if args.mix_cpu_gpu and args.use_one_hot_fea:
# if use_one_hot_fea, user and movie feature is None
# W can be extremely large, with mix_cpu_gpu W should be stored in CPU
self.encoder.partial_to(dev_id)
else:
self.encoder.to(dev_id)
self.decoder = DenseBiDecoder(in_units=args.gcn_out_units,
num_classes=len(args.rating_vals),
num_basis=args.gen_r_num_basis_func)
self.decoder.to(dev_id)
def forward(self, compact_g, frontier, ufeat, ifeat, possible_rating_values):
user_out, movie_out = self.encoder(frontier, ufeat, ifeat)
head_emb = []
tail_emb = []
for possible_rating_value in possible_rating_values:
head, tail = compact_g.all_edges(etype=str(possible_rating_value))
head_emb.append(user_out[head])
tail_emb.append(movie_out[tail])
head_emb = th.cat(head_emb, dim=0)
tail_emb = th.cat(tail_emb, dim=0)
pred_ratings = self.decoder(head_emb, tail_emb)
return pred_ratings
def evaluate(args, dev_id, net, dataset, dataloader, segment='valid'):
possible_rating_values = dataset.possible_rating_values
nd_possible_rating_values = th.FloatTensor(possible_rating_values).to(dev_id)
real_pred_ratings = []
true_rel_ratings = []
for sample_data in dataloader:
compact_g, frontier, head_feat, tail_feat, \
_, true_relation_ratings = sample_data
head_feat = head_feat.to(dev_id)
tail_feat = tail_feat.to(dev_id)
with th.no_grad():
pred_ratings = net(compact_g, frontier,
head_feat, tail_feat, possible_rating_values)
batch_pred_ratings = (th.softmax(pred_ratings, dim=1) *
nd_possible_rating_values.view(1, -1)).sum(dim=1)
real_pred_ratings.append(batch_pred_ratings)
true_rel_ratings.append(true_relation_ratings)
real_pred_ratings = th.cat(real_pred_ratings, dim=0)
true_rel_ratings = th.cat(true_rel_ratings, dim=0).to(dev_id)
rmse = ((real_pred_ratings - true_rel_ratings) ** 2.).mean().item()
rmse = np.sqrt(rmse)
return rmse
# According to https://github.com/pytorch/pytorch/issues/17199, this decorator
# is necessary to make fork() and openmp work together.
def thread_wrapped_func(func):
"""
Wraps a process entry point to make it work with OpenMP.
"""
@wraps(func)
def decorated_function(*args, **kwargs):
queue = Queue()
def _queue_result():
exception, trace, res = None, None, None
try:
res = func(*args, **kwargs)
except Exception as e:
exception = e
trace = traceback.format_exc()
queue.put((res, exception, trace))
start_new_thread(_queue_result, ())
result, exception, trace = queue.get()
if exception is None:
return result
else:
assert isinstance(exception, Exception)
raise exception.__class__(trace)
return decorated_function
def prepare_mp(g):
"""
Explicitly materialize the CSR, CSC and COO representation of the given graph
so that they could be shared via copy-on-write to sampler workers and GPU
trainers.
This is a workaround before full shared memory support on heterogeneous graphs.
"""
for etype in g.canonical_etypes:
g.in_degree(0, etype=etype)
g.out_degree(0, etype=etype)
g.find_edges([0], etype=etype)
def config():
parser = argparse.ArgumentParser(description='GCMC')
parser.add_argument('--seed', default=123, type=int)
parser.add_argument('--gpu', type=str, default='0')
parser.add_argument('--save_dir', type=str, help='The saving directory')
parser.add_argument('--save_id', type=int, help='The saving log id')
parser.add_argument('--silent', action='store_true')
parser.add_argument('--data_name', default='ml-1m', type=str,
help='The dataset name: ml-100k, ml-1m, ml-10m')
parser.add_argument('--data_test_ratio', type=float, default=0.1) ## for ml-100k the test ration is 0.2
parser.add_argument('--data_valid_ratio', type=float, default=0.1)
parser.add_argument('--use_one_hot_fea', action='store_true', default=False)
parser.add_argument('--model_activation', type=str, default="leaky")
parser.add_argument('--gcn_dropout', type=float, default=0.7)
parser.add_argument('--gcn_agg_norm_symm', type=bool, default=True)
parser.add_argument('--gcn_agg_units', type=int, default=500)
parser.add_argument('--gcn_agg_accum', type=str, default="sum")
parser.add_argument('--gcn_out_units', type=int, default=75)
parser.add_argument('--gen_r_num_basis_func', type=int, default=2)
parser.add_argument('--train_max_epoch', type=int, default=1000)
parser.add_argument('--train_log_interval', type=int, default=1)
parser.add_argument('--train_valid_interval', type=int, default=1)
parser.add_argument('--train_optimizer', type=str, default="adam")
parser.add_argument('--train_grad_clip', type=float, default=1.0)
parser.add_argument('--train_lr', type=float, default=0.01)
parser.add_argument('--train_min_lr', type=float, default=0.0001)
parser.add_argument('--train_lr_decay_factor', type=float, default=0.5)
parser.add_argument('--train_decay_patience', type=int, default=25)
parser.add_argument('--train_early_stopping_patience', type=int, default=50)
parser.add_argument('--share_param', default=False, action='store_true')
parser.add_argument('--mix_cpu_gpu', default=False, action='store_true')
parser.add_argument('--minibatch_size', type=int, default=20000)
parser.add_argument('--num_workers_per_gpu', type=int, default=8)
args = parser.parse_args()
### configure save_fir to save all the info
if args.save_dir is None:
args.save_dir = args.data_name+"_" + ''.join(random.choices(string.ascii_uppercase + string.digits, k=2))
if args.save_id is None:
args.save_id = np.random.randint(20)
args.save_dir = os.path.join("log", args.save_dir)
if not os.path.isdir(args.save_dir):
os.makedirs(args.save_dir)
return args
@thread_wrapped_func
def run(proc_id, n_gpus, args, devices, dataset):
dev_id = devices[proc_id]
train_labels = dataset.train_labels
train_truths = dataset.train_truths
num_edges = train_truths.shape[0]
sampler = GCMCSampler(dataset,
'train')
seeds = th.arange(num_edges)
dataloader = DataLoader(
dataset=seeds,
batch_size=args.minibatch_size,
collate_fn=sampler.sample_blocks,
shuffle=True,
pin_memory=True,
drop_last=False,
num_workers=args.num_workers_per_gpu)
if proc_id == 0:
valid_sampler = GCMCSampler(dataset,
'valid')
valid_seeds = th.arange(dataset.valid_truths.shape[0])
valid_dataloader = DataLoader(dataset=valid_seeds,
batch_size=args.minibatch_size,
collate_fn=valid_sampler.sample_blocks,
shuffle=False,
pin_memory=True,
drop_last=False,
num_workers=args.num_workers_per_gpu)
test_sampler = GCMCSampler(dataset,
'test')
test_seeds = th.arange(dataset.test_truths.shape[0])
test_dataloader = DataLoader(dataset=test_seeds,
batch_size=args.minibatch_size,
collate_fn=test_sampler.sample_blocks,
shuffle=False,
pin_memory=True,
drop_last=False,
num_workers=args.num_workers_per_gpu)
if n_gpus > 1:
dist_init_method = 'tcp://{master_ip}:{master_port}'.format(
master_ip='127.0.0.1', master_port='12345')
world_size = n_gpus
th.distributed.init_process_group(backend="nccl",
init_method=dist_init_method,
world_size=world_size,
rank=dev_id)
if n_gpus > 0:
th.cuda.set_device(dev_id)
nd_possible_rating_values = \
th.FloatTensor(dataset.possible_rating_values)
nd_possible_rating_values = nd_possible_rating_values.to(dev_id)
net = Net(args=args, dev_id=dev_id)
net = net.to(dev_id)
if n_gpus > 1:
net = DistributedDataParallel(net, device_ids=[dev_id], output_device=dev_id)
rating_loss_net = nn.CrossEntropyLoss()
learning_rate = args.train_lr
optimizer = get_optimizer(args.train_optimizer)(net.parameters(), lr=learning_rate)
print("Loading network finished ...\n")
### declare the loss information
best_valid_rmse = np.inf
no_better_valid = 0
best_epoch = -1
count_rmse = 0
count_num = 0
count_loss = 0
print("Start training ...")
dur = []
iter_idx = 1
for epoch in range(1, args.train_max_epoch):
if epoch > 1:
t0 = time.time()
net.train()
for step, sample_data in enumerate(dataloader):
compact_g, frontier, head_feat, tail_feat, \
true_relation_labels, true_relation_ratings = sample_data
head_feat = head_feat.to(dev_id)
tail_feat = tail_feat.to(dev_id)
pred_ratings = net(compact_g, frontier, head_feat, tail_feat, dataset.possible_rating_values)
loss = rating_loss_net(pred_ratings, true_relation_labels.to(dev_id)).mean()
count_loss += loss.item()
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(net.parameters(), args.train_grad_clip)
optimizer.step()
if proc_id == 0 and iter_idx == 1:
print("Total #Param of net: %d" % (torch_total_param_num(net)))
real_pred_ratings = (th.softmax(pred_ratings, dim=1) *
nd_possible_rating_values.view(1, -1)).sum(dim=1)
rmse = ((real_pred_ratings - true_relation_ratings.to(dev_id)) ** 2).sum()
count_rmse += rmse.item()
count_num += pred_ratings.shape[0]
if iter_idx % args.train_log_interval == 0:
logging_str = "Iter={}, loss={:.4f}, rmse={:.4f}".format(
iter_idx, count_loss/iter_idx, count_rmse/count_num)
count_rmse = 0
count_num = 0
if iter_idx % args.train_log_interval == 0:
print("[{}] {}".format(proc_id, logging_str))
iter_idx += 1
if epoch > 1:
epoch_time = time.time() - t0
print("Epoch {} time {}".format(epoch, epoch_time))
if epoch % args.train_valid_interval == 0:
if n_gpus > 1:
th.distributed.barrier()
if proc_id == 0:
valid_rmse = evaluate(args=args,
dev_id=dev_id,
net=net,
dataset=dataset,
dataloader=valid_dataloader,
segment='valid')
logging_str += ',\tVal RMSE={:.4f}'.format(valid_rmse)
if valid_rmse < best_valid_rmse:
best_valid_rmse = valid_rmse
no_better_valid = 0
best_epoch = epoch
test_rmse = evaluate(args=args,
dev_id=dev_id,
net=net,
dataset=dataset,
dataloader=test_dataloader,
segment='test')
best_test_rmse = test_rmse
logging_str += ', Test RMSE={:.4f}'.format(test_rmse)
else:
no_better_valid += 1
if no_better_valid > args.train_early_stopping_patience\
and learning_rate <= args.train_min_lr:
logging.info("Early stopping threshold reached. Stop training.")
break
if no_better_valid > args.train_decay_patience:
new_lr = max(learning_rate * args.train_lr_decay_factor, args.train_min_lr)
if new_lr < learning_rate:
logging.info("\tChange the LR to %g" % new_lr)
learning_rate = new_lr
for p in optimizer.param_groups:
p['lr'] = learning_rate
no_better_valid = 0
print("Change the LR to %g" % new_lr)
# sync on evalution
if n_gpus > 1:
th.distributed.barrier()
print(logging_str)
if proc_id == 0:
print('Best epoch Idx={}, Best Valid RMSE={:.4f}, Best Test RMSE={:.4f}'.format(
best_epoch, best_valid_rmse, best_test_rmse))
if __name__ == '__main__':
args = config()
devices = list(map(int, args.gpu.split(',')))
n_gpus = len(devices)
# For GCMC based on sampling, we require node has its own features.
# Otherwise (node_id is the feature), the model can not scale
dataset = MovieLens(args.data_name,
'cpu',
mix_cpu_gpu=args.mix_cpu_gpu,
use_one_hot_fea=args.use_one_hot_fea,
symm=args.gcn_agg_norm_symm,
test_ratio=args.data_test_ratio,
valid_ratio=args.data_valid_ratio)
print("Loading data finished ...\n")
args.src_in_units = dataset.user_feature_shape[1]
args.dst_in_units = dataset.movie_feature_shape[1]
args.rating_vals = dataset.possible_rating_values
# cpu
if devices[0] == -1:
run(0, 0, args, ['cpu'], dataset)
# gpu
elif n_gpus == 1:
run(0, n_gpus, args, devices, dataset)
# multi gpu
else:
prepare_mp(dataset.train_enc_graph)
prepare_mp(dataset.train_dec_graph)
procs = []
for proc_id in range(n_gpus):
p = mp.Process(target=run, args=(proc_id, n_gpus, args, devices, dataset))
p.start()
procs.append(p)
for p in procs:
p.join()
|
test_imperative_data_loader_exit_func.py
|
# Copyright (c) 2020 PaddlePaddle 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.
import sys
import signal
import unittest
import multiprocessing
import time
import paddle.compat as cpt
from paddle.fluid.framework import _test_eager_guard
if sys.version_info[0] == 2:
import Queue as queue
else:
import queue
from paddle.fluid.reader import multiprocess_queue_set, _cleanup, CleanupFuncRegistrar
# NOTE: These special functions cannot be detected by the existing coverage mechanism,
# so the following unittests are added for these internal functions.
class TestDygraphDataLoaderCleanUpFunc(unittest.TestCase):
def setUp(self):
self.capacity = 10
def func_test_clear_queue_set(self):
test_queue = queue.Queue(self.capacity)
global multiprocess_queue_set
multiprocess_queue_set.add(test_queue)
for i in range(0, self.capacity):
test_queue.put(i)
_cleanup()
def test_clear_queue_set(self):
with _test_eager_guard():
self.func_test_clear_queue_set()
self.func_test_clear_queue_set()
class TestRegisterExitFunc(unittest.TestCase):
# This function does not need to be implemented in this case
def none_func(self):
pass
def func_test_not_callable_func(self):
exception = None
try:
CleanupFuncRegistrar.register(5)
except TypeError as ex:
self.assertIn("is not callable", cpt.get_exception_message(ex))
exception = ex
self.assertIsNotNone(exception)
def test_not_callable_func(self):
with _test_eager_guard():
self.func_test_not_callable_func()
self.func_test_not_callable_func()
def func_test_old_handler_for_sigint(self):
CleanupFuncRegistrar.register(function=self.none_func,
signals=[signal.SIGINT])
def test_old_handler_for_sigint(self):
with _test_eager_guard():
self.func_test_old_handler_for_sigint()
self.func_test_old_handler_for_sigint()
def func_test_signal_wrapper_by_sigchld(self):
# This function does not need to be implemented in this case
def __test_process__():
pass
CleanupFuncRegistrar.register(function=self.none_func,
signals=[signal.SIGCHLD])
exception = None
try:
test_process = multiprocessing.Process(target=__test_process__)
test_process.start()
time.sleep(3)
except SystemExit as ex:
exception = ex
self.assertIsNotNone(exception)
def test_signal_wrapper_by_sigchld(self):
with _test_eager_guard():
self.func_test_signal_wrapper_by_sigchld()
self.func_test_signal_wrapper_by_sigchld()
if __name__ == '__main__':
unittest.main()
|
test_git.py
|
"""
test_git.py - tests for the git module
author: nu11us <[email protected]>
"""
import unittest
from mock import MagicMock
from modules import git
from threading import Thread
class TestGit(unittest.TestCase):
def setUp(self):
self.phenny = MagicMock()
self.input = MagicMock()
def test_setup_server(self):
git.setup_server(self.phenny)
thread_status = git.httpd
git.teardown(self.phenny)
self.assertTrue(thread_status)
def test_auto_start(self):
self.input.nick = "begiak2"
self.phenny.nick = "begiak2"
self.phenny.phenny.config.githook_autostart = True
git.auto_start(self.phenny, self.input)
thread_status = git.httpd or Thread(target=git.httpd.serve_forever).isAlive()
git.teardown(self.phenny)
self.assertTrue(thread_status)
def test_auto_start_fail(self):
self.input.nick = "not_begiak2"
self.phenny.nick = "begiak2"
git.auto_start(self.phenny, self.input)
self.assertFalse(git.httpd)
def test_gitserver_status_down(self):
git.teardown(self.phenny)
self.input.admin = False
self.input.group = lambda x: [None, 'status'][x]
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
self.assertTrue("Server is down" in out)
def test_gitserver_status_up(self):
self.input.admin = False
self.input.group = lambda x: [None, 'status'][x]
git.httpd = True
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
git.httpd = None
self.assertTrue("Server is up" in out)
def test_gitserver_status_down_admin(self):
git.teardown(self.phenny)
self.input.admin = True
self.input.group = lambda x: [None, 'status'][x]
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
self.assertTrue("Server is down" in out)
def test_gitserver_status_up_admin(self):
self.input.admin = True
self.input.group = lambda x: [None, 'status'][x]
git.httpd = True
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
git.httpd = None
self.assertTrue("Server is up" in out)
def test_gitserver_stop_on(self):
self.input.admin = True
self.input.group = lambda x: [None, 'stop'][x]
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
self.assertFalse(git.httpd)
def test_gitserver_stop_off(self):
self.input.admin = True
self.input.group = lambda x: [None, 'stop'][x]
git.teardown(self.phenny)
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
self.assertTrue("Server is already down" in out and not git.httpd)
def test_gitserver_start_on(self):
self.input.admin = True
self.input.group = lambda x: [None, 'start'][x]
git.setup_server(self.phenny)
git.gitserver(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
self.assertTrue("Server is already up" in out and git.httpd)
def test_gitserver_start_off(self):
self.input.admin = True
self.input.group = lambda x: [None, 'start'][x]
git.teardown(self.phenny)
git.gitserver(self.phenny, self.input)
self.assertTrue(git.httpd)
def test_to_commit(self):
self.input.group = lambda x: [None, '93dd6c960b6e55d70db6f6704b1304e0e4101d49'][x]
git.to_commit(self.phenny, self.input)
out = self.phenny.reply.call_args[0][0]
real_url = "https://github.com/apertium/lttoolbox/commit/93dd6c960b6e55d70db6f6704b1304e0e4101d49"
self.assertTrue(real_url in out)
|
email_warnings_thread.py
|
# Built-in Python imports
import logging
import threading
import time
# iotalib imports
from . import logutil
from . import notification
from . import config_notification
def start():
"""
Called by the client to kick off the e-mail warning notification thread
"""
logging.info("Starting warning e-mailer thread")
thread = threading.Thread(target=_thread_loop)
thread.daemon = True
thread.start()
def _thread_loop():
"""
Periodically accumulate any log messages of level WARNING or higher
and e-mail them to interested parties
"""
while True:
try:
if not logutil.warning_queue.empty():
logging.info("Sending warning e-mails")
notification.send_warnings()
except Exception as ex:
logging.exception("Error sending warning emails")
time.sleep(config_notification.values.warning_email_min_interval_seconds)
|
HomePage.py
|
import threading
from tkinter import *
import tkinter.filedialog
from tkinter import ttk
import time
import cv2
from PIL import Image, ImageTk
import constants
from datetime import datetime
from VideoProcessor import VideoProcessor
class HomePage(Frame):
def __init__(self, master):
Frame.__init__(self, master, padx=20, bg=constants.colors['main']['bg'])
self.grid(row=1, column=1)
self.nowTimeVar = StringVar(self, value=datetime.now().strftime("Date-%d-%m-%Y Time-%H:%M:%S"))
timeLabel = Label(self, textvariable=self.nowTimeVar, bg=constants.colors['main']['bg'], padx=10)
self.openVideoButton = ttk.Button(self, text='Open Video to Process', command=self.open_vid)
# grid
timeLabel.grid(row=0, column=0, columnspan=2, sticky=N + S + E)
self.openVideoButton.grid(row=1, column=0, columnspan=2, sticky=N + W + S + E, ipady=10, ipadx=40, pady=280, padx=240)
self.updater()
def updater(self):
# clock
self.nowTimeVar.set(datetime.now().strftime("Date-%d-%m-%Y Time-%H:%M:%S"))
self.after(1000, self.updater)
def open_vid(self):
# ask save location
dirname = tkinter.filedialog.askopenfile(mode='r', filetypes=[('Video Files', '*.mp4'),('Image Files', '*.png'),('Image Files', '*.jpg'),('Image Files', '*.jpeg')])
if not dirname:
return
vidLabel = Label(self, pady=10)
plateLabel = Label(self, padx=10, pady=10, bg=constants.colors['main']['bg'])
thread = threading.Thread(target=self.imageRefresh, args=(vidLabel, plateLabel, dirname))
thread.start()
vidLabel.grid(row=1, column=0, columnspan=2, sticky=N)
plateLabel.grid(row=2, column=0, sticky=N + W + S + E, columnspan=2)
def imageRefresh(self, photoLabel, plateLabel, dirname):
vidProcessor = VideoProcessor(dirname)
self.openVideoButton.grid_forget()
while vidProcessor.isFrameAvailable:
img_rgb = cv2.cvtColor(vidProcessor.frame, cv2.COLOR_BGR2RGB)
photoPIL = Image.fromarray(img_rgb)
photowidth, photoheight = photoPIL.size
aspectr = photowidth / photoheight
photoPIL = photoPIL.resize((945, int(945 / aspectr)), Image.ANTIALIAS)
frame_image = ImageTk.PhotoImage(photoPIL)
photoLabel.config(image=frame_image, pady=10)
photoLabel.image = frame_image
img_rgb = cv2.cvtColor(vidProcessor.plateImage, cv2.COLOR_BGR2RGB)
photoPIL = Image.fromarray(img_rgb)
photowidth, photoheight = photoPIL.size
aspectr = photowidth / photoheight
photoPIL = photoPIL.resize((400, int(400 / aspectr)), Image.ANTIALIAS)
plate_image = ImageTk.PhotoImage(photoPIL)
plateLabel.config(image=plate_image, pady=10)
plateLabel.image = plate_image
time.sleep(1 / 5) # this is refresh rate
|
memory_watcher.py
|
# Copyright 2010 Alon Zakai ('kripken'). All rights reserved.
# This file is part of Syntensity/the Intensity Engine, an open source project. See COPYING.txt for licensing.
'''
'''
import os, signal, time, threading, subprocess
from intensity.base import *
def get_memory_usage():
'''Returns memory usage of current process, in MB'''
process = subprocess.Popen(
"ps -o rss %d" % os.getpid(),
shell=True,
stdout=subprocess.PIPE,
)
return float(process.communicate()[0].split('\n')[1])/1024.
def halt_on_excess():
print '<<<! Memory usage is excessive (%f MB), killing the process !>>>' % get_memory_usage()
main_actionqueue.add_action(lambda: show_client_message(ALL_CLIENTS, "Server Memory Monitor", "Shutting down due to excessive memory use"))
time.sleep(5.0) # Let print and message propagate
os.kill(os.getpid(), signal.SIGKILL)
def watcher():
resolution = float(get_config('MemoryWatcher', 'resolution', '1.0'))
threshold = float(get_config('MemoryWatcher', 'threshold', '40')) # 40MB
consecutives_to_act = int(get_config('MemoryWatcher', 'consecutives_to_act', '1')) # How many consecutive threshold passings before acting
action = get_config('MemoryWatcher', 'action', 'halt_on_excess()')
consecutives = 0
while True:
time.sleep(resolution)
if get_memory_usage() >= threshold:
consecutives += 1
else:
consecutives = 0
if consecutives >= consecutives_to_act:
exec(action)
thread = threading.Thread(target=watcher)
thread.setDaemon(True)
thread.start()
|
test_rpc_proxy.py
|
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
import tvm
from tvm import te
import logging
import numpy as np
import time
import multiprocessing
from tvm import rpc
def rpc_proxy_check():
"""This is a simple test function for RPC Proxy
It is not included as pytests, because:
- It depends on tornado
- It relies on the fact that Proxy starts before client and server connects,
which is often the case but not always
User can directly run this script to verify correctness.
"""
try:
from tvm.rpc import proxy
web_port = 8888
prox = proxy.Proxy("localhost", web_port=web_port)
def check():
if not tvm.runtime.enabled("rpc"):
return
@tvm.register_func("rpc.test2.addone")
def addone(x):
return x + 1
@tvm.register_func("rpc.test2.strcat")
def addone(name, x):
return "%s:%d" % (name, x)
server = multiprocessing.Process(
target=proxy.websocket_proxy_server, args=("ws://localhost:%d/ws" % web_port, "x1")
)
# Need to make sure that the connection start after proxy comes up
time.sleep(0.1)
server.deamon = True
server.start()
client = rpc.connect(prox.host, prox.port, key="x1")
f1 = client.get_function("rpc.test2.addone")
assert f1(10) == 11
f2 = client.get_function("rpc.test2.strcat")
assert f2("abc", 11) == "abc:11"
check()
except ImportError:
print("Skipping because tornado is not avaliable...")
if __name__ == "__main__":
logging.basicConfig(level=logging.INFO)
rpc_proxy_check()
|
networkstreams.py
|
import socket
import threading
import tankmanager
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket_port = 16505
socket_hostname = socket.gethostname()
def start_server(hostname=socket_hostname, port=socket_port):
global socket_port, socket_hostname
socket_port = port
socket_hostname = hostname
print('Starting server with hostname ' + hostname + ' on the port ' + str(port))
server_socket.bind((hostname, port))
server_socket.listen(5)
x = threading.Thread(target=handle_connections, daemon=True)
x.start()
def change_properties(hostname=socket_hostname, port=socket_port):
global socket_port, socket_hostname, server_socket
socket_port = port
socket_hostname = hostname
print('Applying any changes to server...')
server_socket.detach()
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_socket.bind((hostname, port))
server_socket.listen(5)
def handle_connections():
while True:
(client_socket, address) = server_socket.accept()
data = client_socket.recv(1024)
for request in data.decode("utf-8").split(' '):
identity = request.split('=')
if len(identity) > 1:
if identity[0] == 'TANK.ID':
tankmanager.status_received_from_tank(identity[1], address[0], address[1])
elif identity[0] == 'DETAILS.ID':
target = tankmanager.get_tank(identity[1])
if type(target) == bool and not target:
client_socket.send(('ID=' + identity[1] + ' STATUS=VANISHED').encode('utf-8'))
else:
client_socket.send(target.dump_details().encode('utf-8'))
elif identity[0] == 'INFO':
client_socket.send(('TYPE=TANKSTATSERV VERSION=' + '0.0.0').encode('utf-8'))
client_socket.close()
|
manager.py
|
import argparse # noqa
import atexit # noqa
import codecs # noqa
import collections
import copy # noqa
import errno # noqa
import fnmatch # noqa
import hashlib # noqa
import os # noqa
import shutil # noqa
import signal # noqa
import sys # noqa
import threading # noqa
import traceback # noqa
from contextlib import contextmanager # noqa
from datetime import datetime, timedelta # noqa
from typing import ( # noqa
TYPE_CHECKING,
Dict,
Iterator,
List,
Optional,
Sequence,
Tuple,
Type,
Union,
)
import sqlalchemy # noqa
import yaml # noqa
from loguru import logger # noqa
from sqlalchemy.engine import Engine
from sqlalchemy.exc import OperationalError # noqa
from sqlalchemy.ext.declarative import declarative_base # noqa
from sqlalchemy.orm import sessionmaker # noqa
# These need to be declared before we start importing from other flexget modules, since they might import them
from flexget.config_schema import ConfigError
from flexget.utils.sqlalchemy_utils import ContextSession # noqa
from flexget.utils.tools import get_current_flexget_version, io_encoding, pid_exists # noqa
Base = declarative_base()
Session: Type[ContextSession] = sessionmaker(class_=ContextSession)
import flexget.log # noqa
from flexget import config_schema, db_schema, plugin # noqa
from flexget.event import fire_event # noqa
from flexget.ipc import IPCClient, IPCServer # noqa
from flexget.options import ( # noqa
CoreArgumentParser,
ParserError,
get_parser,
manager_parser,
unicode_argv,
)
from flexget.task import Task # noqa
from flexget.task_queue import TaskQueue # noqa
from flexget.terminal import console, get_console_output # noqa
if TYPE_CHECKING:
from flexget.tray_icon import TrayIcon
from flexget.utils.simple_persistence import SimplePersistence
logger = logger.bind(name='manager')
manager: Optional['Manager'] = None
DB_CLEANUP_INTERVAL = timedelta(days=7)
class Manager:
"""Manager class for FlexGet
Fires events:
* manager.initialize
The first time the manager is initialized, before config is loaded
* manager.before_config_load
Before the config file is loaded from disk
* manager.before_config_validate
When updating the config, before the validator is run on it
* manager.config_updated
After a configuration file has been loaded or changed (and validated) this event is fired
* manager.startup
After manager has been initialized. This is when application becomes ready to use,
however no database lock is present, so the database must not be modified on this event.
* manager.lock_acquired
The manager does not always require a lock on startup, if one is requested,
this event will run when it has been acquired successfully
* manager.upgrade
If any plugins have declared a newer schema version than exists in the database,
this event will be fired to allow plugins to upgrade their tables
* manager.shutdown_requested
When shutdown has been requested. Any plugins which might add to
execution queue should stop when this is fired.
* manager.shutdown
When the manager is exiting
* manager.execute.completed
If execution in current process was completed
* manager.daemon.started
* manager.daemon.completed
* manager.db_cleanup
"""
unit_test = False
options: argparse.Namespace
def __init__(self, args: Optional[List[str]]) -> None:
"""
:param args: CLI args
"""
global manager
if not self.unit_test:
assert not manager, 'Only one instance of Manager should be created at a time!'
elif manager:
logger.info('last manager was not torn down correctly')
if args is None:
# Decode all arguments to unicode before parsing
args = unicode_argv()[1:]
self.args = args
self.autoreload_config = False
self.config_file_hash: Optional[str] = None
self.config_base: str = ''
self.config_name: str = ''
self.config_path: str = ''
self.log_filename: str = ''
self.db_filename: str = ''
self.engine: Optional[Engine] = None
self.lockfile: str = ''
self.database_uri: str = ''
self.db_upgraded = False
self._has_lock = False
self.is_daemon = False
self.ipc_server: IPCServer
self.task_queue: TaskQueue
self.persist: 'SimplePersistence'
self.initialized = False
self.config: Dict = {}
self.options = self._init_options(self.args)
try:
self._init_config(create=False)
except Exception:
flexget.log.start(level=self.options.loglevel, to_file=False)
raise
manager = self
logger.debug('sys.defaultencoding: {}', sys.getdefaultencoding())
logger.debug('sys.getfilesystemencoding: {}', sys.getfilesystemencoding())
logger.debug('flexget detected io encoding: {}', io_encoding)
logger.debug('os.path.supports_unicode_filenames: {}', os.path.supports_unicode_filenames)
if (
codecs.lookup(sys.getfilesystemencoding()).name == 'ascii'
and not os.path.supports_unicode_filenames
):
logger.warning(
'Your locale declares ascii as the filesystem encoding. Any plugins reading filenames from '
'disk will not work properly for filenames containing non-ascii characters. Make sure your '
'locale env variables are set up correctly for the environment which is launching FlexGet.'
)
def _add_tray_icon_items(self, tray_icon: 'TrayIcon'):
tray_icon.add_menu_item(text='Shutdown', action=self.shutdown, index=2)
tray_icon.add_menu_item(text='Reload Config', action=self.load_config, index=3)
tray_icon.add_menu_separator(index=4)
@staticmethod
def _init_options(args: List[str]) -> argparse.Namespace:
"""Initialize argument parsing"""
try:
options = CoreArgumentParser().parse_known_args(args, do_help=False)[0]
except ParserError as exc:
try:
# If a non-built-in command was used, we need to parse with a parser that
# doesn't define the subparsers
options = manager_parser.parse_known_args(args, do_help=False)[0]
except ParserError:
manager_parser.print_help()
print(f'\nError: {exc.message}')
sys.exit(1)
return options
def _init_logging(self, to_file: bool = True) -> None:
"""Initialize logging facilities"""
log_file = os.path.expanduser(self.options.logfile)
# If an absolute path is not specified, use the config directory.
if not os.path.isabs(log_file):
log_file = os.path.join(self.config_base, log_file)
self.log_filename = log_file
flexget.log.start(
log_file, self.options.loglevel, to_file=to_file, to_console=not self.options.cron
)
def initialize(self) -> None:
"""
Load plugins, database, and config. Also initializes (but does not start) the task queue and ipc server.
This should only be called after obtaining a lock.
"""
if self.initialized:
raise RuntimeError('Cannot call initialize on an already initialized manager.')
plugin.load_plugins(
extra_plugins=[os.path.join(self.config_base, 'plugins')],
extra_components=[os.path.join(self.config_base, 'components')],
)
# Reparse CLI options now that plugins are loaded
self.options = get_parser().parse_args(self.args)
self.task_queue = TaskQueue()
self.ipc_server = IPCServer(self, self.options.ipc_port)
self.setup_yaml()
self.init_sqlalchemy()
fire_event('manager.initialize', self)
try:
self.load_config()
except ValueError as e:
logger.critical('Failed to load config file: {}', e.args[0])
raise
# cannot be imported at module level because of circular references
from flexget.utils.simple_persistence import SimplePersistence
self.persist = SimplePersistence('manager')
if db_schema.upgrade_required():
logger.info('Database upgrade is required. Attempting now.')
fire_event('manager.upgrade', self)
if manager.db_upgraded:
fire_event('manager.db_upgraded', self)
fire_event('manager.startup', self)
self.initialized = True
@property
def tasks(self) -> List[str]:
"""A list of tasks in the config"""
if not self.config:
return []
return list(self.config.get('tasks', {}).keys())
@property
def has_lock(self) -> bool:
return self._has_lock
def execute(
self,
options: Union[dict, argparse.Namespace] = None,
priority: int = 1,
suppress_warnings: Sequence[str] = None,
) -> List[Tuple[str, str, threading.Event]]:
"""
Run all (can be limited with options) tasks from the config.
:param options: Either an :class:`argparse.Namespace` instance, or a dict, containing options for execution
:param priority: If there are other executions waiting to be run, they will be run in priority order,
lowest first.
:param suppress_warnings: Allows suppressing log warning about missing plugin in key phases
:returns: a list of :class:`threading.Event` instances which will be
set when each respective task has finished running
"""
if options is None:
options = copy.copy(self.options.execute)
elif isinstance(options, dict):
options_namespace = copy.copy(self.options.execute)
options_namespace.__dict__.update(options)
options = options_namespace
task_names = self.tasks
# Only reload config if daemon
config_hash = self.hash_config()
if self.is_daemon and self.autoreload_config and self.config_file_hash != config_hash:
logger.info('Config change detected. Reloading.')
try:
self.load_config(output_to_console=False, config_file_hash=config_hash)
logger.info('Config successfully reloaded!')
except Exception as e:
logger.error('Reloading config failed: {}', e)
# Handle --tasks
if options.tasks:
# Consider * the same as not specifying tasks at all (makes sure manual plugin still works)
if options.tasks == ['*']:
options.tasks = None
else:
# Create list of tasks to run, preserving order
task_names = []
for arg in options.tasks:
matches = [
t for t in self.tasks if fnmatch.fnmatchcase(str(t).lower(), arg.lower())
]
if not matches:
msg = f'`{arg}` does not match any tasks'
logger.error(msg)
continue
task_names.extend(m for m in matches if m not in task_names)
# Set the option as a list of matching task names so plugins can use it easily
options.tasks = task_names
# TODO: 1.2 This is a hack to make task priorities work still, not sure if it's the best one
task_names = sorted(
task_names, key=lambda t: self.config['tasks'][t].get('priority', 65535)
)
finished_events = []
for task_name in task_names:
task = Task(
self,
task_name,
options=options,
output=get_console_output(),
session_id=flexget.log.get_log_session_id(),
priority=priority,
suppress_warnings=suppress_warnings,
)
self.task_queue.put(task)
finished_events.append((task.id, task.name, task.finished_event))
return finished_events
def start(self) -> None:
"""
Starting point when executing from commandline, dispatch execution to correct destination.
If there is a FlexGet process with an ipc server already running, the command will be sent there for execution
and results will be streamed back.
If not, this will attempt to obtain a lock, initialize the manager, and run the command here.
"""
# When we are in test mode, we use a different lock file and db
if self.options.test:
self.lockfile = os.path.join(self.config_base, f'.test-{self.config_name}-lock')
# If another process is started, send the execution to the running process
ipc_info = self.check_ipc_info()
# If we are connecting to a running daemon, we don't want to log to the log file,
# the daemon is already handling that.
self._init_logging(to_file=not ipc_info)
if ipc_info:
console(
'There is a FlexGet process already running for this config, sending execution there.'
)
logger.debug('Sending command to running FlexGet process: {}', self.args)
try:
client = IPCClient(ipc_info['port'], ipc_info['password'])
except ValueError as e:
logger.error(e)
else:
try:
client.handle_cli(self.args)
except KeyboardInterrupt:
logger.error(
'Disconnecting from daemon due to ctrl-c. Executions will still continue in the '
'background.'
)
except EOFError:
logger.error('Connection from daemon was severed.')
return
if self.options.test:
logger.info('Test mode, creating a copy from database ...')
db_test_filename = os.path.join(self.config_base, f'test-{self.config_name}.sqlite')
if os.path.exists(self.db_filename):
shutil.copy(self.db_filename, db_test_filename)
logger.info('Test database created')
self.db_filename = db_test_filename
# No running process, we start our own to handle command
with self.acquire_lock():
self.initialize()
self.handle_cli()
self._shutdown()
def handle_cli(self, options: argparse.Namespace = None) -> None:
"""
Dispatch a cli command to the appropriate function.
* :meth:`.execute_command`
* :meth:`.daemon_command`
* CLI plugin callback function
The manager should have a lock and be initialized before calling this method.
:param options: argparse options for command. Defaults to options that manager was instantiated with.
"""
if not options:
options = self.options
command = options.cli_command
if command is None:
raise Exception('Command missing')
command_options = getattr(options, command)
# First check for built-in commands
if command in ['execute', 'daemon']:
if command == 'execute':
self.execute_command(command_options)
elif command == 'daemon':
self.daemon_command(command_options)
else:
# Otherwise dispatch the command to the callback function
options.cli_command_callback(self, command_options)
def execute_command(self, options: argparse.Namespace) -> None:
"""
Handles the 'execute' CLI command.
If there is already a task queue running in this process, adds the execution to the queue.
If FlexGet is being invoked with this command, starts up a task queue and runs the execution.
Fires events:
* manager.execute.started
* manager.execute.completed
:param options: argparse options
"""
fire_event('manager.execute.started', self, options)
if self.task_queue.is_alive() or self.is_daemon:
if not self.task_queue.is_alive():
logger.error(
'Task queue has died unexpectedly. Restarting it. Please open an issue on Github and include'
' any previous error logs.'
)
self.task_queue = TaskQueue()
self.task_queue.start()
if len(self.task_queue):
logger.verbose('There is a task already running, execution queued.')
finished_events = self.execute(options)
if not options.cron:
# Wait until execution of all tasks has finished
for _, _, event in finished_events:
event.wait()
else:
self.task_queue.start()
self.ipc_server.start()
self.execute(options)
self.shutdown(finish_queue=True)
self.task_queue.wait()
fire_event('manager.execute.completed', self, options)
def daemon_command(self, options: argparse.Namespace) -> None:
"""
Handles the 'daemon' CLI command.
Fires events:
* manager.daemon.started
* manager.daemon.completed
:param options: argparse options
"""
# Import API so it can register to daemon.started event
if options.action == 'start':
if self.is_daemon:
logger.error('Daemon already running for this config.')
return
elif self.task_queue.is_alive():
logger.error(
'Non-daemon execution of FlexGet is running. Cannot start daemon until it is finished.'
)
return
if options.daemonize:
self.daemonize()
if options.autoreload_config:
self.autoreload_config = True
try:
signal.signal(signal.SIGTERM, self._handle_sigterm)
except ValueError as e:
# If flexget is being called from another script, e.g. windows service helper, and we are not the
# main thread, this error will occur.
logger.debug('Error registering sigterm handler: {}', e)
self.is_daemon = True
def run_daemon(tray_icon: 'TrayIcon' = None):
fire_event('manager.daemon.started', self)
self.task_queue.start()
self.ipc_server.start()
self.task_queue.wait()
fire_event('manager.daemon.completed', self)
if tray_icon:
tray_icon.stop()
if options.tray_icon:
from flexget.tray_icon import tray_icon # noqa
self._add_tray_icon_items(tray_icon)
# Tray icon must be run in the main thread.
m = threading.Thread(target=run_daemon, args=(tray_icon,))
m.start()
tray_icon.run()
m.join()
else:
run_daemon()
elif options.action in ['stop', 'reload-config', 'status']:
if not self.is_daemon:
console('There does not appear to be a daemon running.')
return
if options.action == 'status':
logger.debug('`daemon status` called. Daemon running. (PID: {})', os.getpid())
console(f'Daemon running. (PID: {os.getpid()})')
elif options.action == 'stop':
tasks = (
'all queued tasks (if any) have'
if options.wait
else 'currently running task (if any) has'
)
logger.info(
'Daemon shutdown requested. Shutdown will commence when {} finished executing.',
tasks,
)
self.shutdown(options.wait)
elif options.action == 'reload-config':
logger.info('Reloading config from disk.')
try:
self.load_config()
except ValueError as e:
logger.error('Error loading config: {}', e.args[0])
else:
logger.info('Config successfully reloaded from disk.')
def _handle_sigterm(self, signum, frame) -> None:
logger.info('Got SIGTERM. Shutting down.')
self.shutdown(finish_queue=False)
def setup_yaml(self) -> None:
"""Customize the yaml loader/dumper behavior"""
# Represent OrderedDict as a regular dict (but don't sort it alphabetically)
# This lets us order a dict in a yaml file for easier human consumption
represent_dict_order = lambda self, data: self.represent_mapping(
'tag:yaml.org,2002:map', data.items()
)
yaml.add_representer(collections.OrderedDict, represent_dict_order)
# Set up the dumper to increase the indent for lists
def increase_indent_wrapper(func):
def increase_indent(self, flow=False, indentless=False):
func(self, flow, False)
return increase_indent
yaml.Dumper.increase_indent = increase_indent_wrapper(yaml.Dumper.increase_indent)
yaml.SafeDumper.increase_indent = increase_indent_wrapper(yaml.SafeDumper.increase_indent)
def _init_config(self, create: bool = False) -> None:
"""
Find and load the configuration file.
:param bool create: If a config file is not found, and create is True, one will be created in the home folder
:raises: `OSError` when no config file could be found, and `create` is False.
"""
home_path = os.path.join(os.path.expanduser('~'), '.flexget')
options_config = os.path.expanduser(self.options.config)
possible = []
if os.path.isabs(options_config):
# explicit path given, don't try anything
config = options_config
possible = [config]
else:
logger.debug('Figuring out config load paths')
try:
possible.append(os.getcwd())
except OSError:
logger.debug('current directory invalid, not searching for config there')
# for virtualenv / dev sandbox
if hasattr(sys, 'real_prefix'):
logger.debug('Adding virtualenv path')
possible.append(sys.prefix)
# normal lookup locations
possible.append(home_path)
if sys.platform.startswith('win'):
# On windows look in ~/flexget as well, as explorer does not let you create a folder starting with a dot
home_path = os.path.join(os.path.expanduser('~'), 'flexget')
possible.append(home_path)
else:
# The freedesktop.org standard config location
xdg_config = os.environ.get(
'XDG_CONFIG_HOME', os.path.join(os.path.expanduser('~'), '.config')
)
possible.append(os.path.join(xdg_config, 'flexget'))
for path in possible:
config = os.path.join(path, options_config)
if os.path.exists(config):
logger.debug('Found config: {}', config)
break
else:
config = None
if create and not (config and os.path.exists(config)):
config = os.path.join(home_path, options_config)
logger.info('Config file {} not found. Creating new config {}', options_config, config)
with open(config, 'w') as newconfig:
# Write empty tasks to the config
newconfig.write(yaml.dump({'tasks': {}}))
elif not config:
logger.critical('Failed to find configuration file {}', options_config)
logger.info('Tried to read from: {}', ', '.join(possible))
raise OSError('No configuration file found.')
if not os.path.isfile(config):
raise OSError(f'Config `{config}` does not appear to be a file.')
logger.debug('Config file {} selected', config)
self.config_path = config
self.config_name = os.path.splitext(os.path.basename(config))[0]
self.config_base = os.path.normpath(os.path.dirname(config))
self.lockfile = os.path.join(self.config_base, f'.{self.config_name}-lock')
self.db_filename = os.path.join(self.config_base, f'db-{self.config_name}.sqlite')
def hash_config(self) -> Optional[str]:
if not self.config_path:
return None
sha1_hash = hashlib.sha1()
with open(self.config_path, 'rb') as f:
while True:
data = f.read(65536)
if not data:
break
sha1_hash.update(data)
return sha1_hash.hexdigest()
def load_config(self, output_to_console: bool = True, config_file_hash: str = None) -> None:
"""
Loads the config file from disk, validates and activates it.
:raises: `ValueError` if there is a problem loading the config file
"""
fire_event('manager.before_config_load', self)
with open(self.config_path, 'r', encoding='utf-8') as f:
try:
raw_config = f.read()
except UnicodeDecodeError:
logger.critical('Config file must be UTF-8 encoded.')
raise ValueError('Config file is not UTF-8 encoded')
try:
self.config_file_hash = config_file_hash or self.hash_config()
config = yaml.safe_load(raw_config) or {}
except yaml.YAMLError as e:
msg = str(e).replace('\n', ' ')
msg = ' '.join(msg.split())
logger.critical(msg)
if output_to_console:
print('')
print('-' * 79)
print(' Malformed configuration file (check messages above). Common reasons:')
print('-' * 79)
print('')
print(' o Indentation error')
print(' o Missing : from end of the line')
print(' o Non ASCII characters (use UTF8)')
print(
' o If text contains any of :[]{}% characters it must be single-quoted '
'(eg. value{1} should be \'value{1}\')\n'
)
# Not very good practice but we get several kind of exceptions here, I'm not even sure all of them
# At least: ReaderError, YmlScannerError (or something like that)
if isinstance(e, yaml.MarkedYAMLError):
lines = 0
if e.problem is not None:
print(f' Reason: {e.problem}\n')
if e.problem == 'mapping values are not allowed here':
print(' ----> MOST LIKELY REASON: Missing : from end of the line!')
print('')
if e.context_mark is not None:
print(
' Check configuration near line %s, column %s'
% (e.context_mark.line, e.context_mark.column)
)
lines += 1
if e.problem_mark is not None:
print(
' Check configuration near line %s, column %s'
% (e.problem_mark.line, e.problem_mark.column)
)
lines += 1
if lines:
print('')
if lines == 1:
print(' Fault is almost always in this or previous line\n')
if lines == 2:
print(' Fault is almost always in one of these lines or previous ones\n')
# When --debug escalate to full stacktrace
if self.options.debug or not output_to_console:
raise
raise ValueError('Config file is not valid YAML')
# config loaded successfully
logger.debug('config_name: {}', self.config_name)
logger.debug('config_base: {}', self.config_base)
# Install the newly loaded config
self.update_config(config)
def update_config(self, config: dict) -> None:
"""
Provide a new config for the manager to use.
:raises: `ValueError` and rolls back to previous config if the provided config is not valid.
"""
new_user_config = config
old_config = self.config
try:
self.config = self.validate_config(config)
except ConfigError as e:
for error in getattr(e, 'errors', []):
logger.critical('[{}] {}', error.json_pointer, error.message)
logger.debug('invalid config, rolling back')
self.config = old_config
raise
logger.debug('New config data loaded.')
self.user_config = copy.deepcopy(new_user_config)
fire_event('manager.config_updated', self)
def backup_config(self) -> str:
backup_path = os.path.join(
self.config_base,
f'{self.config_name}-{datetime.now().strftime("%y%m%d%H%M%S")}.bak',
)
logger.debug(f'backing up old config to {backup_path} before new save')
try:
shutil.copy(self.config_path, backup_path)
except OSError as e:
logger.warning(f'Config backup creation failed: {e}')
raise
return backup_path
def save_config(self) -> None:
"""Dumps current config to yaml config file"""
# TODO: Only keep x number of backups..
# Back up the user's current config before overwriting
try:
self.backup_config()
except OSError:
return
with open(self.config_path, 'w') as config_file:
config_file.write(yaml.dump(self.user_config, default_flow_style=False))
def config_changed(self) -> None:
"""Makes sure that all tasks will have the config_modified flag come out true on the next run.
Useful when changing the db and all tasks need to be completely reprocessed."""
from flexget.task import config_changed
config_changed()
fire_event('manager.config_updated', self)
def validate_config(self, config: dict = None) -> dict:
"""
Check all root level keywords are valid. Config may be modified by before_config_validate hooks. Modified
config will be returned.
:param config: Config to check. If not provided, current manager config will be checked.
:raises: `ValueError` when config fails validation. There will be an `errors` attribute with the schema errors.
:returns: Final validated config.
"""
conf = config if config else self.config
conf = fire_event('manager.before_config_validate', conf, self)
errors = config_schema.process_config(conf)
if errors:
err = ConfigError('Did not pass schema validation.')
err.errors = errors
raise err
else:
return conf
def init_sqlalchemy(self) -> None:
"""Initialize SQLAlchemy"""
try:
if [int(part) for part in sqlalchemy.__version__.split('.')] < [0, 7, 0]:
print(
'FATAL: SQLAlchemy 0.7.0 or newer required. Please upgrade your SQLAlchemy.',
file=sys.stderr,
)
sys.exit(1)
except ValueError:
logger.critical('Failed to check SQLAlchemy version, you may need to upgrade it')
# SQLAlchemy
if not self.database_uri:
# in case running on windows, needs double \\
filename = self.db_filename.replace('\\', '\\\\')
self.database_uri = f'sqlite:///{filename}'
if self.db_filename and not os.path.exists(self.db_filename):
logger.verbose('Creating new database {} - DO NOT INTERRUPT ...', self.db_filename)
# fire up the engine
logger.debug('Connecting to: {}', self.database_uri)
try:
self.engine = sqlalchemy.create_engine(
self.database_uri,
echo=self.options.debug_sql,
connect_args={'check_same_thread': False, 'timeout': 10},
)
except ImportError as e:
print(
'FATAL: Unable to use SQLite. Are you running Python 2.7, 3.3 or newer ?\n'
'Python should normally have SQLite support built in.\n'
'If you\'re running correct version of Python then it is not equipped with SQLite.\n'
'You can try installing `pysqlite`. If you have compiled python yourself, '
'recompile it with SQLite support.\n'
f'Error: {e}',
file=sys.stderr,
)
sys.exit(1)
Session.configure(bind=self.engine)
# create all tables, doesn't do anything to existing tables
try:
Base.metadata.create_all(bind=self.engine)
except OperationalError as e:
if os.path.exists(self.db_filename):
print(
'%s - make sure you have write permissions to file %s'
% (e.message, self.db_filename),
file=sys.stderr,
)
else:
print(
'%s - make sure you have write permissions to directory %s'
% (e.message, self.config_base),
file=sys.stderr,
)
raise
def _read_lock(self) -> Optional[dict]:
"""
Read the values from the lock file. Returns None if there is no current lock file.
"""
if self.lockfile and os.path.exists(self.lockfile):
result: Dict[str, Union[str, int]] = {}
with open(self.lockfile, encoding='utf-8') as f:
lines = [line for line in f.readlines() if line]
for line in lines:
try:
key, value = line.split(':', 1)
except ValueError:
logger.debug('Invalid line in lock file: {}', line)
continue
result[key.strip().lower()] = value.strip()
for key in result:
if result[key].isdigit():
result[key] = int(result[key])
result.setdefault('pid', None)
if not result['pid']:
logger.error(
'Invalid lock file. Make sure FlexGet is not running, then delete it.'
)
elif not pid_exists(result['pid']):
return None
return result
return None
def check_lock(self) -> bool:
"""Returns True if there is a lock on the database."""
lock_info = self._read_lock()
if not lock_info:
return False
# Don't count it if we hold the lock
if os.getpid() == lock_info['pid']:
return False
return True
def check_ipc_info(self) -> Optional[dict]:
"""If a daemon has a lock on the database, return info to connect to IPC."""
lock_info = self._read_lock()
if lock_info and 'port' in lock_info:
return lock_info
return None
@contextmanager
def acquire_lock(self, event: bool = True) -> Iterator:
"""
:param bool event: If True, the 'manager.lock_acquired' event will be fired after a lock is obtained
"""
acquired = False
try:
# Don't do anything if we already have a lock. This means only the outermost call will release the lock file
if not self._has_lock:
# Exit if there is an existing lock.
if self.check_lock():
with open(self.lockfile, encoding='utf-8') as f:
pid = f.read()
print(
'Another process (%s) is running, will exit.' % pid.split('\n')[0],
file=sys.stderr,
)
print(
"If you're sure there is no other instance running, delete %s"
% self.lockfile,
file=sys.stderr,
)
sys.exit(1)
self._has_lock = True
self.write_lock()
acquired = True
if event:
fire_event('manager.lock_acquired', self)
yield
finally:
if acquired:
self.release_lock()
self._has_lock = False
def write_lock(self, ipc_info: dict = None) -> None:
assert self._has_lock
with open(self.lockfile, 'w', encoding='utf-8') as f:
f.write(f'PID: {os.getpid()}\n')
if ipc_info:
for key in sorted(ipc_info):
f.write(f'{key}: {ipc_info[key]}\n')
def release_lock(self) -> None:
try:
os.remove(self.lockfile)
except OSError as e:
if e.errno != errno.ENOENT:
raise
logger.debug(f'Lockfile {self.lockfile} not found')
else:
logger.debug(f'Removed {self.lockfile}')
def daemonize(self) -> None:
"""Daemonizes the current process. Returns the new pid"""
if sys.platform.startswith('win'):
logger.error('Cannot daemonize on windows')
return
if threading.active_count() != 1:
logger.critical(
'There are {!r} active threads. Daemonizing now may cause strange failures.',
threading.enumerate(),
)
logger.info('Daemonizing...')
try:
pid = os.fork()
if pid > 0:
# Don't run the exit handlers on the parent
atexit._exithandlers = []
# exit first parent
sys.exit(0)
except OSError as e:
sys.stderr.write(f'fork #1 failed: {e.errno} ({e.strerror})\n')
sys.exit(1)
# decouple from parent environment
os.chdir('/')
os.setsid()
os.umask(0)
# do second fork
try:
pid = os.fork()
if pid > 0:
# Don't run the exit handlers on the parent
atexit._exithandlers = []
# exit from second parent
sys.exit(0)
except OSError as e:
sys.stderr.write(f'fork #2 failed: {e.errno} ({e.strerror})\n')
sys.exit(1)
logger.info(f'Daemonize complete. New PID: {os.getpid()}')
# redirect standard file descriptors
sys.stdout.flush()
sys.stderr.flush()
si = open(os.devnull, 'r')
so = open(os.devnull, 'ab+')
se = open(os.devnull, 'ab+', 0)
os.dup2(si.fileno(), sys.stdin.fileno())
os.dup2(so.fileno(), sys.stdout.fileno())
os.dup2(se.fileno(), sys.stderr.fileno())
# If we have a lock, update the lock file with our new pid
if self._has_lock:
self.write_lock()
def db_cleanup(self, force: bool = False) -> None:
"""
Perform database cleanup if cleanup interval has been met.
Fires events:
* manager.db_cleanup
If interval was met. Gives session to do the cleanup as a parameter.
:param bool force: Run the cleanup no matter whether the interval has been met.
"""
expired = (
self.persist.get('last_cleanup', datetime(1900, 1, 1))
< datetime.now() - DB_CLEANUP_INTERVAL
)
if force or expired:
logger.info('Running database cleanup.')
with Session() as session:
fire_event('manager.db_cleanup', self, session)
# Try to VACUUM after cleanup
fire_event('manager.db_vacuum', self)
# Just in case some plugin was overzealous in its cleaning, mark the config changed
self.config_changed()
self.persist['last_cleanup'] = datetime.now()
else:
logger.debug('Not running db cleanup, last run {}', self.persist.get('last_cleanup'))
def shutdown(self, finish_queue: bool = True) -> None:
"""
Request manager shutdown.
:param bool finish_queue: Should scheduler finish the task queue
"""
if not self.initialized:
raise RuntimeError('Cannot shutdown manager that was never initialized.')
fire_event('manager.shutdown_requested', self)
self.task_queue.shutdown(finish_queue)
def _shutdown(self) -> None:
"""Runs when the manager is done processing everything."""
if self.ipc_server:
self.ipc_server.shutdown()
fire_event('manager.shutdown', self)
if not self.unit_test: # don't scroll "nosetests" summary results when logging is enabled
logger.debug('Shutting down')
self.engine.dispose()
# remove temporary database used in test mode
if self.options.test:
if 'test' not in self.db_filename:
raise Exception('trying to delete non test database?')
if self._has_lock:
os.remove(self.db_filename)
logger.info('Removed test database')
global manager
manager = None
def crash_report(self) -> str:
"""
This should be called when handling an unexpected exception. Will create a new log file containing the last 50
debug messages as well as the crash traceback.
"""
if not self.unit_test:
log_dir = os.path.dirname(self.log_filename)
filename = os.path.join(
log_dir, datetime.now().strftime('crash_report.%Y.%m.%d.%H%M%S%f.log')
)
with codecs.open(filename, 'w', encoding='utf-8') as outfile:
outfile.writelines(flexget.log.debug_buffer)
traceback.print_exc(file=outfile)
logger.critical(
'An unexpected crash has occurred. Writing crash report to {}. '
'Please verify you are running the latest version of flexget by using "flexget -V" '
'from CLI or by using version_checker plugin'
' at http://flexget.com/wiki/Plugins/version_checker. '
'You are currently using version {}',
filename,
get_current_flexget_version(),
)
logger.opt(exception=True).debug('Traceback:')
return traceback.format_exc()
|
parser.py
|
import os
import sys
import time
import signal
import multiprocessing
PROJECT_PATH = os.path.abspath(os.path.dirname(__file__))
sys.path.append(os.path.join(PROJECT_PATH, '..', '..'))
from pygithub3 import Github
import src.todoMelvin
from src.todoMelvin import settings, createGithubObject
from src.todoLogging import WarningLevels, log
from src.db.todoRepos import RepoQueues, Repo
from src.workers.workerStatus import WorkerStatus
redis = src.db.todoRedis.connect()
def parseRepo(repo):
src.todoMelvin.parseRepoForTodos(repo)
if len(repo.Todos) > 0:
redis.rpush(RepoQueues.Posting, repo.key())
else:
log(WarningLevels.Debug, "0 TODOs found, deleting from Redis.")
redis.delete(repo.key())
def runWorker(status):
#This causes this thread to ignore interrupt signals so theya re only handled by parent
signal.signal(signal.SIGINT, signal.SIG_IGN)
#Loop will be closed externally
while status.value != WorkerStatus.Dead:
try:
parseCount = redis.llen(RepoQueues.Parsing)
except:
log(WarningLevels.Fatal, "Parsing Worker unable to reach Redis")
break
if parseCount > 0:
repoKey = redis.lpop(RepoQueues.Parsing)
repo = Repo()
repo.loadFromKey(repoKey)
#sanity check our loaded key
assert repo.key() == repoKey, "Bad repo saved in parsing Queue! Key %s not found!"%(repoKey)
#Parse repo for todos and then deletelocal content
parser = multiprocessing.Process(target = parseRepo, args = (repo,))
startTime = time.time()
parser.start()
while parser.is_alive():
time.sleep(0.5)
if time.time() - startTime > float(settings.parserRepoTimeout):
parser.terminate()
parser.join()
log(WarningLevels.Warn, "Parse timed out, skipping the rest of the parse.")
redis.delete(repoKey)
break
if status.value == WorkerStatus.Dead:
#Worker was killed during parsing, cleanup
parser.terminate()
parser.join()
log(WarningLevels.Debug, "Parsing Interrupted, returning to parsing queue.")
redis.rpush(RepoQueues.Parsing, repoKey)
return #Skip the rest and kill the process
src.todoMelvin.deleteLocalRepo(repo)
else:
sleepTime = float(settings.parserSleepTime)
log(WarningLevels.Debug, "Parsing Worker going to sleep...")
#Set to sleeping for faster shutdown
status.value = WorkerStatus.Sleeping
time.sleep(sleepTime)
status.value = WorkerStatus.Working
def main(argv):
src.todoLogging.logSender = "PAR%s"%(argv)
log(WarningLevels.Info, "Starting Parsing Worker.")
#async global status value that is shared with processes
status = multiprocessing.Value('i', WorkerStatus.Working)
try:
#Start the function and wait for it to end
process = multiprocessing.Process(target = runWorker, args = (status, ))
process.start()
process.join()
except KeyboardInterrupt, SystemExit:
if status.value == WorkerStatus.Sleeping:
log(WarningLevels.Info, "Shutdown signal received while asleep. Parsing worker shutting down.")
process.terminate()
process.join()
else:
log(WarningLevels.Info, "Shutdown signal received. Allow Parser to finish current operation.")
status.value = WorkerStatus.Dead
process.join()
log(WarningLevels.Info, "Parsing Worker has shut down.")
if __name__ == "__main__":
if len(sys.argv) > 1:
main(sys.argv[1])
else:
main("0")
|
testdisk_gui.py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Dec 30 11:44:00 2016
@author: pavel
"""
import os
import sys
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Gdk, GObject
import threading
import signal
signal.signal(signal.SIGINT, signal.SIG_DFL) #handle Ctrl-C
APP_NAME = "testdisk"
GLADE_FILE = "ui.glade"
import disk_operations
import testdisk
import report
import utils
import filesave
# decorators
def gtk_idle(gui_task):
def job(*args, **kwargs):
def idle():
gui_task(*args, **kwargs)
return False # !!!
GObject.idle_add(idle)
return job
def async(func):
def job(*args, **kwargs):
thr = threading.Thread(target = func, args=args, kwargs = kwargs)
thr.start()
return job
class Singleton(type):
""" A metaclass that creates a Singleton base class when called. """
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
return cls._instances[cls]
class AboutDialog(metaclass=Singleton):
def __init__(self, builder):
self.builder = builder
self.dialog = self.builder.get_object("about_dialog")
self.dialog.connect("delete-event", self.on_hide)
def show(self):
self.dialog.run()
self.on_hide()
def on_hide(self, *args):
self.dialog.hide()
return True
class TestSettingsDialog(metaclass=Singleton):
def __init__(self, builder):
self.builder = builder
self.dialog = self.builder.get_object("test_settings_dialog")
self.dialog.connect("delete-event", self.on_hide)
self.start_entry = self.builder.get_object("settings_dialog_start")
self.stop_entry = self.builder.get_object("settings_dialog_stop")
self.start_entry.connect("changed", self.force_digits)
self.stop_entry.connect("changed", self.force_digits)
self.entry_values = {self.start_entry : 0,
self.stop_entry : -1}
def on_hide(self, *args):
self.dialog.hide()
return True
def show(self, start, stop):
self.entry_values[self.start_entry] = start
self.entry_values[self.stop_entry] = stop
self.start_entry.set_text(str(start))
self.stop_entry.set_text(str(stop))
response = self.dialog.run()
self.on_hide()
if response == Gtk.ResponseType.APPLY: # confirmed
start = self.entry_values.get(self.start_entry)
stop = self.entry_values.get(self.stop_entry)
return start, stop
def force_digits(self, entry):
new_val = entry.get_text().strip()
try:
if len(new_val) == 0:
new_val = 0
elif new_val == "-" :# allowing minus sign alone
new_val = -1
else:
new_val = int(new_val)
self.entry_values[entry] = new_val
except:
entry.set_text(str(self.entry_values[entry]))
class FileSaveDialog(metaclass=Singleton):
def __init__(self, builder):
self.builder = builder
self.dialog = self.builder.get_object("file_save_dialog")
self.dialog.connect("delete-event", self.on_hide)
self.last_dir = filesave.get_home_dir()
def on_hide(self, *args):
self.last_dir = self.dialog.get_current_folder()
self.dialog.hide()
return True
def get_fname(self, default_name):
self.dialog.set_current_folder(self.last_dir)
self.dialog.set_current_name(default_name)
response = self.dialog.run()
self.on_hide()
if response == Gtk.ResponseType.OK:
return self.dialog.get_filename()
class ConfirmationDialog(metaclass=Singleton):
def __init__(self, builder):
self.builder = builder
self.dialog = self.builder.get_object("confirm_dialog")
self.dialog.connect("delete-event", self.on_hide)
def on_hide(self, *args):
self.dialog.hide()
return True
def confirm(self, text, additional_text, func, *args, **kwargs):
self.dialog.set_property("text", text)
self.dialog.set_property("secondary-text", additional_text)
response = self.dialog.run()
self.on_hide()
if response == Gtk.ResponseType.YES: # confirmed
func(*args, **kwargs)
class ErrorDialog(metaclass=Singleton):
def __init__(self, builder):
self.builder = builder
self.dialog = self.builder.get_object("error_dialog")
self.dialog.connect("delete-event", self.on_hide)
def on_hide(self, *args):
self.dialog.hide()
return True
def show(self, err_text):
self.dialog.set_property("secondary-text", err_text)
response = self.dialog.run()
self.on_hide()
class DriveSelection:
DRIVE_NAME = 0
DRIVE_SIZE = 1
def __init__(self, builder, on_change_cb):
self.builder = builder
self.on_change_cb = on_change_cb
self.drive_box = self.builder.get_object("drive_selection_box")
self.drive_box.connect("changed", self.on_drive_changed)
self.list_store = Gtk.ListStore(str, str)
self.drive_box.set_model(self.list_store)
self.renderer_name = Gtk.CellRendererText()
self.renderer_size = Gtk.CellRendererText()
self.drive_box.pack_start(self.renderer_name, True)
self.drive_box.add_attribute(self.renderer_name, "text", self.DRIVE_NAME)
self.drive_box.pack_start(self.renderer_size, False)
self.drive_box.add_attribute(self.renderer_size, "text", self.DRIVE_SIZE)
self.update_model()
def update_model(self):
self.list_store.clear()
try:
for dev in disk_operations.detect_devs():
size = utils.pretty_disk_size(disk_operations.size(dev))
print("detected", dev, size)
self.list_store.append([dev, size])
except Exception as e:
print(e)
def get_drive(self):
"""return drive name or None"""
iter_ = self.drive_box.get_active_iter()
if iter_ is not None:
return self.list_store.get_value(iter_, self.DRIVE_NAME)
def on_drive_changed(self, *args):
self.on_change_cb(self.get_drive())
def enable(self):
self.drive_box.set_sensitive(True)
def disable(self):
self.drive_box.set_sensitive(False)
class RunButton:
TXT_RUN = "Test"
TXT_STOP = "Stop"
def __init__(self, builder, on_click_cb):
self.builder = builder
self.on_click_cb = on_click_cb
self.button = self.builder.get_object("run_test_btn")
self.button.connect("clicked", self.on_clicked)
#self.disable()
#self.set_txt_run()
def on_clicked(self, *args):
self.on_click_cb()
def set_txt(self, txt):
self.button.set_label(txt)
def enable(self):
self.button.set_sensitive(True)
def disable(self):
self.button.set_sensitive(False)
class TestVisualization:
CONTEXT_ID = 0
def __init__(self, builder):
self.builder = builder
self.progress_bar = self.builder.get_object("progress_bar")
self.status_lbl = self.builder.get_object("status_lbl")
self.status_extra_lbl = self.builder.get_object("status_extra_lbl")
self.speed_lbl = self.builder.get_object("speed_lbl")
self.progress_lbl = self.builder.get_object("progress_lbl")
self.time_elp_lbl = self.builder.get_object("time_elapsed_lbl")
self.time_left_lbl = self.builder.get_object("time_left_lbl")
self.info_view = self.builder.get_object("info_view")
self.info_buffer = self.info_view.get_buffer()
@gtk_idle
def reset(self):
self.progress_bar.set_fraction(0)
self.status_lbl.set_text("")
self.status_extra_lbl.set_text("")
self.speed_lbl.set_text("")
self.progress_lbl.set_text("")
self.time_elp_lbl.set_text("")
self.time_left_lbl.set_text("")
@gtk_idle
def on_status_updated(self, old_status, new_status):
status_name = testdisk.get_status_name(new_status)
self.status_lbl.set_text(status_name)
@gtk_idle
def on_error(self, err):
enditer = self.info_buffer.get_end_iter()
enditer = self.info_buffer.insert(enditer, os.linesep)
self.info_buffer.insert(enditer, err)
@gtk_idle
def on_progress(self, group_val, gr_start_sector, gr_num_sectors,
speed, percent, elapsed_time, left_time):
self.progress_bar.set_fraction(percent / 100)
self.speed_lbl.set_text(utils.pretty_speed(speed))
self.progress_lbl.set_text(utils.pretty_percent(percent))
self.time_elp_lbl.set_text(utils.pretty_time_diff(elapsed_time))
self.time_left_lbl.set_text(utils.pretty_time_diff(left_time))
self.status_extra_lbl.set_text("sector {}".format(gr_start_sector + gr_num_sectors))
@gtk_idle
def on_device_changed(self, device):
self.reset()
device_info = report.info_generator(device).strip()
self.info_buffer.set_text(device_info)
@gtk_idle
def on_test_report(self, report):
self.info_buffer.set_text(report.strip())
class Window:
def __init__(self):
self.builder = Gtk.Builder()
self.builder.set_translation_domain(APP_NAME)
self.builder.add_from_file(GLADE_FILE)
self.window = self.builder.get_object("main_window")
self.window.connect("delete-event", self.on_close)
self.drive_selection = DriveSelection(self.builder, self.on_drive_selection)
self.run_button = RunButton(self.builder, self.on_run_clicked)
self.test_visual_info = TestVisualization(self.builder)
self.confirm_dialog = ConfirmationDialog(self.builder)
self.__init_vars()
self.__init_menu()
def __init_vars(self):
self.drive = None
self.drive_test = None
self.test_report = ("", "")
self.first_sector_ind = 100000 #0
self.last_sector_ind = 200000 #-1
def __init_menu(self):
self.menuitem_quit = self.builder.get_object("menuitem_quit")
self.menuitem_save = self.builder.get_object("menuitem_save")
self.menuitem_reload = self.builder.get_object("menuitem_reload")
self.menuitem_sett = self.builder.get_object("menuitem_settings")
self.menuitem_about = self.builder.get_object("menuitem_about")
self.menuitem_quit.connect("activate", self.on_close)
self.menuitem_save.connect("activate", self.on_report_save)
self.menuitem_reload.connect("activate",
lambda *args: self.drive_selection.update_model())
self.menuitem_sett.connect("activate", self.on_settings_edit)
self.menuitem_about.connect("activate",
lambda *args: AboutDialog(self.builder).show())
def show(self):
self.window.show()
Gtk.main()
def on_close(self, *args):
self.confirm_dialog.confirm("Close the program?", "", Gtk.main_quit)
return True
def on_drive_selection(self, new_drive):
self.drive = new_drive
self.test_visual_info.reset()
if self.drive is not None:
self.run_button.enable()
self.test_visual_info.on_device_changed(self.drive)
def on_settings_edit(self, *args):
result = TestSettingsDialog(self.builder).show(self.first_sector_ind,
self.last_sector_ind)
if result is not None:
first_sector, last_sector = result
self.first_sector_ind = first_sector
self.last_sector_ind = last_sector
def on_run_clicked(self):
if (self.drive is not None) and (self.drive_test is None):
self.confirm_dialog.confirm("This will destroy all data on the drive.",
"Start the test?", self.run_test)
elif (self.drive_test is not None):
self.confirm_dialog.confirm("All progress will be lost.",
"Stop the test?", self.stop_test)
def run_test(self):
@async
def start_test():
self.drive_test = testdisk.DriveTest(self.drive,
self.first_sector_ind,
self.last_sector_ind)
handler = self.drive_test.get_handler()
handler.add_callback("update",
self.test_visual_info.on_status_updated)
handler.add_callback("progress", self.test_visual_info.on_progress)
handler.add_callback("error", self.on_test_error, self.drive)
handler.add_callback("cancel", self.on_test_cancel, self.drive)
handler.add_callback("finish", self.on_test_finish, self.drive)
self.drive_test.test()
self.disallow_changes()
start_test()
def stop_test(self):
self.drive_test.cancel()
def on_test_error(self, err, drive):
self.test_visual_info.on_error(err)
self.allow_changes()
ErrorDialog(self.builder).show(err)
def on_test_cancel(self, bads, write_speed, read_speed, timer, drive):
rep = report.report_generator(drive, bads,
write_speed, read_speed, timer)
self.test_report = (drive, rep)
self.test_visual_info.on_test_report(rep)
self.allow_changes()
def on_test_finish(self, bads, write_speed, read_speed, timer, drive):
rep = report.report_generator(drive, bads,
write_speed, read_speed, timer)
self.test_report = (drive, rep)
self.test_visual_info.on_test_report(rep)
self.allow_changes()
#save rep to tmp
filesave.autosave(drive, rep)
def on_report_save(self, *args):
drive, rep = self.test_report
fname = FileSaveDialog(self.builder).get_fname(filesave.get_fname(drive))
if fname is not None:
err = filesave.save(fname, rep)
if err is not None:
ErrorDialog(self.builder).show(err)
def allow_changes(self):
self.drive_test = None
self.drive_selection.enable()
self.run_button.set_txt("Test")
self.menuitem_reload.set_sensitive(True)
self.menuitem_sett.set_sensitive(True)
def disallow_changes(self):
self.drive_selection.disable()
self.run_button.set_txt("Stop")
self.menuitem_reload.set_sensitive(False)
self.menuitem_sett.set_sensitive(False)
if __name__ == "__main__":
window = Window()
window.show()
|
common_func.py
|
#!/usr/bin/env python3
# coding=utf-8
from __future__ import print_function, unicode_literals, division, absolute_import
import sys
import time
import binascii
import struct
import collections
import logging
import socket
import select
import threading
import traceback
import functools
import server_pool
try:
# for pycharm type hinting
from typing import Union, Callable
except:
pass
# socket recv buffer, 16384 bytes
RECV_BUFFER_SIZE = 2 ** 14
# default secretkey, use -k/--secretkey to change
#SECRET_KEY = "shootback"
# how long a SPARE slaver would keep
# once slaver received an heart-beat package from master,
# the TTL would be reset. And heart-beat delay is less than TTL,
# so, theoretically, spare slaver never timeout,
# except network failure
# notice: working slaver would NEVER timeout
SPARE_SLAVER_TTL = 300
# internal program version, appears in CtrlPkg
INTERNAL_VERSION = 0x000D
# version for human readable
__version__ = (2, 2, 8, INTERNAL_VERSION)
# just a logger
log = logging.getLogger(__name__)
def version_info():
"""get program version for human. eg: "2.1.0-r2" """
return "{}.{}.{}-r{}".format(*__version__)
def configure_logging(level):
logging.basicConfig(
level=level,
format='[%(levelname)s %(asctime)s] %(message)s',
)
def fmt_addr(socket):
"""(host, int(port)) --> "host:port" """
return "{}:{}".format(*socket)
def split_host(x):
""" "host:port" --> (host, int(port))"""
try:
host, port = x.split(":")
port = int(port)
except:
raise ValueError(
"wrong syntax, format host:port is "
"required, not {}".format(x))
else:
return host, port
def try_close(closable):
"""try close something
same as
try:
connection.close()
except:
pass
"""
try:
closable.close()
except:
pass
def select_recv(conn, buff_size, timeout=None):
"""add timeout for socket.recv()
:type conn: socket.SocketType
:type buff_size: int
:type timeout: float
:rtype: Union[bytes, None]
"""
rlist, _, _ = select.select([conn], [], [], timeout)
if not rlist:
# timeout
raise RuntimeError("recv timeout")
buff = conn.recv(buff_size)
if not buff:
raise RuntimeError("received zero bytes, socket was closed")
return buff
class SocketBridge:
"""
transfer data between sockets
"""
def __init__(self):
self.conn_rd = set() # record readable-sockets
self.map = {} # record sockets pairs
self.callbacks = {} # record callbacks
self.tmp_thread = None
def add_conn_pair(self, conn1, conn2,tmp=None, callback=None):
"""
transfer anything between two sockets
:type conn1: socket.SocketType
:type conn2: socket.SocketType
:param callback: callback in connection finish
:type callback: Callable
"""
# mark as readable
self.conn_rd.add(conn1)
self.conn_rd.add(conn2)
# record sockets pairs
self.map[conn1] = conn2
self.map[conn2] = conn1
# record callback
if callback is not None:
self.callbacks[conn1] = callback
if tmp is not None:
conn2.send(tmp)
logging.info("tmp send:{}".format(len(tmp)))
def get_thread(self):
return self.tmp_thread
def start_as_daemon(self):
t = threading.Thread(target=self.start)
t.daemon = True
t.start()
log.info("SocketBridge daemon started")
self.tmp_thread = t;
# return t
def start(self):
server_pool.ServerPool.bridgeAdd += 1
while True:
try:
self._start()
except:
log.error("FATAL ERROR! SocketBridge failed {}".format(
traceback.format_exc()
))
def _start(self):
# memoryview act as an recv buffer
# refer https://docs.python.org/3/library/stdtypes.html#memoryview
buff = memoryview(bytearray(RECV_BUFFER_SIZE))
while True:
if not self.conn_rd:
# sleep if there is no connections
time.sleep(0.06)
continue
# blocks until there is socket(s) ready for .recv
# notice: sockets which were closed by remote,
# are also regarded as read-ready by select()
r, w, e = select.select(self.conn_rd, [], [], 0.5)
for s in r: # iter every read-ready or closed sockets
try:
# here, we use .recv_into() instead of .recv()
# recv data directly into the pre-allocated buffer
# to avoid many unnecessary malloc()
# see https://docs.python.org/3/library/socket.html#socket.socket.recv_into
rec_len = s.recv_into(buff, RECV_BUFFER_SIZE)
# agre = "http"
# url = agre + '://' + heads['Host']
# heads = httphead(buff.tobytes().decode('utf-8'))
# logging.info("recv head:{}".format(heads))
except Exception as e:
# unable to read, in most cases, it's due to socket close
self._rd_shutdown(s)
continue
if not rec_len:
# read zero size, closed or shutdowned socket
self._rd_shutdown(s)
continue
try:
# send data, we use `buff[:rec_len]` slice because
# only the front of buff is filled
self.map[s].send(buff[:rec_len])
except Exception as e:
# unable to send, close connection
self._rd_shutdown(s)
continue
def _rd_shutdown(self, conn, once=False):
"""action when connection should be read-shutdown
:type conn: socket.SocketType
"""
if conn in self.conn_rd:
self.conn_rd.remove(conn)
try:
conn.shutdown(socket.SHUT_RD)
except:
pass
if not once and conn in self.map: # use the `once` param to avoid infinite loop
# if a socket is rd_shutdowned, then it's
# pair should be wr_shutdown.
self._wr_shutdown(self.map[conn], True)
if self.map.get(conn) not in self.conn_rd:
# if both two connection pair was rd-shutdowned,
# this pair sockets are regarded to be completed
# so we gonna close them
self._tterminate(conn)
def _wr_shutdown(self, conn, once=False):
"""action when connection should be write-shutdown
:type conn: socket.SocketType
"""
try:
conn.shutdown(socket.SHUT_WR)
except:
pass
if not once and conn in self.map: # use the `once` param to avoid infinite loop
# pair should be rd_shutdown.
# if a socket is wr_shutdowned, then it's
self._rd_shutdown(self.map[conn], True)
def _tterminate(self, conn):
"""terminate a sockets pair (two socket)
:type conn: socket.SocketType
:param conn: any one of the sockets pair
"""
try_close(conn) # close the first socket
server_pool.ServerPool.bridgeRemove += 1
# ------ close and clean the mapped socket, if exist ------
if conn in self.map:
_mapped_conn = self.map[conn]
try_close(_mapped_conn)
if _mapped_conn in self.map:
del self.map[_mapped_conn]
del self.map[conn] # clean the first socket
else:
_mapped_conn = None # just a fallback
# ------ callback --------
# because we are not sure which socket are assigned to callback,
# so we should try both
if conn in self.callbacks:
try:
self.callbacks[conn]()
except Exception as e:
log.error("traceback error: {}".format(e))
log.debug(traceback.format_exc())
del self.callbacks[conn]
elif _mapped_conn and _mapped_conn in self.callbacks:
try:
self.callbacks[_mapped_conn]()
except Exception as e:
log.error("traceback error: {}".format(e))
log.debug(traceback.format_exc())
del self.callbacks[_mapped_conn]
class CtrlPkg:
PACKAGE_SIZE = 2 ** 6 # 64 bytes
CTRL_PKG_TIMEOUT = 5 # CtrlPkg recv timeout, in second
# CRC32 for SECRET_KEY and Reversed(SECRET_KEY)
SECRET_KEY_CRC32 = 0# = binascii.crc32(SECRET_KEY.encode('utf-8')) & 0xffffffff
SECRET_KEY_REVERSED_CRC32 = 0# = binascii.crc32(SECRET_KEY[::-1].encode('utf-8')) & 0xffffffff
# Package Type
PTYPE_HS_S2M = -1 # handshake pkg, slaver to master
PTYPE_HEART_BEAT = 0 # heart beat pkg
PTYPE_HS_M2S = +1 # handshake pkg, Master to Slaver
TYPE_NAME_MAP = {
PTYPE_HS_S2M: "PTYPE_HS_S2M",
PTYPE_HEART_BEAT: "PTYPE_HEART_BEAT",
PTYPE_HS_M2S: "PTYPE_HS_M2S",
}
# formats
# see https://docs.python.org/3/library/struct.html#format-characters
# for format syntax
FORMAT_PKG = "!b b H 20x 40s"
FORMATS_DATA = {
PTYPE_HS_S2M: "!I 36x",
PTYPE_HEART_BEAT: "!40x",
PTYPE_HS_M2S: "!I 36x",
}
def __init__(self, pkg_ver=0x01, pkg_type=0,
prgm_ver=INTERNAL_VERSION, data=(),
raw=None,SECRET_KEY_CRC32=0,SECRET_KEY_REVERSED_CRC32=0
):
"""do not call this directly, use `CtrlPkg.pbuild_*` instead"""
self._cache_prebuilt_pkg = {} # cache
self.pkg_ver = pkg_ver
self.pkg_type = pkg_type
self.prgm_ver = prgm_ver
self.data = data
self.SECRET_KEY_CRC32 = SECRET_KEY_CRC32
self.SECRET_KEY_REVERSED_CRC32 = SECRET_KEY_REVERSED_CRC32
if raw:
self.raw = raw
else:
self._build_bytes()
@property
def type_name(self):
"""返回人类可读的包类型"""
return self.TYPE_NAME_MAP.get(self.pkg_type, "TypeUnknown")
def __str__(self):
return """pkg_ver: {} pkg_type:{} prgm_ver:{} data:{}""".format(
self.pkg_ver,
self.type_name,
self.prgm_ver,
self.data,
)
def __repr__(self):
return self.__str__()
def _build_bytes(self):
self.raw = struct.pack(
self.FORMAT_PKG,
self.pkg_ver,
self.pkg_type,
self.prgm_ver,
self.data_encode(self.pkg_type, self.data),
)
def _prebuilt_pkg(cls, pkg_type, fallback):
"""act as lru_cache"""
if pkg_type not in cls._cache_prebuilt_pkg:
pkg = fallback(force_rebuilt=True)
cls._cache_prebuilt_pkg[pkg_type] = pkg
logging.info("_prebuilt_pkg,id:{}".format(id(cls._cache_prebuilt_pkg)))
return cls._cache_prebuilt_pkg[pkg_type]
def recalc_crc32(cls,skey):
cls.skey = skey
cls.SECRET_KEY_CRC32 = binascii.crc32(skey.encode('utf-8')) & 0xffffffff
cls.SECRET_KEY_REVERSED_CRC32 = binascii.crc32(skey[::-1].encode('utf-8')) & 0xffffffff
logging.info("main key:{},id:{},{},{}".format(cls.skey,id(cls),cls.SECRET_KEY_CRC32,cls.SECRET_KEY_REVERSED_CRC32))
def clean_crc32(self):
self.skey = ""
self.SECRET_KEY_CRC32 = "closed hahaha"
self.SECRET_KEY_REVERSED_CRC32 = "closed hahaha"
def data_decode(cls, ptype, data_raw):
return struct.unpack(cls.FORMATS_DATA[ptype], data_raw)
def data_encode(cls, ptype, data):
return struct.pack(cls.FORMATS_DATA[ptype], *data)
def verify(self, pkg_type=None):
logging.info("verify 响应包 {},{},{}".format(self.data, self.SECRET_KEY_CRC32,self.SECRET_KEY_REVERSED_CRC32))
try:
if pkg_type is not None and self.pkg_type != pkg_type:
return False
elif self.pkg_type == self.PTYPE_HS_S2M:
# Slaver-->Master 的握手响应包
logging.info("Slaver-->Master 的握手响应包 {},{}".format(self.data[0],self.SECRET_KEY_REVERSED_CRC32))
return self.data[0] == self.SECRET_KEY_REVERSED_CRC32
elif self.pkg_type == self.PTYPE_HEART_BEAT:
# 心跳
return True
elif self.pkg_type == self.PTYPE_HS_M2S:
# Master-->Slaver 的握手包
logging.info("Master-->Slaver 的握手包".format(self.data[0], self.SECRET_KEY_CRC32))
return self.data[0] == self.SECRET_KEY_CRC32
else:
return True
except:
return False
def decode_only(cls, raw):
"""
decode raw bytes to CtrlPkg instance, no verify
use .decode_verify() if you also want verify
:param raw: raw bytes content of package
:type raw: bytes
:rtype: CtrlPkg
"""
if not raw or len(raw) != cls.PACKAGE_SIZE:
raise ValueError("content size should be {}, but {}".format(
cls.PACKAGE_SIZE, len(raw)
))
pkg_ver, pkg_type, prgm_ver, data_raw = struct.unpack(cls.FORMAT_PKG, raw)
logging.info("CtrlPkg,decode_only,,,,pkg_ver:{}, pkg_type:{}, prgm_ver:{}".format(pkg_ver, pkg_type, prgm_ver))
data = cls.data_decode(pkg_type, data_raw)
logging.info("CtrlPkg,decode_only,data:{}".format(data))
return CtrlPkg(
pkg_ver=pkg_ver, pkg_type=pkg_type,
prgm_ver=prgm_ver,
data=data,
raw=raw,
SECRET_KEY_CRC32=cls.SECRET_KEY_CRC32, SECRET_KEY_REVERSED_CRC32=cls.SECRET_KEY_REVERSED_CRC32
)
def decode_verify(cls, raw, pkg_type=None):
"""decode and verify a package
:param raw: raw bytes content of package
:type raw: bytes
:param pkg_type: assert this package's type,
if type not match, would be marked as wrong
:type pkg_type: int
:rtype: CtrlPkg, bool
:return: tuple(CtrlPkg, is_it_a_valid_package)
"""
try:
pkg = cls.decode_only(raw)
except:
return None, False
else:
return pkg, pkg.verify(pkg_type=pkg_type)
def pbuild_hs_m2s(cls, force_rebuilt=False):
"""pkg build: Handshake Master to Slaver"""
# because py27 do not have functools.lru_cache, so we must write our own
if force_rebuilt:
return CtrlPkg(
pkg_type=cls.PTYPE_HS_M2S,
data=(cls.SECRET_KEY_CRC32,),
SECRET_KEY_CRC32=cls.SECRET_KEY_CRC32, SECRET_KEY_REVERSED_CRC32=cls.SECRET_KEY_REVERSED_CRC32
)
else:
return cls._prebuilt_pkg(cls.PTYPE_HS_M2S, cls.pbuild_hs_m2s)
def pbuild_hs_s2m(cls, force_rebuilt=False):
"""pkg build: Handshake Slaver to Master"""
if force_rebuilt:
return CtrlPkg(
pkg_type=cls.PTYPE_HS_S2M,
data=(cls.SECRET_KEY_REVERSED_CRC32,),
SECRET_KEY_CRC32=cls.SECRET_KEY_CRC32, SECRET_KEY_REVERSED_CRC32=cls.SECRET_KEY_REVERSED_CRC32
)
else:
return cls._prebuilt_pkg(cls.PTYPE_HS_S2M, cls.pbuild_hs_s2m)
def pbuild_heart_beat(cls, force_rebuilt=False):
"""pkg build: Heart Beat Package"""
if force_rebuilt:
return CtrlPkg(
pkg_type=cls.PTYPE_HEART_BEAT,
SECRET_KEY_CRC32=cls.SECRET_KEY_CRC32, SECRET_KEY_REVERSED_CRC32=cls.SECRET_KEY_REVERSED_CRC32
)
else:
return cls._prebuilt_pkg(cls.PTYPE_HEART_BEAT, cls.pbuild_heart_beat)
def recv(cls, sock, timeout=CTRL_PKG_TIMEOUT, expect_ptype=None):
"""just a shortcut function
:param sock: which socket to recv CtrlPkg from
:type sock: socket.SocketType
:rtype: CtrlPkg,bool
"""
logging.info("CtrlPkg,recv,sock:{},expect_ptype:{}".format(sock,expect_ptype))
buff = select_recv(sock, cls.PACKAGE_SIZE, timeout)
pkg, verify = cls.decode_verify(buff, pkg_type=expect_ptype) # type: CtrlPkg,bool
return pkg, verify
def httphead(request):
header = request.split('\r\n\r\n', 1)[0]
headers = dict()
for line in header.split('\r\n')[1:]:
key, val = line.split(': ', 1)
headers[key] = val
return headers
|
MF_socketIO.py
|
#-------------------------------------------------------------------------------
#Targeting: Python 2 and 3
#Use: Wrapper to implement a socketIO connection to a MF controller
#-------------------------------------------------------------------------------
from socketIO_client import SocketIO, LoggingNamespace, BaseNamespace
from threading import Thread
#-------------------------------------------------------------------------------
class MF_socketIO:
def __init__(self, controllerBaseUrl, controllerPort, password):
self.baseUrl = controllerBaseUrl
self.port = controllerPort
self.password = password
#create a new socketIO client connection to the controller
self.socket = SocketIO(self.baseUrl, self.port, LoggingNamespace)
#hub currently expects imediate auth after connecting
self.auth(password)
#setup thread for reciving events - not used yet
self.receive_events_thread = Thread(target=self.on_message_recived)
self.receive_events_thread.daemon = True
self.receive_events_thread.start()
def auth(self, password):
def on_auth_result(*args):
#todo: process the result here or pass to callback
#print args
pass
self.socket.emit('auth', {'password': self.password}, on_auth_result)
self.socket.wait_for_callbacks(seconds=10)
def on_message_recived(self):
self.socket.wait()
#todo: add processing of incoming messages
#no requirement for this yet
def get(self, command, callback):
self.socket.emit(command, callback)
self.socket.wait_for_callbacks(seconds=5)
def getWithParam(self, command, param, callback):
self.socket.emit(command, param, callback)
self.socket.wait_for_callbacks(seconds=5)
def send(self, room, command, score):
self.socket.emit('sendCommand', room, command, score)
#-------------------------------------------------------------------------------
|
__init__.py
|
"""MIT License
Copyright (c) 2017-2022 TwitchIO
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
"""
import asyncio
import audioop
import dataclasses
import io
import logging
import subprocess
import threading
import time
from functools import partial
from typing import Any, Callable, Coroutine, Dict, List, Optional, TypeVar, Union
import pyaudio
from yt_dlp import YoutubeDL
__all__ = ("Sound", "AudioPlayer")
logger = logging.getLogger(__name__)
AP = TypeVar("AP", bound="AudioPlayer")
has_ffmpeg: bool
try:
proc = subprocess.Popen("ffmpeg -version", stdout=subprocess.PIPE, stderr=subprocess.PIPE)
except FileNotFoundError:
has_ffmpeg = False
else:
has_ffmpeg = True
__all__ = ("Sound", "AudioPlayer")
@dataclasses.dataclass
class OutputDevice:
"""Class which represents an OutputDevice usable with :class:`AudioPlayer`.
Pass this into the appropriate :class:`AudioPlayer`s method to set or change device.
Attributes
----------
name: str
The name of the device.
index: int
The index of the device.
channels: int
The amount of available channels this device has.
"""
name: str
index: int
channels: int
class Sound:
"""TwitchIO Sound Source.
This is the class that represents a TwitchIO Sound, able to be played in :class:`AudioPlayer`.
.. warning::
This class is still in Beta stages and currently only supports generating sounds via :meth:`ytdl_search`
or locally downloaded audio files. Future versions will have support for file like objects.
Parameters
__________
source: Optional[Union[str, io.BufferedIOBase]]
The source to play. Could be a string representing a local file or bytes.
To search YouTube, use :meth:`ytdl_search` instead.
info: Optional[dict]
The info dict provided via ytdl. Only available when searching via YouTube. Do not pass this directly.
Attributes
----------
title: str
The title of the track. Will be None if :class:`io.BufferedIOBase` is supplied as a source.
url: Optional[str]
The url of the track searched via YouTube. Will be None if source is supplied.
"""
CODECS = (
"mp3",
"aac",
"flv",
"wav",
"opus",
)
YTDLOPTS = {
"format": "bestaudio/best",
"restrictfilenames": True,
"noplaylist": True,
"nocheckcertificate": True,
"ignoreerrors": False,
"logtostderr": False,
"quiet": True,
"progress": False,
"no_warnings": True,
"default_search": "auto",
"source_address": "0.0.0.0", # ipv6 addresses cause issues sometimes
}
YTDL = YoutubeDL(YTDLOPTS)
def __init__(self, source: Optional[Union[str, io.BufferedIOBase]] = None, *, info: Optional[dict] = None):
self.title = None
self.url = None
self.proc = None
if not has_ffmpeg:
raise RuntimeError("ffmpeg is required to create and play Sounds. For more information visit: ...")
if info:
self.proc = subprocess.Popen(
[
"ffmpeg.exe",
"-reconnect",
"1",
"-reconnect_streamed",
"1",
"-reconnect_delay_max",
"5",
"-i",
info["url"],
"-loglevel",
"panic",
"-vn",
"-f",
"s16le",
"pipe:1",
],
stdout=subprocess.PIPE,
)
self.title = info.get("title", None)
self.url = info.get("url", None)
elif isinstance(source, str):
self.title = source
self.proc = subprocess.Popen(
["ffmpeg.exe", "-i", source, "-loglevel", "panic", "-vn", "-f", "s16le", "pipe:1"],
stdout=subprocess.PIPE,
)
self._channels = 2
self._rate = 48000
@classmethod
async def ytdl_search(cls, search: str, *, loop: Optional[asyncio.BaseEventLoop] = None):
"""|coro|
Search songs via YouTube ready to be played.
"""
loop = loop or asyncio.get_event_loop()
to_run = partial(cls.YTDL.extract_info, url=search, download=False)
data = await loop.run_in_executor(None, to_run)
if "entries" in data:
# take first item from a playlist
data = data["entries"][0]
data["time"] = time.time()
return cls(info=data)
@property
def channels(self):
"""The audio source channels."""
return self._channels
@property
def rate(self):
"""The audio source sample rate."""
return self._rate
@property
def source(self):
"""The raw audio source."""
return self._source
def __del__(self):
self._source = None
if self.proc:
self.proc.kill()
class AudioPlayer:
"""TwitchIO Sounds Audio Player.
Use this class to control and play sounds generated with :class:`Sound`.
Parameters
----------
callback: Coroutine
The coroutine called when a Sound has finished playing.
.. note ::
To use this player with the system non default output device, see :meth:`with_device`, or
:property:`active_device`. The output device can be changed live by setting `active_device` with an
:class:`OutputDevice`.
"""
def __init__(self, *, callback: Callable[..., Coroutine[Any, Any, None]]):
self._pa = pyaudio.PyAudio()
self._stream = None
self._current: Sound = None # type: ignore
self._paused: bool = False
self._playing: bool = False
self._volume = 100
self._callback = callback
self._thread: threading.Thread = None # type: ignore
self._loop = asyncio.get_event_loop()
self._devices: Dict[int, OutputDevice] = {}
self._get_devices()
self._active_devices: List[OutputDevice] = []
self._use_device: Optional[OutputDevice] = None
def _get_devices(self):
for index in range(self._pa.get_device_count()):
device = self._pa.get_device_info_by_index(index)
if device["maxInputChannels"] != 0:
continue
self._devices[index] = OutputDevice(
name=device["name"], index=device["index"], channels=device["maxOutputChannels"]
)
def play(self, sound: Sound, *, replace: bool = False) -> None:
"""Play a :class:`Sound` object.
When play has finished playing, the event :meth:`event_player_finished` is called.
"""
if not isinstance(sound, Sound):
raise TypeError("sound parameter must be of type <Sound>.")
if self._playing and replace:
self.stop()
elif self._playing and not replace:
return
self._thread = threading.Thread(target=self._play_run, args=([sound]), daemon=True)
self._thread.start()
def _play_run(self, sound: Sound):
self._current = sound
device = self._use_device.index if self._use_device else None
self._stream = self._pa.open(
format=pyaudio.paInt16, output=True, channels=sound.channels, rate=sound.rate, output_device_index=device
)
bytes_ = sound.proc.stdout.read(4096)
self._playing = True
while self._playing:
while self._paused:
time.sleep(0.1)
if self._playing is False:
break
if not bytes_:
break
self._stream.write(audioop.mul(bytes_, 2, self._volume / 100))
bytes_ = sound.proc.stdout.read(4096)
self._clean(sound)
asyncio.run_coroutine_threadsafe(self._callback(), loop=self._loop)
def _clean(self, sound: Sound):
sound.proc.kill()
self._stream = None
self._current = None
self._paused = False
self._playing = False
@property
def source(self):
"""The currently playing :class:`Sound` object."""
return self._current
@property
def current(self):
"""An alias to :meth:`source`."""
return self.source
def pause(self):
"""Method which pauses the player."""
self._paused = True
def resume(self):
"""Method which resumes the player."""
self._paused = False
@property
def is_paused(self) -> bool:
"""Property which returns whether the player is currently paused."""
return self._paused
def stop(self):
"""Stops the player and clears the source."""
self._playing = False
@property
def is_playing(self):
"""Property which returns whether the player is currently playing."""
return self._playing
@property
def volume(self) -> int:
"""Property which returns the current volume.
This property can also be set with a volume between 1 and 100, to change the volume.
"""
return self._volume
@volume.setter
def volume(self, level: int) -> None:
if level > 100 or level < 1:
raise ValueError("Volume must be between 1 and 100")
self._volume = level
@property
def devices(self) -> Dict[int, OutputDevice]:
"""Return a dict of :class:`OutputDevice` that can be used to output audio."""
return self._devices
@property
def active_device(self) -> Optional[OutputDevice]:
"""Return the active output device for this player. Could be None if default is being used.
This property can also be set with a new :class:`OutputDevice` to change audio output.
"""
return self._use_device
@active_device.setter
def active_device(self, device: OutputDevice) -> None:
if not isinstance(device, OutputDevice):
raise TypeError(f"Parameter <device> must be of type <{type(OutputDevice)}> not <{type(device)}>.")
self._use_device = device
if not self._stream:
return
if self._playing:
self._paused = True
self._stream = self._pa.open(
format=pyaudio.paInt16,
output=True,
channels=self._current.channels,
rate=self._current.rate,
output_device_index=device.index,
)
self._paused = False
@classmethod
def with_device(cls, *, callback: Callable[..., Coroutine[Any, Any, None]], device: OutputDevice) -> AP:
"""Method which returns a player ready to be used with the given :class:`OutputDevice`.
Returns
-------
:class:`OutputDevice`
"""
if not isinstance(device, OutputDevice):
raise TypeError(f"Parameter <device> must be of type <{type(OutputDevice)}> not <{type(device)}>.")
self = cls(callback=callback)
self._use_device = device
return self
|
start_all.py
|
"""
This is the code to automatically start up the hosts Apple and Banana in a
synchronized way.
To make it work for other groups of hosts, you only need to edit the HOSTS
and MASTERCONFIG constants for this file.
The synchronization currently only supports the case where all hosts operate
in separate processes from each other.
"""
import multiprocessing as mp
from Apple import Apple
from Banana import Banana
from Canteloupe import Canteloupe
from Durian import Durian
import time
MASTERCONFIG = './testconf.json'
HOSTS = [Apple, Banana, Canteloupe, Durian]
def starter(host, probe, trigger):
x = host(MASTERCONFIG)
probe.put('setup complete')
while trigger.empty():
pass
x.run()
if __name__ == '__main__':
probe = mp.Queue()
trigger = mp.Queue()
procs = []
for host in HOSTS:
proc = mp.Process(target=starter, args=(host, probe, trigger))
procs.append(proc)
for proc in procs:
proc.start()
for proc in procs:
probe.get(block=True)
time.sleep(1)
trigger.put('all setup complete')
for proc in procs:
proc.join()
|
rate_limits.py
|
# -*- coding: utf-8 -*-
import logging
import urllib2
import httplib
import threading
# import time
from ...core.models import HEADERS
logger = logging.getLogger('sitetest')
def test_rate_limits(site, total_count=500, verbose=False):
"""
Hammer the homepage to see if it hits any limits
"""
if verbose:
logger.debug('Running rate limit tests...')
url = site.canonical_domain
# TODO --- allow urls to test to be configurable
use_basic_auth = site.use_basic_auth
basic_auth_username = site.basic_auth_username
basic_auth_password = site.basic_auth_password
counter = {
'total_count': total_count,
'current_count': 0,
'success_count': 0,
'error_count': 0,
}
# start = time.time()
urls = [url for x in range(total_count)]
def fetch_url(url, counter):
code = None
try:
request = urllib2.Request(url, headers=HEADERS)
if use_basic_auth:
password_manager = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_manager.add_password(None, url, basic_auth_username, basic_auth_password)
password_handler = urllib2.HTTPBasicAuthHandler(password_manager)
opener = urllib2.build_opener(password_handler)
logger.debug('using basic auth opener for rate limiter...')
response = opener.open(request)
else:
response = urllib2.urlopen(request)
code = response.code
response.read()
counter['success_count'] += 1
except urllib2.HTTPError as e:
code = e.code
logger.error('---> urllib2.HTTPError %s - %s' % (e.code, e.headers))
counter['error_count'] += 1
except urllib2.URLError as e:
code = e.reason
counter['error_count'] += 1
except httplib.BadStatusLine as e:
code = "Bad Status Error"
counter['error_count'] += 1
except Exception:
code = "Unkown Exception"
counter['error_count'] += 1
counter['current_count'] += 1
if verbose:
logger.debug("Attempt %s/%s: %s" % (counter['current_count'], counter['total_count'], code))
threads = [threading.Thread(target=fetch_url, args=(url_item, counter)) for url_item in urls]
for thread in threads:
thread.start()
for thread in threads:
thread.join()
# elapsed = (time.time() - start)
# average = elapsed / total_count
# loads_per_second_allowed = counter['success_count'] / elapsed
# success_rate = (float(counter['success_count']) / float(total_count)) * float(100)
# success_rate_formatted = "{0:.0f}%".format(success_rate)
message = "%s loads were attempted on %s. %s were successful." % (total_count,
url, counter['success_count'])
if verbose:
logger.debug(message)
site.add_info_message(message)
|
service_zipkin_test.py
|
#
# voice-skill-sdk
#
# (C) 2020, Deutsche Telekom AG
#
# This file is distributed under the terms of the MIT license.
# For details see the file LICENSE in the top directory.
#
#
import logging
import threading
import unittest
from configparser import ConfigParser
from unittest.mock import patch, Mock
from skill_sdk import tracing
from skill_sdk.services import zipkin
from skill_sdk.services.zipkin import QUEUE
from skill_sdk.services.zipkin import setup_service, queued_transport, zipkin_report_worker, B3Codec, SpanContext
from py_zipkin.zipkin import ZipkinAttrs, zipkin_span
from requests.sessions import Session
from requests.exceptions import ConnectionError
test_config = ConfigParser()
test_config['zipkin'] = {'server_url': 'http://localhost:9411/api/v1/spans'}
class TestTransport(unittest.TestCase):
@patch('skill_sdk.services.zipkin.config', new=test_config)
@patch('skill_sdk.services.zipkin.ZIPKIN_API_URL', 'http://localhost:9411/api/v1/spans')
@patch('requests.post')
def test_queued_transport(self, request_mock):
threading.Thread(target=zipkin_report_worker, daemon=True).start()
queued_transport(b'demodata')
QUEUE.join()
request_mock.assert_called_once_with(
url='http://localhost:9411/api/v1/spans',
data=b'demodata',
headers={'Content-Type': 'application/x-thrift'}
)
with patch.object(zipkin.QUEUE, 'put') as put_mock, patch.object(zipkin, 'ZIPKIN_API_URL', new=None):
queued_transport(b'wont send')
put_mock.assert_not_called()
@patch('skill_sdk.services.zipkin.config', new=test_config)
@patch('skill_sdk.services.zipkin.ZIPKIN_API_URL', 'http://localhost:9411/api/v1/spans')
@patch.object(zipkin.QUEUE, 'task_done', side_effect=StopIteration)
@patch('requests.post')
def test_transport_handler(self, request_mock, task_done):
with patch.object(zipkin.QUEUE, 'get', return_value='<spam span/>'):
with self.assertRaises(StopIteration):
zipkin_report_worker()
request_mock.assert_called_once_with(
url='http://localhost:9411/api/v1/spans',
data='<spam span/>',
headers={'Content-Type': 'application/x-thrift'}
)
with patch.object(logging.Logger, 'error') as log_mock:
request_mock.side_effect = ConnectionError()
with self.assertRaises(StopIteration):
zipkin_report_worker()
log_mock.assert_any_call('Zipkin reporter failed for service [%s]: %s', 'unnamed_service', 'ConnectionError()')
class TestZipkin(unittest.TestCase):
def setUp(self):
test_config = ConfigParser()
test_config['zipkin'] = {'server_url': 'http://localhost:9411/api/v1/spans'}
with patch('skill_sdk.config.config', new=test_config):
setup_service()
self.request = Mock()
self.request.headers = {
'X-B3-TraceId': '430ee1c3e2deccfa',
'X-B3-ParentSpanId': '01e97311cfec540a',
'X-B3-SpanId': 'd4aeec01e3c43faa',
'X-B3-Sampled': '1',
'X-B3-Debug': '0'}
@patch('py_zipkin.zipkin.generate_random_64bit_string', return_value='0123456789abcdef')
def test_init(self, *args):
span = tracing.start_active_span('span', self.request).span
self.assertEqual(span.parent_id, 'd4aeec01e3c43faa')
self.assertEqual(span.trace_id, '430ee1c3e2deccfa')
self.assertEqual(span.span_id, '0123456789abcdef')
self.assertEqual(span.is_sampled(), True)
self.assertEqual(span.flags, 1)
def test_init_no_headers(self):
request = Mock()
request.headers = {}
span = tracing.start_active_span('span', request).span
self.assertEqual(span.is_sampled(), False)
self.assertEqual(span.flags, 0)
def test_span(self):
scope = tracing.start_active_span('span', self.request)
span = scope.span.tracer.start_span('testspan')
self.assertEqual(span.operation_name, 'testspan')
self.assertEqual(span._span.sample_rate, 100.0)
self.assertEqual(span._span.transport_handler, queued_transport)
@patch.object(zipkin_span, 'start')
@patch.object(zipkin_span, 'stop')
def test_new_span(self, stop_span, start_span):
with tracing.start_active_span('active span', self.request) as scope:
with scope.span.tracer.start_span('inner span') as span:
self.assertEqual(span.tracer.service_name, 'unnamed-skill')
self.assertEqual(span.operation_name, 'inner span')
span.set_operation_name('new_span')
self.assertEqual(span.operation_name, 'new_span')
span.log_kv({'key': 'value'}, 123456789)
self.assertEqual(span._span.annotations, {'{"key": "value"}': 123456789})
# Ensure both spans are started
self.assertEqual(start_span.call_count, 2)
# Ensure both spans are finished when out of scope
self.assertEqual(stop_span.call_count, 2)
@patch('py_zipkin.zipkin.create_attrs_for_span', return_value=ZipkinAttrs(
trace_id='430ee1c3e2deccfc',
span_id='d4aeec01e3c43fac',
parent_span_id=None,
flags='0',
is_sampled=True,
))
@patch.object(Session, 'request', return_value=Mock(status_code=200))
def test_request_headers_propagation(self, request_mock, *mocks):
from skill_sdk.requests import CircuitBreakerSession
with CircuitBreakerSession(internal=True) as s:
s.get('http://localhost/')
request_mock.assert_any_call(s, 'GET', 'http://localhost/', timeout=5, allow_redirects=True,
headers={'X-B3-TraceId': '430ee1c3e2deccfc',
'X-B3-SpanId': 'd4aeec01e3c43fac'})
def test_extract_inject_exceptions(self):
tracer = tracing.global_tracer()
with self.assertRaises(tracing.UnsupportedFormatException):
tracer.extract(tracing.Format.BINARY, {})
ctx = tracing.SpanContext(None, None)
with self.assertRaises(tracing.UnsupportedFormatException):
tracer.inject(ctx, tracing.Format.BINARY, {})
class TestB3Codec(unittest.TestCase):
def test_b3_extract(self):
codec = B3Codec()
with self.assertRaises(tracing.InvalidCarrierException):
codec.extract([])
# Implicit case insensitivity testing
carrier = {'X-b3-SpanId': 'a2fb4a1d1a96d312', 'X-B3-ParentSpanId': '0020000000000001',
'X-B3-traceId': '463ac35c9f6413ad48485a3953bb6124', 'X-B3-flags': '1'}
span_context = codec.extract(carrier)
assert span_context.span_id == 'a2fb4a1d1a96d312'
assert span_context.trace_id == '463ac35c9f6413ad48485a3953bb6124'
assert span_context.parent_id == '0020000000000001'
assert span_context.flags == 0x02
# validate that missing parentspanid does not cause an error
carrier.pop('X-B3-ParentSpanId')
span_context = codec.extract(carrier)
assert span_context.parent_id is None
carrier.update({'X-b3-sampled': '1'})
span_context = codec.extract(carrier)
assert span_context.flags == 0x03
carrier.pop('X-B3-flags')
span_context = codec.extract(carrier)
assert span_context.flags == 0x01
def test_b3_inject(self):
codec = B3Codec()
with self.assertRaises(tracing.InvalidCarrierException):
codec.inject(None, [])
ctx = SpanContext(trace_id='463ac35c9f6413ad48485a3953bb6124', span_id='a2fb4a1d1a96d312', parent_id='0020000000000001', flags=2)
carrier = {}
codec.inject(ctx, carrier)
self.assertEqual(carrier, {'X-B3-SpanId': 'a2fb4a1d1a96d312', 'X-B3-ParentSpanId': '0020000000000001',
'X-B3-TraceId': '463ac35c9f6413ad48485a3953bb6124', 'X-B3-Flags': '1'})
|
streaming_puppet_gui.py
|
from multiprocessing import Process, Queue
import time
import serial
import numpy
import pandas as pd
from scipy import signal
from scipy import fftpack
import math
import sys
import PySimpleGUI as sg
def sync_to_uq(ser):
"""
Aligns the serial port read to the next 'UQ' header at the start of a data frame.
:type ser: pySerial Serial object
:param ser: The opened pySerial port bound to the Bluetooth connection with the BWT901CL.
:rtype: Bool, bytestring
:return: return the synced state (should be True on return), and the 9 bytes of 'UQ' accel data
"""
synced = False
u_flag = False
# Inner loop discards bytes until we align with the next 'UQ' header.
while not synced:
byte = ser.read(1)
# We haven't set the u_flag yet and we just hit a 'U' byte
if not u_flag and byte == b'U':
u_flag = True
# The last byte was 'U' and this byte is 'Q', so we're done
elif u_flag and byte == b'Q':
synced = True
# Either u_flag wasn't set and this byte isn't 'U', or
# u_flag was set and this byte wasn't 'Q'
# either way, reset the state flags.
else:
u_flag = False
synced = False
# Since we've aligned to the 'UQ' header, grab and return the 'UQ' accels.
# If we desynced on the previous measurement, no sense in throwing away a
# second data point while we're aligning.
uq_bytes = ser.read(9)
return synced, uq_bytes
def acquire_data(sample_freq, capture_window, queue):
"""
Acquires accelerometer data and stores it in arrays.
:type sample_freq: int
:param sample_freq: Sampling frequency in Hz
:type capture_window: int
:param capture_window: the number of data points to capture before writing to the queue. If acquire_data()
happens to desync at the end of the capture window, it may return more data points
than requested.
:type queue: Multiprocessing Queue
:param queue: A multiprocessing queue that allows a dict containing a captured batch of measurements to be
passed to detect_events().
:return: None
"""
print("Starting data capture...")
accel = [[] for i in range(3)]
w_vel = [[] for i in range(3)]
mag_angle = [[] for i in range(3)]
desync_count = 0
capture_count = 0
with serial.Serial('/dev/rfcomm0', 115200, timeout=100) as ser:
# Once we've opened the serial port, do a first alignment and
# initialize last_realtime from the hardware clock.
synced, a_raw = sync_to_uq(ser)
last_realtime = time.clock_gettime(time.CLOCK_MONOTONIC_RAW)
# Outer loop captures until process is terminated
while True:
# If this is the first iteration or we desynced on the last iteration, realign to the next 'UQ' header.
if not synced:
# Wait on align to sync. TODO: Alignment should have a timeout for squawk-and-stop.
synced, a_raw = sync_to_uq(ser)
a_1_int = int.from_bytes(a_raw[0:2], byteorder='little', signed=True)
a_2_int = int.from_bytes(a_raw[2:4], byteorder='little', signed=True)
a_3_int = int.from_bytes(a_raw[4:6], byteorder='little', signed=True)
# Otherwise just attempt to read the 'UQ' frame and get the accel data.
else:
s = ser.read(11)
if s[0:2] != b'UQ':
# Commenting out these desyncs, because we already know we are getting desynced in
# nominal operation. NaN counting statistics in detect_events() give roughly equivalent
# diagnostic information, and don't cause the real time performance hit of writing
# to stdout.
# print("Desynced! " + str(s[0:2]))
synced = False
continue
else:
a_1_int = int.from_bytes(s[2:4], byteorder='little', signed=True)
a_2_int = int.from_bytes(s[4:6], byteorder='little', signed=True)
a_3_int = int.from_bytes(s[6:8], byteorder='little', signed=True)
# Read the 'UR' frame and get the gyro angular velocity data.
s = ser.read(11)
if s[0:2] != b'UR':
# print("Desynced! " + str(s[0:2]))
synced = False
desync_count += 1
continue
else:
w_1_int = int.from_bytes(s[2:4], byteorder='little', signed=True)
w_2_int = int.from_bytes(s[4:6], byteorder='little', signed=True)
w_3_int = int.from_bytes(s[6:8], byteorder='little', signed=True)
# Read the 'US' frame and get the magnetometer angles.
s = ser.read(11)
if s[0:2] != b'US':
# print("Desynced! " + str(s[0:2]))
synced = False
desync_count += 1
continue
else:
angle_1_int = int.from_bytes(s[2:4], byteorder='little', signed=True)
angle_2_int = int.from_bytes(s[4:6], byteorder='little', signed=True)
angle_3_int = int.from_bytes(s[6:8], byteorder='little', signed=True)
# I haven't been able to figure out what the data is in the 'UT' frame
s = ser.read(11)
if __name__ == '__main__':
if s[0:2] != b'UT':
# print("Desynced! " + str(s[0:2]))
synced = False
desync_count += 1
continue
# We made it to the end of one complete frame, so we are assuming that this is a good data point.
# Before capturing this data, we need to check if a desync has caused data dropout. If so, we'll
# fill with NaN.
realtime = time.clock_gettime(time.CLOCK_MONOTONIC_RAW)
# If the elapsed time since we last captured a good data point is greater than the BWT901CL's
# sampling period, then we lost one or more data points to a desync.
time_delta = int(round((realtime - last_realtime) / (1.0 / sample_freq)))
# ...and update last_realtime to the current realtime, for use on the next cycle.
last_realtime = realtime
# If we lost data, append NaN's for the missing data points, then append the new good data point.
# If we didn't lose data, just append the new good data point.
if time_delta > 1:
# print("DEBUG: time_delta: " + str(time_delta))
for i in range(time_delta - 1):
# Increment the total count of data points, including dropped data.
capture_count += 1
for idx in range(3):
accel[idx].append(math.nan)
w_vel[idx].append(math.nan)
mag_angle[idx].append(math.nan)
# Increment the total count of data points by one for our new good data point.
capture_count += 1
for idx, value in enumerate([a_1_int, a_2_int, a_3_int]):
accel[idx].append(value / 32768.0 * 16)
for idx, value in enumerate([w_1_int, w_2_int, w_3_int]):
w_vel[idx].append(value / 32768.0 * 2000)
for idx, value in enumerate([angle_1_int, angle_2_int, angle_3_int]):
mag_angle[idx].append(value / 32768.0 * 180)
if capture_count >= capture_window:
capture_count = 0
window_dict = {'accel': accel,
'w_vel': w_vel,
'mag_angle': mag_angle,
'timestamp': time.clock_gettime(time.CLOCK_MONOTONIC_RAW),
'desync_count': desync_count}
# Uncomment this to print the raw x-axis accel values for debugging.
# print(accel[0])
# Clear the temporary measurement buffers.
accel = [[] for i in range(3)]
w_vel = [[] for i in range(3)]
mag_angle = [[] for i in range(3)]
queue.put(window_dict)
def detect_events(sample_freq, queue):
"""
Does FFT based event detection and plotting.
:type sample_freq: int
:param sample_freq: Sampling frequency in Hz
:type queue: Multiprocessing Queue
:param queue: detect_events() reads from this queue to acquire batches of IMU data captured by the acquire_data()
process.
:return: None
"""
BAR_WIDTH = 10
BAR_SPACING = 15
EDGE_OFFSET = 3
GRAPH_SIZE = (500, 100)
DATA_SIZE = (500, 100)
graph = sg.Graph(GRAPH_SIZE, (0, 0), DATA_SIZE)
# detect_events() blocks on the queue read, so data processing rate is driven by the rate that
layout = [[sg.Image(filename='blank.png', key='image')],
[graph],
[sg.Button('Exit', size=(10, 1), font='Helvetica 14')]]
# create the window and show it without the plot
window = sg.Window('Demo Application - Scratching Detection',
location=(800, 400))
window.Layout(layout).Finalize()
while True:
imu_data_dict = queue.get()
# Check the timestamp on this data frame. If it's more than one second behind the current
# CLOCK_MONOTONIC_RAW time, then detect_events() isn't keeping up with the incoming stream
# of IMU measurements comming from acquire_data(). Jump back to the top of the while loop,
# and get another data frame. We'll keep doing that until we're reading fresh data again.
# TODO: the threshold here might need to be adjusted, and perhaps the whole queue should be cleared.
if (time.clock_gettime(time.CLOCK_MONOTONIC_RAW) - imu_data_dict['timestamp']) > 1:
continue
df = pd.DataFrame(data=imu_data_dict['w_vel'][0], columns=['x'])
# print("Number of NaN points: " + str(df.isna().sum()))
# Doing a linear interpolation that replaces the NaN placeholders for desynced, dropped data
# with a straight line between the last good data point before a dropout and the next good data
# point. This does seem to improve the signal-to-noise ratio in the FFT.
df = df.interpolate()
yf = fftpack.rfft(df.loc[:, 'x'])
# Is this a better way of getting the power spectrum than numpy.abs(yf?)
yf = numpy.sqrt((yf * yf.conj()).real)
xf = fftpack.rfftfreq((len(df.index)), 1./sample_freq)
peaks, peaks_dict = signal.find_peaks(yf, height=1)
#print(xf[peaks], yf[peaks])
#print(peaks, peaks_dict)
# Check if any peak has been detected between 3 and 5 Hz, along the x axis. This is our rule for detecting
# tooth-brushing behavior.
event, values = window.Read(timeout=0, timeout_key='timeout')
graph.Erase()
for i in range(len(peaks_dict['peak_heights'])):
graph_value = peaks_dict['peak_heights'][i]
graph.DrawRectangle(top_left=(i * BAR_SPACING + EDGE_OFFSET, graph_value),
bottom_right=(i * BAR_SPACING + EDGE_OFFSET + BAR_WIDTH, 0), fill_color='blue')
graph.DrawText(text=graph_value, location=(i * BAR_SPACING + EDGE_OFFSET + 25, graph_value + 10))
if event == 'Exit' or event is None:
sys.exit(0)
# Scratching motion of puppet causes slow roll ( < 1 hz) along x axis.
if numpy.where(peaks_dict['peak_heights'] > 800)[0].size > 0:
window.FindElement('image').Update(filename='rat.png')
print("Scratching Detected!")
else:
window.FindElement('image').Update(filename='blank.png')
def main():
"""
Main function acquires data from the BWT901CL for a fixed length of time, and then performs a FFT analysis on it.
:return: None
"""
default_sample_freq = 10
capture_window = 20
data_queue = Queue()
# Spawn acquire_data() in a separate process, so that IMU data acquisition won't be delayed by the data processing
# in detect_events(). acquire_data() and detect_events() are the producer and consumer in a producer-consumer
# design pattern.
acquire_data_p = Process(target=acquire_data, args=(default_sample_freq, capture_window, data_queue,))
acquire_data_p.daemon = True
acquire_data_p.start()
detect_events(default_sample_freq, data_queue)
if __name__ == "__main__":
main()
|
ga5.py
|
'''
rewrite in 2014/10/01:
- all multiprocess
- standard GA
'''
import multiprocessing as mp
from numpy import *
from time import time
class extended_Queue(object):
def __init__(self, max = 500, threshold = 50):
self.qs = [mp.Queue() for i in range(max)]
self.ind = 0
self.max = max
self.threshold = threshold
self.count = 0
def put(self, ele):
if self.qs[self.ind].qsize() > self.threshold:
self.ind += 1
if self.ind >= self.max:
pass
# raw_input('leaking')
self.qs[self.ind].put(ele)
def get(self):
if self.qs[self.ind].empty():
self.ind -= 1
# print self.ind
# print self.__repr__()
return self.qs[self.ind].get()
def refresh(self):
while self.qs[self.ind].qsize() > self.threshold:
self.ind += 1
def __repr__(self):
return '<Extended Queue; Qsizes: '+str(map(lambda x: x.qsize(), self.qs)) + '>'
def choice(eles, num, p):
ans = []
for i in xrange(num):
acc = .0
thr = random.rand()
for ind, ele in enumerate(p):
acc += ele
if acc > thr:
ans.append(eles[ind])
break
return ans
class GA(object):
def __init__(self, fitness_f, terminator, generation_size, generation_init,
p_crossover, crossover_f, mutation_rate, mutation_f,
plot = False, plot_f = None, plot_interval = 100,
cmp_f = None,
cores = 1 ):
self.fitness_f = fitness_f
if 'fitness_thresold' in terminator:
self.fitness_thresold = terminator['fitness_thresold']
self.iter_maximum = None
else:
self.iter_maximum = terminator['iter_maximum']
self.fitness_thresold = None
#adjust for multiprocess
self.generation_size = ((generation_size-1)/cores + 1) * cores
self.generation_init = generation_init
self.p_crossover = p_crossover
self.crossover_f = crossover_f
self.mutation_rate = mutation_rate
self.mutation_f = mutation_f
self.plot = plot
self.plot_f = plot_f
self.best_fitness = None
self.plot_interval = plot_interval
self.cores = cores
if cmp_f == None:
self.cmp_f = lambda a,b: a>b
else:
self.cmp_f = cmp_f
def result(self):
self.best_fitness = None
self.fit()
return self.best_biont
def fit(self):
res = extended_Queue()
#mission
def f(times, res):
for i in xrange(times):
biont = self.generation_init()
fitness = self.fitness_f(biont)
res.put((biont, fitness))
#arrange the tasks
tasks = []
for ind in xrange(self.cores):
p = mp.Process(target = f, name = 'Process: %d' % ind, args = (self.generation_size/self.cores,res))
tasks.append(p)
p.start()
for task in tasks:
task.join()
res.refresh()
generation = [None] * self.generation_size
fitness = [None] * self.generation_size
fitness_max = None
for ind in xrange(self.generation_size):
biont__, fitness__ = res.get()
generation[ind] = biont__
fitness[ind] = fitness__
if fitness_max == None or self.cmp_f(fitness__, fitness_max):
fitness_max = fitness__
best_child = biont__
fitness_sum = sum(fitness)
iteration = 0
while (self.fitness_thresold == None and iteration < self.iter_maximum) or \
(self.iter_maximum == None and not self.cmp_f(fitness_max,self.fitness_thresold)):
start_time = time()
if self.best_fitness == None or self.cmp_f(fitness_max, self.best_fitness):
self.best_fitness = fitness_max
self.best_biont = best_child
print '%03dth generation|\tbest fitness:\t%lf|\tbest child fitness:\t%lf' % (iteration, self.best_fitness,fitness_max)
if self.plot and iteration % self.plot_interval == 0:
self.plot_f(best_child, 'red', False)
self.plot_f(self.best_biont, 'blue', True)
iteration += 1
#generation probability
gen_pr = array(fitness)
gen_pr = gen_pr - gen_pr.min()
if gen_pr.sum() == 0: gen_pr = 1 - gen_pr
gen_pr = gen_pr / gen_pr.max()
gen_pr = exp(gen_pr)
gen_pr = gen_pr / gen_pr.sum()
#sample next generation
next_generation = []
seeds = sort(random.uniform(0, 1, size = (self.generation_size,)))
acc = 0; cur = 0; ind = 0
while ind < self.generation_size:
acc += gen_pr[cur]
while ind < self.generation_size and seeds[ind] <= acc:
next_generation.append(generation[cur])
ind += 1
cur += 1
#crossover
seeds = list((random.binomial(1, self.p_crossover, self.generation_size)\
* range(self.generation_size)).nonzero()[0])
if len(seeds) % 2 == 1:
seeds.pop(-1)
def f(mission, res):
for father, mother in mission:
child0, child1 = self.crossover_f(father[1], mother[1])
res.put((father[0], child0))
res.put((mother[0], child1))
missions = [[] for i in range(self.cores)]
l = len(seeds)
for ind in range(l)[::2]:
ind0 = seeds[ind]
ind1 = seeds[ind+1]
missions[ind/2 % self.cores].append( ( (ind0, next_generation[ind0]),
(ind1, next_generation[ind1]) ) )
tasks = []
for ind, ele in enumerate(missions):
p = mp.Process(target = f, args = (ele, res))
p.start()
tasks.append(p)
for ele in tasks:
ele.join()
res.refresh()
for ind__ in range(l):
ind, ele = res.get()
next_generation[ind] = ele
print 'cross mission', map(lambda x: len(x), missions)
#mutation
seeds = list((random.binomial(1, self.mutation_rate, self.generation_size)\
* range(self.generation_size)).nonzero()[0])
def f(mission, res):
for ind, ele in mission:
res.put((ind, self.mutation_f(ele)))
missions = [[] for i in range(self.cores)]
for ind, ele in enumerate(seeds):
missions[ind % self.cores].append( (ele, next_generation[ele]) )
tasks = []
for ind, ele in enumerate(missions):
p = mp.Process(target = f, args=(ele, res))
p.start()
tasks.append(p)
for task in tasks:
task.join()
res.refresh()
for i__ in range(len(seeds)):
ind, ele = res.get()
next_generation[ind] = ele
print 'mutate mission', map(lambda x: len(x), missions)
#inherit
#calc the fitness
generation = copy(next_generation)
#mp that line
missions = [[] for i in range(self.cores)]
for ind, ele in enumerate(generation):
missions[ind % self.cores].append((ind, ele))
def f(mission, res):
for ind, ele in mission:
res.put((ind, self.fitness_f(ele)))
tasks = []
for ind, ele in enumerate(missions):
p = mp.Process(target = f, name = 'MP:'+str(ind),
args=(ele, res))
tasks.append(p)
p.start()
for task in tasks:
task.join()
#the context is copied by other processing
#restore the context
res.refresh()
for ind in range(self.generation_size):
index, value = res.get()
fitness[index] = value
if fitness_max == None or self.cmp_f(value, fitness_max):
fitness_max = value
best_child = generation[index]
print 'eval mission', map(lambda x: len(x), missions)
fitness_sum = sum(fitness)
end_time = time()
print 'takes %.5f'% (-start_time + end_time)
self.plot_f(best_child, 'red', False)
self.plot_f(self.best_biont, 'blue', True)
raw_input('Done.')
|
main.py
|
from threading import Thread
from animation import*
from RealTime_Stock_Price import*
def main():
data = stock_data(['AAPL','ACB','TSLA','FB'])
animating = animation(data.stock_list)
Thread(target = data.save_data).start()
animating.display()
main()
|
process_replay.py
|
#!/usr/bin/env python3
import capnp
import os
import sys
import threading
import importlib
if "CI" in os.environ:
def tqdm(x):
return x
else:
from tqdm import tqdm # type: ignore
from cereal import car, log
from selfdrive.car.car_helpers import get_car
import selfdrive.manager as manager
import cereal.messaging as messaging
from common.params import Params
from cereal.services import service_list
from collections import namedtuple
ProcessConfig = namedtuple('ProcessConfig', ['proc_name', 'pub_sub', 'ignore', 'init_callback', 'should_recv_callback'])
def wait_for_event(evt):
if not evt.wait(15):
if threading.currentThread().getName() == "MainThread":
# tested process likely died. don't let test just hang
raise Exception("Timeout reached. Tested process likely crashed.")
else:
# done testing this process, let it die
sys.exit(0)
class FakeSocket:
def __init__(self, wait=True):
self.data = []
self.wait = wait
self.recv_called = threading.Event()
self.recv_ready = threading.Event()
def receive(self, non_blocking=False):
if non_blocking:
return None
if self.wait:
self.recv_called.set()
wait_for_event(self.recv_ready)
self.recv_ready.clear()
return self.data.pop()
def send(self, data):
if self.wait:
wait_for_event(self.recv_called)
self.recv_called.clear()
self.data.append(data)
if self.wait:
self.recv_ready.set()
def wait_for_recv(self):
wait_for_event(self.recv_called)
class DumbSocket:
def __init__(self, s=None):
if s is not None:
try:
dat = messaging.new_message(s)
except capnp.lib.capnp.KjException: # pylint: disable=c-extension-no-member
# lists
dat = messaging.new_message(s, 0)
self.data = dat.to_bytes()
def receive(self, non_blocking=False):
return self.data
def send(self, dat):
pass
class FakeSubMaster(messaging.SubMaster):
def __init__(self, services):
super(FakeSubMaster, self).__init__(services, addr=None)
self.sock = {s: DumbSocket(s) for s in services}
self.update_called = threading.Event()
self.update_ready = threading.Event()
self.wait_on_getitem = False
def __getitem__(self, s):
# hack to know when fingerprinting is done
if self.wait_on_getitem:
self.update_called.set()
wait_for_event(self.update_ready)
self.update_ready.clear()
return self.data[s]
def update(self, timeout=-1):
self.update_called.set()
wait_for_event(self.update_ready)
self.update_ready.clear()
def update_msgs(self, cur_time, msgs):
wait_for_event(self.update_called)
self.update_called.clear()
super(FakeSubMaster, self).update_msgs(cur_time, msgs)
self.update_ready.set()
def wait_for_update(self):
wait_for_event(self.update_called)
class FakePubMaster(messaging.PubMaster):
def __init__(self, services): # pylint: disable=super-init-not-called
self.data = {}
self.sock = {}
self.last_updated = None
for s in services:
try:
data = messaging.new_message(s)
except capnp.lib.capnp.KjException:
data = messaging.new_message(s, 0)
self.data[s] = data.as_reader()
self.sock[s] = DumbSocket()
self.send_called = threading.Event()
self.get_called = threading.Event()
def send(self, s, dat):
self.last_updated = s
if isinstance(dat, bytes):
self.data[s] = log.Event.from_bytes(dat)
else:
self.data[s] = dat.as_reader()
self.send_called.set()
wait_for_event(self.get_called)
self.get_called.clear()
def wait_for_msg(self):
wait_for_event(self.send_called)
self.send_called.clear()
dat = self.data[self.last_updated]
self.get_called.set()
return dat
def fingerprint(msgs, fsm, can_sock):
print("start fingerprinting")
fsm.wait_on_getitem = True
# populate fake socket with data for fingerprinting
canmsgs = [msg for msg in msgs if msg.which() == "can"]
wait_for_event(can_sock.recv_called)
can_sock.recv_called.clear()
can_sock.data = [msg.as_builder().to_bytes() for msg in canmsgs[:300]]
can_sock.recv_ready.set()
can_sock.wait = False
# we know fingerprinting is done when controlsd sets sm['pathPlan'].sensorValid
wait_for_event(fsm.update_called)
fsm.update_called.clear()
fsm.wait_on_getitem = False
can_sock.wait = True
can_sock.data = []
fsm.update_ready.set()
print("finished fingerprinting")
def get_car_params(msgs, fsm, can_sock):
can = FakeSocket(wait=False)
sendcan = FakeSocket(wait=False)
canmsgs = [msg for msg in msgs if msg.which() == 'can']
for m in canmsgs[:300]:
can.send(m.as_builder().to_bytes())
_, CP = get_car(can, sendcan)
Params().put("CarParams", CP.to_bytes())
def radar_rcv_callback(msg, CP, cfg, fsm):
if msg.which() != "can":
return [], False
elif CP.radarOffCan:
return ["radarState", "liveTracks"], True
radar_msgs = {"honda": [0x445], "toyota": [0x19f, 0x22f], "gm": [0x474],
"chrysler": [0x2d4]}.get(CP.carName, None)
if radar_msgs is None:
raise NotImplementedError
for m in msg.can:
if m.src == 1 and m.address in radar_msgs:
return ["radarState", "liveTracks"], True
return [], False
def calibration_rcv_callback(msg, CP, cfg, fsm):
# calibrationd publishes 1 calibrationData every 5 cameraOdometry packets.
# should_recv always true to increment frame
if msg.which() == 'carState':
if ((fsm.frame + 1) % 25) == 0:
recv_socks = ["liveCalibration"]
else:
recv_socks = []
return recv_socks, True
else:
return [], False
CONFIGS = [
ProcessConfig(
proc_name="controlsd",
pub_sub={
"can": ["controlsState", "carState", "carControl", "sendcan", "carEvents", "carParams"],
"thermal": [], "health": [], "liveCalibration": [], "dMonitoringState": [], "plan": [], "pathPlan": [], "gpsLocation": [], "liveLocationKalman": [],
"model": [], "frame": [],
},
ignore=["logMonoTime", "valid", "controlsState.startMonoTime", "controlsState.cumLagMs"],
init_callback=fingerprint,
should_recv_callback=None,
),
ProcessConfig(
proc_name="radard",
pub_sub={
"can": ["radarState", "liveTracks"],
"liveParameters": [], "controlsState": [], "model": [],
},
ignore=["logMonoTime", "valid", "radarState.cumLagMs"],
init_callback=get_car_params,
should_recv_callback=radar_rcv_callback,
),
ProcessConfig(
proc_name="plannerd",
pub_sub={
"model": ["pathPlan"], "radarState": ["plan"],
"carState": [], "controlsState": [], "liveParameters": [],
},
ignore=["logMonoTime", "valid", "plan.processingDelay"],
init_callback=get_car_params,
should_recv_callback=None,
),
ProcessConfig(
proc_name="calibrationd",
pub_sub={
"carState": ["liveCalibration"],
"cameraOdometry": []
},
ignore=["logMonoTime", "valid"],
init_callback=get_car_params,
should_recv_callback=calibration_rcv_callback,
),
ProcessConfig(
proc_name="dmonitoringd",
pub_sub={
"driverState": ["dMonitoringState"],
"liveCalibration": [], "carState": [], "model": [], "gpsLocation": [],
},
ignore=["logMonoTime", "valid"],
init_callback=get_car_params,
should_recv_callback=None,
),
ProcessConfig(
proc_name="locationd",
pub_sub={
"cameraOdometry": ["liveLocationKalman"],
"sensorEvents": [], "gpsLocationExternal": [], "liveCalibration": [], "carState": [],
},
ignore=["logMonoTime", "valid"],
init_callback=get_car_params,
should_recv_callback=None,
),
]
def replay_process(cfg, lr):
sub_sockets = [s for _, sub in cfg.pub_sub.items() for s in sub]
pub_sockets = [s for s in cfg.pub_sub.keys() if s != 'can']
fsm = FakeSubMaster(pub_sockets)
fpm = FakePubMaster(sub_sockets)
args = (fsm, fpm)
if 'can' in list(cfg.pub_sub.keys()):
can_sock = FakeSocket()
args = (fsm, fpm, can_sock)
all_msgs = sorted(lr, key=lambda msg: msg.logMonoTime)
pub_msgs = [msg for msg in all_msgs if msg.which() in list(cfg.pub_sub.keys())]
params = Params()
params.clear_all()
params.manager_start()
params.put("OpenpilotEnabledToggle", "1")
params.put("Passive", "0")
params.put("CommunityFeaturesToggle", "1")
os.environ['NO_RADAR_SLEEP'] = "1"
manager.prepare_managed_process(cfg.proc_name)
mod = importlib.import_module(manager.managed_processes[cfg.proc_name])
thread = threading.Thread(target=mod.main, args=args)
thread.daemon = True
thread.start()
if cfg.init_callback is not None:
if 'can' not in list(cfg.pub_sub.keys()):
can_sock = None
cfg.init_callback(all_msgs, fsm, can_sock)
CP = car.CarParams.from_bytes(params.get("CarParams", block=True))
# wait for started process to be ready
if 'can' in list(cfg.pub_sub.keys()):
can_sock.wait_for_recv()
else:
fsm.wait_for_update()
log_msgs, msg_queue = [], []
for msg in tqdm(pub_msgs):
if cfg.should_recv_callback is not None:
recv_socks, should_recv = cfg.should_recv_callback(msg, CP, cfg, fsm)
else:
recv_socks = [s for s in cfg.pub_sub[msg.which()] if
(fsm.frame + 1) % int(service_list[msg.which()].frequency / service_list[s].frequency) == 0]
should_recv = bool(len(recv_socks))
if msg.which() == 'can':
can_sock.send(msg.as_builder().to_bytes())
else:
msg_queue.append(msg.as_builder())
if should_recv:
fsm.update_msgs(0, msg_queue)
msg_queue = []
recv_cnt = len(recv_socks)
while recv_cnt > 0:
m = fpm.wait_for_msg()
log_msgs.append(m)
recv_cnt -= m.which() in recv_socks
return log_msgs
|
test_functools.py
|
import abc
import builtins
import collections
import collections.abc
import copy
from itertools import permutations
import pickle
from random import choice
import sys
from test import support
import threading
import time
import typing
import unittest
import unittest.mock
from weakref import proxy
import contextlib
import functools
py_functools = support.import_fresh_module('functools', blocked=['_functools'])
c_functools = support.import_fresh_module('functools', fresh=['_functools'])
decimal = support.import_fresh_module('decimal', fresh=['_decimal'])
@contextlib.contextmanager
def replaced_module(name, replacement):
original_module = sys.modules[name]
sys.modules[name] = replacement
try:
yield
finally:
sys.modules[name] = original_module
def capture(*args, **kw):
"""capture all positional and keyword arguments"""
return args, kw
def signature(part):
""" return the signature of a partial object """
return (part.func, part.args, part.keywords, part.__dict__)
class MyTuple(tuple):
pass
class BadTuple(tuple):
def __add__(self, other):
return list(self) + list(other)
class MyDict(dict):
pass
class TestPartial:
def test_basic_examples(self):
p = self.partial(capture, 1, 2, a=10, b=20)
self.assertTrue(callable(p))
self.assertEqual(p(3, 4, b=30, c=40),
((1, 2, 3, 4), dict(a=10, b=30, c=40)))
p = self.partial(map, lambda x: x*10)
self.assertEqual(list(p([1,2,3,4])), [10, 20, 30, 40])
def test_attributes(self):
p = self.partial(capture, 1, 2, a=10, b=20)
# attributes should be readable
self.assertEqual(p.func, capture)
self.assertEqual(p.args, (1, 2))
self.assertEqual(p.keywords, dict(a=10, b=20))
def test_argument_checking(self):
self.assertRaises(TypeError, self.partial) # need at least a func arg
try:
self.partial(2)()
except TypeError:
pass
else:
self.fail('First arg not checked for callability')
def test_protection_of_callers_dict_argument(self):
# a caller's dictionary should not be altered by partial
def func(a=10, b=20):
return a
d = {'a':3}
p = self.partial(func, a=5)
self.assertEqual(p(**d), 3)
self.assertEqual(d, {'a':3})
p(b=7)
self.assertEqual(d, {'a':3})
def test_kwargs_copy(self):
# Issue #29532: Altering a kwarg dictionary passed to a constructor
# should not affect a partial object after creation
d = {'a': 3}
p = self.partial(capture, **d)
self.assertEqual(p(), ((), {'a': 3}))
d['a'] = 5
self.assertEqual(p(), ((), {'a': 3}))
def test_arg_combinations(self):
# exercise special code paths for zero args in either partial
# object or the caller
p = self.partial(capture)
self.assertEqual(p(), ((), {}))
self.assertEqual(p(1,2), ((1,2), {}))
p = self.partial(capture, 1, 2)
self.assertEqual(p(), ((1,2), {}))
self.assertEqual(p(3,4), ((1,2,3,4), {}))
def test_kw_combinations(self):
# exercise special code paths for no keyword args in
# either the partial object or the caller
p = self.partial(capture)
self.assertEqual(p.keywords, {})
self.assertEqual(p(), ((), {}))
self.assertEqual(p(a=1), ((), {'a':1}))
p = self.partial(capture, a=1)
self.assertEqual(p.keywords, {'a':1})
self.assertEqual(p(), ((), {'a':1}))
self.assertEqual(p(b=2), ((), {'a':1, 'b':2}))
# keyword args in the call override those in the partial object
self.assertEqual(p(a=3, b=2), ((), {'a':3, 'b':2}))
def test_positional(self):
# make sure positional arguments are captured correctly
for args in [(), (0,), (0,1), (0,1,2), (0,1,2,3)]:
p = self.partial(capture, *args)
expected = args + ('x',)
got, empty = p('x')
self.assertTrue(expected == got and empty == {})
def test_keyword(self):
# make sure keyword arguments are captured correctly
for a in ['a', 0, None, 3.5]:
p = self.partial(capture, a=a)
expected = {'a':a,'x':None}
empty, got = p(x=None)
self.assertTrue(expected == got and empty == ())
def test_no_side_effects(self):
# make sure there are no side effects that affect subsequent calls
p = self.partial(capture, 0, a=1)
args1, kw1 = p(1, b=2)
self.assertTrue(args1 == (0,1) and kw1 == {'a':1,'b':2})
args2, kw2 = p()
self.assertTrue(args2 == (0,) and kw2 == {'a':1})
def test_error_propagation(self):
def f(x, y):
x / y
self.assertRaises(ZeroDivisionError, self.partial(f, 1, 0))
self.assertRaises(ZeroDivisionError, self.partial(f, 1), 0)
self.assertRaises(ZeroDivisionError, self.partial(f), 1, 0)
self.assertRaises(ZeroDivisionError, self.partial(f, y=0), 1)
def test_weakref(self):
f = self.partial(int, base=16)
p = proxy(f)
self.assertEqual(f.func, p.func)
f = None
self.assertRaises(ReferenceError, getattr, p, 'func')
def test_with_bound_and_unbound_methods(self):
data = list(map(str, range(10)))
join = self.partial(str.join, '')
self.assertEqual(join(data), '0123456789')
join = self.partial(''.join)
self.assertEqual(join(data), '0123456789')
def test_nested_optimization(self):
partial = self.partial
inner = partial(signature, 'asdf')
nested = partial(inner, bar=True)
flat = partial(signature, 'asdf', bar=True)
self.assertEqual(signature(nested), signature(flat))
def test_nested_partial_with_attribute(self):
# see issue 25137
partial = self.partial
def foo(bar):
return bar
p = partial(foo, 'first')
p2 = partial(p, 'second')
p2.new_attr = 'spam'
self.assertEqual(p2.new_attr, 'spam')
def test_repr(self):
args = (object(), object())
args_repr = ', '.join(repr(a) for a in args)
kwargs = {'a': object(), 'b': object()}
kwargs_reprs = ['a={a!r}, b={b!r}'.format_map(kwargs),
'b={b!r}, a={a!r}'.format_map(kwargs)]
if self.partial in (c_functools.partial, py_functools.partial):
name = 'functools.partial'
else:
name = self.partial.__name__
f = self.partial(capture)
self.assertEqual(f'{name}({capture!r})', repr(f))
f = self.partial(capture, *args)
self.assertEqual(f'{name}({capture!r}, {args_repr})', repr(f))
f = self.partial(capture, **kwargs)
self.assertIn(repr(f),
[f'{name}({capture!r}, {kwargs_repr})'
for kwargs_repr in kwargs_reprs])
f = self.partial(capture, *args, **kwargs)
self.assertIn(repr(f),
[f'{name}({capture!r}, {args_repr}, {kwargs_repr})'
for kwargs_repr in kwargs_reprs])
def test_recursive_repr(self):
if self.partial in (c_functools.partial, py_functools.partial):
name = 'functools.partial'
else:
name = self.partial.__name__
f = self.partial(capture)
f.__setstate__((f, (), {}, {}))
try:
self.assertEqual(repr(f), '%s(...)' % (name,))
finally:
f.__setstate__((capture, (), {}, {}))
f = self.partial(capture)
f.__setstate__((capture, (f,), {}, {}))
try:
self.assertEqual(repr(f), '%s(%r, ...)' % (name, capture,))
finally:
f.__setstate__((capture, (), {}, {}))
f = self.partial(capture)
f.__setstate__((capture, (), {'a': f}, {}))
try:
self.assertEqual(repr(f), '%s(%r, a=...)' % (name, capture,))
finally:
f.__setstate__((capture, (), {}, {}))
def test_pickle(self):
with self.AllowPickle():
f = self.partial(signature, ['asdf'], bar=[True])
f.attr = []
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
f_copy = pickle.loads(pickle.dumps(f, proto))
self.assertEqual(signature(f_copy), signature(f))
def test_copy(self):
f = self.partial(signature, ['asdf'], bar=[True])
f.attr = []
f_copy = copy.copy(f)
self.assertEqual(signature(f_copy), signature(f))
self.assertIs(f_copy.attr, f.attr)
self.assertIs(f_copy.args, f.args)
self.assertIs(f_copy.keywords, f.keywords)
def test_deepcopy(self):
f = self.partial(signature, ['asdf'], bar=[True])
f.attr = []
f_copy = copy.deepcopy(f)
self.assertEqual(signature(f_copy), signature(f))
self.assertIsNot(f_copy.attr, f.attr)
self.assertIsNot(f_copy.args, f.args)
self.assertIsNot(f_copy.args[0], f.args[0])
self.assertIsNot(f_copy.keywords, f.keywords)
self.assertIsNot(f_copy.keywords['bar'], f.keywords['bar'])
def test_setstate(self):
f = self.partial(signature)
f.__setstate__((capture, (1,), dict(a=10), dict(attr=[])))
self.assertEqual(signature(f),
(capture, (1,), dict(a=10), dict(attr=[])))
self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20}))
f.__setstate__((capture, (1,), dict(a=10), None))
self.assertEqual(signature(f), (capture, (1,), dict(a=10), {}))
self.assertEqual(f(2, b=20), ((1, 2), {'a': 10, 'b': 20}))
f.__setstate__((capture, (1,), None, None))
#self.assertEqual(signature(f), (capture, (1,), {}, {}))
self.assertEqual(f(2, b=20), ((1, 2), {'b': 20}))
self.assertEqual(f(2), ((1, 2), {}))
self.assertEqual(f(), ((1,), {}))
f.__setstate__((capture, (), {}, None))
self.assertEqual(signature(f), (capture, (), {}, {}))
self.assertEqual(f(2, b=20), ((2,), {'b': 20}))
self.assertEqual(f(2), ((2,), {}))
self.assertEqual(f(), ((), {}))
def test_setstate_errors(self):
f = self.partial(signature)
self.assertRaises(TypeError, f.__setstate__, (capture, (), {}))
self.assertRaises(TypeError, f.__setstate__, (capture, (), {}, {}, None))
self.assertRaises(TypeError, f.__setstate__, [capture, (), {}, None])
self.assertRaises(TypeError, f.__setstate__, (None, (), {}, None))
self.assertRaises(TypeError, f.__setstate__, (capture, None, {}, None))
self.assertRaises(TypeError, f.__setstate__, (capture, [], {}, None))
self.assertRaises(TypeError, f.__setstate__, (capture, (), [], None))
def test_setstate_subclasses(self):
f = self.partial(signature)
f.__setstate__((capture, MyTuple((1,)), MyDict(a=10), None))
s = signature(f)
self.assertEqual(s, (capture, (1,), dict(a=10), {}))
self.assertIs(type(s[1]), tuple)
self.assertIs(type(s[2]), dict)
r = f()
self.assertEqual(r, ((1,), {'a': 10}))
self.assertIs(type(r[0]), tuple)
self.assertIs(type(r[1]), dict)
f.__setstate__((capture, BadTuple((1,)), {}, None))
s = signature(f)
self.assertEqual(s, (capture, (1,), {}, {}))
self.assertIs(type(s[1]), tuple)
r = f(2)
self.assertEqual(r, ((1, 2), {}))
self.assertIs(type(r[0]), tuple)
def test_recursive_pickle(self):
with self.AllowPickle():
f = self.partial(capture)
f.__setstate__((f, (), {}, {}))
try:
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
with self.assertRaises(RecursionError):
pickle.dumps(f, proto)
finally:
f.__setstate__((capture, (), {}, {}))
f = self.partial(capture)
f.__setstate__((capture, (f,), {}, {}))
try:
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
f_copy = pickle.loads(pickle.dumps(f, proto))
try:
self.assertIs(f_copy.args[0], f_copy)
finally:
f_copy.__setstate__((capture, (), {}, {}))
finally:
f.__setstate__((capture, (), {}, {}))
f = self.partial(capture)
f.__setstate__((capture, (), {'a': f}, {}))
try:
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
f_copy = pickle.loads(pickle.dumps(f, proto))
try:
self.assertIs(f_copy.keywords['a'], f_copy)
finally:
f_copy.__setstate__((capture, (), {}, {}))
finally:
f.__setstate__((capture, (), {}, {}))
# Issue 6083: Reference counting bug
def test_setstate_refcount(self):
class BadSequence:
def __len__(self):
return 4
def __getitem__(self, key):
if key == 0:
return max
elif key == 1:
return tuple(range(1000000))
elif key in (2, 3):
return {}
raise IndexError
f = self.partial(object)
self.assertRaises(TypeError, f.__setstate__, BadSequence())
@unittest.skipUnless(c_functools, 'requires the C _functools module')
class TestPartialC(TestPartial, unittest.TestCase):
if c_functools:
partial = c_functools.partial
class AllowPickle:
def __enter__(self):
return self
def __exit__(self, type, value, tb):
return False
def test_attributes_unwritable(self):
# attributes should not be writable
p = self.partial(capture, 1, 2, a=10, b=20)
self.assertRaises(AttributeError, setattr, p, 'func', map)
self.assertRaises(AttributeError, setattr, p, 'args', (1, 2))
self.assertRaises(AttributeError, setattr, p, 'keywords', dict(a=1, b=2))
p = self.partial(hex)
try:
del p.__dict__
except TypeError:
pass
else:
self.fail('partial object allowed __dict__ to be deleted')
def test_manually_adding_non_string_keyword(self):
p = self.partial(capture)
# Adding a non-string/unicode keyword to partial kwargs
p.keywords[1234] = 'value'
r = repr(p)
self.assertIn('1234', r)
self.assertIn("'value'", r)
with self.assertRaises(TypeError):
p()
def test_keystr_replaces_value(self):
p = self.partial(capture)
class MutatesYourDict(object):
def __str__(self):
p.keywords[self] = ['sth2']
return 'astr'
# Replacing the value during key formatting should keep the original
# value alive (at least long enough).
p.keywords[MutatesYourDict()] = ['sth']
r = repr(p)
self.assertIn('astr', r)
self.assertIn("['sth']", r)
class TestPartialPy(TestPartial, unittest.TestCase):
partial = py_functools.partial
class AllowPickle:
def __init__(self):
self._cm = replaced_module("functools", py_functools)
def __enter__(self):
return self._cm.__enter__()
def __exit__(self, type, value, tb):
return self._cm.__exit__(type, value, tb)
if c_functools:
class CPartialSubclass(c_functools.partial):
pass
class PyPartialSubclass(py_functools.partial):
pass
@unittest.skipUnless(c_functools, 'requires the C _functools module')
class TestPartialCSubclass(TestPartialC):
if c_functools:
partial = CPartialSubclass
# partial subclasses are not optimized for nested calls
test_nested_optimization = None
class TestPartialPySubclass(TestPartialPy):
partial = PyPartialSubclass
class TestPartialMethod(unittest.TestCase):
class A(object):
nothing = functools.partialmethod(capture)
positional = functools.partialmethod(capture, 1)
keywords = functools.partialmethod(capture, a=2)
both = functools.partialmethod(capture, 3, b=4)
spec_keywords = functools.partialmethod(capture, self=1, func=2)
nested = functools.partialmethod(positional, 5)
over_partial = functools.partialmethod(functools.partial(capture, c=6), 7)
static = functools.partialmethod(staticmethod(capture), 8)
cls = functools.partialmethod(classmethod(capture), d=9)
a = A()
def test_arg_combinations(self):
self.assertEqual(self.a.nothing(), ((self.a,), {}))
self.assertEqual(self.a.nothing(5), ((self.a, 5), {}))
self.assertEqual(self.a.nothing(c=6), ((self.a,), {'c': 6}))
self.assertEqual(self.a.nothing(5, c=6), ((self.a, 5), {'c': 6}))
self.assertEqual(self.a.positional(), ((self.a, 1), {}))
self.assertEqual(self.a.positional(5), ((self.a, 1, 5), {}))
self.assertEqual(self.a.positional(c=6), ((self.a, 1), {'c': 6}))
self.assertEqual(self.a.positional(5, c=6), ((self.a, 1, 5), {'c': 6}))
self.assertEqual(self.a.keywords(), ((self.a,), {'a': 2}))
self.assertEqual(self.a.keywords(5), ((self.a, 5), {'a': 2}))
self.assertEqual(self.a.keywords(c=6), ((self.a,), {'a': 2, 'c': 6}))
self.assertEqual(self.a.keywords(5, c=6), ((self.a, 5), {'a': 2, 'c': 6}))
self.assertEqual(self.a.both(), ((self.a, 3), {'b': 4}))
self.assertEqual(self.a.both(5), ((self.a, 3, 5), {'b': 4}))
self.assertEqual(self.a.both(c=6), ((self.a, 3), {'b': 4, 'c': 6}))
self.assertEqual(self.a.both(5, c=6), ((self.a, 3, 5), {'b': 4, 'c': 6}))
self.assertEqual(self.A.both(self.a, 5, c=6), ((self.a, 3, 5), {'b': 4, 'c': 6}))
self.assertEqual(self.a.spec_keywords(), ((self.a,), {'self': 1, 'func': 2}))
def test_nested(self):
self.assertEqual(self.a.nested(), ((self.a, 1, 5), {}))
self.assertEqual(self.a.nested(6), ((self.a, 1, 5, 6), {}))
self.assertEqual(self.a.nested(d=7), ((self.a, 1, 5), {'d': 7}))
self.assertEqual(self.a.nested(6, d=7), ((self.a, 1, 5, 6), {'d': 7}))
self.assertEqual(self.A.nested(self.a, 6, d=7), ((self.a, 1, 5, 6), {'d': 7}))
def test_over_partial(self):
self.assertEqual(self.a.over_partial(), ((self.a, 7), {'c': 6}))
self.assertEqual(self.a.over_partial(5), ((self.a, 7, 5), {'c': 6}))
self.assertEqual(self.a.over_partial(d=8), ((self.a, 7), {'c': 6, 'd': 8}))
self.assertEqual(self.a.over_partial(5, d=8), ((self.a, 7, 5), {'c': 6, 'd': 8}))
self.assertEqual(self.A.over_partial(self.a, 5, d=8), ((self.a, 7, 5), {'c': 6, 'd': 8}))
def test_bound_method_introspection(self):
obj = self.a
self.assertIs(obj.both.__self__, obj)
self.assertIs(obj.nested.__self__, obj)
self.assertIs(obj.over_partial.__self__, obj)
self.assertIs(obj.cls.__self__, self.A)
self.assertIs(self.A.cls.__self__, self.A)
def test_unbound_method_retrieval(self):
obj = self.A
self.assertFalse(hasattr(obj.both, "__self__"))
self.assertFalse(hasattr(obj.nested, "__self__"))
self.assertFalse(hasattr(obj.over_partial, "__self__"))
self.assertFalse(hasattr(obj.static, "__self__"))
self.assertFalse(hasattr(self.a.static, "__self__"))
def test_descriptors(self):
for obj in [self.A, self.a]:
with self.subTest(obj=obj):
self.assertEqual(obj.static(), ((8,), {}))
self.assertEqual(obj.static(5), ((8, 5), {}))
self.assertEqual(obj.static(d=8), ((8,), {'d': 8}))
self.assertEqual(obj.static(5, d=8), ((8, 5), {'d': 8}))
self.assertEqual(obj.cls(), ((self.A,), {'d': 9}))
self.assertEqual(obj.cls(5), ((self.A, 5), {'d': 9}))
self.assertEqual(obj.cls(c=8), ((self.A,), {'c': 8, 'd': 9}))
self.assertEqual(obj.cls(5, c=8), ((self.A, 5), {'c': 8, 'd': 9}))
def test_overriding_keywords(self):
self.assertEqual(self.a.keywords(a=3), ((self.a,), {'a': 3}))
self.assertEqual(self.A.keywords(self.a, a=3), ((self.a,), {'a': 3}))
def test_invalid_args(self):
with self.assertRaises(TypeError):
class B(object):
method = functools.partialmethod(None, 1)
with self.assertRaises(TypeError):
class B:
method = functools.partialmethod()
with self.assertRaises(TypeError):
class B:
method = functools.partialmethod(func=capture, a=1)
def test_repr(self):
self.assertEqual(repr(vars(self.A)['both']),
'functools.partialmethod({}, 3, b=4)'.format(capture))
def test_abstract(self):
class Abstract(abc.ABCMeta):
@abc.abstractmethod
def add(self, x, y):
pass
add5 = functools.partialmethod(add, 5)
self.assertTrue(Abstract.add.__isabstractmethod__)
self.assertTrue(Abstract.add5.__isabstractmethod__)
for func in [self.A.static, self.A.cls, self.A.over_partial, self.A.nested, self.A.both]:
self.assertFalse(getattr(func, '__isabstractmethod__', False))
def test_positional_only(self):
def f(a, b, /):
return a + b
p = functools.partial(f, 1)
self.assertEqual(p(2), f(1, 2))
class TestUpdateWrapper(unittest.TestCase):
def check_wrapper(self, wrapper, wrapped,
assigned=functools.WRAPPER_ASSIGNMENTS,
updated=functools.WRAPPER_UPDATES):
# Check attributes were assigned
for name in assigned:
self.assertIs(getattr(wrapper, name), getattr(wrapped, name))
# Check attributes were updated
for name in updated:
wrapper_attr = getattr(wrapper, name)
wrapped_attr = getattr(wrapped, name)
for key in wrapped_attr:
if name == "__dict__" and key == "__wrapped__":
# __wrapped__ is overwritten by the update code
continue
self.assertIs(wrapped_attr[key], wrapper_attr[key])
# Check __wrapped__
self.assertIs(wrapper.__wrapped__, wrapped)
def _default_update(self):
def f(a:'This is a new annotation'):
"""This is a test"""
pass
f.attr = 'This is also a test'
f.__wrapped__ = "This is a bald faced lie"
def wrapper(b:'This is the prior annotation'):
pass
functools.update_wrapper(wrapper, f)
return wrapper, f
def test_default_update(self):
wrapper, f = self._default_update()
self.check_wrapper(wrapper, f)
self.assertIs(wrapper.__wrapped__, f)
self.assertEqual(wrapper.__name__, 'f')
self.assertEqual(wrapper.__qualname__, f.__qualname__)
self.assertEqual(wrapper.attr, 'This is also a test')
self.assertEqual(wrapper.__annotations__['a'], 'This is a new annotation')
self.assertNotIn('b', wrapper.__annotations__)
@unittest.skipIf(sys.flags.optimize >= 2,
"Docstrings are omitted with -O2 and above")
def test_default_update_doc(self):
wrapper, f = self._default_update()
self.assertEqual(wrapper.__doc__, 'This is a test')
def test_no_update(self):
def f():
"""This is a test"""
pass
f.attr = 'This is also a test'
def wrapper():
pass
functools.update_wrapper(wrapper, f, (), ())
self.check_wrapper(wrapper, f, (), ())
self.assertEqual(wrapper.__name__, 'wrapper')
self.assertNotEqual(wrapper.__qualname__, f.__qualname__)
self.assertEqual(wrapper.__doc__, None)
self.assertEqual(wrapper.__annotations__, {})
self.assertFalse(hasattr(wrapper, 'attr'))
def test_selective_update(self):
def f():
pass
f.attr = 'This is a different test'
f.dict_attr = dict(a=1, b=2, c=3)
def wrapper():
pass
wrapper.dict_attr = {}
assign = ('attr',)
update = ('dict_attr',)
functools.update_wrapper(wrapper, f, assign, update)
self.check_wrapper(wrapper, f, assign, update)
self.assertEqual(wrapper.__name__, 'wrapper')
self.assertNotEqual(wrapper.__qualname__, f.__qualname__)
self.assertEqual(wrapper.__doc__, None)
self.assertEqual(wrapper.attr, 'This is a different test')
self.assertEqual(wrapper.dict_attr, f.dict_attr)
def test_missing_attributes(self):
def f():
pass
def wrapper():
pass
wrapper.dict_attr = {}
assign = ('attr',)
update = ('dict_attr',)
# Missing attributes on wrapped object are ignored
functools.update_wrapper(wrapper, f, assign, update)
self.assertNotIn('attr', wrapper.__dict__)
self.assertEqual(wrapper.dict_attr, {})
# Wrapper must have expected attributes for updating
del wrapper.dict_attr
with self.assertRaises(AttributeError):
functools.update_wrapper(wrapper, f, assign, update)
wrapper.dict_attr = 1
with self.assertRaises(AttributeError):
functools.update_wrapper(wrapper, f, assign, update)
@support.requires_docstrings
@unittest.skipIf(sys.flags.optimize >= 2,
"Docstrings are omitted with -O2 and above")
def test_builtin_update(self):
# Test for bug #1576241
def wrapper():
pass
functools.update_wrapper(wrapper, max)
self.assertEqual(wrapper.__name__, 'max')
self.assertTrue(wrapper.__doc__.startswith('max('))
self.assertEqual(wrapper.__annotations__, {})
class TestWraps(TestUpdateWrapper):
def _default_update(self):
def f():
"""This is a test"""
pass
f.attr = 'This is also a test'
f.__wrapped__ = "This is still a bald faced lie"
@functools.wraps(f)
def wrapper():
pass
return wrapper, f
def test_default_update(self):
wrapper, f = self._default_update()
self.check_wrapper(wrapper, f)
self.assertEqual(wrapper.__name__, 'f')
self.assertEqual(wrapper.__qualname__, f.__qualname__)
self.assertEqual(wrapper.attr, 'This is also a test')
@unittest.skipIf(sys.flags.optimize >= 2,
"Docstrings are omitted with -O2 and above")
def test_default_update_doc(self):
wrapper, _ = self._default_update()
self.assertEqual(wrapper.__doc__, 'This is a test')
def test_no_update(self):
def f():
"""This is a test"""
pass
f.attr = 'This is also a test'
@functools.wraps(f, (), ())
def wrapper():
pass
self.check_wrapper(wrapper, f, (), ())
self.assertEqual(wrapper.__name__, 'wrapper')
self.assertNotEqual(wrapper.__qualname__, f.__qualname__)
self.assertEqual(wrapper.__doc__, None)
self.assertFalse(hasattr(wrapper, 'attr'))
def test_selective_update(self):
def f():
pass
f.attr = 'This is a different test'
f.dict_attr = dict(a=1, b=2, c=3)
def add_dict_attr(f):
f.dict_attr = {}
return f
assign = ('attr',)
update = ('dict_attr',)
@functools.wraps(f, assign, update)
@add_dict_attr
def wrapper():
pass
self.check_wrapper(wrapper, f, assign, update)
self.assertEqual(wrapper.__name__, 'wrapper')
self.assertNotEqual(wrapper.__qualname__, f.__qualname__)
self.assertEqual(wrapper.__doc__, None)
self.assertEqual(wrapper.attr, 'This is a different test')
self.assertEqual(wrapper.dict_attr, f.dict_attr)
class TestReduce:
def test_reduce(self):
class Squares:
def __init__(self, max):
self.max = max
self.sofar = []
def __len__(self):
return len(self.sofar)
def __getitem__(self, i):
if not 0 <= i < self.max: raise IndexError
n = len(self.sofar)
while n <= i:
self.sofar.append(n*n)
n += 1
return self.sofar[i]
def add(x, y):
return x + y
self.assertEqual(self.reduce(add, ['a', 'b', 'c'], ''), 'abc')
self.assertEqual(
self.reduce(add, [['a', 'c'], [], ['d', 'w']], []),
['a','c','d','w']
)
self.assertEqual(self.reduce(lambda x, y: x*y, range(2,8), 1), 5040)
self.assertEqual(
self.reduce(lambda x, y: x*y, range(2,21), 1),
2432902008176640000
)
self.assertEqual(self.reduce(add, Squares(10)), 285)
self.assertEqual(self.reduce(add, Squares(10), 0), 285)
self.assertEqual(self.reduce(add, Squares(0), 0), 0)
self.assertRaises(TypeError, self.reduce)
self.assertRaises(TypeError, self.reduce, 42, 42)
self.assertRaises(TypeError, self.reduce, 42, 42, 42)
self.assertEqual(self.reduce(42, "1"), "1") # func is never called with one item
self.assertEqual(self.reduce(42, "", "1"), "1") # func is never called with one item
self.assertRaises(TypeError, self.reduce, 42, (42, 42))
self.assertRaises(TypeError, self.reduce, add, []) # arg 2 must not be empty sequence with no initial value
self.assertRaises(TypeError, self.reduce, add, "")
self.assertRaises(TypeError, self.reduce, add, ())
self.assertRaises(TypeError, self.reduce, add, object())
class TestFailingIter:
def __iter__(self):
raise RuntimeError
self.assertRaises(RuntimeError, self.reduce, add, TestFailingIter())
self.assertEqual(self.reduce(add, [], None), None)
self.assertEqual(self.reduce(add, [], 42), 42)
class BadSeq:
def __getitem__(self, index):
raise ValueError
self.assertRaises(ValueError, self.reduce, 42, BadSeq())
# Test reduce()'s use of iterators.
def test_iterator_usage(self):
class SequenceClass:
def __init__(self, n):
self.n = n
def __getitem__(self, i):
if 0 <= i < self.n:
return i
else:
raise IndexError
from operator import add
self.assertEqual(self.reduce(add, SequenceClass(5)), 10)
self.assertEqual(self.reduce(add, SequenceClass(5), 42), 52)
self.assertRaises(TypeError, self.reduce, add, SequenceClass(0))
self.assertEqual(self.reduce(add, SequenceClass(0), 42), 42)
self.assertEqual(self.reduce(add, SequenceClass(1)), 0)
self.assertEqual(self.reduce(add, SequenceClass(1), 42), 42)
d = {"one": 1, "two": 2, "three": 3}
self.assertEqual(self.reduce(add, d), "".join(d.keys()))
@unittest.skipUnless(c_functools, 'requires the C _functools module')
class TestReduceC(TestReduce, unittest.TestCase):
if c_functools:
reduce = c_functools.reduce
class TestReducePy(TestReduce, unittest.TestCase):
reduce = staticmethod(py_functools.reduce)
class TestCmpToKey:
def test_cmp_to_key(self):
def cmp1(x, y):
return (x > y) - (x < y)
key = self.cmp_to_key(cmp1)
self.assertEqual(key(3), key(3))
self.assertGreater(key(3), key(1))
self.assertGreaterEqual(key(3), key(3))
def cmp2(x, y):
return int(x) - int(y)
key = self.cmp_to_key(cmp2)
self.assertEqual(key(4.0), key('4'))
self.assertLess(key(2), key('35'))
self.assertLessEqual(key(2), key('35'))
self.assertNotEqual(key(2), key('35'))
def test_cmp_to_key_arguments(self):
def cmp1(x, y):
return (x > y) - (x < y)
key = self.cmp_to_key(mycmp=cmp1)
self.assertEqual(key(obj=3), key(obj=3))
self.assertGreater(key(obj=3), key(obj=1))
with self.assertRaises((TypeError, AttributeError)):
key(3) > 1 # rhs is not a K object
with self.assertRaises((TypeError, AttributeError)):
1 < key(3) # lhs is not a K object
with self.assertRaises(TypeError):
key = self.cmp_to_key() # too few args
with self.assertRaises(TypeError):
key = self.cmp_to_key(cmp1, None) # too many args
key = self.cmp_to_key(cmp1)
with self.assertRaises(TypeError):
key() # too few args
with self.assertRaises(TypeError):
key(None, None) # too many args
def test_bad_cmp(self):
def cmp1(x, y):
raise ZeroDivisionError
key = self.cmp_to_key(cmp1)
with self.assertRaises(ZeroDivisionError):
key(3) > key(1)
class BadCmp:
def __lt__(self, other):
raise ZeroDivisionError
def cmp1(x, y):
return BadCmp()
with self.assertRaises(ZeroDivisionError):
key(3) > key(1)
def test_obj_field(self):
def cmp1(x, y):
return (x > y) - (x < y)
key = self.cmp_to_key(mycmp=cmp1)
self.assertEqual(key(50).obj, 50)
def test_sort_int(self):
def mycmp(x, y):
return y - x
self.assertEqual(sorted(range(5), key=self.cmp_to_key(mycmp)),
[4, 3, 2, 1, 0])
def test_sort_int_str(self):
def mycmp(x, y):
x, y = int(x), int(y)
return (x > y) - (x < y)
values = [5, '3', 7, 2, '0', '1', 4, '10', 1]
values = sorted(values, key=self.cmp_to_key(mycmp))
self.assertEqual([int(value) for value in values],
[0, 1, 1, 2, 3, 4, 5, 7, 10])
def test_hash(self):
def mycmp(x, y):
return y - x
key = self.cmp_to_key(mycmp)
k = key(10)
self.assertRaises(TypeError, hash, k)
self.assertNotIsInstance(k, collections.abc.Hashable)
@unittest.skipUnless(c_functools, 'requires the C _functools module')
class TestCmpToKeyC(TestCmpToKey, unittest.TestCase):
if c_functools:
cmp_to_key = c_functools.cmp_to_key
class TestCmpToKeyPy(TestCmpToKey, unittest.TestCase):
cmp_to_key = staticmethod(py_functools.cmp_to_key)
class TestTotalOrdering(unittest.TestCase):
def test_total_ordering_lt(self):
@functools.total_ordering
class A:
def __init__(self, value):
self.value = value
def __lt__(self, other):
return self.value < other.value
def __eq__(self, other):
return self.value == other.value
self.assertTrue(A(1) < A(2))
self.assertTrue(A(2) > A(1))
self.assertTrue(A(1) <= A(2))
self.assertTrue(A(2) >= A(1))
self.assertTrue(A(2) <= A(2))
self.assertTrue(A(2) >= A(2))
self.assertFalse(A(1) > A(2))
def test_total_ordering_le(self):
@functools.total_ordering
class A:
def __init__(self, value):
self.value = value
def __le__(self, other):
return self.value <= other.value
def __eq__(self, other):
return self.value == other.value
self.assertTrue(A(1) < A(2))
self.assertTrue(A(2) > A(1))
self.assertTrue(A(1) <= A(2))
self.assertTrue(A(2) >= A(1))
self.assertTrue(A(2) <= A(2))
self.assertTrue(A(2) >= A(2))
self.assertFalse(A(1) >= A(2))
def test_total_ordering_gt(self):
@functools.total_ordering
class A:
def __init__(self, value):
self.value = value
def __gt__(self, other):
return self.value > other.value
def __eq__(self, other):
return self.value == other.value
self.assertTrue(A(1) < A(2))
self.assertTrue(A(2) > A(1))
self.assertTrue(A(1) <= A(2))
self.assertTrue(A(2) >= A(1))
self.assertTrue(A(2) <= A(2))
self.assertTrue(A(2) >= A(2))
self.assertFalse(A(2) < A(1))
def test_total_ordering_ge(self):
@functools.total_ordering
class A:
def __init__(self, value):
self.value = value
def __ge__(self, other):
return self.value >= other.value
def __eq__(self, other):
return self.value == other.value
self.assertTrue(A(1) < A(2))
self.assertTrue(A(2) > A(1))
self.assertTrue(A(1) <= A(2))
self.assertTrue(A(2) >= A(1))
self.assertTrue(A(2) <= A(2))
self.assertTrue(A(2) >= A(2))
self.assertFalse(A(2) <= A(1))
def test_total_ordering_no_overwrite(self):
# new methods should not overwrite existing
@functools.total_ordering
class A(int):
pass
self.assertTrue(A(1) < A(2))
self.assertTrue(A(2) > A(1))
self.assertTrue(A(1) <= A(2))
self.assertTrue(A(2) >= A(1))
self.assertTrue(A(2) <= A(2))
self.assertTrue(A(2) >= A(2))
def test_no_operations_defined(self):
with self.assertRaises(ValueError):
@functools.total_ordering
class A:
pass
def test_type_error_when_not_implemented(self):
# bug 10042; ensure stack overflow does not occur
# when decorated types return NotImplemented
@functools.total_ordering
class ImplementsLessThan:
def __init__(self, value):
self.value = value
def __eq__(self, other):
if isinstance(other, ImplementsLessThan):
return self.value == other.value
return False
def __lt__(self, other):
if isinstance(other, ImplementsLessThan):
return self.value < other.value
return NotImplemented
@functools.total_ordering
class ImplementsGreaterThan:
def __init__(self, value):
self.value = value
def __eq__(self, other):
if isinstance(other, ImplementsGreaterThan):
return self.value == other.value
return False
def __gt__(self, other):
if isinstance(other, ImplementsGreaterThan):
return self.value > other.value
return NotImplemented
@functools.total_ordering
class ImplementsLessThanEqualTo:
def __init__(self, value):
self.value = value
def __eq__(self, other):
if isinstance(other, ImplementsLessThanEqualTo):
return self.value == other.value
return False
def __le__(self, other):
if isinstance(other, ImplementsLessThanEqualTo):
return self.value <= other.value
return NotImplemented
@functools.total_ordering
class ImplementsGreaterThanEqualTo:
def __init__(self, value):
self.value = value
def __eq__(self, other):
if isinstance(other, ImplementsGreaterThanEqualTo):
return self.value == other.value
return False
def __ge__(self, other):
if isinstance(other, ImplementsGreaterThanEqualTo):
return self.value >= other.value
return NotImplemented
@functools.total_ordering
class ComparatorNotImplemented:
def __init__(self, value):
self.value = value
def __eq__(self, other):
if isinstance(other, ComparatorNotImplemented):
return self.value == other.value
return False
def __lt__(self, other):
return NotImplemented
with self.subTest("LT < 1"), self.assertRaises(TypeError):
ImplementsLessThan(-1) < 1
with self.subTest("LT < LE"), self.assertRaises(TypeError):
ImplementsLessThan(0) < ImplementsLessThanEqualTo(0)
with self.subTest("LT < GT"), self.assertRaises(TypeError):
ImplementsLessThan(1) < ImplementsGreaterThan(1)
with self.subTest("LE <= LT"), self.assertRaises(TypeError):
ImplementsLessThanEqualTo(2) <= ImplementsLessThan(2)
with self.subTest("LE <= GE"), self.assertRaises(TypeError):
ImplementsLessThanEqualTo(3) <= ImplementsGreaterThanEqualTo(3)
with self.subTest("GT > GE"), self.assertRaises(TypeError):
ImplementsGreaterThan(4) > ImplementsGreaterThanEqualTo(4)
with self.subTest("GT > LT"), self.assertRaises(TypeError):
ImplementsGreaterThan(5) > ImplementsLessThan(5)
with self.subTest("GE >= GT"), self.assertRaises(TypeError):
ImplementsGreaterThanEqualTo(6) >= ImplementsGreaterThan(6)
with self.subTest("GE >= LE"), self.assertRaises(TypeError):
ImplementsGreaterThanEqualTo(7) >= ImplementsLessThanEqualTo(7)
with self.subTest("GE when equal"):
a = ComparatorNotImplemented(8)
b = ComparatorNotImplemented(8)
self.assertEqual(a, b)
with self.assertRaises(TypeError):
a >= b
with self.subTest("LE when equal"):
a = ComparatorNotImplemented(9)
b = ComparatorNotImplemented(9)
self.assertEqual(a, b)
with self.assertRaises(TypeError):
a <= b
def test_pickle(self):
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
for name in '__lt__', '__gt__', '__le__', '__ge__':
with self.subTest(method=name, proto=proto):
method = getattr(Orderable_LT, name)
method_copy = pickle.loads(pickle.dumps(method, proto))
self.assertIs(method_copy, method)
@functools.total_ordering
class Orderable_LT:
def __init__(self, value):
self.value = value
def __lt__(self, other):
return self.value < other.value
def __eq__(self, other):
return self.value == other.value
class TestLRU:
def test_lru(self):
def orig(x, y):
return 3 * x + y
f = self.module.lru_cache(maxsize=20)(orig)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(maxsize, 20)
self.assertEqual(currsize, 0)
self.assertEqual(hits, 0)
self.assertEqual(misses, 0)
domain = range(5)
for i in range(1000):
x, y = choice(domain), choice(domain)
actual = f(x, y)
expected = orig(x, y)
self.assertEqual(actual, expected)
hits, misses, maxsize, currsize = f.cache_info()
self.assertTrue(hits > misses)
self.assertEqual(hits + misses, 1000)
self.assertEqual(currsize, 20)
f.cache_clear() # test clearing
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(hits, 0)
self.assertEqual(misses, 0)
self.assertEqual(currsize, 0)
f(x, y)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(hits, 0)
self.assertEqual(misses, 1)
self.assertEqual(currsize, 1)
# Test bypassing the cache
self.assertIs(f.__wrapped__, orig)
f.__wrapped__(x, y)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(hits, 0)
self.assertEqual(misses, 1)
self.assertEqual(currsize, 1)
# test size zero (which means "never-cache")
@self.module.lru_cache(0)
def f():
nonlocal f_cnt
f_cnt += 1
return 20
self.assertEqual(f.cache_info().maxsize, 0)
f_cnt = 0
for i in range(5):
self.assertEqual(f(), 20)
self.assertEqual(f_cnt, 5)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(hits, 0)
self.assertEqual(misses, 5)
self.assertEqual(currsize, 0)
# test size one
@self.module.lru_cache(1)
def f():
nonlocal f_cnt
f_cnt += 1
return 20
self.assertEqual(f.cache_info().maxsize, 1)
f_cnt = 0
for i in range(5):
self.assertEqual(f(), 20)
self.assertEqual(f_cnt, 1)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(hits, 4)
self.assertEqual(misses, 1)
self.assertEqual(currsize, 1)
# test size two
@self.module.lru_cache(2)
def f(x):
nonlocal f_cnt
f_cnt += 1
return x*10
self.assertEqual(f.cache_info().maxsize, 2)
f_cnt = 0
for x in 7, 9, 7, 9, 7, 9, 8, 8, 8, 9, 9, 9, 8, 8, 8, 7:
# * * * *
self.assertEqual(f(x), x*10)
self.assertEqual(f_cnt, 4)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(hits, 12)
self.assertEqual(misses, 4)
self.assertEqual(currsize, 2)
def test_lru_no_args(self):
@self.module.lru_cache
def square(x):
return x ** 2
self.assertEqual(list(map(square, [10, 20, 10])),
[100, 400, 100])
self.assertEqual(square.cache_info().hits, 1)
self.assertEqual(square.cache_info().misses, 2)
self.assertEqual(square.cache_info().maxsize, 128)
self.assertEqual(square.cache_info().currsize, 2)
def test_lru_bug_35780(self):
# C version of the lru_cache was not checking to see if
# the user function call has already modified the cache
# (this arises in recursive calls and in multi-threading).
# This cause the cache to have orphan links not referenced
# by the cache dictionary.
once = True # Modified by f(x) below
@self.module.lru_cache(maxsize=10)
def f(x):
nonlocal once
rv = f'.{x}.'
if x == 20 and once:
once = False
rv = f(x)
return rv
# Fill the cache
for x in range(15):
self.assertEqual(f(x), f'.{x}.')
self.assertEqual(f.cache_info().currsize, 10)
# Make a recursive call and make sure the cache remains full
self.assertEqual(f(20), '.20.')
self.assertEqual(f.cache_info().currsize, 10)
def test_lru_bug_36650(self):
# C version of lru_cache was treating a call with an empty **kwargs
# dictionary as being distinct from a call with no keywords at all.
# This did not result in an incorrect answer, but it did trigger
# an unexpected cache miss.
@self.module.lru_cache()
def f(x):
pass
f(0)
f(0, **{})
self.assertEqual(f.cache_info().hits, 1)
def test_lru_hash_only_once(self):
# To protect against weird reentrancy bugs and to improve
# efficiency when faced with slow __hash__ methods, the
# LRU cache guarantees that it will only call __hash__
# only once per use as an argument to the cached function.
@self.module.lru_cache(maxsize=1)
def f(x, y):
return x * 3 + y
# Simulate the integer 5
mock_int = unittest.mock.Mock()
mock_int.__mul__ = unittest.mock.Mock(return_value=15)
mock_int.__hash__ = unittest.mock.Mock(return_value=999)
# Add to cache: One use as an argument gives one call
self.assertEqual(f(mock_int, 1), 16)
self.assertEqual(mock_int.__hash__.call_count, 1)
self.assertEqual(f.cache_info(), (0, 1, 1, 1))
# Cache hit: One use as an argument gives one additional call
self.assertEqual(f(mock_int, 1), 16)
self.assertEqual(mock_int.__hash__.call_count, 2)
self.assertEqual(f.cache_info(), (1, 1, 1, 1))
# Cache eviction: No use as an argument gives no additional call
self.assertEqual(f(6, 2), 20)
self.assertEqual(mock_int.__hash__.call_count, 2)
self.assertEqual(f.cache_info(), (1, 2, 1, 1))
# Cache miss: One use as an argument gives one additional call
self.assertEqual(f(mock_int, 1), 16)
self.assertEqual(mock_int.__hash__.call_count, 3)
self.assertEqual(f.cache_info(), (1, 3, 1, 1))
def test_lru_reentrancy_with_len(self):
# Test to make sure the LRU cache code isn't thrown-off by
# caching the built-in len() function. Since len() can be
# cached, we shouldn't use it inside the lru code itself.
old_len = builtins.len
try:
builtins.len = self.module.lru_cache(4)(len)
for i in [0, 0, 1, 2, 3, 3, 4, 5, 6, 1, 7, 2, 1]:
self.assertEqual(len('abcdefghijklmn'[:i]), i)
finally:
builtins.len = old_len
def test_lru_star_arg_handling(self):
# Test regression that arose in ea064ff3c10f
@functools.lru_cache()
def f(*args):
return args
self.assertEqual(f(1, 2), (1, 2))
self.assertEqual(f((1, 2)), ((1, 2),))
def test_lru_type_error(self):
# Regression test for issue #28653.
# lru_cache was leaking when one of the arguments
# wasn't cacheable.
@functools.lru_cache(maxsize=None)
def infinite_cache(o):
pass
@functools.lru_cache(maxsize=10)
def limited_cache(o):
pass
with self.assertRaises(TypeError):
infinite_cache([])
with self.assertRaises(TypeError):
limited_cache([])
def test_lru_with_maxsize_none(self):
@self.module.lru_cache(maxsize=None)
def fib(n):
if n < 2:
return n
return fib(n-1) + fib(n-2)
self.assertEqual([fib(n) for n in range(16)],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610])
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=28, misses=16, maxsize=None, currsize=16))
fib.cache_clear()
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=0, misses=0, maxsize=None, currsize=0))
def test_lru_with_maxsize_negative(self):
@self.module.lru_cache(maxsize=-10)
def eq(n):
return n
for i in (0, 1):
self.assertEqual([eq(n) for n in range(150)], list(range(150)))
self.assertEqual(eq.cache_info(),
self.module._CacheInfo(hits=0, misses=300, maxsize=0, currsize=0))
def test_lru_with_exceptions(self):
# Verify that user_function exceptions get passed through without
# creating a hard-to-read chained exception.
# http://bugs.python.org/issue13177
for maxsize in (None, 128):
@self.module.lru_cache(maxsize)
def func(i):
return 'abc'[i]
self.assertEqual(func(0), 'a')
with self.assertRaises(IndexError) as cm:
func(15)
self.assertIsNone(cm.exception.__context__)
# Verify that the previous exception did not result in a cached entry
with self.assertRaises(IndexError):
func(15)
def test_lru_with_types(self):
for maxsize in (None, 128):
@self.module.lru_cache(maxsize=maxsize, typed=True)
def square(x):
return x * x
self.assertEqual(square(3), 9)
self.assertEqual(type(square(3)), type(9))
self.assertEqual(square(3.0), 9.0)
self.assertEqual(type(square(3.0)), type(9.0))
self.assertEqual(square(x=3), 9)
self.assertEqual(type(square(x=3)), type(9))
self.assertEqual(square(x=3.0), 9.0)
self.assertEqual(type(square(x=3.0)), type(9.0))
self.assertEqual(square.cache_info().hits, 4)
self.assertEqual(square.cache_info().misses, 4)
def test_lru_with_keyword_args(self):
@self.module.lru_cache()
def fib(n):
if n < 2:
return n
return fib(n=n-1) + fib(n=n-2)
self.assertEqual(
[fib(n=number) for number in range(16)],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]
)
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=28, misses=16, maxsize=128, currsize=16))
fib.cache_clear()
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=0, misses=0, maxsize=128, currsize=0))
def test_lru_with_keyword_args_maxsize_none(self):
@self.module.lru_cache(maxsize=None)
def fib(n):
if n < 2:
return n
return fib(n=n-1) + fib(n=n-2)
self.assertEqual([fib(n=number) for number in range(16)],
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610])
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=28, misses=16, maxsize=None, currsize=16))
fib.cache_clear()
self.assertEqual(fib.cache_info(),
self.module._CacheInfo(hits=0, misses=0, maxsize=None, currsize=0))
def test_kwargs_order(self):
# PEP 468: Preserving Keyword Argument Order
@self.module.lru_cache(maxsize=10)
def f(**kwargs):
return list(kwargs.items())
self.assertEqual(f(a=1, b=2), [('a', 1), ('b', 2)])
self.assertEqual(f(b=2, a=1), [('b', 2), ('a', 1)])
self.assertEqual(f.cache_info(),
self.module._CacheInfo(hits=0, misses=2, maxsize=10, currsize=2))
def test_lru_cache_decoration(self):
def f(zomg: 'zomg_annotation'):
"""f doc string"""
return 42
g = self.module.lru_cache()(f)
for attr in self.module.WRAPPER_ASSIGNMENTS:
self.assertEqual(getattr(g, attr), getattr(f, attr))
def test_lru_cache_threaded(self):
n, m = 5, 11
def orig(x, y):
return 3 * x + y
f = self.module.lru_cache(maxsize=n*m)(orig)
hits, misses, maxsize, currsize = f.cache_info()
self.assertEqual(currsize, 0)
start = threading.Event()
def full(k):
start.wait(10)
for _ in range(m):
self.assertEqual(f(k, 0), orig(k, 0))
def clear():
start.wait(10)
for _ in range(2*m):
f.cache_clear()
orig_si = sys.getswitchinterval()
support.setswitchinterval(1e-6)
try:
# create n threads in order to fill cache
threads = [threading.Thread(target=full, args=[k])
for k in range(n)]
with support.start_threads(threads):
start.set()
hits, misses, maxsize, currsize = f.cache_info()
if self.module is py_functools:
# XXX: Why can be not equal?
self.assertLessEqual(misses, n)
self.assertLessEqual(hits, m*n - misses)
else:
self.assertEqual(misses, n)
self.assertEqual(hits, m*n - misses)
self.assertEqual(currsize, n)
# create n threads in order to fill cache and 1 to clear it
threads = [threading.Thread(target=clear)]
threads += [threading.Thread(target=full, args=[k])
for k in range(n)]
start.clear()
with support.start_threads(threads):
start.set()
finally:
sys.setswitchinterval(orig_si)
def test_lru_cache_threaded2(self):
# Simultaneous call with the same arguments
n, m = 5, 7
start = threading.Barrier(n+1)
pause = threading.Barrier(n+1)
stop = threading.Barrier(n+1)
@self.module.lru_cache(maxsize=m*n)
def f(x):
pause.wait(10)
return 3 * x
self.assertEqual(f.cache_info(), (0, 0, m*n, 0))
def test():
for i in range(m):
start.wait(10)
self.assertEqual(f(i), 3 * i)
stop.wait(10)
threads = [threading.Thread(target=test) for k in range(n)]
with support.start_threads(threads):
for i in range(m):
start.wait(10)
stop.reset()
pause.wait(10)
start.reset()
stop.wait(10)
pause.reset()
self.assertEqual(f.cache_info(), (0, (i+1)*n, m*n, i+1))
def test_lru_cache_threaded3(self):
@self.module.lru_cache(maxsize=2)
def f(x):
time.sleep(.01)
return 3 * x
def test(i, x):
with self.subTest(thread=i):
self.assertEqual(f(x), 3 * x, i)
threads = [threading.Thread(target=test, args=(i, v))
for i, v in enumerate([1, 2, 2, 3, 2])]
with support.start_threads(threads):
pass
def test_need_for_rlock(self):
# This will deadlock on an LRU cache that uses a regular lock
@self.module.lru_cache(maxsize=10)
def test_func(x):
'Used to demonstrate a reentrant lru_cache call within a single thread'
return x
class DoubleEq:
'Demonstrate a reentrant lru_cache call within a single thread'
def __init__(self, x):
self.x = x
def __hash__(self):
return self.x
def __eq__(self, other):
if self.x == 2:
test_func(DoubleEq(1))
return self.x == other.x
test_func(DoubleEq(1)) # Load the cache
test_func(DoubleEq(2)) # Load the cache
self.assertEqual(test_func(DoubleEq(2)), # Trigger a re-entrant __eq__ call
DoubleEq(2)) # Verify the correct return value
def test_lru_method(self):
class X(int):
f_cnt = 0
@self.module.lru_cache(2)
def f(self, x):
self.f_cnt += 1
return x*10+self
a = X(5)
b = X(5)
c = X(7)
self.assertEqual(X.f.cache_info(), (0, 0, 2, 0))
for x in 1, 2, 2, 3, 1, 1, 1, 2, 3, 3:
self.assertEqual(a.f(x), x*10 + 5)
self.assertEqual((a.f_cnt, b.f_cnt, c.f_cnt), (6, 0, 0))
self.assertEqual(X.f.cache_info(), (4, 6, 2, 2))
for x in 1, 2, 1, 1, 1, 1, 3, 2, 2, 2:
self.assertEqual(b.f(x), x*10 + 5)
self.assertEqual((a.f_cnt, b.f_cnt, c.f_cnt), (6, 4, 0))
self.assertEqual(X.f.cache_info(), (10, 10, 2, 2))
for x in 2, 1, 1, 1, 1, 2, 1, 3, 2, 1:
self.assertEqual(c.f(x), x*10 + 7)
self.assertEqual((a.f_cnt, b.f_cnt, c.f_cnt), (6, 4, 5))
self.assertEqual(X.f.cache_info(), (15, 15, 2, 2))
self.assertEqual(a.f.cache_info(), X.f.cache_info())
self.assertEqual(b.f.cache_info(), X.f.cache_info())
self.assertEqual(c.f.cache_info(), X.f.cache_info())
def test_pickle(self):
cls = self.__class__
for f in cls.cached_func[0], cls.cached_meth, cls.cached_staticmeth:
for proto in range(pickle.HIGHEST_PROTOCOL + 1):
with self.subTest(proto=proto, func=f):
f_copy = pickle.loads(pickle.dumps(f, proto))
self.assertIs(f_copy, f)
def test_copy(self):
cls = self.__class__
def orig(x, y):
return 3 * x + y
part = self.module.partial(orig, 2)
funcs = (cls.cached_func[0], cls.cached_meth, cls.cached_staticmeth,
self.module.lru_cache(2)(part))
for f in funcs:
with self.subTest(func=f):
f_copy = copy.copy(f)
self.assertIs(f_copy, f)
def test_deepcopy(self):
cls = self.__class__
def orig(x, y):
return 3 * x + y
part = self.module.partial(orig, 2)
funcs = (cls.cached_func[0], cls.cached_meth, cls.cached_staticmeth,
self.module.lru_cache(2)(part))
for f in funcs:
with self.subTest(func=f):
f_copy = copy.deepcopy(f)
self.assertIs(f_copy, f)
def test_lru_cache_parameters(self):
@self.module.lru_cache(maxsize=2)
def f():
return 1
self.assertEqual(f.cache_parameters(), {'maxsize': 2, "typed": False})
@self.module.lru_cache(maxsize=1000, typed=True)
def f():
return 1
self.assertEqual(f.cache_parameters(), {'maxsize': 1000, "typed": True})
@py_functools.lru_cache()
def py_cached_func(x, y):
return 3 * x + y
@c_functools.lru_cache()
def c_cached_func(x, y):
return 3 * x + y
class TestLRUPy(TestLRU, unittest.TestCase):
module = py_functools
cached_func = py_cached_func,
@module.lru_cache()
def cached_meth(self, x, y):
return 3 * x + y
@staticmethod
@module.lru_cache()
def cached_staticmeth(x, y):
return 3 * x + y
class TestLRUC(TestLRU, unittest.TestCase):
module = c_functools
cached_func = c_cached_func,
@module.lru_cache()
def cached_meth(self, x, y):
return 3 * x + y
@staticmethod
@module.lru_cache()
def cached_staticmeth(x, y):
return 3 * x + y
class TestSingleDispatch(unittest.TestCase):
def test_simple_overloads(self):
@functools.singledispatch
def g(obj):
return "base"
def g_int(i):
return "integer"
g.register(int, g_int)
self.assertEqual(g("str"), "base")
self.assertEqual(g(1), "integer")
self.assertEqual(g([1,2,3]), "base")
def test_mro(self):
@functools.singledispatch
def g(obj):
return "base"
class A:
pass
class C(A):
pass
class B(A):
pass
class D(C, B):
pass
def g_A(a):
return "A"
def g_B(b):
return "B"
g.register(A, g_A)
g.register(B, g_B)
self.assertEqual(g(A()), "A")
self.assertEqual(g(B()), "B")
self.assertEqual(g(C()), "A")
self.assertEqual(g(D()), "B")
def test_register_decorator(self):
@functools.singledispatch
def g(obj):
return "base"
@g.register(int)
def g_int(i):
return "int %s" % (i,)
self.assertEqual(g(""), "base")
self.assertEqual(g(12), "int 12")
self.assertIs(g.dispatch(int), g_int)
self.assertIs(g.dispatch(object), g.dispatch(str))
# Note: in the assert above this is not g.
# @singledispatch returns the wrapper.
def test_wrapping_attributes(self):
@functools.singledispatch
def g(obj):
"Simple test"
return "Test"
self.assertEqual(g.__name__, "g")
if sys.flags.optimize < 2:
self.assertEqual(g.__doc__, "Simple test")
@unittest.skipUnless(decimal, 'requires _decimal')
@support.cpython_only
def test_c_classes(self):
@functools.singledispatch
def g(obj):
return "base"
@g.register(decimal.DecimalException)
def _(obj):
return obj.args
subn = decimal.Subnormal("Exponent < Emin")
rnd = decimal.Rounded("Number got rounded")
self.assertEqual(g(subn), ("Exponent < Emin",))
self.assertEqual(g(rnd), ("Number got rounded",))
@g.register(decimal.Subnormal)
def _(obj):
return "Too small to care."
self.assertEqual(g(subn), "Too small to care.")
self.assertEqual(g(rnd), ("Number got rounded",))
def test_compose_mro(self):
# None of the examples in this test depend on haystack ordering.
c = collections.abc
mro = functools._compose_mro
bases = [c.Sequence, c.MutableMapping, c.Mapping, c.Set]
for haystack in permutations(bases):
m = mro(dict, haystack)
self.assertEqual(m, [dict, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable,
c.Container, object])
bases = [c.Container, c.Mapping, c.MutableMapping, collections.OrderedDict]
for haystack in permutations(bases):
m = mro(collections.ChainMap, haystack)
self.assertEqual(m, [collections.ChainMap, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable,
c.Container, object])
# If there's a generic function with implementations registered for
# both Sized and Container, passing a defaultdict to it results in an
# ambiguous dispatch which will cause a RuntimeError (see
# test_mro_conflicts).
bases = [c.Container, c.Sized, str]
for haystack in permutations(bases):
m = mro(collections.defaultdict, [c.Sized, c.Container, str])
self.assertEqual(m, [collections.defaultdict, dict, c.Sized,
c.Container, object])
# MutableSequence below is registered directly on D. In other words, it
# precedes MutableMapping which means single dispatch will always
# choose MutableSequence here.
class D(collections.defaultdict):
pass
c.MutableSequence.register(D)
bases = [c.MutableSequence, c.MutableMapping]
for haystack in permutations(bases):
m = mro(D, bases)
self.assertEqual(m, [D, c.MutableSequence, c.Sequence, c.Reversible,
collections.defaultdict, dict, c.MutableMapping, c.Mapping,
c.Collection, c.Sized, c.Iterable, c.Container,
object])
# Container and Callable are registered on different base classes and
# a generic function supporting both should always pick the Callable
# implementation if a C instance is passed.
class C(collections.defaultdict):
def __call__(self):
pass
bases = [c.Sized, c.Callable, c.Container, c.Mapping]
for haystack in permutations(bases):
m = mro(C, haystack)
self.assertEqual(m, [C, c.Callable, collections.defaultdict, dict, c.Mapping,
c.Collection, c.Sized, c.Iterable,
c.Container, object])
def test_register_abc(self):
c = collections.abc
d = {"a": "b"}
l = [1, 2, 3]
s = {object(), None}
f = frozenset(s)
t = (1, 2, 3)
@functools.singledispatch
def g(obj):
return "base"
self.assertEqual(g(d), "base")
self.assertEqual(g(l), "base")
self.assertEqual(g(s), "base")
self.assertEqual(g(f), "base")
self.assertEqual(g(t), "base")
g.register(c.Sized, lambda obj: "sized")
self.assertEqual(g(d), "sized")
self.assertEqual(g(l), "sized")
self.assertEqual(g(s), "sized")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized")
g.register(c.MutableMapping, lambda obj: "mutablemapping")
self.assertEqual(g(d), "mutablemapping")
self.assertEqual(g(l), "sized")
self.assertEqual(g(s), "sized")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized")
g.register(collections.ChainMap, lambda obj: "chainmap")
self.assertEqual(g(d), "mutablemapping") # irrelevant ABCs registered
self.assertEqual(g(l), "sized")
self.assertEqual(g(s), "sized")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized")
g.register(c.MutableSequence, lambda obj: "mutablesequence")
self.assertEqual(g(d), "mutablemapping")
self.assertEqual(g(l), "mutablesequence")
self.assertEqual(g(s), "sized")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized")
g.register(c.MutableSet, lambda obj: "mutableset")
self.assertEqual(g(d), "mutablemapping")
self.assertEqual(g(l), "mutablesequence")
self.assertEqual(g(s), "mutableset")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized")
g.register(c.Mapping, lambda obj: "mapping")
self.assertEqual(g(d), "mutablemapping") # not specific enough
self.assertEqual(g(l), "mutablesequence")
self.assertEqual(g(s), "mutableset")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sized")
g.register(c.Sequence, lambda obj: "sequence")
self.assertEqual(g(d), "mutablemapping")
self.assertEqual(g(l), "mutablesequence")
self.assertEqual(g(s), "mutableset")
self.assertEqual(g(f), "sized")
self.assertEqual(g(t), "sequence")
g.register(c.Set, lambda obj: "set")
self.assertEqual(g(d), "mutablemapping")
self.assertEqual(g(l), "mutablesequence")
self.assertEqual(g(s), "mutableset")
self.assertEqual(g(f), "set")
self.assertEqual(g(t), "sequence")
g.register(dict, lambda obj: "dict")
self.assertEqual(g(d), "dict")
self.assertEqual(g(l), "mutablesequence")
self.assertEqual(g(s), "mutableset")
self.assertEqual(g(f), "set")
self.assertEqual(g(t), "sequence")
g.register(list, lambda obj: "list")
self.assertEqual(g(d), "dict")
self.assertEqual(g(l), "list")
self.assertEqual(g(s), "mutableset")
self.assertEqual(g(f), "set")
self.assertEqual(g(t), "sequence")
g.register(set, lambda obj: "concrete-set")
self.assertEqual(g(d), "dict")
self.assertEqual(g(l), "list")
self.assertEqual(g(s), "concrete-set")
self.assertEqual(g(f), "set")
self.assertEqual(g(t), "sequence")
g.register(frozenset, lambda obj: "frozen-set")
self.assertEqual(g(d), "dict")
self.assertEqual(g(l), "list")
self.assertEqual(g(s), "concrete-set")
self.assertEqual(g(f), "frozen-set")
self.assertEqual(g(t), "sequence")
g.register(tuple, lambda obj: "tuple")
self.assertEqual(g(d), "dict")
self.assertEqual(g(l), "list")
self.assertEqual(g(s), "concrete-set")
self.assertEqual(g(f), "frozen-set")
self.assertEqual(g(t), "tuple")
def test_c3_abc(self):
c = collections.abc
mro = functools._c3_mro
class A(object):
pass
class B(A):
def __len__(self):
return 0 # implies Sized
@c.Container.register
class C(object):
pass
class D(object):
pass # unrelated
class X(D, C, B):
def __call__(self):
pass # implies Callable
expected = [X, c.Callable, D, C, c.Container, B, c.Sized, A, object]
for abcs in permutations([c.Sized, c.Callable, c.Container]):
self.assertEqual(mro(X, abcs=abcs), expected)
# unrelated ABCs don't appear in the resulting MRO
many_abcs = [c.Mapping, c.Sized, c.Callable, c.Container, c.Iterable]
self.assertEqual(mro(X, abcs=many_abcs), expected)
def test_false_meta(self):
# see issue23572
class MetaA(type):
def __len__(self):
return 0
class A(metaclass=MetaA):
pass
class AA(A):
pass
@functools.singledispatch
def fun(a):
return 'base A'
@fun.register(A)
def _(a):
return 'fun A'
aa = AA()
self.assertEqual(fun(aa), 'fun A')
def test_mro_conflicts(self):
c = collections.abc
@functools.singledispatch
def g(arg):
return "base"
class O(c.Sized):
def __len__(self):
return 0
o = O()
self.assertEqual(g(o), "base")
g.register(c.Iterable, lambda arg: "iterable")
g.register(c.Container, lambda arg: "container")
g.register(c.Sized, lambda arg: "sized")
g.register(c.Set, lambda arg: "set")
self.assertEqual(g(o), "sized")
c.Iterable.register(O)
self.assertEqual(g(o), "sized") # because it's explicitly in __mro__
c.Container.register(O)
self.assertEqual(g(o), "sized") # see above: Sized is in __mro__
c.Set.register(O)
self.assertEqual(g(o), "set") # because c.Set is a subclass of
# c.Sized and c.Container
class P:
pass
p = P()
self.assertEqual(g(p), "base")
c.Iterable.register(P)
self.assertEqual(g(p), "iterable")
c.Container.register(P)
with self.assertRaises(RuntimeError) as re_one:
g(p)
self.assertIn(
str(re_one.exception),
(("Ambiguous dispatch: <class 'collections.abc.Container'> "
"or <class 'collections.abc.Iterable'>"),
("Ambiguous dispatch: <class 'collections.abc.Iterable'> "
"or <class 'collections.abc.Container'>")),
)
class Q(c.Sized):
def __len__(self):
return 0
q = Q()
self.assertEqual(g(q), "sized")
c.Iterable.register(Q)
self.assertEqual(g(q), "sized") # because it's explicitly in __mro__
c.Set.register(Q)
self.assertEqual(g(q), "set") # because c.Set is a subclass of
# c.Sized and c.Iterable
@functools.singledispatch
def h(arg):
return "base"
@h.register(c.Sized)
def _(arg):
return "sized"
@h.register(c.Container)
def _(arg):
return "container"
# Even though Sized and Container are explicit bases of MutableMapping,
# this ABC is implicitly registered on defaultdict which makes all of
# MutableMapping's bases implicit as well from defaultdict's
# perspective.
with self.assertRaises(RuntimeError) as re_two:
h(collections.defaultdict(lambda: 0))
self.assertIn(
str(re_two.exception),
(("Ambiguous dispatch: <class 'collections.abc.Container'> "
"or <class 'collections.abc.Sized'>"),
("Ambiguous dispatch: <class 'collections.abc.Sized'> "
"or <class 'collections.abc.Container'>")),
)
class R(collections.defaultdict):
pass
c.MutableSequence.register(R)
@functools.singledispatch
def i(arg):
return "base"
@i.register(c.MutableMapping)
def _(arg):
return "mapping"
@i.register(c.MutableSequence)
def _(arg):
return "sequence"
r = R()
self.assertEqual(i(r), "sequence")
class S:
pass
class T(S, c.Sized):
def __len__(self):
return 0
t = T()
self.assertEqual(h(t), "sized")
c.Container.register(T)
self.assertEqual(h(t), "sized") # because it's explicitly in the MRO
class U:
def __len__(self):
return 0
u = U()
self.assertEqual(h(u), "sized") # implicit Sized subclass inferred
# from the existence of __len__()
c.Container.register(U)
# There is no preference for registered versus inferred ABCs.
with self.assertRaises(RuntimeError) as re_three:
h(u)
self.assertIn(
str(re_three.exception),
(("Ambiguous dispatch: <class 'collections.abc.Container'> "
"or <class 'collections.abc.Sized'>"),
("Ambiguous dispatch: <class 'collections.abc.Sized'> "
"or <class 'collections.abc.Container'>")),
)
class V(c.Sized, S):
def __len__(self):
return 0
@functools.singledispatch
def j(arg):
return "base"
@j.register(S)
def _(arg):
return "s"
@j.register(c.Container)
def _(arg):
return "container"
v = V()
self.assertEqual(j(v), "s")
c.Container.register(V)
self.assertEqual(j(v), "container") # because it ends up right after
# Sized in the MRO
def test_cache_invalidation(self):
from collections import UserDict
import weakref
class TracingDict(UserDict):
def __init__(self, *args, **kwargs):
super(TracingDict, self).__init__(*args, **kwargs)
self.set_ops = []
self.get_ops = []
def __getitem__(self, key):
result = self.data[key]
self.get_ops.append(key)
return result
def __setitem__(self, key, value):
self.set_ops.append(key)
self.data[key] = value
def clear(self):
self.data.clear()
td = TracingDict()
with support.swap_attr(weakref, "WeakKeyDictionary", lambda: td):
c = collections.abc
@functools.singledispatch
def g(arg):
return "base"
d = {}
l = []
self.assertEqual(len(td), 0)
self.assertEqual(g(d), "base")
self.assertEqual(len(td), 1)
self.assertEqual(td.get_ops, [])
self.assertEqual(td.set_ops, [dict])
self.assertEqual(td.data[dict], g.registry[object])
self.assertEqual(g(l), "base")
self.assertEqual(len(td), 2)
self.assertEqual(td.get_ops, [])
self.assertEqual(td.set_ops, [dict, list])
self.assertEqual(td.data[dict], g.registry[object])
self.assertEqual(td.data[list], g.registry[object])
self.assertEqual(td.data[dict], td.data[list])
self.assertEqual(g(l), "base")
self.assertEqual(g(d), "base")
self.assertEqual(td.get_ops, [list, dict])
self.assertEqual(td.set_ops, [dict, list])
g.register(list, lambda arg: "list")
self.assertEqual(td.get_ops, [list, dict])
self.assertEqual(len(td), 0)
self.assertEqual(g(d), "base")
self.assertEqual(len(td), 1)
self.assertEqual(td.get_ops, [list, dict])
self.assertEqual(td.set_ops, [dict, list, dict])
self.assertEqual(td.data[dict],
functools._find_impl(dict, g.registry))
self.assertEqual(g(l), "list")
self.assertEqual(len(td), 2)
self.assertEqual(td.get_ops, [list, dict])
self.assertEqual(td.set_ops, [dict, list, dict, list])
self.assertEqual(td.data[list],
functools._find_impl(list, g.registry))
class X:
pass
c.MutableMapping.register(X) # Will not invalidate the cache,
# not using ABCs yet.
self.assertEqual(g(d), "base")
self.assertEqual(g(l), "list")
self.assertEqual(td.get_ops, [list, dict, dict, list])
self.assertEqual(td.set_ops, [dict, list, dict, list])
g.register(c.Sized, lambda arg: "sized")
self.assertEqual(len(td), 0)
self.assertEqual(g(d), "sized")
self.assertEqual(len(td), 1)
self.assertEqual(td.get_ops, [list, dict, dict, list])
self.assertEqual(td.set_ops, [dict, list, dict, list, dict])
self.assertEqual(g(l), "list")
self.assertEqual(len(td), 2)
self.assertEqual(td.get_ops, [list, dict, dict, list])
self.assertEqual(td.set_ops, [dict, list, dict, list, dict, list])
self.assertEqual(g(l), "list")
self.assertEqual(g(d), "sized")
self.assertEqual(td.get_ops, [list, dict, dict, list, list, dict])
self.assertEqual(td.set_ops, [dict, list, dict, list, dict, list])
g.dispatch(list)
g.dispatch(dict)
self.assertEqual(td.get_ops, [list, dict, dict, list, list, dict,
list, dict])
self.assertEqual(td.set_ops, [dict, list, dict, list, dict, list])
c.MutableSet.register(X) # Will invalidate the cache.
self.assertEqual(len(td), 2) # Stale cache.
self.assertEqual(g(l), "list")
self.assertEqual(len(td), 1)
g.register(c.MutableMapping, lambda arg: "mutablemapping")
self.assertEqual(len(td), 0)
self.assertEqual(g(d), "mutablemapping")
self.assertEqual(len(td), 1)
self.assertEqual(g(l), "list")
self.assertEqual(len(td), 2)
g.register(dict, lambda arg: "dict")
self.assertEqual(g(d), "dict")
self.assertEqual(g(l), "list")
g._clear_cache()
self.assertEqual(len(td), 0)
def test_annotations(self):
@functools.singledispatch
def i(arg):
return "base"
@i.register
def _(arg: collections.abc.Mapping):
return "mapping"
@i.register
def _(arg: "collections.abc.Sequence"):
return "sequence"
self.assertEqual(i(None), "base")
self.assertEqual(i({"a": 1}), "mapping")
self.assertEqual(i([1, 2, 3]), "sequence")
self.assertEqual(i((1, 2, 3)), "sequence")
self.assertEqual(i("str"), "sequence")
# Registering classes as callables doesn't work with annotations,
# you need to pass the type explicitly.
@i.register(str)
class _:
def __init__(self, arg):
self.arg = arg
def __eq__(self, other):
return self.arg == other
self.assertEqual(i("str"), "str")
def test_method_register(self):
class A:
@functools.singledispatchmethod
def t(self, arg):
self.arg = "base"
@t.register(int)
def _(self, arg):
self.arg = "int"
@t.register(str)
def _(self, arg):
self.arg = "str"
a = A()
a.t(0)
self.assertEqual(a.arg, "int")
aa = A()
self.assertFalse(hasattr(aa, 'arg'))
a.t('')
self.assertEqual(a.arg, "str")
aa = A()
self.assertFalse(hasattr(aa, 'arg'))
a.t(0.0)
self.assertEqual(a.arg, "base")
aa = A()
self.assertFalse(hasattr(aa, 'arg'))
def test_staticmethod_register(self):
class A:
@functools.singledispatchmethod
@staticmethod
def t(arg):
return arg
@t.register(int)
@staticmethod
def _(arg):
return isinstance(arg, int)
@t.register(str)
@staticmethod
def _(arg):
return isinstance(arg, str)
a = A()
self.assertTrue(A.t(0))
self.assertTrue(A.t(''))
self.assertEqual(A.t(0.0), 0.0)
def test_classmethod_register(self):
class A:
def __init__(self, arg):
self.arg = arg
@functools.singledispatchmethod
@classmethod
def t(cls, arg):
return cls("base")
@t.register(int)
@classmethod
def _(cls, arg):
return cls("int")
@t.register(str)
@classmethod
def _(cls, arg):
return cls("str")
self.assertEqual(A.t(0).arg, "int")
self.assertEqual(A.t('').arg, "str")
self.assertEqual(A.t(0.0).arg, "base")
def test_callable_register(self):
class A:
def __init__(self, arg):
self.arg = arg
@functools.singledispatchmethod
@classmethod
def t(cls, arg):
return cls("base")
@A.t.register(int)
@classmethod
def _(cls, arg):
return cls("int")
@A.t.register(str)
@classmethod
def _(cls, arg):
return cls("str")
self.assertEqual(A.t(0).arg, "int")
self.assertEqual(A.t('').arg, "str")
self.assertEqual(A.t(0.0).arg, "base")
def test_abstractmethod_register(self):
class Abstract(abc.ABCMeta):
@functools.singledispatchmethod
@abc.abstractmethod
def add(self, x, y):
pass
self.assertTrue(Abstract.add.__isabstractmethod__)
def test_type_ann_register(self):
class A:
@functools.singledispatchmethod
def t(self, arg):
return "base"
@t.register
def _(self, arg: int):
return "int"
@t.register
def _(self, arg: str):
return "str"
a = A()
self.assertEqual(a.t(0), "int")
self.assertEqual(a.t(''), "str")
self.assertEqual(a.t(0.0), "base")
def test_invalid_registrations(self):
msg_prefix = "Invalid first argument to `register()`: "
msg_suffix = (
". Use either `@register(some_class)` or plain `@register` on an "
"annotated function."
)
@functools.singledispatch
def i(arg):
return "base"
with self.assertRaises(TypeError) as exc:
@i.register(42)
def _(arg):
return "I annotated with a non-type"
self.assertTrue(str(exc.exception).startswith(msg_prefix + "42"))
self.assertTrue(str(exc.exception).endswith(msg_suffix))
with self.assertRaises(TypeError) as exc:
@i.register
def _(arg):
return "I forgot to annotate"
self.assertTrue(str(exc.exception).startswith(msg_prefix +
"<function TestSingleDispatch.test_invalid_registrations.<locals>._"
))
self.assertTrue(str(exc.exception).endswith(msg_suffix))
with self.assertRaises(TypeError) as exc:
@i.register
def _(arg: typing.Iterable[str]):
# At runtime, dispatching on generics is impossible.
# When registering implementations with singledispatch, avoid
# types from `typing`. Instead, annotate with regular types
# or ABCs.
return "I annotated with a generic collection"
self.assertTrue(str(exc.exception).startswith(
"Invalid annotation for 'arg'."
))
self.assertTrue(str(exc.exception).endswith(
'typing.Iterable[str] is not a class.'
))
def test_invalid_positional_argument(self):
@functools.singledispatch
def f(*args):
pass
msg = 'f requires at least 1 positional argument'
with self.assertRaisesRegex(TypeError, msg):
f()
class CachedCostItem:
_cost = 1
def __init__(self):
self.lock = py_functools.RLock()
@py_functools.cached_property
def cost(self):
"""The cost of the item."""
with self.lock:
self._cost += 1
return self._cost
class OptionallyCachedCostItem:
_cost = 1
def get_cost(self):
"""The cost of the item."""
self._cost += 1
return self._cost
cached_cost = py_functools.cached_property(get_cost)
class CachedCostItemWait:
def __init__(self, event):
self._cost = 1
self.lock = py_functools.RLock()
self.event = event
@py_functools.cached_property
def cost(self):
self.event.wait(1)
with self.lock:
self._cost += 1
return self._cost
class CachedCostItemWithSlots:
__slots__ = ('_cost')
def __init__(self):
self._cost = 1
@py_functools.cached_property
def cost(self):
raise RuntimeError('never called, slots not supported')
class TestCachedProperty(unittest.TestCase):
def test_cached(self):
item = CachedCostItem()
self.assertEqual(item.cost, 2)
self.assertEqual(item.cost, 2) # not 3
def test_cached_attribute_name_differs_from_func_name(self):
item = OptionallyCachedCostItem()
self.assertEqual(item.get_cost(), 2)
self.assertEqual(item.cached_cost, 3)
self.assertEqual(item.get_cost(), 4)
self.assertEqual(item.cached_cost, 3)
def test_threaded(self):
go = threading.Event()
item = CachedCostItemWait(go)
num_threads = 3
orig_si = sys.getswitchinterval()
sys.setswitchinterval(1e-6)
try:
threads = [
threading.Thread(target=lambda: item.cost)
for k in range(num_threads)
]
with support.start_threads(threads):
go.set()
finally:
sys.setswitchinterval(orig_si)
self.assertEqual(item.cost, 2)
def test_object_with_slots(self):
item = CachedCostItemWithSlots()
with self.assertRaisesRegex(
TypeError,
"No '__dict__' attribute on 'CachedCostItemWithSlots' instance to cache 'cost' property.",
):
item.cost
def test_immutable_dict(self):
class MyMeta(type):
@py_functools.cached_property
def prop(self):
return True
class MyClass(metaclass=MyMeta):
pass
with self.assertRaisesRegex(
TypeError,
"The '__dict__' attribute on 'MyMeta' instance does not support item assignment for caching 'prop' property.",
):
MyClass.prop
def test_reuse_different_names(self):
"""Disallow this case because decorated function a would not be cached."""
with self.assertRaises(RuntimeError) as ctx:
class ReusedCachedProperty:
@py_functools.cached_property
def a(self):
pass
b = a
self.assertEqual(
str(ctx.exception.__context__),
str(TypeError("Cannot assign the same cached_property to two different names ('a' and 'b')."))
)
def test_reuse_same_name(self):
"""Reusing a cached_property on different classes under the same name is OK."""
counter = 0
@py_functools.cached_property
def _cp(_self):
nonlocal counter
counter += 1
return counter
class A:
cp = _cp
class B:
cp = _cp
a = A()
b = B()
self.assertEqual(a.cp, 1)
self.assertEqual(b.cp, 2)
self.assertEqual(a.cp, 1)
def test_set_name_not_called(self):
cp = py_functools.cached_property(lambda s: None)
class Foo:
pass
Foo.cp = cp
with self.assertRaisesRegex(
TypeError,
"Cannot use cached_property instance without calling __set_name__ on it.",
):
Foo().cp
def test_access_from_class(self):
self.assertIsInstance(CachedCostItem.cost, py_functools.cached_property)
def test_doc(self):
self.assertEqual(CachedCostItem.cost.__doc__, "The cost of the item.")
if __name__ == '__main__':
unittest.main()
|
robot_script.py
|
#!/usr/bin/env python3
import socket, sys
from threading import Thread
import logging
from math import sin, cos
import numpy as np
import ev3dev.auto as ev3
try:
import cPickle as pickle
except:
import pickle
### Initialize ###
# Constants
PORT = 50008
THIS_ROBOT = 2 # Our own ID
PI = 3.1415
TWO_PI = 2 * PI
CIRCLE = 1
GO_TO_CENTER = 0
CENTER = np.array([1920 / 2, 1080 / 2])
MODE = CIRCLE # GO_TO_CENTER or CIRCLE
# Server communication
robot_broadcast_data = {'states': {}, 'balls': {}, 'settings': {}}
running = True
logging.basicConfig( # filename='position_server.log', # To a file. Or not.
filemode='w', # Start each run with a fresh log
format='%(asctime)s, %(levelname)s, %(message)s',
datefmt='%H:%M:%S',
level=logging.INFO, ) # Log info, and warning
# Robot setup
left_motor = ev3.LargeMotor(ev3.OUTPUT_B)
right_motor = ev3.LargeMotor(ev3.OUTPUT_C)
### Helpers ###
def vec2d_length(vector):
"""
Calculates the length of a 2D vector
:param vector: 1 x 2 numpy array
:return: length (float)
"""
return np.dot(vector, vector) ** 0.5
def vec2d_angle(vector):
"""
Calculates the angle of a vector with the horizontal axis (X),
in right handed Cartesian space. (A turn to the left is positive, Y axis pointing up).
:param vector: 1 x 2 numpy array
:return: angle in radians (float)
"""
return np.arctan2(vector[1], vector[0])
def clamp(n, range):
"""
Given a number and a range, return the number, or the extreme it is closest to.
:param n: number
:param range: tuple with min and max
:return: number
"""
minn, maxn = range
return max(min(maxn, n), minn)
def circle_steps(origin, radius, step_px):
circumference = radius * 2 * PI
numsteps = int(circumference / step_px) + 1
i = 0
while True:
angle = 2 * PI / numsteps * i
coord = np.array([cos(angle) * radius + origin[0], sin(angle) * radius + origin[1]])
yield coord
i += 1
if i > numsteps: i = 0
### Get robot positions from server ###
def get_camera_data():
global robot_broadcast_data, running
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(('', PORT))
while running:
try:
data, server = s.recvfrom(2048)
robot_broadcast_data = pickle.loads(data)
except:
e = sys.exc_info()[0]
logging.warning(e)
raise
s.close()
### Run the main loop ###
if __name__ == '__main__':
get_positions_thread = Thread(target=get_camera_data)
get_positions_thread.start()
circle_step = circle_steps((1920//2, 1080//2), 400, 50)
if MODE == CIRCLE:
target = next(circle_step)
else:
target = CENTER
logging.info("Current target:" + str(target))
logging.info("Running")
while 1:
try:
# We put this in a try statement because we need to clean up after ctrl-c
if THIS_ROBOT in robot_broadcast_data['states']:
# Copy global variable to local ones, otherwise Bad Shit Happens in MultiThreading
center, nose = np.array(robot_broadcast_data['states'][THIS_ROBOT])
heading = vec2d_angle(nose - center)
# Calculate vector from nose to target
path = target - nose
if MODE == CIRCLE:
if vec2d_length(path) <= 6:
try:
target = next(circle_step)
logging.info("Current target:" + str(target))
except:
break # no more points to be had
path = target - nose
target_direction = vec2d_angle(path) - heading
turnrate = clamp(vec2d_length(path) * sin(target_direction) * -1, (-500, 500))
speed = clamp(vec2d_length(path) * cos(target_direction) * -2, (-500, 500))
left_motor.run_forever(speed_sp=(speed + turnrate))
right_motor.run_forever(speed_sp=(speed - turnrate))
else:
# No data about our robot's position. Stop the engines!
left_motor.stop()
right_motor.stop()
except:
# User pressed ctrl-c or something bad happened
e = sys.exc_info()[0]
logging.warning(e)
running = False
left_motor.stop()
right_motor.stop()
logging.info("Cleaned up")
raise
# Clean up
running = False
left_motor.stop()
right_motor.stop()
logging.info("Cleaned up")
|
test_loader_semaphore.py
|
# Copyright (c) MONAI Consortium
# 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.
"""this test should not generate errors or
UserWarning: semaphore_tracker: There appear to be 1 leaked semaphores"""
import multiprocessing as mp
import unittest
import monai # noqa
def w():
pass
def _main():
ps = mp.Process(target=w)
ps.start()
ps.join()
def _run_test():
try:
tmp = mp.get_context("spawn")
except RuntimeError:
tmp = mp
p = tmp.Process(target=_main)
p.start()
p.join()
class TestImportLock(unittest.TestCase):
def test_start(self):
_run_test()
if __name__ == "__main__":
unittest.main()
|
ventilator.py
|
# Copyright (c) 2017-2018 Uber Technologies, Inc.
#
# 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.
import random
import threading
from abc import ABCMeta, abstractmethod
from time import sleep
import six
_VENTILATION_INTERVAL = 0.01
@six.add_metaclass(ABCMeta)
class Ventilator(object):
"""Manages items to be ventilated to a worker pool."""
def __init__(self, ventilate_fn):
self._ventilate_fn = ventilate_fn
@abstractmethod
def start(self):
"""Starts the ventilator, beginning to ventilate to the worker pool after this call.
Therefore the worker pool must be ready to receive ventilated items."""
return
@abstractmethod
def processed_item(self):
"""A callback for the worker pool to tell the ventilator that it has processed an item from the ventilation
queue. This allows the ventilator to know how many items are currently on the ventilation queue.
This function should not have a return value."""
pass
@abstractmethod
def completed(self):
"""Returns whether the ventilator has completed ventilating all items it expects to ever ventilate."""
return
@abstractmethod
def stop(self):
"""Tells the ventilator to stop ventilating."""
return
class ConcurrentVentilator(Ventilator):
"""
A ConcurrentVentilator handles ventilation of a pre-determined list of items to a worker pool and performs
the ventilation concurrently in a separate thread. It will keep track of how many items are currently in the
ventilation queue and prevent it from monotonically increasing in order to prevent boundless memory requirements.
It allows for multiple (or infinite) iterations of ventilating the items, optionally randomizing the order of
items being ventilated at the start of each iteration.
"""
def __init__(self,
ventilate_fn,
items_to_ventilate,
iterations=1,
randomize_item_order=False,
max_ventilation_queue_size=None,
ventilation_interval=_VENTILATION_INTERVAL):
"""
Constructor for a concurrent ventilator.
:param ventilate_fn: The function to be called when ventilating. Usually the worker pool ventilate function.
:param items_to_ventilate: (``list[dict]``) The list of items to ventilate. Each item is a ``dict`` denoting
the ``**kwargs`` eventually passed to a worker process function
:param iterations: (int) How many iterations through items_to_ventilate should be done and ventilated to the
worker pool. For example if set to 2 each item in items_to_ventilate will be ventilated 2 times. If
``None`` is passed, the ventilator will continue ventilating forever.
:param randomize_item_order: (``bool``) Whether to randomize the item order in items_to_ventilate. This will be
done on every individual iteration.
:param max_ventilation_queue_size: (``int``) The maximum number of items to be stored in the ventilation queue.
The higher this number, the higher potential memory requirements. By default it will use the size
of items_to_ventilate since that can definitely be held in memory.
:param ventilation_interval: (``float`` in seconds) How much time passes between checks on whether something
can be ventilated (when the ventilation queue is considered full).
"""
super(ConcurrentVentilator, self).__init__(ventilate_fn)
if iterations is not None and (not isinstance(iterations, int) or iterations < 1):
raise ValueError('iterations must be positive integer or None')
if not isinstance(items_to_ventilate, list) or any(not isinstance(item, dict) for item in items_to_ventilate):
raise ValueError('items_to_ventilate must be a list of dicts')
self._items_to_ventilate = items_to_ventilate
self._iterations_remaining = iterations
self._randomize_item_order = randomize_item_order
# For the default max ventilation queue size we will use the size of the items to ventilate
self._max_ventilation_queue_size = max_ventilation_queue_size or len(items_to_ventilate)
self._ventilation_interval = ventilation_interval
self._current_item_to_ventilate = 0
self._ventilation_thread = None
self._ventilated_items_count = 0
self._processed_items_count = 0
self._stop_requested = False
def start(self):
# Start the ventilation thread
self._ventilation_thread = threading.Thread(target=self._ventilate, args=())
self._ventilation_thread.daemon = True
self._ventilation_thread.start()
def processed_item(self):
self._processed_items_count += 1
def completed(self):
assert self._iterations_remaining is None or self._iterations_remaining >= 0
return self._stop_requested or self._iterations_remaining == 0 or not self._items_to_ventilate
def _ventilate(self):
while True:
# Stop condition is when no iterations are remaining or there are no items to ventilate
if self.completed():
break
# If we are ventilating the first item, we check if we would like to randomize the item order
if self._current_item_to_ventilate == 0 and self._randomize_item_order:
random.shuffle(self._items_to_ventilate)
# Block until queue has room, but use continue to allow for checking if stop has been called
if self._ventilated_items_count - self._processed_items_count >= self._max_ventilation_queue_size:
sleep(self._ventilation_interval)
continue
item_to_ventilate = self._items_to_ventilate[self._current_item_to_ventilate]
self._ventilate_fn(**item_to_ventilate)
self._current_item_to_ventilate += 1
self._ventilated_items_count += 1
if self._current_item_to_ventilate >= len(self._items_to_ventilate):
self._current_item_to_ventilate = 0
# If iterations was set to None, that means we will iterate until stop is called
if self._iterations_remaining is not None:
self._iterations_remaining -= 1
def stop(self):
self._stop_requested = True
if self._ventilation_thread:
self._ventilation_thread.join()
self._ventilation_thread = None
|
messenger_manager.py
|
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import logging
import os
import sys
import threading
import time
import traceback
from parlai.messenger.core.agents import MessengerAgent
from parlai.messenger.core.message_socket import MessageSocket
from parlai.messenger.core.message_sender import MessageSender
import parlai.messenger.core.server_utils as server_utils
import parlai.messenger.core.shared_utils as shared_utils
parent_dir = os.path.dirname(os.path.abspath(__file__))
class AgentState:
"""Keeps track of a messenger connection through multiple potential
worlds"""
def __init__(self, messenger_id, overworld_agent):
self.messenger_id = messenger_id
self.overworld_agent = overworld_agent
self.active_agent = overworld_agent
self.task_id_to_agent = {}
self.onboard_data = None
self.stored_data = {}
self.time_in_pool = {}
def get_active_agent(self):
return self.active_agent
def set_active_agent(self, active_agent):
self.active_agent = active_agent
def get_overworld_agent(self):
return self.overworld_agent
def get_id(self):
return self.messenger_id
def has_task(self, task_id):
return task_id in self.task_id_to_agent
def get_agent_for_task(self, task_id):
if self.has_task(task_id):
return self.task_id_to_agent[task_id]
else:
return None
def assign_agent_to_task(self, agent, task_id):
self.task_id_to_agent[task_id] = agent
class MessengerManager:
"""Manages interactions between agents on messenger as well as direct
interactions between agents and the messenger overworld
"""
def __init__(self, opt):
"""Create an MessengerManager using the given setup options
"""
self.opt = opt
self.server_url = None
self.port = 443
self.agent_pool_change_condition = threading.Condition()
self.overworld_func = None
self.overworld_threads = {}
self.active_worlds = {}
self.message_socket = None
self.message_sender = None
self.page_id = None
self._init_logs()
self.running = True
self.conversation_index = 0
self.shutting_down = True
self.bypass_server_setup = self.opt.get('bypass_server_setup')
# Messaging interaction functions that determine what to do when
# messages are confirmed as delivered, marked as read by a user, and
# noted as read by the bot.
self.confirm_message_delivery = self._confirm_message_delivery
self.handle_message_read = self._handle_message_read
self.handle_bot_read = self._handle_bot_read
# Helpers and internal manager methods #
def _init_logs(self):
"""Initialize logging settings from the opt"""
shared_utils.set_is_debug(self.opt['is_debug'])
shared_utils.set_log_level(self.opt['log_level'])
def add_agent_to_pool(self, agent, world_type='default'):
"""Add the agent to pool"""
with self.agent_pool_change_condition:
shared_utils.print_and_log(
logging.DEBUG, "Adding agent {} to pool...".format(agent.messenger_id)
)
# time agent entered agent_pool
agent.time_in_pool.setdefault(world_type, time.time())
# add agent to pool
self.agent_pool.setdefault(world_type, []).append(agent)
def mark_removed(self, agent_id, pageid):
"""Mark the agent as removed from the pool. Can be overriden to change
other metadata linked to agent removal."""
pass
def remove_agent_from_pool(self, agent, world_type='default', mark_removed=True):
"""Remove agent from the pool."""
with self.agent_pool_change_condition:
shared_utils.print_and_log(
logging.DEBUG,
"Removing agent {} from pool...".format(agent.messenger_id),
)
if world_type in self.agent_pool and agent in self.agent_pool[world_type]:
self.agent_pool[world_type].remove(agent)
# reset agent's time_in_pool
if world_type in agent.time_in_pool:
del agent.time_in_pool[world_type]
# maybe mark agent as removed
if mark_removed:
agent.stored_data['removed_from_pool'] = True
if self.page_id is not None:
self.mark_removed(int(agent.messenger_id), int(self.page_id))
def _expire_all_conversations(self):
"""iterate through all sub-worlds and shut them down"""
self.running = False
for agent_id, overworld_thread in self.agent_id_to_overworld_thread.items():
self.observe_message(
agent_id,
"System: The conversation bot going to go offline soon, "
"finish any active conversations in the next 5 minutes.",
)
overworld_thread.join()
# 5 minute grace period for conversations to finish
time_passed = 0
while time_passed < 5 * 60:
any_alive = False
for task_thread in self.active_worlds.values():
if task_thread is not None:
any_alive = any_alive or task_thread.isAlive()
if not any_alive:
break
time.sleep(1)
# Tell the worlds that they should be shutting down at this point,
# agents will refer to this value
self.shutting_down = True
def _get_unique_pool(self, eligibility_functions):
"""Return a filtered version of the agent pool where each agent is
only listed a maximum of one time.
"""
# TODO filter by psid -> agent id mappings for multi-page setup
if eligibility_functions is None:
return self.agent_pool
valid_pools = {}
for world_type, agent_pool in self.agent_pool.items():
if (
world_type in eligibility_functions
and eligibility_functions[world_type] is not None
):
valid_pools[world_type] = [
w for w in agent_pool if eligibility_functions[world_type](w)
]
else:
valid_pools[world_type] = self.agent_pool[world_type]
return valid_pools
def _handle_bot_read(self, agent_id):
self.message_sender.send_read(agent_id)
self.message_sender.typing_on(agent_id)
def _confirm_message_delivery(self, event):
# By default we don't actually do anything when messages are marked as
# being delivered, but we expose the ability for others to
shared_utils.print_and_log(
logging.DEBUG,
"Messages {} marked as received.".format(event['delivery']['mids']),
)
def _handle_message_read(self, event):
# If the message was sent by another user (as in during a conversation)
# then we need to propogate the read back to that user.
shared_utils.print_and_log(
logging.DEBUG, "Messages {} marked as read.".format(event['read'])
)
reader = event['sender']['id']
agent_state = self.get_agent_state(reader)
if agent_state is None:
return
agent = agent_state.get_active_agent()
if agent is not None:
for partner in agent.message_partners:
# We don't know who sent the message that was seen, but we can
# send a message observed event to everyone else in the chat
self.message_sender.send_read(partner.id)
def _handle_webhook_event(self, event):
if 'message' in event:
if ('image_url' in event and event['image_url'] is not None) or (
'attachment_url' in event and event['attachment_url'] is not None
):
event['message']['image'] = True
self._on_new_message(event)
elif 'delivery' in event:
self.confirm_message_delivery(event)
elif 'read' in event:
self.handle_message_read(event)
def _on_first_message(self, message):
"""Handle a new incoming message from a psid that is not yet
registered to any assignment.
"""
if self.page_id is None:
self.page_id = message['recipient']['id']
agent_id = message['sender']['id']
if self.opt['password'] is not None:
if message['message']['text'] != self.opt['password']:
self.observe_message(
agent_id,
"Sorry, this conversation bot is password-protected. If "
"you have the password, please send it now.",
)
return
def _overworld_function(opt, agent_id, task_id):
"""Wrapper function for maintaining an overworld"""
agent_state = self.get_agent_state(agent_id)
if self.opt['password'] is None:
agent_state.stored_data['first_message'] = message
agent = agent_state.get_overworld_agent()
overworld = self.overworld_func(opt, agent)
while self.running:
world_type = overworld.parley()
if world_type is None:
continue
self._onboard_new_worker(agent_id, world_type)
time.sleep(5) # wait for onboard_world to start
while agent_state.get_active_agent() != agent:
time.sleep(1)
overworld.return_overworld()
task_id = 'overworld-{}-{}'.format(agent_id, time.time())
agent = self._create_agent(task_id, agent_id)
agent_state = AgentState(agent_id, agent)
self.messenger_agent_states[agent_id] = agent_state
# Start the onboarding thread and run it
overworld_thread = threading.Thread(
target=_overworld_function, args=(self.opt, agent_id, task_id), name=task_id
)
overworld_thread.daemon = True
overworld_thread.start()
self.agent_id_to_overworld_thread[agent_id] = overworld_thread
pass
def after_agent_removed(self, agent_id):
"""Perform any changes to metadata on agent removal
override if extra bookkeeping must be done when removing agent"""
pass
def _on_new_message(self, message):
"""Put an incoming message onto the correct agent's message queue.
"""
agent_id = message['sender']['id']
if agent_id not in self.messenger_agent_states:
self._on_first_message(message)
return
agent_state = self.get_agent_state(agent_id)
if agent_state.get_active_agent() is None:
# return agent to overworld
if (
'text' in message['message']
and message['message']['text'].upper() == 'EXIT'
):
# remove agent from agent_pool
to_remove = []
for world_type, _time in agent_state.time_in_pool.items():
to_remove.append(world_type)
for world_type in to_remove:
self.remove_agent_from_pool(
agent_state, world_type, mark_removed=False
)
self.after_agent_removed(agent_state.get_id())
agent_state.set_active_agent(agent_state.get_overworld_agent())
else:
self.observe_message(
agent_id,
"Please wait while we pair you with another person. "
"If you wish to exit, type *EXIT*.",
)
self.message_sender.typing_on(agent_id)
else:
# If an agent is in a solo world, we can put a typing indicator
# and mark the message as read
agent = agent_state.get_active_agent()
if len(agent.message_partners) == 0:
self.handle_bot_read(agent.id)
agent.put_data(message)
def _create_agent(self, task_id, agent_id):
"""Initialize an agent and return it"""
return MessengerAgent(self.opt, self, task_id, agent_id, self.page_id)
def _onboard_new_worker(self, agent_id, world_type):
"""Handle creating an onboarding thread and moving an agent through
the onboarding process
"""
def _onboard_function(opt, agent_id, world_type, task_id):
"""Onboarding wrapper to set state to onboarding properly"""
agent_state = self.get_agent_state(agent_id)
data = None
if (
world_type in self.onboard_functions
and self.onboard_functions[world_type] is not None
):
# call onboarding function
agent = self._create_agent(task_id, agent_id)
agent_state.set_active_agent(agent)
agent_state.assign_agent_to_task(agent, task_id)
try:
data = self.onboard_functions[world_type](opt, agent, task_id)
agent_state.onboard_data = data
agent_state.set_active_agent(None)
except Exception as e:
shared_utils.print_and_log(
logging.ERROR,
'Onboard {} had error {}'.format(world_type, repr(e)),
should_print=True,
)
traceback.print_exc(file=sys.stderr)
self.observe_message(
agent.id, "Sorry, this world closed. Returning to overworld."
)
agent_state.set_active_agent(agent_state.get_overworld_agent())
return
# once onboarding is done, move into a waiting world
self.add_agent_to_pool(agent_state, world_type)
task_id = 'onboard-{}-{}'.format(agent_id, time.time())
# Start the onboarding thread and run it
onboard_thread = threading.Thread(
target=_onboard_function,
args=(self.opt, agent_id, world_type, task_id),
name=task_id,
)
onboard_thread.daemon = True
onboard_thread.start()
self.agent_id_to_onboard_thread[agent_id] = onboard_thread
def get_agent_state(self, agent_id):
"""A safe way to get a worker by agent_id"""
if agent_id in self.messenger_agent_states:
return self.messenger_agent_states[agent_id]
return None
def _get_agent(self, agent_id, task_id):
"""A safe way to get an agent by agent_id and task_id"""
agent_state = self.get_agent_state(agent_id)
if agent_state is not None:
if agent_state.has_task(task_id):
return agent_state.get_agent_for_task(task_id)
return None
def _log_missing_agent(self, agent_id, assignment_id):
"""Logs when an agent was expected to exist, yet for some reason it
didn't. If these happen often there is a problem"""
shared_utils.print_and_log(
logging.WARN,
'Expected to have an agent for {}_{}, yet none was found'.format(
agent_id, assignment_id
),
)
# Manager Lifecycle Functions #
def setup_server(self):
"""Prepare the Messenger server for handling messages"""
if self.bypass_server_setup:
return
shared_utils.print_and_log(
logging.INFO,
'\nYou are going to allow people on Facebook to be agents in '
'ParlAI.\nDuring this process, Internet connection is required, '
'and you should turn off your computer\'s auto-sleep '
'feature.\n',
should_print=True,
)
input('Please press Enter to continue... ')
shared_utils.print_and_log(logging.NOTSET, '', True)
if self.opt['local'] is True:
shared_utils.print_and_log(
logging.INFO,
"In order to run the server locally, you will need "
"to have a public HTTPS endpoint (SSL signed) running on "
"the server you are currently excecuting ParlAI on. Enter "
"that public URL hostname when prompted and ensure that the "
"port being used by ParlAI (usually 3000) has external "
"traffic routed to it.",
should_print=True,
)
input('Please press Enter to continue... ')
shared_utils.print_and_log(
logging.INFO, 'Setting up Messenger webhook...', should_print=True
)
# Setup the server with a task name related to the current task
task_name = '{}-{}'.format('ParlAI-Messenger', self.opt['task'])
self.server_task_name = ''.join(
e for e in task_name.lower() if e.isalnum() or e == '-'
)
self.server_url = server_utils.setup_server(
self.server_task_name, local=self.opt['local']
)
shared_utils.print_and_log(
logging.INFO,
'Webhook address: {}/webhook'.format(self.server_url),
should_print=True,
)
# override if permission needed externally
def get_app_token(self):
"""Find and return an app access token"""
if not self.opt.get('force_page_token'):
if not os.path.exists(os.path.expanduser('~/.parlai/')):
os.makedirs(os.path.expanduser('~/.parlai/'))
access_token_file_path = '~/.parlai/messenger_token'
expanded_file_path = os.path.expanduser(access_token_file_path)
if os.path.exists(expanded_file_path):
with open(expanded_file_path, 'r') as access_token_file:
return access_token_file.read()
token = input(
'Enter your page\'s access token from the developer page at'
'https://developers.facebook.com/apps/<YOUR APP ID>'
'/messenger/settings/ to continue setup:'
)
access_token_file_path = '~/.parlai/messenger_token'
expanded_file_path = os.path.expanduser(access_token_file_path)
with open(expanded_file_path, 'w+') as access_token_file:
access_token_file.write(token)
return token
def setup_socket(self):
"""Set up socket to start communicating to workers"""
if not self.bypass_server_setup:
shared_utils.print_and_log(
logging.INFO, 'Local: Setting up WebSocket...', should_print=True
)
self.app_token = self.get_app_token()
self.message_sender = MessageSender(self.app_token)
# Set up receive
if not self.bypass_server_setup:
socket_use_url = self.server_url
if self.opt['local']: # skip some hops for local stuff
socket_use_url = "https://localhost"
self.message_socket = MessageSocket(
socket_use_url, self.port, self._handle_webhook_event
)
def init_new_state(self):
"""Initialize everything in the agent, task, and thread states
to prepare for a new run
"""
self.agent_pool = {}
self.messenger_agent_states = {}
self.task_to_agent_ids = {}
self.agent_id_to_onboard_thread = {}
self.agent_id_to_overworld_thread = {}
def start_new_run(self):
self.run_id = str(int(time.time()))
self.task_group_id = '{}_{}'.format(self.opt['task'], self.run_id)
def set_onboard_functions(self, onboard_functions):
self.onboard_functions = onboard_functions
def set_overworld_func(self, overworld_func):
self.overworld_func = overworld_func
def set_agents_required(self, max_agents_for):
self.max_agents_for = max_agents_for
def check_timeout_in_pool(self, world_type, agent_pool, max_time_in_pool):
for agent_state in agent_pool:
time_in_pool = agent_state.time_in_pool.get(world_type)
if (
time_in_pool
and time.time() - time_in_pool > max_time_in_pool[world_type]
):
# remove agent from agent_pool
self.remove_agent_from_pool(agent_state, world_type)
# put agent back in overworld
agent_state.set_active_agent(agent_state.get_overworld_agent())
agent_state.stored_data['removed_after_timeout'] = True
self.after_agent_removed(agent_state.messenger_id)
# reset wait message state
agent_state.stored_data['seen_wait_message'] = False
elif time_in_pool and time.time() - time_in_pool > 30:
# tell agent that a match is taking longer than
# expected
if (
not agent_state.stored_data.get('seen_wait_message')
or not agent_state.stored_data['seen_wait_message']
):
self.observe_message(
agent_state.messenger_id,
"Pairing is taking longer than expected. "
"If you wish to exit, type *EXIT*.",
)
self.message_sender.typing_on(agent_state.messenger_id)
agent_state.stored_data['seen_wait_message'] = True
def start_task(
self,
assign_role_functions,
task_functions,
max_time_in_pool=None,
eligibility_functions=None,
):
"""Handle running a task by checking to see when enough agents are
in the pool to start an instance of the task. Continue doing this
until the desired number of conversations is had.
"""
def _task_function(opt, agents, conversation_id, world_type):
"""Run the task function for the given agents"""
shared_utils.print_and_log(
logging.INFO, 'Starting task {}...'.format(conversation_id)
)
try:
task_functions[world_type](self, opt, agents, conversation_id)
except Exception as e:
shared_utils.print_and_log(
logging.ERROR,
'World {} had error {}'.format(world_type, repr(e)),
should_print=True,
)
print("Exception in user code:")
traceback.print_exc(file=sys.stdout)
for agent in agents:
self.observe_message(
agent.id, "Sorry, this world closed. Returning to overworld."
)
self.active_worlds[task_id] = None
for agent in agents:
self.after_agent_removed(agent.id)
agent_state = self.get_agent_state(agent.id)
agent_state.set_active_agent(agent_state.get_overworld_agent())
self.running = True
while self.running:
# Loop forever until the server is shut down
with self.agent_pool_change_condition:
valid_pools = self._get_unique_pool(eligibility_functions)
for world_type, agent_pool in valid_pools.items():
# check if agent has exceeded max time in pool
if (
max_time_in_pool is not None
and max_time_in_pool[world_type] is not None
):
self.check_timeout_in_pool(
world_type, agent_pool, max_time_in_pool
)
needed_agents = self.max_agents_for[world_type]
if len(agent_pool) >= needed_agents:
# enough agents in pool to start new conversation
self.conversation_index += 1
task_id = 't_{}'.format(self.conversation_index)
# Add the required number of valid agents to the conv
agent_states = [w for w in agent_pool[:needed_agents]]
agents = []
for state in agent_states:
agent = self._create_agent(task_id, state.get_id())
agent.onboard_data = state.onboard_data
state.assign_agent_to_task(agent, task_id)
state.set_active_agent(agent)
agents.append(agent)
# reset wait message state
state.stored_data['seen_wait_message'] = False
assign_role_functions[world_type](agents)
# Allow task creator to filter out workers and run
# versions of the task that require fewer agents
agents = [a for a in agents if a.disp_id is not None]
for a in agents:
# Remove selected workers from the agent pool
self.remove_agent_from_pool(
self.get_agent_state(a.id),
world_type=world_type,
mark_removed=False,
)
for a in agents:
partner_list = agents.copy()
partner_list.remove(a)
a.message_partners = partner_list
# Start a new thread for this task world
task_thread = threading.Thread(
target=_task_function,
args=(self.opt, agents, task_id, world_type),
name='task-{}'.format(task_id),
)
task_thread.daemon = True
task_thread.start()
self.active_worlds[task_id] = task_thread
time.sleep(shared_utils.THREAD_MEDIUM_SLEEP)
def shutdown(self):
"""Handle any client shutdown cleanup."""
# Ensure all threads are cleaned and conversations are handled
try:
self.is_running = False
if not self.bypass_server_setup:
self.message_socket.keep_running = False
self._expire_all_conversations()
except BaseException:
pass
finally:
if not self.bypass_server_setup:
server_utils.delete_server(self.server_task_name, self.opt['local'])
# Agent Interaction Functions #
def observe_message(self, receiver_id, text, quick_replies=None, persona_id=None):
"""Send a message through the message manager"""
return self.message_sender.send_fb_message(
receiver_id, text, True, quick_replies=quick_replies, persona_id=persona_id
)
def observe_payload(self, receiver_id, data, quick_replies=None, persona_id=None):
"""Send a payload through the message manager"""
return self.message_sender.send_fb_payload(
receiver_id, data, quick_replies=quick_replies, persona_id=persona_id
)
def upload_attachment(self, payload):
"""Uploads an attachment and returns an attachment ID
`payload` should be a dict of the format
{'type': <TYPE>, 'url': <URL>} or
{'type': <TYPE>, 'filename': <FILENAME>, 'format': <FILEFORMAT>}.
For example,
{'type': 'image', 'filename': 'test.png', 'format': 'png'}
"""
return self.message_sender.upload_fb_attachment(payload)
|
timeout.py
|
# coding=utf-8
# Copyright 2021 The Google Research 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.
"""Timeout function."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import threading
class FunctionTimeoutError(Exception):
"""Timeout Error."""
pass
class RunWithTimeout(object):
"""Runs a python function with a timeout and gets a returned value.
NOTE(leeley): This class is forked from answer in
https://stackoverflow.com/questions/46858493/python-run-a-function-with-a-timeout-and-get-a-returned-value
I added a FunctionTimeoutError when time limit is reached.
"""
def __init__(self, function, args, name=None):
"""Initializer.
Args:
function: Callable, function to run.
args: Tuple of function arguments.
name: String, the name of the function. Default None, function.__name__
will be used.
"""
self.function = function
self.args = args
self.answer = None
if name is None:
self.name = function.__name__
else:
self.name = name
def _worker(self):
self.answer = self.function(*self.args)
def run(self, time_limit_seconds):
"""Runs function.
Args:
time_limit_seconds: Float, timeout limit in seconds.
Returns:
output of function.
Raises:
FunctionTimeoutError: If output of the answer is None.
"""
thread = threading.Thread(target=self._worker)
thread.start()
thread.join(time_limit_seconds)
if self.answer is None:
raise FunctionTimeoutError(
'%s timeout after %f.' % (self.name, time_limit_seconds))
return self.answer
|
test_soef_integration.py
|
# -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------
#
# Copyright 2018-2020 Fetch.AI Limited
#
# 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.
#
# ------------------------------------------------------------------------------
"""This module contains the tests of the soef connection module."""
import logging
import time
import urllib
from threading import Thread
from typing import Any, Dict, Optional, Tuple, cast
from unittest.mock import MagicMock
from urllib.parse import urlencode
import pytest
from defusedxml import ElementTree as ET # pylint: disable=wrong-import-order
from aea.configurations.base import ConnectionConfig
from aea.configurations.constants import DEFAULT_LEDGER
from aea.crypto.base import Crypto
from aea.crypto.registries import make_crypto
from aea.helpers.search.models import (
Constraint,
ConstraintType,
Description,
Location,
Query,
)
from aea.identity.base import Identity
from aea.mail.base import Envelope
from aea.multiplexer import Multiplexer
from packages.fetchai.connections.soef.connection import SOEFConnection
from packages.fetchai.protocols.oef_search.message import OefSearchMessage
from .test_soef import OefSearchDialogues
from tests.common.utils import wait_for_condition
from tests.test_packages.test_connections.test_soef import models
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)
def make_multiplexer_and_dialogues() -> Tuple[
Multiplexer, OefSearchDialogues, Crypto, SOEFConnection
]:
"""Return multplexer, dialogues and crypto instances."""
crypto = make_crypto(DEFAULT_LEDGER)
identity = Identity("identity", address=crypto.address)
skill_id = "some/skill:0.1.0"
oef_search_dialogues = OefSearchDialogues(skill_id)
# create the connection and multiplexer objects
configuration = ConnectionConfig(
api_key="TwiCIriSl0mLahw17pyqoA",
soef_addr="s-oef.fetch.ai",
soef_port=443,
restricted_to_protocols={
OefSearchMessage.protocol_specification_id,
OefSearchMessage.protocol_id,
},
connection_id=SOEFConnection.connection_id,
)
soef_connection = SOEFConnection(
configuration=configuration, data_dir=MagicMock(), identity=identity,
)
multiplexer = Multiplexer([soef_connection])
return multiplexer, oef_search_dialogues, crypto, soef_connection
class Instance:
"""Test agent instance."""
def __init__(self, location: Location) -> None:
"""Init instance with location provided."""
self.location = location
(
self.multiplexer,
self.oef_search_dialogues,
self.crypto,
self.connection,
) = make_multiplexer_and_dialogues()
self.thread = Thread(target=self.multiplexer.connect)
@property
def address(self) -> str:
"""Get agent adress."""
return self.crypto.address
def start(self) -> None:
"""Start multipelxer."""
self.thread.start()
wait_for_condition(lambda: self.multiplexer.is_connected, timeout=5)
self.register_location()
def stop(self):
"""Stop multipelxer and wait."""
self.multiplexer.disconnect()
self.thread.join()
def register_location(self, disclosure_accuracy: Optional[str] = None) -> None:
"""Register location."""
service_instance: Dict[str, Any] = {"location": self.location}
if disclosure_accuracy:
service_instance["disclosure_accuracy"] = disclosure_accuracy
service_description = Description(
service_instance, data_model=models.AGENT_LOCATION_MODEL
)
message, sending_dialogue = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(to=message.to, sender=message.sender, message=message,)
logger.info(
"Registering agent at location=({},{}) by agent={}".format(
self.location.latitude, self.location.longitude, self.crypto.address,
)
)
self.multiplexer.put(envelope)
# check for register results
envelope = self.get()
assert envelope
message = cast(OefSearchMessage, envelope.message)
receiving_dialogue = self.oef_search_dialogues.update(message)
assert sending_dialogue == receiving_dialogue
def wait_registered(self) -> None:
"""Wait connection gets unique_page_address."""
wait_for_condition(
lambda: self.connection.channel.unique_page_address, timeout=10
)
def register_personality_pieces(
self, piece: str = "genus", value: str = "service"
) -> None:
"""Register personality pieces."""
service_instance = {"piece": piece, "value": value}
service_description = Description(
service_instance, data_model=models.AGENT_PERSONALITY_MODEL
)
message, sending_dialogue = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(to=message.to, sender=message.sender, message=message,)
logger.info("Registering agent personality")
self.multiplexer.put(envelope)
# check for register results
envelope = self.get()
assert envelope
message = cast(OefSearchMessage, envelope.message)
receiving_dialogue = self.oef_search_dialogues.update(message)
assert sending_dialogue == receiving_dialogue
def register_service_key(self, key: str, value: str) -> None:
"""Register service key."""
service_instance = {"key": "test", "value": "test"}
service_description = Description(
service_instance, data_model=models.SET_SERVICE_KEY_MODEL
)
message, sending_dialogue = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(to=message.to, sender=message.sender, message=message,)
logger.info("Registering agent service key")
self.multiplexer.put(envelope)
# check for register results
envelope = self.get()
assert envelope
message = cast(OefSearchMessage, envelope.message)
receiving_dialogue = self.oef_search_dialogues.update(message)
assert sending_dialogue == receiving_dialogue
def search(self, query: Query) -> OefSearchMessage:
"""Perform search with query provided."""
message, sending_dialogue = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.SEARCH_SERVICES,
query=query,
)
search_envelope = Envelope(
to=message.to, sender=message.sender, message=message,
)
logger.info(f"Searching for agents with query: {query}")
self.multiplexer.put(search_envelope)
# check for search results
envelope = self.get()
assert envelope
message = cast(OefSearchMessage, envelope.message)
receiving_dialogue = self.oef_search_dialogues.update(message)
assert sending_dialogue == receiving_dialogue
return message
def get(self):
"""Get an instance."""
wait_for_condition(lambda: not self.multiplexer.in_queue.empty(), timeout=20)
return self.multiplexer.get()
def generic_command(self, command: str, parameters: Optional[dict] = None) -> None:
"""Register personality pieces."""
service_instance = {"command": command}
if parameters:
service_instance["parameters"] = urlencode(parameters)
service_description = Description(
service_instance, data_model=models.AGENT_GENERIC_COMMAND_MODEL
)
message, _ = self.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(to=message.to, sender=message.sender, message=message,)
logger.info(f"Send generic command {command} {parameters}")
self.multiplexer.put(envelope)
class TestRealNetwork:
"""Perform tests using real soef server."""
LOCATION = (52.2057092, 2.1183431)
@pytest.mark.integration
def test_search_no_filters(self):
"""Perform tests over real networ with no filters."""
agent_location = Location(*self.LOCATION)
agent = Instance(agent_location)
agent2 = Instance(agent_location)
try:
agent.start()
agent2.start()
agent.wait_registered()
agent2.wait_registered()
time.sleep(2)
# find agents near me
radius = 0.1
close_to_my_service = Constraint(
"location", ConstraintType("distance", (agent_location, radius))
)
closeness_query = Query(
[close_to_my_service], model=models.AGENT_LOCATION_MODEL
)
# search for agents close to me
message = agent.search(closeness_query)
assert message.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert len(message.agents) >= 1
# second message in a raw to check we dont hit limit
message = agent.search(closeness_query)
assert message.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert len(message.agents) >= 1
assert agent2.address in message.agents
finally:
agent.stop()
agent2.stop()
@pytest.mark.integration
def test_search_filters(self):
"""Test find agents near me with filter."""
agent_location = Location(*self.LOCATION)
agent = Instance(agent_location)
agent2 = Instance(agent_location)
agent3 = Instance(agent_location)
agent.start()
agent2.start()
agent3.start()
try:
agent2.register_personality_pieces(piece="genus", value="service")
agent2.register_service_key(key="test", value="test")
agent2.register_location(disclosure_accuracy="medium")
agent3.register_personality_pieces(piece="genus", value="service")
agent3.register_service_key(key="test", value="test")
time.sleep(3)
radius = 0.1
close_to_my_service = Constraint(
"location", ConstraintType("distance", (agent_location, radius))
)
personality_filters = [
Constraint("genus", ConstraintType("==", "service")),
]
service_key_filters = [
Constraint("test", ConstraintType("==", "test")),
]
constraints = (
[close_to_my_service] + personality_filters + service_key_filters
)
closeness_query = Query(constraints)
logger.info(
"Searching for agents in radius={} of myself at location=({},{}) with personality filters".format(
radius, agent_location.latitude, agent_location.longitude,
)
)
message = agent.search(closeness_query)
assert message.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert len(message.agents) >= 1
assert agent2.address in message.agents
assert agent3.address in message.agents
agent2_info = message.agents_info.get_info_for_agent(agent2.address)
assert agent2_info
assert "name" in agent2_info
assert "location" in agent2_info
assert agent2_info["genus"] == "service"
agent3_info = message.agents_info.get_info_for_agent(agent3.address)
assert agent3_info
assert "name" in agent3_info
assert "location" not in agent3_info
assert agent3_info["genus"] == "service"
finally:
agent.stop()
agent2.stop()
agent3.stop()
@pytest.mark.integration
def test_ping(self):
"""Test ping command."""
agent_location = Location(*self.LOCATION)
agent = Instance(agent_location)
agent.start()
try:
service_description = Description({}, data_model=models.PING_MODEL)
message, _ = agent.oef_search_dialogues.create(
counterparty=str(SOEFConnection.connection_id.to_any()),
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
)
envelope = Envelope(
to=message.to, sender="some/skill:0.1.0", message=message,
)
logger.info("Pinging")
agent.multiplexer.put(envelope)
envelope = agent.get()
assert (
envelope.message.performative == OefSearchMessage.Performative.SUCCESS
)
finally:
agent.stop()
@pytest.mark.integration
def test_generic_command(self):
"""Test generic command."""
agent_location = Location(*self.LOCATION)
agent = Instance(agent_location)
agent.start()
try:
agent.generic_command("set_service_key", {"key": "test", "value": "test"})
envelope = agent.get()
assert (
envelope.message.performative == OefSearchMessage.Performative.SUCCESS
)
ET.fromstring(envelope.message.agents_info.body["response"]["content"])
agent.generic_command("bad_command")
envelope = agent.get()
assert (
envelope.message.performative == OefSearchMessage.Performative.OEF_ERROR
)
finally:
agent.stop()
@pytest.mark.integration
def test_generic_command_set_declared_name(self):
"""Test generic command."""
agent_location = Location(*self.LOCATION)
agent1 = Instance(agent_location)
agent1.start()
agent2 = Instance(agent_location)
agent2.start()
declared_name = "new_declared_name"
try:
# send generic command."""
service_description = Description(
{
"command": "set_declared_name",
"parameters": urllib.parse.urlencode({"name": declared_name}),
},
data_model=models.AGENT_GENERIC_COMMAND_MODEL,
)
message, _ = agent1.oef_search_dialogues.create(
performative=OefSearchMessage.Performative.REGISTER_SERVICE,
service_description=service_description,
counterparty=str(SOEFConnection.connection_id.to_any()),
)
envelope = Envelope(to=message.to, sender=message.sender, message=message,)
agent1.multiplexer.put(envelope)
envelope = agent1.get()
assert (
envelope.message.performative == OefSearchMessage.Performative.SUCCESS
)
radius = 0.1
close_to_my_service = Constraint(
"location", ConstraintType("distance", (agent_location, radius))
)
closeness_query = Query(
[close_to_my_service], model=models.AGENT_LOCATION_MODEL
)
message = agent2.search(closeness_query)
assert message.performative == OefSearchMessage.Performative.SEARCH_RESULT
assert len(message.agents) >= 1
assert agent1.address in message.agents_info.body
assert message.agents_info.body[agent1.address]["name"] == declared_name
finally:
agent1.stop()
agent2.stop()
|
sensing_interface.py
|
#!/usr/bin/env python3
import rospy
import rospkg
import re
import threading
import numpy as np
from threading import Lock
import imp
from rosplan_knowledge_msgs.srv import KnowledgeUpdateServiceArray, KnowledgeUpdateServiceArrayRequest
from rosplan_knowledge_msgs.srv import GetDomainPredicateDetailsService, GetDomainPredicateDetailsServiceRequest
from rosplan_knowledge_msgs.srv import GetDomainAttributeService
from rosplan_knowledge_msgs.srv import GetAttributeService, GetAttributeServiceRequest
from rosplan_knowledge_msgs.srv import GetInstanceService, GetInstanceServiceRequest
from rosplan_knowledge_msgs.srv import SetNamedBool, SetNamedBoolRequest
from rosplan_knowledge_msgs.msg import KnowledgeItem, StatusUpdate
from diagnostic_msgs.msg import KeyValue
class RosplanSensing:
def __init__(self):
self.mutex = Lock()
self.srv_mutex = Lock()
self.dump_cache_mutex = Lock()
################################################################################################################
self.knowledge_base = '/rosplan_knowledge_base'
if rospy.has_param('~knowledge_base'):
self.knowledge_base = rospy.get_param('~knowledge_base')
# Init clients and publishers
rospy.wait_for_service(self.knowledge_base + '/update_array')
self.update_kb_srv = rospy.ServiceProxy(self.knowledge_base + '/update_array', KnowledgeUpdateServiceArray)
rospy.wait_for_service(self.knowledge_base + '/domain/predicate_details')
self.get_predicates_srv = rospy.ServiceProxy(self.knowledge_base + '/domain/predicate_details', GetDomainPredicateDetailsService)
rospy.wait_for_service(self.knowledge_base + '/domain/functions')
self.get_functions_srv = rospy.ServiceProxy(self.knowledge_base + '/domain/functions', GetDomainAttributeService)
rospy.wait_for_service(self.knowledge_base + '/state/instances')
self.get_instances_srv = rospy.ServiceProxy(self.knowledge_base + '/state/instances', GetInstanceService)
rospy.wait_for_service(self.knowledge_base + '/state/propositions')
self.get_state_propositions_srv = rospy.ServiceProxy(self.knowledge_base + '/state/propositions', GetAttributeService)
rospy.wait_for_service(self.knowledge_base + '/state/functions')
self.get_state_functions_srv = rospy.ServiceProxy(self.knowledge_base + '/state/functions', GetAttributeService)
self.set_sensed_predicate_srv = rospy.ServiceProxy(self.knowledge_base + '/update_sensed_predicates', SetNamedBool)
self.kb_update_status_subs = rospy.Subscriber(self.knowledge_base + '/status/update', StatusUpdate, self.kb_update_status)
################################################################################################################
# Get cfg
self.cfg_topics = self.cfg_service = {}
self.functions_path = None
found_config = False
if rospy.has_param('~topics'):
self.cfg_topics = rospy.get_param('~topics')
found_config = True
if rospy.has_param('~services'):
self.cfg_service = rospy.get_param('~services')
found_config = True
if rospy.has_param('~functions'):
self.functions_path = rospy.get_param('~functions')[0]
regexp = re.compile('\$\(find (.*)\)')
groups = regexp.match(self.functions_path).groups()
if len(groups):
try:
ros_pkg_path = rospkg.RosPack().get_path(groups[0])
self.functions_path = regexp.sub(ros_pkg_path, self.functions_path)
except:
rospy.logerr('KCL: (RosplanSensing) Error: Package %s was not found! Fix configuration file and retry.' % groups[0])
rospy.signal_shutdown('Wrong path in cfg file')
return
if not found_config:
rospy.logerr('KCL: (RosplanSensing) Error: configuration file is not defined!')
rospy.signal_shutdown('Config not found')
return
################################################################################################################
# Load scripts
if self.functions_path:
self.scripts = imp.load_source('sensing_scripts', self.functions_path)
# Declare tools in the scripts module:
self.scripts.get_kb_attribute = self.get_kb_attribute
self.scripts.rospy = rospy
################################################################################################################
# Init variables
self.sensed_topics = {}
self.sensed_services = {}
self.params = {} # Params defined for each predicate
######
# Subscribe to all the topics
self.offset = {} # Offset for reading cfg
for predicate_name, predicate_info in self.cfg_topics.iteritems():
if type(predicate_info) is list: # We have nested elements in the predicate
for i, pi in enumerate(predicate_info):
pi['sub_idx'] = i
subscribed = self.subscribe_topic(predicate_name, pi)
if not subscribed:
rospy.loginfo('Could not subscribe for predicate ' + predicate_name + ' and config: ' + str(pi))
continue
else:
predicate_info['sub_idx'] = 0 # As we don't have nested elements in this predicate
subscribed = self.subscribe_topic(predicate_name, predicate_info)
if not subscribed:
rospy.loginfo('Could not subscribe for predicate ' + predicate_name + ' and config: ' + str(predicate_info))
############
# Create clients for all the services
self.service_clients = []
self.service_names = []
self.service_type_names = []
self.service_predicate_names = []
self.last_called_time = []
self.time_between_calls = []
self.request_src = []
self.response_process_src = []
self.clients_sub_idx = []
for predicate_name, predicate_info in self.cfg_service.iteritems():
if type(predicate_info) is list:
for i, pi in enumerate(predicate_info):
pi['sub_idx'] = i
client_created = self.create_service_client(predicate_name, pi)
if not client_created:
rospy.loginfo('Could not create client for predicate ' + predicate_name + ' and config: ' + str(pi))
continue
else:
predicate_info['sub_idx'] = 0 # As we don't have nested elements in this predicate
client_created = self.create_service_client(predicate_name, predicate_info)
if not client_created:
rospy.loginfo('Could not create client for predicate ' + predicate_name + ' and config: ' + str(predicate_info))
continue
# Returns (bool, bool), first tells if the parameters could be loaded, second if parameters were loaded from config file and false if they were taken directly from the kb
def load_params(self, predicate_name, predicate_info):
# Check if predicate
kb_info = None
try:
kb_info = self.get_predicates_srv.call(GetDomainPredicateDetailsServiceRequest(predicate_name)).predicate
except Exception as e:
kb_info = self.get_function_params(predicate_name)
if not kb_info:
rospy.logerr("KCL: (RosplanSensing) Could not find predicate or function %s" % predicate_name)
return (False, False)
if predicate_name not in self.params: # Prepare dictionary
self.params[predicate_name] = {}
# Obtain all the instances for each parameter
kb_params = []
for p in kb_info.typed_parameters:
instances = self.get_instances_srv.call(GetInstanceServiceRequest(p.value)).instances
kb_params.append(instances)
if 'params' in predicate_info:
params = predicate_info['params']
if len(kb_params) != len(params):
rospy.logerr("KCL: (RosplanSensing) Parameters defined for predicate %s don't match the knowledge base" % predicate_name)
rospy.signal_shutdown('Wrong cfg file parameters definition')
return (False, True)
# Check params
wildcard = False
for i, p in enumerate(params):
if p != '*' and p != '_':
if p in kb_params[i]:
kb_params[i] = [p]
else:
rospy.logerr('KCL: (RosplanSensing) Unknown parameter instance "%s" of type "%s" for predicate "%s"',
p, kb_info.typed_parameters[i].value, predicate_name)
rospy.signal_shutdown('Wrong cfg file parameters definition')
return (False, True)
else:
wildcard = True
# If the params are fully instantiated we store them as a list, else it will be a matrix with a list of
# instances per parameter
self.params[predicate_name][predicate_info['sub_idx']] = kb_params if wildcard else params
return (True, True)
else:
self.params[predicate_name][predicate_info['sub_idx']] = kb_params
return (True, False)
def subscribe_topic(self, predicate_name, predicate_info):
params_loaded = self.load_params(predicate_name, predicate_info) # If parameters found, add 1 to the indexes
if not params_loaded[0]:
return False
if len(predicate_info) < 2 + int(params_loaded[1]):
rospy.logerr("Error: Wrong configuration file for predicate %s" % predicate_name)
return False
try:
msg_type = predicate_info['msg_type']
except KeyError:
rospy.logerr("Error: msg_type was not specified for predicate %s" % predicate_name)
return False
self.import_msg(msg_type)
try:
if isinstance(predicate_info['topic'], list):
for topic in predicate_info['topic']:
pred_info = predicate_info.copy()
pred_info['publisher'] = topic
rospy.Subscriber(str(topic), eval(msg_type[msg_type.rfind('/') + 1:]), self.subs_callback, (predicate_name, pred_info))
else:
rospy.Subscriber(predicate_info['topic'], eval(msg_type[msg_type.rfind('/') + 1:]), self.subs_callback, (predicate_name, predicate_info))
except KeyError:
rospy.logerr("Error: topic was not specified for predicate %s" % predicate_name)
return False
# self.sensed_topics[predicate_name] = (None, False)
try: # Update KB to inform about the sensed predicates
sensed_srv_req = SetNamedBoolRequest()
sensed_srv_req.name = predicate_name
sensed_srv_req.value = True
self.set_sensed_predicate_srv.call(sensed_srv_req)
except Exception as e:
rospy.logerr(
'KCL: (RosplanSensing) Could not update sensing information in Knowledge Base for proposition %s',
predicate_name)
rospy.loginfo('KCL: (RosplanSensing) Predicate %s: Subscribed to topic %s of type %s', predicate_name,
predicate_info['topic'], msg_type)
return True
def create_service_client(self, predicate_name, predicate_info):
params_loaded = self.load_params(predicate_name, predicate_info) # If parameters found, add 1 to the indexes
if not params_loaded[0]:
return False
if len(predicate_info) < 2 + int(params_loaded[1]):
rospy.logerr("Error: Wrong configuration file for predicate %s" % predicate_name)
return False
try:
srv_type = predicate_info['srv_type']
except KeyError:
rospy.logerr("Error: service was not specified for predicate %s" % predicate_name)
return False
srv_typename = self.import_srv(srv_type)
self.service_type_names.append(srv_typename)
self.clients_sub_idx.append(predicate_info['sub_idx'])
try:
self.service_clients.append(rospy.ServiceProxy(predicate_info['service'], eval(srv_typename)))
self.service_names.append(predicate_info['service'])
except KeyError:
rospy.logerr("Error: service was not specified for predicate %s" % predicate_name)
return False
self.service_predicate_names.append(predicate_name)
self.last_called_time.append(rospy.Time(0))
try:
self.time_between_calls.append(predicate_info['time_between_calls'])
except:
rospy.logerr("Error: time_between_calls was not specified for predicate %s" % predicate_name)
return False
# Gets the request creation
if 'request' in predicate_info:
self.request_src.append(predicate_info['request'])
else:
self.request_src.append(None)
# Gets the result processing
if 'operation' in predicate_info:
self.response_process_src.append(predicate_info['operation'])
else:
self.response_process_src.append(None)
try: # Update KB to inform about the sensed predicates
sensed_srv_req = SetNamedBoolRequest()
sensed_srv_req.name = predicate_name
sensed_srv_req.value = True
self.set_sensed_predicate_srv.call(sensed_srv_req)
except Exception as e:
rospy.logerr(
'KCL: (RosplanSensing) Could not update sensing information in Knowledge Base for proposition %s',
predicate_name)
rospy.loginfo('KCL: (RosplanSensing) Predicate %s: Client for service %s of type %s is ready', predicate_name,
predicate_info['service'], srv_type)
return True
def get_function_params(self, func_name):
functions = self.get_functions_srv.call()
for i in functions.items:
if i.name == func_name:
return i
return None
def subs_callback(self, msg, predicate):
pred_name, pred_info = predicate
if 'operation' in pred_info: # pred_info is of type self.cfg_topics[pred_name]
python_string = pred_info['operation']
else: # Call the method from the scripts.py file
if not pred_name in dir(self.scripts):
rospy.logerr('KCL: (RosplanSensing) Predicate "%s" does not have either a function or processing information' % pred_name)
return None
if 'publisher' in pred_info:
python_string = "self.scripts." + pred_name + "(msg, self.params[pred_name][pred_info['sub_idx']], pred_info['publisher'])"
else:
python_string = "self.scripts." + pred_name + "(msg, self.params[pred_name][pred_info['sub_idx']])"
self.mutex.acquire(True)
result = eval(python_string, globals(), locals())
self.mutex.release()
changed = False
if type(result) is list:
for params, val in result:
self.mutex.acquire(True) # ROS subscribers are multithreaded in Python
try:
if type(val) is bool:
changed = self.sensed_topics[pred_name + ':' + params][0] ^ val
else:
changed = self.sensed_topics[pred_name + ':' + params][0] != val
except: # If hasn't been added yet just ignore it
changed = True
if changed:
self.sensed_topics[pred_name + ':' + params] = (val, changed, False)
self.mutex.release()
else:
params = reduce(lambda r, x: r + ':' + x, self.params[pred_name][pred_info['sub_idx']])
if type(params) == list:
rospy.logerr('KCL: (RosplanSensing) Predicate "%s" needs to have all the parameters defined and fully instantiated' % pred_name)
rospy.signal_shutdown('Wrong cfg params')
return None
self.mutex.acquire(True) # ROS subscribers are multithreaded in Python
try:
if type(result) is bool:
changed = self.sensed_topics[pred_name + ':' + params][0] ^ result
else:
changed = self.sensed_topics[pred_name + ':' + params][0] != result
except: # If hasn't been added yet just ignore it
changed = True
if changed:
self.sensed_topics[pred_name + ':' + params] = (result, changed, False)
self.mutex.release()
# Import a ros msg type of type pkg_name/MessageName
def import_msg(self, ros_msg_string):
# msg_string will be something like std_msgs/String -> convert it to from std_msgs.msg import String
i = ros_msg_string.find('/')
pkg_name = ros_msg_string[:i]
msg_name = ros_msg_string[i+1:]
exec('from ' + pkg_name + ".msg import " + msg_name, globals())
exec('self.scripts.' + msg_name + " = " + msg_name, globals(), locals())
# Import a ros srv type of type pkg_name/MessageName
def import_srv(self, ros_srv_string):
# srv str will be something like std_msgs/String -> convert it to from std_msgs.srv import String StringRequest
i = ros_srv_string.find('/')
pkg_name = ros_srv_string[:i]
srv_name = ros_srv_string[i + 1:]
exec ('from ' + pkg_name + ".srv import " + srv_name + ", " + srv_name + "Request", globals())
exec ('self.scripts.' + srv_name + " = " + srv_name, globals(), locals())
exec ('self.scripts.' + srv_name + "Request = " + srv_name + "Request", globals(), locals())
return srv_name
# To be run in its own thread
def call_services(self):
rospy.loginfo("Waiting for services to become available...")
for i in xrange(len(self.service_names)):
rospy.loginfo(' Waiting for %s', self.service_names[i])
rospy.wait_for_service(self.service_names[i], 20)
rospy.loginfo('All services are ready.')
r = rospy.Rate(20)
while not rospy.is_shutdown():
for i in xrange(len(self.service_clients)):
now = rospy.Time.now()
if (now-self.last_called_time[i]) < rospy.Duration(self.time_between_calls[i]):
continue
pred_name = self.service_predicate_names[i]
# Get request
if self.request_src[i]:
python_string = self.request_src[i]
else: # Call the method from the scripts.py file
if not ('req_' + pred_name) in dir(self.scripts):
rospy.logerr(
'KCL: (RosplanSensing) Predicate "%s" does not have either a Request creation method' % pred_name)
continue
python_string = "self.scripts." + 'req_' + pred_name + "()"
req = eval(python_string, globals(), locals())
try:
res = self.service_clients[i].call(req)
self.last_called_time[i] = now
except Exception as e:
rospy.logerr("KCL (SensingInterface) Failed to call service for predicate %s base: %s" % (pred_name, e.message))
continue
# Process response
if self.response_process_src[i]:
python_string = self.response_process_src[i]
else: # Call the method from the scripts.py file
if not pred_name in dir(self.scripts):
rospy.logerr('KCL: (RosplanSensing) Predicate "%s" does not have either a function or processing information' %
pred_name)
continue
python_string = "self.scripts." + pred_name + "(res, self.params[pred_name][self.clients_sub_idx[i]])"
result = eval(python_string, globals(), locals())
changed = False
if type(result) is list:
for params, val in result:
self.srv_mutex.acquire(True) # ROS subscribers are multithreaded in Python
try:
if type(val) is bool:
changed = self.sensed_services[pred_name + ':' + params][0] ^ val
else:
changed = self.sensed_services[pred_name + ':' + params][0] != val
except: # If hasn't been added yet just ignore it
changed = True
if changed:
self.sensed_services[pred_name + ':' + params] = (val, changed, False)
self.srv_mutex.release()
else:
params = reduce(lambda r, x: r + ':' + x, self.params[pred_name][self.clients_sub_idx[i]]) if self.params[pred_name][self.clients_sub_idx[i]] else ''
if type(params) == list:
rospy.logerr(
'KCL: (RosplanSensing) Predicate "%s" needs to have all the parameters defined and fully instantiated' % pred_name)
rospy.signal_shutdown('Wrong cfg params')
return None
self.srv_mutex.acquire(True) # ROS subscribers are multithreaded in Python
try:
if type(result) is bool:
changed = self.sensed_services[pred_name + ':' + params][0] ^ result
else:
changed = self.sensed_services[pred_name + ':' + params][0] != result
except: # If hasn't been added yet just ignore it
changed = True
if changed:
self.sensed_services[pred_name + ':' + params] = (result, changed, False)
self.srv_mutex.release()
r.sleep()
return None # Finish thread
def update_kb(self):
kus = KnowledgeUpdateServiceArrayRequest()
# Get info from KB functions and propositions (to know type of variable)
# Fill update
self.dump_cache_mutex.acquire(True)
self.mutex.acquire(True)
sensed_predicates = self.sensed_topics.copy()
self.mutex.release()
self.srv_mutex.acquire(True)
sensed_predicates.update(self.sensed_services.copy())
self.srv_mutex.release()
for predicate, (val, changed, updated) in sensed_predicates.iteritems():
if updated:
continue
if predicate in self.sensed_topics:
self.mutex.acquire(True)
self.sensed_topics[predicate] = (self.sensed_topics[predicate][0], False, True) # Set to not changed and updated KB
self.mutex.release()
else:
self.srv_mutex.acquire(True)
self.sensed_services[predicate] = (self.sensed_services[predicate][0], False, True) # Set to not changed and updated KB
self.srv_mutex.release()
predicate_info = predicate.split(':')
ki = KnowledgeItem()
ki.attribute_name = predicate_info.pop(0)
if type(val) is bool:
ki.knowledge_type = ki.FACT
ki.is_negative = not val
else:
ki.knowledge_type = ki.FUNCTION
ki.function_value = val
# TODO what to do if no parameters specified? iterate over all the instantiated parameters and add them?
for i, param in enumerate(predicate_info):
kv = KeyValue()
kv.key = 'p' + str(i)
kv.value = param
ki.values.append(kv)
kus.update_type += np.array(kus.ADD_KNOWLEDGE).tostring()
kus.knowledge.append(ki)
self.dump_cache_mutex.release()
# Update the KB with the full array
if len(kus.update_type) > 0:
try:
self.update_kb_srv.call(kus)
except Exception as e:
rospy.logerr("KCL (SensingInterface) Failed to update knowledge base: %s" % e.message)
def get_kb_attribute(self, attribute_name):
try:
request = GetAttributeServiceRequest(attribute_name)
ret = self.get_state_propositions_srv.call(request)
if len(ret.attributes) > 0:
return ret.attributes
return self.get_state_functions_srv.call(request).attributes
except Exception as e:
rospy.logwarn("KCL (SensingInterface) Failed to call knowledge base for details: %s" % e.message)
return []
def kb_update_status(self, msg):
if not msg.last_update_client == rospy.get_name(): # if I did not update the KB....
self.dump_cache_mutex.acquire(True)
self.mutex.acquire(True)
self.srv_mutex.acquire(True)
# Dump cache, it will be reloaded in the next update
for predicate, (val, changed, updated) in self.sensed_topics.iteritems():
self.sensed_topics[predicate] = (val, changed, False)
self.sensed_services.clear()
self.srv_mutex.release()
self.mutex.release()
self.dump_cache_mutex.release()
if __name__ == "__main__":
rospy.init_node('rosplan_sensing_interface', anonymous=False)
rps = RosplanSensing()
t = threading.Thread(target=RosplanSensing.call_services, args=(rps,))
# main loop
hz_rate = rospy.get_param('~main_rate', 10)
rate = rospy.Rate(hz_rate) # 10hz
t.start()
while not rospy.is_shutdown():
# Note: spin is not needed in python as the callback methods are run in a different thread
rps.update_kb()
rate.sleep()
t.join()
|
sleep.py
|
__copyright__ = "Copyright 2013-2016, http://radical.rutgers.edu"
__license__ = "MIT"
import os
import time
import threading as mt
import radical.utils as ru
from ... import states as rps
from ... import constants as rpc
from .base import AgentExecutingComponent
# ------------------------------------------------------------------------------
#
class Sleep(AgentExecutingComponent) :
# --------------------------------------------------------------------------
#
def __init__(self, cfg, session):
AgentExecutingComponent.__init__ (self, cfg, session)
# --------------------------------------------------------------------------
#
def initialize(self):
self._pwd = os.getcwd()
self.register_input(rps.AGENT_EXECUTING_PENDING,
rpc.AGENT_EXECUTING_QUEUE, self.work)
self.register_output(rps.AGENT_STAGING_OUTPUT_PENDING,
rpc.AGENT_STAGING_OUTPUT_QUEUE)
self.register_publisher (rpc.AGENT_UNSCHEDULE_PUBSUB)
self._terminate = mt.Event()
self._tasks_lock = ru.RLock()
self._tasks = list()
self._delay = 0.1
self._watcher = mt.Thread(target=self._timed)
self._watcher.daemon = True
self._watcher.start()
# --------------------------------------------------------------------------
#
def finalize(self):
self._terminate.set()
self._watcher.join()
# --------------------------------------------------------------------------
#
def work(self, tasks):
self.advance(tasks, rps.AGENT_EXECUTING, publish=True, push=False)
for task in tasks:
try:
self._handle_task(task)
except Exception:
# append the startup error to the tasks stderr. This is
# not completely correct (as this text is not produced
# by the task), but it seems the most intuitive way to
# communicate that error to the application/user.
self._log.exception("error running Task")
if task['stderr'] is None:
task['stderr'] = ''
task['stderr'] += '\nPilot cannot start task:\n'
task['stderr'] += '\n'.join(ru.get_exception_trace())
# can't rely on the executor base to free the task resources
self._prof.prof('unschedule_start', uid=task['uid'])
self.publish(rpc.AGENT_UNSCHEDULE_PUBSUB, task)
self.advance(task, rps.FAILED, publish=True, push=False)
with self._tasks_lock:
self._tasks.extend(tasks)
# --------------------------------------------------------------------------
#
def _handle_task(self, task):
now = time.time()
# assert(t['description']['executable'].endswith('sleep'))
task['to_finish'] = now + float(task['description']['arguments'][0])
uid = task['uid']
self._prof.prof('exec_start', uid=uid)
self._prof.prof('exec_ok', uid=uid)
self._prof.prof('task_start', uid=uid)
self._prof.prof('task_exec_start', uid=uid)
self._prof.prof('app_start', uid=uid)
# --------------------------------------------------------------------------
#
def _timed(self):
while not self._terminate.is_set():
time.sleep(self._delay)
with self._tasks_lock:
now = time.time()
to_finish = [t for t in self._tasks if t['to_finish'] <= now]
self._tasks = [t for t in self._tasks if t['to_finish'] > now]
for task in to_finish:
uid = task['uid']
task['target_state'] = 'DONE'
self._prof.prof('app_stop', uid=uid)
self._prof.prof('task_exec_stop', uid=uid)
self._prof.prof('task_stop', uid=uid)
self._prof.prof('exec_stop', uid=uid)
self._prof.prof('unschedule_start', uid=uid)
self.publish(rpc.AGENT_UNSCHEDULE_PUBSUB, task)
self.advance(to_finish, rps.AGENT_STAGING_OUTPUT_PENDING,
publish=True, push=True)
# --------------------------------------------------------------------------
#
def command_cb(self, topic, msg):
self._log.info('command_cb [%s]: %s', topic, msg)
cmd = msg['cmd']
if cmd == 'cancel_tasks':
# FIXME: clarify how to cancel tasks
pass
return True
# ------------------------------------------------------------------------------
|
threading_with_webservers__flask.py
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
import threading
def run(port=80):
from flask import Flask
app = Flask(__name__)
import logging
logging.basicConfig(level=logging.DEBUG)
@app.route("/")
def index():
html = "Hello World! (port={})".format(port)
print(html)
return html
app.run(port=port)
if __name__ == '__main__':
# NOTE: recommended to add daemon=False or call join() for each thread
thread = threading.Thread(target=run, args=(5000, ))
thread.start()
thread = threading.Thread(target=run, args=(5001, ))
thread.start()
thread = threading.Thread(target=run, args=(5002,))
thread.start()
# OR:
# for port in [5000, 5001, 5002]:
# thread = threading.Thread(target=run, args=(port,))
# thread.start()
|
test_restful.py
|
#!/usr/bin/python3
'''
DISTRIBUTION STATEMENT A. Approved for public release: distribution unlimited.
This material is based upon work supported by the Assistant Secretary of Defense for
Research and Engineering under Air Force Contract No. FA8721-05-C-0002 and/or
FA8702-15-D-0001. Any opinions, findings, conclusions or recommendations expressed in this
material are those of the author(s) and do not necessarily reflect the views of the
Assistant Secretary of Defense for Research and Engineering.
Copyright 2017 Massachusetts Institute of Technology.
The software/firmware is provided to you on an As-Is basis
Delivered to the US Government with Unlimited Rights, as defined in DFARS Part
252.227-7013 or 7014 (Feb 2014). Notwithstanding any copyright notice, U.S. Government
rights in this work are defined by DFARS 252.227-7013 or DFARS 252.227-7014 as detailed
above. Use of this work other than as specifically authorized by the U.S. Government may
violate any copyrights that exist in this work.
'''
""" NOTE:
This unittest is being used as a procedural test.
The tests must be run in-order and CANNOT be parallelized!
Tests all but two RESTful interfaces:
* agent's POST /v2/keys/vkey
- Done by CV after the CV's POST /v2/agents/{UUID} command is performed
* CV's PUT /v2/agents/{UUID}
- POST already bootstraps agent, so PUT is redundant in this test
The registrar's PUT vactivate interface is only tested if a vTPM is present!
"""
""" USAGE:
Should be run in test directory under root privileges with either command:
* python -m unittest -v test_restful
* green -vv
(with `pip install green`)
To run without root privileges, be sure to export KEYLIME_TEST=True
For Python Coverage support (pip install coverage), set env COVERAGE_FILE and:
* coverage run --parallel-mode test_restful.py
"""
# System imports
import asyncio
import http.client
import dbus
import sys
import signal
import unittest
import subprocess
import time
import os
import configparser
import base64
import threading
import shutil
import errno
import pytest
import hashlib
try:
import simplejson as json
except ImportError:
raise("Simplejson is mandatory, please install")
from pathlib import Path
# Coverage support
if "COVERAGE_FILE" in os.environ:
FORK_ARGS = ["coverage", "run", "--parallel-mode"]
if "COVERAGE_DIR" in os.environ:
FORK_ARGS += ["--rcfile="+os.environ["COVERAGE_DIR"]+"/.coveragerc"]
else:
FORK_ARGS = ["python3"]
# Custom imports
PACKAGE_ROOT = Path(__file__).parents[1]
KEYLIME_DIR=(f"{PACKAGE_ROOT}/keylime")
sys.path.append(KEYLIME_DIR)
# Custom imports
# PACKAGE_ROOT = Path(__file__).parents[1]
# CODE_ROOT = (f"{PACKAGE_ROOT}/keylime/")
# sys.path.insert(0, CODE_ROOT)
# keylime imports
from keylime import common
from keylime import tornado_requests
from keylime import httpclient_requests
from keylime import registrar_client
from keylime import tenant
from keylime import crypto
from keylime import user_data_encrypt
from keylime import secure_mount
from keylime import tpm_obj
from keylime import tpm_abstract
# Will be used to communicate with the TPM
tpm = None
# cmp depreciated in Python 3, so lets recreate it.
def cmp(a, b):
return (a > b) - (a < b)
#Ensure this is run as root
if os.geteuid() != 0 and common.REQUIRE_ROOT:
exit("Tests need to be run with root privileges, or set env KEYLIME_TEST=True!")
# Force sorting tests alphabetically
unittest.TestLoader.sortTestMethodsUsing = lambda _, x, y: cmp(x, y)
# Config-related stuff
config = configparser.ConfigParser()
config.read(common.CONFIG_FILE)
# Environment to pass to services
script_env = os.environ.copy()
# Globals to keep track of Keylime components
cv_process = None
reg_process = None
agent_process = None
tenant_templ = None
# Class-level components that are not static (so can't be added to test class)
public_key = None
keyblob = None
ek = None
aik = None
vtpm = False
# Like os.remove, but ignore file DNE exceptions
def fileRemove(path):
try:
os.remove(path)
except OSError as e:
# Ignore if file does not exist
if e.errno != errno.ENOENT:
raise
# Boring setup stuff
def setUpModule():
try:
env = os.environ.copy()
env['PATH']=env['PATH']+":/usr/local/bin"
# Run init_tpm_server and tpm_serverd (start fresh)
its = subprocess.Popen(["init_tpm_server"], shell=False, env=env)
its.wait()
tsd = subprocess.Popen(["tpm_serverd"], shell=False, env=env)
tsd.wait()
except Exception as e:
print("WARNING: Restarting TPM emulator failed!")
# Note: the following is required as abrmd is failing to reconnect to MSSIM, once
# MSSIM is killed and restarted. If this is an proved an actual bug and is
# fixed upstream, the following dbus restart call can be removed.
try:
sysbus = dbus.SystemBus()
systemd1 = sysbus.get_object('org.freedesktop.systemd1', '/org/freedesktop/systemd1')
manager = dbus.Interface(systemd1, 'org.freedesktop.systemd1.Manager')
# If the systemd service exists, let's restart it.
for service in sysbus.list_names():
if "com.intel.tss2.Tabrmd" in service:
print("Found dbus service:", str(service))
try:
print("Restarting tpm2-abrmd.service.")
job = manager.RestartUnit('tpm2-abrmd.service', 'fail')
except dbus.exceptions.DBusException as e:
print(e)
except Exception as e:
print("Non systemd agent detected, no tpm2-abrmd restart required.")
try:
# Start with a clean slate for this test
fileRemove(common.WORK_DIR + "/tpmdata.yaml")
fileRemove(common.WORK_DIR + "/cv_data.sqlite")
fileRemove(common.WORK_DIR + "/reg_data.sqlite")
shutil.rmtree(common.WORK_DIR + "/cv_ca", True)
except Exception as e:
print("WARNING: Cleanup of TPM files failed!")
# CV must be run first to create CA and certs!
launch_cloudverifier()
launch_registrar()
#launch_cloudagent()
# get the tpm object
global tpm
tpm = tpm_obj.getTPM(need_hw_tpm=True)
# Make the Tenant do a lot of set-up work for us
global tenant_templ
tenant_templ = tenant.Tenant()
tenant_templ.cloudagent_ip = "localhost"
tenant_templ.agent_uuid = config.get('cloud_agent', 'agent_uuid')
tenant_templ.registrar_boot_port = config.get('registrar', 'registrar_port')
tenant_templ.registrar_tls_boot_port = config.get('registrar', 'registrar_tls_port')
# Destroy everything on teardown
def tearDownModule():
# Tear down in reverse order of dependencies
kill_cloudagent()
kill_cloudverifier()
kill_registrar()
def launch_cloudverifier():
"""Start up the cloud verifier"""
global cv_process, script_env, FORK_ARGS
if cv_process is None:
cv_process = subprocess.Popen(
"keylime_verifier",
shell=False,
preexec_fn=os.setsid,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=script_env
)
def initthread():
sys.stdout.write('\033[96m' + "\nCloud Verifier Thread" + '\033[0m')
while True:
line = cv_process.stdout.readline()
if line==b'':
break
line = line.decode('utf-8')
line = line.rstrip(os.linesep)
sys.stdout.flush()
sys.stdout.write('\n\033[96m' + line + '\033[0m')
t = threading.Thread(target=initthread)
t.start()
time.sleep(30)
return True
def launch_registrar():
"""Start up the registrar"""
global reg_process, script_env, FORK_ARGS
if reg_process is None:
reg_process = subprocess.Popen(
"keylime_registrar",
shell=False,
preexec_fn=os.setsid,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=script_env
)
def initthread():
sys.stdout.write('\033[95m' + "\nRegistrar Thread" + '\033[0m')
while True:
line = reg_process.stdout.readline()
if line==b"":
break
#line = line.rstrip(os.linesep)
line = line.decode('utf-8')
sys.stdout.flush()
sys.stdout.write('\n\033[95m' + line + '\033[0m')
t = threading.Thread(target=initthread)
t.start()
time.sleep(10)
return True
def launch_cloudagent():
"""Start up the cloud agent"""
global agent_process, script_env, FORK_ARGS
if agent_process is None:
agent_process = subprocess.Popen(
"keylime_agent",
shell=False,
preexec_fn=os.setsid,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=script_env
)
def initthread():
sys.stdout.write('\033[94m' + "\nCloud Agent Thread" + '\033[0m')
while True:
line = agent_process.stdout.readline()
if line==b'':
break
#line = line.rstrip(os.linesep)
line = line.decode('utf-8')
sys.stdout.flush()
sys.stdout.write('\n\033[94m' + line + '\033[0m')
t = threading.Thread(target=initthread)
t.start()
time.sleep(10)
return True
def kill_cloudverifier():
"""Kill the cloud verifier"""
global cv_process
if cv_process is None:
return
os.killpg(os.getpgid(cv_process.pid), signal.SIGINT)
cv_process.wait()
cv_process = None
def kill_registrar():
"""Kill the registrar"""
global reg_process
if reg_process is None:
return
os.killpg(os.getpgid(reg_process.pid), signal.SIGINT)
reg_process.wait()
reg_process = None
def kill_cloudagent():
"""Kill the cloud agent"""
global agent_process
if agent_process is None:
return
os.killpg(os.getpgid(agent_process.pid), signal.SIGINT)
agent_process.wait()
agent_process = None
def services_running():
if reg_process.poll() is None and cv_process.poll() is None:
return True
return False
class TestRestful(unittest.TestCase):
# Static class members (won't change between tests)
payload = None
auth_tag = None
tpm_policy = None
vtpm_policy = {}
metadata = {}
ima_whitelist = {}
revocation_key = ""
K = None
U = None
V = None
api_version = common.API_VERSION
@classmethod
def setUpClass(cls):
"""Prepare the keys and payload to give to the CV"""
contents = "random garbage to test as payload"
#contents = contents.encode('utf-8')
ret = user_data_encrypt.encrypt(contents)
cls.K = ret['k']
cls.U = ret['u']
cls.V = ret['v']
cls.payload = ret['ciphertext']
"""Set up to register an agent"""
cls.auth_tag = crypto.do_hmac(cls.K,tenant_templ.agent_uuid)
"""Prepare policies for agent"""
cls.tpm_policy = config.get('tenant', 'tpm_policy')
cls.vtpm_policy = config.get('tenant', 'vtpm_policy')
cls.tpm_policy = tpm_abstract.TPM_Utilities.readPolicy(cls.tpm_policy)
cls.vtpm_policy = tpm_abstract.TPM_Utilities.readPolicy(cls.vtpm_policy)
"""Allow targeting a specific API version (default latest)"""
cls.api_version = common.API_VERSION
def setUp(self):
"""Nothing to set up before each test"""
pass
"""Ensure everyone is running before doing tests"""
def test_000_services(self):
self.assertTrue(services_running(), "Not all services started successfully!")
"""Registrar Testset"""
def test_010_reg_agent_post(self):
"""Test registrar's POST /v2/agents/{UUID} Interface"""
global keyblob, aik, vtpm, ek
# Change CWD for TPM-related operations
cwd = os.getcwd()
common.ch_dir(common.WORK_DIR,None)
secdir = secure_mount.mount()
# Initialize the TPM with AIK
(ek,ekcert,aik,ek_tpm,aik_name) = tpm.tpm_init(self_activate=False,config_pw=config.get('cloud_agent','tpm_ownerpassword'))
vtpm = tpm.is_vtpm()
# Seed RNG (root only)
if common.REQUIRE_ROOT:
tpm.init_system_rand()
# Handle virtualized and emulated TPMs
if ekcert is None:
if vtpm:
ekcert = 'virtual'
elif tpm.is_emulator():
ekcert = 'emulator'
# Get back to our original CWD
common.ch_dir(cwd,None)
data = {
'ek': ek,
'ekcert': ekcert,
'aik': aik,
'aik_name': aik_name,
'ek_tpm': ek_tpm,
'tpm_version': tpm.get_tpm_version(),
}
v_json_message = json.dumps(data)
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("POST", "%s"%tenant_templ.registrar_ip,tenant_templ.registrar_boot_port, params=params, data=v_json_message, context=None)
self.assertEqual(response.status, 200, "Non-successful Registrar agent Add return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("blob", json_response["results"], "Malformed response body!")
keyblob = json_response["results"]["blob"]
self.assertIsNotNone(keyblob, "Malformed response body!")
@unittest.skipIf(vtpm == True, "Registrar's PUT /v2/agents/{UUID}/activate only for non-vTPMs!")
def test_011_reg_agent_activate_put(self):
"""Test registrar's PUT /v2/agents/{UUID}/activate Interface"""
global keyblob, aik
self.assertIsNotNone(keyblob, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(aik, "Required value not set. Previous step may have failed?")
key = tpm.activate_identity(keyblob)
data = {
'auth_tag': crypto.do_hmac(key,tenant_templ.agent_uuid),
}
v_json_message = json.dumps(data)
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}/activate"
response = httpclient_requests.request("PUT", "%s"%tenant_templ.registrar_ip,tenant_templ.registrar_boot_port, params=params, data=v_json_message, context=None)
self.assertEqual(response.status, 200, "Non-successful Registrar agent Activate return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
@unittest.skipIf(vtpm == False, "Registrar's PUT /v2/agents/{UUID}/vactivate only for vTPMs!")
def test_012_reg_agent_vactivate_put(self):
"""Test registrar's PUT /v2/agents/{UUID}/vactivate Interface"""
global keyblob, aik, ek
self.assertIsNotNone(keyblob, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(aik, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(ek, "Required value not set. Previous step may have failed?")
key = tpm.activate_identity(keyblob)
deepquote = tpm.create_deep_quote(hashlib.sha1(key).hexdigest(),tenant_templ.agent_uuid+aik+ek)
data = {
'deepquote': deepquote,
}
v_json_message = json.dumps(data)
params = '/v%s/agents/%s/vactivate'% self.api_version, tenant_templ.agent_uuid
response = httpclient_requests.request("PUT", "%s"%tenant_templ.registrar_ip,tenant_templ.registrar_tls_boot_port, params=params, data=v_json_message, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful Registrar agent vActivate return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
def test_013_reg_agents_get(self):
"""Test registrar's GET /v2/agents Interface"""
params = f"/v{self.api_version}/agents/"
response = httpclient_requests.request("GET", "%s"%tenant_templ.registrar_ip,tenant_templ.registrar_tls_boot_port, params=params, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful Registrar agent List return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("uuids", json_response["results"], "Malformed response body!")
# We registered exactly one agent so far
self.assertEqual(1, len(json_response["results"]["uuids"]), "Incorrect system state!")
def test_014_reg_agent_get(self):
"""Test registrar's GET /v2/agents/{UUID} Interface"""
global aik
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("GET", "%s"%(tenant_templ.registrar_ip),tenant_templ.registrar_tls_boot_port, params=params, data=None, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful Registrar agent return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("aik", json_response["results"], "Malformed response body!")
self.assertIn("ek", json_response["results"], "Malformed response body!")
self.assertIn("ekcert", json_response["results"], "Malformed response body!")
aik = json_response["results"]["aik"]
#TODO: results->provider_keys is only for virtual mode
def test_015_reg_agent_delete(self):
"""Test registrar's DELETE /v2/agents/{UUID} Interface"""
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("DELETE", "%s"%(tenant_templ.registrar_ip),tenant_templ.registrar_tls_boot_port, params=params, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful Registrar Delete return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
"""Agent Setup Testset"""
def test_020_agent_keys_pubkey_get(self):
"""Test agent's GET /v2/keys/pubkey Interface"""
# We want a real cloud agent to communicate with!
launch_cloudagent()
params = f"/v{self.api_version}/keys/pubkey"
response = httpclient_requests.request("GET", "%s"%tenant_templ.cloudagent_ip,tenant_templ.cloudagent_port, params=params)
self.assertEqual(response.status, 200, "Non-successful Agent pubkey return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("pubkey", json_response["results"], "Malformed response body!")
global public_key
public_key = json_response["results"]["pubkey"]
self.assertNotEqual(public_key, None, "Malformed response body!")
def test_021_reg_agent_get(self):
# We need to refresh the aik value we've stored in case it changed
self.test_014_reg_agent_get()
def test_022_agent_quotes_identity_get(self):
"""Test agent's GET /v2/quotes/identity Interface"""
global aik
self.assertIsNotNone(aik, "Required value not set. Previous step may have failed?")
nonce = tpm_abstract.TPM_Utilities.random_password(20)
numretries = config.getint('tenant','max_retries')
while numretries >= 0:
params = f"/v{self.api_version}/quotes/identity?nonce={nonce}"
response = httpclient_requests.request("GET", "%s"%tenant_templ.cloudagent_ip,tenant_templ.cloudagent_port, params=params, data=None, context=None)
if response.status == 200:
break
numretries-=1
time.sleep(config.getint('tenant','max_retries'))
self.assertEqual(response.status, 200, "Non-successful Agent identity return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("quote", json_response["results"], "Malformed response body!")
self.assertIn("pubkey", json_response["results"], "Malformed response body!")
# Check the quote identity
self.assertTrue(tpm.check_quote(tenant_templ.agent_uuid,nonce,json_response["results"]["pubkey"],json_response["results"]["quote"],aik),
"Invalid quote!")
@unittest.skip("Testing of agent's POST /v2/keys/vkey disabled! (spawned CV should do this already)")
def test_023_agent_keys_vkey_post(self):
"""Test agent's POST /v2/keys/vkey Interface"""
# CV should do this (during CV POST/PUT test)
# Running this test might hide problems with the CV sending the V key
global public_key
self.assertIsNotNone(self.V, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(public_key, "Required value not set. Previous step may have failed?")
encrypted_V = crypto.rsa_encrypt(crypto.rsa_import_pubkey(public_key),str(self.V))
b64_encrypted_V = base64.b64encode(encrypted_V)
data = {
'encrypted_key': b64_encrypted_V
}
v_json_message = json.dumps(data)
params = f"/v{self.api_version}/keys/vkey"
response = httpclient_requests.request("POST", "%s"%tenant_templ.cloudagent_ip,tenant_templ.cloudagent_port, params=params, data=v_json_message)
self.assertEqual(response.status, 200, "Non-successful Agent vkey post return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
def test_024_agent_keys_ukey_post(self):
"""Test agents's POST /v2/keys/ukey Interface"""
global public_key
self.assertIsNotNone(public_key, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(self.U, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(self.auth_tag, "Required value not set. Previous step may have failed?")
self.assertIsNotNone(self.payload, "Required value not set. Previous step may have failed?")
encrypted_U = crypto.rsa_encrypt(crypto.rsa_import_pubkey(public_key),self.U)
b64_encrypted_u = base64.b64encode(encrypted_U)
data = {
'encrypted_key': b64_encrypted_u,
'auth_tag': self.auth_tag,
'payload': self.payload
}
u_yaml_message = json.dumps(data)
params = '/v%s/keys/ukey'% self.api_version
response = httpclient_requests.request("POST", "%s"%tenant_templ.cloudagent_ip,tenant_templ.cloudagent_port, params=params, data=u_yaml_message)
self.assertEqual(response.status, 200, "Non-successful Agent ukey post return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
"""Cloud Verifier Testset"""
def test_030_cv_agent_post(self):
"""Test CV's POST /v2/agents/{UUID} Interface"""
self.assertIsNotNone(self.V, "Required value not set. Previous step may have failed?")
b64_v = base64.b64encode(self.V)
data = {
'v': b64_v,
'cloudagent_ip': tenant_templ.cloudagent_ip,
'cloudagent_port': tenant_templ.cloudagent_port,
'tpm_policy': json.dumps(self.tpm_policy),
'vtpm_policy':json.dumps(self.vtpm_policy),
'ima_whitelist':json.dumps(self.ima_whitelist),
'metadata':json.dumps(self.metadata),
'revocation_key':self.revocation_key,
'accept_tpm_hash_algs': config.get('tenant','accept_tpm_hash_algs').split(','),
'accept_tpm_encryption_algs': config.get('tenant','accept_tpm_encryption_algs').split(','),
'accept_tpm_signing_algs': config.get('tenant','accept_tpm_signing_algs').split(','),
}
yaml_message = json.dumps(data)
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("POST", "%s"%(tenant_templ.cloudverifier_ip),tenant_templ.cloudverifier_port, params=params, data=yaml_message, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful CV agent Post return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
time.sleep(10)
@unittest.skip("Testing of CV's PUT /v2/agents/{UUID} disabled!")
def test_031_cv_agent_put(self):
"""Test CV's PUT /v2/agents/{UUID} Interface"""
#TODO: this should actually test PUT functionality (e.g., make agent fail and then PUT back up)
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("PUT", "%s"%(tenant_templ.cloudverifier_ip),tenant_templ.cloudverifier_port, params=params, data=b'', context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful CV agent Post return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
def test_032_cv_agents_get(self):
"""Test CV's GET /v2/agents Interface"""
params = f"/v{self.api_version}/agents/"
response = httpclient_requests.request("GET", "%s"%tenant_templ.cloudverifier_ip,tenant_templ.cloudverifier_port, params=params, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful CV agent List return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("uuids", json_response["results"], "Malformed response body!")
# Be sure our agent is registered
self.assertEqual(1, len(json_response["results"]["uuids"]))
def test_033_cv_agent_get(self):
"""Test CV's GET /v2/agents/{UUID} Interface"""
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("GET", "%s"%tenant_templ.cloudverifier_ip,tenant_templ.cloudverifier_port, params=params, context=tenant_templ.context)
self.assertEqual(response.status, 200, "Non-successful CV agent return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
# Check a few of the important properties are present
self.assertIn("operational_state", json_response["results"], "Malformed response body!")
self.assertIn("ip", json_response["results"], "Malformed response body!")
self.assertIn("port", json_response["results"], "Malformed response body!")
"""Agent Poll Testset"""
def test_040_agent_quotes_integrity_get(self):
"""Test agent's GET /v2/quotes/integrity Interface"""
global public_key, aik
self.assertIsNotNone(aik, "Required value not set. Previous step may have failed?")
nonce = tpm_abstract.TPM_Utilities.random_password(20)
mask = self.tpm_policy["mask"]
vmask = self.vtpm_policy["mask"]
partial = "1"
if public_key is None:
partial = "0"
params = f"/v{self.api_version}/quotes/integrity?nonce={nonce}&mask={mask}&vmask={vmask}&partial={partial}"
response = httpclient_requests.request("GET", "%s"%tenant_templ.cloudagent_ip,tenant_templ.cloudagent_port, params=params)
self.assertEqual(response.status, 200, "Non-successful Agent Integrity Get return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("quote", json_response["results"], "Malformed response body!")
if public_key is None:
self.assertIn("pubkey", json_response["results"], "Malformed response body!")
public_key = json_response["results"]["pubkey"]
self.assertIn("tpm_version", json_response["results"], "Malformed response body!")
self.assertIn("hash_alg", json_response["results"], "Malformed response body!")
quote = json_response["results"]["quote"]
tpm_version = json_response["results"]["tpm_version"]
hash_alg = json_response["results"]["hash_alg"]
validQuote = tpm.check_quote(tenant_templ.agent_uuid,
nonce,
public_key,
quote,
aik,
self.tpm_policy,
hash_alg=hash_alg)
self.assertTrue(validQuote)
async def test_041_agent_keys_verify_get(self):
"""Test agent's GET /v2/keys/verify Interface
We use async here to allow function await while key processes"""
self.assertIsNotNone(self.K, "Required value not set. Previous step may have failed?")
challenge = tpm_abstract.TPM_Utilities.random_password(20)
encoded = base64.b64encode(self.K).decode('utf-8')
response = tornado_requests.request("GET",
"http://%s:%s/keys/verify?challenge=%s"%(self.cloudagent_ip,self.cloudagent_port,challenge))
response = await response
self.assertEqual(response.status, 200, "Non-successful Agent verify return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
self.assertIn("hmac", json_response["results"], "Malformed response body!")
# Be sure response is valid
mac = json_response['results']['hmac']
ex_mac = crypto.do_hmac(encoded, challenge)
# ex_mac = crypto.do_hmac(self.K, challenge)
self.assertEqual(mac, ex_mac, "Agent failed to validate challenge code!")
"""CV Cleanup Testset"""
def test_050_cv_agent_delete(self):
"""Test CV's DELETE /v2/agents/{UUID} Interface"""
time.sleep(5)
params = f"/v{self.api_version}/agents/{tenant_templ.agent_uuid}"
response = httpclient_requests.request("DELETE", "%s"%tenant_templ.cloudverifier_ip,tenant_templ.cloudverifier_port, params=params, context=tenant_templ.context)
self.assertEqual(response.status, 202, "Non-successful CV agent Delete return code!")
json_response = json.loads(response.read().decode())
# Ensure response is well-formed
self.assertIn("results", json_response, "Malformed response body!")
def tearDown(self):
"""Nothing to bring down after each test"""
pass
@classmethod
def tearDownClass(cls):
"""Nothing to bring down"""
pass
if __name__ == '__main__':
unittest.main()
|
launch.py
|
#!/usr/bin/python2
"""
(C) Copyright 2018-2019 Intel Corporation.
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.
GOVERNMENT LICENSE RIGHTS-OPEN SOURCE SOFTWARE
The Government's rights to use, modify, reproduce, release, perform, display,
or disclose this software are subject to the terms of the Apache License as
provided in Contract No. B609815.
Any reproduction of computer software, computer software documentation, or
portions thereof marked with this legend must also reproduce the markings.
"""
from __future__ import print_function
from argparse import ArgumentParser, RawDescriptionHelpFormatter
import json
from multiprocessing import Process
import os
import re
import socket
import subprocess
from sys import version_info
import time
import yaml
try:
# For python versions >= 3.2
from tempfile import TemporaryDirectory
except ImportError:
# Basic implementation of TemporaryDirectory for python versions < 3.2
from tempfile import mkdtemp
from shutil import rmtree
class TemporaryDirectory(object):
# pylint: disable=too-few-public-methods
"""Create a temporary directory.
When the last reference of this object goes out of scope the directory
and its contents are removed.
"""
def __init__(self):
"""Initialize a TemporaryDirectory object."""
self.name = mkdtemp()
def __del__(self):
"""Destroy a TemporaryDirectory object."""
rmtree(self.name)
TEST_LOG_FILE_YAML = "./data/daos_avocado_test.yaml"
BASE_LOG_FILE_YAML = "./data/daos_server_baseline.yaml"
SERVER_KEYS = (
"test_machines",
"test_servers",
"daos_servers",
)
CLIENT_KEYS = (
"test_clients",
)
def get_build_environment():
"""Obtain DAOS build environment variables from the .build_vars.json file.
Returns:
dict: a dictionary of DAOS build environment variable names and values
"""
build_vars_file = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"../../.build_vars.json")
with open(build_vars_file) as vars_file:
return json.load(vars_file)
def set_test_environment():
"""Set up the test environment.
Returns:
None
"""
base_dir = get_build_environment()["PREFIX"]
bin_dir = os.path.join(base_dir, "bin")
sbin_dir = os.path.join(base_dir, "sbin")
path = os.environ.get("PATH")
if base_dir == "/usr":
tmp_dir = os.getenv('DAOS_TEST_SHARED_DIR', \
os.path.expanduser('~/daos_test'))
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
else:
tmp_dir = os.path.join(base_dir, "tmp")
# Update env definitions
os.environ["PATH"] = ":".join([bin_dir, sbin_dir, path])
os.environ["DAOS_SINGLETON_CLI"] = "1"
os.environ["CRT_CTX_SHARE_ADDR"] = "1"
os.environ["CRT_ATTACH_INFO_PATH"] = tmp_dir
# Python paths required for functional testing
python_version = "python{}{}".format(
version_info.major,
"" if version_info.major > 2 else ".{}".format(version_info.minor))
required_python_paths = [
os.path.abspath("util/apricot"),
os.path.abspath("util"),
os.path.join(base_dir, "lib64", python_version, "site-packages"),
]
# Check the PYTHONPATH env definition
python_path = os.environ.get("PYTHONPATH")
if python_path is None or python_path == "":
# Use the required paths to define the PYTHONPATH env if it is not set
os.environ["PYTHONPATH"] = ":".join(required_python_paths)
else:
# Append any missing required paths to the existing PYTHONPATH env
defined_python_paths = [
os.path.abspath(os.path.expanduser(path))
for path in python_path.split(":")]
for required_path in required_python_paths:
if required_path not in defined_python_paths:
python_path += ":" + required_path
os.environ["PYTHONPATH"] = python_path
def get_output(cmd):
"""Get the output of given command executed on this host.
Args:
cmd (str): command from which to obtain the output
Returns:
str: command output
"""
try:
print("Running {}".format(cmd))
return subprocess.check_output(
cmd, stderr=subprocess.STDOUT, shell=True)
except subprocess.CalledProcessError as err:
print("Error executing '{}':\n\t{}".format(cmd, err))
exit(1)
def time_command(cmd):
"""Execute the command on this host and display its duration.
Args:
cmd (str): command to time
Returns:
int: return code of the command
"""
print("Running {}".format(cmd))
start_time = int(time.time())
return_code = subprocess.call(cmd, shell=True)
end_time = int(time.time())
print("Total test time: {}s".format(end_time - start_time))
return return_code
def spawn_commands(host_list, command, timeout=120):
"""Run the command on each specified host in parallel.
Args:
host_list (list): list of hosts
command (str): command to run on each host
timeout (int): number of seconds to wait for all jobs to complete
"""
# Create a job to run the command on each host
jobs = []
for host in host_list:
host_command = command.format(host=host)
jobs.append(Process(target=get_output, args=(host_command,)))
# Start the background jobs
for job in jobs:
job.start()
# Block until each job is complete or the overall timeout is reached
elapsed = 0
for job in jobs:
# Update the join timeout to account for previously joined jobs
join_timeout = timeout - elapsed if elapsed <= timeout else 0
# Block until this job completes or the overall timeout is reached
start_time = int(time.time())
job.join(join_timeout)
# Update the amount of time that has elapsed since waiting for jobs
elapsed += int(time.time()) - start_time
# Terminate any processes that may still be running after timeout
return_value = True
for job in jobs:
if job.is_alive():
print("Terminating job {}".format(job.pid))
job.terminate()
if job.exitcode != 0:
return_value = False
return return_value
def find_values(obj, keys, key=None, val_type=list):
"""Find dictionary values of a certain type specified with certain keys.
Args:
obj (obj): a python object; initailly the dictionary to search
keys (list): list of keys to find their matching list values
key (str, optional): key to check for a match. Defaults to None.
Returns:
dict: a dictionary of each matching key and its value
"""
matches = {}
if isinstance(obj, val_type) and isinstance(key, str) and key in keys:
# Match found
matches[key] = obj
elif isinstance(obj, dict):
# Recursively look for matches in each dictionary entry
for key, val in obj.items():
matches.update(find_values(val, keys, key, val_type))
elif isinstance(obj, list):
# Recursively look for matches in each list entry
for item in obj:
matches.update(find_values(item, keys, None, val_type))
return matches
def get_test_list(tags):
"""Generate a list of tests and avocado tag filter from a list of tags.
Args:
tags (list): a list of tag or test file names
Returns:
(str, list): a tuple of the avacado tag filter and lists of tests
"""
test_tags = []
test_list = []
for tag in tags:
if ".py" in tag:
# Assume '.py' indicates a test and just add it to the list
test_list.append(tag)
else:
# Otherwise it is assumed that this is a tag
test_tags.append(" --filter-by-tags={}".format(tag))
# Add to the list of tests any test that matches the specified tags. If no
# tags and no specific tests have been specified then all of the functional
# tests will be added.
if test_tags or not test_list:
command = " | ".join([
"avocado list --paginator off{} ./".format(" ".join(test_tags)),
r"sed -ne '/INSTRUMENTED/s/.* \([^:]*\):.*/\1/p'",
"uniq"])
test_list.extend(get_output(command).splitlines())
return " ".join(test_tags), test_list
def get_test_files(test_list, args, tmp_dir):
"""Get a list of the test scripts to run and their yaml files.
Args:
test_list (list): list of test scripts to run
args (argparse.Namespace): command line arguments for this program
tmp_dir (TemporaryDirectory): temporary directory object to use to
write modified yaml files
Returns:
list: a list of dictionaries of each test script and yaml file; If
there was an issue replacing a yaml host placeholder the yaml
dictionary entry will be set to None.
"""
test_files = [{"py": test, "yaml": None} for test in test_list]
for test_file in test_files:
base, _ = os.path.splitext(test_file["py"])
test_file["yaml"] = replace_yaml_file(
"{}.yaml".format(base), args, tmp_dir)
return test_files
def replace_yaml_file(yaml_file, args, tmp_dir):
"""Replace the server/client yaml file placeholders.
Replace any server or client yaml file placeholder names with the host
names provided by the command line arguments in a copy of the original
test yaml file. If no replacements are specified return the original
test yaml file.
Args:
yaml_file (str): test yaml file
args (argparse.Namespace): command line arguments for this program
tmp_dir (TemporaryDirectory): temporary directory object to use to
write modified yaml files
Returns:
str: the test yaml file; None if the yaml file contains placeholders
w/o replacements
"""
if args.test_servers:
# Determine which placeholder names need to be replaced in this yaml by
# getting the lists of hosts specified in the yaml file
unique_hosts = {"servers": set(), "clients": set()}
for key, placeholders in find_yaml_hosts(yaml_file).items():
if key in SERVER_KEYS:
unique_hosts["servers"].update(placeholders)
elif key in CLIENT_KEYS:
# If no specific clients are specified use a specified server
key = "clients" if args.test_clients else "servers"
unique_hosts[key].update(placeholders)
# Map the placeholder names to values provided by the user
mapping_pairings = [("servers", args.test_servers.split(","))]
if args.test_clients:
mapping_pairings.append(("clients", args.test_clients.split(",")))
mapping = {
tmp: node_list[index] if index < len(node_list) else None
for key, node_list in mapping_pairings
for index, tmp in enumerate(sorted(unique_hosts[key]))}
# Read in the contents of the yaml file to retain the !mux entries
print("Reading {}".format(yaml_file))
with open(yaml_file) as yaml_buffer:
file_str = yaml_buffer.read()
# Apply the placeholder replacements
missing_replacements = []
for placeholder, host in mapping.items():
if host:
# Replace the host entries with their mapped values
file_str = re.sub(
"- {}".format(placeholder), "- {}".format(host), file_str)
elif args.discard:
# Discard any host entries without a replacement value
file_str = re.sub(r"\s+- {}".format(placeholder), "", file_str)
else:
# Keep track of any placeholders without a replacement value
missing_replacements.append(placeholder)
if missing_replacements:
# Report an error for all of the placeholders w/o a replacement
print(
"Error: Placeholders missing replacements in {}:\n {}".format(
yaml_file, ", ".join(missing_replacements)))
return None
# Write the modified yaml file into a temporary file. Use the path to
# ensure unique yaml files for tests with the same filename.
yaml_name = get_test_category(yaml_file)
yaml_file = os.path.join(tmp_dir.name, "{}.yaml".format(yaml_name))
print("Creating {}".format(yaml_file))
with open(yaml_file, "w") as yaml_buffer:
yaml_buffer.write(file_str)
# Return the untouched or modified yaml file
return yaml_file
def run_tests(test_files, tag_filter, args):
"""Run or display the test commands.
Args:
test_files (dict): a list of dictionaries of each test script/yaml file
tag_filter (str): the avocado tag filter command line argument
args (argparse.Namespace): command line arguments for this program
Returns:
int: a bitwise-or of all the return codes of each 'avocado run' command
"""
return_code = 0
# Determine the location of the avocado logs for archiving or renaming
avocado_logs_dir = None
if args.archive or args.rename:
avocado_logs_dir = get_output(
"avocado config | sed -ne '/logs_dir/s/.* *//p'").strip()
avocado_logs_dir = os.path.expanduser(avocado_logs_dir)
print("Avocado logs stored in {}".format(avocado_logs_dir))
# Create the base avocado run command
command_list = [
"avocado",
"run",
"--ignore-missing-references on",
"--show-job-log" if not args.sparse else "",
"--html-job-result on",
tag_filter
]
# Run each test
for test_file in test_files:
if isinstance(test_file["yaml"], str):
# Optionally clean the log files before running this test on the
# servers and clients specified for this test
if args.clean:
if not clean_logs(test_file["yaml"], args):
return 128
# Execute this test
test_command_list = list(command_list)
test_command_list.append("--mux-yaml {}".format(test_file["yaml"]))
test_command_list.append("-- {}".format(test_file["py"]))
return_code |= time_command(
" ".join([item for item in test_command_list if item != ""]))
# Optionally store all of the doas server and client log files
# along with the test results
if args.archive:
archive_logs(avocado_logs_dir, test_file["yaml"], args)
# Optionally rename the test results directory for this test
if args.rename:
rename_logs(avocado_logs_dir, test_file["py"])
else:
# The test was not run due to an error replacing host placeholders
# in the yaml file. Treat this like a failed avocado command.
return_code |= 4
return return_code
def get_yaml_data(yaml_file):
"""Get the contents of a yaml file as a dictionary.
Args:
yaml_file (str): yaml file to read
Raises:
Exception: if an error is encountered reading the yaml file
Returns:
dict: the contents of the yaml file
"""
yaml_data = {}
if os.path.isfile(yaml_file):
with open(yaml_file, "r") as open_file:
try:
file_data = open_file.read()
yaml_data = yaml.safe_load(file_data.replace("!mux", ""))
except yaml.YAMLError as error:
print("Error reading {}: {}".format(yaml_file, error))
exit(1)
return yaml_data
def get_log_files(config_yaml, daos_files=None):
"""Get a list of DAOS files used by the specified yaml file.
Args:
config_yaml (str): yaml file defining log file locations
daos_files (dict, optional): dictionary of default DAOS log files whose
keys define which yaml log parameters to use to update the default
values. Defaults to None.
Returns:
dict: a dictionary of DAOS file name keys and full path values
"""
# List of default DAOS files
if daos_files is None:
daos_core_test_dir = os.path.split(
os.getenv("D_LOG_FILE", "/tmp/server.log"))[0]
daos_files = {
"log_file": "/tmp/server.log",
"agent_log_file": "/tmp/daos_agent.log",
"control_log_file": "/tmp/daos_control.log",
"socket_dir": "/tmp/daos_sockets",
"debug_log_default": os.getenv("D_LOG_FILE", "/tmp/daos.log"),
"test_variant_client_logs":
"{}/*_client_daos.log".format(daos_core_test_dir),
"test_variant_server_logs":
"{}/*_server_daos.log".format(daos_core_test_dir),
}
# Determine the log file locations defined by the last run test
print("Checking {} for daos log file locations".format(config_yaml))
yaml_data = get_yaml_data(config_yaml)
# Replace any default log file with its yaml definition
matches = find_values(yaml_data, daos_files.keys(), val_type=str)
for key, value in matches.items():
if value != daos_files[key]:
print(
" Update found for {}: {} -> {}".format(
key, daos_files[key], value))
daos_files[key] = value
return daos_files
def find_yaml_hosts(test_yaml):
"""Find the all the host values in the specified yaml file.
Args:
test_yaml (str): test yaml file
Returns:
dict: a dictionary of each host key and its host values
"""
return find_values(get_yaml_data(test_yaml), SERVER_KEYS + CLIENT_KEYS)
def get_hosts_from_yaml(test_yaml, args):
"""Extract the list of hosts from the test yaml file.
This host will be included in the list if no clients are explicitly called
out in the test's yaml file.
Args:
test_yaml (str): test yaml file
args (argparse.Namespace): command line arguments for this program
Returns:
list: a unique list of hosts specified in the test's yaml file
"""
host_set = set()
if args.include_localhost:
host_set.add(socket.gethostname().split(".")[0])
found_client_key = False
for key, value in find_yaml_hosts(test_yaml).items():
host_set.update(value)
if key in CLIENT_KEYS:
found_client_key = True
# Include this host as a client if no clients are specified
if not found_client_key:
host_set.add(socket.gethostname().split(".")[0])
return sorted(list(host_set))
def clean_logs(test_yaml, args):
"""Remove the test log files on each test host.
Args:
test_yaml (str): yaml file containing host names
args (argparse.Namespace): command line arguments for this program
"""
# Use the default server yaml and then the test yaml to update the default
# DAOS log file locations. This should simulate how the test defines which
# log files it will use when it is run.
log_files = get_log_files(test_yaml, get_log_files(BASE_LOG_FILE_YAML))
host_list = get_hosts_from_yaml(test_yaml, args)
command = "ssh {{host}} \"rm -fr {}\"".format(" ".join(log_files.values()))
print("Cleaning logs on {}".format(host_list))
if not spawn_commands(host_list, command):
print("Error cleaning logs, aborting")
return False
return True
def archive_logs(avocado_logs_dir, test_yaml, args):
"""Copy all of the host test log files to the avocado results directory.
Args:
avocado_logs_dir ([type]): [description]
test_yaml (str): yaml file containing host names
args (argparse.Namespace): command line arguments for this program
"""
this_host = socket.gethostname().split(".")[0]
log_files = get_log_files(TEST_LOG_FILE_YAML)
host_list = get_hosts_from_yaml(test_yaml, args)
doas_logs_dir = os.path.join(avocado_logs_dir, "latest", "daos_logs")
# Create a subdirectory in the avocado logs directory for this test
print("Archiving host logs from {} in {}".format(host_list, doas_logs_dir))
get_output("mkdir {}".format(doas_logs_dir))
# Create a list of log files that are not directories
non_dir_files = [
log_file for log_file in log_files.values()
if os.path.splitext(os.path.basename(log_file))[1] != ""]
# Copy any log files that exist on the test hosts and remove them from the
# test host if the copy is successful
command = "ssh {{host}} 'set -e; {}'".format(
"for file in {}; do if [ -e $file ]; then "
"scp $file {}:{}/${{{{file##*/}}}}-{{host}} && rm -fr $file; fi; "
"done".format(" ".join(non_dir_files), this_host, doas_logs_dir))
spawn_commands(host_list, command)
def rename_logs(avocado_logs_dir, test_file):
"""Append the test name to its avocado job-results directory name.
Args:
avocado_logs_dir (str): avocado job-results directory
test_file (str): the test python file
"""
test_name = get_test_category(test_file)
test_logs_lnk = os.path.join(avocado_logs_dir, "latest")
test_logs_dir = os.path.realpath(test_logs_lnk)
new_test_logs_dir = "{}-{}".format(test_logs_dir, test_name)
try:
os.rename(test_logs_dir, new_test_logs_dir)
os.remove(test_logs_lnk)
os.symlink(new_test_logs_dir, test_logs_lnk)
print("Renamed {} to {}".format(test_logs_dir, new_test_logs_dir))
except OSError as error:
print(
"Error renaming {} to {}: {}".format(
test_logs_dir, new_test_logs_dir, error))
def get_test_category(test_file):
"""Get a category for the specified test using its path and name.
Args:
test_file (str): the test python file
Returns:
str: concatenation of the test path and base filename joined by dashes
"""
file_parts = os.path.split(test_file)
return "-".join(
[os.path.splitext(os.path.basename(part))[0] for part in file_parts])
def main():
"""Launch DAOS functional tests."""
# Parse the command line arguments
description = [
"DAOS functional test launcher",
"",
"Launches tests by specifying a test tag. For example:",
"\tbadconnect --run pool connect tests that pass NULL ptrs, etc.",
"\tbadevict --run pool client evict tests that pass NULL ptrs, "
"etc.",
"\tbadexclude --run pool target exclude tests that pass NULL ptrs, "
"etc.",
"\tbadparam --run tests that pass NULL ptrs, etc.",
"\tbadquery --run pool query tests that pass NULL ptrs, etc.",
"\tmulticreate --run tests that create multiple pools at once",
"\tmultitarget --run tests that create pools over multiple servers",
"\tpool --run all pool related tests",
"\tpoolconnect --run all pool connection related tests",
"\tpooldestroy --run all pool destroy related tests",
"\tpoolevict --run all client pool eviction related tests",
"\tpoolinfo --run all pool info retrieval related tests",
"\tquick --run tests that complete quickly, with minimal "
"resources",
"",
"Multiple tags can be specified:",
"\ttag_a,tag_b -- run all tests with both tag_a and tag_b",
"\ttag_a tag_b -- run all tests with either tag_a or tag_b",
"",
"Specifying no tags will run all of the available tests.",
"",
"Tests can also be launched by specifying a path to the python script "
"instead of its tag.",
"",
"The placeholder server and client names in the yaml file can also be "
"replaced with the following options:",
"\tlaunch.py -ts node1,node2 -tc node3 <tag>",
"\t - Use node[1-2] to run the daos server in each test",
"\t - Use node3 to run the daos client in each test",
"\tlaunch.py -ts node1,node2 <tag>",
"\t - Use node[1-2] to run the daos server or client in each test",
"\tlaunch.py -ts node1,node2 -d <tag>",
"\t - Use node[1-2] to run the daos server or client in each test",
"\t - Discard of any additional server or client placeholders for "
"each test",
"",
"You can also specify the sparse flag -s to limit output to "
"pass/fail.",
"\tExample command: launch.py -s pool"
]
parser = ArgumentParser(
prog="launcher.py",
formatter_class=RawDescriptionHelpFormatter,
description="\n".join(description))
parser.add_argument(
"-a", "--archive",
action="store_true",
help="archive host log files in the avocado job-results directory")
parser.add_argument(
"-c", "--clean",
action="store_true",
help="remove daos log files from the test hosts prior to the test")
parser.add_argument(
"-d", "--discard",
action="store_true",
help="when replacing server/client yaml file placeholders, discard "
"any placeholders that do not end up with a replacement value")
parser.add_argument(
"-i", "--include_localhost",
action="store_true",
help="include the local host when cleaning and archiving")
parser.add_argument(
"-l", "--list",
action="store_true",
help="list the python scripts that match the specified tags")
parser.add_argument(
"-r", "--rename",
action="store_true",
help="rename the avocado test logs directory to include the test name")
parser.add_argument(
"-s", "--sparse",
action="store_true",
help="limit output to pass/fail")
parser.add_argument(
"tags",
nargs="*",
type=str,
help="test category or file to run")
parser.add_argument(
"-tc", "--test_clients",
action="store",
help="comma-separated list of hosts to use as replacement values for "
"client placeholders in each test's yaml file")
parser.add_argument(
"-ts", "--test_servers",
action="store",
help="comma-separated list of hosts to use as replacement values for "
"server placeholders in each test's yaml file. If the "
"'--test_clients' argument is not specified, this list of hosts "
"will also be used to replace client placeholders.")
args = parser.parse_args()
print("Arguments: {}".format(args))
# Setup the user environment
set_test_environment()
# Process the tags argument to determine which tests to run
tag_filter, test_list = get_test_list(args.tags)
# Verify at least one test was requested
if len(test_list) == 0:
print("ERROR: No tests or tags found via {}".format(args.tags))
exit(1)
# Display a list of the tests matching the tags
print("Detected tests: \n{}".format(" \n".join(test_list)))
if args.list:
exit(0)
# Create a temporary directory
tmp_dir = TemporaryDirectory()
# Create a dictionary of test and their yaml files
test_files = get_test_files(test_list, args, tmp_dir)
# Run all the tests
status = run_tests(test_files, tag_filter, args)
# Process the avocado run return codes and only treat job and command
# failures as errors.
ret_code = 0
if status == 0:
print("All avocado tests passed!")
else:
if status & 1 == 1:
print("Detected one or more avocado test failures!")
if status & 8 == 8:
print("Detected one or more interrupted avocado jobs!")
if status & 2 == 2:
print("ERROR: Detected one or more avocado job failures!")
ret_code = 1
if status & 4 == 4:
print("ERROR: Detected one or more failed avocado commands!")
ret_code = 1
if status & 128 == 128:
print("ERROR: Failed to clean logs in preparation for test run!")
ret_code = 1
exit(ret_code)
if __name__ == "__main__":
main()
|
installwizard.py
|
from functools import partial
import threading
from kivy.app import App
from kivy.clock import Clock
from kivy.lang import Builder
from kivy.properties import ObjectProperty, StringProperty, OptionProperty
from kivy.core.window import Window
from kivy.uix.button import Button
from kivy.utils import platform
from kivy.uix.widget import Widget
from kivy.core.window import Window
from kivy.clock import Clock
from kivy.utils import platform
from electrum_commercium.base_wizard import BaseWizard
from . import EventsDialog
from ...i18n import _
from .password_dialog import PasswordDialog
# global Variables
is_test = (platform == "linux")
test_seed = "time taxi field recycle tiny license olive virus report rare steel portion achieve"
test_xpub = "xpub661MyMwAqRbcEbvVtRRSjqxVnaWVUMewVzMiURAKyYratih4TtBpMypzzefmv8zUNebmNVzB3PojdC5sV2P9bDgMoo9B3SARw1MXUUfU1GL"
Builder.load_string('''
#:import Window kivy.core.window.Window
#:import _ electrum_commercium_gui.kivy.i18n._
<WizardTextInput@TextInput>
border: 4, 4, 4, 4
font_size: '15sp'
padding: '15dp', '15dp'
background_color: (1, 1, 1, 1) if self.focus else (0.454, 0.698, 0.909, 1)
foreground_color: (0.31, 0.31, 0.31, 1) if self.focus else (0.835, 0.909, 0.972, 1)
hint_text_color: self.foreground_color
background_active: 'atlas://gui/kivy/theming/light/create_act_text_active'
background_normal: 'atlas://gui/kivy/theming/light/create_act_text_active'
size_hint_y: None
height: '48sp'
<WizardButton@Button>:
root: None
size_hint: 1, None
height: '48sp'
on_press: if self.root: self.root.dispatch('on_press', self)
on_release: if self.root: self.root.dispatch('on_release', self)
<BigLabel@Label>
color: .854, .925, .984, 1
size_hint: 1, None
text_size: self.width, None
height: self.texture_size[1]
bold: True
<-WizardDialog>
text_color: .854, .925, .984, 1
value: ''
#auto_dismiss: False
size_hint: None, None
canvas.before:
Color:
rgba: 0, 0, 0, .9
Rectangle:
size: Window.size
Color:
rgba: .239, .588, .882, 1
Rectangle:
size: Window.size
crcontent: crcontent
# add electrum icon
BoxLayout:
orientation: 'vertical' if self.width < self.height else 'horizontal'
padding:
min(dp(27), self.width/32), min(dp(27), self.height/32),\
min(dp(27), self.width/32), min(dp(27), self.height/32)
spacing: '10dp'
GridLayout:
id: grid_logo
cols: 1
pos_hint: {'center_y': .5}
size_hint: 1, None
height: self.minimum_height
Label:
color: root.text_color
text: 'ELECTRUM'
size_hint: 1, None
height: self.texture_size[1] if self.opacity else 0
font_size: '33sp'
font_name: 'gui/kivy/data/fonts/tron/Tr2n.ttf'
GridLayout:
cols: 1
id: crcontent
spacing: '1dp'
Widget:
size_hint: 1, 0.3
GridLayout:
rows: 1
spacing: '12dp'
size_hint: 1, None
height: self.minimum_height
WizardButton:
id: back
text: _('Back')
root: root
WizardButton:
id: next
text: _('Next')
root: root
disabled: root.value == ''
<WizardMultisigDialog>
value: 'next'
Widget
size_hint: 1, 1
Label:
color: root.text_color
size_hint: 1, None
text_size: self.width, None
height: self.texture_size[1]
text: _("Choose the number of signatures needed to unlock funds in your wallet")
Widget
size_hint: 1, 1
GridLayout:
orientation: 'vertical'
cols: 2
spacing: '14dp'
size_hint: 1, 1
height: self.minimum_height
Label:
color: root.text_color
text: _('From {} cosigners').format(n.value)
Slider:
id: n
range: 2, 5
step: 1
value: 2
Label:
color: root.text_color
text: _('Require {} signatures').format(m.value)
Slider:
id: m
range: 1, n.value
step: 1
value: 2
<WizardChoiceDialog>
message : ''
Widget:
size_hint: 1, 1
Label:
color: root.text_color
size_hint: 1, None
text_size: self.width, None
height: self.texture_size[1]
text: root.message
Widget
size_hint: 1, 1
GridLayout:
row_default_height: '48dp'
orientation: 'vertical'
id: choices
cols: 1
spacing: '14dp'
size_hint: 1, None
<MButton@Button>:
size_hint: 1, None
height: '33dp'
on_release:
self.parent.update_amount(self.text)
<WordButton@Button>:
size_hint: None, None
padding: '5dp', '5dp'
text_size: None, self.height
width: self.texture_size[0]
height: '30dp'
on_release:
self.parent.new_word(self.text)
<SeedButton@Button>:
height: dp(100)
border: 4, 4, 4, 4
halign: 'justify'
valign: 'top'
font_size: '18dp'
text_size: self.width - dp(24), self.height - dp(12)
color: .1, .1, .1, 1
background_normal: 'atlas://gui/kivy/theming/light/white_bg_round_top'
background_down: self.background_normal
size_hint_y: None
<SeedLabel@Label>:
font_size: '12sp'
text_size: self.width, None
size_hint: 1, None
height: self.texture_size[1]
halign: 'justify'
valign: 'middle'
border: 4, 4, 4, 4
<RestoreSeedDialog>
message: ''
word: ''
BigLabel:
text: "ENTER YOUR SEED PHRASE"
GridLayout
cols: 1
padding: 0, '12dp'
orientation: 'vertical'
spacing: '12dp'
size_hint: 1, None
height: self.minimum_height
SeedButton:
id: text_input_seed
text: ''
on_text: Clock.schedule_once(root.on_text)
on_release: root.options_dialog()
SeedLabel:
text: root.message
BoxLayout:
id: suggestions
height: '35dp'
size_hint: 1, None
new_word: root.on_word
BoxLayout:
id: line1
update_amount: root.update_text
size_hint: 1, None
height: '30dp'
MButton:
text: 'Q'
MButton:
text: 'W'
MButton:
text: 'E'
MButton:
text: 'R'
MButton:
text: 'T'
MButton:
text: 'Y'
MButton:
text: 'U'
MButton:
text: 'I'
MButton:
text: 'O'
MButton:
text: 'P'
BoxLayout:
id: line2
update_amount: root.update_text
size_hint: 1, None
height: '30dp'
Widget:
size_hint: 0.5, None
height: '33dp'
MButton:
text: 'A'
MButton:
text: 'S'
MButton:
text: 'D'
MButton:
text: 'F'
MButton:
text: 'G'
MButton:
text: 'H'
MButton:
text: 'J'
MButton:
text: 'K'
MButton:
text: 'L'
Widget:
size_hint: 0.5, None
height: '33dp'
BoxLayout:
id: line3
update_amount: root.update_text
size_hint: 1, None
height: '30dp'
Widget:
size_hint: 1, None
MButton:
text: 'Z'
MButton:
text: 'X'
MButton:
text: 'C'
MButton:
text: 'V'
MButton:
text: 'B'
MButton:
text: 'N'
MButton:
text: 'M'
MButton:
text: ' '
MButton:
text: '<'
<AddXpubDialog>
title: ''
message: ''
BigLabel:
text: root.title
GridLayout
cols: 1
padding: 0, '12dp'
orientation: 'vertical'
spacing: '12dp'
size_hint: 1, None
height: self.minimum_height
SeedButton:
id: text_input
text: ''
on_text: Clock.schedule_once(root.check_text)
SeedLabel:
text: root.message
GridLayout
rows: 1
spacing: '12dp'
size_hint: 1, None
height: self.minimum_height
IconButton:
id: scan
height: '48sp'
on_release: root.scan_xpub()
icon: 'atlas://gui/kivy/theming/light/camera'
size_hint: 1, None
WizardButton:
text: _('Paste')
on_release: root.do_paste()
WizardButton:
text: _('Clear')
on_release: root.do_clear()
<ShowXpubDialog>
xpub: ''
message: _('Here is your master public key. Share it with your cosigners.')
BigLabel:
text: "MASTER PUBLIC KEY"
GridLayout
cols: 1
padding: 0, '12dp'
orientation: 'vertical'
spacing: '12dp'
size_hint: 1, None
height: self.minimum_height
SeedButton:
id: text_input
text: root.xpub
SeedLabel:
text: root.message
GridLayout
rows: 1
spacing: '12dp'
size_hint: 1, None
height: self.minimum_height
WizardButton:
text: _('QR code')
on_release: root.do_qr()
WizardButton:
text: _('Copy')
on_release: root.do_copy()
WizardButton:
text: _('Share')
on_release: root.do_share()
<ShowSeedDialog>
spacing: '12dp'
value: 'next'
BigLabel:
text: "PLEASE WRITE DOWN YOUR SEED PHRASE"
GridLayout:
id: grid
cols: 1
pos_hint: {'center_y': .5}
size_hint_y: None
height: self.minimum_height
orientation: 'vertical'
spacing: '12dp'
SeedButton:
text: root.seed_text
on_release: root.options_dialog()
SeedLabel:
text: root.message
<LineDialog>
BigLabel:
text: root.title
SeedLabel:
text: root.message
TextInput:
id: passphrase_input
multiline: False
size_hint: 1, None
height: '27dp'
SeedLabel:
text: root.warning
''')
class WizardDialog(EventsDialog):
''' Abstract dialog to be used as the base for all Create Account Dialogs
'''
crcontent = ObjectProperty(None)
def __init__(self, wizard, **kwargs):
super(WizardDialog, self).__init__()
self.wizard = wizard
self.ids.back.disabled = not wizard.can_go_back()
self.app = App.get_running_app()
self.run_next = kwargs['run_next']
_trigger_size_dialog = Clock.create_trigger(self._size_dialog)
Window.bind(size=_trigger_size_dialog,
rotation=_trigger_size_dialog)
_trigger_size_dialog()
self._on_release = False
def _size_dialog(self, dt):
app = App.get_running_app()
if app.ui_mode[0] == 'p':
self.size = Window.size
else:
#tablet
if app.orientation[0] == 'p':
#portrait
self.size = Window.size[0]/1.67, Window.size[1]/1.4
else:
self.size = Window.size[0]/2.5, Window.size[1]
def add_widget(self, widget, index=0):
if not self.crcontent:
super(WizardDialog, self).add_widget(widget)
else:
self.crcontent.add_widget(widget, index=index)
def on_dismiss(self):
app = App.get_running_app()
if app.wallet is None and not self._on_release:
app.stop()
def get_params(self, button):
return (None,)
def on_release(self, button):
self._on_release = True
self.close()
if not button:
self.parent.dispatch('on_wizard_complete', None)
return
if button is self.ids.back:
self.wizard.go_back()
return
params = self.get_params(button)
self.run_next(*params)
class WizardMultisigDialog(WizardDialog):
def get_params(self, button):
m = self.ids.m.value
n = self.ids.n.value
return m, n
class WizardChoiceDialog(WizardDialog):
def __init__(self, wizard, **kwargs):
super(WizardChoiceDialog, self).__init__(wizard, **kwargs)
self.message = kwargs.get('message', '')
choices = kwargs.get('choices', [])
layout = self.ids.choices
layout.bind(minimum_height=layout.setter('height'))
for action, text in choices:
l = WizardButton(text=text)
l.action = action
l.height = '48dp'
l.root = self
layout.add_widget(l)
def on_parent(self, instance, value):
if value:
app = App.get_running_app()
self._back = _back = partial(app.dispatch, 'on_back')
def get_params(self, button):
return (button.action,)
class LineDialog(WizardDialog):
title = StringProperty('')
message = StringProperty('')
warning = StringProperty('')
def __init__(self, wizard, **kwargs):
WizardDialog.__init__(self, wizard, **kwargs)
self.ids.next.disabled = False
def get_params(self, b):
return (self.ids.passphrase_input.text,)
class ShowSeedDialog(WizardDialog):
seed_text = StringProperty('')
message = _("If you forget your PIN or lose your device, your seed phrase will be the only way to recover your funds.")
ext = False
def __init__(self, wizard, **kwargs):
super(ShowSeedDialog, self).__init__(wizard, **kwargs)
self.seed_text = kwargs['seed_text']
def on_parent(self, instance, value):
if value:
app = App.get_running_app()
self._back = _back = partial(self.ids.back.dispatch, 'on_release')
def options_dialog(self):
from .seed_options import SeedOptionsDialog
def callback(status):
self.ext = status
d = SeedOptionsDialog(self.ext, callback)
d.open()
def get_params(self, b):
return (self.ext,)
class WordButton(Button):
pass
class WizardButton(Button):
pass
class RestoreSeedDialog(WizardDialog):
def __init__(self, wizard, **kwargs):
super(RestoreSeedDialog, self).__init__(wizard, **kwargs)
self._test = kwargs['test']
from electrum_commercium.mnemonic import Mnemonic
from electrum_commercium.old_mnemonic import words as old_wordlist
self.words = set(Mnemonic('en').wordlist).union(set(old_wordlist))
self.ids.text_input_seed.text = test_seed if is_test else ''
self.message = _('Please type your seed phrase using the virtual keyboard.')
self.title = _('Enter Seed')
self.ext = False
def options_dialog(self):
from .seed_options import SeedOptionsDialog
def callback(status):
self.ext = status
d = SeedOptionsDialog(self.ext, callback)
d.open()
def get_suggestions(self, prefix):
for w in self.words:
if w.startswith(prefix):
yield w
def on_text(self, dt):
self.ids.next.disabled = not bool(self._test(self.get_text()))
text = self.ids.text_input_seed.text
if not text:
last_word = ''
elif text[-1] == ' ':
last_word = ''
else:
last_word = text.split(' ')[-1]
enable_space = False
self.ids.suggestions.clear_widgets()
suggestions = [x for x in self.get_suggestions(last_word)]
if last_word in suggestions:
b = WordButton(text=last_word)
self.ids.suggestions.add_widget(b)
enable_space = True
for w in suggestions:
if w != last_word and len(suggestions) < 10:
b = WordButton(text=w)
self.ids.suggestions.add_widget(b)
i = len(last_word)
p = set()
for x in suggestions:
if len(x)>i: p.add(x[i])
for line in [self.ids.line1, self.ids.line2, self.ids.line3]:
for c in line.children:
if isinstance(c, Button):
if c.text in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
c.disabled = (c.text.lower() not in p) and bool(last_word)
elif c.text == ' ':
c.disabled = not enable_space
def on_word(self, w):
text = self.get_text()
words = text.split(' ')
words[-1] = w
text = ' '.join(words)
self.ids.text_input_seed.text = text + ' '
self.ids.suggestions.clear_widgets()
def get_text(self):
ti = self.ids.text_input_seed
return ' '.join(ti.text.strip().split())
def update_text(self, c):
c = c.lower()
text = self.ids.text_input_seed.text
if c == '<':
text = text[:-1]
else:
text += c
self.ids.text_input_seed.text = text
def on_parent(self, instance, value):
if value:
tis = self.ids.text_input_seed
tis.focus = True
#tis._keyboard.bind(on_key_down=self.on_key_down)
self._back = _back = partial(self.ids.back.dispatch,
'on_release')
app = App.get_running_app()
def on_key_down(self, keyboard, keycode, key, modifiers):
if keycode[0] in (13, 271):
self.on_enter()
return True
def on_enter(self):
#self._remove_keyboard()
# press next
next = self.ids.next
if not next.disabled:
next.dispatch('on_release')
def _remove_keyboard(self):
tis = self.ids.text_input_seed
if tis._keyboard:
tis._keyboard.unbind(on_key_down=self.on_key_down)
tis.focus = False
def get_params(self, b):
return (self.get_text(), False, self.ext)
class ConfirmSeedDialog(RestoreSeedDialog):
def get_params(self, b):
return (self.get_text(),)
def options_dialog(self):
pass
class ShowXpubDialog(WizardDialog):
def __init__(self, wizard, **kwargs):
WizardDialog.__init__(self, wizard, **kwargs)
self.xpub = kwargs['xpub']
self.ids.next.disabled = False
def do_copy(self):
self.app._clipboard.copy(self.xpub)
def do_share(self):
self.app.do_share(self.xpub, _("Master Public Key"))
def do_qr(self):
from .qr_dialog import QRDialog
popup = QRDialog(_("Master Public Key"), self.xpub, True)
popup.open()
class AddXpubDialog(WizardDialog):
def __init__(self, wizard, **kwargs):
WizardDialog.__init__(self, wizard, **kwargs)
self.is_valid = kwargs['is_valid']
self.title = kwargs['title']
self.message = kwargs['message']
self.allow_multi = kwargs.get('allow_multi', False)
def check_text(self, dt):
self.ids.next.disabled = not bool(self.is_valid(self.get_text()))
def get_text(self):
ti = self.ids.text_input
return ti.text.strip()
def get_params(self, button):
return (self.get_text(),)
def scan_xpub(self):
def on_complete(text):
if self.allow_multi:
self.ids.text_input.text += text + '\n'
else:
self.ids.text_input.text = text
self.app.scan_qr(on_complete)
def do_paste(self):
self.ids.text_input.text = test_xpub if is_test else self.app._clipboard.paste()
def do_clear(self):
self.ids.text_input.text = ''
class InstallWizard(BaseWizard, Widget):
'''
events::
`on_wizard_complete` Fired when the wizard is done creating/ restoring
wallet/s.
'''
__events__ = ('on_wizard_complete', )
def on_wizard_complete(self, wallet):
"""overriden by main_window"""
pass
def waiting_dialog(self, task, msg):
'''Perform a blocking task in the background by running the passed
method in a thread.
'''
def target():
# run your threaded function
try:
task()
except Exception as err:
self.show_error(str(err))
# on completion hide message
Clock.schedule_once(lambda dt: app.info_bubble.hide(now=True), -1)
app = App.get_running_app()
app.show_info_bubble(
text=msg, icon='atlas://gui/kivy/theming/light/important',
pos=Window.center, width='200sp', arrow_pos=None, modal=True)
t = threading.Thread(target = target)
t.start()
def terminate(self, **kwargs):
self.dispatch('on_wizard_complete', self.wallet)
def choice_dialog(self, **kwargs):
choices = kwargs['choices']
if len(choices) > 1:
WizardChoiceDialog(self, **kwargs).open()
else:
f = kwargs['run_next']
f(choices[0][0])
def multisig_dialog(self, **kwargs): WizardMultisigDialog(self, **kwargs).open()
def show_seed_dialog(self, **kwargs): ShowSeedDialog(self, **kwargs).open()
def line_dialog(self, **kwargs): LineDialog(self, **kwargs).open()
def confirm_seed_dialog(self, **kwargs):
kwargs['title'] = _('Confirm Seed')
kwargs['message'] = _('Please retype your seed phrase, to confirm that you properly saved it')
ConfirmSeedDialog(self, **kwargs).open()
def restore_seed_dialog(self, **kwargs):
RestoreSeedDialog(self, **kwargs).open()
def add_xpub_dialog(self, **kwargs):
kwargs['message'] += ' ' + _('Use the camera button to scan a QR code.')
AddXpubDialog(self, **kwargs).open()
def add_cosigner_dialog(self, **kwargs):
kwargs['title'] = _("Add Cosigner") + " %d"%kwargs['index']
kwargs['message'] = _('Please paste your cosigners master public key, or scan it using the camera button.')
AddXpubDialog(self, **kwargs).open()
def show_xpub_dialog(self, **kwargs): ShowXpubDialog(self, **kwargs).open()
def show_error(self, msg):
app = App.get_running_app()
Clock.schedule_once(lambda dt: app.show_error(msg))
def request_password(self, run_next, force_disable_encrypt_cb=False):
def on_success(old_pin, pin):
assert old_pin is None
run_next(pin, False)
def on_failure():
self.show_error(_('PIN mismatch'))
self.run('request_password', run_next)
popup = PasswordDialog()
app = App.get_running_app()
popup.init(app, None, _('Choose PIN code'), on_success, on_failure, is_change=2)
popup.open()
def action_dialog(self, action, run_next):
f = getattr(self, action)
f()
|
Fundus_Cam.py
|
##############################################################################
######################### Fundus_Cam.py #########################
######################### Primary Author: Ebin #########################
######################### Version : 1.0 #########################
######################### Contributor: Ayush Yadav #########################
##############################################################################
from picamera.array import PiRGBArray
from picamera import PiCamera
from threading import Thread
import cv2
import numpy as np
import io
###############################################################################
### This class provides access to the picamera and its associated functions ###
###############################################################################
class Fundus_Cam(object):
# The constructor initializes the camera object and starts preview
def __init__(self, framerate=12,preview=False):
# initialize the camera
self.camera = PiCamera()
self.camera.resolution = self.camera.MAX_RESOLUTION
self.camera.framerate = framerate
# stream is a file-like type used to store captured images to memory
# rather than onto disk
self.stream = io.BytesIO()
# this determines the vertical flip_state of the picamera
# this can be toggled by Fundus_Cam.flip_cam()
self.flip_state=False
# This is a list to store images captured
# in Fundus_Cam.continuous_capture()
self.images=[]
self.camera.start_preview()
# used to stop and start recording in versions higher than1.0
self.stopped = False
def continuous_capture(self):
# starts a new thread, which runs the update()
self.stopped = False
Thread(target=self.update, args=()).start()
# continuosly captures frames from the camera, in a seperate thread
def update(self):
# keep looping infinitely until the thread is stopped
# In version 1.0 it grabs only 10 frames
while True:
# grab the frame from the stream
self.camera.capture(self.stream,format='jpeg',use_video_port=True)
# convert the frame captures to numpy array and append to images
self.images.append(np.fromstring(self.stream.getvalue(),dtype=np.uint8))
# clear the stream for the next frame
self.stream.truncate()
self.stream.seek(0)
if(len(self.images)>9):
self.stopped=True
return
# to flip the camera
def flip_cam(self):
self.camera.vflip=(not self.flip_state)
#to capture a single image
def capture(self):
self.camera.capture(self.stream,format='jpeg',use_video_port=True)
# convert to numpy array
self.image=np.fromstring(self.stream.getvalue(),dtype=np.uint8)
# clear the stream
self.stream.truncate()
self.stream.seek(0)
# return the captured image
return self.image
# to start camera preview
def preview(self):
self.camera.start_preview()
# to stop camera preview
def stop_preview(self):
self.camera.stop_preview()
# used in version higher than 1.0
def stop(self):
self.stopped=True
## decode function
## decode,process and save the grabbed image
## the decode function has been moved to the fundus_mod3.py file for easy access
## def decode_image(images,path_sen,name):
## #name=raw_input("enter the name to be saved")
## no=1
## if type(images) is list:
##
## for img in images:
## image=cv2.imdecode(img,1)
## #image=get_fundus(image)
## cv2.imwrite(path_sen + name + '_'+str(no)+'.jpg',image)
## no=no+1
## else:
## image=cv2.imdecode(images,1)
## #image=get_fundus(image)
## cv2.imwrite(path_sen + name + '.jpg',image)
##############################################################################
##################### End of Class Implementation ########################
##############################################################################
# for debugging
if __name__=='__main__':
fundus_cam=Fundus_Cam()
## this part of the code is for debugging and testing the Fundus_Cam class
image=fundus_cam.capture()
raw_input("start continuous??")
fundus_cam.continuous_capture()
while not fundus_cam.stopped:
pass
print "decoding still"
decode_image(image)
print "decoding continuous capture"
decode_image(fundus_cam.images)
fundus_cam.stop_preview()
|
server.py
|
import eel
import configparser
import subprocess
import threading
import sys
import os
import json
import glob
# ユーザー定義ファイル
import main
eel.init('view',allowed_extensions=['.js','.html','.css'])
@eel.expose
def on_button_clicked():
print("Button clicked[Python]")
eel.showAlert("Button clicked!")
@eel.expose
def config_import():
config_ini = configparser.ConfigParser()
config_ini.read('config/config.ini', encoding='utf-8')
config_bems = config_ini["BEMS"]
config_control = config_ini["CONTROL"]
config_simulation = config_ini["SIMULATION"]
config_layout = config_ini["LAYOUT"]
config_calc = config_ini["CALCULATION"]
return config_simulation["Simulation_time"], config_simulation["Output_folder_path"], config_bems["BEMS_file_path"], config_control["Control_file_path"], config_layout["Heat_source_file_path"], config_layout["Lyaout_floor_file_path"], config_calc["multiprocess"]
@eel.expose
def configure_save(simulation_step,out_folder,bems_file,control_folder,source_folder,layout_folder,mp):
config_ini = configparser.ConfigParser()
config_ini.read('config/config.ini', encoding='utf-8')
config_ini["SIMULATION"]["Simulation_time"] = simulation_step
config_ini["SIMULATION"]["output_folder_path"] = out_folder
config_ini["BEMS"]["bems_file_path"] = bems_file
config_ini["CONTROL"]["control_file_path"] = control_folder
config_ini["LAYOUT"]["heat_source_file_path"] = source_folder
config_ini["LAYOUT"]["lyaout_floor_file_path"] = layout_folder
if mp == "Yes":
config_ini["CALCULATION"]["multiprocess"] = "True"
else:
config_ini["CALCULATION"]["multiprocess"] = "False"
print("Save Configuration")
with open('config/config.ini', 'w',encoding="utf-8") as configfile:
# 指定したconfigファイルを書き込み
config_ini.write(configfile,True)
def simulation():
print("シミュレーションを実行します")
subprocess.run('python main.py', shell=True)
@eel.expose
def prepare_simulation():
thread1 = threading.Thread(target=simulation)
thread1.start()
@eel.expose
def render_dir():
path = 'out'
files = os.listdir(path)
files_dir = [f for f in files if os.path.isdir(os.path.join(path, f))]
return files_dir
@eel.expose
def render_floors(dir):
path = 'out/{}/'.format(dir)
files = os.listdir(path)
floors = []
for i in files:
if '.json' in i:
floors.append(i)
return floors
@eel.expose
def import_result_data(path):
json_open = open(path, 'r')
return json.load(json_open)
@eel.expose
def exit_simulation():
print("シミュレーションを中止します。")
eel.start('index.html',port=8080)
|
CanvasServer.py
|
from typing import Dict, Optional, Callable, Any
from threading import Thread
import json
import os.path as ospath
from .FileServer import (
FileServer,
relative_file_handler,
absolute_file_handler,
)
from .WebsocketServer import WebsocketServer
from . import Canvas, create_canvas, DispatchEvent, ReceiveEvent
class CanvasServer:
"""
A local HTTP server using WebSockets to transmit data.
"""
def __init__(self, file: Optional[str], host: str, port: int):
self._canvases: Dict[str, Canvas] = {}
file_handler = None
if file is None:
file_handler = absolute_file_handler(
ospath.abspath(ospath.dirname(__file__)), "algorithmx.html"
)
else:
file_handler = relative_file_handler(file)
self.file_server = FileServer(file_handler, host, port)
self.websocket_server = WebsocketServer(host, port + 1)
def receive_raw(message: str):
event = json.loads(message)
canvas_name = event["canvas"] if "canvas" in event else "0"
if canvas_name in self._canvases:
self._canvases[canvas_name].receive(event)
self.websocket_server.onreceive(receive_raw)
def start(self):
"""
Starts the server on the current threat, blocking all further execution until
the server shuts down.
"""
websocket_thread = Thread(
target=lambda: self.websocket_server.start(), daemon=True
)
websocket_thread.start()
try:
self.file_server.start()
except (KeyboardInterrupt, SystemExit):
pass
def shutdown(self):
"""
Shuts down the server. This must be called on a different thread to the one used
to start the server.
"""
self.file_server.shutdown()
def canvas(self, name: Optional[str] = None) -> Canvas:
"""Returns an :class:`~api.Canvas` interface, which will dispatch and receive
events through a WebSocket connected to the server.
:name: (Optional) The name of the canvas. By default, each server will only
render one canvas, and so this argument has no affect. However, if you wish
to design a custom UI with more than one canvas per page, you can use this
to differentiate between them.
"""
full_name = name or "0"
if full_name in self._canvases:
return self._canvases[full_name]
def dispatch(event: DispatchEvent):
json_event = {
**event,
**({"canvas": name} if name is not None else {}),
}
self.websocket_server.dispatch(json.dumps(json_event))
canvas = create_canvas()
canvas.ondispatch(dispatch)
self._canvases[full_name] = canvas
return canvas
|
test_core.py
|
# -*- coding: utf-8 -*-
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
from __future__ import print_function
import json
import mock
import multiprocessing
import os
import re
import signal
import sqlalchemy
import subprocess
import tempfile
from datetime import timedelta
from dateutil.relativedelta import relativedelta
from email.mime.application import MIMEApplication
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from numpy.testing import assert_array_almost_equal
from six.moves.urllib.parse import urlencode
from time import sleep, time
from bs4 import BeautifulSoup
from airflow.executors import SequentialExecutor
from airflow.models import DagModel, Variable, TaskInstance, DagRun
from airflow import jobs, models, DAG, utils, settings, exceptions
from airflow.models import BaseOperator, Connection, TaskFail
from airflow.operators.bash_operator import BashOperator
from airflow.operators.check_operator import CheckOperator, ValueCheckOperator
from airflow.operators.dagrun_operator import TriggerDagRunOperator
from airflow.operators.python_operator import PythonOperator
from airflow.operators.dummy_operator import DummyOperator
from airflow.hooks.base_hook import BaseHook
from airflow.hooks.sqlite_hook import SqliteHook
from airflow.bin import cli
from airflow.utils.file import TemporaryDirectory
from airflow.www import app as application
from airflow.settings import Session
from airflow.utils import timezone
from airflow.utils.timezone import datetime
from airflow.utils.state import State
from airflow.utils.timeout import timeout
from airflow.utils.dates import days_ago, infer_time_unit, round_time, scale_time_units
from airflow.exceptions import AirflowException
from airflow.configuration import (
AirflowConfigException, run_command, conf, parameterized_config, DEFAULT_CONFIG
)
from jinja2.exceptions import SecurityError
from jinja2 import UndefinedError
from pendulum import utcnow
import six
from tests.test_utils.config import conf_vars
if six.PY2:
# Need `assertWarns` back-ported from unittest2
import unittest2 as unittest
else:
import unittest
NUM_EXAMPLE_DAGS = 24
DEV_NULL = '/dev/null'
TEST_DAG_FOLDER = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'dags')
DEFAULT_DATE = datetime(2015, 1, 1)
DEFAULT_DATE_ISO = DEFAULT_DATE.isoformat()
DEFAULT_DATE_DS = DEFAULT_DATE_ISO[:10]
TEST_DAG_ID = 'unit_tests'
EXAMPLE_DAG_DEFAULT_DATE = days_ago(2)
try:
import cPickle as pickle
except ImportError:
# Python 3
import pickle # type: ignore
class OperatorSubclass(BaseOperator):
"""
An operator to test template substitution
"""
template_fields = ['some_templated_field']
def __init__(self, some_templated_field, *args, **kwargs):
super(OperatorSubclass, self).__init__(*args, **kwargs)
self.some_templated_field = some_templated_field
def execute(*args, **kwargs):
pass
class CoreTest(unittest.TestCase):
default_scheduler_args = {"num_runs": 1}
def setUp(self):
self.dagbag = models.DagBag(
dag_folder=DEV_NULL, include_examples=True)
self.args = {'owner': 'airflow', 'start_date': DEFAULT_DATE}
self.dag = DAG(TEST_DAG_ID, default_args=self.args)
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
self.run_after_loop = self.dag_bash.get_task('run_after_loop')
self.run_this_last = self.dag_bash.get_task('run_this_last')
def tearDown(self):
session = Session()
session.query(DagRun).filter(
DagRun.dag_id == TEST_DAG_ID).delete(
synchronize_session=False)
session.query(TaskInstance).filter(
TaskInstance.dag_id == TEST_DAG_ID).delete(
synchronize_session=False)
session.query(TaskFail).filter(
TaskFail.dag_id == TEST_DAG_ID).delete(
synchronize_session=False)
session.commit()
session.close()
def test_schedule_dag_no_previous_runs(self):
"""
Tests scheduling a dag with no previous runs
"""
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_no_previous_runs')
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertEqual(dag.dag_id, dag_run.dag_id)
self.assertIsNotNone(dag_run.run_id)
self.assertNotEqual('', dag_run.run_id)
self.assertEqual(
datetime(2015, 1, 2, 0, 0),
dag_run.execution_date,
msg='dag_run.execution_date did not match expectation: {0}'
.format(dag_run.execution_date)
)
self.assertEqual(State.RUNNING, dag_run.state)
self.assertFalse(dag_run.external_trigger)
dag.clear()
def test_schedule_dag_relativedelta(self):
"""
Tests scheduling a dag with a relativedelta schedule_interval
"""
delta = relativedelta(hours=+1)
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_relativedelta',
schedule_interval=delta)
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertEqual(dag.dag_id, dag_run.dag_id)
self.assertIsNotNone(dag_run.run_id)
self.assertNotEqual('', dag_run.run_id)
self.assertEqual(
datetime(2015, 1, 2, 0, 0),
dag_run.execution_date,
msg='dag_run.execution_date did not match expectation: {0}'
.format(dag_run.execution_date)
)
self.assertEqual(State.RUNNING, dag_run.state)
self.assertFalse(dag_run.external_trigger)
dag_run2 = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
self.assertIsNotNone(dag_run2)
self.assertEqual(dag.dag_id, dag_run2.dag_id)
self.assertIsNotNone(dag_run2.run_id)
self.assertNotEqual('', dag_run2.run_id)
self.assertEqual(
datetime(2015, 1, 2, 0, 0) + delta,
dag_run2.execution_date,
msg='dag_run2.execution_date did not match expectation: {0}'
.format(dag_run2.execution_date)
)
self.assertEqual(State.RUNNING, dag_run2.state)
self.assertFalse(dag_run2.external_trigger)
dag.clear()
def test_schedule_dag_fake_scheduled_previous(self):
"""
Test scheduling a dag where there is a prior DagRun
which has the same run_id as the next run should have
"""
delta = timedelta(hours=1)
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_fake_scheduled_previous',
schedule_interval=delta,
start_date=DEFAULT_DATE)
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=DEFAULT_DATE))
scheduler = jobs.SchedulerJob(**self.default_scheduler_args)
dag.create_dagrun(run_id=models.DagRun.id_for_date(DEFAULT_DATE),
execution_date=DEFAULT_DATE,
state=State.SUCCESS,
external_trigger=True)
dag_run = scheduler.create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertEqual(dag.dag_id, dag_run.dag_id)
self.assertIsNotNone(dag_run.run_id)
self.assertNotEqual('', dag_run.run_id)
self.assertEqual(
DEFAULT_DATE + delta,
dag_run.execution_date,
msg='dag_run.execution_date did not match expectation: {0}'
.format(dag_run.execution_date)
)
self.assertEqual(State.RUNNING, dag_run.state)
self.assertFalse(dag_run.external_trigger)
def test_schedule_dag_once(self):
"""
Tests scheduling a dag scheduled for @once - should be scheduled the first time
it is called, and not scheduled the second.
"""
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_once')
dag.schedule_interval = '@once'
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
dag_run = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
dag_run2 = jobs.SchedulerJob(**self.default_scheduler_args).create_dag_run(dag)
self.assertIsNotNone(dag_run)
self.assertIsNone(dag_run2)
dag.clear()
def test_fractional_seconds(self):
"""
Tests if fractional seconds are stored in the database
"""
dag = DAG(TEST_DAG_ID + 'test_fractional_seconds')
dag.schedule_interval = '@once'
dag.add_task(models.BaseOperator(
task_id="faketastic",
owner='Also fake',
start_date=datetime(2015, 1, 2, 0, 0)))
start_date = timezone.utcnow()
run = dag.create_dagrun(
run_id='test_' + start_date.isoformat(),
execution_date=start_date,
start_date=start_date,
state=State.RUNNING,
external_trigger=False
)
run.refresh_from_db()
self.assertEqual(start_date, run.execution_date,
"dag run execution_date loses precision")
self.assertEqual(start_date, run.start_date,
"dag run start_date loses precision ")
def test_schedule_dag_start_end_dates(self):
"""
Tests that an attempt to schedule a task after the Dag's end_date
does not succeed.
"""
delta = timedelta(hours=1)
runs = 3
start_date = DEFAULT_DATE
end_date = start_date + (runs - 1) * delta
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_start_end_dates',
start_date=start_date,
end_date=end_date,
schedule_interval=delta)
dag.add_task(models.BaseOperator(task_id='faketastic',
owner='Also fake'))
# Create and schedule the dag runs
dag_runs = []
scheduler = jobs.SchedulerJob(**self.default_scheduler_args)
for i in range(runs):
dag_runs.append(scheduler.create_dag_run(dag))
additional_dag_run = scheduler.create_dag_run(dag)
for dag_run in dag_runs:
self.assertIsNotNone(dag_run)
self.assertIsNone(additional_dag_run)
def test_schedule_dag_no_end_date_up_to_today_only(self):
"""
Tests that a Dag created without an end_date can only be scheduled up
to and including the current datetime.
For example, if today is 2016-01-01 and we are scheduling from a
start_date of 2015-01-01, only jobs up to, but not including
2016-01-01 should be scheduled.
"""
session = settings.Session()
delta = timedelta(days=1)
now = utcnow()
start_date = now.subtract(weeks=1)
runs = (now - start_date).days
dag = DAG(TEST_DAG_ID + 'test_schedule_dag_no_end_date_up_to_today_only',
start_date=start_date,
schedule_interval=delta)
dag.add_task(models.BaseOperator(task_id='faketastic',
owner='Also fake'))
dag_runs = []
scheduler = jobs.SchedulerJob(**self.default_scheduler_args)
for i in range(runs):
dag_run = scheduler.create_dag_run(dag)
dag_runs.append(dag_run)
# Mark the DagRun as complete
dag_run.state = State.SUCCESS
session.merge(dag_run)
session.commit()
# Attempt to schedule an additional dag run (for 2016-01-01)
additional_dag_run = scheduler.create_dag_run(dag)
for dag_run in dag_runs:
self.assertIsNotNone(dag_run)
self.assertIsNone(additional_dag_run)
def test_confirm_unittest_mod(self):
self.assertTrue(conf.get('core', 'unit_test_mode'))
def test_pickling(self):
dp = self.dag.pickle()
self.assertEqual(dp.pickle.dag_id, self.dag.dag_id)
def test_rich_comparison_ops(self):
class DAGsubclass(DAG):
pass
dag_eq = DAG(TEST_DAG_ID, default_args=self.args)
dag_diff_load_time = DAG(TEST_DAG_ID, default_args=self.args)
dag_diff_name = DAG(TEST_DAG_ID + '_neq', default_args=self.args)
dag_subclass = DAGsubclass(TEST_DAG_ID, default_args=self.args)
dag_subclass_diff_name = DAGsubclass(
TEST_DAG_ID + '2', default_args=self.args)
for d in [dag_eq, dag_diff_name, dag_subclass, dag_subclass_diff_name]:
d.last_loaded = self.dag.last_loaded
# test identity equality
self.assertEqual(self.dag, self.dag)
# test dag (in)equality based on _comps
self.assertEqual(dag_eq, self.dag)
self.assertNotEqual(dag_diff_name, self.dag)
self.assertNotEqual(dag_diff_load_time, self.dag)
# test dag inequality based on type even if _comps happen to match
self.assertNotEqual(dag_subclass, self.dag)
# a dag should equal an unpickled version of itself
d = pickle.dumps(self.dag)
self.assertEqual(pickle.loads(d), self.dag)
# dags are ordered based on dag_id no matter what the type is
self.assertLess(self.dag, dag_diff_name)
self.assertGreater(self.dag, dag_diff_load_time)
self.assertLess(self.dag, dag_subclass_diff_name)
# greater than should have been created automatically by functools
self.assertGreater(dag_diff_name, self.dag)
# hashes are non-random and match equality
self.assertEqual(hash(self.dag), hash(self.dag))
self.assertEqual(hash(dag_eq), hash(self.dag))
self.assertNotEqual(hash(dag_diff_name), hash(self.dag))
self.assertNotEqual(hash(dag_subclass), hash(self.dag))
def test_check_operators(self):
conn_id = "sqlite_default"
captainHook = BaseHook.get_hook(conn_id=conn_id)
captainHook.run("CREATE TABLE operator_test_table (a, b)")
captainHook.run("insert into operator_test_table values (1,2)")
t = CheckOperator(
task_id='check',
sql="select count(*) from operator_test_table",
conn_id=conn_id,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
t = ValueCheckOperator(
task_id='value_check',
pass_value=95,
tolerance=0.1,
conn_id=conn_id,
sql="SELECT 100",
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
captainHook.run("drop table operator_test_table")
def test_clear_api(self):
task = self.dag_bash.tasks[0]
task.clear(
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE,
upstream=True, downstream=True)
ti = models.TaskInstance(task=task, execution_date=DEFAULT_DATE)
ti.are_dependents_done()
def test_illegal_args(self):
"""
Tests that Operators reject illegal arguments
"""
with self.assertWarns(PendingDeprecationWarning) as cm:
task = BashOperator(
task_id='test_illegal_args',
bash_command='echo success',
dag=self.dag,
illegal_argument_1234='hello?')
assert task, "The task should be created."
warning = cm.warning
assert "Invalid arguments were passed to BashOperator " \
"(task_id: test_illegal_args). Support for passing such arguments will be dropped " \
"in Airflow 2.0. Invalid arguments were:\n" \
"*args: ()\n" \
"**kwargs: {'illegal_argument_1234': 'hello?'}" == warning.args[0]
def test_bash_operator(self):
t = BashOperator(
task_id='test_bash_operator',
bash_command="echo success",
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_bash_operator_multi_byte_output(self):
t = BashOperator(
task_id='test_multi_byte_bash_operator',
bash_command=u"echo \u2600",
dag=self.dag,
output_encoding='utf-8')
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_bash_operator_kill(self):
import psutil
sleep_time = "100%d" % os.getpid()
t = BashOperator(
task_id='test_bash_operator_kill',
execution_timeout=timedelta(seconds=1),
bash_command="/bin/bash -c 'sleep %s'" % sleep_time,
dag=self.dag)
self.assertRaises(
exceptions.AirflowTaskTimeout,
t.run,
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE)
sleep(2)
pid = -1
for proc in psutil.process_iter():
if proc.cmdline() == ['sleep', sleep_time]:
pid = proc.pid
if pid != -1:
os.kill(pid, signal.SIGTERM)
self.fail("BashOperator's subprocess still running after stopping on timeout!")
def test_on_failure_callback(self):
# Annoying workaround for nonlocal not existing in python 2
data = {'called': False}
def check_failure(context, test_case=self):
data['called'] = True
error = context.get('exception')
test_case.assertIsInstance(error, AirflowException)
t = BashOperator(
task_id='check_on_failure_callback',
bash_command="exit 1",
dag=self.dag,
on_failure_callback=check_failure)
self.assertRaises(
exceptions.AirflowException,
t.run,
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
self.assertTrue(data['called'])
def test_trigger_dagrun(self):
def trigga(context, obj):
if True:
return obj
t = TriggerDagRunOperator(
task_id='test_trigger_dagrun',
trigger_dag_id='example_bash_operator',
python_callable=trigga,
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_dryrun(self):
t = BashOperator(
task_id='test_dryrun',
bash_command="echo success",
dag=self.dag)
t.dry_run()
def test_sqlite(self):
import airflow.operators.sqlite_operator
t = airflow.operators.sqlite_operator.SqliteOperator(
task_id='time_sqlite',
sql="CREATE TABLE IF NOT EXISTS unitest (dummy VARCHAR(20))",
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_timeout(self):
t = PythonOperator(
task_id='test_timeout',
execution_timeout=timedelta(seconds=1),
python_callable=lambda: sleep(5),
dag=self.dag)
self.assertRaises(
exceptions.AirflowTaskTimeout,
t.run,
start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_python_op(self):
def test_py_op(templates_dict, ds, **kwargs):
if not templates_dict['ds'] == ds:
raise Exception("failure")
t = PythonOperator(
task_id='test_py_op',
provide_context=True,
python_callable=test_py_op,
templates_dict={'ds': "{{ ds }}"},
dag=self.dag)
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_complex_template(self):
def verify_templated_field(context):
self.assertEqual(context['ti'].task.some_templated_field['bar'][1],
context['ds'])
t = OperatorSubclass(
task_id='test_complex_template',
some_templated_field={
'foo': '123',
'bar': ['baz', '{{ ds }}']
},
dag=self.dag)
t.execute = verify_templated_field
t.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
def test_template_non_bool(self):
"""
Test templates can handle objects with no sense of truthiness
"""
class NonBoolObject(object):
def __len__(self):
return NotImplemented
def __bool__(self):
return NotImplemented
t = OperatorSubclass(
task_id='test_bad_template_obj',
some_templated_field=NonBoolObject(),
dag=self.dag)
t.resolve_template_files()
def test_task_get_template(self):
TI = models.TaskInstance
ti = TI(
task=self.runme_0, execution_date=DEFAULT_DATE)
ti.dag = self.dag_bash
ti.run(ignore_ti_state=True)
context = ti.get_template_context()
# DEFAULT DATE is 2015-01-01
self.assertEqual(context['ds'], '2015-01-01')
self.assertEqual(context['ds_nodash'], '20150101')
# next_ds is 2015-01-02 as the dag interval is daily
self.assertEqual(context['next_ds'], '2015-01-02')
self.assertEqual(context['next_ds_nodash'], '20150102')
# prev_ds is 2014-12-31 as the dag interval is daily
self.assertEqual(context['prev_ds'], '2014-12-31')
self.assertEqual(context['prev_ds_nodash'], '20141231')
self.assertEqual(context['ts'], '2015-01-01T00:00:00+00:00')
self.assertEqual(context['ts_nodash'], '20150101T000000')
self.assertEqual(context['ts_nodash_with_tz'], '20150101T000000+0000')
self.assertEqual(context['yesterday_ds'], '2014-12-31')
self.assertEqual(context['yesterday_ds_nodash'], '20141231')
self.assertEqual(context['tomorrow_ds'], '2015-01-02')
self.assertEqual(context['tomorrow_ds_nodash'], '20150102')
def test_import_examples(self):
self.assertEqual(len(self.dagbag.dags), NUM_EXAMPLE_DAGS)
def test_local_task_job(self):
TI = models.TaskInstance
ti = TI(
task=self.runme_0, execution_date=DEFAULT_DATE)
job = jobs.LocalTaskJob(task_instance=ti, ignore_ti_state=True)
job.run()
def test_raw_job(self):
TI = models.TaskInstance
ti = TI(
task=self.runme_0, execution_date=DEFAULT_DATE)
ti.dag = self.dag_bash
ti.run(ignore_ti_state=True)
def test_variable_set_get_round_trip(self):
Variable.set("tested_var_set_id", "Monday morning breakfast")
self.assertEqual("Monday morning breakfast", Variable.get("tested_var_set_id"))
def test_variable_set_existing_value_to_blank(self):
test_value = 'Some value'
test_key = 'test_key'
Variable.set(test_key, test_value)
Variable.set(test_key, '')
self.assertEqual('', Variable.get('test_key'))
def test_variable_set_get_round_trip_json(self):
value = {"a": 17, "b": 47}
Variable.set("tested_var_set_id", value, serialize_json=True)
self.assertEqual(value, Variable.get("tested_var_set_id", deserialize_json=True))
def test_get_non_existing_var_should_return_default(self):
default_value = "some default val"
self.assertEqual(default_value, Variable.get("thisIdDoesNotExist",
default_var=default_value))
def test_get_non_existing_var_should_raise_key_error(self):
with self.assertRaises(KeyError):
Variable.get("thisIdDoesNotExist")
def test_get_non_existing_var_with_none_default_should_return_none(self):
self.assertIsNone(Variable.get("thisIdDoesNotExist", default_var=None))
def test_get_non_existing_var_should_not_deserialize_json_default(self):
default_value = "}{ this is a non JSON default }{"
self.assertEqual(default_value, Variable.get("thisIdDoesNotExist",
default_var=default_value,
deserialize_json=True))
def test_variable_setdefault_round_trip(self):
key = "tested_var_setdefault_1_id"
value = "Monday morning breakfast in Paris"
Variable.setdefault(key, value)
self.assertEqual(value, Variable.get(key))
def test_variable_setdefault_round_trip_json(self):
key = "tested_var_setdefault_2_id"
value = {"city": 'Paris', "Hapiness": True}
Variable.setdefault(key, value, deserialize_json=True)
self.assertEqual(value, Variable.get(key, deserialize_json=True))
def test_variable_setdefault_existing_json(self):
key = "tested_var_setdefault_2_id"
value = {"city": 'Paris', "Hapiness": True}
Variable.set(key, value, serialize_json=True)
val = Variable.setdefault(key, value, deserialize_json=True)
# Check the returned value, and the stored value are handled correctly.
self.assertEqual(value, val)
self.assertEqual(value, Variable.get(key, deserialize_json=True))
def test_variable_delete(self):
key = "tested_var_delete"
value = "to be deleted"
# No-op if the variable doesn't exist
Variable.delete(key)
with self.assertRaises(KeyError):
Variable.get(key)
# Set the variable
Variable.set(key, value)
self.assertEqual(value, Variable.get(key))
# Delete the variable
Variable.delete(key)
with self.assertRaises(KeyError):
Variable.get(key)
def test_parameterized_config_gen(self):
cfg = parameterized_config(DEFAULT_CONFIG)
# making sure some basic building blocks are present:
self.assertIn("[core]", cfg)
self.assertIn("dags_folder", cfg)
self.assertIn("sql_alchemy_conn", cfg)
self.assertIn("fernet_key", cfg)
# making sure replacement actually happened
self.assertNotIn("{AIRFLOW_HOME}", cfg)
self.assertNotIn("{FERNET_KEY}", cfg)
def test_config_use_original_when_original_and_fallback_are_present(self):
self.assertTrue(conf.has_option("core", "FERNET_KEY"))
self.assertFalse(conf.has_option("core", "FERNET_KEY_CMD"))
FERNET_KEY = conf.get('core', 'FERNET_KEY')
with conf_vars({('core', 'FERNET_KEY_CMD'): 'printf HELLO'}):
FALLBACK_FERNET_KEY = conf.get(
"core",
"FERNET_KEY"
)
self.assertEqual(FERNET_KEY, FALLBACK_FERNET_KEY)
def test_config_throw_error_when_original_and_fallback_is_absent(self):
self.assertTrue(conf.has_option("core", "FERNET_KEY"))
self.assertFalse(conf.has_option("core", "FERNET_KEY_CMD"))
with conf_vars({('core', 'fernet_key'): None}):
with self.assertRaises(AirflowConfigException) as cm:
conf.get("core", "FERNET_KEY")
exception = str(cm.exception)
message = "section/key [core/fernet_key] not found in config"
self.assertEqual(message, exception)
def test_config_override_original_when_non_empty_envvar_is_provided(self):
key = "AIRFLOW__CORE__FERNET_KEY"
value = "some value"
self.assertNotIn(key, os.environ)
os.environ[key] = value
FERNET_KEY = conf.get('core', 'FERNET_KEY')
self.assertEqual(value, FERNET_KEY)
# restore the envvar back to the original state
del os.environ[key]
def test_config_override_original_when_empty_envvar_is_provided(self):
key = "AIRFLOW__CORE__FERNET_KEY"
value = ""
self.assertNotIn(key, os.environ)
os.environ[key] = value
FERNET_KEY = conf.get('core', 'FERNET_KEY')
self.assertEqual(value, FERNET_KEY)
# restore the envvar back to the original state
del os.environ[key]
def test_round_time(self):
rt1 = round_time(datetime(2015, 1, 1, 6), timedelta(days=1))
self.assertEqual(datetime(2015, 1, 1, 0, 0), rt1)
rt2 = round_time(datetime(2015, 1, 2), relativedelta(months=1))
self.assertEqual(datetime(2015, 1, 1, 0, 0), rt2)
rt3 = round_time(datetime(2015, 9, 16, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 16, 0, 0), rt3)
rt4 = round_time(datetime(2015, 9, 15, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 15, 0, 0), rt4)
rt5 = round_time(datetime(2015, 9, 14, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 14, 0, 0), rt5)
rt6 = round_time(datetime(2015, 9, 13, 0, 0), timedelta(1), datetime(
2015, 9, 14, 0, 0))
self.assertEqual(datetime(2015, 9, 14, 0, 0), rt6)
def test_infer_time_unit(self):
self.assertEqual('minutes', infer_time_unit([130, 5400, 10]))
self.assertEqual('seconds', infer_time_unit([110, 50, 10, 100]))
self.assertEqual('hours', infer_time_unit([100000, 50000, 10000, 20000]))
self.assertEqual('days', infer_time_unit([200000, 100000]))
def test_scale_time_units(self):
# use assert_almost_equal from numpy.testing since we are comparing
# floating point arrays
arr1 = scale_time_units([130, 5400, 10], 'minutes')
assert_array_almost_equal(arr1, [2.167, 90.0, 0.167], decimal=3)
arr2 = scale_time_units([110, 50, 10, 100], 'seconds')
assert_array_almost_equal(arr2, [110.0, 50.0, 10.0, 100.0], decimal=3)
arr3 = scale_time_units([100000, 50000, 10000, 20000], 'hours')
assert_array_almost_equal(arr3, [27.778, 13.889, 2.778, 5.556],
decimal=3)
arr4 = scale_time_units([200000, 100000], 'days')
assert_array_almost_equal(arr4, [2.315, 1.157], decimal=3)
def test_bad_trigger_rule(self):
with self.assertRaises(AirflowException):
DummyOperator(
task_id='test_bad_trigger',
trigger_rule="non_existent",
dag=self.dag)
def test_terminate_task(self):
"""If a task instance's db state get deleted, it should fail"""
TI = models.TaskInstance
dag = self.dagbag.dags.get('test_utils')
task = dag.task_dict.get('sleeps_forever')
ti = TI(task=task, execution_date=DEFAULT_DATE)
job = jobs.LocalTaskJob(
task_instance=ti, ignore_ti_state=True, executor=SequentialExecutor())
# Running task instance asynchronously
p = multiprocessing.Process(target=job.run)
p.start()
sleep(5)
settings.engine.dispose()
session = settings.Session()
ti.refresh_from_db(session=session)
# making sure it's actually running
self.assertEqual(State.RUNNING, ti.state)
ti = session.query(TI).filter_by(
dag_id=task.dag_id,
task_id=task.task_id,
execution_date=DEFAULT_DATE
).one()
# deleting the instance should result in a failure
session.delete(ti)
session.commit()
# waiting for the async task to finish
p.join()
# making sure that the task ended up as failed
ti.refresh_from_db(session=session)
self.assertEqual(State.FAILED, ti.state)
session.close()
def test_task_fail_duration(self):
"""If a task fails, the duration should be recorded in TaskFail"""
p = BashOperator(
task_id='pass_sleepy',
bash_command='sleep 3',
dag=self.dag)
f = BashOperator(
task_id='fail_sleepy',
bash_command='sleep 5',
execution_timeout=timedelta(seconds=3),
retry_delay=timedelta(seconds=0),
dag=self.dag)
session = settings.Session()
try:
p.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
except Exception:
pass
try:
f.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
except Exception:
pass
p_fails = session.query(TaskFail).filter_by(
task_id='pass_sleepy',
dag_id=self.dag.dag_id,
execution_date=DEFAULT_DATE).all()
f_fails = session.query(TaskFail).filter_by(
task_id='fail_sleepy',
dag_id=self.dag.dag_id,
execution_date=DEFAULT_DATE).all()
self.assertEqual(0, len(p_fails))
self.assertEqual(1, len(f_fails))
self.assertGreaterEqual(sum([f.duration for f in f_fails]), 3)
def test_run_command(self):
if six.PY3:
write = r'sys.stdout.buffer.write("\u1000foo".encode("utf8"))'
else:
write = r'sys.stdout.write(u"\u1000foo".encode("utf8"))'
cmd = 'import sys; {0}; sys.stdout.flush()'.format(write)
self.assertEqual(run_command("python -c '{0}'".format(cmd)),
u'\u1000foo' if six.PY3 else 'foo')
self.assertEqual(run_command('echo "foo bar"'), u'foo bar\n')
self.assertRaises(AirflowConfigException, run_command, 'bash -c "exit 1"')
def test_trigger_dagrun_with_execution_date(self):
utc_now = timezone.utcnow()
run_id = 'trig__' + utc_now.isoformat()
def payload_generator(context, object):
object.run_id = run_id
return object
task = TriggerDagRunOperator(task_id='test_trigger_dagrun_with_execution_date',
trigger_dag_id='example_bash_operator',
python_callable=payload_generator,
execution_date=utc_now,
dag=self.dag)
task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
dag_runs = models.DagRun.find(dag_id='example_bash_operator',
run_id=run_id)
self.assertEqual(len(dag_runs), 1)
dag_run = dag_runs[0]
self.assertEqual(dag_run.execution_date, utc_now)
def test_trigger_dagrun_with_str_execution_date(self):
utc_now_str = timezone.utcnow().isoformat()
self.assertIsInstance(utc_now_str, six.string_types)
run_id = 'trig__' + utc_now_str
def payload_generator(context, object):
object.run_id = run_id
return object
task = TriggerDagRunOperator(
task_id='test_trigger_dagrun_with_str_execution_date',
trigger_dag_id='example_bash_operator',
python_callable=payload_generator,
execution_date=utc_now_str,
dag=self.dag)
task.run(start_date=DEFAULT_DATE, end_date=DEFAULT_DATE, ignore_ti_state=True)
dag_runs = models.DagRun.find(dag_id='example_bash_operator',
run_id=run_id)
self.assertEqual(len(dag_runs), 1)
dag_run = dag_runs[0]
self.assertEqual(dag_run.execution_date.isoformat(), utc_now_str)
def test_trigger_dagrun_with_templated_execution_date(self):
task = TriggerDagRunOperator(
task_id='test_trigger_dagrun_with_str_execution_date',
trigger_dag_id='example_bash_operator',
execution_date='{{ execution_date }}',
dag=self.dag)
self.assertTrue(isinstance(task.execution_date, six.string_types))
self.assertEqual(task.execution_date, '{{ execution_date }}')
ti = TaskInstance(task=task, execution_date=DEFAULT_DATE)
ti.render_templates()
self.assertEqual(timezone.parse(task.execution_date), DEFAULT_DATE)
def test_externally_triggered_dagrun(self):
TI = models.TaskInstance
# Create the dagrun between two "scheduled" execution dates of the DAG
EXECUTION_DATE = DEFAULT_DATE + timedelta(days=2)
EXECUTION_DS = EXECUTION_DATE.strftime('%Y-%m-%d')
EXECUTION_DS_NODASH = EXECUTION_DS.replace('-', '')
dag = DAG(
TEST_DAG_ID,
default_args=self.args,
schedule_interval=timedelta(weeks=1),
start_date=DEFAULT_DATE)
task = DummyOperator(task_id='test_externally_triggered_dag_context',
dag=dag)
dag.create_dagrun(run_id=models.DagRun.id_for_date(EXECUTION_DATE),
execution_date=EXECUTION_DATE,
state=State.RUNNING,
external_trigger=True)
task.run(
start_date=EXECUTION_DATE, end_date=EXECUTION_DATE)
ti = TI(task=task, execution_date=EXECUTION_DATE)
context = ti.get_template_context()
# next_ds/prev_ds should be the execution date for manually triggered runs
self.assertEqual(context['next_ds'], EXECUTION_DS)
self.assertEqual(context['next_ds_nodash'], EXECUTION_DS_NODASH)
self.assertEqual(context['prev_ds'], EXECUTION_DS)
self.assertEqual(context['prev_ds_nodash'], EXECUTION_DS_NODASH)
class CliTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
super(CliTests, cls).setUpClass()
cls._cleanup()
def setUp(self):
super(CliTests, self).setUp()
from airflow.www_rbac import app as application
self.app, self.appbuilder = application.create_app(session=Session, testing=True)
self.app.config['TESTING'] = True
self.parser = cli.CLIFactory.get_parser()
self.dagbag = models.DagBag(dag_folder=DEV_NULL, include_examples=True)
settings.configure_orm()
self.session = Session
def tearDown(self):
self._cleanup(session=self.session)
super(CliTests, self).tearDown()
@staticmethod
def _cleanup(session=None):
if session is None:
session = Session()
session.query(models.Pool).delete()
session.query(models.Variable).delete()
session.commit()
session.close()
def test_cli_list_dags(self):
args = self.parser.parse_args(['list_dags', '--report'])
cli.list_dags(args)
def test_cli_list_dag_runs(self):
cli.trigger_dag(self.parser.parse_args([
'trigger_dag', 'example_bash_operator', ]))
args = self.parser.parse_args(['list_dag_runs',
'example_bash_operator',
'--no_backfill'])
cli.list_dag_runs(args)
def test_cli_create_user_random_password(self):
args = self.parser.parse_args([
'create_user', '-u', 'test1', '-l', 'doe', '-f', 'jon',
'-e', '[email protected]', '-r', 'Viewer', '--use_random_password'
])
cli.create_user(args)
def test_cli_create_user_supplied_password(self):
args = self.parser.parse_args([
'create_user', '-u', 'test2', '-l', 'doe', '-f', 'jon',
'-e', '[email protected]', '-r', 'Viewer', '-p', 'test'
])
cli.create_user(args)
def test_cli_delete_user(self):
args = self.parser.parse_args([
'create_user', '-u', 'test3', '-l', 'doe', '-f', 'jon',
'-e', '[email protected]', '-r', 'Viewer', '--use_random_password'
])
cli.create_user(args)
args = self.parser.parse_args([
'delete_user', '-u', 'test3',
])
cli.delete_user(args)
def test_cli_list_users(self):
for i in range(0, 3):
args = self.parser.parse_args([
'create_user', '-u', 'user{}'.format(i), '-l', 'doe', '-f', 'jon',
'-e', 'jdoe+{}@gmail.com'.format(i), '-r', 'Viewer',
'--use_random_password'
])
cli.create_user(args)
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.list_users(self.parser.parse_args(['list_users']))
stdout = mock_stdout.getvalue()
for i in range(0, 3):
self.assertIn('user{}'.format(i), stdout)
@mock.patch("airflow.settings.RBAC", True)
@mock.patch("airflow.settings.STORE_SERIALIZED_DAGS", True)
@mock.patch("airflow.bin.cli.DagBag")
def test_cli_sync_perm(self, dagbag_mock):
self.expect_dagbag_contains([
DAG('has_access_control',
access_control={
'Public': {'can_dag_read'}
}),
DAG('no_access_control')
], dagbag_mock)
self.appbuilder.sm = mock.Mock()
args = self.parser.parse_args([
'sync_perm'
])
cli.sync_perm(args)
self.appbuilder.sm.sync_roles.assert_called_once()
dagbag_mock.assert_called_once_with(store_serialized_dags=True)
self.assertEqual(2, len(self.appbuilder.sm.sync_perm_for_dag.mock_calls))
self.appbuilder.sm.sync_perm_for_dag.assert_any_call(
'has_access_control',
{'Public': {'can_dag_read'}}
)
self.appbuilder.sm.sync_perm_for_dag.assert_any_call(
'no_access_control',
None,
)
def expect_dagbag_contains(self, dags, dagbag_mock):
dagbag = mock.Mock()
dagbag.dags = {dag.dag_id: dag for dag in dags}
dagbag_mock.return_value = dagbag
def test_cli_list_tasks(self):
for dag_id in self.dagbag.dags.keys():
args = self.parser.parse_args(['list_tasks', dag_id])
cli.list_tasks(args)
args = self.parser.parse_args([
'list_tasks', 'example_bash_operator', '--tree'])
cli.list_tasks(args)
@mock.patch("airflow.bin.cli.db.initdb")
def test_cli_initdb(self, initdb_mock):
cli.initdb(self.parser.parse_args(['initdb']))
initdb_mock.assert_called_once_with(False)
@mock.patch("airflow.bin.cli.db.resetdb")
def test_cli_resetdb(self, resetdb_mock):
cli.resetdb(self.parser.parse_args(['resetdb', '--yes']))
resetdb_mock.assert_called_once_with(False)
def test_cli_connections_list(self):
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(['connections', '--list']))
stdout = mock_stdout.getvalue()
conns = [[x.strip("'") for x in re.findall(r"'\w+'", line)[:2]]
for ii, line in enumerate(stdout.split('\n'))
if ii % 2 == 1]
conns = [conn for conn in conns if len(conn) > 0]
# Assert that some of the connections are present in the output as
# expected:
self.assertIn(['aws_default', 'aws'], conns)
self.assertIn(['beeline_default', 'beeline'], conns)
self.assertIn(['emr_default', 'emr'], conns)
self.assertIn(['mssql_default', 'mssql'], conns)
self.assertIn(['mysql_default', 'mysql'], conns)
self.assertIn(['postgres_default', 'postgres'], conns)
self.assertIn(['wasb_default', 'wasb'], conns)
self.assertIn(['segment_default', 'segment'], conns)
# Attempt to list connections with invalid cli args
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--list', '--conn_id=fake', '--conn_uri=fake-uri',
'--conn_type=fake-type', '--conn_host=fake_host',
'--conn_login=fake_login', '--conn_password=fake_password',
'--conn_schema=fake_schema', '--conn_port=fake_port', '--conn_extra=fake_extra']))
stdout = mock_stdout.getvalue()
# Check list attempt stdout
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
("\tThe following args are not compatible with the " +
"--list flag: ['conn_id', 'conn_uri', 'conn_extra', " +
"'conn_type', 'conn_host', 'conn_login', " +
"'conn_password', 'conn_schema', 'conn_port']"),
])
def test_cli_connections_list_redirect(self):
cmd = ['airflow', 'connections', '--list']
with tempfile.TemporaryFile() as fp:
p = subprocess.Popen(cmd, stdout=fp)
p.wait()
self.assertEqual(0, p.returncode)
def test_cli_connections_add_delete(self):
# Add connections:
uri = 'postgresql://airflow:airflow@host:5432/airflow'
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new1',
'--conn_uri=%s' % uri]))
cli.connections(self.parser.parse_args(
['connections', '-a', '--conn_id=new2',
'--conn_uri=%s' % uri]))
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new3',
'--conn_uri=%s' % uri, '--conn_extra', "{'extra': 'yes'}"]))
cli.connections(self.parser.parse_args(
['connections', '-a', '--conn_id=new4',
'--conn_uri=%s' % uri, '--conn_extra', "{'extra': 'yes'}"]))
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new5',
'--conn_type=hive_metastore', '--conn_login=airflow',
'--conn_password=airflow', '--conn_host=host',
'--conn_port=9083', '--conn_schema=airflow']))
cli.connections(self.parser.parse_args(
['connections', '-a', '--conn_id=new6',
'--conn_uri', "", '--conn_type=google_cloud_platform', '--conn_extra', "{'extra': 'yes'}"]))
stdout = mock_stdout.getvalue()
# Check addition stdout
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
("\tSuccessfully added `conn_id`=new1 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new2 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new3 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new4 : " +
"postgresql://airflow:airflow@host:5432/airflow"),
("\tSuccessfully added `conn_id`=new5 : " +
"hive_metastore://airflow:******@host:9083/airflow"),
("\tSuccessfully added `conn_id`=new6 : " +
"google_cloud_platform://:******@:")
])
# Attempt to add duplicate
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new1',
'--conn_uri=%s' % uri]))
stdout = mock_stdout.getvalue()
# Check stdout for addition attempt
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
"\tA connection with `conn_id`=new1 already exists",
])
# Attempt to add without providing conn_id
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_uri=%s' % uri]))
stdout = mock_stdout.getvalue()
# Check stdout for addition attempt
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
("\tThe following args are required to add a connection:" +
" ['conn_id']"),
])
# Attempt to add without providing conn_uri
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--add', '--conn_id=new']))
stdout = mock_stdout.getvalue()
# Check stdout for addition attempt
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
("\tThe following args are required to add a connection:" +
" ['conn_uri or conn_type']"),
])
# Prepare to add connections
session = settings.Session()
extra = {'new1': None,
'new2': None,
'new3': "{'extra': 'yes'}",
'new4': "{'extra': 'yes'}"}
# Add connections
for index in range(1, 6):
conn_id = 'new%s' % index
result = (session
.query(Connection)
.filter(Connection.conn_id == conn_id)
.first())
result = (result.conn_id, result.conn_type, result.host,
result.port, result.get_extra())
if conn_id in ['new1', 'new2', 'new3', 'new4']:
self.assertEqual(result, (conn_id, 'postgres', 'host', 5432,
extra[conn_id]))
elif conn_id == 'new5':
self.assertEqual(result, (conn_id, 'hive_metastore', 'host',
9083, None))
elif conn_id == 'new6':
self.assertEqual(result, (conn_id, 'google_cloud_platform',
None, None, "{'extra': 'yes'}"))
# Delete connections
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new1']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new2']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new3']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new4']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new5']))
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=new6']))
stdout = mock_stdout.getvalue()
# Check deletion stdout
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
"\tSuccessfully deleted `conn_id`=new1",
"\tSuccessfully deleted `conn_id`=new2",
"\tSuccessfully deleted `conn_id`=new3",
"\tSuccessfully deleted `conn_id`=new4",
"\tSuccessfully deleted `conn_id`=new5",
"\tSuccessfully deleted `conn_id`=new6"
])
# Check deletions
for index in range(1, 7):
conn_id = 'new%s' % index
result = (session.query(Connection)
.filter(Connection.conn_id == conn_id)
.first())
self.assertTrue(result is None)
# Attempt to delete a non-existing connnection
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=fake']))
stdout = mock_stdout.getvalue()
# Check deletion attempt stdout
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
"\tDid not find a connection with `conn_id`=fake",
])
# Attempt to delete with invalid cli args
with mock.patch('sys.stdout',
new_callable=six.StringIO) as mock_stdout:
cli.connections(self.parser.parse_args(
['connections', '--delete', '--conn_id=fake',
'--conn_uri=%s' % uri, '--conn_type=fake-type']))
stdout = mock_stdout.getvalue()
# Check deletion attempt stdout
lines = [line for line in stdout.split('\n') if len(line) > 0]
self.assertListEqual(lines, [
("\tThe following args are not compatible with the " +
"--delete flag: ['conn_uri', 'conn_type']"),
])
session.close()
def test_cli_test(self):
cli.test(self.parser.parse_args([
'test', 'example_bash_operator', 'runme_0',
DEFAULT_DATE.isoformat()]))
cli.test(self.parser.parse_args([
'test', 'example_bash_operator', 'runme_0', '--dry_run',
DEFAULT_DATE.isoformat()]))
def test_cli_test_with_params(self):
cli.test(self.parser.parse_args([
'test', 'example_passing_params_via_test_command', 'run_this',
'-tp', '{"foo":"bar"}', DEFAULT_DATE.isoformat()]))
cli.test(self.parser.parse_args([
'test', 'example_passing_params_via_test_command', 'also_run_this',
'-tp', '{"foo":"bar"}', DEFAULT_DATE.isoformat()]))
def test_cli_run(self):
cli.run(self.parser.parse_args([
'run', 'example_bash_operator', 'runme_0', '-l',
DEFAULT_DATE.isoformat()]))
def test_task_state(self):
cli.task_state(self.parser.parse_args([
'task_state', 'example_bash_operator', 'runme_0',
DEFAULT_DATE.isoformat()]))
def test_dag_state(self):
self.assertEqual(None, cli.dag_state(self.parser.parse_args([
'dag_state', 'example_bash_operator', DEFAULT_DATE.isoformat()])))
def test_pause(self):
args = self.parser.parse_args([
'pause', 'example_bash_operator'])
cli.pause(args)
self.assertIn(self.dagbag.dags['example_bash_operator'].is_paused, [True, 1])
args = self.parser.parse_args([
'unpause', 'example_bash_operator'])
cli.unpause(args)
self.assertIn(self.dagbag.dags['example_bash_operator'].is_paused, [False, 0])
def test_subdag_clear(self):
args = self.parser.parse_args([
'clear', 'example_subdag_operator', '--no_confirm'])
cli.clear(args)
args = self.parser.parse_args([
'clear', 'example_subdag_operator', '--no_confirm', '--exclude_subdags'])
cli.clear(args)
def test_parentdag_downstream_clear(self):
args = self.parser.parse_args([
'clear', 'example_subdag_operator.section-1', '--no_confirm'])
cli.clear(args)
args = self.parser.parse_args([
'clear', 'example_subdag_operator.section-1', '--no_confirm',
'--exclude_parentdag'])
cli.clear(args)
def test_get_dags(self):
dags = cli.get_dags(self.parser.parse_args(['clear', 'example_subdag_operator',
'-c']))
self.assertEqual(len(dags), 1)
dags = cli.get_dags(self.parser.parse_args(['clear', 'subdag', '-dx', '-c']))
self.assertGreater(len(dags), 1)
with self.assertRaises(AirflowException):
cli.get_dags(self.parser.parse_args(['clear', 'foobar', '-dx', '-c']))
def test_process_subdir_path_with_placeholder(self):
self.assertEqual(os.path.join(settings.DAGS_FOLDER, 'abc'), cli.process_subdir('DAGS_FOLDER/abc'))
def test_trigger_dag(self):
cli.trigger_dag(self.parser.parse_args([
'trigger_dag', 'example_bash_operator',
'-c', '{"foo": "bar"}']))
self.assertRaises(
ValueError,
cli.trigger_dag,
self.parser.parse_args([
'trigger_dag', 'example_bash_operator',
'--run_id', 'trigger_dag_xxx',
'-c', 'NOT JSON'])
)
def test_delete_dag(self):
DM = models.DagModel
key = "my_dag_id"
session = settings.Session()
session.add(DM(dag_id=key))
session.commit()
cli.delete_dag(self.parser.parse_args([
'delete_dag', key, '--yes']))
self.assertEqual(session.query(DM).filter_by(dag_id=key).count(), 0)
self.assertRaises(
AirflowException,
cli.delete_dag,
self.parser.parse_args([
'delete_dag',
'does_not_exist_dag',
'--yes'])
)
def test_delete_dag_existing_file(self):
# Test to check that the DAG should be deleted even if
# the file containing it is not deleted
DM = DagModel
key = "my_dag_id"
session = settings.Session()
with tempfile.NamedTemporaryFile() as f:
session.add(DM(dag_id=key, fileloc=f.name))
session.commit()
cli.delete_dag(self.parser.parse_args([
'delete_dag', key, '--yes']))
self.assertEqual(session.query(DM).filter_by(dag_id=key).count(), 0)
def test_pool_create(self):
cli.pool(self.parser.parse_args(['pool', '-s', 'foo', '1', 'test']))
self.assertEqual(self.session.query(models.Pool).count(), 1)
def test_pool_get(self):
cli.pool(self.parser.parse_args(['pool', '-s', 'foo', '1', 'test']))
try:
cli.pool(self.parser.parse_args(['pool', '-g', 'foo']))
except Exception as e:
self.fail("The 'pool -g foo' command raised unexpectedly: %s" % e)
def test_pool_delete(self):
cli.pool(self.parser.parse_args(['pool', '-s', 'foo', '1', 'test']))
cli.pool(self.parser.parse_args(['pool', '-x', 'foo']))
self.assertEqual(self.session.query(models.Pool).count(), 0)
def test_pool_no_args(self):
try:
cli.pool(self.parser.parse_args(['pool']))
except Exception as e:
self.fail("The 'pool' command raised unexpectedly: %s" % e)
def test_pool_import_export(self):
# Create two pools first
pool_config_input = {
"foo": {
"description": "foo_test",
"slots": 1
},
"baz": {
"description": "baz_test",
"slots": 2
}
}
with open('pools_import.json', mode='w') as f:
json.dump(pool_config_input, f)
# Import json
try:
cli.pool(self.parser.parse_args(['pool', '-i', 'pools_import.json']))
except Exception as e:
self.fail("The 'pool -i pools_import.json' failed: %s" % e)
# Export json
try:
cli.pool(self.parser.parse_args(['pool', '-e', 'pools_export.json']))
except Exception as e:
self.fail("The 'pool -e pools_export.json' failed: %s" % e)
with open('pools_export.json', mode='r') as f:
pool_config_output = json.load(f)
self.assertEqual(
pool_config_input,
pool_config_output,
"Input and output pool files are not same")
os.remove('pools_import.json')
os.remove('pools_export.json')
def test_variables(self):
# Checks if all subcommands are properly received
cli.variables(self.parser.parse_args([
'variables', '-s', 'foo', '{"foo":"bar"}']))
cli.variables(self.parser.parse_args([
'variables', '-g', 'foo']))
cli.variables(self.parser.parse_args([
'variables', '-g', 'baz', '-d', 'bar']))
cli.variables(self.parser.parse_args([
'variables']))
cli.variables(self.parser.parse_args([
'variables', '-x', 'bar']))
cli.variables(self.parser.parse_args([
'variables', '-i', DEV_NULL]))
cli.variables(self.parser.parse_args([
'variables', '-e', DEV_NULL]))
cli.variables(self.parser.parse_args([
'variables', '-s', 'bar', 'original']))
# First export
cli.variables(self.parser.parse_args([
'variables', '-e', 'variables1.json']))
first_exp = open('variables1.json', 'r')
cli.variables(self.parser.parse_args([
'variables', '-s', 'bar', 'updated']))
cli.variables(self.parser.parse_args([
'variables', '-s', 'foo', '{"foo":"oops"}']))
cli.variables(self.parser.parse_args([
'variables', '-x', 'foo']))
# First import
cli.variables(self.parser.parse_args([
'variables', '-i', 'variables1.json']))
self.assertEqual('original', Variable.get('bar'))
self.assertEqual('{\n "foo": "bar"\n}', Variable.get('foo'))
# Second export
cli.variables(self.parser.parse_args([
'variables', '-e', 'variables2.json']))
second_exp = open('variables2.json', 'r')
self.assertEqual(first_exp.read(), second_exp.read())
second_exp.close()
first_exp.close()
# Second import
cli.variables(self.parser.parse_args([
'variables', '-i', 'variables2.json']))
self.assertEqual('original', Variable.get('bar'))
self.assertEqual('{\n "foo": "bar"\n}', Variable.get('foo'))
# Set a dict
cli.variables(self.parser.parse_args([
'variables', '-s', 'dict', '{"foo": "oops"}']))
# Set a list
cli.variables(self.parser.parse_args([
'variables', '-s', 'list', '["oops"]']))
# Set str
cli.variables(self.parser.parse_args([
'variables', '-s', 'str', 'hello string']))
# Set int
cli.variables(self.parser.parse_args([
'variables', '-s', 'int', '42']))
# Set float
cli.variables(self.parser.parse_args([
'variables', '-s', 'float', '42.0']))
# Set true
cli.variables(self.parser.parse_args([
'variables', '-s', 'true', 'true']))
# Set false
cli.variables(self.parser.parse_args([
'variables', '-s', 'false', 'false']))
# Set none
cli.variables(self.parser.parse_args([
'variables', '-s', 'null', 'null']))
# Export and then import
cli.variables(self.parser.parse_args([
'variables', '-e', 'variables3.json']))
cli.variables(self.parser.parse_args([
'variables', '-i', 'variables3.json']))
# Assert value
self.assertEqual({'foo': 'oops'}, models.Variable.get('dict', deserialize_json=True))
self.assertEqual(['oops'], models.Variable.get('list', deserialize_json=True))
self.assertEqual('hello string', models.Variable.get('str')) # cannot json.loads(str)
self.assertEqual(42, models.Variable.get('int', deserialize_json=True))
self.assertEqual(42.0, models.Variable.get('float', deserialize_json=True))
self.assertEqual(True, models.Variable.get('true', deserialize_json=True))
self.assertEqual(False, models.Variable.get('false', deserialize_json=True))
self.assertEqual(None, models.Variable.get('null', deserialize_json=True))
os.remove('variables1.json')
os.remove('variables2.json')
os.remove('variables3.json')
class TestCliWebServer(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.parser = cli.get_parser()
def setUp(self):
self._check_processes()
self._clean_pidfiles()
def tearDown(self):
self._check_processes()
self._clean_pidfiles()
def _check_processes(self):
# Confirm that webserver hasn't been launched.
# pgrep returns exit status 1 if no process matched.
exit_code_pgrep_webserver = subprocess.Popen(["pgrep", "-c", "-f", "airflow webserver"]).wait()
exit_code_pgrep_gunicorn = subprocess.Popen(["pgrep", "-c", "-f", "gunicorn"]).wait()
if exit_code_pgrep_webserver != 1 or exit_code_pgrep_gunicorn != 1:
subprocess.Popen(["ps", "-ax"]).wait()
if exit_code_pgrep_webserver != 1:
subprocess.Popen(["pkill", "-9", "-f", "airflow webserver"]).wait()
if exit_code_pgrep_gunicorn != 1:
subprocess.Popen(["pkill", "-9", "-f", "gunicorn"]).wait()
raise AssertionError(
"Background processes are running that prevent the test from passing successfully."
)
def _clean_pidfiles(self):
pidfile_webserver = cli.setup_locations("webserver")[0]
pidfile_monitor = cli.setup_locations("webserver-monitor")[0]
if os.path.exists(pidfile_webserver):
os.remove(pidfile_webserver)
if os.path.exists(pidfile_monitor):
os.remove(pidfile_monitor)
def _wait_pidfile(self, pidfile):
start_time = time()
while True:
try:
with open(pidfile) as file:
return int(file.read())
except Exception: # pylint: disable=broad-except
if start_time - time() > 60:
raise
sleep(1)
def test_cli_webserver_foreground(self):
with mock.patch.dict(
"os.environ",
AIRFLOW__CORE__DAGS_FOLDER="/dev/null",
AIRFLOW__CORE__LOAD_EXAMPLES="False",
AIRFLOW__WEBSERVER__WORKERS="1"
):
# Run webserver in foreground and terminate it.
proc = subprocess.Popen(["airflow", "webserver"])
self.assertEqual(None, proc.poll())
# Wait for process
sleep(10)
# Terminate webserver
proc.terminate()
with timeout(60):
# -15 - the server was stopped before it started
# 0 - the server terminated correctly
self.assertIn(proc.wait(), (-15, 0))
def test_cli_webserver_foreground_with_pid(self):
with TemporaryDirectory(prefix='tmp-pid') as tmpdir:
pidfile = "{}/pidfile".format(tmpdir)
with mock.patch.dict(
"os.environ",
AIRFLOW__CORE__DAGS_FOLDER="/dev/null",
AIRFLOW__CORE__LOAD_EXAMPLES="False",
AIRFLOW__WEBSERVER__WORKERS="1"
):
proc = subprocess.Popen(["airflow", "webserver", "--pid", pidfile])
self.assertEqual(None, proc.poll())
# Check the file specified by --pid option exists
self._wait_pidfile(pidfile)
# Terminate webserver
proc.terminate()
with timeout(60):
self.assertEqual(0, proc.wait())
def test_cli_webserver_background(self):
import psutil
with TemporaryDirectory(prefix="gunicorn") as tmpdir, \
mock.patch.dict(
"os.environ",
AIRFLOW__CORE__DAGS_FOLDER="/dev/null",
AIRFLOW__CORE__LOAD_EXAMPLES="False",
AIRFLOW__WEBSERVER__WORKERS="1"):
pidfile_webserver = "{}/pidflow-webserver.pid".format(tmpdir)
pidfile_monitor = "{}/pidflow-webserver-monitor.pid".format(tmpdir)
stdout = "{}/airflow-webserver.out".format(tmpdir)
stderr = "{}/airflow-webserver.err".format(tmpdir)
logfile = "{}/airflow-webserver.log".format(tmpdir)
try:
# Run webserver as daemon in background. Note that the wait method is not called.
proc = subprocess.Popen([
"airflow",
"webserver",
"--daemon",
"--pid", pidfile_webserver,
"--stdout", stdout,
"--stderr", stderr,
"--log-file", logfile,
])
self.assertEqual(None, proc.poll())
pid_monitor = self._wait_pidfile(pidfile_monitor)
self._wait_pidfile(pidfile_webserver)
# Assert that gunicorn and its monitor are launched.
self.assertEqual(
0, subprocess.Popen(["pgrep", "-f", "-c", "airflow webserver --daemon"]).wait()
)
self.assertEqual(0, subprocess.Popen(["pgrep", "-c", "-f", "gunicorn: master"]).wait())
# Terminate monitor process.
proc = psutil.Process(pid_monitor)
proc.terminate()
with timeout(120):
self.assertIn(proc.wait(), (0, None))
self._check_processes()
except Exception:
# List all logs
subprocess.Popen(["ls", "-lah", tmpdir]).wait()
# Dump all logs
subprocess.Popen(["bash", "-c", "ls {}/* | xargs -n 1 -t cat".format(tmpdir)]).wait()
raise
# Patch for causing webserver timeout
@mock.patch("airflow.bin.cli.GunicornMonitor._get_num_workers_running", return_value=0)
def test_cli_webserver_shutdown_when_gunicorn_master_is_killed(self, _):
# Shorten timeout so that this test doesn't take too long time
args = self.parser.parse_args(['webserver'])
with conf_vars({('webserver', 'web_server_master_timeout'): '10'}):
with self.assertRaises(SystemExit) as e:
cli.webserver(args)
self.assertEqual(e.exception.code, 1)
@conf_vars({('webserver', 'authenticate'): 'False', ('core', 'expose_config'): 'True'})
class SecurityTests(unittest.TestCase):
def setUp(self):
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
self.dagbag = models.DagBag(
dag_folder=DEV_NULL, include_examples=True)
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
def get_csrf(self, response):
tree = BeautifulSoup(response.data, 'html.parser')
return tree.find('input', attrs={'name': '_csrf_token'})['value']
def test_csrf_rejection(self):
endpoints = ([
"/admin/queryview/",
"/admin/airflow/paused?dag_id=example_python_operator&is_paused=false",
])
for endpoint in endpoints:
response = self.app.post(endpoint)
self.assertIn('CSRF token is missing', response.data.decode('utf-8'))
def test_csrf_acceptance(self):
response = self.app.get("/admin/queryview/")
csrf = self.get_csrf(response)
response = self.app.post("/admin/queryview/", data=dict(csrf_token=csrf))
self.assertEqual(200, response.status_code)
def test_xss(self):
try:
self.app.get("/admin/airflow/tree?dag_id=<script>alert(123456)</script>")
except Exception:
# exception is expected here since dag doesnt exist
pass
response = self.app.get("/admin/log", follow_redirects=True)
self.assertNotIn("<script>alert(123456)</script>", response.data.decode('UTF-8'))
def test_chart_data_template(self):
"""Protect chart_data from being able to do RCE."""
session = settings.Session()
Chart = models.Chart
chart1 = Chart(
label='insecure_chart',
conn_id='airflow_db',
chart_type='bar',
sql="SELECT {{ ''.__class__.__mro__[1].__subclasses__() }}"
)
chart2 = Chart(
label="{{ ''.__class__.__mro__[1].__subclasses__() }}",
conn_id='airflow_db',
chart_type='bar',
sql="SELECT 1"
)
chart3 = Chart(
label="{{ subprocess.check_output('ls') }}",
conn_id='airflow_db',
chart_type='bar',
sql="SELECT 1"
)
session.add(chart1)
session.add(chart2)
session.add(chart3)
session.commit()
chart1 = session.query(Chart).filter(Chart.label == 'insecure_chart').first()
with self.assertRaises(SecurityError):
self.app.get("/admin/airflow/chart_data?chart_id={}".format(chart1.id))
chart2 = session.query(Chart).filter(
Chart.label == "{{ ''.__class__.__mro__[1].__subclasses__() }}"
).first()
with self.assertRaises(SecurityError):
self.app.get("/admin/airflow/chart_data?chart_id={}".format(chart2.id))
chart3 = session.query(Chart).filter(
Chart.label == "{{ subprocess.check_output('ls') }}"
).first()
with self.assertRaises(UndefinedError):
self.app.get("/admin/airflow/chart_data?chart_id={}".format(chart3.id))
def tearDown(self):
self.dag_bash.clear(start_date=DEFAULT_DATE, end_date=timezone.utcnow())
@conf_vars({('webserver', 'authenticate'): 'False', ('core', 'expose_config'): 'True'})
class WebUiTests(unittest.TestCase):
def setUp(self):
app = application.create_app()
app.config['TESTING'] = True
app.config['WTF_CSRF_METHODS'] = []
self.app = app.test_client()
self.dagbag = models.DagBag(include_examples=True)
self.dag_bash = self.dagbag.dags['example_bash_operator']
self.dag_python = self.dagbag.dags['example_python_operator']
self.sub_dag = self.dagbag.dags['example_subdag_operator']
self.runme_0 = self.dag_bash.get_task('runme_0')
self.example_xcom = self.dagbag.dags['example_xcom']
session = Session()
session.query(models.DagRun).delete()
session.query(models.TaskInstance).delete()
session.commit()
session.close()
self.dagrun_python = self.dag_python.create_dagrun(
run_id="test_{}".format(models.DagRun.id_for_date(timezone.utcnow())),
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
start_date=timezone.utcnow(),
state=State.RUNNING
)
self.sub_dag.create_dagrun(
run_id="test_{}".format(models.DagRun.id_for_date(timezone.utcnow())),
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
start_date=timezone.utcnow(),
state=State.RUNNING
)
self.example_xcom.create_dagrun(
run_id="test_{}".format(models.DagRun.id_for_date(timezone.utcnow())),
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
start_date=timezone.utcnow(),
state=State.RUNNING
)
def test_index(self):
response = self.app.get('/', follow_redirects=True)
resp_html = response.data.decode('utf-8')
self.assertIn("DAGs", resp_html)
self.assertIn("example_bash_operator", resp_html)
# The HTML should contain data for the last-run. A link to the specific run,
# and the text of the date.
url = "/admin/airflow/graph?" + urlencode({
"dag_id": self.dag_python.dag_id,
"execution_date": self.dagrun_python.execution_date,
}).replace("&", "&")
self.assertIn(url, resp_html)
self.assertIn(
self.dagrun_python.execution_date.strftime("%Y-%m-%d %H:%M"),
resp_html)
def test_query(self):
response = self.app.get('/admin/queryview/')
self.assertIn("Ad Hoc Query", response.data.decode('utf-8'))
response = self.app.post(
"/admin/queryview/", data=dict(
conn_id="airflow_db",
sql="SELECT+COUNT%281%29+as+TEST+FROM+task_instance"))
self.assertIn("TEST", response.data.decode('utf-8'))
def test_health(self):
BJ = jobs.BaseJob
session = Session()
# case-1: healthy scheduler status
last_scheduler_heartbeat_for_testing_1 = timezone.utcnow()
session.add(BJ(job_type='SchedulerJob',
state='running',
latest_heartbeat=last_scheduler_heartbeat_for_testing_1))
session.commit()
response_json = json.loads(self.app.get('/health').data.decode('utf-8'))
self.assertEqual('healthy', response_json['metadatabase']['status'])
self.assertEqual('healthy', response_json['scheduler']['status'])
self.assertEqual(last_scheduler_heartbeat_for_testing_1.isoformat(),
response_json['scheduler']['latest_scheduler_heartbeat'])
session.query(BJ).\
filter(BJ.job_type == 'SchedulerJob',
BJ.state == 'running',
BJ.latest_heartbeat == last_scheduler_heartbeat_for_testing_1).\
delete()
session.commit()
# case-2: unhealthy scheduler status - scenario 1 (SchedulerJob is running too slowly)
last_scheduler_heartbeat_for_testing_2 = timezone.utcnow() - timedelta(minutes=1)
(session.query(BJ)
.filter(BJ.job_type == 'SchedulerJob')
.update({'latest_heartbeat': last_scheduler_heartbeat_for_testing_2 - timedelta(seconds=1)}))
session.add(BJ(job_type='SchedulerJob',
state='running',
latest_heartbeat=last_scheduler_heartbeat_for_testing_2))
session.commit()
response_json = json.loads(self.app.get('/health').data.decode('utf-8'))
self.assertEqual('healthy', response_json['metadatabase']['status'])
self.assertEqual('unhealthy', response_json['scheduler']['status'])
self.assertEqual(last_scheduler_heartbeat_for_testing_2.isoformat(),
response_json['scheduler']['latest_scheduler_heartbeat'])
session.query(BJ).\
filter(BJ.job_type == 'SchedulerJob',
BJ.state == 'running',
BJ.latest_heartbeat == last_scheduler_heartbeat_for_testing_1).\
delete()
session.commit()
# case-3: unhealthy scheduler status - scenario 2 (no running SchedulerJob)
session.query(BJ).\
filter(BJ.job_type == 'SchedulerJob',
BJ.state == 'running').\
delete()
session.commit()
response_json = json.loads(self.app.get('/health').data.decode('utf-8'))
self.assertEqual('healthy', response_json['metadatabase']['status'])
self.assertEqual('unhealthy', response_json['scheduler']['status'])
self.assertIsNone(response_json['scheduler']['latest_scheduler_heartbeat'])
session.close()
def test_noaccess(self):
response = self.app.get('/admin/airflow/noaccess')
self.assertIn("You don't seem to have access.", response.data.decode('utf-8'))
def test_pickle_info(self):
response = self.app.get('/admin/airflow/pickle_info')
self.assertIn('{', response.data.decode('utf-8'))
def test_dag_views(self):
response = self.app.get(
'/admin/airflow/graph?dag_id=example_bash_operator')
self.assertIn("runme_0", response.data.decode('utf-8'))
# confirm that the graph page loads when execution_date is blank
response = self.app.get(
'/admin/airflow/graph?dag_id=example_bash_operator&execution_date=')
self.assertIn("runme_0", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/tree?num_runs=25&dag_id=example_bash_operator')
self.assertIn("runme_0", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/duration?days=30&dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/duration?days=30&dag_id=missing_dag',
follow_redirects=True)
self.assertIn("seems to be missing", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/tries?days=30&dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/landing_times?'
'days=30&dag_id=example_python_operator')
self.assertIn("example_python_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/landing_times?'
'days=30&dag_id=example_xcom')
self.assertIn("example_xcom", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/gantt?dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/code?dag_id=example_bash_operator')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/blocked')
response = self.app.get(
'/admin/configurationview/')
self.assertIn("Airflow Configuration", response.data.decode('utf-8'))
self.assertIn("Running Configuration", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/rendered?'
'task_id=runme_1&dag_id=example_bash_operator&'
'execution_date={}'.format(DEFAULT_DATE_ISO))
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/log?task_id=run_this_last&'
'dag_id=example_bash_operator&execution_date={}'
''.format(DEFAULT_DATE_ISO))
self.assertIn("run_this_last", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/task?'
'task_id=runme_0&dag_id=example_bash_operator&'
'execution_date={}'.format(EXAMPLE_DAG_DEFAULT_DATE))
self.assertIn("Attributes", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/dag_stats')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/task_stats')
self.assertIn("example_bash_operator", response.data.decode('utf-8'))
response = self.app.post("/admin/airflow/success", data=dict(
task_id="print_the_context",
dag_id="example_python_operator",
success_upstream="false",
success_downstream="false",
success_future="false",
success_past="false",
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
origin="/admin"))
self.assertIn("Wait a minute", response.data.decode('utf-8'))
response = self.app.post('/admin/airflow/clear', data=dict(
task_id="print_the_context",
dag_id="example_python_operator",
future="true",
past="false",
upstream="true",
downstream="false",
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
origin="/admin"))
self.assertIn("Wait a minute", response.data.decode('utf-8'))
form = dict(
task_id="section-1",
dag_id="example_subdag_operator",
success_upstream="true",
success_downstream="true",
success_future="false",
success_past="false",
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
origin="/admin")
response = self.app.post("/admin/airflow/success", data=form)
self.assertIn("Wait a minute", response.data.decode('utf-8'))
self.assertIn("section-1-task-1", response.data.decode('utf-8'))
self.assertIn("section-1-task-2", response.data.decode('utf-8'))
self.assertIn("section-1-task-3", response.data.decode('utf-8'))
self.assertIn("section-1-task-4", response.data.decode('utf-8'))
self.assertIn("section-1-task-5", response.data.decode('utf-8'))
form["confirmed"] = "true"
response = self.app.post("/admin/airflow/success", data=form)
self.assertEqual(response.status_code, 302)
form = dict(
task_id="print_the_context",
dag_id="example_python_operator",
future="false",
past="false",
upstream="false",
downstream="true",
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
origin="/admin")
response = self.app.post("/admin/airflow/clear", data=form)
self.assertIn("Wait a minute", response.data.decode('utf-8'))
form["confirmed"] = "true"
response = self.app.post("/admin/airflow/clear", data=form)
self.assertEqual(response.status_code, 302)
form = dict(
task_id="section-1-task-1",
dag_id="example_subdag_operator.section-1",
future="false",
past="false",
upstream="false",
downstream="true",
recursive="true",
execution_date=EXAMPLE_DAG_DEFAULT_DATE,
origin="/admin")
response = self.app.post("/admin/airflow/clear", data=form)
self.assertIn("Wait a minute", response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.end",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-1.section-1-task-1",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-1",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-2",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-2.section-2-task-1",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-2.section-2-task-2",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-2.section-2-task-3",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-2.section-2-task-4",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.section-2.section-2-task-5",
response.data.decode('utf-8'))
self.assertIn("example_subdag_operator.some-other-task",
response.data.decode('utf-8'))
url = (
"/admin/airflow/run?task_id=runme_0&"
"dag_id=example_bash_operator&ignore_all_deps=false&ignore_ti_state=true&"
"ignore_task_deps=true&execution_date={}&"
"origin=/admin".format(EXAMPLE_DAG_DEFAULT_DATE))
response = self.app.get(url)
response = self.app.get(
"/admin/airflow/refresh?dag_id=example_bash_operator")
response = self.app.get("/admin/airflow/refresh_all")
response = self.app.post(
"/admin/airflow/paused?"
"dag_id=example_python_operator&is_paused=false")
self.assertIn("OK", response.data.decode('utf-8'))
response = self.app.get("/admin/xcom", follow_redirects=True)
self.assertIn("Xcoms", response.data.decode('utf-8'))
def test_charts(self):
session = Session()
chart_label = "Airflow task instance by type"
chart = session.query(
models.Chart).filter(models.Chart.label == chart_label).first()
chart_id = chart.id
session.close()
response = self.app.get(
'/admin/airflow/chart'
'?chart_id={}&iteration_no=1'.format(chart_id))
self.assertIn("Airflow task instance by type", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/chart_data'
'?chart_id={}&iteration_no=1'.format(chart_id))
self.assertIn("example", response.data.decode('utf-8'))
response = self.app.get(
'/admin/airflow/dag_details?dag_id=example_branch_operator')
self.assertIn("run_this_first", response.data.decode('utf-8'))
def test_fetch_task_instance(self):
url = (
"/admin/airflow/object/task_instances?"
"dag_id=example_python_operator&"
"execution_date={}".format(EXAMPLE_DAG_DEFAULT_DATE))
response = self.app.get(url)
self.assertIn("print_the_context", response.data.decode('utf-8'))
def test_dag_view_task_with_python_operator_using_partial(self):
response = self.app.get(
'/admin/airflow/task?'
'task_id=test_dagrun_functool_partial&dag_id=test_task_view_type_check&'
'execution_date={}'.format(EXAMPLE_DAG_DEFAULT_DATE))
self.assertIn("A function with two args", response.data.decode('utf-8'))
def test_dag_view_task_with_python_operator_using_instance(self):
response = self.app.get(
'/admin/airflow/task?'
'task_id=test_dagrun_instance&dag_id=test_task_view_type_check&'
'execution_date={}'.format(EXAMPLE_DAG_DEFAULT_DATE))
self.assertIn("A __call__ method", response.data.decode('utf-8'))
def tearDown(self):
self.dag_bash.clear(start_date=EXAMPLE_DAG_DEFAULT_DATE,
end_date=timezone.utcnow())
session = Session()
session.query(models.DagRun).delete()
session.query(models.TaskInstance).delete()
session.commit()
session.close()
@conf_vars({('webserver', 'authenticate'): 'False', ('core', 'secure_mode'): 'True'})
class SecureModeWebUiTests(unittest.TestCase):
def setUp(self):
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
def test_query(self):
response = self.app.get('/admin/queryview/')
self.assertEqual(response.status_code, 404)
def test_charts(self):
response = self.app.get('/admin/chart/')
self.assertEqual(response.status_code, 404)
class PasswordUserTest(unittest.TestCase):
def setUp(self):
user = models.User()
from airflow.contrib.auth.backends.password_auth import PasswordUser
self.password_user = PasswordUser(user)
self.password_user.username = "password_test"
@mock.patch('airflow.contrib.auth.backends.password_auth.generate_password_hash')
def test_password_setter(self, mock_gen_pass_hash):
mock_gen_pass_hash.return_value = b"hashed_pass" if six.PY3 else "hashed_pass"
self.password_user.password = "secure_password"
mock_gen_pass_hash.assert_called_with("secure_password", 12)
def test_password_unicode(self):
# In python2.7 no conversion is required back to str
# In python >= 3 the method must convert from bytes to str
self.password_user.password = "secure_password"
self.assertIsInstance(self.password_user.password, str)
def test_password_user_authenticate(self):
self.password_user.password = "secure_password"
self.assertTrue(self.password_user.authenticate("secure_password"))
def test_password_unicode_user_authenticate(self):
self.password_user.username = u"🐼" # This is a panda
self.password_user.password = "secure_password"
self.assertTrue(self.password_user.authenticate("secure_password"))
def test_password_authenticate_session(self):
from airflow.contrib.auth.backends.password_auth import PasswordUser
self.password_user.password = 'test_password'
session = Session()
session.add(self.password_user)
session.commit()
query_user = session.query(PasswordUser).filter_by(
username=self.password_user.username).first()
self.assertTrue(query_user.authenticate('test_password'))
session.query(models.User).delete()
session.commit()
session.close()
@conf_vars({('webserver', 'authenticate'): 'True',
('webserver', 'auth_backend'): 'airflow.contrib.auth.backends.password_auth'})
class WebPasswordAuthTest(unittest.TestCase):
def setUp(self):
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
from airflow.contrib.auth.backends.password_auth import PasswordUser
session = Session()
user = models.User()
password_user = PasswordUser(user)
password_user.username = 'airflow_passwordauth'
password_user.password = 'password'
print(password_user._password)
session.add(password_user)
session.commit()
session.close()
def get_csrf(self, response):
tree = BeautifulSoup(response.data, 'html.parser')
return tree.find('input', attrs={'name': '_csrf_token'})['value']
def login(self, username, password):
response = self.app.get('/admin/airflow/login')
csrf_token = self.get_csrf(response)
return self.app.post('/admin/airflow/login', data=dict(
username=username,
password=password,
csrf_token=csrf_token
), follow_redirects=True)
def logout(self):
return self.app.get('/admin/airflow/logout', follow_redirects=True)
def test_login_logout_password_auth(self):
self.assertTrue(conf.getboolean('webserver', 'authenticate'))
response = self.login('user1', 'whatever')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('airflow_passwordauth', 'wrongpassword')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('airflow_passwordauth', 'password')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
response = self.logout()
self.assertIn('form-signin', response.data.decode('utf-8'))
def test_unauthorized_password_auth(self):
response = self.app.get("/admin/airflow/landing_times")
self.assertEqual(response.status_code, 302)
def tearDown(self):
session = Session()
session.query(models.User).delete()
session.commit()
session.close()
@conf_vars({('webserver', 'authenticate'): 'True',
('webserver', 'auth_backend'): 'airflow.contrib.auth.backends.ldap_auth',
('ldap', 'uri'): 'ldap://openldap:389',
('ldap', 'user_filter'): 'objectClass=*',
('ldap', 'user_name_attr'): 'uid',
('ldap', 'bind_user'): 'cn=Manager,dc=example,dc=com',
('ldap', 'bind_password'): 'insecure',
('ldap', 'basedn'): 'dc=example,dc=com',
('ldap', 'cacert'): '',
})
class WebLdapAuthTest(unittest.TestCase):
def setUp(self):
app = application.create_app()
app.config['TESTING'] = True
self.app = app.test_client()
def get_csrf(self, response):
tree = BeautifulSoup(response.data, 'html.parser')
return tree.find('input', attrs={'name': '_csrf_token'})['value']
def login(self, username, password):
response = self.app.get('/admin/airflow/login')
csrf_token = self.get_csrf(response)
return self.app.post('/admin/airflow/login', data=dict(
username=username,
password=password,
csrf_token=csrf_token
), follow_redirects=True)
def logout(self):
return self.app.get('/admin/airflow/logout', follow_redirects=True)
def test_login_logout_ldap(self):
self.assertTrue(conf.getboolean('webserver', 'authenticate'))
response = self.login('user1', 'userx')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('userz', 'user1')
self.assertIn('Incorrect login details', response.data.decode('utf-8'))
response = self.login('user1', 'user1')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
response = self.logout()
self.assertIn('form-signin', response.data.decode('utf-8'))
def test_unauthorized(self):
response = self.app.get("/admin/airflow/landing_times")
self.assertEqual(response.status_code, 302)
def test_no_filter(self):
response = self.login('user1', 'user1')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
self.assertIn('Connections', response.data.decode('utf-8'))
@conf_vars({('ldap', 'superuser_filter'): 'description=superuser',
('ldap', 'data_profiler_filter'): 'description=dataprofiler'})
def test_with_filters(self):
response = self.login('dataprofiler', 'dataprofiler')
self.assertIn('Data Profiling', response.data.decode('utf-8'))
response = self.logout()
self.assertIn('form-signin', response.data.decode('utf-8'))
response = self.login('superuser', 'superuser')
self.assertIn('Connections', response.data.decode('utf-8'))
def tearDown(self):
session = Session()
session.query(models.User).delete()
session.commit()
session.close()
@conf_vars({('webserver', 'authenticate'): 'True',
('webserver', 'auth_backend'): 'airflow.contrib.auth.backends.ldap_auth',
('ldap', 'uri'): 'ldap://openldap:389',
('ldap', 'user_filter'): 'objectClass=*',
('ldap', 'user_name_attr'): 'uid',
('ldap', 'bind_user'): 'cn=Manager,dc=example,dc=com',
('ldap', 'bind_password'): 'insecure',
('ldap', 'basedn'): 'dc=example,dc=com',
('ldap', 'cacert'): '',
})
class LdapGroupTest(unittest.TestCase):
def test_group_belonging(self):
from airflow.contrib.auth.backends.ldap_auth import LdapUser
users = {"user1": ["group1", "group3"],
"user2": ["group2"]
}
for user in users:
mu = models.User(username=user,
is_superuser=False)
auth = LdapUser(mu)
self.assertEqual(set(users[user]), set(auth.ldap_groups))
class FakeWebHDFSHook(object):
def __init__(self, conn_id):
self.conn_id = conn_id
def get_conn(self):
return self.conn_id
def check_for_path(self, hdfs_path):
return hdfs_path
class FakeSnakeBiteClientException(Exception):
pass
class FakeSnakeBiteClient(object):
def __init__(self):
self.started = True
def ls(self, path, include_toplevel=False):
"""
the fake snakebite client
:param path: the array of path to test
:param include_toplevel: to return the toplevel directory info
:return: a list for path for the matching queries
"""
if path[0] == '/datadirectory/empty_directory' and not include_toplevel:
return []
elif path[0] == '/datadirectory/datafile':
return [{
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 0,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/datafile'
}]
elif path[0] == '/datadirectory/empty_directory' and include_toplevel:
return [{
'group': u'supergroup',
'permission': 493,
'file_type': 'd',
'access_time': 0,
'block_replication': 0,
'modification_time': 1481132141540,
'length': 0,
'blocksize': 0,
'owner': u'hdfs',
'path': '/datadirectory/empty_directory'
}]
elif path[0] == '/datadirectory/not_empty_directory' and include_toplevel:
return [{
'group': u'supergroup',
'permission': 493,
'file_type': 'd',
'access_time': 0,
'block_replication': 0,
'modification_time': 1481132141540,
'length': 0,
'blocksize': 0,
'owner': u'hdfs',
'path': '/datadirectory/empty_directory'
}, {
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 0,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/not_empty_directory/test_file'
}]
elif path[0] == '/datadirectory/not_empty_directory':
return [{
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 0,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/not_empty_directory/test_file'
}]
elif path[0] == '/datadirectory/not_existing_file_or_directory':
raise FakeSnakeBiteClientException
elif path[0] == '/datadirectory/regex_dir':
return [{
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862, 'length': 12582912,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/regex_dir/test1file'
}, {
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 12582912,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/regex_dir/test2file'
}, {
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 12582912,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/regex_dir/test3file'
}, {
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 12582912,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/regex_dir/copying_file_1.txt._COPYING_'
}, {
'group': u'supergroup',
'permission': 420,
'file_type': 'f',
'access_time': 1481122343796,
'block_replication': 3,
'modification_time': 1481122343862,
'length': 12582912,
'blocksize': 134217728,
'owner': u'hdfs',
'path': '/datadirectory/regex_dir/copying_file_3.txt.sftp'
}]
else:
raise FakeSnakeBiteClientException
class FakeHDFSHook(object):
def __init__(self, conn_id=None):
self.conn_id = conn_id
def get_conn(self):
client = FakeSnakeBiteClient()
return client
class ConnectionTest(unittest.TestCase):
def setUp(self):
utils.db.initdb(rbac=True)
os.environ['AIRFLOW_CONN_TEST_URI'] = (
'postgres://username:[email protected]:5432/the_database')
os.environ['AIRFLOW_CONN_TEST_URI_NO_CREDS'] = (
'postgres://ec2.compute.com/the_database')
def tearDown(self):
env_vars = ['AIRFLOW_CONN_TEST_URI', 'AIRFLOW_CONN_AIRFLOW_DB']
for ev in env_vars:
if ev in os.environ:
del os.environ[ev]
def test_using_env_var(self):
c = SqliteHook.get_connection(conn_id='test_uri')
self.assertEqual('ec2.compute.com', c.host)
self.assertEqual('the_database', c.schema)
self.assertEqual('username', c.login)
self.assertEqual('password', c.password)
self.assertEqual(5432, c.port)
def test_using_unix_socket_env_var(self):
c = SqliteHook.get_connection(conn_id='test_uri_no_creds')
self.assertEqual('ec2.compute.com', c.host)
self.assertEqual('the_database', c.schema)
self.assertIsNone(c.login)
self.assertIsNone(c.password)
self.assertIsNone(c.port)
def test_param_setup(self):
c = Connection(conn_id='local_mysql', conn_type='mysql',
host='localhost', login='airflow',
password='airflow', schema='airflow')
self.assertEqual('localhost', c.host)
self.assertEqual('airflow', c.schema)
self.assertEqual('airflow', c.login)
self.assertEqual('airflow', c.password)
self.assertIsNone(c.port)
def test_env_var_priority(self):
c = SqliteHook.get_connection(conn_id='airflow_db')
self.assertNotEqual('ec2.compute.com', c.host)
os.environ['AIRFLOW_CONN_AIRFLOW_DB'] = \
'postgres://username:[email protected]:5432/the_database'
c = SqliteHook.get_connection(conn_id='airflow_db')
self.assertEqual('ec2.compute.com', c.host)
self.assertEqual('the_database', c.schema)
self.assertEqual('username', c.login)
self.assertEqual('password', c.password)
self.assertEqual(5432, c.port)
del os.environ['AIRFLOW_CONN_AIRFLOW_DB']
def test_dbapi_get_uri(self):
conn = BaseHook.get_connection(conn_id='test_uri')
hook = conn.get_hook()
self.assertEqual('postgres://username:[email protected]:5432/the_database', hook.get_uri())
conn2 = BaseHook.get_connection(conn_id='test_uri_no_creds')
hook2 = conn2.get_hook()
self.assertEqual('postgres://ec2.compute.com/the_database', hook2.get_uri())
def test_dbapi_get_sqlalchemy_engine(self):
conn = BaseHook.get_connection(conn_id='test_uri')
hook = conn.get_hook()
engine = hook.get_sqlalchemy_engine()
self.assertIsInstance(engine, sqlalchemy.engine.Engine)
self.assertEqual('postgres://username:[email protected]:5432/the_database', str(engine.url))
def test_get_connections_env_var(self):
conns = SqliteHook.get_connections(conn_id='test_uri')
assert len(conns) == 1
assert conns[0].host == 'ec2.compute.com'
assert conns[0].schema == 'the_database'
assert conns[0].login == 'username'
assert conns[0].password == 'password'
assert conns[0].port == 5432
class WebHDFSHookTest(unittest.TestCase):
def test_simple_init(self):
from airflow.hooks.webhdfs_hook import WebHDFSHook
c = WebHDFSHook()
self.assertIsNone(c.proxy_user)
def test_init_proxy_user(self):
from airflow.hooks.webhdfs_hook import WebHDFSHook
c = WebHDFSHook(proxy_user='someone')
self.assertEqual('someone', c.proxy_user)
HDFSHook = None
if six.PY2:
from airflow.hooks.hdfs_hook import HDFSHook
import snakebite
@unittest.skipIf(HDFSHook is None,
"Skipping test because HDFSHook is not installed")
class HDFSHookTest(unittest.TestCase):
def setUp(self):
os.environ['AIRFLOW_CONN_HDFS_DEFAULT'] = 'hdfs://localhost:8020'
def test_get_client(self):
client = HDFSHook(proxy_user='foo').get_conn()
self.assertIsInstance(client, snakebite.client.Client)
self.assertEqual('localhost', client.host)
self.assertEqual(8020, client.port)
self.assertEqual('foo', client.service.channel.effective_user)
@mock.patch('airflow.hooks.hdfs_hook.AutoConfigClient')
@mock.patch('airflow.hooks.hdfs_hook.HDFSHook.get_connections')
def test_get_autoconfig_client(self, mock_get_connections,
MockAutoConfigClient):
c = Connection(conn_id='hdfs', conn_type='hdfs',
host='localhost', port=8020, login='foo',
extra=json.dumps({'autoconfig': True}))
mock_get_connections.return_value = [c]
HDFSHook(hdfs_conn_id='hdfs').get_conn()
MockAutoConfigClient.assert_called_once_with(effective_user='foo',
use_sasl=False)
@mock.patch('airflow.hooks.hdfs_hook.AutoConfigClient')
def test_get_autoconfig_client_no_conn(self, MockAutoConfigClient):
HDFSHook(hdfs_conn_id='hdfs_missing', autoconfig=True).get_conn()
MockAutoConfigClient.assert_called_once_with(effective_user=None,
use_sasl=False)
@mock.patch('airflow.hooks.hdfs_hook.HDFSHook.get_connections')
def test_get_ha_client(self, mock_get_connections):
c1 = Connection(conn_id='hdfs_default', conn_type='hdfs',
host='localhost', port=8020)
c2 = Connection(conn_id='hdfs_default', conn_type='hdfs',
host='localhost2', port=8020)
mock_get_connections.return_value = [c1, c2]
client = HDFSHook().get_conn()
self.assertIsInstance(client, snakebite.client.HAClient)
send_email_test = mock.Mock()
@conf_vars({('email', 'email_backend'): None})
class EmailTest(unittest.TestCase):
@mock.patch('airflow.utils.email.send_email')
def test_default_backend(self, mock_send_email):
res = utils.email.send_email('to', 'subject', 'content')
mock_send_email.assert_called_with('to', 'subject', 'content')
self.assertEqual(mock_send_email.return_value, res)
@mock.patch('airflow.utils.email.send_email_smtp')
def test_custom_backend(self, mock_send_email):
with conf_vars({('email', 'email_backend'): 'tests.core.send_email_test'}):
utils.email.send_email('to', 'subject', 'content')
send_email_test.assert_called_with(
'to', 'subject', 'content', files=None, dryrun=False,
cc=None, bcc=None, mime_charset='us-ascii', mime_subtype='mixed')
self.assertFalse(mock_send_email.called)
@conf_vars({('smtp', 'smtp_ssl'): 'False'})
class EmailSmtpTest(unittest.TestCase):
@mock.patch('airflow.utils.email.send_MIME_email')
def test_send_smtp(self, mock_send_mime):
attachment = tempfile.NamedTemporaryFile()
attachment.write(b'attachment')
attachment.seek(0)
utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name])
self.assertTrue(mock_send_mime.called)
call_args = mock_send_mime.call_args[0]
self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), call_args[0])
self.assertEqual(['to'], call_args[1])
msg = call_args[2]
self.assertEqual('subject', msg['Subject'])
self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), msg['From'])
self.assertEqual(2, len(msg.get_payload()))
filename = u'attachment; filename="' + os.path.basename(attachment.name) + '"'
self.assertEqual(filename, msg.get_payload()[-1].get(u'Content-Disposition'))
mimeapp = MIMEApplication('attachment')
self.assertEqual(mimeapp.get_payload(), msg.get_payload()[-1].get_payload())
@mock.patch('airflow.utils.email.send_MIME_email')
def test_send_smtp_with_multibyte_content(self, mock_send_mime):
utils.email.send_email_smtp('to', 'subject', '🔥', mime_charset='utf-8')
self.assertTrue(mock_send_mime.called)
call_args = mock_send_mime.call_args[0]
msg = call_args[2]
mimetext = MIMEText('🔥', 'mixed', 'utf-8')
self.assertEqual(mimetext.get_payload(), msg.get_payload()[0].get_payload())
@mock.patch('airflow.utils.email.send_MIME_email')
def test_send_bcc_smtp(self, mock_send_mime):
attachment = tempfile.NamedTemporaryFile()
attachment.write(b'attachment')
attachment.seek(0)
utils.email.send_email_smtp('to', 'subject', 'content', files=[attachment.name], cc='cc', bcc='bcc')
self.assertTrue(mock_send_mime.called)
call_args = mock_send_mime.call_args[0]
self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), call_args[0])
self.assertEqual(['to', 'cc', 'bcc'], call_args[1])
msg = call_args[2]
self.assertEqual('subject', msg['Subject'])
self.assertEqual(conf.get('smtp', 'SMTP_MAIL_FROM'), msg['From'])
self.assertEqual(2, len(msg.get_payload()))
self.assertEqual(u'attachment; filename="' + os.path.basename(attachment.name) + '"',
msg.get_payload()[-1].get(u'Content-Disposition'))
mimeapp = MIMEApplication('attachment')
self.assertEqual(mimeapp.get_payload(), msg.get_payload()[-1].get_payload())
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime(self, mock_smtp, mock_smtp_ssl):
mock_smtp.return_value = mock.Mock()
mock_smtp_ssl.return_value = mock.Mock()
msg = MIMEMultipart()
utils.email.send_MIME_email('from', 'to', msg, dryrun=False)
mock_smtp.assert_called_with(
conf.get('smtp', 'SMTP_HOST'),
conf.getint('smtp', 'SMTP_PORT'),
)
self.assertTrue(mock_smtp.return_value.starttls.called)
mock_smtp.return_value.login.assert_called_with(
conf.get('smtp', 'SMTP_USER'),
conf.get('smtp', 'SMTP_PASSWORD'),
)
mock_smtp.return_value.sendmail.assert_called_with('from', 'to', msg.as_string())
self.assertTrue(mock_smtp.return_value.quit.called)
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime_ssl(self, mock_smtp, mock_smtp_ssl):
mock_smtp.return_value = mock.Mock()
mock_smtp_ssl.return_value = mock.Mock()
with conf_vars({('smtp', 'smtp_ssl'): 'True'}):
utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=False)
self.assertFalse(mock_smtp.called)
mock_smtp_ssl.assert_called_with(
conf.get('smtp', 'SMTP_HOST'),
conf.getint('smtp', 'SMTP_PORT'),
)
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime_noauth(self, mock_smtp, mock_smtp_ssl):
mock_smtp.return_value = mock.Mock()
mock_smtp_ssl.return_value = mock.Mock()
with conf_vars({
('smtp', 'smtp_user'): None,
('smtp', 'smtp_password'): None,
}):
utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=False)
self.assertFalse(mock_smtp_ssl.called)
mock_smtp.assert_called_with(
conf.get('smtp', 'SMTP_HOST'),
conf.getint('smtp', 'SMTP_PORT'),
)
self.assertFalse(mock_smtp.login.called)
@mock.patch('smtplib.SMTP_SSL')
@mock.patch('smtplib.SMTP')
def test_send_mime_dryrun(self, mock_smtp, mock_smtp_ssl):
utils.email.send_MIME_email('from', 'to', MIMEMultipart(), dryrun=True)
self.assertFalse(mock_smtp.called)
self.assertFalse(mock_smtp_ssl.called)
if __name__ == '__main__':
unittest.main()
|
env_player.py
|
# -*- coding: utf-8 -*-
"""This module defines a player class exposing the Open AI Gym API.
"""
from abc import ABC, abstractmethod, abstractproperty
from gym.core import Env # pyre-ignore
from queue import Queue
from threading import Thread
from typing import Any, Callable, List, Optional, Tuple
from poke_env.environment.battle import Battle
from poke_env.player.player import Player
from poke_env.player_configuration import PlayerConfiguration
from poke_env.server_configuration import ServerConfiguration
from poke_env.utils import to_id_str
import asyncio
import numpy as np # pyre-ignore
import time
class EnvPlayer(Player, Env, ABC): # pyre-ignore
"""Player exposing the Open AI Gym Env API. Recommended use is with play_against.
"""
MAX_BATTLE_SWITCH_RETRY = 10000
PAUSE_BETWEEN_RETRIES = 0.001
def __init__(
self,
player_configuration: PlayerConfiguration,
*,
avatar: Optional[int] = None,
battle_format: str,
log_level: Optional[int] = None,
server_configuration: ServerConfiguration,
start_listening: bool = True,
):
"""
:param player_configuration: Player configuration.
:type player_configuration: PlayerConfiguration
:param avatar: Player avatar id. Optional.
:type avatar: int, optional
:param battle_format: Name of the battle format this player plays.
:type battle_format: str
:param log_level: The player's logger level.
:type log_level: int. Defaults to logging's default level.
:param server_configuration: Server configuration.
:type server_configuration: ServerConfiguration
:param start_listening: Wheter to start listening to the server. Defaults to
True.
:type start_listening: bool
"""
super(EnvPlayer, self).__init__(
player_configuration=player_configuration,
avatar=avatar,
battle_format=battle_format,
log_level=log_level,
max_concurrent_battles=1,
server_configuration=server_configuration,
start_listening=start_listening,
)
self._actions = {}
self._current_battle: Battle
self._observations = {}
self._reward_buffer = {}
self._start_new_battle = False
@abstractmethod
def _action_to_move(self, action: int, battle: Battle) -> str:
"""Abstract method converting elements of the action space to move orders.
"""
pass
def _battle_finished_callback(self, battle: Battle) -> None:
self._observations[battle].put(self.embed_battle(battle))
def _init_battle(self, battle: Battle) -> None:
self._observations[battle] = Queue()
self._actions[battle] = Queue()
def choose_move(self, battle: Battle) -> str:
if battle not in self._observations or battle not in self._actions:
self._init_battle(battle)
self._observations[battle].put(self.embed_battle(battle))
action = self._actions[battle].get()
return self._action_to_move(action, battle)
def close(self) -> None:
"""Unimplemented. Has no effect."""
pass
def complete_current_battle(self) -> None:
"""Completes the current battle by performing random moves."""
done = self._current_battle.finished
while not done:
_, _, done, _ = self.step(np.random.choice(self._ACTION_SPACE))
def compute_reward(self, battle: Battle) -> float:
"""Returns a reward for the given battle.
The default implementation corresponds to the default parameters of the
reward_computing_helper method.
:param battle: The battle for which to compute the reward.
:type battle: Battle
:return: The computed reward.
:rtype: float
"""
return self.reward_computing_helper(battle)
@abstractmethod
def embed_battle(self, battle: Battle) -> Any:
"""Abstract method for embedding battles.
:param battle: The battle whose state is being embedded
:type battle: Battle
:return: The computed embedding
:rtype: Any
"""
pass
def reset(self) -> Any:
"""Resets the internal environment state. The current battle will be set to an
active unfinished battle.
:return: The observation of the new current battle.
:rtype: Any
:raies: EnvironmentError
"""
for _ in range(self.MAX_BATTLE_SWITCH_RETRY):
battles = dict(self._actions.items())
battles = [b for b in battles if not b.finished]
if battles:
self._current_battle = battles[0]
observation = self._observations[self._current_battle].get()
return observation
time.sleep(self.PAUSE_BETWEEN_RETRIES)
else:
raise EnvironmentError("User %s has no active battle." % self.username)
def render(self, mode="human") -> None:
"""A one line rendering of the current state of the battle.
"""
print(
" Turn %4d. | [%s][%3d/%3dhp] %10.10s - %10.10s [%3d%%hp][%s]"
% (
self._current_battle.turn,
"".join(
[
"⦻" if mon.fainted else "●"
for mon in self._current_battle.team.values()
]
),
self._current_battle.active_pokemon.current_hp or 0,
self._current_battle.active_pokemon.max_hp or 0,
self._current_battle.active_pokemon.species,
self._current_battle.opponent_active_pokemon.species,
self._current_battle.opponent_active_pokemon.current_hp or 0,
"".join(
[
"⦻" if mon.fainted else "●"
for mon in self._current_battle.opponent_team.values()
]
),
),
end="\n" if self._current_battle.finished else "\r",
)
def reward_computing_helper(
self,
battle: Battle,
*,
fainted_value: float = 0.0,
hp_value: float = 0.0,
number_of_pokemons: int = 6,
starting_value: float = 0.0,
status_value: float = 0.0,
victory_value: float = 1.0,
) -> float:
"""A helper function to compute rewards.
The reward is computed by computing the value of a game state, and by comparing
it to the last state.
State values are computed by weighting different factor. Fainted pokemons,
their remaining HP, inflicted statuses and winning are taken into account.
For instance, if the last time this function was called for battle A it had
a state value of 8 and this call leads to a value of 9, the returned reward will
be 9 - 8 = 1.
Consider a single battle where each player has 6 pokemons. No opponent pokemon
has fainted, but our team has one fainted pokemon. Three opposing pokemons are
burned. We have one pokemon missing half of its HP, and our fainted pokemon has
no HP left.
The value of this state will be:
- With fainted value: 1, status value: 0.5, hp value: 1:
= - 1 (fainted) + 3 * 0.5 (status) - 1.5 (our hp) = -1
- With fainted value: 3, status value: 0, hp value: 1:
= - 3 + 3 * 0 - 1.5 = -4.5
:param battle: The battle for which to compute rewards.
:type battle: Battle
:param fainted_value: The reward weight for fainted pokemons. Defaults to 0.
:type fainted_value: float
:param hp_value: The reward weight for hp per pokemon. Defaults to 0.
:type hp_value: float
:param number_of_pokemons: The number of pokemons per team. Defaults to 6.
:type number_of_pokemons: int
:param starting_value: The default reference value evaluation. Defaults to 0.
:type starting_value: float
:param status_value: The reward value per non-fainted status. Defaults to 0.
:type status_value: float
:param victory_value: The reward value for winning. Defaults to 1.
:type victory_value: float
:return: The reward.
:rtype: float
"""
if battle not in self._reward_buffer:
self._reward_buffer[battle] = starting_value
current_value = 0
for mon in battle.team.values():
current_value += mon.current_hp_fraction * hp_value
if mon.fainted:
current_value -= fainted_value
elif mon.status is not None:
current_value -= status_value
current_value += (number_of_pokemons - len(battle.team)) * hp_value
for mon in battle.opponent_team.values():
current_value -= mon.current_hp_fraction * hp_value
if mon.fainted:
current_value += fainted_value
elif mon.status is not None:
current_value += status_value
current_value -= (number_of_pokemons - len(battle.opponent_team)) * hp_value
if battle.won:
current_value += victory_value
elif battle.lost:
current_value -= victory_value
to_return = current_value - self._reward_buffer[battle]
self._reward_buffer[battle] = current_value
return to_return
def seed(self, seed=None) -> None:
"""Sets the numpy seed."""
np.random.seed(seed)
def step(self, action: int) -> Tuple:
"""Performs action in the current battle.
:param action: The action to perform.
:type action: int
:return: A tuple containing the next observation, the reward, a boolean
indicating wheter the episode is finished, and additional information
:rtype: tuple
"""
self._actions[self._current_battle].put(action)
observation = self._observations[self._current_battle].get()
return (
observation,
self.compute_reward(self._current_battle),
self._current_battle.finished,
{},
)
def play_against(
self, env_algorithm: Callable, opponent: Player, env_algorithm_kwargs=None
):
"""Executes a function controlling the player while facing opponent.
The env_algorithm function is executed with the player environment as first
argument. It exposes the open ai gym API.
Additional arguments can be passed to the env_algorithm function with
env_algorithm_kwargs.
Battles against opponent will be launched as long as env_algorithm is running.
When env_algorithm returns, the current active battle will be finished randomly
if it is not already.
:param env_algorithm: A function that controls the player. It must accept the
player as first argument. Additional arguments can be passed with the
env_algorithm_kwargs argument.
:type env_algorithm: callable
:param opponent: A player against with the env player will player.
:type opponent: Player
:param env_algorithm_kwargs: Optional arguments to pass to the env_algorithm.
Defaults to None.
"""
self._start_new_battle = True
async def launch_battles(player: EnvPlayer, opponent: Player):
battles_coroutine = asyncio.gather(
player.send_challenges(
opponent=to_id_str(opponent.username),
n_challenges=1,
to_wait=opponent.logged_in,
),
opponent.accept_challenges(
opponent=to_id_str(player.username), n_challenges=1
),
)
await battles_coroutine
def env_algorithm_wrapper(player, kwargs):
env_algorithm(player, **kwargs)
player._start_new_battle = False
while True:
try:
player.complete_current_battle()
player.reset()
except OSError:
break
loop = asyncio.get_event_loop()
if env_algorithm_kwargs is None:
env_algorithm_kwargs = {}
thread = Thread(
target=lambda: env_algorithm_wrapper(self, env_algorithm_kwargs)
)
thread.start()
while self._start_new_battle:
loop.run_until_complete(launch_battles(self, opponent))
thread.join()
@abstractproperty
def action_space(self) -> List:
"""Returns the action space of the player. Must be implemented by subclasses."""
pass
class Gen7EnvSinglePlayer(EnvPlayer):
_ACTION_SPACE = list(range(3 * 4 + 6))
def _action_to_move(self, action: int, battle: Battle) -> str:
"""Converts actions to move orders.
The conversion is done as follows:
0 <= action < 4:
The actionth available move in battle.available_moves is executed.
4 <= action < 8:
The action - 4th available move in battle.available_moves is executed, with
z-move.
8 <= action < 12:
The action - 8th available move in battle.available_moves is executed, with
mega-evolution.
12 <= action < 18
The action - 12th available switch in battle.available_switches is executed.
If the proposed action is illegal, a random legal move is performed.
:param action: The action to convert.
:type action: int
:param battle: The battle in which to act.
:type battle: Battle
:return: the order to send to the server.
:rtype: str
"""
if (
action < 4
and action < len(battle.available_moves)
and not battle.force_switch
):
return self.create_order(battle.available_moves[action])
elif (
not battle.force_switch
and battle.can_z_move
and 0 <= action - 4 < len(battle.active_pokemon.available_z_moves)
):
return self.create_order(
battle.active_pokemon.available_z_moves[action - 4], z_move=True
)
elif (
battle.can_mega_evolve
and 0 <= action - 8 < len(battle.available_moves)
and not battle.force_switch
):
return self.create_order(battle.available_moves[action - 8], mega=True)
elif 0 <= action - 12 < len(battle.available_switches):
return self.create_order(battle.available_switches[action - 12])
else:
return self.choose_random_move(battle)
@property
def action_space(self) -> List:
"""The action space for gen 7 single battles.
The conversion to moves is done as follows:
0 <= action < 4:
The actionth available move in battle.available_moves is executed.
4 <= action < 8:
The action - 4th available move in battle.available_moves is executed,
with z-move.
8 <= action < 12:
The action - 8th available move in battle.available_moves is executed,
with mega-evolution.
12 <= action < 18
The action - 12th available switch in battle.available_switches is
executed.
"""
return self._ACTION_SPACE
|
controller.py
|
''' Implement infrastructure for the solver to add various interfaces '''
from functools import wraps
import threading
try:
from thread import LockType
except ImportError:
from _thread import LockType
from pysph.base.particle_array import ParticleArray
import logging
logger = logging.getLogger(__name__)
class DummyComm(object):
''' A dummy MPI.Comm implementation as placeholder for for serial runs '''
def Get_size(self):
''' return the size of the comm (1) '''
return 1
def Get_rank(self):
''' return the rank of the process (0) '''
return 0
def send(self, data, pid):
''' dummy send implementation '''
self.data = data
def recv(self, pid):
''' dummy recv implementation '''
data = self.data
del self.data
return data
def bcast(self, data):
''' bcast (broadcast) implementation for serial run '''
return data
def gather(self, data):
''' gather implementation for serial run '''
return [data]
def synchronized(lock_or_func):
''' decorator for synchronized (thread safe) function
Usage:
- sync_func = synchronized(lock)(func) # sync with an existing lock
- sync_func = synchronized(func) # sync with a new private lock
'''
if isinstance(lock_or_func, LockType):
lock = lock_or_func
def synchronized_inner(func):
@wraps(func)
def wrapped(*args, **kwargs):
with lock:
return func(*args, **kwargs)
return wrapped
return synchronized_inner
else:
func = lock_or_func
lock = threading.Lock()
return synchronized(lock)(func)
def wrap_dispatcher(obj, meth, *args2, **kwargs2):
@wraps(meth)
def wrapped(*args, **kwargs):
kw = {}
kw.update(kwargs2)
kw.update(kwargs)
return meth(obj.block, *(args2+args), **kw)
return wrapped
class Controller(object):
''' Controller class acts a a proxy to control the solver
This is passed as an argument to the interface
**Methods available**:
- get -- get the value of a solver parameter
- set -- set the value of a solver parameter
- get_result -- return result of a queued command
- pause_on_next -- pause solver thread on next iteration
- wait -- wait (block) calling thread till solver is paused
(call after `pause_on_next`)
- cont -- continue solver thread (call after `pause_on_next`)
Various other methods are also available as listed in
:data:`CommandManager.dispatch_dict` which perform different functions.
- The methods in CommandManager.active_methods do their operation and return
the result (if any) immediately
- The methods in CommandManager.lazy_methods do their later when solver
thread is available and return a task-id. The result of the task can be
obtained later using the blocking call `get_result()` which waits till
result is available and returns the result.
The availability of the result can be checked using the lock returned
by `get_task_lock()` method
FIXME: wait/cont currently do not work in parallel
'''
def __init__(self, command_manager, block=True):
super(Controller, self).__init__()
self.__command_manager = command_manager
self.daemon = True
self.block = block
self._set_methods()
def _set_methods(self):
for prop in self.__command_manager.solver_props:
setattr(self, 'get_'+prop, wrap_dispatcher(self, self.__command_manager.dispatch, 'get', prop))
setattr(self, 'set_'+prop, wrap_dispatcher(self, self.__command_manager.dispatch, 'set', prop))
for meth in self.__command_manager.solver_methods:
setattr(self, meth, wrap_dispatcher(self, self.__command_manager.dispatch, meth))
for meth in self.__command_manager.lazy_methods:
setattr(self, meth, wrap_dispatcher(self, self.__command_manager.dispatch, meth))
for meth in self.__command_manager.active_methods:
setattr(self, meth, wrap_dispatcher(self, self.__command_manager.dispatch, meth))
def get(self, name):
''' get a solver property; returns immediately '''
return self.__command_manager.dispatch(self.block, 'get', name)
def set(self, name, value):
''' set a solver property; returns immediately; '''
return self.__command_manager.dispatch(self.block, 'set', name, value)
def pause_on_next(self):
''' pause the solver thread on next iteration '''
return self.__command_manager.pause_on_next()
def wait(self):
''' block the calling thread until the solver thread pauses
call this only after calling the `pause_on_next` method to tell
the controller to pause the solver thread'''
self.__command_manager.wait()
return True
def get_prop_names(self):
return list(self.__command_manager.solver_props)
def cont(self):
''' continue solver thread after it has been paused by `pause_on_next`
call this only after calling the `pause_on_next` method '''
return self.__command_manager.cont()
def get_result(self, task_id):
''' get the result of a previously queued command '''
return self.__command_manager.get_result(task_id)
def set_blocking(self, block):
''' set the blocking mode to True/False
In blocking mode (block=True) all methods other than getting of
solver properties block until the command is executed by the solver
and return the results. The blocking time can vary depending on the
time taken by solver per iteration and the command_interval
In non-blocking mode, these methods queue the command for later
and return a string corresponding to the task_id of the operation.
The result can be later obtained by a (blocking) call to get_result
with the task_id as argument
'''
if block != self.block:
self.block = block
self._set_methods()
return self.block
def get_blocking(self):
''' get the blocking mode ( True/False ) '''
return self.block
def ping(self):
return True
def on_root_proc(f):
''' run the decorated function only on the root proc '''
@wraps(f)
def wrapper(self, *args, **kwds):
if self.comm.Get_rank()==0:
return f(self, *args, **kwds)
return wrapper
def in_parallel(f):
''' return a list of results of running decorated function on all procs '''
@wraps(f)
def wrapper(self, *args, **kwds):
return self.comm.gather(f(self, *args, **kwds))
return wrapper
class CommandManager(object):
''' Class to manage and synchronize commands from various Controllers '''
solver_props = set(('t', 'tf', 'dt', 'count', 'pfreq', 'fname',
'detailed_output', 'output_directory', 'command_interval'))
solver_methods = set(('dump_output',))
lazy_methods = set(('get_particle_array_names', 'get_named_particle_array',
'get_particle_array_combined', 'get_particle_array_from_procs'))
active_methods = set(('get_status', 'get_task_lock', 'set_log_level'))
def __init__(self, solver, comm=None):
if comm is not None:
self.comm = comm
self.rank = comm.Get_rank()
else:
try:
self.comm = solver.particles.cell_manager.parallel_controller.comm
except AttributeError:
self.comm = DummyComm()
self.rank = 0
logger.debug('CommandManager: using comm: %s'%self.comm)
self.solver = solver
self.interfaces = []
self.func_dict = {}
self.rlock = threading.RLock()
self.res_lock = threading.Lock()
self.plock = threading.Condition()
self.qlock = threading.Condition() # queue lock
self.queue = []
self.queue_dict = {}
self.queue_lock_map = {}
self.results = {}
self.pause = set([])
@on_root_proc
def add_interface(self, callable, block=True):
''' Add a callable interface to the controller
The callable must accept an Controller instance argument.
The callable is called in a new thread of its own and it can
do various actions with methods defined on the Controller
instance passed to it
The new created thread is set to daemon mode and returned
'''
logger.debug('adding_interface: %s'%callable)
control = Controller(self, block)
thr = threading.Thread(target=callable, args=(control,))
thr.daemon = True
thr.start()
return thr
def add_function(self, callable, interval=1):
''' add a function to to be called every `interval` iterations '''
l = self.func_dict[interval] = self.func_dict.get(interval, [])
l.append(callable)
def execute_commands(self, solver):
''' called by the solver after each timestep '''
# TODO: first synchronize all the controllers in different processes
# using mpi
self.sync_commands()
with self.qlock:
self.run_queued_commands()
if self.rank == 0:
logger.debug('control handler: count=%d'%solver.count)
for interval in self.func_dict:
if solver.count%interval == 0:
for func in self.func_dict[interval]:
func(solver)
self.wait_for_cmd()
def wait_for_cmd(self):
''' wait for command from any interface '''
with self.qlock:
while self.pause:
with self.plock:
self.plock.notify_all()
self.qlock.wait()
self.run_queued_commands()
def sync_commands(self):
''' send the pending commands to all the procs in parallel run '''
self.queue_dict, self.queue, self.pause = self.comm.bcast((self.queue_dict, self.queue, self.pause))
def run_queued_commands(self):
while self.queue:
lock_id = self.queue.pop(0)
meth, args, kwargs = self.queue_dict[lock_id]
with self.res_lock:
try:
self.results[lock_id] = self.run_command(meth, args, kwargs)
finally:
del self.queue_dict[lock_id]
if self.comm.Get_rank()==0:
self.queue_lock_map[lock_id].release()
def run_command(self, cmd, args=[], kwargs={}):
res = self.dispatch_dict[cmd](self, *args, **kwargs)
logger.debug('controller: running_command: %s %s %s %s'%(
cmd, args, kwargs, res))
return res
def pause_on_next(self):
''' pause and wait for command on the next control interval '''
if self.comm.Get_size() > 1:
logger.debug('pause/continue not yet supported in parallel runs')
return False
with self.plock:
self.pause.add(threading.current_thread().ident)
self.plock.notify()
return True
def wait(self):
with self.plock:
self.plock.wait()
def cont(self):
''' continue after a pause command '''
if self.comm.Get_size() > 1:
logger.debug('pause/continue noy yet supported in parallel runs')
return
with self.plock:
self.pause.remove(threading.current_thread().ident)
self.plock.notify()
with self.qlock:
self.qlock.notify_all()
def get_result(self, lock_id):
''' get the result of a previously queued command '''
lock_id = int(lock_id)
lock = self.queue_lock_map[lock_id]
with lock:
with self.res_lock:
ret = self.results[lock_id]
del self.results[lock_id]
del self.queue_lock_map[lock_id]
return ret
def get_task_lock(self, lock_id):
''' get the Lock instance associated with a command '''
return self.queue_lock_map[int(lock_id)]
def get_prop(self, name):
''' get a solver property '''
return getattr(self.solver, name)
def set_prop(self, name, value):
''' set a solver property '''
return setattr(self.solver, name, value)
def solver_method(self, name, *args, **kwargs):
''' execute a method on the solver '''
ret = getattr(self.solver, name)(*args, **kwargs)
ret = self.comm.gather(ret)
return ret
def get_particle_array_names(self):
''' get the names of the particle arrays '''
return [pa.name for pa in self.solver.particles]
def get_named_particle_array(self, name, props=None):
for pa in self.solver.particles:
if pa.name == name:
if props:
return [getattr(pa, p) for p in props if hasattr(pa, p)]
else:
return pa
def get_particle_array_index(self, name):
''' get the index of the named particle array '''
for i,pa in enumerate(self.solver.particles):
if pa.name == name:
return i
def get_particle_array_from_procs(self, idx, procs=None):
''' get particle array at index from all processes
specifying processes is currently not implemented
'''
if procs is None:
procs = list(range(self.comm.size))
pa = self.solver.particles[idx]
pas = self.comm.gather(pa)
return pas
def get_particle_array_combined(self, idx, procs=None):
''' get a single particle array with combined data from all procs
specifying processes is currently not implemented
'''
if procs is None:
procs = list(range(self.comm.size))
pa = self.solver.particles[idx]
pas = self.comm.gather(pa)
pa = ParticleArray(name=pa.name)
for p in pas:
pa.append_parray(p)
return pa
def get_status(self):
''' get the status of the controller '''
return 'commands queued: %d'%len(self.queue)
def set_log_level(self, level):
''' set the logging level '''
logger.setLevel(level)
dispatch_dict = {'get':get_prop, 'set':set_prop}
for meth in solver_methods:
dispatch_dict[meth] = solver_method
for meth in lazy_methods:
dispatch_dict[meth] = locals()[meth]
for meth in active_methods:
dispatch_dict[meth] = locals()[meth]
@synchronized
def dispatch(self, block, meth, *args, **kwargs):
''' execute/queue a command with specified arguments '''
if meth in self.dispatch_dict:
if meth=='get' or meth=='set':
prop = args[0]
if prop not in self.solver_props:
raise RuntimeError('Invalid dispatch on method: %s with '
'non-existant property: %s '%(meth,prop))
if block or meth=='get' or meth in self.active_methods:
logger.debug('controller: immediate dispatch(): %s %s %s'%(
meth, args, kwargs))
return self.dispatch_dict[meth](self, *args, **kwargs)
else:
lock = threading.Lock()
lock.acquire()
lock_id = id(lock)
with self.qlock:
self.queue_lock_map[lock_id] = lock
self.queue_dict[lock_id] = (meth, args, kwargs)
self.queue.append(lock_id)
logger.debug('controller: dispatch(%d): %s %s %s'%(
lock_id, meth, args, kwargs))
return str(lock_id)
else:
raise RuntimeError('Invalid dispatch on method: '+meth)
|
win32eventreactor.py
|
# Copyright (c) Twisted Matrix Laboratories.
# See LICENSE for details.
"""
A win32event based implementation of the Twisted main loop.
This requires pywin32 (formerly win32all) or ActivePython to be installed.
To install the event loop (and you should do this before any connections,
listeners or connectors are added)::
from twisted.internet import win32eventreactor
win32eventreactor.install()
LIMITATIONS:
1. WaitForMultipleObjects and thus the event loop can only handle 64 objects.
2. Process running has some problems (see L{Process} docstring).
TODO:
1. Event loop handling of writes is *very* problematic (this is causing failed tests).
Switch to doing it the correct way, whatever that means (see below).
2. Replace icky socket loopback waker with event based waker (use dummyEvent object)
3. Switch everyone to using Free Software so we don't have to deal with proprietary APIs.
ALTERNATIVE SOLUTIONS:
- IIRC, sockets can only be registered once. So we switch to a structure
like the poll() reactor, thus allowing us to deal with write events in
a decent fashion. This should allow us to pass tests, but we're still
limited to 64 events.
Or:
- Instead of doing a reactor, we make this an addon to the select reactor.
The WFMO event loop runs in a separate thread. This means no need to maintain
separate code for networking, 64 event limit doesn't apply to sockets,
we can run processes and other win32 stuff in default event loop. The
only problem is that we're stuck with the icky socket based waker.
Another benefit is that this could be extended to support >64 events
in a simpler manner than the previous solution.
The 2nd solution is probably what will get implemented.
"""
# System imports
import time
import sys
from threading import Thread
from weakref import WeakKeyDictionary
from zope.interface import implements
# Win32 imports
from win32file import FD_READ, FD_CLOSE, FD_ACCEPT, FD_CONNECT, WSAEventSelect
try:
# WSAEnumNetworkEvents was added in pywin32 215
from win32file import WSAEnumNetworkEvents
except ImportError:
import warnings
warnings.warn(
'Reliable disconnection notification requires pywin32 215 or later',
category=UserWarning)
def WSAEnumNetworkEvents(fd, event):
return set([FD_READ])
from win32event import CreateEvent, MsgWaitForMultipleObjects
from win32event import WAIT_OBJECT_0, WAIT_TIMEOUT, QS_ALLINPUT
import win32gui
# Twisted imports
from twisted.internet import posixbase
from twisted.python import log, threadable, failure
from twisted.internet.interfaces import IReactorFDSet
from twisted.internet.interfaces import IReactorWin32Events
from twisted.internet.threads import blockingCallFromThread
class Win32Reactor(posixbase.PosixReactorBase):
"""
Reactor that uses Win32 event APIs.
@ivar _reads: A dictionary mapping L{FileDescriptor} instances to a
win32 event object used to check for read events for that descriptor.
@ivar _writes: A dictionary mapping L{FileDescriptor} instances to a
arbitrary value. Keys in this dictionary will be given a chance to
write out their data.
@ivar _events: A dictionary mapping win32 event object to tuples of
L{FileDescriptor} instances and event masks.
@ivar _closedAndReading: Along with C{_closedAndNotReading}, keeps track of
descriptors which have had close notification delivered from the OS but
which we have not finished reading data from. MsgWaitForMultipleObjects
will only deliver close notification to us once, so we remember it in
these two dictionaries until we're ready to act on it. The OS has
delivered close notification for each descriptor in this dictionary, and
the descriptors are marked as allowed to handle read events in the
reactor, so they can be processed. When a descriptor is marked as not
allowed to handle read events in the reactor (ie, it is passed to
L{IReactorFDSet.removeReader}), it is moved out of this dictionary and
into C{_closedAndNotReading}. The descriptors are keys in this
dictionary. The values are arbitrary.
@type _closedAndReading: C{dict}
@ivar _closedAndNotReading: These descriptors have had close notification
delivered from the OS, but are not marked as allowed to handle read
events in the reactor. They are saved here to record their closed
state, but not processed at all. When one of these descriptors is
passed to L{IReactorFDSet.addReader}, it is moved out of this dictionary
and into C{_closedAndReading}. The descriptors are keys in this
dictionary. The values are arbitrary. This is a weak key dictionary so
that if an application tells the reactor to stop reading from a
descriptor and then forgets about that descriptor itself, the reactor
will also forget about it.
@type _closedAndNotReading: C{WeakKeyDictionary}
"""
implements(IReactorFDSet, IReactorWin32Events)
dummyEvent = CreateEvent(None, 0, 0, None)
def __init__(self):
self._reads = {}
self._writes = {}
self._events = {}
self._closedAndReading = {}
self._closedAndNotReading = WeakKeyDictionary()
posixbase.PosixReactorBase.__init__(self)
def _makeSocketEvent(self, fd, action, why):
"""
Make a win32 event object for a socket.
"""
event = CreateEvent(None, 0, 0, None)
WSAEventSelect(fd, event, why)
self._events[event] = (fd, action)
return event
def addEvent(self, event, fd, action):
"""
Add a new win32 event to the event loop.
"""
self._events[event] = (fd, action)
def removeEvent(self, event):
"""
Remove an event.
"""
del self._events[event]
def addReader(self, reader):
"""
Add a socket FileDescriptor for notification of data available to read.
"""
if reader not in self._reads:
self._reads[reader] = self._makeSocketEvent(
reader, 'doRead', FD_READ | FD_ACCEPT | FD_CONNECT | FD_CLOSE)
# If the reader is closed, move it over to the dictionary of reading
# descriptors.
if reader in self._closedAndNotReading:
self._closedAndReading[reader] = True
del self._closedAndNotReading[reader]
def addWriter(self, writer):
"""
Add a socket FileDescriptor for notification of data available to write.
"""
if writer not in self._writes:
self._writes[writer] = 1
def removeReader(self, reader):
"""Remove a Selectable for notification of data available to read.
"""
if reader in self._reads:
del self._events[self._reads[reader]]
del self._reads[reader]
# If the descriptor is closed, move it out of the dictionary of
# reading descriptors into the dictionary of waiting descriptors.
if reader in self._closedAndReading:
self._closedAndNotReading[reader] = True
del self._closedAndReading[reader]
def removeWriter(self, writer):
"""Remove a Selectable for notification of data available to write.
"""
if writer in self._writes:
del self._writes[writer]
def removeAll(self):
"""
Remove all selectables, and return a list of them.
"""
return self._removeAll(self._reads, self._writes)
def getReaders(self):
return self._reads.keys()
def getWriters(self):
return self._writes.keys()
def doWaitForMultipleEvents(self, timeout):
log.msg(channel='system', event='iteration', reactor=self)
if timeout is None:
timeout = 100
# Keep track of whether we run any application code before we get to the
# MsgWaitForMultipleObjects. If so, there's a chance it will schedule a
# new timed call or stop the reactor or do something else that means we
# shouldn't block in MsgWaitForMultipleObjects for the full timeout.
ranUserCode = False
# If any descriptors are trying to close, try to get them out of the way
# first.
for reader in self._closedAndReading.keys():
ranUserCode = True
self._runAction('doRead', reader)
for fd in self._writes.keys():
ranUserCode = True
log.callWithLogger(fd, self._runWrite, fd)
if ranUserCode:
# If application code *might* have scheduled an event, assume it
# did. If we're wrong, we'll get back here shortly anyway. If
# we're right, we'll be sure to handle the event (including reactor
# shutdown) in a timely manner.
timeout = 0
if not (self._events or self._writes):
# sleep so we don't suck up CPU time
time.sleep(timeout)
return
handles = self._events.keys() or [self.dummyEvent]
timeout = int(timeout * 1000)
val = MsgWaitForMultipleObjects(handles, 0, timeout, QS_ALLINPUT)
if val == WAIT_TIMEOUT:
return
elif val == WAIT_OBJECT_0 + len(handles):
exit = win32gui.PumpWaitingMessages()
if exit:
self.callLater(0, self.stop)
return
elif val >= WAIT_OBJECT_0 and val < WAIT_OBJECT_0 + len(handles):
event = handles[val - WAIT_OBJECT_0]
fd, action = self._events[event]
if fd in self._reads:
# Before anything, make sure it's still a valid file descriptor.
fileno = fd.fileno()
if fileno == -1:
self._disconnectSelectable(fd, posixbase._NO_FILEDESC, False)
return
# Since it's a socket (not another arbitrary event added via
# addEvent) and we asked for FD_READ | FD_CLOSE, check to see if
# we actually got FD_CLOSE. This needs a special check because
# it only gets delivered once. If we miss it, it's gone forever
# and we'll never know that the connection is closed.
events = WSAEnumNetworkEvents(fileno, event)
if FD_CLOSE in events:
self._closedAndReading[fd] = True
log.callWithLogger(fd, self._runAction, action, fd)
def _runWrite(self, fd):
closed = 0
try:
closed = fd.doWrite()
except:
closed = sys.exc_info()[1]
log.deferr()
if closed:
self.removeReader(fd)
self.removeWriter(fd)
try:
fd.connectionLost(failure.Failure(closed))
except:
log.deferr()
elif closed is None:
return 1
def _runAction(self, action, fd):
try:
closed = getattr(fd, action)()
except:
closed = sys.exc_info()[1]
log.deferr()
if closed:
self._disconnectSelectable(fd, closed, action == 'doRead')
doIteration = doWaitForMultipleEvents
class _ThreadFDWrapper(object):
"""
This wraps an event handler and translates notification in the helper
L{Win32Reactor} thread into a notification in the primary reactor thread.
@ivar _reactor: The primary reactor, the one to which event notification
will be sent.
@ivar _fd: The L{FileDescriptor} to which the event will be dispatched.
@ivar _action: A C{str} giving the method of C{_fd} which handles the event.
@ivar _logPrefix: The pre-fetched log prefix string for C{_fd}, so that
C{_fd.logPrefix} does not need to be called in a non-main thread.
"""
def __init__(self, reactor, fd, action, logPrefix):
self._reactor = reactor
self._fd = fd
self._action = action
self._logPrefix = logPrefix
def logPrefix(self):
"""
Return the original handler's log prefix, as it was given to
C{__init__}.
"""
return self._logPrefix
def _execute(self):
"""
Callback fired when the associated event is set. Run the C{action}
callback on the wrapped descriptor in the main reactor thread and raise
or return whatever it raises or returns to cause this event handler to
be removed from C{self._reactor} if appropriate.
"""
return blockingCallFromThread(
self._reactor, lambda: getattr(self._fd, self._action)())
def connectionLost(self, reason):
"""
Pass through to the wrapped descriptor, but in the main reactor thread
instead of the helper C{Win32Reactor} thread.
"""
self._reactor.callFromThread(self._fd.connectionLost, reason)
class _ThreadedWin32EventsMixin(object):
"""
This mixin implements L{IReactorWin32Events} for another reactor by running
a L{Win32Reactor} in a separate thread and dispatching work to it.
@ivar _reactor: The L{Win32Reactor} running in the other thread. This is
C{None} until it is actually needed.
@ivar _reactorThread: The L{threading.Thread} which is running the
L{Win32Reactor}. This is C{None} until it is actually needed.
"""
implements(IReactorWin32Events)
_reactor = None
_reactorThread = None
def _unmakeHelperReactor(self):
"""
Stop and discard the reactor started by C{_makeHelperReactor}.
"""
self._reactor.callFromThread(self._reactor.stop)
self._reactor = None
def _makeHelperReactor(self):
"""
Create and (in a new thread) start a L{Win32Reactor} instance to use for
the implementation of L{IReactorWin32Events}.
"""
self._reactor = Win32Reactor()
# This is a helper reactor, it is not the global reactor and its thread
# is not "the" I/O thread. Prevent it from registering it as such.
self._reactor._registerAsIOThread = False
self._reactorThread = Thread(
target=self._reactor.run, args=(False,))
self.addSystemEventTrigger(
'after', 'shutdown', self._unmakeHelperReactor)
self._reactorThread.start()
def addEvent(self, event, fd, action):
"""
@see: L{IReactorWin32Events}
"""
if self._reactor is None:
self._makeHelperReactor()
self._reactor.callFromThread(
self._reactor.addEvent,
event, _ThreadFDWrapper(self, fd, action, fd.logPrefix()),
"_execute")
def removeEvent(self, event):
"""
@see: L{IReactorWin32Events}
"""
self._reactor.callFromThread(self._reactor.removeEvent, event)
def install():
threadable.init(1)
r = Win32Reactor()
import main
main.installReactor(r)
__all__ = ["Win32Reactor", "install"]
|
test_coco.py
|
# -*- coding:utf-8 -*-
from __future__ import absolute_import
from __future__ import print_function
from __future__ import division
import os
import sys
import tensorflow as tf
import time
import cv2
import numpy as np
import json
import math
from tqdm import tqdm
import argparse
from multiprocessing import Queue, Process
sys.path.append("../")
from data.io.image_preprocess import short_side_resize_for_inference_data
from libs.networks import build_whole_network
from help_utils import tools
from libs.label_name_dict.label_dict import *
def worker(gpu_id, images, det_net, eval_data, result_queue):
os.environ["CUDA_VISIBLE_DEVICES"] = str(gpu_id)
# 1. preprocess img
img_plac = tf.placeholder(dtype=tf.uint8, shape=[None, None, 3]) # is RGB. not BGR
img_batch = tf.cast(img_plac, tf.float32)
img_batch = short_side_resize_for_inference_data(img_tensor=img_batch,
target_shortside_len=cfgs.IMG_SHORT_SIDE_LEN,
length_limitation=cfgs.IMG_MAX_LENGTH)
if cfgs.NET_NAME in ['resnet152_v1d', 'resnet101_v1d', 'resnet50_v1d']:
img_batch = (img_batch / 255 - tf.constant(cfgs.PIXEL_MEAN_)) / tf.constant(cfgs.PIXEL_STD)
else:
img_batch = img_batch - tf.constant(cfgs.PIXEL_MEAN)
img_batch = tf.expand_dims(img_batch, axis=0)
detection_boxes, detection_scores, detection_category = det_net.build_whole_detection_network(
input_img_batch=img_batch,
gtboxes_batch=None)
init_op = tf.group(
tf.global_variables_initializer(),
tf.local_variables_initializer()
)
restorer, restore_ckpt = det_net.get_restorer()
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
with tf.Session(config=config) as sess:
sess.run(init_op)
if not restorer is None:
restorer.restore(sess, restore_ckpt)
print('restore model %d ...' % gpu_id)
for a_img in images:
raw_img = cv2.imread(os.path.join(eval_data, a_img['file_name']))
raw_h, raw_w = raw_img.shape[0], raw_img.shape[1]
resized_img, detected_boxes, detected_scores, detected_categories = \
sess.run(
[img_batch, detection_boxes, detection_scores, detection_category],
feed_dict={img_plac: raw_img[:, :, ::-1]}
)
resized_h, resized_w = resized_img.shape[1], resized_img.shape[2]
scales = [raw_w / resized_w, raw_h / resized_h]
result_dict = {'scales': scales, 'boxes': detected_boxes,
'scores': detected_scores, 'labels': detected_categories,
'image_id': a_img['id']}
result_queue.put_nowait(result_dict)
def test_coco(det_net, real_test_img_list, eval_data, gpu_ids):
save_path = os.path.join('./eval_coco', cfgs.VERSION)
tools.mkdir(save_path)
fw_json_dt = open(os.path.join(save_path, 'coco_test-dev.json'), 'w')
coco_det = []
nr_records = len(real_test_img_list)
pbar = tqdm(total=nr_records)
gpu_num = len(gpu_ids.strip().split(','))
nr_image = math.ceil(nr_records / gpu_num)
result_queue = Queue(500)
procs = []
for i in range(gpu_num):
start = i * nr_image
end = min(start + nr_image, nr_records)
split_records = real_test_img_list[start:end]
proc = Process(target=worker, args=(int(gpu_ids.strip().split(',')[i]), split_records, det_net, eval_data, result_queue))
print('process:%d, start:%d, end:%d' % (i, start, end))
proc.start()
procs.append(proc)
for i in range(nr_records):
res = result_queue.get()
xmin, ymin, xmax, ymax = res['boxes'][:, 0], res['boxes'][:, 1], \
res['boxes'][:, 2], res['boxes'][:, 3]
xmin = xmin * res['scales'][0]
xmax = xmax * res['scales'][0]
ymin = ymin * res['scales'][1]
ymax = ymax * res['scales'][1]
boxes = np.transpose(np.stack([xmin, ymin, xmax-xmin, ymax-ymin]))
for j, box in enumerate(boxes):
coco_det.append({'bbox': [float(box[0]), float(box[1]), float(box[2]), float(box[3])],
'score': float(res['scores'][j]), 'image_id': res['image_id'],
'category_id': int(classes_originID[LABEL_NAME_MAP[res['labels'][j]]])})
pbar.set_description("Test image %s" % res['image_id'])
pbar.update(1)
for p in procs:
p.join()
json.dump(coco_det, fw_json_dt)
fw_json_dt.close()
def eval(num_imgs, eval_data, json_file, gpu_ids):
with open(json_file) as f:
test_img_list = json.load(f)['images']
if num_imgs == np.inf:
real_test_img_list = test_img_list
else:
real_test_img_list = test_img_list[: num_imgs]
fcos = build_whole_network.DetectionNetwork(base_network_name=cfgs.NET_NAME,
is_training=False)
test_coco(det_net=fcos, real_test_img_list=real_test_img_list, eval_data=eval_data, gpu_ids=gpu_ids)
def parse_args():
parser = argparse.ArgumentParser('evaluate the result with Pascal2007 stdand')
parser.add_argument('--eval_data', dest='eval_data',
help='evaluate imgs dir ',
default='/data/COCO/test2017', type=str)
parser.add_argument('--json_file', dest='json_file',
help='test-dev json file',
default='image_info_test-dev2017.json', type=str)
parser.add_argument('--showbox', dest='showbox',
help='whether show detecion results when evaluation',
default=False, type=bool)
parser.add_argument('--gpus', dest='gpus',
help='gpu id',
default='0,1,2,3,4,5,6,7', type=str)
parser.add_argument('--eval_num', dest='eval_num',
help='the num of eval imgs',
default=np.inf, type=int)
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
print(20*"--")
print(args)
print(20*"--")
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpus
eval(np.inf, # use np.inf to test all the imgs. use 10 to test 10 imgs.
eval_data=args.eval_data,
json_file=args.eval_gt,
gpu_ids=args.gpus)
# os.environ["CUDA_VISIBLE_DEVICES"] = '0'
# eval(np.inf, # use np.inf to test all the imgs. use 10 to test 10 imgs.
# eval_data='/data/COCO/test2017',
# json_file='/data/COCO/annotation/image_info_test-dev2017.json',
# gpu_ids='0,1,2,3')
# cocoval('./eval_coco/FPN_Res101_20190108_v1/coco_res.json',
# '/unsullied/sharefs/_research_detection/GeneralDetection/COCO/data/MSCOCO/instances_minival2014.json')
|
threads_py37.py
|
from time import perf_counter
from typing import Tuple, List, NamedTuple
from threading import Thread
from queue import SimpleQueue
from primes import is_prime, NUMBERS
class Result(NamedTuple): # <3>
flag: bool
elapsed: float
def check(n: int) -> Result: # <5>
t0 = perf_counter()
res = is_prime(n)
return Result(res, perf_counter() - t0)
def job(n: int, results: SimpleQueue) -> None: # <6>
results.put((n, check(n))) # <7>
def main() -> None:
t0 = perf_counter()
results = SimpleQueue() # type: ignore
workers: List[Thread] = [] # <2>
for n in NUMBERS:
worker = Thread(target=job, args=(n, results)) # <3>
worker.start() # <4>
workers.append(worker) # <5>
for _ in workers: # <6>
n, (prime, elapsed) = results.get() # <7>
label = 'P' if prime else ' '
print(f'{n:16} {label} {elapsed:9.6f}s')
time = perf_counter() - t0
print('Total time:', f'{time:0.2f}s')
if __name__ == '__main__':
main()
|
__init__.py
|
# -*- coding: utf-8 -*-
"""Miscellaneous helper functions (not wiki-dependent)."""
#
# (C) Pywikibot team, 2008-2017
#
# Distributed under the terms of the MIT license.
#
from __future__ import absolute_import, unicode_literals
__version__ = '$Id: c3e2d6f1b048f74faa4f4ae4a06a0c8518e74447 $'
import collections
import gzip
import hashlib
import inspect
import itertools
import os
import re
import stat
import subprocess
import sys
import threading
import time
import types
from distutils.version import Version
from warnings import catch_warnings, simplefilter, warn
PYTHON_VERSION = sys.version_info[:3]
PY2 = (PYTHON_VERSION[0] == 2)
if not PY2:
import queue as Queue
StringTypes = basestring = (str,)
UnicodeType = unicode = str
else:
import Queue
StringTypes = types.StringTypes
UnicodeType = types.UnicodeType
from pywikibot.logging import debug
try:
import bz2
except ImportError as bz2_import_error:
try:
import bz2file as bz2
warn('package bz2 was not found; using bz2file', ImportWarning)
except ImportError:
warn('package bz2 and bz2file were not found', ImportWarning)
bz2 = bz2_import_error
if PYTHON_VERSION < (3, 5):
# although deprecated in 3 completely no message was emitted until 3.5
ArgSpec = inspect.ArgSpec
getargspec = inspect.getargspec
else:
ArgSpec = collections.namedtuple('ArgSpec', ['args', 'varargs', 'keywords',
'defaults'])
def getargspec(func):
"""Python 3 implementation using inspect.signature."""
sig = inspect.signature(func)
args = []
defaults = []
varargs = None
kwargs = None
for p in sig.parameters.values():
if p.kind == inspect.Parameter.VAR_POSITIONAL:
varargs = p.name
elif p.kind == inspect.Parameter.VAR_KEYWORD:
kwargs = p.name
else:
args += [p.name]
if p.default != inspect.Parameter.empty:
defaults += [p.default]
if defaults:
defaults = tuple(defaults)
else:
defaults = None
return ArgSpec(args, varargs, kwargs, defaults)
_logger = 'tools'
class _NotImplementedWarning(RuntimeWarning):
"""Feature that is no longer implemented."""
pass
class NotImplementedClass(object):
"""No implementation is available."""
def __init__(self, *args, **kwargs):
"""Constructor."""
raise NotImplementedError(
'%s: %s' % (self.__class__.__name__, self.__doc__))
if PYTHON_VERSION < (2, 7):
try:
import future.backports.misc
except ImportError:
warn("""
pywikibot support of Python 2.6 relies on package future for many features.
Please upgrade to Python 2.7+ or Python 3.3+, or run:
"pip install future>=0.15.0"
""", RuntimeWarning)
try:
from ordereddict import OrderedDict
except ImportError:
class OrderedDict(NotImplementedClass):
"""OrderedDict not found."""
pass
try:
from counter import Counter
except ImportError:
class Counter(NotImplementedClass):
"""Counter not found."""
pass
count = None
else:
Counter = future.backports.misc.Counter
OrderedDict = future.backports.misc.OrderedDict
try:
count = future.backports.misc.count
except AttributeError:
warn('Please update the "future" package to at least version '
'0.15.0 to use its count.', RuntimeWarning, 2)
count = None
del future
if count is None:
def count(start=0, step=1):
"""Backported C{count} to support keyword arguments and step."""
while True:
yield start
start += step
else:
Counter = collections.Counter
OrderedDict = collections.OrderedDict
count = itertools.count
def has_module(module):
"""Check whether a module can be imported."""
try:
__import__(module)
except ImportError:
return False
else:
return True
def empty_iterator():
# http://stackoverflow.com/a/13243870/473890
"""An iterator which does nothing."""
return
yield
def py2_encode_utf_8(func):
"""Decorator to optionally encode the string result of a function on Python 2.x."""
if PY2:
return lambda s: func(s).encode('utf-8')
else:
return func
class classproperty(object): # flake8: disable=N801
"""
Metaclass to accesss a class method as a property.
This class may be used as a decorator::
class Foo(object):
_bar = 'baz' # a class property
@classproperty
def bar(cls): # a class property method
return cls._bar
Foo.bar gives 'baz'.
"""
def __init__(self, cls_method):
"""Hold the class method."""
self.method = cls_method
def __get__(self, instance, owner):
"""Get the attribute of the owner class by its method."""
return self.method(owner)
class suppress_warnings(catch_warnings): # flake8: disable=N801
"""A context manager that temporarily suppresses warnings."""
def __enter__(self):
"""Catch the old filter settings and ignore all warnings."""
super(suppress_warnings, self).__enter__()
simplefilter('ignore')
class UnicodeMixin(object):
"""Mixin class to add __str__ method in Python 2 or 3."""
@py2_encode_utf_8
def __str__(self):
"""Return the unicode representation as the str representation."""
return self.__unicode__()
# From http://python3porting.com/preparing.html
class ComparableMixin(object):
"""Mixin class to allow comparing to other objects which are comparable."""
def __lt__(self, other):
"""Compare if self is less than other."""
return other > self._cmpkey()
def __le__(self, other):
"""Compare if self is less equals other."""
return other >= self._cmpkey()
def __eq__(self, other):
"""Compare if self is equal to other."""
return other == self._cmpkey()
def __ge__(self, other):
"""Compare if self is greater equals other."""
return other <= self._cmpkey()
def __gt__(self, other):
"""Compare if self is greater than other."""
return other < self._cmpkey()
def __ne__(self, other):
"""Compare if self is not equal to other."""
return other != self._cmpkey()
class DotReadableDict(UnicodeMixin):
"""Parent class of Revision() and FileInfo().
Provide:
- __getitem__(), __unicode__() and __repr__().
"""
def __getitem__(self, key):
"""Give access to class values by key.
Revision class may also give access to its values by keys
e.g. revid parameter may be assigned by revision['revid']
as well as revision.revid. This makes formatting strings with
% operator easier.
"""
return getattr(self, key)
def __unicode__(self):
"""Return string representation."""
# TODO: This is more efficient if the PY2 test is done during
# class instantiation, and not inside the method.
if not PY2:
return repr(self.__dict__)
else:
_content = u', '.join(
u'{0}: {1}'.format(k, v) for k, v in self.__dict__.items())
return u'{{{0}}}'.format(_content)
def __repr__(self):
"""Return a more complete string representation."""
return repr(self.__dict__)
class FrozenDict(dict):
"""
Frozen dict, preventing write after initialisation.
Raises TypeError if write attempted.
"""
def __init__(self, data=None, error=None):
"""
Constructor.
@param data: mapping to freeze
@type data: mapping
@param error: error message
@type error: basestring
"""
if data:
args = [data]
else:
args = []
super(FrozenDict, self).__init__(*args)
self._error = error or 'FrozenDict: not writable'
def update(self, *args, **kwargs):
"""Prevent updates."""
raise TypeError(self._error)
__setitem__ = update
def concat_options(message, line_length, options):
"""Concatenate options."""
indent = len(message) + 2
line_length -= indent
option_msg = u''
option_line = u''
for option in options:
if option_line:
option_line += ', '
# +1 for ','
if len(option_line) + len(option) + 1 > line_length:
if option_msg:
option_msg += '\n' + ' ' * indent
option_msg += option_line[:-1] # remove space
option_line = ''
option_line += option
if option_line:
if option_msg:
option_msg += '\n' + ' ' * indent
option_msg += option_line
return u'{0} ({1}):'.format(message, option_msg)
class LazyRegex(object):
"""
Regex object that obtains and compiles the regex on usage.
Instances behave like the object created using L{re.compile}.
"""
def __init__(self, pattern, flags=0):
"""
Constructor.
@param pattern: L{re} regex pattern
@type pattern: str or callable
@param flags: L{re.compile} flags
@type flags: int
"""
self.raw = pattern
self.flags = flags
super(LazyRegex, self).__init__()
@property
def raw(self):
"""Get raw property."""
if callable(self._raw):
self._raw = self._raw()
return self._raw
@raw.setter
def raw(self, value):
"""Set raw property."""
self._raw = value
self._compiled = None
@property
def flags(self):
"""Get flags property."""
return self._flags
@flags.setter
def flags(self, value):
"""Set flags property."""
self._flags = value
self._compiled = None
def __getattr__(self, attr):
"""Compile the regex and delegate all attribute to the regex."""
if self._raw:
if not self._compiled:
self._compiled = re.compile(self.raw, self.flags)
if hasattr(self._compiled, attr):
return getattr(self._compiled, attr)
raise AttributeError('%s: attr %s not recognised'
% (self.__class__.__name__, attr))
else:
raise AttributeError('%s.raw not set' % self.__class__.__name__)
class DeprecatedRegex(LazyRegex):
"""Regex object that issues a deprecation notice."""
def __init__(self, pattern, flags=0, name=None, instead=None):
"""
Constructor.
If name is None, the regex pattern will be used as part of
the deprecation warning.
@param name: name of the object that is deprecated
@type name: str or None
@param instead: if provided, will be used to specify the replacement
of the deprecated name
@type instead: str
"""
super(DeprecatedRegex, self).__init__(pattern, flags)
self._name = name or self.raw
self._instead = instead
def __getattr__(self, attr):
"""Issue deprecation warning."""
issue_deprecation_warning(
self._name, self._instead, 2)
return super(DeprecatedRegex, self).__getattr__(attr)
def first_lower(string):
"""
Return a string with the first character uncapitalized.
Empty strings are supported. The original string is not changed.
"""
return string[:1].lower() + string[1:]
def first_upper(string):
"""
Return a string with the first character capitalized.
Empty strings are supported. The original string is not changed.
Warning: Python 2 and 3 capitalize "ß" differently. MediaWiki does
not capitalize ß at the beginning. See T179115.
"""
first = string[:1]
if first != 'ß':
first = first.upper()
return first + string[1:]
def normalize_username(username):
"""Normalize the username."""
if not username:
return None
username = re.sub('[_ ]+', ' ', username).strip()
return first_upper(username)
class MediaWikiVersion(Version):
"""
Version object to allow comparing 'wmf' versions with normal ones.
The version mainly consist of digits separated by periods. After that is a
suffix which may only be 'wmf<number>', 'alpha', 'beta<number>' or
'-rc.<number>' (the - and . are optional). They are considered from old to
new in that order with a version number without suffix is considered the
newest. This secondary difference is stored in an internal _dev_version
attribute.
Two versions are equal if their normal version and dev version are equal. A
version is greater if the normal version or dev version is greater. For
example:
1.24 < 1.24.1 < 1.25wmf1 < 1.25alpha < 1.25beta1 < 1.25beta2
< 1.25-rc-1 < 1.25-rc.2 < 1.25
Any other suffixes are considered invalid.
"""
MEDIAWIKI_VERSION = re.compile(
r'^(\d+(?:\.\d+)+)(-?wmf\.?(\d+)|alpha|beta(\d+)|-?rc\.?(\d+)|.*)?$')
@classmethod
def from_generator(cls, generator):
"""Create instance using the generator string."""
if not generator.startswith('MediaWiki '):
raise ValueError('Generator string ({0!r}) must start with '
'"MediaWiki "'.format(generator))
return cls(generator[len('MediaWiki '):])
def parse(self, vstring):
"""Parse version string."""
version_match = MediaWikiVersion.MEDIAWIKI_VERSION.match(vstring)
if not version_match:
raise ValueError('Invalid version number "{0}"'.format(vstring))
components = [int(n) for n in version_match.group(1).split('.')]
# The _dev_version numbering scheme might change. E.g. if a stage
# between 'alpha' and 'beta' is added, 'beta', 'rc' and stable releases
# are reassigned (beta=3, rc=4, stable=5).
if version_match.group(3): # wmf version
self._dev_version = (0, int(version_match.group(3)))
elif version_match.group(4):
self._dev_version = (2, int(version_match.group(4)))
elif version_match.group(5):
self._dev_version = (3, int(version_match.group(5)))
elif version_match.group(2) in ('alpha', '-alpha'):
self._dev_version = (1, )
else:
for handled in ('wmf', 'alpha', 'beta', 'rc'):
# if any of those pops up here our parser has failed
assert handled not in version_match.group(2), \
'Found "{0}" in "{1}"'.format(handled, version_match.group(2))
if version_match.group(2):
debug('Additional unused version part '
'"{0}"'.format(version_match.group(2)),
_logger)
self._dev_version = (4, )
self.suffix = version_match.group(2) or ''
self.version = tuple(components)
def __str__(self):
"""Return version number with optional suffix."""
return '.'.join(str(v) for v in self.version) + self.suffix
def _cmp(self, other):
if isinstance(other, basestring):
other = MediaWikiVersion(other)
if self.version > other.version:
return 1
if self.version < other.version:
return -1
if self._dev_version > other._dev_version:
return 1
if self._dev_version < other._dev_version:
return -1
return 0
if PY2:
__cmp__ = _cmp
class ThreadedGenerator(threading.Thread):
"""Look-ahead generator class.
Runs a generator in a separate thread and queues the results; can
be called like a regular generator.
Subclasses should override self.generator, I{not} self.run
Important: the generator thread will stop itself if the generator's
internal queue is exhausted; but, if the calling program does not use
all the generated values, it must call the generator's stop() method to
stop the background thread. Example usage:
>>> gen = ThreadedGenerator(target=range, args=(20,))
>>> try:
... data = list(gen)
... finally:
... gen.stop()
>>> data
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
"""
def __init__(self, group=None, target=None, name="GeneratorThread",
args=(), kwargs=None, qsize=65536):
"""Constructor. Takes same keyword arguments as threading.Thread.
target must be a generator function (or other callable that returns
an iterable object).
@param qsize: The size of the lookahead queue. The larger the qsize,
the more values will be computed in advance of use (which can eat
up memory and processor time).
@type qsize: int
"""
if kwargs is None:
kwargs = {}
if target:
self.generator = target
if not hasattr(self, "generator"):
raise RuntimeError("No generator for ThreadedGenerator to run.")
self.args, self.kwargs = args, kwargs
threading.Thread.__init__(self, group=group, name=name)
self.queue = Queue.Queue(qsize)
self.finished = threading.Event()
def __iter__(self):
"""Iterate results from the queue."""
if not self.isAlive() and not self.finished.isSet():
self.start()
# if there is an item in the queue, yield it, otherwise wait
while not self.finished.isSet():
try:
yield self.queue.get(True, 0.25)
except Queue.Empty:
pass
except KeyboardInterrupt:
self.stop()
def stop(self):
"""Stop the background thread."""
self.finished.set()
def run(self):
"""Run the generator and store the results on the queue."""
iterable = any(hasattr(self.generator, key)
for key in ('__iter__', '__getitem__'))
if iterable and not self.args and not self.kwargs:
self.__gen = self.generator
else:
self.__gen = self.generator(*self.args, **self.kwargs)
for result in self.__gen:
while True:
if self.finished.isSet():
return
try:
self.queue.put_nowait(result)
except Queue.Full:
time.sleep(0.25)
continue
break
# wait for queue to be emptied, then kill the thread
while not self.finished.isSet() and not self.queue.empty():
time.sleep(0.25)
self.stop()
def itergroup(iterable, size):
"""Make an iterator that returns lists of (up to) size items from iterable.
Example:
>>> i = itergroup(range(25), 10)
>>> print(next(i))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(next(i))
[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
>>> print(next(i))
[20, 21, 22, 23, 24]
>>> print(next(i))
Traceback (most recent call last):
...
StopIteration
"""
group = []
for item in iterable:
group.append(item)
if len(group) == size:
yield group
group = []
if group:
yield group
def islice_with_ellipsis(iterable, *args, **kwargs):
u"""
Generator which yields the first n elements of the iterable.
If more elements are available and marker is True, it returns an extra
string marker as continuation mark.
Function takes the
and the additional keyword marker.
@param iterable: the iterable to work on
@type iterable: iterable
@param args: same args as:
- C{itertools.islice(iterable, stop)}
- C{itertools.islice(iterable, start, stop[, step])}
@keyword marker: element to yield if iterable still contains elements
after showing the required number.
Default value: '…'
No other kwargs are considered.
@type marker: str
"""
s = slice(*args)
marker = kwargs.pop('marker', '…')
try:
k, v = kwargs.popitem()
raise TypeError(
"islice_with_ellipsis() take only 'marker' as keyword arg, not %s"
% k)
except KeyError:
pass
_iterable = iter(iterable)
for el in itertools.islice(_iterable, *args):
yield el
if marker and s.stop is not None:
try:
next(_iterable)
except StopIteration:
pass
else:
yield marker
class ThreadList(list):
"""A simple threadpool class to limit the number of simultaneous threads.
Any threading.Thread object can be added to the pool using the append()
method. If the maximum number of simultaneous threads has not been reached,
the Thread object will be started immediately; if not, the append() call
will block until the thread is able to start.
>>> pool = ThreadList(limit=10)
>>> def work():
... time.sleep(1)
...
>>> for x in range(20):
... pool.append(threading.Thread(target=work))
...
"""
_logger = "threadlist"
def __init__(self, limit=128, *args):
"""Constructor."""
self.limit = limit
super(ThreadList, self).__init__(*args)
for item in self:
if not isinstance(threading.Thread, item):
raise TypeError("Cannot add '%s' to ThreadList" % type(item))
def active_count(self):
"""Return the number of alive threads, and delete all non-alive ones."""
cnt = 0
for item in self[:]:
if item.isAlive():
cnt += 1
else:
self.remove(item)
return cnt
def append(self, thd):
"""Add a thread to the pool and start it."""
if not isinstance(thd, threading.Thread):
raise TypeError("Cannot append '%s' to ThreadList" % type(thd))
while self.active_count() >= self.limit:
time.sleep(2)
super(ThreadList, self).append(thd)
thd.start()
debug("thread %d ('%s') started" % (len(self), type(thd)),
self._logger)
def stop_all(self):
"""Stop all threads the pool."""
if self:
debug(u'EARLY QUIT: Threads: %d' % len(self), self._logger)
for thd in self:
thd.stop()
debug(u'EARLY QUIT: Queue size left in %s: %s'
% (thd, thd.queue.qsize()), self._logger)
def intersect_generators(genlist):
"""
Intersect generators listed in genlist.
Yield items only if they are yielded by all generators in genlist.
Threads (via ThreadedGenerator) are used in order to run generators
in parallel, so that items can be yielded before generators are
exhausted.
Threads are stopped when they are either exhausted or Ctrl-C is pressed.
Quitting before all generators are finished is attempted if
there is no more chance of finding an item in all queues.
@param genlist: list of page generators
@type genlist: list
"""
# If any generator is empty, no pages are going to be returned
for source in genlist:
if not source:
debug('At least one generator ({0!r}) is empty and execution was '
'skipped immediately.'.format(source), 'intersect')
return
# Item is cached to check that it is found n_gen
# times before being yielded.
cache = collections.defaultdict(set)
n_gen = len(genlist)
# Class to keep track of alive threads.
# Start new threads and remove completed threads.
thrlist = ThreadList()
for source in genlist:
threaded_gen = ThreadedGenerator(name=repr(source), target=source)
threaded_gen.daemon = True
thrlist.append(threaded_gen)
while True:
# Get items from queues in a round-robin way.
for t in thrlist:
try:
# TODO: evaluate if True and timeout is necessary.
item = t.queue.get(True, 0.1)
# Cache entry is a set of thread.
# Duplicates from same thread are not counted twice.
cache[item].add(t)
if len(cache[item]) == n_gen:
yield item
# Remove item from cache.
# No chance of seeing it again (see later: early stop).
cache.pop(item)
active = thrlist.active_count()
max_cache = n_gen
if cache.values():
max_cache = max(len(v) for v in cache.values())
# No. of active threads is not enough to reach n_gen.
# We can quit even if some thread is still active.
# There could be an item in all generators which has not yet
# appeared from any generator. Only when we have lost one
# generator, then we can bail out early based on seen items.
if active < n_gen and n_gen - max_cache > active:
thrlist.stop_all()
return
except Queue.Empty:
pass
except KeyboardInterrupt:
thrlist.stop_all()
finally:
# All threads are done.
if thrlist.active_count() == 0:
return
def filter_unique(iterable, container=None, key=None, add=None):
"""
Yield unique items from an iterable, omitting duplicates.
By default, to provide uniqueness, it puts the generated items into
the keys of a dict created as a local variable, each with a value of True.
It only yields items which are not already present in the local dict.
For large collections, this is not memory efficient, as a strong reference
to every item is kept in a local dict which can not be cleared.
Also, the local dict cant be re-used when chaining unique operations on
multiple generators.
To avoid these issues, it is advisable for the caller to provide their own
container and set the key parameter to be the function L{hash}, or use a
L{weakref} as the key.
The container can be any object that supports __contains__.
If the container is a set or dict, the method add or __setitem__ will be
used automatically. Any other method may be provided explicitly using the
add parameter.
Beware that key=id is only useful for cases where id() is not unique.
Note: This is not thread safe.
@param iterable: the source iterable
@type iterable: collections.Iterable
@param container: storage of seen items
@type container: type
@param key: function to convert the item to a key
@type key: callable
@param add: function to add an item to the container
@type add: callable
"""
if container is None:
container = {}
if not add:
if hasattr(container, 'add'):
def container_add(x):
container.add(key(x) if key else x)
add = container_add
else:
def container_setitem(x):
container.__setitem__(key(x) if key else x,
True)
add = container_setitem
for item in iterable:
try:
if (key(item) if key else item) not in container:
add(item)
yield item
except StopIteration:
return
class CombinedError(KeyError, IndexError):
"""An error that gets caught by both KeyError and IndexError."""
class EmptyDefault(str, collections.Mapping):
"""
A default for a not existing siteinfo property.
It should be chosen if there is no better default known. It acts like an
empty collections, so it can be iterated through it savely if treated as a
list, tuple, set or dictionary. It is also basically an empty string.
Accessing a value via __getitem__ will result in an combined KeyError and
IndexError.
"""
def __init__(self):
"""Initialise the default as an empty string."""
str.__init__(self)
def _empty_iter(self):
"""An iterator which does nothing and drops the argument."""
return empty_iterator()
def __getitem__(self, key):
"""Raise always a L{CombinedError}."""
raise CombinedError(key)
iteritems = itervalues = iterkeys = __iter__ = _empty_iter
EMPTY_DEFAULT = EmptyDefault()
class SelfCallMixin(object):
"""
Return self when called.
When '_own_desc' is defined it'll also issue a deprecation warning using
issue_deprecation_warning('Calling ' + _own_desc, 'it directly').
"""
def __call__(self):
"""Do nothing and just return itself."""
if hasattr(self, '_own_desc'):
issue_deprecation_warning('Calling {0}'.format(self._own_desc),
'it directly', 2)
return self
class SelfCallDict(SelfCallMixin, dict):
"""Dict with SelfCallMixin."""
class SelfCallString(SelfCallMixin, str):
"""Unicode string with SelfCallMixin."""
class IteratorNextMixin(collections.Iterator):
"""Backwards compatibility for Iterators."""
if PY2:
def next(self):
"""Python 2 next."""
return self.__next__()
class DequeGenerator(IteratorNextMixin, collections.deque):
"""A generator that allows items to be added during generating."""
def __next__(self):
"""Python 3 iterator method."""
if len(self):
return self.popleft()
else:
raise StopIteration
class ContextManagerWrapper(object):
"""
Wraps an object in a context manager.
It is redirecting all access to the wrapped object and executes 'close' when
used as a context manager in with-statements. In such statements the value
set via 'as' is directly the wrapped object. For example:
>>> class Wrapper(object):
... def close(self): pass
>>> an_object = Wrapper()
>>> wrapped = ContextManagerWrapper(an_object)
>>> with wrapped as another_object:
... assert another_object is an_object
It does not subclass the object though, so isinstance checks will fail
outside a with-statement.
"""
def __init__(self, wrapped):
"""Create a new wrapper."""
super(ContextManagerWrapper, self).__init__()
super(ContextManagerWrapper, self).__setattr__('_wrapped', wrapped)
def __enter__(self):
"""Enter a context manager and use the wrapped object directly."""
return self._wrapped
def __exit__(self, exc_type, exc_value, traceback):
"""Call close on the wrapped object when exiting a context manager."""
self._wrapped.close()
def __getattr__(self, name):
"""Get the attribute from the wrapped object."""
return getattr(self._wrapped, name)
def __setattr__(self, name, value):
"""Set the attribute in the wrapped object."""
setattr(self._wrapped, name, value)
def open_archive(filename, mode='rb', use_extension=True):
"""
Open a file and uncompress it if needed.
This function supports bzip2, gzip and 7zip as compression containers. It
uses the packages available in the standard library for bzip2 and gzip so
they are always available. 7zip is only available when a 7za program is
available and only supports reading from it.
The compression is either selected via the magic number or file ending.
@param filename: The filename.
@type filename: str
@param use_extension: Use the file extension instead of the magic number
to determine the type of compression (default True). Must be True when
writing or appending.
@type use_extension: bool
@param mode: The mode in which the file should be opened. It may either be
'r', 'rb', 'a', 'ab', 'w' or 'wb'. All modes open the file in binary
mode. It defaults to 'rb'.
@type mode: string
@raises ValueError: When 7za is not available or the opening mode is unknown
or it tries to write a 7z archive.
@raises FileNotFoundError: When the filename doesn't exist and it tries
to read from it or it tries to determine the compression algorithm (or
IOError on Python 2).
@raises OSError: When it's not a 7z archive but the file extension is 7z.
It is also raised by bz2 when its content is invalid. gzip does not
immediately raise that error but only on reading it.
@return: A file-like object returning the uncompressed data in binary mode.
Before Python 2.7 the GzipFile object and before 2.7.1 the BZ2File are
wrapped in a ContextManagerWrapper with its advantages/disadvantages.
@rtype: file-like object
"""
def wrap(wrapped, sub_ver):
"""Wrap in a wrapper when this is below Python version 2.7."""
if PYTHON_VERSION < (2, 7, sub_ver):
return ContextManagerWrapper(wrapped)
else:
return wrapped
if mode in ('r', 'a', 'w'):
mode += 'b'
elif mode not in ('rb', 'ab', 'wb'):
raise ValueError('Invalid mode: "{0}"'.format(mode))
if use_extension:
# if '.' not in filename, it'll be 1 character long but otherwise
# contain the period
extension = filename[filename.rfind('.'):][1:]
else:
if mode != 'rb':
raise ValueError('Magic number detection only when reading')
with open(filename, 'rb') as f:
magic_number = f.read(8)
if magic_number.startswith(b'BZh'):
extension = 'bz2'
elif magic_number.startswith(b'\x1F\x8B\x08'):
extension = 'gz'
elif magic_number.startswith(b"7z\xBC\xAF'\x1C"):
extension = '7z'
else:
extension = ''
if extension == 'bz2':
if isinstance(bz2, ImportError):
raise bz2
return wrap(bz2.BZ2File(filename, mode), 1)
elif extension == 'gz':
return wrap(gzip.open(filename, mode), 0)
elif extension == '7z':
if mode != 'rb':
raise NotImplementedError('It is not possible to write a 7z file.')
try:
process = subprocess.Popen(['7za', 'e', '-bd', '-so', filename],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
bufsize=65535)
except OSError:
raise ValueError('7za is not installed or cannot '
'uncompress "{0}"'.format(filename))
else:
stderr = process.stderr.read()
process.stderr.close()
if stderr != b'':
process.stdout.close()
raise OSError(
'Unexpected STDERR output from 7za {0}'.format(stderr))
else:
return process.stdout
else:
# assume it's an uncompressed file
return open(filename, 'rb')
def merge_unique_dicts(*args, **kwargs):
"""
Return a merged dict and making sure that the original dicts had unique keys.
The positional arguments are the dictionaries to be merged. It is also
possible to define an additional dict using the keyword arguments.
"""
args = list(args) + [dict(kwargs)]
conflicts = set()
result = {}
for arg in args:
conflicts |= set(arg.keys()) & set(result.keys())
result.update(arg)
if conflicts:
raise ValueError('Multiple dicts contain the same keys: '
'{0}'.format(', '.join(sorted(unicode(key) for key in conflicts))))
return result
# Decorators
#
# Decorator functions without parameters are _invoked_ differently from
# decorator functions with function syntax. For example, @deprecated causes
# a different invocation to @deprecated().
# The former is invoked with the decorated function as args[0].
# The latter is invoked with the decorator arguments as *args & **kwargs,
# and it must return a callable which will be invoked with the decorated
# function as args[0].
# The follow deprecators may support both syntax, e.g. @deprecated and
# @deprecated() both work. In order to achieve that, the code inspects
# args[0] to see if it callable. Therefore, a decorator must not accept
# only one arg, and that arg be a callable, as it will be detected as
# a deprecator without any arguments.
def signature(obj):
"""
Safely return function Signature object (PEP 362).
inspect.signature was introduced in 3.3, however backports are available.
In Python 3.3, it does not support all types of callables, and should
not be relied upon. Python 3.4 works correctly.
Any exception calling inspect.signature is ignored and None is returned.
@param obj: Function to inspect
@type obj: callable
@rtype: inpect.Signature or None
"""
try:
return inspect.signature(obj)
except (AttributeError, ValueError):
return None
def add_decorated_full_name(obj, stacklevel=1):
"""Extract full object name, including class, and store in __full_name__.
This must be done on all decorators that are chained together, otherwise
the second decorator will have the wrong full name.
@param obj: A object being decorated
@type obj: object
@param stacklevel: level to use
@type stacklevel: int
"""
if hasattr(obj, '__full_name__'):
return
# The current frame is add_decorated_full_name
# The next frame is the decorator
# The next frame is the object being decorated
frame = sys._getframe(stacklevel + 1)
class_name = frame.f_code.co_name
if class_name and class_name != '<module>':
obj.__full_name__ = (obj.__module__ + '.' +
class_name + '.' +
obj.__name__)
else:
obj.__full_name__ = (obj.__module__ + '.' +
obj.__name__)
def manage_wrapping(wrapper, obj):
"""Add attributes to wrapper and wrapped functions."""
wrapper.__doc__ = obj.__doc__
wrapper.__name__ = obj.__name__
wrapper.__module__ = obj.__module__
wrapper.__signature__ = signature(obj)
if not hasattr(obj, '__full_name__'):
add_decorated_full_name(obj, 2)
wrapper.__full_name__ = obj.__full_name__
# Use the previous wrappers depth, if it exists
wrapper.__depth__ = getattr(obj, '__depth__', 0) + 1
# Obtain the wrapped object from the previous wrapper
wrapped = getattr(obj, '__wrapped__', obj)
wrapper.__wrapped__ = wrapped
# Increment the number of wrappers
if hasattr(wrapped, '__wrappers__'):
wrapped.__wrappers__ += 1
else:
wrapped.__wrappers__ = 1
def get_wrapper_depth(wrapper):
"""Return depth of wrapper function."""
return wrapper.__wrapped__.__wrappers__ + (1 - wrapper.__depth__)
def add_full_name(obj):
"""
A decorator to add __full_name__ to the function being decorated.
This should be done for all decorators used in pywikibot, as any
decorator that does not add __full_name__ will prevent other
decorators in the same chain from being able to obtain it.
This can be used to monkey-patch decorators in other modules.
e.g.
<xyz>.foo = add_full_name(<xyz>.foo)
@param obj: The function to decorate
@type obj: callable
@return: decorating function
@rtype: function
"""
def outer_wrapper(*outer_args, **outer_kwargs):
"""Outer wrapper.
The outer wrapper may be the replacement function if the decorated
decorator was called without arguments, or the replacement decorator
if the decorated decorator was called without arguments.
@param outer_args: args
@type outer_args: list
@param outer_kwargs: kwargs
@type outer_kwargs: dict
"""
def inner_wrapper(*args, **kwargs):
"""Replacement function.
If the decorator supported arguments, they are in outer_args,
and this wrapper is used to process the args which belong to
the function that the decorated decorator was decorating.
@param args: args passed to the decorated function.
@param kwargs: kwargs passed to the decorated function.
"""
add_decorated_full_name(args[0])
return obj(*outer_args, **outer_kwargs)(*args, **kwargs)
inner_wrapper.__doc__ = obj.__doc__
inner_wrapper.__name__ = obj.__name__
inner_wrapper.__module__ = obj.__module__
inner_wrapper.__signature__ = signature(obj)
# The decorator being decorated may have args, so both
# syntax need to be supported.
if (len(outer_args) == 1 and len(outer_kwargs) == 0 and
callable(outer_args[0])):
add_decorated_full_name(outer_args[0])
return obj(outer_args[0])
else:
return inner_wrapper
if not __debug__:
return obj
return outer_wrapper
def issue_deprecation_warning(name, instead, depth, warning_class=None):
"""Issue a deprecation warning."""
if instead:
if warning_class is None:
warning_class = DeprecationWarning
warn(u'{0} is deprecated; use {1} instead.'.format(name, instead),
warning_class, depth + 1)
else:
if warning_class is None:
warning_class = _NotImplementedWarning
warn('{0} is deprecated.'.format(name), warning_class, depth + 1)
@add_full_name
def deprecated(*args, **kwargs):
"""Decorator to output a deprecation warning.
@kwarg instead: if provided, will be used to specify the replacement
@type instead: string
"""
def decorator(obj):
"""Outer wrapper.
The outer wrapper is used to create the decorating wrapper.
@param obj: function being wrapped
@type obj: object
"""
def wrapper(*args, **kwargs):
"""Replacement function.
@param args: args passed to the decorated function.
@type args: list
@param kwargs: kwargs passed to the decorated function.
@type kwargs: dict
@return: the value returned by the decorated function
@rtype: any
"""
name = obj.__full_name__
depth = get_wrapper_depth(wrapper) + 1
issue_deprecation_warning(name, instead, depth)
return obj(*args, **kwargs)
def add_docstring(wrapper):
"""Add a Deprecated notice to the docstring."""
deprecation_notice = 'Deprecated'
if instead:
deprecation_notice += '; use ' + instead + ' instead'
deprecation_notice += '.\n\n'
if wrapper.__doc__: # Append old docstring after the notice
wrapper.__doc__ = deprecation_notice + wrapper.__doc__
else:
wrapper.__doc__ = deprecation_notice
if not __debug__:
return obj
manage_wrapping(wrapper, obj)
# Regular expression to find existing deprecation notices
deprecated_notice = re.compile(r'(^|\s)DEPRECATED[.:;,]',
re.IGNORECASE)
# Add the deprecation notice to the docstring if not present
if not wrapper.__doc__:
add_docstring(wrapper)
else:
if not deprecated_notice.search(wrapper.__doc__):
add_docstring(wrapper)
else:
# Get docstring up to @params so deprecation notices for
# parameters don't disrupt it
trim_params = re.compile(r'^.*?((?=@param)|$)', re.DOTALL)
trimmed_doc = trim_params.match(wrapper.__doc__).group(0)
if not deprecated_notice.search(trimmed_doc): # No notice
add_docstring(wrapper)
return wrapper
without_parameters = len(args) == 1 and len(kwargs) == 0 and callable(args[0])
if 'instead' in kwargs:
instead = kwargs['instead']
elif not without_parameters and len(args) == 1:
instead = args[0]
else:
instead = False
# When called as @deprecated, return a replacement function
if without_parameters:
if not __debug__:
return args[0]
return decorator(args[0])
# Otherwise return a decorator, which returns a replacement function
else:
return decorator
def deprecate_arg(old_arg, new_arg):
"""Decorator to declare old_arg deprecated and replace it with new_arg."""
return deprecated_args(**{old_arg: new_arg})
def deprecated_args(**arg_pairs):
"""
Decorator to declare multiple args deprecated.
@param arg_pairs: Each entry points to the new argument name. With True or
None it drops the value and prints a warning. If False it just drops
the value.
"""
def decorator(obj):
"""Outer wrapper.
The outer wrapper is used to create the decorating wrapper.
@param obj: function being wrapped
@type obj: object
"""
def wrapper(*__args, **__kw):
"""Replacement function.
@param __args: args passed to the decorated function
@type __args: list
@param __kwargs: kwargs passed to the decorated function
@type __kwargs: dict
@return: the value returned by the decorated function
@rtype: any
"""
name = obj.__full_name__
depth = get_wrapper_depth(wrapper) + 1
for old_arg, new_arg in arg_pairs.items():
output_args = {
'name': name,
'old_arg': old_arg,
'new_arg': new_arg,
}
if old_arg in __kw:
if new_arg not in [True, False, None]:
if new_arg in __kw:
warn(u"%(new_arg)s argument of %(name)s "
u"replaces %(old_arg)s; cannot use both."
% output_args,
RuntimeWarning, depth)
else:
# If the value is positionally given this will
# cause a TypeError, which is intentional
warn(u"%(old_arg)s argument of %(name)s "
u"is deprecated; use %(new_arg)s instead."
% output_args,
DeprecationWarning, depth)
__kw[new_arg] = __kw[old_arg]
else:
if new_arg is False:
cls = PendingDeprecationWarning
else:
cls = DeprecationWarning
warn(u"%(old_arg)s argument of %(name)s is deprecated."
% output_args,
cls, depth)
del __kw[old_arg]
return obj(*__args, **__kw)
if not __debug__:
return obj
manage_wrapping(wrapper, obj)
if wrapper.__signature__:
# Build a new signature with deprecated args added.
# __signature__ is only available in Python 3 which has OrderedDict
params = OrderedDict()
for param in wrapper.__signature__.parameters.values():
params[param.name] = param.replace()
for old_arg, new_arg in arg_pairs.items():
params[old_arg] = inspect.Parameter(
old_arg, kind=inspect._POSITIONAL_OR_KEYWORD,
default='[deprecated name of ' + new_arg + ']'
if new_arg not in [True, False, None]
else NotImplemented)
wrapper.__signature__ = inspect.Signature()
wrapper.__signature__._parameters = params
return wrapper
return decorator
def remove_last_args(arg_names):
"""
Decorator to declare all args additionally provided deprecated.
All positional arguments appearing after the normal arguments are marked
deprecated. It marks also all keyword arguments present in arg_names as
deprecated. Any arguments (positional or keyword) which are not present in
arg_names are forwarded. For example a call with 3 parameters and the
original function requests one and arg_names contain one name will result
in an error, because the function got called with 2 parameters.
The decorated function may not use C{*args} or C{**kwargs}.
@param arg_names: The names of all arguments.
@type arg_names: iterable; for the most explanatory message it should
retain the given order (so not a set for example).
"""
def decorator(obj):
"""Outer wrapper.
The outer wrapper is used to create the decorating wrapper.
@param obj: function being wrapped
@type obj: object
"""
def wrapper(*__args, **__kw):
"""Replacement function.
@param __args: args passed to the decorated function
@type __args: list
@param __kwargs: kwargs passed to the decorated function
@type __kwargs: dict
@return: the value returned by the decorated function
@rtype: any
"""
name = obj.__full_name__
depth = get_wrapper_depth(wrapper) + 1
args, varargs, kwargs, _ = getargspec(wrapper.__wrapped__)
if varargs is not None and kwargs is not None:
raise ValueError('{0} may not have * or ** args.'.format(
name))
deprecated = set(__kw) & set(arg_names)
if len(__args) > len(args):
deprecated.update(arg_names[:len(__args) - len(args)])
# remove at most |arg_names| entries from the back
new_args = tuple(__args[:max(len(args), len(__args) - len(arg_names))])
new_kwargs = dict((arg, val) for arg, val in __kw.items()
if arg not in arg_names)
if deprecated:
# sort them according to arg_names
deprecated = [arg for arg in arg_names if arg in deprecated]
warn(u"The trailing arguments ('{0}') of {1} are deprecated. "
u"The value(s) provided for '{2}' have been dropped.".
format("', '".join(arg_names),
name,
"', '".join(deprecated)),
DeprecationWarning, depth)
return obj(*new_args, **new_kwargs)
manage_wrapping(wrapper, obj)
return wrapper
return decorator
def redirect_func(target, source_module=None, target_module=None,
old_name=None, class_name=None):
"""
Return a function which can be used to redirect to 'target'.
It also acts like marking that function deprecated and copies all
parameters.
@param target: The targeted function which is to be executed.
@type target: callable
@param source_module: The module of the old function. If '.' defaults
to target_module. If 'None' (default) it tries to guess it from the
executing function.
@type source_module: basestring
@param target_module: The module of the target function. If
'None' (default) it tries to get it from the target. Might not work
with nested classes.
@type target_module: basestring
@param old_name: The old function name. If None it uses the name of the
new function.
@type old_name: basestring
@param class_name: The name of the class. It's added to the target and
source module (separated by a '.').
@type class_name: basestring
@return: A new function which adds a warning prior to each execution.
@rtype: callable
"""
def call(*a, **kw):
issue_deprecation_warning(old_name, new_name, 2)
return target(*a, **kw)
if target_module is None:
target_module = target.__module__
if target_module and target_module[-1] != '.':
target_module += '.'
if source_module is '.':
source_module = target_module
elif source_module and source_module[-1] != '.':
source_module += '.'
else:
source_module = sys._getframe(1).f_globals['__name__'] + '.'
if class_name:
target_module += class_name + '.'
source_module += class_name + '.'
old_name = source_module + (old_name or target.__name__)
new_name = target_module + target.__name__
if not __debug__:
return target
return call
class ModuleDeprecationWrapper(types.ModuleType):
"""A wrapper for a module to deprecate classes or variables of it."""
def __init__(self, module):
"""
Initialise the wrapper.
It will automatically overwrite the module with this instance in
C{sys.modules}.
@param module: The module name or instance
@type module: str or module
"""
if isinstance(module, basestring):
module = sys.modules[module]
super(ModuleDeprecationWrapper, self).__setattr__('_deprecated', {})
super(ModuleDeprecationWrapper, self).__setattr__('_module', module)
self.__dict__.update(module.__dict__)
if __debug__:
sys.modules[module.__name__] = self
def _add_deprecated_attr(self, name, replacement=None,
replacement_name=None, warning_message=None):
"""
Add the name to the local deprecated names dict.
@param name: The name of the deprecated class or variable. It may not
be already deprecated.
@type name: str
@param replacement: The replacement value which should be returned
instead. If the name is already an attribute of that module this
must be None. If None it'll return the attribute of the module.
@type replacement: any
@param replacement_name: The name of the new replaced value. Required
if C{replacement} is not None and it has no __name__ attribute.
If it contains a '.', it will be interpreted as a Python dotted
object name, and evaluated when the deprecated object is needed.
@type replacement_name: str
@param warning_message: The warning to display, with positional
variables: {0} = module, {1} = attribute name, {2} = replacement.
@type warning_message: basestring
"""
if '.' in name:
raise ValueError('Deprecated name "{0}" may not contain '
'".".'.format(name))
if name in self._deprecated:
raise ValueError('Name "{0}" is already deprecated.'.format(name))
if replacement is not None and hasattr(self._module, name):
raise ValueError('Module has already an attribute named '
'"{0}".'.format(name))
if replacement_name is None:
if hasattr(replacement, '__name__'):
replacement_name = replacement.__module__
if hasattr(replacement, '__self__'):
replacement_name += '.'
replacement_name += replacement.__self__.__class__.__name__
replacement_name += '.' + replacement.__name__
else:
raise TypeError('Replacement must have a __name__ attribute '
'or a replacement name must be set '
'specifically.')
if not warning_message:
if replacement_name:
warning_message = '{0}.{1} is deprecated; use {2} instead.'
else:
warning_message = u"{0}.{1} is deprecated."
self._deprecated[name] = replacement_name, replacement, warning_message
def __setattr__(self, attr, value):
"""Set the value of the wrapped module."""
self.__dict__[attr] = value
setattr(self._module, attr, value)
def __getattr__(self, attr):
"""Return the attribute with a deprecation warning if required."""
if attr in self._deprecated:
warning_message = self._deprecated[attr][2]
warn(warning_message.format(self._module.__name__, attr,
self._deprecated[attr][0]),
DeprecationWarning, 2)
if self._deprecated[attr][1]:
return self._deprecated[attr][1]
elif '.' in self._deprecated[attr][0]:
try:
package_name = self._deprecated[attr][0].split('.', 1)[0]
module = __import__(package_name)
context = {package_name: module}
replacement = eval(self._deprecated[attr][0], context)
self._deprecated[attr] = (
self._deprecated[attr][0],
replacement,
self._deprecated[attr][2]
)
return replacement
except Exception:
pass
return getattr(self._module, attr)
@deprecated('open_archive()')
def open_compressed(filename, use_extension=False):
"""DEPRECATED: Open a file and uncompress it if needed."""
return open_archive(filename, use_extension=use_extension)
def file_mode_checker(filename, mode=0o600):
"""Check file mode and update it, if needed.
@param filename: filename path
@type filename: basestring
@param mode: requested file mode
@type mode: int
"""
warn_str = 'File {0} had {1:o} mode; converted to {2:o} mode.'
st_mode = os.stat(filename).st_mode
if stat.S_ISREG(st_mode) and (st_mode - stat.S_IFREG != mode):
os.chmod(filename, mode)
# re-read and check changes
if os.stat(filename).st_mode != st_mode:
warn(warn_str.format(filename, st_mode - stat.S_IFREG, mode))
def compute_file_hash(filename, sha='sha1', bytes_to_read=None):
"""Compute file hash.
Result is expressed as hexdigest().
@param filename: filename path
@type filename: basestring
@param func: hashing function among the following in hashlib:
md5(), sha1(), sha224(), sha256(), sha384(), and sha512()
function name shall be passed as string, e.g. 'sha1'.
@type filename: basestring
@param bytes_to_read: only the first bytes_to_read will be considered;
if file size is smaller, the whole file will be considered.
@type bytes_to_read: None or int
"""
size = os.path.getsize(filename)
if bytes_to_read is None:
bytes_to_read = size
else:
bytes_to_read = min(bytes_to_read, size)
step = 1 << 20
shas = ['md5', 'sha1', 'sha224', 'sha256', 'sha384', 'sha512']
assert sha in shas
sha = getattr(hashlib, sha)() # sha instance
with open(filename, 'rb') as f:
while bytes_to_read > 0:
read_bytes = f.read(min(bytes_to_read, step))
assert read_bytes # make sure we actually read bytes
bytes_to_read -= len(read_bytes)
sha.update(read_bytes)
return sha.hexdigest()
|
http_1_0_server_socket_client_100_continue_test.py
|
import test_util.proxy
import test_util.runner
import http
import http.server
import threading
import test_util.thread_safe_counter
import random
import socket
import time
if __name__ == "__main__":
request_counter = test_util.thread_safe_counter.Counter()
# This is HTTP 1.1 server that does not support persisent connections
class Server(http.server.BaseHTTPRequestHandler):
protocol_version = "HTTP/1.1"
disable_nagle_algorithm = True
def handle_expect_100(self):
if self.path == "/reject_continue_no_body/":
self.send_response(404)
self.send_header("Content-Length", "0")
self.end_headers()
return False
elif self.path == "/reject_continue_body/":
self.send_response(404)
self.send_header("Content-Length", "4")
self.end_headers()
self.wfile.flush()
time.sleep(0.01)
self.wfile.write(b"nope")
return False
else:
self.send_response_only(http.HTTPStatus.CONTINUE)
self.end_headers()
return True
def do_POST(self):
self.handle_expect_100
request_counter.increment()
content_length = int(self.headers["Content-Length"])
body = self.rfile.read(content_length) if content_length > 0 else ""
body_length = len(body)
if self.path == "/body_200_length/":
self.send_response(200)
response = b"<h1>body_200 %d</h1>" % body_length
self.send_header("Content-type", "text/html")
self.send_header("Content-Length", str(len(response)))
self.end_headers()
self.wfile.write(response)
elif self.path == "/no_body_200_length/":
self.send_response(200)
self.send_header("Content-type", "text/html")
self.send_header("Content-Length", "0")
self.end_headers()
server = http.server.HTTPServer(("localhost", 0), Server)
server_port = server.server_address[1]
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True # thread dies with the program
thread.start()
expected_request_counter = 0
def test_requests(proxy_port, behavior, send_immediately, suffix):
if suffix.startswith("reject_continue_") and behavior != "default":
return True
global expected_request_counter
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("127.0.0.1", proxy_port))
test_util.runner.get_line_from_queue_and_assert(queue, "connection\n")
url = "http://localhost:%d/%s/" % (server_port, suffix)
# We want to often test short payloads that will fit in the same
# packet with the pre body.
body_length = random.choice([random.randint(1, 2), random.randint(3, 100000)])
body = b"a" * body_length
client.send(
b"POST %s HTTP/1.1\r\n"
b"Host: localhost:%d\r\n"
b"Accept-Encoding: identity\r\n"
b"Content-Length: %d\r\n"
b"Expect: 100-continue\r\n\r\n" % (url.encode(), proxy_port, len(body))
)
stream = (
"downstream"
if behavior
in {
"request_pre_body_generates_response_with_body",
"request_pre_body_generates_response_without_body",
"request_body_last_generates_response_with_body",
"request_body_last_generates_response_without_body",
"request_pre_body_generates_404_response_with_body",
"request_pre_body_generates_404_response_without_body",
}
else "upstream"
)
if not suffix.startswith("reject_continue_") and (
behavior.endswith("default")
or behavior.endswith("response_pre_body_generates_response_with_body")
or behavior.endswith("response_pre_body_generates_response_without_body")
or behavior.endswith("response_pre_body_prepend")
or behavior.endswith("response_body_prepend")
or behavior.endswith("response_body_append")
):
expected_request_counter += 1
test_util.runner.get_line_from_queue_and_assert(
queue, "request_pre_body /%s/ %s\n" % (suffix, stream)
)
if behavior not in {
"request_pre_body_generates_response_with_body",
"request_pre_body_generates_response_without_body",
"request_body_last_generates_response_with_body",
"request_body_last_generates_response_without_body",
"request_pre_body_generates_404_response_with_body",
"request_pre_body_generates_404_response_without_body",
}:
code = (
200
if behavior
in {
"response_pre_body_generates_response_with_body",
"response_pre_body_generates_response_without_body",
}
else (404 if suffix.startswith("reject_continue") else 100)
)
test_util.runner.get_line_from_queue_and_assert(
queue, "response_pre_body /%s/ %d downstream\n" % (suffix, code)
)
response = b""
while response.count(b"\n") < 2:
response += client.recv(4096)
if suffix.startswith("reject_continue_") or behavior.startswith(
"request_pre_body_generates_404_response_"
):
assert response.startswith(b"HTTP/1.1 404 Not Found\r\n"), "Didn't get 404"
if suffix.startswith("reject_continue_"):
test_util.runner.get_line_from_queue_and_assert(
queue, "response_body_some_last /%s/\n" % suffix
)
test_util.runner.get_line_from_queue_and_assert(
queue, "response_finished\n"
)
else:
expected_response = b"HTTP/1.1 100 Continue\r\n\r\n"
assert response.startswith(expected_response), "Didn't get 100 Continue"
response = response[len(expected_response) :]
client.send(body)
test_util.runner.get_line_from_queue_and_assert(
queue, "request_body_some_last /%s/\n" % suffix
)
if (
behavior.endswith("default")
or behavior.endswith("response_pre_body_generates_response_with_body")
or behavior.endswith(
"response_pre_body_generates_response_without_body"
)
or behavior.endswith("response_pre_body_prepend")
or behavior.endswith("response_body_prepend")
or behavior.endswith("response_body_append")
):
stream = "none" if False else "downstream"
test_util.runner.get_line_from_queue_and_assert(
queue, "response_pre_body /%s/ 200 %s\n" % (suffix, stream)
)
test_util.runner.get_line_from_queue_and_assert(
queue, "response_body_some_last /%s/\n" % suffix
)
test_util.runner.get_line_from_queue_and_assert(
queue, "response_finished\n"
)
if (
behavior
in {
"request_pre_body_generates_response_with_body",
"request_body_last_generates_response_with_body",
}
or behavior.endswith("response_pre_body_generates_response_with_body")
):
expected_body = b"<h1>%s</h1>" % str.encode(behavior)
else:
if (
suffix == "no_body_200_length"
or behavior
in {
"request_pre_body_generates_response_without_body",
"request_body_last_generates_response_without_body",
}
or behavior.endswith(
"response_pre_body_generates_response_without_body"
)
):
expected_body = b""
else:
expected_body = (
b"<h1>body_200</h1>"
if body_length is None
else (b"<h1>body_200 %d</h1>" % body_length)
)
if behavior.endswith("response_pre_body_prepend") or behavior.endswith(
"response_body_prepend"
):
expected_body = b"<h1>Pre body</h1>" + expected_body
elif behavior.endswith("response_body_append"):
expected_body += b"<h1>Post body</h1>"
expected_length = 10 ** 10
first = True
while len(response) < expected_length:
if not first:
piece = client.recv(4096)
if len(piece) == 0:
break
response += piece
first = False
body_end = response.find(b"\r\n\r\n")
if body_end > -1:
headers = response[:body_end].split(b"\r\n")[1:]
for header in headers:
if header.startswith(b"Content-Length: "):
body_len = int(header[len(b"Content-Length: ") :])
expected_length = body_end + 4 + body_len
break
else:
assert False, "Invalid response"
read_body = response[response.index(b"\r\n\r\n") + 4 :]
assert read_body == expected_body, "%s body %s doesn't match %s!" % (
url,
read_body,
expected_body,
)
client.close()
assert expected_request_counter == request_counter.value(), (
"Unexpected request_count - expected %d was %d",
expected_request_counter,
request_counter.value(),
)
test_util.runner.get_line_from_queue_and_assert(queue, "connection_finished\n")
for behavior in [
"default",
"request_pre_body_generates_response_with_body",
"request_pre_body_generates_response_without_body",
"request_body_last_generates_response_with_body",
"request_body_last_generates_response_without_body",
"response_pre_body_generates_response_with_body",
"response_pre_body_generates_response_without_body",
"response_pre_body_prepend",
"response_body_prepend",
"response_body_append",
"request_pre_body_generates_404_response_with_body",
"request_pre_body_generates_404_response_without_body",
]:
for send_immediately in [True, False]:
queue, proxy_process = test_util.runner.run(
"./tests-proxy/server/switch_callbacks_proxy",
[behavior, "immediately" if send_immediately else "collect"],
)
proxy_port = int(queue.get().strip())
for suffix in [
"body_200_length",
"no_body_200_length",
"reject_continue_body",
"reject_continue_no_body",
]:
test_requests(proxy_port, behavior, send_immediately, suffix)
proxy_process.kill()
|
real_functions.py
|
from __future__ import print_function
from builtins import object
import numpy
from multiprocessing import Process, Queue
import keras
from keras import backend as K
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
import tensorflow as tf
from keras.datasets import cifar10
from oct2py import octave
octave.addpath(octave.genpath("gpml-matlab-v4.0-2016-10-19"))
def run_in_separate_process(method, args):
def queue_wrapper(q, params):
r = method(*params)
q.put(r)
q = Queue()
p = Process(target=queue_wrapper, args=(q, args))
p.start()
return_val = q.get()
p.join()
if type(return_val) is Exception:
raise return_val
return return_val
class CIFAR10(object):
def __init__(self):
self._dim = 5
self._search_domain = numpy.array([[-6, 0], [32, 512], [5, 9], [5, 9], [5, 9]])
self._num_init_pts = 1
self._sample_var = 0.0
self._min_value = 0.0
self._observations = []
self._num_fidelity = 0
def train(self, x):
try:
# Data loading and preprocessing
# The data, shuffled and split between train and test sets:
num_classes = 10
# The data, shuffled and split between train and test sets:
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
# Convert class vectors to binary class matrices.
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
lr, batch_size, unit1, unit2, unit3 = x
lr = pow(10, lr)
unit1 = int(pow(2, unit1))
unit2 = int(pow(2, unit2))
unit3 = int(pow(2, unit3))
batch_size = int(batch_size)
K.clear_session()
sess = tf.Session()
K.set_session(sess)
graphr = K.get_session().graph
with graphr.as_default():
num_classes = 10
epochs = 50
data_augmentation = True
model = Sequential()
# cov bloack
model.add(Conv2D(unit1, (3, 3), padding='same',
input_shape=x_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(unit1, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(unit2, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(unit2, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(unit3, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(unit3, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(num_classes))
model.add(Activation('softmax'))
# initiate RMSprop optimizer
opt = keras.optimizers.Adam(lr=lr)
# Let's train the model using RMSprop
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
if not data_augmentation:
print('Not using data augmentation.')
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
validation_data=(x_test, y_test),
shuffle=True)
else:
print('Using real-time data augmentation.')
# This will do preprocessing and realtime data augmentation:
datagen = ImageDataGenerator(
featurewise_center=False, # set input mean to 0 over the dataset
samplewise_center=False, # set each sample mean to 0
featurewise_std_normalization=False, # divide inputs by std of the dataset
samplewise_std_normalization=False, # divide each input by its std
zca_whitening=False, # apply ZCA whitening
rotation_range=0., # randomly rotate images in the range (degrees, 0 to 180)
width_shift_range=0.1, # randomly shift images horizontally (fraction of total width)
height_shift_range=0.1, # randomly shift images vertically (fraction of total height)
horizontal_flip=True, # randomly flip images
vertical_flip=False) # randomly flip images
# Compute quantities required for feature-wise normalization
# (std, mean, and principal components if ZCA whitening is applied).
datagen.fit(x_train)
# Fit the model on the batches generated by datagen.flow().
model.fit_generator(datagen.flow(x_train, y_train,
batch_size=batch_size),
steps_per_epoch=x_train.shape[0] // batch_size,
epochs=epochs,
validation_data=None)
# Evaluate model with test data set and share sample prediction results
evaluation = model.evaluate_generator(datagen.flow(x_test, y_test,
batch_size=batch_size),
steps=x_test.shape[0] // batch_size)
print('Model Accuracy = %.2f' % (evaluation[1]))
return 1-evaluation[1]
except Exception as e:
return e
def evaluate_true(self, x):
loss = run_in_separate_process(self.train, [x])
if type(loss) is Exception:
raise loss
else:
return numpy.array([loss])
def evaluate(self, x):
return self.evaluate_true(x)
class KISSGP(object):
def __init__(self):
self._dim = 3
self._search_domain = numpy.array([[-1, 3], [-1, 3], [-1, 3]])
self._num_init_pts = 1
self._sample_var = 0.0
self._min_value = 0.0
self._num_observations = numpy.arange(self._dim)
self._num_fidelity = 0
def evaluate_true(self, x):
value = numpy.array(octave.KISSGP(numpy.exp(x))).flatten()
return value
def evaluate(self, x):
return self.evaluate_true(x)
|
TestThreadingLocal.py
|
"""Test the ThreadingLocal module."""
import sys
import unittest
from threading import Thread
sys.path.insert(1, '../..')
from DBUtils.PersistentDB import local
__version__ = '1.2'
class TestThreadingLocal(unittest.TestCase):
def test0_GetAttr(self):
mydata = local()
mydata.number = 42
self.assertEqual(mydata.number, 42)
def test1_Dict(self):
mydata = local()
mydata.number = 42
self.assertEqual(mydata.__dict__, {'number': 42})
mydata.__dict__.setdefault('widgets', [])
self.assertEqual(mydata.widgets, [])
def test2_ThreadLocal(self):
def f():
items = sorted(mydata.__dict__.items())
log.append(items)
mydata.number = 11
log.append(mydata.number)
mydata = local()
mydata.number = 42
log = []
thread = Thread(target=f)
thread.start()
thread.join()
self.assertEqual(log, [[], 11])
self.assertEqual(mydata.number, 42)
def test3_SubClass(self):
class MyLocal(local):
number = 2
initialized = 0
def __init__(self, **kw):
if self.initialized:
raise SystemError
self.initialized = 1
self.__dict__.update(kw)
def squared(self):
return self.number ** 2
mydata = MyLocal(color='red')
self.assertEqual(mydata.number, 2)
self.assertEqual(mydata.color, 'red')
del mydata.color
self.assertEqual(mydata.squared(), 4)
def f():
items = sorted(mydata.__dict__.items())
log.append(items)
mydata.number = 7
log.append(mydata.number)
log = []
thread = Thread(target=f)
thread.start()
thread.join()
self.assertEqual(log,
[[('color', 'red'), ('initialized', 1)], 7])
self.assertEqual(mydata.number, 2)
self.assertTrue(not hasattr(mydata, 'color'))
class MyLocal(local):
__slots__ = 'number'
mydata = MyLocal()
mydata.number = 42
mydata.color = 'red'
thread = Thread(target=f)
thread.start()
thread.join()
self.assertEqual(mydata.number, 7)
if __name__ == '__main__':
unittest.main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.