def __init__(self, redis_pool, message_handler, pubsub_key):
self.pubsub_key = pubsub_key
self.message_handler = message_handler
self.redis_pool = redis_pool
self.subscriber = None
self.message_loop_task = None
asyncio.new_event_loop().run_until_complete(self.setup_subscriber())
def test_loop_asyncio():
import asyncio
aio_loop = asyncio.new_event_loop()
loop.integrate(aio_loop, reset=False)
res = []
def callback():
res.append(1)
loop.call_soon(callback)
aio_loop.stop()
aio_loop.run_forever()
assert len(res) == 1
# Now run wrong loop
aio_loop = asyncio.new_event_loop()
# loop.integrate(aio_loop, reset=False) -> dont do this (yet)
loop.call_soon(callback)
aio_loop.stop()
aio_loop.run_forever()
assert len(res) == 1
loop.integrate(aio_loop, reset=False) # but do it now
aio_loop.stop()
aio_loop.run_forever()
aio_loop.stop()
aio_loop.run_forever()
assert len(res) == 2
def test_flexx_in_thread1():
""" Test threading and ioloop selection.
"""
def main():
asyncio.set_event_loop(loop2)
app.create_server()
# Create 3 loops, nr 2 is made current in the thread
loop1 = asyncio.new_event_loop()
loop2 = asyncio.new_event_loop()
loop3 = asyncio.new_event_loop()
asyncio.set_event_loop(loop1)
server1 = app.create_server()
t = threading.Thread(target=main)
t.start()
t.join()
server2 = app.current_server() # still current as set by the thread
asyncio.set_event_loop(loop3)
server3 = app.create_server()
assert server1._loop is loop1
assert server2._loop is loop2
assert server3._loop is loop3
def test_rebinding_ioloop():
""" Test recreating server objects, and its binding to the current ioloop.
"""
res = []
def add_res(i):
res.append(i)
# Create new ioloop
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
# Create new flexx server, which binds to that loop
server1 = app.create_server()
assert server1 is app.current_server()
#
assert loop is server1._loop
# Create new ioloop
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
# This is a new loop
assert loop is not server1._loop
# Create new flexx server, which binds to that loop
server2 = app.create_server()
assert server2 is app.current_server()
assert server1 is not server2
#
assert loop is server2._loop
def get_loop(self):
if self.loop is None:
try:
self.loop = asyncio.get_event_loop()
except RuntimeError:
# attempt to recover by making new loop
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
if self.loop.is_closed():
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
return self.loop
def test_asyncio_composition_checks_for_same_loop(self):
import asyncio
f1 = asyncio.Future(loop=asyncio.new_event_loop())
f2 = asyncio.Future(loop=asyncio.new_event_loop())
self.assertRaises(ValueError, asyncio.Future.gather, [f1, f2])
self.assertRaises(ValueError, asyncio.Future.first, [f1, f2])
self.assertRaises(ValueError, asyncio.Future.first_successful, [f1, f2])
f1 = asyncio.Future.failed(TypeError())
f3 = f1.fallback(f2)
self.assertRaises(ValueError, asyncio.get_event_loop().run_until_complete, f3)
def test_server_in_separate_thread(self):
sock = socket.socket()
server_loop = asyncio.new_event_loop()
server_loop.set_debug(True)
server, server_thread = self._start_server_thread(server_loop, sock)
client_loop = asyncio.new_event_loop()
client_loop.set_debug(True)
add_result = client_loop.run_until_complete(
test_server_with_client(sock, client_loop),
)
self.assertEqual(42, add_result)
server_loop.call_soon_threadsafe(server.close)
server_thread.join()
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.transport = unittest.mock.Mock()
self.stream = aiohttp.StreamParser(loop=self.loop)
self.response = HttpResponse('get', 'http://python.org')
def main():
asyncio.set_event_loop(None)
if args.iocp:
from asyncio.windows_events import ProactorEventLoop
loop = ProactorEventLoop()
else:
loop = asyncio.new_event_loop()
sslctx = None
if args.tls:
import ssl
# TODO: take cert/key from args as well.
here = os.path.join(os.path.dirname(__file__), '..', 'tests')
sslctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
sslctx.options |= ssl.OP_NO_SSLv2
sslctx.load_cert_chain(
certfile=os.path.join(here, 'ssl_cert.pem'),
keyfile=os.path.join(here, 'ssl_key.pem'))
cache = Cache(loop)
task = asyncio.streams.start_server(cache.handle_client,
args.host, args.port,
ssl=sslctx, loop=loop)
svr = loop.run_until_complete(task)
for sock in svr.sockets:
logging.info('socket %s', sock.getsockname())
try:
loop.run_forever()
finally:
loop.close()
def test_ctor_with_default_loop(self):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self.addCleanup(loop.close)
self.addCleanup(asyncio.set_event_loop, None)
conn = aiohttp.BaseConnector()
self.assertIs(loop, conn._loop)
def seed_fetcher(self, fetcher_inbox):
loop = new_event_loop()
ActorCls = FetcherSeeder.init(self.seed_path)
outbox = UnixSocketClient(fetcher_inbox, loop)
actor = ActorCls(None, outbox, loop=loop)
loop.run_until_complete(actor.start())
def setUp(self):
# This simulates the effect of an asyncio test harness like
# pytest-asyncio.
self.orig_loop = asyncio.get_event_loop()
self.new_loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.new_loop)
super(GetNewIOLoopTest, self).setUp()
def add_task(self, task_id):
try:
loop = asyncio.get_event_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(self._new_task(task_id))
def run_loop(action, options):
assert callable(action)
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
print_header('START {}'.format(action.__name__))
try:
config = backend.get_config()
cli_delegate = CliDelegate()
result = loop.run_until_complete(action(config, block=True, async_delegate=cli_delegate, options=options))
pp = PrettyPrint(result)
pp.stage_name = action.__name__
pp.beautify('print_data')
finally:
loop.close()
exitcode = 0
for host_result in result:
for command_result in host_result:
for host, process_result in command_result.items():
if process_result['returncode'] != 0:
exitcode += 1
print_header('ACTION {} COMPLETE'.format(action.__name__))
pp.print_summary()
return exitcode
def run_in_loop(s_args, s_kwargs, c_args, c_kwargs):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
server = aioftp.Server(*s_args, loop=loop, **s_kwargs)
client = aioftp.Client(*c_args, loop=loop, **c_kwargs)
coro = asyncio.coroutine(f)
try:
loop.run_until_complete(coro(loop, client, server))
finally:
if hasattr(server, "server"):
server.close()
loop.run_until_complete(server.wait_closed())
if hasattr(client, "writer"):
client.close()
loop.close()
def http(self):
if self._parent:
return self._parent.http
else:
if self._http is None:
self._http = HttpClient(loop=asyncio.new_event_loop())
return self._http
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.database = 'aiopg'
self.user = '******'
self.host = '127.0.0.1'
self.password = '******'
def test_worker_close(worker):
loop = asyncio.new_event_loop()
asyncio.sleep = mock.Mock(wraps=asyncio.coroutine(lambda *a, **kw: None))
worker.ppid = 1
worker.pid = 2
worker.cfg.graceful_timeout = 1.0
worker.signal = mock.Mock()
worker.signal.stopped = False
worker.wsgi = mock.Mock()
conn = mock.Mock()
conn.websocket = mock.Mock()
conn.websocket.close_connection = mock.Mock(
wraps=asyncio.coroutine(lambda *a, **kw: None)
)
worker.connections = set([conn])
worker.log = mock.Mock()
worker.loop = loop
server = mock.Mock()
server.close = mock.Mock(wraps=lambda *a, **kw: None)
server.wait_closed = mock.Mock(
wraps=asyncio.coroutine(lambda *a, **kw: None)
)
worker.servers = {server: {"requests_count": 14}}
worker.max_requests = 10
# close worker
_close = asyncio.ensure_future(worker.close(), loop=loop)
loop.run_until_complete(_close)
assert worker.signal.stopped
assert conn.websocket.close_connection.called
assert len(worker.servers) == 0
def setUp(self):
self.transport = Mock()
self.transport.write = self._write
self.responses = []
self._old_loop = asyncio.get_event_loop()
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
def setUp(self):
self._bot = make_mock_bot()
self._store = make_clean_mongo_store()
self._looper = FakeLooper()
# http://stackoverflow.com/questions/23033939/how-to-test-python-3-4-asyncio-code
self._loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
def test_run_max_requests_exceeded(worker):
loop = asyncio.new_event_loop()
worker.ppid = 1
worker.alive = True
sock = mock.Mock()
sock.cfg_addr = ("localhost", 8080)
worker.sockets = [sock]
worker.wsgi = mock.Mock()
worker.connections = set()
worker.log = mock.Mock()
worker.loop = loop
worker.servers = {
"server1": {"requests_count": 14},
"server2": {"requests_count": 15},
}
worker.max_requests = 10
worker._run = mock.Mock(wraps=asyncio.coroutine(lambda *a, **kw: None))
# exceeding request count
_runner = asyncio.ensure_future(worker._check_alive(), loop=loop)
loop.run_until_complete(_runner)
assert not worker.alive
worker.notify.assert_called_with()
worker.log.info.assert_called_with(
"Max requests exceeded, shutting " "down: %s", worker
)
def wrapper(*args, **kwargs):
coroutine = asyncio.coroutine(function)
loop = asyncio.new_event_loop()
kwargs['loop'] = loop
future = coroutine(*args, **kwargs)
loop.run_until_complete(future)
loop.close()
def loop():
'''
Keep things clean by using a new event loop
'''
loop = asyncio.new_event_loop()
loop.set_debug(True)
return loop
def wrapper(**kwargs):
@asyncio.coroutine
def coroutine(loop, kwargs):
redis = yield from find_connection(loop)
if 'redis' in kwargs:
kwargs['redis'] = redis
if 'loop' in kwargs:
kwargs['loop'] = loop
try:
yield from asyncio.coroutine(f)(**kwargs)
except Exception:
raise
finally:
yield from redis.flushdb()
redis.close()
yield from redis.wait_closed()
loop = asyncio.new_event_loop()
if 'set_loop' in kwargs:
asyncio.set_event_loop(loop)
else:
asyncio.set_event_loop(None)
loop.run_until_complete(coroutine(loop, kwargs))
loop.stop()
loop.run_forever()
loop.close()
gc.collect()
asyncio.set_event_loop(None)
def __init__(self, now_playing):
config = ConfigParser()
config.read(os.path.join('..', 'config.ini'))
conf = {
'discord': {
'email': config.get('discord', 'email'),
'pass': config.get('discord', 'pass'),
},
}
print('Starting new event loop for discord api')
loop = asyncio.new_event_loop()
try:
self.client = discord.Client(loop=loop)
print('Discord client created')
@self.client.event
async def on_ready():
print('Client ready')
await self.client.change_status(game=discord.Game(name=now_playing))
print('Status set')
loop.run_until_complete(self.client.close())
print('Shutting down client')
self.client.run(conf['discord']['email'], conf['discord']['pass'])
except Exception:
print("Exception! Quitting")
loop.run_until_complete(self.client.close())
finally:
print('Closing event loop')
loop.close()
def create_router(self):
class MockController(object):
def __init__(self, configuration, cache_factory, *args):
pass
@asyncio.coroutine
def test_operation(self, parameter1: 'help1', parameter2: 'help2', parameter3: 'help3'='default'):
"""function help"""
return parameter1 + parameter2 + parameter3
@asyncio.coroutine
def test_raise_controller_error(self):
"""raise 1"""
raise colorcore.routing.ControllerError('Test error')
@asyncio.coroutine
def test_raise_transaction_builder_error(self):
"""raise 2"""
raise openassets.transactions.InsufficientAssetQuantityError
self.configuration = unittest.mock.Mock()
self.output = io.StringIO()
event_loop = asyncio.new_event_loop()
create_server_return_value = asyncio.Future(loop=event_loop)
create_server_return_value.set_result(None)
event_loop.create_server = unittest.mock.Mock(
spec=event_loop.create_server, return_value=create_server_return_value)
return (
colorcore.routing.Router(MockController, self.output, object, self.configuration, event_loop),
event_loop)
def test_lock_by_with_statement(self):
loop = asyncio.new_event_loop() # don't use TestLoop quirks
self.set_event_loop(loop)
primitives = [
asyncio.Lock(loop=loop),
asyncio.Condition(loop=loop),
asyncio.Semaphore(loop=loop),
asyncio.BoundedSemaphore(loop=loop),
]
@asyncio.coroutine
def test(lock):
yield from asyncio.sleep(0.01, loop=loop)
self.assertFalse(lock.locked())
with self.assertWarns(DeprecationWarning):
with (yield from lock) as _lock:
self.assertIs(_lock, None)
self.assertTrue(lock.locked())
yield from asyncio.sleep(0.01, loop=loop)
self.assertTrue(lock.locked())
self.assertFalse(lock.locked())
for primitive in primitives:
loop.run_until_complete(test(primitive))
self.assertFalse(primitive.locked())
def _set_event_loop(self):
if self.run_async:
self._event_loop = asyncio.get_event_loop()
else:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
self._event_loop = loop
def run(self):
"""
The thread function. This represents a new thread of execution.
"""
while self.should_run is True:
if self.discord_connection is not None:
self.discord_connection.logout()
print("!!! Attempting to reconnect.")
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.discord_connection = discord.Client()
@self.discord_connection.event
@asyncio.coroutine
def on_message(message):
if message.type is discord.MessageType.default:
self.outgoing_lock.acquire()
self.outgoing_messages.append(message)
self.outgoing_lock.release()
try:
self.discord_connection.loop.create_task(self.process_input_messages())
self.discord_connection.run(self.configuration["token"])
except Exception as e:
print("!!! Discord connection threw an exception: %s" % str(e))
def run(args):
"""Handle ensure configuration commandline script."""
# Disable logging
logging.getLogger('homeassistant.core').setLevel(logging.CRITICAL)
parser = argparse.ArgumentParser(
description=("Run a Home Assistant benchmark."))
parser.add_argument('name', choices=BENCHMARKS)
parser.add_argument('--script', choices=['benchmark'])
args = parser.parse_args()
bench = BENCHMARKS[args.name]
print('Using event loop:', asyncio.get_event_loop_policy().__module__)
with suppress(KeyboardInterrupt):
while True:
loop = asyncio.new_event_loop()
hass = core.HomeAssistant(loop)
hass.async_stop_track_tasks()
runtime = loop.run_until_complete(bench(hass))
print('Benchmark {} done in {}s'.format(bench.__name__, runtime))
loop.run_until_complete(hass.async_stop())
loop.close()
return 0
def make_pool(cls):
pool = concurrent.futures.ThreadPoolExecutor(1)
pool.submit(adjust_event_loop_policy).result()
pool.submit(
lambda: asyncio.set_event_loop(asyncio.new_event_loop())).result()
return pool
def init_loop(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
self.loop.queue = asyncio.Queue()
def run(
provider,
# AWS
profile=None,
aws_access_key_id=None,
aws_secret_access_key=None,
aws_session_token=None,
# Azure
user_account=False,
service_account=None,
cli=False,
msi=False,
service_principal=False,
file_auth=None,
tenant_id=None,
subscription_id=None,
client_id=None,
client_secret=None,
username=None,
password=None,
# GCP
project_id=None,
folder_id=None,
organization_id=None,
all_projects=False,
# Aliyun
access_key_id=None,
access_key_secret=None,
# General
report_name=None,
report_dir=None,
timestamp=False,
services=[],
skipped_services=[],
result_format='json',
database_name=None,
host_ip='127.0.0.1',
host_port=8000,
max_workers=10,
regions=[],
excluded_regions=[],
fetch_local=False,
update=False,
max_rate=None,
ip_ranges=[],
ip_ranges_name_key='name',
ruleset='default.json',
exceptions=None,
force_write=False,
debug=False,
quiet=False,
log_file=None,
no_browser=False,
programmatic_execution=True):
"""
Run a scout job in an async event loop.
"""
loop = asyncio.get_event_loop()
if loop.is_closed():
loop = asyncio.new_event_loop()
# Set the throttler within the loop so it's accessible later on
loop.throttler = Throttler(rate_limit=max_rate if max_rate else 999999,
period=1)
loop.set_default_executor(ThreadPoolExecutor(max_workers=max_workers))
result = loop.run_until_complete(
_run(**locals())) # pass through all the parameters
loop.close()
return result
def run_client(my_configs_path,
other_configs_path,
num_of_commands=10,
port=0):
''' Run the VASP's client to send commands to the other VASP.
The VASP sends <num_of_commands> commands to the other VASP, on port <port>.
If <port> is 0, the VASP defaults to the port specified in <other_configs>.
Being able to easily modify the port allows to quickly test performance
in different situations, such as HTTP, HTTPS, or custom port.
The arguments <my_configs_path> and <other_configs_path> are paths to
files describing the configurations of the current VASP and of the other
VASP, respectively. Configs are dict taking the following form:
configs = {
'addr': <LibraAddress>,
'base_url': <str>,
'port': <int>,
}
'''
assert num_of_commands > 0
my_configs = load_configs(my_configs_path)
other_configs = load_configs(other_configs_path)
my_addr = my_configs['addr']
other_addr = other_configs['addr']
# Create VASP.
vasp = Vasp(my_addr,
host='0.0.0.0',
port=my_configs['port'],
business_context=TestBusinessContext(my_addr),
info_context=SimpleVASPInfo(my_configs, other_configs, port),
database={})
logging.info(f'Created VASP {my_addr.as_str()}.')
# Run VASP services.
def start_services(vasp, loop):
vasp.start_services()
logging.debug('Start main loop.')
try:
loop.run_forever()
finally:
loop.run_until_complete(loop.shutdown_asyncgens())
loop.close()
loop = asyncio.new_event_loop()
vasp.set_loop(loop)
t = Thread(target=start_services, args=(vasp, loop), daemon=True)
t.start()
logging.info(f'VASP services are running on port {vasp.port}.')
# Make a payment commands.
commands = []
for cid in range(num_of_commands):
sub_a = LibraAddress.from_bytes(b'A' * 16, b'a' * 8).as_str()
sub_b = LibraAddress.from_bytes(b'B' * 16, b'b' * 8).as_str()
sender = PaymentActor(sub_b, StatusObject(Status.none), [])
receiver = PaymentActor(sub_a, StatusObject(Status.none), [])
action = PaymentAction(10, 'TIK', 'charge', '2020-01-02 18:00:00 UTC')
reference = f'{my_addr.as_str()}_{cid}'
payment = PaymentObject(sender, receiver, reference, 'orig_ref',
'desc', action)
cmd = PaymentCommand(payment)
commands += [cmd]
# Send commands.
logging.info(
'Start measurements: '
f'sending {num_of_commands} commands to {other_addr.as_str()}.')
logging.info(
f'The target URL is {vasp.info_context.get_peer_base_url(other_addr)}')
start_time = time.perf_counter()
async def send_commands(vasp, commands):
return await asyncio.gather(
*[vasp.new_command_async(other_addr, c) for c in commands],
return_exceptions=True)
res = asyncio.run_coroutine_threadsafe(send_commands(vasp, commands), loop)
res = res.result()
elapsed = (time.perf_counter() - start_time)
# Display performance and success rate.
success_number = sum([1 for r in res if r])
logging.info(f'Commands executed in {elapsed:0.2f} seconds.')
logging.info(f'Success #: {success_number}/{len(commands)}.')
logging.info(f'Estimate throughput #: {len(commands)/elapsed} TPS.')
def __init__(self, controller):
self._controller = controller
self._users = {}
self._loop = asyncio.new_event_loop()
asyncio.set_event_loop(self._loop)
def event_loop():
"""A module-scoped event loop."""
return asyncio.new_event_loop()
def __exit__(self, exc_type, exc_value, traceback):
"""Remove self from existing instances."""
sys.path = self.stored_path
self.__class__.instances = []
asyncio.set_event_loop(asyncio.new_event_loop())
def delete_upload_async(request):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
result = loop.run_in_executor(None, delete_media_files)
return redirect('collage:collage-form')
def run(self):
global LIST_LOOP
LIST_LOOP = asyncio.new_event_loop()
result = LIST_LOOP.run_until_complete(self.start_listener())
def setUp(self):
"""Set up test class."""
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(self.loop)
def perspective_thread(manager):
"""Start a new perspective loop in this thread."""
loop = asyncio.new_event_loop()
manager.set_loop_callback(loop.call_soon_threadsafe)
loop.run_forever()
def __start(self):
loop = asyncio.new_event_loop()
loop.run_until_complete(self.receive_weights())
loop.run_forever()
def setUp(self):
self.loop = asyncio.new_event_loop()
asyncio.set_event_loop(None)
self.handler = xss.XssEmulator()
def main():
loop = asyncio.new_event_loop()
client = TelegramClient(
'anon',
settings.TELEGRAM_API_ID,
settings.TELEGRAM_API_HASH,
loop=loop).start(bot_token=settings.TELEGRAM_BOT_TOKEN)
@client.on(events.CallbackQuery)
async def callback(event):
data = event.query.data.decode("utf-8").lower()
print(data)
cmd_out = BOX.commands(data)(event=event)
# print(workpackages)
# if(workpackages):
# print("true1")
# cmd_out= BOX.commands(data)(event,workpackages)
# print("true")
# else:
# print("false")
# cmd_out= BOX.commands(data)(event)
# print("false")
#workpackages = cmd_out[3]
# print(event.query.user_id)
# print(event.query.__dict__.keys())
# print(event.query.data.decode("utf-8"))
# print(BOX.commands(event.query.data.decode("utf-8").lower())()[0])
# print(cmd_out)
await client.edit_message(event.chat_id,
event.query.msg_id,
cmd_out[0],
buttons=cmd_out[1])
def funcname(parameter_list):
pass
@client.on(events.NewMessage(pattern='/start'))
@client.on(events.NewMessage(pattern='/help'))
async def start(event):
"""Send a message when the command /start is issued."""
await event.respond(
"Hi, I'm an audio slave! :3\nI would love to convert every wav you got into a telegram voice message. (>.<)"
)
raise events.StopPropagation
@client.on(events.NewMessage(pattern='/init'))
async def start(event):
"""Send a message when the command /start is issued."""
cmd_out = BOX.commands('start')()
print(cmd_out)
await event.respond(cmd_out[0], buttons=cmd_out[1])
raise events.StopPropagation
@client.on(events.NewMessage)
async def echo(event):
"""Echo the user message."""
# if telegram message has attached a wav file, download and convert it
if event.message.file and event.message.file.mime_type == 'audio/x-wav':
msg = await event.respond("Processing...")
try:
#start = time.time()
await msg.edit("**Downloading start...**")
# audio_in = io.BytesIO()
#audio_in.name = f"{event.message.file.name.split('.')[0]}_snek_{event.message.date.strftime('%m-%d_%H-%M')}.wav"
# audio_in = await client.download_media(event.message, audio_in, progress_callback=lambda d, t: asyncio.get_event_loop().create_task(
# progress(d, t, msg, start)))
# audio_seg = AudioSegment.from_wav(audio_in)
# audio_out = io.BytesIO()
# audio_out = audio_seg.export(audio_out, bitrate="128k", format='ogg', codec="opus", parameters=["-strict", "-2", "-ac", "2", "-vol", "150"], tags={"ARTIST": "waveater", "GENRE": "Meeting/Trashtalk", "ALBUM": "waveater", "TITLE": f"{event.message.file.name.split('.')[0]}_{event.message.media.document.date.strftime('%m-%d_%H-%M')}", "DATE": f"{event.message.media.document.date.strftime('%Y/%m/%d_%H:%M:%S')}", "COMMENT": f"A wav file converted to telegram voice message.", "CONTACT":"@waveater"})
# audio_out.name = f"{event.message.file.name.split('.')[0]}_{event.message.media.document.date.strftime('%m-%d_%H-%M')}.ogg"
# print(len(audio_seg)//1000)
# print(event.message.file.id)
# print(event.message.file.title)
# print(event.message.file.performer)
# print(event.message.file.name)
# print(event.message.file.duration)
result = await client.send_file(
event.chat_id,
audio_out,
voice_note=True,
caption=
f"{event.message.message}\n\n`track: '{event.message.file.name.split('.')[0]}_{event.message.media.document.date.strftime('%m-%d_%H-%M')}',\nchannel: '{audio_seg.channels}'',\nformat: 'ogg',\ncodec: 'opus',\nbitrate: '128k'`",
reply_to=event.message)
# print(result.file.duration)
# print(result.file.performer)
await msg.delete()
except Exception as e:
print(e)
await msg.edit(
f"OwO Shit happens! Something has gone wrong.\n\n**Error:** {e}"
)
# print(f"{threading.enumerate()}")
client.run_until_disconnected()
def asyncio_thread(self):
self.txloop = asyncio.new_event_loop()
self.txloop.set_debug(True)
asyncio.set_event_loop(self.txloop)
asyncio.run_coroutine_threadsafe(self.setup(), self.txloop)
self.txloop.run_forever()
def thread_handler():
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(read_bytes_from_outside())
loop.close()
def teardown_module(module):
try:
loop = asyncio.get_running_loop()
except RuntimeError:
loop = asyncio.new_event_loop()
loop.run_until_complete(f.shutdown())
def get_stations_synchronously() -> List[WeatherStation]:
""" Get list of stations - in a synchronous/blocking call.
"""
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
return loop.run_until_complete(get_stations_from_source(StationSourceEnum.LOCAL_STORAGE))
def go(self, fn, args):
return asyncio.new_event_loop().run_until_complete(fn(*args))
def __init__(self, uri, client_class=Client, *args, **kwargs):
super().__init__()
LOGGER.info('Server URI: %s', uri)
self._loop = asyncio.new_event_loop()
self._client = client_class(uri, self._loop, *args, **kwargs)
self.daemon = True
def run(
coro: Coroutine,
*,
loop: Optional[asyncio.AbstractEventLoop] = None,
debug: bool = False,
set_to_none: bool = False,
) -> Any:
"""Run a |coroutine_link|_.
This function runs the passed coroutine, taking care
of the event loop and shutting down asynchronous generators.
This function is basically ported from Python 3.7 for backwards compability
with earlier versions of Python.
This function cannot be called when another event loop is
running in the same thread.
If ``debug`` is ``True``, the event loop will be run in debug mode.
This function creates a new event loop and closes it at the end if a ``loop`` is ``None``.
If a loop is given, this function basically calls :meth:`asyncio.AbstractEventLoop.run_until_complete`.
It should be used as a main entry point to asyncio programs, and should
ideally be called only once.
Example:
.. code-block:: python3
async def test(pid):
return pid
one = gd.utils.run(test(1))
Parameters
----------
coro: |coroutine_link|_
Coroutine to run.
loop: Optional[:class:`asyncio.AbstractEventLoop`]
A loop to run ``coro`` with. If ``None`` or omitted, a new event loop is created.
debug: :class:`bool`
Whether or not to run event loop in debug mode.
set_to_none: :class:`bool`
Indicates if the loop should be set to None after execution.
Returns
-------
`Any`
Anything that ``coro`` returns.
"""
if asyncio._get_running_loop() is not None:
raise RuntimeError(
"Can not perform gd.utils.run() in a running event loop.")
if not asyncio.iscoroutine(coro):
raise ValueError(f"A coroutine was expected, got {coro!r}.")
shutdown = False
if loop is None:
loop = asyncio.new_event_loop()
shutdown = True
try:
asyncio.set_event_loop(loop)
loop.set_debug(debug)
return loop.run_until_complete(coro)
finally:
if shutdown:
shutdown_loop(loop)
if set_to_none:
loop = None
else:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
def connect(self):
""" """
loop = asyncio.new_event_loop()
self._event_thread = threading.Thread(target=self._run_loop, args=(loop,), daemon=True)
self._event_thread.start()
asyncio.run_coroutine_threadsafe(AioRobot.connect(self), loop).result()
def run(self):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
asyncio.get_event_loop().run_until_complete(self.send())
asyncio.get_event_loop().close()
def pingloop():
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(_pingloop())
loop.close()
def get_data_wrapper(*args, **kwargs):
# New thread - get the loop.
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
assert not loop.is_running()
return loop.run_until_complete(fn(*args, **kwargs))
def deepfryer(bot: Bot, update: Update):
global deepdata
global deepdata2
global deepdata3
message = update.effective_message
if message.reply_to_message:
deepdata = message.reply_to_message.photo
deepdata2 = message.reply_to_message.sticker
deepdata3 = message.reply_to_message.animation
else:
deepdata = []
deepdata2 = []
deepdata3 = []
# check if message does contain a photo and cancel when not
if not deepdata and not deepdata2 and not deepdata3:
message.reply_text("What am I supposed to do with this?!")
return
# download last photo (highres) as byte array
if deepdata:
photodata = deepdata[len(deepdata) -
1].get_file().download_as_bytearray()
image = Image.open(io.BytesIO(photodata))
elif deepdata2:
sticker = bot.get_file(deepdata2.file_id)
sticker.download('sticker.png')
image = Image.open("sticker.png")
elif deepdata3:
global fps
global imgno
global chat_id
chat_id = update.effective_chat.id
message.reply_text("detected gif")
gif = bot.get_file(deepdata3.file_id)
gif.download('gif.mp4')
if not Path('gifdata').is_dir():
os.makedirs('gifdata')
jsondata = ast.literal_eval(
os.popen(
'ffprobe -i gif.mp4 -v quiet -print_format json -show_format -show_streams -hide_banner'
).read())
stringfps = jsondata["streams"][0]["avg_frame_rate"]
templist = []
for i in stringfps.split('/'):
templist.append(float(i))
fps = numpy.divide(templist[0], templist[1])
if fps > 30.0:
message.reply_text(
"fps of the gif is too high! Make sure its less than or equal to 30! Reducing it to 20"
)
fps = 20.0
filesize = float(os.path.getsize('gif.mp4'))
if filesize > 5000000.0:
message.reply_text("Filesize is larger than 5MB! not allowed!")
deepdata3 = []
return
os.system('ffmpeg -i gif.mp4 -r {} gifdata/out%05d.jpg'.format(fps))
duration = float(jsondata["streams"][0]["duration"])
imgno = int(duration * fps)
image = 0
# the following needs to be executed async (because dumb lib)
loop = asyncio.new_event_loop()
loop.run_until_complete(
process_deepfry(image, message.reply_to_message, bot))
loop.close()
import asyncio
import sys
loop = asyncio.new_event_loop()
print(loop)
asyncio.set_event_loop(loop)
import pdb; pdb.set_trace()
if sys.platform != "win32":
watcher = asyncio.get_child_watcher()
# a gotcha --> must attach to the newly created loop to the event loop policy's watcher
# to make sure that our event loop monitors the termination of newly spawned subprocesses on UNIX systems.
watcher.attach_loop(loop)
def __init__(self):
super().__init__(name="NetworkThread")
# There is only one event loop and no more than one thread must be created
assert not self.network_event_loop
NetworkThread.network_event_loop = asyncio.new_event_loop()
def setUp(self):
self.loop = asyncio.new_event_loop()
self.loop.set_debug(False)
asyncio.set_event_loop(self.loop)
self.devices = self.load_credits()
self.assertFalse(len(self.devices) == 0)
async def requestandSend():
while True:
try :
inputSend()
except IOError:
#sys.exit() #Terminate the program
print("err")
def start_loop(loop):
asyncio.set_event_loop(loop)
loop.run_forever()
##Essentially the main()
##if you want to update a global within a function declare as global at start of function
loop1 = asyncio.new_event_loop()
t1 = Thread(target=start_loop, args=(loop1,))
loop2 = asyncio.new_event_loop()
t2 = Thread(target=start_loop, args=(loop2,))
t1.start() ##2 threads running in parallel
t2.start()
asyncio.run_coroutine_threadsafe(receiveandPrint(),loop1)
asyncio.run_coroutine_threadsafe(requestandSend(),loop2)
