Ejemplo n.º 1
0
def app_main():
    args = docopt.docopt(__doc__, version=__version__)

    debug = args["-d"]

    if debug:
        log_level = logging.DEBUG
    else:
        log_level = [logging.ERROR, logging.INFO, logging.DEBUG][args["-v"]]

    try:
        import coloredlogs

        coloredlogs.install(
            level=log_level, stream=stderr, datefmt=DATEFMT, fmt=LOGFMT
        )
    except ImportError:
        _LOGGER.debug("no colored logs. pip install coloredlogs?")
        logging.basicConfig(
            level=log_level, stream=stderr, datefmt=DATEFMT, format=LOGFMT
        )

    logging.captureWarnings(debug)

    if debug:
        _LOGGER.info("Debug is on")

    try:
        asyncio.run(main(args), debug=debug)  # pylint: disable=no-member
    except KeyboardInterrupt:
        exit()
Ejemplo n.º 2
0
    def test_asyncio_run_debug(self):
        async def main(expected):
            loop = asyncio.get_event_loop()
            self.assertIs(loop.get_debug(), expected)

        asyncio.run(main(False))
        asyncio.run(main(True), debug=True)
Ejemplo n.º 3
0
    def test_asyncio_run_raises(self):
        async def main():
            await asyncio.sleep(0)
            raise ValueError('spam')

        with self.assertRaisesRegex(ValueError, 'spam'):
            asyncio.run(main())
Ejemplo n.º 4
0
Archivo: base.py Proyecto: nak/pyllars
    def generate_code(node_tree: code_structure.TranslationUnitDecl,
                      src_paths: List[str],
                      output_dir: str,
                      compiler: Compiler):
        from .base2 import GeneratorHeader
        objects = []
        for src_path in src_paths:
            folder = Folder(output_dir)
            Generator.generator_mapping = {}

            queue = collections.deque()
            for element in node_tree.children():
                queue.append((element, folder, None))

            def pop():
                try:
                    return queue.pop()
                except IndexError:
                    return None, None, None

            async def generate_elements():
                nonlocal objects, queue
                element, folder, parent = pop()
                while element is not None:
                    if os.path.abspath(element.location) != os.path.abspath(src_path) or element.is_implicit:
                        element, folder, parent = pop()
                        continue

                    with GeneratorHeader.generator(element=element, src_path=src_path, folder=folder, parent=parent) as header_generator:
                        try:
                            header_generator.generate()
                        except:
                            log.exception("Failed to generate for element %s and its children" % element.name)
                            return
                    with GeneratorBody.generator(element=element, src_path=src_path, folder=folder, parent=parent) as body_generator:
                        try:
                            body_generator.generate()
                        except:
                            import traceback
                            traceback.print_exc()
                            log.exception("Failed to generate body for element %s" % element.name)
                            return
                    try:
                        obj = await compiler.compile_async(body_generator.body_file_path)
                        objects.append(obj)

                        for child in element.children():
                            queue.append((child, header_generator.folder, header_generator))
                    except:
                        log.exception("Failed to compile %s" % body_generator.body_file_path)
                    element, folder, parent = pop()
                GeneratorBody.common_stream().flush()

            async def main():
                await asyncio.gather(*[generate_elements() for _ in range(multiprocessing.cpu_count())])
                obj = await compiler.compile_async(GeneratorBody.common_stream().name);
                objects.append(obj)
            asyncio.run(main())
        return objects
Ejemplo n.º 5
0
 def __del__(self):
   if self.__our_session:
     loop = asyncio.get_event_loop()
     closer = self.session.close()
     if loop.is_running():
       asyncio.ensure_future(closer)
     else:
       asyncio.run(closer)
def main():
    if WINDOWS:
        asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())

    try:
        asyncio.run(amain())
    except (KeyboardInterrupt, SystemExit) as e:
        rootlogger.info('Received %r', e)
Ejemplo n.º 7
0
 def event_handler(self, data):
     rpt = Reporter(data)
     rpt.adorn(self._pepper)
     fmt = rpt.tidy()
     detail = rpt.detail()
     if fmt:
         asyncio.run(RealTimeMessage.send(fmt))
     if detail:
         self._result.append(detail)
Ejemplo n.º 8
0
 def anotherproc(path):
     async def lotsofwrites(path):
         os.remove(pathlib.Path(path).with_suffix('.opts.yaml'))
         async with await s_lmdbslab.Slab.anit(path, map_size=100000) as slab:
             foo = slab.initdb('foo', dupsort=True)
             mapsize = slab.mapsize
             count = 0
             while mapsize == slab.mapsize:
                 count += 1
                 slab.put(b'abcd', s_common.guid(count).encode('utf8') + byts, dupdata=True, db=foo)
     asyncio.run(lotsofwrites(path))
Ejemplo n.º 9
0
def render_html_to_png(html_data, filename):
    ws_url = get_ws_url()
    for i in range(0, 2):
        if i == 1:
            ws_url = get_ws_url(force=True)
        try:
            asyncio.run(render_html_async(html_data, filename, ws_url=ws_url))
            return
        except:
            if i > 0:
                raise
Ejemplo n.º 10
0
    def test_asyncio_run_from_running_loop(self):
        async def main():
            coro = main()
            try:
                asyncio.run(coro)
            finally:
                coro.close()  # Suppress ResourceWarning

        with self.assertRaisesRegex(RuntimeError,
                                    'cannot be called from a running'):
            asyncio.run(main())
Ejemplo n.º 11
0
 def run_async_test(self, func, jumpFrom, jumpTo, expected, error=None,
              event='line', decorated=False):
     tracer = JumpTracer(func, jumpFrom, jumpTo, event, decorated)
     sys.settrace(tracer.trace)
     output = []
     if error is None:
         asyncio.run(func(output))
     else:
         with self.assertRaisesRegex(*error):
             asyncio.run(func(output))
     sys.settrace(None)
     self.compare_jump_output(expected, output)
Ejemplo n.º 12
0
def main() -> None:
    """
    main method of application,  expressed as a function so pylint won't
    complain about how I use the main namespace.  Boots asynchronous main
    method inside default event loop.

    :return:
    """
    if "LOGGING_LEVEL" in environ:
        getLogger(None).setLevel(environ["LOGGING_LEVEL"])
    getLogger(None).addHandler(StreamHandler())

    run(amain())
Ejemplo n.º 13
0
    def test_proactor_win_policy(self):
        async def main():
            self.assertIsInstance(
                asyncio.get_running_loop(),
                asyncio.ProactorEventLoop)

        old_policy = asyncio.get_event_loop_policy()
        try:
            asyncio.set_event_loop_policy(
                asyncio.WindowsProactorEventLoopPolicy())
            asyncio.run(main())
        finally:
            asyncio.set_event_loop_policy(old_policy)
Ejemplo n.º 14
0
def run(
        bot_constructor: BotConstructor,
        config_file: str = "bot.conf",
        ) -> None:
    async def _run() -> None:
        while True:
            # Load the config file
            config = configparser.ConfigParser(allow_no_value=True)
            config.read(config_file)

            bot = bot_constructor(config, config_file)
            await bot.run()

    asyncio.run(_run())
Ejemplo n.º 15
0
 def status_handler(self, data, runner_config=None):
     status = data.get('status', '') if isinstance(data, dict) else data
     for item in self._drawer:
         if item.get('status', None) == status:
             raw = item.get('raw', lambda: {})()
             after = item.get('after', lambda: {})()
             # print('====>', raw, after)
             rpt = Reporter(raw)
             rpt.adorn({raw.get('event'): after})
             fmt = rpt.tidy()
             detail = rpt.detail()
             if fmt:
                 asyncio.run(RealTimeMessage.send(fmt))
                 # await RealTimeMessage.send(fmt)
             if detail:
                 self._result.append(detail)
Ejemplo n.º 16
0
def get_master_list(name, *args, **kwargs):
    assert name in ('mounts', 'pets', 'achievements', 'realms')

    async def get():
        async with BnetClient() as client:
            return (await getattr(client, name)(*args, **kwargs))
    return asyncio.run(get())
Ejemplo n.º 17
0
def run_modulebot(
        modulebot_constructor: ModuleBotConstructor,
        module_constructors: Dict[str, ModuleConstructor],
        config_file: str = "bot.conf",
        ) -> None:
    async def _run() -> None:
        while True:
            # Load the config file
            config = configparser.ConfigParser(allow_no_value=True)
            config.read(config_file)

            modulebot = modulebot_constructor(config, config_file,
                    module_constructors)
            await modulebot.run()

    asyncio.run(_run())
Ejemplo n.º 18
0
    def test_asyncio_run_reports_hanging_tasks_errors(self):
        lo_task = None
        call_exc_handler_mock = mock.Mock()

        async def leftover():
            try:
                await asyncio.sleep(0.1)
            except asyncio.CancelledError:
                1 / 0

        async def main():
            loop = asyncio.get_running_loop()
            loop.call_exception_handler = call_exc_handler_mock

            nonlocal lo_task
            lo_task = asyncio.create_task(leftover())
            return 123

        self.assertEqual(asyncio.run(main()), 123)
        self.assertTrue(lo_task.done())

        call_exc_handler_mock.assert_called_with({
            'message': test_utils.MockPattern(r'asyncio.run.*shutdown'),
            'task': lo_task,
            'exception': test_utils.MockInstanceOf(ZeroDivisionError)
        })
Ejemplo n.º 19
0
Archivo: cli.py Proyecto: orf/xcat
def detect(attack_context):
    payloads: List[Injection] = asyncio.run(get_injections(attack_context))

    if not payloads:
        click.echo(click.style('Error: No injections detected', 'red'), err=True)
        exit(1)

    for payload in payloads:
        click.echo(click.style(payload.name, 'green'))
        click.echo('Example: ' + click.style(payload.example, 'yellow'))
    click.echo()

    features: List[Tuple[Feature, bool]] = asyncio.run(get_features(attack_context, payloads[0]))
    click.echo('Detected features:')
    for feature, available in features:
        click.echo(click.style(feature.name, 'blue') + ': ', nl=False)
        click.echo(click.style(str(available), 'green' if available else 'red'))
Ejemplo n.º 20
0
def block_processing(evt1):
    '''
    Function to make a base and call main().  Used as a Process target.

    Args:
        evt1 (multiprocessing.Event): event to twiddle
    '''
    async def main():

        base = await s_base.Base.anit()
        await base.addSignalHandlers()

        evt1.set()

        await base.waitfini()

    asyncio.run(main())
    sys.exit(137)
Ejemplo n.º 21
0
def test_wraps_async():
    # from https://github.com/mahmoud/boltons/issues/194
    import asyncio

    def delayed(func):
        @wraps(func)
        async def wrapped(*args, **kw):
            await asyncio.sleep(1.0)
            return await func(*args, **kw)

        return wrapped


    async def f():
        await asyncio.sleep(0.1)

    assert asyncio.iscoroutinefunction(f)

    f2 = delayed(f)

    assert asyncio.iscoroutinefunction(f2)

    # from https://github.com/mahmoud/boltons/pull/195
    def yolo():
        def make_time_decorator(wrapped):
            @wraps(wrapped)
            async def decorator(*args, **kw):
                return (await wrapped(*args, **kw))
            return decorator

        return make_time_decorator


    @yolo()
    async def foo(x):
        await asyncio.sleep(x)

    start_time = time.monotonic()
    asyncio.run(foo(0.3))
    duration = time.monotonic() - start_time

    # lol windows py37 somehow completes this in under 0.3
    # "assert 0.29700000000002547 > 0.3" https://ci.appveyor.com/project/mahmoud/boltons/builds/22261051/job/3jfq1tq2233csqp6
    assert duration > 0.25
Ejemplo n.º 22
0
def test_ping_elsewhere():
    """
    The following is a private network that you probably aren't on.  Unless you are!

    Should always fail to route because you can't route to this address via the public
    internet.

    :return:
    """
    assert(not run(ping("10.254.254.254")))
Ejemplo n.º 23
0
    def test_asyncio_run_cancels_hanging_tasks(self):
        lo_task = None

        async def leftover():
            await asyncio.sleep(0.1)

        async def main():
            nonlocal lo_task
            lo_task = asyncio.create_task(leftover())
            return 123

        self.assertEqual(asyncio.run(main()), 123)
        self.assertTrue(lo_task.done())
Ejemplo n.º 24
0
def test():
  urls = (
    'http://lilydjwg.is-programmer.com/',
    'http://www.baidu.com',
    'https://zh.wikipedia.org', # redirection
    'http://redis.io/',
    'http://lilydjwg.is-programmer.com/2012/10/27/streaming-gzip-decompression-in-python.36130.html', # maybe timeout
    'http://img.vim-cn.com/22/cd42b4c776c588b6e69051a22e42dabf28f436', # image with length
    'https://github.com/m13253/titlebot/blob/master/titlebot.py_', # 404
    'http://lilydjwg.is-programmer.com/admin', # redirection
    'http://twitter.com', # connect timeout
    'http://www.wordpress.com', # reset
    'http://jquery-api-zh-cn.googlecode.com/svn/trunk/xml/jqueryapi.xml', # xml
    'http://lilydjwg.is-programmer.com/user_files/lilydjwg/config/avatar.png', # PNG
    'http://img01.taobaocdn.com/bao/uploaded/i1/110928240/T2okG7XaRbXXXXXXXX_!!110928240.jpg', # JPEG with Start Of Frame as the second block
    'http://file3.u148.net/2013/1/images/1357536246993.jpg', # JPEG that failed previous code
    'http://gouwu.hao123.com/', # HTML5 GBK encoding
    'https://github.com/lilydjwg/winterpy', # github url finder
    'http://github.com/lilydjwg/winterpy', # github url finder with redirect
    'http://导航.中国/', # Punycode. This should not be redirected
    'http://t.cn/zTOgr1n', # multiple redirections
    'http://www.galago-project.org/specs/notification/0.9/x408.html', # </TITLE\n>
    'http://x.co/dreamz', # redirection caused false ConnectionClosed error
    'https://www.inoreader.com', # malformed start tag: <meta http-equiv="Content-Type" content="text/html" ; charset="UTF-8">
    'https://linuxtoy.org/archives/linux-deepin-2014-alpha-into-new-deepin-world.html', # charref outside ASCII
    'http://74.125.235.191/search?site=&source=hp&q=%E6%9C%8D%E5%8A%A1%E5%99%A8+SSD&btnG=Google+%E6%90%9C%E7%B4%A2', # right charset in HTTP, wrong in HTML
    'http://digital.sina.com.hk/news/-7-1514837/1.html', # mixed Big5 and non-Big5 escaped Unicode character
    'http://cache.baiducontent.com/c?m=9f65cb4a8c8507ed4fece7631046893b4c4380147c808c5528888448e435061e5a27b9e867750d04d6c57f6102ad4b57f7fa3372340126bc9fcc825e98e6d27e20d77465671df65663a70edecb5124b137e65ffed86ef0bb8025e3ddc5a2de4352ba44757d97818d4d0164dd1efa034093b1e842022e60adec40728f2d6058e93430c6508ae5256f779686d94b3db3&p=882a9e41c0d25ffc57efdc394c52&newp=8a64865b85cc43ff57e6902c495f92695803ed603fd3d7&user=baidu&fm=sc&query=mac%CF%C2%D7%EE%BA%C3%B5%C4%C8%CB%C8%CB%BF%CD%BB%A7%B6%CB&qid=&p1=5', # HTML document inside another, correct charset is in outside one and title inside
    'http://www.wooyun.org/bugs/wooyun-2014-069132?214&1780', # provide cookie or loop
    'https://togetherjs.com/', # fail if no SNI
    'https://forum.suse.org.cn/', # most Linux distributions seem not to trust this
    'http://www.aosabook.org/en/posa/parsing-xml-at-the-speed-of-light.html', # <span> tag inside <title> tag
    'http://github.com/contact', # redirect and should not use GitHub API
    'http://caml.inria.fr/pub/docs/manual-ocaml/',
    'http://localhost/', # should fail with ValueError
    'https://friends.nico',
  )
  asyncio.run(main(urls))
Ejemplo n.º 25
0
def main(argv=None):
	if argv is None:
		argv = sys.argv

	try:
		if sys.platform == "win32":
			asyncio.set_event_loop_policy(asyncio.WindowsProactorEventLoopPolicy())

		return asyncio.run(amain(
			args=argv[1:],
			prog=argv[0]
		))
	except KeyboardInterrupt:
		print(file=sys.stderr)
Ejemplo n.º 26
0
    def test_asyncio_run_closes_gens_after_hanging_tasks_errors(self):
        spinner = None
        lazyboy = None

        class FancyExit(Exception):
            pass

        async def fidget():
            while True:
                yield 1
                await asyncio.sleep(1)

        async def spin():
            nonlocal spinner
            spinner = fidget()
            try:
                async for the_meaning_of_life in spinner:  # NoQA
                    pass
            except asyncio.CancelledError:
                1 / 0

        async def main():
            loop = asyncio.get_running_loop()
            loop.call_exception_handler = mock.Mock()

            nonlocal lazyboy
            lazyboy = asyncio.create_task(spin())
            raise FancyExit

        with self.assertRaises(FancyExit):
            asyncio.run(main())

        self.assertTrue(lazyboy.done())

        self.assertIsNone(spinner.ag_frame)
        self.assertFalse(spinner.ag_running)
Ejemplo n.º 27
0
Archivo: main.py Proyecto: icgood/pymap
def main() -> None:
    parser = ArgumentParser(
        description=__doc__,
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser.add_argument('--debug', action='store_true',
                        help='increase printed output for debugging')
    parser.add_argument('--version', action='version',
                        version='%(prog)s ' + __version__)
    parser.add_argument('--set-uid', metavar='USER', type=_get_pwd,
                        help='drop privileges to user name or uid')
    parser.add_argument('--set-gid', metavar='GROUP', type=_get_grp,
                        help='drop privileges to group name or gid')
    parser.add_argument('--logging-cfg', metavar='PATH',
                        help='config file for logging')
    parser.add_argument('--no-service', dest='skip_services', action='append',
                        metavar='NAME', help='do not run the given service')
    subparsers = parser.add_subparsers(dest='backend',
                                       help='which pymap backend to use')

    backends: _Backends = _load_entry_points('pymap.backend')
    services: _Services = _load_entry_points('pymap.service')

    for backend_name, backend_cls in backends.items():
        backend_cls.add_subparser(backend_name, subparsers)
    for service_cls in services.values():
        service_cls.add_arguments(parser)
    parser.set_defaults(skip_services=[])
    args = parser.parse_args()

    if args.logging_cfg:
        logging.config.fileConfig(args.logging_config)
    else:
        logging.basicConfig(level=logging.WARNING)
    if args.debug:
        logging.getLogger(__package__).setLevel(logging.DEBUG)

    if not args.backend:
        parser.error('Expected backend name')
    backend_type = backends[args.backend]

    service_types = [service for name, service in services.items()
                     if name not in args.skip_services]

    try:
        return asyncio.run(run(args, backend_type, service_types), debug=False)
    except KeyboardInterrupt:
        pass
Ejemplo n.º 28
0
def main() -> int:
    parser = ArgumentParser(description=__doc__)
    parser.add_argument('--version', action='version',
                        version='%(prog)s' + __version__)
    parser.add_argument('--outfile', metavar='PATH',
                        type=FileType('w'), default=sys.stdout,
                        help='the output file (default: stdout)')
    parser.add_argument('--socket', metavar='PATH', help='path to socket file')

    subparsers = parser.add_subparsers(dest='command',
                                       help='which admin command to run')
    commands = _load_entry_points('pymap.admin.client')
    for command_name, command_cls in commands.items():
        command_cls.add_subparser(command_name, subparsers)
    args = parser.parse_args()

    if not args.command:
        parser.error('Expected command name.')
    command = commands[args.command]

    return asyncio.run(run(parser, args, command), debug=False)
Ejemplo n.º 29
0
Archivo: client.py Proyecto: cylc/cylc
    def serial_request(self, command, args=None, timeout=None):
        """Send a request.

        For convenience use ``__call__`` to call this method.

        Args:
            command (str): The name of the endpoint to call.
            args (dict): Arguments to pass to the endpoint function.
            timeout (float): Override the default timeout (seconds).

        Raises:
            ClientTimeout: If a response takes longer than timeout to arrive.
            ClientError: Coverall for all other issues including failed auth.

        Returns:
            object: The data exactly as returned from the endpoint function,
                nothing more, nothing less.

        """
        return asyncio.run(
            self.async_request(command, args, timeout))
Ejemplo n.º 30
0
    def test_asyncio_task_decimal_context(self):
        async def fractions(t, precision, x, y):
            with decimal.localcontext() as ctx:
                ctx.prec = precision
                a = decimal.Decimal(x) / decimal.Decimal(y)
                await asyncio.sleep(t)
                b = decimal.Decimal(x) / decimal.Decimal(y ** 2)
                return a, b

        async def main():
            r1, r2 = await asyncio.gather(
                fractions(0.1, 3, 1, 3), fractions(0.2, 6, 1, 3))

            return r1, r2

        r1, r2 = asyncio.run(main())

        self.assertEqual(str(r1[0]), '0.333')
        self.assertEqual(str(r1[1]), '0.111')

        self.assertEqual(str(r2[0]), '0.333333')
        self.assertEqual(str(r2[1]), '0.111111')
Ejemplo n.º 31
0
class AsyncPiSysData:
    def __await__(self):
        return PiSystemData()

async def get_data():
    return AsyncPiSysData()

async def send(): # This should work for creating the async verison of the PiSystemData class.
    task1 = asyncio.create_task(get_data())
    task2 = asyncio.create_task(asyncio.sleep(0.01))
    await task1
    await task2

st = dt.datetime.now()
asyncio.run(send())
print(f"time: {dt.datetime.now() - st} seconds")

UNITS = {1: "B", 1024: "KB", 1024*1024: "MB", 1024*1024*1024: "GB", 1024*1024*1024*1024: "TB"}

@dataclass
class CpuData:
    logical: int = field(init=False)
    freq: Dict[str, float] = field(init=False, metadata={"unit": "MHz"})
    load: Dict[str, float] = field(init=False, metadata={"unit": "percent"})
    temp: float = field(init=False, metadata={"unit": "°C"})

    def __post_init__(self):
        self.logical = ps.cpu_count()
        cpu_freq = ps.cpu_freq(percpu=True)
        self.freq = {"current": cpu_freq[0].current, "min": cpu_freq[0].min, "max": cpu_freq[0].max}
 def run(self):
     asyncio.run(self._life_cycle())
    writer.write("cisco\n")
    await reader.readuntil("#")
    writer.write("terminal length 0\n")
    await reader.readuntil("#")
    sleep_sec = choice([4, 1, 5])
    print(f"Посплю {sleep_sec} секунд")
    await asyncio.sleep(sleep_sec)
    print(f'Отправляю команду {command} на {device["host"]}')
    writer.write(command + "\n")
    output = await reader.readuntil("#")
    ssh.close()
    print(f'Получили данные от {device["host"]}')
    return output


async def send_command_to_devices(devices, command):
    task_1 = asyncio.create_task(connect_ssh(devices[0], command))
    task_2 = asyncio.create_task(connect_ssh(devices[1], command))
    task_3 = asyncio.create_task(connect_ssh(devices[2], command))
    result1 = await task_1
    result2 = await task_2
    result3 = await task_3
    return [result1, result2, result3]


if __name__ == "__main__":
    with open("devices.yaml") as f:
        devices = yaml.safe_load(f)
    results = asyncio.run(send_command_to_devices(devices, "sh ip int br"))
    pprint(results, width=120)
Ejemplo n.º 34
0
def removetasks(loop: object) -> object:
    tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]

    for task in tasks:
        # skipping over shielded coro still does not help
        if task._coro.__name__ == "cant_stop_me":
            continue
        task.cancel()

    print("Cancelling outstanding tasks")
    #    await asyncio.gather(*tasks, return_exceptions=True)
    loop.stop()


async def shutdown_signal(signal, loop):
    print("Received exit signal {signal.name}...")
    await removetasks(loop)


available()
connect()
sleep(0.5)

Gamepad()
loop = asyncio.get_event_loop()
loop.run_until_complete(is_connected())
asyncio.run(read_gamepad_inputs())
loop.close()
#
Ejemplo n.º 35
0
def main():
    """
    main CLI entry point

    parses commands and jumps into the subprogram's entry point
    """
    cli = argparse.ArgumentParser()

    cli.add_argument(
        "-c",
        "--config-path",
        default="/etc/abrechnung/abrechnung.yaml",
        help="config file, default: %(default)s",
    )

    cli.add_argument("-d",
                     "--debug",
                     action="store_true",
                     help="enable asyncio debugging")
    cli.add_argument("-v",
                     "--verbose",
                     action="count",
                     default=0,
                     help="increase program verbosity")
    cli.add_argument("-q",
                     "--quiet",
                     action="count",
                     default=0,
                     help="decrease program verbosity")

    subparsers = cli.add_subparsers()

    def add_subcommand(name, subcommand_class):
        subparser = subparsers.add_parser(name)
        subparser.set_defaults(subcommand_class=subcommand_class)
        subcommand_class.argparse_register(subparser)

    # add all the subcommands here
    from . import mailer

    add_subcommand("mailer", mailer.Mailer)

    from . import http

    add_subcommand("api", http.HTTPService)

    from . import database

    add_subcommand("db", database.CLI)

    from . import admin

    add_subcommand("admin", admin.Admin)

    from . import demo

    add_subcommand("demo", demo.Demo)

    args = vars(cli.parse_args())

    # set up log level
    log_setup(args["verbose"] - args["quiet"])

    # enable asyncio debugging
    # loop = asyncio.get_event_loop()
    # loop.set_debug(args["debug"])

    config_path = args.pop("config_path")
    config = Config.from_file(Path(config_path))

    try:
        subcommand_class = args.pop("subcommand_class")
    except KeyError:
        cli.error("no subcommand was given")
    subcommand_class.argparse_validate(args, cli.error)
    subcommand_object = subcommand_class(config=config, **args)
    asyncio.run(subcommand_object.run())
Ejemplo n.º 36
0
    print(f"Requesting test XPX for {alice.address.address}")
    reply = requests.get(
        f"https://bctestnetfaucet.xpxsirius.io/api/faucet/GetXpx/{alice.address.address}"
    ).json()
    print(f"{reply}\n")

except:
    print("not available")

# Print their account credentials
print_account_info(alice)

name = "sharmelen"  #put any name you want

# Register namespace

tx = models.RegisterNamespaceTransaction.create_root_namespace(
    deadline=models.Deadline.create(),
    network_type=network_type,
    namespace_name=name,
    duration=10)

# Sign the transaction with Alice's account
signed_tx = tx.sign_with(account=alice, gen_hash=block_info.generation_hash)

# We run announce() as an asynchronous function because it uses Listener that comes
# only in async implementation
result = asyncio.run(announce(signed_tx))
print_account_mosaics(alice)
print("Namespace has been sucessfully registered")
Ejemplo n.º 37
0
 def run(self):
     try:
         self.result = asyncio.run(self.func(*self.args, **self.kwargs))
     except Exception as e:
         self.exception = e
Ejemplo n.º 38
0
def uasubscribe():
    asyncio.run(_uasubscribe())
Ejemplo n.º 39
0
def uaclient():
    asyncio.run(_uaclient())
Ejemplo n.º 40
0
def uawrite():
    asyncio.run(_uawrite())
Ejemplo n.º 41
0
def uals():
    asyncio.run(_uals())
Ejemplo n.º 42
0
def uaread():
    asyncio.run(_uaread())
Ejemplo n.º 43
0
    else:
        firstPos = R / total

    if G == 0:
        secondPos = 0
    else:
        secondPos = G / total

    return [firstPos, secondPos]


biglight = Bridge('192.168.86.26')
biglight.connect()
for l in biglight.lights:
    print(l.name)


async def Biglight(brightness, R, G, B):
    light_name = 'Deckenlicht'
    biglight.set_light(light_name, 'on', True)
    biglight.set_light(light_name, 'bri', brightness)
    biglight.set_light(light_name, 'xy', convertColor(R, G, B))


while (True):
    R = random.randint(0, 15)
    G = random.randint(0, 15)
    B = random.randint(0, 15)
    asyncio.run(Biglight(254, R, G, B))
    time.sleep(5)
Ejemplo n.º 44
0

class GBNServerProtocol(GBNProtocol):
    FilterError = int(c['server']['FilterError'])
    FilterLost = int(c['server']['FilterLost'])

    def connection_made(self, transport):
        self.transport = transport


async def main():
    print("Starting UDP server")

    # Get a reference to the event loop as we plan to use
    # low-level APIs.
    loop = asyncio.get_running_loop()

    # One protocol instance will be created to serve all
    # client requests.
    transport, _ = await loop.create_datagram_endpoint(
        lambda: GBNServerProtocol(loop, None, print_rx=True, print_tx=True),
        local_addr=('127.0.0.1', int(c['server']['UDPPort'])), remote_addr=('127.0.0.1', int(c['client']['UDPPort'])), allow_broadcast=True)

    try:
        await asyncio.sleep(3600)  # Serve for 1 hour.
    finally:
        transport.close()


asyncio.run(main())
Ejemplo n.º 45
0
def __main():
    asyncio.run(RecognizeAndRespond().run())
    pass
Ejemplo n.º 46
0
from Aviao_class import Aviao
import asyncio

aviao1 = Aviao('Boing777', 'PYTHON', 2020, 'TAM')
aviao2 = Aviao('TitanicAereo', 'NODE-JS', 2020, 'GOL')

asyncio.run(aviao1.decolar())
asyncio.run(aviao1.pousar())
asyncio.run(aviao2.decolar())
asyncio.run(aviao2.pousar())
Ejemplo n.º 47
0
        while True:
            await asyncio.sleep(1)

    except KeyboardInterrupt:
        pass

    finally:
        controller.stop_websocket()
        await controller.session.close()


if __name__ == "__main__":
    logging.basicConfig(format="%(message)s", level=logging.DEBUG)
    parser = argparse.ArgumentParser()
    parser.add_argument("host", type=str)
    parser.add_argument("username", type=str)
    parser.add_argument("password", type=str)
    parser.add_argument("-p", "--port", type=int, default=8443)
    parser.add_argument("-s", "--site", type=str, default="default")
    args = parser.parse_args()
    LOGGER.info("%s %s %s %s %s", args.host, args.username, args.password,
                args.port, args.site)
    asyncio.run(
        main(
            host=args.host,
            username=args.username,
            password=args.password,
            port=args.port,
            site=args.site,
        ))
Ejemplo n.º 48
0
                print(f"Client {address}: {item} from {manager.address}")
            except QUEUE.Empty:
                continue


async def main(count: int):
    init_queue_manager_server()
    term_ev: threading.Event = threading.Event()
    # pylint: disable=consider-using-with
    executor: concurrent.futures.ThreadPoolExecutor = (
        concurrent.futures.ThreadPoolExecutor()
    )

    i: int
    for i in range(count):
        asyncio.ensure_future(
            asyncio.get_running_loop().run_in_executor(executor, serve, i, term_ev)
        )

    # Gracefully shut down
    try:
        await asyncio.get_running_loop().create_future()
    except asyncio.CancelledError:
        term_ev.set()
        executor.shutdown()
        raise


if __name__ == "__main__":
    asyncio.run(main(int(sys.argv[1])))
Ejemplo n.º 49
0

def get_title(html, episode):
    print(f"{Fore.GREEN} getting title from episode {episode}")
    grabbing_page = soup(html, "html.parser")
    title = grabbing_page.find("h1")
    return "No title" if not title else title.text


async def main_coro():

    tasks = []

    for episode in range(100, 130):
        task = (episode, aio.create_task(get_page(episode)))
        tasks.append(task)

    for episode, task in tasks:
        html = await task
        title = get_title(html, episode)
        print(f"{title}\n")


if __name__ == '__main__':
    start = time.time()
    print(f"Started at {time.strftime('%X')}")
    aio.run(main_coro())
    print(
        f"Finished at {time.strftime('%X')}, overall time is {time.time() - start}"
    )
Ejemplo n.º 50
0
{Fore.CYAN}│ / ____/ / / / /_/ /  __/ /_/ / /_/ (__  ) │
{Fore.CYAN}│/_/   /_/ /_/\____/\___/_.___/\__,_/____/  │
{Fore.CYAN}│                                           │
{Fore.CYAN}└─────────────────────────────nina🪴#6666───┘'''
print(title)

def loadconfig():
    global bearer, refresh, headers
    config.read('config.ini')
    bearer = config['Account']['bearer']
    refresh = config['Account']['refresh_token']
    headers={"Content-type": "application/json", "Authorization": "Bearer " + bearer}

async def bearercheck(bearer, refresh, headers):
    async with aiohttp.ClientSession(headers=headers) as session:
        async with session.post("https://api.minecraftservices.com/minecraft/profile") as response:
            if response.status == 400:
                print(f'{Fore.GREEN}[Success] {response.status} {Fore.RESET}| Bearer is valid')
            else:
                async with session.post(f"https://api.gosnipe.tech/api/refresh?code={refresh}") as r:
                    res = r.json()
                    bearer = (await res)['access_token']
                    config.set('Account', 'bearer', bearer)
                    with open('config.ini', 'w') as cfg:
                        config.write(cfg)
                    print(f'{Fore.GREEN}[Success] {r.status} {Fore.RESET}| Updated bearer')

if __name__ == "__main__":
    loadconfig()
    results = asyncio.run(bearercheck(bearer, refresh, headers))
Ejemplo n.º 51
0
    if url.scheme == 'https':
        reader, writer = await asyncio.open_connection(
            url.hostname, 443, ssl=True)
    else:
        reader, writer = await asyncio.open_connection(
            url.hostname, 80)

    query = (
        f"HEAD {url.path or '/'} HTTP/1.0\r\n"
        f"Host: {url.hostname}\r\n"
        f"\r\n"
    )

    writer.write(query.encode('latin-1'))
    while True:
        line = await reader.readline()
        if not line:
            break

        line = line.decode('latin-1').rstrip()
        if line:
            print(f'HTTP header> {line}')

    # Ignore the body, close the socket
    writer.close()

# コメント: http://example.com/ で十分
url = sys.argv[1]

asyncio.run(print_http_headers(url))
Ejemplo n.º 52
0
def async_entry(message=None, server=None, port=None, N=1, queue=None, validate=False):
    """Start async execution in current process"""
    if queue:
        queue.put(asyncio.run(tcp_client(message, server=server, port=port, N=N, validate=validate)))
    else:
        asyncio.run(tcp_client(message, server=server, port=port, N=N, validate=validate))
Ejemplo n.º 53
0
# -*- coding:utf-8 -*-
# @author: Crepuscule_v
# @time  : 2021/1/22
# @file  : getYingXiaoHao.py

'''
给定关键词,自动生成一篇营销号文章
'''

import asyncio

async def getPassage(obj : str, event : str, anotherWay : str) -> str:
    passage = ""
    passage += f"{obj}{event}是怎么回事呢?"
    passage += f"{obj}相信大家都很熟悉, 但是{obj}{event}是怎么回事呢?下面小编就来带大家一起了解吧。"
    passage += f"{obj}{event}其实就是{anotherWay},大家可能会很惊讶,{event}怎么会是{anotherWay}呢? 但事实就是这样。"
    passage += f"这就是关于{obj}{event}的事情。大家有什么想法呢? 欢迎在评论区告诉小编一起讨论哦!"
    print(passage)
    return passage

# DEBUG
if __name__ == "__main__":
    asyncio.run(getPassage("xxx", "高数挂了", "高数不及格"))
Ejemplo n.º 54
0
from kasa import Discover
from kasa import SmartPlug
from os import path

device_name = 'light-1'


def setup_device_info():
    devices = asyncio.run(Discover.discover())
    for addr, dev in devices.items():
        asyncio.run(dev.update())
        if dev.alias == device_name:
            print("Found device")
            f = open("device-ip.txt", "a")
            f.write(addr)
            f.close()


async def get_device():
    f = open("device-ip.txt", "r")
    device = SmartPlug(f.read())
    await device.update()
    await device.turn_off()


if not path.exists("device-ip.txt"):
    print("Device IP not known, discovering devices now")
    setup_device_info()

asyncio.run(get_device())
Ejemplo n.º 55
0
# ANSI colors
c = (
    "\033[0m",
    "\033[36m",
    "\033[91m",
    "\033[35m",
)


async def makerandom(idx: int, threshold: int = 6) -> int:
    print(c[idx + 1] + f"Initiated makerandom({idx}.")
    i = random.randint(0, 10)
    while i <= threshold:
        print(c[idx + 1] + f"makerandom({idx} == {i} too low; retrying.")
        await asyncio.sleep(idx + 1)
        i = random.randint(0, 10)
        print(c[idx + 1] + f"---> Finished: makerandom({idx}) == {i}" + c[0])
        return i


async def main():
    res = await asyncio.gather(*(makerandom(i, 10 - i - 1) for i in range(3)))
    return res


if __name__ == "__main__":
    random.seed(444)
    r1, r2, r3 = asyncio.run(main())
    print()
    print(f"r1: {r1}, r2: {r2}, r3: {r3}")
Ejemplo n.º 56
0
"""
Services
----------------

An example showing how to fetch all services and print them.

Updated on 2019-03-25 by hbldh <*****@*****.**>

"""

import sys
import asyncio
import platform

from bleak import BleakClient

ADDRESS = ("24:71:89:cc:09:05" if platform.system() != "Darwin" else
           "B9EA5233-37EF-4DD6-87A8-2A875E821C46")


async def main(address: str):
    async with BleakClient(address) as client:
        svcs = await client.get_services()
        print("Services:")
        for service in svcs:
            print(service)


if __name__ == "__main__":
    asyncio.run(main(sys.argv[1] if len(sys.argv) == 2 else ADDRESS))
Ejemplo n.º 57
0
def main():
    asyncio.run(go())
    print("DONE")
Ejemplo n.º 58
0
                          'adjust': False
                      },
                      reload_quotes=True,
                      news_titles_source=news_titles_source,
                      verbose=True,
                      base_option='for_merge',
                      add_time_features=True,
                      nlp_treator=embedding_pool,
                      nlp_treator_signature=['sister'],
                      nlp_treator_config=config,
                      nlp_ductor='post',
                      export_chunk=100_000)
# base_option='without'

# data = await loader.read()
data = asyncio.run(loader.read())
"""
data = data.dropna()

d = './result.csv'
data.to_csv(d, sep=';', index=False)
"""
"""
# data.columns = [x.replace('_PCT1', '') for x in data.columns.values]
data.dropna().sort_values(by=['title', 'lag'])

d = './dataset_use_timed.csv'
data.dropna().sort_values(by=['title', 'lag']).to_csv(d, index=False)
"""
"""
g = 'E:/dataset_use_timed.csv'
Ejemplo n.º 59
0
    print('consume time :{}'.format((timeit.default_timer() - start)))


async def async_download(i):
    # async def는 해당 함수를 코루틴으로 만들어줍니다.
    # i: int 라는 부분은 type annotation입니다. 본 소스의 동작에는 일체의 영향을 주지 않습니다.
    async with aiohttp.ClientSession(
    ) as session:  # requests의 Session 클래스 같은 역할입니다.
        # 실제 요청을 비동기적으로 발생시킵니다.
        async with session.get(
                f'http://www.randomtext.me/api/lorem/p-1/32') as resp:
            # Python의 기본 open 함수는 비동기 입출력을 지원하지 않습니다. 그렇기에 외부 의존성을 씁니다.
            # 파일명 부분의 f'{i}.txt' 는 formatted string 구문입니다.
            async with aiofiles.open(f'{i}.txt', 'w') as f:
                await f.write(await resp.text())  # 결과를 text로 불러와서 파일에 저장합니다.


if __name__ == '__main__':
    # sync_download( 'sync' )

    makedir("async")
    os.chdir("async")
    start = timeit.default_timer()

    # 요청 2048개를 준비합니다.
    # 만든 당시에는 아직 아무것도 일어나지 않고, 아랫줄의 asyncio.wait에 의해 동시에 실행됩니다.
    tasks = [async_download(x) for x in range(128)]
    asyncio.run(asyncio.wait(tasks))
    print('consume time :{}'.format((timeit.default_timer() - start)))
Ejemplo n.º 60
0
目前无法实现的功能:

1、暂时无法对 Grid3D 设置 轴线和轴坐标的 style (非白色背景下有问题)
"""


async def get_json_data(url: str) -> dict:
    async with ClientSession(connector=TCPConnector(ssl=False)) as session:
        async with session.get(url=url) as response:
            return await response.json()


# 获取官方的数据
data = asyncio.run(
    get_json_data(
        url="https://echarts.baidu.com/examples/data/asset/data/nutrients.json"
    ))

# 列名映射
field_indices = {
    "calcium": 3,
    "calories": 12,
    "carbohydrate": 8,
    "fat": 10,
    "fiber": 5,
    "group": 1,
    "id": 16,
    "monounsat": 14,
    "name": 0,
    "polyunsat": 15,
    "potassium": 7,