from commando import management
BaseFlushCommand = management.get_command_class(
"flush", exclude_packages=("commando",))
if BaseFlushCommand is not None:
base = BaseFlushCommand()
class FlushCommandOptions(management.CommandOptions):
"""
Flush command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[flush options]",
"These options will be passed to flush.",
option_list,
),) if option_list else ()
actions = ("flush",)
def handle_flush(self, *args, **options):
return self.call_command("flush", *args, **options)
class FlushCommand(FlushCommandOptions, management.StandardCommand):
from commando import management
BaseMigrateCommand = management.get_command_class(
"migrate", exclude_packages=("commando", ))
if BaseMigrateCommand is not None:
base = BaseMigrateCommand()
class MigrateCommandOptions(management.CommandOptions):
"""
Migrate command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[migrate options]",
"These options will be passed to migrate.",
option_list,
), ) if option_list else ()
actions = ("migrate", )
def handle_migrate(self, *args, **options):
return self.call_command("migrate", *args, **options)
class MigrateCommand(MigrateCommandOptions, management.StandardCommand):
"""
Migrate command.
from commando import management
BaseRunFCGICommand = management.get_command_class(
"runfcgi", exclude_packages=("commando",))
if BaseRunFCGICommand is not None:
base = BaseRunFCGICommand()
class RunFCGICommandOptions(management.CommandOptions):
"""
RunFCGI command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[runfcgi options]",
"These options will be passed to runfcgi.",
option_list,
),) if option_list else ()
actions = ("runfcgi",)
def handle_runfcgi(self, *args, **options):
return self.call_command("runfcgi", *args, **options)
class RunFCGICommand(RunFCGICommandOptions, management.StandardCommand):
from commando import management
BaseMigrationCheckCommand = management.get_command_class(
"migrationcheck", exclude_packages=("commando",))
if BaseMigrationCheckCommand is not None:
base = BaseMigrationCheckCommand()
class MigrationCheckCommandOptions(management.CommandOptions):
"""
MigrationCheck command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[migrationcheck options]",
"These options will be passed to migrationcheck.",
option_list,
),) if option_list else ()
actions = ("migrationcheck",)
def handle_migrationcheck(self, *args, **options):
return self.call_command("migrationcheck", *args, **options)
class MigrationCheckCommand(MigrationCheckCommandOptions, management.StandardCommand):
from commando import management
BaseValidateCommand = management.get_command_class(
"validate", exclude_packages=("commando", ))
if BaseValidateCommand is not None:
base = BaseValidateCommand()
class ValidateCommandOptions(management.CommandOptions):
"""
Validate command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[validate options]",
"These options will be passed to validate.",
option_list,
), ) if option_list else ()
actions = ("validate", )
def handle_validate(self, *args, **options):
return self.call_command("validate", *args, **options)
class ValidateCommand(ValidateCommandOptions, management.StandardCommand):
"""
Validate command.
from commando import management
BaseSyncDBCommand = management.get_command_class(
"syncdb", exclude_packages=("commando", ))
if BaseSyncDBCommand is not None:
base = BaseSyncDBCommand()
class SyncDBCommandOptions(management.CommandOptions):
"""
SyncDB command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[syncdb options]",
"These options will be passed to syncdb.",
option_list,
), ) if option_list else ()
actions = ("syncdb", )
def handle_syncdb(self, *args, **options):
return self.call_command("syncdb", *args, **options)
class SyncDBCommand(SyncDBCommandOptions, management.StandardCommand):
"""
SyncDB command.
from commando import management
BaseFlushCommand = management.get_command_class(
"flush", exclude_packages=("commando", ))
if BaseFlushCommand is not None:
base = BaseFlushCommand()
class FlushCommandOptions(management.CommandOptions):
"""
Flush command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[flush options]",
"These options will be passed to flush.",
option_list,
), ) if option_list else ()
actions = ("flush", )
def handle_flush(self, *args, **options):
return self.call_command("flush", *args, **options)
class FlushCommand(FlushCommandOptions, management.StandardCommand):
"""
Flush command.
from commando import management
BaseGraphMigrationsCommand = management.get_command_class(
"graphmigrations", exclude_packages=("commando",))
if BaseGraphMigrationsCommand is not None:
base = BaseGraphMigrationsCommand()
class GraphMigrationsCommandOptions(management.CommandOptions):
"""
GraphMigrations command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[graphmigrations options]",
"These options will be passed to graphmigrations.",
option_list,
),) if option_list else ()
actions = ("graphmigrations",)
def handle_graphmigrations(self, *args, **options):
return self.call_command("graphmigrations", *args, **options)
class GraphMigrationsCommand(GraphMigrationsCommandOptions, management.StandardCommand):
from commando import management
BaseBuildSolrSchemaCommand = management.get_command_class(
"build_solr_schema", exclude_packages=("commando",))
if BaseBuildSolrSchemaCommand is not None:
base = BaseBuildSolrSchemaCommand()
class BuildSolrSchemaCommandOptions(management.CommandOptions):
"""
BuildSolrSchema command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[build_solr_schema options]",
"These options will be passed to build_solr_schema.",
option_list,
),) if option_list else ()
actions = ("build_solr_schema",)
def handle_build_solr_schema(self, *args, **options):
return self.call_command("build_solr_schema", *args, **options)
class BuildSolrSchemaCommand(BuildSolrSchemaCommandOptions, management.StandardCommand):
from commando import management
BasePublisherPublishCommand = management.get_command_class(
"publisher_publish", exclude_packages=("commando",))
if BasePublisherPublishCommand is not None:
base = BasePublisherPublishCommand()
class PublisherPublishCommandOptions(management.CommandOptions):
"""
PublisherPublish command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[publisher_publish options]",
"These options will be passed to publisher_publish.",
option_list,
),) if option_list else ()
actions = ("publisher_publish",)
def handle_publisher_publish(self, *args, **options):
return self.call_command("publisher_publish", *args, **options)
class PublisherPublishCommand(PublisherPublishCommandOptions, management.StandardCommand):
from commando import management
BaseOGRInspectCommand = management.get_command_class(
"ogrinspect", exclude_packages=("commando",))
if BaseOGRInspectCommand is not None:
base = BaseOGRInspectCommand()
class OGRInspectCommandOptions(management.CommandOptions):
"""
OGRInspect command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[ogrinspect options]",
"These options will be passed to ogrinspect.",
option_list,
),) if option_list else ()
actions = ("ogrinspect",)
def handle_ogrinspect(self, *args, **options):
return self.call_command("ogrinspect", *args, **options)
class OGRInspectCommand(OGRInspectCommandOptions, management.StandardCommand):
from commando import management
BaseStartAppCommand = management.get_command_class("startapp", exclude_packages=("commando",))
if BaseStartAppCommand is not None:
base = BaseStartAppCommand()
class StartAppCommandOptions(management.CommandOptions):
"""
StartApp command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.option_list) :]
option_groups = (
(("[startapp options]", "These options will be passed to startapp.", option_list),) if option_list else ()
)
actions = ("startapp",)
def handle_startapp(self, *args, **options):
return self.call_command("startapp", *args, **options)
class StartAppCommand(StartAppCommandOptions, management.StandardCommand):
"""
StartApp command.
"""
from commando import management
BaseSQLInitialDataCommand = management.get_command_class(
"sqlinitialdata", exclude_packages=("commando",))
if BaseSQLInitialDataCommand is not None:
base = BaseSQLInitialDataCommand()
class SQLInitialDataCommandOptions(management.CommandOptions):
"""
SQLInitialData command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[sqlinitialdata options]",
"These options will be passed to sqlinitialdata.",
option_list,
),) if option_list else ()
actions = ("sqlinitialdata",)
def handle_sqlinitialdata(self, *args, **options):
return self.call_command("sqlinitialdata", *args, **options)
class SQLInitialDataCommand(SQLInitialDataCommandOptions, management.StandardCommand):
from commando import management
BaseConvertToSouthCommand = management.get_command_class(
"convert_to_south", exclude_packages=("commando",))
if BaseConvertToSouthCommand is not None:
base = BaseConvertToSouthCommand()
class ConvertToSouthCommandOptions(management.CommandOptions):
"""
ConvertToSouth command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[convert_to_south options]",
"These options will be passed to convert_to_south.",
option_list,
),) if option_list else ()
actions = ("convert_to_south",)
def handle_convert_to_south(self, *args, **options):
return self.call_command("convert_to_south", *args, **options)
class ConvertToSouthCommand(ConvertToSouthCommandOptions, management.StandardCommand):
from commando import management
BaseSQLCustomCommand = management.get_command_class(
"sqlcustom", exclude_packages=("commando", ))
if BaseSQLCustomCommand is not None:
base = BaseSQLCustomCommand()
class SQLCustomCommandOptions(management.CommandOptions):
"""
SQLCustom command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[sqlcustom options]",
"These options will be passed to sqlcustom.",
option_list,
), ) if option_list else ()
actions = ("sqlcustom", )
def handle_sqlcustom(self, *args, **options):
return self.call_command("sqlcustom", *args, **options)
class SQLCustomCommand(SQLCustomCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseConvertToSouthCommand = management.get_command_class(
"convert_to_south", exclude_packages=("commando", ))
if BaseConvertToSouthCommand is not None:
base = BaseConvertToSouthCommand()
class ConvertToSouthCommandOptions(management.CommandOptions):
"""
ConvertToSouth command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[convert_to_south options]",
"These options will be passed to convert_to_south.",
option_list,
), ) if option_list else ()
actions = ("convert_to_south", )
def handle_convert_to_south(self, *args, **options):
return self.call_command("convert_to_south", *args, **options)
class ConvertToSouthCommand(ConvertToSouthCommandOptions,
management.StandardCommand):
"""
from commando import management
BasePingGoogleCommand = management.get_command_class("ping_google", exclude_packages=("commando",))
if BasePingGoogleCommand is not None:
base = BasePingGoogleCommand()
class PingGoogleCommandOptions(management.CommandOptions):
"""
PingGoogle command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.option_list) :]
option_groups = (
(("[ping_google options]", "These options will be passed to ping_google.", option_list),)
if option_list
else ()
)
actions = ("ping_google",)
def handle_ping_google(self, *args, **options):
return self.call_command("ping_google", *args, **options)
class PingGoogleCommand(PingGoogleCommandOptions, management.StandardCommand):
"""
PingGoogle command.
from commando import management
BaseTestCommand = management.get_command_class(
"test", exclude_packages=("commando",))
if BaseTestCommand is not None:
base = BaseTestCommand()
class TestCommandOptions(management.CommandOptions):
"""
Test command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[test options]",
"These options will be passed to test.",
option_list,
),) if option_list else ()
actions = ("test",)
def handle_test(self, *args, **options):
return self.call_command("test", *args, **options)
class TestCommand(TestCommandOptions, management.StandardCommand):
from commando import management
BaseLoadDataCommand = management.get_command_class(
"loaddata", exclude_packages=("commando",))
if BaseLoadDataCommand is not None:
base = BaseLoadDataCommand()
class LoadDataCommandOptions(management.CommandOptions):
"""
LoadData command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[loaddata options]",
"These options will be passed to loaddata.",
option_list,
),) if option_list else ()
actions = ("loaddata",)
def handle_loaddata(self, *args, **options):
return self.call_command("loaddata", *args, **options)
class LoadDataCommand(LoadDataCommandOptions, management.StandardCommand):
from commando import management
BaseCMSCommand = management.get_command_class(
"cms", exclude_packages=("commando",))
if BaseCMSCommand is not None:
base = BaseCMSCommand()
class CMSCommandOptions(management.CommandOptions):
"""
CMS command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[cms options]",
"These options will be passed to cms.",
option_list,
),) if option_list else ()
actions = ("cms",)
subcommands = base.subcommands
def handle_cms(self, *args, **options):
return self.call_command("cms", *args, **options)
from commando import management
BaseSQLSequenceResetCommand = management.get_command_class(
"sqlsequencereset", exclude_packages=("commando",))
if BaseSQLSequenceResetCommand is not None:
base = BaseSQLSequenceResetCommand()
class SQLSequenceResetCommandOptions(management.CommandOptions):
"""
SQLSequenceReset command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[sqlsequencereset options]",
"These options will be passed to sqlsequencereset.",
option_list,
),) if option_list else ()
actions = ("sqlsequencereset",)
def handle_sqlsequencereset(self, *args, **options):
return self.call_command("sqlsequencereset", *args, **options)
class SQLSequenceResetCommand(SQLSequenceResetCommandOptions, management.StandardCommand):
from commando import management
BaseUpdateIndexCommand = management.get_command_class(
"update_index", exclude_packages=("commando",))
if BaseUpdateIndexCommand is not None:
base = BaseUpdateIndexCommand()
class UpdateIndexCommandOptions(management.CommandOptions):
"""
UpdateIndex command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[update_index options]",
"These options will be passed to update_index.",
option_list,
),) if option_list else ()
actions = ("update_index",)
def handle_update_index(self, *args, **options):
return self.call_command("update_index", *args, **options)
class UpdateIndexCommand(UpdateIndexCommandOptions, management.StandardCommand):
from commando import management
BaseClearSessionsCommand = management.get_command_class(
"clearsessions", exclude_packages=("commando",))
if BaseClearSessionsCommand is not None:
base = BaseClearSessionsCommand()
class ClearSessionsCommandOptions(management.CommandOptions):
"""
ClearSessions command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[clearsessions options]",
"These options will be passed to clearsessions.",
option_list,
),) if option_list else ()
actions = ("clearsessions",)
def handle_clearsessions(self, *args, **options):
return self.call_command("clearsessions", *args, **options)
class ClearSessionsCommand(ClearSessionsCommandOptions, management.StandardCommand):
from commando import management
BaseTestCommand = management.get_command_class("test",
exclude_packages=("commando", ))
if BaseTestCommand is not None:
base = BaseTestCommand()
class TestCommandOptions(management.CommandOptions):
"""
Test command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[test options]",
"These options will be passed to test.",
option_list,
), ) if option_list else ()
actions = ("test", )
def handle_test(self, *args, **options):
return self.call_command("test", *args, **options)
class TestCommand(TestCommandOptions, management.StandardCommand):
"""
Test command.
from commando import management
BaseGraphMigrationsCommand = management.get_command_class(
"graphmigrations", exclude_packages=("commando", ))
if BaseGraphMigrationsCommand is not None:
base = BaseGraphMigrationsCommand()
class GraphMigrationsCommandOptions(management.CommandOptions):
"""
GraphMigrations command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[graphmigrations options]",
"These options will be passed to graphmigrations.",
option_list,
), ) if option_list else ()
actions = ("graphmigrations", )
def handle_graphmigrations(self, *args, **options):
return self.call_command("graphmigrations", *args, **options)
class GraphMigrationsCommand(GraphMigrationsCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseFindStaticCommand = management.get_command_class(
"findstatic", exclude_packages=("commando", ))
if BaseFindStaticCommand is not None:
base = BaseFindStaticCommand()
class FindStaticCommandOptions(management.CommandOptions):
"""
FindStatic command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[findstatic options]",
"These options will be passed to findstatic.",
option_list,
), ) if option_list else ()
actions = ("findstatic", )
def handle_findstatic(self, *args, **options):
return self.call_command("findstatic", *args, **options)
class FindStaticCommand(FindStaticCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseHaystackInfoCommand = management.get_command_class(
"haystack_info", exclude_packages=("commando",))
if BaseHaystackInfoCommand is not None:
base = BaseHaystackInfoCommand()
class HaystackInfoCommandOptions(management.CommandOptions):
"""
HaystackInfo command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[haystack_info options]",
"These options will be passed to haystack_info.",
option_list,
),) if option_list else ()
actions = ("haystack_info",)
def handle_haystack_info(self, *args, **options):
return self.call_command("haystack_info", *args, **options)
class HaystackInfoCommand(HaystackInfoCommandOptions, management.StandardCommand):
from commando import management
BaseCreateCacheTableCommand = management.get_command_class(
"createcachetable", exclude_packages=("commando",))
if BaseCreateCacheTableCommand is not None:
base = BaseCreateCacheTableCommand()
class CreateCacheTableCommandOptions(management.CommandOptions):
"""
Create cache table command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[createcachetable options]",
"These options will be passed to createcachetable.",
option_list,
),) if option_list else ()
actions = ("createcachetable",)
def handle_createcachetable(self, *args, **options):
return self.call_command("createcachetable", *args, **options)
class CreateCacheTableCommand(CreateCacheTableCommandOptions, management.StandardCommand):
from commando import management
BaseSQLCommand = management.get_command_class(
"sql", exclude_packages=("commando",))
if BaseSQLCommand is not None:
base = BaseSQLCommand()
class SQLCommandOptions(management.CommandOptions):
"""
SQL command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[sql options]",
"These options will be passed to sql.",
option_list,
),) if option_list else ()
actions = ("sql",)
def handle_sql(self, *args, **options):
return self.call_command("sql", *args, **options)
class SQLCommand(SQLCommandOptions, management.StandardCommand):
from commando import management
BaseStartProjectCommand = management.get_command_class(
"startproject", exclude_packages=("commando", ))
if BaseStartProjectCommand is not None:
base = BaseStartProjectCommand()
class StartProjectCommandOptions(management.CommandOptions):
"""
StartProject command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[startproject options]",
"These options will be passed to startproject.",
option_list,
), ) if option_list else ()
actions = ("startproject", )
def handle_startproject(self, *args, **options):
return self.call_command("startproject", *args, **options)
class StartProjectCommand(StartProjectCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseSQLSequenceResetCommand = management.get_command_class(
"sqlsequencereset", exclude_packages=("commando", ))
if BaseSQLSequenceResetCommand is not None:
base = BaseSQLSequenceResetCommand()
class SQLSequenceResetCommandOptions(management.CommandOptions):
"""
SQLSequenceReset command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[sqlsequencereset options]",
"These options will be passed to sqlsequencereset.",
option_list,
), ) if option_list else ()
actions = ("sqlsequencereset", )
def handle_sqlsequencereset(self, *args, **options):
return self.call_command("sqlsequencereset", *args, **options)
class SQLSequenceResetCommand(SQLSequenceResetCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseUpdateIndexCommand = management.get_command_class(
"update_index", exclude_packages=("commando", ))
if BaseUpdateIndexCommand is not None:
base = BaseUpdateIndexCommand()
class UpdateIndexCommandOptions(management.CommandOptions):
"""
UpdateIndex command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[update_index options]",
"These options will be passed to update_index.",
option_list,
), ) if option_list else ()
actions = ("update_index", )
def handle_update_index(self, *args, **options):
return self.call_command("update_index", *args, **options)
class UpdateIndexCommand(UpdateIndexCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseSQLInitialDataCommand = management.get_command_class(
"sqlinitialdata", exclude_packages=("commando", ))
if BaseSQLInitialDataCommand is not None:
base = BaseSQLInitialDataCommand()
class SQLInitialDataCommandOptions(management.CommandOptions):
"""
SQLInitialData command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[sqlinitialdata options]",
"These options will be passed to sqlinitialdata.",
option_list,
), ) if option_list else ()
actions = ("sqlinitialdata", )
def handle_sqlinitialdata(self, *args, **options):
return self.call_command("sqlinitialdata", *args, **options)
class SQLInitialDataCommand(SQLInitialDataCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseDBShellCommand = management.get_command_class(
"dbshell", exclude_packages=("commando", ))
if BaseDBShellCommand is not None:
base = BaseDBShellCommand()
class DBShellCommandOptions(management.CommandOptions):
"""
Database shell command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[dbshell options]",
"These options will be passed to dbshell.",
option_list,
), ) if option_list else ()
actions = ("dbshell", )
def handle_dbshell(self, *args, **options):
return self.call_command("dbshell", *args, **options)
class DBShellCommand(DBShellCommandOptions, management.StandardCommand):
"""
Database shell command.
from commando import management
BaseSyncDBCommand = management.get_command_class(
"syncdb", exclude_packages=("commando",))
if BaseSyncDBCommand is not None:
base = BaseSyncDBCommand()
class SyncDBCommandOptions(management.CommandOptions):
"""
SyncDB command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[syncdb options]",
"These options will be passed to syncdb.",
option_list,
),) if option_list else ()
actions = ("syncdb",)
def handle_syncdb(self, *args, **options):
return self.call_command("syncdb", *args, **options)
class SyncDBCommand(SyncDBCommandOptions, management.StandardCommand):
from commando import management
BaseOGRInspectCommand = management.get_command_class("ogrinspect", exclude_packages=("commando",))
if BaseOGRInspectCommand is not None:
base = BaseOGRInspectCommand()
class OGRInspectCommandOptions(management.CommandOptions):
"""
OGRInspect command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.option_list) :]
option_groups = (
(("[ogrinspect options]", "These options will be passed to ogrinspect.", option_list),)
if option_list
else ()
)
actions = ("ogrinspect",)
def handle_ogrinspect(self, *args, **options):
return self.call_command("ogrinspect", *args, **options)
class OGRInspectCommand(OGRInspectCommandOptions, management.StandardCommand):
"""
OGRInspect command.
from commando import management
BaseCreateCacheTableCommand = management.get_command_class(
"createcachetable", exclude_packages=("commando", ))
if BaseCreateCacheTableCommand is not None:
base = BaseCreateCacheTableCommand()
class CreateCacheTableCommandOptions(management.CommandOptions):
"""
Create cache table command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[createcachetable options]",
"These options will be passed to createcachetable.",
option_list,
), ) if option_list else ()
actions = ("createcachetable", )
def handle_createcachetable(self, *args, **options):
return self.call_command("createcachetable", *args, **options)
class CreateCacheTableCommand(CreateCacheTableCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseStartAppCommand = management.get_command_class(
"startapp", exclude_packages=("commando", ))
if BaseStartAppCommand is not None:
base = BaseStartAppCommand()
class StartAppCommandOptions(management.CommandOptions):
"""
StartApp command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[startapp options]",
"These options will be passed to startapp.",
option_list,
), ) if option_list else ()
actions = ("startapp", )
def handle_startapp(self, *args, **options):
return self.call_command("startapp", *args, **options)
class StartAppCommand(StartAppCommandOptions, management.StandardCommand):
"""
StartApp command.
from commando import management
BaseDiffSettingsCommand = management.get_command_class(
"diffsettings", exclude_packages=("commando", ))
if BaseDiffSettingsCommand is not None:
base = BaseDiffSettingsCommand()
class DiffSettingsCommandOptions(management.CommandOptions):
"""
Diff settings command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[diffsettings options]",
"These options will be passed to diffsettings.",
option_list,
), ) if option_list else ()
actions = ("diffsettings", )
def handle_diffsettings(self, *args, **options):
return self.call_command("diffsettings", *args, **options)
class DiffSettingsCommand(DiffSettingsCommandOptions,
management.StandardCommand):
"""
from commando import management
BasePingGoogleCommand = management.get_command_class(
"ping_google", exclude_packages=("commando", ))
if BasePingGoogleCommand is not None:
base = BasePingGoogleCommand()
class PingGoogleCommandOptions(management.CommandOptions):
"""
PingGoogle command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[ping_google options]",
"These options will be passed to ping_google.",
option_list,
), ) if option_list else ()
actions = ("ping_google", )
def handle_ping_google(self, *args, **options):
return self.call_command("ping_google", *args, **options)
class PingGoogleCommand(PingGoogleCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseCreateSuperuserCommand = management.get_command_class(
"createsuperuser", exclude_packages=("commando",))
if BaseCreateSuperuserCommand is not None:
base = BaseCreateSuperuserCommand()
class CreateSuperuserCommandOptions(management.CommandOptions):
"""
CreateSuperuser command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[createsuperuser options]",
"These options will be passed to createsuperuser.",
option_list,
),) if option_list else ()
actions = ("createsuperuser",)
def handle_createsuperuser(self, *args, **options):
return self.call_command("createsuperuser", *args, **options)
class CreateSuperuserCommand(CreateSuperuserCommandOptions, management.StandardCommand):
from commando import management
BaseHaystackInfoCommand = management.get_command_class(
"haystack_info", exclude_packages=("commando", ))
if BaseHaystackInfoCommand is not None:
base = BaseHaystackInfoCommand()
class HaystackInfoCommandOptions(management.CommandOptions):
"""
HaystackInfo command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[haystack_info options]",
"These options will be passed to haystack_info.",
option_list,
), ) if option_list else ()
actions = ("haystack_info", )
def handle_haystack_info(self, *args, **options):
return self.call_command("haystack_info", *args, **options)
class HaystackInfoCommand(HaystackInfoCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseDumpDataCommand = management.get_command_class(
"dumpdata", exclude_packages=("commando", ))
if BaseDumpDataCommand is not None:
base = BaseDumpDataCommand()
class DumpDataCommandOptions(management.CommandOptions):
"""
Dump data command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[dumpdata options]",
"These options will be passed to dumpdata.",
option_list,
), ) if option_list else ()
actions = ("dumpdata", )
def handle_dumpdata(self, *args, **options):
return self.call_command("dumpdata", *args, **options)
class DumpDataCommand(DumpDataCommandOptions, management.StandardCommand):
"""
Dump data command.
from commando import management
BaseSchemaMigrationCommand = management.get_command_class(
"schemamigration", exclude_packages=("commando",))
if BaseSchemaMigrationCommand is not None:
base = BaseSchemaMigrationCommand()
class SchemaMigrationCommandOptions(management.CommandOptions):
"""
SchemaMigration command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[schemamigration options]",
"These options will be passed to schemamigration.",
option_list,
),) if option_list else ()
actions = ("schemamigration",)
def handle_schemamigration(self, *args, **options):
return self.call_command("schemamigration", *args, **options)
class SchemaMigrationCommand(SchemaMigrationCommandOptions, management.StandardCommand):
from commando import management
BaseValidateCommand = management.get_command_class(
"validate", exclude_packages=("commando",))
if BaseValidateCommand is not None:
base = BaseValidateCommand()
class ValidateCommandOptions(management.CommandOptions):
"""
Validate command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[validate options]",
"These options will be passed to validate.",
option_list,
),) if option_list else ()
actions = ("validate",)
def handle_validate(self, *args, **options):
return self.call_command("validate", *args, **options)
class ValidateCommand(ValidateCommandOptions, management.StandardCommand):
from commando import management
BaseCollectStaticCommand = management.get_command_class(
"collectstatic", exclude_packages=("commando",))
if BaseCollectStaticCommand is not None:
base = BaseCollectStaticCommand()
class CollectStaticCommandOptions(management.CommandOptions):
"""
CollectStatic command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[collectstatic options]",
"These options will be passed to collectstatic.",
option_list,
),) if option_list else ()
actions = ("collectstatic",)
def handle_collectstatic(self, *args, **options):
return self.call_command("collectstatic", *args, **options)
class CollectStaticCommand(CollectStaticCommandOptions, management.StandardCommand):
from commando import management
BaseCleanupCommand = management.get_command_class(
"cleanup", exclude_packages=("commando",))
if BaseCleanupCommand is not None:
base = BaseCleanupCommand()
class CleanupCommandOptions(management.CommandOptions):
"""
Cleanup command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[cleanup options]",
"These options will be passed to cleanup.",
option_list,
),) if option_list else ()
actions = ("cleanup",)
def handle_cleanup(self, *args, **options):
return self.call_command("cleanup", *args, **options)
class CleanupCommand(CleanupCommandOptions, management.StandardCommand):
from commando import management
BaseStartMigrationCommand = management.get_command_class(
"startmigration", exclude_packages=("commando", ))
if BaseStartMigrationCommand is not None:
base = BaseStartMigrationCommand()
class StartMigrationCommandOptions(management.CommandOptions):
"""
StartMigration command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[startmigration options]",
"These options will be passed to startmigration.",
option_list,
), ) if option_list else ()
actions = ("startmigration", )
def handle_startmigration(self, *args, **options):
return self.call_command("startmigration", *args, **options)
class StartMigrationCommand(StartMigrationCommandOptions,
management.StandardCommand):
"""
from commando import management
BaseDiffSettingsCommand = management.get_command_class("diffsettings", exclude_packages=("commando",))
if BaseDiffSettingsCommand is not None:
base = BaseDiffSettingsCommand()
class DiffSettingsCommandOptions(management.CommandOptions):
"""
Diff settings command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.option_list) :]
option_groups = (
(("[diffsettings options]", "These options will be passed to diffsettings.", option_list),)
if option_list
else ()
)
actions = ("diffsettings",)
def handle_diffsettings(self, *args, **options):
return self.call_command("diffsettings", *args, **options)
class DiffSettingsCommand(DiffSettingsCommandOptions, management.StandardCommand):
"""
Diff settings command.
from commando import management
BaseSQLClearCommand = management.get_command_class(
"sqlclear", exclude_packages=("commando", ))
if BaseSQLClearCommand is not None:
base = BaseSQLClearCommand()
class SQLClearCommandOptions(management.CommandOptions):
"""
SQLClear command options.
"""
args = base.args
help = base.help
option_list = base.option_list[len(management.BaseCommandOptions.
option_list):]
option_groups = ((
"[sqlclear options]",
"These options will be passed to sqlclear.",
option_list,
), ) if option_list else ()
actions = ("sqlclear", )
def handle_sqlclear(self, *args, **options):
return self.call_command("sqlclear", *args, **options)
class SQLClearCommand(SQLClearCommandOptions, management.StandardCommand):
"""
SQLClear command.
from commando import management
BaseChangePasswordCommand = management.get_command_class(
"changepassword", exclude_packages=("commando",))
if BaseChangePasswordCommand is not None:
base = BaseChangePasswordCommand()
class ChangePasswordCommandOptions(management.CommandOptions):
"""
ChangePassword command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[changepassword options]",
"These options will be passed to changepassword.",
option_list,
),) if option_list else ()
actions = ("changepassword",)
def handle_changepassword(self, *args, **options):
return self.call_command("changepassword", *args, **options)
class ChangePasswordCommand(ChangePasswordCommandOptions, management.StandardCommand):
from commando import management
BaseShellCommand = management.get_command_class(
"shell", exclude_packages=("commando",))
if BaseShellCommand is not None:
base = BaseShellCommand()
class ShellCommandOptions(management.CommandOptions):
"""
Shell command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[shell options]",
"These options will be passed to shell.",
option_list,
),) if option_list else ()
actions = ("shell",)
def handle_shell(self, *args, **options):
return self.call_command("shell", *args, **options)
class ShellCommand(ShellCommandOptions, management.StandardCommand):
from commando import management
BaseCompileMessagesCommand = management.get_command_class(
"compilemessages", exclude_packages=("commando",))
if BaseCompileMessagesCommand is not None:
base = BaseCompileMessagesCommand()
class CompileMessagesCommandOptions(management.CommandOptions):
"""
Cleanup command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[compilemesssages options]",
"These options will be passed to compilemessages.",
option_list,
),) if option_list else ()
actions = ("compilemessages",)
def handle_compilemessages(self, *args, **options):
return self.call_command("compilemessages", *args, **options)
class CompileMessagesCommand(CompileMessagesCommandOptions, management.StandardCommand):
from commando import management
BaseMigrateCommand = management.get_command_class(
"migrate", exclude_packages=("commando",))
if BaseMigrateCommand is not None:
base = BaseMigrateCommand()
class MigrateCommandOptions(management.CommandOptions):
"""
Migrate command options.
"""
args = base.args
help = base.help
option_list = base.option_list[
len(management.BaseCommandOptions.option_list):]
option_groups = (
("[migrate options]",
"These options will be passed to migrate.",
option_list,
),) if option_list else ()
actions = ("migrate",)
def handle_migrate(self, *args, **options):
return self.call_command("migrate", *args, **options)
class MigrateCommand(MigrateCommandOptions, management.StandardCommand):
