def run_pyflakes_for_package(package_name, extra_ignore=None): """ If pyflakes is installed, run it across the given package name returning any warnings found. """ ignore_strings = PYFLAKES_IGNORE if extra_ignore: ignore_strings += extra_ignore try: from pyflakes.checker import Checker except ImportError: return [] warnings = [] for (root, dirs, files) in os.walk(path_for_import(package_name)): for f in files: # Ignore migrations. directory = root.split(os.sep)[-1] if not f.endswith(".py") or directory == "migrations": continue path = os.path.join(root, f) with open(path, "U") as source_file: source = source_file.read() try: compile(source, f, "exec") except (SyntaxError, IndentationError), value: info = (path, value.lineno, value.args[0]) warnings.append("Invalid syntax in %s:%d: %s" % info) result = Checker(parse(source), path) for warning in result.messages: message = unicode(warning) for ignore in ignore_strings: if ignore in message: break else: warnings.append(message)
def handle_label(self, theme_name, **options): """ Copy the templates and media files for the given theme package into the current project. """ try: theme_path = path_for_import(theme_name) except ImportError: raise CommandError("Could not import the theme: %s" % theme_name) copy_paths = ( (os.path.join(theme_path, "templates"), settings.TEMPLATE_DIRS[-1]), (os.path.join(theme_path, "media"), settings.MEDIA_ROOT), ) if options.get("interactive"): confirm = raw_input(""" Theme installation may overwrite existing template and media files. Are you sure you want to do this? Type 'yes' to continue, or 'no' to cancel: """) if confirm != "yes": raise CommandError("Theme installation cancelled.") for (path_from, path_to) in copy_paths: if os.path.exists(path_from): copy_tree(path_from, path_to)
def handle_label(self, theme_name, **options): """ Create a new Django app and copy all available templates into it. """ super(Command, self).handle_label(theme_name, **options) # Build a unique list of template names from ``INSTALLED_APPS`` and # ``TEMPLATE_DIRS`` then determine which template files they belong # to and copy them to the theme/templates directory. templates = set() for app in settings.INSTALLED_APPS: if app.startswith("django.") or app in settings.OPTIONAL_APPS: continue templates_path = os.path.join(path_for_import(app), "templates") for (root, dirs, files) in os.walk(templates_path): for f in files: template = os.path.join(root, f)[len(templates_path):] if not template.startswith("/admin/"): templates.add(template.lstrip("/")) templates_path = os.path.join(theme_name, "templates") os.mkdir(templates_path) for template in templates: path_from = unicode(template_path(template)) path_to = os.path.join(templates_path, template) try: os.makedirs(os.path.dirname(path_to)) except OSError: pass copy(path_from, path_to) copytree(settings.MEDIA_ROOT, os.path.join(theme_name, "media"))
def serve_with_theme(request, path): """ Mimics ``django.views.static.serve`` for serving files from ``MEDIA_ROOT`` during development, first checking for the file in the theme defined by the ``THEME`` setting if specified. """ theme = getattr(settings, "THEME") if theme: theme_root = os.path.join(path_for_import(theme), "media") try: return serve(request, path, document_root=theme_root) except Http404: pass return serve(request, path, document_root=settings.MEDIA_ROOT)
def create_project(): """ Copies the contents of the project_template directory to a new directory specified as an argument to the command line. """ parser = OptionParser(usage="usage: %prog [options] project_name") parser.add_option("-a", "--alternate", dest="alt", metavar="PACKAGE", help="Alternate package to use, containing a project_template") parser.add_option("-s", "--source", dest="copy_source", default=False, action="store_true", help="Copy package source to new project") parser.add_option("-t", "--templates", dest="copy_templates", default=True, action="store_false", help="Copy templates to the project [default]") (options, args) = parser.parse_args() if len(args) != 1: parser.error("project_name must be specified") project_name = args[0] if project_name.startswith("-"): parser.error("project_name cannot start with '-'") project_path = os.path.join(os.getcwd(), project_name) # Ensure the given directory name doesn't clash with an existing Python # package/module. try: __import__(project_name) except ImportError: pass else: parser.error("'%s' conflicts with the name of an existing " "Python module and cannot be used as a project name. " "Please try another name." % project_name) # Create the list of packages to build from - at this stage it should # only be one or two names, mezzanine plus an alternate package. packages = ["mezzanine"] if options.alt: packages.append(options.alt) for package_name in packages: try: __import__(package_name) except ImportError: parser.error("Could not import package '%s'" % package_name) # Build the project up copying over the project_template from each of # the packages. for package_name in packages: package_path = path_for_import(package_name) if options.copy_source: copy_tree(package_path, os.path.join(project_path, package_name)) copy_tree(os.path.join(package_path, "project_template"), project_path) move(os.path.join(project_path, "local_settings.py.template"), os.path.join(project_path, "local_settings.py")) if options.copy_templates: template_path = os.path.join(project_path, "templates") for app_dir in os.listdir(package_path): template_dir = os.path.join(package_path, app_dir, "templates") if os.path.isdir(template_dir): copy_tree(template_dir, template_path) # Generate a unique SECREY_KEY for the project's setttings module. settings_path = os.path.join(os.getcwd(), project_name, "settings.py") with open(settings_path, "r") as f: data = f.read() with open(settings_path, "w") as f: secret_key = "%s%s%s" % (uuid4(), uuid4(), uuid4()) f.write(data.replace("%(SECRET_KEY)s", secret_key)) # Clean up pyc files. for (root, dirs, files) in os.walk(project_path, False): for f in files: if f.endswith(".pyc"): os.remove(os.path.join(root, f))
def set_dynamic_settings(s): """ Called at the end of the project's settings module and is passed its globals dict for updating with some final tweaks for settings that generally aren't specified but can be given some better defaults based on other settings that have been specified. Broken out into its own function so that the code need not be replicated in the settings modules of other project-based apps that leverage Mezzanine's settings module. """ s["TEMPLATE_DEBUG"] = s["DEBUG"] add_to_builtins("mezzanine.template.loader_tags") # Set ADMIN_MEDIA_PREFIX for Grappelli. if s.get("PACKAGE_NAME_GRAPPELLI") in s["INSTALLED_APPS"]: # Adopted from django.core.management.commands.runserver # Easiest way so far to actually get all the media for Grappelli # working with the dev server is to hard-code the host:port to # ADMIN_MEDIA_PREFIX, so here we check for a custom host:port # before doing this. if len(sys.argv) >= 2 and sys.argv[1] == "runserver": addrport = "" if len(sys.argv) > 2: addrport = sys.argv[2] if not addrport: addr, port = "", "8000" else: try: addr, port = addrport.split(":") except ValueError: addr, port = "", addrport if not addr: addr = "127.0.0.1" s["ADMIN_MEDIA_PREFIX"] = "http://%s:%s%s" % (addr, port, s["ADMIN_MEDIA_PREFIX"]) # Some settings tweaks for different DB engines. backend_path = "django.db.backends." backend_shortnames = ( "postgresql_psycopg2", "postgresql", "mysql", "sqlite3", "oracle", ) for (key, db) in s["DATABASES"].items(): if db["ENGINE"] in backend_shortnames: s["DATABASES"][key]["ENGINE"] = backend_path + db["ENGINE"] shortname = db["ENGINE"].split(".")[-1] if shortname == "sqlite3" and os.sep not in db["NAME"]: # If the Sqlite DB name doesn't contain a path, assume it's # in the project directory and add the path to it. s["DATABASES"][key]["NAME"] = os.path.join( s.get("_project_path", ""), db["NAME"]) elif shortname == "mysql": # Required MySQL collation for tests. s["DATABASES"][key]["TEST_COLLATION"] = "utf8_general_ci" elif shortname.startswith("postgresql") and not s.get("TIME_ZONE", 1): # Specifying a blank time zone to fall back to the system's # time zone will break table creation in Postgres so remove it. del s["TIME_ZONE"] # If a theme is defined then add its template path to the template dirs. theme = s.get("THEME") if theme: theme_templates = os.path.join(path_for_import(theme), "templates") s["TEMPLATE_DIRS"] = [theme_templates] + list(s["TEMPLATE_DIRS"]) # Remaining code is for Django 1.1 support. if VERSION >= (1, 2, 0): return # Add the dummy csrf_token template tag to builtins and remove # Django's CsrfViewMiddleware. add_to_builtins("mezzanine.core.templatetags.dummy_csrf") s["MIDDLEWARE_CLASSES"] = [mw for mw in s["MIDDLEWARE_CLASSES"] if mw != "django.middleware.csrf.CsrfViewMiddleware"] # Use the single DB settings. old_db_settings_mapping = { "ENGINE": "DATABASE_ENGINE", "HOST": "DATABASE_HOST", "NAME": "DATABASE_NAME", "OPTIONS": "DATABASE_OPTIONS", "PASSWORD": "******", "PORT": "DATABASE_PORT", "USER": "******", "TEST_CHARSET": "TEST_DATABASE_CHARSET", "TEST_COLLATION": "TEST_DATABASE_COLLATION", "TEST_NAME": "TEST_DATABASE_NAME", } for (new_name, old_name) in old_db_settings_mapping.items(): value = s["DATABASES"]["default"].get(new_name) if value is not None: if new_name == "ENGINE" and value.startswith(backend_path): value = value.replace(backend_path, "", 1) s[old_name] = value # Revert to some old names. processors = list(s["TEMPLATE_CONTEXT_PROCESSORS"]) for (i, processor) in enumerate(processors): if processor == "django.contrib.auth.context_processors.auth": processors[i] = "django.core.context_processors.auth" s["TEMPLATE_CONTEXT_PROCESSORS"] = processors loaders = list(s["TEMPLATE_LOADERS"]) for (i, loader) in enumerate(loaders): if loader.startswith("django.") and loader.endswith(".Loader"): loaders[i] = loader.replace(".Loader", ".load_template_source", 1) s["TEMPLATE_LOADERS"] = loaders
from django.conf.urls.defaults import * from django.contrib import admin from mezzanine.conf import settings from mezzanine.utils.path import path_for_import admin.autodiscover() urlpatterns = patterns("", ("^admin/", include(admin.site.urls)), ("^", include("mezzanine.urls")), ) if getattr(settings, "DEV_SERVER", False): media_root = settings.MEDIA_ROOT theme = getattr(settings, "THEME") if theme: media_root = path_for_import(theme) urlpatterns += patterns("", ("^%s/(?P<path>.*)$" % settings.MEDIA_URL.strip("/"), "django.views.static.serve", {"document_root": media_root}), ("^favicon.ico$", "django.views.static.serve", {"document_root": media_root, "path": "img/favicon.ico"}), )
#!/usr/bin/env python # When project_template is used as the actual project during Mezzanine # development, insert the development path into sys.path so that the # development version of Mezzanine is used rather than the installed version. import os import sys project_path = os.path.dirname(os.path.abspath(__file__)) project_dir = project_path.split(os.sep)[-1] if project_dir == "project_template": dev_path = os.path.abspath(os.path.join(project_path, "..", "..")) if dev_path not in sys.path: sys.path.insert(0, dev_path) from mezzanine.utils.path import path_for_import mezzanine_path = path_for_import("mezzanine") assert os.path.abspath(os.path.join(mezzanine_path, "..")) == dev_path from django.core.management import execute_manager try: import settings # Assumed to be in the same directory. except ImportError: import sys sys.stderr.write("Error: Can't find the file 'settings.py' in the " "directory containing %r. It appears you've customized things.\n" "You'll have to run django-admin.py, passing it your settings module.\n" "(If the file settings.py does indeed exist, it's causing an " "ImportError somehow.)\n" % __file__) sys.exit(1) if __name__ == "__main__": execute_manager(settings)
else: INSTALLED_APPS += (app,) INSTALLED_APPS = sorted(list(INSTALLED_APPS), reverse=True) # Optional app settings. from mezzanine.utils.path import path_for_import from mezzanine.utils.conf import set_dynamic_settings if "debug_toolbar" in INSTALLED_APPS: DEBUG_TOOLBAR_CONFIG = {"INTERCEPT_REDIRECTS": False} MIDDLEWARE_CLASSES += ("debug_toolbar.middleware.DebugToolbarMiddleware",) if PACKAGE_NAME_GRAPPELLI in INSTALLED_APPS: GRAPPELLI_ADMIN_HEADLINE = "Mezzanine" GRAPPELLI_ADMIN_TITLE = "Mezzanine" GRAPPELLI_MEDIA_PATH = os.path.join( path_for_import(PACKAGE_NAME_GRAPPELLI), "media") if PACKAGE_NAME_FILEBROWSER in INSTALLED_APPS: FILEBROWSER_URL_FILEBROWSER_MEDIA = "/filebrowser/media/" FILEBROWSER_PATH_FILEBROWSER_MEDIA = os.path.join( path_for_import(PACKAGE_NAME_FILEBROWSER), "media", "filebrowser") # Caching. CACHE_BACKEND = "" CACHE_TIMEOUT = CACHE_MIDDLEWARE_SECONDS = 0 try: import cmemcache except ImportError: try: import memcache except ImportError: CACHE_BACKEND = "locmem:///"