def handle_noargs(self, **options): utilityOne = ManagementUtility(['./manage.py', 'syncdb']) utilityOne.execute() utilityTwo = ManagementUtility(['./manage.py', 'loaddata', 'sample_data']) utilityTwo.execute() return 'Sample data loaded.'
def create_project(project_name): """Create the project using the Django startproject command""" print("Creating a Wagtail project called {project_name}".format( project_name=project_name)) import wagtailstartproject wagtailstartproject_path = os.path.dirname(wagtailstartproject.__file__) template_path = os.path.join(wagtailstartproject_path, 'project_template') # Call django-admin startproject utility_args = [ 'django-admin.py', 'startproject', '--template=' + template_path, '--extension=py,ini,html,rst,json,cfg', project_name ] # always put the project template inside the current directory: utility_args.append('.') utility = ManagementUtility(utility_args) utility.execute() print("Success! {project_name} has been created".format( project_name=project_name))
def manage(command, args=[], as_thread=False): """ Run a django command on the kalite project :param command: The django command string identifier, e.g. 'runserver' :param args: List of options to parse to the django management command :param as_thread: Runs command in thread and returns immediately """ args = update_default_args(["--traceback"], args) if not as_thread: if PROFILE: profile_memory() utility = ManagementUtility([os.path.basename(sys.argv[0]), command] + args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute() else: get_commands() # Needed to populate the available commands before issuing one in a thread thread = ManageThread(command, args=args, name=" ".join([command] + args)) thread.start() return thread
def run(self, project_name=None, dest_dir=None): # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: sys.exit("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) print("Creating a Tendenci project called %(project_name)s" % {'project_name': project_name}) # noqa # First find the path to Tendenci template_path = "https://github.com/tendenci/tendenci-project-template/archive/master.zip" # Call django-admin startproject utility_args = [ 'django-admin.py', 'startproject', '--template=' + template_path, project_name ] #if dest_dir: #utility_args.append(dest_dir) utility = ManagementUtility(utility_args) utility.execute() print("Success! %(project_name)s has been created" % {'project_name': project_name}) # noqa
def manage(command, args=None, as_thread=False): """ Run a django command on the kalite project :param command: The django command string identifier, e.g. 'runserver' :param args: List of options to parse to the django management command :param as_thread: Runs command in thread and returns immediately """ if not args: args = [] args = update_default_args(["--traceback"], args) if not as_thread: utility = ManagementUtility([os.path.basename(sys.argv[0]), command] + args) # This ensures that 'kalite' is printed in help menus instead of # 'kalite' or 'kalite.__main__' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute() else: get_commands() # Needed to populate the available commands before issuing one in a thread thread = ManageThread(command, args=args, name=" ".join([command] + args)) thread.start() return thread
def run(self, project_name=None, dest_dir=None): # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: sys.exit("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) print("Creating a Wagtail project called %(project_name)s" % {'project_name': project_name}) # noqa # Create the project from the Wagtail template using startapp # First find the path to Wagtail import wagtail wagtail_path = os.path.dirname(wagtail.__file__) template_path = os.path.join(wagtail_path, 'project_template') # Call django-admin startproject utility_args = ['django-admin.py', 'startproject', '--template=' + template_path, '--ext=html,rst', '--name=Dockerfile', project_name] if dest_dir: utility_args.append(dest_dir) utility = ManagementUtility(utility_args) utility.execute() print("Success! %(project_name)s has been created" % {'project_name': project_name}) # noqa
def manage(command, args=[], in_background=False): """ Run a django command on the kalite project :param command: The django command string identifier, e.g. 'runserver' :param args: List of options to parse to the django management command :param in_background: Creates a sub-process for the command """ # Ensure that django.core.management's global _command variable is set # before call commands, especially the once that run in the background get_commands() # Import here so other commands can run faster if not in_background: utility = ManagementUtility([os.path.basename(sys.argv[0]), command] + args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute() else: if os.name != "nt": thread = ManageThread(command, args=args, name=" ".join([command]+args)) thread.start() else: # TODO (aron): for versions > 0.13, see if we can just have everyone spawn another process (Popen vs. ManageThread) Popen([sys.executable, os.path.abspath(sys.argv[0]), "manage", command] + args, creationflags=CREATE_NEW_PROCESS_GROUP)
def start (args): # if a specific conf has been provided (which it # will be), if we're inside the django reloaded if "RAPIDSMS_INI" in os.environ: ini = os.environ["RAPIDSMS_INI"] # use a local ini (for development) # if one exists, to avoid everyone # having their own rapidsms.ini elif os.path.isfile("local.ini"): ini = "local.ini" # otherwise, fall back else: ini = "rapidsms.ini" # add the ini path to the environment, so we can # access it globally, including any subprocesses # spawned by django os.environ["RAPIDSMS_INI"] = ini os.environ["DJANGO_SETTINGS_MODULE"] = "rapidsms.webui.settings" # read the config, which is shared # between the back and frontend conf = Config(ini) # if we found a config ini, try to configure Django if conf.sources: # This builds the django config from rapidsms.config, in a # round-about way. # Can't do it until env[RAPIDSMS_INI] is defined from rapidsms.webui import settings import_local_settings(settings, ini) # whatever we're doing, we'll need to call # django's setup_environ, to configure the ORM from django.core.management import setup_environ, execute_manager setup_environ(settings) else: settings = None # if one or more arguments were passed, we're # starting up django -- copied from manage.py if len(args) < 2: print "Commands: route, startproject <name>, startapp <name>" sys.exit(1) if hasattr(Manager, args[1]): handler = getattr(Manager(), args[1]) handler(conf, *args[2:]) elif settings: # none of the commands were recognized, # so hand off to Django from django.core.management import ManagementUtility # The following is equivalent to django's "execute_manager(settings)" # only without overriding RapidSMS webui settings utility = ManagementUtility() utility.execute()
def run(self, project_name=None, dest_dir=None): # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: sys.exit("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) print("Creating a CodeRed CMS project called %(project_name)s" % {'project_name': project_name}) # noqa # Create the project from the Wagtail template using startapp # First find the path to Wagtail import coderedcms codered_path = os.path.dirname(coderedcms.__file__) template_path = os.path.join(codered_path, 'project_template') # Call django-admin startproject utility_args = [ 'django-admin.py', 'startproject', '--template=' + template_path, '--ext=html,rst', '--name=Dockerfile', project_name ] if dest_dir: utility_args.append(dest_dir) utility = ManagementUtility(utility_args) utility.execute() print("Success! %(project_name)s has been created" % {'project_name': project_name}) # noqa
def create_project(args): """ Create a new django project using the longclaw template """ # Make sure given name is not already in use by another python package/module. try: __import__(args.project_name) except ImportError: pass else: sys.exit("'{}' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name.".format(args.project_name)) # Get the longclaw template path template_path = path.join(path.dirname(longclaw.__file__), 'project_template') utility = ManagementUtility( ('django-admin.py', 'startproject', '--template={}'.format(template_path), '--ext=html,css,js,py,txt', args.project_name)) utility.execute() print("{} has been created.".format(args.project_name))
def run(self): utility = ManagementUtility( [os.path.basename(sys.argv[0]), self.command] + self.args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute()
def handle(self,*args,**options): #Delete old DB print 'Deleting old sqlite db....' try: if settings.ON_OPENSHIFT: os.remove(os.path.join(os.environ['OPENSHIFT_DATA_DIR'],'mwach.db')) else: os.remove(os.path.join(settings.PROJECT_PATH,'mwach.db')) except OSError: pass if not os.path.isfile(JSON_DATA_FILE): sys.exit('JSON file %s Does Not Exist'%(JSON_DATA_FILE,)) #Migrate new models print 'Migrating new db....' utility = ManagementUtility(['reset_db.py','migrate']) utility.execute() #Turn off Autocommit #transaction.set_autocommit(False) config.CURRENT_DATE = datetime.date.today() with transaction.atomic(): create_backend() if options['participants'] > 0: load_old_participants(options) if options['jennifer']: add_jennifers()
def manage(command, args=[], in_background=False): """ Run a django command on the kalite project :param command: The django command string identifier, e.g. 'runserver' :param args: List of options to parse to the django management command :param in_background: Creates a sub-process for the command """ # Ensure that django.core.management's global _command variable is set # before call commands, especially the once that run in the background get_commands() # Import here so other commands can run faster if not in_background: utility = ManagementUtility([os.path.basename(sys.argv[0]), command] + args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute() else: if os.name != "nt": thread = ManageThread(command, args=args, name=" ".join([command] + args)) thread.start() else: # TODO (aron): for versions > 0.13, see if we can just have everyone spawn another process (Popen vs. ManageThread) Popen([ sys.executable, os.path.abspath(sys.argv[0]), "manage", command ] + args, creationflags=CREATE_NEW_PROCESS_GROUP)
def cmd_e2e( self, cmd: typing.Sequence[str], stdin: typing.Optional[typing.Union[io.StringIO, bytes]] = None, stdout: typing.Optional[io.StringIO] = None, stderr: typing.Optional[io.StringIO] = None, ) -> typing.Tuple[str, str]: """Call a management command the way manage.py does. Unlike call_command, this method also tests the argparse configuration of the called command. """ stdout = stdout or io.StringIO() stderr = stderr or io.StringIO() if stdin is None: stdin = io.StringIO() if isinstance(stdin, io.StringIO): stdin_mock = mock.patch("sys.stdin", stdin) else: def _read_mock(size=None): # type: ignore # pylint: disable=unused-argument return stdin # TYPE NOTE: mypy detects a different type, but important thing is its a context manager stdin_mock = mock.patch( # type: ignore[assignment] "sys.stdin.buffer.read", side_effect=_read_mock ) with stdin_mock, mock.patch("sys.stdout", stdout), mock.patch("sys.stderr", stderr): util = ManagementUtility(["manage.py"] + list(cmd)) util.execute() return stdout.getvalue(), stderr.getvalue()
def run_command(self, command, *args, **kwargs): """ Runs a Django command. """ self.init_project() argv = ['nina cmd', command, *map(str, args), *to_argv(**kwargs)] utility = ManagementUtility(argv) utility.execute()
def _run(coor, argv): global urlpatterns urlpatterns = patterns('', url('.*', coor or DjangoCoor()) ) os.environ['DJANGO_SETTINGS_MODULE'] = __name__ utility = ManagementUtility(sys.argv[:1] + argv) utility.execute()
def update_migrations(): """ Creates schemamigrations for localshop. """ from django.core.management import ManagementUtility args = 'manage.py schemamigration localshop --auto'.split(' ') utility = ManagementUtility(args) utility.execute()
def update_migrations(): """ Creates schemamigrations for sentry. """ from django.core.management import ManagementUtility args = 'manage.py schemamigration sentry --auto'.split(' ') utility = ManagementUtility(args) utility.execute()
def execute_from_command_line(argv=None): """ A simple method that runs a ManagementUtility. """ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "colab.settings") utility = ManagementUtility(argv) utility.execute()
def create_project(parser, options, args): # Validate args if len(args) < 2: parser.error('Please specify a name for your Arctic installation') elif len(args) > 3: parser.error('Too many arguments') project_name = args[1] try: dest_dir = args[2] except IndexError: dest_dir = '' # Make sure given name is not already in use by another # python package/module. try: __import__(project_name) except ImportError: pass else: parser.error('"{}" conflicts with the name of an existing ' 'Python module and cannot be used as a project ' 'name. Please try another name.'.format(project_name)) print('Creating an Arctic project named {}'.format(project_name)) # Create the project from the Arctic template using startapp # First find the path to Arctic import arctic arctic_path = os.path.dirname(arctic.__file__) template_path = os.path.join(arctic_path, 'project_template') # Call django-admin startproject utility_args = [ 'django-admin.py', 'startproject', '--template=' + template_path, '--ext=html,rst', project_name ] if dest_dir: utility_args.append(dest_dir) utility = ManagementUtility(utility_args) utility.execute() # add execute permission to manage.py, somehow it gets lost on the way manage_py = os.path.join(dest_dir or project_name, 'manage.py') st = os.stat(manage_py) os.chmod(manage_py, st.st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH) print('Congratulations! {0} has been created.\n' 'The next steps are:\n' '- In config/settings.py change the database settings (if needed).\n' '- Run database migrations: {0}/manage.py migrate.\n' '- Create an admin user: {0}/manage.py createsuperuser.\n' '- Finally run the project: {0}/manage.py runserver.\n'.format( project_name))
def run_management_command(self, *args): from django.core.management import ManagementUtility args = ['manage.py'] + list(args) utility = ManagementUtility(args) try: utility.execute() except SystemExit: pass print('')
def run_management_command(self, *args): from django.core.management import ManagementUtility args = ['manage.py'] + list(args) utility = ManagementUtility(args) try: utility.execute() except SystemExit: pass print('')
def test_update_settings(self): self.assertTrue(settings.DEBUG) args = ['manage.py', 'settings', '--django_debug=False', 'DEBUG'] utility = ManagementUtility(argv=args) self.begin_capture() try: utility.execute() finally: self.end_capture() self.assertTrue('False' in self.capture['stdout'])
def test_version_is_printed_once(self): args = ['manage.py', '--version'] utility = ManagementUtility(argv=args) self.begin_capture() try: utility.execute() finally: self.end_capture() expected = get_version() self.assertTrue(self.capture['stdout'].count(expected) == 1)
def test_update_settings(self): self.assertTrue(settings.DEBUG) args = ['manage.py', 'settings', '--django_debug=False', 'DEBUG'] utility = ManagementUtility(argv=args) self.begin_capture() try: utility.execute() finally: self.end_capture() self.assertTrue('False' in self.capture['stdout'])
def test_version_is_printed_once(self): args = ['manage.py', '--version'] utility = ManagementUtility(argv=args) self.begin_capture() try: utility.execute() finally: self.end_capture() expected = get_version() self.assertTrue(self.capture['stdout'].count(expected) == 1)
def cmd_help_text(self, cmd: str) -> str: """Get the help message for a given management command. Also asserts that stderr is empty and the command exists with status code 0.""" stdout = io.StringIO() stderr = io.StringIO() with mock.patch("sys.stdout", stdout), mock.patch("sys.stderr", stderr): util = ManagementUtility(["manage.py", cmd, "--help"]) with self.assertSystemExit(0): util.execute() self.assertEqual(stderr.getvalue(), "") return stdout.getvalue()
def execute_from_command_line(argv=None): """ A simple method that runs a ManagementUtility. """ os.environ.setdefault("DJANGO_SETTINGS_MODULE", "colab.settings") from django.conf import settings if not hasattr(settings, 'SECRET_KEY') and 'initconfig' in sys.argv: command = initconfig.Command() command.handle() else: utility = ManagementUtility(argv) utility.execute()
def execute_manager(settings_mod, argv=None): """ Like execute_from_command_line(), but for use by manage.py, a project-specific django-admin.py utility. """ # don't add the project directory to the environment, as this ends # up importing classes using the project name, and self.assertIsInstance # requires us to specify the project name, making our tests non-portable. # setup_environ(settings_mod) import binder.monkeypatch utility = ManagementUtility(argv) utility.execute()
def cmd_e2e(self, cmd, stdin=None, stdout=None, stderr=None): """Call a management command the way manage.py does. Unlike call_command, this method also tests the argparse configuration of the called command. """ stdout = stdout or StringIO() stderr = stderr or StringIO() if stdin is None: stdin = StringIO() with patch('sys.stdin', stdin), patch('sys.stdout', stdout), patch('sys.stderr', stderr): util = ManagementUtility(['manage.py', ] + list(cmd)) util.execute() return stdout.getvalue(), stderr.getvalue()
def start(self, args): project_name = args.project_name print('Gabo is starting {0}...'.format(project_name)) PROJECT_PACKAGE = Path(__file__).resolve().parent.parent macondo_project_path = os.path.join(PROJECT_PACKAGE, 'macondo_project') django_args = [ 'django-admin.py', 'startproject', '--template={0}'.format(macondo_project_path), project_name ] django_management = ManagementUtility(django_args) django_management.execute()
def create_project(parser, options, args): # Validate args if len(args) < 2: parser.error("Please specify a name for your Wagtail installation") elif len(args) > 3: print(args) parser.error("Too many arguments") project_name = args[1] try: dest_dir = args[2] except IndexError: dest_dir = None # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: parser.error("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) print("Creating a Wagtail project called %(project_name)s" % {'project_name': project_name}) # noqa # Create the project from the Wagtail template using startapp # First find the path to Wagtail import wagtail wagtail_path = os.path.dirname(wagtail.__file__) template_path = os.path.join(wagtail_path, 'project_template') # Call django-admin startproject utility_args = ['django-admin.py', 'startproject', '--template=' + template_path, '--ext=html,rst', project_name] if dest_dir: utility_args.append(dest_dir) utility = ManagementUtility(utility_args) utility.execute() print("Success! %(project_name)s has been created" % {'project_name': project_name}) # noqa
def schemamigration(): # turn ``schemamigration.py --initial`` into # ``manage.py schemamigration cmsplugin_disqus --initial`` and setup the # enviroment from django.conf import settings from django.core.management import ManagementUtility settings.configure(INSTALLED_APPS=INSTALLED_APPS, ROOT_URLCONF=ROOT_URLCONF, DATABASES=DATABASES, TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS) argv = list(sys.argv) argv.insert(1, 'schemamigration') argv.insert(2, 'djangocms_style') utility = ManagementUtility(argv) utility.execute()
def handle(self, *args, **kwargs): """ Handle command execution :param args: :param kwargs: :return: None """ args = [sys.argv[0], 'makemigrations'] for app in settings.INSTALLED_APPS: app_dir = os.path.join(settings.BASE_DIR, app) if os.path.isdir(app_dir): args.append(app) utility = ManagementUtility(args) utility.execute()
def create_project(parser, options, args): # Validate args if len(args) < 2: parser.error("Please specify a name for your wagtail installation") elif len(args) > 3: parser.error("Too many arguments") project_name = args[1] try: dest_dir = args[2] except IndexError: dest_dir = None # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: parser.error("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) print("Creating a wagtail project called %(project_name)s" % {'project_name': project_name}) # Create the project from the wagtail template using startapp # First find the path to wagtail import wagtail wagtail_path = os.path.dirname(wagtail.__file__) template_path = os.path.join(wagtail_path, 'project_template') # Call django-admin startproject utility_args = ['django-admin.py', 'startproject', '--template=' + template_path, '--name=Vagrantfile', '--ext=html,rst', project_name] if dest_dir: utility_args.append(dest_dir) utility = ManagementUtility(utility_args) utility.execute() print("Success! %(project_name)s is created" % {'project_name': project_name})
def schemamigration(): # turn ``schemamigration.py --initial`` into # ``manage.py schemamigration cmsplugin_disqus --initial`` and setup the # enviroment from django.conf import settings from django.core.management import ManagementUtility settings.configure( INSTALLED_APPS=test_settings.INSTALLED_APPS, DATABASES=test_settings.DATABASES, TEMPLATE_CONTEXT_PROCESSORS=test_settings.TEMPLATE_CONTEXT_PROCESSORS, ROOT_URLCONF=test_settings.ROOT_URLCONF) argv = list(sys.argv) argv.insert(1, 'schemamigration') argv.insert(2, 'djangocms_text_ckeditor') utility = ManagementUtility(argv) utility.execute()
def create_project(parser, options, args): # Validate args if len(args) < 2: parser.error("Please specify a name for your wagtail installation") elif len(args) > 2: parser.error("Too many arguments") project_name = args[1] # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: parser.error("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) # Make sure directory does not already exist if os.path.exists(project_name): print('A directory called %(project_name)s already exists. \ Please choose another name for your wagtail project or remove the existing directory.' % {'project_name': project_name}) sys.exit(errno.EEXIST) print("Creating a wagtail project called %(project_name)s" % {'project_name': project_name}) # Create the project from the wagtail template using startapp # First find the path to wagtail import wagtail wagtail_path = os.path.dirname(wagtail.__file__) template_path = os.path.join(wagtail_path, 'project_template') # Call django-admin startproject utility = ManagementUtility([ 'django-admin.py', 'startproject', '--template=' + template_path, '--name=Vagrantfile', '--ext=html,rst', project_name ]) utility.execute() print("Success! %(project_name)s is created" % {'project_name': project_name})
def manage(command, args=[], in_background=False): """ Run a django command on the kalite project :param command: The django command string identifier, e.g. 'runserver' :param args: List of options to parse to the django management command :param in_background: Creates a sub-process for the command """ # Import here so other commands can run faster if not in_background: utility = ManagementUtility([os.path.basename(sys.argv[0]), command] + args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute() else: thread = ManageThread(command, args=args) thread.start()
def execute_manager(settings_mod, argv=None): """ Like execute_from_command_line(), but for use by manage.py, a project-specific django-admin.py utility. """ # don't add the project directory to the environment, as this ends # up importing classes using the project name, and self.assertIsInstance # requires us to specify the project name, making our tests non-portable. # setup_environ(settings_mod) # No monkey patches yet :) # import binder.monkeypatch # But we do need to do this first: os.environ['DJANGO_SETTINGS_MODULE'] = 'settings' utility = ManagementUtility(argv) utility.execute()
def create_project(parser, options, args): # Validate args if len(args) < 2: parser.error("Please specify a name for your wagtail installation") elif len(args) > 2: parser.error("Too many arguments") project_name = args[1] # Make sure given name is not already in use by another python package/module. try: __import__(project_name) except ImportError: pass else: parser.error("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project " "name. Please try another name." % project_name) # Make sure directory does not already exist if os.path.exists(project_name): print('A directory called %(project_name)s already exists. \ Please choose another name for your wagtail project or remove the existing directory.' % {'project_name': project_name}) sys.exit(errno.EEXIST) print("Creating a wagtail project called %(project_name)s" % {'project_name': project_name}) # Create the project from the wagtail template using startapp # First find the path to wagtail import wagtail wagtail_path = os.path.dirname(wagtail.__file__) template_path = os.path.join(wagtail_path, 'project_template') # Call django-admin startproject utility = ManagementUtility([ 'django-admin.py', 'startproject', '--template=' + template_path, '--name=Vagrantfile', '--ext=html,rst', project_name ]) utility.execute() print("Success! %(project_name)s is created" % {'project_name': project_name})
def schemamigration(): # turn ``schemamigration.py --initial`` into # ``manage.py schemamigration cmsplugin_disqus --initial`` and setup the # enviroment from django.conf import settings from django.core.management import ManagementUtility settings.configure( INSTALLED_APPS=INSTALLED_APPS, DATABASES=DATABASES, TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS ) argv = list(sys.argv) argv.insert(1, 'schemamigration') argv.insert(2, 'cmsplugin_articles') utility = ManagementUtility(argv) utility.execute()
def run_django_command(command, args): try: sys.path.append(path.join(MAIN_DIR, "server")); server_py = path.join(MAIN_DIR, "server", "manage.py") os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings") # Prepare argv argv = list(args) argv.insert(0, command) argv.insert(0, server_py) from django.core.management import ManagementUtility commander = ManagementUtility(argv) commander.execute() except: print "There was an error running a the '%s' command with '%s'" % (command, args) sys.exit(1) return
def schemamigration(): # # turn ``schemamigration.py --initial`` into: # ``manage.py schemamigration aldryn_segmentation --initial`` # and setup the environment. # from django.conf import settings from django.core.management import ManagementUtility settings.configure(INSTALLED_APPS=INSTALLED_APPS, ROOT_URLCONF=ROOT_URLCONF, DATABASES=DATABASES, TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS) argv = list(sys.argv) argv.insert(1, 'schemamigration') argv.insert(2, 'aldryn_segmentation') utility = ManagementUtility(argv) utility.execute()
def main(): """ django-develop CLI entry point. """ # XXX: Bail out early if being invoked for autocompletion. utility = ManagementUtility() utility.autocomplete() if not utils.is_inside_virtual_env(): _fail('Run django-develop inside a virtualenv') dd = _get_DjangoDevelop() if not dd.instance_path.exists(): _fail('django-develop not configured, try "django-develop-config"') else: # Set up and hand over to Django dd.activate_dev_settings() utility.execute()
def djangomigration(): # turn ``djangomigration.py`` into # ``manage.py makemigrations djangocms_grid`` and setup the # environment from django.conf import settings from django.core.management import ManagementUtility settings.configure( INSTALLED_APPS=INSTALLED_APPS, ROOT_URLCONF=ROOT_URLCONF, DATABASES=DATABASES, TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS, MIGRATION_MODULES=MIGRATION_MODULES, LANGUAGE_CODE=LANGUAGE_CODE, LANGUAGES=LANGUAGES, SITE_ID=SITE_ID, ) argv = list(sys.argv) argv.insert(1, 'makemigrations') argv.insert(2, 'djangocms_grid') utility = ManagementUtility(argv) utility.execute()
def djangomigration(): # turn ``djangomigration.py`` into # ``manage.py makemigrations djangocms_grid`` and setup the # environment from django.conf import settings from django.core.management import ManagementUtility settings.configure( INSTALLED_APPS=INSTALLED_APPS, ROOT_URLCONF=ROOT_URLCONF, DATABASES=DATABASES, TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS, MIGRATION_MODULES=MIGRATION_MODULES, LANGUAGE_CODE=LANGUAGE_CODE, LANGUAGES=LANGUAGES, SITE_ID=SITE_ID, ) argv = list(sys.argv) argv.insert(1, 'makemigrations') argv.insert(2, 'djangocms_grid') utility = ManagementUtility(argv) utility.execute()
def schemamigration(): # # turn ``schemamigration.py --initial`` into: # ``manage.py schemamigration aldryn_segmentation --initial`` # and setup the environment. # from django.conf import settings from django.core.management import ManagementUtility settings.configure( INSTALLED_APPS=INSTALLED_APPS, ROOT_URLCONF=ROOT_URLCONF, DATABASES=DATABASES, TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS ) argv = list(sys.argv) argv.insert(1, 'schemamigration') argv.insert(2, 'country_segment') utility = ManagementUtility(argv) utility.execute()
def run_django_command(command, args, require_settings = True): try: sys.path.append(path.join(MAIN_DIR, "server")); server_py = path.join(MAIN_DIR, "server", "manage.py") # Differentiates between those manage.py commands that require # a working settings.py, and those that can run without it, like # startapp. if require_settings: os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings") # Prepare argv argv = list(args) argv.insert(0, command) argv.insert(0, server_py) from django.core.management import ManagementUtility commander = ManagementUtility(argv) commander.execute() except Exception, e: print "There was an error running the '%s' command with '%s'." % (command, args) raise
def run_django_command(command, args, require_settings = True): try: sys.path.append(path.join(MAIN_DIR, "server")); server_py = path.join(MAIN_DIR, "server", "manage.py") # Differentiates between those manage.py commands that require # a working settings.py, and those that can run without it, like # startapp. if require_settings: os.environ.setdefault("DJANGO_SETTINGS_MODULE", "settings") # Prepare argv argv = list(args) argv.insert(0, command) argv.insert(0, server_py) from django.core.management import ManagementUtility commander = ManagementUtility(argv) commander.execute() except Exception, e: print "There was an error running the '%s' command with '%s'." % (command, args) raise
def manage(command, args=[], as_thread=False): """ Run a django command on the kalite project :param command: The django command string identifier, e.g. 'runserver' :param args: List of options to parse to the django management command :param as_daemon: Creates a new process for the command :param as_thread: Runs command in thread and returns immediately """ if not as_thread: if PROFILE: profile_memory() utility = ManagementUtility([os.path.basename(sys.argv[0]), command] + args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute() else: get_commands() # Needed to populate the available commands before issuing one in a thread thread = ManageThread(command, args=args, name=" ".join([command] + args)) thread.start()
def application_tests(self): self.log_header('Application tests:') try: import django # noqa except ImportError: print('Are you in a activated virtualenv and have installed the requirements?') print('virtualenv --python=/usr/bin/python3 tmp;source ./tmp/bin/activate;\ pip install -r web_frontend/requirements/local.txt') return work_dir = os.getcwd() try: osmaxx_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'web_frontend') sys.path.append(osmaxx_path) os.chdir(osmaxx_path) os.environ['DJANGO_SETTINGS_MODULE'] = 'config.settings.test' utility = ManagementUtility(['manage.py', 'test']) utility.execute() except subprocess.CalledProcessError as e: logger.info(e.output.decode()) self.log_failure("Tests failed. Please have a look at the {logfile};!".format(logfile=LOGFILE)) finally: os.chdir(work_dir)
def SvcDoRun(self): sys.stdout = open(os.path.join(project_dir, 'log', 'harmonyserv.log' ), 'at', buffering=0) sys.stderr = open(os.path.join(project_dir, 'log', 'harmonyserv.error.log'), 'at', buffering=0) host = HOST port = PORT if port is None: try: port = int(host) host = None except: pass if host is None: if HOST is None: import socket host = socket.gethostbyname(socket.gethostname()) else: host = HOST setup_environ(settings) utility = ManagementUtility([sys.argv[0], 'runserver', '%s:%s' % (host, port or PORT), '--noreload']) utility.execute()
def execute_manager(settings_mod, argv=None): """ Like execute_from_command_line(), but for use by manage.py, a project-specific django-admin.py utility. """ setup_environ(settings_mod) # Set up Green Plum Database Features execfile(os.path.abspath(os.path.join(os.path.dirname(__file__), 'greenplum_monkey_patch.py'))) if os.getpid() - os.getppid() == 1: # Let Run-Server print the notifications once on the console sys.stdout.write("Applying Green plum Monkey Patch...Success\n") sys.stdout.flush() # END Set up Green Plum Database Features utility = ManagementUtility(argv) if 'syncdb' in sys.argv: from django import get_version from django.core.management import LaxOptionParser from django.core.management.commands import syncdb parser = LaxOptionParser(usage="%prog subcommand [options] [args]", version=get_version(), option_list=syncdb.Command.option_list) options = parser.parse_args(sys.argv)[0] create_schema_before_syncdb(**options.__dict__) # create_views_on_piggy_back_keys() utility.execute()
#!/usr/bin/env python import os from django.core.management import setup_environ, ManagementUtility try: import settings # Assumed to be in the same directory. except ImportError: import sys sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n(If the file settings.py does indeed exist, it's causing an ImportError somehow.)\n" % __file__) sys.exit(1) if __name__ == "__main__": setup_environ(settings, original_settings_path=os.environ.get('DJANGO_SETTINGS_MODULE', 'settings')) utility = ManagementUtility(None) utility.execute()
def run(self): utility = ManagementUtility([os.path.basename(sys.argv[0]), self.command] + self.args) # This ensures that 'kalite' is printed in help menus instead of # 'kalitectl.py' (a part from the top most text in `kalite manage help` utility.prog_name = 'kalite manage' utility.execute()
def main(settings): setup_django(settings) utility = ManagementUtility(sys.argv) utility.execute()