def load(): """ Load ``cron`` modules for applications listed in ``INSTALLED_APPS``. """ paths = ['%s.cron' % PROJECT_MODULE.__name__] if '.' in PROJECT_MODULE.__name__: paths.append('%s.cron' % '.'.join( PROJECT_MODULE.__name__.split('.')[0:-1])) for application in settings.INSTALLED_APPS: paths.append('%s.cron' % application) # load kronostasks for p in paths: try: import_module(p) except ImportError as e: if 'No module named' not in str(e): print(e) # load django tasks for cmd, app in get_commands().items(): try: load_command_class(app, cmd) except django.core.exceptions.ImproperlyConfigured: pass
def load(): """ Load ``cron`` modules for applications listed in ``INSTALLED_APPS``. """ paths = ['%s.cron' % PROJECT_MODULE.__name__] if '.' in PROJECT_MODULE.__name__: paths.append('%s.cron' % '.'.join(PROJECT_MODULE.__name__.split('.')[0:-1])) for application in settings.INSTALLED_APPS: paths.append('%s.cron' % application) # load kronostasks for p in paths: try: import_module(p) except ImportError as e: if 'No module named' not in str(e): print(e) # load django tasks for cmd, app in get_commands().items(): try: load_command_class(app, cmd) except django.core.exceptions.ImproperlyConfigured: pass
def test_load_commands(self): """Try to load every management command to catch exceptions.""" try: for command in self.commands: load_command_class('django_extensions', command) except Exception as e: self.fail("Can't load command class of {0}\n{1}".format(command, e))
def test_load_commands(self): try: management_dir = os.path.join('django_extensions', 'management') commands = find_commands(management_dir) for command in commands: load_command_class('django_extensions', command) except Exception as e: self.fail("Can't load command class of {0}\n{1}".format(command, e))
def setUp(self): self.original_cursor_wrapper = db_backends_util.CursorDebugWrapper # Since debugsqlshell monkey-patches django.db.backends.utils, we can # test it simply by loading it, without executing it. But we have to # undo the monkey-patch on exit. command_name = 'debugsqlshell' app_name = management.get_commands()[command_name] management.load_command_class(app_name, command_name)
def test_load_commands(self): try: management_dir = os.path.join('django_extensions', 'management') commands = find_commands(management_dir) for command in commands: load_command_class('django_extensions', command) except Exception as e: self.fail("Can't load command class of {0}\n{1}".format( command, e))
def handle(self, *args, **options): cmds = [(app, cmd, load_command_class(app, cmd).help) for cmd, app in get_commands().items() if not app.startswith('django') and not hasattr(load_command_class(app, cmd), 'ScheduledJob')] for app, g in groupby(sorted(cmds, key=lambda r: r[0]), lambda r: r[0]): self.stdout.write("* {}".format(app)) found = False for x, c, h in g: self.stdout.write(" {} -- {}".format(c, h)) found = True if found: self.stdout.write("")
def locate_command(name): """ Apps may override Django commands, what we want to do is subclass whichever one had precedence before the gcloudc.commands app and subclass that """ try: index = settings.INSTALLED_APPS.index("gcloudc.commands") except ValueError: raise ImproperlyConfigured( "Unable to locate gcloudc.commands in INSTALLED_APPS") APPS_TO_CHECK = list(settings.INSTALLED_APPS) + ["django.core"] for i in range(index + 1, len(APPS_TO_CHECK)): app_label = APPS_TO_CHECK[i] try: command = load_command_class(app_label, name) except ModuleNotFoundError: continue if command: return command.__class__ else: raise ImportError("Unable to locate a base %s Command to subclass" % name)
def run_with_argv_raw(self, argv_raw): try: argv = [self.app_name, self.command_name] + shlex.split(argv_raw) command_class = load_command_class(self.app_name, self.command_name) command_class.run_from_argv(argv) except SystemExit: pass
def get_apps_with_commands(self): apps = [] for app_name in self.get_app_names(): management_module = self.find_management_module(app_name) commands = [] if management_module: command_names = find_commands(management_module) for command_name in command_names: command = {'command_name': command_name} try: command_class = load_command_class(app_name, command_name) available_options = self.get_available_options(command_class) command.update({ 'success': True, 'message': command_class.help, 'available_options': available_options }) except Exception, e: command.update({ 'success': False, 'message': force_str(e) }) commands.append(command) if commands: apps.append({'app_name': app_name, 'commands': commands})
def handle(self, *args, **options): # The tools which don't use other tools are loaded first. # keys are the command name, values are the command objects primary_tools = dict() secondary_tools = dict() apps_to_run_admin_commands = ['biotools'] for app_config in list(apps.get_app_configs()): if app_config.name in apps_to_run_admin_commands: path = os.path.join(app_config.path, 'management') command_names = find_commands(path) for command_name in command_names: if command_name == 'load_all_biotools': continue command = load_command_class(app_config.name, command_name) if hasattr(command, 'uses_other_biotools') and command.uses_other_biotools is True: secondary_tools[command_name] = command else: primary_tools[command_name] = command # load the primary tools for name in primary_tools: command = primary_tools[name] self.stdout.write("INFO: {0} - {1}\n".format(name, command.help)) command.handle() # load the secondary tools for name in secondary_tools: command = secondary_tools[name] self.stdout.write("INFO: {0} - {1}\n".format(name, command.help)) command.handle()
def fetch_command(subcommand: str) -> BaseCommand: """ Tries to fetch the given subcommand, printing a message with the appropriate command called from the command line (usually "django-admin" or "manage.py") if it can't be found. override a few django commands in the case where settings not loaded. hard to test this because we need to simulate settings not being configured """ if subcommand in ['startapp', 'startproject', 'unzip', 'zip']: command_module = import_module( 'otree.management.commands.{}'.format(subcommand)) return command_module.Command() commands = get_commands() try: app_name = commands[subcommand] except KeyError: sys.stderr.write( "Unknown command: %r\nType 'otree help' for usage.\n" % subcommand) sys.exit(1) if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, subcommand) return klass
def send_reminder(self, request, sdo=None): opts = self.model._meta app_label = opts.app_label output = None sdo_pk = sdo and sdo.pk or None if request.method == 'POST' and request.POST.get('send', False): command = load_command_class('ietf.liaisons', 'remind_update_sdo_list') output = command.handle(return_output=True, sdo_pk=sdo_pk) output = '\n'.join(output) context = { 'opts': opts, 'has_change_permission': self.has_change_permission(request), 'app_label': app_label, 'output': output, 'sdo': sdo, } return render_to_response( 'admin/group/group/send_sdo_reminder.html', context, context_instance=template.RequestContext( request, current_app=self.admin_site.name), )
def __new__(cls, *args, **kwargs): """ Sets option_list and help dynamically. """ obj = super(BaseTenantCommand, cls).__new__(cls, *args, **kwargs) app_name = get_commands()[obj.COMMAND_NAME] if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. cmdclass = app_name else: cmdclass = load_command_class(app_name, obj.COMMAND_NAME) # inherit the options from the original command obj.option_list = cmdclass.option_list obj.option_list += (make_option("-s", "--schema", dest="schema_name"), ) obj.option_list += (make_option("-p", "--skip-public", dest="skip_public", action="store_true", default=False), ) # prepend the command's original help with the info about schemata iteration obj.help = "Calls %s for all registered schemata. You can use regular %s options. "\ "Original help for %s: %s" % (obj.COMMAND_NAME, obj.COMMAND_NAME, obj.COMMAND_NAME, getattr(cmdclass, 'help', 'none')) return obj
def get_command_class(name): app_name = get_commands()[name] if isinstance(app_name, BaseCommand): instance = app_name else: instance = load_command_class(app_name, name) return type(instance)
def run_from_argv(self, argv): """ Changes the option_list to use the options from the wrapped command. Adds schema parameter to specify which schema will be used when executing the wrapped command. """ # load the command object. try: app_name = get_commands()[argv[2]] except KeyError: raise CommandError("Unknown command: {}".format(argv[2])) if isinstance(app_name, BaseCommand): # if the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, argv[2]) # Ugly, but works. Delete tenant_command from the argv, parse the schema manually # and forward the rest of the arguments to the actual command being wrapped. del argv[1] schema_parser = argparse.ArgumentParser() schema_parser.add_argument("-s", "--schema", dest="schema_name", help="specify tenant schema") schema_namespace, args = schema_parser.parse_known_args(argv) tenant = self.get_tenant_from_options_or_interactive(schema_name=schema_namespace.schema_name) connection.set_tenant(tenant) klass.run_from_argv(args)
def command_details(request, app_name, command_name): command = load_command_class(app_name, command_name) template = loader.get_template('djangoappengine_rdbms/command_details.html') # stdout = StringIO.StringIO() stderr = StringIO.StringIO() @redirect_stderr_stdout(stdout=stdout,stderr=stderr) def _execute_command(command, command_name, stdout, stderr, argv): parser = command.create_parser("manage.py", command_name) options, argss = parser.parse_args(argv.split()) handle_default_options(options) options.__dict__["stdout"] = stdout options.__dict__["stderr"] = stderr options.__dict__['interactive'] = False #import debugger; debugger.pdb().set_trace() try: return command.execute(*argss, **options.__dict__) except SystemExit, e: pass except Exception, e: stderr.write(e)
def fetch_command(command_name): try: app_name = get_available_commands()[command_name] except KeyError: return None klass = load_command_class(app_name, command_name) return klass
def fetch_command(self, subcommand): commands = get_commands() try: app_name = commands[subcommand] except KeyError: if os.environ.get('DJANGO_SETTINGS_MODULE'): # If `subcommand` is missing due to misconfigured settings, the # following line will retrigger an ImproperlyConfigured exception # (get_commands() swallows the original one) so the user is # informed about it. settings.INSTALLED_APPS else: sys.stderr.write("No Django settings specified.\n") possible_matches = get_close_matches(subcommand, commands) sys.stderr.write('Unknown command: %r' % subcommand) if possible_matches: sys.stderr.write('. Did you mean %s?' % possible_matches[0]) sys.stderr.write("\nType '%s help' for usage.\n" % self.prog_name) sys.exit(1) if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, subcommand) return klass
def run_from_argv(self, argv): """ Changes the option_list to use the options from the wrapped command. Adds schema parameter to specify which schema will be used when executing the wrapped command. """ # load the command object. if len(argv) <= 2: return try: app_name = get_commands()[argv[2]] except KeyError: raise CommandError("Unknown command: %r" % argv[2]) if isinstance(app_name, BaseCommand): # if the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, argv[2]) # Ugly, but works. Delete tenant_command from the argv, parse the schema manually # and forward the rest of the arguments to the actual command being wrapped. del argv[1] schema_parser = argparse.ArgumentParser() schema_parser.add_argument("-s", "--schema", dest="schema_name", help="specify tenant schema") schema_namespace, args = schema_parser.parse_known_args(argv) tenant = self.get_tenant_from_options_or_interactive(schema_name=schema_namespace.schema_name) connection.set_tenant(tenant) klass.run_from_argv(args)
def fetch_command(subcommand: str) -> BaseCommand: """ Tries to fetch the given subcommand, printing a message with the appropriate command called from the command line (usually "django-admin" or "manage.py") if it can't be found. override a few django commands in the case where settings not loaded. hard to test this because we need to simulate settings not being configured """ if subcommand in ['startapp', 'startproject']: command_module = import_module( 'otree.management.commands.{}'.format(subcommand)) return command_module.Command() commands = get_commands() try: app_name = commands[subcommand] except KeyError: sys.stderr.write( "Unknown command: %r\nType 'otree help' for usage.\n" % subcommand ) sys.exit(1) if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, subcommand) return klass
def run_from_argv(self, argv): """ Changes the option_list to use the options from the wrapped command. """ # load the command object. if len(argv) <= 2: return try: app_name = get_commands()[argv[2]] except KeyError: raise CommandError("Unknown command: %r" % argv[2]) if isinstance(app_name, BaseCommand): # if the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, argv[2]) # Ugly, but works. Delete tenant_command from the argv, parse the schema manually # and forward the rest of the arguments to the actual command being wrapped. del argv[1] schema_parser = argparse.ArgumentParser() schema_namespace, args = schema_parser.parse_known_args(argv) print(args) tenant_model = get_tenant_model() tenants = tenant_model.objects.all() for tenant in tenants: self.stdout.write("Applying command to: %s" % tenant.schema_name) connection.set_tenant(tenant) klass.run_from_argv(args)
def test_run(self) : command = load_command_class('biotools', 'load_geneid__1_4') command.handle() biotools_settings = configparser.ConfigParser() biotools_settings.read( os.path.join( os.path.abspath(os.path.dirname(__file__)), '../settings.ini') ) genome_file = LocalFile( label = 'C. cerevisiae S288C genome', \ path = "{0}/Saccharomyces_cerevisiae_S288C/Saccharomyces_cerevisiae_S288C.genomic.fna".format(settings.EMERGENCE_EXAMPLE_DATA_ROOT) ) genome_file.save() geneid = StandaloneTool.objects.get( name='geneid', version='1.4' ) flow = geneid.new_flow() flow.save() command = flow.get_command(name='Run geneid') command.set_param(name='<sequence_filename>', val=genome_file.path) command.stdout = '/tmp/geneid.test.out' geneid_settings = biotools_settings[ "geneid 1.4" ] command.set_param(name='-P', val=geneid_settings['test_param_file'] ) flow.run() while flow.is_executing(): flow = Flow.objects.get(id=flow.id) print("Gene prediction state is: {0}".format(flow.get_state_display()) ) sleep(1) self.assertEqual(format(flow.get_state_display()) , 'complete')
def __new__(cls, *args, **kwargs): """ Sets option_list and help dynamically. """ # instantiate obj = super(BaseTenantCommand, cls).__new__(cls, *args, **kwargs) app_name = get_commands()[obj.COMMAND_NAME] if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. cmdclass = app_name else: cmdclass = load_command_class(app_name, obj.COMMAND_NAME) # inherit the options from the original command obj.option_list = cmdclass.option_list #print obj.option_list obj.option_list += ( make_option("-s", "--schema", dest="schema_name"), ) obj.option_list += ( make_option("-p", "--skip-public", dest="skip_public", action="store_true", default=False), ) # prepend the command's original help with the info about schemata iteration obj.help = "Calls %s for all registered schemata. You can use regular %s options. "\ "Original help for %s: %s"\ % (obj.COMMAND_NAME, obj.COMMAND_NAME, obj.COMMAND_NAME,\ getattr(cmdclass, 'help', 'none')) return obj
def _dj_call_command(command_name, *args, **options): try: command = load_command_class('django.core', command_name) except ImportError: return None parser = command.create_parser('', command_name) # Use the `dest` option name from the parser option if hasattr(parser, '_actions'): opt_mapping = { min(s_opt.option_strings).lstrip('-').replace('-', '_'): s_opt.dest for s_opt in parser._actions if s_opt.option_strings } else: opt_mapping = {} arg_options = { opt_mapping.get(key, key): value for key, value in options.items() } defaults = parser.parse_args(args=[force_text(a) for a in args]) if hasattr(defaults, '_get_kwargs'): defaults = dict(defaults._get_kwargs(), **arg_options) else: defaults = dict(**arg_options) # Move positional args out of options to mimic legacy optparse args = defaults.pop('args', ()) if 'skip_checks' not in options: defaults['skip_checks'] = True return command.execute(*args, **defaults)
def test_run(self) : # Load dependent tools. This is only needed because Django creates a new database for each test for tool_name in ( 'load_nucmer__3_23', 'load_show_coords__3_23', 'load_nucmer_genome_coverage__1_0' ): command = load_command_class('emergence.apps.biotools', tool_name) command.handle() print("INFO: Loading E. coli K12") k12_genome_file = LocalFile( label = 'E. coli K12 DH10B genome', \ path = "{0}/Escherichia_coli_K12_DH10B/e_coli_k12_dh10b.fna".format(settings.EMERGENCE_EXAMPLE_DATA_ROOT) ) k12_genome_file.save() print("INFO: Loading E. coli O157 H7") o157_genome_file = LocalFile( label = 'E. coli K12 DH10B genome', \ path = "{0}/Escherichia_coli_O157_H7_1044/NZ_AERP00000000.scaffolds.fna".format(settings.EMERGENCE_EXAMPLE_DATA_ROOT) ) o157_genome_file.save() genome_cov = StandaloneTool.objects.get( name='NUCmer genome coverage', version='1.0' ) ## this results in a built Flow flow = genome_cov.new_flow() flow.save() print("DEBUG: Flow that was just built:") for thing in flow.get_children(): print("step: {0}".format(thing)) nucmer_command = flow.get_command(name='Run NUCmer') print("DEBUG: TESTING: Within the test, flow.get_command() for nucmer returned this exec string: {0}".format(nucmer_command.exec_string)) nucmer_command.set_param(name='<reference_in>', val=k12_genome_file.path) nucmer_command.set_param(name='<query_in>', val=o157_genome_file.path) #sc_command = flow.get_command(name='Run show-coords') # THIS NEEDS TO BE SET TO THE CWD/out.delta but we don't know the CWD at build time. Issue. #sc_command.set_param(name='<deltafile>', val=nuc ) flow.run()
def test_run(self) : command = load_command_class('biotools', 'load_prodigal__2_60') command.handle() genome_file = LocalFile( label = 'E. coli K12 DH10B genome', \ path = "{0}/Escherichia_coli_K12_DH10B/e_coli_k12_dh10b.fna".format(settings.EMERGENCE_EXAMPLE_DATA_ROOT) ) genome_file.save() prodigal = StandaloneTool.objects.get( name='Prodigal', version='2.60' ) flow = prodigal.new_flow() flow.save() command = flow.get_command(name='Run prodigal') command.set_param(name='-i', val=genome_file.path) command.set_param(name='-o', val='/tmp/prodigal.test.out' ) command.set_param(name='-g', val='10' ) flow.run() while flow.is_executing(): flow = Flow.objects.get(id=flow.id) print("Gene prediction state is: {0}".format(flow.get_state_display()) ) sleep(1) self.assertEqual(format(flow.get_state_display()) , 'complete')
def management_view(self, request, *args, **kwargs): class DummyParser: def __init__(self, cmd): if cmd is None: return self.arguments = [] cmd.add_arguments(self) def add_argument(self, name, nargs='*', type=str, help='', # pylint:disable=redefined-builtin action=None, default=None, metavar=None, dest=None, choices=None, add_mutually_exclusive_group=None): self.arguments.append( {'name': name, 'nargs': nargs, 'type': type.__name__, 'help': help }) def get_arguments(self): return self.arguments raw_commands = get_commands() commands = [] modules = [] for key in raw_commands.keys(): if raw_commands[key] not in self.ignore_modules: module = raw_commands[key] name = key command = load_command_class(module, name) parser = DummyParser(command) if module not in modules: modules.append(module) if name not in self.ignore_commands: commands.append({ 'module': module, 'command': name, 'help': command.help, 'arguments': parser.get_arguments(), 'css_order': len(commands) % 2 + 1 }) context = {'test': 'test', 'opts': self.Meta, 'change': False, 'is_popup': False, 'save_as': False, 'has_delete_permission': False, 'has_add_permission': False, 'has_change_permission': False, 'commands': commands, 'modules': modules, 'results': kwargs.get('results', None), 'errors': kwargs.get('errors', None) } return TemplateResponse(request, template="admin/management_admin.html", context=context)
def __init__(self, *args, **kwargs): super(CommandExecutionForm, self).__init__(*args, **kwargs) self.command_dict = get_commands() self.allowed_commands = [] apps = {} for command_name, app_name in self.command_dict.iteritems(): if self.command_allowed(command_name, app_name): self.allowed_commands.append(command_name) command_class = load_command_class(app_name, command_name) # creating an optionparser optparser = command_class.create_parser( './manage.py', command_name) # get the docstring from the parser docstring = '' if optparser.usage is not None: docstring = optparser.usage.replace('%prog', './manage.py') # get the options options = [] Option = namedtuple('Option', ['opt_string', 'help']) for opt in getattr(optparser, 'option_list', []): if opt.dest is not None: dest = opt.dest.upper() else: dest = '' opt_string = ','.join(opt._long_opts) if dest: opt_string += '={0}'.format(dest) if opt._short_opts: opt_string = '{0} {1}, '.format( ','.join(opt._short_opts), dest) + opt_string options.append(Option(opt_string, opt.help)) Command = namedtuple('Command', ['command', 'docstring', 'options', 'log']) if command_class.__doc__ is not None: # in case there's a docstring on the class, prepend it to # make sure all description is included. docstring = command_class.__doc__ + '\n\n' + docstring log = None if app_settings.LOGFILE_PATH is not None: file_name = os.path.join( app_settings.LOGFILE_PATH, 'command_interface_log-{0}.log'.format(command_name)) try: with open(file_name, 'r') as f: log = f.read() except IOError: pass command = Command(command_name, docstring, options, log) App = namedtuple(app_name.replace('.', '_'), ['app_name', 'commands']) if not app_name in apps: apps[app_name] = App(app_name, [command]) else: apps[app_name].commands.append(command) self.apps = apps.values()
def test_help_message_contains_the_time(self): ''' Test that when you run the help command on the command inactiveuser - That you get the minutes that were set for that command. ''' command_class = management.load_command_class('front', 'changeemail') self.assertIn( 'after {} minutes'.format( settings.CHANGE_EMAIL_EXPIRY_MINUTES_TIME), command_class.help)
def get_command(name): # this is a copy pasted from django.core.management.call_command app_name = get_commands()[name] if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, name) return klass
def handle_post_migrate(sender, **kwargs): ScheduledJob = sender.get_model('ScheduledJob') with transaction.atomic(): # Check that our own app has actually been migrated. If it has not, just don't # do anything -- it might be part of an initial migration of just some apps. curs = connection.cursor() curs.execute("SELECT id FROM django_migrations WHERE app='scheduler'") if curs.rowcount == 0: print("Job scheduler not yet installed, not triggering migration") return jobs = [] for name, app in get_commands().items(): if app.startswith('django'): continue cmd = load_command_class(app, name) if hasattr(cmd, 'ScheduledJob'): job, created = ScheduledJob.objects.get_or_create(app=app, command=name) dirty = False def _update_field(jobfield, cmdfield, obj=cmd.ScheduledJob, default=None): if getattr(job, jobfield) != getattr( obj, cmdfield, default): setattr(job, jobfield, getattr(obj, cmdfield, default)) return True return False dirty += _update_field('description', 'help', obj=cmd) dirty += _update_field('scheduled_interval', 'scheduled_interval') dirty += _update_field('scheduled_times', 'scheduled_times') if dirty: job.full_clean() if created: if getattr(cmd.ScheduledJob, 'default_notify_on_success', None): job.notifyonsuccess = True reschedule_job(job, save=False) job.save() if created: print("Created scheduled job for {}".format( job.description)) else: print("Updated scheduled job for {}".format( job.description)) jobs.append(job.pk) for dj in ScheduledJob.objects.exclude(pk__in=jobs): print("Deleted scheduled job for {}".format(dj.description)) dj.delete()
def test_loads_all_regiond_commands(self): parser = ArgumentParser() cli.register_cli_commands(parser) for name, app, help_text in cli.regiond_commands: subparser = parser.subparsers.choices.get(name) klass = management.load_command_class(app, name) if help_text is None: help_text = klass.help self.assertIsNotNone(subparser) self.assertEqual(help_text, subparser.description)
def index(request): all_cmds = management.get_commands() cmds = [] for cmd, app in all_cmds.items(): if app == 'data': cmd_class = management.load_command_class("data", cmd) cmd_class.name = cmd cmds.append(cmd_class) return render(request, 'data/index.html', {"cmds": cmds})
def can_ping(fqdn, count=4, timeout=5): ping_cls = load_command_class('relops_hardware_controller.api', 'ping') try: call_command(ping_cls, fqdn, 'ping', '-c', count, '-w', timeout) logger.debug('pinging %s succeeded', fqdn) return True except Exception as error: logger.warn('pinging %s failed: %s', fqdn, error) return False
def get_command_by_name(command_name: str) -> BaseCommand: """ Gets Django management BaseCommand derived command class instance by name. """ all_commands = get_commands() app_name = all_commands.get(command_name) if app_name is None: raise Exception(f"Django management command {command_name} not found") command = app_name if isinstance(app_name, BaseCommand) else load_command_class(app_name, command_name) assert isinstance(command, BaseCommand) return command
def _get_command_class(self, name): try: app_name = get_commands()[name] if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, name) except KeyError: raise CommandError("Unknown command: %r" % name) return klass
def get_management_command_details(command_name): """ Get the help output of the management command. """ app_name = get_management_commands_apps()[command_name] command_class = load_command_class(app_name, command_name) parser = command_class.create_parser("", command_name) with io.StringIO() as output: parser.print_help(output) cmd_help_output = output.getvalue() return cmd_help_output
def call_command(name, *args, **options): """ Calls the given command, with the given options and args/kwargs. This is the primary API you should use for calling specific commands. Some examples: call_command('migrate') call_command('shell', plain=True) call_command('sqlmigrate', 'myapp') Copy of the function from django.core.management. In addition to the standard functionality, stores the raw args on the command instance. """ # Load the command object. try: app_name = get_commands()[name] except KeyError: raise CommandError("Unknown command: %r" % name) if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. command = app_name else: command = load_command_class(app_name, name) # Store the raw args on the command so they can be used later if needed command.raw_args = args # Simulate argument parsing to get the option defaults (see #10080 for details). parser = command.create_parser('', name) if command.use_argparse: # Use the `dest` option name from the parser option opt_mapping = { sorted(s_opt.option_strings)[0].lstrip('-').replace('-', '_'): s_opt.dest for s_opt in parser._actions if s_opt.option_strings } arg_options = { opt_mapping.get(key, key): value for key, value in options.items() } defaults = parser.parse_args(args=args) defaults = dict(defaults._get_kwargs(), **arg_options) # Move positional args out of options to mimic legacy optparse args = defaults.pop('args', ()) else: # Legacy optparse method defaults, _ = parser.parse_args(args=[]) defaults = dict(defaults.__dict__, **options) if 'skip_checks' not in options: defaults['skip_checks'] = True return command.execute(*args, **defaults)
def load(): """ Load ``cron`` modules for applications listed in ``INSTALLED_APPS``. """ autodiscover_modules('cron') if '.' in PROJECT_MODULE.__name__: try: import_module('%s.cron' % '.'.join( PROJECT_MODULE.__name__.split('.')[0:-1])) except ImportError as e: if 'No module named' not in str(e): print(e) # load django tasks for cmd, app in get_commands().items(): try: load_command_class(app, cmd) except django.core.exceptions.ImproperlyConfigured: pass
def load_regiond_commands(management, parser): """Load the allowed regiond commands into the MAAS cli.""" for name, app, help_text in regiond_commands: klass = management.load_command_class(app, name) if help_text is None: help_text = klass.help command_parser = parser.subparsers.add_parser( safe_name(name), help=help_text, description=help_text) klass.add_arguments(command_parser) command_parser.set_defaults( execute=partial(run_regiond_command, management))
def setUpTestData(cls): cls.import_command = management.load_command_class( ConsumptionConfig.name, 'import') # change to test data path cls.import_command.user_data_path = os.path.join( settings.TESTDATA_DIR, settings.IMPORT_USER_DATA_PATH) cls.import_command.consumption_path = os.path.join( settings.TESTDATA_DIR, settings.IMPORT_CONSUMPTION_PATH) # execute cls.import_command.handle()
def load(): """ Load ``cron`` modules for applications listed in ``INSTALLED_APPS``. """ autodiscover_modules('cron') if PROJECT_MODULE: if '.' in PROJECT_MODULE.__name__: try: import_module('%s.cron' % '.'.join( PROJECT_MODULE.__name__.split('.')[0:-1])) except ImportError as e: if 'No module named' not in str(e): print(e) # load django tasks for cmd, app in get_commands().items(): try: load_command_class(app, cmd) except django.core.exceptions.ImproperlyConfigured: pass
def monkey_patch_command_execute(name): """ Monkey patches a django management command to give it an execute function that does not sys.exit(1) on CommandError. Bug was fixed in django 1.5 and hence this should only be used for less than 1.5 django version """ from django.core import management from django.core.management.base import CommandError, BaseCommand import types # Populate the cache app_name = management.get_commands()[name] # Get the command if isinstance(app_name, BaseCommand): klass = app_name else: klass = management.load_command_class(app_name, name) def execute(self, *args, **options): """ Try to execute this command, performing model validation if needed (as controlled by the attribute ``self.requires_model_validation``). If the command raises a ``CommandError``, intercept it and print it sensibly to stderr. """ from django.utils.encoding import smart_str import sys show_traceback = options.get('traceback', False) try: self.stdout = options.get('stdout', sys.stdout) self.stderr = options.get('stderr', sys.stderr) if self.requires_model_validation: self.validate() output = self.handle(*args, **options) if output: if self.output_transaction: # This needs to be imported here, because it relies on # settings. from django.db import connections, DEFAULT_DB_ALIAS connection = connections[options.get('database', DEFAULT_DB_ALIAS)] if connection.ops.start_transaction_sql(): self.stdout.write(self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()) + '\n') self.stdout.write(output) if self.output_transaction: self.stdout.write('\n' + self.style.SQL_KEYWORD("COMMIT;") + '\n') except CommandError, e: if show_traceback: traceback.print_exc() else: self.stderr.write(smart_str(self.style.ERROR('Error: %s\n' % e)))
def get_command_from_arg(self, arg): *chunks, command = arg.split(".") path = ".".join(chunks) if not path: path = get_commands().get(command) try: cmd = load_command_class(path, command) except Exception: raise CommandError("Unknown command: %s" % arg) if isinstance(cmd, WrappedSchemaOption): raise CommandError("Command '%s' cannot be used in runschema" % arg) return cmd
def handle(self, *args, **options): app_names = [a for a in settings.INSTALLED_APPS if a.endswith(".biotools")] for app_name in app_names: command_names = find_commands(find_management_module(app_name)) for command_name in command_names: if command_name == 'load_all_biotools': continue command = load_command_class(app_name, command_name) self.stdout.write("INFO: {0} - {1}\n".format(command_name, command.help)) command.handle()
def load(): """ Load ``cron`` modules for applications listed in ``INSTALLED_APPS``. """ paths = ['%s.cron' % PROJECT_MODULE.__name__] if '.' in PROJECT_MODULE.__name__: paths.append('%s.cron' % '.'.join( PROJECT_MODULE.__name__.split('.')[0:-1])) for application in settings.INSTALLED_APPS: paths.append('%s.cron' % application) # load kronostasks for p in paths: try: import_module(p) except ImportError: pass # load django tasks for cmd, app in get_commands().items(): load_command_class(app, cmd)
def __new__(cls, *args, **kwargs): """ Sets option_list and help dynamically. """ # instantiate obj = super(BaseSchemataCommand, cls).__new__(cls, *args, **kwargs) # load the command class cmdclass = load_command_class(get_commands()[obj.COMMAND_NAME], obj.COMMAND_NAME) # inherit the options from the original command obj.option_list = cmdclass.option_list # prepend the command's original help with the info about schemata iteration obj.help = "Calls %s for all registered schemata. You can use regular %s options. " \ "Original help for %s: %s" \ % (obj.COMMAND_NAME, obj.COMMAND_NAME, obj.COMMAND_NAME, \ getattr(cmdclass, 'help', 'none')) return obj
def group_commands(): grouped = {} for command, provider in get_commands().items(): if isinstance(provider, basestring): key = provider cls = load_command_class(provider, command) elif isinstance(provider, base.BaseCommand): cls = provider mod = provider.__module__ idx = mod.find('management') - 1 key = mod[:idx] else: key = '?unknown' value = (command, getattr(cls, 'help', '')) grouped[key] = sorted(grouped.get(key, []) + [value]) return grouped
def __new__(cls, *args, **kwargs): """ Sets option_list and help dynamically. """ obj = super(BaseTenantCommand, cls).__new__(cls, *args) app_name = get_commands()[obj.COMMAND_NAME] if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. cmdclass = app_name else: cmdclass = load_command_class(app_name, obj.COMMAND_NAME) # prepend the command's original help with the info about schemata iteration obj.help = "Calls {0} for all registered schemata. You can use regular {0} options. " \ "Original help for {0}: {1}".format(obj.COMMAND_NAME, getattr(cmdclass, 'help', 'none')) return obj
def handle_noargs(self, **options): from django.conf import settings from django.db import models from django.core.management.sql import emit_post_sync_signal from django.db.utils import DEFAULT_DB_ALIAS from django.core.management import call_command ignore_reset = options.get('ignore_reset') if ignore_reset is None: ignore_reset = self.ignore_reset_default db = options.get('database', DEFAULT_DB_ALIAS) database_config = settings.DATABASES[db] if not ignore_reset: reset_schema(database_config) # hack to avoid using south klass = load_command_class('django.core', 'syncdb') args = {} defaults = {} options['interactive'] = False for opt in klass.option_list: if opt.default is NO_DEFAULT: defaults[opt.dest] = None else: defaults[opt.dest] = opt.default defaults.update(options) klass.execute(*args, **defaults) # Emit the post sync signal. This allows individual # applications to respond as if the database had been # sync'd from scratch. emit_post_sync_signal(models.get_models(), 0, 0, db) call_command('migrate', fake=True) self.log("load Random Dummy data ...") try: user = get_user_model().objects.create_superuser('admin', '*****@*****.**', DUMMY_PASSWORD) user.first_name, user.last_name = name_factory.get_full_name() user.save() self.log("superuser: admin") except Exception, e: self.log("WARNING: could not create superuser: %s" % str(e))
def fetch_command(self, subcommand): commands = get_commands() try: app_name = commands[subcommand] except KeyError: sys.stderr.write("Unknown command: %r\nType '%s help' for usage.\n" % (subcommand, self.prog_name)) sys.exit(1) if isinstance(app_name, management.BaseCommand): klass = app_name else: klass = management.load_command_class(app_name, subcommand) return klass
def the_patched(*args, **kw): res = get_commands(*args, **kw) tester = res.get('test', None) if tester is None: return res if isinstance(tester, basestring): tester = management.load_command_class('django.core', 'test') new_options = basic[:] ignored_opts = ('--unit', '--functional', '--integration') for opt in tester.option_list: if opt.get_opt_string() not in ignored_opts: new_options.insert(0, opt) tester.option_list = tuple(new_options) res['test'] = tester return res
def monkey_patch_command_execute(name): """ Monkey patches a django management command to give it an execute function that does not sys.exit(1) on CommandError. Bug was fixed in django 1.5 and hence this should only be used for less than 1.5 django version """ from django.core import management from django.core.management.base import CommandError, BaseCommand import types # Populate the cache app_name = management.get_commands()[name] # Get the command if isinstance(app_name, BaseCommand): klass = app_name else: klass = management.load_command_class(app_name, name) def execute(self, *args, **options): """ Try to execute this command, performing model validation if needed (as controlled by the attribute ``self.requires_model_validation``). If the command raises a ``CommandError``, intercept it and print it sensibly to stderr. """ from django.utils.encoding import smart_str import sys try: self.stdout = options.get('stdout', sys.stdout) self.stderr = options.get('stderr', sys.stderr) if self.requires_model_validation: self.validate() output = self.handle(*args, **options) if output: # Since this is only used for error catching an actual body in # this is useless. Just pass pass except CommandError as e: self.stderr.write(smart_str(self.style.ERROR('Error: %s\n' % e))) setattr(klass, 'execute', types.MethodType(execute, klass)) # Finalize command manipulation management._commands[name] = klass
def fetch_command(self, subcommand): """ Tries to fetch the given subcommand, printing a message with the appropriate command called from the command line (usually "django-admin.py" or "manage.py") if it can't be found. """ try: app_name = get_commands()[subcommand] except KeyError: sys.stderr.write(("Unknown command: %r\n" "Type '%s help' for usage.\n") % (subcommand, self.prog_name)) sys.exit(1) if isinstance(app_name, BaseCommand): # If the command is already loaded, use it directly. klass = app_name else: klass = load_command_class(app_name, subcommand) return klass