def getPairsThread(pairs):
xVals = []
res = Queue()
processors = multiprocessing.cpu_count()
width = len(pairs)/(processors -1)
processes = []
print "Initial pairs len " + str(len(pairs)) + " " + str(width)
##processes = [Process(target=getPairs, args=(pairs, xVals)) for i in xrange(processors)]
available = processors -1
for i in xrange(available):
start = width * i
end = ((i + 1) * width)
p = Process(target=getPairs, args=(pairs[start:end], res))
processes.append(p)
if (width * processors < len(pairs)):
p = Process(target=getPairs, args=(pairs[(width*processors):(len(pairs))], res))
processes.append(p)
for p in processes:
p.start()
for p in processes:
p.join()
xVals = res.get()
for r in range(res.qsize()):
xVals += res.get()
return xVals
def start(repos, counter):
"""
creates the whole user connected graph
parameters:
repos - comma separated repository ids
counter - int value
"""
unExploredUserQueue = Queue() # queue for maintaining the unexplored users
ExploredUserMap = {} # map for maintaining the explored users
global userMap, userCount, userIndexFile
usersSet = getUsers(repos)
print len(usersSet)
userConnectedGraph = nx.DiGraph()
userConnectedGraph.add_nodes_from(usersSet)
try:
for user in usersSet:
if user not in userMap:
userMap[user] = userCount
userIndexFile.write(user + " " + str(userCount))
userIndexFile.write("\n")
userCount += 1
unExploredUserQueue.put(user)
createUserConnectedWholeGraph(userConnectedGraph, unExploredUserQueue, ExploredUserMap)
gp.processGraph(userConnectedGraph)
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print (exc_type, fname, exc_tb.tb_lineno)
raise e
def __init__(self): # Global variables self.history = [] self._historyPos = None CNC.loadConfig(Utils.config) self.gcode = GCode() self.cnc = self.gcode.cnc self.log = Queue() # Log queue returned from GRBL self.queue = Queue() # Command queue to send to GRBL self.pendant = Queue() # Command queue to be executed from Pendant self.serial = None self.thread = None self.controller = Utils.CONTROLLER["Grbl"] self._posUpdate = False # Update position self._probeUpdate= False # Update probe self._gUpdate = False # Update $G self._update = None # Generic update self.running = False self._runLines = 0 self._stop = False # Raise to stop current run self._quit = 0 self._pause = False # machine is on Hold self._alarm = True # Display alarm message if true self._msg = None self._sumcline = 0 self._lastFeed = 0 self._newFeed = 0
def startForCreatingWholeGraph(repos, counter):
"""
creates the whole user connected graph
parameters:
repos - comma separated repository ids
counter - int value
"""
unExploredUserQueue = Queue() #queue for maintaining the unexplored users
ExploredUserMap = {} #map for maintaining the explored users
usersSet = getUsers(repos)
print len(usersSet)
userConnectedGraph = nx.DiGraph()
#userConnectedGraph = nx.Graph()
try:
#add the users to the unExploredQueue
for user in usersSet:
unExploredUserQueue.put(user)
createUserConnectedWholeGraph(userConnectedGraph,unExploredUserQueue, ExploredUserMap)
calculateEigenCentrality(userConnectedGraph, counter)
calculateDegreeCentrality(userConnectedGraph, counter)
#calculateClosenessCentrality(userConnectedGraph, counter)
filesList = []
filesList.append('eigenCentrality' + str(counter))
filesList.append('degreeCentrality' + str(counter))
#filesList.append('closenessCentrality'+str(counter))
plotgraphForCentralities(path, filesList)
except Exception as e:
print e
def receive_token(self, token):
self.__token = token
self.token_node()
if self.is_proxy():
q = Queue()
while not self.__request.empty():
request = self.__request.get(False)
#if request[2] < self.__token.get_counter():
if request[0] is self:
child_node = self.get_child_node(request[1])
if child_node is not None:
print "Proxy MSS %d grants token to MH %d via MSS %d" % (self.__name, request[1].get_name(), child_node.get_name())
child_node.process_mh_token(self.__token, request)
else:
print "Proxy MSS %d cannot find MH %d...request dropped" % (self.__name, request[1].get_name())
elif request[0] is not None:
request[0].process_proxy_token(self.__token, request)
# else:
# q.put(request)
if not q.empty():
del self.__request
self.__request = q
else:
del q
class pr_subscriber(Thread):
def __init__(self, top = None, loc = "tcp://localhost:5556"):
Thread.__init__(self)
self.loc = loc
self.top = top
self.messages = Queue()
self.listen = True
def run(self):
context = zmq.Context()
socket = context.socket(zmq.SUB)
socket.connect(self.loc)
if self.top:
socket.setsockopt(zmq.SUBSCRIBE, self.top)
while self.listen:
string = socket.recv()
self.messages.put(string)
def poll(self):
res = None
try:
res = self.messages.get_nowait()
except Empty:
return res
return pr_message.decode(res)
def kill(self):
self.listen = False
class AsyncImageGrabber(threading.Thread):
def __init__(self, url, interval, size=3):
super(AsyncImageGrabber, self).__init__()
self.queue = Queue(3)
self.imageGrabber = ImageGrabber(url)
self.running = True
self.interval = interval
# def initialize(self, filename, interval, resolution):
# self.recorder.initialize(filename, interval, resolution)
def clean(self):
self.running = False
# while not self.queue.empty():
# self.queue.get()
# self.queue.task_done()
# self.queue.join()
def get(self):
image = self.queue.get()
self.queue.task_done()
return image
def run(self):
while self.running:
try:
# image = imageGrabber.getFrame()
image = self.imageGrabber.getFrame()
except Exception as e:
logging.error('Failed to grab image due to exception(%s)' % (str(e),))
self.running = False
break
# self.queue.put(self.imageGrabber.getFrame())
self.queue.put(image)
time.sleep(self.interval)
def main():
start = {}
start['url'] = "http://www.hao123.com"
logop = {}
logop['logfile'] = "log.txt"#uop['logfile']
logop['loglevel'] = "INFO"#uop['level']
global logger
logger = getlog(logop)#构造log对象
global db
db = dbhand(logger)
dbfile = "todayb.db"
db.dbconnect(dbfile)
db.initdatabase()#数据表初始化
db.selecturls2()
db.insertone(start,'urls')
queue = Queue()
threadnumber = 30
lock = threading.Lock()
for i in range(threadnumber):#初始化线程池
t1 = multigeturl(queue,'urlt_'+str(i),logger,lock)
t1.setDaemon(True)
t1.start()
allurl = db.selecturls2()
while True:
while len(allurl) > 0:
t = allurl.pop()
queue.put(t)
allurl = db.selecturls2()
queue.join()
def test_lock(processes=10, lock=Lock(), queue=None):
print_result = False
if queue == None:
print_result = True
queue = Queue()
procs = []
for i in xrange(processes):
procs.append(Process(target=test_lock_process, args=(lock, i, queue,)))
start = time.time()
for t in procs:
t.start()
for t in procs:
t.join()
end = time.time()
print end - start
res = [(None, 0, None)]
i = 0
if print_result:
try:
while True:
res.append(queue.get(block=False))
if res[-1][0] == res[-2][0]:
sys.stderr.write("{}:\n".format(i))
for r in res[-2 ** 2:]:
sys.stderr.write("{}\n".format(r))
sys.stderr.write("\n")
i += 1
except Empty:
sys.stderr.write("{}:".format(i))
def __init__(self): # Global variables self.history = [] self._historyPos = None CNC.loadConfig(Utils.config) self.gcode = GCode() self.cnc = self.gcode.cnc self.wait = False # wait for commands to complete self.log = Queue() # Log queue returned from GRBL self.queue = Queue() # Command queue to send to GRBL self.pendant = Queue() # Command queue to be executed from Pendant self.serial = None self.thread = None self._posUpdate = False self._probeUpdate= False self._gUpdate = False self.running = False self._runLines = 0 self._stop = False # Raise to stop current run self._quit = 0 self._pause = False # machine is on Hold self._alarm = True self._msg = None self._update = None
class WorkManager():
def __init__(self,work_count = 10,timeout = 0,is_daemon = bool('true')):
self.work_queue = Queue()
self.result_queue = Queue()
self.works = []
self.timeout = 0
self.__init__workers__(work_count)
def __init_workers__(self,work_count):
for i in range(work_count):
work = Work(self.work_queue,self.result_queue,is_daemon,self_timeout)
self.works.append(work)
def add_worker(callback,*arg,**kwds):
self.work_queue.put((callback,*arg,**kwds))
def start(self):
for work in works:
work.start()
def get_result(self):
return self.result_queue
def wait_for_complete(self):
while len(self.works):
w = self.workers.pop()
w.join()
if w.isAlive() and not self.work_queue.empty():
self.works.append(w)
print 'all done'
def run_skink_server():
root_dir = abspath(dirname(__file__))
server = Server(root_dir=root_dir)
server.build_dir = join(root_dir, "ci_tmp")
server.subscribe('on_user_authentication_failed', on_user_authentication_failed_handler)
server.context.current_project = None
server.context.current_command = None
server.context.current_log = ""
server.context.build_queue = Queue.deque()
server.context.projects_being_built = Queue.deque()
builder = BuilderPlugin(cherrypy.engine, server)
builder.subscribe()
monitor = MonitorPlugin(cherrypy.engine, server)
monitor.subscribe()
try:
server.start("config.ini", non_block=True)
for plugin in SkinkPlugin.all():
config = server.context.settings.config
if config.has_section(plugin.__name__) and \
config.get(plugin.__name__, "enabled") == "True":
cherrypy.log('Plugin %s enabled!' % plugin.__name__,
'PLUGINS')
instance = plugin(server)
cherrypy.engine.block()
except KeyboardInterrupt:
server.stop()
def getSolarSystems(self, solarSystems, deuteriumSourcePlanet = None): # solarsytems is an iterable of tuples
if deuteriumSourcePlanet:
self.goToPlanet(deuteriumSourcePlanet)
threads = []
inputQueue = Queue()
outputQueue = Queue()
for galaxy, solarSystem in solarSystems:
params = {'session':self.session, 'galaxy':galaxy, 'system':solarSystem }
url = "http://%s/game/index.php?page=galaxyContent&ajax=1&%s" % (self.config.webpage, urllib.urlencode(params))
inputQueue.put((galaxy,solarSystem,url))
# Each day, all the new inactive planets appear at midnight, usually with plenty
# of resources, as nobody has attacked them yet. In order to find and
# attack them before others do, spawn a thread per 50 solar systems to scan:
for dummy in range((len(solarSystems) / 50) +1 ):
thread = ScanThread(inputQueue, outputQueue, self.opener)
thread.start()
threads.append(thread)
found = []
while True:
try:
output = outputQueue.get(True,1)
if output not in found:
found.append(output)
yield output
except Empty:
if not filter(threading.Thread.isAlive, threads):
break
for thread in threads:
if thread.exception:
raise thread.exception
def call_external(method, cpu_seconds = None):
queue = None
call_child = None
track_child = None
try:
queue = multiprocessing.Queue()
call_child = ExternalCall(method, queue)
child.start()
track_child = ExternalCall(call_child.pid, queue)
track_child.start()
try:
return queue.get(timeout = timeout)
except queue.Empty:
return None
finally:
if queue is not None:
queue.close()
queue.join_thread()
if child is not None and child.is_alive():
child.terminate()
child.join()
class pong(object):
def __init__(self):
self.queue_in=Queue()
self.queue_out=Queue()
thread.start_new_thread(self.run,())
self.resttime=0
self.lastcmd=0
def run(self):
while 1:
recv=self.queue_in.get()
try:
_, msg_header, msg_payload = recv.split(":",2)
identification, msg_type, msg_receiver = msg_header.strip(" ").split(" ")
sender=identification.split("!")
if msg_payload[0]=="\x01" and msg_payload[1:6]=="PING ":
self.queue_out.put("NOTICE %s :%s\n"%(sender[0],msg_payload))
self.lastcmd=time.time()
except IndexError:
print "IndexError"
pass
except ValueError: # no normal channel/private message
print "ValueError"
pass
def cmd(self,msg):
self.queue_in.put(msg)
def __init__(self):
self.queue_in=Queue()
self.queue_out=Queue()
thread.start_new_thread(self.run,())
self.h=HTMLParser.HTMLParser()
self.resttime=10
self.lastcmd=0
def __init__(self, nick):
self.queue_in = Queue()
self.queue_out = Queue()
thread.start_new_thread(self.run, ())
self.resttime = 0
self.lastcmd = 0
self.nick = nick
self.logfile = "msglogabb0t.gz"
self.blacklist = ["bottle", "Abb0t", "Ezrael"]
self.msgblacklistfile = "msgblacklist.gz"
self.msgblacklist = gzip.open(self.msgblacklistfile).read().lower().strip("\n").split("\n")
self.ziplines = gzip.open(self.logfile).read().strip("\n").split("\n")
self.all_msgs = []
tmp = []
for line in self.ziplines:
l = line
l = l.lower().strip("\t\n \r,").split(";", 2)
if l[1] not in self.blacklist and len(l[2]) > 0 and l[2][0] != "!":
try:
self.all_msgs.append(abb0t.de.stemWord(l[2].decode("utf-8")))
except UnicodeDecodeError:
self.all_msgs.append(abb0t.de.stemWord(l[2].decode("iso-8859-1")))
tmp.append(line)
self.ziplines = tmp
# self.vectorizer = TfidfVectorizer(min_df=1)#CountVectorizer(min_df=1)
self.vectorizer = CountVectorizer(min_df=1)
self.X = self.vectorizer.fit_transform(self.all_msgs)
class log(object):
def __init__(self):
self.queue_in=Queue()
self.queue_out=Queue()
thread.start_new_thread(self.run,())
def run(self):
while 1:
recv=self.queue_in.get()
try:
_, msg_header, msg_payload = recv.split(":",2)
identification, msg_type, msg_receiver = msg_header.strip(" ").split(" ")
sender=identification.split("!")
if msg_payload and msg_receiver[0]=="#":
with gzip.open("msglog.gz","a+") as log:
#print "logged:",msg_payload
log.write(str(time.time())+";"+sender[0]+";"+msg_payload+"\n")
except IndexError:
print "IndexError"
pass
except ValueError: # no normal channel/private message
print "ValueError"
pass
def cmd(self,msg):
self.queue_in.put(msg)
def new_queue(serialized_queue=None):
if not serialized_queue:
serialized_queue = mxcube.empty_queue
queue = pickle.loads(serialized_queue)
import Queue
Queue.init_signals(queue)
return queue
def test_create_and_cancel_job(self):
"""test creating and using cancel_job deletes job properly"""
queue = Queue(connection=self.testconn)
job = queue.enqueue(fixtures.say_hello)
self.assertEqual(1, len(queue.get_jobs()))
cancel_job(job.id)
self.assertEqual(0, len(queue.get_jobs()))
class ReservationManager:
""" Manages reservations for a movie theater. """
def __init__(self):
""" Creates a new instance of the reservation manager. """
self.current_id = 0
self.requests = Queue()
self.all_reservations = SwapList(ArrayList())
def queue_reservation(self, Request):
""" Queues a reservation for a showtime for processing. """
self.requests.enqueue(Request)
def process_reservations(self):
""" Processes all queued reservations and returns a read-only list containing the newly made reservations. """
results = ArrayList()
while not self.requests.is_empty:
request = self.requests.dequeue()
reserv = request.showtime.make_reservation(self.current_id, request)
if reserv is not None:
self.current_id += 1
self.all_reservations.add(reserv)
results.add(reserv)
return results
@property
def reservations(self):
""" Gets the movie theater's processed and accepted reservations. """
return self.all_reservations
def generatePathWithBFS(self, tank, graph, start = 1, goal = 2):
dist = []
prev = []
Q = []
for i in xrange(len(graph)): #// Initialization
dist.append(float('Inf')) #// Unknown distance from source to v
prev.append(None) #// Previous node in optimal path from source
Q.append(i) #// All nodes initially in Q (unvisited nodes)
dist[start] = 0 #// Distance from source to source
while Q:
dist_u, u = min((val, idx) for (idx, val) in enumerate(dist) if idx in Q)
Q.remove(u)
if u == goal:
return self.convertBFSPath(u, prev, graph)
for neighbor in xrange(1,len(graph)): #// where v is still in Q.
if graph[u][neighbor] == 0:
continue
alt = dist_u + distance(graph[0][u], graph[0][neighbor])
if alt < dist[neighbor]: #// A shorter path to v has been found
dist[neighbor] = alt
prev[neighbor] = u
print self.convertBFSPath(u, prev, graph)
raise Exception('Shortest Path not Found')
def threadload(f, directory, queue):
p = subprocess.Popen('elm-doc ' + os.path.relpath(f, directory), stdout=subprocess.PIPE, cwd=directory, shell=True)
output = p.communicate()[0].strip() or 'Could not document: ' + f
# print output
if output.startswith('Could not document: '):
p = subprocess.Popen('elm -mo --print-types ' + os.path.relpath(f, directory), stdout=subprocess.PIPE, cwd=directory, shell=True)
output = p.communicate()[0].strip() or 'Could not compile: ' + f
types = parse_print_types(output)
raw_values = []
with open(f) as module:
first_line = module.readline()
if first_line.startswith('module ') and first_line.endswith(' where'):
module_name = first_line.split()[1]
module_name = module_name.split('(')[0]
else:
module_name = os.path.split(f)[1][:-4]
for t in types:
try:
if not name(t).startswith('Could not compile: '):
if name(t).startswith(module_name):
raw_values.append(t[len(module_name)+1:])
except IndexError:
pass
data = {'name': module_name, 'document': '', 'aliases': [], 'datatypes': [], 'values': [{'raw': t} for t in raw_values]}
queue.put(data)
def runTask(task):
global config
try:
exitCode, taskStartDate = 0, datetime.datetime.now()
# print(datetime.datetime.now()," - INFO - ","runTask for task: ", task.taskName ," STARTING STEPS: ", task.start)
print(datetime.datetime.now()," - INFO - ","runTask for task: ", task.taskName , " STARTING STEPS: ", task.start,file = log)
if isinstance(task.start, dict):
allStartingSteps = []
for mergeStep, startSteps in task.start.iteritems():
allStartingSteps += startSteps
if (len(allStartingSteps) > 1):
branchQueue = Queue()
for branchName in allStartingSteps:
branchQueue.put(task.branchesDict[branchName])
exitCode = forkBranches(task, branchQueue)
elif (len(allStartingSteps) == 1):
branchName = allStartingSteps[0]
branch = task.branchesDict[branchName]
exitCode = getStep(task, branch)
if exitCode is None : exitCode = -1
print(datetime.datetime.now()," - INFO - task: ", task.taskName , " execution time is: ", datetime.datetime.now() - taskStartDate ,file = log)
except:
exitCode = -1
e = sys.exc_info()
print(datetime.datetime.now()," - ERROR - ","Exception occurred in runTask for task: ", task.taskName , " error: ", e)
print(datetime.datetime.now()," - ERROR - ","Exception occurred in runTask for task: ", task.taskName , " error: ", e ,file = log)
return exitCode
return exitCode
def load_dependency_docs(name):
try:
directory = os.path.split(name)[0]
try:
data = []
source_files = []
for root, dirs, files in os.walk(directory):
for filename in files:
if filename.lower().endswith('.elm'):
f = os.path.join(root, filename)
if not '_internals' in f:
source_files.append((f, filename))
queue = queue.Queue()
global POOL
threads = [POOL.add_task(threadload, f[0], directory, queue) for f in source_files]
POOL.wait_completion()
modules = []
while True:
if not queue.empty():
modules.append(queue.get())
else:
break
for root, dirs, files in os.walk(directory):
for filename in files:
if filename.lower().endswith('.json') and filename in [f[1][:-4] + '.json' for f in source_files]:
x = os.path.join(root, filename.lower())
if '_internals' not in x:
with open(x) as f:
data.append(json.load(f))
return modules + data
except KeyError:
return []
except:
return []
class Stack_from_Queues(object): def __init__(self): self.in_queue = Queue() self.out_queue = Queue() self.length = 0 def push(self, element): self.in_queue.enqueue(element) self.length += 1 def pop(self): while(self.in_queue.get_size() > 1): element = self.in_queue.dequeue() if (element): #Check if not None self.out_queue.enqueue(element) if (self.in_queue.get_size() == 1): self.length -= 1 return self.in_queue.dequeue() elif (self.out_queue.get_size() > 0): self.length -= 1 return self.out_queue.dequeue() def is_empty(self): return self.length <= 0 def __repr__(self): return "IN: " + str(self.in_queue) + "\nOUT: " + str(self.out_queue)
def _dbThread(self, queue):
while 1:
op = queue.get()
reset_queries()
if op is None:
close_connection()
queue.task_done()
return
func, args, kwargs, d, finished = op
start = datetime.datetime.now()
try:
result = d.callback, func(*args, **kwargs)
except:
_rollback_on_exception()
result = d.errback, Failure()
delta = datetime.datetime.now() - start
queries = ''
if delta.seconds > 0.5:
q = []
for conn in connections.all():
q.extend(conn.queries)
queries = ': QUERIES: %r' % (q,)
log.msg('Query took too long %s on thread %s queue %s: func =\n %r queries =\n %s' % (delta, threading.currentThread().getName(), queue.qsize(), repr.repr((func.__module__, func.func_name, args, kwargs,)), queries[:1024],))
finished(*result)
queue.task_done()
def __importTemple( self, temple, project, override = False ):
fqueue = Queue( 0, [ temple ] )
temple = altsep( temple )
project= altsep( project )
while True:
if fqueue.empty(): break
src_dir = altsep( fqueue.get() )
des_dir = src_dir.replace( temple, project )
items = os.listdir( src_dir )
message( "directory:" + src_dir, c = DEBUG )
for item in items:
src = os.path.join( src_dir, item )
des = os.path.join( des_dir, item )
message( "file: " + src, c = DEBUG )
if os.path.isdir( src ):
if not os.path.isdir( des ):
os.makedirs( des )
message( "create directory: " + des, c = DEBUG )
fqueue.put( src )
else:
if not os.path.isfile( des ) or override:
shutil.copy2( src, des )
message( "copy file: " + src, c = DEBUG )
else:
message( "ignore file:" + src, c = DEBUG )
def testQueue():
print("Testing Queue")
queue=Queue()
for i in range(1,16):
queue.enqueue(i)
while (queue.checkSize() != 0):
print(queue.dequeue())
def on_packet(self, header, payload):
client_ref = header.get('client_ref', '')
queue_id, call_id = client_ref.split(':', 1)
queue_id = int(queue_id)
#queue_id = header.get('queue_id', '')
queue = self.get_thread_queue(queue_id)
queue.put((header, payload))
import Queue
import threading
import os
import gzip
import sys
import common
import storages
from storages import *
import filecmp
import shutil
storagelist = storages.__all__
storageQueue = Queue.Queue()
class StorageThread(threading.Thread):
'''Class of storage-related threads.'''
def __init__(self, queue):
threading.Thread.__init__(self)
self.queue = queue
def run(self):
while True:
method, args = self.queue.get()
getattr(self, method)(*args)
self.queue.task_done()
def syncMirror(self, setting, nodeid, path):
class myHandler(BaseHTTPRequestHandler):
#Handler for the GET requests
def do_GET(self):
self.send_response(200)
self.end_headers()
if self.path == '/start':
self.startPing()
return
elif self.path == '/stop':
self.stopPing()
return
# Send the html message
# This is for returning JSON for device signal strength
data = str(os.popen(CMD).read()).strip()
if data == '':
return
lines = data.split('\n')
result = {}
for i in range(0, len(lines), 2):
dev = lines[i]
signal = lines[i + 1]
devMac = dev.split(' ')[1]
signalVal = re.compile("[ \t]").split(signal)[4]
signalVal = int(signalVal)
result[devMac] = signalVal
self.wfile.write(json.dumps(result))
return
q = Queue.Queue()
def startPing(self):
if self.q.empty():
print('Start pinging')
self.q.put(0)
thr = threading.Thread(target=self.beginPing, args=[self.q])
thr.start()
def beginPing(self, q):
# First, get IP of client (assume only one client)
IP_CMD = 'cat /var/lib/misc/dnsmasq.leases'
data = str(os.popen(IP_CMD).read()).strip()
if data == '':
return
ip = data.split(' ')[2]
PING_CMD = 'ping -c 1 -W 1 ' + ip
print(PING_CMD)
# It takes about 10 ms to do a local ping
# Do this at 250 ms rate, lower than 100 ms RTT from central
TIME = 10
TGT = 250
RATE = TGT - TIME
while not q.empty(): # This value should be changed, hopefully
# print('Ping!')
os.popen(PING_CMD)
time.sleep(RATE / 1000.0) # Milliseconds
def stopPing(self):
if not self.q.empty():
print('Done pinging!')
self.q.get()
continue
def stage_load_dlrm(run_q, batch_q, qid, stop, sls_type, lru, libFlashRec, sparse_feature_size):
while True:
try:
batch = batch_q.get(block=False)
#print("Loading batch " + str(batch))
listResult = slsload(sls_type, lru, libFlashRec, sparse_feature_size, lX[batch], lS_l[batch], lS_i[batch], qid)
run_q.put((batch, listResult))
batch_q.task_done()
except Queue.Empty:
if stop():
break
else:
continue
stop_workers = False
run_q = Queue.Queue()
batch_q = Queue.Queue()
for i in xrange(run_instances):
run_worker = Thread(target = stage_run_dlrm,
args = (dlrm_run_instances[i], run_q, (lambda : stop_workers)))
run_worker.setDaemon(True)
run_worker.start()
for i in xrange(load_instances):
load_worker = Thread(target = stage_load_dlrm,
args = (run_q, batch_q, i, (lambda : stop_workers),
args.sls_type, lru, libFlashRec, args.arch_sparse_feature_size))
load_worker.setDaemon(True)
load_worker.start()
for k in xrange(args.nepochs):
for i in xrange(nbatches):
batch_q.put(i)
if len(sys.argv) == 1:
print banner
print "[*] bypass waf"
print "[*] python {0} url <proxy_ip> <webpath>".format(sys.argv[0])
exit(1)
TARGET = sys.argv[1]
IPFILES = 'output/proxy_ip.txt'
WEBPATH = sys.argv[2] if len(
sys.argv) == 3 else "e:\Tools\PassList\Webpath\\fuckyou.txt"
with open(IPFILES, 'r') as f:
proxy_ip_list = [line.rstrip() for line in f.readlines()]
web_file = Queue.Queue()
with open(WEBPATH, 'r') as f:
for line in f.readlines():
web_file.put(line.rstrip())
def scan(web_file):
HEADERS = {'user-agent': random.choice(agents_list)}
proxy_ip = random.choice(proxy_ip_list)
url = TARGET + '/' + web_file
try:
r = requests.get(url,
headers=HEADERS,
timeout=10,
pthreads = int(pthreads)
pm_args.pop(pm_args.index('-pt') + 1)
pm_args.pop(pm_args.index('-pt'))
if '-sf' in pm_args:
start_frame = pm_args[pm_args.index('-sf') + 1]
if start_frame[0] == '-' or not start_frame.isdigit():
print "ERROR: Missing or invalid start frame number (-sf option)"
sys.exit()
start_frame = int(start_frame)
pm_args.pop(pm_args.index('-sf') + 1)
pm_args.pop(pm_args.index('-sf'))
start = datetime.today()
# build the queue for the processing threads
checklist = {}
queue = Queue.Queue()
for path in paths:
# convert the path to absolute
abs_path = os.path.abspath(path)
# search for cr2 files
print "Scanning path for CR2 files: %s" % path
search = find_cr2_images(abs_path)
# iterate through the found images
for source_path in sorted(search):
images = search[source_path]
# add this path and the number of images
# to the checklist
checklist[source_path] = len(images)
def __init__(self, pymol_instance, skin):
# prevent overloading
self.initializePlugins = self._initializePlugins
self.allow_after = 1 # easy switch for troubleshooting threads
self.pymol = pymol_instance
if self.pymol._ext_gui != None:
raise RuntimeError # only one PMGApp should ever be instantiated
else:
# create a FIFO so that PyMOL can send code to be executed by the GUI thread
self.fifo = Queue.Queue(0)
# create a pymol global so that PyMOL can find the external GUI
self.pymol._ext_gui = self
self.skin = None
# initialize Tcl/Tk
self.root = Tk() # creates the root window for the application
# color scheme
self.initializeTk_colors_common()
# operating-system dependencies
self.initOS()
# Python megawigit initialization
Pmw.initialise(self.root)
# Initialize the base class
Pmw.MegaWidget.__init__(self, parent=self.root)
# read the command line arguments regarding:
# - the size of the root window
# - the skin to use
inv = sys.modules.get("pymol.invocation", None)
if inv != None:
if skin == None:
skin = inv.options.skin
self.frameWidth = inv.options.win_x + 220
self.frameXPos = inv.options.win_px - self.frameXAdjust
self.frameHeight = inv.options.ext_y
self.frameYPos = inv.options.win_py - (self.frameHeight +
self.frameYAdjust)
self.setSkin(skin, run=0)
# define the size of the root window
import platform
if sys.platform == 'darwin' and platform.mac_ver()[0] >= '10.9':
# let OS X Maverics place the window automatically, to avoid
# off-screen placement in multi-monitor setup
self.root.geometry('%dx%d' %
(self.frameWidth, self.frameHeight))
else:
self.root.geometry('%dx%d+%d+%d' %
(self.frameWidth, self.frameHeight,
self.frameXPos, self.frameYPos))
# activate polling on the fifo
if self.allow_after:
self.root.after(1000, self.flush_fifo)
# and let 'er rip
self.runSkin()
def run_in_thread(func): """Runs |func| in a parallel thread, returns future (as Queue).""" result = Queue.Queue() thread = threading.Thread(target=lambda: result.put(func())) thread.start() return result
def __init__(self, work_num=1000, thread_num=2):
self.work_queue = Queue.Queue()
self.threads = []
self.__init_work_queue(work_num)
self.__init_thread_pool(thread_num)
WORKERS = 2
class Worker(threading.Thread):
def __init__(self, queue):
self.__queue = queue
threading.Thread.__init__(self)
def run(self):
while 1:
item = self.__queue.get()
if item is None:
break # reached end of queue
# pretend we're doing something that takes 10?00 ms
time.sleep(random.randint(10, 100) / 1000.0)
print "task", item, "finished"
#
# run with limited queue
queue = Queue.Queue(3)
for i in range(WORKERS):
Worker(queue).start() # start a worker
for item in range(10):
print "push", item
queue.put(item)
for i in range(WORKERS):
queue.put(None) # add end-of-queue markers
def __init__(self) :
#setup the map with a sample queue.
self.qMap = dict([('127.0.0.1', Queue.Queue())])
def __init__(self):
self.yy = 0
self.qq = Queue.Queue()
self.qq.put((self.aa, 1))
self.yy = 1
print 'alread user port'
def main(argv):
if not check_output('which ceph')[0]:
logger.error("No 'ceph' command available. Run this script from node, which has ceph access")
return
# TODO: Logs from down OSD
opts = parse_args(argv)
res_q = Queue.Queue()
run_q = Queue.Queue()
with warnings.catch_warnings():
warnings.simplefilter("ignore")
out_folder = os.tempnam()
os.makedirs(out_folder)
setup_loggers(getattr(logging, opts.log_level),
os.path.join(out_folder, "log.txt"))
global logger_ready
logger_ready = True
global SSH_OPTS
SSH_OPTS = SSH_OPTS.format(opts.ssh_conn_timeout, opts.ssh_private_key)
global USERNAME
USERNAME = opts.username
collector_settings = CollectSettings()
map(collector_settings.disable, opts.disable)
allowed_collectors = opts.collectors.split(',')
collectors = []
if CephDataCollector.name in allowed_collectors:
ceph_collector = CephDataCollector(opts, collector_settings, res_q)
collectors.append(ceph_collector)
else:
ceph_collector = None
if NodeCollector.name in allowed_collectors:
node_collector = NodeCollector(opts, collector_settings, res_q)
collectors.append(node_collector)
else:
node_collector = None
if NodeResourseUsageCollector.name in allowed_collectors:
node_resource_collector = NodeResourseUsageCollector(opts, collector_settings, res_q)
else:
node_resource_collector = None
if CephPerformanceCollector.name in allowed_collectors:
if CephDataCollector.name not in allowed_collectors:
logger.error("Can't collect performance info without ceph info collected")
exit(1)
else:
ceph_performance_collector = CephPerformanceCollector(opts, collector_settings, res_q)
else:
ceph_performance_collector = None
nodes = discover_nodes(opts)
nodes['master'][None] = [{}]
for role, nodes_with_args in nodes.items():
if role == 'node':
continue
logger.info("Found %s hosts with role %s", len(nodes_with_args), role)
logger.info("Found %s services with role %s",
sum(map(len, nodes_with_args.values())), role)
logger.info("Found %s hosts total", len(nodes['node']))
good_hosts = set(get_sshable_hosts(nodes['node'].keys()))
bad_hosts = set(nodes['node'].keys()) - good_hosts
if len(bad_hosts) != 0:
logger.warning("Next hosts aren't awailable over ssh and would be skipped: %s",
",".join(bad_hosts))
res_q.put((True, "bad_hosts", 'json', json.dumps(list(bad_hosts))))
new_nodes = collections.defaultdict(lambda: {})
for role, role_objs in nodes.items():
if role == 'master':
new_nodes[role] = role_objs
else:
for node, args in role_objs.items():
if node in good_hosts:
new_nodes[role][node] = args
nodes = new_nodes
# collect data at the beginning
if node_resource_collector is not None:
for node, _ in nodes['node'].items():
run_q.put((node_resource_collector.collect_node, "", node, {}))
for role, nodes_with_args in nodes.items():
for collector in collectors:
if hasattr(collector, 'collect_' + role):
coll_func = getattr(collector, 'collect_' + role)
for node, kwargs_list in nodes_with_args.items():
for kwargs in kwargs_list:
run_q.put((coll_func, "", node, kwargs))
save_results_thread = threading.Thread(target=save_results_th_func,
args=(opts, res_q, out_folder))
save_results_thread.daemon = True
save_results_thread.start()
t1 = time.time()
try:
run_all(opts, run_q)
# collect data at the end
if node_resource_collector is not None:
dt = opts.usage_collect_interval - (time.time() - t1)
if dt > 0:
logger.info("Will wait for {0} seconds for usage data collection".format(int(dt)))
for i in range(int(dt / 0.1)):
time.sleep(0.1)
logger.info("Start final usage collection")
for node, _ in nodes['node'].items():
run_q.put((node_resource_collector.collect_node, "", node, {}))
run_all(opts, run_q)
if ceph_performance_collector is not None:
logger.info("Start performace monitoring.")
with ceph_collector.osd_devs_lock:
osd_devs = ceph_collector.osd_devs.copy()
per_node = collections.defaultdict(lambda: [])
for node, data_dev, j_dev in osd_devs.values():
per_node[node].extend((data_dev, j_dev))
# start monitoring
for node, data in per_node.items():
run_q.put((ceph_performance_collector.start_performance_monitoring,
"", node, {'osd_devs': data}))
run_all(opts, run_q)
dt = opts.performance_collect_seconds
logger.info("Will wait for {0} seconds for performance data collection".format(int(dt)))
for i in range(int(dt / 0.1)):
time.sleep(0.1)
# collect results
for node, data in per_node.items():
run_q.put((ceph_performance_collector.collect_performance_data,
"", node, {}))
run_all(opts, run_q)
except Exception:
logger.exception("When collecting data:")
finally:
res_q.put(None)
# wait till all data collected
save_results_thread.join()
if opts.result is None:
with warnings.catch_warnings():
warnings.simplefilter("ignore")
out_file = os.tempnam() + ".tar.gz"
else:
out_file = opts.result
check_output("cd {0} ; tar -zcvf {1} *".format(out_folder, out_file))
logger.info("Result saved into %r", out_file)
if opts.log_level in ('WARNING', 'ERROR', "CRITICAL"):
print "Result saved into %r" % (out_file,)
if not opts.dont_remove_unpacked:
shutil.rmtree(out_folder)
else:
logger.info("Temporary folder %r", out_folder)
if opts.log_level in ('WARNING', 'ERROR', "CRITICAL"):
print "Temporary folder %r" % (out_folder,)
import cgi
import sys
import json
import time
import urllib
import Queue
import traceback
recvQueue = Queue.Queue()
sendQueue = Queue.Queue()
# class to receive requests
class Receiver:
# constructor
def __init__(self, rank=None, nonMPIMode=False):
if nonMPIMode:
self.comm = None
self.stat = None
self.nRank = 0
self.totalRanks = 1
self.selectSource = None
else:
from mpi4py import MPI
self.comm = MPI.COMM_WORLD
self.stat = MPI.Status()
self.nRank = self.comm.Get_rank()
self.totalRanks = self.comm.Get_size()
self.selectSource = MPI.ANY_SOURCE
import os
from Queue import *
from threading import *
import glob
data = glob.glob(os.path.expanduser("~/apa/data.apa/*"))
num_worker_threads = 20
q = Queue()
def worker():
while True:
task = q.get()
os.system(task)
q.task_done()
# raw
tasks = []
for lib_id in data:
lib_id = os.path.basename(lib_id) # get lib_id from full path
tasks.append(
"pybio.bamclip -bam \"~/apa/data.apa/%s/*/*/*.bam\" -image ~/apa/data.apa/%s/%s_clipping"
% (lib_id, lib_id, lib_id))
for i in range(num_worker_threads):
t = Thread(target=worker)
t.daemon = True
t.start()
redispool = redis.ConnectionPool(host=Config.RedisIp, port=6379, db=0)
redata = redis.Redis(connection_pool=redispool)
redpipe = redata.pipeline()
#验证该日期数据是否已被处理
if redata.hexists("checkdate", datadate):
logger.error("The day the data has been processed")
sys.exit(Config.EX_CODE_1)
else:
redata.hset("checkdate", datadate, 1)
#添加当天日期到全局日期列表
redata.rpush("date", datadate)
#添加当天日期到uid_rdate
queue = Queue.Queue(0)
for i in range(Config.workers):
worker_obj = HandleUserinfo(queue, logger, datadate, Config)
worker_obj.setDaemon(True)
worker_obj.start()
user_list = list(redata.smembers("user_info"))
for item in user_list:
queue.put(item)
queue.join()
time.sleep(5)
if isExists(logger, redpipe):
for bvalue in redata.transaction(handleInit, "loadtable", "playtable",
"endlist", "regiontable"):
def __init__(self):
self.pq = Queue.PriorityQueue()
self.removed = set()
self.count = 0
def __init__(self):
_MockConnBase.__init__(self)
self._queue = Queue.Queue()
templateF.close()
o = open(os.path.join(tempPath, ".htaccess"), "w")
accessFileF = open(os.path.join(os.path.dirname(os.path.realpath(__file__)), ".htaccess"))
accessFile = accessFileF.read()
o.write(accessFile)
o.close()
accessFileF.close()
#os.rmdir(tempPath)
#os.system("tar cjf " + outFileBZ2 + " --totals " + " ".join(fileList))
#os.chdir(originalPath)
#print os.getcwd()
workQueue = Queue.Queue()
def worker():
#while not workQueue.empty():
while True:
try:
item = workQueue.get()
if item.endswith("stats.gz") or item.endswith("stats.bz2"):
#prof = cProfile.Profile().runctx("processStats(item)", globals(), locals())
#stream = StringIO.StringIO()
#stats = pstats.Stats(prof, stream=stream)
#stats.sort_stats("time") # Or cumulative
#stats.print_stats() # 80 = how many to print
#print stream.getvalue()
processStats(item)
from dashboard.io_adafruit import ioAdafruitDash
import threading
import Queue
import time
import signal
import sys
from other import utils
THSens = THSensor()
GyroAcc = MPU6050GryroAccSensor()
Disp = OLEDDisplay()
dashboard = ioAdafruitDash()
mAccEvent = AccEvents()
mEvent = evt
# queue
qTH = Queue.Queue(maxsize=1)
qGA = Queue.Queue(maxsize=1)
qHB = Queue.Queue(maxsize=1)
qSensorData = Queue.Queue(maxsize=1)
qEvents = Queue.Queue(maxsize=10)
# thread list
lThreadsID = []
TAG = os.path.basename(__file__)
def signalHandler(sig, frame):
print 'You pressed ctrl+c'
print lThreadsID
if len(lThreadsID) == 0:
sys.exit(0)
def __init__(self, grid):
self.grid = grid
self.q = Q.PriorityQueue()
@app.route('/')
def index():
# return Response(out, mimetype='application/json')
n = random.randint(0, 100)
q.put(n)
return '%s\n' % n
def worker():
while True:
item = q.get()
if item is None:
break
print('Processing %s' % item) # do the work e.g. update database
cmd = ["sh","shodan.sh"]
p = subprocess.Popen(cmd, stdout = subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE)
out,err = p.communicate()
time.sleep(50)
q.task_done()
if __name__ == "__main__" :
q = Queue.Queue()
t = Thread(target=worker)
t.start()
app.run(host='0.0.0.0', port=3333, debug=True)
q.join()
q.put(None)
t.join()
def main():
parser = argparse.ArgumentParser(description='Runs clang-tidy over all files '
'in a compilation database. Requires '
'clang-tidy and clang-apply-replacements in '
'$PATH.')
parser.add_argument('-clang-tidy-binary', metavar='PATH',
default='clang-tidy',
help='path to clang-tidy binary')
parser.add_argument('-clang-apply-replacements-binary', metavar='PATH',
default='clang-apply-replacements',
help='path to clang-apply-replacements binary')
parser.add_argument('-checks', default=None,
help='checks filter, when not specified, use clang-tidy '
'default')
parser.add_argument('-config', default=None,
help='Specifies a configuration in YAML/JSON format: '
' -config="{Checks: \'*\', '
' CheckOptions: [{key: x, '
' value: y}]}" '
'When the value is empty, clang-tidy will '
'attempt to find a file named .clang-tidy for '
'each source file in its parent directories.')
parser.add_argument('-header-filter', default=None,
help='regular expression matching the names of the '
'headers to output diagnostics from. Diagnostics from '
'the main file of each translation unit are always '
'displayed.')
parser.add_argument('-export-fixes', metavar='filename', dest='export_fixes',
help='Create a yaml file to store suggested fixes in, '
'which can be applied with clang-apply-replacements.')
parser.add_argument('-j', type=int, default=0,
help='number of tidy instances to be run in parallel.')
parser.add_argument('files', nargs='*', default=['.*'],
help='files to be processed (regex on path)')
parser.add_argument('-fix', action='store_true', help='apply fix-its')
parser.add_argument('-format', action='store_true', help='Reformat code '
'after applying fixes')
parser.add_argument('-style', default='file', help='The style of reformat '
'code after applying fixes')
parser.add_argument('-p', dest='build_path',
help='Path used to read a compile command database.')
parser.add_argument('-extra-arg', dest='extra_arg',
action='append', default=[],
help='Additional argument to append to the compiler '
'command line.')
parser.add_argument('-extra-arg-before', dest='extra_arg_before',
action='append', default=[],
help='Additional argument to prepend to the compiler '
'command line.')
parser.add_argument('-quiet', action='store_true',
help='Run clang-tidy in quiet mode')
parser.add_argument('-warnings-as-errors', action=None,
help="Upgrades warnings to errors. Same format as "
"'-checks'.")
args = parser.parse_args()
db_path = 'compile_commands.json'
if args.build_path is not None:
build_path = args.build_path
else:
# Find our database
build_path = find_compilation_database(db_path)
try:
invocation = [args.clang_tidy_binary, '-list-checks']
invocation.append('-p=' + build_path)
if args.checks:
invocation.append('-checks=' + args.checks)
invocation.append('-')
subprocess.check_call(invocation)
except:
print("Unable to run clang-tidy.", file=sys.stderr)
sys.exit(1)
# Load the database and extract all files.
database = json.load(open(os.path.join(build_path, db_path)))
files = [make_absolute(entry['file'], entry['directory'])
for entry in database]
max_task = args.j
if max_task == 0:
max_task = multiprocessing.cpu_count()
tmpdir = None
if args.fix or args.export_fixes:
check_clang_apply_replacements_binary(args)
tmpdir = tempfile.mkdtemp()
# Build up a big regexy filter from all command line arguments.
file_name_re = re.compile('|'.join(args.files))
return_code = 0
try:
# Spin up a bunch of tidy-launching threads.
task_queue = queue.Queue(max_task)
# List of files with a non-zero return code.
failed_files = []
for _ in range(max_task):
t = threading.Thread(target=run_tidy,
args=(args, tmpdir, build_path, task_queue, failed_files))
t.daemon = True
t.start()
# Fill the queue with files.
for name in files:
if file_name_re.search(name):
task_queue.put(name)
# Wait for all threads to be done.
task_queue.join()
if len(failed_files):
return_code = 1
except KeyboardInterrupt:
# This is a sad hack. Unfortunately subprocess goes
# bonkers with ctrl-c and we start forking merrily.
print('\nCtrl-C detected, goodbye.')
if tmpdir:
shutil.rmtree(tmpdir)
os.kill(0, 9)
if args.export_fixes:
print('Writing fixes to ' + args.export_fixes + ' ...')
try:
merge_replacement_files(tmpdir, args.export_fixes)
except:
print('Error exporting fixes.\n', file=sys.stderr)
traceback.print_exc()
return_code=1
if args.fix:
print('Applying fixes ...')
try:
apply_fixes(args, tmpdir)
except:
print('Error applying fixes.\n', file=sys.stderr)
traceback.print_exc()
return_code=1
if tmpdir:
shutil.rmtree(tmpdir)
sys.exit(return_code)
from FifteenPuzzle import FifteenPuzzle
from EightPuzzle import EightPuzzle
from Solution import solution
try:
import Queue as Q # ver. < 3.0
except ImportError:
import queue as Q
frontier = Q.LifoQueue()
frontier_metrics = dict()
visited_hashes = dict()
class Node:
def __init__(self, state, parent):
self.parent = parent
self.state = state
self.G = 0
self.metric = self.G + state.heuristic()
def IDFS(limit):
return RIDFS(limit)
def RIDFS(limit):
if frontier.empty():
return "failure"
# get next un-visited node in stack
u_node = frontier.get()[1]
except:
erf = sys.__stderr__
print>>erf, '\n' + '-'*40
print>>erf, 'Unhandled server exception!'
print>>erf, 'Thread: %s' % threading.currentThread().getName()
print>>erf, 'Client Address: ', client_address
print>>erf, 'Request: ', repr(request)
traceback.print_exc(file=erf)
print>>erf, '\n*** Unrecoverable, server exiting!'
print>>erf, '-'*40
os._exit(0)
#----------------- end class RPCServer --------------------
objecttable = {}
request_queue = Queue.Queue(0)
response_queue = Queue.Queue(0)
class SocketIO(object):
nextseq = 0
def __init__(self, sock, objtable=None, debugging=None):
self.sockthread = threading.currentThread()
if debugging is not None:
self.debugging = debugging
self.sock = sock
if objtable is None:
objtable = objecttable
self.objtable = objtable
def translate(self, **kwargs):
response = cherrypy.response
response.headers['Content-Type'] = 'application/json'
errors = self._check_params_translate(kwargs)
if errors:
cherrypy.response.status = 400
return self._dump_json(errors)
self.log("The server is working on: %s" % repr(kwargs["q"]))
if "segid" in kwargs:
segid = kwargs["segid"]
else:
segid = "0000"
self.log("The server is working on segid: %s" % repr(segid))
if self.verbose > 0:
self.log("Request before preprocessing: %s" % repr(kwargs["q"]))
q = self._prepro(self.filter.filter(kwargs["q"]))
if self.verbose > 0:
self.log("Request after preprocessing: %s" % repr(q))
translation = ""
if q.strip():
result_queue = Queue.Queue()
key = self._get_engine_key(segid)
self.log("KEY: %s" % repr(key))
self.queue_translate[key].put((result_queue, segid, q))
try:
if self.timeout and self.timeout > 0:
name, translation = result_queue.get(timeout=self.timeout)
else:
name, translation = result_queue.get()
self.log("Engine name: %s" % name)
except Queue.Empty:
return self._timeout_error(q, 'translation')
if self.verbose > 0:
self.log(
"Translation before sentence-level confidence estimation: %s" %
translation)
self.log("Source before sentence-level confidence estimation: %s" %
q)
sentenceConfidence = None
if self.sentence_confidence_enabled == 1:
if self.verbose > 0:
self.log(
"Translation before sentence-level confidence estimation: %s"
% translation)
self.log(
"Source before sentence-level confidence estimation: %s" %
q)
sentenceConfidence = self._get_sentence_confidence(
"ID", q, translation)
if self.verbose > 0:
self.log("Sentence Confidence: %s" % sentenceConfidence)
self.log("Translation after postprocessing: %s" % translation)
if self.verbose > 0:
self.log("Translation before postprocessing: %s" % translation)
translation = self._postpro(translation)
if self.verbose > 0:
self.log("Translation after postprocessing: %s" % translation)
translation, phraseAlignment = self._getPhraseAlignment(translation)
if self.verbose > 1:
self.log("Phrase alignment: %s" % str(phraseAlignment))
self.log("Translation after removing phrase-alignment: %s" %
translation)
translation, wordAlignment = self._getWordAlignment(translation)
if self.verbose > 1:
self.log("Word alignment: %s" % str(wordAlignment))
self.log("Translation after removing word-alignment: %s" %
translation)
translation = self._getOnlyTranslation(translation)
if self.verbose > 1:
self.log("Translation after removing additional info: %s" %
translation)
translationDict = {}
if translation:
if (re.match("_NOSUGGESTION_", name)):
translationDict["translatedText"] = " "
else:
translationDict["translatedText"] = translation
if phraseAlignment:
if (re.match("_NOSUGGESTION_", name)):
translationDict["phraseAlignment"] = ""
else:
translationDict["phraseAlignment"] = phraseAlignment
if wordAlignment:
if (re.match("_NOSUGGESTION_", name)):
translationDict["wordAlignment"] = ""
else:
translationDict["wordAlignment"] = wordAlignment
if self.sentence_confidence_enabled == 1:
self.log("sentence_confidence_enabled: passed")
if sentenceConfidence:
if (re.match("_NOSUGGESTION_", name)):
translationDict["sentence_confidence"] = ""
else:
translationDict["sentence_confidence"] = sentenceConfidence
translationDict["systemName"] = name
translationDict["segmentID"] = segid
answerDict = {}
answerDict["translations"] = [translationDict]
data = {"data": answerDict}
# data = {"data" : {"translations" : [translationDict]}}
self.log("The server is returning: %s" % self._dump_json(data))
return self._dump_json(data)
try:
(ev, data) = recv.get(timeout=timeout)
except Queue.Empty:
raise Exception('operation timeout')
try:
tags.remove(ev)
except:
pass
arg_parser = argparse.ArgumentParser(
description='Command line python tool. hang test')
arg_parser.add_argument('--tv',
type=bool,
default=False,
help='enable tv-mode')
args = vars(arg_parser.parse_args())
recv = Queue.Queue()
umc = MediaPlayer()
start_proxy(umc, recv)
try:
umc.load('file://dummy', "sim")
wait_reply(recv, ['load'])
umc.sendDebugMsg('hang')
umc.play()
wait_reply(recv, ['play'])
finally:
umc.unload()
def update(self, **kwargs):
response = cherrypy.response
response.headers['Content-Type'] = 'application/json'
errors = self._check_params_update(kwargs)
if errors:
cherrypy.response.status = 400
return self._dump_json(errors)
source = kwargs["segment"]
target = kwargs["translation"]
self.log("The server is updating, segment: %s" % repr(source))
self.log("The server is updating, translation: %s" % repr(target))
if "segid" in kwargs:
segid = kwargs["segid"]
else:
segid = "0000"
self.log("The server is working on segid: %s" % repr(segid))
key = self._get_updater_key(segid)
if self.updater[key] == None:
answerDict = {}
answerDict["code"] = "0"
answerDict[
"string"] = "OK, but this engine/updater combination does not manage user feedback"
answerDict["systemName"] = key
answerDict["segmentID"] = segid
data = {"data": answerDict}
self.log("The server is returning: %s" % self._dump_json(data))
return self._dump_json(data)
source = self._updater_source_prepro(self.filter.filter(source))
source = self._removeXMLTags(source)
source = source.encode("utf-8")
target = self._updater_target_prepro(self.filter.filter(target))
target = self._removeXMLTags(target)
target = target.encode("utf-8")
self.log("The server is updating, after preprocessing segment: %s" %
repr(source))
self.log(
"The server is updating, after preprocessing translation: %s" %
repr(target))
if "extra" in kwargs:
extra = kwargs["extra"]
self.log("The server is working on update, extra: %s" %
repr(extra))
annotation = self.updater[key].update(source=source, target=target)
self.log(
"The server created this annotation: %s from the current segment and translation"
% annotation)
annotation = annotation.decode("utf-8")
q = annotation
if self.verbose > 0:
self.log("Request Dummy_Input: %s" % repr(q))
translation = ""
result_queue = Queue.Queue()
key = self._get_engine_key(segid)
self.queue_translate[key].put((result_queue, segid, q))
try:
if self.timeout and self.timeout > 0:
name, translation = result_queue.get(timeout=self.timeout)
else:
name, translation = result_queue.get()
except Queue.Empty:
return self._timeout_error(q, 'dummy_translation')
if self.verbose > 0:
self.log(
"Request after translation of Dummy_Input (NOT USED): %s" %
repr(translation))
answerDict = {}
answerDict["code"] = "0"
answerDict["string"] = "OK"
answerDict["systemName"] = name
answerDict["segmentID"] = segid
data = {"data": answerDict}
self.log("The server is returning: %s" % self._dump_json(data))
return self._dump_json(data)
from SocketServer import TCPServer
from SocketServer import ThreadingMixIn
from SimpleXMLRPCServer import SimpleXMLRPCServer
from SimpleXMLRPCServer import SimpleXMLRPCRequestHandler
#the handler of the log and database module
logger = None
#store the task information
task_status = {}
#the queue used for task scheduling
sched_queue = []
#task preprocessing, e.g., time estimation, download.
preproc_queue = Queue.Queue(100)
#the video blocks waitting for distributing
disb_queue = Queue.Queue(5000)
#the blocks that have been dispatched, not been finished
ongoing_blocks = []
#the ip and port information of the master server
master_ip = config.master_ip
master_rev_port = int(config.master_rev_port)
master_snd_port = int(config.master_snd_port)
master_rpc_port = int(config.master_rpc_port)
redis_ip = 'localhost'
red_con = redis.StrictRedis(host=redis_ip, port=6379, db=0)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#分布式进程
#在Thread和Process中，应当优选Process，因为Process更稳定，而且，Process可以
#分布到多台机器上，而Thread最多只能分布到同一台机器的多个CPU上。
#managers子模块还支持把多进程分布到多台机器上
import random, time, Queue
from multiprocessing.managers import BaseManager
#发送队列
task_que = Queue.Queue()
#接受队列
result_que = Queue.Queue()
class QueueManager(BaseManager):
pass
#注册到网络
def cal1():
return task_que
def cal2():
return result_que
def reset(self, **kwargs):
response = cherrypy.response
response.headers['Content-Type'] = 'application/json'
errors = self._check_params_reset(kwargs)
if errors:
cherrypy.response.status = 400
return self._dump_json(errors)
#We assume that the string for resetting is the same for all MT engines, and it is created by any updater
if "segid" in kwargs:
segid = kwargs["segid"]
else:
segid = "0000"
self.log("The server is working on segid: %s" % repr(segid))
k = self._get_updater_key(segid)
if updater_config[k] == None:
answerDict = {}
answerDict["code"] = "0"
answerDict[
"string"] = "OK, but this engine/updater combination does not manage this request"
answerDict["systemName"] = k
answerDict["segmentID"] = segid
data = {"data": answerDict}
self.log("The server is returning: %s" % self._dump_json(data))
return self._dump_json(data)
annotation = self.updater[k].reset()
if self.verbose > 0:
self.log("The server created this annotation: %s" % annotation)
q = annotation
if self.verbose > 0:
self.log("Request Dummy_Input: %s" % repr(q))
for k in moses.keys():
translation = ""
result_queue = Queue.Queue()
self.queue_translate[k].put((result_queue, segid, q))
try:
if self.timeout and self.timeout > 0:
name, translation = result_queue.get(timeout=self.timeout)
else:
name, translation = result_queue.get()
except Queue.Empty:
return self._timeout_error(q, 'dummy_translation')
if self.verbose > 0:
self.log(
"Request after translation of Dummy_Input (NOT USED): %s" %
repr(translation))
answerDict = {}
answerDict["code"] = "0"
answerDict["string"] = "OK"
data = {"data": answerDict}
self.log("The server is returning: %s" % self._dump_json(data))
return self._dump_json(data)
