def test_burgers_ei_results(): from pymordemos import burgers_ei app = Typer() app.command()(burgers_ei.main) args = list(map(str, [1, 2, 10, 100, 10, 30])) _test_demo(lambda: runner.invoke(app, args, catch_exceptions=False)) ei_results, greedy_results = burgers_ei.test_results ei_results['greedy_max_errs'] = greedy_results['max_errs'] check_results('test_burgers_ei_results', args, ei_results, (1e-13, 1e-7), 'errors', 'triangularity_errors', 'greedy_max_errs')
def test_demos(demo_args): module, args = demo_args module = import_module(module) if hasattr(module, 'app'): app = module.app else: app = Typer() app.command()(module.main) args = [str(arg) for arg in args] result = _test_demo( lambda: runner.invoke(app, args, catch_exceptions=False)) assert result.exit_code == 0
class TestHashCredentials(TestCase): def setUp(self) -> None: self.app = Typer() self.app.command()(hash_credentials) self.runner = CliRunner() def test_hash_credentials(self): result = self.runner.invoke(self.app) self.assertNotEqual(result.exit_code, 0) self.assertTrue("Error: Missing argument 'PASSWORD'." in result.stdout) result = self.runner.invoke(self.app, "test_password") self.assertEqual(result.exit_code, 0) # Hash is salted, therefore exact comparison is not possible self.assertTrue("$2b$12$" in result.stdout) self.assertEqual(60, len(result.stdout.strip()))
def test_thermalblock_results(thermalblock_args): from pymordemos import thermalblock app = Typer() app.command()(thermalblock.main) args = [str(arg) for arg in thermalblock_args[1]] _test_demo(lambda: runner.invoke(app, args, catch_exceptions=False)) results = thermalblock.test_results # due to the symmetry of the problem and the random test parameters, the estimated # error may change a lot # fenics varies more than others between MPI/serial first_tolerance = ( 1e-13, 3.5e-6) if '--fenics' in thermalblock_args[1] else (1e-13, 1e-7) check_results('test_thermalblock_results', thermalblock_args[1], results, first_tolerance, 'basis_sizes', 'norms', 'max_norms', (1e-13, 4.), 'errors', 'max_errors', 'rel_errors', 'max_rel_errors', 'error_estimates', 'max_error_estimates', 'effectivities', 'min_effectivities', 'max_effectivities', 'errors')
from enum import Enum from typing import Optional from typer import Typer, Context, Option, echo, Exit from pms import logger, __doc__, __version__ from pms.sensor import SensorReader from pms.sensor.cli import serial, csv from pms.service.cli import influxdb, mqtt, bridge main = Typer(help=__doc__) main.command()(serial) main.command()(csv) main.command()(influxdb) main.command()(mqtt) main.command()(bridge) class Supported(str, Enum): PMSx003 = "PMSx003" PMS3003 = "PMS3003" PMS5003S = "PMS5003S" PMS5003ST = "PMS5003ST" PMS5003T = "PMS5003T" SDS01x = "SDS01x" SDS198 = "SDS198" HPMA115S0 = "HPMA115S0" HPMA115C0 = "HPMA115C0" SPS30 = "SPS30" MCU680 = "MCU680"
def _helper(command_name: str, command_function: Callable): main_app = Typer() main_app.callback()(_main_callback) main_app.command(name=command_name)(command_function) return main_app
def add_legacy_compatible_commands(app: typer.Typer): """ Add commands from the restructured CLI under the previous names for the commands to the root ``typer`` app. """ # Applications app.command( name="list-applications", help="LIST the available applications", )(list_applications) app.command( name="get-application", help="GET an Application.", )(get_application) app.command( name="create-application", help="CREATE an Application.", )(create_application) app.command( name="delete-application", help="DELETE an Application.", )(delete_application) app.command( name="update-application", help="UPDATE an Application.", )(update_application) # Job Scripts app.command( name="list-job-scripts", help="LIST job scripts", )(list_job_scripts) app.command( name="get-job-script", help="GET a job script", )(get_job_script) app.command( name="create-job-script", help="CREATE a job script", )(create_job_script) app.command( name="update-job-script", help="UPDATE a job script", )(update_job_script) app.command( name="delete-job-script", help="DELETE a job script", )(delete_job_script) # Job Submissions app.command( name="list-job-submissions", help="LIST job submissions", )(list_job_submissions) app.command( name="get-job-submission", help="GET a job submission", )(get_job_submission) app.command( name="create-job-submission", help="CREATE a job submission", )(create_job_submission) app.command( name="delete-job-submission", help="DELETE a job submission", )(delete_job_submission)
) # Log the beginning of the experiment logger.info(f"Running experiment {experiment_name}") # Catch possible keyyboard interrupt try: logger.info(f"Launching experiment {experiment_name}") # Launch the experiment experiment.launch() logger.debug(f"Successful ending for experiment {experiment_name}") # Save the experiment experiment.end() logger.debug(f"Cleaning data for experiment {experiment_name}") # Clean up the experiment experiment.clean() logger.debug(f"Experiment {experiment_name} was run successfully.") except KeyboardInterrupt: logger.info(f"Stopping experiment {experiment_name} through keyboard" "interrupt.") experiment.stop() except Exception as e: logger.critical("Encountered exception while launching experiment" f"{experiment_name}: {e}") experiment.fail() cli.command()(run) if __name__ == "__main__": cli()
from os import path from typer import Context, Typer from kolombo import conf from kolombo.console import error from kolombo.dkim import dkim_cli from kolombo.domain import domain_cli from kolombo.init import init from kolombo.run import run_cli from kolombo.stop import stop_cli from kolombo.user import user_cli kolombo_cli = Typer(name="kolombo", add_completion=True) kolombo_cli.command("init")(init) kolombo_cli.add_typer(domain_cli, name="domain") kolombo_cli.add_typer(dkim_cli, name="dkim") kolombo_cli.add_typer(user_cli, name="user") kolombo_cli.add_typer(run_cli, name="run") kolombo_cli.add_typer(stop_cli, name="stop") @kolombo_cli.callback() def main(ctx: Context) -> None: if ctx.invoked_subcommand == "init": return if not path.exists("/etc/kolombo/kolombo.conf"): error("Kolombo is not initialized! Run [code]kolombo init[/] first") exit(1)
from typer import Argument, Context, Exit, Option, Typer, echo from pms import logger from pms.core import MessageReader, SensorReader, Supported main = Typer( help= "Data acquisition and logging for Air Quality Sensors with UART interface") """ Extra cli commands from plugins additional Typer commands are loaded from plugins (entry points) advertized as `"pypms.extras"` """ for ep in metadata.entry_points(group="pypms.extras"): main.command(name=ep.name)(ep.load()) logging.basicConfig(level=os.getenv("LEVEL", "WARNING")) def version_callback(value: bool): # pragma: no cover if not value: return package = "PyPMS" echo(f"{package} version {metadata.version(package)}") raise Exit() @main.callback() def callback(
import os import signal from pyprocs import main from typer import Typer from typer.testing import CliRunner app = Typer() app.command()(main) runner = CliRunner() def handler(signo, frame): os.kill(os.getpid(), signal.SIGINT) def test_main(): signal.signal(signal.SIGALRM, handler) signal.alarm(2) runner.invoke(app, ["-s", "tests/app.py"]) def test_timeout(): signal.signal(signal.SIGALRM, handler) signal.alarm(2) runner.invoke(app, ["-s", "--graceful-timeout", "2", "tests/timeout_app.py"]) def test_bad():
__version__ = "0.9.1" from typer import Typer from pyrepositoryminer.commands import analyze, branch, clone, commits app = Typer(help="Efficient Repository Mining in Python.") app.command()(analyze) app.command()(branch) app.command()(clone) app.command()(commits) __all__ = ("app", )
class TestGenerateToken(TestCase): mock_config_patcher = None mock_cobald_config_loader_patcher = None @classmethod def setUpClass(cls) -> None: cls.mock_config_patcher = patch("tardis.rest.app.security.Configuration") cls.mock_config = cls.mock_config_patcher.start() cls.mock_cobald_config_loader_patcher = patch( "tardis.rest.token_generator.generate_token.load" ) cls.mock_cobald_config_loader = cls.mock_cobald_config_loader_patcher.start() @classmethod def tearDownClass(cls) -> None: cls.mock_config_patcher.stop() cls.mock_cobald_config_loader_patcher.stop() def setUp(self) -> None: self.app = Typer() self.app.command()(generate_token) self.runner = CliRunner() config = self.mock_config.return_value config.Services.restapi.secret_key = ( "752e003f636f402cc23728e185ce8c9eef27b7e02cf509b3015f7757e625b8e4" ) config.Services.restapi.algorithm = "HS256" @staticmethod def clear_lru_cache(): get_algorithm.cache_clear() get_secret_key.cache_clear() def test_generate_token(self): result = self.runner.invoke(self.app) self.assertNotEqual(result.exit_code, 0) self.assertTrue("Missing option '--user-name'" in result.stdout) result = self.runner.invoke(self.app, ["--user-name=test"]) self.assertEqual(result.exit_code, 1) self.assertTrue( "Either a config-file or a secret-key and algorithm needs to be specified!" in result.stdout ) expected_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ0ZXN0Iiwic2NvcGVzIjpbInJlc291cmNlczpnZXQiXX0.JtjroDVX2FlHI-DFO3XErRutDjvcZwbZF4Bqx736JTc" # noqa: B950 result = self.runner.invoke( self.app, [ "--user-name=test", "--algorithm=HS256", "--secret-key=752e003f636f402cc23728e185ce8c9eef27b7e02cf509b3015f7757e625b8e4", # noqa: B950 ], ) self.assertEqual(result.exit_code, 0) self.assertEqual(result.stdout.strip(), expected_token) self.clear_lru_cache() result = self.runner.invoke( self.app, ["--user-name=test", "--config-file=test.yml"] ) self.mock_cobald_config_loader.assert_called_once_with("test.yml") self.assertEqual(result.exit_code, 0) self.assertEqual(result.stdout.strip(), expected_token)