Package: django-quicky
Django-quickyA collection of tools to make setting up Django quicker.It is NOT a microframework and is meant to be used withing an ordinary Django
setup as it's fully compatible with the standard usages.You will love this tool if you ever wished you could do:@url('/user/\d+')@view(render_to='user.html')defuser_view(request,id):# ...return{'users':users}@user_view.ajax(render_to='json')defajax_user_view(request,id,context):# ...returncontextNote that this software is beta, but it's already used in production.Justpip install django-quicky.Url decoratorsIf you like micro frameworks likebottle, you probably miss the very easy way to declare a route.Now you can do this:fromdjango_quickyimportroutingurl,urlpatterns=routing()@url('/any/regex/django/accepts')defan_ordinary_view(request):#...@url('/you/can/stack/routing')@url('/any/regex/django/accepts')defan_ordinary_view(request):# ...Just declare your routes in the view. And use your view file inURL_ROOTor anyinclude()like you would do withurls.py.Remember, order matters, so:views declared first will match first. Avoid declaring@url(r'^$')first (at the begining of views.py) or it will prevent others from matching.when using several@urlon the same view, the first applied (the lowest@urlin the decorators pile) will match first.always put@urlas the LAST decorator applied (at the very top of the decorators pile).If you are in the mood for fancy stuff, and feel like adding a url manually, just do:urlpatterns.add_url(url,view,[kwargs,name,prefix])And for an include:urlpatterns.include(url,view,[name,prefix])And since you often add the admin url:urlpatterns.add_admin(url)Adding http error views is neither hard nor useful (most of the time), but for completeness:@url.http404defhttp404(request):# ...Of course, your view needs to return the proper status code.View decoratorsRendering template and json bore you to death?fromdjango_quickyimportview@view(render_to='template.html')defan_ordinary_view(request):return{'stuff':stuff}@view(render_to='json')defa_json_view(request):return{'stuff':stuff}@view(render_to='raw')defa_raw_view(request):return'hey'For the first one, the returned dictionary will be used as a context (with RequestContext) to render the template. For the second one, it will be serialised to JSON. The last one will just return the string./!\ WARNING:The view decorator should always be the first decorator to be applied (the lowest one in the decorator pile).Conditional renderingYou can also declare alternatives based on a condition, for a single view:fromdjango_quickyimportview@view(render_to='template.html')defcommon_views(request):return{'stuff':stuff}@common_views.post()defpost_view(request,context):# do more stuffreturncontext@common_views.ajax(render_to='json')defjson_view(request,context):returncontextThe first view will be rendered as-is if it receives a normal GET request. The second view will be rendered only for POST requests, but will be passed the result of the execution of the first view. The second view will be rendered only for AJAX requests, and as JSON, but will be passed the result of the execution first view.Just remember that alternative views must acceptcontextas a parameter, because they will always receive the result of the main view.Oh, and of course you can define your own conditions:@view(render_to='template.html')defcommon_views(request):return{'stuff':stuff}@common_views.render_if(conditon=a_function_that_returns_a_bool)defconditional_view(request,context):# do more stuffreturncontextSuper user middlewareDouble authentification? Short session timeout? Permission issue? Loooooooong password.In, dev, just do:ifDEBUG:MIDDLEWARE_CLASSES+=('django_quicky.middleware.ForceSuperUserMiddleWare',)You will always be logged in as a super user. No password required. No timeout.Serve static middlewareServing static files IN DEV without worries:ifDEBUG:MIDDLEWARE_CLASSES+=('django_quicky.middleware.StaticServe',)And if you do want to test your site withDEBUGset to False, you can just remove the condition.The middleware accessesrequest.META['HTTP_HOST']on requests but uses "django_quicky_fake_host" as a fallback for clients that don't provide it via headers (e.g: Django's test client). If you want to specify a different fallback host, you can do so by settingDJANGO_QUICKY_DEFAULT_HOSTin your settings.py file.(Idea borrowed from the excellentdjango-annoying, but I stripped the internal test onDEBUGwhich is a pain during testing.)Settings context processorBecause everyone ends up needing access to the settings in his templates one day or the other:TEMPLATE_CONTEXT_PROCESSORS=(..."django_quicky.context_processors.settings")Loading settingsWhen you are not in Django, you may still want to import some django pieces, but they require a settings file.This function make it easy to do so:fromdjango_quickyimportload_configload_config('/absolute/path/to/setting/file.py')You can also call it with a relative path:load_config('../../relative/path/to/setting/file.py')But the starting point will be the one given with os.getcwd(), which is probably not what you want. You can force a starting point, most often you'll want the current file, by passing it manually:load_config('../../relative/path/to/setting/file.py',starting_point=__file__)starting_pointcan be either a file (basename will be stripped) or a directory.You can also pass a directory path, in which case Python will try to load a settings module from this directory:load_config('/path/to/settings/directory')It will attempt to load a module named as inos.environ['DJANGO_SETTINGS_MODULE']or default tosettings. You can force the name by passing thesettings_moduleparameter.DEBUGGINGThe first rule when debugging decorators, is to be sure you use the right syntax:@decoratorand@decorator()are very different and both syntaxically valid. In django-quickly's case, all decorators should be called with@decorator()or@decorator(arguments).Also remember that when it comes to decorators,order matters. Most of the time, you don't care about the order you apply your decorators, but in this case, you should ALWAYS apply@viewfirst and@urllast. E.G:@url(r'$')@login_required@view('app/home.html')defhome(request):# ...If you don't do this, some decorators will never be executed as@viewbypasses decorators applied before it and@urlbypasses decorators after it.Also, the order in which you declare your fonction matters, just like patterns order matters inurls.py. So avoid putting global matching urls such as@url('^$')at the begining ofviews.py, otherwise this view will be used all the time, since the others will never have a chance to match.Last wordsThere are other utility functions, but I didn't take the time to document them here, so you'll have to dig in the code. fields.py contains some useful model fields, utils.py has some shortcut functions and models.py comes with tools to get random entries or patch a model.BTW, it's under thezlib license.It embedsnamegen, a name generator under BSD license.