aDriv4 website!

Linux server192.web-hosting.com 4.18.0-513.18.1.lve.el8.x86_64 #1 SMP Thu Feb 22 12:55:50 UTC 2024 x86_64
LiteSpeed
198.54.114.198

File Name : runners.py

__all__ = ('Runner', 'run')

import contextvars
import enum
import functools
import threading
import signal
import sys
from . import coroutines
from . import events
from . import exceptions
from . import tasks

class _State(enum.Enum):
    CREATED = "created"
    INITIALIZED = "initialized"
    CLOSED = "closed"

class Runner:
    """A context manager that controls event loop life cycle.

The context manager always creates a new event loop,
    allows to run async functions inside it,
    and properly finalizes the loop at the context manager exit.

If debug is True, the event loop will be run in debug mode.
    If loop_factory is passed, it is used for new event loop creation.

asyncio.run(main(), debug=True)

is a shortcut for

with asyncio.Runner(debug=True) as runner:
        runner.run(main())

The run() method can be called multiple times within the runner's context.

This can be useful for interactive console (e.g. IPython),
    unittest runners, console tools, -- everywhere when async code
    is called from existing sync framework and where the preferred single
    asyncio.run() call doesn't work.

"""

# Note: the class is final, it is not intended for inheritance.

def __init__(self, *, debug=None, loop_factory=None):
        self._state = _State.CREATED
        self._debug = debug
        self._loop_factory = loop_factory
        self._loop = None
        self._context = None
        self._interrupt_count = 0
        self._set_event_loop = False

def __enter__(self):
        self._lazy_init()
        return self

def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()

def close(self):
        """Shutdown and close event loop."""
        if self._state is not _State.INITIALIZED:
            return
        try:
            loop = self._loop
            _cancel_all_tasks(loop)
            loop.run_until_complete(loop.shutdown_asyncgens())
            loop.run_until_complete(loop.shutdown_default_executor())
        finally:
            if self._set_event_loop:
                events.set_event_loop(None)
            loop.close()
            self._loop = None
            self._state = _State.CLOSED

def get_loop(self):
        """Return embedded event loop."""
        self._lazy_init()
        return self._loop

def run(self, coro, *, context=None):
        """Run a coroutine inside the embedded event loop."""
        if not coroutines.iscoroutine(coro):
            raise ValueError("a coroutine was expected, got {!r}".format(coro))

if events._get_running_loop() is not None:
            # fail fast with short traceback
            raise RuntimeError(
                "Runner.run() cannot be called from a running event loop")

self._lazy_init()

if context is None:
            context = self._context
        task = self._loop.create_task(coro, context=context)

if (threading.current_thread() is threading.main_thread()
            and signal.getsignal(signal.SIGINT) is signal.default_int_handler
        ):
            sigint_handler = functools.partial(self._on_sigint, main_task=task)
            try:
                signal.signal(signal.SIGINT, sigint_handler)
            except ValueError:
                # `signal.signal` may throw if `threading.main_thread` does
                # not support signals (e.g. embedded interpreter with signals
                # not registered - see gh-91880)
                sigint_handler = None
        else:
            sigint_handler = None

self._interrupt_count = 0
        try:
            return self._loop.run_until_complete(task)
        except exceptions.CancelledError:
            if self._interrupt_count > 0:
                uncancel = getattr(task, "uncancel", None)
                if uncancel is not None and uncancel() == 0:
                    raise KeyboardInterrupt()
            raise  # CancelledError
        finally:
            if (sigint_handler is not None
                and signal.getsignal(signal.SIGINT) is sigint_handler
            ):
                signal.signal(signal.SIGINT, signal.default_int_handler)

def _lazy_init(self):
        if self._state is _State.CLOSED:
            raise RuntimeError("Runner is closed")
        if self._state is _State.INITIALIZED:
            return
        if self._loop_factory is None:
            self._loop = events.new_event_loop()
            if not self._set_event_loop:
                # Call set_event_loop only once to avoid calling
                # attach_loop multiple times on child watchers
                events.set_event_loop(self._loop)
                self._set_event_loop = True
        else:
            self._loop = self._loop_factory()
        if self._debug is not None:
            self._loop.set_debug(self._debug)
        self._context = contextvars.copy_context()
        self._state = _State.INITIALIZED

def _on_sigint(self, signum, frame, main_task):
        self._interrupt_count += 1
        if self._interrupt_count == 1 and not main_task.done():
            main_task.cancel()
            # wakeup loop if it is blocked by select() with long timeout
            self._loop.call_soon_threadsafe(lambda: None)
            return
        raise KeyboardInterrupt()

def run(main, *, debug=None):
    """Execute the coroutine and return the result.

This function runs the passed coroutine, taking care of
    managing the asyncio event loop and finalizing asynchronous
    generators.

This function cannot be called when another asyncio event loop is
    running in the same thread.

If debug is True, the event loop will be run in debug mode.

This function always creates a new event loop and closes it at the end.
    It should be used as a main entry point for asyncio programs, and should
    ideally only be called once.

Example:

async def main():
            await asyncio.sleep(1)
            print('hello')

asyncio.run(main())
    """
    if events._get_running_loop() is not None:
        # fail fast with short traceback
        raise RuntimeError(
            "asyncio.run() cannot be called from a running event loop")

with Runner(debug=debug) as runner:
        return runner.run(main)

def _cancel_all_tasks(loop):
    to_cancel = tasks.all_tasks(loop)
    if not to_cancel:
        return

for task in to_cancel:
        task.cancel()

loop.run_until_complete(tasks.gather(*to_cancel, return_exceptions=True))

for task in to_cancel:
        if task.cancelled():
            continue
        if task.exception() is not None:
            loop.call_exception_handler({
                'message': 'unhandled exception during asyncio.run() shutdown',
                'exception': task.exception(),
                'task': task,
            })

Name	Type	Size	Owner/Group	Permission	Last Modified	Actions
.	dir	-	root/linksafe	0755	2025-05-13 05:08:23
..	dir	-	root/linksafe	0755	2025-05-13 05:08:23
__pycache__	dir	-	root/linksafe	0755	2025-05-13 05:08:23
__init__.py	text/plain	1.16 KB	root/linksafe	0644	2025-04-08 02:15:29
__main__.py	text/x-script.python	3.3 KB	root/linksafe	0644	2025-04-08 02:15:29
base_events.py	text/plain	73.62 KB	root/linksafe	0644	2025-04-08 02:15:29
base_futures.py	text/x-script.python	1.96 KB	root/linksafe	0644	2025-04-08 02:15:29
base_subprocess.py	text/x-script.python	8.66 KB	root/linksafe	0644	2025-04-08 02:15:29
base_tasks.py	text/x-script.python	2.58 KB	root/linksafe	0644	2025-04-08 02:15:29
constants.py	text/x-script.python	1.29 KB	root/linksafe	0644	2025-04-08 02:15:29
coroutines.py	text/x-script.python	3.32 KB	root/linksafe	0644	2025-04-08 02:15:29
events.py	text/plain	27.97 KB	root/linksafe	0644	2025-04-08 02:15:29
exceptions.py	text/plain	1.71 KB	root/linksafe	0644	2025-04-08 02:15:29
format_helpers.py	text/x-script.python	2.35 KB	root/linksafe	0644	2025-04-08 02:15:29
futures.py	text/plain	13.88 KB	root/linksafe	0644	2025-04-08 02:15:29
locks.py	text/plain	18.57 KB	root/linksafe	0644	2025-04-08 02:15:29
log.py	text/plain	124 B	root/linksafe	0644	2025-04-08 02:15:29
mixins.py	text/plain	481 B	root/linksafe	0644	2025-04-08 02:15:29
proactor_events.py	text/plain	32.48 KB	root/linksafe	0644	2025-04-08 02:15:29
protocols.py	text/plain	6.79 KB	root/linksafe	0644	2025-04-08 02:15:29
queues.py	text/x-script.python	7.79 KB	root/linksafe	0644	2025-04-08 02:15:29
runners.py	text/x-script.python	6.68 KB	root/linksafe	0644	2025-04-08 02:15:29
selector_events.py	text/plain	44.34 KB	root/linksafe	0644	2025-04-08 02:15:29
sslproto.py	text/x-script.python	31 KB	root/linksafe	0644	2025-04-08 02:15:29
staggered.py	text/plain	5.85 KB	root/linksafe	0644	2025-04-08 02:15:29
streams.py	text/x-script.python	26.86 KB	root/linksafe	0644	2025-04-08 02:15:29
subprocess.py	text/x-script.python	7.5 KB	root/linksafe	0644	2025-04-08 02:15:29
taskgroups.py	text/x-script.python	8.27 KB	root/linksafe	0644	2025-04-08 02:15:29
tasks.py	text/plain	33.63 KB	root/linksafe	0644	2025-04-08 02:15:29
threads.py	text/plain	790 B	root/linksafe	0644	2025-04-08 02:15:29
timeouts.py	text/x-script.python	5.2 KB	root/linksafe	0644	2025-04-08 02:15:29
transports.py	text/plain	10.47 KB	root/linksafe	0644	2025-04-08 02:15:29
trsock.py	text/x-script.python	2.42 KB	root/linksafe	0644	2025-04-08 02:15:29
unix_events.py	text/plain	50.7 KB	root/linksafe	0644	2025-04-08 02:15:29
windows_events.py	text/plain	33.88 KB	root/linksafe	0644	2025-04-08 02:15:29
windows_utils.py	text/plain	4.94 KB	root/linksafe	0644	2025-04-08 02:15:29

For more Private tool come to me!

https://t.me/aDriv4vz