Here are the examples of the python api django.db.models.get_apps taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
120 Examples
3
Example 1
def render(self, context):
all_apps = {}
for app in models.get_apps():
name = len(rsplit(app.__name__, '.', 0))>1 and rsplit(app.__name__, '.', 0)[-2] or app.__name__
all_apps[name] = app.__name__
filtered_app_list = []
for entry in context[self.listname]:
app = all_apps.get(entry['name'].lower(),'')
if not app.startswith('satchmo_'):
filtered_app_list.append(entry)
context[self.varname] = filtered_app_list
return ''
3
Example 2
Project: sqjobs Source File: finders.py
def get_apps_names():
"""
copied from django-extensions compatibility sheam
"""
try:
# django >= 1.7, to support AppConfig
from django.apps import apps
return [app.name for app in apps.get_app_configs()]
except ImportError:
from django.db import models
return [app.__name__[:-7] for app in models.get_apps()]
3
Example 3
Project: snowy Source File: migration.py
def get_migrated_apps():
"""
Returns all apps with migrations.
"""
for mapp in models.get_apps():
app = get_app(mapp)
if app:
yield app
3
Example 4
def emit_post_sync_signal(created_models, verbosity, interactive, db):
# Emit the post_sync signal for every application.
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
if verbosity >= 2:
print("Running post-sync handlers for application %s" % app_name)
models.signals.post_syncdb.send(sender=app, app=app,
created_models=created_models, verbosity=verbosity,
interactive=interactive, db=db)
3
Example 5
def create_project_sig():
"""
Create a dictionary representation of the apps in a given project.
"""
proj_sig = {
'__version__': 1,
}
for app in get_apps():
proj_sig[app.__name__.split('.')[-2]] = create_app_sig(app)
return proj_sig
3
Example 6
def __init__(self, stream_or_string, **options):
"""
Init this serializer given a stream or a string
"""
self.options = options
if isinstance(stream_or_string, basestring):
self.stream = StringIO(stream_or_string)
else:
self.stream = stream_or_string
# hack to make sure that the models have all been loaded before
# deserialization starts (otherwise subclass calls to get_model()
# and friends might fail...)
models.get_apps()
3
Example 7
Project: sentry Source File: urls.py
def init_all_applications():
"""
Forces import of all applications to ensure code is registered.
"""
from django.db.models import get_apps, get_models
for app in get_apps():
try:
get_models(app)
except Exception:
continue
3
Example 8
Project: django-data-tools Source File: loaddata.py
def get_app_fixtures(self):
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__)
return [os.path.join(os.path.dirname(path), 'fixtures') for path in app_module_paths]
3
Example 9
def load_initial_data(self, target, db='default'):
if target is None or target != target.migrations[-1]:
return
# Load initial data, if we ended up at target
if self.verbosity:
print " - Loading initial data for %s." % target.app_label()
# Override Django's get_apps call temporarily to only load from the
# current app
old_get_apps = models.get_apps
new_get_apps = lambda: [models.get_app(target.app_label())]
models.get_apps = new_get_apps
loaddata.get_apps = new_get_apps
try:
call_command('loaddata', 'initial_data', verbosity=self.verbosity, database=db)
finally:
models.get_apps = old_get_apps
loaddata.get_apps = old_get_apps
3
Example 10
def unmonkeypatch(self):
"""Undoes what monkeypatch did."""
from django.db import models
from django.conf import settings
models.get_apps = models.get_apps_old
settings.INSTALLED_APPS = settings.OLD_INSTALLED_APPS
self.redo_app_cache()
3
Example 11
def discover(self):
if self.discovered:
return
for app in get_apps():
# Try to import populate module in this app
app_name = app.__name__.split(".")[:-1]
module_name = ".".join(app_name + [POPULATE_MODULE_NAME])
try:
# Simply importing the module will register the models
populate_module = __import__(module_name, '', '', [''])
logging.debug("Registering populate module: %s" % module_name)
except ImportError:
pass
self.discovered = True
3
Example 12
Project: flow Source File: test.py
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = TestCaseSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return suite
3
Example 13
Project: hue Source File: sql.py
def emit_pre_sync_signal(create_models, verbosity, interactive, db):
# Emit the pre_sync signal for every application.
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
if verbosity >= 2:
print("Running pre-sync handlers for application %s" % app_name)
models.signals.pre_syncdb.send(sender=app, app=app,
create_models=create_models,
verbosity=verbosity,
interactive=interactive,
db=db)
3
Example 14
Project: satchmo Source File: __init__.py
def active_gateways():
"""Get a list of activated payment gateways, in the form of
[(module, config module name),...]
"""
from django.db import models
gateways = []
for app in models.get_apps():
if hasattr(app, 'PAYMENT_PROCESSOR'):
parts = app.__name__.split('.')[:-1]
module = ".".join(parts)
group = 'PAYMENT_%s' % parts[-1].upper()
gateways.append((module, group))
return gateways
3
Example 15
Project: satchmo Source File: __init__.py
def app_enabled(appname):
"""Check the app list to see if a named app is installed."""
from django.db import models
all_apps = {}
for app in models.get_apps():
n = app.__name__.split('.')[-2]
if n == appname:
return True
return False
3
Example 16
Project: satchmo Source File: __init__.py
def active_product_types():
"""Get a list of activated product modules, in the form of
[(module, config module name),...]
"""
from django.db import models
gateways = []
for app in models.get_apps():
if hasattr(app, 'SATCHMO_PRODUCT'):
parts = app.__name__.split('.')[:-1]
module = ".".join(parts)
if hasattr(app, 'get_product_types'):
subtypes = app.get_product_types()
for subtype in subtypes:
gateways.append((module, subtype))
else:
gateways.append((module, parts[-1].capitalize() + 'Product'))
return gateways
3
Example 17
def __init__(self, stream_or_string, **options):
"""
Init this serializer given a stream or a string
"""
self.options = options
if isinstance(stream_or_string, six.string_types):
self.stream = six.StringIO(stream_or_string)
else:
self.stream = stream_or_string
# hack to make sure that the models have all been loaded before
# deserialization starts (otherwise subclass calls to get_model()
# and friends might fail...)
models.get_apps()
3
Example 18
Project: feedsanitizer Source File: sql.py
def emit_post_sync_signal(created_models, verbosity, interactive, db):
# Emit the post_sync signal for every application.
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
if verbosity >= 2:
print "Running post-sync handlers for application", app_name
models.signals.post_syncdb.send(sender=app, app=app,
created_models=created_models, verbosity=verbosity,
interactive=interactive, db=db)
3
Example 19
Project: djangae Source File: fields.py
@memoized
def model_from_db_table(db_table):
for app in models.get_apps():
for model in models.get_models(app):
if model._meta.db_table == db_table:
return model
raise ValueError("Couldn't find model class for %s" % db_table)
3
Example 20
Project: betafarm Source File: base.py
def all_migrations(applications=None):
"""
Returns all Migrations for all `applications` that are migrated.
"""
if applications is None:
applications = models.get_apps()
for model_module in applications:
# The app they've passed is the models module - go up one level
app_path = ".".join(model_module.__name__.split(".")[:-1])
app = ask_for_it_by_name(app_path)
try:
yield Migrations(app)
except exceptions.NoMigrations:
pass
3
Example 21
def handle(self, *args, **options):
db_values = []
""" Taken from django.core.management.commands.syncdb"""
for app in models.get_apps():
model_list = models.get_models(app, include_auto_created=True)
"""Performance is not so important, we do it once... """
for m in model_list:
if hasattr(m, '_translation_fields'):
for x in m._translation_fields:
for y in m.objects.all():
db_values.append( getattr(y, x) )
#print db_values
f = file('db_translation.html', "w")
""" blocktrans and we dont have to worry about to escape the string etc."""
for v in db_values:
f.write('{%% blocktrans %%}%s{%% endblocktrans %%}\n' % smart_str(v))
f.close()
3
Example 22
def validate(cls, model):
""" Validates if model is well configured """
# Before we can introspect models, they need to be fully loaded so that
# inter-relations are set up correctly. We force that here.
models.get_apps()
# Call each option validation
validate_fields(cls, model)
3
Example 23
def installed_models(self, tables):
"Returns a set of all models represented by the provided list of table names."
from django.db import models, router
all_models = []
for app in models.get_apps():
for model in models.get_models(app):
if router.allow_syncdb(self.connection.alias, model):
all_models.append(model)
return set([m for m in all_models
if self.table_name_converter(m._meta.db_table) in map(self.table_name_converter, tables)
])
3
Example 24
def is_installed(app_name):
if django.VERSION[:2] < (1, 7):
from django.db.models import get_apps
return app_name in get_apps()
else:
from django.apps import apps
return apps.is_installed(app_name)
3
Example 25
Project: hunch-gift-app Source File: __init__.py
def installed_models(self, tables):
"Returns a set of all models represented by the provided list of table names."
from django.db import models, router
all_models = []
for app in models.get_apps():
for model in models.get_models(app):
if router.allow_syncdb(self.connection.alias, model):
all_models.append(model)
tables = map(self.table_name_converter, tables)
return set([
m for m in all_models
if self.table_name_converter(m._meta.db_table) in tables
])
3
Example 26
Project: GAE-Bulk-Mailer Source File: simple.py
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (unittest.TestCase,))
3
Example 27
def handle(self, *args, **options):
from django.contrib.auth.management import create_permissions
from django.db.models import get_apps, get_models
verbosity = int(options['verbosity'])
for app in get_apps():
create_permissions(app, None, verbosity)
3
Example 28
Project: django-cassandra-engine Source File: utils.py
def get_installed_apps():
"""
Return list of all installed apps
"""
if django.VERSION >= (1, 7):
from django.apps import apps
return [a.models_module for a in apps.get_app_configs()
if a.models_module is not None]
else:
from django.db import models
return models.get_apps()
0
Example 29
def handle_noargs(self, **options):
"""Handle the command."""
models = []
for app in get_apps():
models.extend(get_models(app))
OBJECT_LIMIT = 150
serializer = serializers.get_serializer("json")()
totalobjs = 0
for model in models:
totalobjs += model.objects.count()
prev_pct = -1
i = 0
self.stderr.write("Dump the database. This may take a while...\n")
self.stdout.write("# dbdump v1 - %s objects" % totalobjs)
for model in models:
count = model.objects.count()
j = 0
while j < count:
for obj in model.objects.all()[j:j + OBJECT_LIMIT].iterator():
value = serializer.serialize([obj])
if value != "[]":
self.stdout.write(value[1:-1]) # Skip the "[" and "]"
i += 1
pct = i * 100 / totalobjs
if pct != prev_pct:
self.stderr.write(" [%s%%]\r" % pct)
self.stderr.flush()
prev_pct = pct
j += OBJECT_LIMIT
self.stderr.write("\nDone.\n")
0
Example 30
Project: GAE-Bulk-Mailer Source File: loaddata.py
def handle(self, *fixture_labels, **options):
ignore = options.get('ignore')
using = options.get('database')
connection = connections[using]
if not len(fixture_labels):
raise CommandError(
"No database fixture specified. Please provide the path of at "
"least one fixture in the command line."
)
verbosity = int(options.get('verbosity'))
show_traceback = options.get('traceback')
# commit is a stealth option - it isn't really useful as
# a command line option, but it can be useful when invoking
# loaddata from within another script.
# If commit=True, loaddata will use its own transaction;
# if commit=False, the data load SQL will become part of
# the transaction in place when loaddata was invoked.
commit = options.get('commit', True)
# Keep a count of the installed objects and fixtures
fixture_count = 0
loaded_object_count = 0
fixture_object_count = 0
models = set()
humanize = lambda dirname: "'%s'" % dirname if dirname else 'absolute path'
# Get a cursor (even though we don't need one yet). This has
# the side effect of initializing the test database (if
# it isn't already initialized).
cursor = connection.cursor()
# Start transaction management. All fixtures are installed in a
# single transaction to ensure that all references are resolved.
if commit:
transaction.commit_unless_managed(using=using)
transaction.enter_transaction_management(using=using)
transaction.managed(True, using=using)
class SingleZipReader(zipfile.ZipFile):
def __init__(self, *args, **kwargs):
zipfile.ZipFile.__init__(self, *args, **kwargs)
if settings.DEBUG:
assert len(self.namelist()) == 1, "Zip-compressed fixtures must contain only one file."
def read(self):
return zipfile.ZipFile.read(self, self.namelist()[0])
compression_types = {
None: open,
'gz': gzip.GzipFile,
'zip': SingleZipReader
}
if has_bz2:
compression_types['bz2'] = bz2.BZ2File
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(upath(path))
else:
# It's a models.py module
app_module_paths.append(upath(app.__file__))
app_fixtures = [os.path.join(os.path.dirname(path), 'fixtures') for path in app_module_paths]
try:
with connection.constraint_checks_disabled():
for fixture_label in fixture_labels:
parts = fixture_label.split('.')
if len(parts) > 1 and parts[-1] in compression_types:
compression_formats = [parts[-1]]
parts = parts[:-1]
else:
compression_formats = compression_types.keys()
if len(parts) == 1:
fixture_name = parts[0]
formats = serializers.get_public_serializer_formats()
else:
fixture_name, format = '.'.join(parts[:-1]), parts[-1]
if format in serializers.get_public_serializer_formats():
formats = [format]
else:
formats = []
if formats:
if verbosity >= 2:
self.stdout.write("Loading '%s' fixtures..." % fixture_name)
else:
raise CommandError(
"Problem installing fixture '%s': %s is not a known serialization format." %
(fixture_name, format))
if os.path.isabs(fixture_name):
fixture_dirs = [fixture_name]
else:
fixture_dirs = app_fixtures + list(settings.FIXTURE_DIRS) + ['']
for fixture_dir in fixture_dirs:
if verbosity >= 2:
self.stdout.write("Checking %s for fixtures..." % humanize(fixture_dir))
label_found = False
for combo in product([using, None], formats, compression_formats):
database, format, compression_format = combo
file_name = '.'.join(
p for p in [
fixture_name, database, format, compression_format
]
if p
)
if verbosity >= 3:
self.stdout.write("Trying %s for %s fixture '%s'..." % \
(humanize(fixture_dir), file_name, fixture_name))
full_path = os.path.join(fixture_dir, file_name)
open_method = compression_types[compression_format]
try:
fixture = open_method(full_path, 'r')
except IOError:
if verbosity >= 2:
self.stdout.write("No %s fixture '%s' in %s." % \
(format, fixture_name, humanize(fixture_dir)))
else:
try:
if label_found:
raise CommandError("Multiple fixtures named '%s' in %s. Aborting." %
(fixture_name, humanize(fixture_dir)))
fixture_count += 1
objects_in_fixture = 0
loaded_objects_in_fixture = 0
if verbosity >= 2:
self.stdout.write("Installing %s fixture '%s' from %s." % \
(format, fixture_name, humanize(fixture_dir)))
objects = serializers.deserialize(format, fixture, using=using, ignorenonexistent=ignore)
for obj in objects:
objects_in_fixture += 1
if router.allow_syncdb(using, obj.object.__class__):
loaded_objects_in_fixture += 1
models.add(obj.object.__class__)
try:
obj.save(using=using)
except (DatabaseError, IntegrityError) as e:
e.args = ("Could not load %(app_label)s.%(object_name)s(pk=%(pk)s): %(error_msg)s" % {
'app_label': obj.object._meta.app_label,
'object_name': obj.object._meta.object_name,
'pk': obj.object.pk,
'error_msg': force_text(e)
},)
raise
loaded_object_count += loaded_objects_in_fixture
fixture_object_count += objects_in_fixture
label_found = True
except Exception as e:
if not isinstance(e, CommandError):
e.args = ("Problem installing fixture '%s': %s" % (full_path, e),)
raise
finally:
fixture.close()
# If the fixture we loaded contains 0 objects, assume that an
# error was encountered during fixture loading.
if objects_in_fixture == 0:
raise CommandError(
"No fixture data found for '%s'. (File format may be invalid.)" %
(fixture_name))
# Since we disabled constraint checks, we must manually check for
# any invalid keys that might have been added
table_names = [model._meta.db_table for model in models]
try:
connection.check_constraints(table_names=table_names)
except Exception as e:
e.args = ("Problem installing fixtures: %s" % e,)
raise
except (SystemExit, KeyboardInterrupt):
raise
except Exception as e:
if commit:
transaction.rollback(using=using)
transaction.leave_transaction_management(using=using)
raise
# If we found even one object in a fixture, we need to reset the
# database sequences.
if loaded_object_count > 0:
sequence_sql = connection.ops.sequence_reset_sql(no_style(), models)
if sequence_sql:
if verbosity >= 2:
self.stdout.write("Resetting sequences\n")
for line in sequence_sql:
cursor.execute(line)
if commit:
transaction.commit(using=using)
transaction.leave_transaction_management(using=using)
if verbosity >= 1:
if fixture_object_count == loaded_object_count:
self.stdout.write("Installed %d object(s) from %d fixture(s)" % (
loaded_object_count, fixture_count))
else:
self.stdout.write("Installed %d object(s) (of %d) from %d fixture(s)" % (
loaded_object_count, fixture_object_count, fixture_count))
# Close the DB connection. This is required as a workaround for an
# edge case in MySQL: if the same connection is used to
# create tables, load data, and query, the query can return
# incorrect results. See Django #7572, MySQL #37735.
if commit:
connection.close()
0
Example 31
Project: reviewboard Source File: loaddb.py
def handle(self, *args, **options):
"""Handle the command."""
if len(args) != 1:
raise CommandError("You must specify a filename on the command "
"line.")
filename = args[0]
if not os.path.exists(filename):
raise CommandError("%s does not exist." % filename)
try:
import django_reset
except ImportError:
raise CommandError("Before using this command, you need to "
"install the 'django-reset' package")
confirm = input("""
This will wipe out your existing database prior to loading. It is highly
recommended that you have a full SQL database dump in case things go wrong.
You should only use this if you're migrating from one type of database to
another, with the same version of Review Board on each.
Are you sure you want to continue?"
Type 'yes' to continue, or 'no' to cancel: """)
if confirm != 'yes':
return
apps = [app.__name__.split('.')[-2] for app in get_apps()]
os.system('./reviewboard/manage.py reset --noinput %s'
% ' '.join(apps))
transaction_setup = False
try:
with open(filename, 'r') as f:
line = f.readline()
m = re.match("^# dbdump v(\d+) - (\d+) objects$", line)
if not m:
raise CommandError("Unknown dump format\n")
version = int(m.group(1))
totalobjs = int(m.group(2))
i = 0
prev_pct = -1
if version != 1:
raise CommandError("Unknown dump version\n")
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
transaction_setup = True
self.stdout.write("Importing new style dump format (v%s)" %
version)
for line in f:
if line[0] == "{":
for obj in serializers.deserialize("json",
"[%s]" % line):
try:
obj.save()
except Exception as e:
self.stderr.write("Error: %s\n" % e)
self.stderr.write("Line %s: '%s'" % (i, line))
elif line[0] != "#":
self.stderr.write("Junk data on line %s" % i)
db.reset_queries()
i += 1
pct = (i * 100 / totalobjs)
if pct != prev_pct:
self.stdout.write(" [%s%%]\r" % pct)
self.stdout.flush()
prev_pct = pct
transaction.commit()
transaction.leave_transaction_management()
except Exception as e:
raise CommandError("Problem installing '%s': %s\n" % (filename, e))
if transaction_setup:
transaction.rollback()
transaction.leave_transaction_management()
self.stdout.write('\nDone.')
0
Example 32
Project: talk.org Source File: syncdb.py
def handle_noargs(self, **options):
from django.db import connection, transaction, models
from django.conf import settings
from django.core.management.sql import table_list, installed_models, sql_model_create, sql_for_pending_references, many_to_many_sql_for_model, custom_sql_for_model, sql_indexes_for_model, emit_post_sync_signal
verbosity = int(options.get('verbosity', 1))
interactive = options.get('interactive')
self.style = no_style()
# Import the 'management' module within each installed app, to register
# dispatcher events.
for app_name in settings.INSTALLED_APPS:
try:
__import__(app_name + '.management', {}, {}, [''])
except ImportError, exc:
if not exc.args[0].startswith('No module named management'):
raise
cursor = connection.cursor()
if connection.features.uses_case_insensitive_names:
table_name_converter = lambda x: x.upper()
else:
table_name_converter = lambda x: x
# Get a list of all existing database tables, so we know what needs to
# be added.
tables = [table_name_converter(name) for name in table_list()]
# Get a list of already installed *models* so that references work right.
seen_models = installed_models(tables)
created_models = set()
pending_references = {}
# Create the tables for each model
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
model_list = models.get_models(app)
for model in model_list:
# Create the model's database table, if it doesn't already exist.
if verbosity >= 2:
print "Processing %s.%s model" % (app_name, model._meta.object_name)
if table_name_converter(model._meta.db_table) in tables:
continue
sql, references = sql_model_create(model, self.style, seen_models)
seen_models.add(model)
created_models.add(model)
for refto, refs in references.items():
pending_references.setdefault(refto, []).extend(refs)
if refto in seen_models:
sql.extend(sql_for_pending_references(refto, self.style, pending_references))
sql.extend(sql_for_pending_references(model, self.style, pending_references))
if verbosity >= 1:
print "Creating table %s" % model._meta.db_table
for statement in sql:
cursor.execute(statement)
tables.append(table_name_converter(model._meta.db_table))
# Create the m2m tables. This must be done after all tables have been created
# to ensure that all referred tables will exist.
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
model_list = models.get_models(app)
for model in model_list:
if model in created_models:
sql = many_to_many_sql_for_model(model, self.style)
if sql:
if verbosity >= 2:
print "Creating many-to-many tables for %s.%s model" % (app_name, model._meta.object_name)
for statement in sql:
cursor.execute(statement)
transaction.commit_unless_managed()
# Send the post_syncdb signal, so individual apps can do whatever they need
# to do at this point.
emit_post_sync_signal(created_models, verbosity, interactive)
# Install custom SQL for the app (but only if this
# is a model we've just created)
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
for model in models.get_models(app):
if model in created_models:
custom_sql = custom_sql_for_model(model)
if custom_sql:
if verbosity >= 1:
print "Installing custom SQL for %s.%s model" % (app_name, model._meta.object_name)
try:
for sql in custom_sql:
cursor.execute(sql)
except Exception, e:
sys.stderr.write("Failed to install custom SQL for %s.%s model: %s" % \
(app_name, model._meta.object_name, e))
transaction.rollback_unless_managed()
else:
transaction.commit_unless_managed()
# Install SQL indicies for all newly created models
for app in models.get_apps():
app_name = app.__name__.split('.')[-2]
for model in models.get_models(app):
if model in created_models:
index_sql = sql_indexes_for_model(model, self.style)
if index_sql:
if verbosity >= 1:
print "Installing index for %s.%s model" % (app_name, model._meta.object_name)
try:
for sql in index_sql:
cursor.execute(sql)
except Exception, e:
sys.stderr.write("Failed to install index for %s.%s model: %s" % \
(app_name, model._meta.object_name, e))
transaction.rollback_unless_managed()
else:
transaction.commit_unless_managed()
# Install the 'initial_data' fixture, using format discovery
from django.core.management import call_command
call_command('loaddata', 'initial_data', verbosity=verbosity)
0
Example 33
def handle_noargs(self, **options):
# Work out what uses migrations and so doesn't need syncing
apps_needing_sync = []
apps_migrated = []
for app in models.get_apps():
app_name = get_app_name(app)
migrations = migration.get_app(app)
if migrations is None:
apps_needing_sync.append(app_name)
else:
# This is a migrated app, leave it
apps_migrated.append(app_name)
verbosity = int(options.get('verbosity', 0))
# Run syncdb on only the ones needed
if verbosity > 0:
print "Syncing..."
old_installed, settings.INSTALLED_APPS = settings.INSTALLED_APPS, apps_needing_sync
old_app_store, cache.app_store = cache.app_store, SortedDict([
(k, v) for (k, v) in cache.app_store.items()
if get_app_name(k) in apps_needing_sync
])
syncdb.Command().execute(**options)
settings.INSTALLED_APPS = old_installed
cache.app_store = old_app_store
# Migrate if needed
if options.get('migrate', True):
if verbosity > 0:
print "Migrating..."
management.call_command('migrate', **options)
# Be obvious about what we did
if verbosity > 0:
print "\nSynced:\n > %s" % "\n > ".join(apps_needing_sync)
if options.get('migrate', True):
if verbosity > 0:
print "\nMigrated:\n - %s" % "\n - ".join(apps_migrated)
else:
if verbosity > 0:
print "\nNot synced (use migrations):\n - %s" % "\n - ".join(apps_migrated)
print "(use ./manage.py migrate to migrate these)"
0
Example 34
Project: GAE-Bulk-Mailer Source File: python.py
def Deserializer(object_list, **options):
"""
Deserialize simple Python objects back into Django ORM instances.
It's expected that you pass the Python objects themselves (instead of a
stream or a string) to the constructor
"""
db = options.pop('using', DEFAULT_DB_ALIAS)
ignore = options.pop('ignorenonexistent', False)
models.get_apps()
for d in object_list:
# Look up the model and starting build a dict of data for it.
Model = _get_model(d["model"])
data = {Model._meta.pk.attname: Model._meta.pk.to_python(d["pk"])}
m2m_data = {}
model_fields = Model._meta.get_all_field_names()
# Handle each field
for (field_name, field_value) in six.iteritems(d["fields"]):
if ignore and field_name not in model_fields:
# skip fields no longer on model
continue
if isinstance(field_value, str):
field_value = smart_text(field_value, options.get("encoding", settings.DEFAULT_CHARSET), strings_only=True)
field = Model._meta.get_field(field_name)
# Handle M2M relations
if field.rel and isinstance(field.rel, models.ManyToManyRel):
if hasattr(field.rel.to._default_manager, 'get_by_natural_key'):
def m2m_convert(value):
if hasattr(value, '__iter__') and not isinstance(value, six.text_type):
return field.rel.to._default_manager.db_manager(db).get_by_natural_key(*value).pk
else:
return smart_text(field.rel.to._meta.pk.to_python(value))
else:
m2m_convert = lambda v: smart_text(field.rel.to._meta.pk.to_python(v))
m2m_data[field.name] = [m2m_convert(pk) for pk in field_value]
# Handle FK fields
elif field.rel and isinstance(field.rel, models.ManyToOneRel):
if field_value is not None:
if hasattr(field.rel.to._default_manager, 'get_by_natural_key'):
if hasattr(field_value, '__iter__') and not isinstance(field_value, six.text_type):
obj = field.rel.to._default_manager.db_manager(db).get_by_natural_key(*field_value)
value = getattr(obj, field.rel.field_name)
# If this is a natural foreign key to an object that
# has a FK/O2O as the foreign key, use the FK value
if field.rel.to._meta.pk.rel:
value = value.pk
else:
value = field.rel.to._meta.get_field(field.rel.field_name).to_python(field_value)
data[field.attname] = value
else:
data[field.attname] = field.rel.to._meta.get_field(field.rel.field_name).to_python(field_value)
else:
data[field.attname] = None
# Handle all other fields
else:
data[field.name] = field.to_python(field_value)
yield base.DeserializedObject(Model(**data), m2m_data)
0
Example 35
Project: snowy Source File: migration.py
def migrate_app(app, target_name=None, resolve_mode=None, fake=False, db_dry_run=False, yes=False, silent=False, load_inital_data=False, skip=False):
app_name = get_app_name(app)
db.debug = not silent
# If any of their app names in the DB contain a ., they're 0.2 or below, so migrate em
longuns = MigrationHistory.objects.filter(app_name__contains=".")
if longuns:
for mh in longuns:
mh.app_name = short_from_long(mh.app_name)
mh.save()
if not silent:
print "- Updated your South 0.2 database."
# Find out what delightful migrations we have
tree = dependency_tree()
migrations = get_migration_names(app)
# If there aren't any, quit quizically
if not migrations:
if not silent:
print "? You have no migrations for the '%s' app. You might want some." % app_name
return
if target_name not in migrations and target_name not in ["zero", None]:
matches = [x for x in migrations if x.startswith(target_name)]
if len(matches) == 1:
target = migrations.index(matches[0]) + 1
if not silent:
print " - Soft matched migration %s to %s." % (
target_name,
matches[0]
)
target_name = matches[0]
elif len(matches) > 1:
if not silent:
print " - Prefix %s matches more than one migration:" % target_name
print " " + "\n ".join(matches)
return
else:
if not silent:
print " ! '%s' is not a migration." % target_name
return
# Check there's no strange ones in the database
ghost_migrations = []
for m in MigrationHistory.objects.filter(applied__isnull = False):
try:
if get_app(m.app_name) not in tree or m.migration not in tree[get_app(m.app_name)]:
ghost_migrations.append(m)
except ImproperlyConfigured:
pass
if ghost_migrations:
if not silent:
print " ! These migrations are in the database but not on disk:"
print " - " + "\n - ".join(["%s: %s" % (x.app_name, x.migration) for x in ghost_migrations])
print " ! I'm not trusting myself; fix this yourself by fiddling"
print " ! with the south_migrationhistory table."
return
# Say what we're doing
if not silent:
print "Running migrations for %s:" % app_name
# Get the forwards and reverse dependencies for this target
if target_name == None:
target_name = migrations[-1]
if target_name == "zero":
forwards = []
backwards = needed_before_backwards(tree, app, migrations[0]) + [(app, migrations[0])]
else:
forwards = needed_before_forwards(tree, app, target_name) + [(app, target_name)]
# When migrating backwards we want to remove up to and including
# the next migration up in this app (not the next one, that includes other apps)
try:
migration_before_here = migrations[migrations.index(target_name)+1]
backwards = needed_before_backwards(tree, app, migration_before_here) + [(app, migration_before_here)]
except IndexError:
backwards = []
# Get the list of currently applied migrations from the db
current_migrations = []
for m in MigrationHistory.objects.filter(applied__isnull = False):
try:
current_migrations.append((get_app(m.app_name), m.migration))
except ImproperlyConfigured:
pass
direction = None
bad = False
# Work out the direction
applied_for_this_app = list(MigrationHistory.objects.filter(app_name=app_name, applied__isnull=False).order_by("migration"))
if target_name == "zero":
direction = -1
elif not applied_for_this_app:
direction = 1
elif migrations.index(target_name) > migrations.index(applied_for_this_app[-1].migration):
direction = 1
elif migrations.index(target_name) < migrations.index(applied_for_this_app[-1].migration):
direction = -1
else:
direction = None
# Is the whole forward branch applied?
missing = [step for step in forwards if step not in current_migrations]
# If they're all applied, we only know it's not backwards
if not missing:
direction = None
# If the remaining migrations are strictly a right segment of the forwards
# trace, we just need to go forwards to our target (and check for badness)
else:
problems = forwards_problems(tree, forwards, current_migrations, silent=silent)
if problems:
bad = True
direction = 1
# What about the whole backward trace then?
if not bad:
missing = [step for step in backwards if step not in current_migrations]
# If they're all missing, stick with the forwards decision
if missing == backwards:
pass
# If what's missing is a strict left segment of backwards (i.e.
# all the higher migrations) then we need to go backwards
else:
problems = backwards_problems(tree, backwards, current_migrations, silent=silent)
if problems:
bad = True
direction = -1
if bad and resolve_mode not in ['merge'] and not skip:
if not silent:
print " ! Inconsistent migration history"
print " ! The following options are available:"
print " --merge: will just attempt the migration ignoring any potential dependency conflicts."
sys.exit(1)
if direction == 1:
if not silent:
print " - Migrating forwards to %s." % target_name
try:
for mapp, mname in forwards:
if (mapp, mname) not in current_migrations:
result = run_forwards(mapp, [mname], fake=fake, db_dry_run=db_dry_run, silent=silent)
if result is False: # The migrations errored, but nicely.
return False
finally:
# Call any pending post_syncdb signals
db.send_pending_create_signals()
# Now load initial data, only if we're really doing things and ended up at current
if not fake and not db_dry_run and load_inital_data and target_name == migrations[-1]:
print " - Loading initial data for %s." % app_name
# Override Django's get_apps call temporarily to only load from the
# current app
old_get_apps, models.get_apps = (
models.get_apps,
lambda: [models.get_app(get_app_name(app))],
)
# Load the initial fixture
call_command('loaddata', 'initial_data', verbosity=1)
# Un-override
models.get_apps = old_get_apps
elif direction == -1:
if not silent:
print " - Migrating backwards to just after %s." % target_name
for mapp, mname in backwards:
if (mapp, mname) in current_migrations:
run_backwards(mapp, [mname], fake=fake, db_dry_run=db_dry_run, silent=silent)
else:
if not silent:
print "- Nothing to migrate."
0
Example 36
Project: talk.org Source File: adminapplist.py
def render(self, context):
from django.db import models
from django.utils.text import capfirst
app_list = []
user = context['user']
for app in models.get_apps():
# Determine the app_label.
app_models = get_models(app)
if not app_models:
continue
app_label = app_models[0]._meta.app_label
has_module_perms = user.has_module_perms(app_label)
if has_module_perms:
model_list = []
for m in app_models:
if m._meta.admin:
perms = {
'add': user.has_perm("%s.%s" % (app_label, m._meta.get_add_permission())),
'change': user.has_perm("%s.%s" % (app_label, m._meta.get_change_permission())),
'delete': user.has_perm("%s.%s" % (app_label, m._meta.get_delete_permission())),
}
# Check whether user has any perm for this module.
# If so, add the module to the model_list.
if True in perms.values():
model_list.append({
'name': force_unicode(capfirst(m._meta.verbose_name_plural)),
'admin_url': mark_safe(u'%s/%s/' % (force_unicode(app_label), m.__name__.lower())),
'perms': perms,
})
if model_list:
# Sort using verbose decorate-sort-undecorate pattern
# instead of key argument to sort() for python 2.3 compatibility
decorated = [(x['name'], x) for x in model_list]
decorated.sort()
model_list = [x for key, x in decorated]
app_list.append({
'name': app_label.title(),
'has_module_perms': has_module_perms,
'models': model_list,
})
context[self.varname] = app_list
return ''
0
Example 37
Project: talk.org Source File: simple.py
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
old_name = settings.DATABASE_NAME
create_test_db(verbosity, autoclobber=not interactive)
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
destroy_test_db(old_name, verbosity)
teardown_test_environment()
return len(result.failures) + len(result.errors)
0
Example 38
def validate(cls, model):
"""
Does basic ModelAdmin option validation. Calls custom validation
classmethod in the end if it is provided in cls. The signature of the
custom validation classmethod should be: def validate(cls, model).
"""
# Before we can introspect models, they need to be fully loaded so that
# inter-relations are set up correctly. We force that here.
models.get_apps()
opts = model._meta
validate_base(cls, model)
# list_display
if hasattr(cls, 'list_display'):
check_isseq(cls, 'list_display', cls.list_display)
for idx, field in enumerate(cls.list_display):
if not callable(field):
if not hasattr(cls, field):
if not hasattr(model, field):
try:
opts.get_field(field)
except models.FieldDoesNotExist:
raise ImproperlyConfigured("%s.list_display[%d], %r is not a callable or an attribute of %r or found in the model %r."
% (cls.__name__, idx, field, cls.__name__, model._meta.object_name))
else:
# getattr(model, field) could be an X_RelatedObjectsDescriptor
f = fetch_attr(cls, model, opts, "list_display[%d]" % idx, field)
if isinstance(f, models.ManyToManyField):
raise ImproperlyConfigured("'%s.list_display[%d]', '%s' is a ManyToManyField which is not supported."
% (cls.__name__, idx, field))
# list_display_links
if hasattr(cls, 'list_display_links'):
check_isseq(cls, 'list_display_links', cls.list_display_links)
for idx, field in enumerate(cls.list_display_links):
if field not in cls.list_display:
raise ImproperlyConfigured("'%s.list_display_links[%d]' "
"refers to '%s' which is not defined in 'list_display'."
% (cls.__name__, idx, field))
# list_filter
if hasattr(cls, 'list_filter'):
check_isseq(cls, 'list_filter', cls.list_filter)
for idx, item in enumerate(cls.list_filter):
# There are three options for specifying a filter:
# 1: 'field' - a basic field filter, possibly w/ relationships (eg, 'field__rel')
# 2: ('field', SomeFieldListFilter) - a field-based list filter class
# 3: SomeListFilter - a non-field list filter class
if callable(item) and not isinstance(item, models.Field):
# If item is option 3, it should be a ListFilter...
if not issubclass(item, ListFilter):
raise ImproperlyConfigured("'%s.list_filter[%d]' is '%s'"
" which is not a descendant of ListFilter."
% (cls.__name__, idx, item.__name__))
# ... but not a FieldListFilter.
if issubclass(item, FieldListFilter):
raise ImproperlyConfigured("'%s.list_filter[%d]' is '%s'"
" which is of type FieldListFilter but is not"
" associated with a field name."
% (cls.__name__, idx, item.__name__))
else:
if isinstance(item, (tuple, list)):
# item is option #2
field, list_filter_class = item
if not issubclass(list_filter_class, FieldListFilter):
raise ImproperlyConfigured("'%s.list_filter[%d][1]'"
" is '%s' which is not of type FieldListFilter."
% (cls.__name__, idx, list_filter_class.__name__))
else:
# item is option #1
field = item
# Validate the field string
try:
get_fields_from_path(model, field)
except (NotRelationField, FieldDoesNotExist):
raise ImproperlyConfigured("'%s.list_filter[%d]' refers to '%s'"
" which does not refer to a Field."
% (cls.__name__, idx, field))
# list_per_page = 100
if hasattr(cls, 'list_per_page') and not isinstance(cls.list_per_page, int):
raise ImproperlyConfigured("'%s.list_per_page' should be a integer."
% cls.__name__)
# list_max_show_all
if hasattr(cls, 'list_max_show_all') and not isinstance(cls.list_max_show_all, int):
raise ImproperlyConfigured("'%s.list_max_show_all' should be an integer."
% cls.__name__)
# list_editable
if hasattr(cls, 'list_editable') and cls.list_editable:
check_isseq(cls, 'list_editable', cls.list_editable)
for idx, field_name in enumerate(cls.list_editable):
try:
field = opts.get_field_by_name(field_name)[0]
except models.FieldDoesNotExist:
raise ImproperlyConfigured("'%s.list_editable[%d]' refers to a "
"field, '%s', not defined on %s.%s."
% (cls.__name__, idx, field_name, model._meta.app_label, model.__name__))
if field_name not in cls.list_display:
raise ImproperlyConfigured("'%s.list_editable[%d]' refers to "
"'%s' which is not defined in 'list_display'."
% (cls.__name__, idx, field_name))
if field_name in cls.list_display_links:
raise ImproperlyConfigured("'%s' cannot be in both '%s.list_editable'"
" and '%s.list_display_links'"
% (field_name, cls.__name__, cls.__name__))
if not cls.list_display_links and cls.list_display[0] in cls.list_editable:
raise ImproperlyConfigured("'%s.list_editable[%d]' refers to"
" the first field in list_display, '%s', which can't be"
" used unless list_display_links is set."
% (cls.__name__, idx, cls.list_display[0]))
if not field.editable:
raise ImproperlyConfigured("'%s.list_editable[%d]' refers to a "
"field, '%s', which isn't editable through the admin."
% (cls.__name__, idx, field_name))
# search_fields = ()
if hasattr(cls, 'search_fields'):
check_isseq(cls, 'search_fields', cls.search_fields)
# date_hierarchy = None
if cls.date_hierarchy:
f = get_field(cls, model, opts, 'date_hierarchy', cls.date_hierarchy)
if not isinstance(f, (models.DateField, models.DateTimeField)):
raise ImproperlyConfigured("'%s.date_hierarchy is "
"neither an instance of DateField nor DateTimeField."
% cls.__name__)
# ordering = None
if cls.ordering:
check_isseq(cls, 'ordering', cls.ordering)
for idx, field in enumerate(cls.ordering):
if field == '?' and len(cls.ordering) != 1:
raise ImproperlyConfigured("'%s.ordering' has the random "
"ordering marker '?', but contains other fields as "
"well. Please either remove '?' or the other fields."
% cls.__name__)
if field == '?':
continue
if field.startswith('-'):
field = field[1:]
# Skip ordering in the format field1__field2 (FIXME: checking
# this format would be nice, but it's a little fiddly).
if '__' in field:
continue
get_field(cls, model, opts, 'ordering[%d]' % idx, field)
if hasattr(cls, "readonly_fields"):
check_readonly_fields(cls, model, opts)
# list_select_related = False
# save_as = False
# save_on_top = False
for attr in ('list_select_related', 'save_as', 'save_on_top'):
if not isinstance(getattr(cls, attr), bool):
raise ImproperlyConfigured("'%s.%s' should be a boolean."
% (cls.__name__, attr))
# inlines = []
if hasattr(cls, 'inlines'):
check_isseq(cls, 'inlines', cls.inlines)
for idx, inline in enumerate(cls.inlines):
if not issubclass(inline, BaseModelAdmin):
raise ImproperlyConfigured("'%s.inlines[%d]' does not inherit "
"from BaseModelAdmin." % (cls.__name__, idx))
if not inline.model:
raise ImproperlyConfigured("'model' is a required attribute "
"of '%s.inlines[%d]'." % (cls.__name__, idx))
if not issubclass(inline.model, models.Model):
raise ImproperlyConfigured("'%s.inlines[%d].model' does not "
"inherit from models.Model." % (cls.__name__, idx))
validate_base(inline, inline.model)
validate_inline(inline, cls, model)
0
Example 39
Project: hubplus Source File: evolve.py
def handle(self, *app_labels, **options):
verbosity = int(options['verbosity'])
interactive = options['interactive']
execute = options['execute']
compile_sql = options['compile_sql']
hint = options['hint']
purge = options['purge']
# Use the list of all apps, unless app labels are specified.
if app_labels:
if execute:
raise CommandError('Cannot specify an application name when executing evolutions.')
try:
app_list = [get_app(app_label) for app_label in app_labels]
except (ImproperlyConfigured, ImportError), e:
raise CommandError("%s. Are you sure your INSTALLED_APPS setting is correct?" % e)
else:
app_list = get_apps()
# Iterate over all applications running the mutations
evolution_required = False
simulated = True
sql = []
new_evolutions = []
current_proj_sig = create_project_sig()
current_signature = pickle.dumps(current_proj_sig)
try:
latest_version = Version.objects.latest('when')
database_sig = pickle.loads(str(latest_version.signature))
diff = Diff(database_sig, current_proj_sig)
except Evolution.DoesNotExist:
print self.style.ERROR("Can't evolve yet. Need to set an evolution baseline.")
sys.exit(1)
try:
for app in app_list:
app_label = app.__name__.split('.')[-2]
if hint:
evolutions = []
hinted_evolution = diff.evolution()
mutations = hinted_evolution.get(app_label,[])
else:
evolutions = get_unapplied_evolutions(app)
mutations = get_mutations(app, evolutions)
if mutations:
app_sql = ['-- Evolve application %s' % app_label]
evolution_required = True
for mutation in mutations:
# Only compile SQL if we want to show it
if compile_sql or execute:
app_sql.extend(mutation.mutate(app_label, database_sig))
# Now run the simulation, which will modify the signatures
try:
mutation.simulate(app_label, database_sig)
except CannotSimulate:
simulated = False
new_evolutions.extend(Evolution(app_label=app_label, label=label)
for label in evolutions)
if not execute:
if compile_sql:
write_sql(app_sql)
else:
print '#----- Evolution for %s' % app_label
print 'from django_evolution.mutations import *'
print 'from django.db import models'
print
print 'MUTATIONS = ['
print ' ',
print ',\n '.join(unicode(m) for m in mutations)
print ']'
print '#----------------------'
sql.extend(app_sql)
else:
if verbosity > 1:
print 'Application %s is up to date' % app_label
# Process the purged applications if requested to do so.
if purge:
if diff.deleted:
evolution_required = True
delete_app = DeleteApplication()
purge_sql = []
for app_label in diff.deleted:
if compile_sql or execute:
purge_sql.append('-- Purge application %s' % app_label)
purge_sql.extend(delete_app.mutate(app_label, database_sig))
delete_app.simulate(app_label, database_sig)
if not execute:
if compile_sql:
write_sql(purge_sql)
else:
print 'The following application(s) can be purged:'
for app_label in diff.deleted:
print ' ', app_label
print
sql.extend(purge_sql)
else:
if verbosity > 1:
print 'No applications need to be purged.'
except EvolutionException, e:
print self.style.ERROR(e)
sys.exit(1)
if simulated:
diff = Diff(database_sig, current_proj_sig)
if not diff.is_empty(not purge):
if hint:
print self.style.ERROR('Your models contain changes that Django Evolution cannot resolve automatically.')
print 'This is probably due to a currently unimplemented mutation type.'
print 'You will need to manually construct a mutation to resolve the remaining changes.'
else:
print self.style.ERROR('The stored evolutions do not completely resolve all model changes.')
print 'Run `./manage.py evolve --hint` to see a suggestion for the changes required.'
print
print 'The following are the changes that could not be resolved:'
print diff
sys.exit(1)
else:
print self.style.NOTICE('Evolution could not be simulated, possibly due to raw SQL mutations')
if evolution_required:
if execute:
# Now that we've worked out the mutations required,
# and we know they simulate OK, run the evolutions
if interactive:
confirm = raw_input("""
You have requested a database evolution. This will alter tables
and data currently in the %r database, and may result in
IRREVERSABLE DATA LOSS. Evolutions should be *thoroughly* reviewed
prior to execution.
Are you sure you want to execute the evolutions?
Type 'yes' to continue, or 'no' to cancel: """ % settings.DATABASE_NAME)
else:
confirm = 'yes'
if confirm.lower() == 'yes':
# Begin Transaction
transaction.enter_transaction_management()
transaction.managed(True)
cursor = connection.cursor()
try:
# Perform the SQL
execute_sql(cursor, sql)
# Now update the evolution table
version = Version(signature=current_signature)
version.save()
for evolution in new_evolutions:
evolution.version = version
evolution.save()
transaction.commit()
except Exception, ex:
transaction.rollback()
print self.style.ERROR('Error applying evolution: %s' % str(ex))
sys.exit(1)
transaction.leave_transaction_management()
if verbosity > 0:
print 'Evolution successful.'
else:
print self.style.ERROR('Evolution cancelled.')
elif not compile_sql:
if verbosity > 0:
if simulated:
print "Trial evolution successful."
print "Run './manage.py evolve %s--execute' to apply evolution." % (hint and '--hint ' or '')
else:
if verbosity > 0:
print 'No evolution required.'
0
Example 40
Project: GAE-Bulk-Mailer Source File: dumpdata.py
def handle(self, *app_labels, **options):
from django.db.models import get_app, get_apps, get_model
format = options.get('format')
indent = options.get('indent')
using = options.get('database')
excludes = options.get('exclude')
show_traceback = options.get('traceback')
use_natural_keys = options.get('use_natural_keys')
use_base_manager = options.get('use_base_manager')
excluded_apps = set()
excluded_models = set()
for exclude in excludes:
if '.' in exclude:
app_label, model_name = exclude.split('.', 1)
model_obj = get_model(app_label, model_name)
if not model_obj:
raise CommandError('Unknown model in excludes: %s' % exclude)
excluded_models.add(model_obj)
else:
try:
app_obj = get_app(exclude)
excluded_apps.add(app_obj)
except ImproperlyConfigured:
raise CommandError('Unknown app in excludes: %s' % exclude)
if len(app_labels) == 0:
app_list = SortedDict((app, None) for app in get_apps() if app not in excluded_apps)
else:
app_list = SortedDict()
for label in app_labels:
try:
app_label, model_label = label.split('.')
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" % app_label)
if app in excluded_apps:
continue
model = get_model(app_label, model_label)
if model is None:
raise CommandError("Unknown model: %s.%s" % (app_label, model_label))
if app in app_list.keys():
if app_list[app] and model not in app_list[app]:
app_list[app].append(model)
else:
app_list[app] = [model]
except ValueError:
# This is just an app - no model qualifier
app_label = label
try:
app = get_app(app_label)
except ImproperlyConfigured:
raise CommandError("Unknown application: %s" % app_label)
if app in excluded_apps:
continue
app_list[app] = None
# Check that the serialization format exists; this is a shortcut to
# avoid collating all the objects and _then_ failing.
if format not in serializers.get_public_serializer_formats():
raise CommandError("Unknown serialization format: %s" % format)
try:
serializers.get_serializer(format)
except KeyError:
raise CommandError("Unknown serialization format: %s" % format)
def get_objects():
# Collate the objects to be serialized.
for model in sort_dependencies(app_list.items()):
if model in excluded_models:
continue
if not model._meta.proxy and router.allow_syncdb(using, model):
if use_base_manager:
objects = model._base_manager
else:
objects = model._default_manager
for obj in objects.using(using).\
order_by(model._meta.pk.name).iterator():
yield obj
try:
self.stdout.ending = None
serializers.serialize(format, get_objects(), indent=indent,
use_natural_keys=use_natural_keys, stream=self.stdout)
except Exception as e:
if show_traceback:
raise
raise CommandError("Unable to serialize database: %s" % e)
0
Example 41
Project: django-generate Source File: generate.py
def handle(self, *app_labels, **options):
from django.db.models import get_app, get_apps
exclude = options.get('exclude', [])
excluded_apps = [get_app(app_label) for app_label in exclude]
if len(app_labels) == 0:
app_list = [app for app in get_apps() if app not in excluded_apps]
else:
app_list = [get_app(app_label) for app_label in app_labels]
for app in app_list:
name = app.__name__.replace('.models', '')
app_path = __import__(name, {}, {}, [name.split('.')[-1]]).__path__
try:
params = imp.find_module('generator', app_path)
except ImportError:
pass
else:
generator = imp.load_module(name + '.generator', *params)
print "Generating items for %s." % name.title()
start = time.time()
load_json(generator.generate())
now = time.time()
print "Generation completed in %s seconds" % (now - start)
0
Example 42
def evolution(app, created_models, verbosity=1, **kwargs):
"""
A hook into syncdb's post_syncdb signal, that is used to notify the user
if a model evolution is necessary.
"""
proj_sig = create_project_sig()
signature = pickle.dumps(proj_sig)
try:
latest_version = django_evolution.Version.objects.latest('when')
except django_evolution.Version.DoesNotExist:
# We need to create a baseline version.
if verbosity > 0:
print "Installing baseline version"
latest_version = django_evolution.Version(signature=signature)
latest_version.save()
for a in get_apps():
app_label = a.__name__.split('.')[-2]
sequence = get_evolution_sequence(a)
if sequence:
if verbosity > 0:
print 'Evolutions in %s baseline:' % app_label,', '.join(sequence)
for evo_label in sequence:
evolution = django_evolution.Evolution(app_label=app_label,
label=evo_label,
version=latest_version)
evolution.save()
unapplied = get_unapplied_evolutions(app)
if unapplied:
print style.NOTICE('There are unapplied evolutions for %s.' % app.__name__.split('.')[-2])
# Evolutions are checked over the entire project, so we only need to
# check once. We do this check when Django Evolutions itself is synchronized.
if app == django_evolution:
old_proj_sig = pickle.loads(str(latest_version.signature))
# If any models have been added, a baseline must be set
# for those new models
changed = False
for app_name, new_app_sig in proj_sig.items():
if app_name == '__version__':
# Ignore the __version__ tag
continue
old_app_sig = old_proj_sig.get(app_name, None)
if old_app_sig is None:
# App has been added
old_proj_sig[app_name] = proj_sig[app_name]
changed = True
continue
for model_name, new_model_sig in new_app_sig.items():
old_model_sig = old_app_sig.get(model_name, None)
if old_model_sig is None:
# Model has been added
old_proj_sig[app_name][model_name] = proj_sig[app_name][model_name]
changed = True
if changed:
if verbosity > 0:
print "Adding baseline version for new models"
latest_version = django_evolution.Version(signature=pickle.dumps(old_proj_sig))
latest_version.save()
# TODO: Model introspection step goes here.
# # If the current database state doesn't match the last
# # saved signature (as reported by latest_version),
# # then we need to update the Evolution table.
# actual_sig = introspect_project_sig()
# acutal = pickle.dumps(actual_sig)
# if actual != latest_version.signature:
# nudge = Version(signature=actual)
# nudge.save()
# latest_version = nudge
diff = Diff(old_proj_sig, proj_sig)
if not diff.is_empty():
print style.NOTICE('Project signature has changed - an evolution is required')
if verbosity > 1:
old_proj_sig = pickle.loads(str(latest_version.signature))
print diff
0
Example 43
def handle(self, *args, **options):
for app in get_apps():
couchdbkit_handler.sync(app, verbosity=2)
0
Example 44
Project: django-pyodbc Source File: ss_loaddata.py
def handle(self, *fixture_labels, **options):
from django.db.models import get_apps
from django.core import serializers
from django.db import connection, transaction
from django.conf import settings
self.style = no_style()
verbosity = int(options.get('verbosity', 1))
show_traceback = options.get('traceback', False)
# commit is a stealth option - it isn't really useful as
# a command line option, but it can be useful when invoking
# loaddata from within another script.
# If commit=True, loaddata will use its own transaction;
# if commit=False, the data load SQL will become part of
# the transaction in place when loaddata was invoked.
commit = options.get('commit', True)
# Keep a count of the installed objects and fixtures
fixture_count = 0
object_count = 0
models = set()
humanize = lambda dirname: dirname and "'%s'" % dirname or 'absolute path'
# Get a cursor (even though we don't need one yet). This has
# the side effect of initializing the test database (if
# it isn't already initialized).
cursor = connection.cursor()
# Start transaction management. All fixtures are installed in a
# single transaction to ensure that all references are resolved.
if commit:
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
self.disable_forward_ref_checks()
class SingleZipReader(zipfile.ZipFile):
def __init__(self, *args, **kwargs):
zipfile.ZipFile.__init__(self, *args, **kwargs)
if settings.DEBUG:
assert len(self.namelist()) == 1, "Zip-compressed fixtures must contain only one file."
def read(self):
return zipfile.ZipFile.read(self, self.namelist()[0])
compression_types = {
None: file,
'gz': gzip.GzipFile,
'zip': SingleZipReader
}
if has_bz2:
compression_types['bz2'] = bz2.BZ2File
app_fixtures = [os.path.join(os.path.dirname(app.__file__), 'fixtures') for app in get_apps()]
for fixture_label in fixture_labels:
parts = fixture_label.split('.')
if len(parts) > 1 and parts[-1] in compression_types:
compression_formats = [parts[-1]]
parts = parts[:-1]
else:
compression_formats = compression_types.keys()
if len(parts) == 1:
fixture_name = parts[0]
formats = serializers.get_public_serializer_formats()
else:
fixture_name, format = '.'.join(parts[:-1]), parts[-1]
if format in serializers.get_public_serializer_formats():
formats = [format]
else:
formats = []
if formats:
if verbosity > 1:
print "Loading '%s' fixtures..." % fixture_name
else:
self.enable_forward_ref_checks(cursor)
sys.stderr.write(
self.style.ERROR("Problem installing fixture '%s': %s is not a known serialization format." %
(fixture_name, format)))
transaction.rollback()
transaction.leave_transaction_management()
return
if os.path.isabs(fixture_name):
fixture_dirs = [fixture_name]
else:
fixture_dirs = app_fixtures + list(settings.FIXTURE_DIRS) + ['']
for fixture_dir in fixture_dirs:
if verbosity > 1:
print "Checking %s for fixtures..." % humanize(fixture_dir)
label_found = False
for format in formats:
for compression_format in compression_formats:
if compression_format:
file_name = '.'.join([fixture_name, format,
compression_format])
else:
file_name = '.'.join([fixture_name, format])
if verbosity > 1:
print "Trying %s for %s fixture '%s'..." % \
(humanize(fixture_dir), file_name, fixture_name)
full_path = os.path.join(fixture_dir, file_name)
open_method = compression_types[compression_format]
try:
fixture = open_method(full_path, 'r')
if label_found:
fixture.close()
self.enable_forward_ref_checks(cursor)
print self.style.ERROR("Multiple fixtures named '%s' in %s. Aborting." %
(fixture_name, humanize(fixture_dir)))
transaction.rollback()
transaction.leave_transaction_management()
return
else:
fixture_count += 1
objects_in_fixture = 0
if verbosity > 0:
print "Installing %s fixture '%s' from %s." % \
(format, fixture_name, humanize(fixture_dir))
try:
objects = serializers.deserialize(format, fixture)
for obj in objects:
objects_in_fixture += 1
self.handle_ref_checks(cursor, obj)
models.add(obj.object.__class__)
obj.save()
object_count += objects_in_fixture
label_found = True
except (SystemExit, KeyboardInterrupt):
self.enable_forward_ref_checks(cursor)
raise
except Exception:
import traceback
fixture.close()
self.enable_forward_ref_checks(cursor)
transaction.rollback()
transaction.leave_transaction_management()
if show_traceback:
traceback.print_exc()
else:
sys.stderr.write(
self.style.ERROR("Problem installing fixture '%s': %s\n" %
(full_path, ''.join(traceback.format_exception(sys.exc_type,
sys.exc_value, sys.exc_traceback)))))
return
fixture.close()
# If the fixture we loaded contains 0 objects, assume that an
# error was encountered during fixture loading.
if objects_in_fixture == 0:
self.enable_forward_ref_checks(cursor)
sys.stderr.write(
self.style.ERROR("No fixture data found for '%s'. (File format may be invalid.)" %
(fixture_name)))
transaction.rollback()
transaction.leave_transaction_management()
return
except Exception, e:
if verbosity > 1:
print "No %s fixture '%s' in %s." % \
(format, fixture_name, humanize(fixture_dir))
self.enable_forward_ref_checks(cursor)
# If we found even one object in a fixture, we need to reset the
# database sequences.
if object_count > 0:
sequence_sql = connection.ops.sequence_reset_sql(self.style, models)
if sequence_sql:
if verbosity > 1:
print "Resetting sequences"
for line in sequence_sql:
cursor.execute(line)
if commit:
transaction.commit()
transaction.leave_transaction_management()
if object_count == 0:
if verbosity > 1:
print "No fixtures found."
else:
if verbosity > 0:
print "Installed %d object(s) from %d fixture(s)" % (object_count, fixture_count)
# Close the DB connection. This is required as a workaround for an
# edge case in MySQL: if the same connection is used to
# create tables, load data, and query, the query can return
# incorrect results. See Django #7572, MySQL #37735.
if commit:
connection.close()
0
Example 45
def handle(self, *args, **options):
for app in get_apps():
couchdbkit_handler.copy_designs(app, temp='tmp', verbosity=2)
0
Example 46
Project: talk.org Source File: python.py
def Deserializer(object_list, **options):
"""Deserialize simple Python objects back into Model instances.
It's expected that you pass the Python objects themselves (instead of a
stream or a string) to the constructor
"""
models.get_apps()
for d in object_list:
# Look up the model and starting build a dict of data for it.
Model = python._get_model(d["model"])
data = {}
key = resolve_key(Model._meta.module_name, d["pk"])
if key.name():
data["key_name"] = key.name()
parent = None
if key.parent():
parent = FakeParent(key.parent())
m2m_data = {}
# Handle each field
for (field_name, field_value) in d["fields"].iteritems():
if isinstance(field_value, str):
field_value = smart_unicode(
field_value, options.get("encoding",
settings.DEFAULT_CHARSET),
strings_only=True)
field = Model.properties()[field_name]
if isinstance(field, db.Reference):
# Resolve foreign key references.
data[field.name] = resolve_key(Model._meta.module_name, field_value)
if not data[field.name].name():
raise base.DeserializationError(u"Cannot load Reference with "
"unnamed key: '%s'" % field_value)
else:
data[field.name] = field.validate(field_value)
# Create the new model instance with all it's data, but no parent.
object = Model(**data)
# Now add the parent into the hidden attribute, bypassing the type checks
# in the Model's __init__ routine.
object._parent = parent
# When the deserialized object is saved our replacement DeserializedObject
# class will set object._parent to force the real parent model to be loaded
# the first time it is referenced.
yield base.DeserializedObject(object, m2m_data)
0
Example 47
Project: talk.org Source File: loaddata.py
def handle(self, *fixture_labels, **options):
from django.db.models import get_apps
from django.core import serializers
from django.db import connection, transaction
from django.conf import settings
self.style = no_style()
verbosity = int(options.get('verbosity', 1))
show_traceback = options.get('traceback', False)
# Keep a count of the installed objects and fixtures
fixture_count = 0
object_count = 0
models = set()
humanize = lambda dirname: dirname and "'%s'" % dirname or 'absolute path'
# Get a cursor (even though we don't need one yet). This has
# the side effect of initializing the test database (if
# it isn't already initialized).
cursor = connection.cursor()
# Start transaction management. All fixtures are installed in a
# single transaction to ensure that all references are resolved.
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
app_fixtures = [os.path.join(os.path.dirname(app.__file__), 'fixtures') for app in get_apps()]
for fixture_label in fixture_labels:
parts = fixture_label.split('.')
if len(parts) == 1:
fixture_name = fixture_label
formats = serializers.get_public_serializer_formats()
else:
fixture_name, format = '.'.join(parts[:-1]), parts[-1]
if format in serializers.get_public_serializer_formats():
formats = [format]
else:
formats = []
if verbosity >= 2:
if formats:
print "Loading '%s' fixtures..." % fixture_name
else:
print "Skipping fixture '%s': %s is not a known serialization format" % (fixture_name, format)
if os.path.isabs(fixture_name):
fixture_dirs = [fixture_name]
else:
fixture_dirs = app_fixtures + list(settings.FIXTURE_DIRS) + ['']
for fixture_dir in fixture_dirs:
if verbosity > 1:
print "Checking %s for fixtures..." % humanize(fixture_dir)
label_found = False
for format in formats:
serializer = serializers.get_serializer(format)
if verbosity > 1:
print "Trying %s for %s fixture '%s'..." % \
(humanize(fixture_dir), format, fixture_name)
try:
full_path = os.path.join(fixture_dir, '.'.join([fixture_name, format]))
fixture = open(full_path, 'r')
if label_found:
fixture.close()
print self.style.ERROR("Multiple fixtures named '%s' in %s. Aborting." %
(fixture_name, humanize(fixture_dir)))
transaction.rollback()
transaction.leave_transaction_management()
return
else:
fixture_count += 1
if verbosity > 0:
print "Installing %s fixture '%s' from %s." % \
(format, fixture_name, humanize(fixture_dir))
try:
objects = serializers.deserialize(format, fixture)
for obj in objects:
object_count += 1
models.add(obj.object.__class__)
obj.save()
label_found = True
except Exception, e:
fixture.close()
transaction.rollback()
transaction.leave_transaction_management()
if show_traceback:
import traceback
traceback.print_exc()
else:
sys.stderr.write(
self.style.ERROR("Problem installing fixture '%s': %s\n" %
(full_path, str(e))))
return
fixture.close()
except:
if verbosity >= 2:
print "No %s fixture '%s' in %s." % \
(format, fixture_name, humanize(fixture_dir))
if object_count > 0:
sequence_sql = connection.ops.sequence_reset_sql(self.style, models)
if sequence_sql:
if verbosity > 1:
print "Resetting sequences"
for line in sequence_sql:
cursor.execute(line)
transaction.commit()
transaction.leave_transaction_management()
if object_count == 0:
if verbosity >= 2:
print "No fixtures found."
else:
if verbosity > 0:
print "Installed %d object(s) from %d fixture(s)" % (object_count, fixture_count)
0
Example 48
Project: GAE-Bulk-Mailer Source File: flush.py
def handle_noargs(self, **options):
db = options.get('database')
connection = connections[db]
verbosity = int(options.get('verbosity'))
interactive = options.get('interactive')
# 'reset_sequences' is a stealth option
reset_sequences = options.get('reset_sequences', True)
self.style = no_style()
# Import the 'management' module within each installed app, to register
# dispatcher events.
for app_name in settings.INSTALLED_APPS:
try:
import_module('.management', app_name)
except ImportError:
pass
sql_list = sql_flush(self.style, connection, only_django=True, reset_sequences=reset_sequences)
if interactive:
confirm = input("""You have requested a flush of the database.
This will IRREVERSIBLY DESTROY all data currently in the %r database,
and return each table to the state it was in after syncdb.
Are you sure you want to do this?
Type 'yes' to continue, or 'no' to cancel: """ % connection.settings_dict['NAME'])
else:
confirm = 'yes'
if confirm == 'yes':
try:
cursor = connection.cursor()
for sql in sql_list:
cursor.execute(sql)
except Exception as e:
transaction.rollback_unless_managed(using=db)
raise CommandError("""Database %s couldn't be flushed. Possible reasons:
* The database isn't running or isn't configured correctly.
* At least one of the expected database tables doesn't exist.
* The SQL was invalid.
Hint: Look at the output of 'django-admin.py sqlflush'. That's the SQL this command wasn't able to run.
The full error: %s""" % (connection.settings_dict['NAME'], e))
transaction.commit_unless_managed(using=db)
# Emit the post sync signal. This allows individual
# applications to respond as if the database had been
# sync'd from scratch.
all_models = []
for app in models.get_apps():
all_models.extend([
m for m in models.get_models(app, include_auto_created=True)
if router.allow_syncdb(db, m)
])
emit_post_sync_signal(set(all_models), verbosity, interactive, db)
# Reinstall the initial_data fixture.
kwargs = options.copy()
kwargs['database'] = db
if options.get('load_initial_data'):
# Reinstall the initial_data fixture.
call_command('loaddata', 'initial_data', **options)
else:
self.stdout.write("Flush cancelled.\n")
0
Example 49
def handle(self, *args, **options):
for app in get_apps():
couchdbkit_handler.sync(app, verbosity=2, temp='tmp')
0
Example 50
Project: foodnetwork Source File: dumpscript.py
def get_models(app_labels):
""" Gets a list of models for the given app labels, with some exceptions.
TODO: If a required model is referenced, it should also be included.
Or at least discovered with a get_or_create() call.
"""
from django.db.models import get_app, get_apps, get_model
from django.db.models import get_models as get_all_models
# These models are not to be output, e.g. because they can be generated automatically
# TODO: This should be "appname.modelname" string
from django.contrib.contenttypes.models import ContentType
EXCLUDED_MODELS = (ContentType, )
models = []
# If no app labels are given, return all
if not app_labels:
for app in get_apps():
models += [ m for m in get_all_models(app) if m not in EXCLUDED_MODELS ]
# Get all relevant apps
for app_label in app_labels:
# If a specific model is mentioned, get only that model
if "." in app_label:
app_label, model_name = app_label.split(".", 1)
models.append(get_model(app_label, model_name))
# Get all models for a given app
else:
models += [ m for m in get_all_models(get_app(app_label)) if m not in EXCLUDED_MODELS ]
return models