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."
def _redo_app_cache(self):
"""
Used to repopulate AppCache after fiddling with INSTALLED_APPS.
"""
a = AppCache()
a.loaded = False
a._populate()
def get_columns(request,tables):
# Strip leading/trailing whitespace and punctuation (so we only have
# comma-delimited list)
tables = tables.strip(string.whitespace + string.punctuation)
if not tables:
raise Http404
tables = tables.split(",")
app_loader = AppCache()
tables2 = []
real_tables = []
columns = []
for table in tables:
try:
real_table = APP_MAP[table]
model = app_loader.get_model(*real_table.split("."))
tables2.append(table)
real_tables.append(real_table)
columns.append(
model.objects.all().values()[0].keys()
)
except:
pass
return HttpResponse(
json.dumps({
"tables":tables,
"real_tables":real_tables,
"columns":columns
}, indent=4),
mimetype="text/javascript")
def _redo_app_cache(self):
"""
Used to repopulate AppCache after fiddling with INSTALLED_APPS.
"""
a = AppCache()
a.loaded = False
a._populate()
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_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)
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 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, ))
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
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
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)
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)
class Models(object):
def __init__(self):
self.cache = AppCache()
def __getattr__(self, name):
"""
If the package doesn't exist, then locate it, attach it and return it
"""
try:
package = ModelPackage(self.cache.get_app(name), name, self)
setattr(self, name, package)
return package
except:
raise AttributeError("object 'Models' has no attribute '{}'".format(name))
def _get_models(self, pkg):
"""
get the models for a given package. used by Package children
"""
return self.cache.get_models(pkg)
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 render_to_response("scaffold/section.html", {'section': section}, context_instance=RequestContext(request))
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."
def clean_cache():
from django.db.models.loading import AppCache
cache = AppCache()
from django.utils.datastructures import SortedDict
cache.app_store = SortedDict()
cache.app_models = SortedDict()
cache.app_errors = {}
cache.handled = {}
cache.loaded = False
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."
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
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
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
# 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)
def redo_app_cache(self):
from django.db.models.loading import AppCache
a = AppCache()
a.loaded = False
a._populate()
def reload_modules():
"""
Reload modules that don't have any variables that can be reset.
Note that python reloading is a tricky art and strange things have
been known to happen if debugging and reloading a lot. A server
cold reboot is often needed eventually.
"""
# We protect e.g. src/ from reload since reloading it in a running
# server can create unexpected results (and besides, non-evennia devs
# should never need to do that anyway). Updating src requires a server
# reboot. Modules in except_dirs are considered ok to reload despite being
# inside src/
protected_dirs = ('src.', 'django.', 'twisted.') # note that these MUST be tuples!
except_dirs = ('src.commands.default.',) # "
# flag 'dangerous' typeclasses (those which retain a memory
# reference, notably Scripts with a timer component) for
# non-reload, since these cannot be safely cleaned from memory
# without causing havoc. A server reboot is required for updating
# these (or killing all running, timed scripts).
unsafe_modules = []
for scriptobj in ScriptDB.objects.get_all_scripts():
if (scriptobj.interval > -1) and scriptobj.typeclass_path:
unsafe_modules.append(scriptobj.typeclass_path)
unsafe_modules = list(set(unsafe_modules))
def safe_dir_to_reload(modpath):
"Check so modpath is not a subdir of a protected dir, and not an ok exception"
return not any(modpath.startswith(pdir) and not any(modpath.startswith(edir) for edir in except_dirs) for pdir in protected_dirs)
def safe_mod_to_reload(modpath):
"Check so modpath is not in an unsafe module"
return not any(mpath.startswith(modpath) for mpath in unsafe_modules)
#cemit_info(" Cleaning module caches ...")
# clean as much of the caches as we can
cache = AppCache()
cache.app_store = SortedDict()
#cache.app_models = SortedDict() # cannot clean this, it resets ContentTypes!
cache.app_errors = {}
cache.handled = {}
cache.loaded = False
# find modified modules
modified = reimport.modified()
safe_dir_modified = [mod for mod in modified if safe_dir_to_reload(mod)]
unsafe_dir_modified = [mod for mod in modified if mod not in safe_dir_modified]
safe_modified = [mod for mod in safe_dir_modified if safe_mod_to_reload(mod)]
unsafe_mod_modified = [mod for mod in safe_dir_modified if mod not in safe_modified]
string = ""
if unsafe_dir_modified or unsafe_mod_modified:
if unsafe_mod_modified:
string += "\n {rModules containing Script classes with a timer component{n"
string += "\n {rand which has already spawned instances cannot be reloaded safely.{n"
string += "\n {rThese module(s) can only be reloaded by server reboot:{n\n %s\n"
string = string % ", ".join(unsafe_dir_modified + unsafe_mod_modified)
if string:
cemit_info(string)
if safe_modified:
cemit_info(" Reloading safe module(s):{n\n %s" % "\n ".join(safe_modified))
reimport.reimport(*safe_modified)
wait_time = 5
cemit_info(" Waiting %s secs to give modules time to re-cache ..." % wait_time)
time.sleep(wait_time)
cemit_info(" ... all safe modules reloaded.")
else:
cemit_info(" No modules reloaded.")
# clean out cache dictionary of typeclasses, exits and channels
typeclassmodels.reset()
channelhandler.CHANNELHANDLER.update()
#! /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),
def get_django_models():
ac = AppCache()
return ac.get_models()
import json
from django.http import HttpResponseBadRequest, HttpResponse
from lfs.addresses.models import Address
from django.utils import simplejson
from django.conf import settings
from django.db.models.loading import AppCache
from django.core.serializers.json import DjangoJSONEncoder
from django.utils import simplejson
if hasattr(settings, "LFS_ADDRESS_MODEL"):
path, app_name, models, address_model = settings.LFS_ADDRESS_MODEL.rsplit('.',3)
cache = AppCache()
address_model = cache.get_model(app_name, address_model)
else:
address_model = Address
def retrieve_address(request):
""" This function is used to retrieve the address information of an
address, given address id via ajax call
"""
if not request.is_ajax():
return HttpResponseBadRequest("XMLHttpRequest expected")
address_id = request.POST.get('address_id')
address_info = address_model.objects.filter(id=address_id).values()
if address_info is None:
from app.detective import parser, utils
from app.detective.modelrules import ModelRules
from app.detective.models import Topic
from django.conf.urls import url, include, patterns
from django.conf import settings
from django.core.cache import cache
from django.core.urlresolvers import clear_url_caches
from django.db.models.loading import AppCache
from tastypie.api import NamespacedApi
import importlib
import sys
import imp
appcache = AppCache()
class TopicRegistor(object):
__instance = None
def __is_topic(self, topic):
return isinstance(topic, Topic)
def __get_topic_key(self, topic):
key = topic
if self.__is_topic(topic):
key = topic.ontology_as_mod
return key
def __topic_models(self, topic):
key = self.__get_topic_key(topic)
def restart_cache():
import os
from django.db.models.loading import AppCache
cache = AppCache()
cache.loaded = False
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
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
def get_searchable_models():
"""
Returns a list of all models in the Django project which implement ISearchable
"""
app = AppCache();
return filter(lambda klass: implements(klass, ISearchable), app.get_models())
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)
def __init__(self):
app = AppCache()
models = app.get_models()
for m in models:
setattr(self, m.__name__, m)
def get_django_models():
ac = AppCache()
return ac.get_models()
def __init__(self):
self.cache = AppCache()
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
def redo_app_cache(self):
from django.db.models.loading import AppCache
a = AppCache()
a.loaded = False
a._populate()
