File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/management.tar
Back
base.py 0000644 00000057227 15030001101 0006022 0 ustar 00 """ Base classes for writing management commands (named commands which can be executed through ``django-admin`` or ``manage.py``). """ import argparse import os import sys from argparse import ArgumentParser, HelpFormatter from functools import partial from io import TextIOBase import django from django.core import checks from django.core.exceptions import ImproperlyConfigured from django.core.management.color import color_style, no_style from django.db import DEFAULT_DB_ALIAS, connections ALL_CHECKS = "__all__" class CommandError(Exception): """ Exception class indicating a problem while executing a management command. If this exception is raised during the execution of a management command, it will be caught and turned into a nicely-printed error message to the appropriate output stream (i.e., stderr); as a result, raising this exception (with a sensible description of the error) is the preferred way to indicate that something has gone wrong in the execution of a command. """ def __init__(self, *args, returncode=1, **kwargs): self.returncode = returncode super().__init__(*args, **kwargs) class SystemCheckError(CommandError): """ The system check framework detected unrecoverable errors. """ pass class CommandParser(ArgumentParser): """ Customized ArgumentParser class to improve some error messages and prevent SystemExit in several occasions, as SystemExit is unacceptable when a command is called programmatically. """ def __init__( self, *, missing_args_message=None, called_from_command_line=None, **kwargs ): self.missing_args_message = missing_args_message self.called_from_command_line = called_from_command_line super().__init__(**kwargs) def parse_args(self, args=None, namespace=None): # Catch missing argument for a better error message if self.missing_args_message and not ( args or any(not arg.startswith("-") for arg in args) ): self.error(self.missing_args_message) return super().parse_args(args, namespace) def error(self, message): if self.called_from_command_line: super().error(message) else: raise CommandError("Error: %s" % message) def add_subparsers(self, **kwargs): parser_class = kwargs.get("parser_class", type(self)) if issubclass(parser_class, CommandParser): kwargs["parser_class"] = partial( parser_class, called_from_command_line=self.called_from_command_line, ) return super().add_subparsers(**kwargs) def handle_default_options(options): """ Include any default options that all commands should accept here so that ManagementUtility can handle them before searching for user commands. """ if options.settings: os.environ["DJANGO_SETTINGS_MODULE"] = options.settings if options.pythonpath: sys.path.insert(0, options.pythonpath) def no_translations(handle_func): """Decorator that forces a command to run with translations deactivated.""" def wrapper(*args, **kwargs): from django.utils import translation saved_locale = translation.get_language() translation.deactivate_all() try: res = handle_func(*args, **kwargs) finally: if saved_locale is not None: translation.activate(saved_locale) return res return wrapper class DjangoHelpFormatter(HelpFormatter): """ Customized formatter so that command-specific arguments appear in the --help output before arguments common to all commands. """ show_last = { "--version", "--verbosity", "--traceback", "--settings", "--pythonpath", "--no-color", "--force-color", "--skip-checks", } def _reordered_actions(self, actions): return sorted( actions, key=lambda a: set(a.option_strings) & self.show_last != set() ) def add_usage(self, usage, actions, *args, **kwargs): super().add_usage(usage, self._reordered_actions(actions), *args, **kwargs) def add_arguments(self, actions): super().add_arguments(self._reordered_actions(actions)) class OutputWrapper(TextIOBase): """ Wrapper around stdout/stderr """ @property def style_func(self): return self._style_func @style_func.setter def style_func(self, style_func): if style_func and self.isatty(): self._style_func = style_func else: self._style_func = lambda x: x def __init__(self, out, ending="\n"): self._out = out self.style_func = None self.ending = ending def __getattr__(self, name): return getattr(self._out, name) def flush(self): if hasattr(self._out, "flush"): self._out.flush() def isatty(self): return hasattr(self._out, "isatty") and self._out.isatty() def write(self, msg="", style_func=None, ending=None): ending = self.ending if ending is None else ending if ending and not msg.endswith(ending): msg += ending style_func = style_func or self.style_func self._out.write(style_func(msg)) class BaseCommand: """ The base class from which all management commands ultimately derive. Use this class if you want access to all of the mechanisms which parse the command-line arguments and work out what code to call in response; if you don't need to change any of that behavior, consider using one of the subclasses defined in this file. If you are interested in overriding/customizing various aspects of the command-parsing and -execution behavior, the normal flow works as follows: 1. ``django-admin`` or ``manage.py`` loads the command class and calls its ``run_from_argv()`` method. 2. The ``run_from_argv()`` method calls ``create_parser()`` to get an ``ArgumentParser`` for the arguments, parses them, performs any environment changes requested by options like ``pythonpath``, and then calls the ``execute()`` method, passing the parsed arguments. 3. The ``execute()`` method attempts to carry out the command by calling the ``handle()`` method with the parsed arguments; any output produced by ``handle()`` will be printed to standard output and, if the command is intended to produce a block of SQL statements, will be wrapped in ``BEGIN`` and ``COMMIT``. 4. If ``handle()`` or ``execute()`` raised any exception (e.g. ``CommandError``), ``run_from_argv()`` will instead print an error message to ``stderr``. Thus, the ``handle()`` method is typically the starting point for subclasses; many built-in commands and command types either place all of their logic in ``handle()``, or perform some additional parsing work in ``handle()`` and then delegate from it to more specialized methods as needed. Several attributes affect behavior at various steps along the way: ``help`` A short description of the command, which will be printed in help messages. ``output_transaction`` A boolean indicating whether the command outputs SQL statements; if ``True``, the output will automatically be wrapped with ``BEGIN;`` and ``COMMIT;``. Default value is ``False``. ``requires_migrations_checks`` A boolean; if ``True``, the command prints a warning if the set of migrations on disk don't match the migrations in the database. ``requires_system_checks`` A list or tuple of tags, e.g. [Tags.staticfiles, Tags.models]. System checks registered in the chosen tags will be checked for errors prior to executing the command. The value '__all__' can be used to specify that all system checks should be performed. Default value is '__all__'. To validate an individual application's models rather than all applications' models, call ``self.check(app_configs)`` from ``handle()``, where ``app_configs`` is the list of application's configuration provided by the app registry. ``stealth_options`` A tuple of any options the command uses which aren't defined by the argument parser. """ # Metadata about this command. help = "" # Configuration shortcuts that alter various logic. _called_from_command_line = False output_transaction = False # Whether to wrap the output in a "BEGIN; COMMIT;" requires_migrations_checks = False requires_system_checks = "__all__" # Arguments, common to all commands, which aren't defined by the argument # parser. base_stealth_options = ("stderr", "stdout") # Command-specific options not defined by the argument parser. stealth_options = () suppressed_base_arguments = set() def __init__(self, stdout=None, stderr=None, no_color=False, force_color=False): self.stdout = OutputWrapper(stdout or sys.stdout) self.stderr = OutputWrapper(stderr or sys.stderr) if no_color and force_color: raise CommandError("'no_color' and 'force_color' can't be used together.") if no_color: self.style = no_style() else: self.style = color_style(force_color) self.stderr.style_func = self.style.ERROR if ( not isinstance(self.requires_system_checks, (list, tuple)) and self.requires_system_checks != ALL_CHECKS ): raise TypeError("requires_system_checks must be a list or tuple.") def get_version(self): """ Return the Django version, which should be correct for all built-in Django commands. User-supplied commands can override this method to return their own version. """ return django.get_version() def create_parser(self, prog_name, subcommand, **kwargs): """ Create and return the ``ArgumentParser`` which will be used to parse the arguments to this command. """ kwargs.setdefault("formatter_class", DjangoHelpFormatter) parser = CommandParser( prog="%s %s" % (os.path.basename(prog_name), subcommand), description=self.help or None, missing_args_message=getattr(self, "missing_args_message", None), called_from_command_line=getattr(self, "_called_from_command_line", None), **kwargs, ) self.add_base_argument( parser, "--version", action="version", version=self.get_version(), help="Show program's version number and exit.", ) self.add_base_argument( parser, "-v", "--verbosity", default=1, type=int, choices=[0, 1, 2, 3], help=( "Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, " "3=very verbose output" ), ) self.add_base_argument( parser, "--settings", help=( "The Python path to a settings module, e.g. " '"myproject.settings.main". If this isn\'t provided, the ' "DJANGO_SETTINGS_MODULE environment variable will be used." ), ) self.add_base_argument( parser, "--pythonpath", help=( "A directory to add to the Python path, e.g. " '"/home/djangoprojects/myproject".' ), ) self.add_base_argument( parser, "--traceback", action="store_true", help="Raise on CommandError exceptions.", ) self.add_base_argument( parser, "--no-color", action="store_true", help="Don't colorize the command output.", ) self.add_base_argument( parser, "--force-color", action="store_true", help="Force colorization of the command output.", ) if self.requires_system_checks: parser.add_argument( "--skip-checks", action="store_true", help="Skip system checks.", ) self.add_arguments(parser) return parser def add_arguments(self, parser): """ Entry point for subclassed commands to add custom arguments. """ pass def add_base_argument(self, parser, *args, **kwargs): """ Call the parser's add_argument() method, suppressing the help text according to BaseCommand.suppressed_base_arguments. """ for arg in args: if arg in self.suppressed_base_arguments: kwargs["help"] = argparse.SUPPRESS break parser.add_argument(*args, **kwargs) def print_help(self, prog_name, subcommand): """ Print the help message for this command, derived from ``self.usage()``. """ parser = self.create_parser(prog_name, subcommand) parser.print_help() def run_from_argv(self, argv): """ Set up any environment changes requested (e.g., Python path and Django settings), then run this command. If the command raises a ``CommandError``, intercept it and print it sensibly to stderr. If the ``--traceback`` option is present or the raised ``Exception`` is not ``CommandError``, raise it. """ self._called_from_command_line = True parser = self.create_parser(argv[0], argv[1]) options = parser.parse_args(argv[2:]) cmd_options = vars(options) # Move positional args out of options to mimic legacy optparse args = cmd_options.pop("args", ()) handle_default_options(options) try: self.execute(*args, **cmd_options) except CommandError as e: if options.traceback: 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(e.returncode) finally: try: connections.close_all() except ImproperlyConfigured: # Ignore if connections aren't setup at this point (e.g. no # configured settings). pass def execute(self, *args, **options): """ Try to execute this command, performing system checks if needed (as controlled by the ``requires_system_checks`` attribute, except if force-skipped). """ if options["force_color"] and options["no_color"]: raise CommandError( "The --no-color and --force-color options can't be used together." ) if options["force_color"]: self.style = color_style(force_color=True) elif options["no_color"]: self.style = no_style() self.stderr.style_func = None if options.get("stdout"): self.stdout = OutputWrapper(options["stdout"]) if options.get("stderr"): self.stderr = OutputWrapper(options["stderr"]) if self.requires_system_checks and not options["skip_checks"]: if self.requires_system_checks == ALL_CHECKS: self.check() else: self.check(tags=self.requires_system_checks) if self.requires_migrations_checks: self.check_migrations() output = self.handle(*args, **options) if output: if self.output_transaction: connection = connections[options.get("database", DEFAULT_DB_ALIAS)] output = "%s\n%s\n%s" % ( self.style.SQL_KEYWORD(connection.ops.start_transaction_sql()), output, self.style.SQL_KEYWORD(connection.ops.end_transaction_sql()), ) self.stdout.write(output) return output def check( self, app_configs=None, tags=None, display_num_errors=False, include_deployment_checks=False, fail_level=checks.ERROR, databases=None, ): """ Use the system check framework to validate entire Django project. Raise CommandError for any serious message (error or critical errors). If there are only light messages (like warnings), print them to stderr and don't raise an exception. """ all_issues = checks.run_checks( app_configs=app_configs, tags=tags, include_deployment_checks=include_deployment_checks, databases=databases, ) header, body, footer = "", "", "" visible_issue_count = 0 # excludes silenced warnings if all_issues: debugs = [ e for e in all_issues if e.level < checks.INFO and not e.is_silenced() ] infos = [ e for e in all_issues if checks.INFO <= e.level < checks.WARNING and not e.is_silenced() ] warnings = [ e for e in all_issues if checks.WARNING <= e.level < checks.ERROR and not e.is_silenced() ] errors = [ e for e in all_issues if checks.ERROR <= e.level < checks.CRITICAL and not e.is_silenced() ] criticals = [ e for e in all_issues if checks.CRITICAL <= e.level and not e.is_silenced() ] sorted_issues = [ (criticals, "CRITICALS"), (errors, "ERRORS"), (warnings, "WARNINGS"), (infos, "INFOS"), (debugs, "DEBUGS"), ] for issues, group_name in sorted_issues: if issues: visible_issue_count += len(issues) formatted = ( self.style.ERROR(str(e)) if e.is_serious() else self.style.WARNING(str(e)) for e in issues ) formatted = "\n".join(sorted(formatted)) body += "\n%s:\n%s\n" % (group_name, formatted) if visible_issue_count: header = "System check identified some issues:\n" if display_num_errors: if visible_issue_count: footer += "\n" footer += "System check identified %s (%s silenced)." % ( "no issues" if visible_issue_count == 0 else "1 issue" if visible_issue_count == 1 else "%s issues" % visible_issue_count, len(all_issues) - visible_issue_count, ) if any(e.is_serious(fail_level) and not e.is_silenced() for e in all_issues): msg = self.style.ERROR("SystemCheckError: %s" % header) + body + footer raise SystemCheckError(msg) else: msg = header + body + footer if msg: if visible_issue_count: self.stderr.write(msg, lambda x: x) else: self.stdout.write(msg) def check_migrations(self): """ Print a warning if the set of migrations on disk don't match the migrations in the database. """ from django.db.migrations.executor import MigrationExecutor try: executor = MigrationExecutor(connections[DEFAULT_DB_ALIAS]) except ImproperlyConfigured: # No databases are configured (or the dummy one) return plan = executor.migration_plan(executor.loader.graph.leaf_nodes()) if plan: apps_waiting_migration = sorted( {migration.app_label for migration, backwards in plan} ) self.stdout.write( self.style.NOTICE( "\nYou have %(unapplied_migration_count)s unapplied migration(s). " "Your project may not work properly until you apply the " "migrations for app(s): %(apps_waiting_migration)s." % { "unapplied_migration_count": len(plan), "apps_waiting_migration": ", ".join(apps_waiting_migration), } ) ) self.stdout.write( self.style.NOTICE("Run 'python manage.py migrate' to apply them.") ) def handle(self, *args, **options): """ The actual logic of the command. Subclasses must implement this method. """ raise NotImplementedError( "subclasses of BaseCommand must provide a handle() method" ) class AppCommand(BaseCommand): """ A management command which takes one or more installed application labels as arguments, and does something with each of them. Rather than implementing ``handle()``, subclasses must implement ``handle_app_config()``, which will be called once for each application. """ missing_args_message = "Enter at least one application label." def add_arguments(self, parser): parser.add_argument( "args", metavar="app_label", nargs="+", help="One or more application label.", ) def handle(self, *app_labels, **options): from django.apps import apps try: app_configs = [apps.get_app_config(app_label) for app_label in app_labels] except (LookupError, ImportError) as e: raise CommandError( "%s. Are you sure your INSTALLED_APPS setting is correct?" % e ) output = [] for app_config in app_configs: app_output = self.handle_app_config(app_config, **options) if app_output: output.append(app_output) return "\n".join(output) def handle_app_config(self, app_config, **options): """ Perform the command's actions for app_config, an AppConfig instance corresponding to an application label given on the command line. """ raise NotImplementedError( "Subclasses of AppCommand must provide a handle_app_config() method." ) class LabelCommand(BaseCommand): """ A management command which takes one or more arbitrary arguments (labels) on the command line, and does something with each of them. Rather than implementing ``handle()``, subclasses must implement ``handle_label()``, which will be called once for each label. If the arguments should be names of installed applications, use ``AppCommand`` instead. """ label = "label" missing_args_message = "Enter at least one %s." % label def add_arguments(self, parser): parser.add_argument("args", metavar=self.label, nargs="+") def handle(self, *labels, **options): output = [] for label in labels: label_output = self.handle_label(label, **options) if label_output: output.append(label_output) return "\n".join(output) def handle_label(self, label, **options): """ Perform the command's actions for ``label``, which will be the string as given on the command line. """ raise NotImplementedError( "subclasses of LabelCommand must provide a handle_label() method" ) templates.py 0000644 00000036212 15030001101 0007075 0 ustar 00 import argparse import mimetypes import os import posixpath import shutil import stat import tempfile from importlib import import_module from urllib.request import build_opener import django from django.conf import settings from django.core.management.base import BaseCommand, CommandError from django.core.management.utils import ( find_formatters, handle_extensions, run_formatters, ) from django.template import Context, Engine from django.utils import archive from django.utils.http import parse_header_parameters from django.utils.version import get_docs_version class TemplateCommand(BaseCommand): """ Copy either a Django application layout template or a Django project layout template into the specified directory. :param style: A color style object (see django.core.management.color). :param app_or_project: The string 'app' or 'project'. :param name: The name of the application or project. :param directory: The directory to which the template should be copied. :param options: The additional variables passed to project or app templates """ requires_system_checks = [] # The supported URL schemes url_schemes = ["http", "https", "ftp"] # Rewrite the following suffixes when determining the target filename. rewrite_template_suffixes = ( # Allow shipping invalid .py files without byte-compilation. (".py-tpl", ".py"), ) def add_arguments(self, parser): parser.add_argument("name", help="Name of the application or project.") parser.add_argument( "directory", nargs="?", help="Optional destination directory" ) parser.add_argument( "--template", help="The path or URL to load the template from." ) parser.add_argument( "--extension", "-e", dest="extensions", action="append", default=["py"], help='The file extension(s) to render (default: "py"). ' "Separate multiple extensions with commas, or use " "-e multiple times.", ) parser.add_argument( "--name", "-n", dest="files", action="append", default=[], help="The file name(s) to render. Separate multiple file names " "with commas, or use -n multiple times.", ) parser.add_argument( "--exclude", "-x", action="append", default=argparse.SUPPRESS, nargs="?", const="", help=( "The directory name(s) to exclude, in addition to .git and " "__pycache__. Can be used multiple times." ), ) def handle(self, app_or_project, name, target=None, **options): self.app_or_project = app_or_project self.a_or_an = "an" if app_or_project == "app" else "a" self.paths_to_remove = [] self.verbosity = options["verbosity"] self.validate_name(name) # if some directory is given, make sure it's nicely expanded if target is None: top_dir = os.path.join(os.getcwd(), name) try: os.makedirs(top_dir) except FileExistsError: raise CommandError("'%s' already exists" % top_dir) except OSError as e: raise CommandError(e) else: top_dir = os.path.abspath(os.path.expanduser(target)) if app_or_project == "app": self.validate_name(os.path.basename(top_dir), "directory") if not os.path.exists(top_dir): raise CommandError( "Destination directory '%s' does not " "exist, please create it first." % top_dir ) # Find formatters, which are external executables, before input # from the templates can sneak into the path. formatter_paths = find_formatters() extensions = tuple(handle_extensions(options["extensions"])) extra_files = [] excluded_directories = [".git", "__pycache__"] for file in options["files"]: extra_files.extend(map(lambda x: x.strip(), file.split(","))) if exclude := options.get("exclude"): for directory in exclude: excluded_directories.append(directory.strip()) if self.verbosity >= 2: self.stdout.write( "Rendering %s template files with extensions: %s" % (app_or_project, ", ".join(extensions)) ) self.stdout.write( "Rendering %s template files with filenames: %s" % (app_or_project, ", ".join(extra_files)) ) base_name = "%s_name" % app_or_project base_subdir = "%s_template" % app_or_project base_directory = "%s_directory" % app_or_project camel_case_name = "camel_case_%s_name" % app_or_project camel_case_value = "".join(x for x in name.title() if x != "_") context = Context( { **options, base_name: name, base_directory: top_dir, camel_case_name: camel_case_value, "docs_version": get_docs_version(), "django_version": django.__version__, }, autoescape=False, ) # Setup a stub settings environment for template rendering if not settings.configured: settings.configure() django.setup() template_dir = self.handle_template(options["template"], base_subdir) prefix_length = len(template_dir) + 1 for root, dirs, files in os.walk(template_dir): path_rest = root[prefix_length:] relative_dir = path_rest.replace(base_name, name) if relative_dir: target_dir = os.path.join(top_dir, relative_dir) os.makedirs(target_dir, exist_ok=True) for dirname in dirs[:]: if "exclude" not in options: if dirname.startswith(".") or dirname == "__pycache__": dirs.remove(dirname) elif dirname in excluded_directories: dirs.remove(dirname) for filename in files: if filename.endswith((".pyo", ".pyc", ".py.class")): # Ignore some files as they cause various breakages. continue old_path = os.path.join(root, filename) new_path = os.path.join( top_dir, relative_dir, filename.replace(base_name, name) ) for old_suffix, new_suffix in self.rewrite_template_suffixes: if new_path.endswith(old_suffix): new_path = new_path[: -len(old_suffix)] + new_suffix break # Only rewrite once if os.path.exists(new_path): raise CommandError( "%s already exists. Overlaying %s %s into an existing " "directory won't replace conflicting files." % ( new_path, self.a_or_an, app_or_project, ) ) # Only render the Python files, as we don't want to # accidentally render Django templates files if new_path.endswith(extensions) or filename in extra_files: with open(old_path, encoding="utf-8") as template_file: content = template_file.read() template = Engine().from_string(content) content = template.render(context) with open(new_path, "w", encoding="utf-8") as new_file: new_file.write(content) else: shutil.copyfile(old_path, new_path) if self.verbosity >= 2: self.stdout.write("Creating %s" % new_path) try: self.apply_umask(old_path, new_path) self.make_writeable(new_path) except OSError: self.stderr.write( "Notice: Couldn't set permission bits on %s. You're " "probably using an uncommon filesystem setup. No " "problem." % new_path, self.style.NOTICE, ) if self.paths_to_remove: if self.verbosity >= 2: self.stdout.write("Cleaning up temporary files.") for path_to_remove in self.paths_to_remove: if os.path.isfile(path_to_remove): os.remove(path_to_remove) else: shutil.rmtree(path_to_remove) run_formatters([top_dir], **formatter_paths) def handle_template(self, template, subdir): """ Determine where the app or project templates are. Use django.__path__[0] as the default because the Django install directory isn't known. """ if template is None: return os.path.join(django.__path__[0], "conf", subdir) else: if template.startswith("file://"): template = template[7:] expanded_template = os.path.expanduser(template) expanded_template = os.path.normpath(expanded_template) if os.path.isdir(expanded_template): return expanded_template if self.is_url(template): # downloads the file and returns the path absolute_path = self.download(template) else: absolute_path = os.path.abspath(expanded_template) if os.path.exists(absolute_path): return self.extract(absolute_path) raise CommandError( "couldn't handle %s template %s." % (self.app_or_project, template) ) def validate_name(self, name, name_or_dir="name"): if name is None: raise CommandError( "you must provide {an} {app} name".format( an=self.a_or_an, app=self.app_or_project, ) ) # Check it's a valid directory name. if not name.isidentifier(): raise CommandError( "'{name}' is not a valid {app} {type}. Please make sure the " "{type} is a valid identifier.".format( name=name, app=self.app_or_project, type=name_or_dir, ) ) # Check it cannot be imported. try: import_module(name) except ImportError: pass else: raise CommandError( "'{name}' conflicts with the name of an existing Python " "module and cannot be used as {an} {app} {type}. Please try " "another {type}.".format( name=name, an=self.a_or_an, app=self.app_or_project, type=name_or_dir, ) ) def download(self, url): """ Download the given URL and return the file name. """ def cleanup_url(url): tmp = url.rstrip("/") filename = tmp.split("/")[-1] if url.endswith("/"): display_url = tmp + "/" else: display_url = url return filename, display_url prefix = "django_%s_template_" % self.app_or_project tempdir = tempfile.mkdtemp(prefix=prefix, suffix="_download") self.paths_to_remove.append(tempdir) filename, display_url = cleanup_url(url) if self.verbosity >= 2: self.stdout.write("Downloading %s" % display_url) the_path = os.path.join(tempdir, filename) opener = build_opener() opener.addheaders = [("User-Agent", f"Django/{django.__version__}")] try: with opener.open(url) as source, open(the_path, "wb") as target: headers = source.info() target.write(source.read()) except OSError as e: raise CommandError( "couldn't download URL %s to %s: %s" % (url, filename, e) ) used_name = the_path.split("/")[-1] # Trying to get better name from response headers content_disposition = headers["content-disposition"] if content_disposition: _, params = parse_header_parameters(content_disposition) guessed_filename = params.get("filename") or used_name else: guessed_filename = used_name # Falling back to content type guessing ext = self.splitext(guessed_filename)[1] content_type = headers["content-type"] if not ext and content_type: ext = mimetypes.guess_extension(content_type) if ext: guessed_filename += ext # Move the temporary file to a filename that has better # chances of being recognized by the archive utils if used_name != guessed_filename: guessed_path = os.path.join(tempdir, guessed_filename) shutil.move(the_path, guessed_path) return guessed_path # Giving up return the_path def splitext(self, the_path): """ Like os.path.splitext, but takes off .tar, too """ base, ext = posixpath.splitext(the_path) if base.lower().endswith(".tar"): ext = base[-4:] + ext base = base[:-4] return base, ext def extract(self, filename): """ Extract the given file to a temporary directory and return the path of the directory with the extracted content. """ prefix = "django_%s_template_" % self.app_or_project tempdir = tempfile.mkdtemp(prefix=prefix, suffix="_extract") self.paths_to_remove.append(tempdir) if self.verbosity >= 2: self.stdout.write("Extracting %s" % filename) try: archive.extract(filename, tempdir) return tempdir except (archive.ArchiveException, OSError) as e: raise CommandError( "couldn't extract file %s to %s: %s" % (filename, tempdir, e) ) def is_url(self, template): """Return True if the name looks like a URL.""" if ":" not in template: return False scheme = template.split(":", 1)[0].lower() return scheme in self.url_schemes def apply_umask(self, old_path, new_path): current_umask = os.umask(0) os.umask(current_umask) current_mode = stat.S_IMODE(os.stat(old_path).st_mode) os.chmod(new_path, current_mode & ~current_umask) def make_writeable(self, filename): """ Make sure that the file is writeable. Useful if our source is read-only. """ if not os.access(filename, os.W_OK): st = os.stat(filename) new_permissions = stat.S_IMODE(st.st_mode) | stat.S_IWUSR os.chmod(filename, new_permissions) __pycache__/__init__.cpython-310.pyc 0000644 00000032025 15030001101 0013173 0 ustar 00 o �hD � @ s d dl Z d dlZd dlZd dlZd dlmZmZmZmZ d dl m Z d dl m Z d dl mZ d dlZd dlmZ d dlmZ d dlmZ d d lmZmZmZmZ d d lm Z d d l m Z d d � Z dd� Z e j!dd�dd� �Z"dd� Z#G dd� d�Z$ddd�Z%dS )� N)�_AppendConstAction� _CountAction�_StoreConstAction�_SubParsersAction)� defaultdict)�get_close_matches)� import_module)�apps)�settings)�ImproperlyConfigured)� BaseCommand� CommandError� CommandParser�handle_default_options)� color_style)� autoreloadc C s$ t j�| d�}dd� t�|g�D �S )zp Given a path to a management directory, return a list of all the command names that are available. �commandsc S s$ g | ]\}}}|s|� d �s|�qS )�_�� startswith)�.0r �name�is_pkg� r �R/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/__init__.py� <listcomp># s ���z!find_commands.<locals>.<listcomp>)�os�path�join�pkgutil� iter_modules)�management_dir� command_dirr r r � find_commands s �r# c C s t d| |f �}|�� S )z� Given a command name and an application name, return the Command class instance. Allow all errors raised by the import process (ImportError, AttributeError) to propagate. z%s.management.commands.%s)r �Command)�app_namer �moduler r r �load_command_class* s r' )�maxsizec sb dd� t td �D �} tjs| S tt�� �D ]� tj� � jd�}| � � fdd�t |�D �� q| S )a� Return a dictionary mapping command names to their callback applications. Look for a management.commands package in django.core, and in each installed application -- if a commands package exists, register all commands in that package. Core commands are always included. If a settings module has been specified, also include user-defined commands. The dictionary is in the format {command_name: app_name}. Key-value pairs from this dictionary can then be used in calls to load_command_class(app_name, command_name) The dictionary is cached on the first call and reused on subsequent calls. c S s i | ]}|d �qS )� django.corer �r r r r r � <dictcomp>G � z get_commands.<locals>.<dictcomp>r � managementc s i | ]}|� j �qS r )r r* �� app_configr r r+ N s ) r# �__path__r � configured�reversedr �get_app_configsr r r �update)r r r r. r � get_commands4 s r5 c sZ t | t�r| }|jj�d�d } n"zt� | }W n ty% td| ��w t |t�r.|}nt|| �}|� d| �}dd� |j D ���fdd�|� � D �}g }|D ]}t |t t f�ra|tt|�7 }qP|�t|�� qP� fdd �� t � |��} d d � |jD �} | D ]T��j|v rӈjs��| v r�t�fd d ���� D ��} | dkr�td�j�d���|�t�j�� t �tttf�r�q|�j } t | t t f�r�|tt| �7 }q|�t| �� q|j |d�} t | � � fi |��} t |j |j! �}dd � | D �}||B �"��}t |�| }|�rtd| d�#t$|��d�#t$|��f ��| �%dd�}d|v�r%d| d< |j&|i | ��S )a{ Call the given command, with the given options and args/kwargs. This is the primary API you should use for calling specific commands. `command_name` may be a string or a command object. Using a string is preferred unless the command object is required for further processing or testing. Some examples: call_command('migrate') call_command('shell', plain=True) call_command('sqlmigrate', 'myapp') from django.core.management.commands import flush cmd = flush.Command() call_command(cmd, verbosity=0, interactive=False) # Do something with cmd ... �.����Unknown command: %r� c S s. i | ]}|j rt|j ��d ��d d�|j�qS )�-r )�option_strings�min�lstrip�replace�dest�r �s_optr r r r+ { s ��z call_command.<locals>.<dictcomp>c s i | ] \}}� � ||�|�qS r )�get)r �key�value)� opt_mappingr r r+ � s c 3 sB � | j D ]}t|t�r|j�� D ] }� |�E d H qq|V qd S �N)�_actions� isinstancer �choices�values)�parser�opt�sub_opt)� get_actionsr r rN � s � ��z!call_command.<locals>.get_actionsc S s" h | ] }|j D ]}|jr|�qqS r )�_group_actions�required)r �grouprL r r r � <setcomp>� s ���z call_command.<locals>.<setcomp>c 3 s � | ]}|� j kV qd S rF �r? )r �v)rL r r � <genexpr>� � � z call_command.<locals>.<genexpr>� zCannot pass the dest z/ that matches multiple arguments via **options.)�argsc S s h | ]}|j �qS r rS )r �actionr r r rR � r, z<Unknown option(s) for %s command: %s. Valid options are: %s.z, rX r � skip_checksT)'rH r � __class__� __module__�splitr5 �KeyErrorr r' � create_parserrG �items�list�tuple�map�str�append�_mutually_exclusive_groupsr? rP �sumrJ � TypeErrorr< r; r r r � parse_args�dict� _get_kwargs�set�base_stealth_options�stealth_options�unionr �sorted�pop�execute)� command_namerX �options�commandr% rK � arg_optionsri �arg�parser_actions�#mutually_exclusive_required_options�opt_dest_countrD �defaultsrn �dest_parameters� valid_options�unknown_optionsr )rN rL rE r � call_commandS s~ � � � � � � ��� r c @ s< e Zd ZdZddd�Zddd�Zdd � Zd d � Zd d � ZdS )�ManagementUtilityzL Encapsulate the logic of the django-admin and manage.py utilities. Nc C sB |pt jd d � | _tj�| jd �| _| jdkr d| _d | _d S )Nr z __main__.pyzpython -m django)�sys�argvr r �basename� prog_name�settings_exception)�selfr� r r r �__init__� s zManagementUtility.__init__Fc C s� |rt t� �}ngdd| j ddg}tdd� �}t� �� D ]\}}|dkr'd}n|�d�d }|| �|� q t� }t |�D ]!}|�d� |�|�d | �� t || �D ] }|�d | � qTq=| j d uro|�|�d | j �� d� |�S )z0Return the script's main help text, as a string.r9 z>Type '%s help <subcommand>' for help on a specific subcommand.zAvailable subcommands:c S s g S rF r r r r r �<lambda>� s z2ManagementUtility.main_help_text.<locals>.<lambda>r) �djangor6 r7 z[%s]z %sNzcNote that only Django core commands are listed as settings are not properly configured (error: %s).� ) rp r5 r� r r` � rpartitionre r �NOTICEr� r )r� � commands_only�usage� commands_dictr �app�styler r r �main_help_text� s> �� � ��� z ManagementUtility.main_help_textc C s� t � }z|| }W nC tyL tj�d�rtj n tjs#tj � d� t ||�}tj � d| � |r<tj � d|d � tj � d| j � t� d� Y nw t|t�rV|}|S t||�}|S )z� Try 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. �DJANGO_SETTINGS_MODULEz No Django settings specified. r8 z. Did you mean %s?r z Type '%s help' for usage. rW )r5 r^ r �environrB r �INSTALLED_APPSr1 r� �stderr�writer r� �exitrH r r' )r� � subcommandr r% �possible_matches�klassr r r � fetch_command� s( � �z ManagementUtility.fetch_commandc s� dt jvrdS t jd �� dd� }tt jd �}z||d � W n ty, d� Y nw g t� �d�}dg}|dkrLtd �tt � fd d �|���� nx|d |v r�|d dkr�| � |d �}|d d v rzt � � }|� dd� |D �� W n ty~ Y nw |�d|d �}|� dd� |jD �� dd� |d|d � D ���fdd�|D �}t� fdd�|D ��}|D ]\}} | r�|d7 }t|� q�t�d � dS )a� Output completion suggestions for BASH. The output of this function is passed to BASH's `COMREPLY` variable and treated as completion suggestions. `COMREPLY` expects a space separated string as the result. The `COMP_WORDS` and `COMP_CWORD` BASH environment variables are used to get information about the cli input. Please refer to the BASH man-page for more information about this variables. Subcommand options are saved as pairs. A pair consists of the long option string (e.g. '--exclude') and a boolean value indicating if the option requires arguments. When printing to stdout, an equal sign is appended to options which require arguments. Note: If debugging this function, it is recommended to write the debug output in a separate file. Otherwise the debug output will be treated and formatted as potential completion suggestions. �DJANGO_AUTO_COMPLETEN� COMP_WORDSrW � COMP_CWORDr9 �help)�--helpF� c s | � � �S rF r )�x��currr r r� < s z0ManagementUtility.autocomplete.<locals>.<lambda>r )�dumpdata� sqlmigrate�sqlsequencereset�testc s s � | ]}|j d fV qdS �r N)�label)r r/ r r r rU F rV z1ManagementUtility.autocomplete.<locals>.<genexpr>c s s* � | ]}|j rt|j �|jd kfV qdS r� )r; r< �nargsr@ r r r rU L s � � �c S s h | ] }|� d �d �qS )�=r )r] )r r� r r r rR R s z1ManagementUtility.autocomplete.<locals>.<setcomp>c 3 s � | ] }|d � vr|V qdS r� r )r rL )� prev_optsr r rU S s � c 3 s& � | ]\}}|� � �r||fV qd S rF r )r �krT r� r r rU V s �$ r� )r r� r] �int� IndexErrorr5 �printr rp �filterr� r r3 �extend� ImportErrorr_ rG r� r� ) r� �cwords�cword� subcommandsrt �subcommand_cls� app_configsrK � opt_label� require_argr )r� r� r � autocomplete sD �" � � z ManagementUtility.autocompletec C s� z| j d }W n ty d}Y nw t| jdddd�}|�d� |�d� |jdd d � z|�| j d d � �\}}t|� W n tyH Y nw ztj W n) t yc } z || _ W Y d }~nd }~w t yw } z || _ W Y d }~nd }~ww tj r�|d kr�d| j vr�z t�tj�� W n> ty� tt�t_i t_d t_ t_t_| �d �� dd �}|�| j d d � �\}}|D ]} | j � | � q�Y nw t�� | � � |dk�rd|v r�t j �!| j"dd�d � d S |j#s�t j �!| �"� d � d S | �|j#d ��$| j|j#d � d S |dk�s| j dd � dgk�r$t j �!t�%� d � d S | j dd � dgdgfv �r>t j �!| �"� d � d S | �|��&| j � d S )z� Given the command-line arguments, figure out which subcommand is being run, create a parser appropriate to that command, and run it. rW r� z$%(prog)s subcommand [options] [args]F)�progr� �add_help� allow_abbrevz --settingsz --pythonpathrX �*)r� � N� runserverz --noreloadTr� z --commands)r� r� r �versionz --versionr� z-h)'r� r� r r� � add_argument�parse_known_argsr r r r� r r� r� r1 r � check_errorsr� �setup� Exceptionr rj r � all_modelsr� � apps_ready� models_ready�readyr� r_ �remover� r� �stdoutr� r� rX � print_help� get_version� run_from_argv) r� r� rK rt rX �exc�_parser�_options�_args�_argr r r rr a sx �� � ��� ��� � zManagementUtility.executerF )F) �__name__r\ � __qualname__�__doc__r� r� r� r� rr r r r r r� � s % Kr� c C s t | �}|�� dS )zRun a ManagementUtility.N)r� rr )r� �utilityr r r �execute_from_command_line� s r� rF )&� functoolsr r r� �argparser r r r � collectionsr �difflibr � importlibr r� � django.appsr � django.confr �django.core.exceptionsr �django.core.management.baser r r r � django.core.management.colorr � django.utilsr r# r' � lru_cacher5 r r� r� r r r r �<module> s. r s __pycache__/color.cpython-310.pyc 0000644 00000005264 15030001101 0012557 0 ustar 00 o �h> � @ s� d Z ddlZddlZddlZddlmZ z ddlZe�� W n ee fy+ dZ Y nw dZ dd� Z G dd � d �Z dd d �Z ejdd �dd� �Zddd�ZdS )z$ Sets up the terminal color scheme. � N)� termcolorsFTc C sZ dd� } t tjd�otj�� }|o,tjdkp,tp,dtjv p,dtjv p,tj�d�dkp,| � S ) z_ Return True if the running system's terminal supports color, and False otherwise. c S s` zddl } W n ty Y dS w z| �| jd�}| �|d�\}}W |dkS ty/ Y dS w )z� Check the Windows Registry to see if VT code handling has been enabled by default, see https://superuser.com/a/1300251/447564. r NF�Console�VirtualTerminalLevel� )�winreg� ImportError�OpenKey�HKEY_CURRENT_USER� QueryValueEx�FileNotFoundError)r �reg_key� reg_key_value�_� r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/color.py�$vt_codes_enabled_in_windows_registry s � ��z<supports_color.<locals>.vt_codes_enabled_in_windows_registry�isatty�win32�ANSICON� WT_SESSION� TERM_PROGRAM�vscode) �hasattr�sys�stdoutr �platform� HAS_COLORAMA�os�environ�get)r �is_a_ttyr r r �supports_color s ���� �r! c @ s e Zd ZdS )�StyleN)�__name__� __module__� __qualname__r r r r r" ? s r" � c C sd t � }t�| �}tjtj D ] }|r!|�|i �}tjdi |��}ndd� }t|||� q|j|_ |S )z� Create a Style object from the given config_string. If config_string is empty django.utils.termcolors.DEFAULT_PALETTE is used. c S s | S )Nr )�xr r r � style_funcW s z make_style.<locals>.style_funcNr ) r" r �parse_color_setting�PALETTES�NOCOLOR_PALETTEr � make_style�setattr�ERROR� ERROR_OUTPUT)� config_string�style�color_settings�role�formatr( r r r r, C s r, )�maxsizec C s t d�S )z5 Return a Style object with no color scheme. �nocolor)r, r r r r �no_stylec s r7 c C s" | st � st� S ttj�dd��S )z= Return a Style object from the Django color scheme. � DJANGO_COLORSr& )r! r7 r, r r r )� force_colorr r r � color_stylek s r: )r& )F)�__doc__� functoolsr r � django.utilsr �colorama�initr �OSErrorr r! r" r, � lru_cacher7 r: r r r r �<module> s$ �* __pycache__/sql.cpython-310.pyc 0000644 00000002551 15030001101 0012234 0 ustar 00 o �h; � @ s> d dl Z d dlmZ d dlmZ d dd�Zdd � Zd d � ZdS ) � N)�apps)�modelsTFc C s$ |j jddd�}|jj| |||d�S )zI Return a list of the SQL statements used to flush the database. TF)� only_existing� include_views)�reset_sequences� allow_cascade)� introspection�django_table_names�ops� sql_flush)�style� connectionr r �tables� r �M/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/sql.pyr s ��r c K �d t �� D ]+}|jd u r q| dkr |�dtj�}|�d|j � tj j j d||| ||d�|�� qd S )N� �stdoutz/Running pre-migrate handlers for application %s��sender� app_config� verbosity� interactive�usingr ) r �get_app_configs� models_module�get�sysr �write�labelr �signals� pre_migrate�send�r r �db�kwargsr r r r r �emit_pre_migrate_signal �$ � ���r& c K r )Nr r z0Running post-migrate handlers for application %sr r ) r r r r r r r r r r � post_migrater" r# r r r �emit_post_migrate_signal* r' r) )TF)r � django.appsr � django.dbr r r& r) r r r r �<module> s __pycache__/templates.cpython-310.pyc 0000644 00000025070 15030001101 0013434 0 ustar 00 o �h�< � @ s� d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZ d dl m Z d dl Z d dl m Z d dlmZmZ d dlmZmZmZ d dlmZmZ d dlmZ d d lmZ d d l m Z G d d � d e�Z dS ) � N)� import_module)� build_opener)�settings)� BaseCommand� CommandError)�find_formatters�handle_extensions�run_formatters)�Context�Engine)�archive)�parse_header_parameters)�get_docs_versionc @ st e Zd ZdZg Zg d�ZdZdd� Zddd�Zd d � Z dd d �Z dd� Z dd� Z dd� Z dd� Zdd� Zdd� ZdS ) �TemplateCommanda� Copy either a Django application layout template or a Django project layout template into the specified directory. :param style: A color style object (see django.core.management.color). :param app_or_project: The string 'app' or 'project'. :param name: The name of the application or project. :param directory: The directory to which the template should be copied. :param options: The additional variables passed to project or app templates )�http�https�ftp))z.py-tplz.pyc C sx |j ddd� |j dddd� |j dd d� |j d d d d dgdd� |j dddd g dd� |j ddd tjdddd� d S )N�namez#Name of the application or project.)�help� directory�?z Optional destination directory)�nargsr z --templatez*The path or URL to load the template from.z --extensionz-e� extensions�append�pyztThe file extension(s) to render (default: "py"). Separate multiple extensions with commas, or use -e multiple times.)�dest�action�defaultr z--namez-n�filesz_The file name(s) to render. Separate multiple file names with commas, or use -n multiple times.z --excludez-x� zbThe directory name(s) to exclude, in addition to .git and __pycache__. Can be used multiple times.)r r r �constr )� add_argument�argparse�SUPPRESS)�self�parser� r& �S/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/templates.py� add_arguments. s@ ��� � �z TemplateCommand.add_argumentsNc ' K s� || _ |dkr dnd| _g | _|d | _| �|� |d u rJtj�t�� |�}zt� |� W n@ t y: t d| �� t yI } zt |��d }~ww tj� tj�|��}|dkrb| �tj�|�d� tj�|�snt d| ��t� }tt|d ��}g } d d g} |d D ]} | �td d � | �d��� q�|�d� } r�| D ] } | �| �� � q�| jdkr�| j�d|d�|�f � | j�d|d�| �f � d| }d| }d| }d| }d�dd� |� � D ��}t i |�||||||dt � d t j i�d d �}t!j"�st!�#� t �$� | �%|d |�}t&|�d }t�'|�D �]"\}}}||d � }|�(||�}|�r9tj�||�}tj |d!d"� |d d � D ]$} d|v�rX| �)d#��sQ| d k�rV|�*| � �q?| | v �rb|�*| � �q?|D ]�} | �+d$��rp�qftj�|| �} tj�||| �(||��} | j,D ]\} }!| �+| ��r�| d t&| � � |! } n�q�tj�| ��r�t d%| | j|f ��| �+|��s�| | v �r�t-| d&d'�� }"|"�.� }#W d � n 1 �s�w Y t/� �0|#�}$|$�1|�}#t-| d(d&d'�� }%|%�|#� W d � n 1 �s�w Y nt2�3| | � | jdk�r| j�d)| � z| �4| | � | �5| � W �qf t �y7 | j6�d*| | j7j8� Y �qfw �q| j�rd| jdk�rJ| j�d+� | jD ]}&tj�9|&��r]t�*|&� �qMt2�:|&� �qMt;|gfi |�� d S ),N�app�an�a� verbosityz'%s' already existsr zBDestination directory '%s' does not exist, please create it first.r z.git� __pycache__r c S s | � � S �N)�strip)�xr& r& r' �<lambda>y s z(TemplateCommand.handle.<locals>.<lambda>�,�exclude� z/Rendering %s template files with extensions: %sz, z.Rendering %s template files with filenames: %sz%s_namez %s_templatez %s_directoryzcamel_case_%s_namer c s s � | ] }|d kr|V qdS )�_Nr& )�.0r0 r& r& r' � <genexpr>� s � z)TemplateCommand.handle.<locals>.<genexpr>� docs_version�django_versionF)� autoescape�template� T)�exist_ok�.)z.pyoz.pycz .py.classz_%s already exists. Overlaying %s %s into an existing directory won't replace conflicting files.zutf-8)�encoding�wz Creating %szkNotice: Couldn't set permission bits on %s. You're probably using an uncommon filesystem setup. No problem.z Cleaning up temporary files.)<�app_or_project�a_or_an�paths_to_remover, � validate_name�os�path�join�getcwd�makedirs�FileExistsErrorr �OSError�abspath� expanduser�basename�existsr �tupler �extend�map�split�getr r/ �stdout�write�titler r �django� __version__r � configured� configure�setup�handle_template�len�walk�replace� startswith�remove�endswith�rewrite_template_suffixes�open�readr � from_string�render�shutil�copyfile� apply_umask�make_writeable�stderr�style�NOTICE�isfile�rmtreer )'r$ rA r �target�options�top_dir�e�formatter_pathsr � extra_files�excluded_directories�filer3 r � base_name� base_subdir�base_directory�camel_case_name�camel_case_value�context� template_dir� prefix_length�root�dirsr � path_rest� relative_dir� target_dir�dirname�filename�old_path�new_path� old_suffix� new_suffix� template_file�contentr; �new_file�path_to_remover& r& r' �handleV s �� �� �� ����� � � � ���� � �� � ���1 zTemplateCommand.handlec C s� |du rt j�tjd d|�S |�d�r|dd� }t j�|�}t j�|�}t j�|�r.|S | � |�r9| � |�}nt j� |�}t j� |�rJ| � |�S td| j|f ��)z� Determine where the app or project templates are. Use django.__path__[0] as the default because the Django install directory isn't known. Nr �confzfile://� z couldn't handle %s template %s.)rE rF rG rX �__path__ra rM �normpath�isdir�is_url�downloadrL rO �extractr rA )r$ r; �subdir�expanded_template� absolute_pathr& r& r' r] � s �z TemplateCommand.handle_templater c C sx |d u rt dj| j| jd���|�� s t dj|| j|d���zt|� W n ty. Y d S w t dj|| j| j|d���)Nz you must provide {an} {app} name)r* r) zX'{name}' is not a valid {app} {type}. Please make sure the {type} is a valid identifier.)r r) �typez�'{name}' conflicts with the name of an existing Python module and cannot be used as {an} {app} {type}. Please try another {type}.)r r* r) r� )r �formatrB rA � isidentifierr � ImportError)r$ r � name_or_dirr& r& r' rD s< ���� ���z TemplateCommand.validate_namec C s� dd� }d| j }tj|dd�}| j�|� ||�\}}| jdkr)| j�d| � tj � ||�}t � }dd t j � �fg|_z7|�|��(} t|d ��} | �� } | �| �� � W d � n1 s_w Y W d � n1 snw Y W n ty� } z td ||| f ��d } ~ ww |�d �d } | d }|r�t|�\}}|�d�p�| }n| }| �|�d }| d }|s�|r�t�|�}|r�||7 }| |kr�tj � ||�}t�||� |S |S )zB Download the given URL and return the file name. c S s> | � d�}|�d�d }| �d�r|d }||fS | }||fS )N�/���)�rstriprS rc )�url�tmpr� � display_urlr& r& r' � cleanup_url- s �z-TemplateCommand.download.<locals>.cleanup_url�django_%s_template_� _download��prefix�suffixr4 zDownloading %sz User-AgentzDjango/�wbNz"couldn't download URL %s to %s: %sr� r� zcontent-dispositionr� r< z content-type) rA �tempfile�mkdtemprC r r, rU rV rE rF rG r rX rY � addheadersre �inforf rK r rS r rT �splitext� mimetypes�guess_extensionri �move)r$ r� r� r� �tempdirr� r� �the_path�opener�sourcerr �headersru � used_name�content_dispositionr5 �params�guessed_filename�ext� content_type� guessed_pathr& r& r' r� ( sR �� � ��� zTemplateCommand.downloadc C s@ t �|�\}}|�� �d�r |dd� | }|dd� }||fS )z@ Like os.path.splitext, but takes off .tar, too z.tar���N)� posixpathr� �lowerrc )r$ r� �baser� r& r& r' r� f s zTemplateCommand.splitextc C s� d| j }tj|dd�}| j�|� | jdkr | j�d| � z t� ||� |W S tj t fy@ } z t d|||f ��d}~ww )z� Extract the given file to a temporary directory and return the path of the directory with the extracted content. r� �_extractr� r4 z Extracting %sz"couldn't extract file %s to %s: %sN) rA r� r� rC r r, rU rV r r� �ArchiveExceptionrK r )r$ r� r� r� ru r& r& r' r� p s ���zTemplateCommand.extractc C s* d|vrdS |� dd�d �� }|| jv S )z)Return True if the name looks like a URL.�:Fr< r )rS r� � url_schemes)r$ r; �schemer& r& r' r� � s zTemplateCommand.is_urlc C s< t �d�}t �|� t�t �|�j�}t �||| @ � d S )Nr )rE �umask�stat�S_IMODE�st_mode�chmod)r$ r� r� � current_umask� current_moder& r& r' rk � s zTemplateCommand.apply_umaskc C s> t �|t j�s t �|�}t�|j�tjB }t �||� dS dS )zb Make sure that the file is writeable. Useful if our source is read-only. N)rE �access�W_OKr� r� r� �S_IWUSRr� )r$ r� �st�new_permissionsr& r& r' rl � s �z TemplateCommand.make_writeabler. )r )�__name__� __module__� __qualname__�__doc__�requires_system_checksr� rd r( r� r] rD r� r� r� r� rk rl r& r& r& r' r s ( #> r ) r" r� rE r� ri r� r� � importlibr �urllib.requestr rX � django.confr �django.core.management.baser r � django.core.management.utilsr r r �django.templater r � django.utilsr �django.utils.httpr �django.utils.versionr r r& r& r& r' �<module> s$ __pycache__/utils.cpython-310.pyc 0000644 00000013061 15030001101 0012573 0 ustar 00 o �h5 � @ s� d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dlmZ d dl m Z d dl m Z ddlmZmZ d d d �Zd d � Zd dd�Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Ze� Zfd d �Z dS ) � N)�Path)�run)�apps��get_random_string)�DEFAULT_LOCALE_ENCODING� )� CommandError� CommandParser�utf-8c C sd z t | dtjdkd�}W n ty! } z td| d �|�d}~ww |j�|�|jjtdd�|j fS ) zf Friendly wrapper around Popen. Return stdout output, stderr output, and OS status code. T�nt)�capture_output� close_fdszError executing %sr N�replace)�errors) r �os�name�OSErrorr �stdout�decode�stderrr � returncode)�args�stdout_encoding�p�err� r �O/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/utils.py� popen_wrapper s �� �r c C sZ g }| D ]}|� |�dd��d�� qt|�D ]\}}|�d�s(d|| ||< qt|�S )a� Organize multiple extensions that are separated with commas or passed by using --extension/-e multiple times. For example: running 'django-admin makemessages -e js,txt -e xhtml -a' would result in an extension list: ['.js', '.txt', '.xhtml'] >>> handle_extensions(['.html', 'html,js,py,py,py,.py', 'py,.py']) {'.html', '.js', '.py'} >>> handle_extensions(['.html, txt,.tpl']) {'.html', '.tpl', '.txt'} � � �,�.z.%s)�extendr �split� enumerate� startswith�set)� extensions�ext_list�ext�ir r r �handle_extensions s �r, c C s� |d u rt j�dd��t j�}t|t�r|g}|d u r&t j�dd��t j�}|D ] }| �|�r4dg} nq(|D ](}t j� || �}t j� |�rJ| S |D ]}|| }t j� |�r^| S qLq7d S )N�PATHr �PATHEXTz.COM;.EXE;.BAT;.CMD) r �environ�getr$ �pathsep� isinstance�str�endswith�path�join�isfile)�cmdr5 �pathextr* r �f�fextr r r � find_command6 s, � ��r< c C s d} t d| �S )zS Return a 50 character random string usable as a SECRET_KEY setting value. z2abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)�2 r )�charsr r r �get_random_secret_keyO s r? c C s� t � }t � }| D ]@}d|v r)zt�|�}W n ty" td| ��w |�|� qzt�|�}W n tyB } ztt|���d}~ww |�|� q||fS )z� Parse a list of "app_label.ModelName" or "app_label" strings into actual objects and return a two-element tuple: (set of model classes, set of app_configs). Raise a CommandError if some specified models or apps don't exist. r" zUnknown model: %sN)r' �installed_apps� get_model� LookupErrorr �add�get_app_configr3 )�labelsr �models�label�model� app_config�er r r �parse_apps_and_model_labelsW s$ � �� rK c C sN t ddd�}|j|dd� z|�| dd� �\}}W |jS ty& Y dS w )z� Return the value of a command line option (which should include leading dashes, e.g. '--testrunner') from an argument list. Return None if the option wasn't passed or if the argument list couldn't be parsed. F)�add_help� allow_abbrev�value)�dest� N)r � add_argument�parse_known_argsr rN )�argv�option�parser�options�_r r r �get_command_line_optionr s ��rX c C sn dd� | D �} dd� dt jhD �}g }| D ] }|D ]}|�|�r.|�|dt|� � � nq|�|� q|S )z9Normalize an iterable of glob style patterns based on OS.c S s g | ]}t j�|��qS r )r r5 �normcase)�.0r r r r � <listcomp>� s z+normalize_path_patterns.<locals>.<listcomp>c S s h | ]}d | �qS )z%s*r )rZ �path_sepr r r � <setcomp>� s z*normalize_path_patterns.<locals>.<setcomp>�/N)r �sepr4 �append�len)�patterns� dir_suffixes� norm_patterns�pattern� dir_suffixr r r �normalize_path_patterns� s � �rg c s. t ����fdd�� t� fdd�t|�D ��S )zy Check if the given path should be ignored or not based on matching one of the glob style `ignore_patterns`. c s t �� j| �pt �t� �| �S �N)�fnmatch� fnmatchcaser r3 )re )r5 r r �ignore� s �z is_ignored_path.<locals>.ignorec 3 s � | ]}� |�V qd S rh r )rZ re )rk r r � <genexpr>� s � z"is_ignored_path.<locals>.<genexpr>)r �anyrg )r5 �ignore_patternsr )rk r5 r �is_ignored_path� s ro c C s dt �d�iS )N� black_path�black)�shutil�whichr r r r �find_formatters� s rt c C s6 |t u r t�d�}|rtj|ddg| �dd� dS dS )z9 Run the black formatter on the specified files. rq z--fastz--T)r N)�sentinelrr rs � subprocessr )� written_filesrp r r r �run_formatters� s ��rx )r )NN) ri r rr rv �pathlibr r � django.appsr r@ �django.utils.cryptor �django.utils.encodingr �baser r r r, r< r? rK rX rg ro rt �objectru rx r r r r �<module> s( __pycache__/base.cpython-310.pyc 0000644 00000054733 15030001101 0012360 0 ustar 00 o �h�^ � @ s d Z ddlZddlZddlZddlmZmZ ddlmZ ddlm Z ddl Z ddl m Z ddl mZ ddlmZmZ dd lmZmZ d ZG d d � d e�ZG d d� de�ZG dd� de�Zdd� Zdd� ZG dd� de�Z G dd� de �Z G dd� d�Z G dd � d e �Z G d d � d e �Z dS ) z� Base classes for writing management commands (named commands which can be executed through ``django-admin`` or ``manage.py``). � N)�ArgumentParser� HelpFormatter)�partial)� TextIOBase)�checks)�ImproperlyConfigured)� color_style�no_style)�DEFAULT_DB_ALIAS� connections�__all__c s& e Zd ZdZdd�� fdd� Z� ZS )� CommandErrora� Exception class indicating a problem while executing a management command. If this exception is raised during the execution of a management command, it will be caught and turned into a nicely-printed error message to the appropriate output stream (i.e., stderr); as a result, raising this exception (with a sensible description of the error) is the preferred way to indicate that something has gone wrong in the execution of a command. � )� returncodec s || _ t� j|i |�� d S �N)r �super�__init__)�selfr �args�kwargs�� __class__� �N/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/base.pyr " s zCommandError.__init__)�__name__� __module__� __qualname__�__doc__r � __classcell__r r r r r s r c @ s e Zd ZdZdS )�SystemCheckErrorzC The system check framework detected unrecoverable errors. N)r r r r r r r r r ' s r c sN e Zd ZdZddd�� fdd� Zd � fdd� Z� fdd �Z� fd d �Z� ZS ) � CommandParserz� Customized ArgumentParser class to improve some error messages and prevent SystemExit in several occasions, as SystemExit is unacceptable when a command is called programmatically. N)�missing_args_message�called_from_command_linec s" || _ || _t� jdi |�� d S )Nr )r! r" r r )r r! r" r r r r r 6 s zCommandParser.__init__c s6 | j r|stdd� |D ��s| �| j � t� �||�S )Nc s s � | ] }|� d � V qdS )�-N)� startswith)�.0�argr r r � <genexpr>@ s � z+CommandParser.parse_args.<locals>.<genexpr>)r! �any�errorr � parse_args)r r � namespacer r r r* = s �� zCommandParser.parse_argsc s" | j r t� �|� d S td| ��)Nz Error: %s)r" r r) r )r �messager r r r) E s zCommandParser.errorc s> |� dt| ��}t|t�rt|| jd�|d< t� jdi |��S )N� parser_class)r" r )�get�type� issubclassr r r" r �add_subparsers)r r r- r r r r1 K s �z CommandParser.add_subparsers)NN) r r r r r r* r) r1 r r r r r r / s � r c C s0 | j r | j tjd< | jrtj�d| j� dS dS )z� Include any default options that all commands should accept here so that ManagementUtility can handle them before searching for user commands. �DJANGO_SETTINGS_MODULEr N)�settings�os�environ� pythonpath�sys�path�insert)�optionsr r r �handle_default_optionsU s �r; c s � fdd�}|S )zEDecorator that forces a command to run with translations deactivated.c sZ ddl m} |�� }|�� z� | i |��}W |d ur |�|� |S |d ur,|�|� w w )Nr )� translation)� django.utilsr< � get_language�deactivate_all�activate)r r r< � saved_locale�res�� handle_funcr r �wrapperd s � �z no_translations.<locals>.wrapperr )rD rE r rC r �no_translationsa s rF c s< e Zd ZdZh d�Zdd� Z� fdd�Z� fdd�Z� ZS ) �DjangoHelpFormatterz� Customized formatter so that command-specific arguments appear in the --help output before arguments common to all commands. > � --version� --no-color� --settings� --traceback� --verbosity� --pythonpath� --force-color� --skip-checksc s t |� fdd�d�S )Nc s t | j�� j@ t � kS r )�set�option_strings� show_last)�a�r r r �<lambda>� � z8DjangoHelpFormatter._reordered_actions.<locals>.<lambda>)�key)�sorted�r �actionsr rT r �_reordered_actions� s �z&DjangoHelpFormatter._reordered_actionsc s& t � j|| �|�g|�R i |�� d S r )r � add_usager[ )r �usagerZ r r r r r r\ � s &z DjangoHelpFormatter.add_usagec s t � �| �|�� d S r )r � add_argumentsr[ rY r r r r^ � � z!DjangoHelpFormatter.add_arguments) r r r r rR r[ r\ r^ r r r r r rG s s rG c @ sV e Zd ZdZedd� �Zejdd� �Zddd�Zdd � Zd d � Z d d � Z ddd�Z dS )� OutputWrapperz& Wrapper around stdout/stderr c C s | j S r )� _style_funcrT r r r � style_func� s zOutputWrapper.style_funcc C s$ |r | � � r || _d S dd� | _d S )Nc S � | S r r ��xr r r rU � � z*OutputWrapper.style_func.<locals>.<lambda>)�isattyra )r rb r r r rb � s � c C s || _ d | _|| _d S r )�_outrb �ending)r �outrj r r r r � s zOutputWrapper.__init__c C s t | j|�S r )�getattrri )r �namer r r � __getattr__� s zOutputWrapper.__getattr__c C s t | jd�r | j�� d S d S )N�flush)�hasattrri ro rT r r r ro � s �zOutputWrapper.flushc C s t | jd�o | j�� S )Nrg )rp ri rg rT r r r rg � r_ zOutputWrapper.isatty� Nc C sF |d u r| j n|}|r|�|�s||7 }|p| j}| j�||�� d S r )rj �endswithrb ri �write)r �msgrb rj r r r rs � s zOutputWrapper.write)rh )rq NN) r r r r �propertyrb �setterr rn ro rg rs r r r r r` � s r` c @ s� e Zd ZdZdZdZdZdZdZdZ dZ e � Z d dd �Z d d � Zd d � Zdd� Zdd� Zdd� Zdd� Zdd� Zddddejdfdd�Zdd� Zd d � ZdS ) � BaseCommanda The base class from which all management commands ultimately derive. Use this class if you want access to all of the mechanisms which parse the command-line arguments and work out what code to call in response; if you don't need to change any of that behavior, consider using one of the subclasses defined in this file. If you are interested in overriding/customizing various aspects of the command-parsing and -execution behavior, the normal flow works as follows: 1. ``django-admin`` or ``manage.py`` loads the command class and calls its ``run_from_argv()`` method. 2. The ``run_from_argv()`` method calls ``create_parser()`` to get an ``ArgumentParser`` for the arguments, parses them, performs any environment changes requested by options like ``pythonpath``, and then calls the ``execute()`` method, passing the parsed arguments. 3. The ``execute()`` method attempts to carry out the command by calling the ``handle()`` method with the parsed arguments; any output produced by ``handle()`` will be printed to standard output and, if the command is intended to produce a block of SQL statements, will be wrapped in ``BEGIN`` and ``COMMIT``. 4. If ``handle()`` or ``execute()`` raised any exception (e.g. ``CommandError``), ``run_from_argv()`` will instead print an error message to ``stderr``. Thus, the ``handle()`` method is typically the starting point for subclasses; many built-in commands and command types either place all of their logic in ``handle()``, or perform some additional parsing work in ``handle()`` and then delegate from it to more specialized methods as needed. Several attributes affect behavior at various steps along the way: ``help`` A short description of the command, which will be printed in help messages. ``output_transaction`` A boolean indicating whether the command outputs SQL statements; if ``True``, the output will automatically be wrapped with ``BEGIN;`` and ``COMMIT;``. Default value is ``False``. ``requires_migrations_checks`` A boolean; if ``True``, the command prints a warning if the set of migrations on disk don't match the migrations in the database. ``requires_system_checks`` A list or tuple of tags, e.g. [Tags.staticfiles, Tags.models]. System checks registered in the chosen tags will be checked for errors prior to executing the command. The value '__all__' can be used to specify that all system checks should be performed. Default value is '__all__'. To validate an individual application's models rather than all applications' models, call ``self.check(app_configs)`` from ``handle()``, where ``app_configs`` is the list of application's configuration provided by the app registry. ``stealth_options`` A tuple of any options the command uses which aren't defined by the argument parser. rq Fr )�stderr�stdoutr Nc C s~ t |ptj�| _t |p tj�| _|r|rtd��|r t� | _n t|�| _| jj| j_ t | j t t f�s;| j tkr=td��d S d S )Nz4'no_color' and 'force_color' can't be used together.z/requires_system_checks must be a list or tuple.)r` r7 ry rx r r �styler �ERRORrb � isinstance�requires_system_checks�list�tuple� ALL_CHECKS� TypeError)r ry rx �no_color� force_colorr r r r s � �zBaseCommand.__init__c C s t �� S )z� Return the Django version, which should be correct for all built-in Django commands. User-supplied commands can override this method to return their own version. )�django� get_versionrT r r r r� s zBaseCommand.get_versionc K s� |� dt� td dtj�|�|f | jpdt| dd�t| dd�d�|��}| j|dd| � � d d � | j|d d d t g d�dd� | j|ddd� | j|ddd� | j|dddd� | j|dddd� | j|d dd d� | j ru|j d dd d� | � |� |S )!z} Create and return the ``ArgumentParser`` which will be used to parse the arguments to this command. �formatter_classz%s %sNr! �_called_from_command_line)�prog� descriptionr! r" rH �versionz'Show program's version number and exit.)�actionr� �helpz-vrL r )r r � � z[Verbosity level; 0=minimal output, 1=normal output, 2=verbose output, 3=very verbose output)�defaultr/ �choicesr� rJ z�The Python path to a settings module, e.g. "myproject.settings.main". If this isn't provided, the DJANGO_SETTINGS_MODULE environment variable will be used.)r� rM zMA directory to add to the Python path, e.g. "/home/djangoprojects/myproject".rK � store_truez!Raise on CommandError exceptions.)r� r� rI z"Don't colorize the command output.rN z)Force colorization of the command output.rO zSkip system checks.r )� setdefaultrG r r4 r8 �basenamer� rl �add_base_argumentr� �intr} � add_argumentr^ )r � prog_name� subcommandr �parserr r r � create_parser& sz ���� � ����� zBaseCommand.create_parserc C s dS )zN Entry point for subclassed commands to add custom arguments. Nr �r r� r r r r^ r s zBaseCommand.add_argumentsc O s6 |D ]}|| j v rtj|d< nq|j|i |�� dS )z� Call the parser's add_argument() method, suppressing the help text according to BaseCommand.suppressed_base_arguments. r� N)�suppressed_base_arguments�argparse�SUPPRESSr� )r r� r r r& r r r r� x s �z BaseCommand.add_base_argumentc C s | � ||�}|�� dS )za Print the help message for this command, derived from ``self.usage()``. N)r� � print_help)r r� r� r� r r r r� � s zBaseCommand.print_helpc C s d| _ | �|d |d �}|�|dd� �}t|�}|�dd�}t|� zWz | j|i |�� W n9 tyh } z-|jr;� t |t �rL| j � t |�dd � � n | j � d |jj|f � t�|j� W Y d}~nd}~ww W zt�� W dS ty{ Y dS w zt�� W w ty� Y w w ) aZ Set up any environment changes requested (e.g., Python path and Django settings), then run this command. If the command raises a ``CommandError``, intercept it and print it sensibly to stderr. If the ``--traceback`` option is present or the raised ``Exception`` is not ``CommandError``, raise it. Tr r r� Nr r c S rc r r rd r r r rU � rf z+BaseCommand.run_from_argv.<locals>.<lambda>z%s: %s)r� r� r* �vars�popr; �executer � tracebackr| r rx rs �strr r r7 �exitr r � close_allr )r �argvr� r: � cmd_optionsr �er r r � run_from_argv� s8 ��� �� �zBaseCommand.run_from_argvc O s |d r |d r t d��|d rtdd�| _n |d r#t� | _d| j_|�d�r/t|d �| _|�d�r;t|d �| _| j rS|d sS| j t krL| � � n| j | j d � | j rZ| � � | j|i |��}|r�| jr�t|�d t� }d | j�|j�� �|| j�|j�� �f }| j�|� |S ) z� Try to execute this command, performing system checks if needed (as controlled by the ``requires_system_checks`` attribute, except if force-skipped). r� r� z@The --no-color and --force-color options can't be used together.T)r� Nry rx � skip_checks)�tags�databasez%s %s %s)r r rz r rx rb r. r` ry r} r� �check�requires_migrations_checks�check_migrations�handle�output_transactionr r � SQL_KEYWORD�ops�start_transaction_sql�end_transaction_sqlrs )r r r: �output� connectionr r r r� � s< � � zBaseCommand.executec s� t j||||d�}d\}} } d} |rmdd� |D �} dd� |D �} dd� |D �}dd� |D �}d d� |D �}|d f|d f|d f| d f| dfg}|D ]$\}}|rl| t|�7 } �fdd�|D �}d�t|��}| d||f 7 } qH| rqd}|r�| ry| d7 } | d| dkr�dn | dkr�dnd| t|�| f 7 } t� fdd�|D ��r��j�d| �| | }t|��|| | }|r�| rÈj � |dd � � d S �j � |� d S d S ) a Use the system check framework to validate entire Django project. Raise CommandError for any serious message (error or critical errors). If there are only light messages (like warnings), print them to stderr and don't raise an exception. )� app_configsr� �include_deployment_checks� databases)rq rq rq r c S s$ g | ]}|j tjk r|�� s|�qS r )�levelr �INFO� is_silenced�r% r� r r r � <listcomp>� s z%BaseCommand.check.<locals>.<listcomp>c S �6 g | ]}t j|j krt jk rn n|�� s|�qS r )r r� r� �WARNINGr� r� r r r r� � � &�c S r� r )r r� r� r{ r� r� r r r r� � r� c S r� r )r r{ r� �CRITICALr� r� r r r r� � r� c S s$ g | ]}t j|jkr|�� s|�qS r )r r� r� r� r� r r r r� s �� CRITICALS�ERRORS�WARNINGS�INFOS�DEBUGSc 3 s8 � | ]}|� � r� j�t|��n� j�t|��V qd S r )� is_seriousrz r{ r� r� r� rT r r r' s � �� �z$BaseCommand.check.<locals>.<genexpr>rh z %s: %s z%System check identified some issues: z)System check identified %s (%s silenced).z no issuesr z1 issuez %s issuesc 3 s$ � | ] }|� � �o |�� V qd S r )r� r� r� )� fail_levelr r r' * s �" zSystemCheckError: %sc S rc r r rd r r r rU 2 rf z#BaseCommand.check.<locals>.<lambda>N) r � run_checks�len�joinrX r( rz r{ r rx rs ry )r r� r� �display_num_errorsr� r� r� � all_issues�header�body�footer�visible_issue_count�debugs�infos�warnings�errors� criticals� sorted_issues�issues� group_name� formattedrt r )r� r r r� � sz � ������ ���� � �zBaseCommand.checkc C s� ddl m} z|tt �}W n ty Y dS w |�|jj�� �}|rMt dd� |D ��}| j � | j � dt|�d�|�d� �� | j � | j � d �� dS dS ) zv Print a warning if the set of migrations on disk don't match the migrations in the database. r )�MigrationExecutorNc S s h | ]\}}|j �qS r )� app_label)r% � migration� backwardsr r r � <setcomp>F rV z/BaseCommand.check_migrations.<locals>.<setcomp>z� You have %(unapplied_migration_count)s unapplied migration(s). Your project may not work properly until you apply the migrations for app(s): %(apps_waiting_migration)s.z, )�unapplied_migration_count�apps_waiting_migrationz-Run 'python manage.py migrate' to apply them.)� django.db.migrations.executorr� r r r �migration_plan�loader�graph� leaf_nodesrX ry rs rz �NOTICEr� r� )r r� �executor�planr� r r r r� 6 s0 � ����� ��z BaseCommand.check_migrationsc O � t d��)za The actual logic of the command. Subclasses must implement this method. z8subclasses of BaseCommand must provide a handle() method��NotImplementedError)r r r: r r r r� W � �zBaseCommand.handle)NNFF)r r r r r� r� r� r� r} �base_stealth_options�stealth_optionsrP r� r r� r� r^ r� r� r� r� r r{ r� r� r� r r r r rw � s6 H L $) �` !rw c @ s, e Zd ZdZdZdd� Zdd� Zdd� Zd S ) � AppCommanda A management command which takes one or more installed application labels as arguments, and does something with each of them. Rather than implementing ``handle()``, subclasses must implement ``handle_app_config()``, which will be called once for each application. z%Enter at least one application label.c C s |j ddddd� d S )Nr r� �+z One or more application label.)�metavar�nargsr� )r� r� r r r r^ l s �zAppCommand.add_argumentsc s� ddl m� z � fdd�|D �}W n ttfy% } ztd| ��d }~ww g }|D ]}| j|fi |��}|r<|�|� q*d�|�S )Nr ��appsc s g | ]}� � |��qS r )�get_app_config)r% r� r� r r r� x rV z%AppCommand.handle.<locals>.<listcomp>z8%s. Are you sure your INSTALLED_APPS setting is correct?rh )� django.appsr� � LookupError� ImportErrorr �handle_app_config�appendr� )r � app_labelsr: r� r� r� � app_config� app_outputr r� r r� t s ��� � zAppCommand.handlec K r� )z� Perform the command's actions for app_config, an AppConfig instance corresponding to an application label given on the command line. zCSubclasses of AppCommand must provide a handle_app_config() method.r� )r r r: r r r r� � r� z AppCommand.handle_app_configN)r r r r r! r^ r� r� r r r r r� a s r� c @ s4 e Zd ZdZdZde Zdd� Zdd� Zdd � Zd S ) � LabelCommanda A management command which takes one or more arbitrary arguments (labels) on the command line, and does something with each of them. Rather than implementing ``handle()``, subclasses must implement ``handle_label()``, which will be called once for each label. If the arguments should be names of installed applications, use ``AppCommand`` instead. �labelzEnter at least one %s.c C s |j d| jdd� d S )Nr r� )r� r� )r� r r� r r r r^ � r_ zLabelCommand.add_argumentsc O s8 g }|D ]}| j |fi |��}|r|�|� qd�|�S )Nrh )� handle_labelr� r� )r �labelsr: r� r � label_outputr r r r� � s � zLabelCommand.handlec K r� )z} Perform the command's actions for ``label``, which will be the string as given on the command line. z?subclasses of LabelCommand must provide a handle_label() methodr� )r r r: r r r r � r� zLabelCommand.handle_labelN) r r r r r r! r^ r� r r r r r r � s r )!r r� r4 r7 r r � functoolsr �ior r� � django.corer �django.core.exceptionsr � django.core.management.colorr r � django.dbr r r� � Exceptionr r r r; rF rG r` rw r� r r r r r �<module> s4 & ' -- sql.py 0000644 00000003473 15030001101 0005701 0 ustar 00 import sys from django.apps import apps from django.db import models def sql_flush(style, connection, reset_sequences=True, allow_cascade=False): """ Return a list of the SQL statements used to flush the database. """ tables = connection.introspection.django_table_names( only_existing=True, include_views=False ) return connection.ops.sql_flush( style, tables, reset_sequences=reset_sequences, allow_cascade=allow_cascade, ) def emit_pre_migrate_signal(verbosity, interactive, db, **kwargs): # Emit the pre_migrate signal for every application. for app_config in apps.get_app_configs(): if app_config.models_module is None: continue if verbosity >= 2: stdout = kwargs.get("stdout", sys.stdout) stdout.write( "Running pre-migrate handlers for application %s" % app_config.label ) models.signals.pre_migrate.send( sender=app_config, app_config=app_config, verbosity=verbosity, interactive=interactive, using=db, **kwargs, ) def emit_post_migrate_signal(verbosity, interactive, db, **kwargs): # Emit the post_migrate signal for every application. for app_config in apps.get_app_configs(): if app_config.models_module is None: continue if verbosity >= 2: stdout = kwargs.get("stdout", sys.stdout) stdout.write( "Running post-migrate handlers for application %s" % app_config.label ) models.signals.post_migrate.send( sender=app_config, app_config=app_config, verbosity=verbosity, interactive=interactive, using=db, **kwargs, ) commands/dumpdata.py 0000644 00000025320 15030001101 0010475 0 ustar 00 import gzip import os import warnings from django.apps import apps from django.core import serializers from django.core.management.base import BaseCommand, CommandError from django.core.management.utils import parse_apps_and_model_labels from django.db import DEFAULT_DB_ALIAS, router try: import bz2 has_bz2 = True except ImportError: has_bz2 = False try: import lzma has_lzma = True except ImportError: has_lzma = False class ProxyModelWarning(Warning): pass class Command(BaseCommand): help = ( "Output the contents of the database as a fixture of the given format " "(using each model's default manager unless --all is specified)." ) def add_arguments(self, parser): parser.add_argument( "args", metavar="app_label[.ModelName]", nargs="*", help=( "Restricts dumped data to the specified app_label or " "app_label.ModelName." ), ) parser.add_argument( "--format", default="json", help="Specifies the output serialization format for fixtures.", ) parser.add_argument( "--indent", type=int, help="Specifies the indent level to use when pretty-printing output.", ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help="Nominates a specific database to dump fixtures from. " 'Defaults to the "default" database.', ) parser.add_argument( "-e", "--exclude", action="append", default=[], help="An app_label or app_label.ModelName to exclude " "(use multiple --exclude to exclude multiple apps/models).", ) parser.add_argument( "--natural-foreign", action="store_true", dest="use_natural_foreign_keys", help="Use natural foreign keys if they are available.", ) parser.add_argument( "--natural-primary", action="store_true", dest="use_natural_primary_keys", help="Use natural primary keys if they are available.", ) parser.add_argument( "-a", "--all", action="store_true", dest="use_base_manager", help=( "Use Django's base manager to dump all models stored in the database, " "including those that would otherwise be filtered or modified by a " "custom manager." ), ) parser.add_argument( "--pks", dest="primary_keys", help="Only dump objects with given primary keys. Accepts a comma-separated " "list of keys. This option only works when you specify one model.", ) parser.add_argument( "-o", "--output", help="Specifies file to which the output is written." ) def handle(self, *app_labels, **options): format = options["format"] indent = options["indent"] using = options["database"] excludes = options["exclude"] output = options["output"] show_traceback = options["traceback"] use_natural_foreign_keys = options["use_natural_foreign_keys"] use_natural_primary_keys = options["use_natural_primary_keys"] use_base_manager = options["use_base_manager"] pks = options["primary_keys"] if pks: primary_keys = [pk.strip() for pk in pks.split(",")] else: primary_keys = [] excluded_models, excluded_apps = parse_apps_and_model_labels(excludes) if not app_labels: if primary_keys: raise CommandError("You can only use --pks option with one model") app_list = dict.fromkeys( app_config for app_config in apps.get_app_configs() if app_config.models_module is not None and app_config not in excluded_apps ) else: if len(app_labels) > 1 and primary_keys: raise CommandError("You can only use --pks option with one model") app_list = {} for label in app_labels: try: app_label, model_label = label.split(".") try: app_config = apps.get_app_config(app_label) except LookupError as e: raise CommandError(str(e)) if app_config.models_module is None or app_config in excluded_apps: continue try: model = app_config.get_model(model_label) except LookupError: raise CommandError( "Unknown model: %s.%s" % (app_label, model_label) ) app_list_value = app_list.setdefault(app_config, []) # We may have previously seen an "all-models" request for # this app (no model qualifier was given). In this case # there is no need adding specific models to the list. if app_list_value is not None and model not in app_list_value: app_list_value.append(model) except ValueError: if primary_keys: raise CommandError( "You can only use --pks option with one model" ) # This is just an app - no model qualifier app_label = label try: app_config = apps.get_app_config(app_label) except LookupError as e: raise CommandError(str(e)) if app_config.models_module is None or app_config in excluded_apps: continue app_list[app_config] = None # Check that the serialization format exists; this is a shortcut to # avoid collating all the objects and _then_ failing. if format not in serializers.get_public_serializer_formats(): try: serializers.get_serializer(format) except serializers.SerializerDoesNotExist: pass raise CommandError("Unknown serialization format: %s" % format) def get_objects(count_only=False): """ Collate the objects to be serialized. If count_only is True, just count the number of objects to be serialized. """ if use_natural_foreign_keys: models = serializers.sort_dependencies( app_list.items(), allow_cycles=True ) else: # There is no need to sort dependencies when natural foreign # keys are not used. models = [] for app_config, model_list in app_list.items(): if model_list is None: models.extend(app_config.get_models()) else: models.extend(model_list) for model in models: if model in excluded_models: continue if model._meta.proxy and model._meta.proxy_for_model not in models: warnings.warn( "%s is a proxy model and won't be serialized." % model._meta.label, category=ProxyModelWarning, ) if not model._meta.proxy and router.allow_migrate_model(using, model): if use_base_manager: objects = model._base_manager else: objects = model._default_manager queryset = objects.using(using).order_by(model._meta.pk.name) if primary_keys: queryset = queryset.filter(pk__in=primary_keys) if count_only: yield queryset.order_by().count() else: yield from queryset.iterator() try: self.stdout.ending = None progress_output = None object_count = 0 # If dumpdata is outputting to stdout, there is no way to display progress if output and self.stdout.isatty() and options["verbosity"] > 0: progress_output = self.stdout object_count = sum(get_objects(count_only=True)) if output: file_root, file_ext = os.path.splitext(output) compression_formats = { ".bz2": (open, {}, file_root), ".gz": (gzip.open, {}, output), ".lzma": (open, {}, file_root), ".xz": (open, {}, file_root), ".zip": (open, {}, file_root), } if has_bz2: compression_formats[".bz2"] = (bz2.open, {}, output) if has_lzma: compression_formats[".lzma"] = ( lzma.open, {"format": lzma.FORMAT_ALONE}, output, ) compression_formats[".xz"] = (lzma.open, {}, output) try: open_method, kwargs, file_path = compression_formats[file_ext] except KeyError: open_method, kwargs, file_path = (open, {}, output) if file_path != output: file_name = os.path.basename(file_path) warnings.warn( f"Unsupported file extension ({file_ext}). " f"Fixtures saved in '{file_name}'.", RuntimeWarning, ) stream = open_method(file_path, "wt", **kwargs) else: stream = None try: serializers.serialize( format, get_objects(), indent=indent, use_natural_foreign_keys=use_natural_foreign_keys, use_natural_primary_keys=use_natural_primary_keys, stream=stream or self.stdout, progress_output=progress_output, object_count=object_count, ) finally: if stream: stream.close() except Exception as e: if show_traceback: raise raise CommandError("Unable to serialize database: %s" % e) commands/createcachetable.py 0000644 00000011010 15030001101 0012124 0 ustar 00 from django.conf import settings from django.core.cache import caches from django.core.cache.backends.db import BaseDatabaseCache from django.core.management.base import BaseCommand, CommandError from django.db import ( DEFAULT_DB_ALIAS, DatabaseError, connections, models, router, transaction, ) class Command(BaseCommand): help = "Creates the tables needed to use the SQL cache backend." requires_system_checks = [] def add_arguments(self, parser): parser.add_argument( "args", metavar="table_name", nargs="*", help=( "Optional table names. Otherwise, settings.CACHES is used to find " "cache tables." ), ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help="Nominates a database onto which the cache tables will be " 'installed. Defaults to the "default" database.', ) parser.add_argument( "--dry-run", action="store_true", help="Does not create the table, just prints the SQL that would be run.", ) def handle(self, *tablenames, **options): db = options["database"] self.verbosity = options["verbosity"] dry_run = options["dry_run"] if tablenames: # Legacy behavior, tablename specified as argument for tablename in tablenames: self.create_table(db, tablename, dry_run) else: for cache_alias in settings.CACHES: cache = caches[cache_alias] if isinstance(cache, BaseDatabaseCache): self.create_table(db, cache._table, dry_run) def create_table(self, database, tablename, dry_run): cache = BaseDatabaseCache(tablename, {}) if not router.allow_migrate_model(database, cache.cache_model_class): return connection = connections[database] if tablename in connection.introspection.table_names(): if self.verbosity > 0: self.stdout.write("Cache table '%s' already exists." % tablename) return fields = ( # "key" is a reserved word in MySQL, so use "cache_key" instead. models.CharField( name="cache_key", max_length=255, unique=True, primary_key=True ), models.TextField(name="value"), models.DateTimeField(name="expires", db_index=True), ) table_output = [] index_output = [] qn = connection.ops.quote_name for f in fields: field_output = [ qn(f.name), f.db_type(connection=connection), "%sNULL" % ("NOT " if not f.null else ""), ] if f.primary_key: field_output.append("PRIMARY KEY") elif f.unique: field_output.append("UNIQUE") if f.db_index: unique = "UNIQUE " if f.unique else "" index_output.append( "CREATE %sINDEX %s ON %s (%s);" % ( unique, qn("%s_%s" % (tablename, f.name)), qn(tablename), qn(f.name), ) ) table_output.append(" ".join(field_output)) full_statement = ["CREATE TABLE %s (" % qn(tablename)] for i, line in enumerate(table_output): full_statement.append( " %s%s" % (line, "," if i < len(table_output) - 1 else "") ) full_statement.append(");") full_statement = "\n".join(full_statement) if dry_run: self.stdout.write(full_statement) for statement in index_output: self.stdout.write(statement) return with transaction.atomic( using=database, savepoint=connection.features.can_rollback_ddl ): with connection.cursor() as curs: try: curs.execute(full_statement) except DatabaseError as e: raise CommandError( "Cache table '%s' could not be created.\nThe error was: %s." % (tablename, e) ) for statement in index_output: curs.execute(statement) if self.verbosity > 1: self.stdout.write("Cache table '%s' created." % tablename) commands/testserver.py 0000644 00000004305 15030001101 0011104 0 ustar 00 from django.core.management import call_command from django.core.management.base import BaseCommand from django.db import connection class Command(BaseCommand): help = "Runs a development server with data from the given fixture(s)." requires_system_checks = [] def add_arguments(self, parser): parser.add_argument( "args", metavar="fixture", nargs="*", help="Path(s) to fixtures to load before running the server.", ) parser.add_argument( "--noinput", "--no-input", action="store_false", dest="interactive", help="Tells Django to NOT prompt the user for input of any kind.", ) parser.add_argument( "--addrport", default="", help="Port number or ipaddr:port to run the server on.", ) parser.add_argument( "--ipv6", "-6", action="store_true", dest="use_ipv6", help="Tells Django to use an IPv6 address.", ) def handle(self, *fixture_labels, **options): verbosity = options["verbosity"] interactive = options["interactive"] # Create a test database. db_name = connection.creation.create_test_db( verbosity=verbosity, autoclobber=not interactive, serialize=False ) # Import the fixture data into the test database. call_command("loaddata", *fixture_labels, **{"verbosity": verbosity}) # Run the development server. Turn off auto-reloading because it causes # a strange error -- it causes this handle() method to be called # multiple times. shutdown_message = ( "\nServer stopped.\nNote that the test database, %r, has not been " "deleted. You can explore it on your own." % db_name ) use_threading = connection.features.test_db_allows_multiple_connections call_command( "runserver", addrport=options["addrport"], shutdown_message=shutdown_message, use_reloader=False, use_ipv6=options["use_ipv6"], use_threading=use_threading, ) commands/test.py 0000644 00000004772 15030001101 0007665 0 ustar 00 import sys from django.conf import settings from django.core.management.base import BaseCommand from django.core.management.utils import get_command_line_option from django.test.runner import get_max_test_processes from django.test.utils import NullTimeKeeper, TimeKeeper, get_runner class Command(BaseCommand): help = "Discover and run tests in the specified modules or the current directory." # DiscoverRunner runs the checks after databases are set up. requires_system_checks = [] test_runner = None def run_from_argv(self, argv): """ Pre-parse the command line to extract the value of the --testrunner option. This allows a test runner to define additional command line arguments. """ self.test_runner = get_command_line_option(argv, "--testrunner") super().run_from_argv(argv) def add_arguments(self, parser): parser.add_argument( "args", metavar="test_label", nargs="*", help=( "Module paths to test; can be modulename, modulename.TestCase or " "modulename.TestCase.test_method" ), ) parser.add_argument( "--noinput", "--no-input", action="store_false", dest="interactive", help="Tells Django to NOT prompt the user for input of any kind.", ) parser.add_argument( "--failfast", action="store_true", help="Tells Django to stop running the test suite after first failed test.", ) parser.add_argument( "--testrunner", help="Tells Django to use specified test runner class instead of " "the one specified by the TEST_RUNNER setting.", ) test_runner_class = get_runner(settings, self.test_runner) if hasattr(test_runner_class, "add_arguments"): test_runner_class.add_arguments(parser) def handle(self, *test_labels, **options): TestRunner = get_runner(settings, options["testrunner"]) time_keeper = TimeKeeper() if options.get("timing", False) else NullTimeKeeper() parallel = options.get("parallel") if parallel == "auto": options["parallel"] = get_max_test_processes() test_runner = TestRunner(**options) with time_keeper.timed("Total run"): failures = test_runner.run_tests(test_labels) time_keeper.print_results() if failures: sys.exit(1) commands/diffsettings.py 0000644 00000006742 15030001101 0011376 0 ustar 00 from django.core.management.base import BaseCommand def module_to_dict(module, omittable=lambda k: k.startswith("_") or not k.isupper()): """Convert a module namespace to a Python dictionary.""" return {k: repr(getattr(module, k)) for k in dir(module) if not omittable(k)} class Command(BaseCommand): help = """Displays differences between the current settings.py and Django's default settings.""" requires_system_checks = [] def add_arguments(self, parser): parser.add_argument( "--all", action="store_true", help=( 'Display all settings, regardless of their value. In "hash" ' 'mode, default values are prefixed by "###".' ), ) parser.add_argument( "--default", metavar="MODULE", help=( "The settings module to compare the current settings against. Leave " "empty to compare against Django's default settings." ), ) parser.add_argument( "--output", default="hash", choices=("hash", "unified"), help=( "Selects the output format. 'hash' mode displays each changed " "setting, with the settings that don't appear in the defaults " "followed by ###. 'unified' mode prefixes the default setting " "with a minus sign, followed by the changed setting prefixed " "with a plus sign." ), ) def handle(self, **options): from django.conf import Settings, global_settings, settings # Because settings are imported lazily, we need to explicitly load them. if not settings.configured: settings._setup() user_settings = module_to_dict(settings._wrapped) default = options["default"] default_settings = module_to_dict( Settings(default) if default else global_settings ) output_func = { "hash": self.output_hash, "unified": self.output_unified, }[options["output"]] return "\n".join(output_func(user_settings, default_settings, **options)) def output_hash(self, user_settings, default_settings, **options): # Inspired by Postfix's "postconf -n". output = [] for key in sorted(user_settings): if key not in default_settings: output.append("%s = %s ###" % (key, user_settings[key])) elif user_settings[key] != default_settings[key]: output.append("%s = %s" % (key, user_settings[key])) elif options["all"]: output.append("### %s = %s" % (key, user_settings[key])) return output def output_unified(self, user_settings, default_settings, **options): output = [] for key in sorted(user_settings): if key not in default_settings: output.append( self.style.SUCCESS("+ %s = %s" % (key, user_settings[key])) ) elif user_settings[key] != default_settings[key]: output.append( self.style.ERROR("- %s = %s" % (key, default_settings[key])) ) output.append( self.style.SUCCESS("+ %s = %s" % (key, user_settings[key])) ) elif options["all"]: output.append(" %s = %s" % (key, user_settings[key])) return output commands/migrate.py 0000644 00000051631 15030001101 0010332 0 ustar 00 import sys import time from importlib import import_module from django.apps import apps from django.core.management.base import BaseCommand, CommandError, no_translations from django.core.management.sql import emit_post_migrate_signal, emit_pre_migrate_signal from django.db import DEFAULT_DB_ALIAS, connections, router from django.db.migrations.autodetector import MigrationAutodetector from django.db.migrations.executor import MigrationExecutor from django.db.migrations.loader import AmbiguityError from django.db.migrations.state import ModelState, ProjectState from django.utils.module_loading import module_has_submodule from django.utils.text import Truncator class Command(BaseCommand): help = ( "Updates database schema. Manages both apps with migrations and those without." ) requires_system_checks = [] def add_arguments(self, parser): parser.add_argument( "--skip-checks", action="store_true", help="Skip system checks.", ) parser.add_argument( "app_label", nargs="?", help="App label of an application to synchronize the state.", ) parser.add_argument( "migration_name", nargs="?", help="Database state will be brought to the state after that " 'migration. Use the name "zero" to unapply all migrations.', ) parser.add_argument( "--noinput", "--no-input", action="store_false", dest="interactive", help="Tells Django to NOT prompt the user for input of any kind.", ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( 'Nominates a database to synchronize. Defaults to the "default" ' "database." ), ) parser.add_argument( "--fake", action="store_true", help="Mark migrations as run without actually running them.", ) parser.add_argument( "--fake-initial", action="store_true", help=( "Detect if tables already exist and fake-apply initial migrations if " "so. Make sure that the current database schema matches your initial " "migration before using this flag. Django will only check for an " "existing table name." ), ) parser.add_argument( "--plan", action="store_true", help="Shows a list of the migration actions that will be performed.", ) parser.add_argument( "--run-syncdb", action="store_true", help="Creates tables for apps without migrations.", ) parser.add_argument( "--check", action="store_true", dest="check_unapplied", help=( "Exits with a non-zero status if unapplied migrations exist and does " "not actually apply migrations." ), ) parser.add_argument( "--prune", action="store_true", dest="prune", help="Delete nonexistent migrations from the django_migrations table.", ) @no_translations def handle(self, *args, **options): database = options["database"] if not options["skip_checks"]: self.check(databases=[database]) self.verbosity = options["verbosity"] self.interactive = options["interactive"] # Import the 'management' module within each installed app, to register # dispatcher events. for app_config in apps.get_app_configs(): if module_has_submodule(app_config.module, "management"): import_module(".management", app_config.name) # Get the database we're operating from connection = connections[database] # Hook for backends needing any database preparation connection.prepare_database() # Work out which apps have migrations and which do not executor = MigrationExecutor(connection, self.migration_progress_callback) # Raise an error if any migrations are applied before their dependencies. executor.loader.check_consistent_history(connection) # Before anything else, see if there's conflicting apps and drop out # hard if there are any conflicts = executor.loader.detect_conflicts() if conflicts: name_str = "; ".join( "%s in %s" % (", ".join(names), app) for app, names in conflicts.items() ) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str ) # If they supplied command line arguments, work out what they mean. run_syncdb = options["run_syncdb"] target_app_labels_only = True if options["app_label"]: # Validate app_label. app_label = options["app_label"] try: apps.get_app_config(app_label) except LookupError as err: raise CommandError(str(err)) if run_syncdb: if app_label in executor.loader.migrated_apps: raise CommandError( "Can't use run_syncdb with app '%s' as it has migrations." % app_label ) elif app_label not in executor.loader.migrated_apps: raise CommandError("App '%s' does not have migrations." % app_label) if options["app_label"] and options["migration_name"]: migration_name = options["migration_name"] if migration_name == "zero": targets = [(app_label, None)] else: try: migration = executor.loader.get_migration_by_prefix( app_label, migration_name ) except AmbiguityError: raise CommandError( "More than one migration matches '%s' in app '%s'. " "Please be more specific." % (migration_name, app_label) ) except KeyError: raise CommandError( "Cannot find a migration matching '%s' from app '%s'." % (migration_name, app_label) ) target = (app_label, migration.name) # Partially applied squashed migrations are not included in the # graph, use the last replacement instead. if ( target not in executor.loader.graph.nodes and target in executor.loader.replacements ): incomplete_migration = executor.loader.replacements[target] target = incomplete_migration.replaces[-1] targets = [target] target_app_labels_only = False elif options["app_label"]: targets = [ key for key in executor.loader.graph.leaf_nodes() if key[0] == app_label ] else: targets = executor.loader.graph.leaf_nodes() if options["prune"]: if not options["app_label"]: raise CommandError( "Migrations can be pruned only when an app is specified." ) if self.verbosity > 0: self.stdout.write("Pruning migrations:", self.style.MIGRATE_HEADING) to_prune = set(executor.loader.applied_migrations) - set( executor.loader.disk_migrations ) squashed_migrations_with_deleted_replaced_migrations = [ migration_key for migration_key, migration_obj in executor.loader.replacements.items() if any(replaced in to_prune for replaced in migration_obj.replaces) ] if squashed_migrations_with_deleted_replaced_migrations: self.stdout.write( self.style.NOTICE( " Cannot use --prune because the following squashed " "migrations have their 'replaces' attributes and may not " "be recorded as applied:" ) ) for migration in squashed_migrations_with_deleted_replaced_migrations: app, name = migration self.stdout.write(f" {app}.{name}") self.stdout.write( self.style.NOTICE( " Re-run 'manage.py migrate' if they are not marked as " "applied, and remove 'replaces' attributes in their " "Migration classes." ) ) else: to_prune = sorted( migration for migration in to_prune if migration[0] == app_label ) if to_prune: for migration in to_prune: app, name = migration if self.verbosity > 0: self.stdout.write( self.style.MIGRATE_LABEL(f" Pruning {app}.{name}"), ending="", ) executor.recorder.record_unapplied(app, name) if self.verbosity > 0: self.stdout.write(self.style.SUCCESS(" OK")) elif self.verbosity > 0: self.stdout.write(" No migrations to prune.") plan = executor.migration_plan(targets) if options["plan"]: self.stdout.write("Planned operations:", self.style.MIGRATE_LABEL) if not plan: self.stdout.write(" No planned migration operations.") else: for migration, backwards in plan: self.stdout.write(str(migration), self.style.MIGRATE_HEADING) for operation in migration.operations: message, is_error = self.describe_operation( operation, backwards ) style = self.style.WARNING if is_error else None self.stdout.write(" " + message, style) if options["check_unapplied"]: sys.exit(1) return if options["check_unapplied"]: if plan: sys.exit(1) return if options["prune"]: return # At this point, ignore run_syncdb if there aren't any apps to sync. run_syncdb = options["run_syncdb"] and executor.loader.unmigrated_apps # Print some useful info if self.verbosity >= 1: self.stdout.write(self.style.MIGRATE_HEADING("Operations to perform:")) if run_syncdb: if options["app_label"]: self.stdout.write( self.style.MIGRATE_LABEL( " Synchronize unmigrated app: %s" % app_label ) ) else: self.stdout.write( self.style.MIGRATE_LABEL(" Synchronize unmigrated apps: ") + (", ".join(sorted(executor.loader.unmigrated_apps))) ) if target_app_labels_only: self.stdout.write( self.style.MIGRATE_LABEL(" Apply all migrations: ") + (", ".join(sorted({a for a, n in targets})) or "(none)") ) else: if targets[0][1] is None: self.stdout.write( self.style.MIGRATE_LABEL(" Unapply all migrations: ") + str(targets[0][0]) ) else: self.stdout.write( self.style.MIGRATE_LABEL(" Target specific migration: ") + "%s, from %s" % (targets[0][1], targets[0][0]) ) pre_migrate_state = executor._create_project_state(with_applied_migrations=True) pre_migrate_apps = pre_migrate_state.apps emit_pre_migrate_signal( self.verbosity, self.interactive, connection.alias, stdout=self.stdout, apps=pre_migrate_apps, plan=plan, ) # Run the syncdb phase. if run_syncdb: if self.verbosity >= 1: self.stdout.write( self.style.MIGRATE_HEADING("Synchronizing apps without migrations:") ) if options["app_label"]: self.sync_apps(connection, [app_label]) else: self.sync_apps(connection, executor.loader.unmigrated_apps) # Migrate! if self.verbosity >= 1: self.stdout.write(self.style.MIGRATE_HEADING("Running migrations:")) if not plan: if self.verbosity >= 1: self.stdout.write(" No migrations to apply.") # If there's changes that aren't in migrations yet, tell them # how to fix it. autodetector = MigrationAutodetector( executor.loader.project_state(), ProjectState.from_apps(apps), ) changes = autodetector.changes(graph=executor.loader.graph) if changes: self.stdout.write( self.style.NOTICE( " Your models in app(s): %s have changes that are not " "yet reflected in a migration, and so won't be " "applied." % ", ".join(repr(app) for app in sorted(changes)) ) ) self.stdout.write( self.style.NOTICE( " Run 'manage.py makemigrations' to make new " "migrations, and then re-run 'manage.py migrate' to " "apply them." ) ) fake = False fake_initial = False else: fake = options["fake"] fake_initial = options["fake_initial"] post_migrate_state = executor.migrate( targets, plan=plan, state=pre_migrate_state.clone(), fake=fake, fake_initial=fake_initial, ) # post_migrate signals have access to all models. Ensure that all models # are reloaded in case any are delayed. post_migrate_state.clear_delayed_apps_cache() post_migrate_apps = post_migrate_state.apps # Re-render models of real apps to include relationships now that # we've got a final state. This wouldn't be necessary if real apps # models were rendered with relationships in the first place. with post_migrate_apps.bulk_update(): model_keys = [] for model_state in post_migrate_apps.real_models: model_key = model_state.app_label, model_state.name_lower model_keys.append(model_key) post_migrate_apps.unregister_model(*model_key) post_migrate_apps.render_multiple( [ModelState.from_model(apps.get_model(*model)) for model in model_keys] ) # Send the post_migrate signal, so individual apps can do whatever they need # to do at this point. emit_post_migrate_signal( self.verbosity, self.interactive, connection.alias, stdout=self.stdout, apps=post_migrate_apps, plan=plan, ) def migration_progress_callback(self, action, migration=None, fake=False): if self.verbosity >= 1: compute_time = self.verbosity > 1 if action == "apply_start": if compute_time: self.start = time.monotonic() self.stdout.write(" Applying %s..." % migration, ending="") self.stdout.flush() elif action == "apply_success": elapsed = ( " (%.3fs)" % (time.monotonic() - self.start) if compute_time else "" ) if fake: self.stdout.write(self.style.SUCCESS(" FAKED" + elapsed)) else: self.stdout.write(self.style.SUCCESS(" OK" + elapsed)) elif action == "unapply_start": if compute_time: self.start = time.monotonic() self.stdout.write(" Unapplying %s..." % migration, ending="") self.stdout.flush() elif action == "unapply_success": elapsed = ( " (%.3fs)" % (time.monotonic() - self.start) if compute_time else "" ) if fake: self.stdout.write(self.style.SUCCESS(" FAKED" + elapsed)) else: self.stdout.write(self.style.SUCCESS(" OK" + elapsed)) elif action == "render_start": if compute_time: self.start = time.monotonic() self.stdout.write(" Rendering model states...", ending="") self.stdout.flush() elif action == "render_success": elapsed = ( " (%.3fs)" % (time.monotonic() - self.start) if compute_time else "" ) self.stdout.write(self.style.SUCCESS(" DONE" + elapsed)) def sync_apps(self, connection, app_labels): """Run the old syncdb-style operation on a list of app_labels.""" with connection.cursor() as cursor: tables = connection.introspection.table_names(cursor) # Build the manifest of apps and models that are to be synchronized. all_models = [ ( app_config.label, router.get_migratable_models( app_config, connection.alias, include_auto_created=False ), ) for app_config in apps.get_app_configs() if app_config.models_module is not None and app_config.label in app_labels ] def model_installed(model): opts = model._meta converter = connection.introspection.identifier_converter return not ( (converter(opts.db_table) in tables) or ( opts.auto_created and converter(opts.auto_created._meta.db_table) in tables ) ) manifest = { app_name: list(filter(model_installed, model_list)) for app_name, model_list in all_models } # Create the tables for each model if self.verbosity >= 1: self.stdout.write(" Creating tables...") with connection.schema_editor() as editor: for app_name, model_list in manifest.items(): for model in model_list: # Never install unmanaged models, etc. if not model._meta.can_migrate(connection): continue if self.verbosity >= 3: self.stdout.write( " Processing %s.%s model" % (app_name, model._meta.object_name) ) if self.verbosity >= 1: self.stdout.write( " Creating table %s" % model._meta.db_table ) editor.create_model(model) # Deferred SQL is executed when exiting the editor's context. if self.verbosity >= 1: self.stdout.write(" Running deferred SQL...") @staticmethod def describe_operation(operation, backwards): """Return a string that describes a migration operation for --plan.""" prefix = "" is_error = False if hasattr(operation, "code"): code = operation.reverse_code if backwards else operation.code action = (code.__doc__ or "") if code else None elif hasattr(operation, "sql"): action = operation.reverse_sql if backwards else operation.sql else: action = "" if backwards: prefix = "Undo " if action is not None: action = str(action).replace("\n", "") elif backwards: action = "IRREVERSIBLE" is_error = True if action: action = " -> " + action truncated = Truncator(action) return prefix + operation.describe() + truncated.chars(40), is_error commands/makemigrations.py 0000644 00000053654 15030001101 0011723 0 ustar 00 import os import sys import warnings from itertools import takewhile from django.apps import apps from django.conf import settings from django.core.management.base import BaseCommand, CommandError, no_translations from django.core.management.utils import run_formatters from django.db import DEFAULT_DB_ALIAS, OperationalError, connections, router from django.db.migrations import Migration from django.db.migrations.autodetector import MigrationAutodetector from django.db.migrations.loader import MigrationLoader from django.db.migrations.migration import SwappableTuple from django.db.migrations.optimizer import MigrationOptimizer from django.db.migrations.questioner import ( InteractiveMigrationQuestioner, MigrationQuestioner, NonInteractiveMigrationQuestioner, ) from django.db.migrations.state import ProjectState from django.db.migrations.utils import get_migration_name_timestamp from django.db.migrations.writer import MigrationWriter class Command(BaseCommand): help = "Creates new migration(s) for apps." def add_arguments(self, parser): parser.add_argument( "args", metavar="app_label", nargs="*", help="Specify the app label(s) to create migrations for.", ) parser.add_argument( "--dry-run", action="store_true", help="Just show what migrations would be made; don't actually write them.", ) parser.add_argument( "--merge", action="store_true", help="Enable fixing of migration conflicts.", ) parser.add_argument( "--empty", action="store_true", help="Create an empty migration.", ) parser.add_argument( "--noinput", "--no-input", action="store_false", dest="interactive", help="Tells Django to NOT prompt the user for input of any kind.", ) parser.add_argument( "-n", "--name", help="Use this name for migration file(s).", ) parser.add_argument( "--no-header", action="store_false", dest="include_header", help="Do not add header comments to new migration file(s).", ) parser.add_argument( "--check", action="store_true", dest="check_changes", help=( "Exit with a non-zero status if model changes are missing migrations " "and don't actually write them. Implies --dry-run." ), ) parser.add_argument( "--scriptable", action="store_true", dest="scriptable", help=( "Divert log output and input prompts to stderr, writing only " "paths of generated migration files to stdout." ), ) parser.add_argument( "--update", action="store_true", dest="update", help=( "Merge model changes into the latest migration and optimize the " "resulting operations." ), ) @property def log_output(self): return self.stderr if self.scriptable else self.stdout def log(self, msg): self.log_output.write(msg) @no_translations def handle(self, *app_labels, **options): self.written_files = [] self.verbosity = options["verbosity"] self.interactive = options["interactive"] self.dry_run = options["dry_run"] self.merge = options["merge"] self.empty = options["empty"] self.migration_name = options["name"] if self.migration_name and not self.migration_name.isidentifier(): raise CommandError("The migration name must be a valid Python identifier.") self.include_header = options["include_header"] check_changes = options["check_changes"] if check_changes: self.dry_run = True self.scriptable = options["scriptable"] self.update = options["update"] # If logs and prompts are diverted to stderr, remove the ERROR style. if self.scriptable: self.stderr.style_func = None # Make sure the app they asked for exists app_labels = set(app_labels) has_bad_labels = False for app_label in app_labels: try: apps.get_app_config(app_label) except LookupError as err: self.stderr.write(str(err)) has_bad_labels = True if has_bad_labels: sys.exit(2) # Load the current graph state. Pass in None for the connection so # the loader doesn't try to resolve replaced migrations from DB. loader = MigrationLoader(None, ignore_no_migrations=True) # Raise an error if any migrations are applied before their dependencies. consistency_check_labels = {config.label for config in apps.get_app_configs()} # Non-default databases are only checked if database routers used. aliases_to_check = ( connections if settings.DATABASE_ROUTERS else [DEFAULT_DB_ALIAS] ) for alias in sorted(aliases_to_check): connection = connections[alias] if connection.settings_dict["ENGINE"] != "django.db.backends.dummy" and any( # At least one model must be migrated to the database. router.allow_migrate( connection.alias, app_label, model_name=model._meta.object_name ) for app_label in consistency_check_labels for model in apps.get_app_config(app_label).get_models() ): try: loader.check_consistent_history(connection) except OperationalError as error: warnings.warn( "Got an error checking a consistent migration history " "performed for database connection '%s': %s" % (alias, error), RuntimeWarning, ) # Before anything else, see if there's conflicting apps and drop out # hard if there are any and they don't want to merge conflicts = loader.detect_conflicts() # If app_labels is specified, filter out conflicting migrations for # unspecified apps. if app_labels: conflicts = { app_label: conflict for app_label, conflict in conflicts.items() if app_label in app_labels } if conflicts and not self.merge: name_str = "; ".join( "%s in %s" % (", ".join(names), app) for app, names in conflicts.items() ) raise CommandError( "Conflicting migrations detected; multiple leaf nodes in the " "migration graph: (%s).\nTo fix them run " "'python manage.py makemigrations --merge'" % name_str ) # If they want to merge and there's nothing to merge, then politely exit if self.merge and not conflicts: self.log("No conflicts detected to merge.") return # If they want to merge and there is something to merge, then # divert into the merge code if self.merge and conflicts: return self.handle_merge(loader, conflicts) if self.interactive: questioner = InteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=self.dry_run, prompt_output=self.log_output, ) else: questioner = NonInteractiveMigrationQuestioner( specified_apps=app_labels, dry_run=self.dry_run, verbosity=self.verbosity, log=self.log, ) # Set up autodetector autodetector = MigrationAutodetector( loader.project_state(), ProjectState.from_apps(apps), questioner, ) # If they want to make an empty migration, make one for each app if self.empty: if not app_labels: raise CommandError( "You must supply at least one app label when using --empty." ) # Make a fake changes() result we can pass to arrange_for_graph changes = {app: [Migration("custom", app)] for app in app_labels} changes = autodetector.arrange_for_graph( changes=changes, graph=loader.graph, migration_name=self.migration_name, ) self.write_migration_files(changes) return # Detect changes changes = autodetector.changes( graph=loader.graph, trim_to_apps=app_labels or None, convert_apps=app_labels or None, migration_name=self.migration_name, ) if not changes: # No changes? Tell them. if self.verbosity >= 1: if app_labels: if len(app_labels) == 1: self.log("No changes detected in app '%s'" % app_labels.pop()) else: self.log( "No changes detected in apps '%s'" % ("', '".join(app_labels)) ) else: self.log("No changes detected") else: if self.update: self.write_to_last_migration_files(changes) else: self.write_migration_files(changes) if check_changes: sys.exit(1) def write_to_last_migration_files(self, changes): loader = MigrationLoader(connections[DEFAULT_DB_ALIAS]) new_changes = {} update_previous_migration_paths = {} for app_label, app_migrations in changes.items(): # Find last migration. leaf_migration_nodes = loader.graph.leaf_nodes(app=app_label) if len(leaf_migration_nodes) == 0: raise CommandError( f"App {app_label} has no migration, cannot update last migration." ) leaf_migration_node = leaf_migration_nodes[0] # Multiple leaf nodes have already been checked earlier in command. leaf_migration = loader.graph.nodes[leaf_migration_node] # Updated migration cannot be a squash migration, a dependency of # another migration, and cannot be already applied. if leaf_migration.replaces: raise CommandError( f"Cannot update squash migration '{leaf_migration}'." ) if leaf_migration_node in loader.applied_migrations: raise CommandError( f"Cannot update applied migration '{leaf_migration}'." ) depending_migrations = [ migration for migration in loader.disk_migrations.values() if leaf_migration_node in migration.dependencies ] if depending_migrations: formatted_migrations = ", ".join( [f"'{migration}'" for migration in depending_migrations] ) raise CommandError( f"Cannot update migration '{leaf_migration}' that migrations " f"{formatted_migrations} depend on." ) # Build new migration. for migration in app_migrations: leaf_migration.operations.extend(migration.operations) for dependency in migration.dependencies: if isinstance(dependency, SwappableTuple): if settings.AUTH_USER_MODEL == dependency.setting: leaf_migration.dependencies.append( ("__setting__", "AUTH_USER_MODEL") ) else: leaf_migration.dependencies.append(dependency) elif dependency[0] != migration.app_label: leaf_migration.dependencies.append(dependency) # Optimize migration. optimizer = MigrationOptimizer() leaf_migration.operations = optimizer.optimize( leaf_migration.operations, app_label ) # Update name. previous_migration_path = MigrationWriter(leaf_migration).path name_fragment = self.migration_name or leaf_migration.suggest_name() suggested_name = leaf_migration.name[:4] + f"_{name_fragment}" if leaf_migration.name == suggested_name: new_name = leaf_migration.name + "_updated" else: new_name = suggested_name leaf_migration.name = new_name # Register overridden migration. new_changes[app_label] = [leaf_migration] update_previous_migration_paths[app_label] = previous_migration_path self.write_migration_files(new_changes, update_previous_migration_paths) def write_migration_files(self, changes, update_previous_migration_paths=None): """ Take a changes dict and write them out as migration files. """ directory_created = {} for app_label, app_migrations in changes.items(): if self.verbosity >= 1: self.log(self.style.MIGRATE_HEADING("Migrations for '%s':" % app_label)) for migration in app_migrations: # Describe the migration writer = MigrationWriter(migration, self.include_header) if self.verbosity >= 1: # Display a relative path if it's below the current working # directory, or an absolute path otherwise. migration_string = self.get_relative_path(writer.path) self.log(" %s\n" % self.style.MIGRATE_LABEL(migration_string)) for operation in migration.operations: self.log(" - %s" % operation.describe()) if self.scriptable: self.stdout.write(migration_string) if not self.dry_run: # Write the migrations file to the disk. migrations_directory = os.path.dirname(writer.path) if not directory_created.get(app_label): os.makedirs(migrations_directory, exist_ok=True) init_path = os.path.join(migrations_directory, "__init__.py") if not os.path.isfile(init_path): open(init_path, "w").close() # We just do this once per app directory_created[app_label] = True migration_string = writer.as_string() with open(writer.path, "w", encoding="utf-8") as fh: fh.write(migration_string) self.written_files.append(writer.path) if update_previous_migration_paths: prev_path = update_previous_migration_paths[app_label] rel_prev_path = self.get_relative_path(prev_path) if writer.needs_manual_porting: migration_path = self.get_relative_path(writer.path) self.log( self.style.WARNING( f"Updated migration {migration_path} requires " f"manual porting.\n" f"Previous migration {rel_prev_path} was kept and " f"must be deleted after porting functions manually." ) ) else: os.remove(prev_path) self.log(f"Deleted {rel_prev_path}") elif self.verbosity == 3: # Alternatively, makemigrations --dry-run --verbosity 3 # will log the migrations rather than saving the file to # the disk. self.log( self.style.MIGRATE_HEADING( "Full migrations file '%s':" % writer.filename ) ) self.log(writer.as_string()) run_formatters(self.written_files) @staticmethod def get_relative_path(path): try: migration_string = os.path.relpath(path) except ValueError: migration_string = path if migration_string.startswith(".."): migration_string = path return migration_string def handle_merge(self, loader, conflicts): """ Handles merging together conflicted migrations interactively, if it's safe; otherwise, advises on how to fix it. """ if self.interactive: questioner = InteractiveMigrationQuestioner(prompt_output=self.log_output) else: questioner = MigrationQuestioner(defaults={"ask_merge": True}) for app_label, migration_names in conflicts.items(): # Grab out the migrations in question, and work out their # common ancestor. merge_migrations = [] for migration_name in migration_names: migration = loader.get_migration(app_label, migration_name) migration.ancestry = [ mig for mig in loader.graph.forwards_plan((app_label, migration_name)) if mig[0] == migration.app_label ] merge_migrations.append(migration) def all_items_equal(seq): return all(item == seq[0] for item in seq[1:]) merge_migrations_generations = zip(*(m.ancestry for m in merge_migrations)) common_ancestor_count = sum( 1 for common_ancestor_generation in takewhile( all_items_equal, merge_migrations_generations ) ) if not common_ancestor_count: raise ValueError( "Could not find common ancestor of %s" % migration_names ) # Now work out the operations along each divergent branch for migration in merge_migrations: migration.branch = migration.ancestry[common_ancestor_count:] migrations_ops = ( loader.get_migration(node_app, node_name).operations for node_app, node_name in migration.branch ) migration.merged_operations = sum(migrations_ops, []) # In future, this could use some of the Optimizer code # (can_optimize_through) to automatically see if they're # mergeable. For now, we always just prompt the user. if self.verbosity > 0: self.log(self.style.MIGRATE_HEADING("Merging %s" % app_label)) for migration in merge_migrations: self.log(self.style.MIGRATE_LABEL(" Branch %s" % migration.name)) for operation in migration.merged_operations: self.log(" - %s" % operation.describe()) if questioner.ask_merge(app_label): # If they still want to merge it, then write out an empty # file depending on the migrations needing merging. numbers = [ MigrationAutodetector.parse_number(migration.name) for migration in merge_migrations ] try: biggest_number = max(x for x in numbers if x is not None) except ValueError: biggest_number = 1 subclass = type( "Migration", (Migration,), { "dependencies": [ (app_label, migration.name) for migration in merge_migrations ], }, ) parts = ["%04i" % (biggest_number + 1)] if self.migration_name: parts.append(self.migration_name) else: parts.append("merge") leaf_names = "_".join( sorted(migration.name for migration in merge_migrations) ) if len(leaf_names) > 47: parts.append(get_migration_name_timestamp()) else: parts.append(leaf_names) migration_name = "_".join(parts) new_migration = subclass(migration_name, app_label) writer = MigrationWriter(new_migration, self.include_header) if not self.dry_run: # Write the merge migrations file to the disk with open(writer.path, "w", encoding="utf-8") as fh: fh.write(writer.as_string()) run_formatters([writer.path]) if self.verbosity > 0: self.log("\nCreated new merge migration %s" % writer.path) if self.scriptable: self.stdout.write(writer.path) elif self.verbosity == 3: # Alternatively, makemigrations --merge --dry-run --verbosity 3 # will log the merge migrations rather than saving the file # to the disk. self.log( self.style.MIGRATE_HEADING( "Full merge migrations file '%s':" % writer.filename ) ) self.log(writer.as_string()) commands/__pycache__/compilemessages.cpython-310.pyc 0000644 00000012227 15030001101 0016417 0 ustar 00 o �hP � @ st d dl Z d dlZd dlZd dlZd dlmZ d dlmZm Z d dl m Z m Z m Z dd� Zdd� ZG d d � d e�ZdS ) � N)�Path)� BaseCommand� CommandError)� find_command�is_ignored_path� popen_wrapperc C sJ | � d�� }|�d�}W d � n1 sw Y |�tjtjtjf�S )N�rb� )�open�read� startswith�codecs�BOM_UTF8� BOM_UTF16_LE� BOM_UTF16_BE)�fn�f�sample� r �b/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/compilemessages.py�has_bom s ��r c C sV z t | d�� t�| d � W d � W dS 1 sw Y W dS ty* Y dS w )N�aFT)r �os�utime�OSError)�pathr r r � is_writable s �� ��r c @ s6 e Zd ZdZg ZdZdgZdd� Zdd� Zdd � Z d S ) �CommandzECompiles .po files to .mo files for use with builtin gettext support.�msgfmtz--check-formatc C sX |j dddg dd� |j dddg dd� |j d d d d d d� |j ddddg ddd� d S )Nz--localez-l�appendzYLocale(s) to process (e.g. de_AT). Default is to process all. Can be used multiple times.)�action�default�helpz --excludez-xz@Locales to exclude. Default is none. Can be used multiple times.z --use-fuzzy�-f�fuzzy� store_truezUse fuzzy translations.)�destr r" z--ignorez-i�ignore_patterns�PATTERNzWIgnore directories matching this glob-style pattern. Use multiple times to ignore more.)r r& r! �metavarr" )� add_argument)�self�parserr r r � add_arguments& s< ��� �zCommand.add_argumentsc s� |d }|d }t |d �}|d | _|d r | jdg | _t| j�d u r,td| j ��tj�dd�dg}tj � d �rGd d l m } |� |j� tjd d d�D ],\�}}|D ]$} ttj�tj��| ��|�rk|�| � qU| dkry|�tj��| �� qUqNt ttjjttjj|���}|s�td��g } |D ]� ttjjt�d� ��} | � ttjj| �� q�|p�| } t | ��|�} d| _|D ]6� | rʇ fdd�| D �} n� g} g }| D ]}t�|�D ]\�}}|� �fdd�|D �� q�q�|r�| � |� q�| jr�td��d S )N�locale�excluder' � verbosityr$ r# zLCan't find %s. Make sure you have GNU gettext tools 0.15 or newer installed.�conf�DJANGO_SETTINGS_MODULEr )�settings�.T)�topdownzzThis script should be run from the Django Git checkout or your project or app tree, or with the settings module specified.z%s/*Fc s g | ] }t j�� |d ��qS )� LC_MESSAGES)r r �join)�.0r. )�basedirr r � <listcomp>} s �z"Command.handle.<locals>.<listcomp>c 3 s" � | ] }|� d �r� |fV qdS )z.poN)�endswith)r8 r )�dirpathr r � <genexpr>� s � � �z!Command.handle.<locals>.<genexpr>z-compilemessages generated one or more errors.) �setr0 �program_optionsr �programr r r r7 �environ�get� django.confr3 �extend� LOCALE_PATHS�walkr �normpath�remover �map�abspath�filter�isdir�glob�basename� difference� has_errors�compile_messages)r+ �optionsr. r/ r' �basedirsr3 �dirnames� filenames�dirname� all_locales� locale_dirs�locales�dirs� locations�ldirr )r9 r< r �handleH sr �� � �� � � �� ��zCommand.handlec C s� t j�� ��}g }t|�D ]�\}\}}t|�| }|�d�}z|�� j|�� jkr7| jdkr5| j � d| � W q W n t yA Y nw | jdkrQ| j � d||f � t |�ra| j � d| � d| _q |dkr}t|�s}| j � d| � d| _ W d � dS | jg| j�d �|�|�} |�|�t| �� q t j�|�D ]*} | �� \} } } | r�| jdkr�| r�| j � d | j| f � n | j � d | j � d| _q�W d � dS 1 s�w Y dS ) zI Locations is a list of tuples: [(directory, file), ...] z.mor u1 File “%s” is already compiled and up to date.zprocessing file %s in %szmThe %s file has a BOM (Byte Order Mark). Django only supports .po files encoded in UTF-8 and without any BOM.TzeThe po files under %s are in a seemingly not writable location. mo files will not be updated/created.Nz-ozExecution of %s failed: %szExecution of %s failed)� concurrent�futures�ThreadPoolExecutor� enumerater � with_suffix�stat�st_mtimer0 �stdout�write�FileNotFoundErrorr �stderrrP r r@ r? r �submitr � as_completed�result)r+ r[ �executorr_ �ir< r �po_path�mo_path�args�future�output�errors�statusr r r rQ � sh ��� � �����$ ���"�zCommand.compile_messagesN) �__name__� __module__� __qualname__r" �requires_system_checksr@ r? r- r] rQ r r r r r s " Fr )r �concurrent.futuresr^ rM r �pathlibr �django.core.management.baser r � django.core.management.utilsr r r r r r r r r r �<module> s commands/__pycache__/shell.cpython-310.pyc 0000644 00000006113 15030001101 0014343 0 ustar 00 o �h � @ sP d dl Z d dlZd dlZd dlZd dlmZmZ d dlmZ G dd� de�Z dS )� N)� BaseCommand� CommandError)� OrderedSetc @ sD e Zd ZdZg Zg d�Zdd� Zdd� Zdd� Zd d � Z d d � Z d S )�Commandz�Runs a Python interactive interpreter. Tries to use IPython or bpython, if one of them is available. Any standard input is executed as code.)�ipython�bpython�pythonc C s8 |j dddd� |j dd| jdd� |j d d d d � d S ) Nz --no-startup� store_truezaWhen using plain Python, ignore the PYTHONSTARTUP environment variable and ~/.pythonrc.py script.)�action�helpz-iz --interfacezcSpecify an interactive interpreter interface. Available options: "ipython", "bpython", and "python")�choicesr z-cz --commandzJInstead of opening an interactive shell, run a command as Django and exit.)r )� add_argument�shells)�self�parser� r �X/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/shell.py� add_arguments s �� �zCommand.add_argumentsc C s ddl m} |g d� d S )Nr )� start_ipython)�argv)�IPythonr )r �optionsr r r r r / s zCommand.ipythonc C s dd l }|�� d S )Nr )r �embed)r r r r r r r 4 s zCommand.bpythonc C s@ dd l }i }|d sUttj�d�tj�d�g�D ]<}|s qtj�|�s$qt|�� }|� � }W d � n1 s7w Y z t t ||d�|� W q t yT t �� Y qw ztj}W n tyc Y nw z|� W n t yz td� t �� Y nw zdd l}dd l} |�| �|�j� W n ty� Y nw |j|d� d S )Nr � no_startup� PYTHONSTARTUPz~/.pythonrc.py�execz&Failed calling sys.__interactivehook__)�local)�coder �os�environ�get�path� expanduser�isfile�open�readr �compile� Exception� traceback� print_exc�sys�__interactivehook__�AttributeError�print�readline� rlcompleter� set_completer� Completer�complete� ImportError�interact) r r r �imported_objects�pythonrc�handle� pythonrc_code�hookr. r/ r r r r 9 sJ � � � � � �zCommand.pythonc K s� |d rt |d t� � d S tjdkr/tj�� s/t�tjgg g d�d r/t tj�� t� � d S |d r8|d gn| j}|D ]}z t | |�|�W S t yR Y q=w t d� |���)N�command�win32r � interfacez Couldn't import {} interface.) r �globalsr* �platform�stdin�isatty�selectr% r �getattrr3 r �format)r r �available_shells�shellr r r r7 r s& ��� �zCommand.handleN) �__name__� __module__� __qualname__r �requires_system_checksr r r r r r7 r r r r r s � 9r ) r rA r* r( �django.core.managementr r �django.utils.datastructuresr r r r r r �<module> s commands/__pycache__/testserver.cpython-310.pyc 0000644 00000003555 15030001101 0015451 0 ustar 00 o �h� � @ s8 d dl mZ d dlmZ d dlmZ G dd� de�ZdS )� )� call_command)� BaseCommand)� connectionc @ s$ e Zd ZdZg Zdd� Zdd� ZdS )�Commandz>Runs a development server with data from the given fixture(s).c C sN |j ddddd� |j dddd d d � |j d d dd� |j dddddd � d S )N�args�fixture�*z6Path(s) to fixtures to load before running the server.)�metavar�nargs�helpz --noinputz --no-input� store_false� interactivez:Tells Django to NOT prompt the user for input of any kind.)�action�destr z --addrport� z0Port number or ipaddr:port to run the server on.)�defaultr z--ipv6z-6� store_true�use_ipv6z$Tells Django to use an IPv6 address.)� add_argument)�self�parser� r �]/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/testserver.py� add_arguments s2 ��� �zCommand.add_argumentsc O sn |d }|d }t jj|| dd�}tdg|�R i d|i�� d| }t jj}td|d |d|d |d � d S ) N� verbosityr F)r � autoclobber� serialize�loaddatazg Server stopped. Note that the test database, %r, has not been deleted. You can explore it on your own.� runserver�addrportr )r �shutdown_message� use_reloaderr � use_threading)r �creation�create_test_dbr �features�#test_db_allows_multiple_connections)r �fixture_labels�optionsr r �db_namer r" r r r �handle& s& ��� �zCommand.handleN)�__name__� __module__� __qualname__r �requires_system_checksr r* r r r r r s r N)�django.core.managementr �django.core.management.baser � django.dbr r r r r r �<module> s commands/__pycache__/check.cpython-310.pyc 0000644 00000004626 15030001101 0014320 0 ustar 00 o �h\ � @ sH d dl mZ d dlmZ d dlmZ d dlmZmZ G dd� de�Z dS )� )�apps)�checks)�registry)� BaseCommand� CommandErrorc @ s$ e Zd ZdZg Zdd� Zdd� ZdS )�Commandz8Checks the entire Django project for potential problems.c C sp |j dddd� |j ddddd d � |j d d d d� |j dd dd� |j ddg d�dd� |j ddddd � d S )N�args� app_label�*)�metavar�nargsz--tagz-t�append�tagsz'Run only checks labeled with given tag.)�action�dest�helpz --list-tags� store_truezList available tags.)r r z--deployzCheck deployment settings.z --fail-level�ERROR)�CRITICALr �WARNING�INFO�DEBUGz[Message level that will cause the command to exit with a non-zero status. Default is ERROR.)�default�choicesr z --database� databasesz2Run database related checks against these aliases.)� add_argument)�self�parser� r �X/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/check.py� add_arguments s< ���� �zCommand.add_argumentsc s� |d � |d r| j �d�tt�� ���� d S |r"dd� |D �}nd }|d }|rGz t� fdd�|D ��}W n ty@ Y nw td | ��| j ||d � t t |d �|d d � d S )N�deploy� list_tags� c S s g | ]}t �|��qS r )r �get_app_config)�.0r r r r � <listcomp>8 s z"Command.handle.<locals>.<listcomp>r c 3 s � | ] }t �|� �s|V qd S )N)r � tag_exists)r% �tag��include_deployment_checksr r � <genexpr>? s � � �z!Command.handle.<locals>.<genexpr>z+There is no system check with the "%s" tag.T� fail_levelr )� app_configsr �display_num_errorsr* r, r ) �stdout�write�join�sortedr �tags_available�next� StopIterationr �check�getattrr )r � app_labels�optionsr- r � invalid_tagr r) r �handle/ s: � � �� �zCommand.handleN)�__name__� __module__� __qualname__r �requires_system_checksr r; r r r r r s #r N) � django.appsr � django.corer �django.core.checks.registryr �django.core.management.baser r r r r r r �<module> s commands/__pycache__/showmigrations.cpython-310.pyc 0000644 00000011224 15030001101 0016310 0 ustar 00 o �h� � @ s\ d dl Z d dlmZ d dlmZ d dlmZmZ d dlm Z d dl m Z G dd� de�Z dS ) � N)�apps)� BaseCommand)�DEFAULT_DB_ALIAS� connections)�MigrationLoader)�MigrationRecorderc @ s< e Zd ZdZdd� Zdd� Zdd� Zd d d �Zd d d �ZdS )�Commandz6Shows all available migrations for the current projectc C sd |j dddd� |j dtdd� |�� }|j dd d d d d d� |j ddd d ddd� |jd d� d S )N� app_label�*z2App labels of applications to limit the output to.)�nargs�helpz --databasezPNominates a database to show migrations for. Defaults to the "default" database.)�defaultr z--listz-l� store_const�format�listz�Shows a list of all migrations and which are applied. With a verbosity level of 2 or above, the applied datetimes will be included.)�action�dest�constr z--planz-p�planz�Shows all migrations in the order they will be applied. With a verbosity level of 2 or above all direct migration dependencies and reverse dependencies (run_before) will be included.)r )� add_argumentr � add_mutually_exclusive_group� set_defaults)�self�parser�formats� r �a/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/showmigrations.py� add_arguments s8 �� � � zCommand.add_argumentsc O sF |d | _ |d }t| }|d dkr| �||d �S | �||d �S )N� verbosity�databaser r r )r r � show_plan� show_list)r �args�options�db� connectionr r r �handle8 s zCommand.handlec C sj d}|D ]%}zt �|� W q ty) } z| j�t|�� d}W Y d }~qd }~ww |r3t�d� d S d S )NFT� )r �get_app_config� LookupError�stderr�write�str�sys�exit)r �loader� app_names� has_bad_names�app_name�errr r r �_validate_app_namesD s ���zCommand._validate_app_namesNc C s\ t |dd�}t|�}|�� }|j}|r| �||� nt|j�}|D ]�}| j�|| j j � t � }|� |�D ]k} |� | �D ]c} | |vr�| d |kr�| d } |j| jr]| dt|j| j� 7 } |j�| �} | r�| |v rnd| } n| d7 } d| } | jd kr�t| d �r�| d | j�d � 7 } | j�| � n| j�d | � |�| � q;q4|s�| j�d| j j� q!dS )zh Show a list of all migrations on the system, or only those of some named apps. T)�ignore_no_migrationsr � z (%s squashed migrations)z [X] %sz- Run 'manage.py migrate' to finish recording.z [-] %sr' �appliedz (applied at %s)z%Y-%m-%d %H:%M:%Sz [ ] %sz (no migrations)N)r r �applied_migrations�graphr4 �sorted� migrated_apps�stdoutr+ �style� MIGRATE_LABEL�set� leaf_nodes� forwards_plan�nodes�replaces�len�getr �hasattrr7 �strftime�add�ERROR)r r% r0 r/ �recorder�recorded_migrationsr9 r2 �shown�node� plan_node�title�applied_migration�outputr r r r! O sV � ���� �� ��zCommand.show_listc s t |�}|j}� r| �|� � � fdd�|�� D �}n|�� }g }t� }|D ] }|�|�D ]} | |vrB|j| } |�| � |�| � q-q&dd� } |D ]6} d} | j dkrW| | �} | j |j v ro| j � d| j d | j d | f � qJ| j � d | j d | j d | f � qJ|s�| j � d | jj� d S d S ) z� Show all known migrations (or only those of the specified app_names) in the order they will be applied. c s g | ] }|d � v r|�qS )r r )�.0�key�r0 r r � <listcomp>� s z%Command.show_plan.<locals>.<listcomp>c S s: g }t | j�D ] }|�d|j � q|rdd�|� S dS )Nz%s.%sz ... (%s)z, � )r: �parents�appendrS �join)rM �out�parentr r r � print_deps� s z%Command.show_plan.<locals>.print_depsrV r' z [X] %s.%s%sr r6 z [ ] %s.%s%sz(no migrations)N)r r9 r4 r@ r? rA �node_maprX rH r rS r8 r< r+ r= rI ) r r% r0 r/ r9 �targetsr �seen�target� migrationrM r\ �depsr rT r r � s6 �� $$�zCommand.show_plan)N) �__name__� __module__� __qualname__r r r& r4 r! r r r r r r s + 7r ) r- � django.appsr �django.core.management.baser � django.dbr r �django.db.migrations.loaderr � django.db.migrations.recorderr r r r r r �<module> s commands/__pycache__/sqlmigrate.cpython-310.pyc 0000644 00000004757 15030001101 0015420 0 ustar 00 o �h� � @ sP d dl mZ d dlmZmZ d dlmZmZ d dlm Z m Z G dd� de�Z dS )� )�apps)� BaseCommand� CommandError)�DEFAULT_DB_ALIAS� connections)�AmbiguityError�MigrationLoaderc s4 e Zd ZdZdZdd� Z� fdd�Zdd� Z� ZS ) �Commandz2Prints the SQL statements for the named migration.Tc C s@ |j ddd� |j ddd� |j dtdd� |j d d d d � d S ) N� app_labelz6App label of the application containing the migration.)�help�migration_namez$Migration name to print the SQL for.z --databasezKNominates a database to create SQL for. Defaults to the "default" database.)�defaultr z --backwards� store_truez=Creates SQL to unapply the migration, rather than to apply it)�actionr )� add_argumentr )�self�parser� r �]/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/sqlmigrate.py� add_arguments s ��� �zCommand.add_argumentsc s d|d< t � j|i |��S )NT�no_color)�super�execute)r �args�options�� __class__r r r ! s zCommand.executec O s t |d }t|dd�}|d |d }}zt�|� W n ty. } ztt|���d }~ww ||jvr:td| ��z|�||�}W n t yQ td||f �� t y_ td||f ��w ||j f} |j ok|j j| _|jj| |d fg} |�| �} | s�|d d kr�| j�d � d �| �S )N�databaseF)�replace_migrationsr r z!App '%s' does not have migrationszJMore than one migration matches '%s' in app '%s'. Please be more specific.zMCannot find a migration matching '%s' from app '%s'. Is it in INSTALLED_APPS?� backwards� verbosity� zNo operations found.� )r r r �get_app_config� LookupErrorr �str� migrated_apps�get_migration_by_prefixr �KeyError�name�atomic�features�can_rollback_ddl�output_transaction�graph�nodes� collect_sql�stderr�write�join) r r r � connection�loaderr r �err� migration�target�plan�sql_statementsr r r �handle( sD �� �� ��� � zCommand.handle) �__name__� __module__� __qualname__r r- r r r; � __classcell__r r r r r s r N) � django.appsr �django.core.management.baser r � django.dbr r �django.db.migrations.loaderr r r r r r r �<module> s commands/__pycache__/__init__.cpython-310.pyc 0000644 00000000270 15030001101 0014771 0 ustar 00 o �h � @ s d S )N� r r r �[/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/__init__.py�<module> s commands/__pycache__/makemigrations.cpython-310.pyc 0000644 00000032457 15030001101 0016260 0 ustar 00 o �h�W � @ s� d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZ d dl m Z m Z m Z d dl mZ d dlmZmZmZmZ d dlmZ d d lmZ d d lmZ d d lmZ d d l m Z d d l m Z m Z m!Z! d dl"m#Z# d dl$m%Z% d dl&m'Z' G dd� de �Z(dS )� N)� takewhile)�apps)�settings)� BaseCommand� CommandError�no_translations)�run_formatters)�DEFAULT_DB_ALIAS�OperationalError� connections�router�� Migration)�MigrationAutodetector)�MigrationLoader)�SwappableTuple)�MigrationOptimizer)� InteractiveMigrationQuestioner�MigrationQuestioner�!NonInteractiveMigrationQuestioner)� ProjectState)� get_migration_name_timestamp)�MigrationWriterc @ s^ e Zd ZdZdd� Zedd� �Zdd� Zedd � �Z d d � Z dd d�Z e dd� �Z dd� Zd S )�Commandz"Creates new migration(s) for apps.c C s� |j ddddd� |j dddd � |j d dd d � |j d dd d � |j dddddd� |j dddd� |j ddddd� |j ddd d d� |j d dd d d� |j d!dd"d#d� d S )$N�args� app_label�*z2Specify the app label(s) to create migrations for.)�metavar�nargs�helpz --dry-run� store_truezCJust show what migrations would be made; don't actually write them.)�actionr z--mergez%Enable fixing of migration conflicts.z--emptyzCreate an empty migration.z --noinputz --no-input� store_false� interactivez:Tells Django to NOT prompt the user for input of any kind.)r! �destr z-nz--namez$Use this name for migration file(s).)r z --no-header�include_headerz4Do not add header comments to new migration file(s).z--check� check_changeszuExit with a non-zero status if model changes are missing migrations and don't actually write them. Implies --dry-run.z --scriptable� scriptableziDivert log output and input prompts to stderr, writing only paths of generated migration files to stdout.z--update�updatezTMerge model changes into the latest migration and optimize the resulting operations.)� add_argument)�self�parser� r, �a/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/makemigrations.py� add_arguments sr �������� � �zCommand.add_argumentsc C s | j r| jS | jS �N)r' �stderr�stdout)r* r, r, r- � log_outputa s zCommand.log_outputc C s | j �|� d S r/ )r2 �write)r* �msgr, r, r- �loge s z Command.logc s� g | _ |d | _|d | _|d | _|d | _|d | _|d | _| jr-| j�� s-td��|d | _ |d }|r;d | _|d | _ |d | _ | j rLd | j _ t� �� d }� D ]%}zt�|� W qT tyy } z| j �t|�� d }W Y d }~qTd }~ww |r�t�d� td d d�}dd� t�� D �}tjr�tntg} t | �D ]<} t| ��j d dkr�t �fdd�|D ��r�z|� �� W q� t y� } zt!�"d| | f t#� W Y d } ~ q�d } ~ ww q�|�$� } � r� fdd�| �%� D �} | �r| j�sd�&dd� | �%� D ��} td| ��| j�r| �s| �'d � d S | j�r | �r | �(|| �S | j�r,t)� | j| j*d �}n t+� | j| j| j'd �}t,|�-� t.�/t�|�}| j�re� �sMtd ��d d� � D �}|j0||j1| jd!�}| �2|� d S |j3|j1� �pmd � �pqd | jd"�}|�s�| jd#k�r�� �r�t4� �d#k�r�| �'d$� �5� � d S | �'d%d&�&� � � d S | �'d'� d S d S | j �r�| �6|� n| �2|� |�r�t�d#� d S d S )(N� verbosityr# �dry_run�merge�empty�namez5The migration name must be a valid Python identifier.r% r& Tr' r( F� )�ignore_no_migrationsc S s h | ]}|j �qS r, )�label)�.0�configr, r, r- � <setcomp>� s z!Command.handle.<locals>.<setcomp>�ENGINEzdjango.db.backends.dummyc 3 s: � | ]}t �|��� D ]}tj� j||jjd �V q qdS ))� model_nameN)r �get_app_config� get_modelsr � allow_migrate�alias�_meta� object_name)r> r �model)� connectionr, r- � <genexpr>� s � �� � �z!Command.handle.<locals>.<genexpr>z_Got an error checking a consistent migration history performed for database connection '%s': %sc s i | ] \}}|� v r||�qS r, r, )r> r �conflict)� app_labelsr, r- � <dictcomp>� s �z"Command.handle.<locals>.<dictcomp>z; c s s& � | ]\}}d d� |�|f V qdS )z%s in %s�, N)�join)r> �app�namesr, r, r- rK � s � �z�Conflicting migrations detected; multiple leaf nodes in the migration graph: (%s). To fix them run 'python manage.py makemigrations --merge'z No conflicts detected to merge.)�specified_appsr7 � prompt_output)rS r7 r6 r5 z:You must supply at least one app label when using --empty.c S s i | ] }|t d |�g�qS )�customr )r> rQ r, r, r- rN � s )�changes�graph�migration_name)rW � trim_to_apps� convert_appsrX � z No changes detected in app '%s'z No changes detected in apps '%s'z', 'zNo changes detected)7� written_filesr6 r# r7 r8 r9 rX � isidentifierr r% r' r( r0 � style_func�setr rC � LookupErrorr3 �str�sys�exitr �get_app_configsr �DATABASE_ROUTERSr r �sorted� settings_dict�any�check_consistent_historyr �warnings�warn�RuntimeWarning�detect_conflicts�itemsrP r5 � handle_merger r2 r r � project_stater � from_apps�arrange_for_graphrW �write_migration_filesrV �len�pop� write_to_last_migration_files)r* rM �optionsr& �has_bad_labelsr �err�loader�consistency_check_labels�aliases_to_checkrF �error� conflicts�name_str� questioner� autodetectorrV r, )rM rJ r- �handleh s� �� � ������ � ��� ����� � ��� �zCommand.handlec s� t tt �}i }i }|�� D ]�\}}|jj|d�}t|�dkr'td|� d���|d � |jj� }|j r<td|� d���� |j v rItd|� d���� fdd �|j � � D �} | rld � d d � | D ��} td |� d | � d���|D ]5} |j�| j� | jD ](} t| t�r�tj| jkr�|j�d� qz|j�| � qz| d | jkr�|j�| � qzqnt� } | �|j|�|_t|�j}| j p�|� � }|j d d� d|� � }|j |kr�|j d }n|}||_ |g||< |||< q| � ||� d S )N)rQ r zApp z0 has no migration, cannot update last migration.z Cannot update squash migration 'z'.z!Cannot update applied migration 'c s g | ] }� |j v r|�qS r, )� dependencies�r> � migration��leaf_migration_noder, r- � <listcomp> s �z9Command.write_to_last_migration_files.<locals>.<listcomp>rO c S s g | ]}d |� d ��qS )�'r, r� r, r, r- r� & s zCannot update migration 'z' that migrations z depend on.)� __setting__�AUTH_USER_MODEL� �_�_updated) r r r rn rW � leaf_nodesrt r �nodes�replaces�applied_migrations�disk_migrations�valuesrP � operations�extendr� � isinstancer r r� �setting�appendr r �optimizer �pathrX � suggest_namer: rs )r* rV rz � new_changes� update_previous_migration_pathsr �app_migrations�leaf_migration_nodes�leaf_migration�depending_migrations�formatted_migrationsr� � dependency� optimizer�previous_migration_path� name_fragment�suggested_name�new_namer, r� r- rv st � � � � ��� � �� � z%Command.write_to_last_migration_filesNc C s� i }|� � D ]�\}}| jdkr| �| j�d| �� |D ]�}t|| j�}| jdkrR| �|j�}| �d| j� |� � |j D ] } | �d| � � � q=| j rR| j �|� | js�tj�|j�} |�|�s�tj| dd� tj�| d�} tj�| �s|t| d��� d||< |�� }t|jdd d ��} | �|� | j�|j� W d � n1 s�w Y |r�|| } | �| �}|jr�| �|j�}| �| j� d |� d |� d��� q t� | � | �d|� �� q | jdkr�| �| j�d|j �� | �|�� � q qt | j� d S )zL Take a changes dict and write them out as migration files. r[ zMigrations for '%s':z %s � - %sT)�exist_okz __init__.py�w�utf-8��encodingNzUpdated migration z- requires manual porting. Previous migration z? was kept and must be deleted after porting functions manually.zDeleted � zFull migrations file '%s':) rn r6 r5 �style�MIGRATE_HEADINGr r% �get_relative_pathr� � MIGRATE_LABELr� �describer' r1 r3 r7 �os�dirname�get�makedirsrP �isfile�open�close� as_stringr\ r� �needs_manual_porting�WARNING�remove�filenamer )r* rV r� �directory_createdr r� r� �writer�migration_string� operation�migrations_directory� init_path�fh� prev_path� rel_prev_path�migration_pathr, r, r- rs N sf � ��� � ����4z Command.write_migration_filesc C s: zt j�| �}W n ty | }Y nw |�d�r| }|S )Nz..)r� r� �relpath� ValueError� startswith)r� r� r, r, r- r� � s � zCommand.get_relative_pathc s | j r t| jd�}ntddid�}|�� D �]j\� }g }|D ] }��� |���fdd��j�� |f�D ��_|� �� q dd� }t d d � |D �� }t d d � t ||�D ��} | s]t d | ��|D ]��j| d � �_�fdd ��jD �} t | g ��_q_| jdkr�| �| j�d� �� |D ] �| �| j�d�j �� �jD ] } | �d| �� � q�q�|�� ��r�dd� |D �} z tdd � | D ��} W n t y� d} Y nw tdtfd� fdd�|D �i�}d| d g}| jr�|� | j� n$|� d� d� t d d � |D ���}t |�d k�r|� t � � n|� |� d� |�}||� �}t || j!�}| j"�sgt#|j$d d d ��}|�%|�&� � W d � n 1 �sBw Y t'|j$g� | jdk�rf| �d!|j$ � | j(�rf| j)�%|j$� q| jd"k�r�| �| j�d#|j* �� | �|�&� � qd S )$z� Handles merging together conflicted migrations interactively, if it's safe; otherwise, advises on how to fix it. )rT � ask_mergeT)�defaultsc s g | ] }|d � j kr|�qS )r �r )r> �mig)r� r, r- r� � s �z(Command.handle_merge.<locals>.<listcomp>c s t � fdd�� dd � D ��S )Nc 3 s � | ] }|� d kV qdS )r Nr, )r> �item��seqr, r- rK � � � z@Command.handle_merge.<locals>.all_items_equal.<locals>.<genexpr>r[ )�allr� r, r� r- �all_items_equal� s z-Command.handle_merge.<locals>.all_items_equalc s � � | ]}|j V qd S r/ )�ancestry)r> �mr, r, r- rK � � � z'Command.handle_merge.<locals>.<genexpr>c s s � | ]}d V qdS )r[ Nr, )r> �common_ancestor_generationr, r, r- rK � s � � �z$Could not find common ancestor of %sNc 3 s" � | ] \}}� � ||�jV qd S r/ )� get_migrationr� )r> �node_app� node_name)rz r, r- rK � s � � �r z Merging %sz Branch %sr� c S s g | ]}t �|j��qS r, )r � parse_numberr: r� r, r, r- r� � s ��c s s � | ] }|d ur|V qd S r/ r, )r> �xr, r, r- rK � r� r[ r r� c s g | ]}� |j f�qS r, �r: r� r� r, r- r� � s ��z%04ir8 r� c s r� r/ r� r� r, r, r- rK � r� �/ r� r� r� z Created new merge migration %sr� z Full merge migrations file '%s':)+r# r r2 r rn r� rW � forwards_planr� r� �zip�sumr r� �branch�merged_operationsr6 r5 r� r� r� r: r� r� �max�typer rX rP rf rt r r r% r7 r� r� r3 r� r r' r1 r� )r* rz r~ r� �migration_names�merge_migrationsrX r� � merge_migrations_generations�common_ancestor_count�migrations_opsr� �numbers�biggest_number�subclass�parts� leaf_names� new_migrationr� r� r, )r rz r� r- ro � s� � ��� � � � � ��� � � � ����zCommand.handle_merger/ )�__name__� __module__� __qualname__r r. �propertyr2 r5 r r� rv rs � staticmethodr� ro r, r, r, r- r s D G> r ))r� rb rj � itertoolsr � django.appsr � django.confr �django.core.management.baser r r � django.core.management.utilsr � django.dbr r r r �django.db.migrationsr �!django.db.migrations.autodetectorr �django.db.migrations.loaderr � django.db.migrations.migrationr � django.db.migrations.optimizerr � django.db.migrations.questionerr r r �django.db.migrations.stater �django.db.migrations.utilsr �django.db.migrations.writerr r r, r, r, r- �<module> s& commands/__pycache__/loaddata.cpython-310.pyc 0000644 00000027013 15030001101 0015007 0 ustar 00 o �hr> � @ sJ d dl Z d dlZd dlZd dlZd dlZd dlZd dlZd dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d dlmZmZ d dlmZ d d lmZ d d lmZmZmZm Z m Z m Z d d l m Z zd dl!Z!d Z"W n e#yw d Z"Y nw zd dl$Z$d Z%W n e#y� d Z%Y nw dZ&G dd� de�Z'G dd� dej(�Z)dd� Z*dS )� N)�product)�apps)�settings)� serializers)�ImproperlyConfigured)� BaseCommand� CommandError)�no_style)�parse_apps_and_model_labels)�DEFAULT_DB_ALIAS� DatabaseError�IntegrityError� connections�router� transaction)�cached_propertyTF�-c @ s� e Zd ZdZdZdd� Zdd� Zedd� �Zd d � Z d d � Z d d� Z dd� Z dd� Z dd� Zdd� Zejdd�dd� �Zedd � �Zd d � ZdS ) �Commandz.Installs the named fixture(s) in the database.zcNo database fixture specified. Please provide the path of at least one fixture in the command line.c C sl |j ddddd� |j dtdd� |j d d d d � |j d ddddd� |j dddg dd� |j ddd� d S )N�args�fixture�+zFixture labels.)�metavar�nargs�helpz --databasezXNominates a specific database to load fixtures into. Defaults to the "default" database.)�defaultr z--app� app_labelz,Only look for fixtures in the specified app.)�destr z--ignorenonexistentz-i� store_true�ignorez[Ignores entries in the serialized data for fields that do not currently exist on the model.)�actionr r z-ez --exclude�appendzKAn app_label or app_label.ModelName to exclude. Can be used multiple times.)r r r z--formatz2Format of serialized data when reading from stdin.)r )� add_argumentr )�self�parser� r$ �[/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/loaddata.py� add_arguments3 s> ����� �zCommand.add_argumentsc O s� |d | _ |d | _|d | _|d | _t|d �\| _| _|d | _tj | jd�� | � |� W d � n1 s:w Y t� | j�rNt | j � � d S d S )Nr �databaser � verbosity�exclude�format��using)r r, r r( r �excluded_models� excluded_appsr* r �atomic�loaddata�get_autocommitr �close)r" �fixture_labels�optionsr$ r$ r% �handle[ s � � �zCommand.handlec C sZ t dftjdftdfdd� dfd�}trtjdf|d< tr+tj df|d< tj df|d < |S ) z@A dict mapping format names to (open function, mode arg) tuples.�rb�rc W s t jS )N)�sys�stdin)r r$ r$ r% �<lambda>x s z-Command.compression_formats.<locals>.<lambda>N)N�gz�zipr9 �bz2�lzma�xz) �open�gzip�GzipFile�SingleZipReader�has_bz2r= �BZ2File�has_lzmar> �LZMAFile)r" �compression_formatsr$ r$ r% rH o s �zCommand.compression_formatsc C sp |j �t� |�}|r6| jdkr| j�d� |�� �}|D ]}|�|� q W d � dS 1 s/w Y dS dS )z=Reset database sequences for the given connection and models.� zResetting sequencesN)�ops�sequence_reset_sqlr r( �stdout�write�cursor�execute)r" � connection�models� sequence_sqlrN �liner$ r$ r% �reset_sequences� s �"��zCommand.reset_sequencesc C s\ t | j }d| _d| _d| _t� | _t�� | _ |D ] }| � |�r" nqd S g | _ |� � � |D ]}| � |� q/| j D ] }|j| jd� q:W d � n1 sNw Y dd� | jD �}z|j|d� W n tyv } zd| f|_� d }~ww | jdkr�| �|| j� | jdkr�| j| jkr�| j�d| j| jf � d S | j�d | j| j| jf � d S d S ) Nr r+ c S s g | ]}|j j�qS r$ )�_meta�db_table)�.0�modelr$ r$ r% � <listcomp>� � z$Command.loaddata.<locals>.<listcomp>)� table_namesz Problem installing fixtures: %s� z)Installed %d object(s) from %d fixture(s)z1Installed %d object(s) (of %d) from %d fixture(s))r r, � fixture_count�loaded_object_count�fixture_object_count�setrQ r � get_public_serializer_formats�serialization_formats� find_fixtures�objs_with_deferred_fields�constraint_checks_disabled� load_label�save_deferred_fields�check_constraints� Exceptionr rT r( rL rM )r" r3 rP � fixture_label�objr[ �er$ r$ r% r0 � sZ � � � �� ������zCommand.loaddatac C s� |j jj| jv st|j �| jv rdS d}t�| j|j j �rPd}| j � |j j � z |j | jd� W n t ttfyO } zd|j jj|j j|d� f|_� d}~ww |jrY| j�|� |S )z Save an object if permitted.FTr+ z9Could not load %(object_label)s(pk=%(pk)s): %(error_msg)s)� object_label�pk� error_msgN)�objectrU � app_configr. �typer- r �allow_migrate_modelr, � __class__rQ �add�saver r � ValueError�labelrn r �deferred_fieldsrd r )r" rk �savedrl r$ r$ r% �save_obj� s. ����� zCommand.save_objc C sz | j dk}| �|�D ]�\}}}| �tj�|��\}}}| j| \} } | || �} | jd7 _d} d} | j dkrD| j� d||t |�f � zMz,t j || | j | jdd�}|D ]}| d7 } | �|�ro| d7 } |ro| jj d| d d � qTW n ty� } zt|t�s�d ||f f|_� d }~ww W | �� n| �� w | r�|r�| j� � | j| 7 _| j| 7 _| dkr�t�d | t� q d S )z&Load fixtures files for a given label.� r\ r rI z#Installing %s fixture '%s' from %s.T)r, �ignorenonexistent�handle_forward_referencesz Processed %i object(s).� )�endingz#Problem installing fixture '%s': %sNz=No fixture data found for '%s'. (File format may be invalid.))r( rc � parse_name�os�path�basenamerH r] rL rM �humanizer � deserializer, r r{ ri � isinstancer r r2 r^ r_ �warnings�warn�RuntimeWarning)r" rj � show_progress� fixture_file� fixture_dir� fixture_name�_�ser_fmt�cmp_fmt� open_method�moder �objects_in_fixture�loaded_objects_in_fixture�objectsrk rl r$ r$ r% rf � sr � ��� ��� ���� ����zCommand.load_labelc s^ t j�|�\� }t j�|�r� g}||fS | j}t jjt j�|�v r+� fdd�|D �}||fS )Nc s g | ] }t j�|� ��qS r$ )r� r� �join)rW �dir_��dirnamer$ r% rY s z5Command.get_fixture_name_and_dirs.<locals>.<listcomp>)r� r� �split�isabs� fixture_dirs�sep�normpath)r" r� r� r� r$ r� r% �get_fixture_name_and_dirs s �z!Command.get_fixture_name_and_dirsc sL | j d g}|d u r | jn|g}|d u r| jn|g}� fdd�t|||�D �S )Nc s( h | ]}d � d� dd� |D ��f �qS )z%s.%s�.c S s g | ]}|r|�qS r$ r$ )rW �extr$ r$ r% rY + rZ z1Command.get_targets.<locals>.<setcomp>.<listcomp>)r� )rW �combo�r� r$ r% � <setcomp>' s ����z&Command.get_targets.<locals>.<setcomp>)r, rH rb r )r" r� r� r� � databases�cmp_fmts�ser_fmtsr$ r� r% � get_targets# s �zCommand.get_targetsc C sP g }t j�||�}t�t�|�d �D ]}t j�|�|v r%|�|||f� q|S )N�*)r� r� r� �glob�iglob�escaper� r )r" r� r� �targets�fixture_files_in_dirr� � candidater$ r$ r% �find_fixture_files_in_dir0 s �z!Command.find_fixture_files_in_dirN)�maxsizec C s� |t kr t dt fgS | �|�\}}}| jdkr | j�d| � | �|�\}}| �|||�}g }|D ]@}| jdkrB| j�dt|� � | �|||�} | jdkr\| s\| j�d|t|�f � t | �dkrlt d|t|�f ��|� | � q1|szt d| ��|S ) z%Find fixture files for a given label.NrI zLoading '%s' fixtures...zChecking %s for fixtures...zNo fixture '%s' in %s.r\ z-Multiple fixtures named '%s' in %s. Aborting.z No fixture named '%s' found.) � READ_STDINr� r( rL rM r� r� r� r� �lenr �extend) r" rj r� r� r� r� r� � fixture_filesr� r� r$ r$ r% rc : s< �� �� zCommand.find_fixturesc C s� g }t j}t|�tt|��krtd��t�� D ]2}|j}tj � |j d�}|dd� |D �v r5td||f ��| j r>|| j kr>qtj � |�rI|� |� q|�|� |� d� dd� |D �S )z� Return a list of fixture directories. The list contains the 'fixtures' subdirectory of each installed application, if it exists, the directories in FIXTURE_DIRS, and the current directory. z*settings.FIXTURE_DIRS contains duplicates.�fixturesc S s g | ]}t |��qS r$ )�str�rW �dr$ r$ r% rY r rZ z(Command.fixture_dirs.<locals>.<listcomp>zc'%s' is a default fixture directory for the '%s' app and cannot be listed in settings.FIXTURE_DIRS.r c S s g | ]}t j�|��qS r$ )r� r� �realpathr� r$ r$ r% rY s )r � FIXTURE_DIRSr� r` r r �get_app_configsrx r� r� r� r �isdirr r� )r" �dirsr� rq r �app_dirr$ r$ r% r� b s* �� � zCommand.fixture_dirsc C s� |t kr| js td��t | jdfS |�dd�}t|�dkr/|d | jv r/|d }|dd� }nd}t|�dkrZ|d | jv rI|d }|dd� }ntdd�|dd� �|d f ��d}d�|�}|||fS ) zW Split fixture name in name, serialization format, compression format. z3--format must be specified when reading from stdin.r9 r� rI r\ ���NzHProblem installing fixture '%s': %s is not a known serialization format.)r� r* r �rsplitr� rH rb r� )r" r� �partsr� r� �namer$ r$ r% r� � s. � �� zCommand.parse_name)�__name__� __module__� __qualname__r �missing_args_messager& r5 r rH rT r0 r{ rf r� r� r� � functools� lru_cacherc r� r� r$ r$ r$ r% r , s( �( : 8 ' r c s$ e Zd Z� fdd�Zdd� Z� ZS )rC c s. t � j|i |�� t| �� �dkrtd��d S )Nr\ z.Zip-compressed fixtures must contain one file.)�super�__init__r� �namelistrw )r" r �kwargs�rt r$ r% r� � s �zSingleZipReader.__init__c C s t j�| | �� d �S )Nr )�zipfile�ZipFile�readr� )r" r$ r$ r% r� � s zSingleZipReader.read)r� r� r� r� r� � __classcell__r$ r$ r� r% rC � s rC c C s | rd| S dS )Nz'%s'z absolute pathr$ r� r$ r$ r% r� � s r� )+r� r� rA r� r8 r� r� � itertoolsr � django.appsr � django.confr � django.corer �django.core.exceptionsr �django.core.management.baser r � django.core.management.colorr � django.core.management.utilsr � django.dbr r r r r r �django.utils.functionalr r= rD � ImportErrorr> rF r� r r� rC r� r$ r$ r$ r% �<module> sF � � { commands/__pycache__/migrate.cpython-310.pyc 0000644 00000030547 15030001101 0014674 0 ustar 00 o �h�S � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZmZm Z d dl m Z m Z d dl mZmZmZ d dlmZ d dlmZ d d lmZ d d lmZmZ d d lmZ d d l m Z G d d� de�Z dS )� N)� import_module)�apps)� BaseCommand� CommandError�no_translations)�emit_post_migrate_signal�emit_pre_migrate_signal)�DEFAULT_DB_ALIAS� connections�router)�MigrationAutodetector)�MigrationExecutor)�AmbiguityError)� ModelState� ProjectState)�module_has_submodule)� Truncatorc @ sF e Zd ZdZg Zdd� Zedd� �Zddd �Zd d � Z e d d � �Z dS )�CommandzMUpdates database schema. Manages both apps with migrations and those without.c C s� |j dddd� |j dddd� |j d dd d� |j d d d ddd� |j dtdd� |j dddd� |j dddd� |j dddd� |j dddd� |j d dd d d� |j d dd d!d� d S )"Nz --skip-checks� store_truezSkip system checks.)�action�help� app_label�?z5App label of an application to synchronize the state.)�nargsr �migration_namezpDatabase state will be brought to the state after that migration. Use the name "zero" to unapply all migrations.z --noinputz --no-input� store_false� interactivez:Tells Django to NOT prompt the user for input of any kind.)r �destr z --databasezHNominates a database to synchronize. Defaults to the "default" database.)�defaultr z--fakez5Mark migrations as run without actually running them.z--fake-initialz�Detect if tables already exist and fake-apply initial migrations if so. Make sure that the current database schema matches your initial migration before using this flag. Django will only check for an existing table name.z--planz=Shows a list of the migration actions that will be performed.z --run-syncdbz+Creates tables for apps without migrations.z--check�check_unappliedzbExits with a non-zero status if unapplied migrations exist and does not actually apply migrations.z--prune�prunez?Delete nonexistent migrations from the django_migrations table.)� add_argumentr )�self�parser� r$ �Z/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/migrate.py� add_arguments sv ������� ��� �zCommand.add_argumentsc % s� |d }|d s| j |gd� |d | _|d | _t�� D ]}t|jd�r+td|j� q t | }|� � t || j �}|j �|� |j �� }|rYd�d d � |�� D ��}td | ��|d } d } |d r�|d � zt�� � W n ty� } ztt| ���d } ~ ww | r�� |j jv r�td� ��n � |j jvr�td� ��|d r�|d r�|d } | dkr�� d fg} nGz |j �� | �}W n ty� td| � f �� ty� td| � f ��w � |jf}||j jjvr�||j j v r�|j j | }|j d }|g} d} n|d �r� fdd�|j j� � D �} n|j j� � } |d �r�|d �s#td��| jdk�r2| j � d | j!j"� t#|j j$�t#|j j%� ��fd d�|j j �� D �}|�ry| j � | j!�&d �� |D ]}|\}}| j � d |� d |� �� �qZ| j � | j!�&d!�� nTt'� fd"d ��D �����r��D ]6}|\}}| jdk�r�| j j | j!�(d#|� d |� ��d$d%� |j)�*||� | jdk�r�| j � | j!�+d&�� �q�n | jdk�r�| j � d'� |�,| �}|d( �r+| j � d)| j!j(� |�s�| j � d*� d S |D ]1\}}| j � t|�| j!j"� |j-D ] }| �.||�\}}|�r| j!j/nd }| j � d | |� �q��q�|d+ �r)t0�1d,� d S |d+ �r:|�r8t0�1d,� d S |d �rAd S |d �oI|j j2} | jd,k�r�| j � | j!�"d-�� | �r�|d �ro| j � | j!�(d.� �� n| j � | j!�(d/�d0�t'|j j2�� � | �r�| j � | j!�(d1�d0�t'd2d3� | D ����p�d4 � n4| d d, d u �r�| j � | j!�(d5�t| d d � � n| j � | j!�(d6�d7| d d, | d d f � |j3d d8�}|j}t4| j| j|j5| j ||d9� | �r| jd,k�r�| j � | j!�"d:�� |d �r | �6|� g� n| �6||j j2� | jd,k�r"| j � | j!�"d;�� |�sl| jd,k�rg| j � d<� t7|j �8� t9�:t��} | j;|j jd=�} | �rg| j � | j!�&d>d0�d?d � t'| �D �� �� | j � | j!�&d@�� d} d} n|dA } |dB } |j<| ||�=� | | dC�} | �>� | j}!|!�?� �! g }"|!j@D ]}#|#jA|#jBf}$|"�C|$� |!jD|$� �q�W d � n 1 �s�w Y |!�EdDd� |"D �� tF| j| j|j5| j |!|d9� d S )EN�database� skip_checks)� databases� verbosityr � managementz .managementz; c s s& � | ]\}}d d� |�|f V qdS )z%s in %s�, N)�join)�.0�app�namesr$ r$ r% � <genexpr>~ s � �z!Command.handle.<locals>.<genexpr>z�Conflicting migrations detected; multiple leaf nodes in the migration graph: (%s). To fix them run 'python manage.py makemigrations --merge'� run_syncdbTr z8Can't use run_syncdb with app '%s' as it has migrations.z"App '%s' does not have migrations.r �zerozJMore than one migration matches '%s' in app '%s'. Please be more specific.z4Cannot find a migration matching '%s' from app '%s'.���Fc s g | ] }|d � kr|�qS )r r$ )r. �key�r r$ r% � <listcomp>� s z"Command.handle.<locals>.<listcomp>r z7Migrations can be pruned only when an app is specified.r zPruning migrations:c s, g | ]\}}t � fd d�|jD ��r|�qS )c 3 s � | ]}|� v V qd S �Nr$ )r. �replaced��to_pruner$ r% r1 � � � z,Command.handle.<locals>.<listcomp>.<genexpr>)�any�replaces)r. � migration_key� migration_objr: r$ r% r7 � s ��z� Cannot use --prune because the following squashed migrations have their 'replaces' attributes and may not be recorded as applied:z �.z| Re-run 'manage.py migrate' if they are not marked as applied, and remove 'replaces' attributes in their Migration classes.c 3 s � | ] }|d � kr|V qdS )r Nr$ )r. � migrationr6 r$ r% r1 � s � �z Pruning � ��ending� OKz No migrations to prune.�planzPlanned operations:z" No planned migration operations.r � zOperations to perform:z Synchronize unmigrated app: %sz Synchronize unmigrated apps: r, z Apply all migrations: c S s h | ]\}}|�qS r$ r$ )r. �a�nr$ r$ r% � <setcomp> s z!Command.handle.<locals>.<setcomp>z(none)z Unapply all migrations: z Target specific migration: z %s, from %s)�with_applied_migrations)�stdoutr rG z&Synchronizing apps without migrations:zRunning migrations:z No migrations to apply.)�graphzl Your models in app(s): %s have changes that are not yet reflected in a migration, and so won't be applied.c s s � | ]}t |�V qd S r8 )�repr)r. r/ r$ r$ r% r1 U r< zk Run 'manage.py makemigrations' to make new migrations, and then re-run 'manage.py migrate' to apply them.�fake� fake_initial)rG �staterP rQ c S s g | ] }t �tj|� ��qS r$ )r � from_modelr � get_model)r. �modelr$ r$ r% r7 z s )G�checkr* r r �get_app_configsr �moduler �namer �prepare_databaser �migration_progress_callback�loader�check_consistent_history�detect_conflictsr- �itemsr �get_app_config� LookupError�str� migrated_apps�get_migration_by_prefixr �KeyErrorrN �nodes� replacementsr> � leaf_nodesrM �write�style�MIGRATE_HEADING�set�applied_migrations�disk_migrations�NOTICE�sorted� MIGRATE_LABEL�recorder�record_unapplied�SUCCESS�migration_plan� operations�describe_operation�WARNING�sys�exit�unmigrated_apps�_create_project_stater �alias� sync_appsr � project_stater � from_apps�changes�migrate�clone�clear_delayed_apps_cache� bulk_update� real_modelsr � name_lower�append�unregister_model�render_multipler )%r" �args�optionsr' � app_config� connection�executor� conflicts�name_strr2 �target_app_labels_only�errr �targetsrB �target�incomplete_migration�4squashed_migrations_with_deleted_replaced_migrationsr/ rY rG � backwards� operation�message�is_errorrj �pre_migrate_state�pre_migrate_apps� autodetectorr� rP rQ �post_migrate_state�post_migrate_apps� model_keys� model_state� model_keyr$ )r r; r% �handle` s� � ��� �� ��� � �� ��� � � � ��� �� � � �� � �� �� �� �� �� �� � � ������� � � � �zCommand.handleNFc C s� | j dkr�| j dk}|dkr&|rt�� | _| jjd| dd� | j�� d S |dkrU|r5dt�� | j nd}|rG| j�| j�d| �� d S | j�| j�d | �� d S |d krq|r`t�� | _| jjd | dd� | j�� d S |d kr�|r�dt�� | j nd}|r�| j�| j�d| �� d S | j�| j�d | �� d S |d kr�|r�t�� | _| jjddd� | j�� d S |dkr�|r�dt�� | j nd}| j�| j�d| �� d S d S d S )NrH � apply_startz Applying %s...rC rD � apply_successz (%.3fs)z FAKEDrF � unapply_startz Unapplying %s...�unapply_success� render_startz Rendering model states...�render_successz DONE) r* �time� monotonic�startrM ri �flushrj rt )r" r rB rP � compute_time�elapsedr$ r$ r% r[ � sF � � � �!z#Command.migration_progress_callbackc sJ �� � �}�j�|��W d � n1 sw Y � �fdd�t�� D �}��fdd���fdd�|D �}| jdkrA| j�d � ��� �V}|� � D ]5\}}|D ].} | j � ��sYqP| jd krj| j�d || j j f � | jdkry| j�d | j j � |�| � qPqJ| jdkr�| j�d � W d � dS W d � dS 1 s�w Y dS )z;Run the old syncdb-style operation on a list of app_labels.Nc s8 g | ]}|j d ur|j� v r|jtj|�jdd�f�qS )NF)�include_auto_created)� models_module�labelr �get_migratable_modelsr} )r. r� )� app_labelsr� r$ r% r7 � s ���z%Command.sync_apps.<locals>.<listcomp>c s6 | j }� jj}||j��v p|jo||jj j��v S r8 )�_meta� introspection�identifier_converter�db_table� auto_created)rU �opts� converter)r� �tablesr$ r% �model_installed� s �z*Command.sync_apps.<locals>.model_installedc s i | ] \}}|t t� |���qS r$ )�list�filter)r. �app_name� model_list)r� r$ r% � <dictcomp>� s ��z%Command.sync_apps.<locals>.<dictcomp>rH z Creating tables...� z Processing %s.%s modelz Creating table %sz Running deferred SQL...)�cursorr� � table_namesr rW r* rM ri � schema_editorr_ r� � can_migrate� object_namer� � create_model) r" r� r� r� � all_models�manifest�editorr� r� rU r$ )r� r� r� r� r% r~ � sD � � � �� � � �"�zCommand.sync_appsc C s� d}d}t | d�r|r| jn| j}|r|jpdnd}nt | d�r)|r%| jn| j}nd}|r/d}|dur<t|��dd�}n|rBd}d }|rHd | }t|�}|| � � |� d � |fS ) z@Return a string that describes a migration operation for --plan.rC F�codeN�sqlzUndo � � IRREVERSIBLETz -> �( ) �hasattr� reverse_coder� �__doc__� reverse_sqlr� rb �replacer �describe�chars)r� r� �prefixr� r� r � truncatedr$ r$ r% rw � s* � zCommand.describe_operation)NF) �__name__� __module__� __qualname__r �requires_system_checksr& r r� r[ r~ � staticmethodrw r$ r$ r$ r% r s �I )(9r ) ry r� � importlibr � django.appsr �django.core.management.baser r r �django.core.management.sqlr r � django.dbr r r �!django.db.migrations.autodetectorr � django.db.migrations.executorr �django.db.migrations.loaderr �django.db.migrations.stater r �django.utils.module_loadingr �django.utils.textr r r$ r$ r$ r% �<module> s commands/__pycache__/optimizemigration.cpython-310.pyc 0000644 00000007246 15030001101 0017016 0 ustar 00 o �hh � @ s� d dl Z d dlZd dlmZ d dlmZmZ d dlmZ d dl m Z d dl m Z d dl mZ d dlmZ d d lmZ d d lmZ G d d � d e�ZdS ) � N)�apps)� BaseCommand� CommandError)�run_formatters)� migrations)�AmbiguityError)�MigrationLoader)�MigrationOptimizer)�MigrationWriter)�get_docs_versionc @ s e Zd ZdZdd� Zdd� ZdS )�Commandz1Optimizes the operations for the named migration.c C s0 |j ddd� |j ddd� |j dddd � d S ) N� app_labelz;App label of the application to optimize the migration for.)�help�migration_namez.Migration name to optimize the operations for.z--check� store_truez>Exit with a non-zero status if the migration can be optimized.)�actionr )� add_argument)�self�parser� r �d/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/optimizemigration.py� add_arguments s �� �zCommand.add_argumentsc O sn |d }|d }|d }|d }zt �|� W n ty) } ztt|���d }~ww td �}||jvr;td|� d���z|�||�} W n# tyU td|� d|� d ��� t yf td |� d |� d ���w t � } | � | j | j �} t| j �t| �kr�|d kr�| j�d� d S |d kr�| j�dt| j �t| �f � |r�t�d� | | _ t| �} | �� } | jr�| jr�tdt� ��tdtjf| j| | j | j fgd��}d| j }|||�}t|�} | �� } |d kr�| j�| j � d�d � t � d�r�| j�| j �!d�� t"| j#ddd�� }|�| � W d � n 1 �sw Y t$| j#g� |d k�r5| j�| j � d | j#� ��� d S d S ) N� verbosityr r �checkzApp 'z' does not have migrations.z!More than one migration matches 'z ' in app 'z'. Please be more specific.z"Cannot find a migration matching 'z ' from app 'z'.r zNo optimizations possible.z/Optimizing from %d operations to %d operations.� z�Migration will require manual porting but is already a squashed migration. Transition to a normal migration first: https://docs.djangoproject.com/en/%s/topics/migrations/#squashing-migrations� Migration)� dependencies� operations�replacesz %s_optimizedzManual porting requiredz� Your migrations contained functions that must be manually copied over, as we could not safely copy their implementation. See the comment at the top of the optimized migration for details.�blackz^Optimized migration couldn't be formatted using the "black" command. You can call it manually.�wzutf-8)�encodingzOptimized migration )%r �get_app_config� LookupErrorr �strr � migrated_apps�get_migration_by_prefixr �KeyErrorr �optimizer r �len�stdout�write�sys�exitr � as_string�needs_manual_portingr r �typer r r �name�style�MIGRATE_HEADING�shutil�which�WARNING�open�pathr )r �args�optionsr r r r �err�loader� migration� optimizer�new_operations�writer�migration_file_string�subclass�optimized_migration_name�optimized_migration�fhr r r �handle s� �� �� ��� �� �� �� � �� � ��zCommand.handleN)�__name__� __module__� __qualname__r r rF r r r r r s r )r4 r, � django.appsr �django.core.management.baser r � django.core.management.utilsr � django.dbr � django.db.migrations.exceptionsr �django.db.migrations.loaderr � django.db.migrations.optimizerr �django.db.migrations.writerr �django.utils.versionr r r r r r �<module> s commands/__pycache__/dbshell.cpython-310.pyc 0000644 00000003064 15030001101 0014653 0 ustar 00 o �h� � @ s< d dl Z d dlmZmZ d dlmZmZ G dd� de�ZdS )� N)� BaseCommand� CommandError)�DEFAULT_DB_ALIAS� connectionsc @ s$ e Zd ZdZg Zdd� Zdd� ZdS )�CommandzaRuns the command-line client for specified database, or the default database if none is provided.c C s0 |j dtdd� |jddd�}|j ddd� d S ) Nz --databasezTNominates a database onto which to open a shell. Defaults to the "default" database.)�default�help� parametersz--)� prefix_chars�*)�nargs)� add_argumentr �add_argument_group)�self�parserr � r �Z/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/dbshell.py� add_arguments s �zCommand.add_argumentsc K sz t |d }z |j�|d � W d S ty td|jj �� tjy< } ztdd�|j �|j f |j d��d }~ww )N�databaser z@You appear not to have the %r program installed or on your path.z&"%s" returned non-zero exit status %s.� )� returncode) r �client�runshell�FileNotFoundErrorr �executable_name� subprocess�CalledProcessError�join�cmdr )r �options� connection�er r r �handle s( �� �����zCommand.handleN)�__name__� __module__� __qualname__r �requires_system_checksr r" r r r r r s � r )r �django.core.management.baser r � django.dbr r r r r r r �<module> s commands/__pycache__/dumpdata.cpython-310.pyc 0000644 00000014733 15030001101 0015042 0 ustar 00 o �h�* � @ s� d dl Z d dlZd dlZd dlmZ d dlmZ d dlmZm Z d dl m Z d dl m Z mZ zd dlZdZW n eyA dZY nw zd dlZdZW n eyU dZY nw G d d � d e�ZG d d � d e�ZdS ) � N)�apps)� serializers)� BaseCommand� CommandError)�parse_apps_and_model_labels)�DEFAULT_DB_ALIAS�routerTFc @ s e Zd ZdS )�ProxyModelWarningN)�__name__� __module__� __qualname__� r r �[/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/dumpdata.pyr s r c @ s e Zd ZdZdd� Zdd� ZdS )�Commandz�Output the contents of the database as a fixture of the given format (using each model's default manager unless --all is specified).c C s� |j ddddd� |j dddd � |j d td d � |j d tdd � |j dddg dd� |j ddddd� |j ddddd� |j d d dd d d� |j d d!d"d#� |j d$d%d&d'� d S )(N�argszapp_label[.ModelName]�*zHRestricts dumped data to the specified app_label or app_label.ModelName.)�metavar�nargs�helpz--format�jsonz7Specifies the output serialization format for fixtures.)�defaultr z--indentz>Specifies the indent level to use when pretty-printing output.)�typer z --databasezXNominates a specific database to dump fixtures from. Defaults to the "default" database.z-ez --exclude�appendzhAn app_label or app_label.ModelName to exclude (use multiple --exclude to exclude multiple apps/models).)�actionr r z--natural-foreign� store_true�use_natural_foreign_keysz/Use natural foreign keys if they are available.)r �destr z--natural-primary�use_natural_primary_keysz/Use natural primary keys if they are available.z-az--all�use_base_managerz�Use Django's base manager to dump all models stored in the database, including those that would otherwise be filtered or modified by a custom manager.z--pks� primary_keysz�Only dump objects with given primary keys. Accepts a comma-separated list of keys. This option only works when you specify one model.)r r z-oz--outputz.Specifies file to which the output is written.)r )� add_argument�intr )�self�parserr r r � add_arguments$ sn � ������� � �zCommand.add_argumentsc s |d }|d }|d �|d }|d }|d }|d �|d }|d �|d } | r5d d � | � d �D ��ng �t|�\��|sT�rEtd��t��fdd�t�� D ��� n�t|�dkr`�r`td��i � |D ]�} zX| � d�\} } zt�| �} W n t y� } ztt |���d }~ww | j d u s�| �v r�W qdz| � | �}W n t y� td| | f ��w � � | g �}|d ur�||vr�|�|� W qd ty� �r�td��| } zt�| �} W n t y� } ztt |���d }~ww | j d u s�| �v r�Y qdd � | < Y qdw |t�� v�rzt�|� W n tj�y Y nw td| ��d&� �����fdd� }z�d | j_d }d}|�rH| j�� �rH|d dk�rH| j}t|dd��}|�r�tj�|�\}}ti |ft ji |fti |fti |fti |fd �}t �rvt ji |f|d < t �r�t jdt j!i|f|d < t ji |f|d < z || \}}}W n t"�y� ti |}}}Y nw ||k�r�tj�#|�}t$�%d |� d!|� d"�t&� ||d#fi |��}nd }z tj'||� |�||�p�| j||d$� W |�r�|�(� W d S W d S |�r�|�(� w w t)�y } z |�r� td%| ��d }~ww )'N�format�indent�database�exclude�output� tracebackr r r r c S s g | ]}|� � �qS r )�strip)�.0�pkr r r � <listcomp>t s z"Command.handle.<locals>.<listcomp>�,z,You can only use --pks option with one modelc 3 s& � | ]}|j d ur|� vr|V qd S )N)� models_module)r, � app_config)� excluded_appsr r � <genexpr>} s � ��z!Command.handle.<locals>.<genexpr>� �.zUnknown model: %s.%sz Unknown serialization format: %sFc 3 s � �r t j� �� dd�}n g }� �� D ]\}}|du r#|�|�� � q|�|� q|D ]S}|�v r2q+|jjrG|jj|vrGtj d|jj t d� |jjs~t � �|�r~�rW|j}n|j}|����|jjj�}�rm|j�d�}| rw|�� �� V q+|�� E dH q+dS )z� Collate the objects to be serialized. If count_only is True, just count the number of objects to be serialized. T)� allow_cyclesNz,%s is a proxy model and won't be serialized.)�category)�pk__in)r �sort_dependencies�items�extend� get_models�_meta�proxy�proxy_for_model�warnings�warn�labelr r �allow_migrate_model� _base_manager�_default_manager�using�order_byr- �name�filter�count�iterator)� count_only�modelsr1 � model_list�model�objects�queryset)�app_list�excluded_modelsr r r rF r r � get_objects� s@ �� �� ��z#Command.handle.<locals>.get_objectsr � verbosityT)rL )�.bz2z.gz�.lzma�.xzz.ziprV rW rX z Unsupported file extension (z). Fixtures saved in 'z'.�wt)r& r r �stream�progress_output� object_countz Unable to serialize database: %s)F)*�splitr r �dict�fromkeysr �get_app_configs�len�get_app_config� LookupError�strr0 � get_model� setdefaultr � ValueErrorr � get_public_serializer_formats�get_serializer�SerializerDoesNotExist�stdout�ending�isatty�sum�os�path�splitext�open�gzip�has_bz2�bz2�has_lzma�lzma� FORMAT_ALONE�KeyError�basenamer@ rA �RuntimeWarning� serialize�close� Exception) r" � app_labels�optionsr% r& �excludesr) �show_tracebackr �pksrB � app_label� model_labelr1 �erO �app_list_valuerT r[ r\ � file_root�file_ext�compression_formats� open_method�kwargs� file_path� file_namerZ r )rR r2 rS r r r rF r �handleg s � �� �� � � �� �� ) ��� �� � � � ��zCommand.handleN)r r r r r$ r� r r r r r s � Cr )rs ro r@ � django.appsr � django.corer �django.core.management.baser r � django.core.management.utilsr � django.dbr r ru rt � ImportErrorrw rv �Warningr r r r r r �<module> s, � � commands/__pycache__/sqlsequencereset.cpython-310.pyc 0000644 00000002556 15030001101 0016636 0 ustar 00 o �h% � @ s0 d dl mZ d dlmZmZ G dd� de�ZdS )� )� AppCommand)�DEFAULT_DB_ALIAS� connectionsc s, e Zd ZdZdZ� fdd�Zdd� Z� ZS )�CommandzLPrints the SQL statements for resetting sequences for the given app name(s).Tc s t � �|� |jdtdd� d S )Nz --databasezNNominates a database to print the SQL for. Defaults to the "default" database.)�default�help)�super� add_arguments� add_argumentr )�self�parser�� __class__� �c/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/sqlsequencereset.pyr s �zCommand.add_argumentsc K s\ |j d u rd S t|d }|jdd�}|j�| j|�}|s)|d dkr)| j�d� d�|�S )N�databaseT)�include_auto_created� verbosity� zNo sequences found.� ) � models_moduler � get_models�ops�sequence_reset_sql�style�stderr�write�join)r � app_config�options� connection�models� statementsr r r �handle_app_config s zCommand.handle_app_config)�__name__� __module__� __qualname__r �output_transactionr r# � __classcell__r r r r r s � r N)�django.core.management.baser � django.dbr r r r r r r �<module> s commands/__pycache__/squashmigrations.cpython-310.pyc 0000644 00000014562 15030001101 0016644 0 ustar 00 o �hm* � @ s� d dl Z d dlZd dlmZ d dlmZ d dlmZmZ d dl m Z d dl m Z m Z mZ d dlmZmZ d dlmZ d d lmZ d d lmZ d d lmZ G d d � d e�ZdS )� N)�apps)�settings)� BaseCommand� CommandError)�run_formatters)�DEFAULT_DB_ALIAS� connections� migrations)�AmbiguityError�MigrationLoader)�SwappableTuple)�MigrationOptimizer)�MigrationWriter)�get_docs_versionc @ s( e Zd ZdZdd� Zdd� Zdd� ZdS ) �CommandzZSquashes an existing set of migrations (from first until specified) into a single new one.c C st |j ddd� |j dddd� |j dd d� |j d d d d � |j dddddd� |j ddd� |j ddddd� d S )N� app_labelz6App label of the application to squash migrations for.)�help�start_migration_name�?zGMigrations will be squashed starting from and including this migration.)�nargsr �migration_namez?Migrations will be squashed until and including this migration.z --no-optimize� store_truez/Do not try to optimize the squashed operations.)�actionr z --noinputz --no-input� store_false� interactivez:Tells Django to NOT prompt the user for input of any kind.)r �destr z--squashed-namez,Sets the name of the new squashed migration.z --no-header�include_headerz:Do not add a header comment to the new squashed migration.)� add_argument)�self�parser� r �c/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/squashmigrations.py� add_arguments sF ������ �zCommand.add_argumentsc s� |d | _ |d | _|d }|d }|d }|d }|d }|d }zt�|� W n ty; } ztt|���d }~ww ttt �� |� j vrMtd | ��| � � ||��� �fd d �� j � �j�jf�D �} |r�| � � ||�} � �| j| j�} z | �| �} | | d � } W n ty� td | �|f ��w | j d ks�| jr�| j�| j�d�� | D ] �| j�d�j � q�| jr�d } | r�| dvr�td�} | s�d} n | d �� } | r�| dvs�| dkr�d S g }t� }d}| D ]C}|jr�tdt� ��|� |j � |j D ]+}t |t ��rt!j"|j#k�r|�$d� q�|�$|� q�|d |jk�s |�r$|�$|� q�d}q�|�r>| j d k�r;| j�| j�d�� |}n>| j d k�rN| j�| j�d�� t%� }|�&|�j�}| j d k�r|t'|�t'|�k�rn| j�d� n| j�dt'|�t'|�f � g }| D ]��j�r�|� �j� �q�|�(�j�jf� �q�t)d t*j+f|||d ��}|�r�|�r�| j�,d d �\}}d ||f }nd!| j�jf }|||�}nd"|�p�d#�j }|||�}d|_-t.||�}t/j0�1|j0��r�td$|j� d%���t2|j0d&d'd(��} | �|�3� � W d � n 1 �s w Y t4|j0g� | j d k�rN| j�| j�d)|j0 �d* � |j5�rP| j�| j�d+�d, � t6�7d-��rR| j�| j�8d.�� d S d S d S d S )/N� verbosityr r r r � no_optimize� squashed_namer zLApp '%s' does not have migrations (so squashmigrations on it makes no sense)c s& g | ]\}}|�j kr� �||��qS r )r � get_migration)�.0�al�mn��loader� migrationr r! � <listcomp>X s �z"Command.handle.<locals>.<listcomp>z�The migration '%s' cannot be found. Maybe it comes after the migration '%s'? Have a look at: python manage.py showmigrations %s to debug this issue.r z%Will squash the following migrations:z - %s�ynz Do you wish to proceed? [yN] �n�yTz�You cannot squash squashed migrations! Please transition it to a normal migration first: https://docs.djangoproject.com/en/%s/topics/migrations/#squashing-migrations)� __setting__�AUTH_USER_MODELFz(Skipping optimization.)z Optimizing...z No optimizations possible.z0 Optimized from %s operations to %s operations.� Migration)� dependencies� operations�replaces�_� z%s_%sz%s_squashed_%sz0001_%sz squashed_%sz Migration z& already exists. Use a different name.�wzutf-8)�encodingz!Created new squashed migration %sz� You should commit this migration but leave the old ones in place; the new migration will be used for new installs. Once you are sure all instances of the codebase have applied the migrations you squashed, you can delete them.zManual porting requiredz� Your migrations contained functions that must be manually copied over, as we could not safely copy their implementation. See the comment at the top of the squashed migration for details.�blackz]Squashed migration couldn't be formatted using the "black" command. You can call it manually.)9r# r r �get_app_config� LookupErrorr �strr r r � migrated_apps�find_migration�graph� forwards_planr �namer& �index� ValueError�stdout�write�style�MIGRATE_HEADING�input�lower�setr6 r �extendr5 r4 � isinstancer r r2 �setting�addr �optimize�len�append�typer r3 �split�initialr �os�path�exists�open� as_stringr �needs_manual_porting�shutil�which�WARNING) r �optionsr r r r$ r% r �err�migrations_to_squash�start_migration�start� start_index�answerr5 r4 �first_migration� smigration� dependency�new_operations� optimizerr6 �subclass�prefixr7 rC � new_migration�writer�fhr r* r! �handle> s. �� �� ���� ��� � ��� � � ���� � � ��� � ��� zCommand.handlec C sJ z|� ||�W S ty td||f �� ty$ td||f ��w )NzJMore than one migration matches '%s' in app '%s'. Please be more specific.z4Cannot find a migration matching '%s' from app '%s'.)�get_migration_by_prefixr r �KeyError)r r+ r rC r r r! r@ � s �� ���zCommand.find_migrationN)�__name__� __module__� __qualname__r r" rq r@ r r r r! r s �( Br )rW r] � django.appsr � django.confr �django.core.management.baser r � django.core.management.utilsr � django.dbr r r �django.db.migrations.loaderr r � django.db.migrations.migrationr � django.db.migrations.optimizerr �django.db.migrations.writerr �django.utils.versionr r r r r r! �<module> s commands/__pycache__/makemessages.cpython-310.pyc 0000644 00000050234 15030001101 0015704 0 ustar 00 o �h�r � @ sP d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dlm Z d dl Z d dl m Z d dl mZ d dlmZ d dlmZmZ d d lmZmZmZmZ d d lmZ d d lm Z d d l m Z d d l m Z d dl!m"Z" d dl#m$Z$ e dej%ej&B �Z'd Z(e)� Z*dd� Z+dd� Z,eG dd� d��Z-G dd� d�Z.dd� Z/dd � Z0G d d � d e�Z1dS ) � N)�total_ordering)� dropwhile)�Path)�settings)�ImproperlyConfigured)�NamedTemporaryFile)� BaseCommand� CommandError)� find_command�handle_extensions�is_ignored_path� popen_wrapper)�DEFAULT_LOCALE_ENCODING)�cached_property)�prepare_js_for_gettext)�_lazy_re_compile)� get_text_list)� templatizez$^(?P<value>"Plural-Forms.+?\\n")\s*$c G s& | D ]}t |�d u rtd| ��qd S )NzLCan't find %s. Make sure you have GNU gettext tools 0.15 or newer installed.)r r )�programs�program� r �_/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/makemessages.py�check_programs" s ����r c C s t �d| �p t �d| �S )Nz^[a-z]+$z^[a-z]+_[A-Z].*$)�re�match)�localer r r �is_valid_locale+ s r c @ s8 e Zd Zdd� Zdd� Zdd� Zdd� Zed d � �Zd S ) �TranslatableFilec C s || _ || _|| _d S �N)�file�dirpath� locale_dir)�selfr � file_namer! r r r �__init__1 � zTranslatableFile.__init__c C s d| j jtj�| j| jg�f S )Nz<%s: %s>)� __class__�__name__�os�sep�joinr r �r" r r r �__repr__6 s �zTranslatableFile.__repr__c C s | j |j kS r ��path�r" �otherr r r �__eq__< � zTranslatableFile.__eq__c C s | j |j k S r r- r/ r r r �__lt__? r2 zTranslatableFile.__lt__c C s t j�| j| j�S r )r( r. r* r r r+ r r r r. B s zTranslatableFile.pathN) r' � __module__� __qualname__r$ r, r1 r3 �propertyr. r r r r r / s r c @ sT e Zd ZdZdd� Zedd� �Zedd� �Zedd � �Zd d � Z d d � Z dd� Z dS )� BuildFilezN Represent the state of a translatable file during the build process. c C s || _ || _|| _d S r )�command�domain� translatable)r" r8 r9 r: r r r r$ L r% zBuildFile.__init__c C s@ | j dkr | jjdk S | j dkr tj�| jj�d }|dkS dS )N�djangojs)r � � �django� z.pyF)r9 r8 �gettext_versionr( r. �splitextr: r )r" �file_extr r r �is_templatizedQ s zBuildFile.is_templatizedc C s | j jS r )r: r. r+ r r r r. Z s zBuildFile.pathc C s@ | j s| jS ddd��| j�}d| jj|f }tj�| jj|�S )z� Path to a file which is being fed into GNU gettext pipeline. This may be either a translatable or its preprocessed version. �c�py�r; r> z%s.%s) rC r. �getr9 r: r r( r* r )r" � extension�filenamer r r � work_path^ s ��zBuildFile.work_pathc C s� | j sdS t| jdd�� }|�� }W d � n1 sw Y | jdkr*t|�}n| jdkr:t|| jdd� d�}t| jddd��}|�|� W d � dS 1 sSw Y dS ) zz Preprocess (if necessary) a translatable file before passing it to xgettext GNU gettext utility. N�utf-8��encodingr; r> � )�origin�w) rC �openr. �readr9 r r rJ �write)r" �fp�src_data�contentr r r � preprocessm s � "�zBuildFile.preprocessc sj | j s|S tjdkr| j�| j� n| jdd� �| jdd� � tjdt��� d � �fdd�|tjd�S ) z� Postprocess messages generated by xgettext GNU gettext utility. Transform paths as if these messages were generated from original translatable files rather than from preprocessed versions. �ntrN Nz ^(#: .*)(�)c s | d � �� �S )Nr )�replace�r ��new_path�old_pathr r �<lambda>� s z0BuildFile.postprocess_messages.<locals>.<lambda>)�flags) rC r( �namerJ r. r �sub�escape� MULTILINE)r" �msgsr r\ r �postprocess_messages� s �z BuildFile.postprocess_messagesc C s, | j rtj�| j�rt�| j� dS dS dS )zM Remove a preprocessed copy of a translatable file (if any). N)rC r( r. �existsrJ �unlinkr+ r r r �cleanup� s �zBuildFile.cleanupN) r' r4 r5 �__doc__r$ r rC r. rJ rW rf ri r r r r r7 G s r7 c C s( | � � }|r|d r|�d� d�|�S )a Take a block of raw text that will be passed through str.splitlines() to get universal newlines treatment. Return the resulting block of text with normalized ` ` EOL sequences ready to be written to disk using current platform's native EOLs. ���� � )� splitlines�appendr* )� raw_contents� lines_listr r r �normalize_eols� s rr c C s� |� � }tj�| �rtt|�}n&g }d\}}|D ] }|s*|s*d|v r*d}|�dd�}|s0|s0d}|�|� qd�|�}t | dddd��}|� |� W d � d S 1 sTw Y d S ) z\ Write the `potfile` with the `msgs` contents, making sure its format is valid. )FFzcharset=CHARSETTz charset=UTF-8rm �arK )rM �newlineN) rn r( r. rg r �lenrZ ro r* rQ rS )�potfilere � pot_lines�lines�found� header_read�linerT r r r �write_pot_file� s" "�r| c @ s� e Zd ZdZeZeZg Zg d�Z dgZ dgZ ddgZ dd� Z d d � Zed d � �Zed d� �Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd S ) �CommandaH Runs over the entire source tree of the current directory and pulls out all strings marked for translation. It creates (or updates) a message file in the conf/locale (in the django tree) or locale (for projects and applications) directory. You must run this command with one of either the --locale, --exclude, or --all options.)z-qz --backup=nonez --previousz--updatez--to-code=utf-8� --no-obsoletez--from-code=UTF-8z--add-comments=Translatorsc C s� |j ddg ddd� |j ddg ddd� |j d d d d d � |j ddddd� |j dddddd� |j ddddd� |j dd dd g d d d � |j d!d"d#d$d%� |j d&dd'd� |j d(dd)d� |j d*d+d,d-d.d/� |j d0dd1d� |j d2dd3d� d S )4Nz--localez-lro zfCreates or updates the message files for the given locale(s) (e.g. pt_BR). Can be used multiple times.)�default�action�helpz --excludez-xz@Locales to exclude. Default is none. Can be used multiple times.z--domain�-dr> z4The domain of the message files (default: "django").)r r� z--allz-a� store_truez3Updates the message files for all existing locales.)r� r� z --extensionz-e� extensionsz�The file extension(s) to examine (default: "html,txt,py", or "js" if the domain is "djangojs"). Separate multiple extensions with commas, or use -e multiple times.)�destr� r� z --symlinksz-szaFollows symlinks to directories when examining source code and templates for translation strings.z--ignorez-i�ignore_patterns�PATTERNz`Ignore files or directories matching this glob-style pattern. Use multiple times to ignore more.)r� r� r �metavarr� z--no-default-ignore� store_false�use_default_ignore_patternszJDon't ignore the common glob-style patterns 'CVS', '.*', '*~' and '*.pyc'.)r� r� r� � --no-wrapz2Don't break long message lines into several lines.� --no-locationz%Don't write '#: filename:line' lines.z--add-location)�fullr �neverr� �?a' Controls '#: filename:line' lines. If the option is 'full' (the default if not given), the lines include both file name and line number. If it's 'file', the line number is omitted. If it's 'never', the lines are suppressed (same as --no-location). --add-location requires gettext 0.19 or newer.)�choices�const�nargsr� r~ z Remove obsolete message strings.z --keep-potz<Keep .pot file after making messages. Useful when debugging.)� add_argument)r" �parserr r r � add_arguments� s� � ���� �� � ��� � �zCommand.add_argumentsc s� |d }|d }|d | _ |d | _|d }|d }|d | _|d }|d r-|g d �7 }tt|��| _|d rd| jd d � d g | _| jd d � d g | _| jd d � d g | _| j d d � d g | _ |d r�| jd d � dg | _| jd d � dg | _| jd d � dg | _| j d d � dg | _ |d r�| j dk r�t dd� dd� | j D �� ��d|d }| jd d � |g | _| jd d � |g | _| jd d � |g | _| j d d � |g | _ |d | _ |d | _| j dvr�t d��| j dkr�|p�dg} n|�pg d �} t| �| _|�s|�s|�r| j d u �r)t d tj�tjd �tjd f ��| jd k�r=| j�d tt| j�d!� � d"| _g | _d | _tj� tj� d#d���ritj� tj� d#d��g| _| jd | _d$| _n.| j �rt| j� t j!� tj� d��r�| j�"tj� d�� | j�r�| jd | _tj#| jd$d%� t$�%d&�� t&tjj t'�'d'| j ��} � fd(d)�t(tjj| �D �} |�r�| } n |�p�| } t| ��)|�} | �r�t*d*d+d,� t*d-� z�| �+� } | D ]m}t,|��s/t$�-d.|�}|�r|�.� }|d/ �/� }|d0 d d1� �0� |d0 d1d � }|� d2|� �}n|�/� }t,|��r%| j�d3||f � n| j�d4| � �q�| jd k�r=| j�d5| � | D ] }| �1||� �q?�q�W | j�sV| �2� d S d S | j�sa| �2� w w )6Nr �excluder9 � verbosity�allr� �symlinksr� r� )�CVSz.*z*~z*.pyc�no_wrapr� � no_locationr� � add_location)r � zFThe --add-location option requires gettext 0.19 or later. You have %s.�.c s s � | ]}t |�V qd S r )�str)�.0�xr r r � <genexpr>c s � z!Command.handle.<locals>.<genexpr>z--add-location=%s� no_obsolete�keep_pot)r> r; zDcurrently makemessages only supports domains 'django' and 'djangojs'r; �js)�html�txtrE z(Type '%s help %s' for usage information.r r? z'examining files with the extensions: %s�andF�confT��exist_okz[a-z]{2}z%s/*c s g | ] }� � |�r|�qS r r[ )r� � lang_code��looks_like_localer r � <listcomp>� s ��z"Command.handle.<locals>.<listcomp>�msguniq�msgmerge� msgattrib�xgettextzB^(?P<language>[a-zA-Z]+)(?P<separator>[^a-zA-Z])(?P<territory>.+)$�language� territoryrN �_z#invalid locale %s, did you mean %s?zinvalid locale %szprocessing locale %s)3r9 r� r� �list�setr� �msgmerge_options�msguniq_options�msgattrib_options�xgettext_optionsr@ r r* r� r� r r� r( r. �basename�sys�argv�stdoutrS r �invoked_for_django� locale_paths�default_locale_path�isdir�abspath�settings_available�extendr � LOCALE_PATHSro �makedirsr �compile�filter�glob�map� differencer �build_potfilesr r � groupdict�lower�upper� write_po_file�remove_potfiles)r" �args�optionsr r� � process_allr� r� �arg_add_location�exts� locale_dirs� all_locales�locales�potfilesr � locale_partsr� r� �proposed_localerv r r� r �handleF s� �� � �� �� � � � �� ��� ��* � �zCommand.handlec C sD t ddgtd�\}}}t�d|�}|r tdd� |�� D ��S td��)Nr� z --version)�stdout_encodingz(\d+)\.(\d+)\.?(\d+)?c s s � | ] }|d urt |�V qd S r )�int)r� �dr r r r� � s � z*Command.gettext_version.<locals>.<genexpr>z/Unable to get gettext version. Is it installed?)r r r �search�tuple�groupsr )r" �out�err�status�mr r r r@ � s � zCommand.gettext_versionc C s8 zt j W dS ty | jdkr| j�d� Y dS w )Nr? z$Running without configured settings.FT)r r� r r� �stderrrS r+ r r r r� � s � �zCommand.settings_availablec C s� | � d�}| �� | �|� g }| jD ]_}tj�|d| j �}tj�|�s&qdg| j |g }t |�\}}}|rM|t krBt d| ��| j dkrM| j�|� t|�}t|ddd�� } | �|� W d � n1 shw Y |�|� q|S ) z< Build pot files and apply msguniq to them. r� �%s.potr� z(errors happened while running msguniq %sr rP rK rL N)� find_filesr� � process_filesr� r( r. r* r9 rg r� r � STATUS_OKr r� r� rS rr rQ ro ) r" � file_listr� r. rv r� re �errorsr� rT r r r r� � s. � � zCommand.build_potfilesc C s: | j D ]}tj�|d| j �}tj�|�rt�|� qd S )Nr� )r� r( r. r* r9 rg rh )r" r. �pot_pathr r r r� s ��zCommand.remove_potfilesc C s� g }g }| j rdd� tjtjfD �}tj|d| jd�D ]�\}}}|dd� D ]J}ttj� tj� ||��| j �sDtj� tj� |�|�|v rW|� |� | jdkrV| j�d| � q&|dkrp|� |� | j�d tj� tj� |�|�� q&|D ]Z}tj� tj� ||��} tj�|�d } | | jvs�t| | j �r�| jdkr�| j�d ||f � qsd} | jD ]} tj� |��tj�| ��r�| } nq�| p�| jp�t} |�| �||| �� qsqt|�S ) zx Get all files in the given root. Also check that there is a matching locale dir for each file. c S s g | ] }|rt j�|��qS r )r( r. �normpath)r� �pr r r r� s � �z&Command.find_files.<locals>.<listcomp>T)�topdown� followlinksNr? zignoring directory %sr r zignoring file %s in %s) r� r � MEDIA_ROOT� STATIC_ROOTr( �walkr� r r. r� r* r� r� �remover� r� rS r� �insertrA r� � startswith�dirnamer� � NO_LOCALE_DIRro �translatable_file_class�sorted) r" �root� all_files� ignored_rootsr �dirnames� filenamesr� rI � file_pathrB r! r. r r r r� sb ���� � �� � �� � ��zCommand.find_filesc C sH i }|D ]}|� |jg �}|�|� q|�� D ] \}}| �||� qdS )zu Group translatable files by locale directory and run pot file build process for each group. N)� setdefaultr! ro �items�process_locale_dir)r" r� � file_groupsr: � file_groupr! �filesr r r r� M s �zCommand.process_filesc C s| g }|D ]\}| j dkr| j�d|j|jf � | jdvr q| �| | j|�}z|�� W n/ tyJ } z| j�d|j|j|f � W Y d}~qd}~w t yZ |D ]}|� � qR� w |� |� q| jdkr~|j }dd| jd |rrd nd f d d ddddg }n| jdkr�dd| jdd d ddddddg }ndS dd� |D �} t dd��)} | �d�| �� | �� |�d| jg� |�| j� t|�\} } } W d � n1 s�w Y | r�| tkr�|D ]}|� � q�td d�| �| f ��| j d kr�| j�| � | �r2|tu �r|D ]}|� � �qtj�|d j�}td | ��|D ]}|�| �} �qtj�|d | j �}t|| � |D ]}|� � �q4dS ) z� Extract translatable literals from the specified files, creating or updating the POT file for a given locale directory. Use the xgettext GNU gettext utility. r? zprocessing file %s in %srF z6UnicodeDecodeError: skipped file %s in %s (reason: %s)Nr; r� r� z --language=%s�C� JavaScriptz--keyword=gettext_noopz--keyword=gettext_lazyz--keyword=ngettext_lazy:1,2z--keyword=pgettext:1c,2z--keyword=npgettext:1c,2,3z --output=-r> z--language=Pythonz --keyword=pgettext_lazy:1c,2z --keyword=npgettext_lazy:1c,2,3c S s g | ]}|j �qS r )rJ )r� �bfr r r r� � s z.Command.process_locale_dir.<locals>.<listcomp>zw+)�moderm z --files-fromz/errors happened while running xgettext on %s %sr z�Unable to find a locale path to store translations for file %s. Make sure the 'locale' directory exists in an app or LOCALE_PATHS setting is set.r� ) r� r� rS r r r9 �build_file_classrW �UnicodeDecodeError� BaseExceptionri ro rC r r* �flushr� ra r� r r� r r� r( r. r� rf r| )r" r! r � build_filesr: � build_file�erC r� � input_files�input_files_listre r� r� r rv r r r r Y s� �� ��� � � � � � �� �� �zCommand.process_locale_dirc C s� t j�t j�|�|d�}t j|dd� t j�|d| j �}t j�|�rTdg| j ||g }t|�\}}}|rK|t kr@t d| ��| j dkrK| j � |� t|�jdd �} n#t|dd �� } | �� } W d � n1 siw Y | jsw| �| |�} t| �} | �d | j d �} t|d dd �� } | � | � W d � n1 s�w Y | jr�dg| j d||g }t|�\} }}|r�|t kr�t d| ��| j dkr�| j � |� d S d S d S d S )z� Create or update the PO file for self.domain and `locale`. Use contents of the existing `potfile`. Use msgmerge and msgattrib GNU gettext utilities. � LC_MESSAGESTr� �%s.por� z)errors happened while running msgmerge %sr rK rL Nz2#. #-#-#-#-# %s.pot (PACKAGE VERSION) #-#-#-#-# rl rP r� z-oz*errors happened while running msgattrib %s)r( r. r* r� r� r9 rg r� r r� r r� r� rS r � read_textrQ rR r� �copy_plural_formsrr rZ r� r� ) r" rv r �basedir�pofiler� r� r� r� re rT r r r r� � sN � � � �� �zCommand.write_po_filec C s t j�t j�t j�tj���}| jdkrd}nd}|D ]j}t j�|dd|dd| �}t j�|�r�t |dd ��}t � |� � �}W d � n1 sHw Y |r�|d } | j d kr`| j�d | � g } d} |�� D ]} | sw| rst � | �rw| } d} | �| � qhd�| �} |S q|S )z� Copy plural forms header contents from a Django catalog of locale to the msgs string, inserting it at the right place. msgs should be the contents of a newly created .po file. r; rF )r> r� r r r rK rL N�valuer? zcopying plural forms: %sFTrm )r( r. r� r* r� r> �__file__r9 rg rQ �plural_forms_rer� rR r� r� rS rn ro ) r" re r � django_dir�domainsr9 � django_porT r� �plural_form_linerx ry r{ r r r r � s8 � � � zCommand.copy_plural_formsN)r' r4 r5 r� r r r7 r �requires_system_checksr� r� r� r� r� r� r r@ r� r� r� r� r� r r� r r r r r r} � s0 �c 6 j -r} )2r� r( r r� � functoolsr � itertoolsr �pathlibr r> � django.confr �django.core.exceptionsr �django.core.files.tempr �django.core.management.baser r � django.core.management.utilsr r r r �django.utils.encodingr �django.utils.functionalr �django.utils.jslexr �django.utils.regex_helperr �django.utils.textr �django.utils.translationr rd �DOTALLr# r� �objectr� r r r r7 rr r| r} r r r r �<module> s@ � _ commands/__pycache__/sqlflush.cpython-310.pyc 0000644 00000002474 15030001101 0015103 0 ustar 00 o �h� � @ s< d dl mZ d dlmZ d dlmZmZ G dd� de�ZdS )� )� BaseCommand)� sql_flush)�DEFAULT_DB_ALIAS� connectionsc s, e Zd ZdZdZ� fdd�Zdd� Z� ZS )�Commandz�Returns a list of the SQL statements required to return all tables in the database to the state they were in just after they were installed.Tc s t � �|� |jdtdd� d S )Nz --databasezNNominates a database to print the SQL for. Defaults to the "default" database.)�default�help)�super� add_arguments� add_argumentr )�self�parser�� __class__� �[/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/sqlflush.pyr s �zCommand.add_argumentsc K s: t | jt|d �}|s|d dkr| j�d� d�|�S )N�database� verbosity� zNo tables found.� )r �styler �stderr�write�join)r �options�sql_statementsr r r �handle s zCommand.handle)�__name__� __module__� __qualname__r �output_transactionr r � __classcell__r r r r r s � r N)�django.core.management.baser �django.core.management.sqlr � django.dbr r r r r r r �<module> s commands/__pycache__/startapp.cpython-310.pyc 0000644 00000001555 15030001101 0015077 0 ustar 00 o �h� � @ s d dl mZ G dd� de�ZdS )� )�TemplateCommandc s$ e Zd ZdZdZ� fdd�Z� ZS )�Commandz~Creates a Django app directory structure for the given app name in the current directory or optionally in the given directory.z%You must provide an application name.c s0 |� d�}|� d�}t� jd||fi |�� d S )N�name� directory�app)�pop�super�handle)�self�options�app_name�target�� __class__� �[/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/startapp.pyr s zCommand.handle)�__name__� __module__� __qualname__�help�missing_args_messager � __classcell__r r r r r s �r N)� django.core.management.templatesr r r r r r �<module> s commands/__pycache__/inspectdb.cpython-310.pyc 0000644 00000023305 15030001101 0015211 0 ustar 00 o �h8C � @ sP d dl Z d dlZd dlmZmZ d dlmZmZ d dlm Z G dd� de�Z dS )� N)� BaseCommand� CommandError)�DEFAULT_DB_ALIAS� connections)� LOOKUP_SEPc @ sL e Zd ZdZg ZdZdZdd� Zdd� Zdd � Z d d � Z d d � Z dd� Z dS )�CommandzXIntrospects the database tables in the given database and outputs a Django model module.)�table_name_filterz django.dbc C sF |j ddtdd� |j dtdd� |j dd d d � |j d d d d � d S )N�table�*z4Selects what tables or views should be introspected.)�nargs�type�helpz --databasezMNominates a database to introspect. Defaults to using the "default" database.)�defaultr z--include-partitions� store_truez(Also output models for partition tables.)�actionr z--include-viewsz&Also output models for database views.)� add_argument�strr )�self�parser� r �\/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/inspectdb.py� add_arguments s* ��� �zCommand.add_argumentsc K s: z| � |�D ]}| j�|� qW d S ty td��w )NzPDatabase inspection isn't supported for the currently selected database backend.)�handle_inspection�stdout�write�NotImplementedErrorr )r �options�liner r r �handle, s � ��zCommand.handlec ) # s � t |d }|�d�}dd� }|�� ��g}dV dV dV dV d V d V d V d | j V g }d h� |d r?� �d� |d rH� �d� |j�|�}� fdd�|D �}|d pctdd� |D ��D �]}|d urtt|�rt||�stqdzKz |j� ||�} W n t y� i } Y nw z |j� ||�} W n t y� i } Y nw |j� ||�} | r�| d nd } dd� | � � D �} |j�||�}W n ty� } zd| V d| V W Y d }~qdd }~ww ||�}d V d V d | V |�|� g }i }t� }|D �]J}g }i }|j}|| v }| �|||�\}}}|�|� |�|� |�|� |||< || k�r?d |d < t| �d k�r>|�d!d"�| � � n || v �rHd |d#< |�r�| | \} } |�d#d$��s^|�d ��rad%} nd&} |j�|| �} | �rv| | k�rv| |d'< | |k�r}d(n|| �} | |v �r�d)| | f }!nd*| | f }!| |v �r�d+|�� |f |d,< |�| � n| �|||�\}!}"}#|�|"� |�|#� |!d-7 }!|d.k�r�|d d ik�r�|!d/k�r�q�|!|j j d0 d- k�r�|�d1� |j �r�d |d2< d |d3< d4|d5|!v �r�d nd6|!f }$|!� d7��r|$d87 }$|j j �r|j!�r|j!|d9< |�r/|$�"d-��s!|$d"7 }$|$d"�d:d� |�#� D ��7 }$|$d;7 }$|�r?|$d<d=�|� 7 }$d>|$ V q�d }%|�|� }&�rb|&j$dk}'|&j$dk}(|j j �ra|&j!}%nd$}'d$}(| �%|| ||'|(|%�E d H qdW d � d S 1 �s�w Y d S )?N�databaser c S s t �dd| �� �S )Nz [^a-zA-Z0-9]� )�re�sub�title)� table_namer r r � table2model; s z.Command.handle_inspection.<locals>.table2modelz0# This is an auto-generated Django model module.z<# You'll have to do the following manually to clean this up:z # * Rearrange models' orderz># * Make sure each model has one field with primary_key=Truez]# * Make sure each ForeignKey and OneToOneField has `on_delete` set to the desired behaviorzh# * Remove `managed = False` lines if you wish to allow Django to create, modify, and delete the tablezR# Feel free to rename the models, but don't rename db_table values or field names.zfrom %s import models�t�include_partitions�p� include_views�vc s i | ] }|j � v r|j|�qS r )r �name)�.0�info��typesr r � <dictcomp>X s z-Command.handle_inspection.<locals>.<dictcomp>r c s s � | ]}|V qd S �Nr )r, r+ r r r � <genexpr>Z s � z,Command.handle_inspection.<locals>.<genexpr>r c S s0 g | ]}|d rt |d �dkr|d d �qS )�unique�columns� r )�len�r, �cr r r � <listcomp>s s � �z-Command.handle_inspection.<locals>.<listcomp>z # Unable to inspect table '%s'z# The error was: %sr zclass %s(models.Model):T� primary_keyr5 zZThe composite primary key (%s) found, that is not supported. The first column is selected.�, r3 F� OneToOneField� ForeignKey�to_fieldr z%s(%sz%s('%s'z %s_%s_set� related_name�(�idz AutoField(� AutoFieldz AutoField?�blank�nullz %s = %s%s�.zmodels.)z ForeignKey(zOneToOneField(z, models.DO_NOTHING� db_commentc s s � | ] \}}d ||f V qdS )z%s=%rNr )r, �kr* r r r r2 � s � ��)z # � z %s)&r �get�cursor� db_module�add� introspection�get_table_list�sorted�callable� get_relationsr �get_constraints�get_primary_key_columns�values�get_table_description� Exception�append�setr+ �normalize_col_name�update�extendr6 �join�pop�get_primary_key_column�lower�get_field_type�features�introspected_field_types�null_ok� startswith�supports_comments�comment�endswith�itemsr �get_meta))r r � connectionr r% rK � known_models� table_infor$ � relations� constraints�primary_key_columns�primary_key_column�unique_columns�table_description�e� model_name�used_column_names�column_to_field_name�used_relations�row� comment_notes� extra_params� column_name� is_relation�att_name�params�notes� ref_db_column� ref_db_table�rel_type� ref_pk_column�rel_to� field_type� field_params� field_notes� field_descrg r- �is_view� is_partitionr r. r r 6 s` � ��� � �� ������ �� � � ��� ��� �� � � �� � � � � ��$�zCommand.handle_inspectionc C s� i }g }|� � }||kr|�d� |r#|�d�r |dd� }n||d< t�dd|�\}}|dkr5|�d � |�t�dkr^|�t�dkrP|�td�}|�t�dksC|� � �t�dkr^|�d � |�d�rld | }|�d � |�d�rzd | }|�d� t � |�r�|d7 }|�d� |d � � r�d| }|�d� ||v r�d}d||f |v r�|d7 }d||f |v s�d||f }|�d� ||kr�|r�||d< |||fS )zU Modify the column name to make it Python-compatible as a field name zField name made lowercase.�_idN���� db_columnz\W�_r z.Field renamed to remove unsuitable characters.z>Field renamed because it contained more than one '_' in a row.zfield%sz*Field renamed because it started with '_'.z%sfieldz(Field renamed because it ended with '_'.�_fieldz4Field renamed because it was a Python reserved word.z number_%sz:Field renamed because it wasn't a valid Python identifier.z%s_%dr5 z'Field renamed because of name conflict.) r` rX rh r! �subn�findr �replacere �keyword� iskeyword�isdigit) r �col_namerv r} r� r� �new_name�num_repl�numr r r rZ sX �� �� zCommand.normalize_col_namec C s� i }g }z |j �|j|�}W n ty d}|�d� Y nw |dkr5|jr5t|j� }r5|dkr5||d< |dv rA|jrA|j|d< |dkrw|jd u sO|j d u rm|�d � |jd ur\|jnd |d < |j d urh|j nd |d< n |j|d < |j |d< |||fS )z� Given the database connection, the table name, and the cursor row description, this routine will return the given field type name, as well as any additional keyword parameters and notes for the field. � TextFieldzThis field type is a guess.� CharFieldr � max_length> r� r� � db_collation� DecimalFieldNzamax_digits and decimal_places have been guessed, as this database handles decimal fields as float� � max_digits� �decimal_places) rN ra � type_code�KeyErrorrX � display_size�int� collation� precision�scale)r rk r$ ry r� r� r� �sizer r r ra E s2 � ��� zCommand.get_field_typec s� g }d}|� � D ]/} | d r7| d } d| v rd}� fdd�| D �} t| �dkr7|�tt� fd d �| D ���� q|r=d } n|rBd } nd } d g} |rN| �d� | dd| d| g7 } |rkdd�|� d } | d| g7 } |ru| d|��g7 } | S )z� Return a sequence comprising the lines of code necessary to construct the inner Meta class for the model corresponding to the given database table name. Fr3 r4 NTc s g | ] }|d ur|� v r|�qS r1 r )r, �x�rw r r r9 � s z$Command.get_meta.<locals>.<listcomp>r5 c 3 s � | ]}� | V qd S r1 r r7 r� r r r2 � s � z#Command.get_meta.<locals>.<genexpr>z& # Created from a view. Don't remove.z+ # Created from a partition. Don't remove.r z4 # A unique constraint could not be introspected.z class Meta:z managed = False%sz db_table = %rr@ r; z,)z unique_together = %sz db_table_comment = )rU r6 rX r �tupler] )r r$ ro rw r� r� rg �unique_together�has_unsupported_constraintr r4 �managed_comment�meta�tupr r� r rj n sD � �� �zCommand.get_metaN) �__name__� __module__� __qualname__r �requires_system_checks�stealth_optionsrL r r r rZ ra rj r r r r r s � T< )r ) r� r! �django.core.management.baser r � django.dbr r �django.db.models.constantsr r r r r r �<module> s commands/__pycache__/runserver.cpython-310.pyc 0000644 00000012130 15030001101 0015263 0 ustar 00 o �hH � @ s� d dl Z d dlZd dlZd dlZd dlZd dlmZ d dlmZ d dlm Z m Z d dl m Z m Z mZ d dlmZ d dlmZ edej�ZG d d � d e �ZdS ) � N)�datetime)�settings)� BaseCommand� CommandError)� WSGIServer� get_internal_wsgi_application�run)� autoreload)�_lazy_re_compilez�^(?: (?P<addr> (?P<ipv4>\d{1,3}(?:\.\d{1,3}){3}) | # IPv4 address (?P<ipv6>\[[a-fA-F0-9:]+\]) | # IPv6 address (?P<fqdn>[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*) # FQDN ):)?(?P<port>\d+)$c st e Zd ZdZg ZdZddhZdZdZdZ dZ e Z d d � Z � fd d �Zd d� Zdd� Zdd� Zdd� Zdd� Z� ZS )�Commandz0Starts a lightweight web server for development.)�shutdown_messagez --verbosityz --tracebackz 127.0.0.1z::1�8000�httpc C s\ |j dddd� |j ddddd d � |j d d d dd � |j dd ddd � |j dddd� d S )N�addrport�?z$Optional port number, or ipaddr:port)�nargs�helpz--ipv6z-6� store_true�use_ipv6z$Tells Django to use an IPv6 address.)�action�destr z --nothreading� store_false� use_threadingz"Tells Django to NOT use threading.z --noreload� use_reloaderz*Tells Django to NOT use the auto-reloader.z --skip-checkszSkip system checks.)r r )� add_argument)�self�parser� r �\/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/runserver.py� add_arguments' s6 ���� �zCommand.add_argumentsc s( |d r dt jd< t� j|i |�� d S )N�no_color�nocolor� DJANGO_COLORS)�os�environ�super�execute�r �args�options�� __class__r r r& D s zCommand.executec O s t � S )z/Return the default WSGI handler for the runner.)r r' r r r � get_handlerL s zCommand.get_handlerc O s t js t js td��|d | _| jrtjstd��d| _|d s(d| _| j | _ nKt � t |d �}|d u r<td|d ��|�� \| _}}}| _ | j �� sStd| j ��| jrs|rg| jd d � | _d | _d | _n | jrs|sstd | j ��| js�| jr|| jn| j| _| j| _| jd i |�� d S )Nz6You must set settings.ALLOWED_HOSTS if DEBUG is False.r z"Your Python does not support IPv6.Fr � z5"%s" is not a valid port number or address:port pair.z %r is not a valid port number.� ���Tz!"%s" is not a valid IPv6 address.r )r �DEBUG� ALLOWED_HOSTSr r �socket�has_ipv6� _raw_ipv6�addr� default_port�port�re�match� naiveip_re�groups�isdigit�default_addr_ipv6� default_addrr )r r( r) �m�_ipv4�_ipv6�_fqdnr r r �handleP s< �� zCommand.handlec K s8 |d }|rt j| jfi |�� dS | jdi |�� dS )z1Run the server, using the autoreloader if needed.r N)N)r �run_with_reloader� inner_run)r r) r r r r r q s z Command.runc O s( t �� |d }|�dd�}|d s | j�d� | jdd� | �� z | j|i |��}t| j t | j �|| j || j | jd� W d S ty} } z2tjd tjd tjd i}z||j }W n tyd |}Y nw | j�d | � t�d � W Y d }~d S d }~w ty� |r�| j�|� t�d� Y d S w )Nr r r- � skip_checksz Performing system checks... T)�display_num_errors)�ipv6� threading�on_bind� server_clsz.You don't have permission to access that port.z That port is already in use.z%That IP address can't be assigned to.z Error: %sr. r )r �raise_last_exception�get�stdout�write�check�check_migrationsr, r r5 �intr7 r rJ rK �OSError�errno�EACCES� EADDRINUSE� EADDRNOTAVAIL�KeyError�stderrr# �_exit�KeyboardInterrupt�sys�exit) r r( r) rI r �handler�e�ERRORS� error_textr r r rE z sH � � �� �zCommand.inner_runc C s� t jdkrdnd}| jrd| j� d�}n | jdkr d}n| j}t�� �d�}| �� }t|� d |� d t j �d | j � d |� d |� d|� d�| j d� d S )N�win32z CTRL-BREAKz CONTROL-C�[�]�0z0.0.0.0z%B %d, %Y - %Xz Django version z, using settings z Starting development server at z://�:z/ Quit the server with �.)�file) r\ �platformr4 r5 r �now�strftime� get_version�printr �SETTINGS_MODULE�protocolrN )r � server_port� quit_commandr5 rj �versionr r r rJ � s0 ������ �zCommand.on_bind)�__name__� __module__� __qualname__r �requires_system_checks�stealth_options�suppressed_base_argumentsr> r= r6 ro r rK r r& r, rC r rE rJ � __classcell__r r r* r r s" ! .r )rT r# r8 r2 r\ r � django.confr �django.core.management.baser r � django.core.servers.basehttpr r r � django.utilsr �django.utils.regex_helperr �Xr: r r r r r �<module> s � commands/__pycache__/createcachetable.cpython-310.pyc 0000644 00000006734 15030001101 0016504 0 ustar 00 o �h � @ sh d dl mZ d dlmZ d dlmZ d dlmZmZ d dl m Z m Z m Z m Z mZmZ G dd� de�ZdS ) � )�settings)�caches)�BaseDatabaseCache)� BaseCommand� CommandError)�DEFAULT_DB_ALIAS� DatabaseError� connections�models�router� transactionc @ s, e Zd ZdZg Zdd� Zdd� Zdd� ZdS ) �Commandz7Creates the tables needed to use the SQL cache backend.c C s6 |j ddddd� |j dtdd� |j d d d d � d S ) N�args� table_name�*zNOptional table names. Otherwise, settings.CACHES is used to find cache tables.)�metavar�nargs�helpz --databasezgNominates a database onto which the cache tables will be installed. Defaults to the "default" database.)�defaultr z --dry-run� store_truezADoes not create the table, just prints the SQL that would be run.)�actionr )� add_argumentr )�self�parser� r �c/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/createcachetable.py� add_arguments s � � �zCommand.add_argumentsc O sl |d }|d | _ |d }|r |D ] }| �|||� qd S tjD ]}t| }t|t�r3| �||j|� q d S )N�database� verbosity�dry_run)r � create_tabler �CACHESr � isinstancer �_table)r � tablenames�options�dbr � tablename� cache_alias�cacher r r �handle* s � ��zCommand.handlec C s� t |i �}t�||j�sd S t| }||j�� v r(| jdkr&| j� d| � d S t j ddddd�t j dd�t j d dd �f}g }g }|jj} |D ]O} | | j�| j|d �d | jsXd nd g} | jre| �d� n| jrm| �d� | jr�| jrudnd} |�d| | d|| jf �| |�| | j�f � |�d�| �� qGd| |� g} t|�D ]\}}| �d||t|�d k r�dndf � q�| �d� d�| �} |r�| j� | � |D ]}| j� |� q�d S tj||j j d��E |� � �0}z|� | � W n t �y } zt!d ||f ��d }~ww |D ]}|� |� �qW d � n 1 �sw Y W d � n 1 �s+w Y | jdk�r@| j� d | � d S d S ) Nr z Cache table '%s' already exists.� cache_key� T)�name� max_length�unique� primary_key�value)r- �expires)r- �db_index)� connectionz%sNULLzNOT � z PRIMARY KEY�UNIQUEzUNIQUE z CREATE %sINDEX %s ON %s (%s);z%s_%s� zCREATE TABLE %s (z %s%s� �,z);� )�using� savepointz9Cache table '%s' could not be created. The error was: %s.zCache table '%s' created.)"r r �allow_migrate_model�cache_model_classr � introspection� table_namesr �stdout�writer � CharField� TextField� DateTimeField�ops� quote_namer- �db_type�nullr0 �appendr/ r3 �join� enumerate�lenr �atomic�features�can_rollback_ddl�cursor�executer r )r r r' r r) r4 �fields� table_output� index_output�qn�f� field_outputr/ �full_statement�i�line� statement�curs�er r r r 8 s� � � � ��� � � ����� �� � �zCommand.create_tableN)�__name__� __module__� __qualname__r �requires_system_checksr r* r r r r r r s r N)� django.confr �django.core.cacher � django.core.cache.backends.dbr �django.core.management.baser r � django.dbr r r r r r r r r r r �<module> s commands/__pycache__/flush.cpython-310.pyc 0000644 00000005305 15030001101 0014357 0 ustar 00 o �h � @ sh d dl mZ d dlmZ d dlmZmZ d dlmZ d dl m Z m Z d dl m Z mZ G dd� de�Zd S ) � )� import_module)�apps)� BaseCommand� CommandError)�no_style)�emit_post_migrate_signal� sql_flush)�DEFAULT_DB_ALIAS� connectionsc @ s$ e Zd ZdZdZdd� Zdd� ZdS )�CommandzuRemoves ALL DATA from the database, including data added during migrations. Does not achieve a "fresh install" state.)�reset_sequences� allow_cascade�inhibit_post_migratec C s( |j dddddd� |j dtdd � d S ) Nz --noinputz --no-input� store_false� interactivez:Tells Django to NOT prompt the user for input of any kind.)�action�dest�helpz --databasezBNominates a database to flush. Defaults to the "default" database.)�defaultr )� add_argumentr )�self�parser� r �X/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/flush.py� add_arguments s � �zCommand.add_argumentsc K s" |d }t | }|d }|d }|�dd�}|�dd�}|�dd�}t� | _t�� D ]} ztd | j� W q* ty= Y q*w t | j|||d �} |rSt d |j d �} nd } | d kr�z|j � | � W n tyx } z td|j d f �| �d } ~ ww | r�|s�t|||� d S d S d S | j�d� d S )N�database� verbosityr r Tr Fr z .management)r r z�You have requested a flush of the database. This will IRREVERSIBLY DESTROY all data currently in the "%s" database, and return each table to an empty state. Are you sure you want to do this? Type 'yes' to continue, or 'no' to cancel: �NAME�yesa. Database %s couldn't be flushed. Possible reasons: * The database isn't running or isn't configured correctly. * At least one of the expected database tables doesn't exist. * The SQL was invalid. Hint: Look at the output of 'django-admin sqlflush'. That's the SQL this command wasn't able to run.zFlush cancelled.)r �getr �styler �get_app_configsr �name� ImportErrorr �input� settings_dict�ops�execute_sql_flush� Exceptionr r �stdout�write) r �optionsr � connectionr r r r r � app_config�sql_list�confirm�excr r r �handle sX ���� ����� �zCommand.handleN)�__name__� __module__� __qualname__r �stealth_optionsr r1 r r r r r s � r N)� importlibr � django.appsr �django.core.management.baser r � django.core.management.colorr �django.core.management.sqlr r � django.dbr r r r r r r �<module> s commands/__pycache__/sendtestemail.cpython-310.pyc 0000644 00000003321 15030001101 0016073 0 ustar 00 o �h� � @ sH d dl Z d dlmZmZmZ d dlmZ d dlmZ G dd� de�Z dS )� N)� mail_admins� mail_managers� send_mail)� BaseCommand)�timezonec @ s$ e Zd ZdZdZdd� Zdd� ZdS )�CommandzASends a test email to the email addresses specified as arguments.zRYou must specify some email recipients, or pass the --managers or --admin options.c C s4 |j dddd� |j dddd� |j d dd d� d S ) N�email�*z4One or more email addresses to send a test email to.)�nargs�helpz --managers� store_truezBSend a test email to the addresses specified in settings.MANAGERS.)�actionr z--adminsz@Send a test email to the addresses specified in settings.ADMINS.)� add_argument)�self�parser� r �`/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/sendtestemail.py� add_arguments s �� �zCommand.add_argumentsc O sT dt �� t�� f }t|dd |d d� |d r t|d� |d r(t|d� d S d S ) NzTest email from %s on %sz*If you're reading this, it was successful.r )�subject�message� from_email�recipient_list�managersz)This email was sent to the site managers.�adminsz'This email was sent to the site admins.)�socket� gethostnamer �nowr r r )r �args�kwargsr r r r �handle s � �zCommand.handleN)�__name__� __module__� __qualname__r �missing_args_messager r r r r r r s � r ) r �django.core.mailr r r �django.core.management.baser � django.utilsr r r r r r �<module> s commands/__pycache__/diffsettings.cpython-310.pyc 0000644 00000006022 15030001101 0015724 0 ustar 00 o �h� � @ s0 d dl mZ dd� fdd�ZG dd� de�ZdS ) � )� BaseCommandc C s | � d�p | �� S )N�_)� startswith�isupper)�k� r �_/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/diffsettings.py�<lambda> s r c s � �fdd�t � �D �S )z2Convert a module namespace to a Python dictionary.c s$ i | ]}�|�s|t t� |���qS r )�repr�getattr)�.0r ��module� omittabler r � <dictcomp> s $ z"module_to_dict.<locals>.<dictcomp>)�dirr r r r �module_to_dict s r c @ s4 e Zd ZdZg Zdd� Zdd� Zdd� Zdd � Zd S ) �CommandzWDisplays differences between the current settings.py and Django's default settings.c C s6 |j dddd� |j dddd� |j d d d d d � d S )Nz--all� store_truezfDisplay all settings, regardless of their value. In "hash" mode, default values are prefixed by "###".)�action�helpz --default�MODULEzvThe settings module to compare the current settings against. Leave empty to compare against Django's default settings.)�metavarr z--output�hash�r �unifieda Selects the output format. 'hash' mode displays each changed setting, with the settings that don't appear in the defaults followed by ###. 'unified' mode prefixes the default setting with a minus sign, followed by the changed setting prefixed with a plus sign.)�default�choicesr )� add_argument)�self�parserr r r � add_arguments s �� �zCommand.add_argumentsc K sv ddl m}m}m} |js|�� t|j�}|d }t|r!||�n|�}| j| j d�|d }d� |||fi |���S )Nr )�Settings�global_settings�settingsr r �output� ) � django.confr" r# r$ � configured�_setupr �_wrapped� output_hash�output_unified�join) r �optionsr" r# r$ � user_settingsr �default_settings� output_funcr r r �handle- s ���zCommand.handlec K s| g }t |�D ]5}||vr|�d||| f � q|| || kr,|�d||| f � q|d r;|�d||| f � q|S )Nz %s = %s ###z%s = %s�allz ### %s = %s)�sorted�append�r r/ r0 r. r% �keyr r r r+ ? s �zCommand.output_hashc K s� g }t |�D ]L}||vr |�| j�d||| f �� q|| || krC|�| j�d||| f �� |�| j�d||| f �� q|d rR|�d||| f � q|S )Nz + %s = %sz - %s = %sr3 z %s = %s)r4 r5 �style�SUCCESS�ERRORr6 r r r r, K s" ����zCommand.output_unifiedN) �__name__� __module__� __qualname__r �requires_system_checksr! r2 r+ r, r r r r r s r N)�django.core.management.baser r r r r r r �<module> s commands/__pycache__/test.cpython-310.pyc 0000644 00000005025 15030001101 0014214 0 ustar 00 o �h� � @ s` d dl Z d dlmZ d dlmZ d dlmZ d dlmZ d dl m Z m Z m Z G dd� de�Z dS ) � N)�settings)� BaseCommand)�get_command_line_option)�get_max_test_processes)�NullTimeKeeper� TimeKeeper� get_runnerc s8 e Zd ZdZg ZdZ� fdd�Zdd� Zdd� Z� Z S ) �CommandzIDiscover and run tests in the specified modules or the current directory.Nc s t |d�| _t� �|� dS )z� Pre-parse the command line to extract the value of the --testrunner option. This allows a test runner to define additional command line arguments. � --testrunnerN)r � test_runner�super� run_from_argv)�self�argv�� __class__� �W/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/test.pyr s zCommand.run_from_argvc C sl |j ddddd� |j dddd d d � |j d d dd� |j ddd� tt| j�}t|d�r4|�|� d S d S )N�args� test_label�*z_Module paths to test; can be modulename, modulename.TestCase or modulename.TestCase.test_method)�metavar�nargs�helpz --noinputz --no-input� store_false� interactivez:Tells Django to NOT prompt the user for input of any kind.)�action�destr z --failfast� store_truezDTells Django to stop running the test suite after first failed test.)r r r zhTells Django to use specified test runner class instead of the one specified by the TEST_RUNNER setting.)r � add_arguments)� add_argumentr r r �hasattrr )r �parser�test_runner_classr r r r s4 � ��� �zCommand.add_argumentsc O s� t t|d �}|�dd�rt� nt� }|�d�}|dkr!t� |d< |di |��}|�d�� |�|�}W d � n1 s=w Y |�� |rOt � d� d S d S ) N� testrunner�timingF�parallel�autoz Total run� r ) r r �getr r r �timed� run_tests� print_results�sys�exit)r � test_labels�options� TestRunner� time_keeperr& r �failuresr r r �handle; s ��zCommand.handle) �__name__� __module__� __qualname__r �requires_system_checksr r r r4 � __classcell__r r r r r s !r )r- � django.confr �django.core.management.baser � django.core.management.utilsr �django.test.runnerr �django.test.utilsr r r r r r r r �<module> s commands/__pycache__/startproject.cpython-310.pyc 0000644 00000002055 15030001101 0015761 0 ustar 00 o �h � @ s8 d dl mZ d dlmZ ddlmZ G dd� de�ZdS )� )�SECRET_KEY_INSECURE_PREFIX)�TemplateCommand� )�get_random_secret_keyc s$ e Zd ZdZdZ� fdd�Z� ZS )�Commandz�Creates a Django project directory structure for the given project name in the current directory or optionally in the given directory.z You must provide a project name.c s> |� d�}|� d�}tt� |d< t� jd||fi |�� d S )N�name� directory� secret_key�project)�popr r �super�handle)�self�options� project_name�target�� __class__� �_/usr/local/CyberCP/lib/python3.10/site-packages/django/core/management/commands/startproject.pyr s zCommand.handle)�__name__� __module__� __qualname__�help�missing_args_messager � __classcell__r r r r r s �r N)� django.core.checks.security.baser � django.core.management.templatesr �utilsr r r r r r �<module> s commands/sendtestemail.py 0000644 00000002756 15030001101 0011547 0 ustar 00 import socket from django.core.mail import mail_admins, mail_managers, send_mail from django.core.management.base import BaseCommand from django.utils import timezone class Command(BaseCommand): help = "Sends a test email to the email addresses specified as arguments." missing_args_message = ( "You must specify some email recipients, or pass the --managers or --admin " "options." ) def add_arguments(self, parser): parser.add_argument( "email", nargs="*", help="One or more email addresses to send a test email to.", ) parser.add_argument( "--managers", action="store_true", help="Send a test email to the addresses specified in settings.MANAGERS.", ) parser.add_argument( "--admins", action="store_true", help="Send a test email to the addresses specified in settings.ADMINS.", ) def handle(self, *args, **kwargs): subject = "Test email from %s on %s" % (socket.gethostname(), timezone.now()) send_mail( subject=subject, message="If you're reading this, it was successful.", from_email=None, recipient_list=kwargs["email"], ) if kwargs["managers"]: mail_managers(subject, "This email was sent to the site managers.") if kwargs["admins"]: mail_admins(subject, "This email was sent to the site admins.") commands/showmigrations.py 0000644 00000015227 15030001101 0011760 0 ustar 00 import sys from django.apps import apps from django.core.management.base import BaseCommand from django.db import DEFAULT_DB_ALIAS, connections from django.db.migrations.loader import MigrationLoader from django.db.migrations.recorder import MigrationRecorder class Command(BaseCommand): help = "Shows all available migrations for the current project" def add_arguments(self, parser): parser.add_argument( "app_label", nargs="*", help="App labels of applications to limit the output to.", ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( "Nominates a database to show migrations for. Defaults to the " '"default" database.' ), ) formats = parser.add_mutually_exclusive_group() formats.add_argument( "--list", "-l", action="store_const", dest="format", const="list", help=( "Shows a list of all migrations and which are applied. " "With a verbosity level of 2 or above, the applied datetimes " "will be included." ), ) formats.add_argument( "--plan", "-p", action="store_const", dest="format", const="plan", help=( "Shows all migrations in the order they will be applied. With a " "verbosity level of 2 or above all direct migration dependencies and " "reverse dependencies (run_before) will be included." ), ) parser.set_defaults(format="list") def handle(self, *args, **options): self.verbosity = options["verbosity"] # Get the database we're operating from db = options["database"] connection = connections[db] if options["format"] == "plan": return self.show_plan(connection, options["app_label"]) else: return self.show_list(connection, options["app_label"]) def _validate_app_names(self, loader, app_names): has_bad_names = False for app_name in app_names: try: apps.get_app_config(app_name) except LookupError as err: self.stderr.write(str(err)) has_bad_names = True if has_bad_names: sys.exit(2) def show_list(self, connection, app_names=None): """ Show a list of all migrations on the system, or only those of some named apps. """ # Load migrations from disk/DB loader = MigrationLoader(connection, ignore_no_migrations=True) recorder = MigrationRecorder(connection) recorded_migrations = recorder.applied_migrations() graph = loader.graph # If we were passed a list of apps, validate it if app_names: self._validate_app_names(loader, app_names) # Otherwise, show all apps in alphabetic order else: app_names = sorted(loader.migrated_apps) # For each app, print its migrations in order from oldest (roots) to # newest (leaves). for app_name in app_names: self.stdout.write(app_name, self.style.MIGRATE_LABEL) shown = set() for node in graph.leaf_nodes(app_name): for plan_node in graph.forwards_plan(node): if plan_node not in shown and plan_node[0] == app_name: # Give it a nice title if it's a squashed one title = plan_node[1] if graph.nodes[plan_node].replaces: title += " (%s squashed migrations)" % len( graph.nodes[plan_node].replaces ) applied_migration = loader.applied_migrations.get(plan_node) # Mark it as applied/unapplied if applied_migration: if plan_node in recorded_migrations: output = " [X] %s" % title else: title += " Run 'manage.py migrate' to finish recording." output = " [-] %s" % title if self.verbosity >= 2 and hasattr( applied_migration, "applied" ): output += ( " (applied at %s)" % applied_migration.applied.strftime( "%Y-%m-%d %H:%M:%S" ) ) self.stdout.write(output) else: self.stdout.write(" [ ] %s" % title) shown.add(plan_node) # If we didn't print anything, then a small message if not shown: self.stdout.write(" (no migrations)", self.style.ERROR) def show_plan(self, connection, app_names=None): """ Show all known migrations (or only those of the specified app_names) in the order they will be applied. """ # Load migrations from disk/DB loader = MigrationLoader(connection) graph = loader.graph if app_names: self._validate_app_names(loader, app_names) targets = [key for key in graph.leaf_nodes() if key[0] in app_names] else: targets = graph.leaf_nodes() plan = [] seen = set() # Generate the plan for target in targets: for migration in graph.forwards_plan(target): if migration not in seen: node = graph.node_map[migration] plan.append(node) seen.add(migration) # Output def print_deps(node): out = [] for parent in sorted(node.parents): out.append("%s.%s" % parent.key) if out: return " ... (%s)" % ", ".join(out) return "" for node in plan: deps = "" if self.verbosity >= 2: deps = print_deps(node) if node.key in loader.applied_migrations: self.stdout.write("[X] %s.%s%s" % (node.key[0], node.key[1], deps)) else: self.stdout.write("[ ] %s.%s%s" % (node.key[0], node.key[1], deps)) if not plan: self.stdout.write("(no migrations)", self.style.ERROR) commands/runserver.py 0000644 00000015110 15030001101 0010725 0 ustar 00 import errno import os import re import socket import sys from datetime import datetime from django.conf import settings from django.core.management.base import BaseCommand, CommandError from django.core.servers.basehttp import WSGIServer, get_internal_wsgi_application, run from django.utils import autoreload from django.utils.regex_helper import _lazy_re_compile naiveip_re = _lazy_re_compile( r"""^(?: (?P<addr> (?P<ipv4>\d{1,3}(?:\.\d{1,3}){3}) | # IPv4 address (?P<ipv6>\[[a-fA-F0-9:]+\]) | # IPv6 address (?P<fqdn>[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*) # FQDN ):)?(?P<port>\d+)$""", re.X, ) class Command(BaseCommand): help = "Starts a lightweight web server for development." # Validation is called explicitly each time the server is reloaded. requires_system_checks = [] stealth_options = ("shutdown_message",) suppressed_base_arguments = {"--verbosity", "--traceback"} default_addr = "127.0.0.1" default_addr_ipv6 = "::1" default_port = "8000" protocol = "http" server_cls = WSGIServer def add_arguments(self, parser): parser.add_argument( "addrport", nargs="?", help="Optional port number, or ipaddr:port" ) parser.add_argument( "--ipv6", "-6", action="store_true", dest="use_ipv6", help="Tells Django to use an IPv6 address.", ) parser.add_argument( "--nothreading", action="store_false", dest="use_threading", help="Tells Django to NOT use threading.", ) parser.add_argument( "--noreload", action="store_false", dest="use_reloader", help="Tells Django to NOT use the auto-reloader.", ) parser.add_argument( "--skip-checks", action="store_true", help="Skip system checks.", ) def execute(self, *args, **options): if options["no_color"]: # We rely on the environment because it's currently the only # way to reach WSGIRequestHandler. This seems an acceptable # compromise considering `runserver` runs indefinitely. os.environ["DJANGO_COLORS"] = "nocolor" super().execute(*args, **options) def get_handler(self, *args, **options): """Return the default WSGI handler for the runner.""" return get_internal_wsgi_application() def handle(self, *args, **options): if not settings.DEBUG and not settings.ALLOWED_HOSTS: raise CommandError("You must set settings.ALLOWED_HOSTS if DEBUG is False.") self.use_ipv6 = options["use_ipv6"] if self.use_ipv6 and not socket.has_ipv6: raise CommandError("Your Python does not support IPv6.") self._raw_ipv6 = False if not options["addrport"]: self.addr = "" self.port = self.default_port else: m = re.match(naiveip_re, options["addrport"]) if m is None: raise CommandError( '"%s" is not a valid port number ' "or address:port pair." % options["addrport"] ) self.addr, _ipv4, _ipv6, _fqdn, self.port = m.groups() if not self.port.isdigit(): raise CommandError("%r is not a valid port number." % self.port) if self.addr: if _ipv6: self.addr = self.addr[1:-1] self.use_ipv6 = True self._raw_ipv6 = True elif self.use_ipv6 and not _fqdn: raise CommandError('"%s" is not a valid IPv6 address.' % self.addr) if not self.addr: self.addr = self.default_addr_ipv6 if self.use_ipv6 else self.default_addr self._raw_ipv6 = self.use_ipv6 self.run(**options) def run(self, **options): """Run the server, using the autoreloader if needed.""" use_reloader = options["use_reloader"] if use_reloader: autoreload.run_with_reloader(self.inner_run, **options) else: self.inner_run(None, **options) def inner_run(self, *args, **options): # If an exception was silenced in ManagementUtility.execute in order # to be raised in the child process, raise it now. autoreload.raise_last_exception() threading = options["use_threading"] # 'shutdown_message' is a stealth option. shutdown_message = options.get("shutdown_message", "") if not options["skip_checks"]: self.stdout.write("Performing system checks...\n\n") self.check(display_num_errors=True) # Need to check migrations here, so can't use the # requires_migrations_check attribute. self.check_migrations() try: handler = self.get_handler(*args, **options) run( self.addr, int(self.port), handler, ipv6=self.use_ipv6, threading=threading, on_bind=self.on_bind, server_cls=self.server_cls, ) except OSError as e: # Use helpful error messages instead of ugly tracebacks. ERRORS = { errno.EACCES: "You don't have permission to access that port.", errno.EADDRINUSE: "That port is already in use.", errno.EADDRNOTAVAIL: "That IP address can't be assigned to.", } try: error_text = ERRORS[e.errno] except KeyError: error_text = e self.stderr.write("Error: %s" % error_text) # Need to use an OS exit because sys.exit doesn't work in a thread os._exit(1) except KeyboardInterrupt: if shutdown_message: self.stdout.write(shutdown_message) sys.exit(0) def on_bind(self, server_port): quit_command = "CTRL-BREAK" if sys.platform == "win32" else "CONTROL-C" if self._raw_ipv6: addr = f"[{self.addr}]" elif self.addr == "0": addr = "0.0.0.0" else: addr = self.addr now = datetime.now().strftime("%B %d, %Y - %X") version = self.get_version() print( f"{now}\n" f"Django version {version}, using settings {settings.SETTINGS_MODULE!r}\n" f"Starting development server at {self.protocol}://{addr}:{server_port}/\n" f"Quit the server with {quit_command}.", file=self.stdout, ) commands/sqlsequencereset.py 0000644 00000002045 15030001101 0012270 0 ustar 00 from django.core.management.base import AppCommand from django.db import DEFAULT_DB_ALIAS, connections class Command(AppCommand): help = ( "Prints the SQL statements for resetting sequences for the given app name(s)." ) output_transaction = True def add_arguments(self, parser): super().add_arguments(parser) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( 'Nominates a database to print the SQL for. Defaults to the "default" ' "database." ), ) def handle_app_config(self, app_config, **options): if app_config.models_module is None: return connection = connections[options["database"]] models = app_config.get_models(include_auto_created=True) statements = connection.ops.sequence_reset_sql(self.style, models) if not statements and options["verbosity"] >= 1: self.stderr.write("No sequences found.") return "\n".join(statements) commands/optimizemigration.py 0000644 00000012150 15030001101 0012445 0 ustar 00 import shutil import sys from django.apps import apps from django.core.management.base import BaseCommand, CommandError from django.core.management.utils import run_formatters from django.db import migrations from django.db.migrations.exceptions import AmbiguityError from django.db.migrations.loader import MigrationLoader from django.db.migrations.optimizer import MigrationOptimizer from django.db.migrations.writer import MigrationWriter from django.utils.version import get_docs_version class Command(BaseCommand): help = "Optimizes the operations for the named migration." def add_arguments(self, parser): parser.add_argument( "app_label", help="App label of the application to optimize the migration for.", ) parser.add_argument( "migration_name", help="Migration name to optimize the operations for." ) parser.add_argument( "--check", action="store_true", help="Exit with a non-zero status if the migration can be optimized.", ) def handle(self, *args, **options): verbosity = options["verbosity"] app_label = options["app_label"] migration_name = options["migration_name"] check = options["check"] # Validate app_label. try: apps.get_app_config(app_label) except LookupError as err: raise CommandError(str(err)) # Load the current graph state. loader = MigrationLoader(None) if app_label not in loader.migrated_apps: raise CommandError(f"App '{app_label}' does not have migrations.") # Find a migration. try: migration = loader.get_migration_by_prefix(app_label, migration_name) except AmbiguityError: raise CommandError( f"More than one migration matches '{migration_name}' in app " f"'{app_label}'. Please be more specific." ) except KeyError: raise CommandError( f"Cannot find a migration matching '{migration_name}' from app " f"'{app_label}'." ) # Optimize the migration. optimizer = MigrationOptimizer() new_operations = optimizer.optimize(migration.operations, migration.app_label) if len(migration.operations) == len(new_operations): if verbosity > 0: self.stdout.write("No optimizations possible.") return else: if verbosity > 0: self.stdout.write( "Optimizing from %d operations to %d operations." % (len(migration.operations), len(new_operations)) ) if check: sys.exit(1) # Set the new migration optimizations. migration.operations = new_operations # Write out the optimized migration file. writer = MigrationWriter(migration) migration_file_string = writer.as_string() if writer.needs_manual_porting: if migration.replaces: raise CommandError( "Migration will require manual porting but is already a squashed " "migration.\nTransition to a normal migration first: " "https://docs.djangoproject.com/en/%s/topics/migrations/" "#squashing-migrations" % get_docs_version() ) # Make a new migration with those operations. subclass = type( "Migration", (migrations.Migration,), { "dependencies": migration.dependencies, "operations": new_operations, "replaces": [(migration.app_label, migration.name)], }, ) optimized_migration_name = "%s_optimized" % migration.name optimized_migration = subclass(optimized_migration_name, app_label) writer = MigrationWriter(optimized_migration) migration_file_string = writer.as_string() if verbosity > 0: self.stdout.write( self.style.MIGRATE_HEADING("Manual porting required") + "\n" " Your migrations contained functions that must be manually " "copied over,\n" " as we could not safely copy their implementation.\n" " See the comment at the top of the optimized migration for " "details." ) if shutil.which("black"): self.stdout.write( self.style.WARNING( "Optimized migration couldn't be formatted using the " '"black" command. You can call it manually.' ) ) with open(writer.path, "w", encoding="utf-8") as fh: fh.write(migration_file_string) run_formatters([writer.path]) if verbosity > 0: self.stdout.write( self.style.MIGRATE_HEADING(f"Optimized migration {writer.path}") ) commands/makemessages.py 0000644 00000071244 15030001101 0011351 0 ustar 00 import glob import os import re import sys from functools import total_ordering from itertools import dropwhile from pathlib import Path import django from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django.core.files.temp import NamedTemporaryFile from django.core.management.base import BaseCommand, CommandError from django.core.management.utils import ( find_command, handle_extensions, is_ignored_path, popen_wrapper, ) from django.utils.encoding import DEFAULT_LOCALE_ENCODING from django.utils.functional import cached_property from django.utils.jslex import prepare_js_for_gettext from django.utils.regex_helper import _lazy_re_compile from django.utils.text import get_text_list from django.utils.translation import templatize plural_forms_re = _lazy_re_compile( r'^(?P<value>"Plural-Forms.+?\\n")\s*$', re.MULTILINE | re.DOTALL ) STATUS_OK = 0 NO_LOCALE_DIR = object() def check_programs(*programs): for program in programs: if find_command(program) is None: raise CommandError( "Can't find %s. Make sure you have GNU gettext tools 0.15 or " "newer installed." % program ) def is_valid_locale(locale): return re.match(r"^[a-z]+$", locale) or re.match(r"^[a-z]+_[A-Z].*$", locale) @total_ordering class TranslatableFile: def __init__(self, dirpath, file_name, locale_dir): self.file = file_name self.dirpath = dirpath self.locale_dir = locale_dir def __repr__(self): return "<%s: %s>" % ( self.__class__.__name__, os.sep.join([self.dirpath, self.file]), ) def __eq__(self, other): return self.path == other.path def __lt__(self, other): return self.path < other.path @property def path(self): return os.path.join(self.dirpath, self.file) class BuildFile: """ Represent the state of a translatable file during the build process. """ def __init__(self, command, domain, translatable): self.command = command self.domain = domain self.translatable = translatable @cached_property def is_templatized(self): if self.domain == "djangojs": return self.command.gettext_version < (0, 18, 3) elif self.domain == "django": file_ext = os.path.splitext(self.translatable.file)[1] return file_ext != ".py" return False @cached_property def path(self): return self.translatable.path @cached_property def work_path(self): """ Path to a file which is being fed into GNU gettext pipeline. This may be either a translatable or its preprocessed version. """ if not self.is_templatized: return self.path extension = { "djangojs": "c", "django": "py", }.get(self.domain) filename = "%s.%s" % (self.translatable.file, extension) return os.path.join(self.translatable.dirpath, filename) def preprocess(self): """ Preprocess (if necessary) a translatable file before passing it to xgettext GNU gettext utility. """ if not self.is_templatized: return with open(self.path, encoding="utf-8") as fp: src_data = fp.read() if self.domain == "djangojs": content = prepare_js_for_gettext(src_data) elif self.domain == "django": content = templatize(src_data, origin=self.path[2:]) with open(self.work_path, "w", encoding="utf-8") as fp: fp.write(content) def postprocess_messages(self, msgs): """ Postprocess messages generated by xgettext GNU gettext utility. Transform paths as if these messages were generated from original translatable files rather than from preprocessed versions. """ if not self.is_templatized: return msgs # Remove '.py' suffix if os.name == "nt": # Preserve '.\' prefix on Windows to respect gettext behavior old_path = self.work_path new_path = self.path else: old_path = self.work_path[2:] new_path = self.path[2:] return re.sub( r"^(#: .*)(" + re.escape(old_path) + r")", lambda match: match[0].replace(old_path, new_path), msgs, flags=re.MULTILINE, ) def cleanup(self): """ Remove a preprocessed copy of a translatable file (if any). """ if self.is_templatized: # This check is needed for the case of a symlinked file and its # source being processed inside a single group (locale dir); # removing either of those two removes both. if os.path.exists(self.work_path): os.unlink(self.work_path) def normalize_eols(raw_contents): """ Take a block of raw text that will be passed through str.splitlines() to get universal newlines treatment. Return the resulting block of text with normalized `\n` EOL sequences ready to be written to disk using current platform's native EOLs. """ lines_list = raw_contents.splitlines() # Ensure last line has its EOL if lines_list and lines_list[-1]: lines_list.append("") return "\n".join(lines_list) def write_pot_file(potfile, msgs): """ Write the `potfile` with the `msgs` contents, making sure its format is valid. """ pot_lines = msgs.splitlines() if os.path.exists(potfile): # Strip the header lines = dropwhile(len, pot_lines) else: lines = [] found, header_read = False, False for line in pot_lines: if not found and not header_read: if "charset=CHARSET" in line: found = True line = line.replace("charset=CHARSET", "charset=UTF-8") if not line and not found: header_read = True lines.append(line) msgs = "\n".join(lines) # Force newlines of POT files to '\n' to work around # https://savannah.gnu.org/bugs/index.php?52395 with open(potfile, "a", encoding="utf-8", newline="\n") as fp: fp.write(msgs) class Command(BaseCommand): help = ( "Runs over the entire source tree of the current directory and pulls out all " "strings marked for translation. It creates (or updates) a message file in the " "conf/locale (in the django tree) or locale (for projects and applications) " "directory.\n\nYou must run this command with one of either the --locale, " "--exclude, or --all options." ) translatable_file_class = TranslatableFile build_file_class = BuildFile requires_system_checks = [] msgmerge_options = ["-q", "--backup=none", "--previous", "--update"] msguniq_options = ["--to-code=utf-8"] msgattrib_options = ["--no-obsolete"] xgettext_options = ["--from-code=UTF-8", "--add-comments=Translators"] def add_arguments(self, parser): parser.add_argument( "--locale", "-l", default=[], action="append", help=( "Creates or updates the message files for the given locale(s) (e.g. " "pt_BR). Can be used multiple times." ), ) parser.add_argument( "--exclude", "-x", default=[], action="append", help="Locales to exclude. Default is none. Can be used multiple times.", ) parser.add_argument( "--domain", "-d", default="django", help='The domain of the message files (default: "django").', ) parser.add_argument( "--all", "-a", action="store_true", help="Updates the message files for all existing locales.", ) parser.add_argument( "--extension", "-e", dest="extensions", action="append", help='The file extension(s) to examine (default: "html,txt,py", or "js" ' 'if the domain is "djangojs"). Separate multiple extensions with ' "commas, or use -e multiple times.", ) parser.add_argument( "--symlinks", "-s", action="store_true", help="Follows symlinks to directories when examining source code " "and templates for translation strings.", ) parser.add_argument( "--ignore", "-i", action="append", dest="ignore_patterns", default=[], metavar="PATTERN", help="Ignore files or directories matching this glob-style pattern. " "Use multiple times to ignore more.", ) parser.add_argument( "--no-default-ignore", action="store_false", dest="use_default_ignore_patterns", help=( "Don't ignore the common glob-style patterns 'CVS', '.*', '*~' and " "'*.pyc'." ), ) parser.add_argument( "--no-wrap", action="store_true", help="Don't break long message lines into several lines.", ) parser.add_argument( "--no-location", action="store_true", help="Don't write '#: filename:line' lines.", ) parser.add_argument( "--add-location", choices=("full", "file", "never"), const="full", nargs="?", help=( "Controls '#: filename:line' lines. If the option is 'full' " "(the default if not given), the lines include both file name " "and line number. If it's 'file', the line number is omitted. If " "it's 'never', the lines are suppressed (same as --no-location). " "--add-location requires gettext 0.19 or newer." ), ) parser.add_argument( "--no-obsolete", action="store_true", help="Remove obsolete message strings.", ) parser.add_argument( "--keep-pot", action="store_true", help="Keep .pot file after making messages. Useful when debugging.", ) def handle(self, *args, **options): locale = options["locale"] exclude = options["exclude"] self.domain = options["domain"] self.verbosity = options["verbosity"] process_all = options["all"] extensions = options["extensions"] self.symlinks = options["symlinks"] ignore_patterns = options["ignore_patterns"] if options["use_default_ignore_patterns"]: ignore_patterns += ["CVS", ".*", "*~", "*.pyc"] self.ignore_patterns = list(set(ignore_patterns)) # Avoid messing with mutable class variables if options["no_wrap"]: self.msgmerge_options = self.msgmerge_options[:] + ["--no-wrap"] self.msguniq_options = self.msguniq_options[:] + ["--no-wrap"] self.msgattrib_options = self.msgattrib_options[:] + ["--no-wrap"] self.xgettext_options = self.xgettext_options[:] + ["--no-wrap"] if options["no_location"]: self.msgmerge_options = self.msgmerge_options[:] + ["--no-location"] self.msguniq_options = self.msguniq_options[:] + ["--no-location"] self.msgattrib_options = self.msgattrib_options[:] + ["--no-location"] self.xgettext_options = self.xgettext_options[:] + ["--no-location"] if options["add_location"]: if self.gettext_version < (0, 19): raise CommandError( "The --add-location option requires gettext 0.19 or later. " "You have %s." % ".".join(str(x) for x in self.gettext_version) ) arg_add_location = "--add-location=%s" % options["add_location"] self.msgmerge_options = self.msgmerge_options[:] + [arg_add_location] self.msguniq_options = self.msguniq_options[:] + [arg_add_location] self.msgattrib_options = self.msgattrib_options[:] + [arg_add_location] self.xgettext_options = self.xgettext_options[:] + [arg_add_location] self.no_obsolete = options["no_obsolete"] self.keep_pot = options["keep_pot"] if self.domain not in ("django", "djangojs"): raise CommandError( "currently makemessages only supports domains " "'django' and 'djangojs'" ) if self.domain == "djangojs": exts = extensions or ["js"] else: exts = extensions or ["html", "txt", "py"] self.extensions = handle_extensions(exts) if (not locale and not exclude and not process_all) or self.domain is None: raise CommandError( "Type '%s help %s' for usage information." % (os.path.basename(sys.argv[0]), sys.argv[1]) ) if self.verbosity > 1: self.stdout.write( "examining files with the extensions: %s" % get_text_list(list(self.extensions), "and") ) self.invoked_for_django = False self.locale_paths = [] self.default_locale_path = None if os.path.isdir(os.path.join("conf", "locale")): self.locale_paths = [os.path.abspath(os.path.join("conf", "locale"))] self.default_locale_path = self.locale_paths[0] self.invoked_for_django = True else: if self.settings_available: self.locale_paths.extend(settings.LOCALE_PATHS) # Allow to run makemessages inside an app dir if os.path.isdir("locale"): self.locale_paths.append(os.path.abspath("locale")) if self.locale_paths: self.default_locale_path = self.locale_paths[0] os.makedirs(self.default_locale_path, exist_ok=True) # Build locale list looks_like_locale = re.compile(r"[a-z]{2}") locale_dirs = filter( os.path.isdir, glob.glob("%s/*" % self.default_locale_path) ) all_locales = [ lang_code for lang_code in map(os.path.basename, locale_dirs) if looks_like_locale.match(lang_code) ] # Account for excluded locales if process_all: locales = all_locales else: locales = locale or all_locales locales = set(locales).difference(exclude) if locales: check_programs("msguniq", "msgmerge", "msgattrib") check_programs("xgettext") try: potfiles = self.build_potfiles() # Build po files for each selected locale for locale in locales: if not is_valid_locale(locale): # Try to guess what valid locale it could be # Valid examples are: en_GB, shi_Latn_MA and nl_NL-x-informal # Search for characters followed by a non character (i.e. separator) match = re.match( r"^(?P<language>[a-zA-Z]+)" r"(?P<separator>[^a-zA-Z])" r"(?P<territory>.+)$", locale, ) if match: locale_parts = match.groupdict() language = locale_parts["language"].lower() territory = ( locale_parts["territory"][:2].upper() + locale_parts["territory"][2:] ) proposed_locale = f"{language}_{territory}" else: # It could be a language in uppercase proposed_locale = locale.lower() # Recheck if the proposed locale is valid if is_valid_locale(proposed_locale): self.stdout.write( "invalid locale %s, did you mean %s?" % ( locale, proposed_locale, ), ) else: self.stdout.write("invalid locale %s" % locale) continue if self.verbosity > 0: self.stdout.write("processing locale %s" % locale) for potfile in potfiles: self.write_po_file(potfile, locale) finally: if not self.keep_pot: self.remove_potfiles() @cached_property def gettext_version(self): # Gettext tools will output system-encoded bytestrings instead of UTF-8, # when looking up the version. It's especially a problem on Windows. out, err, status = popen_wrapper( ["xgettext", "--version"], stdout_encoding=DEFAULT_LOCALE_ENCODING, ) m = re.search(r"(\d+)\.(\d+)\.?(\d+)?", out) if m: return tuple(int(d) for d in m.groups() if d is not None) else: raise CommandError("Unable to get gettext version. Is it installed?") @cached_property def settings_available(self): try: settings.LOCALE_PATHS except ImproperlyConfigured: if self.verbosity > 1: self.stderr.write("Running without configured settings.") return False return True def build_potfiles(self): """ Build pot files and apply msguniq to them. """ file_list = self.find_files(".") self.remove_potfiles() self.process_files(file_list) potfiles = [] for path in self.locale_paths: potfile = os.path.join(path, "%s.pot" % self.domain) if not os.path.exists(potfile): continue args = ["msguniq"] + self.msguniq_options + [potfile] msgs, errors, status = popen_wrapper(args) if errors: if status != STATUS_OK: raise CommandError( "errors happened while running msguniq\n%s" % errors ) elif self.verbosity > 0: self.stdout.write(errors) msgs = normalize_eols(msgs) with open(potfile, "w", encoding="utf-8") as fp: fp.write(msgs) potfiles.append(potfile) return potfiles def remove_potfiles(self): for path in self.locale_paths: pot_path = os.path.join(path, "%s.pot" % self.domain) if os.path.exists(pot_path): os.unlink(pot_path) def find_files(self, root): """ Get all files in the given root. Also check that there is a matching locale dir for each file. """ all_files = [] ignored_roots = [] if self.settings_available: ignored_roots = [ os.path.normpath(p) for p in (settings.MEDIA_ROOT, settings.STATIC_ROOT) if p ] for dirpath, dirnames, filenames in os.walk( root, topdown=True, followlinks=self.symlinks ): for dirname in dirnames[:]: if ( is_ignored_path( os.path.normpath(os.path.join(dirpath, dirname)), self.ignore_patterns, ) or os.path.join(os.path.abspath(dirpath), dirname) in ignored_roots ): dirnames.remove(dirname) if self.verbosity > 1: self.stdout.write("ignoring directory %s" % dirname) elif dirname == "locale": dirnames.remove(dirname) self.locale_paths.insert( 0, os.path.join(os.path.abspath(dirpath), dirname) ) for filename in filenames: file_path = os.path.normpath(os.path.join(dirpath, filename)) file_ext = os.path.splitext(filename)[1] if file_ext not in self.extensions or is_ignored_path( file_path, self.ignore_patterns ): if self.verbosity > 1: self.stdout.write( "ignoring file %s in %s" % (filename, dirpath) ) else: locale_dir = None for path in self.locale_paths: if os.path.abspath(dirpath).startswith(os.path.dirname(path)): locale_dir = path break locale_dir = locale_dir or self.default_locale_path or NO_LOCALE_DIR all_files.append( self.translatable_file_class(dirpath, filename, locale_dir) ) return sorted(all_files) def process_files(self, file_list): """ Group translatable files by locale directory and run pot file build process for each group. """ file_groups = {} for translatable in file_list: file_group = file_groups.setdefault(translatable.locale_dir, []) file_group.append(translatable) for locale_dir, files in file_groups.items(): self.process_locale_dir(locale_dir, files) def process_locale_dir(self, locale_dir, files): """ Extract translatable literals from the specified files, creating or updating the POT file for a given locale directory. Use the xgettext GNU gettext utility. """ build_files = [] for translatable in files: if self.verbosity > 1: self.stdout.write( "processing file %s in %s" % (translatable.file, translatable.dirpath) ) if self.domain not in ("djangojs", "django"): continue build_file = self.build_file_class(self, self.domain, translatable) try: build_file.preprocess() except UnicodeDecodeError as e: self.stdout.write( "UnicodeDecodeError: skipped file %s in %s (reason: %s)" % ( translatable.file, translatable.dirpath, e, ) ) continue except BaseException: # Cleanup before exit. for build_file in build_files: build_file.cleanup() raise build_files.append(build_file) if self.domain == "djangojs": is_templatized = build_file.is_templatized args = [ "xgettext", "-d", self.domain, "--language=%s" % ("C" if is_templatized else "JavaScript",), "--keyword=gettext_noop", "--keyword=gettext_lazy", "--keyword=ngettext_lazy:1,2", "--keyword=pgettext:1c,2", "--keyword=npgettext:1c,2,3", "--output=-", ] elif self.domain == "django": args = [ "xgettext", "-d", self.domain, "--language=Python", "--keyword=gettext_noop", "--keyword=gettext_lazy", "--keyword=ngettext_lazy:1,2", "--keyword=pgettext:1c,2", "--keyword=npgettext:1c,2,3", "--keyword=pgettext_lazy:1c,2", "--keyword=npgettext_lazy:1c,2,3", "--output=-", ] else: return input_files = [bf.work_path for bf in build_files] with NamedTemporaryFile(mode="w+") as input_files_list: input_files_list.write("\n".join(input_files)) input_files_list.flush() args.extend(["--files-from", input_files_list.name]) args.extend(self.xgettext_options) msgs, errors, status = popen_wrapper(args) if errors: if status != STATUS_OK: for build_file in build_files: build_file.cleanup() raise CommandError( "errors happened while running xgettext on %s\n%s" % ("\n".join(input_files), errors) ) elif self.verbosity > 0: # Print warnings self.stdout.write(errors) if msgs: if locale_dir is NO_LOCALE_DIR: for build_file in build_files: build_file.cleanup() file_path = os.path.normpath(build_files[0].path) raise CommandError( "Unable to find a locale path to store translations for " "file %s. Make sure the 'locale' directory exists in an " "app or LOCALE_PATHS setting is set." % file_path ) for build_file in build_files: msgs = build_file.postprocess_messages(msgs) potfile = os.path.join(locale_dir, "%s.pot" % self.domain) write_pot_file(potfile, msgs) for build_file in build_files: build_file.cleanup() def write_po_file(self, potfile, locale): """ Create or update the PO file for self.domain and `locale`. Use contents of the existing `potfile`. Use msgmerge and msgattrib GNU gettext utilities. """ basedir = os.path.join(os.path.dirname(potfile), locale, "LC_MESSAGES") os.makedirs(basedir, exist_ok=True) pofile = os.path.join(basedir, "%s.po" % self.domain) if os.path.exists(pofile): args = ["msgmerge"] + self.msgmerge_options + [pofile, potfile] _, errors, status = popen_wrapper(args) if errors: if status != STATUS_OK: raise CommandError( "errors happened while running msgmerge\n%s" % errors ) elif self.verbosity > 0: self.stdout.write(errors) msgs = Path(pofile).read_text(encoding="utf-8") else: with open(potfile, encoding="utf-8") as fp: msgs = fp.read() if not self.invoked_for_django: msgs = self.copy_plural_forms(msgs, locale) msgs = normalize_eols(msgs) msgs = msgs.replace( "#. #-#-#-#-# %s.pot (PACKAGE VERSION) #-#-#-#-#\n" % self.domain, "" ) with open(pofile, "w", encoding="utf-8") as fp: fp.write(msgs) if self.no_obsolete: args = ["msgattrib"] + self.msgattrib_options + ["-o", pofile, pofile] msgs, errors, status = popen_wrapper(args) if errors: if status != STATUS_OK: raise CommandError( "errors happened while running msgattrib\n%s" % errors ) elif self.verbosity > 0: self.stdout.write(errors) def copy_plural_forms(self, msgs, locale): """ Copy plural forms header contents from a Django catalog of locale to the msgs string, inserting it at the right place. msgs should be the contents of a newly created .po file. """ django_dir = os.path.normpath(os.path.join(os.path.dirname(django.__file__))) if self.domain == "djangojs": domains = ("djangojs", "django") else: domains = ("django",) for domain in domains: django_po = os.path.join( django_dir, "conf", "locale", locale, "LC_MESSAGES", "%s.po" % domain ) if os.path.exists(django_po): with open(django_po, encoding="utf-8") as fp: m = plural_forms_re.search(fp.read()) if m: plural_form_line = m["value"] if self.verbosity > 1: self.stdout.write("copying plural forms: %s" % plural_form_line) lines = [] found = False for line in msgs.splitlines(): if not found and (not line or plural_forms_re.search(line)): line = plural_form_line found = True lines.append(line) msgs = "\n".join(lines) break return msgs commands/squashmigrations.py 0000644 00000025155 15030001101 0012305 0 ustar 00 import os import shutil from django.apps import apps from django.conf import settings from django.core.management.base import BaseCommand, CommandError from django.core.management.utils import run_formatters from django.db import DEFAULT_DB_ALIAS, connections, migrations from django.db.migrations.loader import AmbiguityError, MigrationLoader from django.db.migrations.migration import SwappableTuple from django.db.migrations.optimizer import MigrationOptimizer from django.db.migrations.writer import MigrationWriter from django.utils.version import get_docs_version class Command(BaseCommand): help = ( "Squashes an existing set of migrations (from first until specified) into a " "single new one." ) def add_arguments(self, parser): parser.add_argument( "app_label", help="App label of the application to squash migrations for.", ) parser.add_argument( "start_migration_name", nargs="?", help=( "Migrations will be squashed starting from and including this " "migration." ), ) parser.add_argument( "migration_name", help="Migrations will be squashed until and including this migration.", ) parser.add_argument( "--no-optimize", action="store_true", help="Do not try to optimize the squashed operations.", ) parser.add_argument( "--noinput", "--no-input", action="store_false", dest="interactive", help="Tells Django to NOT prompt the user for input of any kind.", ) parser.add_argument( "--squashed-name", help="Sets the name of the new squashed migration.", ) parser.add_argument( "--no-header", action="store_false", dest="include_header", help="Do not add a header comment to the new squashed migration.", ) def handle(self, **options): self.verbosity = options["verbosity"] self.interactive = options["interactive"] app_label = options["app_label"] start_migration_name = options["start_migration_name"] migration_name = options["migration_name"] no_optimize = options["no_optimize"] squashed_name = options["squashed_name"] include_header = options["include_header"] # Validate app_label. try: apps.get_app_config(app_label) except LookupError as err: raise CommandError(str(err)) # Load the current graph state, check the app and migration they asked # for exists. loader = MigrationLoader(connections[DEFAULT_DB_ALIAS]) if app_label not in loader.migrated_apps: raise CommandError( "App '%s' does not have migrations (so squashmigrations on " "it makes no sense)" % app_label ) migration = self.find_migration(loader, app_label, migration_name) # Work out the list of predecessor migrations migrations_to_squash = [ loader.get_migration(al, mn) for al, mn in loader.graph.forwards_plan( (migration.app_label, migration.name) ) if al == migration.app_label ] if start_migration_name: start_migration = self.find_migration( loader, app_label, start_migration_name ) start = loader.get_migration( start_migration.app_label, start_migration.name ) try: start_index = migrations_to_squash.index(start) migrations_to_squash = migrations_to_squash[start_index:] except ValueError: raise CommandError( "The migration '%s' cannot be found. Maybe it comes after " "the migration '%s'?\n" "Have a look at:\n" " python manage.py showmigrations %s\n" "to debug this issue." % (start_migration, migration, app_label) ) # Tell them what we're doing and optionally ask if we should proceed if self.verbosity > 0 or self.interactive: self.stdout.write( self.style.MIGRATE_HEADING("Will squash the following migrations:") ) for migration in migrations_to_squash: self.stdout.write(" - %s" % migration.name) if self.interactive: answer = None while not answer or answer not in "yn": answer = input("Do you wish to proceed? [yN] ") if not answer: answer = "n" break else: answer = answer[0].lower() if answer != "y": return # Load the operations from all those migrations and concat together, # along with collecting external dependencies and detecting # double-squashing operations = [] dependencies = set() # We need to take all dependencies from the first migration in the list # as it may be 0002 depending on 0001 first_migration = True for smigration in migrations_to_squash: if smigration.replaces: raise CommandError( "You cannot squash squashed migrations! Please transition it to a " "normal migration first: https://docs.djangoproject.com/en/%s/" "topics/migrations/#squashing-migrations" % get_docs_version() ) operations.extend(smigration.operations) for dependency in smigration.dependencies: if isinstance(dependency, SwappableTuple): if settings.AUTH_USER_MODEL == dependency.setting: dependencies.add(("__setting__", "AUTH_USER_MODEL")) else: dependencies.add(dependency) elif dependency[0] != smigration.app_label or first_migration: dependencies.add(dependency) first_migration = False if no_optimize: if self.verbosity > 0: self.stdout.write( self.style.MIGRATE_HEADING("(Skipping optimization.)") ) new_operations = operations else: if self.verbosity > 0: self.stdout.write(self.style.MIGRATE_HEADING("Optimizing...")) optimizer = MigrationOptimizer() new_operations = optimizer.optimize(operations, migration.app_label) if self.verbosity > 0: if len(new_operations) == len(operations): self.stdout.write(" No optimizations possible.") else: self.stdout.write( " Optimized from %s operations to %s operations." % (len(operations), len(new_operations)) ) # Work out the value of replaces (any squashed ones we're re-squashing) # need to feed their replaces into ours replaces = [] for migration in migrations_to_squash: if migration.replaces: replaces.extend(migration.replaces) else: replaces.append((migration.app_label, migration.name)) # Make a new migration with those operations subclass = type( "Migration", (migrations.Migration,), { "dependencies": dependencies, "operations": new_operations, "replaces": replaces, }, ) if start_migration_name: if squashed_name: # Use the name from --squashed-name. prefix, _ = start_migration.name.split("_", 1) name = "%s_%s" % (prefix, squashed_name) else: # Generate a name. name = "%s_squashed_%s" % (start_migration.name, migration.name) new_migration = subclass(name, app_label) else: name = "0001_%s" % (squashed_name or "squashed_%s" % migration.name) new_migration = subclass(name, app_label) new_migration.initial = True # Write out the new migration file writer = MigrationWriter(new_migration, include_header) if os.path.exists(writer.path): raise CommandError( f"Migration {new_migration.name} already exists. Use a different name." ) with open(writer.path, "w", encoding="utf-8") as fh: fh.write(writer.as_string()) run_formatters([writer.path]) if self.verbosity > 0: self.stdout.write( self.style.MIGRATE_HEADING( "Created new squashed migration %s" % writer.path ) + "\n" " You should commit this migration but leave the old ones in place;\n" " the new migration will be used for new installs. Once you are sure\n" " all instances of the codebase have applied the migrations you " "squashed,\n" " you can delete them." ) if writer.needs_manual_porting: self.stdout.write( self.style.MIGRATE_HEADING("Manual porting required") + "\n" " Your migrations contained functions that must be manually " "copied over,\n" " as we could not safely copy their implementation.\n" " See the comment at the top of the squashed migration for " "details." ) if shutil.which("black"): self.stdout.write( self.style.WARNING( "Squashed migration couldn't be formatted using the " '"black" command. You can call it manually.' ) ) def find_migration(self, loader, app_label, name): try: return loader.get_migration_by_prefix(app_label, name) except AmbiguityError: raise CommandError( "More than one migration matches '%s' in app '%s'. Please be " "more specific." % (name, app_label) ) except KeyError: raise CommandError( "Cannot find a migration matching '%s' from app '%s'." % (name, app_label) ) commands/check.py 0000644 00000005134 15030001101 0007754 0 ustar 00 from django.apps import apps from django.core import checks from django.core.checks.registry import registry from django.core.management.base import BaseCommand, CommandError class Command(BaseCommand): help = "Checks the entire Django project for potential problems." requires_system_checks = [] def add_arguments(self, parser): parser.add_argument("args", metavar="app_label", nargs="*") parser.add_argument( "--tag", "-t", action="append", dest="tags", help="Run only checks labeled with given tag.", ) parser.add_argument( "--list-tags", action="store_true", help="List available tags.", ) parser.add_argument( "--deploy", action="store_true", help="Check deployment settings.", ) parser.add_argument( "--fail-level", default="ERROR", choices=["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"], help=( "Message level that will cause the command to exit with a " "non-zero status. Default is ERROR." ), ) parser.add_argument( "--database", action="append", dest="databases", help="Run database related checks against these aliases.", ) def handle(self, *app_labels, **options): include_deployment_checks = options["deploy"] if options["list_tags"]: self.stdout.write( "\n".join(sorted(registry.tags_available(include_deployment_checks))) ) return if app_labels: app_configs = [apps.get_app_config(app_label) for app_label in app_labels] else: app_configs = None tags = options["tags"] if tags: try: invalid_tag = next( tag for tag in tags if not checks.tag_exists(tag, include_deployment_checks) ) except StopIteration: # no invalid tags pass else: raise CommandError( 'There is no system check with the "%s" tag.' % invalid_tag ) self.check( app_configs=app_configs, tags=tags, display_num_errors=True, include_deployment_checks=include_deployment_checks, fail_level=getattr(checks, options["fail_level"]), databases=options["databases"], ) commands/dbshell.py 0000644 00000003303 15030001101 0010310 0 ustar 00 import subprocess from django.core.management.base import BaseCommand, CommandError from django.db import DEFAULT_DB_ALIAS, connections class Command(BaseCommand): help = ( "Runs the command-line client for specified database, or the " "default database if none is provided." ) requires_system_checks = [] def add_arguments(self, parser): parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( "Nominates a database onto which to open a shell. Defaults to the " '"default" database.' ), ) parameters = parser.add_argument_group("parameters", prefix_chars="--") parameters.add_argument("parameters", nargs="*") def handle(self, **options): connection = connections[options["database"]] try: connection.client.runshell(options["parameters"]) except FileNotFoundError: # Note that we're assuming the FileNotFoundError relates to the # command missing. It could be raised for some other reason, in # which case this error message would be inaccurate. Still, this # message catches the common case. raise CommandError( "You appear not to have the %r program installed or on your path." % connection.client.executable_name ) except subprocess.CalledProcessError as e: raise CommandError( '"%s" returned non-zero exit status %s.' % ( " ".join(e.cmd), e.returncode, ), returncode=e.returncode, ) commands/compilemessages.py 0000644 00000015520 15030001101 0012057 0 ustar 00 import codecs import concurrent.futures import glob import os from pathlib import Path from django.core.management.base import BaseCommand, CommandError from django.core.management.utils import find_command, is_ignored_path, popen_wrapper def has_bom(fn): with fn.open("rb") as f: sample = f.read(4) return sample.startswith( (codecs.BOM_UTF8, codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE) ) def is_writable(path): # Known side effect: updating file access/modified time to current time if # it is writable. try: with open(path, "a"): os.utime(path, None) except OSError: return False return True class Command(BaseCommand): help = "Compiles .po files to .mo files for use with builtin gettext support." requires_system_checks = [] program = "msgfmt" program_options = ["--check-format"] def add_arguments(self, parser): parser.add_argument( "--locale", "-l", action="append", default=[], help="Locale(s) to process (e.g. de_AT). Default is to process all. " "Can be used multiple times.", ) parser.add_argument( "--exclude", "-x", action="append", default=[], help="Locales to exclude. Default is none. Can be used multiple times.", ) parser.add_argument( "--use-fuzzy", "-f", dest="fuzzy", action="store_true", help="Use fuzzy translations.", ) parser.add_argument( "--ignore", "-i", action="append", dest="ignore_patterns", default=[], metavar="PATTERN", help="Ignore directories matching this glob-style pattern. " "Use multiple times to ignore more.", ) def handle(self, **options): locale = options["locale"] exclude = options["exclude"] ignore_patterns = set(options["ignore_patterns"]) self.verbosity = options["verbosity"] if options["fuzzy"]: self.program_options = self.program_options + ["-f"] if find_command(self.program) is None: raise CommandError( "Can't find %s. Make sure you have GNU gettext " "tools 0.15 or newer installed." % self.program ) basedirs = [os.path.join("conf", "locale"), "locale"] if os.environ.get("DJANGO_SETTINGS_MODULE"): from django.conf import settings basedirs.extend(settings.LOCALE_PATHS) # Walk entire tree, looking for locale directories for dirpath, dirnames, filenames in os.walk(".", topdown=True): for dirname in dirnames: if is_ignored_path( os.path.normpath(os.path.join(dirpath, dirname)), ignore_patterns ): dirnames.remove(dirname) elif dirname == "locale": basedirs.append(os.path.join(dirpath, dirname)) # Gather existing directories. basedirs = set(map(os.path.abspath, filter(os.path.isdir, basedirs))) if not basedirs: raise CommandError( "This script should be run from the Django Git " "checkout or your project or app tree, or with " "the settings module specified." ) # Build locale list all_locales = [] for basedir in basedirs: locale_dirs = filter(os.path.isdir, glob.glob("%s/*" % basedir)) all_locales.extend(map(os.path.basename, locale_dirs)) # Account for excluded locales locales = locale or all_locales locales = set(locales).difference(exclude) self.has_errors = False for basedir in basedirs: if locales: dirs = [ os.path.join(basedir, locale, "LC_MESSAGES") for locale in locales ] else: dirs = [basedir] locations = [] for ldir in dirs: for dirpath, dirnames, filenames in os.walk(ldir): locations.extend( (dirpath, f) for f in filenames if f.endswith(".po") ) if locations: self.compile_messages(locations) if self.has_errors: raise CommandError("compilemessages generated one or more errors.") def compile_messages(self, locations): """ Locations is a list of tuples: [(directory, file), ...] """ with concurrent.futures.ThreadPoolExecutor() as executor: futures = [] for i, (dirpath, f) in enumerate(locations): po_path = Path(dirpath) / f mo_path = po_path.with_suffix(".mo") try: if mo_path.stat().st_mtime >= po_path.stat().st_mtime: if self.verbosity > 0: self.stdout.write( "File “%s” is already compiled and up to date." % po_path ) continue except FileNotFoundError: pass if self.verbosity > 0: self.stdout.write("processing file %s in %s" % (f, dirpath)) if has_bom(po_path): self.stderr.write( "The %s file has a BOM (Byte Order Mark). Django only " "supports .po files encoded in UTF-8 and without any BOM." % po_path ) self.has_errors = True continue # Check writability on first location if i == 0 and not is_writable(mo_path): self.stderr.write( "The po files under %s are in a seemingly not writable " "location. mo files will not be updated/created." % dirpath ) self.has_errors = True return args = [self.program, *self.program_options, "-o", mo_path, po_path] futures.append(executor.submit(popen_wrapper, args)) for future in concurrent.futures.as_completed(futures): output, errors, status = future.result() if status: if self.verbosity > 0: if errors: self.stderr.write( "Execution of %s failed: %s" % (self.program, errors) ) else: self.stderr.write("Execution of %s failed" % self.program) self.has_errors = True commands/sqlflush.py 0000644 00000001737 15030001101 0010545 0 ustar 00 from django.core.management.base import BaseCommand from django.core.management.sql import sql_flush from django.db import DEFAULT_DB_ALIAS, connections class Command(BaseCommand): help = ( "Returns a list of the SQL statements required to return all tables in " "the database to the state they were in just after they were installed." ) output_transaction = True def add_arguments(self, parser): super().add_arguments(parser) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( 'Nominates a database to print the SQL for. Defaults to the "default" ' "database." ), ) def handle(self, **options): sql_statements = sql_flush(self.style, connections[options["database"]]) if not sql_statements and options["verbosity"] >= 1: self.stderr.write("No tables found.") return "\n".join(sql_statements) commands/inspectdb.py 0000644 00000041470 15030001101 0010655 0 ustar 00 import keyword import re from django.core.management.base import BaseCommand, CommandError from django.db import DEFAULT_DB_ALIAS, connections from django.db.models.constants import LOOKUP_SEP class Command(BaseCommand): help = ( "Introspects the database tables in the given database and outputs a Django " "model module." ) requires_system_checks = [] stealth_options = ("table_name_filter",) db_module = "django.db" def add_arguments(self, parser): parser.add_argument( "table", nargs="*", type=str, help="Selects what tables or views should be introspected.", ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( 'Nominates a database to introspect. Defaults to using the "default" ' "database." ), ) parser.add_argument( "--include-partitions", action="store_true", help="Also output models for partition tables.", ) parser.add_argument( "--include-views", action="store_true", help="Also output models for database views.", ) def handle(self, **options): try: for line in self.handle_inspection(options): self.stdout.write(line) except NotImplementedError: raise CommandError( "Database inspection isn't supported for the currently selected " "database backend." ) def handle_inspection(self, options): connection = connections[options["database"]] # 'table_name_filter' is a stealth option table_name_filter = options.get("table_name_filter") def table2model(table_name): return re.sub(r"[^a-zA-Z0-9]", "", table_name.title()) with connection.cursor() as cursor: yield "# This is an auto-generated Django model module." yield "# You'll have to do the following manually to clean this up:" yield "# * Rearrange models' order" yield "# * Make sure each model has one field with primary_key=True" yield ( "# * Make sure each ForeignKey and OneToOneField has `on_delete` set " "to the desired behavior" ) yield ( "# * Remove `managed = False` lines if you wish to allow " "Django to create, modify, and delete the table" ) yield ( "# Feel free to rename the models, but don't rename db_table values or " "field names." ) yield "from %s import models" % self.db_module known_models = [] # Determine types of tables and/or views to be introspected. types = {"t"} if options["include_partitions"]: types.add("p") if options["include_views"]: types.add("v") table_info = connection.introspection.get_table_list(cursor) table_info = {info.name: info for info in table_info if info.type in types} for table_name in options["table"] or sorted(name for name in table_info): if table_name_filter is not None and callable(table_name_filter): if not table_name_filter(table_name): continue try: try: relations = connection.introspection.get_relations( cursor, table_name ) except NotImplementedError: relations = {} try: constraints = connection.introspection.get_constraints( cursor, table_name ) except NotImplementedError: constraints = {} primary_key_columns = ( connection.introspection.get_primary_key_columns( cursor, table_name ) ) primary_key_column = ( primary_key_columns[0] if primary_key_columns else None ) unique_columns = [ c["columns"][0] for c in constraints.values() if c["unique"] and len(c["columns"]) == 1 ] table_description = connection.introspection.get_table_description( cursor, table_name ) except Exception as e: yield "# Unable to inspect table '%s'" % table_name yield "# The error was: %s" % e continue model_name = table2model(table_name) yield "" yield "" yield "class %s(models.Model):" % model_name known_models.append(model_name) used_column_names = [] # Holds column names used in the table so far column_to_field_name = {} # Maps column names to names of model fields used_relations = set() # Holds foreign relations used in the table. for row in table_description: comment_notes = ( [] ) # Holds Field notes, to be displayed in a Python comment. extra_params = {} # Holds Field parameters such as 'db_column'. column_name = row.name is_relation = column_name in relations att_name, params, notes = self.normalize_col_name( column_name, used_column_names, is_relation ) extra_params.update(params) comment_notes.extend(notes) used_column_names.append(att_name) column_to_field_name[column_name] = att_name # Add primary_key and unique, if necessary. if column_name == primary_key_column: extra_params["primary_key"] = True if len(primary_key_columns) > 1: comment_notes.append( "The composite primary key (%s) found, that is not " "supported. The first column is selected." % ", ".join(primary_key_columns) ) elif column_name in unique_columns: extra_params["unique"] = True if is_relation: ref_db_column, ref_db_table = relations[column_name] if extra_params.pop("unique", False) or extra_params.get( "primary_key" ): rel_type = "OneToOneField" else: rel_type = "ForeignKey" ref_pk_column = ( connection.introspection.get_primary_key_column( cursor, ref_db_table ) ) if ref_pk_column and ref_pk_column != ref_db_column: extra_params["to_field"] = ref_db_column rel_to = ( "self" if ref_db_table == table_name else table2model(ref_db_table) ) if rel_to in known_models: field_type = "%s(%s" % (rel_type, rel_to) else: field_type = "%s('%s'" % (rel_type, rel_to) if rel_to in used_relations: extra_params["related_name"] = "%s_%s_set" % ( model_name.lower(), att_name, ) used_relations.add(rel_to) else: # Calling `get_field_type` to get the field type string and any # additional parameters and notes. field_type, field_params, field_notes = self.get_field_type( connection, table_name, row ) extra_params.update(field_params) comment_notes.extend(field_notes) field_type += "(" # Don't output 'id = meta.AutoField(primary_key=True)', because # that's assumed if it doesn't exist. if att_name == "id" and extra_params == {"primary_key": True}: if field_type == "AutoField(": continue elif ( field_type == connection.features.introspected_field_types["AutoField"] + "(" ): comment_notes.append("AutoField?") # Add 'null' and 'blank', if the 'null_ok' flag was present in the # table description. if row.null_ok: # If it's NULL... extra_params["blank"] = True extra_params["null"] = True field_desc = "%s = %s%s" % ( att_name, # Custom fields will have a dotted path "" if "." in field_type else "models.", field_type, ) if field_type.startswith(("ForeignKey(", "OneToOneField(")): field_desc += ", models.DO_NOTHING" # Add comment. if connection.features.supports_comments and row.comment: extra_params["db_comment"] = row.comment if extra_params: if not field_desc.endswith("("): field_desc += ", " field_desc += ", ".join( "%s=%r" % (k, v) for k, v in extra_params.items() ) field_desc += ")" if comment_notes: field_desc += " # " + " ".join(comment_notes) yield " %s" % field_desc comment = None if info := table_info.get(table_name): is_view = info.type == "v" is_partition = info.type == "p" if connection.features.supports_comments: comment = info.comment else: is_view = False is_partition = False yield from self.get_meta( table_name, constraints, column_to_field_name, is_view, is_partition, comment, ) def normalize_col_name(self, col_name, used_column_names, is_relation): """ Modify the column name to make it Python-compatible as a field name """ field_params = {} field_notes = [] new_name = col_name.lower() if new_name != col_name: field_notes.append("Field name made lowercase.") if is_relation: if new_name.endswith("_id"): new_name = new_name[:-3] else: field_params["db_column"] = col_name new_name, num_repl = re.subn(r"\W", "_", new_name) if num_repl > 0: field_notes.append("Field renamed to remove unsuitable characters.") if new_name.find(LOOKUP_SEP) >= 0: while new_name.find(LOOKUP_SEP) >= 0: new_name = new_name.replace(LOOKUP_SEP, "_") if col_name.lower().find(LOOKUP_SEP) >= 0: # Only add the comment if the double underscore was in the original name field_notes.append( "Field renamed because it contained more than one '_' in a row." ) if new_name.startswith("_"): new_name = "field%s" % new_name field_notes.append("Field renamed because it started with '_'.") if new_name.endswith("_"): new_name = "%sfield" % new_name field_notes.append("Field renamed because it ended with '_'.") if keyword.iskeyword(new_name): new_name += "_field" field_notes.append("Field renamed because it was a Python reserved word.") if new_name[0].isdigit(): new_name = "number_%s" % new_name field_notes.append( "Field renamed because it wasn't a valid Python identifier." ) if new_name in used_column_names: num = 0 while "%s_%d" % (new_name, num) in used_column_names: num += 1 new_name = "%s_%d" % (new_name, num) field_notes.append("Field renamed because of name conflict.") if col_name != new_name and field_notes: field_params["db_column"] = col_name return new_name, field_params, field_notes def get_field_type(self, connection, table_name, row): """ Given the database connection, the table name, and the cursor row description, this routine will return the given field type name, as well as any additional keyword parameters and notes for the field. """ field_params = {} field_notes = [] try: field_type = connection.introspection.get_field_type(row.type_code, row) except KeyError: field_type = "TextField" field_notes.append("This field type is a guess.") # Add max_length for all CharFields. if field_type == "CharField" and row.display_size: if (size := int(row.display_size)) and size > 0: field_params["max_length"] = size if field_type in {"CharField", "TextField"} and row.collation: field_params["db_collation"] = row.collation if field_type == "DecimalField": if row.precision is None or row.scale is None: field_notes.append( "max_digits and decimal_places have been guessed, as this " "database handles decimal fields as float" ) field_params["max_digits"] = ( row.precision if row.precision is not None else 10 ) field_params["decimal_places"] = ( row.scale if row.scale is not None else 5 ) else: field_params["max_digits"] = row.precision field_params["decimal_places"] = row.scale return field_type, field_params, field_notes def get_meta( self, table_name, constraints, column_to_field_name, is_view, is_partition, comment, ): """ Return a sequence comprising the lines of code necessary to construct the inner Meta class for the model corresponding to the given database table name. """ unique_together = [] has_unsupported_constraint = False for params in constraints.values(): if params["unique"]: columns = params["columns"] if None in columns: has_unsupported_constraint = True columns = [ x for x in columns if x is not None and x in column_to_field_name ] if len(columns) > 1: unique_together.append( str(tuple(column_to_field_name[c] for c in columns)) ) if is_view: managed_comment = " # Created from a view. Don't remove." elif is_partition: managed_comment = " # Created from a partition. Don't remove." else: managed_comment = "" meta = [""] if has_unsupported_constraint: meta.append(" # A unique constraint could not be introspected.") meta += [ " class Meta:", " managed = False%s" % managed_comment, " db_table = %r" % table_name, ] if unique_together: tup = "(" + ", ".join(unique_together) + ",)" meta += [" unique_together = %s" % tup] if comment: meta += [f" db_table_comment = {comment!r}"] return meta commands/startapp.py 0000644 00000000767 15030001101 0010544 0 ustar 00 from django.core.management.templates import TemplateCommand class Command(TemplateCommand): help = ( "Creates a Django app directory structure for the given app name in " "the current directory or optionally in the given directory." ) missing_args_message = "You must provide an application name." def handle(self, **options): app_name = options.pop("name") target = options.pop("directory") super().handle("app", app_name, target, **options) commands/sqlmigrate.py 0000644 00000006354 15030001101 0011054 0 ustar 00 from django.apps import apps from django.core.management.base import BaseCommand, CommandError from django.db import DEFAULT_DB_ALIAS, connections from django.db.migrations.loader import AmbiguityError, MigrationLoader class Command(BaseCommand): help = "Prints the SQL statements for the named migration." output_transaction = True def add_arguments(self, parser): parser.add_argument( "app_label", help="App label of the application containing the migration." ) parser.add_argument( "migration_name", help="Migration name to print the SQL for." ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( 'Nominates a database to create SQL for. Defaults to the "default" ' "database." ), ) parser.add_argument( "--backwards", action="store_true", help="Creates SQL to unapply the migration, rather than to apply it", ) def execute(self, *args, **options): # sqlmigrate doesn't support coloring its output but we need to force # no_color=True so that the BEGIN/COMMIT statements added by # output_transaction don't get colored either. options["no_color"] = True return super().execute(*args, **options) def handle(self, *args, **options): # Get the database we're operating from connection = connections[options["database"]] # Load up a loader to get all the migration data, but don't replace # migrations. loader = MigrationLoader(connection, replace_migrations=False) # Resolve command-line arguments into a migration app_label, migration_name = options["app_label"], options["migration_name"] # Validate app_label try: apps.get_app_config(app_label) except LookupError as err: raise CommandError(str(err)) if app_label not in loader.migrated_apps: raise CommandError("App '%s' does not have migrations" % app_label) try: migration = loader.get_migration_by_prefix(app_label, migration_name) except AmbiguityError: raise CommandError( "More than one migration matches '%s' in app '%s'. Please be more " "specific." % (migration_name, app_label) ) except KeyError: raise CommandError( "Cannot find a migration matching '%s' from app '%s'. Is it in " "INSTALLED_APPS?" % (migration_name, app_label) ) target = (app_label, migration.name) # Show begin/end around output for atomic migrations, if the database # supports transactional DDL. self.output_transaction = ( migration.atomic and connection.features.can_rollback_ddl ) # Make a plan that represents just the requested migrations and show SQL # for it plan = [(loader.graph.nodes[target], options["backwards"])] sql_statements = loader.collect_sql(plan) if not sql_statements and options["verbosity"] >= 1: self.stderr.write("No operations found.") return "\n".join(sql_statements) commands/loaddata.py 0000644 00000037162 15030001101 0010456 0 ustar 00 import functools import glob import gzip import os import sys import warnings import zipfile from itertools import product from django.apps import apps from django.conf import settings from django.core import serializers from django.core.exceptions import ImproperlyConfigured from django.core.management.base import BaseCommand, CommandError from django.core.management.color import no_style from django.core.management.utils import parse_apps_and_model_labels from django.db import ( DEFAULT_DB_ALIAS, DatabaseError, IntegrityError, connections, router, transaction, ) from django.utils.functional import cached_property try: import bz2 has_bz2 = True except ImportError: has_bz2 = False try: import lzma has_lzma = True except ImportError: has_lzma = False READ_STDIN = "-" class Command(BaseCommand): help = "Installs the named fixture(s) in the database." missing_args_message = ( "No database fixture specified. Please provide the path of at least " "one fixture in the command line." ) def add_arguments(self, parser): parser.add_argument( "args", metavar="fixture", nargs="+", help="Fixture labels." ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help=( "Nominates a specific database to load fixtures into. Defaults to the " '"default" database.' ), ) parser.add_argument( "--app", dest="app_label", help="Only look for fixtures in the specified app.", ) parser.add_argument( "--ignorenonexistent", "-i", action="store_true", dest="ignore", help="Ignores entries in the serialized data for fields that do not " "currently exist on the model.", ) parser.add_argument( "-e", "--exclude", action="append", default=[], help=( "An app_label or app_label.ModelName to exclude. Can be used multiple " "times." ), ) parser.add_argument( "--format", help="Format of serialized data when reading from stdin.", ) def handle(self, *fixture_labels, **options): self.ignore = options["ignore"] self.using = options["database"] self.app_label = options["app_label"] self.verbosity = options["verbosity"] self.excluded_models, self.excluded_apps = parse_apps_and_model_labels( options["exclude"] ) self.format = options["format"] with transaction.atomic(using=self.using): self.loaddata(fixture_labels) # Close the DB connection -- unless we're still in a transaction. This # is required as a workaround for an edge case in MySQL: if the same # connection is used to create tables, load data, and query, the query # can return incorrect results. See Django #7572, MySQL #37735. if transaction.get_autocommit(self.using): connections[self.using].close() @cached_property def compression_formats(self): """A dict mapping format names to (open function, mode arg) tuples.""" # Forcing binary mode may be revisited after dropping Python 2 support # (see #22399). compression_formats = { None: (open, "rb"), "gz": (gzip.GzipFile, "rb"), "zip": (SingleZipReader, "r"), "stdin": (lambda *args: sys.stdin, None), } if has_bz2: compression_formats["bz2"] = (bz2.BZ2File, "r") if has_lzma: compression_formats["lzma"] = (lzma.LZMAFile, "r") compression_formats["xz"] = (lzma.LZMAFile, "r") return compression_formats def reset_sequences(self, connection, models): """Reset database sequences for the given connection and models.""" sequence_sql = connection.ops.sequence_reset_sql(no_style(), models) if sequence_sql: if self.verbosity >= 2: self.stdout.write("Resetting sequences") with connection.cursor() as cursor: for line in sequence_sql: cursor.execute(line) def loaddata(self, fixture_labels): connection = connections[self.using] # Keep a count of the installed objects and fixtures self.fixture_count = 0 self.loaded_object_count = 0 self.fixture_object_count = 0 self.models = set() self.serialization_formats = serializers.get_public_serializer_formats() # Django's test suite repeatedly tries to load initial_data fixtures # from apps that don't have any fixtures. Because disabling constraint # checks can be expensive on some database (especially MSSQL), bail # out early if no fixtures are found. for fixture_label in fixture_labels: if self.find_fixtures(fixture_label): break else: return self.objs_with_deferred_fields = [] with connection.constraint_checks_disabled(): for fixture_label in fixture_labels: self.load_label(fixture_label) for obj in self.objs_with_deferred_fields: obj.save_deferred_fields(using=self.using) # Since we disabled constraint checks, we must manually check for # any invalid keys that might have been added table_names = [model._meta.db_table for model in self.models] try: connection.check_constraints(table_names=table_names) except Exception as e: e.args = ("Problem installing fixtures: %s" % e,) raise # If we found even one object in a fixture, we need to reset the # database sequences. if self.loaded_object_count > 0: self.reset_sequences(connection, self.models) if self.verbosity >= 1: if self.fixture_object_count == self.loaded_object_count: self.stdout.write( "Installed %d object(s) from %d fixture(s)" % (self.loaded_object_count, self.fixture_count) ) else: self.stdout.write( "Installed %d object(s) (of %d) from %d fixture(s)" % ( self.loaded_object_count, self.fixture_object_count, self.fixture_count, ) ) def save_obj(self, obj): """Save an object if permitted.""" if ( obj.object._meta.app_config in self.excluded_apps or type(obj.object) in self.excluded_models ): return False saved = False if router.allow_migrate_model(self.using, obj.object.__class__): saved = True self.models.add(obj.object.__class__) try: obj.save(using=self.using) # psycopg raises ValueError if data contains NUL chars. except (DatabaseError, IntegrityError, ValueError) as e: e.args = ( "Could not load %(object_label)s(pk=%(pk)s): %(error_msg)s" % { "object_label": obj.object._meta.label, "pk": obj.object.pk, "error_msg": e, }, ) raise if obj.deferred_fields: self.objs_with_deferred_fields.append(obj) return saved def load_label(self, fixture_label): """Load fixtures files for a given label.""" show_progress = self.verbosity >= 3 for fixture_file, fixture_dir, fixture_name in self.find_fixtures( fixture_label ): _, ser_fmt, cmp_fmt = self.parse_name(os.path.basename(fixture_file)) open_method, mode = self.compression_formats[cmp_fmt] fixture = open_method(fixture_file, mode) self.fixture_count += 1 objects_in_fixture = 0 loaded_objects_in_fixture = 0 if self.verbosity >= 2: self.stdout.write( "Installing %s fixture '%s' from %s." % (ser_fmt, fixture_name, humanize(fixture_dir)) ) try: objects = serializers.deserialize( ser_fmt, fixture, using=self.using, ignorenonexistent=self.ignore, handle_forward_references=True, ) for obj in objects: objects_in_fixture += 1 if self.save_obj(obj): loaded_objects_in_fixture += 1 if show_progress: self.stdout.write( "\rProcessed %i object(s)." % loaded_objects_in_fixture, ending="", ) except Exception as e: if not isinstance(e, CommandError): e.args = ( "Problem installing fixture '%s': %s" % (fixture_file, e), ) raise finally: fixture.close() if objects_in_fixture and show_progress: self.stdout.write() # Add a newline after progress indicator. self.loaded_object_count += loaded_objects_in_fixture self.fixture_object_count += objects_in_fixture # Warn if the fixture we loaded contains 0 objects. if objects_in_fixture == 0: warnings.warn( "No fixture data found for '%s'. (File format may be " "invalid.)" % fixture_name, RuntimeWarning, ) def get_fixture_name_and_dirs(self, fixture_name): dirname, basename = os.path.split(fixture_name) if os.path.isabs(fixture_name): fixture_dirs = [dirname] else: fixture_dirs = self.fixture_dirs if os.path.sep in os.path.normpath(fixture_name): fixture_dirs = [os.path.join(dir_, dirname) for dir_ in fixture_dirs] return basename, fixture_dirs def get_targets(self, fixture_name, ser_fmt, cmp_fmt): databases = [self.using, None] cmp_fmts = self.compression_formats if cmp_fmt is None else [cmp_fmt] ser_fmts = self.serialization_formats if ser_fmt is None else [ser_fmt] return { "%s.%s" % ( fixture_name, ".".join([ext for ext in combo if ext]), ) for combo in product(databases, ser_fmts, cmp_fmts) } def find_fixture_files_in_dir(self, fixture_dir, fixture_name, targets): fixture_files_in_dir = [] path = os.path.join(fixture_dir, fixture_name) for candidate in glob.iglob(glob.escape(path) + "*"): if os.path.basename(candidate) in targets: # Save the fixture_dir and fixture_name for future error # messages. fixture_files_in_dir.append((candidate, fixture_dir, fixture_name)) return fixture_files_in_dir @functools.lru_cache(maxsize=None) def find_fixtures(self, fixture_label): """Find fixture files for a given label.""" if fixture_label == READ_STDIN: return [(READ_STDIN, None, READ_STDIN)] fixture_name, ser_fmt, cmp_fmt = self.parse_name(fixture_label) if self.verbosity >= 2: self.stdout.write("Loading '%s' fixtures..." % fixture_name) fixture_name, fixture_dirs = self.get_fixture_name_and_dirs(fixture_name) targets = self.get_targets(fixture_name, ser_fmt, cmp_fmt) fixture_files = [] for fixture_dir in fixture_dirs: if self.verbosity >= 2: self.stdout.write("Checking %s for fixtures..." % humanize(fixture_dir)) fixture_files_in_dir = self.find_fixture_files_in_dir( fixture_dir, fixture_name, targets, ) if self.verbosity >= 2 and not fixture_files_in_dir: self.stdout.write( "No fixture '%s' in %s." % (fixture_name, humanize(fixture_dir)) ) # Check kept for backwards-compatibility; it isn't clear why # duplicates are only allowed in different directories. if len(fixture_files_in_dir) > 1: raise CommandError( "Multiple fixtures named '%s' in %s. Aborting." % (fixture_name, humanize(fixture_dir)) ) fixture_files.extend(fixture_files_in_dir) if not fixture_files: raise CommandError("No fixture named '%s' found." % fixture_name) return fixture_files @cached_property def fixture_dirs(self): """ Return a list of fixture directories. The list contains the 'fixtures' subdirectory of each installed application, if it exists, the directories in FIXTURE_DIRS, and the current directory. """ dirs = [] fixture_dirs = settings.FIXTURE_DIRS if len(fixture_dirs) != len(set(fixture_dirs)): raise ImproperlyConfigured("settings.FIXTURE_DIRS contains duplicates.") for app_config in apps.get_app_configs(): app_label = app_config.label app_dir = os.path.join(app_config.path, "fixtures") if app_dir in [str(d) for d in fixture_dirs]: raise ImproperlyConfigured( "'%s' is a default fixture directory for the '%s' app " "and cannot be listed in settings.FIXTURE_DIRS." % (app_dir, app_label) ) if self.app_label and app_label != self.app_label: continue if os.path.isdir(app_dir): dirs.append(app_dir) dirs.extend(fixture_dirs) dirs.append("") return [os.path.realpath(d) for d in dirs] def parse_name(self, fixture_name): """ Split fixture name in name, serialization format, compression format. """ if fixture_name == READ_STDIN: if not self.format: raise CommandError( "--format must be specified when reading from stdin." ) return READ_STDIN, self.format, "stdin" parts = fixture_name.rsplit(".", 2) if len(parts) > 1 and parts[-1] in self.compression_formats: cmp_fmt = parts[-1] parts = parts[:-1] else: cmp_fmt = None if len(parts) > 1: if parts[-1] in self.serialization_formats: ser_fmt = parts[-1] parts = parts[:-1] else: raise CommandError( "Problem installing fixture '%s': %s is not a known " "serialization format." % (".".join(parts[:-1]), parts[-1]) ) else: ser_fmt = None name = ".".join(parts) return name, ser_fmt, cmp_fmt class SingleZipReader(zipfile.ZipFile): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) if len(self.namelist()) != 1: raise ValueError("Zip-compressed fixtures must contain one file.") def read(self): return zipfile.ZipFile.read(self, self.namelist()[0]) def humanize(dirname): return "'%s'" % dirname if dirname else "absolute path" commands/shell.py 0000644 00000011005 15030001101 0010000 0 ustar 00 import os import select import sys import traceback from django.core.management import BaseCommand, CommandError from django.utils.datastructures import OrderedSet class Command(BaseCommand): help = ( "Runs a Python interactive interpreter. Tries to use IPython or " "bpython, if one of them is available. Any standard input is executed " "as code." ) requires_system_checks = [] shells = ["ipython", "bpython", "python"] def add_arguments(self, parser): parser.add_argument( "--no-startup", action="store_true", help=( "When using plain Python, ignore the PYTHONSTARTUP environment " "variable and ~/.pythonrc.py script." ), ) parser.add_argument( "-i", "--interface", choices=self.shells, help=( "Specify an interactive interpreter interface. Available options: " '"ipython", "bpython", and "python"' ), ) parser.add_argument( "-c", "--command", help=( "Instead of opening an interactive shell, run a command as Django and " "exit." ), ) def ipython(self, options): from IPython import start_ipython start_ipython(argv=[]) def bpython(self, options): import bpython bpython.embed() def python(self, options): import code # Set up a dictionary to serve as the environment for the shell. imported_objects = {} # We want to honor both $PYTHONSTARTUP and .pythonrc.py, so follow system # conventions and get $PYTHONSTARTUP first then .pythonrc.py. if not options["no_startup"]: for pythonrc in OrderedSet( [os.environ.get("PYTHONSTARTUP"), os.path.expanduser("~/.pythonrc.py")] ): if not pythonrc: continue if not os.path.isfile(pythonrc): continue with open(pythonrc) as handle: pythonrc_code = handle.read() # Match the behavior of the cpython shell where an error in # PYTHONSTARTUP prints an exception and continues. try: exec(compile(pythonrc_code, pythonrc, "exec"), imported_objects) except Exception: traceback.print_exc() # By default, this will set up readline to do tab completion and to read and # write history to the .python_history file, but this can be overridden by # $PYTHONSTARTUP or ~/.pythonrc.py. try: hook = sys.__interactivehook__ except AttributeError: # Match the behavior of the cpython shell where a missing # sys.__interactivehook__ is ignored. pass else: try: hook() except Exception: # Match the behavior of the cpython shell where an error in # sys.__interactivehook__ prints a warning and the exception # and continues. print("Failed calling sys.__interactivehook__") traceback.print_exc() # Set up tab completion for objects imported by $PYTHONSTARTUP or # ~/.pythonrc.py. try: import readline import rlcompleter readline.set_completer(rlcompleter.Completer(imported_objects).complete) except ImportError: pass # Start the interactive interpreter. code.interact(local=imported_objects) def handle(self, **options): # Execute the command and exit. if options["command"]: exec(options["command"], globals()) return # Execute stdin if it has anything to read and exit. # Not supported on Windows due to select.select() limitations. if ( sys.platform != "win32" and not sys.stdin.isatty() and select.select([sys.stdin], [], [], 0)[0] ): exec(sys.stdin.read(), globals()) return available_shells = ( [options["interface"]] if options["interface"] else self.shells ) for shell in available_shells: try: return getattr(self, shell)(options) except ImportError: pass raise CommandError("Couldn't import {} interface.".format(shell)) commands/flush.py 0000644 00000007033 15030001101 0010020 0 ustar 00 from importlib import import_module from django.apps import apps from django.core.management.base import BaseCommand, CommandError from django.core.management.color import no_style from django.core.management.sql import emit_post_migrate_signal, sql_flush from django.db import DEFAULT_DB_ALIAS, connections class Command(BaseCommand): help = ( "Removes ALL DATA from the database, including data added during " 'migrations. Does not achieve a "fresh install" state.' ) stealth_options = ("reset_sequences", "allow_cascade", "inhibit_post_migrate") def add_arguments(self, parser): parser.add_argument( "--noinput", "--no-input", action="store_false", dest="interactive", help="Tells Django to NOT prompt the user for input of any kind.", ) parser.add_argument( "--database", default=DEFAULT_DB_ALIAS, help='Nominates a database to flush. Defaults to the "default" database.', ) def handle(self, **options): database = options["database"] connection = connections[database] verbosity = options["verbosity"] interactive = options["interactive"] # The following are stealth options used by Django's internals. reset_sequences = options.get("reset_sequences", True) allow_cascade = options.get("allow_cascade", False) inhibit_post_migrate = options.get("inhibit_post_migrate", False) self.style = no_style() # Import the 'management' module within each installed app, to register # dispatcher events. for app_config in apps.get_app_configs(): try: import_module(".management", app_config.name) except ImportError: pass sql_list = sql_flush( self.style, connection, reset_sequences=reset_sequences, allow_cascade=allow_cascade, ) if interactive: confirm = input( """You have requested a flush of the database. This will IRREVERSIBLY DESTROY all data currently in the "%s" database, and return each table to an empty state. Are you sure you want to do this? Type 'yes' to continue, or 'no' to cancel: """ % connection.settings_dict["NAME"] ) else: confirm = "yes" if confirm == "yes": try: connection.ops.execute_sql_flush(sql_list) except Exception as exc: raise CommandError( "Database %s couldn't be flushed. Possible reasons:\n" " * The database isn't running or isn't configured correctly.\n" " * At least one of the expected database tables doesn't exist.\n" " * The SQL was invalid.\n" "Hint: Look at the output of 'django-admin sqlflush'. " "That's the SQL this command wasn't able to run." % (connection.settings_dict["NAME"],) ) from exc # Empty sql_list may signify an empty database and post_migrate # would then crash. if sql_list and not inhibit_post_migrate: # Emit the post migrate signal. This allows individual applications to # respond as if the database had been migrated from scratch. emit_post_migrate_signal(verbosity, interactive, database) else: self.stdout.write("Flush cancelled.") commands/__init__.py 0000644 00000000000 15030001101 0010421 0 ustar 00 commands/startproject.py 0000644 00000001425 15030001101 0011422 0 ustar 00 from django.core.checks.security.base import SECRET_KEY_INSECURE_PREFIX from django.core.management.templates import TemplateCommand from ..utils import get_random_secret_key class Command(TemplateCommand): help = ( "Creates a Django project directory structure for the given project " "name in the current directory or optionally in the given directory." ) missing_args_message = "You must provide a project name." def handle(self, **options): project_name = options.pop("name") target = options.pop("directory") # Create a random SECRET_KEY to put it in the main settings. options["secret_key"] = SECRET_KEY_INSECURE_PREFIX + get_random_secret_key() super().handle("project", project_name, target, **options) color.py 0000644 00000005476 15030001101 0006225 0 ustar 00 """ Sets up the terminal color scheme. """ import functools import os import sys from django.utils import termcolors try: import colorama colorama.init() except (ImportError, OSError): HAS_COLORAMA = False else: HAS_COLORAMA = True def supports_color(): """ Return True if the running system's terminal supports color, and False otherwise. """ def vt_codes_enabled_in_windows_registry(): """ Check the Windows Registry to see if VT code handling has been enabled by default, see https://superuser.com/a/1300251/447564. """ try: # winreg is only available on Windows. import winreg except ImportError: return False else: try: reg_key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Console") reg_key_value, _ = winreg.QueryValueEx(reg_key, "VirtualTerminalLevel") except FileNotFoundError: return False else: return reg_key_value == 1 # isatty is not always implemented, #6223. is_a_tty = hasattr(sys.stdout, "isatty") and sys.stdout.isatty() return is_a_tty and ( sys.platform != "win32" or HAS_COLORAMA or "ANSICON" in os.environ or # Windows Terminal supports VT codes. "WT_SESSION" in os.environ or # Microsoft Visual Studio Code's built-in terminal supports colors. os.environ.get("TERM_PROGRAM") == "vscode" or vt_codes_enabled_in_windows_registry() ) class Style: pass def make_style(config_string=""): """ Create a Style object from the given config_string. If config_string is empty django.utils.termcolors.DEFAULT_PALETTE is used. """ style = Style() color_settings = termcolors.parse_color_setting(config_string) # The nocolor palette has all available roles. # Use that palette as the basis for populating # the palette as defined in the environment. for role in termcolors.PALETTES[termcolors.NOCOLOR_PALETTE]: if color_settings: format = color_settings.get(role, {}) style_func = termcolors.make_style(**format) else: def style_func(x): return x setattr(style, role, style_func) # For backwards compatibility, # set style for ERROR_OUTPUT == ERROR style.ERROR_OUTPUT = style.ERROR return style @functools.lru_cache(maxsize=None) def no_style(): """ Return a Style object with no color scheme. """ return make_style("nocolor") def color_style(force_color=False): """ Return a Style object from the Django color scheme. """ if not force_color and not supports_color(): return no_style() return make_style(os.environ.get("DJANGO_COLORS", "")) __init__.py 0000644 00000042017 15030001101 0006636 0 ustar 00 import functools import os import pkgutil import sys from argparse import ( _AppendConstAction, _CountAction, _StoreConstAction, _SubParsersAction, ) from collections import defaultdict from difflib import get_close_matches from importlib import import_module import django from django.apps import apps from django.conf import settings from django.core.exceptions import ImproperlyConfigured from django.core.management.base import ( BaseCommand, CommandError, CommandParser, handle_default_options, ) from django.core.management.color import color_style from django.utils import autoreload def find_commands(management_dir): """ Given a path to a management directory, return a list of all the command names that are available. """ command_dir = os.path.join(management_dir, "commands") return [ name for _, name, is_pkg in pkgutil.iter_modules([command_dir]) if not is_pkg and not name.startswith("_") ] def load_command_class(app_name, name): """ Given a command name and an application name, return the Command class instance. Allow all errors raised by the import process (ImportError, AttributeError) to propagate. """ module = import_module("%s.management.commands.%s" % (app_name, name)) return module.Command() @functools.lru_cache(maxsize=None) def get_commands(): """ Return a dictionary mapping command names to their callback applications. Look for a management.commands package in django.core, and in each installed application -- if a commands package exists, register all commands in that package. Core commands are always included. If a settings module has been specified, also include user-defined commands. The dictionary is in the format {command_name: app_name}. Key-value pairs from this dictionary can then be used in calls to load_command_class(app_name, command_name) The dictionary is cached on the first call and reused on subsequent calls. """ commands = {name: "django.core" for name in find_commands(__path__[0])} if not settings.configured: return commands for app_config in reversed(apps.get_app_configs()): path = os.path.join(app_config.path, "management") commands.update({name: app_config.name for name in find_commands(path)}) return commands def call_command(command_name, *args, **options): """ Call the given command, with the given options and args/kwargs. This is the primary API you should use for calling specific commands. `command_name` may be a string or a command object. Using a string is preferred unless the command object is required for further processing or testing. Some examples: call_command('migrate') call_command('shell', plain=True) call_command('sqlmigrate', 'myapp') from django.core.management.commands import flush cmd = flush.Command() call_command(cmd, verbosity=0, interactive=False) # Do something with cmd ... """ if isinstance(command_name, BaseCommand): # Command object passed in. command = command_name command_name = command.__class__.__module__.split(".")[-1] else: # Load the command object by name. try: app_name = get_commands()[command_name] except KeyError: raise CommandError("Unknown command: %r" % command_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, command_name) # Simulate argument parsing to get the option defaults (see #10080 for details). parser = command.create_parser("", command_name) # Use the `dest` option name from the parser option opt_mapping = { min(s_opt.option_strings).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()} parse_args = [] for arg in args: if isinstance(arg, (list, tuple)): parse_args += map(str, arg) else: parse_args.append(str(arg)) def get_actions(parser): # Parser actions and actions from sub-parser choices. for opt in parser._actions: if isinstance(opt, _SubParsersAction): for sub_opt in opt.choices.values(): yield from get_actions(sub_opt) else: yield opt parser_actions = list(get_actions(parser)) mutually_exclusive_required_options = { opt for group in parser._mutually_exclusive_groups for opt in group._group_actions if group.required } # Any required arguments which are passed in via **options must be passed # to parse_args(). for opt in parser_actions: if opt.dest in options and ( opt.required or opt in mutually_exclusive_required_options ): opt_dest_count = sum(v == opt.dest for v in opt_mapping.values()) if opt_dest_count > 1: raise TypeError( f"Cannot pass the dest {opt.dest!r} that matches multiple " f"arguments via **options." ) parse_args.append(min(opt.option_strings)) if isinstance(opt, (_AppendConstAction, _CountAction, _StoreConstAction)): continue value = arg_options[opt.dest] if isinstance(value, (list, tuple)): parse_args += map(str, value) else: parse_args.append(str(value)) defaults = parser.parse_args(args=parse_args) defaults = dict(defaults._get_kwargs(), **arg_options) # Raise an error if any unknown options were passed. stealth_options = set(command.base_stealth_options + command.stealth_options) dest_parameters = {action.dest for action in parser_actions} valid_options = (dest_parameters | stealth_options).union(opt_mapping) unknown_options = set(options) - valid_options if unknown_options: raise TypeError( "Unknown option(s) for %s command: %s. " "Valid options are: %s." % ( command_name, ", ".join(sorted(unknown_options)), ", ".join(sorted(valid_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) class ManagementUtility: """ Encapsulate the logic of the django-admin and manage.py utilities. """ def __init__(self, argv=None): self.argv = argv or sys.argv[:] self.prog_name = os.path.basename(self.argv[0]) if self.prog_name == "__main__.py": self.prog_name = "python -m django" self.settings_exception = None def main_help_text(self, commands_only=False): """Return the script's main help text, as a string.""" if commands_only: usage = sorted(get_commands()) else: usage = [ "", "Type '%s help <subcommand>' for help on a specific subcommand." % self.prog_name, "", "Available subcommands:", ] commands_dict = defaultdict(lambda: []) for name, app in get_commands().items(): if app == "django.core": app = "django" else: app = app.rpartition(".")[-1] commands_dict[app].append(name) style = color_style() for app in sorted(commands_dict): usage.append("") usage.append(style.NOTICE("[%s]" % app)) for name in sorted(commands_dict[app]): usage.append(" %s" % name) # Output an extra note if settings are not properly configured if self.settings_exception is not None: usage.append( style.NOTICE( "Note that only Django core commands are listed " "as settings are not properly configured (error: %s)." % self.settings_exception ) ) return "\n".join(usage) def fetch_command(self, subcommand): """ Try 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. """ # Get commands outside of try block to prevent swallowing exceptions 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 elif not settings.configured: 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 autocomplete(self): """ Output completion suggestions for BASH. The output of this function is passed to BASH's `COMREPLY` variable and treated as completion suggestions. `COMREPLY` expects a space separated string as the result. The `COMP_WORDS` and `COMP_CWORD` BASH environment variables are used to get information about the cli input. Please refer to the BASH man-page for more information about this variables. Subcommand options are saved as pairs. A pair consists of the long option string (e.g. '--exclude') and a boolean value indicating if the option requires arguments. When printing to stdout, an equal sign is appended to options which require arguments. Note: If debugging this function, it is recommended to write the debug output in a separate file. Otherwise the debug output will be treated and formatted as potential completion suggestions. """ # Don't complete if user hasn't sourced bash_completion file. if "DJANGO_AUTO_COMPLETE" not in os.environ: return cwords = os.environ["COMP_WORDS"].split()[1:] cword = int(os.environ["COMP_CWORD"]) try: curr = cwords[cword - 1] except IndexError: curr = "" subcommands = [*get_commands(), "help"] options = [("--help", False)] # subcommand if cword == 1: print(" ".join(sorted(filter(lambda x: x.startswith(curr), subcommands)))) # subcommand options # special case: the 'help' subcommand has no options elif cwords[0] in subcommands and cwords[0] != "help": subcommand_cls = self.fetch_command(cwords[0]) # special case: add the names of installed apps to options if cwords[0] in ("dumpdata", "sqlmigrate", "sqlsequencereset", "test"): try: app_configs = apps.get_app_configs() # Get the last part of the dotted path as the app name. options.extend((app_config.label, 0) for app_config in app_configs) except ImportError: # Fail silently if DJANGO_SETTINGS_MODULE isn't set. The # user will find out once they execute the command. pass parser = subcommand_cls.create_parser("", cwords[0]) options.extend( (min(s_opt.option_strings), s_opt.nargs != 0) for s_opt in parser._actions if s_opt.option_strings ) # filter out previously specified options from available options prev_opts = {x.split("=")[0] for x in cwords[1 : cword - 1]} options = (opt for opt in options if opt[0] not in prev_opts) # filter options by current input options = sorted((k, v) for k, v in options if k.startswith(curr)) for opt_label, require_arg in options: # append '=' to options which require args if require_arg: opt_label += "=" print(opt_label) # Exit code of the bash completion function is never passed back to # the user, so it's safe to always exit with 0. # For more details see #25420. sys.exit(0) def execute(self): """ Given the command-line arguments, figure out which subcommand is being run, create a parser appropriate to that command, and run it. """ try: subcommand = self.argv[1] except IndexError: subcommand = "help" # Display help if no arguments were given. # Preprocess options to extract --settings and --pythonpath. # These options could affect the commands that are available, so they # must be processed early. parser = CommandParser( prog=self.prog_name, usage="%(prog)s subcommand [options] [args]", add_help=False, allow_abbrev=False, ) parser.add_argument("--settings") parser.add_argument("--pythonpath") parser.add_argument("args", nargs="*") # catch-all try: options, args = parser.parse_known_args(self.argv[2:]) handle_default_options(options) except CommandError: pass # Ignore any option errors at this point. try: settings.INSTALLED_APPS except ImproperlyConfigured as exc: self.settings_exception = exc except ImportError as exc: self.settings_exception = exc if settings.configured: # Start the auto-reloading dev server even if the code is broken. # The hardcoded condition is a code smell but we can't rely on a # flag on the command class because we haven't located it yet. if subcommand == "runserver" and "--noreload" not in self.argv: try: autoreload.check_errors(django.setup)() except Exception: # The exception will be raised later in the child process # started by the autoreloader. Pretend it didn't happen by # loading an empty list of applications. apps.all_models = defaultdict(dict) apps.app_configs = {} apps.apps_ready = apps.models_ready = apps.ready = True # Remove options not compatible with the built-in runserver # (e.g. options for the contrib.staticfiles' runserver). # Changes here require manually testing as described in # #27522. _parser = self.fetch_command("runserver").create_parser( "django", "runserver" ) _options, _args = _parser.parse_known_args(self.argv[2:]) for _arg in _args: self.argv.remove(_arg) # In all other cases, django.setup() is required to succeed. else: django.setup() self.autocomplete() if subcommand == "help": if "--commands" in args: sys.stdout.write(self.main_help_text(commands_only=True) + "\n") elif not options.args: sys.stdout.write(self.main_help_text() + "\n") else: self.fetch_command(options.args[0]).print_help( self.prog_name, options.args[0] ) # Special-cases: We want 'django-admin --version' and # 'django-admin --help' to work, for backwards compatibility. elif subcommand == "version" or self.argv[1:] == ["--version"]: sys.stdout.write(django.get_version() + "\n") elif self.argv[1:] in (["--help"], ["-h"]): sys.stdout.write(self.main_help_text() + "\n") else: self.fetch_command(subcommand).run_from_argv(self.argv) def execute_from_command_line(argv=None): """Run a ManagementUtility.""" utility = ManagementUtility(argv) utility.execute() utils.py 0000644 00000012465 15030001101 0006243 0 ustar 00 import fnmatch import os import shutil import subprocess from pathlib import Path from subprocess import run from django.apps import apps as installed_apps from django.utils.crypto import get_random_string from django.utils.encoding import DEFAULT_LOCALE_ENCODING from .base import CommandError, CommandParser def popen_wrapper(args, stdout_encoding="utf-8"): """ Friendly wrapper around Popen. Return stdout output, stderr output, and OS status code. """ try: p = run(args, capture_output=True, close_fds=os.name != "nt") except OSError as err: raise CommandError("Error executing %s" % args[0]) from err return ( p.stdout.decode(stdout_encoding), p.stderr.decode(DEFAULT_LOCALE_ENCODING, errors="replace"), p.returncode, ) def handle_extensions(extensions): """ Organize multiple extensions that are separated with commas or passed by using --extension/-e multiple times. For example: running 'django-admin makemessages -e js,txt -e xhtml -a' would result in an extension list: ['.js', '.txt', '.xhtml'] >>> handle_extensions(['.html', 'html,js,py,py,py,.py', 'py,.py']) {'.html', '.js', '.py'} >>> handle_extensions(['.html, txt,.tpl']) {'.html', '.tpl', '.txt'} """ ext_list = [] for ext in extensions: ext_list.extend(ext.replace(" ", "").split(",")) for i, ext in enumerate(ext_list): if not ext.startswith("."): ext_list[i] = ".%s" % ext_list[i] return set(ext_list) def find_command(cmd, path=None, pathext=None): if path is None: path = os.environ.get("PATH", "").split(os.pathsep) if isinstance(path, str): path = [path] # check if there are funny path extensions for executables, e.g. Windows if pathext is None: pathext = os.environ.get("PATHEXT", ".COM;.EXE;.BAT;.CMD").split(os.pathsep) # don't use extensions if the command ends with one of them for ext in pathext: if cmd.endswith(ext): pathext = [""] break # check if we find the command on PATH for p in path: f = os.path.join(p, cmd) if os.path.isfile(f): return f for ext in pathext: fext = f + ext if os.path.isfile(fext): return fext return None def get_random_secret_key(): """ Return a 50 character random string usable as a SECRET_KEY setting value. """ chars = "abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)" return get_random_string(50, chars) def parse_apps_and_model_labels(labels): """ Parse a list of "app_label.ModelName" or "app_label" strings into actual objects and return a two-element tuple: (set of model classes, set of app_configs). Raise a CommandError if some specified models or apps don't exist. """ apps = set() models = set() for label in labels: if "." in label: try: model = installed_apps.get_model(label) except LookupError: raise CommandError("Unknown model: %s" % label) models.add(model) else: try: app_config = installed_apps.get_app_config(label) except LookupError as e: raise CommandError(str(e)) apps.add(app_config) return models, apps def get_command_line_option(argv, option): """ Return the value of a command line option (which should include leading dashes, e.g. '--testrunner') from an argument list. Return None if the option wasn't passed or if the argument list couldn't be parsed. """ parser = CommandParser(add_help=False, allow_abbrev=False) parser.add_argument(option, dest="value") try: options, _ = parser.parse_known_args(argv[2:]) except CommandError: return None else: return options.value def normalize_path_patterns(patterns): """Normalize an iterable of glob style patterns based on OS.""" patterns = [os.path.normcase(p) for p in patterns] dir_suffixes = {"%s*" % path_sep for path_sep in {"/", os.sep}} norm_patterns = [] for pattern in patterns: for dir_suffix in dir_suffixes: if pattern.endswith(dir_suffix): norm_patterns.append(pattern[: -len(dir_suffix)]) break else: norm_patterns.append(pattern) return norm_patterns def is_ignored_path(path, ignore_patterns): """ Check if the given path should be ignored or not based on matching one of the glob style `ignore_patterns`. """ path = Path(path) def ignore(pattern): return fnmatch.fnmatchcase(path.name, pattern) or fnmatch.fnmatchcase( str(path), pattern ) return any(ignore(pattern) for pattern in normalize_path_patterns(ignore_patterns)) def find_formatters(): return {"black_path": shutil.which("black")} def run_formatters(written_files, black_path=(sentinel := object())): """ Run the black formatter on the specified files. """ # Use a sentinel rather than None, as which() returns None when not found. if black_path is sentinel: black_path = shutil.which("black") if black_path: subprocess.run( [black_path, "--fast", "--", *written_files], capture_output=True, )
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.13 |
proxy
|
phpinfo
|
Settings