import argparse import sys from typing import Any from django.core.management import get_commands, load_command_class from django.core.management.base import BaseCommand, CommandError, CommandParser, SystemCheckError from . import WrappedSchemaOption class Command(WrappedSchemaOption, BaseCommand): help = "Wrapper around Django commands for use with an individual schema" def add_arguments(self, parser: CommandParser) -> None: super().add_arguments(parser) parser.add_argument("command_name", help="The command name you want to run") def get_command_from_arg(self, arg: str) -> BaseCommand: *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 run_from_argv(self, argv: list[str]) -> None: # pragma: no cover """ 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. """ try: # load the command object. if len(argv) <= 2: raise CommandError("No command to run") target_class = self.get_command_from_arg(argv[2]) # Ugly, but works. Delete command_name from the argv, parse the schemas manually # and forward the rest of the arguments to the actual command being wrapped. del argv[1] schema_parser = argparse.ArgumentParser() super().add_arguments(schema_parser) schema_ns, args = schema_parser.parse_known_args(argv) schemas = self.get_schemas_from_options( schemas=schema_ns.schemas, all_schemas=schema_ns.all_schemas, static_schemas=schema_ns.static_schemas, dynamic_schemas=schema_ns.dynamic_schemas, tenant_schemas=schema_ns.tenant_schemas, ) executor = self.get_executor_from_options(parallel=schema_ns.parallel) except Exception as e: if not isinstance(e, CommandError): raise # SystemCheckError takes care of its own formatting. if isinstance(e, SystemCheckError): self.stderr.write(str(e), lambda x: x) else: self.stderr.write("%s: %s" % (e.__class__.__name__, e)) sys.exit(1) executor(schemas, target_class, "special:run_from_argv", args) def handle(self, *args: Any, **options: Any) -> None: target = self.get_command_from_arg(options.pop("command_name")) schemas = self.get_schemas_from_options(**options) executor = self.get_executor_from_options(**options) options.pop("schemas") options.pop("excluded_schemas") options.pop("all_schemas") options.pop("static_schemas") options.pop("dynamic_schemas") options.pop("tenant_schemas") options.pop("parallel") options.pop("skip_schema_creation") if self.allow_interactive: options.pop("interactive") executor(schemas, target, "special:call_command", args, options)