def __init__(self): self.cond = Condition() self.readers = 0 self.writers = 0
def __init__(self, max_workers, build, artefact, build_id, printer, inline_log_lines=10, debug=False): self.config = { 'build-directory': build, 'artefact-directory': artefact, } self.printer = printer self.start_timestamp = time.time() self.start_date = datetime.datetime.now(datetime.timezone.utc).replace( microsecond=0).astimezone().isoformat(' ') # Parent task controller self.ctl = TaskController('scheduler', {}, build, artefact, self.printer, inline_log_lines, debug) # Start the log file self.report_file = self.ctl.open_downloadable_file('report.xml', 'w') self.report_file.write("<?xml version=\"1.0\"?>\n") self.report_file.write("<build number=\"%s\">\n" % build_id) # The following attributes (up to self.guard declaration) are guarded # by the self.guard mutex and use self.cond to notify about changes # in any of them. # Lower granularity of the locking would be possible but would # complicate too much the conditions inside queue processing where we # need to react to multiple events (new task added vs some task # terminated vs selecting the right task to be executed). # Known tasks (regardless of their state). The mapping is between # a task id and TaskWrapper class. self.tasks = {} # Queue of tasks not yet run (uses task ids only). We insert mutex # tasks at queue beginning (instead of appending) as a heuristic to # prevent accumulation of mutex tasks at the end of run where it could # hurt concurrent execution. self.queue = [] # Number of currently running (executing) tasks. Used solely to # control number of concurrently running tasks. self.running_tasks_count = 0 # Flag for the queue processing whether to terminate the loop to allow # clean termination of the executor. self.terminate = False # Here we record which mutexes are held by executing tasks. Mutexes are # identified by their (string) name that is used as index. When the # value is True, the mutex is held (i.e. do not run any other task # claming the same mutex), mutex is not held when the value is False # or when the key is not present at all. self.task_mutexes = {} # Condition variable guarding the above attributes. # We initialize CV only without attaching a lock as it creates one # automatically and CV serves as a lock too. # # Always use notify_all as we are waiting in multiple functions # for it (e.g. while processing the queue or in barrier). self.guard = Condition() # Lock guarding output synchronization self.output_lock = Lock() # Executor for running of individual tasks from concurrent.futures import ThreadPoolExecutor self.max_workers = max_workers self.executor = ThreadPoolExecutor(max_workers=max_workers + 2) # Start the queue processor self.executor.submit(BuildScheduler.process_queue_wrapper, self)
def __init__(self, events): self.conds = dict() for evt in events: self.conds[evt] = Condition(Lock()) self.data = None
word = run_through_module(Text('integral')) self.assertEqual(word.get_text(), 'integral') self.assertEqual( word.get_phonotypes(), [VOWEL, NASAL, OBSTR, VOWEL, OBSTR, LIQUID, VOWEL, LIQUID]) def run_through_module(word): pin.acquire() pin.put(word) pin.notify() pin.release() pout.acquire() if pout.empty(): pout.wait() word = pout.get() pout.release() return word print(path_to_scripts + '/configs/conf_hr_lat.json') data = ConfigData(path_to_scripts + '/configs/conf_hr_lat.json') pin = Pipe(Queue(), Condition()) pout = Pipe(Queue(), Condition()) mod = PhonotypeModule([pin, pout], data) if __name__ == '__main__': unittest.main()
cmd = config['source'][len('pipe:'):] (child_out, source) = os.popen2(cmd, 'b') else: # File source source = open(config['source'], "rb") dscfg.set_video_ratelimit(tdef.get_bitrate()) restartstatefilename = config['name'] + '.restart' dscfg.set_video_source(source, restartstatefilename=restartstatefilename) dscfg.set_max_uploads(config['nuploads']) d = s.start_download(tdef, dscfg) d.set_state_callback(state_callback) # condition variable would be prettier, but that don't listen to # KeyboardInterrupt # time.sleep(sys.maxint/2048) # try: # while True: # x = sys.stdin.read() # except: # print_exc() cond = Condition() cond.acquire() cond.wait() s.shutdown() time.sleep(3) shutil.rmtree(statedir)
def __init__(self): self.cv = Condition() self.num = 0
def __init__(self, correlation_id): self.correlation_id = correlation_id self._result = None self._condition = Condition()
def __init__(self, max_retry_time=60 * 60, sleep_time=5): self._condvar = Condition() self._retrying = False self._max_retry_time = max_retry_time self._sleep_time = sleep_time
def send(s, host, port, window, lock): # Variaveis compartilhadas global max_packages max_packages = 2 global aux_time aux_time = time() global aux_lock aux_lock = Condition() global print_lock print_lock = Condition() # Variavel para controlar o fim do programa global end end = False # Número de sequencia do pacote seqNumber = 0 # Pacotes enviados i = 0 payloads = [ '1', '12', '123', '1234', '12345', '123456', '1234567', '12345678', '123456789' ] # Envia 15 pacotes ao servidor while i != 15: # Demora aleatóriamente entre 0.6 e 1.2 para enviar um novo pacote sleep(random.uniform(0.6, 1.2)) # Envia pacotes com tamanho aleatório entre 1 e 9 de acordo com o indice da lista "payloads" data = payloads[random.randint(0, 8)] # Constroi o pacote para ser enviado packet = p_client(data, seqNumber) # Transforma o pacote em um objeto de bytes packet = pickle.dumps(packet) lock.acquire() # Chega se a quantidades de pacotes enviados é maior do que max_package if i > max_packages: lock.wait() lock.release() s.sendto(packet, (host, port)) print_lock.acquire() print("Pacote com número de sequência {} enviado".format(seqNumber)) print_lock.release() # Atualiza o número de sequencia seqNumber += len(data) # Adiciona o pacote na janela lock.acquire() window[i % 7] = (packet, seqNumber) lock.release() # Incrementa os pacotes enviados i += 1 # Atualiza end end = True
print >>cleaningOut, u'\t\t\t<creation-date>'+str(datetime.datetime.now().date())+'</creation-date>' print >>cleaningOut, u'\t\t</extraInfo>\n' print >>cleaningOut, u'\t</doc>\n' prevTitle = cleaned["title"] # sync end if multithread: writeCondition.release() log(u"Obrađeno (" + str(id-1) + "/" + str(linksLen) + ") stranica - " + ("%2.2f" % ((id-1)*100.0/linksLen)) + "%") if __name__ == '__main__': # Monitori za sinkronizaciju if multithread: writeCondition = Condition() logCondition = Condition() # Ispis - start # Izlazna datoteka #cleaningOut = sys.__stdout__ # stdout now = datetime.datetime.now() year = now.year month = now.month day = now.day cleaningOut = codecs.open("jutarnji-kolumne-arhiva-"+str(year)+"-"+('%02d' % month)+"-"+('%02d' % day)+".xml", "w", "utf-8") print >>cleaningOut, u'<?xml version="1.0" encoding="utf-8"?>' print >>cleaningOut, u'<documentSet name="jutarnji-kolumne-arhiva-'+str(year)+'-'+("%02d" % month)+'-'+("%02d" % day)+'" type="" description="Arhiva kolumni Jutarnjeg lista do '+str(year)+'-'+("%02d" % month)+'-'+("%02d" % day)+'" xmlns="http://ktlab.fer.hr" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://ktlab.fer.hr http://ktlab.fer.hr/download/documentSet.xsd">' # Ispis - end
from threading import Thread, Lock, Condition import time import random queue = [] lock = Lock() cv = Condition() class Producer(Thread): def __init__(self, id): Thread.__init__(self) self.id = id def run(self): global queue while True: cv.acquire() val = random.randint(1,1000) print "Producer %d generated : %d" %(self.id, val) queue.append(val) cv.notifyAll() cv.release() time.sleep(random.random()) class Consumer(Thread): def __init__(self, id): Thread.__init__(self) self.id = id def run(self): global queue while True:
def __init__(self): self.reject_calls = 0 self.condition = Condition()
def __init__(self): self.receiver_num = self.next_number() self.condition = Condition() self.messages = []
def __init__(self, max_downloads=2): self._cv = Condition(lock=Lock()) self._active_downloads = set() self._max_downloads = max_downloads
def __init__(self): self._deque = deque() self._closed = False self._lock = Lock() self._cond = Condition(self._lock)
def recv_ack(s, host, port, window, lock, lasted_ack, packages_time): # Variaveis compartilhadas global max_packages global aux_time global aux_lock aux_lock = Condition() global print_lock print_lock = Condition() rtt = 2.0 while True: try: # Tempo que o cliente espera pela confirmação do ack s.settimeout(rtt) # Recebe o pacote e o endereço do servidor data, add = s.recvfrom(4096) # Adiciona o tempo de envio dos pacotes aux_lock.acquire() packages_time.append(time() - aux_time) aux_time = time() aux_lock.release() # Transforma o objeto de bytes no pacotes original packet = pickle.loads(data) print_lock.acquire() print("Ack com número de sequência {} recebido".format(packet.ack)) print_lock.release() # Flag para ver se o ack recebido é o esperado na janela ack_awaited = False # Percorre a janela de transmissão for i in range(lasted_ack, max_packages + 1): # Armazena o elemento (pacote, seqnumber) na variavel lock.acquire() index = window[i % 7] lock.release() # Verifica se o ack recebido é igual ao numero de sequencia do pacote armazenado na janela if (packet.ack == index[1]): # Ack recebido é o esperado ack_awaited = True lock.acquire() # Percorre a janela transformando em None os pacotes confirmados for j in range(lasted_ack, i + 1): window[j % 7] = (None, None) # Atualiza o ultimo ack recebido lasted_ack += 1 max_packages += 1 lock.notify() lock.release() # Ack não é o esperado if (ack_awaited == False): print_lock.acquire() print("Ack duplicado") print_lock.release() # Como foram recebidos ack duplicados a janela é reenviada resend_window(s, host, port, window, lock, lasted_ack) except socket.error as error: print_lock.acquire() print("Timeout") print_lock.release() # Se o houver um timeout a janela será reenviada resend_window(s, host, port, window, lock, lasted_ack) # Variavel para verificar se todos os pacotes da janela foram confirmados empty_window = True # Percorre a janela verificando se existi pacotes não confirmados for i in range(lasted_ack, max_packages + 1): if window[i % 7] != (None, None): # Se houver atualiza a variavel para falso empty_window = False # Verifica se a janela está vazia e se o servidor parou de enviar pacotes if end == True and empty_window == True: break
def __init__(self): Thread.__init__(self) self.on_error = lambda err: print(err) self._running = False self._paused = False self._condition = Condition()
def __init__(self): self.last_frame = datetime.datetime.now() self.condition = Condition() self.screen = bytes()
def __init__(self): self.length = 0 self.nodes = [] self.lock = Lock() self.was_added = Condition(self.lock)
def __init__(self, Qf, Phi, smin, smax, alpha, nmax=200): # Parameters: # $\mathbf{Qf}$ -- $\mathcal{Q}f$, sampled on an $r\theta$ grid. # $\mathbf{Phi}$ ($\phi$) -- Scattering angle # $\mathbf{rmin}$ -- $r_{\min}$, defaults to $1$. # $\mathbf{rmax}$ -- $r_{\max}$, defaults to $6$. # $\mathbf{D}$ -- Numerical implemenation of $\frac{\partial}{\partial r}$. # $\mathbf{nmax}$ -- $n_{\max}$, reconstructs $\tilde{f}\left(r,n\right)$ # for $\left|n\right| \le n_{\max}$. Defaults to $200$. # This reconstruction will assume that $\mathcal{Q}f$ is real and exploit # conjugate symmetry in the Fourier series. # Initialize variables. self.Qf = Qf self.Phi = Phi self.smin = smin self.smax = smax H, W = Qf.shape self.thetamin = thetamin = -pi self.thetamax = thetamax = pi * (1 - 2.0 / H) self.nmax = nmax self.F = None self.F_cartesian = None self.lock = Lock() self.status = Condition(self.lock) self.jobsdone = 0 self.jobcount = nmax + 1 self.running = False self.projectioncount = 0 self.projecting = False self.dr = dr = ds = (smax - smin) / float(W - 1) self.dtheta = dtheta = (thetamax - thetamin) / float(H) # Compute $\widetilde{\mathcal{Q}f}$. self.FQf = FQf = fft(Qf, axis=0) # Perform differentiation of $\widetilde{\mathcal{Q}f}$. D = Sderiv(alpha) try: clip_left, clip_right, self.DFQf = D(FQf, ds) except: clip_left, clip_right, self.DFQf = D(float64(FQf), ds) # Initialize array that will store $\tilde{f}$. self.Ff = zeros(self.DFQf.shape, dtype=complex128) # Initialize $rs$ grid. self.rmin = self.smin + clip_left * ds self.rmax = self.smax - clip_right * ds R = linspace(self.rmin, self.rmax, W - clip_left - clip_right) self.R, self.S = meshgrid(R, R) # Compute $q$, $u$, $v$, $w$, and $v^{2}r*\csc(\phi)*{\Delta}r/s^2$. self.Q = self.S / self.R args = dict(q=self.Q, r=self.R, s=self.S, phi=self.Phi, dr=dr) args["u"] = self.U = self._u(**args) args["v"] = self.V = self._v(**args) self.W = self._w(**args) self.Factor = self._cf(**args)
def __init__(self, action: Callable, **kwargs): """ Mandatory positional arguments action object which will be executed (e.g. a function). Must be a callable or a task object (e.g. Task, Repeated, Periodic). Optional keyword only arguments args: tuple=() argument list of action kwargs: dict={} keyword arguments of action action_stop: Callable=None object (e.g. a function), called when Repeated is stopped. args_stop: tuple=() argument list of action_stop kwargs_stop: dict={} keyword arguments of action_stop action_cont: Callable=None object (e.g. a function), called when Repeated is continued. args_cont: tuple=() argument list of action_cont kwargs_cont: dict={} keyword arguments of action_cont duration: Number=None duration of task (if recursions end earlier, Repeated will wait) num: int maximum number of iterations netto_time: bool=False flag, that waiting is netto (execution of action counts extra) exc_handler: Callable=None user defined handler of exceptions """ assert isinstance(kwargs, dict), \ 'kwarg needs to be a dictionary' self._action = action self._args = kwargs.pop('args', ()) self._kwargs = kwargs.pop('kwargs', {}) self._duration = kwargs.pop('duration', None) self._duration_rest: bool = False # stopped while sleeping self._gap = None # stopped while sleeping self._num = kwargs.pop('num', None) self._exc_handler = kwargs.pop('exc_handler', None) self._next = None # next task in linked list self._root = self # root task self._netto_time = kwargs.pop('netto_time', False) self._cnt = 0 # number of action executions # the following are root only attributes self._action_stop = kwargs.pop('action_stop', None) self._args_stop = kwargs.pop('args_stop', ()) self._kwargs_stop = kwargs.pop('kwargs_stop', {}) self._action_cont = kwargs.pop('action_cont', None) self._args_cont = kwargs.pop('args_cont', ()) self._kwargs_cont = kwargs.pop('kwargs_cont', {}) self._state = STATE_INIT self._activity = ACTIVITY_NONE self._thread = None self._thread_start = None self._thread_cont = None self._restart = False self._lock = Lock() self._cond = Condition(self._lock) self._current = None # current task object self._current_scheduled = None # scheduled time self._last = self # last task object in chain self._time_called_start = None # time of last starting self._time_called_cont = None # time of last continuing self._time_called_stop = None # time of last stopping self._children = [] # child tasks self._cont_join = None # child to join, when continuing self._threadless_child = None # child, started with thread=False self._parent = None # parent task self._exc = None # exception occured self._delay = None # additional timespan in start or cont self._cont_data = None # data used for continuation assert not kwargs, 'unknown keyword arguments: ' + str(kwargs.keys()) assert isinstance(self._action, Callable) or \ isinstance(self._action, Repeated), \ "action needs to be a callable or a task" assert isinstance(self._args, tuple), 'args needs to be a tuple' assert isinstance(self._action, Callable) or \ len(self._args) <= 1, \ "only one argument for Repeated" assert isinstance(self._action, Callable) or \ len(self._args) == 0, \ "no args for tasks" assert isinstance(self._kwargs, dict), \ 'kwargs needs to be a dictionary' assert isinstance(self._action, Callable) or \ not self._kwargs, \ "no kwargs for tasks" if isinstance(self._action, Repeated): # if action is a Repeated, start it as a threadless child self._action = self._action.start self._kwargs['thread'] = False assert ( self._action_stop is None or isinstance(self._action_stop, Callable) ), "action_stop needs to be a callable" assert isinstance(self._args_stop, tuple), \ 'args_stop needs to be a tuple' assert isinstance(self._kwargs_stop, dict), \ 'kwargs_stop needs to be a dictionary' assert ( self._action_cont is None or isinstance(self._action_cont, Callable) ), "action_cont needs to be a callable" assert isinstance(self._args_cont, tuple), \ 'args_cont needs to be a tuple' assert isinstance(self._kwargs_cont, dict), \ 'kwargs_cont needs to be a dictionary' assert ( self._duration is None or isinstance(self._duration, Number) ), 'duration needs to be a number' assert self._duration is None or self._duration >= 0, \ 'duration needs to be positive' assert self._num is None or isinstance(self._num, int), \ 'num must be an integer' assert self._num is None or self._num > 0, 'num must be positive' assert isinstance(self._netto_time, bool), \ 'netto_time must be a bool value' assert ( self._exc_handler is None or isinstance(self._exc_handler, Callable) ), 'exc needs to be a callable'
def __init__(self, interval): self._interval = interval self._flag = 0 # self._cv = threading.Condition() self._cv = Condition()
from tkinter import * from threading import Thread from threading import Condition import seeker import exact_learning import shapes import math condition = Condition() class Game(Thread): def __init__(self, arena, movements, player_positions, rounds): Thread.__init__(self) self.arena = arena self.movements = movements self.player_positions = player_positions self.finished = False self.rounds = rounds def forget(Q, beta): for k in Q: Q[k] = beta * Q[k] def play(self): print("Catching a Moving Prey") # CS - Start position condition.acquire() self.player_positions.append( (self.arena.seeker.get_representation(), self.arena.prey)) condition.notify()
def __init__(self, size=10): self.empty_slots = size self.queue = deque() self.empty = Condition() self.full = Condition() self.lock = Lock()
def __init__(self, prog): self.program = prog self.condition = Condition()
class TrashPurgeScheduleHandler: MODULE_OPTION_NAME = "trash_purge_schedule" SCHEDULE_OID = "rbd_trash_trash_purge_schedule" lock = Lock() condition = Condition(lock) thread = None def __init__(self, module): self.module = module self.log = module.log self.last_refresh_pools = datetime(1970, 1, 1) self.init_schedule_queue() self.thread = Thread(target=self.run) self.thread.start() def run(self): try: self.log.info("TrashPurgeScheduleHandler: starting") while True: self.refresh_pools() with self.lock: (ns_spec, wait_time) = self.dequeue() if not ns_spec: self.condition.wait(min(wait_time, 60)) continue pool_id, namespace = ns_spec self.trash_purge(pool_id, namespace) with self.lock: self.enqueue(datetime.now(), pool_id, namespace) except Exception as ex: self.log.fatal("Fatal runtime error: {}\n{}".format( ex, traceback.format_exc())) def trash_purge(self, pool_id, namespace): try: with self.module.rados.open_ioctx2(int(pool_id)) as ioctx: ioctx.set_namespace(namespace) rbd.RBD().trash_purge(ioctx, datetime.now()) except Exception as e: self.log.error("exception when purgin {}/{}: {}".format( pool_id, namespace, e)) def init_schedule_queue(self): self.queue = {} self.pools = {} self.refresh_pools() self.log.debug("scheduler queue is initialized") def load_schedules(self): self.log.info("TrashPurgeScheduleHandler: load_schedules") schedules = Schedules(self) schedules.load() with self.lock: self.schedules = schedules def refresh_pools(self): if (datetime.now() - self.last_refresh_pools).seconds < 60: return self.log.debug("TrashPurgeScheduleHandler: refresh_pools") self.load_schedules() with self.lock: if not self.schedules: self.images = {} self.queue = {} self.last_refresh_pools = datetime.now() return pools = {} for pool_id, pool_name in get_rbd_pools(self.module).items(): with self.module.rados.open_ioctx2(int(pool_id)) as ioctx: self.load_pool(ioctx, pools) with self.lock: self.refresh_queue(pools) self.pools = pools self.last_refresh_pools = datetime.now() def load_pool(self, ioctx, pools): pool_id = str(ioctx.get_pool_id()) pool_name = ioctx.get_pool_name() pools[pool_id] = {} pool_namespaces = [''] try: pool_namespaces += rbd.RBD().namespace_list(ioctx) except rbd.OperationNotSupported: self.log.debug("namespaces not supported") except Exception as e: self.log.error("exception when scanning pool {}: {}".format( pool_name, e)) for namespace in pool_namespaces: pools[pool_id][namespace] = pool_name def rebuild_queue(self): with self.lock: now = datetime.now() # don't remove from queue "due" images now_string = datetime.strftime(now, "%Y-%m-%d %H:%M:00") for schedule_time in list(self.queue): if schedule_time > now_string: del self.queue[schedule_time] if not self.schedules: return for pool_id, namespaces in self.pools.items(): for namespace in namespaces: self.enqueue(now, pool_id, namespace) self.condition.notify() def refresh_queue(self, current_pools): now = datetime.now() for pool_id, namespaces in self.pools.items(): for namespace in namespaces: if pool_id not in current_pools or \ namespace not in current_pools[pool_id]: self.remove_from_queue(pool_id, namespace) for pool_id, namespaces in current_pools.items(): for namespace in namespaces: if pool_id not in self.pools or \ namespace not in self.pools[pool_id]: self.enqueue(now, pool_id, namespace) self.condition.notify() def enqueue(self, now, pool_id, namespace): schedule = self.schedules.find(pool_id, namespace) if not schedule: return schedule_time = schedule.next_run(now) if schedule_time not in self.queue: self.queue[schedule_time] = [] self.log.debug("schedule image {}/{} at {}".format( pool_id, namespace, schedule_time)) ns_spec = (pool_id, namespace) if ns_spec not in self.queue[schedule_time]: self.queue[schedule_time].append((pool_id, namespace)) def dequeue(self): if not self.queue: return None, 1000 now = datetime.now() schedule_time = sorted(self.queue)[0] if datetime.strftime(now, "%Y-%m-%d %H:%M:%S") < schedule_time: wait_time = (datetime.strptime(schedule_time, "%Y-%m-%d %H:%M:%S") - now) return None, wait_time.total_seconds() namespaces = self.queue[schedule_time] namespace = namespaces.pop(0) if not namespaces: del self.queue[schedule_time] return namespace, 0 def remove_from_queue(self, pool_id, namespace): empty_slots = [] for schedule_time, namespaces in self.queue.items(): if (pool_id, namespace) in namespaces: namespaces.remove((pool_id, namespace)) if not namespaces: empty_slots.append(schedule_time) for schedule_time in empty_slots: del self.queue[schedule_time] def add_schedule(self, level_spec, interval, start_time): self.log.debug( "add_schedule: level_spec={}, interval={}, start_time={}".format( level_spec.name, interval, start_time)) with self.lock: self.schedules.add(level_spec, interval, start_time) # TODO: optimize to rebuild only affected part of the queue self.rebuild_queue() return 0, "", "" def remove_schedule(self, level_spec, interval, start_time): self.log.debug( "remove_schedule: level_spec={}, interval={}, start_time={}".format( level_spec.name, interval, start_time)) with self.lock: self.schedules.remove(level_spec, interval, start_time) # TODO: optimize to rebuild only affected part of the queue self.rebuild_queue() return 0, "", "" def list(self, level_spec): self.log.debug("list: level_spec={}".format(level_spec.name)) with self.lock: result = self.schedules.to_list(level_spec) return 0, json.dumps(result, indent=4, sort_keys=True), "" def status(self, level_spec): self.log.debug("status: level_spec={}".format(level_spec.name)) scheduled = [] with self.lock: for schedule_time in sorted(self.queue): for pool_id, namespace in self.queue[schedule_time]: if not level_spec.matches(pool_id, namespace): continue pool_name = self.pools[pool_id][namespace] scheduled.append({ 'schedule_time' : schedule_time, 'pool_id' : pool_id, 'pool_name' : pool_name, 'namespace' : namespace }) return 0, json.dumps({'scheduled' : scheduled}, indent=4, sort_keys=True), "" def handle_command(self, inbuf, prefix, cmd): level_spec_name = cmd.get('level_spec', "") try: level_spec = LevelSpec.from_name(self, level_spec_name, allow_image_level=False) except ValueError as e: return -errno.EINVAL, '', "Invalid level spec {}: {}".format( level_spec_name, e) if prefix == 'add': return self.add_schedule(level_spec, cmd['interval'], cmd.get('start_time')) elif prefix == 'remove': return self.remove_schedule(level_spec, cmd.get('interval'), cmd.get('start_time')) elif prefix == 'list': return self.list(level_spec) elif prefix == 'status': return self.status(level_spec) raise NotImplementedError(cmd['prefix'])
def __init__(self): self._cond = Condition() self._running = False self._queue = deque() self._terminate_events = {} self._threads = []
def __init__(self, port=9500): Thread.__init__(self) self.app = Flask(__name__) self.port = port self.cv = Condition() self.document = None
def __init__(self): self.frame = None self.buffer = io.BytesIO() self.condition = Condition()
def __init__(self): self._current_packet_id = 0 self._request_response_map = {} self._new_response_condition = Condition() self._packet_id_lock = Lock() self._notification_callbacks = []