本文整理汇总了Python中selectors.DefaultSelector.unregister方法的典型用法代码示例。如果您正苦于以下问题:Python DefaultSelector.unregister方法的具体用法?Python DefaultSelector.unregister怎么用?Python DefaultSelector.unregister使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类selectors.DefaultSelector
的用法示例。
在下文中一共展示了DefaultSelector.unregister方法的11个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
def __init__(self):
self.sel = DefaultSelector()
self.queue = deque()
def create_task(self, coro):
sock = coro.send(None)
self.sel.register(sock, EVENT_WRITE, coro)
self.queue.append(coro)
def run(self):
while self.queue:
events = self.sel.select()
for key, _ in events:
coro = key.data
event = key.events
file_obj = key.fileobj
self.sel.unregister(file_obj)
try:
if event == EVENT_WRITE:
self.sel.register(file_obj, EVENT_READ, coro)
elif event == EVENT_READ:
self.sel.register(file_obj, EVENT_WRITE, coro)
coro.send(None)
except StopIteration:
self.queue.popleft()
except:
pass
else: return
示例2: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
def __init__(self):
self.ready = deque()
self.selector = DefaultSelector()
self.futures = {}
def create_task(self, task):
self.ready.append(task)
def run_forever(self):
while True:
while not self.ready:
completed_futures = [future for future in self.futures if not future.running()]
for future in completed_futures:
self.ready.append(self.futures.pop(future))
# so select() is blocking. If set a negative time out it won't block.
events = self.selector.select(-1)
# add these socket events and unregister them from listened to:
for key, _ in events:
self.ready.append(key.data) # add the task to the ready queue
self.selector.unregister(key.fileobj)
while self.ready:
self.current_task = self.ready.popleft()
# try to run current_task...
try:
# run task to next yield point
reason, what = self.current_task.send(None)
# reason, what = self.current_task.send(None)
if reason == 'waiting_to_accept':
self.selector.register(what, EVENT_READ, self.current_task)
elif reason == 'waiting_to_read':
self.selector.register(what, EVENT_READ, self.current_task)
elif reason == 'waiting_to_write':
self.selector.register(what, EVENT_WRITE, self.current_task)
elif reason == 'waiting_for_future':
self.futures[what] = self.current_task
else:
raise RuntimeError(
'Something bad happened... er. reason={}'.format(reason))
except StopIteration:
pass
async def sock_recv(self, sock, maxbytes):
# wait to read from the socket
await read_wait(sock)
return sock.recv(maxbytes)
async def sock_accept(self, sock):
# wait to read/hear from the socket
await accept_wait(sock)
return sock.accept()
async def sock_sendall(self, sock, data):
while data:
# wait to be able to write to the socket
await write_wait(sock)
nsent = sock.send(data)
data = data[nsent:]
def run_in_executor(self, executor, func, *args):
return executor.submit(func, *args)
示例3: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
def __init__(self):
self.ready = deque()
self.selector = DefaultSelector()
async def sock_recv(self, sock, maxbytes):
await read_wait(sock)
return sock.recv(maxbytes)
async def sock_accept(self, sock):
await read_wait(sock)
return sock.accept()
async def sock_sendall(self, sock, data):
while data:
try:
nsent = sock.send(data)
data = data[nsent:]
except BlockingIOError:
await write_wait(sock)
def create_task(self, coro):
self.ready.append(coro)
def run_forever(self):
while True:
while not self.ready:
events = self.selector.select()
for key, _ in events:
self.ready.append(key.data)
self.selector.unregister(key.fileobj)
while self.ready:
self.current_task = self.ready.popleft()
try:
op, *args = self.current_task.send(None)
getattr(self, op)(*args)
except StopIteration:
pass
def read_wait(self, sock):
self.selector.register(sock, EVENT_READ, self.current_task)
def write_wait(self, sock):
self.selector.register(sock, EVENT_WRITE, self.current_task)
示例4: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
def __init__(self):
self.ready = deque()
self.selector = DefaultSelector()
def create_task(self, task):
self.ready.append(task)
def run_forever(self):
while True:
# hmmn, nothing to run -> must be waiting on stuff...
while not self.ready:
events = self.selector.select()
# add these events and unregister them from listened to:
for key, _ in events:
self.ready.append(key.data)
self.selector.unregister(key.fileobj)
while self.ready:
self.current_task = self.ready.popleft()
# try to run current_task...
try:
# run task to next yield point
reason, sock = next(self.current_task)
if reason == 'waiting_to_accept':
self.selector.register(sock, EVENT_READ, self.current_task)
elif reason == 'waiting_to_read':
self.selector.register(sock, EVENT_READ, self.current_task)
elif reason == 'waiting_to_write':
self.selector.register(sock, EVENT_WRITE, self.current_task)
else:
raise RuntimeError('Something bad happened... er. reason={}'.format(reason))
except StopIteration:
pass
def sock_recv(self, sock, maxbytes):
# wait to read from the socket
return sock.recv(maxbytes)
def sock_accept(self, sock):
# wait to read/hear from the socket
return sock.accept()
def sock_sendall(self, sock, data):
while data:
# wait to be able to write to the socket
nsent = sock.send(data)
data = data[nsent:]
示例5: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
def __init__(self):
self.ready = deque()
self.selectors = DefaultSelector() # a way to watch socket IO
async def sock_recv(self, sock, maxbytes):
await read_wait(sock) # wait for something happen
return sock.recv(maxbytes)
async def sock_accept(self, sock):
await read_wait(sock)
return sock.sock_accept()
async def sock_sendall(self, sock, data):
while data :
try:
nsent = sock.send(data)
data = data[nsent:] # send partial data
except BlockingIOError:
await write_wait(sock)
def create_task(self, coro):
self.ready.append(coro)
def run_forever(self):
while True:
while not self.ready:
events = self.selectors.select()
for key, _ in events:
self.ready.append(key.data)
self.selectors.unregister(key.fileobj)
while self.ready:
self.current_task = self.ready.popleft()
try:
op, *args = self.current_task.send(None) # run to the yield
getattr(self,op)(*args) # Sneaky method call
except StopIteration:
pass
def read_wait(self, sock):
self.selectors.register(sock, EVENT_READ, self.current_task)
def write_wait(self, sock):
self.selectors.register
示例6: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class TCPServer:
def __init__(self, port):
self.port = port
self.sock = None
self.selector = DefaultSelector()
# Advance self.listen() method. A future has been attached to the
# server socket, that has been registered in selector. And a callback
# has been attached to this future.
Task(self.listen())
def run(self):
while True:
ready = self.selector.select()
for key, events in ready:
fut = key.data
fut.resolve()
def listen(self):
server_sock = self._create_socket()
with server_sock:
try:
client_sock, remote_addr = self.sock.accept()
except BlockingIOError:
pass
fut = Future()
self.selector.register(self.sock, EVENT_READ, fut)
while True:
yield fut
Task(self.handle_client())
def handle_client(self):
client_sock, remote_addr = self.sock.accept()
client_sock.setblocking(False)
client_name = '{} {}'.format(*client_sock.getpeername())
print('Connected', client_name)
# Register client socket for reading and wait for this event
fut = Future()
self.selector.register(client_sock, EVENT_READ, fut)
yield fut
buffer = []
while True:
try:
chunk = client_sock.recv(1024)
buffer.append(chunk)
except BlockingIOError:
# Yield the same future, so we don't need to register
# it again. By the way, callback is the same for all
# futures, so it doesn't matter in my case.
yield fut
continue
print('Received chunk from client', client_name)
if chunk.endswith(b'end'):
print('Got all data from client', client_name)
request = b''.join(buffer).decode('utf8')
response = (request.upper() * 100).encode('utf8')
self.selector.unregister(client_sock)
fut = Future()
self.selector.register(client_sock, EVENT_WRITE, fut)
break
# This future was attached to the client_sock
yield fut
while True:
try:
bytes_sent = client_sock.send(response)
print(bytes_sent, 'bytes sent to client', client_name)
response = response[bytes_sent:]
except BlockingIOError:
print('Socket blockes for', client_name)
yield fut
continue
else:
if not response:
# All response sent
print('Response sent to client', client_name)
self.selector.unregister(client_sock)
client_sock.close()
break
def _create_socket(self):
self.sock = socket.socket()
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 10)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind(('', self.port))
self.sock.setblocking(False)
self.sock.listen(10)
self.responses = {}
return self.sock
示例7: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
"""
Событийный цикл, который использует очередь сдвухсторонним доступом
Цикл опрашивает селектор на предмет готовности событий для чтения и записи
в сокет
"""
def __init__(self):
"""
Конструктор событийного цикла, который хранит очередь
:return:
"""
self.ready = deque()
self.selector = DefaultSelector()
async def sock_recv(self, sock, max_bytes):
"""
курутина для чтения данных из сокета в асинхронный способ
:param sock: дескриптор сокета
:param max_bytes: максимальное количество байт, который могут быть
прочитаны за один раз без блокировки
:return: принятые из сокета данные в банарном виде
"""
await read_wait(sock)
return sock.recv(max_bytes)
async def sock_accept(self, sock):
await read_wait(sock)
return sock.accept()
async def sock_sendall(self, sock, data):
while data:
try:
n_sent = sock.send(data)
data = data[n_sent:]
except BlockingIOError:
await write_wait(sock)
def create_task(self, coro):
self.ready.append(coro)
def run_forever(self):
while True:
while not self.ready:
events = self.selector.select()
for key, _ in events:
self.ready.append(key.data)
self.selector.unregister(key.fileobj)
while self.ready:
self.current_task = self.ready.popleft()
try:
# запускаем генератор до появления yield
op, *args = self.current_task.send(None)
getattr(self, op)(*args)
except StopIteration:
pass
def read_wait(self, sock):
self.selector.register(sock, EVENT_READ, self.current_task)
def write_wait(self, sock):
self.selector.register(sock, EVENT_WRITE, self.current_task)
示例8: SimpleServer
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class SimpleServer(object):
""" This is a simple server receiving and sending utf-8 plain text lines
over TCP/IP. It should use epoll or other efficient mechanisms if
available to support a large number of clients without cpu hogging.
All data sent to connections will be utf-8 encoded. All received lines
from clients are expected to be utf-8 encoded.
Lines longer than 10KB will be quietly dropped.
"""
def __init__(self, port, callback):
logging.basicConfig(level=logging.INFO)
self.clients_kept_for_sending = []
self.selector = DefaultSelector()
self.callback = callback
self.server_socket = socket.socket(family=socket.AF_INET6,
type=socket.SOCK_STREAM)
self.server_socket.bind(("::0", port))
self.server_socket.listen(5)
self.selector.register(self.server_socket, EVENT_READ, data=None)
self.server_socket.setblocking(False)
def close(self):
self.server_socket.close()
def _remove_socket(self, socket):
try:
self.selector.unregister(socket)
except KeyError:
pass
def _handle_new_client(self, socket, addr):
client = SimpleClient(socket, self, addr)
self.selector.register(socket, EVENT_READ, data=client)
self.callback(client)
def _mark_client_for_sending(self, client, marked):
if marked:
self.selector.modify(client.socket, EVENT_READ | EVENT_WRITE,
data=client)
else:
self.selector.modify(client.socket, EVENT_READ, data=client)
def tick(self, timeout=0):
""" This will check for any server events and process them.
If timeout is greater than zero, it will wait at most that
amount of time in seconds until something happens.
(This is useful if you want to save some cpu time and you have
nothing else to do)
For debugging purposes, it returns the amount of events processed.
"""
# get rid of old connections we kept around for sending:
entry_removed = True
while entry_removed:
entry_removed = False
for entry in self.clients_kept_for_sending:
if entry[1] <= time.time() or len(entry[0].send_buffer) == 0:
try:
entry[0].close()
except:
pass
self.clients_kept_for_sending.remove(entry)
entry_removed = True
# wait for socket events:
events = self.selector.select(timeout=timeout)
events_processed = 0
for key, mask in events:
if mask & EVENT_READ != 0:
events_processed = events_processed + 1
# handle accept for server socket:
if key.data == None:
conn, addr = self.server_socket.accept()
self._handle_new_client(conn, addr)
continue
# handle client socket receive:
key.data._do_recv()
continue
if mask & EVENT_WRITE != 0:
events_processed = events_processed + 1
# handle client socket send:
key.data._do_outstanding_send()
continue
logging.debugging("unknown socket event happening, bug?")
return events_processed
示例9: print
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
request_callback = lambda sock: sock.send(request.encode())
response_callback = lambda sock: \
print((sock.recv(1000)).decode().split("\n")[-1], 'finish at %s' % str(datetime.now())[:-7])
def get():
sock = socket.socket()
sock.setblocking(False)
try:
sock.connect(('localhost', 3000))
except:
pass
sel.register(sock, EVENT_WRITE, lambda: request_callback(sock))
get_count = 4
print("starts at %s" % str(datetime.now())[:-7])
for i in range(get_count):
get()
while True:
events = sel.select()
for key, _ in events:
callback = key.data
event = key.events
sel.unregister(key.fileobj)
callback()
if event == EVENT_WRITE:
sel.register(key.fileobj, EVENT_READ, lambda: response_callback(key.fileobj))
elif event == EVENT_WRITE:
sel.register(key.fileobj, EVENT_WRITE, lambda: request_callback(key.fileobj))
示例10: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class Loop:
def __init__(self):
self.ready = collections.deque()
self.selector = DefaultSelector()
async def sock_accept(self, sock):
'''
Wait for the server socket to become readable, accept a new
client and return her socket, addr pair.
'''
await read_wait(sock)
return sock.accept()
async def sock_recv(self, sock, maxbytes):
'''
Wait for the socket to become readable, read data from the
socket and return data.
'''
await read_wait(sock)
return sock.recv(maxbytes)
async def sock_sendall(self, sock, data):
'''
While we have some data to send, wait for the socket to become
writeable and send some data.
'''
while data:
await write_wait(sock)
nbytes = sock.send(data)
# Modify data according to the number of bytes sent this time
data = data[nbytes:]
def create_task(self, coro):
self.ready.append(coro)
def run_forever(self):
while True:
while not self.ready:
events = self.selector.select()
for key, _ in events:
self.selector.unregister(key.fileobj)
self.ready.append(key.data)
while self.ready:
# I need this task in another method, so I attach it here
self.current_task = self.ready.popleft()
try:
# drive the coroutine to the next yield
op, *args = self.current_task.send(None)
except StopIteration:
pass
else:
# call method on myself
# this methods will register sockets with selector
getattr(self, op)(*args)
def read_wait(self, sock):
# When this socket is ready, drive this task to the next yield
self.selector.register(sock, EVENT_READ, self.current_task)
def write_wait(self, sock):
self.selector.register(sock, EVENT_WRITE, self.current_task)
示例11: __init__
# 需要导入模块: from selectors import DefaultSelector [as 别名]
# 或者: from selectors.DefaultSelector import unregister [as 别名]
class EventLoop:
def __init__(self):
self.tasks = deque()
self.selector = DefaultSelector()
def run_until_complete(self, task):
self.tasks.append(task)
self.run()
def pause(self):
return "pause", None
def schedule(self, target):
return "schedule", target
def sock_accept(self, sock):
yield ("read", sock)
return sock.accept()
def sock_recv(self, sock):
yield ("read", sock)
return sock.recv(1024)
def sock_sendall(self, sock, data):
yield ("write", sock)
return sock.sendall(data)
def start_server(self, handler, host, port, backlog=0):
handler = partial(handler, self)
with socket.socket() as sock:
sock.bind((host, port))
sock.listen(backlog)
print("Listening on {}:{}".format(host, port))
while True:
conn, addr = yield from self.sock_accept(sock)
print("Accepted client from", addr)
yield self.schedule(handler(conn))
def run(self):
while self.tasks or self.selector.get_map():
for _ in range(len(self.tasks)):
try:
task = self.tasks.popleft()
tag, value = next(task)
if tag == "schedule":
self.tasks.append(value)
self.tasks.append(task)
elif tag == "read":
self.selector.register(value, EVENT_READ, data=task)
elif tag == "write":
self.selector.register(value, EVENT_WRITE, data=task)
elif tag == "pause":
self.tasks.append(task)
else:
raise ValueError("Incorrect tag")
except StopIteration:
continue
if self.selector.get_map():
for key, event in self.selector.select():
if event & EVENT_READ or event & EVENT_WRITE:
self.tasks.append(key.data)
self.selector.unregister(key.fileobj)