class SimpleCSVWriter: def __init__(self, filename, fields=None): self.filename = filename self.lock = RLock() self.isFirstRow = True self.fields = fields def writerow(self, d): self.lock.acquire() fields = self.fields if self.fields is not None else d.keys() if self.isFirstRow: # dump fields f = open(self.filename , "w") writer = csv.writer(f, lineterminator="\n", quoting=csv.QUOTE_ALL) row = [k for k in fields] writer.writerow(row) f.close() self.isFirstRow = False # dump object row = [d.get(k,'') for k in fields] f = open(self.filename , "a") writer = csv.writer(f, lineterminator="\n", quoting=csv.QUOTE_ALL) writer.writerow(row) f.close() self.lock.release()
class ThreadSafeFSM(InstrumentFSM): """ A FSM class that provides thread locking in on_event to prevent simultaneous thread reentry. """ def __init__(self, states, events, enter_event, exit_event): """ """ super(ThreadSafeFSM, self).__init__(states, events, enter_event, exit_event) self._lock = RLock() def on_event(self, event, *args, **kwargs): """ """ self._lock.acquire(True) ex = None try: result = super(ThreadSafeFSM, self).on_event(event, *args, **kwargs) except Exception as ex: result = None log.error("Unhandled Exception") log.exception(ex) finally: self._lock.release() if ex: raise ex return result
class Database(object): UNICODE_TRANSLATE = {ord(u'ö'): u'o', ord(u'ä'): u'a', ord(u'ü'): u'u'} def __init__(self, filename): self.database_file = filename self.channel_map = {} self._db = None self.lock = RLock() def close(self): self.commit() cur = self.cursor(lock=True) log('Optimizing database for faster startup.', sender=self) cur.execute("VACUUM") cur.close() self.lock.release() self._db.close() self._db = None def log(self, message, *args, **kwargs): if False: try: message = message % args log('%s', message, sender=self) except TypeError, e: log('Exception in log(): %s: %s', e, message, sender=self)
class SingleIndexCache(object): def __init__(self): self.lock = RLock() self.cached_vals = [] def __enter__(self): self.lock.acquire() return self def fill(self, values): self.cached_vals = values def wipe(self): self.cached_vals = [] def get_index(self, real_funct, ind_name, **kwargs): kwargs.setdefault("max_results", 999999) if not self.cached_vals: recvs = real_funct(ind_name, **kwargs).results self.fill(recvs) def filter(self, startkey, endkey, max_results=1): c = self.cached_vals for (curr_val, obj_key) in c: if max_results == 0: break if curr_val >= startkey: if curr_val <= endkey: max_results -= 1 yield (curr_val, obj_key) else: break def __exit__(self, *args, **kwargs): self.lock.release()
class XBeeTransparentListener(Thread): def __init__(self, xbee_serial): super().__init__() self.xbser = xbee_serial self.daemon = True self.stopped = False self.pause = RLock() def run(self): while not self.stopped and self.xbser.is_open: with self.pause: try: line = self.xbser.readline() if line: print('>', line.strip()) except Exception as ex: print(str(ex)) def stop(self): self.stopped = True def pause(self): self.pause.acquire() def unpause(self): self.pause.release()
def __init__(self, req, proxy, logger, task, exit_check=None, ignored_errors=[]): Thread.__init__(self, name = "monitor%s" % task.guid) Thread.setDaemon(self, True) # the count of votes per error code self.vote_result = {} # the error code to be ignored self.vote_cleared = set().union(ignored_errors) self.thread_last_seen = {} self.dctlock = RLock() self.votelock = RLock() self.thread_ref = {} self.thread_zombie = set() # HttpReq instance self.req = req # proxy.Pool instance self.proxy = proxy self.logger = logger self.task = task self._exit = exit_check if exit_check else lambda x: False self._cleaning_up = False if os.name == "nt": self.set_title = lambda s:os.system("TITLE %s" % ( s if PY3K else s.encode(CODEPAGE, 'replace'))) elif os.name == 'posix': import sys self.set_title = lambda s:sys.stdout.write("\033]2;%s\007" % ( s if PY3K else s.encode(CODEPAGE, 'replace')))
class XBeeTransparentListener(Thread): def __init__(self, on_received=None): super().__init__() self.xbser = None self.on_received = on_received self.daemon = True self.stopped = False self.pause = RLock() def run(self): while not self.stopped and self.xbser.is_open: with self.pause: try: line = self.xbser.readline() if line: self.received(line) except Exception as ex: print(str(ex)) def received(self, line): """Subclasses may override this method, or provide a callback function when instance is created""" if self.on_received: self.on_received(line) else: print('[XBee]', line.strip()) def stop(self): self.stopped = True def pause(self): self.pause.acquire() def unpause(self): self.pause.release()
class CacheDict(dict): _cacheTimeout = 0 _accesslock = None def __init__(self, timeout): self._cacheTimeout = timeout self._accesslock = RLock() def get(self, key): return self[key]['value'] def cache(self, key, value): self[key] = { 'time' : time.time(), 'value' : value } def isObsolete(self, key): return (not self.has_key(key) or time.time() - self[key]['time'] > self._cacheTimeout) def invalidate(self, key): if self.has_key(key): return self.pop(key)['value'] def acquire(self): self._accesslock.acquire() def release(self): self._accesslock.release()
def __init__(self): Thread.__init__(self) self.positions = list() self.stopped = False self.startTime = time.time() self.timer = 0 self.counter = 0 self.total_uavs = 0 # Total number of UAVs in the air self.steps_counter = 0 self.turn_kill_counter = 0 self.writeState = Event() self.writeCounter = 0 self.readState = Event() self.readCounter = 0 self.lock = RLock() self.lock2 = RLock() try: self.readState.set() logging.info('Read state set.') except: logging.error('Read state not set.')
def __init__(self, ip, port): self.ip = ip self.port = port self.name = "http://" + str(ip) + ":" + str(port) self.hashid = getHash(self.name) self.server = RPCThreading(("", port), logRequests=False) # register functions here self.server.register_function(self.notify, "notify") self.server.register_function(self.getPred, "getPred") self.server.register_function(self.find, "find") self.server.register_function(self.findSuccessor, "findSuccessor") self.server.register_function(self.isAlive, "isAlive") self.server.register_function(self.alert, "alert") self.server.register_function(self.join, "join") self.server.register_function(self.create, "create") self.server.register_function(self.getSuccessorList, "getSuccessorList") self.server.register_function(self.getPredID, "getPredID") # finger[k] = successor of (n + 2**(k-1)) % mod MAX, 1 <= k <= HASHSIZE self.fingers = [None] * HASHSIZE # finger[k] = successor of (n + 2**(k-1)) % mod MAX, 1 <= k <= HASHSIZE self.next = 0 self.pred = self self.succ = self self.successorList = [self.name] * NUM_SUCCESSORS self.running = False self.myThread = None self.successorLock = Lock() self.runningLock = Lock() t = Thread(target=self.server.serve_forever) t.daemon = True t.start()
class DataSignaler(object): def __init__(self, name, pruneFunc, data): super(DataSignaler, self).__init__() assert isinstance(data,TreeFunctioned) self.data = data self.event_signaler = EventSignaler(key=name) if pruneFunc is not None: assert callable(pruneFunc) self.prune_func = pruneFunc self._lock = RLock() def add(self, value): self._lock.acquire() try: self.data.addToTreeByFunction(value) finally: self._lock.release() data = {self.event_signaler.key : {'data': self.data}} self.event_signaler.signalEvent(data) def prune(self): if self.prune_func is not None: return criticalSection(self._lock, lambda: self.prune_func(dataStructure=self.data)) def inByFunction(self, value, hashFuncList=None, depth=0): return criticalSection(self._lock, lambda: self.data.inByFunction(value, hashFuncList, depth)) def getOriginalByFunction(self, value, hashFuncList=None, depth=0): return criticalSection(self._lock, lambda: self.data.getOriginalByFunction(value, hashFuncList, depth))
class VM_Pool(object): def __init__(self, vm_map): self.proc_mgr = proc_mgmt.ProcMgr() self.vm_map = vm_map self.vm_rdy = {} self.init_map() self.pool_gate = RLock() def acquire(self, *names): self.pool_gate.acquire() for name in names: if self.vm_rdy.get(name): self.vm_rdy[name] = False return self.vm_map.get(name) self.pool_gate.release() return None def release(self, name): self.vm_rdy[name] = True def init_map(self): for name, vm_obj in self.vm_map.items(): self.vm_rdy[name] = True def __str__(self): string = 'Pool:' for vm in self.vm_map.keys(): string += vm + ": " + str(self.vm_rdy.get(vm)) + ", " return string
class Framer(Packer): HEADER="!4s4B" def __init__(self, sock): self.sock = sock self.sock_lock = RLock() self.tx_buf = "" self.rx_buf = "" self.security_layer_tx = None self.security_layer_rx = None self.maxbufsize = 65535 def aborted(self): return False def write(self, buf): self.tx_buf += buf def flush(self): self.sock_lock.acquire() try: if self.security_layer_tx: try: cipher_buf = self.security_layer_tx.encode(self.tx_buf) except SASLError, e: raise Closed(str(e)) self._write(cipher_buf) else:
def __init__(self, cache, store, logger, max_writer_threads=30): '''Max. throughput for files < 1MB is max_writer_threads * 100KB per second. :param max_writer_threads: Max. number of writer threads to use. ''' self.logger = logger self.stats = WorkerStats() self.cache = cache self.store = store self.max_writer_threads = max_writer_threads self.WRITE_TIMELIMIT = 60*60*2 #2h self.lock = RLock() self.protect_cache_from_write_access = RLock() #could also be normal lock self.oldest_modified_date = {} #keep track of modified date of a cache entry when it is first enqueued for upload. Their contents might change during upload. self.removers = [] self.writers = [] self.readers = [] self._stop = False self.thread = None self.last_reconnect = time.time() self._heartbeat = time.time() #used for waiting when quota errors occur self.skip_starting_new_writers_for_next_x_cycles = 0 self.do_profiling = False self.upload_process_pool = WriteWorkerProcesses(store, logger) self.logger.info("initialized StoreSyncThread")
def open_dynamic_queue(self): if self._disconnecting: self.logger.info("Connection factory disconnecting, aborting open_dynamic_queue") return else: self.logger.log(TRACE1, "open_dynamic_queue -> not disconnecting") if not self._is_connected: self.logger.log(TRACE1, "open_dynamic_queue -> _is_connected1 %s" % self._is_connected) self._connect() self.logger.log(TRACE1, "open_dynamic_queue -> _is_connected2 %s" % self._is_connected) dynamic_queue = self.mq.Queue(self.mgr, self.dynamic_queue_template, self.CMQC.MQOO_INPUT_SHARED) # A bit hackish, but there's no other way to get its name. dynamic_queue_name = dynamic_queue._Queue__qDesc.ObjectName.strip() lock = RLock() lock.acquire() try: self._open_dynamic_queues_cache[dynamic_queue_name] = dynamic_queue finally: lock.release() self.logger.log(TRACE1, "Successfully created a dynamic queue, descriptor [%s]" % ( dynamic_queue._Queue__qDesc)) return dynamic_queue_name
def close_dynamic_queue(self, dynamic_queue_name): if self._disconnecting: self.logger.info("Connection factory disconnecting, aborting close_dynamic_queue") return else: self.logger.log(TRACE1, "close_dynamic_queue -> not disconnecting") if not self._is_connected: # If we're not connected then all dynamic queues had been already closed. self.logger.log(TRACE1, "close_dynamic_queue -> _is_connected1 %s" % self._is_connected) return else: self.logger.log(TRACE1, "close_dynamic_queue -> _is_connected2 %s" % self._is_connected) lock = RLock() lock.acquire() try: dynamic_queue = self._open_dynamic_queues_cache[dynamic_queue_name] dynamic_queue.close() self._open_dynamic_queues_cache.pop(dynamic_queue_name, None) self._open_send_queues_cache.pop(dynamic_queue_name, None) self._open_receive_queues_cache.pop(dynamic_queue_name, None) self.logger.log(TRACE1, "Successfully closed a dynamic queue [%s]" % ( dynamic_queue_name)) finally: lock.release()
class Main(HTTPServlet): registerShutdown = 1 def __init__(self): HTTPServlet.__init__(self) self.blogDirectory = WeblogDirectory("../blogs.xml") self.mutex = RLock() def awake(self, transaction): # Register our shutdown handler if it hasn't already been done. This is to # make sure the databases are properly closed when the system is shutdown. self.mutex.acquire() try: if (Main.registerShutdown == 1): transaction.application().addShutDownHandler(self.blogDirectory.shutdown) Main.registerShutdown = 0 finally: self.mutex.release() def respondToGet(self, transaction): request = transaction.request() response = transaction.response() pathInfo = request.extraURLPath() try: (blog, pathInfo) = self._parsePathInfo(pathInfo) weblog = self.blogDirectory.getBlog(blog) try: stylesheet = request.field('t', "") # Extra optional argument that can be passed to the stylesheet arg = request.field('a', "") # Content query that can be applied as a final step to extract # something from the rendered content contentQuery = request.field('c', "") result = weblog.handleRequest(pathInfo, stylesheet, arg, contentQuery) # Determine the content-type for the result if (result.startswith("<?xml")): contentType = "text/xml" elif (result.startswith("<html")): contentType = "text/html" else: contentType = "text/plain" #print result response.setStatus(200, 'OK') response.setHeader('Content-type', contentType) response.setHeader('Content-length', str(len(result))) response.write(result) except NotFoundError: response.setStatus(404, 'Not Found') except KeyError, IndexError: response.setStatus(404, 'Weblog Not Found')
class ScrollableHandler(StreamHandlerNoLF): """ ScrollableHandler is a StreamHandler that specially handles scrolling (log messages at the SCROLL level). It allows you to temporarily interrupt the constant scroll with other log messages of different levels (printed at the top of the scroll area) """ # the SCROLL level (a class var) LOGFILE = 11 SCROLL = 12 SHUTDOWN = 13 NOLOGFILE = 14 def __init__(self, *args, **kwargs): self.scrollLock = RLock() self.scrollFlag = False StreamHandlerNoLF.__init__(self, *args, **kwargs) def handle(self, record): """ The 'scroll' level is a constant scroll that can be interrupted. This interruption is done via prepending text to the scroll area """ rv = self.filter(record) if rv: if record.levelno == ScrollableHandler.SCROLL: self.emitSynchronized(record) elif record.levelno == ScrollableHandler.SHUTDOWN: record.msg = '\n\n\n%s\n' % record.msg self.emitSynchronized(record) else: self.scrollLock.acquire() # If scroll is on, interrupt scroll if ScrollableHandler.scrollFlag: self.scrollHeader(record) else: # otherwise if scroll isn't on, just log the message normally self.emitSynchronized(record) self.scrollLock.release() return rv def emitSynchronized(self, record): """ Write a log message atomically. Normal python logging Handler behavior """ self.acquire() try: self.emit(record) finally: self.release() def scrollHeader(self, record): """ Print a log message so that the user can see it during a SCROLL """ msg = self.format(record).rstrip() # Scroller appends newline for us from twisted.internet import reactor if inMainThread(): # FIXME: scrollBegin() should really be creating the scroller instance # FIXME: no unicode crap from normal python log emit Hellanzb.scroller.scrollHeader(msg) else: reactor.callFromThread(Hellanzb.scroller.scrollHeader, msg)
def _threadCallback(self,thread): """ A callback function which gets called when a code thread terminates. """ lock = RLock() lock.acquire() if thread.failed(): self._exceptions[thread._id] = thread.exceptionInfo() self._tracebacks[thread._id] = thread.tracebackInfo() lock.release()
def exit(self): global command_output_thread print("Exiting thread {0}...".format(self)) lock = RLock() lock.acquire() self.EXIT_FLAG = True pgid = self.get_pgid(True) if pgid is not None: call(["ionice", "-c", "0", "-P", str(self.get_pgid(True))]) lock.release()
class Chopstick: def __init__(self, name): self.lock = RLock() self.name = name def pickUp(self): return self.lock.acquire(blocking=False) def putDown(self): self.lock.release()
class MonitorLock(object): def __init__(self): self.lock = RLock() def acquire(self, flag=True): self.lock.acquire() def release(self): self.lock.release() def MONITOR_ENTER(self): self.acquire() def MONITOR_EXIT(self): self.release()
class ThreadSafeDict(dict) : def __init__(self, * p_arg, ** n_arg) : dict.__init__(self, * p_arg, ** n_arg) self._lock = RLock() def __enter__(self) : self._lock.acquire() return self def __exit__(self, type, value, traceback) : self._lock.release()
class Client(KRPC): def __init__(self, table): self.table = table self.lock = RLock() timer(KRPC_TIMEOUT, self.timeout) KRPC.__init__(self) def find_node(self, address, nid=None): nid = self.get_neighbor(nid) if nid else self.table.nid tid = entropy(TID_LENGTH) msg = { "t": tid, "y": "q", "q": "find_node", "a": {"id": nid, "target": random_id()} } self.send_krpc(msg, address) def bootstrap(self): for address in BOOTSTRAP_NODES: self.find_node(address) def timeout(self): if not self.join_successed: self.bootstrap() timer(KRPC_TIMEOUT, self.timeout) def run(self): self.bootstrap() while 1: time.sleep(.001) try: data, address = self.ufd.recvfrom(65536) msg = bdecode(data) self.types[msg["y"]](msg, address) except Exception: pass def foreverloop(self): self.start() while 1: time.sleep(.001) if not self.table.nodes: self.join_successed = False time.sleep(1) continue for node in self.table.nodes: self.find_node((node.ip, node.port), node.nid) self.lock.acquire() self.table.nodes = [] self.lock.release()
def __init__(self, name=""): self.name = name self.readers = 0 self.reader_stacks = [] self.lock = RLock() self.reader_lock = RLock() self.writer_stacks = [] self.writer_id = 0 alllocks.append(self)
class Counter: def __init__(self, start=0, increment=1): self.counter = start self.increment = increment self.lock = RLock() def __call__(self): self.lock.acquire() self.counter += self.increment i = self.counter self.lock.release() return i
class SynchronizedContainer: def __init__(self, obj): self._o = obj self._lock = RLock() def __enter__(self): if self._lock.__enter__(): return self._o def __exit__(self, t, v, tb): self._lock.__exit__(t, v, tb) def __call__(self, *a, **kw): with self as sfnc: return sfnc(*a, **kw)
class NoDispersyRLock(): def __init__(self): self.lock = RLock() @warnDisperyThread def acquire(self, blocking=1): return self.lock.acquire(blocking) @warnDisperyThread def release(self): return self.lock.release()
def wrapper(self, *args, **kwargs): retval = getattr(self, attr, None) if retval is None: retval = fn(self, *args, **kwargs) _lock = RLock() try: _lock.acquire() setattr(self, attr, retval) finally: _lock.release() return retval
def __init__(self): self._msg_queue_lock = RLock() self._users_lock = RLock() self.msg_queue = {} self.bootstrap() self._dying = False Thread.__init__(self) self.daemon = True self.start() self.users = {} self.tags2user = {} self.tags2msg = {}
class WPApp(object): Version = "Undefined" MIME_TYPES_BASE = { "gif": "image/gif", "jpg": "image/jpeg", "jpeg": "image/jpeg", "js": "text/javascript", "html": "text/html", "txt": "text/plain", "css": "text/css" } def __init__(self, root_class, strict=False, static_path="/static", static_location=None, enable_static=False, prefix=None, replace_prefix=None, disable_robots=True): if not isinstance(root_class, type) and callable(root_class): # if it's in fact a function, use LambdaHandlerFactory to wrap # the function into a LambdaHandler root_class = LambdaHandlerFactory(root_class) enable_static = enable_static or (static_location is not None) if static_location is None: static_location = "./static" self.StaticPath = static_path self.StaticLocation = static_location #print("App init: StaticLocation:", static_location) self.StaticEnabled = enable_static and static_location self.RootClass = root_class self.JEnv = None self._AppLock = RLock() self.ScriptHome = None self.Initialized = False self.DisableRobots = disable_robots self.Prefix = prefix self.ReplacePrefix = replace_prefix def _app_lock(self): return self._AppLock def __enter__(self): return self._AppLock.__enter__() def __exit__(self, *params): return self._AppLock.__exit__(*params) # override @app_synchronized def acceptIncomingTransfer(self, method, uri, headers): return True @app_synchronized def initJinjaEnvironment(self, tempdirs=[], filters={}, globals={}): # to be called by subclass #print "initJinja2(%s)" % (tempdirs,) from jinja2 import Environment, FileSystemLoader if not isinstance(tempdirs, list): tempdirs = [tempdirs] self.JEnv = Environment(loader=FileSystemLoader(tempdirs)) for n, f in filters.items(): self.JEnv.filters[n] = f self.JGlobals = {} self.JGlobals.update(globals) @app_synchronized def setJinjaFilters(self, filters): for n, f in filters.items(): self.JEnv.filters[n] = f @app_synchronized def setJinjaGlobals(self, globals): self.JGlobals = {} self.JGlobals.update(globals) def applicationErrorResponse(self, headline, exc_info): typ, val, tb = exc_info exc_text = traceback.format_exception(typ, val, tb) exc_text = ''.join(exc_text) text = """<html><body><h2>Application error</h2> <h3>%s</h3> <pre>%s</pre> </body> </html>""" % (headline, exc_text) #print exc_text return Response(text, status='500 Application Error') def static(self, relpath): #print("WPApp.static: relpath:", relpath) while ".." in relpath: relpath = relpath.replace("..", ".") home = self.StaticLocation #print("WPApp.static: home:", home) path = os.path.join(home, relpath) #print ("static: path:", path) try: st_mode = os.stat(path).st_mode if not stat.S_ISREG(st_mode): #print "not a regular file" raise ValueError("Not regular file") except: raise return Response("Not found", status=404) ext = path.rsplit('.', 1)[-1] mime_type = self.MIME_TYPES_BASE.get(ext, "text/html") def read_iter(f): while True: data = f.read(100000) if not data: break yield data #print "returning response..." return Response(app_iter=read_iter(open(path, "rb")), content_type=mime_type) def convertPath(self, path): if self.Prefix is not None: matched = "" ok = False if path == self.Prefix: matched = path ok = True elif path.startswith(self.Prefix + '/'): matched = self.Prefix ok = True if not ok: return None if self.ReplacePrefix is not None: path = self.ReplacePrefix + (path[len(matched):] or "/") return path def __call__(self, environ, start_response): #print 'app call ...' path = environ.get('PATH_INFO', '') environ["WebPie.original_path"] = path #print 'path:', path_down path = self.convertPath(path) if path is None: return HTTPNotFound()(environ, start_response) environ["PATH_INFO"] = path req = Request(environ) if not self.Initialized: self.ScriptName = environ.get('SCRIPT_NAME', '') self.Script = environ.get('SCRIPT_FILENAME', os.environ.get('UWSGI_SCRIPT_FILENAME')) self.ScriptHome = os.path.dirname(self.Script or sys.argv[0]) or "." if self.StaticEnabled: if not self.StaticLocation[0] in ('.', '/'): self.StaticLocation = self.ScriptHome + "/" + self.StaticLocation #print "static location:", self.StaticLocation self.Initialized = True if self.StaticEnabled and path.startswith(self.StaticPath + "/"): resp = self.static(path[len(self.StaticPath) + 1:]) elif self.DisableRobots and path.endswith("/robots.txt"): resp = Response("User-agent: *\nDisallow: /\n", content_type="text/plain") else: root = self.RootClass(req, self) try: return root.wsgi_call(environ, start_response) except: resp = self.applicationErrorResponse("Uncaught exception", sys.exc_info()) return resp(environ, start_response) def jinja_globals(self): # override me return {} def add_globals(self, d): params = {} params.update(self.JGlobals) params.update(self.jinja_globals()) params.update(d) return params def render_to_string(self, temp, **kv): t = self.JEnv.get_template(temp) return t.render(self.add_globals(kv)) def render_to_iterator(self, temp, **kv): t = self.JEnv.get_template(temp) return t.generate(self.add_globals(kv)) def run_server(self, port, **args): from .HTTPServer import HTTPServer srv = HTTPServer(port, self, **args) srv.start() srv.join()
class Query2HitsMap: def __init__(self): self.lock = RLock() self.d = {} def add_query(self, id, searchstr, timestamp): if DEBUG: print >> sys.stderr, 'q2h: lock1', id self.lock.acquire() try: qrec = self.d.get(id, {}) qrec['searchstr'] = searchstr qrec['timestamp'] = timestamp qrec['hitlist'] = {} self.d[id] = qrec finally: if DEBUG: print >> sys.stderr, 'q2h: unlock1' self.lock.release() def add_hits(self, id, hits): if DEBUG: print >> sys.stderr, 'q2h: lock2', id, len(hits) self.lock.acquire() try: qrec = self.d[id] qrec['hitlist'].update(hits) finally: if DEBUG: print >> sys.stderr, 'q2h: unlock2' self.lock.release() def get_hits(self, id): if DEBUG: print >> sys.stderr, 'q2h: lock3', id self.lock.acquire() try: qrec = self.d[id] return copy.copy(qrec['hitlist']) finally: if DEBUG: print >> sys.stderr, 'q2h: unlock3' self.lock.release() def get_searchstr(self, id): if DEBUG: print >> sys.stderr, 'q2h: lock4' self.lock.acquire() try: qrec = self.d[id] return qrec['searchstr'] finally: if DEBUG: print >> sys.stderr, 'q2h: unlock4' self.lock.release() def garbage_collect_timestamp_smaller(self, timethres): self.lock.acquire() try: idlist = [] for id, qrec in self.d.iteritems(): if qrec['timestamp'] < timethres: idlist.append(id) for id in idlist: del self.d[id] finally: self.lock.release()
def __init__(self, *args, **kwargs): self.socket_list = set() self.send_queue = Queue(0) self.received_queue = Queue(0) self.sockets_lock = RLock()
def __init__(self, my_node_id): self.my_node_id = my_node_id self.trie = Trie(u'01') self.trie[u''] = Bucket(u'') self.lock = RLock()
class WebcamForwarder(StubClientMixin): __signals__ = ["webcam-changed"] def __init__(self): StubClientMixin.__init__(self) #webcam: self.webcam_option = "" self.webcam_forwarding = False self.webcam_device = None self.webcam_device_no = -1 self.webcam_last_ack = -1 self.webcam_ack_check_timer = None self.webcam_send_timer = None self.webcam_lock = RLock() self.server_webcam = False self.server_virtual_video_devices = 0 if not hasattr(self, "send"): self.send = self.noop def noop(self, *_args): pass def cleanup(self): self.stop_sending_webcam() def init(self, opts, _extra_args=[]): self.webcam_option = opts.webcam self.webcam_forwarding = self.webcam_option.lower( ) not in FALSE_OPTIONS self.server_webcam = False self.server_virtual_video_devices = 0 if self.webcam_forwarding: with OSEnvContext(): os.environ["LANG"] = "C" os.environ["LC_ALL"] = "C" try: import cv2 from PIL import Image assert cv2 and Image except ImportError as e: log("init webcam failure", exc_info=True) if WIN32 and BITS == 32: log.info( "32-bit builds do not support webcam forwarding") else: log.warn("Warning: failed to import opencv:") log.warn(" %s", e) log.warn(" webcam forwarding is disabled") self.webcam_forwarding = False log("webcam forwarding: %s", self.webcam_forwarding) def parse_server_capabilities(self): c = self.server_capabilities self.server_webcam = c.boolget("webcam") self.server_webcam_encodings = c.strlistget("webcam.encodings", ("png", "jpeg")) self.server_virtual_video_devices = c.intget("virtual-video-devices") log("webcam server support: %s (%i devices, encodings: %s)", self.server_webcam, self.server_virtual_video_devices, csv(self.server_webcam_encodings)) if self.webcam_forwarding and self.server_webcam and self.server_virtual_video_devices > 0: if self.webcam_option == "on" or self.webcam_option.find( "/dev/video") >= 0: self.start_sending_webcam() return True def webcam_state_changed(self): self.idle_add(self.emit, "webcam-changed") ###################################################################### def start_sending_webcam(self): with self.webcam_lock: self.do_start_sending_webcam(self.webcam_option) def do_start_sending_webcam(self, device_str): assert self.server_webcam device = 0 virt_devices, all_video_devices, non_virtual = {}, {}, {} try: from xpra.platform.webcam import get_virtual_video_devices, get_all_video_devices virt_devices = get_virtual_video_devices() all_video_devices = get_all_video_devices() non_virtual = dict([(k, v) for k, v in all_video_devices.items() if k not in virt_devices]) log("virtual video devices=%s", virt_devices) log("all_video_devices=%s", all_video_devices) log("found %s known non-virtual video devices: %s", len(non_virtual), non_virtual) except ImportError as e: log("no webcam_util: %s", e) log("do_start_sending_webcam(%s)", device_str) if device_str in ("auto", "on", "yes", "off", "false", "true"): if len(non_virtual) > 0: device = tuple(non_virtual.keys())[0] else: log("device_str: %s", device_str) try: device = int(device_str) except: p = device_str.find("video") if p >= 0: try: log("device_str: %s", device_str[p:]) device = int(device_str[p + len("video"):]) except: device = 0 if device in virt_devices: log.warn("Warning: video device %s is a virtual device", virt_devices.get(device, device)) if WEBCAM_ALLOW_VIRTUAL: log.warn(" environment override - this may hang..") else: log.warn(" corwardly refusing to use it") log.warn(" set WEBCAM_ALLOW_VIRTUAL=1 to force enable it") return import cv2 log("do_start_sending_webcam(%s) device=%i", device_str, device) self.webcam_frame_no = 0 try: #test capture: webcam_device = cv2.VideoCapture(device) #0 -> /dev/video0 ret, frame = webcam_device.read() log("test capture using %s: %s, %s", webcam_device, ret, frame is not None) assert ret, "no device or permission" assert frame is not None, "no data" assert frame.ndim == 3, "unexpected number of dimensions: %s" % frame.ndim w, h, Bpp = frame.shape assert Bpp == 3, "unexpected number of bytes per pixel: %s" % Bpp assert frame.size == w * h * Bpp self.webcam_device_no = device self.webcam_device = webcam_device self.send("webcam-start", device, w, h) self.webcam_state_changed() log("webcam started") if self.send_webcam_frame(): delay = 1000 // WEBCAM_TARGET_FPS log("webcam timer with delay=%ims for %i fps target)", delay, WEBCAM_TARGET_FPS) self.cancel_webcam_send_timer() self.webcam_send_timer = self.timeout_add( delay, self.may_send_webcam_frame) except Exception as e: log.warn("webcam test capture failed: %s", e) def cancel_webcam_send_timer(self): wst = self.webcam_send_timer if wst: self.webcam_send_timer = None self.source_remove(wst) def cancel_webcam_check_ack_timer(self): wact = self.webcam_ack_check_timer if wact: self.webcam_ack_check_timer = None self.source_remove(wact) def webcam_check_acks(self, ack=0): self.webcam_ack_check_timer = None log("check_acks: webcam_last_ack=%s", self.webcam_last_ack) if self.webcam_last_ack < ack: log.warn( "Warning: no acknowledgements received from the server for frame %i, stopping webcam", ack) self.stop_sending_webcam() def stop_sending_webcam(self): log("stop_sending_webcam()") with self.webcam_lock: self.do_stop_sending_webcam() def do_stop_sending_webcam(self): self.cancel_webcam_send_timer() self.cancel_webcam_check_ack_timer() wd = self.webcam_device log("do_stop_sending_webcam() device=%s", wd) if not wd: return self.send("webcam-stop", self.webcam_device_no) assert self.server_webcam self.webcam_device = None self.webcam_device_no = -1 self.webcam_frame_no = 0 self.webcam_last_ack = -1 try: wd.release() except Exception as e: log.error("Error closing webcam device %s: %s", wd, e) self.webcam_state_changed() def may_send_webcam_frame(self): self.webcam_send_timer = None if self.webcam_device_no < 0 or not self.webcam_device: return False not_acked = self.webcam_frame_no - 1 - self.webcam_last_ack #not all frames have been acked latency = 100 if len(self.server_ping_latency) > 0: l = [x for _, x in tuple(self.server_ping_latency)] latency = int(1000 * sum(l) / len(l)) #how many frames should be in flight n = max( 1, latency // (1000 // WEBCAM_TARGET_FPS)) #20fps -> 50ms target between frames if not_acked > 0 and not_acked > n: log( "may_send_webcam_frame() latency=%i, not acked=%i, target=%i - will wait for next ack", latency, not_acked, n) return False log( "may_send_webcam_frame() latency=%i, not acked=%i, target=%i - trying to send now", latency, not_acked, n) return self.send_webcam_frame() def send_webcam_frame(self): if not self.webcam_lock.acquire(False): return False log("send_webcam_frame() webcam_device=%s", self.webcam_device) try: assert self.webcam_device_no >= 0, "device number is not set" assert self.webcam_device, "no webcam device to capture from" from xpra.codecs.pillow.encode import get_encodings client_webcam_encodings = get_encodings() common_encodings = list( set(self.server_webcam_encodings).intersection( client_webcam_encodings)) log("common encodings (server=%s, client=%s): %s", csv(self.server_encodings), csv(client_webcam_encodings), csv(common_encodings)) if not common_encodings: log.error("Error: cannot send webcam image, no common formats") log.error(" the server supports: %s", csv(self.server_webcam_encodings)) log.error(" the client supports: %s", csv(client_webcam_encodings)) self.stop_sending_webcam() return False preferred_order = ["jpeg", "png", "png/L", "png/P", "webp"] formats = [x for x in preferred_order if x in common_encodings ] + common_encodings encoding = formats[0] start = monotonic_time() import cv2 ret, frame = self.webcam_device.read() assert ret, "capture failed" assert frame.ndim == 3, "invalid frame data" h, w, Bpp = frame.shape assert Bpp == 3 and frame.size == w * h * Bpp rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) end = monotonic_time() log("webcam frame capture took %ims", (end - start) * 1000) start = monotonic_time() from PIL import Image image = Image.fromarray(rgb) buf = BytesIOClass() image.save(buf, format=encoding) data = buf.getvalue() buf.close() end = monotonic_time() log("webcam frame compression to %s took %ims", encoding, (end - start) * 1000) frame_no = self.webcam_frame_no self.webcam_frame_no += 1 self.send("webcam-frame", self.webcam_device_no, frame_no, encoding, w, h, compression.Compressed(encoding, data)) self.cancel_webcam_check_ack_timer() self.webcam_ack_check_timer = self.timeout_add( 10 * 1000, self.webcam_check_acks) return True except Exception as e: log.error("webcam frame %i failed", self.webcam_frame_no, exc_info=True) log.error("Error sending webcam frame: %s", e) self.stop_sending_webcam() summary = "Webcam forwarding has failed" body = "The system encountered the following error:\n" + \ ("%s\n" % e) self.may_notify(XPRA_WEBCAM_NOTIFICATION_ID, summary, body, expire_timeout=10 * 1000, icon_name="webcam") return False finally: self.webcam_lock.release() ###################################################################### #packet handlers def _process_webcam_stop(self, packet): device_no = packet[1] if device_no != self.webcam_device_no: return self.stop_sending_webcam() def _process_webcam_ack(self, packet): log("process_webcam_ack: %s", packet) with self.webcam_lock: if self.webcam_device: frame_no = packet[2] self.webcam_last_ack = frame_no if self.may_send_webcam_frame(): self.cancel_webcam_send_timer() delay = 1000 // WEBCAM_TARGET_FPS log("new webcam timer with delay=%ims for %i fps target)", delay, WEBCAM_TARGET_FPS) self.webcam_send_timer = self.timeout_add( delay, self.may_send_webcam_frame) def init_authenticated_packet_handlers(self): log("init_authenticated_packet_handlers()") self.set_packet_handlers( self._ui_packet_handlers, { "webcam-stop": self._process_webcam_stop, "webcam-ack": self._process_webcam_ack, })
def __init__(self): self.time = 0 self.lock = RLock()
def __init__(self, parent): self.parent = parent self.is_disposed = False self.lock = RLock()
from functools import partial from hashlib import sha1 from threading import Lock, RLock from calibre.constants import cache_dir, iswindows from calibre.customize.ui import plugin_for_input_format from calibre.srv.errors import BookNotFound, HTTPNotFound from calibre.srv.metadata import book_as_json from calibre.srv.render_book import RENDER_VERSION from calibre.srv.routes import endpoint, json from calibre.srv.utils import get_db, get_library_data from calibre.utils.filenames import rmtree from calibre.utils.serialize import json_dumps from polyglot.builtins import as_unicode, itervalues cache_lock = RLock() queued_jobs = {} failed_jobs = {} def abspath(x): x = os.path.abspath(x) if iswindows and not x.startswith('\\\\?\\'): x = '\\\\?\\' + os.path.abspath(x) return x _books_cache_dir = None def books_cache_dir():
class Session: def __init__(self, io): self._io = io self._mutex = RLock() self.isclosed = False self.handler = Handler self.onopen = lambda session: None self.onclose = lambda session: None # Call a function def call(self, fid, *args): self.invoke(MSG_CALL, fid, args) return self._wait_return() def notify(self, fid, *args): self.invoke(MSG_NOTIFY, fid, args) def invoke(self, t, fid, args): self._mutex.acquire() self._pack = [t, fid, *args] b = self._send_pack() self._mutex.release() self._lastfid = fid return b def close(self): self._mutex.acquire() self._pack = [MSG_CLOSE] b = self._send_pack() self._mutex.release() self._io.close() self._closed = True return b def _return(self, v, t=MSG_RETVAL): self._mutex.acquire() self._pack = [t, v] b = self._send_pack() self._mutex.release() return b # Return a value def run(self): self.onopen(self) while self._recv_pack(): self._handle_invoke() if self.isclosed: break self.onclose(self) def _recv_pack(self): if self.isclosed: return False try: self._pack = msgpack.unpack(self._io) return True except msgpack.UnpackException as e: return False except Exception as e: print("Receive package failure", e) return False def _send_pack(self): if self.isclosed: return False try: msgpack.pack(self._pack, self._io) self._io.flush() return True except Exception as e: # print("Send package failure", e) return False def _type(self): return self._pack[0] # Wait a value from subprocess def _wait_return(self): while self._recv_pack(): t = self._type() if t & 0xF0 == MSG_INVOKE: self._handle_invoke() # handle invoke elif t == MSG_RETVAL: pack = self._pack return pack[1:] if len(pack) > 2 else pack[1] elif t == MSG_NOFUNC: raise Exception('No such function: ' + self._lastfid) else: raise Exception('Unkown flag') # Handle a invoke def _handle_invoke(self): t = self._type() assert t & 0xF0 == MSG_INVOKE if t == MSG_CLOSE: self.isclosed = True else: pack = self._pack fid = pack[1] ret = None try: fun = vars(self.handler).get(fid) if fun: ret = fun(self, *pack[2:]) elif self._type() == MSG_CALL: return self._return(None, MSG_NOFUNC) except Exception as e: print('Throwed a exception during:', fid, e) ret = None except TypeError as e: print('Args\'s number not matched:', fid, e) finally: if t == MSG_CALL: self._return(ret)
def __init__(self, maxsize=10, dispose_func=None): self._maxsize = maxsize self.dispose_func = dispose_func self._container = self.ContainerCls() self.lock = RLock()
def init_process(self): self.tpool = futures.ThreadPoolExecutor(max_workers=self.cfg.threads) self.poller = selectors.DefaultSelector() self._lock = RLock() super(ThreadWorker, self).init_process()
class WindowsBalloonTip(object): ''' Implementation of balloon tip notifications through Windows API. * Register Window class name: https://msdn.microsoft.com/en-us/library/windows/desktop/ms632596.aspx * Create an overlapped window using the registered class. - It's hidden everywhere in GUI unless ShowWindow(handle, SW_SHOW) function is called. * Show/remove a tray icon and a balloon tip notification. Each instance is a separate notification with different parameters. Can be used with Threads. ''' _class_atom = 0 _wnd_class_ex = None _hwnd = None _hicon = None _balloon_icon = None _notify_data = None _count = 0 _lock = RLock() @staticmethod def _get_unique_id(): ''' Keep track of each created balloon tip notification names, so that they can be easily identified even from outside. Make sure the count is shared between all the instances i.e. use a lock, so that _count class variable is incremented safely when using balloon tip notifications with Threads. ''' WindowsBalloonTip._lock.acquire() val = WindowsBalloonTip._count WindowsBalloonTip._count += 1 WindowsBalloonTip._lock.release() return val def __init__(self, title, message, app_name, app_icon='', timeout=10, **kwargs): # pylint: disable=unused-argument,too-many-arguments ''' The app_icon parameter, if given, is an .ICO file. ''' wnd_class_ex = win_api_defs.get_WNDCLASSEXW() class_name = 'PlyerTaskbar' + str(WindowsBalloonTip._get_unique_id()) if PY2: class_name = class_name.decode('utf8') wnd_class_ex.lpszClassName = class_name # keep ref to it as long as window is alive wnd_class_ex.lpfnWndProc = win_api_defs.WindowProc( win_api_defs.DefWindowProcW) wnd_class_ex.hInstance = win_api_defs.GetModuleHandleW(None) if wnd_class_ex.hInstance is None: raise Exception('Could not get windows module instance.') class_atom = win_api_defs.RegisterClassExW(wnd_class_ex) if class_atom == 0: raise Exception('Could not register the PlyerTaskbar class.') self._class_atom = class_atom self._wnd_class_ex = wnd_class_ex # create window self._hwnd = win_api_defs.CreateWindowExW( # dwExStyle, lpClassName, lpWindowName, dwStyle 0, class_atom, '', WS_OVERLAPPED, # x, y, nWidth, nHeight 0, 0, CW_USEDEFAULT, CW_USEDEFAULT, # hWndParent, hMenu, hInstance, lpParam None, None, wnd_class_ex.hInstance, None) if self._hwnd is None: raise Exception('Could not get create window.') win_api_defs.UpdateWindow(self._hwnd) # load .ICO file for as balloon tip and tray icon if app_icon: icon_flags = LR_LOADFROMFILE | LR_DEFAULTSIZE hicon = win_api_defs.LoadImageW(None, app_icon, IMAGE_ICON, 0, 0, icon_flags) if hicon is None: raise Exception('Could not load icon {}'.format(app_icon)) self._balloon_icon = self._hicon = hicon else: self._hicon = win_api_defs.LoadIconW( None, ctypes.cast(IDI_APPLICATION, win_api_defs.LPCWSTR)) # show the notification self.notify(title, message, app_name) if timeout: time.sleep(timeout) def __del__(self): ''' Clean visible parts of the notification object, then free all resources allocated for creating the nofitication Window and icon. ''' self.remove_notify() if self._hicon is not None: win_api_defs.DestroyIcon(self._hicon) if self._wnd_class_ex is not None: win_api_defs.UnregisterClassW(self._class_atom, self._wnd_class_ex.hInstance) if self._hwnd is not None: win_api_defs.DestroyWindow(self._hwnd) def notify(self, title, message, app_name): ''' Displays a balloon in the systray. Can be called multiple times with different parameter values. ''' # remove previous visible balloon tip nofitication if available self.remove_notify() # add icon and messages to window hicon = self._hicon flags = NIF_TIP | NIF_INFO icon_flag = 0 if hicon is not None: flags |= NIF_ICON # if icon is default app's one, don't display it in message if self._balloon_icon is not None: icon_flag = NIIF_USER | NIIF_LARGE_ICON notify_data = win_api_defs.get_NOTIFYICONDATAW( 0, self._hwnd, id(self), flags, 0, hicon, app_name, 0, 0, message, NOTIFYICON_VERSION_4, title, icon_flag, win_api_defs.GUID(), self._balloon_icon) self._notify_data = notify_data if not win_api_defs.Shell_NotifyIconW(NIM_ADD, notify_data): raise Exception('Shell_NotifyIconW failed.') if not win_api_defs.Shell_NotifyIconW(NIM_SETVERSION, notify_data): raise Exception('Shell_NotifyIconW failed.') def remove_notify(self): ''' Removes the notify balloon, if displayed. ''' if self._notify_data is not None: win_api_defs.Shell_NotifyIconW(NIM_DELETE, self._notify_data) self._notify_data = None
def __init__(self, keep_time=10): super(TimedCache, self).__init__() self._lock = RLock() self._cache = {} self._keep_time = keep_time # time in seconds before purging blocks
# coding: utf-8 import threading import os from multiprocessing.pool import ThreadPool from threading import RLock from src.job.job import LogType from src.frp.frp import frp import traceback from src.job.remote_script_job import RemoteScriptJob from src.utils.quick import run_all_arm log_lock = RLock() def deploy(park_list): all_conns = { k: v for k, v in {x: frp.get_conn_info(x) for x in park_list}.items() if v is not None } all_conns = all_conns.values() all_conns.reverse() pool = ThreadPool(100) pool.map(_handle_one_park, all_conns) pool.close() pool.join()
class Program(QtWidgets.QApplication, Logger): PAGE_SIZE = 100 BUG_PAGE = "https://github.com/seanegoodwin/pandaviewer/issues" THUMB_DIR = Utils.convert_from_relative_lsv_path("thumbs") QML_PATH = Utils.convert_from_relative_path("qml/") MAX_TAG_RETURN_COUNT = 5 gallery_lock = RLock() class SortMethodMap(Enum): NameSort = "sort_name" ReadCountSort = "read_count" LastReadSort = "last_read" RatingSort = "sort_rating" DateAddedSort = "time_added" FilePathSort = "sort_path" def __init__(self, args): self.addLibraryPath(Utils.convert_from_relative_path()) super().__init__(args) self.setOrganizationName("PV") self.setOrganizationDomain(self.BUG_PAGE) self.setApplicationName("PandaViewer") self.tags = [] # type: List[str] self.pages = [[]] # type: List[List[GenericGallery]] self.galleries = [] # type: List[GenericGallery] self.removed_galleries = [] # type: List[GenericGallery] self.version = "0.1" # Most likely used for db changes only self.page_number = 0 self.search_text = "" def setup(self): if not os.path.exists(self.THUMB_DIR): os.makedirs(self.THUMB_DIR) user_database.setup() self.qml_engine = QtQml.QQmlApplicationEngine() self.qml_engine.addImportPath(self.QML_PATH) # self.qml_engine.addPluginPath(self.QML_PATH) self.setAttribute(QtCore.Qt.AA_UseOpenGLES, True) self.qml_engine.load(os.path.join(self.QML_PATH, "main.qml")) self.app_window = self.qml_engine.rootObjects()[0] self.app_window.updateGalleryRating.connect(self.update_gallery_rating) self.app_window.askForTags.connect(self.get_tags_from_search) self.app_window.saveSettings.connect(self.update_config) self.app_window.setSortMethod.connect(self.set_sorting) self.app_window.setSearchText.connect(self.update_search) self.app_window.pageChange.connect(self.switch_page) self.app_window.scanGalleries.connect(self.find_galleries) self.app_window.openGallery.connect(self.open_gallery) self.app_window.openGalleryFolder.connect(self.open_gallery_folder) self.app_window.metadataSearch.connect(self.get_metadata) self.app_window.removeGallery.connect(self.remove_gallery_by_uuid) self.app_window.openOnEx.connect(self.open_on_ex) self.app_window.saveGallery.connect(self.save_gallery_customization) self.app_window.searchForDuplicates.connect(self.remove_duplicates) self.app_window.closedUI.connect(self.close) self.app_window.getDetailedGallery.connect(self.get_detailed_gallery) self.app_window.getGalleryImageFolder.connect( self.get_gallery_image_folder) self.app_window.setGalleryImage.connect(self.set_gallery_image) self.app_window.setUISort.emit(Config.sort_type, 1 if Config.sort_mode_reversed else 0) self.completer_line = QtWidgets.QLineEdit() self.completer_line.hide() self.setup_completer() self.setWindowIcon( QtGui.QIcon(Utils.convert_from_relative_path("icon.ico"))) self.set_ui_config() self.app_window.show() def setup_completer(self): self.completer = QtWidgets.QCompleter(self.tags) self.completer.setModelSorting( self.completer.CaseInsensitivelySortedModel) self.completer.setCaseSensitivity(QtCore.Qt.CaseInsensitive) self.completer_line.setCompleter(self.completer) def set_sorting(self, sort_type, reversed): Config.sort_type = sort_type Config.sort_mode_reversed = reversed Config.save() self.sort() self.search() def update_search(self, search_text: str): self.search_text = search_text self.search() def set_ui_gallery(self, gallery: GenericGallery): self.app_window.setGallery.emit(gallery.ui_uuid, gallery.get_json()) def remove_gallery_by_uuid(self, uuid: str): gallery = self.get_gallery_by_ui_uuid(uuid) gallery.mark_for_deletion() # Also removes self.setup_tags() def get_detailed_gallery(self, uuid: str): self.app_window.openDetailedGallery.emit( self.get_gallery_by_ui_uuid(uuid).get_detailed_json()) def get_tags_from_search(self, search: str): self.completer_line.setText(search) self.completer.setCompletionPrefix(search) tags = [] for i in range(self.completer.completionCount()): self.completer.setCurrentRow(i) tags.append(self.completer.currentCompletion()) tags.sort(key=len) self.app_window.setTags(tags[:self.MAX_TAG_RETURN_COUNT]) def get_gallery_by_ui_uuid(self, uuid: str) -> GenericGallery: assert uuid return next(g for g in self.current_page if g.ui_uuid == uuid) def update_gallery_rating(self, uuid: str, rating: str): self.get_gallery_by_ui_uuid(uuid).set_rating(rating) def get_gallery_image_folder(self, uuid: str): self.app_window.setGalleryImageFolder.emit( uuid, self.get_gallery_by_ui_uuid(uuid).image_folder) def set_gallery_image(self, uuid, image_path): self.get_gallery_by_ui_uuid(uuid).set_thumbnail_source(image_path) def open_gallery(self, uuid, index): self.get_gallery_by_ui_uuid(uuid).open(index) def open_random_gallery(self): galleries = self.filter_galleries(self.galleries) index = randint(0, len(galleries) - 1) galleries[index].open() def open_gallery_folder(self, uuid): self.get_gallery_by_ui_uuid(uuid).open_folder() def open_on_ex(self, uuid): self.get_gallery_by_ui_uuid(uuid).open_on_ex() def save_gallery_customization(self, uuid, gallery): self.get_gallery_by_ui_uuid(uuid).save_customization(gallery) def exec_(self): self.find_galleries(initial=True) return super().exec_() @property def current_page(self) -> List[GenericGallery]: return self.pages[self.page_number] @property def page_count(self) -> int: return len(self.pages) def set_ui_config(self): self.app_window.setSettings(Config.get_ui_config()) def update_config(self, ui_config): if Config.update_from_ui_config(ui_config): self.set_auto_metadata_collection() self.setup_tags() self.search() def set_scan_folder(self, folder): self.app_window.setScanFolder(folder) def set_auto_metadata_collection(self, galleries: List[GenericGallery] = None): galleries = galleries or self.galleries for gallery in self.filter_galleries(galleries): metadata_changed = False matching_dir = Utils.get_parent_folder(Config.folders, gallery.folder) assert matching_dir auto_collection = Config.folder_options.get(matching_dir, {}).get( Config.AUTO_METADATA_KEY, True) for metadata_name in metadata.MetadataClassMap: metadata_entry = gallery.metadata_manager.get_metadata( metadata_name) if hasattr( metadata_entry, "auto_collection" ) and metadata_entry.auto_collection != auto_collection: metadata_changed = True metadata_entry.auto_collection = auto_collection if metadata_changed: gallery.save_metadata(update_ui=False) def process_search(self, search_text: str) -> (List[str], [List[str], str]): search_text = search_text.lower() quote_regex = re.compile(r"(-)?\"(.*?)\"") filter_regex = re.compile(r"(?:^|\s)\-(.*?)(?=(?:$|\ ))") rating_method = re.search(r"rating:(\S*)", search_text) if rating_method: search_text = re.sub("rating:\S*", "", search_text) rating_method = rating_method.groups()[0] if rating_method: if rating_method[0] == "=" and rating_method[1] != "=": rating_method = "=" + rating_method try: eval("0.0" + rating_method) except: raise exceptions.InvalidRatingSearch else: raise exceptions.InvalidRatingSearch quoted_words = re.findall(quote_regex, search_text) quoted_words = " ".join( map(lambda x: "".join(x).replace(" ", "_"), quoted_words)) search_text = re.sub(quote_regex, "", search_text) + quoted_words filter_words = re.findall(filter_regex, search_text) words = re.sub(filter_regex, "", search_text).split() self.logger.info("Search words: %s" % words) self.logger.info("Filter words: %s" % filter_words) self.logger.info("Rating function: %s" % rating_method) return words, filter_words, rating_method def search(self): self.logger.info("Search_text: %s" % self.search_text) if self.search_text: words, filters, rating_method = self.process_search( self.search_text) galleries = [] with self.gallery_lock: for gallery in self.filter_galleries(self.galleries): if gallery.expired: continue title = gallery.clean_name.lower().split() rating = gallery.metadata_manager.get_value("rating") tags = [ t.replace(" ", "_").lower() for t in gallery.metadata_manager.all_tags ] if rating_method and ( not rating or not eval(str(rating) + rating_method)): continue if any(self.in_search(tags, title, w) for w in filters): continue if all(self.in_search(tags, title, w) for w in words) or len(words) == 0: galleries.append(gallery) self.app_window.setNoSearchResults.emit(not bool(galleries)) self.setup_pages(galleries) self.show_page() else: self.app_window.setNoSearchResults.emit(False) self.setup_pages() self.show_page() @staticmethod def in_search(tags: List[str], title: str, input_tag: str) -> bool: input_tag, namespace = Utils.separate_tag(input_tag) for title_word in title: if input_tag in title_word: return True for tag in tags: tag, tag_namespace = Utils.separate_tag(tag) if input_tag in tag and (namespace is None or tag_namespace == namespace): return True return False def setup_tags(self): tags = [] # tag_count_map = {} for gallery in self.filter_galleries(self.galleries): new_tags = list( set( map(lambda x: x.replace(" ", "_").lower(), gallery.metadata_manager.all_tags))) # for tag in new_tags: # tag_count_map[tag] = tag_count_map.get(tag, 0) + 1 tags += new_tags self.tags = list(set(tags)) for tag in self.tags[:]: raw_tag, namespace = Utils.separate_tag(tag) if namespace: self.tags.append(raw_tag) self.tags += list(map(lambda x: "-" + x, self.tags)) self.tags = list(set(self.tags)) self.tags.sort() self.setup_completer() def find_galleries(self, initial: bool = False): self.app_window.setScanningMode(True) self.logger.debug("Sending start signal to gallery thread") folders = Config.folders[:] if not initial else None threads.gallery_thread.queue.put(folders) def find_galleries_done(self, galleries: List[GenericGallery]): self.app_window.setScanningMode(False) self.set_auto_metadata_collection(galleries) with self.gallery_lock: self.galleries += galleries self.logger.debug("Gallery thread done") self.setup_tags() self.sort() self.search() def send_page(self, reset_scroll=True): index_list = (i for i in range(0, self.PAGE_SIZE)) for gallery in self.current_page: self.app_window.setUIGallery.emit(next(index_list), gallery.get_json(), reset_scroll) for i in list(index_list)[::-1]: self.app_window.removeUIGallery.emit(i, 1) # index_list = list(index_list) # if index_list: # self.app_window.removeUIGallery.emit(index_list[0], len(index_list)) self.garbage_collect() threads.image_thread.bg_run_count = 0 def garbage_collect(self): return self.qml_engine.clearComponentCache() gc.collect() self.app_window.garbageCollect() def show_page(self, reset_scroll=True): need_images = [ g for g in self.current_page if not g.thumbnail_verified ] if need_images: self.generate_images(need_images) else: self.send_page(reset_scroll) def hide_page(self): self.app_window.clearGalleries.emit() def generate_images(self, galleries: List[GenericGallery]): self.app_window.setScanningMode(True) threads.image_thread.queue.put(galleries) def image_thread_done(self): self.app_window.setScanningMode(False) self.logger.debug("Image thread done.") self.send_page() def get_metadata(self, uuid: str): try: uuid = int(uuid) galleries = [ g for g in self.filter_galleries(self.galleries) if g.metadata_manager.metadata_collection_enabled() ] if uuid == -1: for gallery in galleries: gallery.force_metadata = True except ValueError: gallery = self.get_gallery_by_ui_uuid(uuid) gallery.force_metadata = True galleries = [gallery] self.logger.debug("Starting metadata thread") self.app_window.setSearchMode(True) threads.search_thread.queue.put(galleries) def set_current_metadata_gallery(self, gallery): self.app_window.setCurrentMetadataGallery(gallery.title) def update_gallery_metadata(self, gallery: GenericGallery, metadata: dict): gallery.update_metadata(metadata) gallery.save_metadata() def get_metadata_done(self): self.app_window.setSearchMode(False) self.logger.debug("Metadata thread done.") self.setup_tags() def remove_duplicates(self): self.app_window.setScanningMode(True) threads.duplicate_thread.queue.put( self.filter_galleries(self.galleries)) def duplicate_thread_done(self): self.app_window.setScanningMode(False) self.setup_tags() self.sort() def close(self): try: with self.gallery_lock: for g in self.galleries: g.release() for g in self.removed_galleries: g.release() except: self.logger.error("Failed to complete release, check log", exc_info=True) self.quit() def sort(self): key = attrgetter([t.value for t in self.SortMethodMap][Config.sort_type]) assert key with self.gallery_lock: self.galleries.sort(key=key, reverse=Config.sort_mode_reversed) def switch_page(self, page_num: int): self.page_number = int(page_num) - 1 self.show_page() self.app_window.setPage(self.page_number + 1) def filter_galleries( self, galleries: List[GenericGallery]) -> List[GenericGallery]: return_galleries = [] for gallery in galleries: if gallery.expired: continue if not any( Utils.path_exists_under_directory(d, gallery.folder) for d in Config.folders): continue return_galleries.append(gallery) return return_galleries def setup_pages(self, galleries: List[GenericGallery] = None): if galleries is None: # Need to do it this way because passing in galleries of [] would cause problems galleries = self.galleries galleries = self.filter_galleries(galleries) self.pages = [ galleries[i:i + self.PAGE_SIZE] for i in range(0, len(galleries), self.PAGE_SIZE) ] or [[]] self.app_window.setPageCount(self.page_count) self.page_number = 0 self.app_window.setPage(self.page_number + 1) def remove_gallery_and_recalculate_pages(self, gallery: GenericGallery, force_assertion=True): gallery_in_galleries = gallery in self.galleries if force_assertion: assert gallery_in_galleries elif not gallery_in_galleries: return working_page = None with self.gallery_lock: self.galleries.remove(gallery) for i in range(0, self.page_count): if gallery in self.pages[i]: self.pages[i].remove(gallery) working_page = i break assert working_page is not None initial_page_is_displayed = working_page == self.page_number while working_page < self.page_count - 1: self.pages[working_page].append(self.pages[working_page + 1].pop(0)) working_page += 1 self.pages = [p for p in self.pages if p] if self.page_number >= self.page_count: self.switch_page(self.page_count) elif initial_page_is_displayed: self.show_page(reset_scroll=False) self.removed_galleries.append(gallery) def thread_exception_handler(self, thread, exception): self.exception_hook(*exception) def exception_hook(self, extype, exvalue, extraceback): fatal = True # Default to true for unhandled exceptions if issubclass(extype, exceptions.CustomBaseException): fatal = exvalue.fatal message = exvalue.msg else: message = "Sorry, PandaViewer got an unhandled %s exception and must close.\nPlease feel free to submit a bug report" % extype self.logger.error("Got unhandled exception", exc_info=(extype, exvalue, extraceback)) self.app_window.setException(message, fatal)
def __init__(self, func, name=None, doc=None): self.__name__ = name or func.__name__ self.__module__ = func.__module__ self.__doc__ = doc or func.__doc__ self.func = func self.lock = RLock()
for name in ('RPiGPIOPin', 'RPIOPin', 'PiGPIOPin', 'NativePin'): try: return pkg_resources.load_entry_point(dist, group, name) except ImportError: pass raise BadPinFactory('Unable to locate any default pin factory!') else: for factory in pkg_resources.iter_entry_points(group, name): return factory.load() raise BadPinFactory('Unable to locate pin factory "%s"' % name) pin_factory = _default_pin_factory() _PINS = set() _PINS_LOCK = RLock() # Yes, this needs to be re-entrant def _shutdown(): _threads_shutdown() with _PINS_LOCK: while _PINS: _PINS.pop().close() # Any cleanup routines registered by pins libraries must be called *after* # cleanup of pin objects used by devices _pins_shutdown() atexit.register(_shutdown) class GPIOMeta(type): # NOTE Yes, this is a metaclass. Don't be scared - it's a simple one.
''' RETURN = ''' url: description: - An image file url used to download the file without authentication. returned: on success always type: str error_msg: description: - Its an error message that is returned if there is any exception or error. returned: on failure type: str ''' connection_lock = RLock() class FileSvcUtil(object): # pragma: no cover def __init__(self, authtoken, authurl, user, key, tenant_name, user_domain_name, project_domain_name, auth_version, container_name, temp_url_key, temp_url_key2, connection_retry_count, chosen_temp_url_key): """Init routine.""" self.requests = requests self.authurl = authurl self.preauthtoken = authtoken self.user = user self.key = key self.auth_version = auth_version self.container_name = container_name
sd[key] = sd_temp[key] except IOError: # If file does not exist, it will be created using defaults. with open('./data/sd.json', 'w') as sdf: # save file json.dump(sd, sdf, indent=4, sort_keys=True) nowt = time.localtime() now = timegm(nowt) tz_offset = int( time.time() - timegm(time.localtime()) ) # compatible with Javascript (negative tz shown as positive value) plugin_menu = [] # Empty list of lists for plugin links (e.g. ['name', 'URL']) srvals = [0] * (sd['nst']) # Shift Register values output_srvals = [0] * (sd['nst'] ) # Shift Register values last set by set_output() output_srvals_lock = RLock() rovals = [0] * sd['nbrd'] * 7 # Run Once durations snames = station_names() # Load station names from file pd = load_programs() # Load program data from file plugin_data = {} # Empty dictionary to hold plugin based global data ps = [] # Program schedule (used for UI display) for i in range(sd['nst']): ps.append([0, 0]) pon = None # Program on (Holds program number of a running program) sbits = [0] * (sd['nbrd'] + 1) # Used to display stations that are on in UI rs = [] # run schedule for j in range(sd['nst']): rs.append([ 0, 0, 0, 0
from threading import Thread from Queue import Queue from threading import RLock from datetime import datetime from functools import partial from calibre.ebooks.metadata import title_sort, author_to_author_sort from calibre.utils.date import parse_date, isoformat, local_tz, UNDEFINED_DATE from calibre import isbytestring, force_unicode from calibre.constants import iswindows, DEBUG, plugins from calibre.utils.icu import sort_key from calibre import prints from dateutil.tz import tzoffset global_lock = RLock() _c_speedup = plugins['speedup'][0] def _c_convert_timestamp(val): if not val: return None try: ret = _c_speedup.parse_date(val.strip()) except: ret = None if ret is None: return parse_date(val, as_utc=False) year, month, day, hour, minutes, seconds, tzsecs = ret try:
def __init__(self, file): if not file.isatty(): raise RuntimeError('TTYFileWrapper is supposed to wrap a tty file') self.file = file self.buffer = '' self.lock = RLock()
def __init__(self): self._context_dict = {} self._context_dict_lock = RLock() self._context_id_poll = _IdPool(0x10000000)
def get_caching_wrapper(user_function, max_size, ttl, algorithm, thread_safe, order_independent, custom_key_maker): """Get a caching wrapper for statistics only, without any actual caching""" misses = 0 # number of misses of the cache lock = RLock() if thread_safe else DummyWithable() # ensure thread-safe def wrapper(*args, **kwargs): """The actual wrapper""" nonlocal misses with lock: misses += 1 return user_function(*args, **kwargs) def cache_clear(): """Clear the cache and statistics information""" nonlocal misses with lock: misses = 0 def cache_info(): """ Show statistics information :return: a CacheInfo object describing the cache """ with lock: return CacheInfo(0, misses, 0, max_size, algorithm, ttl, thread_safe, order_independent, custom_key_maker is not None) def cache_is_empty(): """Return True if the cache contains no elements""" return True def cache_is_full(): """Return True if the cache is full""" return True def cache_contains_argument(function_arguments, alive_only=True): """ Return True if the cache contains a cached item with the specified function call arguments :param function_arguments: Can be a list, a tuple or a dict. - Full arguments: use a list to represent both positional arguments and keyword arguments. The list contains two elements, a tuple (positional arguments) and a dict (keyword arguments). For example, f(1, 2, 3, a=4, b=5, c=6) can be represented by: [(1, 2, 3), {'a': 4, 'b': 5, 'c': 6}] - Positional arguments only: when the arguments does not include keyword arguments, a tuple can be used to represent positional arguments. For example, f(1, 2, 3) can be represented by: (1, 2, 3) - Keyword arguments only: when the arguments does not include positional arguments, a dict can be used to represent keyword arguments. For example, f(a=4, b=5, c=6) can be represented by: {'a': 4, 'b': 5, 'c': 6} :param alive_only: Whether to check alive cache item only (default to True). :return: True if the desired cached item is present, False otherwise. """ return False def cache_contains_result(return_value, alive_only=True): """ Return True if the cache contains a cache item with the specified user function return value. O(n) time complexity. :param return_value: A return value coming from the user function. :param alive_only: Whether to check alive cache item only (default to True). :return: True if the desired cached item is present, False otherwise. """ return False def cache_for_each(consumer): """ Perform the given action for each cache element in an order determined by the algorithm until all elements have been processed or the action throws an error :param consumer: an action function to process the cache elements. Must have 3 arguments: def consumer(user_function_arguments, user_function_result, is_alive): ... user_function_arguments is a tuple holding arguments in the form of (args, kwargs). args is a tuple holding positional arguments. kwargs is a dict holding keyword arguments. for example, for a function: foo(a, b, c, d), calling it by: foo(1, 2, c=3, d=4) user_function_arguments == ((1, 2), {'c': 3, 'd': 4}) user_function_result is a return value coming from the user function. cache_result is a return value coming from the user function. is_alive is a boolean value indicating whether the cache is still alive (if a TTL is given). """ pass def cache_arguments(): """ Get user function arguments of all alive cache elements see also: cache_items() Example: @cached def f(a, b, c, d): ... f(1, 2, c=3, d=4) for argument in f.cache_arguments(): print(argument) # ((1, 2), {'c': 3, 'd': 4}) :return: an iterable which iterates through a list of a tuple containing a tuple (positional arguments) and a dict (keyword arguments) """ yield from () def cache_results(): """ Get user function return values of all alive cache elements see also: cache_items() Example: @cached def f(a): return a f('hello') for result in f.cache_results(): print(result) # 'hello' :return: an iterable which iterates through a list of user function result (of any type) """ yield from () def cache_items(): """ Get cache items, i.e. entries of all alive cache elements, in the form of (argument, result). argument: a tuple containing a tuple (positional arguments) and a dict (keyword arguments). result: a user function return value of any type. see also: cache_arguments(), cache_results(). Example: @cached def f(a, b, c, d): return 'the answer is ' + str(a) f(1, 2, c=3, d=4) for argument, result in f.cache_items(): print(argument) # ((1, 2), {'c': 3, 'd': 4}) print(result) # 'the answer is 1' :return: an iterable which iterates through a list of (argument, result) entries """ yield from () def cache_remove_if(predicate): """ Remove all cache elements that satisfy the given predicate :param predicate: a predicate function to judge whether the cache elements should be removed. Must have 3 arguments, and returns True or False: def consumer(user_function_arguments, user_function_result, is_alive): ... user_function_arguments is a tuple holding arguments in the form of (args, kwargs). args is a tuple holding positional arguments. kwargs is a dict holding keyword arguments. for example, for a function: foo(a, b, c, d), calling it by: foo(1, 2, c=3, d=4) user_function_arguments == ((1, 2), {'c': 3, 'd': 4}) user_function_result is a return value coming from the user function. cache_result is a return value coming from the user function. is_alive is a boolean value indicating whether the cache is still alive (if a TTL is given). :return: True if at least one element is removed, False otherwise. """ return False # expose operations and members of wrapper wrapper.cache_clear = cache_clear wrapper.cache_info = cache_info wrapper.cache_is_empty = cache_is_empty wrapper.cache_is_full = cache_is_full wrapper.cache_contains_argument = cache_contains_argument wrapper.cache_contains_result = cache_contains_result wrapper.cache_for_each = cache_for_each wrapper.cache_arguments = cache_arguments wrapper.cache_results = cache_results wrapper.cache_items = cache_items wrapper.cache_remove_if = cache_remove_if wrapper._cache = None return wrapper
class MapQueue: def __init__(self, iterable=None, maxlen=0): self.stack = [] self.maxlen = maxlen if iterable is None: self.length = 0 else: self.length = max(len(iterable, maxlen)) for i in range(self.length): self.stack.append(iterable[i]) self.pending = 0 self.mainlock = Lock() self.innerlock = RLock() def qsize(self): self.innerlock.acquire() try: ret = self.length finally: self.innerlock.release() return ret def task_done(self): self.mainlock.acquire() try: self.pending -= 1 finally: self.mainlock.release() def join(self): self.mainlock.acquire() try: while self.pending > 0: self.mainlock.release() sleep(0.1) self.mainlock.acquire() finally: self.mainlock.release() def get(self, block=True, timeout=None): infinite = timeout is None timeout = ternary(timeout is None, 0, timeout) self.mainlock.acquire() if (self.empty()): if not block: self.mainlock.release() raise Queue.Empty t = clock() curtime = t while self.empty() and curtime - t <= timeout: self.mainlock.release() sleep(0.1) curtime = clock() self.mainlock.acquire() if infinite and self.empty(): timeout = curtime + 1 if (infinite or clock() - t > timeout) and self.empty(): self.mainlock.release() raise Queue.Empty ret = self.stack.pop() self.pending += 1 self.length -= 1 self.mainlock.release() return ret def get_nowait(self): return self.get(False) def put(self, item): self.mainlock.acquire() try: self.stack.append(item) self.length += 1 finally: self.mainlock.release() def empty(self): self.innerlock.acquire() try: ret = self.qsize() == 0 finally: self.innerlock.release() return ret
def __init__(self): #Instagram Account Login Bool self.logged_in = False #Thread Lock Variable self.lock = RLock() self.que = Queue() #Import Config.ini and Configure cwd = os.getcwd() platform = sys.platform if platform == 'win32' or 'cygwin': config_file = (cwd + '\\config.ini') self.xmlfile = (cwd + '\\XML.txt') CHROME_USERDATA = (cwd + '\\chromeuserdata') CHROMEDRIVER_PATH = (cwd + "\\chromedriver.exe") else: config_file = (cwd + '/config.ini') self.xmlfile = (cwd + '/XML.txt') CHROME_USERDATA = (cwd + '/chromeuserdata') CHROMEDRIVER_PATH = (cwd + "/chromedriver.exe") try: config = configparser.ConfigParser() config.read(config_file) except configparser.Error: print('''config.ini Error, Please Check File Paths \n Make sure Chromedriver.exe is in the Current Working Directory and\n Chromedriver and Google Chrome are at compatable versions.''' ) #Instagram Account Username and Password self.username = config['IG_AUTH']['USERNAME'] self.password = config['IG_AUTH']['PASSWORD'] #Logger for Instagram Account Actions- Likes, Follows, ect logging.basicConfig( level=logging.INFO, format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s', datefmt='%m-%d %H:%M', filename=config['LOGS']['INSTAGRAM'], filemode='w') self.logger = logging.getLogger(self.username) #URL Variables self.base_url = config['IG_URLS']['BASE'] self.login_url = config['IG_URLS']['LOGIN'] self.nav_url = config['IG_URLS']['NAV_USER'] self.tag_url = config['IG_URLS']['SEARCH_TAGS'] #Instagram Variables self.tags = config['TAGS']['TAGS_TO_LIKE'].split(',') self.max_likes = int(config['VARS']['MAX_LIKES']) self.MINIMUM_NUMBER_OF_LIKES = int( config['VARS']['MINIMUM_NUMBER_OF_LIKES']) self.liked_pictures = 0 self.new_followers = 0 #Selenium Driver options = webdriver.ChromeOptions() options.add_argument('user-data-dir={}'.format(CHROME_USERDATA)) options.add_argument('--incognito') # options.add_argument('--headless') self.driver = webdriver.Chrome( executable_path=CHROMEDRIVER_PATH, service_log_path=config['LOGS']['CHROME'], options=options) #Populate Queue with Tags from config.ini for item in self.tags: self.que.put(item)
""" motorControl.cpp Created on: 17 mars 2019 Author: clubRobot """ from math import pi from threading import RLock VERROU = RLock() OBSTACLE_DETECTED = False #Variables de communications avec la Teensy RADIAN_TO_MSG_ADDER = pi RADIAN_TO_MSG_FACTOR = 1000 SPEED_ADDER = 1 << 15 XY_ADER = 1 << 15 ANGULAR_SPEED_TO_MSG_FACTOR = (1 << 15) / 30 #max omega=30rad/s ANGULAR_SPEED_TO_MSG_ADDER = (1 << 15) #split uint16 in two SERIAL_BAUDRATE = 115200 SERIAL_PATH = "/dev/ttyAMA0" TIMEOUT = 0.01 STOP_DELAY = 1 MATCH_DURATION = 100 #Couleurs des côtés du terrain et tirette UNDEFINED = 2 VIOLET = 1 JAUNE = 0
def __init__(self): self.lock = RLock() self.d = {}
class PlayerRobot(object): """ Player Robot interface. A PlayerRobot instance encapsulates an interface to a Player robot. It creates and manages a playerc.client object and a set of device proxies wrapped in PlayerDevice objects. In addition, it maintains a run-loop in a separate thread that calls the client's .read() method at regular intervals. The devices are published through standard interfaces on the PlayerRobot instance, and their methods and properties are synchronized with the run thread through a mutex. Example: # set up a robot object with position, laser, and camera objects robot = PlayerRobot(host='myrobot.mydomain.edu',port=6665, devices = [('position2d',0), ('laser',0), ('camera',1)]) # start the run thread, devices will be subscribed # automatically. robot.start() # start the robot turning at 30 deg/sec robot.position2d[0].set_cmd_vel(0, 0, 30*pi/180) # wait for a while time.sleep(5.0) # all stop robot.position2d[0].set_cmd_vel(0,0,0) # shut down the robot's thread, unsubscribing all devices and # disconnecting the client robot.stop() """ def __init__(self,host='localhost',port=6665,speed=20, devices=[]): self._thread = None self._running = False self._lock = RLock() self.speed = speed self._client = PlayerClient(playerc.playerc_client(None,host,port),self._lock) self._queues_running = False self._devices = [] for devname,devnum in devices: self.add_device(devname,devnum=devnum) def start(self): assert self._thread is None self._thread = Thread(target=self.run_loop,name="PlayerRobot Run Loop") self._thread.setDaemon(True) self._thread.start() def stop(self): self._running = False self._thread.join() self._thread = None def run_loop(self): self._client.connect() self._running = True self.subscribe_all() try: while self._running: self._client.read() if self._queues_running: self.process_queues() time.sleep(1.0/self.speed) finally: self.unsubscribe_all() self._client.disconnect() def run_queues(self,run_state): """ When using queues for communication with devices, this method toggles queue processing. It is often useful to turn off queue processing, e.g. when a client does not plan on using queued data for a while. """ self._queues_running = run_state def process_queues(self): for d in self._devices: d.process_queues() def subscribe_all(self): for dev in self._devices: dev.subscribe() def unsubscribe_all(self): for dev in self._devices: dev.unsubscribe() def add_device(self,devname,devnum=0): if devname not in dir(self): setattr(self,devname,{}) proxy_constr = getattr(playerc,'playerc_'+devname) devtype = device_table.get(devname,PlayerDevice) try: self._lock.acquire() dev = devtype(proxy_constr(self._client.proxy,devnum),self._lock) finally: self._lock.release() self._devices.append(dev) getattr(self,devname)[devnum] = dev if self._running: dev.subscribe()
def __init__(self, left=0, right=0): self.__left = left self.__right = right self.__lock = RLock()
MAX_BLOCK_SIZE = 1000000 COIN = 100000000L # 1 btc in satoshis # Keep our own socket map for asyncore, so that we can track disconnects # ourselves (to workaround an issue with closing an asyncore socket when # using select) mininode_socket_map = dict() # One lock for synchronizing all data access between the networking thread (see # NetworkThread below) and the thread running the test logic. For simplicity, # NodeConn acquires this lock whenever delivering a message to to a NodeConnCB, # and whenever adding anything to the send buffer (in send_message()). This # lock should be acquired in the thread running the test logic to synchronize # access to any data shared with the NodeConnCB or NodeConn. mininode_lock = RLock() # Serialization/deserialization tools def sha256(s): return hashlib.new('sha256', s).digest() def hash256(s): return sha256(sha256(s)) def bitglohash(s): return bitglo_hash.getPoWHash(s) def deser_string(f): nit = struct.unpack("<B", f.read(1))[0] if nit == 253: