File: //usr/lib/python2.7/site-packages/flask/views.pyc
�
n�Dac @ s� d Z d d l m Z d d l m Z e d d d d d d d
d g � Z d e f d
� � YZ d e f d � � YZ
d e e
e � f d � � YZ d S( s�
flask.views
~~~~~~~~~~~
This module provides class-based views inspired by the ones in Django.
:copyright: 2010 Pallets
:license: BSD-3-Clause
i ( t with_metaclass( t requestt gett postt headt optionst deletet putt tracet patcht Viewc B s8 e Z d Z d Z d Z d Z d � Z e d � � Z RS( s� Alternative way to use view functions. A subclass has to implement
:meth:`dispatch_request` which is called with the view arguments from
the URL routing system. If :attr:`methods` is provided the methods
do not have to be passed to the :meth:`~flask.Flask.add_url_rule`
method explicitly::
class MyView(View):
methods = ['GET']
def dispatch_request(self, name):
return 'Hello %s!' % name
app.add_url_rule('/hello/<name>', view_func=MyView.as_view('myview'))
When you want to decorate a pluggable view you will have to either do that
when the view function is created (by wrapping the return value of
:meth:`as_view`) or you can use the :attr:`decorators` attribute::
class SecretView(View):
methods = ['GET']
decorators = [superuser_required]
def dispatch_request(self):
...
The decorators stored in the decorators list are applied one after another
when the view function is created. Note that you can *not* use the class
based decorators since those would decorate the view class and not the
generated view function!
c C s
t � � d S( s� Subclasses have to override this method to implement the
actual view function code. This method is called with all
the arguments from the URL rule.
N( t NotImplementedError( t self( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyt dispatch_requestE s c s� � � � f d � � | j rV | � _ | j � _ x | j D] } | � � � q= Wn | � _ | � _ | j � _ | j � _ | j � _ | j � _ � S( s� Converts the class into an actual view function that can be used
with the routing system. Internally this generates a function on the
fly which will instantiate the :class:`View` on each request and call
the :meth:`dispatch_request` method on it.
The arguments passed to :meth:`as_view` are forwarded to the
constructor of the class.
c s" � j � � � } | j | | � S( N( t
view_classR
( t argst kwargsR ( t
class_argst class_kwargst view( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyR W s ( t
decoratorst __name__t
__module__R t __doc__t methodst provide_automatic_options( t clst nameR R t decorator( ( R R R s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyt as_viewL s N( (
R R R t NoneR R R R
t classmethodR ( ( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyR
s t MethodViewTypec B s e Z d Z d � Z RS( sY Metaclass for :class:`MethodView` that determines what methods the view
defines.
c C s� t t | � j | | | � d | k r� t � } x3 | D]+ } t | d d � r8 | j | j � q8 q8 Wx3 t D]+ } t | | � rn | j
| j � � qn qn W| r� | | _ q� n d S( NR ( t superR t __init__t sett getattrR t updateR t http_method_funcst hasattrt addt upper( R R t basest dR t baset key( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyR" t s
( R R R R" ( ( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyR o s t
MethodViewc B s e Z d Z d � Z RS( s A class-based view that dispatches request methods to the corresponding
class methods. For example, if you implement a ``get`` method, it will be
used to handle ``GET`` requests. ::
class CounterAPI(MethodView):
def get(self):
return session.get('counter', 0)
def post(self):
session['counter'] = session.get('counter', 0) + 1
return 'OK'
app.add_url_rule('/counter', view_func=CounterAPI.as_view('counter'))
c O sw t | t j j � d � } | d k rK t j d k rK t | d d � } n | d k sj t d t j � � | | | � S( Nt HEADR s Unimplemented method %r( R$ R t methodt lowerR t AssertionError( R R R t meth( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyR
� s
( R R R R
( ( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyR. � s N( R t _compatR t globalsR t frozensetR& t objectR
t typeR R. ( ( ( s* /tmp/pip-build-W6Gm0N/Flask/flask/views.pyt <module>
s ![