def setup(verbosity, test_labels): from django.conf import settings state = { 'INSTALLED_APPS': settings.INSTALLED_APPS, 'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""), 'TEMPLATE_DIRS': settings.TEMPLATE_DIRS, 'USE_I18N': settings.USE_I18N, 'LOGIN_URL': settings.LOGIN_URL, 'LANGUAGE_CODE': settings.LANGUAGE_CODE, 'MIDDLEWARE_CLASSES': settings.MIDDLEWARE_CLASSES, 'STATIC_URL': settings.STATIC_URL, 'STATIC_ROOT': settings.STATIC_ROOT, } # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = 'urls' settings.STATIC_URL = '/static/' settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static') settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR),) settings.USE_I18N = True settings.LANGUAGE_CODE = 'en' settings.MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.common.CommonMiddleware', ) settings.SITE_ID = 1 # For testing comment-utils, we require the MANAGERS attribute # to be set, so that a test email is sent out which we catch # in our tests. settings.MANAGERS = ("*****@*****.**",) # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) django.setup() from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. test_labels_set = set([label.split('.')[0] for label in test_labels]) test_modules = get_test_modules() for module_name in test_modules: module_label = module_name # if the module was named on the command line, or # no modules were named (i.e., run all), import # this module and add it to the list to test. if not test_labels or module_name in test_labels_set: if verbosity >= 2: print "Importing application %s" % module_name mod = load_app(module_label) if mod: if module_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(module_label) return state
def django_tests(verbosity, interactive, failfast, test_labels): from django.conf import settings old_installed_apps = settings.INSTALLED_APPS old_root_urlconf = getattr(settings, "ROOT_URLCONF", "") old_template_dirs = settings.TEMPLATE_DIRS old_use_i18n = settings.USE_I18N old_login_url = settings.LOGIN_URL old_language_code = settings.LANGUAGE_CODE old_middleware_classes = settings.MIDDLEWARE_CLASSES # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. for model_dir, model_name in get_test_models(): model_label = '.'.join([model_dir, model_name]) try: # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in set([label.split('.')[0] for label in test_labels]): if verbosity >= 1: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) except Exception, e: sys.stderr.write("Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:])) continue
def setup(verbosity, test_labels): from django.conf import settings state = { 'INSTALLED_APPS': settings.INSTALLED_APPS, 'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""), 'TEMPLATE_DIRS': settings.TEMPLATE_DIRS, 'USE_I18N': settings.USE_I18N, 'LOGIN_URL': settings.LOGIN_URL, 'LANGUAGE_CODE': settings.LANGUAGE_CODE, 'MIDDLEWARE_CLASSES': settings.MIDDLEWARE_CLASSES, 'STATIC_URL': settings.STATIC_URL, 'STATIC_ROOT': settings.STATIC_ROOT, } # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = 'urls' settings.STATIC_URL = '/static/' settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static') settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR), ) settings.USE_I18N = True settings.LANGUAGE_CODE = 'en' settings.MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.common.CommonMiddleware', ) settings.SITE_ID = 1 # For testing comment-utils, we require the MANAGERS attribute # to be set, so that a test email is sent out which we catch # in our tests. settings.MANAGERS = ("*****@*****.**", ) # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) django.setup() from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. test_labels_set = set([label.split('.')[0] for label in test_labels]) test_modules = get_test_modules() for module_name in test_modules: module_label = module_name # if the module was named on the command line, or # no modules were named (i.e., run all), import # this module and add it to the list to test. if not test_labels or module_name in test_labels_set: if verbosity >= 2: print "Importing application %s" % module_name mod = load_app(module_label) if mod: if module_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(module_label) return state
def setup(verbosity, test_labels): from django.conf import settings from django.db.models.loading import get_apps, load_app state = { 'INSTALLED_APPS': settings.INSTALLED_APPS, 'ROOT_URLCONF': getattr(settings, "ROOT_URLCONF", ""), 'TEMPLATE_DIRS': settings.TEMPLATE_DIRS, 'LANGUAGE_CODE': settings.LANGUAGE_CODE, 'STATIC_URL': settings.STATIC_URL, 'STATIC_ROOT': settings.STATIC_ROOT, } # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = 'urls' settings.STATIC_URL = '/static/' settings.STATIC_ROOT = os.path.join(TEMP_DIR, 'static') settings.TEMPLATE_DIRS = (os.path.join(RUNTESTS_DIR, TEST_TEMPLATE_DIR),) settings.LANGUAGE_CODE = 'en' settings.SITE_ID = 1 if verbosity > 0: # Ensure any warnings captured to logging are piped through a verbose # logging handler. If any -W options were passed explicitly on command # line, warnings are not captured, and this has no effect. logger = logging.getLogger('py.warnings') handler = logging.StreamHandler() logger.addHandler(handler) # Load all the ALWAYS_INSTALLED_APPS. get_apps() # Load all the test model apps. test_labels_set = set([label.split('.')[0] for label in test_labels]) test_modules = get_test_modules() # If GeoDjango, then we'll want to add in the test applications # that are a part of its test suite. if geodjango(settings): from django.contrib.gis.tests import geo_apps test_modules.extend(geo_apps(runtests=True)) settings.INSTALLED_APPS.extend(['django.contrib.gis', 'django.contrib.sitemaps']) for module_dir, module_name in test_modules: if module_dir: module_label = '.'.join([module_dir, module_name]) else: module_label = module_name # if the module was named on the command line, or # no modules were named (i.e., run all), import # this module and add it to the list to test. if not test_labels or module_name in test_labels_set: if verbosity >= 2: print("Importing application %s" % module_name) mod = load_app(module_label) if mod: if module_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(module_label) return state
def prepareTestRunner(self, test): cur_stdout = sys.stdout cur_stderr = sys.stderr sys.stdout = self.sys_stdout sys.stderr = self.sys_stderr if self.add_apps: for app in self.add_apps: if app in settings.INSTALLED_APPS: continue mod = load_app(app) if mod: settings.INSTALLED_APPS.append(app) get_apps() self.runner.setup_test_environment() if self.needs_db: self.old_names = self.runner.setup_databases() sys.stdout = cur_stdout sys.stderr = cur_stderr self.started = True
def prepareTestRunner(self, test): cur_stdout = sys.stdout cur_stderr = sys.stderr sys.stdout = self.sys_stdout sys.stderr = self.sys_stderr if self.add_apps: for app in self.add_apps: if app in settings.INSTALLED_APPS: continue mod = load_app(app) if mod: settings.INSTALLED_APPS.append(app) get_apps() self.runner.setup_test_environment() if self.needs_db: self.old_names = self.runner.setup_databases() sys.stdout = cur_stdout sys.stderr = cur_stderr self.started = True
def django_tests(verbosity, interactive, failfast, test_labels): from django.conf import settings old_installed_apps = settings.INSTALLED_APPS old_root_urlconf = getattr(settings, "ROOT_URLCONF", "") old_template_dirs = settings.TEMPLATE_DIRS old_use_i18n = settings.USE_I18N old_login_url = settings.LOGIN_URL old_language_code = settings.LANGUAGE_CODE old_middleware_classes = settings.MIDDLEWARE_CLASSES # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = 'urls' settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR), ) settings.USE_I18N = True settings.LANGUAGE_CODE = 'en' settings.LOGIN_URL = '/accounts/login/' settings.MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.common.CommonMiddleware', ) settings.SITE_ID = 1 # For testing comment-utils, we require the MANAGERS attribute # to be set, so that a test email is sent out which we catch # in our tests. settings.MANAGERS = ("*****@*****.**", ) # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. for model_dir, model_name in get_test_models(): model_label = '.'.join([model_dir, model_name]) try: # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in set( [label.split('.')[0] for label in test_labels]): if verbosity >= 1: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) except Exception, e: sys.stderr.write( "Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:])) continue
def django_tests(verbosity, interactive, failfast, test_labels): from django.conf import settings old_installed_apps = settings.INSTALLED_APPS old_test_database_name = settings.TEST_DATABASE_NAME old_root_urlconf = getattr(settings, "ROOT_URLCONF", "") old_template_dirs = settings.TEMPLATE_DIRS old_use_i18n = settings.USE_I18N old_login_url = settings.LOGIN_URL old_language_code = settings.LANGUAGE_CODE old_middleware_classes = settings.MIDDLEWARE_CLASSES # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = "urls" settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),) settings.USE_I18N = True settings.LANGUAGE_CODE = "en" settings.LOGIN_URL = "/accounts/login/" settings.MIDDLEWARE_CLASSES = ( "django.contrib.sessions.middleware.SessionMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware", "django.middleware.common.CommonMiddleware", ) settings.SITE_ID = 1 # For testing comment-utils, we require the MANAGERS attribute # to be set, so that a test email is sent out which we catch # in our tests. settings.MANAGERS = ("*****@*****.**",) # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. for model_dir, model_name in get_test_models(): model_label = ".".join([model_dir, model_name]) try: # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in set([label.split(".")[0] for label in test_labels]): if verbosity >= 1: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) except Exception, e: sys.stderr.write( "Error while importing %s:" % model_name + "".join(traceback.format_exception(*sys.exc_info())[1:]) ) continue
def setup(verbosity, test_labels): from django.conf import settings state = { "INSTALLED_APPS": settings.INSTALLED_APPS, "ROOT_URLCONF": getattr(settings, "ROOT_URLCONF", ""), "TEMPLATE_DIRS": settings.TEMPLATE_DIRS, "USE_I18N": settings.USE_I18N, "LOGIN_URL": settings.LOGIN_URL, "LANGUAGE_CODE": settings.LANGUAGE_CODE, "MIDDLEWARE_CLASSES": settings.MIDDLEWARE_CLASSES, } # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = "urls" settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),) settings.USE_I18N = True settings.LANGUAGE_CODE = "en" settings.LOGIN_URL = "/accounts/login/" settings.MIDDLEWARE_CLASSES = ( "django.contrib.sessions.middleware.SessionMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware", "django.middleware.common.CommonMiddleware", ) settings.SITE_ID = 1 # For testing comment-utils, we require the MANAGERS attribute # to be set, so that a test email is sent out which we catch # in our tests. settings.MANAGERS = ("*****@*****.**",) # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. test_labels_set = set([label.split(".")[0] for label in test_labels]) for model_dir, model_name in get_test_models(): model_label = ".".join([model_dir, model_name]) # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in test_labels_set: if verbosity >= 2: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) return state
def django_tests(verbosity, interactive, test_labels): from django.conf import settings import deseb deseb.add_aka_support() old_installed_apps = settings.INSTALLED_APPS old_test_database_name = settings.TEST_DATABASE_NAME old_root_urlconf = settings.ROOT_URLCONF old_template_dirs = settings.TEMPLATE_DIRS old_use_i18n = settings.USE_I18N old_middleware_classes = settings.MIDDLEWARE_CLASSES # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = 'urls' settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR), ) settings.USE_I18N = True settings.MIDDLEWARE_CLASSES = ( 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.middleware.common.CommonMiddleware', ) if not hasattr(settings, 'SITE_ID'): settings.SITE_ID = 1 # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. test_models = [] for model_dir, model_name in get_test_models(): model_label = '.'.join([model_dir, model_name]) try: # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in set( [label.split('.')[0] for label in test_labels]): if verbosity >= 1: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) except Exception, e: sys.stderr.write( "Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:])) continue
def django_tests(verbosity, interactive, test_labels): from django.conf import settings import deseb deseb.add_aka_support() old_installed_apps = settings.INSTALLED_APPS old_test_database_name = settings.TEST_DATABASE_NAME old_root_urlconf = settings.ROOT_URLCONF old_template_dirs = settings.TEMPLATE_DIRS old_use_i18n = settings.USE_I18N old_middleware_classes = settings.MIDDLEWARE_CLASSES # Redirect some settings for the duration of these tests. settings.INSTALLED_APPS = ALWAYS_INSTALLED_APPS settings.ROOT_URLCONF = "urls" settings.TEMPLATE_DIRS = (os.path.join(os.path.dirname(__file__), TEST_TEMPLATE_DIR),) settings.USE_I18N = True settings.MIDDLEWARE_CLASSES = ( "django.contrib.sessions.middleware.SessionMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.middleware.common.CommonMiddleware", ) if not hasattr(settings, "SITE_ID"): settings.SITE_ID = 1 # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. test_models = [] for model_dir, model_name in get_test_models(): model_label = ".".join([model_dir, model_name]) try: # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in set([label.split(".")[0] for label in test_labels]): if verbosity >= 1: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) except Exception, e: sys.stderr.write( "Error while importing %s:" % model_name + "".join(traceback.format_exception(*sys.exc_info())[1:]) ) continue
def on_each_app(self, methname, *args): "See :func:`dd.on_each_app`." from django.db.models import loading for mod in loading.get_apps(): meth = getattr(mod, methname, None) if meth is not None: meth(self, *args)
def _import_objects(self, modules): from django.db.models.loading import get_models, get_apps loaded_models = get_models() # Set up a dictionary to serve as the environment for the shell, so # that tab completion works on objects that are imported at runtime. # See ticket 5082. imported_objects = {} for app_mod in get_apps(): app_models = get_models(app_mod) if not app_models: continue model_labels = ", ".join([model.__name__ for model in app_models]) print self.style.SQL_COLTYPE( "From '%s' autoload: %s" % (app_mod.__name__.split('.')[-2], model_labels)) for model in app_models: try: imported_objects[model.__name__] = getattr( __import__(app_mod.__name__, {}, {}, model.__name__), model.__name__) except AttributeError, e: print self.style.ERROR_OUTPUT( "Failed to import '%s' from '%s' reason: %s" % (model.__name__, app_mod.__name__.split('.')[-2], str(e))) continue
def filter_model_fields(app_labels=None, model_fields=None): """ Collect a filtered and sorted list of model fields. >>> from django.db import models >>> fields = filter_model_fields( ... app_labels = ("auth",), model_fields = (models.CharField,) ... ) >>> field2dot_name(fields[0]) 'auth.Group.name' >>> [field.get_attname() for field in fields] ['name', 'codename', 'name', 'email', 'first_name', 'last_name', 'password', 'username'] :param app_labels: Filter by app labels, if None: all installed apps :param model_fields: List of field classes for filtering :return: field list, sorted by dot name representation """ filtered_fields = set() for app in get_apps(): for model in get_models(app): for field in model._meta.fields: if app_labels is not None: if field.model._meta.app_label not in app_labels: continue if not isinstance(field, model_fields): continue filtered_fields.add(field) return sort_fields(filtered_fields)
def proposed_indexes(self): """ Return all indexes Django proposes & SQL for indexes """ all_indexes = [] proposed_indexes = {} index_sql = {} for app in get_apps(): all_indexes.append(u'\n'.join(sql_indexes(app, no_style(),connection)).encode('utf-8')) #Sort out all the proposed indexes by table. for index in all_indexes: indice = index.split('\n') for ind in indice: try: match = index_re.search(ind) name, table, field = match.groups() if proposed_indexes.has_key(table): proposed_indexes[table].append(field) else: proposed_indexes[table] = [field] if index_sql.has_key(name): index_sql[name].append(ind) else: index_sql[name] = [ind] except: pass return proposed_indexes, index_sql
def handle_noargs(self, **options): from django.db.models import loading from django.core.management import call_command for app in loading.get_apps(): call_command('reset', app.__name__.split('.')[-2], interactive=False) call_command('syncdb')
def generate_files(self): from lino.ui.extjs3 import UI # ~ UI = settings.SITE.get_ui_class ui = UI(make_messages=True) # ~ # install Lino urls under root location (`/`) # ~ ui = urlpatterns = ui.get_patterns() # ~ settings.SITE.setup() ui.make_linolib_messages() context = dict( header=rstgen.header, h1=curry(rstgen.header, 1), table=rstgen.table, doc=doc2rst, loading=loading, models=models, abstract=abstract, refto=refto, # ~ py2rst=rstgen.py2rst, full_model_name=full_model_name, model_overview=model_overview, model_referenced_from=model_referenced_from, model_ref=model_ref, ) self.generate("index.rst.tmpl", "index.rst", **context) for a in loading.get_apps(): app_label = a.__name__.split(".")[-2] app_models = models.get_models(a, include_auto_created=True) context.update(app=a, app_label=app_label, app_models=app_models) self.generate("app.rst.tmpl", "%s.rst" % app_label, **context) for model in app_models: context.update(model=model) self.generate("model.rst.tmpl", "%s.rst" % full_model_name(model), **context)
def handle_noargs(self, **options): # XXX: (Temporary) workaround for ticket #1796: force early loading of all # models from installed apps. (this is fixed by now, but leaving it here # for people using 0.96 or older trunk (pre [5919]) versions. from django.db.models.loading import get_models, get_apps loaded_models = get_models() use_plain = options.get('plain', False) use_pythonrc = not options.get('no_pythonrc', True) # Set up a dictionary to serve as the environment for the shell, so # that tab completion works on objects that are imported at runtime. # See ticket 5082. from django.conf import settings imported_objects = {'settings': settings} for app_mod in get_apps(): app_models = get_models(app_mod) if not app_models: continue model_labels = ", ".join([model.__name__ for model in app_models]) print self.style.SQL_COLTYPE("From '%s' autoload: %s" % (app_mod.__name__.split('.')[-2], model_labels)) for model in app_models: try: imported_objects[model.__name__] = getattr(__import__(app_mod.__name__, {}, {}, model.__name__), model.__name__) except AttributeError, e: print self.style.ERROR_OUTPUT("Failed to import '%s' from '%s' reason: %s" % (model.__name__, app_mod.__name__.split('.')[-2], str(e))) continue
def runjobs(labels = [], verbose = False): """ Run all jobs in all applications if they match the labels """ if len(labels) > 0: # Import the modules from django.db.models.loading import get_apps # Get all installed applications for app in get_apps(): # Define the job module path job_path = '.'.join(app.__name__.split('.')[:-1])+'.jobs' # Try to import the module try: job_module = __import__(job_path, globals(), locals(), ['*']) except ImportError: pass else: # The module has been imported, get its elements for (job_name, job_class) in inspect.getmembers(job_module): # Use only the classes if inspect.isclass(job_class): # Test the class is Job-based if job_class.__base__ is Job: # Check if the job class is found in labels if job_class.__name__.lower() in labels: # Instantiate the job object job = job_class(verbose = verbose) job.runjobs()
def add_new_model(request, model_name): if (model_name.lower() == model_name): normal_model_name = model_name.capitalize() else: normal_model_name = model_name app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == normal_model_name: form = modelform_factory(model) if request.method == 'POST': form = form(request.POST) if form.is_valid(): try: new_obj = form.save() except forms.ValidationError, error: new_obj = None if new_obj: return HttpResponse('<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script>' % \ (escape(new_obj._get_pk_val()), escape(new_obj))) else: form = form() page_context = {'form': form, 'field': normal_model_name} return render_to_response('widgets/popup.html', page_context, context_instance=RequestContext(request))
def handle(self, *args, **kwargs): if settings.DATABASES['default']['ENGINE'] != 'django.db.backends.sqlite3': if input('Database engine is not SQLite. Do you wish load staging data? [y/N]') != 'y': return env = kwargs.get('env') options = kwargs.get('options', {}) app_module_paths = [] for app in get_apps(): if hasattr(app, '__path__'): # It's a 'models/' subpackage for path in app.__path__: app_module_paths.append(path) else: # It's a models.py module app_module_paths.append(app.__file__) app_fixtures = [os.path.join(os.path.dirname(path), 'fixtures') for path in app_module_paths] app_fixtures += settings.FIXTURE_DIRS fixtures = [] for app in app_fixtures: if os.path.exists(app): fixtures.extend(self.load_path(app, options, env)) call_command('loaddata', *fixtures, **options) on_load_staging.send(app_fixtures)
def get_permission_choices(): """ Rather than creating permissions in the datastore which is incredibly slow (and relational) we just use the permission codenames, stored in a ListField. """ global PERMISSIONS_LIST if PERMISSIONS_LIST: return PERMISSIONS_LIST from django.conf import settings AUTO_PERMISSIONS = getattr(settings, "AUTOGENERATED_PERMISSIONS", ('add', 'change', 'delete')) result = getattr(settings, "MANUAL_PERMISSIONS", []) for app in get_apps(): for model in get_models(app): for action in AUTO_PERMISSIONS: opts = model._meta result.append( ('%s.%s' % (opts.app_label, get_permission_codename(action, opts)), 'Can %s %s' % (action, opts.verbose_name_raw))) PERMISSIONS_LIST = sorted(result) return PERMISSIONS_LIST
def auto_patch_all(): for app in get_apps(): for model in get_models(app): try: patch_admin(model, skip_non_revision=True) except Exception as err: logging.warning("Can't patch admin for model %r: %s" % (model, err))
def get_import_objects(): """ Collect objects to populate the interactive session """ imported_objects = {} loaded_model_names = set() for app in get_apps(): app_name = app.__name__.split('.')[-2] for model in get_models(app): model_name = model.__name__ if model_name in loaded_model_names: model_name = '_'.join((app_name, model_name)) else: loaded_model_names.add(model_name) imported_objects[model_name] = model for extra_import in settings.EXTRA_SHELLPLUS_IMPORTS: if isinstance(extra_import, basestring): obj = import_object(extra_import) name = extra_import.split('.')[-1] else: import_path, name = extra_import obj = import_object(import_path) imported_objects[name] = obj return imported_objects
def filter_model_fields(app_labels=None, model_fields=None): """ Collect a filtered and sorted list of model fields. >>> from django.db import models >>> fields = filter_model_fields( ... app_labels = ("auth",), model_fields = (models.CharField,) ... ) >>> field2dot_name(fields[0]) 'auth.Group.name' >>> [field.get_attname() for field in fields] ['name', 'codename', 'name', 'email', 'first_name', 'last_name', 'password', 'username'] :param app_labels: Filter by app labels, if None: all installed apps :param model_fields: List of field classes for filtering :return: field list, sorted by dot name representation """ filtered_fields = set() for app in get_apps(): for model in get_models(app): for field in model._meta.fields: if app_labels is not None: if field.model._meta.app_label not in app_labels: continue if not isinstance(field, model_fields): continue filtered_fields.add(field) return sort_fields(filtered_fields)
def safe_build_suite(self, test_labels, extra_tests=None, **kwargs): suite = unittest.TestSuite() if test_labels: for label in test_labels: try: if '.' in label: suite.addTest(build_test(label)) else: app = get_app(label) suite.addTest(build_suite(app)) except Exception: log.warning("Could not add test for label: %s" %label) else: for app in get_apps(): try: suite.addTest(build_suite(app)) except Exception: log.warning("Could not add tests for app: %s" %app) if extra_tests: for test in extra_tests: suite.addTest(test) return reorder_suite(suite, (TestCase,))
def add_new_model(request, model_name): if (model_name.lower() == model_name): normal_model_name = model_name.capitalize() else: normal_model_name = model_name app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == normal_model_name: form = modelform_factory(model) if request.method == 'POST': form = form(request.POST) if form.is_valid(): try: new_obj = form.save() except forms.ValidationError as error: new_obj = None if new_obj: return HttpResponse('<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script>' % \ (escape(new_obj._get_pk_val()), escape(new_obj))) else: form = form() page_context = {'form': form, 'field': normal_model_name} return render_to_response( 'browse/popup.html', page_context, context_instance=RequestContext(request))
def add_new_model(request, model_name): if (model_name.lower() == model_name): normal_model_name = model_name.capitalize() else: normal_model_name = model_name app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == normal_model_name: form = modelform_factory(model) if request.method == 'POST': form = form(request.POST) if form.is_valid(): try: new_obj = form.save() except forms.ValidationError as error: new_obj = None if new_obj: return HttpResponse('<script type="text/javascript">opener.location.reload();window.close();</script>') else: form = form() page_context = {'form': form, 'field': normal_model_name} return render_to_response('popup.html', page_context, context_instance=RequestContext(request))
def make_namespace(): ns = {} for app in get_apps(): for model in get_models(app): ns[model.__name__] = model ns[model._meta.app_label + '_' + model._meta.object_name] = model return ns
def generate_files(self): from lino.ui.extjs3 import UI #~ UI = settings.SITE.get_ui_class ui = UI(make_messages=True) # ~ # install Lino urls under root location (`/`) #~ ui = urlpatterns = ui.get_patterns() #~ settings.SITE.setup() ui.make_linolib_messages() context = dict( header=rstgen.header, h1=curry(rstgen.header, 1), table=rstgen.table, doc=doc2rst, loading=loading, models=models, abstract=abstract, refto=refto, #~ py2rst=rstgen.py2rst, full_model_name=full_model_name, model_overview=model_overview, model_referenced_from=model_referenced_from, model_ref=model_ref, ) self.generate('index.rst.tmpl', 'index.rst', **context) for a in loading.get_apps(): app_label = a.__name__.split('.')[-2] app_models = models.get_models(a, include_auto_created=True) context.update(app=a, app_label=app_label, app_models=app_models) self.generate('app.rst.tmpl', '%s.rst' % app_label, **context) for model in app_models: context.update(model=model, ) self.generate('model.rst.tmpl', '%s.rst' % full_model_name(model), **context)
def get_permission_choices(): """ Rather than creating permissions in the datastore which is incredibly slow (and relational) we just use the permission codenames, stored in a ListField. """ global PERMISSIONS_LIST if PERMISSIONS_LIST: return PERMISSIONS_LIST from django.conf import settings AUTO_PERMISSIONS = getattr(settings, "AUTOGENERATED_PERMISSIONS", ('add', 'change', 'delete')) result = getattr(settings, "MANUAL_PERMISSIONS", []) for app in get_apps(): for model in get_models(app): for action in AUTO_PERMISSIONS: opts = model._meta result.append((get_permission_codename(action, opts), 'Can %s %s' % (action, opts.verbose_name_raw))) PERMISSIONS_LIST = sorted(result) return PERMISSIONS_LIST
def make_namespace(): ns = {} for app in get_apps(): for model in get_models(app): ns[model.__name__] = model ns[model._meta.app_label + '_' + model._meta.object_name] = model return ns
def _import_objects(self, modules): from django.db.models.loading import get_models, get_apps loaded_models = get_models() # Set up a dictionary to serve as the environment for the shell, so # that tab completion works on objects that are imported at runtime. # See ticket 5082. imported_objects = {} for app_mod in get_apps(): app_models = get_models(app_mod) if not app_models: continue model_labels = ", ".join([model.__name__ for model in app_models]) print self.style.SQL_COLTYPE("From '%s' autoload: %s" % (app_mod.__name__.split(".")[-2], model_labels)) for model in app_models: try: imported_objects[model.__name__] = getattr( __import__(app_mod.__name__, {}, {}, model.__name__), model.__name__ ) except AttributeError, e: print self.style.ERROR_OUTPUT( "Failed to import '%s' from '%s' reason: %s" % (model.__name__, app_mod.__name__.split(".")[-2], str(e)) ) continue
def bisect_tests(bisection_label, options, test_labels): state = setup(int(options.verbosity), test_labels) if not test_labels: # Get the full list of test labels to use for bisection from django.db.models.loading import get_apps test_labels = [app.__name__.split('.')[-2] for app in get_apps()] print('***** Bisecting test suite: %s' % ' '.join(test_labels)) # Make sure the bisection point isn't in the test list # Also remove tests that need to be run in specific combinations for label in [bisection_label, 'model_inheritance_same_model_name']: try: test_labels.remove(label) except ValueError: pass subprocess_args = [ sys.executable, __file__, '--settings=%s' % options.settings] if options.failfast: subprocess_args.append('--failfast') if options.verbosity: subprocess_args.append('--verbosity=%s' % options.verbosity) if not options.interactive: subprocess_args.append('--noinput') iteration = 1 while len(test_labels) > 1: midpoint = len(test_labels)/2 test_labels_a = test_labels[:midpoint] + [bisection_label] test_labels_b = test_labels[midpoint:] + [bisection_label] print('***** Pass %da: Running the first half of the test suite' % iteration) print('***** Test labels: %s' % ' '.join(test_labels_a)) failures_a = subprocess.call(subprocess_args + test_labels_a) print('***** Pass %db: Running the second half of the test suite' % iteration) print('***** Test labels: %s' % ' '.join(test_labels_b)) print('') failures_b = subprocess.call(subprocess_args + test_labels_b) if failures_a and not failures_b: print("***** Problem found in first half. Bisecting again...") iteration = iteration + 1 test_labels = test_labels_a[:-1] elif failures_b and not failures_a: print("***** Problem found in second half. Bisecting again...") iteration = iteration + 1 test_labels = test_labels_b[:-1] elif failures_a and failures_b: print("***** Multiple sources of failure found") break else: print("***** No source of failure found... try pair execution (--pair)") break if len(test_labels) == 1: print("***** Source of error: %s" % test_labels[0]) teardown(state)
def handle(self, *app_labels, **options): if options.get("list_models", False): print "List all installed models:" data = [] for app in get_apps(): app_name = app.__name__.split('.')[-2] # assuming -1 is 'models' and -2 is name models = tuple([model.__name__ for model in get_models(app)]) if models: data.append([app_name, models]) pprint.pprint(data) return file_path = os.path.join(FIXTURE_PATH, FIXTURE_FILENAME) if options.get("test", False): if not os.path.isfile(file_path): print "fixture file not exist: %r" % file_path return from django.utils import simplejson f = codecs.open(file_path, "r", encoding="utf-8") data = simplejson.load(f) f.close() print "loaded %s entries from %s" % (len(data), file_path) return json_serializer = serializers.get_serializer("json")() objects = [] for app_name, model_names in APP_MODEL_DATA: print "App: %r" % app_name for model_name in model_names: print "\tModel: %r" % model_name model = get_model(app_name, model_name) if model_name == "PageTree": # Get the PageTree objects ordered by topology! data = get_pagetree_objects(model) else: data = model._default_manager.all() objects.extend(data) print " -" * 39 if not os.path.isdir(FIXTURE_PATH): print "Create dir %r" % FIXTURE_PATH os.makedirs(FIXTURE_PATH) print "Serialize data and save it into %r..." % FIXTURE_FILENAME try: with codecs.open(file_path, "w", encoding="utf-8") as out: json_serializer.serialize(objects, indent=options['indent'], stream=out, ensure_ascii=False # http://docs.djangoproject.com/en/dev/topics/serialization/#notes-for-specific-serialization-formats ) except Exception, e: if options['traceback']: raise raise CommandError("Unable to serialize database: %s" % e)
def get_model(model_name): app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == model_name: return model raise Exception('Did not find the model %s' % (model_name))
def get_model(model_name): app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == model_name: return model raise Exception("Did not find the model %s" % model_name)
def run(): for app_mod in get_apps(): app_models = get_models(app_mod) for model in app_models: try: print model.__module__, model.__name__, model.objects.all().count() except Exception, e: print e
def handle(self, *args, **options): all_indexes = [] proposed_indexes = {} index_sql = {} for app in get_apps(): all_indexes.append(u'\n'.join( sql_indexes(app, no_style(), connection)).encode('utf-8')) #Sort out all the proposed indexes by table. for index in all_indexes: indice = index.split('\n') for ind in indice: try: match = index_re.search(ind) name, table, field = match.groups() if table in proposed_indexes: proposed_indexes[table].append(name) else: proposed_indexes[table] = [name] if name in index_sql: index_sql[name].append(ind) else: index_sql[name] = [ind] except: pass #Now get all the real indexes. indexes = {} cursor = connection.cursor() vals = cursor.execute(CURRENT_INDEX_SQL) sql_back = cursor.fetchall() for row in sql_back: name, table = row if table in indexes: indexes[table].append(name) else: indexes[table] = [name] #For all the proposed indexes, see if they exist #If not, tell us! for prop_name, prop_tables in proposed_indexes.items(): for table in prop_tables: try: if not table in indexes[prop_name]: if not options['show']: logger.info("(%s, %s) is missing", prop_name, table) else: for index in index_sql[table]: if prop_name in index: logger.info(index) except KeyError: if not options['show']: logger.info("No Indexes for %s in original db", prop_name) else: for index in index_sql[table]: if table in index: logger.info(index)
def import_objects(options, style): class ObjectImportError(Exception): pass # XXX: (Temporary) workaround for ticket #1796: force early loading of all # models from installed apps. (this is fixed by now, but leaving it here # for people using 0.96 or older trunk (pre [5919]) versions. from django.db.models.loading import get_models, get_apps # from django.db.models.loading import get_models, get_apps loaded_models = get_models() # NOQA from django.conf import settings imported_objects = {'settings': settings} dont_load_cli = options.get('dont_load') # optparse will set this to [] if it doensnt exists dont_load_conf = getattr(settings, 'SHELL_PLUS_DONT_LOAD', []) dont_load = dont_load_cli + dont_load_conf quiet_load = options.get('quiet_load') model_aliases = getattr(settings, 'SHELL_PLUS_MODEL_ALIASES', {}) for app_mod in get_apps(): app_models = get_models(app_mod) if not app_models: continue app_name = app_mod.__name__.split('.')[-2] if app_name in dont_load: continue app_aliases = model_aliases.get(app_name, {}) model_labels = [] for model in app_models: try: imported_object = getattr(__import__(app_mod.__name__, {}, {}, model.__name__), model.__name__) model_name = model.__name__ if "%s.%s" % (app_name, model_name) in dont_load: continue alias = app_aliases.get(model_name, model_name) imported_objects[alias] = imported_object if model_name == alias: model_labels.append(model_name) else: model_labels.append("%s (as %s)" % (model_name, alias)) except AttributeError as e: if not quiet_load: print(style.ERROR("Failed to import '%s' from '%s' reason: %s" % (model.__name__, app_name, str(e)))) continue if not quiet_load: print(style.SQL_COLTYPE("From '%s' autoload: %s" % (app_mod.__name__.split('.')[-2], ", ".join(model_labels)))) return imported_objects
def handle_noargs(self, **options): # XXX: (Temporary) workaround for ticket #1796: force early loading of all # models from installed apps. (this is fixed by now, but leaving it here # for people using 0.96 or older trunk (pre [5919]) versions. from django.db.models.loading import get_models, get_apps loaded_models = get_models() use_ipython = options.get('ipython', False) use_plain = options.get('plain', False) use_pythonrc = not options.get('no_pythonrc', True) if options.get("print_sql", False): # Code from http://gist.github.com/118990 from django.db.backends import util try: import sqlparse except ImportError: sqlparse = None class PrintQueryWrapper(util.CursorDebugWrapper): def execute(self, sql, params=()): try: return self.cursor.execute(sql, params) finally: raw_sql = self.db.ops.last_executed_query( self.cursor, sql, params) if sqlparse: print sqlparse.format(raw_sql, reindent=True) else: print raw_sql print util.CursorDebugWrapper = PrintQueryWrapper # Set up a dictionary to serve as the environment for the shell, so # that tab completion works on objects that are imported at runtime. # See ticket 5082. from django.conf import settings imported_objects = {'settings': settings} for app_mod in get_apps(): app_models = get_models(app_mod) if not app_models: continue model_labels = ", ".join([model.__name__ for model in app_models]) print self.style.SQL_COLTYPE( "From '%s' autoload: %s" % (app_mod.__name__.split('.')[-2], model_labels)) for model in app_models: try: imported_objects[model.__name__] = getattr( __import__(app_mod.__name__, {}, {}, model.__name__), model.__name__) except AttributeError, e: print self.style.ERROR( "Failed to import '%s' from '%s' reason: %s" % (model.__name__, app_mod.__name__.split('.')[-2], str(e))) continue
def get_model_form(model_name): app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == model_name: form = modelform_factory(model) return form raise Exception('Did not find the model %s' % model_name)
def get_model_form(model_name): app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == model_name: form = modelform_factory(model) return form raise Exception('Did not find the model %s' % (model_name))
def run(): for app_mod in get_apps(): app_models = get_models(app_mod) for model in app_models: try: print model.__module__, model.__name__, model.objects.all( ).count() except Exception, e: print e
def handle(self, *args, **options): all_indexes = [] proposed_indexes = {} index_sql = {} for app in get_apps(): all_indexes.append(u'\n'.join(sql_indexes(app, no_style(), connection)).encode('utf-8')) #Sort out all the proposed indexes by table. for index in all_indexes: indice = index.split('\n') for ind in indice: try: match = index_re.search(ind) name, table, field = match.groups() if table in proposed_indexes: proposed_indexes[table].append(name) else: proposed_indexes[table] = [name] if name in index_sql: index_sql[name].append(ind) else: index_sql[name] = [ind] except: pass #Now get all the real indexes. indexes = {} cursor = connection.cursor() vals = cursor.execute(CURRENT_INDEX_SQL) sql_back = cursor.fetchall() for row in sql_back: name, table = row if table in indexes: indexes[table].append(name) else: indexes[table] = [name] #For all the proposed indexes, see if they exist #If not, tell us! for prop_name, prop_tables in proposed_indexes.items(): for table in prop_tables: try: if not table in indexes[prop_name]: if not options['show']: logger.info("(%s, %s) is missing", prop_name, table) else: for index in index_sql[table]: if prop_name in index: logger.info(index) except KeyError: if not options['show']: logger.info("No Indexes for %s in original db", prop_name) else: for index in index_sql[table]: if table in index: logger.info(index)
def get_all_jobs(): jobs = [] for app in get_apps(): try: module = importlib.import_module(app.__name__[:-6] + 'jobs') jobs.extend(get_jobs_from_module(module)) except ImportError: pass return jobs
def handle(self, *args, **options): if len(args) < 1: if options['all_applications']: applications = get_apps() else: raise CommandError("need one or more arguments for appname") else: try: applications = [get_app(label) for label in args] except ImproperlyConfigured, e: raise CommandError("Specified application not found: %s" % e)
def handle_noargs(self, **options): for app in get_apps(): for model in get_models(app): if issubclass(model, SlugifiedModel): print 'Slugifying %s' % model._meta.verbose_name_plural i = 0 for obj in model._default_manager.all().iterator(): obj.save() i += 1 if not i % 100: print '%d %s slugified' % ( i, model._meta.verbose_name_plural)
def _get_containing_app(object_name): candidates = [] for app_config in loading.get_apps(): if app_config.__package__ is None: app_config.__package__ = app_config.__name__.rpartition('.')[0] if object_name.startswith(app_config.__package__): subpath = object_name[len(app_config.__package__):] if subpath == '' or subpath[0] == '.': candidates.append(app_config) if candidates: return sorted(candidates, key=lambda ac: -len(ac.__package__))[0]
def _cache(): if _APP_NAMES_CACHE: return for app in get_apps(): for model in get_models(app, include_auto_created=True): model_name = model._meta.object_name.lower() app_name = model._meta.app_label.lower() _APP_NAMES_CACHE[model_name].add(app_name) _MODEL_CACHE[model_label(model)] = model for model_name, app_labels in _APP_NAMES_CACHE.items(): if len(app_labels) == 1: model = _MODEL_CACHE[model_label(list(app_labels)[0], model_name)] _MODEL_CACHE[model_name] = model
def get_app_paths(): """ Returns a list of paths to all installed apps. Useful for discovering files at conventional locations inside apps (static files, templates, etc.) """ app_paths = [] for app in get_apps(): if hasattr(app, '__path__'): # models/__init__.py package app_paths.extend([upath(path) for path in app.__path__]) else: # models.py module app_paths.append(upath(app.__file__)) return app_paths
def django_tests(verbosity, interactive, failfast, test_labels): from django.conf import settings old_installed_apps = settings.INSTALLED_APPS old_root_urlconf = getattr(settings, "ROOT_URLCONF", "") old_template_dirs = settings.TEMPLATE_DIRS old_use_i18n = settings.USE_I18N old_login_url = settings.LOGIN_URL old_language_code = settings.LANGUAGE_CODE old_middleware_classes = settings.MIDDLEWARE_CLASSES # Load all the ALWAYS_INSTALLED_APPS. # (This import statement is intentionally delayed until after we # access settings because of the USE_I18N dependency.) from django.db.models.loading import get_apps, load_app get_apps() # Load all the test model apps. for model_dir, model_name in get_test_models(): model_label = '.'.join([model_dir, model_name]) try: # if the model was named on the command line, or # no models were named (i.e., run all), import # this model and add it to the list to test. if not test_labels or model_name in set( [label.split('.')[0] for label in test_labels]): if verbosity >= 1: print "Importing model %s" % model_name mod = load_app(model_label) if mod: if model_label not in settings.INSTALLED_APPS: settings.INSTALLED_APPS.append(model_label) except Exception, e: sys.stderr.write( "Error while importing %s:" % model_name + ''.join(traceback.format_exception(*sys.exc_info())[1:])) continue
def _get_all_models(filter_app_name=None): all_models = [] if filter_app_name: apps = [get_app(filter_app_name)] else: apps = get_apps() from django.contrib.admin import site for app in apps: for mod in get_models(app): if mod in site._registry: all_models.append("%s:%s" % (mod._meta.app_label, force_unicode(mod._meta.verbose_name))) return zip(all_models, all_models)
def get_model_form(model_name): app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == model_name: try: # add_new_form is a class method # that can be used to specialize the form form = model.add_new_form() except AttributeError: form = None if not form: form = modelform_factory(model) return form raise Exception('Did not find the model %s' % (model_name))
def __init__(self, *app_names): """ app_names: One or more fully qualified django app names ie: api = AutoAPI('django.contrib.auth', 'example') """ self.api = Api() apps = [] if app_names: for app in app_names: app = load_app(app) apps.append(app) else: # Add all the apps if none are specified apps = get_apps() for app in apps: self.register_app(app)
def add_new_model(request, model_name): if (model_name.lower() == model_name): normal_model_name = model_name.capitalize() else: normal_model_name = model_name current_user = request.user current_profile = current_user.profile current_organization = current_profile and current_profile.organization auto_fields = { 'organization': current_organization, } app_list = get_apps() for app in app_list: for model in get_models(app): if model.__name__ == normal_model_name: # Try to get a form based on model, if you can. form = getattr(sfpirg_forms, '%sForm' % normal_model_name, None) or modelform_factory(model) if request.method == 'POST': form = form(request.POST) if form.is_valid(): try: new_obj = form.save() except forms.ValidationError, error: new_obj = None if new_obj: return HttpResponse('<script type="text/javascript">opener.dismissAddAnotherPopup(window, "%s", "%s");</script>' % \ (escape(new_obj._get_pk_val()), escape(new_obj))) else: form = form() for fieldname, field in form.fields.items(): if fieldname in auto_fields: field.initial = auto_fields[fieldname] field.widget = forms.HiddenInput() page_context = {'form': form, 'field': normal_model_name} return render_to_response( 'popup.html', page_context, context_instance=RequestContext(request))