async def read_async(self, event_loop: asyncio.AbstractEventLoop) -> bytes:
done = asyncio.Event(loop=event_loop)
def read_cb() -> None:
try:
self.__read_internal()
except OSError:
event_loop.remove_reader(self.fd_in)
done.set()
return
except:
event_loop.remove_reader(self.fd_in)
raise
if self.__reader_done:
event_loop.remove_reader(self.fd_in)
done.set()
self.__reader_start()
event_loop.add_reader(self.fd_in, read_cb)
await done.wait()
if self.__reader_done:
return self.__reader_response
else:
raise OSError("Failed to read from connection")
def __init__(self,
sock_fam: socket.AddressFamily,
icmp_proto: int,
src: IPAddressType,
send_limiter: TokenBucket,
*,
loop: asyncio.AbstractEventLoop = None) -> None:
tcp_sock = socket.socket(sock_fam, socket.SOCK_RAW, socket.IPPROTO_TCP)
icmp_sock = socket.socket(sock_fam, socket.SOCK_RAW, icmp_proto)
for sock in (tcp_sock, icmp_sock):
sock.setblocking(False)
sock.setsockopt(socket.SOL_SOCKET, _SO_RCVBUFFORCE, 8_388_608)
sock.bind((str(src), 0))
if loop is None:
loop = asyncio.get_event_loop()
loop.add_reader(tcp_sock.fileno(), self._handle_read)
loop.add_reader(icmp_sock.fileno(), self._handle_icmp_read)
loop.add_writer(tcp_sock.fileno(), self._handle_write)
self._sock = tcp_sock
self._icmp_sock = icmp_sock
self._src_addr: IPAddressType = src
self._test_map: Dict[Tuple[int, bytes, int],
"BaseTest[IPAddressType]"] = {}
self._send_queue: Deque[OutgoingPacket[IPAddressType]] = deque()
self._send_limiter = send_limiter
self._sent_rsts: Dict[Tuple[int, bytes, int], int] = {}
self._loop = loop
def __init__(self, loop: asyncio.AbstractEventLoop,
device_registry: BluetoothDeviceRegistry):
return
self.dev = evdev.InputDevice(mouse_event_device)
self.hidraw = os.open(mouse_raw_device, os.O_RDWR | os.O_NONBLOCK)
self.dev.grab()
self.device_registry = device_registry
self.loop = loop
loop.add_reader(self.hidraw, self.mouse_event)
def setup_listener(self, qtile: "Qtile",
eventloop: asyncio.AbstractEventLoop) -> None:
"""Setup a listener for the given qtile instance
:param qtile:
The qtile instance to dispatch events to.
:param eventloop:
The eventloop to use to listen to the file descriptor.
"""
logger.debug("Adding io watch")
self.qtile = qtile
fd = self.conn.conn.get_file_descriptor()
eventloop.add_reader(fd, self._xpoll)
def __init__(self, event_loop: AbstractEventLoop, device="/dev/ttyUSB0"):
"""Create and open a new connection to an Optolink device."""
self.device = device
self.loop = event_loop
# timeout=0 for non-blocking reads
self.port = serial.Serial(
self.device,
4800,
parity=serial.PARITY_EVEN,
stopbits=serial.STOPBITS_TWO,
timeout=0,
)
self.read_queue = asyncio.Queue()
event_loop.add_reader(self.port.fileno(), self._read_serial)
def start_door_switch_watcher(self, loop: asyncio.AbstractEventLoop,
update_door_state: Callable[[DoorState],
None]):
current_door_value = self.read_window_switches()
if current_door_value == 0:
update_door_state(DoorState.OPEN)
else:
update_door_state(DoorState.CLOSED)
try:
door_fd = self.lines['window_door_sw'].event_get_fd()
loop.add_reader(door_fd, _event_callback, update_door_state,
self.get_door_state)
except Exception:
MODULE_LOG.exception(
"Failed to add fd reader, cannot not monitor window door "
"switch properly")
def __init__(self, device: _Device, filter: HIDMessageFilter,
loop: asyncio.AbstractEventLoop, device_registry: HIDDeviceRegistry):
self.loop = loop
self.filter = filter
self.device_registry = device_registry
self.device_id = device["instance"]
self.device_class = device["id"]
self.name = device["name"]
self.hidraw = cast(str, device["hidraw"])
self.events = cast(List[str], device["events"])
self.events_devices = []
for event in self.events:
event_device = evdev.InputDevice('/dev/input/'+event)
event_device.grab()
self.events_devices.append(event_device)
self.hidraw_file: Optional[int] = os.open('/dev/'+self.hidraw, os.O_RDWR | os.O_NONBLOCK)
loop.add_reader(self.hidraw_file, self.hidraw_event)
print("HID Device ",self.device_id," created")
async def start_client(loop: asyncio.AbstractEventLoop, url: str) -> None:
name = input("Please enter your name: ")
# input reader
def stdin_callback() -> None:
line = sys.stdin.buffer.readline().decode("utf-8")
if not line:
loop.stop()
else:
ws.send_str(name + ": " + line)
loop.add_reader(sys.stdin.fileno(), stdin_callback)
async def dispatch() -> None:
while True:
msg = await ws.receive()
if msg.type == aiohttp.WSMsgType.TEXT:
print("Text: ", msg.data.strip())
elif msg.type == aiohttp.WSMsgType.BINARY:
print("Binary: ", msg.data)
elif msg.type == aiohttp.WSMsgType.PING:
await ws.pong()
elif msg.type == aiohttp.WSMsgType.PONG:
print("Pong received")
else:
if msg.type == aiohttp.WSMsgType.CLOSE:
await ws.close()
elif msg.type == aiohttp.WSMsgType.ERROR:
print("Error during receive %s" % ws.exception())
elif msg.type == aiohttp.WSMsgType.CLOSED:
pass
break
# send request
async with aiohttp.ClientSession() as client:
async with client.ws_connect(url, autoclose=False,
autoping=False) as ws:
await dispatch()
async def setup_server(loop: asyncio.AbstractEventLoop) -> None:
loop.create_task(heartbeat())
loop.add_reader(sys.stdin.fileno(), process_stdin)
loop.add_signal_handler(signal.SIGINT, ask_exit)
async def _watch(self, loop: AbstractEventLoop):
future = asyncio.Future()
loop.add_reader(self.fd, future.set_result, None)
future.add_done_callback(lambda _: loop.remove_reader(self.fd))
await future
async def wait_for_reader(fd: Union[int, io.BufferedReader], loop: asyncio.AbstractEventLoop) -> None:
f: asyncio.Future = asyncio.Future()
loop.add_reader(fd, f.set_result, None)
f.add_done_callback(lambda f: loop.remove_reader(fd))
await f
