Esempio n. 1
0
    def build_suite(self, test_labels, extra_tests=None, **kwargs):
        cache = AppCache()

        get_app = cache.get_app
        get_apps = cache.get_apps

        suite = unittest.TestSuite()

        #get all features for given apps
        if test_labels:
            for label in test_labels:
                if '.' in label:
                    print 'Ignoring label with dot in: ' % label
                    continue
                app = get_app(label)

                features_dir = get_features(app)
                if features_dir is not None:
                    suite.addTest(self.make_bdd_test_suite(features_dir))
        else:
            for app in get_apps():
                features_dir = get_features(app)
                if features_dir is not None:
                    suite.addTest(self.make_bdd_test_suite(features_dir))

        return reorder_suite(suite, (LiveServerTestCase, ))
Esempio n. 2
0
 def _redo_app_cache(self):
     """
     Used to repopulate AppCache after fiddling with INSTALLED_APPS.
     """
     a = AppCache()
     a.loaded = False
     a._populate()
Esempio n. 3
0
    def _reload_models_module(self, app_name):
        """
        Reload Django models
        Based on http://stackoverflow.com/questions/890924/how-do-you-reload-a-django-model-module-using-the-interactive-interpreter-via-m
        """
        curdir = os.getcwd()
        cache = AppCache()
        for app in cache.get_apps():

            f = app.__file__
            if f.startswith(curdir) and f.endswith('.pyc'):
                try:
                    os.remove(f)
                except Exception:
                    pass
            __import__(app.__name__)
            reload(app)

        cache.app_store = SortedDict()
        cache.app_models = SortedDict()
        cache.app_errors = {}
        cache.handled = {}
        cache.loaded = False

        # Reset app's models in global scope
        # Using a dictionary here instead of cache.get_models(app_name)
        # The latter does not seem to work (look into that)
        reimported_app = importlib.import_module("{}.models".format(app_name))
        model_names = self.model_globals[app_name]
        for model_name in model_names:
            self.shell_globals[model_name] = getattr(reimported_app,
                                                     model_name)
            self._update_class_instances(reimported_app, model_name)
Esempio n. 4
0
 def _redo_app_cache(self):
     """
     Used to repopulate AppCache after fiddling with INSTALLED_APPS.
     """
     a = AppCache()
     a.loaded = False
     a.handled = {}
     a.postponed = []
     a.app_store = SortedDict()
     a.app_models = SortedDict()
     a.app_errors = {}
     a._populate()
def reload_django_appcache():
    cache = AppCache()

    cache.app_store = SortedDict()
    cache.app_models = SortedDict()
    cache.app_errors = {}
    cache.handled = {}
    cache.loaded = False

    for app in cache.get_apps():
        __import__(app.__name__)
        reload(app)
Esempio n. 6
0
 def test_missing_app(self):
     """
     Test that repeated app loading doesn't succeed in case there is an
     error. Refs #17667.
     """
     # AppCache is a Borg, so we can instantiate one and change its
     # loaded to False to force the following code to actually try to
     # populate the cache.
     a = AppCache()
     a.loaded = False
     try:
         with override_settings(INSTALLED_APPS=('notexists',)):
             self.assertRaises(ImportError, get_model, 'notexists', 'nomodel', seed_cache=True)
             self.assertRaises(ImportError, get_model, 'notexists', 'nomodel', seed_cache=True)
     finally:
         a.loaded = True
    def handle(self, *args, **options):
        apps = AppCache()
        check = []
        for module in apps.get_apps():
            for d in module.__dict__:
                ref = getattr(module, d)
                if isinstance(ref, simpledb.models.ModelMetaclass):
                    domain = ref.Meta.domain.name
                    if domain not in check:
                        check.append(domain)

        sdb = simpledb.SimpleDB(settings.AWS_KEY, settings.AWS_SECRET)
        domains = [d.name for d in list(sdb)]
        for c in check:
            if c not in domains:
                sdb.create_domain(c)
                print "Creating domain %s ..." % c
Esempio n. 8
0
def reload_models():
    import os
    from django.db.models.loading import AppCache
    cache = AppCache()

    curdir = os.getcwd()

    for app in cache.get_apps():
        f = app.__file__
        if f.startswith(curdir) and f.endswith('.pyc'):
            os.remove(f)
        __import__(app.__name__)
        reload(app)

    from django.utils.datastructures import SortedDict
    cache.app_store = SortedDict()
    cache.app_models = SortedDict()
    cache.app_errors = {}
    cache.handled = {}
    cache.loaded = False
Esempio n. 9
0
def create_node_model(name,
                      fields=None,
                      app_label='',
                      module='',
                      options=None):
    """
    Create specified model
    """
    from app.detective.models import update_topic_cache, delete_entity
    from neo4django.db import models
    from django.db.models.loading import AppCache
    # Django use a cache by model
    cache = AppCache()
    # If we already create a model for this app
    if app_label in cache.app_models and name.lower(
    ) in cache.app_models[app_label]:
        # We just delete it quietly
        del cache.app_models[app_label][name.lower()]

    class Meta:
        # Using type('Meta', ...) gives a dictproxy error during model creation
        pass

    if app_label:
        # app_label must be set using the Meta inner class
        setattr(Meta, 'app_label', app_label)
    # Update Meta with any options that were provided
    if options is not None:
        for key, value in options.iteritems():
            setattr(Meta, key, value)
    # Set up a dictionary to simulate declarations within a class
    attrs = {'__module__': module, 'Meta': Meta}
    # Add in any fields that were provided
    if fields: attrs.update(fields)
    # Create the class, which automatically triggers ModelBase processing
    cls = type(name, (FluidNodeModel, ), attrs)
    signals.post_save.connect(update_topic_cache, sender=cls)
    signals.post_delete.connect(delete_entity, sender=cls)
    return cls
Esempio n. 10
0
def section(request, section_path=None, id_override=None):
    """
    A view of a section.
    """
    try:
        section = get_current_section()
    except MiddlewareNotUsed:
        lookup_from = id_override or request
        section = lookup_section(lookup_from)
    if section:
        return simple.direct_to_template(request,
                                         template="scaffold/section.html",
                                         extra_context={'section': section})
    else:
        app_cache = AppCache()
        try:
            app_cache.get_app('flatpages')
            try:
                return flatpage(request, request.path_info)
            except Http404:
                pass
        except ImproperlyConfigured:
            pass
        raise Http404, "Section does not exist."
Esempio n. 11
0
#! /usr/bin/env python

from sqlalchemy import types, Column, Table

import django
from django.conf import settings
try:
    from django.apps import apps as django_apps
except ImportError:
    from django.db.models.loading import AppCache
    django_apps = AppCache()

from aldjemy.types import simple, foreign_key, varchar

DATA_TYPES = {
    'AutoField':
    simple(types.Integer),
    'BigAutoField':
    simple(types.BigInteger),
    'BooleanField':
    simple(types.Boolean),
    'CharField':
    varchar,
    'CommaSeparatedIntegerField':
    varchar,
    'DateField':
    simple(types.Date),
    'DateTimeField':
    simple(types.DateTime),
    'DecimalField':
    lambda x: types.Numeric(scale=x.decimal_places, precision=x.max_digits),
Esempio n. 12
0
    def render(self, request):
        from django.db.models.query import QuerySet
        seria = self.construct()
        title = "table"
        heads = ""

        if isinstance(self.data, QuerySet):

            model = self.data.model
            fields = [('|' in f) and f.split("|")[0] or f for f in self.fields]
            heads = [get_field_verbosename(model, f, ".") for f in fields]
            title = model._meta.verbose_name
            self.cells = []
            for a in seria:
                cells_list = []
                for f in fields:
                    if f in a:
                        f_check = '.' in f and f.split('.')[0] or f
                        field = ""
                        try:
                            field = model._meta.get_field(f_check)
                        except:
                            pass
                        if field:
                            if isinstance(
                                    field,
                                    models.fields.related.ManyToManyField):
                                m2m_field_display = hasattr(
                                    model, 'Admin'
                                ) and model.Admin.api_m2m_display[
                                    f] or ""  #m2m要显示字段,多对多字段要导出必须在api_fields中配置要显示的字段(一个或多个,多个时用“ ”隔开显示)
                                m2m_field_verbose = []
                                for record in a[f]:
                                    d_list = []
                                    for d in m2m_field_display.split('.'):
                                        d_list.append(record[d])
                                    m2m_field_verbose.append(' '.join(d_list))
                                cells_list.append(','.join(m2m_field_verbose))
                            elif type(a[f]) == dict and isinstance(
                                    field, models.fields.related.ForeignKey):
                                if u"%s" % a[f]['id'] == 'None':
                                    cells_list.append('')
                                else:
                                    if hasattr(field.rel.to, "export_unicode"):
                                        instance = field.rel.to.objects.get(
                                            id=a[f]['id'])
                                        if instance:
                                            cells_list.append(
                                                instance.export_unicode())
                                    else:
                                        cells_list.append(a[f])
                            else:
                                if a[f] == None:
                                    cells_list.append('')
                                else:
                                    if type(a[f]) == dict and u"%s" % (
                                            a[f]['verbose']) == 'None':
                                        cells_list.append('')
                                    else:
                                        cells_list.append(a[f])

                        else:
                            if a[f] == None:
                                cells_list.append('')
                            else:
                                if type(a[f]) == dict and u"%s" % (
                                        a[f]['verbose']) == 'None':
                                    cells_list.append('')
                                else:
                                    cells_list.append(a[f])

                self.cells.append(tuple(cells_list))

        else:
            try:
                from django.db.models.loading import AppCache
                http_app = request.META["HTTP_REFERER"].split("/")[-3]
                http_model = request.META["HTTP_REFERER"].split("/")[-2]
                modelname = AppCache().app_models.get(http_app).get(
                    http_model.lower())
                title = modelname._meta.verbose_name
            except:
                title = "table"

            fields = self.fields or (self.data and self.data[0].keys() or [])
            self.cells = [
                tuple([a[f] or '' for f in fields if f in a]) for a in seria
            ]

        self.head = heads
        if hasattr(request, "special_head"):
            self.head = request.special_head
        rn = request.REQUEST.get("reportname", '')
        title = rn and rn or title
        #print "---rn=%s---title=%s"%(rn,title)
        self.title = title
        self.file_name = "%s_%s" % (
            title, datetime.datetime.now().strftime("%Y%m%d%H%M%S"))
        return self.render_data(request)
Esempio n. 13
0
from django.db.models.loading import AppCache
cache = AppCache()

for app in cache.get_apps():
    __import__(app.__name__)
    reload(app)

from django.utils.datastructures import SortedDict
cache.app_store = SortedDict()
cache.app_models = SortedDict()
cache.app_errors = {}
cache.handled = {}
cache.loaded = False
Esempio n. 14
0
# from https://github.com/dgreisen/django-traversal/blob/master/appring.py
# Apache 2.0 licensed

try:
    from django.db.models.loading import AppCache
    apps = AppCache()
except:
    from django.apps import apps
from django.conf import settings
from importlib import import_module
from types import ModuleType


class Apps(object):
    """
    Return a ModuleWrapper-wrapped instance of the app module. The ModuleWrapper
    makes it easy to get to nested submodules through a dot notation. No need to
    do further importing.
    """
    def __init__(self):
        self.app_paths = {x.split('.')[-1]: x for x in settings.INSTALLED_APPS}

    def __getattr__(self, name):
        """
        If the package doesn't exist, then locate it, attach it and return it
        """
        try:
            packageString = self.app_paths[name]
            package = import_module(packageString)
            package = ModuleWrapper(package, packageString)
            setattr(self, name, package)
Esempio n. 15
0
from django.db import models
from django.db.models.loading import AppCache

app_cache = AppCache()


class DefaultTracker(models.Model):
    built = models.BooleanField(default=False)
    needs_rebuild = models.BooleanField(default=False)

    class Meta:
        abstract = True


class AppDefaultTracker(DefaultTracker):
    app_name = models.CharField(max_length=100, unique=True)

    def get_or_create_model_tracker(self, model_name):
        created = False
        try:
            m = self.model_trackers.get(model_name=model_name)
        except ModelDefaultTracker.DoesNotExist:
            m = self.model_trackers.create(model_name=model_name)
        if created:
            self.built = False
            self.save()
        return m

    def check_models(self):
        built = self.built
        needs_rebuild = False
Esempio n. 16
0
def get_django_models():
    ac = AppCache()
    return ac.get_models()
Esempio n. 17
0
 def redo_app_cache(self):
     from django.db.models.loading import AppCache
     a = AppCache()
     a.loaded = False
     a._populate()