def __init__(self): self._tasks = set() self.queue = Queue() self.closed = Event()
def __init__(self): self.q = Queue()
async def connect(self) -> None: """Connect to the local OEF Node.""" if not self.connection_status.is_connected: self._reader = Queue() self._writer = await self._local_node.connect(self.address, self._reader) self.connection_status.is_connected = True
def service(): yield FilterService(Queue(), Queue())
from asyncio import Queue from hikcamerabot.event_engine.events.abstract import BaseOutboundEvent from hikcamerabot.event_engine.events.outbound import SendTextOutboundEvent _RESULT_QUEUE = Queue() def get_result_queue() -> Queue[BaseOutboundEvent | SendTextOutboundEvent]: return _RESULT_QUEUE
def __init__(self, message_queue: Queue = None) -> None: super(QueueOutputChannel).__init__() self.messages = Queue() if not message_queue else message_queue
def __init__(self): super().__init__() self._progress = Queue() self._progress_task = create_task(self._progress.get()) self._complete_task = create_task(self)
async def put(chat_id: int, **kwargs) -> int: if chat_id not in queues: queues[chat_id] = Queue() await queues[chat_id].put({**kwargs}) return queues[chat_id].qsize()
def __init__(self): self._uri = f"ws://{HOST}:{PORT}" self._txq = Queue() self._rxq = Queue()
def __init__(self, server: GameServer, bot: BotBase): GameConnection.__init__(self, server, f"<direct {id(self)}>") BotConnection.__init__(self, bot) self.send_queue = Queue() self.recv_queue = Queue() self.handshaked = True
def __init__(self, reader: object, writer: object, maxsize: int = 2**16): self.reader = reader self.writer = writer self.message_queue = Queue(maxsize=maxsize) self.frame = Frames(self.reader, self.writer)
def __init__(self): self.results = Queue() self.completed_queries = []
from fastapi import FastAPI, Request, Response, Path from asyncio import Queue import asyncio import json import random app = FastAPI(debug=True) queue = Queue(maxsize=10) # @app.exception_handler(AssertionError) # async def assertion_error_handler(_req: Request, exc: AssertionError): # print(exc) # return Response( # status_code=400, # content=json.dumps({"error": str(exc)}, ensure_ascii=False), # ) @app.api_route("/api/{api:path}", methods=['POST', 'GET', 'PUT', 'DELETE']) async def api_endpoint(req: Request, api: str): # put request in queue, to be verified on the other side queue.put_nowait(req) return {"api": api} @app.api_route("/error/{code}", methods=['POST', 'GET', 'PUT', 'DELETE']) async def error_endpoint(req: Request, code: int=Path(default=500)): return Response(status_code=int(code))
def __init__(self, log_channel_description, maxsize=100, **kwargs): self._discord_channel_description = log_channel_description super().__init__(**kwargs) self._log_queue = Queue(maxsize=maxsize) self._log_handler_thread = None self._webhook = None
def initialize(self, sub_server, resolvers): self.queue = Queue(100) self.subscription_server = sub_server self.resolvers = resolvers
def setUp(self, event_loop): self.golem_message = Ping() self.connection_id = 1 self.request_id = 777 self.queue = Queue(loop=event_loop) self.response_queue = Queue(loop=event_loop)
def __init__(self, keys, average_period_minutes=0): super().__init__(keys, average_period_minutes) self.queue = Queue()
async def connect(sid, environ): logger.info(f"Test Client {sid} Connected!") await sio.save_session(sid, {"environ": environ}) websocket.clients[sid] = Queue() sio.start_background_task(handle_ws_reverse, websocket, sid, environ)
def __init__(self, proxys): self.proxys = proxys self.q_proxys = Queue()
initial_users = [ "82L08CJG0", "2GRJC90L8", "8C2LPGJGV", "JYR20QGU", "QYJ9U228", "Y9YRGV8R", "299JQ2LYR", "2CJLYYY0", "LYPUC9YL", "2LVQGUGRJ", "82V2L9JLG", "2LJCJGUGY", "9QR9PLV8J", "8GJY8UQ8", "RPY0QJCP", "8J0YJ99JU", "8GGL80PCC", "RJLJ00P2", "2PJPVRJ9C", "JC0LRYCU", "2UP0QLJG", "YCL0GJ82", "L90YGLC9", "2RRUPQC0U", "P299QV0L", "8QJY9RP2Q", "8LYRLJYCR", "V9CPRG", "RCG99YVC", "C2J228YQ", "GP2RPCQ8", "2Q22UURYR", "28GYV0LQL", "28JCUCRG", "8VYQPR9R", "890YQQCG", "YPU9U0Q9", "P0RRUGQ8V", "80JQPRGU8", "2GU2CJGL2", "P0VVY2GY", "UYV920U" ] MAX_DECKS = 100000 MAX_USERS = 100000 MAX_TASKERS = 32 # len(initiall_users) queue = Queue() for initial_user in initial_users: queue.put_nowait(initial_user) processor = BattlesProcessor() users = set() | set(initial_users[:MAX_TASKERS]) decks = [] taskers = [] for i in range(MAX_TASKERS): taskers.append(scrap("Task " + str(i), queue, users, decks)) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.wait(taskers)) loop.close()
import re from fake_useragent import UserAgent import json import asyncio import aiohttp from asyncio import Queue import csv from lxml import etree re_url = 'https://blog.csdn.net/api/articles?type=more&category=home&shown_offset=' url_queue = Queue(maxsize=1000) old_urls = set() ua = UserAgent() headers = { 'User-Agent': ua.chrome, 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8', 'accept-encoding': 'gzip, deflate, br', 'accept-language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7', } file_name = 'CSDN.csv' async def csv_writer_headers(file_name): with open(file_name, 'w', encoding='utf-8') as f: writer = csv.DictWriter( f, ['网页', '文章标题', '创建时间', '作者', '阅读量', '点赞数', '评论数', '详细内容']) writer.writeheader()
def create_listener(self): queue = Queue() self._microphone.add(queue) listener = Listener(self._microphone, queue) return listener
from asyncio import Queue from asyncpg.connection import Connection from .mockpreparedstmt import MockPreparedStatement results = Queue() completed_queries = [] class MockConnection(Connection): # __slots__ = Connection.__slots__ def __init__(self): pass @property def completed_queries(self): return completed_queries @property def results(self): return results @results.setter def results(self, result): global results results = result async def general_query(self, query, *args, **kwargs): completed_queries.append((query, *args, kwargs))
def __init__(self, creator: Callable): self._creator = creator self._queue = Queue() self._executor = ProcessPoolExecutor() self._loop = None
def __init__(self, roots, exclude=None, strict=True, max_redirect=10, proxy=None, max_tries=4, user_agents=None, max_tasks=10, time_out=15, allowed_paths=None, item_paths=None, *, loop=None): if not loop: asyncio.set_event_loop_policy(uvloop.EventLoopPolicy()) self.loop = asyncio.get_event_loop() else: self.loop = loop self.roots = roots self.exclude = exclude self.strict = strict self.max_redirect = max_redirect # self.proxy = proxy self.max_tries = max_tries self.max_tasks = max_tasks self.time_out = time_out self.q = Queue(loop=self.loop) self.seen_urls = set() self.done = [] self._session = aiohttp.ClientSession(loop=self.loop) self.root_domains = set() self._allowed_paths = None if allowed_paths: self._allowed_paths = allowed_paths self._item_paths = None if item_paths: self._item_paths = item_paths for root in roots: parts = urllib.parse.urlparse(root) host, port = urllib.parse.splitport(parts.netloc) if not host: continue if re.match(r'\A[\d\.]*\Z', host): self.root_domains.add(host) else: host = host.lower() if self.strict: self.root_domains.add(host) else: self.root_domains.add(lenient_host(host)) for root in roots: self.add_url(root) self.user_agents = self.USER_AGENTS if user_agents: self._user_agents = user_agents self.t0 = time.time() self.t1 = None
class AudioQueue: queue: Queue = Queue() client: Optional[discord.VoiceClient] = None playback_task: Optional[Task] = None on_empty_task: Optional[Task] = None volume: float = 0.7 def start(self, client): if self.client: return self.client = client self.playback_task = asyncio.create_task(self._playback()) def stop(self): if self.playback_task: self.playback_task.cancel() self.playback_task = None if self.on_empty_task: self.on_empty_task.cancel() self.on_empty_task = None if self.client: self.client.stop() self.client = None self.queue = Queue() def set_queue_source(self, source: Callable[[], Awaitable[Union[Iterable[str], str]]]): if not self.playback_task: raise RuntimeError('Playback not active.') if self.on_empty_task: self.on_empty_task.cancel() async def on_empty(): while True: await self.queue.join() next_audio = await source() if isinstance(next_audio, Iterable): for audio in next_audio: self.queue.put_nowait(audio) else: self.queue.put_nowait(next_audio) self.on_empty_task = asyncio.create_task(on_empty()) def enqueue(self, audio): if not self.playback_task: raise RuntimeError('Playback not active.') self.queue.put_nowait(audio) async def _playback(self): playback_finished = asyncio.Event() def after(_err): playback_finished.set() while True: next_audio = await self.queue.get() source = discord.PCMVolumeTransformer( discord.FFmpegPCMAudio(next_audio)) source.volume = self.volume self.client.play(source, after=after) await playback_finished.wait() playback_finished.clear() self.queue.task_done()
def __init__(self, ack_callback: Callable[[int], None]) -> None: self._ack_callback = ack_callback self._eof = False self._unacked: 'Queue[UnackedData]' = Queue() self._acked: 'Deque[AckedData]' = deque() self._acked_size = 0
""" Различные события, которые нужно пересылать клиентам. Доступные типы событий: * Клиент открыл диалог(написал новое сообщение в тех. поддержку), это уведомление получат все пользователи. * Клиент написал сообщение * Новое сообщение от техподдержки """ from asyncio import Queue from enum import Enum events_queue = Queue() subscribed_users = [] class EventType(Enum): """ Тип события. Доступные значения: * NEW_UNASSIGNED_DIALOG_MESSAGE: новое сообщение в диалоге без назначенного пользователя """ NEW_UNASSIGNED_DIALOG_MESSAGE = "NEW_UNASSIGNED_DIALOG_MESSAGE" class Event: """ Событие в системе """ def __init__(self, event_type: EventType, payload: dict) -> None: super().__init__() self.event_type = event_type
axis = { 0: 'ABS_X', 1: 'ABS_Y', 2: 'ABS_RX', 5: 'ABS_RY', 9: 'ABS_Z', 10: 'ABS_RZ', 16: 'ABS_HAT0X', 17: 'ABS_HAT0Y', } button = {} q = Queue() async def get_gamepad(): return await q.get() async def run_controller(): global q dev = None while True: if dev is None: devices = list_devices() if len(devices) == 0: print("Device not found... Trying again in 3s") await asyncio.sleep(3)
async def send(self, frames: list, channel: 'Channel'): self.frames = self.set_sequence_no(frames) current_frames = self.frames[self.window_start:self.window_size] print(list(map(lambda x: x.payload['seq_no'], current_frames))) await channel.connect(self) print(self.name, " :\t sending first batch of frames, window size:", self.window_size) for i in current_frames: await self.out_queue.put(i) while self.window_start <= self.window_end: while True: try: await asyncio.wait_for(channel.transmit(self), timeout=12) val = await asyncio.wait_for(self.in_queue.get(), timeout=10) val = int(str(val), 2) % self.window_size # print("val", val, 'abc', current_frames[0].payload['seq_no'] + 1) if val == ((current_frames[0].payload['seq_no'] + 1) % self.window_size): print(self.name, " :\t ACK for seq_no", val, "received successfully!") del current_frames[0] self.window_start += 1 if self.window_end < len(frames) - 1: self.window_end += 1 current_frames.append(frames[self.window_end]) # print(self.window_start, self.window_end) print( list( map(lambda x: x.payload['seq_no'], current_frames))) if current_frames: print(self.name, " :\t Frame with seq_no", current_frames[-1].payload['seq_no'], "sent in the window!") await self.out_queue.put(current_frames[-1]) break else: print( self.name, " :\tThere seems to be an error, retransmitting the current window" ) await asyncio.sleep(1) del self.out_queue self.out_queue = Queue() for i in current_frames: await self.out_queue.put(i) except asyncio.TimeoutError as e: print(self.name, " :\tTimed Out!", e) await asyncio.sleep(1) print(self.name, " :\tRetransmitting the current window.") del self.out_queue # ! Changed self.out_queue = Queue() # ! Changed for i in current_frames: await self.out_queue.put(i) await asyncio.sleep(3) await asyncio.sleep(1) print(self.name, " :\tTransmission was successful!")