def __init__(self, plugins_manager: PluginManager, session: Session = None): self.logger = logging.getLogger(__name__ + "." + self.__class__.__name__) if session: self._init_session(session) else: self.session = None self.stream = None self.plugins_manager = plugins_manager self._tg = plugins_manager._tg self._reader_task = None self._sender_task = None self._reader_stopped = anyio.create_event() self._sender_stopped = anyio.create_event() self._send_q = anyio.create_queue(10) self._puback_waiters = dict() self._pubrec_waiters = dict() self._pubrel_waiters = dict() self._pubcomp_waiters = dict() self._disconnecting = False self._disconnect_waiter = None self._write_lock = anyio.create_lock()
def __new__(cls, service, id): # pylint: disable=redefined-builtin family_id, code, chksum = split_id(id) cls = dev_classes.get(family_id) # pylint: disable=self-cls-assignment if cls is None: class cls(Device): # pylint: disable=function-redefined family = family_id cls.__name__ = "Device_%02x" % (family_id, ) dev_classes[family_id] = cls self = object.__new__(cls) self.id = id.upper() self.family = family_id self.code = code self.chksum = chksum self.service = service self.bus = None self._unseen = 0 self._events = [] self._wait_bus = anyio.create_event() self._poll = {} # name > poll task scopes self._intervals = {} self._task_lock = anyio.create_lock() return self
async def run(self, evt: anyio.abc.Event=None): """ Process my events. Override+call this e.g. for overall timeouts:: async def run(self): async with anyio.fail_after(30): await super().run() This method creates a runner task that do the actual event processing. A new runner is started if processing an event takes longer than 0.1 seconds. Do not replace this method. Do not call it directly. """ log.debug("SetupRun %r < %r", self, getattr(self, '_prev', None)) if evt is not None: await evt.set() await self.on_start() if self._ready is not None: await self._ready.set() self._proc_lock = anyio.create_lock() while True: if self._n_proc == 0: await self.taskgroup.spawn(self._process, name="Worker " + self.ref_id) self._proc_check = anyio.create_event() await anyio.sleep(0.1) await self._proc_check.wait()
def __init__(self, name, channel, number, prio=0, **kw): self.name = name self.channel = channel self.number = number self._prio = prio for k, v in kw.items(): setattr(self, k, v) self.lock = anyio.create_lock()
async def _get_config_dict_lock(self): # TODO: make this multithreaded? if self._config_dict_lock is None: self._config_dict_lock = anyio.create_lock() return self._config_dict_lock
async def test_acquire_nowait_wouldblock(self): async def try_lock(): pytest.raises(WouldBlock, lock.acquire_nowait) lock = create_lock() async with lock, create_task_group() as tg: assert lock.locked() tg.spawn(try_lock)
def __init__(self, tg, host="localhost", port=7373): type(self)._conn_id += 1 self._conn_id = type(self)._conn_id self.tg = tg self.host = host self.port = port self._socket = None self._seq = 0 self._handlers = {} self._send_lock = anyio.create_lock()
def __init__(self, sock: anyio.SocketStream): """ :param sock: The :class:`anyio.SocketStream` used to connect this redis database. """ self._sock = sock self._parser_lock = anyio.create_lock() self._parser = hiredis.Reader() self._pipeline = None self._closed = False
def __init__(self, bucket: Bucket, response: Response): self.bucket = bucket # These values will be set later. self._date = None self._remaining = 0 self._reset = None self.lock = anyio.create_lock() self.update(response)
def __init__(self, service, host="localhost", port=4304): self.service = service self.host = host self.port = port self.stream = None self._msg_proto = None self.requests = deque() self._wqueue = anyio.create_queue(100) self._scan_task = None self._buses = dict() # path => bus self._scan_lock = anyio.create_lock() self._scan_args = {}
def __init__(self, taskgroup, host, port=59995, freq=None, ping_freq=None): self.task_group = taskgroup self.host = host self.port = port if freq is not None: self.freq = freq if ping_freq is not None: self.ping_freq = freq self._ports = {} self._cmds = [] self._send_lock = anyio.create_lock()
async def __new__(cls): self = super().__new__(cls) self._handlers = [] self._command_lock = anyio.create_lock() import sys self._keepalive = sys._getframe() async with anyio.create_task_group() as self._group: proc = await anyio.run_process(["i3", "--get-socketpath"]) path = proc.stdout.decode().strip() async with await anyio.connect_unix(path) as self._sock: await self._group.spawn(self._loop) yield self await self._group.cancel_scope.cancel()
async def test_lock_cancel(self): async def task(): nonlocal task_started, got_lock task_started = True async with lock: got_lock = True task_started = got_lock = False lock = create_lock() async with create_task_group() as tg: async with lock: await tg.spawn(task) await tg.cancel_scope.cancel() assert task_started assert not got_lock
async def test_lock(self): async def task(): assert lock.locked() async with lock: results.append('2') results = [] lock = create_lock() async with create_task_group() as tg: async with lock: await tg.spawn(task) await wait_all_tasks_blocked() results.append('1') assert not lock.locked() assert results == ['1', '2']
def __init__(self, service, host="localhost", port=4304, name=None): self.service = service self.host = host self.port = port self.name = name or host self.stream = None self._msg_proto = None self.requests = deque() self._wqueue_w, self._wqueue_r = anyio.create_memory_object_stream(100) self._read_task = None self._write_task = None self._scan_task = None self._buses = dict() # path => bus self._scan_lock = anyio.create_lock() self._scan_args = None self._backoff = 2 self._current_tg = None self._current_run = None
async def test_statistics(self): async def waiter(): async with lock: pass lock = create_lock() async with create_task_group() as tg: assert not lock.statistics().locked assert lock.statistics().tasks_waiting == 0 async with lock: assert lock.statistics().locked assert lock.statistics().tasks_waiting == 0 for i in range(1, 3): tg.spawn(waiter) await wait_all_tasks_blocked() assert lock.statistics().tasks_waiting == i assert not lock.statistics().locked assert lock.statistics().tasks_waiting == 0
def __init__(self, protocol, channel_id): self.protocol = protocol self.channel_id = channel_id self.consumer_queues = {} self.consumer_callbacks = {} self.response_future = None self.close_event = anyio.create_event() self.cancelled_consumers = set() self.last_consumer_tag = None self.publisher_confirms = False self.delivery_tag_iter = None # counting iterator, used for mapping delivered messages # to publisher confirms self._write_lock = anyio.create_lock() self._futures = {} self._ctag_events = {}
def __init__(self, links, name, *, timeout, mode="dtmf", info="-", src=None, dst=None, **kw): self.name = name self.mode = importlib.import_module("calltest.mode." + mode).Worker self.src = links[src] if src is not None else None self.dst = links[dst] if dst is not None else None self.info = info self.timeout = timeout self.state = attrdict(status="new", ct_wait=0, ct_run=0) self.state.t_start = time.time() for k, v in kw.items(): setattr(self, k, v) self.lock = anyio.create_lock()
async def test_manual_acquire(self): async def task(): assert lock.locked() await lock.acquire() try: results.append('2') finally: lock.release() results = [] lock = create_lock() async with create_task_group() as tg: await lock.acquire() try: tg.spawn(task) await wait_all_tasks_blocked() results.append('1') finally: lock.release() assert not lock.locked() assert results == ['1', '2']
def __init__(self): self._buckets = {} self.global_lock = anyio.create_lock()
def lock(): return anyio.create_lock()
async def test_lock_release(self): lock = create_lock() lock.acquire_nowait() with pytest.deprecated_call(): await lock.release()
async def test_acquire_nowait(self): lock = create_lock() lock.acquire_nowait() assert lock.locked()
def __init__(self, stream: ByteStream) -> None: self.stream = stream self.read_lock = create_lock() self.write_lock = create_lock()
async def main(): lock = create_lock() async with create_task_group() as tg: for num in range(4): await tg.spawn(use_resource, num, lock)
def __init__(self, stream): self.stream = stream self.lock = anyio.create_lock()
def __init__(self, *a, **kw): self._a = a self._kw = kw self._send_lock = anyio.create_lock() self._receive_lock = anyio.create_lock()
async def _get_index_lock(self) -> Lock: if self._index_lock is None: self._index_lock = create_lock() return self._index_lock
def __init__(self, sock): self.sock = sock self.lock = anyio.create_lock()
def __init__(self) -> None: self._lock = create_lock()
async def _get_init_lock(self): if self._init_lock is None: self._init_lock = anyio.create_lock() return self._init_lock