|
Server : Apache System : Linux cvar2.toservers.com 3.10.0-962.3.2.lve1.5.73.el7.x86_64 #1 SMP Wed Aug 24 21:31:23 UTC 2022 x86_64 User : njnconst ( 1116) PHP Version : 8.4.18 Disable Function : NONE Directory : /lib64/python2.7/site-packages/flask/ |
Upload File : |
�
-/�_c @ s] d Z d d l m Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
m Z d d l m
Z
d d l m Z d d l m Z d d l Z d d l m Z d d
l m Z d d l m Z d d l m Z d d
l m Z d d l m Z d d l m Z d d l m Z d d l m Z y d d l Z Wn e k
rod Z n Xy d d l" Z" Wn e k
r�d Z" n Xd e j# f d � � YZ$ d � Z% dm d � Z& d � Z' d � Z( d � Z) e* d � Z+ d � Z, e j- d g d d d e. d e, d e* d! e* �Z/ d" e0 f d# � � YZ1 d$ e0 f d% � � YZ2 e j3 e2 d& e* �Z4 d' � Z5 d( e j6 f d) � � YZ7 d* e7 f d+ � � YZ8 d, � Z9 d d- � Z: d. � Z; d/ e j< f d0 � � YZ= d1 � Z> d2 e j? f d3 � � YZ@ e jA d4 d5 d6 �e jB d7 d8 d9 d: d d; �e jB d< d= d9 d> d d? �e jB d@ dA e= � d dB �e jB dC dA e j? dD e* dE e. dF e* � d e> d e. d dG �e jB dH d9 d d dI �e jB dJ d9 d d dK �e jB dL d9 d d dM �e jB dN d9 e* d dO �e jB dP d9 d dA e@ � d dQ jC e jD jE � �e4 dR � � � � � � � � � � � � ZF e jA dS d5 dT �e5 dU � � � ZG e jA dV d5 dW �e jB dX dY dA e jH dn � d9 dZ d d^ �e jB d_ d e* d d` �e5 da � � � � � ZI e8 d db jC dc e jJ dd k r
de n df dg e jJ dd k r%dh n di � � ZK e. dj � ZL eM dk k rYeL dl e* � n d S(o s�
flask.cli
~~~~~~~~~
A simple command line application to run flask apps.
:copyright: 2010 Pallets
:license: BSD-3-Clause
i����( t print_functionN( t update_wrapper( t
attrgetter( t Lock( t Thread( t
import_stringi ( t
getargspec( t
itervalues( t reraise( t text_type( t current_app( t get_debug_flag( t get_env( t get_load_dotenvt NoAppExceptionc B s e Z d Z RS( s3 Raised if an application cannot be found or loaded.( t __name__t
__module__t __doc__( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR 0 s c C s� d d l m } x3 d D]+ } t | | d
� } t | | � r | Sq Wg t | j � D] } t | | � rV | ^ qV } t | � d k r� | d St | � d k r� t d j d | j
� � � n x� d D]� } t | | d
� } t j | � r� y& t
| | � } t | | � r| SWq_t k
r[t | � s7� n t d
j d | d | j
� � � q_Xq� q� Wt d j d | j
� � � d
S( sw Given a module instance this tries to find the best possible
application in the module or raises an exception.
i ( t Flaskt appt applicationi st Detected multiple Flask applications in module "{module}". Use "FLASK_APP={module}:name" to specify the correct one.t modulet
create_appt make_apps� Detected factory "{factory}" in module "{module}", but could not call it without arguments. Use "FLASK_APP='{module}:{factory}(args)'" to specify arguments.t factorysn Failed to find Flask application or factory in module "{module}". Use "FLASK_APP={module}:name to specify one.N( s appR ( s
create_appR ( t R t getattrt Nonet
isinstanceR t __dict__t lenR t formatR t inspectt
isfunctiont call_factoryt TypeErrort _called_with_wrong_args( t script_infoR R t attr_nameR t vt matchest app_factory( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt
find_best_app4 s8
1
c C s� t | � } | j } | j } d | k r: | d | | � S| rJ | | � S| ry t | � d k ry | d k ry | | � S| � S( s� Takes an app factory, a ``script_info` object and optionally a tuple
of arguments. Checks for the existence of a script_info argument and calls
the app_factory depending on that and the arguments provided.
R% i N( R t argst defaultsR R ( R% R) t argumentst args_spect arg_namest arg_defaults( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR" g s
%
c C sX t j � d } z= x2 | d k rG | j j | j k r; t S| j } q Wt SWd ~ Xd S( s� Check whether calling a function raised a ``TypeError`` because
the call failed or because something in the factory raised the
error.
:param factory: the factory function that was called
:return: true if the call failed
i N( t syst exc_infoR t tb_framet f_codet __code__t Falset tb_nextt True( R t tb( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR$ z s
c
C s� d d l m } t j d | � } | sC t d j d | � � � n | j � \ } } y t | | � } Wn& t k
r� } t | j d � � n Xt
j | � rp| ry t j
d j d | � � } Wqt t f k
r� } t d j d
| d | � � � qXn d } y t | | | � } Wqvt k
rl} t | � sB� n t d j d
| d | d
| j � � � qvXn | } t | | � r�| St d j d
| j d | � � � d S( s� Checks if the given string is a variable name or a function. If it is a
function, it checks for specified arguments and whether it takes a
``script_info`` argument and calls the function with the appropriate
arguments.
i ( R s% ^ *([^ ()]+) *(?:\((.*?) *,? *\))? *$s= "{name}" is not a valid variable name or function expression.t namei s ({args},)R+ s. Could not parse the arguments in "{app_name}".t et app_namesc {e}
The factory "{app_name}" in module "{module}" could not be called with the specified arguments.R sF A valid Flask application was not obtained from "{module}:{app_name}".N( ( R R t ret matchR R t groupsR t AttributeErrorR+ R R! t astt literal_evalt
ValueErrort SyntaxErrorR" R# R$ R R (
R% R R< R R> R: R+ t attrR; R ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt find_app_by_string� sD " c C s t j j | � } t j j | � \ } } | d k r? | } n t j j | � d k rl t j j | � } n g } xT t r� t j j | � \ } } | j | � t j j t j j
| d � � su Pqu qu Wt j d | k r� t j j d | � n d j
| d d d � � S( s� Given a filename this will try to calculate the python path, add it
to the search path and return the actual module name that is expected.
s .pyt __init__s __init__.pyi t .Ni����(
t ost patht realpatht splitextt basenamet dirnameR8 t splitt appendt existst joinR1 t insert( RJ t fnamet extt module_nameR: ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt prepare_import� s
!c C s� t } y t | � Wnp t k
r� t j � d j r^ t d j d | d t j � � � � q� | r t d j d | � � � q� d Sn Xt j
| } | d k r� t | | � St
| | | � Sd S( Ni����s: While importing "{name}", an ImportError was raised:
{tb}R: R9 s Could not import "{name}".( R8 t
__import__t ImportErrorR1 R2 R7 R R t tracebackt
format_exct modulesR R* RF ( R% RV R< t raise_if_not_foundt __traceback_hide__R ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt
locate_app� s
c C s| | s | j r d Sd d l } d d l m } d } t j | i t j � d 6| d 6| j d 6d | j �| j � d S( Ni����i ( t __version__s7 Python %(python)s
Flask %(flask)s
Werkzeug %(werkzeug)st pythont flaskt werkzeugt color(
t resilient_parsingRc R R` t clickt echot platformt python_versionRd t exit( t ctxt paramt valueRc R` t message( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt get_version s
s --versiont helps Show the flask versiont expose_valuet callbackt is_flagt is_eagert DispatchingAppc B s> e Z d Z e d � Z d � Z d � Z d � Z d � Z RS( s Special application that dispatches to a Flask application which
is imported by name in a background thread. If an error happens
it is recorded and shown as part of the WSGI handling which in case
of the Werkzeug debugger means that it shows up in the browser.
c C sH | | _ d | _ t � | _ d | _ | r: | j � n
| j � d S( N( t loaderR t _appR t _lockt _bg_loading_exc_infot _load_unlockedt _load_in_background( t selfRv t use_eager_loading( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyRG + s
c s2 � f d � } t d | d d � } | j � d S( Nc sK t } � j �6 y � j � Wn t k
r@ t j � � _ n XWd QXd S( N( R8 Rx Rz t ExceptionR1 R2 Ry ( R^ ( R| ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt _load_app6 s
t targetR+ ( ( R t start( R| R t t( ( R| s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR{ 5 s c C s5 t } | j } | d k r1 d | _ t | � n d S( N( R8 Ry R R ( R| R^ R2 ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt _flush_bg_loading_exceptionA s
c C s& t } | j � | _ } d | _ | S( N( R8 Rv Rw R Ry ( R| R^ t rv( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyRz H s c C sw t } | j d k r% | j | | � S| j � | j �9 | j d k rT | j } n | j � } | | | � SWd QXd S( N( R8 Rw R R� Rx Rz ( R| t environt start_responseR^ R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt __call__N s
( R R R R6 RG R{ R� Rz R� ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyRu $ s
t
ScriptInfoc B s) e Z d Z d d e d � Z d � Z RS( s� Helper object to deal with Flask applications. This is usually not
necessary to interface with as it's used internally in the dispatching
to click. In future versions of Flask this object will most likely play
a bigger role. Typically it's created automatically by the
:class:`FlaskGroup` but you can also manually create it and pass it
onwards as click object.
c C sC | p t j j d � | _ | | _ i | _ | | _ d | _ d S( Nt FLASK_APP( RI R� t gett app_import_pathR t datat set_debug_flagR t _loaded_app( R| R� R R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyRG d s
c C s t } | j d k r | j Sd } | j d k rF t | | j � } n� | j r� t j d | j d � d g d \ } } t | � } t | | | � } n? x< d D]4 } t | � } t | | d d t
�} | r� Pq� q� W| s� t d � � n | j rt
� | _ n | | _ | S(
s� Loads the Flask app (if not yet loaded) and returns it. Calling
this multiple times will just result in the already loaded app to
be returned.
s
:(?![\\/])i i s wsgi.pys app.pyR] s� Could not locate a Flask application. You did not provide the "FLASK_APP" environment variable, and a "wsgi.py" or "app.py" module was not found in the current directory.N( s wsgi.pys app.py( R8 R� R R R" R� R= RO RW R_ R6 R R� R t debug( R| R^ R RJ R: t import_name( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt load_appp s.
N( R R R R R8 RG R� ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� [ s t ensurec s% t j � f d � � } t | � � S( s� Wraps a callback so that it's guaranteed to be executed with the
script's application context. If callbacks are registered directly
to the ``app.cli`` object then they are wrapped with this function
by default unless it's disabled.
c s9 | j t � j � j � � | j � | | � SWd QXd S( N( t
ensure_objectR� R� t app_contextt invoke( t __ctxR+ t kwargs( t f( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt decorator� s ( Rf t pass_contextR ( R� R� ( ( R� s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt with_appcontext� s t AppGroupc B s e Z d Z d � Z d � Z RS( s This works similar to a regular click :class:`~click.Group` but it
changes the behavior of the :meth:`command` decorator so that it
automatically wraps the functions in :func:`with_appcontext`.
Not to be confused with :class:`FlaskGroup`.
c s. � j d t � � � � � � f d � } | S( s� This works exactly like the method of the same name on a regular
:class:`click.Group` but it wraps callbacks in :func:`with_appcontext`
unless it's disabled by passing ``with_appcontext=False``.
R� c s1 � r t | � } n t j j � � � � | � S( N( R� Rf t Groupt command( R� ( R+ R� R| t wrap_for_ctx( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s ( t popR8 ( R| R+ R� R� ( ( R+ R� R| R� s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s c O s& | j d t � t j j | | | � S( s� This works exactly like the method of the same name on a regular
:class:`click.Group` but it defaults the group class to
:class:`AppGroup`.
t cls( t
setdefaultR� Rf R� t group( R| R+ R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s ( R R R R� R� ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s t
FlaskGroupc B sJ e Z d Z e d e e e d � Z d � Z d � Z d � Z d � Z RS( sj Special subclass of the :class:`AppGroup` group that supports
loading more commands from the configured Flask app. Normally a
developer does not have to interface with this class but there are
some very advanced use cases for which it makes sense to create an
instance of this.
For information as of why this is useful see :ref:`custom-scripts`.
:param add_default_commands: if this is True then the default run and
shell commands will be added.
:param add_version_option: adds the ``--version`` option.
:param create_app: an optional callback that is passed the script info and
returns the loaded app.
:param load_dotenv: Load the nearest :file:`.env` and :file:`.flaskenv`
files to set environment variables. Will also change the working
directory to the directory containing the first file found.
:param set_debug_flag: Set the app's debug flag based on the active
environment
.. versionchanged:: 1.0
If installed, python-dotenv will be used to load environment variables
from :file:`.env` and :file:`.flaskenv` files.
c K s� t | j d d � p d � } | r4 | j t � n t j | d | | �| | _ | | _ | | _ | r� | j
t � | j
t � | j
t
� n t | _ d S( Nt params( ( t listR� R RP t version_optionR� RG R t load_dotenvR� t add_commandt run_commandt
shell_commandt routes_commandR6 t _loaded_plugin_commands( R| t add_default_commandsR t add_version_optionR� R� t extraR� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyRG � s
c C s{ | j r
d Sy d d l } Wn t k
r: t | _ d SXx0 | j d � D] } | j | j � | j � qK Wt | _ d S( Ni����s flask.commands( R� t
pkg_resourcesRY R8 t iter_entry_pointsR� t loadR: ( R| R� t ep( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt _load_plugin_commands s
c C s� | j � t j | | | � } | d k r/ | S| j t � } y/ | j � j j | | � } | d k rl | SWn t k
r� n Xd S( N( R� R� t get_commandR R� R� R� t cliR ( R| Rk R: R� t info( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� s
c C s | j � t t j j | | � � } | j t � } y# | j | j � j j | � � Wn t
k
rt t j � n Xt
| � S( N( R� t setRf R� t
list_commandsR� R� t updateR� R� R~ RZ t print_exct sorted( R| Rk R� R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� $ s
#
c O s� d t j d <t | j � r& t � n | j d � } | d k r_ t d | j d | j � } n | | d <| j d d � t
t | � j | | � S( Nt truet FLASK_RUN_FROM_CLIt objR R� t auto_envvar_prefixt FLASK(
RI R� R
R� R� R R� R R� R� t superR� t main( R| R+ R� R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� 7 s
N(
R R R R8 R RG R� R� R� R� ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s
c C s/ t j j | | t | � j t j � � | k S( s� Take ``other`` and remove the length of ``path`` from it. Then join it
to ``path``. If it is the original value, ``path`` is an ancestor of
``other``.( RI RJ RR R t lstript sep( RJ t other( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt _path_is_ancestorM s c C s t d k rV | s6 t j j d � s6 t j j d � rR t j d d d d t �n t S| d k r� t j j | � r� t j | � St Sd } x] d D]U } t j
| d t �} | s� q� n | d k r� t j j | � } n t j | � q� W| rt j � | k rt j
| � n | d k S(
sH Load "dotenv" files in order of precedence to set environment variables.
If an env var is already set it is not overwritten, so earlier files in the
list are preferred over later files.
Changes the current working directory to the location of the first file
found, with the assumption that it is in the top level project directory
and will be where the Python path should import local packages from.
This is a no-op if `python-dotenv`_ is not installed.
.. _python-dotenv: https://github.com/theskumar/python-dotenv#readme
:param path: Load the file at this location instead of searching.
:return: ``True`` if a file was loaded.
.. versionchanged:: 1.1.0
Returns ``False`` when python-dotenv is not installed, or when
the given path isn't a file.
.. versionadded:: 1.0
s .envs .flaskenvs^ * Tip: There are .env or .flaskenv files present. Do "pip install python-dotenv" to use them.t fgt yellowt errt usecwdN( s .envs .flaskenv( t dotenvR RI RJ t isfileRf t sechoR8 R6 R� t find_dotenvRN t getcwdt chdir( RJ t new_dirR: ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� T s, *
c C s� t j j d � d k r d S| d k rZ d j | � } | sJ | d 7} n t j | � n t j d j | � � | d k r� t j d d d
�t j d d t �n | d k r� t j d
j | r� d n d � � n d S( s] Show extra startup messages the first time the server is run,
ignoring the reloader.
t WERKZEUG_RUN_MAINR� Ns * Serving Flask app "{0}"s (lazy loading)s * Environment: {0}t
productionsS WARNING: This is a development server. Do not use it in a production deployment.R� t reds( Use a production WSGI server instead.t dims * Debug mode: {0}t ont off( RI R� R� R R Rf Rg R� R8 ( t envR� R� t
eager_loadingRn ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt show_server_banner� s
t
CertParamTypec B s& e Z d Z d Z d � Z d � Z RS( s� Click option type for the ``--cert`` option. Allows either an
existing file, the string ``'adhoc'``, or an import for a
:class:`~ssl.SSLContext` object.
RJ c C s% t j d t d t d t � | _ d S( NRQ t dir_okayt resolve_path( Rf t PathR8 R6 t path_type( R| ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyRG � s c C s t d k r$ t j d | | � � n y | j | | | � SWn� t j k
r� t j | | | � j � } | d k r� y d d l } Wn& t k
r� t j d | | � � n X| St | d t
�} t j d k r� | r� | Sn t
| t j � r� | S� n Xd S(
Ns? Using "--cert" requires Python to be compiled with SSL support.t adhoci����s- Using ad-hoc certificates requires pyOpenSSL.t silenti i i ( i i i ( t sslR Rf t BadParameterR� t STRINGt lowert OpenSSLRY R R8 R1 t version_infoR t
SSLContext( R| Rm Rl Rk R� R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt convert� s.
( R R R R: RG R� ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s c C s | j j d � } | d k } t j d
k rL | oF t | t t f � } n t | t j � } | d k r� | r� t
j d | | � � n | r� t
j d | | � � n | s� t
j d | | � � n | | f | j d <n+ | r| p� | rt
j d | | � � n | S( s� The ``--key`` option must be specified when ``--cert`` is a file.
Modifies the ``cert`` param to be a ``(cert, key)`` pair if needed.
t certR� i i i s. When "--cert" is "adhoc", "--key" is not used.s: When "--cert" is an SSLContext object, "--key is not used.s "--cert" must also be specified.s Required when using "--cert".( i i i N( R� R� R1 R� R R t bytesR� R� R Rf R� ( Rk Rl Rm R� t is_adhoct
is_context( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt
_validate_key� s$ t SeparatedPathTypec B s e Z d Z d � Z RS( s� Click option type that accepts a list of values separated by the
OS's path separator (``:``, ``;`` on Windows). Each value is
validated as a :class:`click.Path` type.
c C sD | j | � } t t | � j } g | D] } | | | | � ^ q( S( N( t split_envvar_valueR� R� R� ( R| Rm Rl Rk t itemst
super_convertt item( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� s ( R R R R� ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s t runt
short_helps Run a development server.s --hosts -ht defaults 127.0.0.1s The interface to bind to.s --ports -pi� s The port to bind to.s --certt types( Specify a certificate file to use HTTPS.s --keyRQ R� R� s2 The key file to use when specifying a certificate.s --reload/--no-reloadsV Enable or disable the reloader. By default the reloader is active if debug is enabled.s --debugger/--no-debuggersV Enable or disable the debugger. By default the debugger is active if debug is enabled.s --eager-loading/--lazy-loadersa Enable or disable eager loading. By default eager loading is enabled if the reloader is disabled.s --with-threads/--without-threadss! Enable or disable multithreading.s
--extra-filessR Extra files that trigger a reload on change. Multiple paths are separated by '{}'.c C s� t � } | d k r | } n | d k r3 | } n | d k rI | } n t t � | | j | � t | j d | �}
d d l m } | | | |
d | d | d | d | d | �d S(
s Run a local development server.
This server is for development purposes only. It does not provide
the stability, security, or performance of production WSGI servers.
The reloader and debugger are enabled by default if
FLASK_ENV=development or FLASK_DEBUG=1.
R} i����( t
run_simplet use_reloadert use_debuggert threadedt ssl_contextt extra_filesN( R R R� R R� Ru R� t werkzeug.servingR� ( R� t hostt portt reloadt debuggerR� t with_threadsR� R� R� R R� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� s& 9
t shells Run a shell in the app context.c
C s� d d l } d d l m } | j j } d t j t j | j | j | j
f } i } t j j
d � } | r� t j j | � r� t | d � �& } t t | j � | d � | � Wd QXn | j | j � � | j d | d
| � d S( s; Run an interactive Python shell in the context of a given
Flask application. The application will populate the default
namespace of this shell according to it's configuration.
This is useful for executing small snippets of management code
without having to manually configure the application.
i����Ni ( t _app_ctx_stacks) Python %s on %s
App: %s [%s]
Instance: %st
PYTHONSTARTUPt rt exect bannert local( t codet globalsR t topR R1 t versionRh R� R� t
instance_pathRI R� R� RJ R� t opent evalt compilet readR� t make_shell_contextt interact( R
R R R Rk t startupR� ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� ` s
(t routess Show the routes for the app.s --sorts -st endpointt methodst ruleR> sg Method to sort routes by. "match" is the order that Flask will match routes when dispatching a request.s
--all-methodss Show HEAD and OPTIONS methods.c C s� t t j j � � } | s, t j d � d St | r; d n d � } | d k rk t | d t | � �} n$ | d k r� t | d d � �} n g | D]" } d
j t | j
| � � ^ q� } d } t d � | D� � t d � | D� � t d � | D� � f } g t | | � D]! \ } } t t
| � | � ^ q} d j | � }
t j |
j | � j � � t j |
j d � | D� � � xE t | | � D]4 \ } } t j |
j | j | | j � j � � q�Wd S( s6 Show all registered routes with endpoints and methods.s No routes were registered.Nt HEADt OPTIONSR R t keyR c S s
t | j � S( N( R� R ( R ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt <lambda>� s s , t Endpointt Methodst Rulec s s | ] } t | j � Vq d S( N( R R ( t .0R ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pys <genexpr>� s c s s | ] } t | � Vq d S( N( R ( R$ R ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pys <genexpr>� s c s s | ] } t | j � Vq d S( N( R R ( R$ R ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pys <genexpr>� s s" {{0:<{0}}} {{1:<{1}}} {{2:<{2}}}c s s | ] } d | Vq d S( t -N( ( R$ t width( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pys <genexpr>� s ( ( s HEADs OPTIONS( s endpoints rule( R! R" R# ( R� R
t url_mapt
iter_rulesRf Rg R� R� R RR R t maxt zipR R t stripR R t rstrip( t sortt all_methodst rulest ignored_methodsR t rule_methodst headerst widthst ht wt rowR ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s(
/7 s� A general utility script for Flask applications.
Provides commands from Flask, extensions, and the application. Loads the
application defined in the FLASK_APP environment variable, or from a wsgi.py
file. Setting the FLASK_ENV environment variable to 'development' will enable
debug mode.
{prefix}{cmd} FLASK_APP=hello.py
{prefix}{cmd} FLASK_ENV=development
{prefix}flask run
t cmdt posixt exportR� t prefixs $ s > c C s- t j d t j d d | r" d n d � d S( NR+ i t prog_names python -m flask( R� R� R1 t argvR ( t as_module( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyR� � s t __main__R= ( ( s endpoints methodss rules match(N R t
__future__R RA R RI Rh R= R1 RZ t functoolsR t operatorR t threadingR R Rf t werkzeug.utilsR t _compatR R R R R R
t helpersR R R
R� RY R R� t
UsageErrorR R* R" R$ RF RW R8 R_ Ro t OptionR6 R� t objectRu R� t make_pass_decoratort pass_script_infoR� R� R� R� R� R� R� t ParamTypeR� R� R� R� R� t optionR RJ t pathsepR� R� t ChoiceR� R: R� R� R ( ( ( s* /tmp/pip-install-sTXtzD/flask/flask/cli.pyt <module>
s�
3 ; 7B = . # -(""
!