def hmland(manager, host, port): while True: print("Connecting to hmland") try: loop = events.get_event_loop() reader = StreamReader(limit=_DEFAULT_LIMIT, loop=loop) protocol = StreamReaderProtocol(reader, loop=loop) transport, _ = yield from loop.create_connection(lambda: protocol, host, port) writer = StreamWriter(transport, protocol, reader, loop) reader, writer = yield from asyncio.open_connection(host, port) transport._sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1) manager.setWriter(writer) asyncio.async(manager.update_locks()) while True: line = yield from reader.readline() if not line: break yield from manager.handle(line.decode("UTF-8").strip()) except: pass yield from asyncio.sleep(2)
def __init__(self, loop=None): if loop is not None: self._loop = loop else: self._loop = events.get_event_loop() self.channels = {} self.start_date = date_1123()
def __init__(self, name, loop=None): if loop is not None: self._loop = loop else: self._loop = events.get_event_loop() self.waiters = collections.deque() self.name = name self.messages = {} self.next_id = 0
async def async_gui(coroutine): loop = get_event_loop() app = WxAsyncApp() task = loop.create_task(app.MainLoop()) try: await coroutine except Exception as e: dlg = wx.MessageDialog(None, str(e), "Error") dlg.ShowModal() finally: task.cancel()
def __init__(self, warn_on_cancel_callback=False, loop=None): global GlobalWxAsyncApp super(WxAsyncApp, self).__init__() if GlobalWxAsyncApp is not None: raise Exception("WxAsyncApp already created") self.loop = loop or get_event_loop() GlobalWxAsyncApp = self self.BoundObjects = {} self.RunningTasks = defaultdict(set) self.SetExitOnFrameDelete(True) self.exiting = False self.warn_on_cancel_callback = warn_on_cancel_callback
def run_in_executor( func: F, executor: ThreadPoolExecutor = None, args: Any = (), kwargs: Any = MappingProxyType({}), ) -> Future: """将耗时函数加入到线程池 .""" loop = get_event_loop() # noinspection PyTypeChecker return loop.run_in_executor( # type: ignore executor, context_partial(func, *args, **kwargs), )
async def start(self, ctx): def shutdown(event): task.cancel() logging.info('Shut down web page change detector') detector = Detector(self.url, self.delay) ctx.publish_resource(detector, context_attr='detector') task = get_event_loop().create_task(detector.run()) ctx.finished.connect(shutdown) logging.info( 'Started web page change detector for url "%s" with a delay of %d seconds', self.url, self.delay)
def __init__(self, fp: Union[str, BytesIO] = "file.pkl", *, create_file: bool = True, autosave: bool = True, autoload: bool = True, loop: Union[bool, AbstractEventLoop] = False): self._exists = True self._create_file = create_file self._autosave = autosave self._autoload = autoload self._cache = dict() if loop: # Autosave and autoload cannot be used in async mode self._autoload = False self._autosave = False self._lock = Lock() # Use provided loop or get event loop if isinstance(loop, AbstractEventLoop): self._loop = loop else: self._loop = get_event_loop() else: # Async mode is off self._loop = None self._lock = None # Test and set file path # Exceptions will be raised if user doesn't have permission, file path # has a bad extension, or file does not exist and `create_file` is off try: self._fp = self.filepath(fp) except Exception as error: raise error # Autoload checks file modified time # Not compatible with BytesIO if isinstance(self._fp, BytesIO): self._autoload = False # Load initial data from file into cache if self._loop: self._loop.create_task(self._async_load()) else: self._load()
def run_in_executor( func, executor=None, args=(), kwargs=MappingProxyType({}), ) -> asyncio.Future: loop = get_event_loop() # noinspection PyTypeChecker return loop.run_in_executor( executor, context_partial(func, *args, **kwargs), )
def __init__(self, threshold=10, loop=None, instance_builder=AsyncObjectPoolInstance): if loop is None: self._loop = events.get_event_loop() else: self._loop = loop self.available = [] self.in_use = [] self.threshold = threshold self.instance_builder = instance_builder
async def wait_for_data(loop=None): """等待数据准备好 .""" if loop is None: _loop = events.get_event_loop() else: _loop = loop _waiter = _loop.create_future() try: # 等待future的返回结果 await _waiter finally: _waiter = None return _waiter
async def manager(reader, writer): """ 获取浏览器请求数据 先获取完整头部 并将数据和writer加入任务队列 """ request_info = { "method": "", "url": "", "version": "", "headers": dict(), } raw_message = bytes() ex_data = bytes() step = 0 while True: data = await reader.read(BUFF) raw_message += data ex_data += data print("==== manager ======= recv: ", data) if len(data) > 0: lines = ex_data.split(LINE_DIV) if len(lines) > 1: for line in lines[:-1]: if step == 0: # 解析请求行 line = line.split() request_info["method"] = line[0].decode("latin-1") request_info["url"] = line[1].decode("latin-1") request_info["version"] = line[2].decode("latin-1") step = 1 elif step == 1: # 解析请求头部 if len(line) > 0: line = line.split(HEADER_DIV, 1) request_info[line[0].decode( "latin-1")] = line[1].decode("latin-1") else: step = 2 break if step == 2: break ex_data = lines[-1] else: break if len(raw_message) > 0: use_loop = events.get_event_loop() rest = rest_handle(raw_message, request_info, reader, writer) use_loop.create_task(rest) else: writer.close()
def __init__(self, *args, quality_check=False, **kwargs): """ Args: *args: quality_check (bool): there are times when we only establish a connection to check the quality of the node/address **kwargs: """ self._stream_reader = StreamReader() self._stream_writer = None nodemanager = kwargs.pop('nodemanager') self.client = NeoNode(self, nodemanager, quality_check) self._loop = events.get_event_loop() super().__init__(self._stream_reader)
def __init__(self, *args, **kwargs): """ Args: *args: **kwargs: """ sr = StreamReader() self._stream_reader_orig = sr self._stream_reader_wr = weakref.ref(sr) self._stream_writer = None self.client = node.NeoNode(self) self._loop = events.get_event_loop() super().__init__(sr)
async def open_saltchannel_connection(host=None, port=None, *, loop=None, limit=streams._DEFAULT_LIMIT, **kwds): if loop is None: loop = events.get_event_loop() reader = SaltChannelStreamReader(limit=limit, loop=loop) protocol = SaltChannelStreamReaderProtocol(reader, loop=loop) transport, _ = await loop.create_connection(lambda: protocol, host, port, **kwds) writer = SaltChannelStreamWriter(transport, protocol, reader, loop) return reader, writer
def __init__(self, *, loop=None): if loop is None: self._loop = events.get_event_loop() else: self._loop = loop self._closed = False self._getters = collections.deque() self._pollers = collections.deque() self._unfinished_tasks = 0 self._finished = locks.Event(loop=self._loop) self._finished.set() self._queue = collections.deque()
def main(): from playground.common.logging import EnablePresetLogging, PRESET_DEBUG EnablePresetLogging(PRESET_DEBUG) args = sys.argv[1:] if len(args) != 4: print("Incorrect number of arguments (got %s, expected 4)" % len(args)) print( "USAGE:\n\tpython3 bank_functional1.py [Bank Cert Path] [User Login Name]\n\t\t[Client/Requester Bank Account Name] [Server/Merchant Bank Account Name]" ) return bankcert = loadCertFromFile(args[0]) username = args[1] pw = getpass.getpass("Enter client/requester's bank password: "******"print('this is a test')" fee = 1 #debugPrint("Creating NullServerWallet") #serverWallet = NullServerWallet() debugPrint("Creating PayingServerWallet") serverWallet = PayingServerWallet(bankcert, merchantaccount) debugPrint("Creating SimplePayingServerAuth") serverAuth = SimplePayingServerAuth(fee) debugPrint("Creating DefaultMobileCodeEngine") serverEngine = DefaultMobileCodeEngine() # debugPrint("Creating NullClientWallet") # clientWallet = NullClientWallet() debugPrint("Creating PayingClientWallet") clientWallet = PayingClientWallet(bankstackfactory, username, pw, payeraccount, merchantaccount) def serverFactory(): debugPrint("Factory creating MobileCodeServer") return MobileCodeServer(serverWallet, serverAuth, serverEngine) debugPrint("Creating MobileCodeClient") client = MobileCodeClient("default", "localhost", 1, samplecode, SimplePayingClientAuth(), clientWallet) coro = playground.getConnector().create_playground_server(serverFactory, 1) loop = get_event_loop() server = loop.run_until_complete(coro) print("Server started") loop.call_later(0, RunCodeAndPrintResult, client) loop.run_forever()
def __init__(self, maxsize=0, *, loop=None): if loop is None: self._loop = events.get_event_loop() else: self._loop = loop self._maxsize = maxsize # Futures. self._getters = collections.deque() # Futures. self._putters = collections.deque() self._unfinished_tasks = 0 self._finished = locks.Event(loop=self._loop) self._finished.set() self._init(maxsize)
async def create_datagram_endpoint(protocol, host, port, loop=None, *kwargs): """创建udp异步客户端 .""" if loop is None: loop = events.get_event_loop() if is_ipv6(host): transport, _ = await loop.create_datagram_endpoint( lambda: protocol, remote_addr=(host, port), family=socket.AF_INET6, **kwargs) else: transport, _ = await loop.create_datagram_endpoint(lambda: protocol, remote_addr=(host, port), **kwargs) return transport
async def call(self, action: ApiAction, params: dict = {}, persistent: bool = False) -> dict: """Performs an API call against the server via this connection.""" self.next_id += 1 fut = get_event_loop().create_future() self.calls[self.next_id] = ApiCall(fut, persistent) await shield( self.send_json_to_server({ "action": action.name, "call_id": self.next_id, **params })) # even if the action causing this call is cancelled, don't cancel the future as it causes errors return await shield(fut)
def __init__(self, maxsize=0, *, loop=None): if loop is None: self._loop = events.get_event_loop() else: self._loop = loop self._maxsize = maxsize # Futures. self._putters = collections.deque() self._finished = locks.Event(loop=self._loop) self._finished.set() self._init(maxsize) ''' TaskQueue's logger ''' self.logger = logging.getLogger(self.__class__.__name__)
async def test_bot_chat_message(): event_loop = get_event_loop() event_loop.set_debug(True) play_media = Mock() media_player = MediaPlayer() media_file_path = "fake/path/test.mp3" media_player.play_media_callback = play_media media_player.add_chat_trigger(media_file_path, False, True) media_player.monitoring_type = 0 await asyncio.sleep(0.1) assert len(media_player.chat_triggers) == 1 c = ChatMessage("123456", None, None, datetime.now(timezone.utc), " ", " ", False, False, False) media_player.chat_updated(c)
def __init__(self, limit=_DEFAULT_LIMIT, loop=None): # The line length limit is a security feature; # it also doubles as half the buffer limit. if limit <= 0: raise ValueError('Limit cannot be <= 0') self._limit = limit self._loop = loop if loop else events.get_event_loop() self._buffer = bytearray() self._eof = False # Whether we're done. self._waiter = None # A future used by _wait_for_data() self._exception = None self._transport = None self._paused = False if self._loop.get_debug(): self._source_traceback = extract_stack(sys._getframe(1))
async def start_saltchannel_server(client_connected_cb, host=None, port=None, *, loop=None, limit=streams._DEFAULT_LIMIT, **kwds): if loop is None: loop = events.get_event_loop() def factory(): reader = SaltChannelStreamReader(limit=limit, loop=loop) protocol = SaltChannelStreamReaderProtocol(reader, client_connected_cb, loop=loop) return protocol return await loop.create_server(factory, host, port, **kwds)
def run(): app = WxAsyncApp() app.path = os.path.dirname(sys.argv[0]) from window.main import Main import prefs import worlds import theme prefs.Initialize() worlds.Initialize() theme.Initialize() frame = Main(None, "wxpymoo") frame.Show(True) loop = get_event_loop() loop.run_until_complete(app.MainLoop())
async def send_data(self, data: bytes) -> None: """ :param data: :type data: bytes :return: :rtype: None """ if self.client_transport is None: ssl_context: Optional[ssl.SSLContext] if self.config["CLIENT_SSL_CERT_FILE"]: ssl_context = ssl.create_default_context( purpose=ssl.Purpose.SERVER_AUTH, cafile=self.config["CLIENT_SSL_CERT_FILE"], ) else: ssl_context = None cls_client = load_object(self.config["CLIENT_PROTOCOL"]) loop = get_event_loop() transport: Transport client: Protocol transport, client = await loop.create_connection( protocol_factory=lambda: cls_client.from_channel(self.channel), host=self.config.get("CLIENT_ADDRESS"), port=self.config.get("CLIENT_PORT"), ssl=ssl_context, ) cert: Dict[str, Union[Tuple, int, str]] if (cert := transport.get_extra_info("peercert") ) and cert["serialNumber"] not in self.certificates: self.logger.info( "Enabled a certificate:\n%s", pprint.pformat(cert), ) self.certificates.add(cert["serialNumber"]) self.stats.increase("certificates") client.server_transport = self.transport self.client_transport = transport
def ensure_future(coro_or_future, *, loop=None): """Wrap a coroutine or an awaitable in a future. If the argument is a Future, it is returned directly. """ if futures.isfuture(coro_or_future): if loop is not None and loop is not coro_or_future._loop: raise ValueError('loop argument must agree with Future') return coro_or_future elif iscoroutine(coro_or_future): if loop is None: loop = events.get_event_loop() task = loop.create_task(coro_or_future) if task._source_traceback: del task._source_traceback[-1] return task elif inspect.isawaitable(coro_or_future): return ensure_future(_wrap_awaitable(coro_or_future), loop=loop) else: raise TypeError('A Future, a coroutine or an awaitable is required')
def isirDownloader(config, limit, start, debug): if debug: config.set_opt("debug", True) if start and start > 0: config.set_opt("dl.start", start) if limit and limit > 0: # Kontrola, ze pocet soubezne stahovanych nebude vetsi nez limit pro stahovani if config["dl.concurrency"] > limit: config.set_opt("dl.concurrency", limit) config.set_opt("dl.limit", limit) dl = Downloader(config) loop = events.get_event_loop() try: loop.run_until_complete(dl.run()) except KeyboardInterrupt: dl.forceStop = True loop.run_forever() loop.close()
def __init__(self, max_workers=None, loop: AbstractEventLoop = None): self.__loop = loop or get_event_loop() self.__futures = set() self.__running = True self.__pool = set() self.__tasks = Queue(0) for idx in range(max_workers): thread = Thread( target=self._in_thread, name="[%d] Thread Pool" % idx, daemon=True, ) self.__pool.add(thread) # Starting the thread only after thread-pool will be started self.__loop.call_soon(thread.start) self.__pool = frozenset(self.__pool)
def run_subprocess_shell(cmd, callback, stdin=PIPE, stdout=PIPE, stderr=PIPE, loop=None, limit=streams._DEFAULT_LIMIT, **kwds): if loop is None: loop = events.get_event_loop() def protocol_factory(): return InteractiveSubprocessProtocol(limit=limit, loop=loop) @coroutine def run_subprocess(): transport, protocol = yield from loop.subprocess_shell( protocol_factory, cmd, stdin=stdin, stdout=stdout, stderr=stderr, **kwds) process = Process(transport, protocol, loop) protocol.configure_handler(process, callback) yield from process.wait() return process output = loop.run_until_complete(run_subprocess()) return output
async def wait_n(fs, *, loop=None, n=1): if loop is None: loop = events.get_event_loop() fs = {ensure_future(f, loop=loop) for f in set(fs)} waiter = loop.create_future() if n > len(fs): raise ValueError('arg `n` can`t be bigger than count of tasks') counter = len(fs) completed_count = 0 def _on_completion(f): nonlocal counter nonlocal completed_count counter -= 1 completed_count += 1 if counter <= 0 or completed_count >= n: if not waiter.done(): waiter.set_result(None) for f in fs: f.add_done_callback(_on_completion) try: await waiter finally: for f in fs: f.remove_done_callback(_on_completion) done, pending = set(), set() for f in fs: if f.done(): done.add(f) else: pending.add(f) return done, pending
def main_async(): # see https://github.com/sirk390/wxasync # application = MainApp(0) # loop = get_event_loop() # loop.run_until_complete(application.MainLoop()) app = wx.PySimpleApp() ogl.OGLInitialize() frame = AppFrame() loop = get_event_loop() loop.run_until_complete(app.MainLoop()) # Let's also cancel all running tasks: # https://stackoverflow.com/questions/37278647/fire-and-forget-python-async-await pending = asyncio.Task.all_tasks() for task in pending: # print("Cancelling leftover task...", task._coro.cr_code.co_name, task._state) task.cancel() # Now we should await task to execute it's cancellation. # Cancelled task raises asyncio.CancelledError that we can suppress: with suppress(asyncio.CancelledError): loop.run_until_complete(task)
async def start(self) -> None: """ :return: :rtype: None """ cls_interface = load_object(self.config["INTERFACE_PROTOCOL"]) loop = get_event_loop() ssl_context: Optional[ssl.SSLContext] if self.config.get("INTERFACE_SSL_CERT_FILE"): ssl_context = ssl.create_default_context( purpose=ssl.Purpose.CLIENT_AUTH) ssl_context.load_cert_chain( certfile=self.config.get("INTERFACE_SSL_CERT_FILE"), keyfile=self.config.get("INTERFACE_SSL_KEY_FILE"), password=self.config.get("INTERFACE_SSL_PASSWORD"), ) else: ssl_context = None self.server = await loop.create_server( protocol_factory=lambda: cls_interface.from_channel( self, role="interface"), host=self.config["INTERFACE_ADDRESS"], port=self.config["INTERFACE_PORT"], ssl=ssl_context, ) self.logger.info( "Channel [%s] is open; " "Protocol [%s] is listening on the interface: [%s:%s]", self.name, self.config["INTERFACE_PROTOCOL"], self.config["INTERFACE_ADDRESS"], self.config["INTERFACE_PORT"], )
def hmland(manager, host, port): while True: print("Connecting to hmland") try: loop = events.get_event_loop() reader, writer = yield from asyncio.open_connection(host, port) manager.setWriter(writer) asyncio. async (manager.update_locks()) print("Connected") while True: line = yield from reader.readline() if not line: break yield from manager.handle(line.decode("UTF-8").strip()) except: pass yield from asyncio.sleep(2)
# or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License # for more details. # Pytigon - wxpython and django application framework # author: "Slawomir Cholaj ([email protected])" # copyright: "Copyright (C) ????/2012 Slawomir Cholaj" # license: "LGPL 3.0" # version: "0.1a" import pendulum import asyncio import types from asyncio.events import get_event_loop loop = get_event_loop() import twisted.internet.asyncioreactor twisted.internet.asyncioreactor.install(loop) from twisted.internet import reactor from twisted.web import xmlrpc, server import logging LOGGER = logging.getLogger("pytigon_task") INIT_TIME = pendulum.now() def at_iterate(param): ret = [] def tab_from_str(s):
def __init__(self, mock_desc, loop=None): self.mock_desc = mock_desc self.loop = loop or get_event_loop()
global _TRACE _TRACE = True elif opt in ('--video',): global _VIDEO, _APP_SIZE _APP_SIZE = (1280, 720) _VIDEO = True return ret _PARAM = process_argv(sys.argv[1:]) if _PARAM == None: sys.exit(0) import asyncio from asyncio.events import get_event_loop LOOP = get_event_loop() from schserw import settings as schserw_settings sys.path.append(schserw_settings.PRJ_PATH) from schlib.schtools.install_init import init init("_schall", schserw_settings.ROOT_PATH, schserw_settings.DATA_PATH, schserw_settings.PRJ_PATH, schserw_settings.STATIC_APP_ROOT, [schserw_settings.MEDIA_ROOT, schserw_settings.UPLOAD_PATH]) import wx _ = wx.GetTranslation def process_adv_argv(): global _PARAM if not ('args' in _PARAM and len(_PARAM['args']) > 0): _app = wx.App()
def current_ioloop(): return events.get_event_loop()