def test_app(self):
info = meta.model_info(Owner)
self.assertIs(info.app_config,
apps.get_containing_app_config(Owner.__module__))
info = meta.model_info(OtherAppInOtherApp)
self.assertIs(info.app_config,
apps.get_containing_app_config(Owner.__module__))
def test_get_containing_app_config_apps_not_ready(self):
"""
apps.get_containing_app_config() should raise an exception if
apps.apps_ready isn't True.
"""
apps.apps_ready = False
try:
with self.assertRaisesMessage(AppRegistryNotReady, "Apps aren't loaded yet"):
apps.get_containing_app_config('foo')
finally:
apps.apps_ready = True
def test_get_containing_app_config_apps_not_ready(self):
"""
apps.get_containing_app_config() should raise an exception if
apps.apps_ready isn't True.
"""
apps.apps_ready = False
try:
with self.assertRaisesMessage(AppRegistryNotReady, "Apps aren't loaded yet"):
apps.get_containing_app_config('foo')
finally:
apps.apps_ready = True
def get_service_type(model):
try:
return model.get_service_name()
except AttributeError:
pass
app_config = apps.get_containing_app_config(model.__module__)
return getattr(app_config, 'service_name', None)
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
apps.register_model(app_config.label, value)
call_command('migrate', verbosity=0, interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def sorcery_apps(self):
"""
All sorcery apps and their alembic configs
"""
configs = OrderedDict()
for db in databases.values():
table_class_map = {model.__table__: model for model in db.models_registry if hasattr(model, "__table__")}
for table in db.metadata.sorted_tables:
model = table_class_map.get(table)
if model:
app = apps.get_containing_app_config(model.__module__)
if app:
path = self.get_app_version_path(app)
if os.path.exists(path):
config = self.get_app_config(app, db)
appconfig = AlembicAppConfig(
name=app.label,
config=config,
db=db,
script=self.get_config_script(config),
version_path=path,
app=app,
tables=[],
)
configs.setdefault(app.label, appconfig).tables.append(table)
for app in configs.values():
signals.alembic_app_created.send(app.app)
signals.alembic_config_created.send(app.config)
return configs
def get_tested_locations(self, test_labels):
locations = []
if test_labels:
pass
elif hasattr(settings, "PROJECT_APPS"):
test_labels = settings.PROJECT_APPS
else:
warnings.warn("No PROJECTS_APPS settings, coverage gathered over all apps")
test_labels = settings.INSTALLED_APPS
try:
from django.apps import apps
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
locations.append(os.path.dirname(app_config.module.__file__))
except ImportError:
# django 1.6
from django.db.models import get_app
for test_label in test_labels:
models_module = get_app(test_label.split(".")[-1])
locations.append(os.path.dirname(models_module.__file__))
return locations
def default_app_label(self):
""" Get default app Label. """
if self.APP_LABEL is None:
return apps.get_containing_app_config(
self.__class__.__module__).label
else:
return self.APP_LABEL
def get_tested_locations(self, test_labels):
locations = []
coverage = apps.get_app_config('django_jenkins').coverage
if test_labels:
pass
elif hasattr(settings, 'PROJECT_APPS'):
test_labels = settings.PROJECT_APPS
elif coverage and coverage.coverage.source:
warnings.warn(
"No PROJECT_APPS settings, using 'source' config from rcfile")
locations = coverage.coverage.source
else:
warnings.warn(
'No PROJECT_APPS settings, coverage gathered over all apps')
test_labels = settings.INSTALLED_APPS
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
if app_config is not None:
locations.append(app_config.path)
else:
warnings.warn('No app found for test: {0}'.format(test_label))
return locations
def get_task_ref(flow_task):
module = flow_task.flow_cls.__module__
app_config = apps.get_containing_app_config(module)
subpath = module.lstrip(app_config.module.__package__ + '.')
return "{}/{}.{}.{}".format(app_config.label, subpath,
flow_task.flow_cls.__name__, flow_task.name)
def type_def(self, type_def):
if isinstance(type_def, str):
type_def = import_string(type_def)
if not issubclass(type_def, self.type_def_subclass):
raise TypeError('type_def must be a subclass of {}'.format(
self.type_def_subclass))
# Import meta options from type_def
with suppress(AttributeError):
self.type_name = type_def.Meta.db_type
with suppress(AttributeError):
self.type_app_label = type_def.Meta.app_label
if not self.type_app_label:
# Determine app_label of enum being used
app_config = apps.get_containing_app_config(type_def.__module__)
if app_config is None:
raise RuntimeError(
"type_def class doesn't declare an explicit app_label, and isn't"
" in an application in INSTALLED_APPS")
self.type_app_label = app_config.label
# Generate type_name if not already set
if not self.type_name:
self.type_name = '{app_label}_{type_subclass}_{type_name}'.format(
app_label=self.type_app_label,
type_subclass=self.type_def_subclass.__name__.lower(),
type_name=type_def.__qualname__.lower())
self._type_def = type_def
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
if models_mod:
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
apps.register_model(app_config.label, value)
call_command('migrate', verbosity=0, interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def get_containing_app_data(module):
"""
Return app label and package string
"""
app_config = apps.get_containing_app_config(module)
if not app_config:
return None, None
return app_config.label, app_config.module.__name__
def get_containing_app_data(module):
"""
Return app label and package string
"""
app_config = apps.get_containing_app_config(module)
if not app_config:
return None, None
return app_config.label, app_config.module.__name__
def app(self):
try:
return apps.get_containing_app_config(
self.__module__).name.split('.')[-1]
except AttributeError:
raise AppNotFound()
finally:
return None
def get_model_template_name(self):
"""Returns the base template path."""
model = self.get_model()
app_config = apps.get_containing_app_config(model.__module__)
return "{}/{}{}.html".format(
model.__name__.lower() if app_config is None else app_config.label,
model.__name__.lower(),
self.template_name_suffix,
)
def get_urls(self):
urlpatterns = []
for report in self._registry:
app_name = apps.get_containing_app_config(report.__module__).name
urlpatterns.append(
url(r"^%s/%s/" % (app_name, report.__name__.lower()),
ReportView.as_view(report_class=report),
name=camel_re.sub(r'\1_\2', report.__name__).lower()))
return urlpatterns
def setup_test_app(package, label=None):
"""
Setup a Django test app for the provided package to allow test-only models
to be used.
This function should be called from myapp.tests.__init__ like so:
setup_test_app(__package__)
Or, if a specific app label is required, like so:
setup_test_app(__package__, 'mytests')
Models defined within the package also require their app labels manually
set to match, e.g.:
class MyTestModel(models.Model):
# ...
class Meta:
app_label = 'mytests'
"""
#
#
if label is None:
containing_app_config = apps.get_containing_app_config(package)
label = containing_app_config.label
# Only suffix the app label if it has not been already. This allows
# duplicate entries to be detected and prevented. It may prevent the
# use of an implicit label if the tests reside in an app that
# legitimately ends with "_tests", but an explicit label can always be
# used. Without this check, earlier entries are returned by
# get_containing_app_config() and suffixed repeatedly.
if not containing_app_config.label.endswith('_tests'):
label = '{}_tests'.format(containing_app_config.label)
if label in apps.app_configs:
# An app with this label already exists, skip adding it. This is
# necessary (vs raising an exception) as there are certain conditions
# that can cause this function to be run multiple times (e.g. errors
# during Django's initialisation can cause this).
return
app_config = AppConfig.create(package)
app_config.apps = apps
app_config.label = label
apps.app_configs[label] = app_config
app_config.import_models()
apps.clear_cache()
def __new__(mcs, name, bases, attrs):
super_new = super().__new__
parents = [b for b in bases if isinstance(b, _CollectionBaseMetaclass)]
if not parents:
return super_new(mcs, name, bases, attrs)
module = attrs.pop('__module__')
new_attrs = {'__module__': module}
classcell = attrs.pop('__classcell__', None)
if classcell is not None:
new_attrs['__classcell__'] = classcell
new_class = super_new(mcs, name, bases, new_attrs)
attr_meta = attrs.pop('Meta', None)
if not attr_meta:
meta = getattr(new_class, 'Meta', None)
else:
meta = attr_meta
app_label = None
# Look for an application configuration to attach the model to.
app_config = apps.get_containing_app_config(module)
if getattr(meta, 'app_label', None) is None:
if app_config is None:
raise RuntimeError(
"resources class %s.%s doesn't declare an explicit "
"app_label and isn't in an application in "
"INSTALLED_APPS." % (module, name))
else:
app_label = app_config.label
meta = new_class._get_options_class()(meta, app_label)
meta.contribute_to_class(new_class, '_meta')
for parent in parents:
if hasattr(parent, '_meta') and parent._meta:
for field, value in parent._meta.fields.items():
if field not in attrs:
attrs[field] = copy.copy(value)
if 'client' not in attrs:
new_class.client = meta.client_class()
new_class.client.contribute_to_class(new_class, 'client')
# Add all attributes to the class.
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
new_class.register_class()
return new_class
def get_prep_value(self, value):
if not isinstance(value, type):
# HACK: Django calls callable due query parameter
# preparation. So here we can get Flow instance,
# even if we pass Flow class to query.
value = value.__class__
module = "{}.{}".format(value.__module__, value.__name__)
app_config = apps.get_containing_app_config(module)
subpath = module.lstrip(app_config.module.__package__+'.')
return "{}/{}".format(app_config.label, subpath)
def current_app_name(self):
app_config = django_apps.get_containing_app_config(
self.__class__.__module__,
)
name = None
if app_config:
name = app_config.name
module_prefix = self.apps_module + '.'
if name.startswith(module_prefix):
name = name[len(module_prefix):]
return name
def get_prep_value(self, value):
if not isinstance(value, type):
# HACK: Django calls callable due query parameter
# preparation. So here we can get Flow instance,
# even if we pass Flow class to query.
value = value.__class__
module = "{}.{}".format(value.__module__, value.__name__)
app_config = apps.get_containing_app_config(module)
subpath = module.lstrip(app_config.module.__package__ + '.')
return "{}/{}".format(app_config.label, subpath)
def get_urls(self):
urlpatterns = []
for report in self._registry:
app_name = apps.get_containing_app_config(report.__module__).name
urlpatterns.append(
url(r"^{0}/{1}/$".format(app_name.replace(".", "_"), report.__name__.lower()),
ReportView.as_view(report_class=report),
name=camel_re.sub(r'\1_\2', report.__name__).lower()
))
return urlpatterns
def __new__(cls, name, bases, attrs):
super_new = super(constructor, cls).__new__
parents = [b for b in bases if isinstance(b, constructor)]
if not parents:
return super_new(cls, name, bases, attrs)
module = attrs.pop('__module__', None)
new_class = super_new(cls, name, bases, attrs)
attr_meta = attrs.pop('Meta', None)
if not attr_meta:
meta = getattr(new_class, 'Meta', ServiceOptions)
else:
params = {
key: value
for key, value in attr_meta.__dict__.items()
if not key.startswith('__') and not callable(key)
}
SubClass = type(attr_meta.__name__, (ServiceOptions, ), params)
meta = SubClass
base_meta = getattr(new_class, '_meta', None)
app_label = None
app_config = apps.get_containing_app_config(module)
if getattr(meta, 'app_label', None) is None:
if app_config is None:
raise RuntimeError(
"Model class %s.%s doesn't declare an explicit "
"app_label and isn't in an application in "
"INSTALLED_APPS." % (module, name))
else:
app_label = app_config.label
_service_fields = getattr(meta, '_service_fields', None)
# import pdb
# pdb.set_trace()
dm = attrs.pop('_default_manager', BaseManager)
service = attrs.pop('_service_api', None)
if not _service_fields:
_service_fields = service.initialize()
# import ipdb; ipdb.set_trace()
new_class.add_to_class(
'_meta',
meta(meta,
app_label=app_label,
the_class=new_class,
_service_fields=_service_fields))
# import pdb; pdb.set_trace()
if dm:
new_class._default_manager = dm(new_class, mailer=service)
new_class.objects = new_class._default_manager
return new_class
def __new__(cls, name, bases, attrs):
new_class = super(FlowMetaClass, cls).__new__(cls, name, bases, attrs)
# singleton instance
new_class.instance = FlowInstanceDescriptor()
# set up flow tasks
nodes = {name: attr for name, attr in attrs.items() if isinstance(attr, flow.Node)}
for name, node in nodes.items():
node.name = name
resolver = Resolver(nodes)
for node in nodes.values():
resolver.resolve_children_links(node)
incoming = defaultdict(lambda: []) # node -> [incoming_nodes]
for _, node in nodes.items():
for outgoing_edge in node._outgoing():
incoming[outgoing_edge.dst].append(outgoing_edge)
for target, edges in incoming.items():
target._incoming_edges = edges
# set up workflow meta
app_config = apps.get_containing_app_config(new_class.__module__)
if app_config is None:
raise ImportError("Flow can't be imported before app setup")
new_class._meta = FlowMeta(app_config.label, new_class, nodes)
# flow back reference
for name, node in nodes.items():
node.flow_cls = new_class
# description
if new_class.__doc__:
docstring = new_class.__doc__.split('\n\n', maxsplit=1)
if 'process_title' not in attrs and len(docstring) > 0:
new_class.process_title = docstring[0].strip()
if 'process_description' not in attrs and len(docstring) > 1:
new_class.process_description = docstring[1].strip()
# index view
if not getattr(new_class, 'index_view', None):
from viewflow.views import index
new_class.index_view = index
new_class.index_view = staticmethod(new_class.index_view)
# done flow setup
for name, node in nodes.items():
node.ready()
return new_class
def get_urls(self):
urlpatterns = []
for report in self._registry:
app_name = apps.get_containing_app_config(report.__module__).name
urlpatterns.append(
url(r"^{0}/{1}/$".format(app_name.replace(".", "_"),
report.__name__.lower()),
admin_site.admin_view(
ReportView.as_view(report_class=report)),
name=camel_re.sub(r'\1_\2', report.__name__).lower()))
return urlpatterns
def __new__(cls, name, bases, attrs):
new_class = super(FlowMetaClass, cls).__new__(cls, name, bases, attrs)
# singleton instance
new_class.instance = FlowInstanceDescriptor()
# set up flow tasks
nodes = {
name: attr
for name, attr in attrs.items() if isinstance(attr, flow.Node)
}
for name, node in nodes.items():
node.name = name
resolver = Resolver(nodes)
for node in nodes.values():
resolver.resolve_children_links(node)
incoming = defaultdict(lambda: []) # node -> [incoming_nodes]
for _, node in nodes.items():
for outgoing_edge in node._outgoing():
incoming[outgoing_edge.dst].append(outgoing_edge)
for target, edges in incoming.items():
target._incoming_edges = edges
# set up workflow meta
app_config = apps.get_containing_app_config(new_class.__module__)
if app_config is None:
raise ImportError("Flow can't be imported before app setup")
new_class._meta = FlowMeta(app_config.label, new_class, nodes)
# flow back reference
for name, node in nodes.items():
node.flow_cls = new_class
# description
if new_class.__doc__:
docstring = new_class.__doc__.split('\n\n', maxsplit=1)
if 'process_title' not in attrs and len(docstring) > 0:
new_class.process_title = docstring[0].strip()
if 'process_description' not in attrs and len(docstring) > 1:
new_class.process_description = docstring[1].strip()
# done flow setup
for name, node in nodes.items():
node.ready()
return new_class
def initialize_type(cls, types=DEFAULT_SPECS, **kwargs):
if not apps.get_containing_app_config('feincms.module.medialibrary'):
raise (ImproperlyConfigured,
'You have to add \'feincms.module.medialibrary\' to your '
'INSTALLED_APPS before creating a %s' % cls.__name__)
cls.specs = dict([('%s_%s' % (spec.name, types.index(spec)), spec)
for spec in types])
cls.spec_choices = [(spec, cls.specs[spec].verbose_name)
for spec in cls.specs]
cls.add_to_class(
'type',
models.CharField(max_length=20,
choices=cls.spec_choices,
default=cls.spec_choices[0][0]))
def migration_hook(request):
'''
Pause migration at the migration named in @pytest.mark.migrate_from('0001-initial-migration')
The migration_hook param will be a callable to then trigger the migration named in:
@pytest.mark.migrate_from('0002-migrate-things')
migration_hook also has an 'apps' attribute which is used to lookup models in the current migration state
eg.
MyModel = migration_hook.apps.get_model('myapp', 'MyModel')
based on: https://www.caktusgroup.com/blog/2016/02/02/writing-unit-tests-django-migrations/
'''
migrate_from_mark = request.node.get_closest_marker('migrate_from')
assert migrate_from_mark, 'must mark the migration to stop at with @pytest.mark.migrate_from()'
assert len(migrate_from_mark.args) == 1, 'migrate_from mark expects 1 arg'
assert not migrate_from_mark.kwargs, 'migrate_from mark takes no keywords'
migrate_to_mark = request.node.get_closest_marker('migrate_to')
assert migrate_to_mark, 'must mark the migration to hook with @pytest.mark.migrate_to()'
assert len(migrate_to_mark.args) == 1, 'migrate_to mark expects 1 arg'
assert not migrate_to_mark.kwargs, 'migrate_to mark takes no keywords'
app = apps.get_containing_app_config(request.module.__name__).name
migrate_from = [(app, migrate_from_mark.args[0])]
migrate_to = [(app, migrate_to_mark.args[0])]
class migration_hook_result(object):
def __init__(self, _from, _to):
self._to = _to
executor = MigrationExecutor(connection)
self.apps = executor.loader.project_state(_from).apps
# Reverse to the original migration
executor.migrate(_from)
def __call__(self):
# Run the migration to test
executor = MigrationExecutor(connection)
executor.loader.build_graph() # reload.
executor.migrate(self._to)
self.apps = executor.loader.project_state(self._to).apps
yield migration_hook_result(migrate_from, migrate_to)
def _create_test_model(
self, base_class=models.Model, fields=None, model_name=None,
options=None
):
self.model_name = model_name or 'TestModel'
self.options = options
# Obtain the app_config and app_label from the test's module path
self.app_config = apps.get_containing_app_config(
object_name=self.__class__.__module__
)
if connection.vendor == 'mysql':
self.skipTest(
reason='MySQL doesn\'t support schema changes inside an '
'atomic block.'
)
attrs = {
'__module__': self.__class__.__module__,
'save': self._get_test_model_save_method(),
'Meta': self._get_test_model_meta(),
}
if fields:
attrs.update(fields)
# Clear previous model registration before re-registering it again to
# avoid conflict with test models with the same name, in the same app
# but from another test module.
apps.all_models[self.app_config.label].pop(self.model_name.lower(), None)
if PY3:
model = type(
self.model_name, (base_class,), attrs
)
else:
model = type(
force_bytes(self.model_name), (base_class,), attrs
)
if not model._meta.proxy:
with connection.schema_editor() as schema_editor:
schema_editor.create_model(model=model)
self._test_models.append(model)
ContentType.objects.clear_cache()
return model
def _update_plugin(self, plugin_name):
# Import here to prevent circular import
from kolibri.plugins.registry import registered_plugins
app_configs = []
plugin_instance = registered_plugins.get(plugin_name)
if plugin_instance is None:
logger.error(
"Tried to run upgrades for plugin {} but it doesn't exist".
format(plugin_name))
return
for app in plugin_instance.INSTALLED_APPS:
if not isinstance(app, AppConfig) and isinstance(app, str):
app = apps.get_containing_app_config(app)
app_configs.append(app)
old_version = config["PLUGIN_VERSIONS"].get(plugin_name, "")
new_version = _get_plugin_version(plugin_name)
try:
self._migrate_plugin(plugin_name, app_configs)
except Exception as e:
logger.error(
"Unhandled exception while migrating {}, exception was:\n\n{}".
format(plugin_name, e))
return
if old_version:
if VersionInfo.parse(normalize_version_to_semver(
old_version)) < VersionInfo.parse(
normalize_version_to_semver(new_version)):
logger.info(
"Running upgrade routines for {}, upgrading from {} to {}".
format(plugin_name, old_version, new_version))
else:
logger.info(
"Running downgrade routines for {}, downgrading from {} to {}"
.format(plugin_name, old_version, new_version))
else:
logger.info(
"Running installation routines for {}, installing {}".format(
plugin_name, new_version))
try:
run_upgrades(old_version, new_version, app_configs=app_configs)
except Exception as e:
logger.error(
"An exception occured running upgrades for plugin {}: {}".
format(plugin_name, e))
return
return new_version
def __new__(mcls, name, bases, attrs): # noqa: B902
meta = attrs.get("Meta", None)
module = attrs.get("__module__")
new_cls = super(MetricMeta, mcls).__new__(mcls, name, bases, attrs)
# Also ensure initialization is only performed for subclasses of Metric
# (excluding Metric class itself).
if not any(
b for b in bases if isinstance(b, MetricMeta) and b is not BaseMetric
):
return new_cls
template_name = getattr(meta, "template_name", None)
template = getattr(meta, "template", None)
abstract = getattr(meta, "abstract", False)
app_label = getattr(meta, "app_label", None)
# Look for an application configuration to attach the model to.
app_config = apps.get_containing_app_config(module)
if app_label is None:
if app_config is None:
if not abstract:
raise RuntimeError(
"Metric class %s.%s doesn't declare an explicit "
"app_label and isn't in an application in "
"INSTALLED_APPS." % (module, name)
)
else:
app_label = app_config.label
if not template_name or not template:
metric_name = new_cls.__name__.lower()
# If template_name not specified in class Meta,
# compute it as <app label>_<lowercased class name>
if not template_name:
template_name = "{}_{}".format(app_label, metric_name)
# template is <app label>_<lowercased class name>-*
template = template or "{}_{}_*".format(app_label, metric_name)
new_cls._template_name = template_name
new_cls._template = template
# Abstract base metrics can't be instantiated and don't appear in
# the list of metrics for an app.
if not abstract:
registry.register(app_label, new_cls)
return new_cls
def get_tested_locations(self, test_labels):
locations = []
if test_labels:
pass
elif hasattr(settings, 'PROJECT_APPS'):
test_labels = settings.PROJECT_APPS
else:
warnings.warn(
'No PROJECT_APPS settings, coverage gathered over all apps')
test_labels = settings.INSTALLED_APPS
try:
from django.apps import apps
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
if app_config is not None:
locations.append(
os.path.dirname(app_config.module.__file__))
else:
warnings.warn(
'No app found for test: {0}'.format(test_label))
except ImportError:
# django 1.6
from django.utils.importlib import import_module
def get_containing_app(object_name):
candidates = []
for app_label in settings.INSTALLED_APPS:
if object_name.startswith(app_label):
subpath = object_name[len(app_label):]
if subpath == '' or subpath[0] == '.':
candidates.append(app_label)
if candidates:
return sorted(candidates, key=lambda label: -len(label))[0]
for test_label in test_labels:
app_label = get_containing_app(test_label)
if app_label is not None:
app_module = import_module(app_label)
locations.append(os.path.dirname(app_module.__file__))
else:
warnings.warn(
'No app found for test: {0}'.format(test_label))
return locations
def migration_hook(request):
'''
Pause migration at the migration named in @pytest.mark.migrate_from('0001-initial-migration')
The migration_hook param will be a callable to then trigger the migration named in:
@pytest.mark.migrate_from('0002-migrate-things')
migration_hook also has an 'apps' attribute which is used to lookup models in the current migration state
eg.
MyModel = migration_hook.apps.get_model('myapp', 'MyModel')
based on: https://www.caktusgroup.com/blog/2016/02/02/writing-unit-tests-django-migrations/
'''
assert 'migrate_from' in request.keywords, 'must mark the migration to stop at with @pytest.mark.migrate_from()'
assert len(request.keywords['migrate_from'].args) == 1, 'migrate_from mark expects 1 arg'
assert not request.keywords['migrate_from'].kwargs, 'migrate_from mark takes no keywords'
assert 'migrate_to' in request.keywords, 'must mark the migration to hook with @pytest.mark.migrate_to()'
assert len(request.keywords['migrate_to'].args) == 1, 'migrate_to mark expects 1 arg'
assert not request.keywords['migrate_to'].kwargs, 'migrate_to mark takes no keywords'
app = apps.get_containing_app_config(request.module.__name__).name
migrate_from = [(app, request.keywords['migrate_from'].args[0])]
migrate_to = [(app, request.keywords['migrate_to'].args[0])]
class migration_hook_result(object):
def __init__(self, _from, _to):
self._to = _to
executor = MigrationExecutor(connection)
self.apps = executor.loader.project_state(_from).apps
# Reverse to the original migration
executor.migrate(_from)
def __call__(self):
# Run the migration to test
executor = MigrationExecutor(connection)
executor.loader.build_graph() # reload.
executor.migrate(self._to)
self.apps = executor.loader.project_state(self._to).apps
yield migration_hook_result(migrate_from, migrate_to)
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
if models_mod:
app_label = app_config.label
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
# The model was likely registered under another app,
# so we need to remove the old one and add the new
# one.
try:
del apps.all_models[value._meta.app_label][
value._meta.model_name]
except KeyError:
pass
value._meta.app_label = app_label
apps.register_model(app_label, value)
call_command('migrate',
run_syncdb=True,
verbosity=0,
interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def _add_django_meta_and_register_model(cls, klass, attrs, name):
# Create the class.
module = attrs.get('__module__')
if not module:
return klass
new_class = klass
attr_meta = attrs.pop('Meta', None)
abstract = getattr(attr_meta, 'abstract', False)
if not attr_meta:
meta = getattr(new_class, 'Meta', None)
else:
meta = attr_meta
if meta:
meta.managed = False
app_label = None
# Look for an application configuration to attach the model to.
app_config = apps.get_containing_app_config(module)
if getattr(meta, 'app_label', None) is None:
if app_config is None:
if not abstract:
raise RuntimeError(
"Model class %s.%s doesn't declare an explicit "
"app_label and isn't in an application in "
"INSTALLED_APPS." % (module, name))
else:
app_label = app_config.label
# Add _meta/Options attribute to the model
new_class.add_to_class(
'_meta', DjangoCassandraOptions(meta, app_label, cls=new_class))
# Add manager to the model
for manager_attr in _django_manager_attr_names:
new_class.add_to_class(manager_attr, new_class.objects)
# Register the model
new_class._meta.apps.register_model(new_class._meta.app_label,
new_class)
return new_class
def _add_django_meta_and_register_model(cls, klass, attrs, name):
# Create the class.
module = attrs.get('__module__')
if not module:
return klass
new_class = klass
attr_meta = attrs.pop('Meta', None)
abstract = getattr(attr_meta, 'abstract', False)
if not attr_meta:
meta = getattr(new_class, 'Meta', None)
else:
meta = attr_meta
if meta:
meta.managed = False
app_label = None
# Look for an application configuration to attach the model to.
app_config = apps.get_containing_app_config(module)
if getattr(meta, 'app_label', None) is None:
if app_config is None:
if not abstract:
raise RuntimeError(
"Model class %s.%s doesn't declare an explicit "
"app_label and isn't in an application in "
"INSTALLED_APPS." % (module, name)
)
else:
app_label = app_config.label
# Add _meta/Options attribute to the model
new_class.add_to_class(
'_meta', DjangoCassandraOptions(meta, app_label, cls=new_class))
# Add manager to the model
for manager_attr in _django_manager_attr_names:
new_class.add_to_class(manager_attr, new_class.objects)
# Register the model
new_class._meta.apps.register_model(new_class._meta.app_label, new_class)
return new_class
def get_containing_app_data(module):
"""Return app label and package string."""
app_config = apps.get_containing_app_config(module)
if not app_config:
return None, None
return app_config.label, app_config.module.__name__
def with_metaclass(meta, *bases):
"""Create a base class with a metaclass."""
class metaclass(meta):
__call__ = type.__call__
__init__ = type.__init__
def __new__(cls, name, this_bases, d):
if this_bases is None:
return type.__new__(cls, name, (), d)
return meta(name, bases, d)
return metaclass('temporary_class', None, {})
def get_tested_locations(self, test_labels):
locations = []
if test_labels:
pass
elif hasattr(settings, 'PROJECT_APPS'):
test_labels = settings.PROJECT_APPS
else:
warnings.warn('No PROJECT_APPS settings, coverage gathered over all apps')
test_labels = settings.INSTALLED_APPS
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
if app_config is not None:
locations.append(os.path.dirname(app_config.module.__file__))
else:
warnings.warn('No app found for test: {0}'.format(test_label))
return locations
def get_containing_app_data(module):
"""Return app label and package string."""
app_config = apps.get_containing_app_config(module)
if not app_config:
return None, None
return app_config.label, app_config.module.__name__
def with_metaclass(meta, *bases):
"""Create a base class with a metaclass."""
class metaclass(meta):
__call__ = type.__call__
__init__ = type.__init__
def __new__(cls, name, this_bases, d):
if this_bases is None:
return type.__new__(cls, name, (), d)
return meta(name, bases, d)
return metaclass('temporary_class', None, {})
def setUp(self):
super(TestModelsLoaderMixin, self).setUp()
# If we made a fake 'models' module, add it to sys.modules.
models_mod = self._tests_loader_models_mod
if models_mod:
sys.modules[models_mod.__name__] = models_mod
self._models_loader_old_settings = settings.INSTALLED_APPS
settings.INSTALLED_APPS = list(settings.INSTALLED_APPS) + [
self.tests_app,
]
if apps:
# Push the new set of installed apps, and begin registering
# each of the models associated with the tests.
apps.set_installed_apps(settings.INSTALLED_APPS)
app_config = apps.get_containing_app_config(self.tests_app)
if models_mod:
app_label = app_config.label
for key, value in six.iteritems(models_mod.__dict__):
if inspect.isclass(value) and issubclass(value, Model):
# The model was likely registered under another app,
# so we need to remove the old one and add the new
# one.
try:
del apps.all_models[value._meta.app_label][
value._meta.model_name]
except KeyError:
pass
value._meta.app_label = app_label
apps.register_model(app_label, value)
call_command('migrate', run_syncdb=True, verbosity=0,
interactive=False)
else:
load_app(self.tests_app)
call_command('syncdb', verbosity=0, interactive=False)
def get_tested_locations(self, test_labels):
locations = []
if test_labels:
pass
elif hasattr(settings, 'PROJECT_APPS'):
test_labels = settings.PROJECT_APPS
else:
warnings.warn('No PROJECT_APPS settings, coverage gathered over all apps')
test_labels = settings.INSTALLED_APPS
try:
from django.apps import apps
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
if app_config is not None:
locations.append(os.path.dirname(app_config.module.__file__))
else:
warnings.warn('No app found for test: {0}'.format(test_label))
except ImportError:
# django 1.6
from importlib import import_module
def get_containing_app(object_name):
candidates = []
for app_label in settings.INSTALLED_APPS:
if object_name.startswith(app_label):
subpath = object_name[len(app_label):]
if subpath == '' or subpath[0] == '.':
candidates.append(app_label)
if candidates:
return sorted(candidates, key=lambda label: -len(label))[0]
for test_label in test_labels:
app_label = get_containing_app(test_label)
if app_label is not None:
app_module = import_module(app_label)
locations.append(os.path.dirname(app_module.__file__))
else:
warnings.warn('No app found for test: {0}'.format(test_label))
return locations
def get_tested_locations(self, test_labels):
locations = []
if test_labels:
pass
elif hasattr(settings, 'PROJECT_APPS'):
test_labels = settings.PROJECT_APPS
else:
warnings.warn(
'No PROJECT_APPS settings, coverage gathered over all apps')
test_labels = settings.INSTALLED_APPS
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
if app_config is not None:
locations.append(os.path.dirname(app_config.module.__file__))
else:
warnings.warn('No app found for test: {0}'.format(test_label))
return locations
def get_tested_locations(self, test_labels):
locations = []
coverage = apps.get_app_config('django_jenkins').coverage
if test_labels:
pass
elif hasattr(settings, 'PROJECT_APPS'):
test_labels = settings.PROJECT_APPS
elif coverage.coverage.source:
warnings.warn("No PROJECT_APPS settings, using 'source' config from rcfile")
locations = coverage.coverage.source
else:
warnings.warn('No PROJECT_APPS settings, coverage gathered over all apps')
test_labels = settings.INSTALLED_APPS
for test_label in test_labels:
app_config = apps.get_containing_app_config(test_label)
if app_config is not None:
locations.append(app_config.path)
else:
warnings.warn('No app found for test: {0}'.format(test_label))
return locations
def contribute_to_class(self, cls, name):
setattr(cls, name, self)
self.original_attrs = {}
if self.meta:
meta_attrs = self.meta.__dict__.copy()
for name in self.meta.__dict__:
if name.startswith('_'):
del meta_attrs[name]
for attr_name in DEFAULT_NAMES:
if attr_name in meta_attrs:
setattr(self,attr_name,meta_attrs.pop(attr_name))
self.original_attrs[attr_name] = getattr(self, attr_name)
elif hasattr(self.meta, attr_name):
setattr(self, attr_name, getattr(self.meta, attr_name))
self.original_attrs[attr_name] = getattr(self, attr_name)
del self.meta
self.object_name = self.base_block.__name__
if self.app_label is None:
module = self.base_block.__module__
self.app_config = apps.get_containing_app_config(module)
self.app_label = self.app_config.label
def get_containing_app_data(module):
"""
Return app label and package string
"""
app_config = apps.get_containing_app_config(module)
return app_config.label, app_config.module.__package__
def app(self):
return apps.get_containing_app_config(type(self).__module__).name
def get_task_ref(flow_task):
module = flow_task.flow_cls.__module__
app_config = apps.get_containing_app_config(module)
subpath = module.lstrip(app_config.module.__package__+'.')
return "{}/{}.{}.{}".format(app_config.label, subpath, flow_task.flow_cls.__name__, flow_task.name)
def default_access_fn(user, url_name, url_args=None, url_kwargs=None): # noqa C901 too complex
"""
Given a url_name and a user, this function tries to assess whether the
user has the right to access the URL.
The application instance of the view is fetched via the Django app
registry.
Once the permissions for the view are known, the access logic used
by the dashboard decorator is evaluated
This function might seem costly, but a simple comparison with DTT
did not show any change in response time
"""
if url_name is None: # it's a heading
return True
# get view module string.
try:
url = reverse(url_name, args=url_args, kwargs=url_kwargs)
except NoReverseMatch:
# In Oscar 1.5 this exception was silently ignored which made debugging
# very difficult. Now it is being logged and in future the exception will
# be propagated.
logger.exception('Invalid URL name {}'.format(url_name))
return False
view_module = resolve(url).func.__module__
# We can't assume that the view has the same parent module as the app
# config, as either the app config or view can be customised. So we first
# look it up in the app registry using "get_containing_app_config", and if
# it isn't found, then we walk up the package tree, looking for an
# OscarDashboardConfig class, from which we get an app label, and use that
# to look it up again in the app registry using "get_app_config".
app_config_instance = apps.get_containing_app_config(view_module)
if app_config_instance is None:
try:
app_config_class = get_app_config_class(view_module)
except AppNotFoundError:
raise ImproperlyConfigured(
"Please provide an OscarDashboardConfig subclass in the apps "
"module or set a custom access_fn")
if hasattr(app_config_class, 'label'):
app_label = app_config_class.label
else:
app_label = app_config_class.name.rpartition('.')[2]
try:
app_config_instance = apps.get_app_config(app_label)
except LookupError:
raise AppNotFoundError(
"Couldn't find an app with the label %s" % app_label)
if not isinstance(app_config_instance, OscarDashboardConfig):
raise AppNotFoundError(
"Couldn't find an Oscar Dashboard app with the label %s" % app_label)
# handle name-spaced view names
if ':' in url_name:
view_name = url_name.split(':')[1]
else:
view_name = url_name
permissions = app_config_instance.get_permissions(view_name)
return check_permissions(user, permissions)
def patched_new(cls, name, bases, attrs):
"Patched version of __new__"
super_new = super(ModelBase, cls).__new__
# Also ensure initialization is only performed for subclasses of Model
# (excluding Model class itself).
parents = [b for b in bases if isinstance(b, ModelBase)]
if not parents:
return super_new(cls, name, bases, attrs)
# Create the class.
module = attrs.pop('__module__')
new_class = super_new(cls, name, bases, {'__module__': module})
attr_meta = attrs.pop('Meta', None)
abstract = getattr(attr_meta, 'abstract', False)
if not attr_meta:
meta = getattr(new_class, 'Meta', None)
else:
meta = attr_meta
base_meta = getattr(new_class, '_meta', None)
# Look for an application configuration to attach the model to.
app_config = apps.get_containing_app_config(module)
if getattr(meta, 'app_label', None) is None:
if app_config is None:
# If the model is imported before the configuration for its
# application is created (#21719), or isn't in an installed
# application (#21680), use the legacy logic to figure out the
# app_label by looking one level up from the package or module
# named 'models'. If no such package or module exists, fall
# back to looking one level up from the module this model is
# defined in.
# For 'django.contrib.sites.models', this would be 'sites'.
# For 'geo.models.places' this would be 'geo'.
if abstract:
kwargs = {"app_label": None}
else:
msg = (
"Model class %s.%s doesn't declare an explicit app_label "
"and either isn't in an application in INSTALLED_APPS or "
"else was imported before its application was loaded. " %
(module, name))
raise RuntimeError(msg)
else:
kwargs = {}
new_class.add_to_class('_meta', Options(meta, **kwargs))
if not abstract:
new_class.add_to_class(
'DoesNotExist',
subclass_exception(
str('DoesNotExist'),
tuple(x.DoesNotExist for x in parents if hasattr(x, '_meta') and not x._meta.abstract) or (ObjectDoesNotExist,),
module,
attached_to=new_class))
new_class.add_to_class(
'MultipleObjectsReturned',
subclass_exception(
str('MultipleObjectsReturned'),
tuple(x.MultipleObjectsReturned for x in parents if hasattr(x, '_meta') and not x._meta.abstract) or (MultipleObjectsReturned,),
module,
attached_to=new_class))
if base_meta and not base_meta.abstract:
# Non-abstract child classes inherit some attributes from their
# non-abstract parent (unless an ABC comes before it in the
# method resolution order).
if not hasattr(meta, 'ordering'):
new_class._meta.ordering = base_meta.ordering
if not hasattr(meta, 'get_latest_by'):
new_class._meta.get_latest_by = base_meta.get_latest_by
is_proxy = new_class._meta.proxy
# If the model is a proxy, ensure that the base class
# hasn't been swapped out.
if is_proxy and base_meta and base_meta.swapped:
raise TypeError("%s cannot proxy the swapped model '%s'." % (name, base_meta.swapped))
if getattr(new_class, '_default_manager', None):
if not is_proxy:
# Multi-table inheritance doesn't inherit default manager from
# parents.
new_class._default_manager = None
new_class._base_manager = None
else:
# Proxy classes do inherit parent's default manager, if none is
# set explicitly.
new_class._default_manager = new_class._default_manager._copy_to_model(new_class)
new_class._base_manager = new_class._base_manager._copy_to_model(new_class)
# Add all attributes to the class.
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
# All the fields of any type declared on this model
new_fields = (
new_class._meta.local_fields +
new_class._meta.local_many_to_many +
new_class._meta.virtual_fields
)
field_names = set(f.name for f in new_fields)
# Basic setup for proxy models.
if is_proxy:
base = None
for parent in [kls for kls in parents if hasattr(kls, '_meta')]:
if parent._meta.abstract:
if parent._meta.fields:
raise TypeError("Abstract base class containing model fields not permitted for proxy model '%s'." % name)
else:
continue
#if base is not None: # patch
while parent._meta.proxy: # patch
parent = parent._meta.proxy_for_model # patch
if base is not None and base is not parent: # patch
raise TypeError("Proxy model '%s' has more than one non-abstract model base class." % name)
else:
base = parent
if base is None:
raise TypeError("Proxy model '%s' has no non-abstract model base class." % name)
new_class._meta.setup_proxy(base)
new_class._meta.concrete_model = base._meta.concrete_model
else:
new_class._meta.concrete_model = new_class
# Collect the parent links for multi-table inheritance.
parent_links = {}
for base in reversed([new_class] + parents):
# Conceptually equivalent to `if base is Model`.
if not hasattr(base, '_meta'):
continue
# Skip concrete parent classes.
if base != new_class and not base._meta.abstract:
continue
# Locate OneToOneField instances.
for field in base._meta.local_fields:
if isinstance(field, OneToOneField):
parent_links[field.rel.to] = field
# Do the appropriate setup for any model parents.
for base in parents:
original_base = base
if not hasattr(base, '_meta'):
# Things without _meta aren't functional models, so they're
# uninteresting parents.
continue
parent_fields = base._meta.local_fields + base._meta.local_many_to_many
# Check for clashes between locally declared fields and those
# on the base classes (we cannot handle shadowed fields at the
# moment).
for field in parent_fields:
if field.name in field_names:
raise FieldError(
'Local field %r in class %r clashes '
'with field of similar name from '
'base class %r' % (field.name, name, base.__name__)
)
if not base._meta.abstract:
# Concrete classes...
base = base._meta.concrete_model
if base in parent_links:
field = parent_links[base]
elif not is_proxy:
attr_name = '%s_ptr' % base._meta.model_name
field = OneToOneField(base, name=attr_name,
auto_created=True, parent_link=True)
# Only add the ptr field if it's not already present;
# e.g. migrations will already have it specified
if not hasattr(new_class, attr_name):
new_class.add_to_class(attr_name, field)
else:
field = None
new_class._meta.parents[base] = field
else:
# .. and abstract ones.
for field in parent_fields:
new_class.add_to_class(field.name, copy.deepcopy(field))
# Pass any non-abstract parent classes onto child.
new_class._meta.parents.update(base._meta.parents)
# Inherit managers from the abstract base classes.
new_class.copy_managers(base._meta.abstract_managers)
# Proxy models inherit the non-abstract managers from their base,
# unless they have redefined any of them.
if is_proxy:
new_class.copy_managers(original_base._meta.concrete_managers)
# Inherit virtual fields (like GenericForeignKey) from the parent
# class
for field in base._meta.virtual_fields:
if base._meta.abstract and field.name in field_names:
raise FieldError(
'Local field %r in class %r clashes '
'with field of similar name from '
'abstract base class %r' % (field.name, name, base.__name__)
)
new_class.add_to_class(field.name, copy.deepcopy(field))
if abstract:
# Abstract base models can't be instantiated and don't appear in
# the list of models for an app. We do the final setup for them a
# little differently from normal models.
attr_meta.abstract = False
new_class.Meta = attr_meta
return new_class
new_class._prepare()
new_class._meta.apps.register_model(new_class._meta.app_label, new_class)
return new_class
def __new__(cls, name, bases, attrs):
super_new = super(ModelBase, cls).__new__
# six.with_metaclass() inserts an extra class called 'NewBase' in the
# inheritance tree: Model -> NewBase -> object. But the initialization
# should be executed only once for a given model class.
# attrs will never be empty for classes declared in the standard way
# (ie. with the `class` keyword). This is quite robust.
if name == "NewBase" and attrs == {}:
return super_new(cls, name, bases, attrs)
# Also ensure initialization is only performed for subclasses of Model
# (excluding Model class itself).
parents = [
b for b in bases if isinstance(b, ModelBase) and not (b.__name__ == "NewBase" and b.__mro__ == (b, object))
]
if not parents:
return super_new(cls, name, bases, attrs)
# Create the class.
module = attrs.pop("__module__")
new_class = super_new(cls, name, bases, {"__module__": module})
attr_meta = attrs.pop("Meta", None)
abstract = getattr(attr_meta, "abstract", False)
if not attr_meta:
meta = getattr(new_class, "Meta", None)
else:
meta = attr_meta
base_meta = getattr(new_class, "_meta", None)
# Look for an application configuration to attach the model to.
app_config = apps.get_containing_app_config(module)
if getattr(meta, "app_label", None) is None:
if app_config is None:
# If the model is imported before the configuration for its
# application is created (#21719), or isn't in an installed
# application (#21680), use the legacy logic to figure out the
# app_label by looking one level up from the package or module
# named 'models'. If no such package or module exists, fall
# back to looking one level up from the module this model is
# defined in.
# For 'django.contrib.sites.models', this would be 'sites'.
# For 'geo.models.places' this would be 'geo'.
msg = (
"Model class %s.%s doesn't declare an explicit app_label "
"and either isn't in an application in INSTALLED_APPS or "
"else was imported before its application was loaded. " % (module, name)
)
if abstract:
msg += "Its app_label will be set to None in Django 1.9."
else:
msg += "This will no longer be supported in Django 1.9."
warnings.warn(msg, PendingDeprecationWarning, stacklevel=2)
model_module = sys.modules[new_class.__module__]
package_components = model_module.__name__.split(".")
package_components.reverse() # find the last occurrence of 'models'
try:
app_label_index = package_components.index(MODELS_MODULE_NAME) + 1
except ValueError:
app_label_index = 1
kwargs = {"app_label": package_components[app_label_index]}
else:
kwargs = {"app_label": app_config.label}
else:
kwargs = {}
new_class.add_to_class("_meta", Options(meta, **kwargs))
if not abstract:
new_class.add_to_class(
"DoesNotExist",
subclass_exception(
str("DoesNotExist"),
tuple(x.DoesNotExist for x in parents if hasattr(x, "_meta") and not x._meta.abstract)
or (ObjectDoesNotExist,),
module,
attached_to=new_class,
),
)
new_class.add_to_class(
"MultipleObjectsReturned",
subclass_exception(
str("MultipleObjectsReturned"),
tuple(x.MultipleObjectsReturned for x in parents if hasattr(x, "_meta") and not x._meta.abstract)
or (MultipleObjectsReturned,),
module,
attached_to=new_class,
),
)
if base_meta and not base_meta.abstract:
# Non-abstract child classes inherit some attributes from their
# non-abstract parent (unless an ABC comes before it in the
# method resolution order).
if not hasattr(meta, "ordering"):
new_class._meta.ordering = base_meta.ordering
if not hasattr(meta, "get_latest_by"):
new_class._meta.get_latest_by = base_meta.get_latest_by
is_proxy = new_class._meta.proxy
# If the model is a proxy, ensure that the base class
# hasn't been swapped out.
if is_proxy and base_meta and base_meta.swapped:
raise TypeError("%s cannot proxy the swapped model '%s'." % (name, base_meta.swapped))
if getattr(new_class, "_default_manager", None):
if not is_proxy:
# Multi-table inheritance doesn't inherit default manager from
# parents.
new_class._default_manager = None
new_class._base_manager = None
else:
# Proxy classes do inherit parent's default manager, if none is
# set explicitly.
new_class._default_manager = new_class._default_manager._copy_to_model(new_class)
new_class._base_manager = new_class._base_manager._copy_to_model(new_class)
# Add all attributes to the class.
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
# All the fields of any type declared on this model
new_fields = new_class._meta.local_fields + new_class._meta.local_many_to_many + new_class._meta.virtual_fields
field_names = set(f.name for f in new_fields)
# Basic setup for proxy models.
if is_proxy:
base = None
for parent in [kls for kls in parents if hasattr(kls, "_meta")]:
if parent._meta.abstract:
if parent._meta.fields:
raise TypeError(
"Abstract base class containing model fields not permitted for proxy model '%s'." % name
)
else:
continue
if base is not None:
raise TypeError("Proxy model '%s' has more than one non-abstract model base class." % name)
else:
base = parent
if base is None:
raise TypeError("Proxy model '%s' has no non-abstract model base class." % name)
if new_class._meta.local_fields or new_class._meta.local_many_to_many:
raise FieldError("Proxy model '%s' contains model fields." % name)
new_class._meta.setup_proxy(base)
new_class._meta.concrete_model = base._meta.concrete_model
else:
new_class._meta.concrete_model = new_class
# Collect the parent links for multi-table inheritance.
parent_links = {}
for base in reversed([new_class] + parents):
# Conceptually equivalent to `if base is Model`.
if not hasattr(base, "_meta"):
continue
# Skip concrete parent classes.
if base != new_class and not base._meta.abstract:
continue
# Locate OneToOneField instances.
for field in base._meta.local_fields:
if isinstance(field, OneToOneField):
parent_links[field.rel.to] = field
# Do the appropriate setup for any model parents.
for base in parents:
original_base = base
if not hasattr(base, "_meta"):
# Things without _meta aren't functional models, so they're
# uninteresting parents.
continue
parent_fields = base._meta.local_fields + base._meta.local_many_to_many
# Check for clashes between locally declared fields and those
# on the base classes (we cannot handle shadowed fields at the
# moment).
for field in parent_fields:
if field.name in field_names:
raise FieldError(
"Local field %r in class %r clashes "
"with field of similar name from "
"base class %r" % (field.name, name, base.__name__)
)
if not base._meta.abstract:
# Concrete classes...
base = base._meta.concrete_model
if base in parent_links:
field = parent_links[base]
elif not is_proxy:
attr_name = "%s_ptr" % base._meta.model_name
field = OneToOneField(base, name=attr_name, auto_created=True, parent_link=True)
new_class.add_to_class(attr_name, field)
else:
field = None
new_class._meta.parents[base] = field
else:
# .. and abstract ones.
for field in parent_fields:
new_class.add_to_class(field.name, copy.deepcopy(field))
# Pass any non-abstract parent classes onto child.
new_class._meta.parents.update(base._meta.parents)
# Inherit managers from the abstract base classes.
new_class.copy_managers(base._meta.abstract_managers)
# Proxy models inherit the non-abstract managers from their base,
# unless they have redefined any of them.
if is_proxy:
new_class.copy_managers(original_base._meta.concrete_managers)
# Inherit virtual fields (like GenericForeignKey) from the parent
# class
for field in base._meta.virtual_fields:
if base._meta.abstract and field.name in field_names:
raise FieldError(
"Local field %r in class %r clashes "
"with field of similar name from "
"abstract base class %r" % (field.name, name, base.__name__)
)
new_class.add_to_class(field.name, copy.deepcopy(field))
if abstract:
# Abstract base models can't be instantiated and don't appear in
# the list of models for an app. We do the final setup for them a
# little differently from normal models.
attr_meta.abstract = False
new_class.Meta = attr_meta
return new_class
new_class._prepare()
new_class._meta.apps.register_model(new_class._meta.app_label, new_class)
return new_class
def app_config(self):
if not self._app_config:
self._app_config = apps.get_containing_app_config(self.model.__module__)
return self._app_config
def namespace(self):
module = "{}.{}".format(self.flow_cls.__module__, self.flow_cls.__name__)
app_config = apps.get_containing_app_config(module)
subpath = module.lstrip(app_config.module.__package__+'.flows.')
return "{}/{}".format(app_config.label, subpath)
def get_app_label(module):
app_config = apps.get_containing_app_config(module)
return app_config.label
def __new__(cls, name, bases, attrs):
new_class = super(BrushfireModelBase, cls).__new__(cls, name, bases, attrs)
parents = [b for b in bases if isinstance(b, BrushfireModelBase)]
module = attrs.pop('__module__')
attr_meta = attrs.pop('Meta', None)
if not attr_meta:
meta = getattr(new_class, 'Meta', None)
else:
meta = attr_meta
app_config = apps.get_containing_app_config(module)
setattr(new_class, 'objects', BrushfireManager(new_class))
if getattr(meta, 'app_label', None):
label = meta.app_label
elif app_config:
label = app_config.label
else:
label = '__NONE__'
new_class.add_to_class('_meta', Options(meta,
**{'app_label':label}))
new_class.add_to_class(
'DoesNotExist',
subclass_exception(
str('DoesNotExist'),
(ObjectDoesNotExist,),
module,
attached_to=new_class))
new_class.add_to_class(
'MultipleObjectsReturned',
subclass_exception(
str('MultipleObjectsReturned'),
(MultipleObjectsReturned,),
module,
attached_to=new_class))
if new_class._meta.proxy:
raise BrushfireException, "BrushfireModels proxies not allowed."
# add attributes to class
for obj_name, obj in attrs.items():
new_class.add_to_class(obj_name, obj)
new_fields = chain(
new_class._meta.local_fields,
new_class._meta.local_many_to_many,
new_class._meta.virtual_fields
)
field_names = {f.name for f in new_fields}
new_class._meta.concrete_model = new_class
# Do the appropriate setup for any model parents.
for base in parents:
if not hasattr(base, '_meta'):
# Things without _meta aren't functional models, so they're
# uninteresting parents.
continue
parent_fields = base._meta.local_fields + base._meta.local_many_to_many
# Check for clashes between locally declared fields and those
# on the base classes (we cannot handle shadowed fields at the
# moment).
for field in parent_fields:
if field.name in field_names:
raise FieldError(
'Local field %r in class %r clashes '
'with field of similar name from '
'base class %r' % (field.name, name, base.__name__)
)
# Inherit virtual fields (like GenericForeignKey) from the parent
# class
for field in base._meta.virtual_fields:
if base._meta.abstract and field.name in field_names:
raise FieldError(
'Local field %r in class %r clashes '
'with field of similar name from '
'abstract base class %r' % (field.name, name, base.__name__)
)
new_class.add_to_class(field.name, copy.deepcopy(field))
# Keep this stuff last
new_class._prepare()
# ModelBase calls this, not sure what it does or if we need it here. Need to investigate further.
#new_class._meta.apps.register_model(new_class._meta.app_label, new_class)
return new_class
def __init__(self, view):
from django.apps import apps
app = apps.get_containing_app_config(utils.qualified_name(view))
super(ViewMeta, self).__init__(app, view.__name__)
self.view = view