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()
