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!")
