import multiprocessing
import threading
import time
import tkinter
# 声明全局对象及类型
_tk: tkinter.Tk
_text: tkinter.Text
_terminate = False
_queue: multiprocessing.Queue

def update_text():
    """子线程侦听进程消息"""
    while not _terminate:
        if not _queue.empty():
            text = _queue.get(False)
            append_text(text)
        else:
            time.sleep(1)

def append_text(text):
    _text.config(state='normal')
    _text.insert('end', f'\n{text}')
    _text.see('end')
    _text.config(state='disabled')

def run(gui_queue):
    global _tk, _text, _queue, _screen_size
    _queue = gui_queue
    # ...
    threading.Thread(target=update_text).start()
    
    _tk.mainloop()

def recognize_digits(image: bytes):
    """进行数字识别"""
    ocr = ddddocr.DdddOcr(show_ad=False)
    result = ocr.classification(image)
    return wash_digits(result)

def wash_digits(digits: str):
    """由于不会出现非数字, 所以对易识别错误的字符进行替换"""
    washed = digits \
        .replace('g', '9').replace('q', '9') \
        .replace('l', '1').replace('i', '1') \
        .replace('z', '2') \
        .replace('o', '0')
    return re.sub(r'\D', '0', washed)

# km.py
"""
Keyboard and mouse input/output,
and ScreenGrabbing
"""
from pynput import keyboard, mouse

def on_click(x, y, btn_type, down):
    """鼠标点击回调函数"""
    if btn_type == mouse.Button.left and down:
        _queue.put((int(x), int(y)))


def on_press(event):
    """按键回调函数"""
    try:
        # 处理正常的ASCII字符
        if event.char == 'q':
            # 设置毒药, 当queue.get()获得None的时候, 消费端应该被kill
            _queue.put(None)
        else:
            _queue.put(event.char)
    except AttributeError:
        # 处理特殊的按键
        if event == keyboard.Key.esc:
            _queue.put('esc')
        elif event == keyboard.Key.enter:
            _queue.put('enter')
        elif event == keyboard.Key.space:
            _queue.put(' ')
        elif event == keyboard.Key.backspace:
            _queue.put('delete')


def space_press_and_release(duration):
    """Press the key 'space' down for a while, and then release"""
    # @param duration: 持续时间
    k = keyboard.Controller()
    k.press(keyboard.Key.space)
    time.sleep(duration)
    k.release(keyboard.Key.space)


def key_press_and_release(key):
    """Press certain key several times down, and then release immediately"""
    # @param key: 按下按键
    k = keyboard.Controller()
    k.press(key)
    k.release(key)
    time.sleep(0.37)


def run(km_queue):
    global _queue
    _queue = km_queue
# 注册键盘事件监听与回调函数
    keyboard_listener = keyboard.Listener(on_press=on_press)
    keyboard_listener.start()
    time.sleep(.5)
    # 注册鼠标事件监听与回调函数
    mouse_listener = mouse.Listener(on_click=on_click)
    mouse_listener.start()


if __name__ == '__main__':
    run(None)
    while True:
        time.sleep(1)

def km_listen_queue():
    while True:
        inputs = _km_queue.get()
        if inputs is None:  # poison bill
            # 接收毒药, 毒药的设置可见上文Listener中回调函数是何时put None的
            if len(_wind_degree_points) > 0:
                with open(_W_D_POINTS_DUMP_NAME, 'wb') as f:
                    pickle.dump(_wind_degree_points, f)
            _gui_process.terminate()
            break
        else:  # handle inputs
            handle_inputs(inputs)

def handle_inputs(inputs):
    """To handle inputs"""
    global _command_flag, _direct_force_typing, _wind_direction
    inputs_type = type(inputs)
    # 键盘事件on_press, 返回str
    if inputs_type == str:
        # press ESC to cancel
        if inputs == 'esc':
            reset_inputs()
        elif inputs == '-':
            _wind_direction = -1
        elif inputs == '=':
            _wind_direction = 1
        # press the key 't' twice to enable command mode
        elif inputs == 't':
            _command_flag += 1
            # 最大t的次数为4, 所以4为一个周期
            _command_flag %= 4
            if _command_flag == 2:
                _gui_queue.put("指令输入开启💡")
            elif _command_flag == 0:
                _gui_queue.put("指令输入关闭🔒")
        elif _command_flag == 2:
            # _command_flag == 2此时为命令模式, 输入enter完成设置, reset_inputs
            # press enter to submit command and fire
            if inputs == 'enter':
                direct_force = analyse_direct_force()
                if direct_force > 0:
                    fire(force=direct_force)
                else:
                    wind, degree, distance = analyse_wind(), analyse_degree(), analyse_distance()
                    fire(wind, degree, distance)
                reset_inputs()
            # edit command
            elif inputs == 'delete':
                _direct_force_typing = _direct_force_typing[:-1]
            else:
                _direct_force_typing += inputs
        # when not in command mode
        # any key except 't' will reset mode flag
        # which means only consecutive 't' input can enable command mode
        elif _command_flag == 1:
            reset_inputs()
    # 鼠标事件on_click, 返回(x, y)
    elif inputs_type == tuple:
        if _command_flag == 2:
            _distance_points.append(inputs)
            _gui_queue.put(f'{len(_distance_points)} 个点已标记')
        # 按三次t之后再点击, 进入设置“角度中心位置、风力中心位置”
        if _command_flag == 3:
            if len(_wind_degree_points) == 2:
                # 如果标记过了风力和角度, 则重新标记
                _wind_degree_points.clear()
            _wind_degree_points.append(inputs)
            if len(_wind_degree_points) == 1:
                _gui_queue.put('角度位置已标记📐️')
            else:
                _gui_queue.put('风力位置已标记🌪️')

def grab_box(box: tuple) -> bytes:
    # 开启内存IO
    bytes_io = io.BytesIO()
    # 截图
    image = ImageGrab.grab().resize((_screen_size[0], _screen_size[1])).crop(box)
    # 写入内存IO
    image.save(bytes_io, format='png')
    # 获得bytes值
    return bytes_io.getvalue()

>>> async def hello(name):
...     print('Hello, %s!' % (name,))
>>>
>>> coro = hello('world')
>>> type(coro)
<class 'coroutine'>
>>> type(coro.send)
<class 'builtin_function_or_method'>
>>> type(coro.throw)
<class 'builtin_function_or_method'>
>>>
...

>>> async def hello(name):
...     print('Hello, %s!' % (name,))
>>>
>>> task = hello('world')
>>> try:
...     task.send(None)
... except StopIteration:
...     pass
Hello, world!

>>> class HelloException(Exception):
...    def __init__(self, name):
...        self._name = name
...    def __str__(self):
...        return 'Hello, %s!' % (self._name,)
>>>
>>> async def hello(name):
...     raise HelloException(name)
>>>
>>> task = hello('world')
>>> try:
...     task.send(None)
... except Exception as error:
...     # NEW: exception will be propagated here!
...     print(error)
Hello, world!

>>> class Hello(Exception):
...    def __init__(self, name):
...        self._name = name
...    def __str__(self):
...        return 'Hello, %s!' % (self._name,)
>>>
>>> async def hello():
...     pass
>>>
>>> task = hello()
>>> try:
...     # NEW: inject exception.
...     task.throw(Hello('world'))
... except Exception as error:
...     print(error)
Hello, world!

>>> from types import coroutine
>>>
>>> # NEW: this is an awaitable object!
>>> @coroutine
... def nice():
...     yield
>>>
>>> async def hello(name):
...     # NEW: this makes ``.send()`` return!
...     await nice()
...     print('Hello, %s!' % (name,))
>>>
>>> task = hello('world')
>>> # NEW: call send twice!
>>> task.send(None)
>>> try:
...     task.send(None)
... except StopIteration:
...     pass
Hello, world!

>>> from types import coroutine
>>>
>>> @coroutine
... def nice():
...     yield
>>>
>>> async def hello(name):
...     # NEW: yield many times!
...     for i in range(5):
...         await nice()
...     print('Hello, %s!' % (name,))
>>>
>>> task = hello('world')
>>> try:
...     # NEW: loop!
...     while True:
...         task.send(None)
... except StopIteration:
...     pass
Hello, world!

>>> from types import coroutine
>>>
>>> @coroutine
... def nice():
...     yield
>>>
>>> async def hello(name):
...     for i in range(5):
...         await nice()
...     print('Hello, %s!' % (name,))
>>>
>>> # NEW: now a reusable function!
>>> def run_until_complete(task):
...     try:
...         while True:
...             task.send(None)
...     except StopIteration:
...         pass
>>>
>>> # NEW: call it as a function!
>>> run_until_complete(hello('world'))
Hello, world!

>>> from inspect import iscoroutine
>>> from types import coroutine
>>>
>>> # NEW: awaitable object that sends a request to launch a child task!
>>> @coroutine
... def spawn(task):
...     yield task
>>>
>>> async def hello(name):
...     await nice()
...     print('Hello, %s!' % (name,))
>>>
>>> # NEW: parent task!
>>> async def main():
...      # NEW: create a child task!
...     await spawn(hello('world'))
>>>
>>> def run_until_complete(task):
...     # NEW: schedule the "root" task.
...     tasks = [(task, None)]
...     while tasks:
...         # NEW: round-robin between a set tasks (we may now have more
...         #      than one and we'd like to be as "fair" as possible).
...         queue, tasks = tasks, []
...         for task, data in queue:
...             # NEW: resume the task *once*.
...             try:
...                 data = task.send(data)
...             except StopIteration:
...                 pass
...             except Exception as error:
...                 # NEW: prevent crashed task from ending the loop.
...                 print(error)
...             else:
...                 # NEW: schedule the child task.
...                 if iscoroutine(data):
...                     tasks.append((data, None))
...                 # NEW: reschedule the parent task.
...                 tasks.append((task, None))
>>>
>>> run_until_complete(main())
Hello, world!

>>> from collections import defaultdict
>>> from types import coroutine
>>>
>>> @coroutine
... def nice():
...     yield
>>>
>>> @coroutine
... def spawn(task):
...     # NEW: recover the child task handle to pass it back to the parent.
...     child = yield ('spawn', task)
...     return child
>>>
>>> # NEW: awaitable object that sends a request to be notified when a
>>> #      concurrent task completes.
>>> @coroutine
... def join(task):
...     yield ('join', task)
>>>
>>> async def hello(name):
...     await nice()
...     print('Hello, %s!' % (name,))
>>>
>>> async def main():
...     # NEW: recover the child task handle.
...     child = await spawn(hello('world'))
...     # NEW: wait for the child task to complete.
...     await join(child)
...     print('(after join)')
>>>
>>> def run_until_complete(task):
...     tasks = [(task, None)]
...     # NEW: keep track of tasks to resume when a task completes.
...     watch = defaultdict(list)
...     while tasks:
...         queue, tasks = tasks, []
...         for task, data in queue:
...             try:
...                 data = task.send(data)
...             except StopIteration:
...                 # NEW: wait up tasks waiting on this one.
...                 tasks.extend((t, None) for t in watch.pop(task, []))
...             else:
...                 # NEW: dispatch request sent by awaitable object since
...                 #      we now have 3 different types of requests.
...                 if data and data[0] == 'spawn':
...                     tasks.append((data[1], None))
...                     tasks.append((task, data[1]))
...                 elif data and data[0] == 'join':
...                     watch[data[1]].append(task)
...                 else:
...                     tasks.append((task, None))
>>>
>>> run_until_complete(main())
Hello, world!
(after join)

>>> from heapq import heappop, heappush
>>> from time import sleep as _sleep
>>> from timeit import default_timer
>>> from types import coroutine
>>>
>>> # NEW: we need to keep track of elapsed time.
>>> clock = default_timer
>>>
>>> # NEW: request that the event loop reschedule us "later".
>>> @coroutine
... def sleep(seconds):
...     yield ('sleep', seconds)
>>>
>>> # NEW: verify elapsed time matches our request.
>>> async def hello(name):
...     ref = clock()
...     await sleep(3.0)
...     now = clock()
...     assert (now - ref) >= 3.0
...     print('Hello, %s!' % (name,))
>>>
>>> def run_until_complete(task):
...     tasks = [(task, None)]
...
...     # NEW: keep track of tasks that are sleeping.
...     timers = []
...
...     # NEW: watch out, all tasks might be suspended at the same time.
...     while tasks or timers:
...
...         # NEW: if we have nothing to do for now, don't spin.
...         if not tasks:
...             _sleep(max(0.0, timers[0][0] - clock()))
...
...         # NEW: schedule tasks when their timer has elapsed.
...         while timers and timers[0][0] < clock():
...             _, task = heappop(timers)
...             tasks.append((task, None))
...
...         queue, tasks = tasks, []
...         for task, data in queue:
...             try:
...                 data = task.send(data)
...             except StopIteration:
...                 pass
...             else:
...                 # NEW: set a timer and don't reschedule right away.
...                 if data and data[0] == 'sleep':
...                     heappush(timers, (clock() + data[1], task))
...                 else:
...                     tasks.append((task, None))
>>>
>>> run_until_complete(hello('world'))
Hello, world!

>>> from selectors import (
...     DefaultSelector,
...     EVENT_READ,
...     EVENT_WRITE,
... )
>>> from socket import socketpair as _socketpair
>>> from types import coroutine
>>>
>>> # NEW: request that the event loop tell us when we can read.
>>> @coroutine
... def recv(stream, size):
...     yield (EVENT_READ, stream)
...     return stream.recv(size)
>>>
>>> # NEW: request that the event loop tell us when we can write.
>>> @coroutine
... def send(stream, data):
...     while data:
...         yield (EVENT_WRITE, stream)
...         size = stream.send(data)
...         data = data[size:]
>>>
>>> # NEW: connect sockets, make sure they never, ever block the loop.
>>> @coroutine
... def socketpair():
...     lhs, rhs = _socketpair()
...     lhs.setblocking(False)
...     rhs.setblocking(False)
...     yield
...     return lhs, rhs
>>>
>>> # NEW: send a message through the socket pair.
>>> async def hello(name):
...     lhs, rhs = await socketpair()
...     await send(lhs, 'Hello, world!'.encode('utf-8'))
...     data = await recv(rhs, 1024)
...     print(data.decode('utf-8'))
...     lhs.close()
...     rhs.close()
>>>
>>> def run_until_complete(task):
...     tasks = [(task, None)]
...
...     # NEW: prepare for I/O multiplexing.
...     selector = DefaultSelector()
...
...     # NEW: watch out, all tasks might be suspended at the same time.
...     while tasks or selector.get_map():
...
...         # NEW: poll I/O operation status and resume tasks when ready.
...         timeout = 0.0 if tasks else None
...         for key, events in selector.select(timeout):
...             tasks.append((key.data, None))
...             selector.unregister(key.fileobj)
...
...         queue, tasks = tasks, []
...         for task, data in queue:
...             try:
...                 data = task.send(data)
...             except StopIteration:
...                 pass
...             else:
...                 # NEW: register for I/O and suspend the task.
...                 if data and data[0] == EVENT_READ:
...                     selector.register(data[1], EVENT_READ, task)
...                 elif data and data[0] == EVENT_WRITE:
...                     selector.register(data[1], EVENT_WRITE, task)
...                 else:
...                     tasks.append((task, None))
>>>
>>> run_until_complete(hello('world'))
Hello, world!

>>> from inspect import iscoroutine
>>> from types import coroutine
>>>
>>> @coroutine
... def spawn(task):
...     task = yield ('spawn', task)
...     return task
>>>
>>> @coroutine
... def join(task):
...     yield ('join', task)
>>>
>>> # NEW: exception to be raised inside tasks when they are cancelled.
>>> class CancelledError(Exception):
...     pass
>>>
>>> # NEW: request that CancelledError be raised inside the task.
>>> @coroutine
... def cancel(task):
...     cancelled = yield ('cancel', task, CancelledError())
...     assert cancelled is True
>>>
>>> # NEW: pause the task without plans to reschedule it (this is simply to
>>> #      guarantee execution order in this demo).
>>> @coroutine
... def suspend():
...     yield ('suspend',)
>>>
>>> async def hello(name):
...     try:
...         await suspend()
...     except CancelledError:
...         print('Hello, %s!' % (name,))
...         raise
>>>
>>> # NEW: spawn a task and then cancel it.
>>> async def main():
...     child = await spawn(hello('world'))
...     await cancel(child)
...     await join(child)
>>>
>>> def run_until_complete(task):
...     tasks = [(task, None)]
...     watch = defaultdict(list)
...
...     # NEW: keep track of all tasks in the tree.
...     tree = {task}
...
...     while tasks:
...         queue, tasks = tasks, []
...         for task, data in queue:
...             try:
...                 # NEW: we may need to pass data or inject an exception.
...                 if isinstance(data, Exception):
...                     data = task.throw(data)
...                 else:
...                     data = task.send(data)
...             except (StopIteration, CancelledError):
...                 tasks.extend((t, None) for t in watch.pop(task, []))
...                 # NEW: update bookkeeping.
...                 tree.discard(task)
...             else:
...                 if data and data[0] == 'spawn':
...                     tasks.append((data[1], None))
...                     tasks.append((task, data[1]))
...                     # NEW: update bookkeeping.
...                     tree.add(data[1])
...                 elif data and data[0] == 'join':
...                     watch[data[1]].append(task)
...                 elif data and data[0] == 'cancel':
...                     # NEW: schedule to raise the exception in the task.
...                     if data[1] in tree:
...                         tasks.append((data[1], data[2]))
...                         tasks.append((task, True))
...                     else:
...                         tasks.append((task, False))
...                 elif data and data[0] == 'suspend':
...                     pass
...                 else:
...                     tasks.append((task, None))
>>>
>>> run_until_complete(main())
Hello, world!

from types import coroutine


# NEW: this is an awaitable object!
@coroutine
def nice():
    print('before yield')
    yield
    print("after yield")


async def hello(name):
    # NEW: this makes ``.send()`` return!
    await nice()
    print('Hello, %s!' % (name,))


task = hello('world')

# NEW: call send twice!
task.send(None)
print("after first sned")
try:
    task.send(None)
except StopIteration:
    pass
"""
before yield
after first sned
after yield
Hello, world!
"""

from inspect import iscoroutine
from types import coroutine


@coroutine
def nice():
    print("before nice")
    yield
    print("after nice")


# NEW: awaitable object that sends a request to launch a child task!
@coroutine
def spawn(task):
    print("before spawn")
    yield task
    print("after spawn")


async def hello(name):
    print("hello: before await")
    await nice()
    print('Hello, %s!' % (name,))


# NEW: parent task!
async def main():
    print("main: before")
    # NEW: create a child task!
    await spawn(hello('world'))
    print("main: after")


def run_until_complete(task):
    # NEW: schedule the "root" task.
    tasks = [(task, None)]
    while tasks:
        # NEW: round-robin between a set tasks (we may now have more than one and we'd like to be as "fair" as possible).
        # 新：一组任务之间的循环（我们现在可能有多个任务，我们希望尽可能“公平”）。
        queue, tasks = tasks, []
        for task, data in queue:
            # NEW: resume the task *once*.
            try:
                data = task.send(data)
            except StopIteration:
                pass
            except Exception as error:
                # NEW: prevent crashed task from ending the loop.
                print(error)
            else:
                # NEW: schedule the child task.
                if iscoroutine(data):
                    tasks.append((data, None))
                # NEW: reschedule the parent task.
                tasks.append((task, None))


run_until_complete(main())
"""
main: before
before spawn
hello: before await
before nice
after spawn
main: after
after nice
Hello, world!
"""

from collections import defaultdict
from types import coroutine


@coroutine
def nice():
    print("nice: before yield")
    yield
    print("nice: after yield")


@coroutine
def spawn(task):
    # NEW: recover the child task handle to pass it back to the parent.
    print("spawn: before yield")
    child = yield ('spawn', task)
    print("spawn: after yield")
    return child


# NEW: awaitable object that sends a request to be notified when a
#      concurrent task completes.
@coroutine
def join(task):
    print("join: before yield")
    yield ('join', task)
    print("join: after yield")

async def hello(name):
    print("hello: before nice()")
    await nice()
    print('Hello, %s!' % (name,))


async def main():
    # NEW: recover the child task handle.
    child = await spawn(hello('world'))
    print("main: after spawn and before join()")
    # NEW: wait for the child task to complete.
    # 等待子协程完成
    await join(child)
    print('(after join)')


def run_until_complete(task):
    tasks = [(task, None)]
    # NEW: keep track of tasks to resume when a task completes.
    watch = defaultdict(list)
    while tasks:
        queue, tasks = tasks, []
        for task, data in queue:
            try:
                data = task.send(data)
            except StopIteration:
                # NEW: wait up tasks waiting on this one.
                # 子协程退出时, 唤醒被join阻塞的父协程
                # 对watch中的task进行pop, 如果没有则返回[]
                tasks.extend((t, None) for t in watch.pop(task, []))
            else:
                # NEW: dispatch request sent by awaitable object since we now have 3 different types of requests.
                # NEW: 由等待对象发送的调度请求，因为我们现在有 3 种不同类型的请求
                # 1. 如果是会产生新协程的操作
                if data and data[0] == 'spawn':
                    # 将新协程加入
                    tasks.append((data[1], None))
                    # 将父协程和新协程写入, 在task.send(data)中可以使得父协程中赋值child=yield epx为子协程值
                    tasks.append((task, data[1]))
                elif data and data[0] == 'join':
                    # 如果父协程执行的快, 那么把子协程与父协程的绑定关系记录下来
                    watch[data[1]].append(task)
                else:
                    # 正常协程执行结果
                    tasks.append((task, None))


run_until_complete(main())

"""
spawn: before yield
hello: before nice()
nice: before yield
spawn: after yield
main: after spawn and before join()
--- 此时main执行完成, join等待nice()被执行
join: before yield
nice: after yield
--- nice执行完成
Hello, world!
--- hello执行完成
join: after yield
--- join结束
(after join)
"""

from heapq import heappop, heappush
from time import sleep as _sleep
from timeit import default_timer
from types import coroutine

# NEW: we need to keep track of elapsed time.
clock = default_timer

# NEW: request that the event loop reschedule us "later".
@coroutine
def sleep(seconds):
    yield ('sleep', seconds)

# NEW: verify elapsed time matches our request.
async def hello(name):
    ref = clock()
    await sleep(3.0)
    now = clock()
    assert (now - ref) >= 3.0
    print('Hello, %s!' % (name,))

def run_until_complete(task):
    tasks = [(task, None)]

    # NEW: keep track of tasks that are sleeping.
    timers = []

    # NEW: watch out, all tasks might be suspended at the same time.
    while tasks or timers:

        # NEW: if we have nothing to do for now, don't spin.
        if not tasks:
            _sleep(max(0.0, timers[0][0] - clock()))

        # NEW: schedule tasks when their timer has elapsed.
        # 如果times队列中有任务, 且最近的时间已经到了, 则取出任务
        while timers and timers[0][0] < clock():
            _, task = heappop(timers)
            tasks.append((task, None))

        queue, tasks = tasks, []
        for task, data in queue:
            try:
                data = task.send(data)
            except StopIteration:
                pass
            else:
                # NEW: set a timer and don't reschedule right away.
                if data and data[0] == 'sleep':
                    # 往堆里面添加任务, 默认以时间最近的在上(最小堆)
                    heappush(timers, (clock() + data[1], task))
                else:
                    # 递归添加下一次要做的协程任务
                    tasks.append((task, None))

run_until_complete(hello('world'))

from selectors import (
    DefaultSelector,
    EVENT_READ,
    EVENT_WRITE,
)
from socket import socketpair as _socketpair
from types import coroutine


# NEW: request that the event loop tell us when we can read.
@coroutine
def recv(stream, size):
    yield (EVENT_READ, stream)
    return stream.recv(size)


# NEW: request that the event loop tell us when we can write.
@coroutine
def send(stream, data):
    while data:
        yield (EVENT_WRITE, stream)
        size = stream.send(data)
        data = data[size:]


# NEW: connect sockets, make sure they never, ever block the loop.
@coroutine
def socketpair():
    lhs, rhs = _socketpair()
    lhs.setblocking(False)
    rhs.setblocking(False)
    yield
    return lhs, rhs


# NEW: send a message through the socket pair.
async def hello(name):
    lhs, rhs = await socketpair()
    await send(lhs, 'Hello, world!'.encode('utf-8'))
    data = await recv(rhs, 1024)
    print(data.decode('utf-8'))
    lhs.close()
    rhs.close()


def run_until_complete(task):
    tasks = [(task, None)]

    # NEW: prepare for I/O multiplexing.
    selector = DefaultSelector()

    # NEW: watch out, all tasks might be suspended at the same time.
    while tasks or selector.get_map():

        # NEW: poll I/O operation status and resume tasks when ready.
        timeout = 0.0 if tasks else None
        for key, events in selector.select(timeout):
            tasks.append((key.data, None))
            selector.unregister(key.fileobj)

        queue, tasks = tasks, []
        for task, data in queue:
            try:
                data = task.send(data)
            except StopIteration:
                pass
            else:
                # NEW: register for I/O and suspend the task.
                if data and data[0] == EVENT_READ:
                    selector.register(data[1], EVENT_READ, task)
                elif data and data[0] == EVENT_WRITE:
                    selector.register(data[1], EVENT_WRITE, task)
                else:
                    tasks.append((task, None))


run_until_complete(hello('world'))

import asyncio
from pyppeteer import launch

async def main():
    # 启动浏览器
    browser = await launch(headless=True)
    # 打开并跳转页面
    page = await browser.newPage()
    await page.goto('https://example.com')
    # 截图
    await page.screenshot({'path': 'example.png'})
    await browser.close()

asyncio.get_event_loop().run_until_complete(main())

dimensions = await page.evaluate('''() => {
    return {
        width: document.documentElement.clientWidth,
        height: document.documentElement.clientHeight,
        deviceScaleFactor: window.devicePixelRatio,
    }
}''')

print(dimensions)
# >>> {'width': 800, 'height': 600, 'deviceScaleFactor': 1}
await browser.close()

# 使用xpath
await page.waitForXPath('//input[contains(@id, "mat-input")]')
await asyncio.sleep(10)
inputs = await page.xpath('//input[contains(@id, "mat-input")]')
print(len(inputs))
await inputs[1].type('janetgao@indiana.edu')
await inputs[2].type('KAProject2021')
# 使用selector
await page.waitForSelector('#mat-input-1')
await page.type('#mat-input-1', 'janetgao@indiana.edu')
await page.type('#mat-input-2', 'KAProject2021')

import asyncio
from pyppeteer import launch
from pyppeteer_stealth import stealth
 
async def main():
    browser = await launch(headless=True)
    page = await browser.newPage()
 
    await stealth(page)  # <-- Here
 
    await page.goto("https://bot.sannysoft.com/")
    await browser.close()
asyncio.get_event_loop().run_until_complete(main())

async def start_browser():
    browser = await launch(**{"headless": False})
    # 创建隐身上下文
    browser_context = await browser.createIncognitoBrowserContext()
    page = await browser_context.newPage()

    await page.goto("http://www.baidu.com")
    await browser.close()
    return

import pyppeteer.chromium_downloader
print('默认版本是：{}'.format(pyppeteer.__chromium_revision__))
print('可执行文件默认路径：{}'.format(pyppeteer.chromium_downloader.chromiumExecutable.get('win64')))
print('win64平台下载链接为：{}'.format(pyppeteer.chromium_downloader.downloadURLs.get('win64')))
"""
默认版本是：588429
可执行文件默认路径：C:\Users\mrli\AppData\Local\pyppeteer\pyppeteer\local-chromium\588429\chrome-win32\chrome.exe
win64平台下载链接为：https://storage.googleapis.com/chromium-browser-snapshots/Win_x64/588429/chrome-win32.zip
"""

import mitmproxy.http
from mitmproxy import ctx

num = 0


def request(flow: mitmproxy.http.HTTPFlow):
    global num
    num = num + 1
    ctx.log.info("We've seen %d flows" % num)

import mitmproxy.http
from mitmproxy import ctx


class Counter:
    def __init__(self):
        self.num = 0
# 重写指定方法
    def request(self, flow: mitmproxy.http.HTTPFlow):
        self.num = self.num + 1
        ctx.log.info("We've seen %d flows" % self.num)


addons = [
    Counter()
]

# ECB模式加密解密
from Crypto.Cipher import AES

password = b'1234567812345678' #秘钥，b就是表示为bytes类型
text = b'abcdefghijklmnhi' #需要加密的内容，bytes类型
aes = AES.new(password,AES.MODE_ECB) #创建一个aes对象
# AES.MODE_ECB 表示模式是ECB模式
en_text = aes.encrypt(text) #加密明文
print("密文：",en_text) #加密明文，bytes类型

den_text = aes.decrypt(en_text) # 解密密文
print("明文：",den_text)

# CBC
from Crypto.Cipher import AES

password = b'1234567812345678' #秘钥，b就是表示为bytes类型
iv = b'1234567812345678' # iv偏移量，bytes类型
text = b'abcdefghijklmnhi' #需要加密的内容，bytes类型
aes = AES.new(password,AES.MODE_CBC,iv) #创建一个aes对象
# AES.MODE_CBC 表示模式是CBC模式
en_text = aes.encrypt(text) 
print("密文：",en_text) #加密明文，bytes类型

aes = AES.new(password,AES.MODE_CBC,iv) #CBC模式下解密需要重新创建一个aes对象
den_text = aes.decrypt(en_text)
print("明文：",den_text)

import hashlib
string='任性的90后boy'
md5 = hashlib.md5()
md5.update(string.encode('utf-8'))#转码，update里的必须是字节型
# 默认是32位小写
res = md5.hexdigest() #返回字符型摘要信息print(md5.digest())#返回字节型的摘要信息
# 切换到16位大写
# res=md5.hexdigest()[8:-8]
print("md5加密结果:",res)

import hashlib
string='任性的90后boy'
sha256 = hashlib.sha256()
sha256.update(string.encode('utf-8'))
res = sha256.hexdigest()
print("sha256加密结果:",res)

import requests

cookies = {
    'PB3_SESSION': '"2|1:0|10:1650810241|11:PB3_SESSION|40:djJleDo1Mi4xNDAuMjAxLjIxMTo1OTQ4NjM0Mg==|f661892137fd704b91fa09d8c58fd641a15ab9e83f94c69981dbeed7980fc9e4"',
    'V2EX_LANG': 'zhcn',
}

headers = {
    'authority': 'cn.v2ex.com',
    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9',
    'accept-language': 'zh-CN,zh;q=0.9,en;q=0.8',
    'cache-control': 'no-cache',
    'pragma': 'no-cache',
    'sec-ch-ua': '" Not A;Brand";v="99", "Chromium";v="100", "Google Chrome";v="100"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'document',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-site': 'none',
    'sec-fetch-user': '?1',
    'upgrade-insecure-requests': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.60 Safari/537.36',
}

http_proxy = "socks5h://127.0.0.1:10808"
https_proxy = "socks5h://127.0.0.1:10808"
proxies = {
    "https": https_proxy,
    "http": http_proxy
}

response = requests.get('https://cn.v2ex.com/about', cookies=cookies, headers=headers, proxies=proxies)

from requests_html import AsyncHTMLSession

http_proxy = "socks5h://127.0.0.1:10808"
https_proxy = "socks5h://127.0.0.1:10808"
proxies = {
    "https": https_proxy,
    "http": http_proxy
}

session = AsyncHTMLSession()

async def getDataByChromeDriver(index: Union[int, str]):
response = await session.get('https://www.qkl123.com/sector/{}'.format(index), headers=headers, proxies=proxies)
    # ...

from requests_html import AsyncHTMLSession
asession = AsyncHTMLSession()
async def get_pyclock(index):
    r = await asession.get('http://httpbin.org/get')
    await r.html.arender()
    return r

results = asession.run(get_pyclock, get_pyclock,
                       get_pyclock)  # 这里作者将同一个页面使用异步方式进行了3次渲染，但是实际上使用的时间并不是平时的3倍！可能只是比平时渲染一个页面多花了一点时间而已！这就是异步的好处！
print(results)