inveniosoftware / flask-cli / 57

pending completion

Build # 57

Build Type

Pull #16

travis-ci

Committed by

jezdez

Commit Message

<a href="https://github.com/inveniosoftware/flask-cli/commit/7f808b58a">fixed unmatched elif

Backport of https://github.com/pallets/flask/commit/</a><a class="double-link" href="https://github.com/inveniosoftware/flask-cli/commit/fe5f71402">fe5f71402</a>

Pull Request Pull Request #16: Updates from Flask 0.11, fixes #15

Run Details

62 of 62 new or added lines in 3 files covered. (100.0%)

211 of 320 relevant lines covered (65.94%)

7.13 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

58.37

/flask_cli/cli.py

# -*- coding: utf-8 -*-
"""
    flask.cli
    ~~~~~~~~~

    A simple command line application to run flask apps.

    :copyright: (c) 2015 by Armin Ronacher.
    :license: BSD, see LICENSE for more details.
"""

import os
import sys
from functools import update_wrapper
from threading import Lock, Thread

import click
from flask import __version__ as __flask_version__

from ._compat import iteritems, reraise
from .helpers import get_debug_flag


class NoAppException(click.UsageError):
    """Raised if an application cannot be found or loaded."""


def find_best_app(module):
    """Given a module instance this tries to find the best possible
    application in the module or raises an exception.
    """
    from flask import Flask

    # Search for the most common names first.
    for attr_name in 'app', 'application':
        app = getattr(module, attr_name, None)
        if app is not None and isinstance(app, Flask):
            return app

    # Otherwise find the only object that is a Flask instance.
    matches = [v for k, v in iteritems(module.__dict__)
               if isinstance(v, Flask)]

    if len(matches) == 1:
        return matches[0]
    raise NoAppException('Failed to find application in module "%s".  Are '
                         'you sure it contains a Flask application?  Maybe '
                         'you wrapped it in a WSGI middleware or you are '
                         'using a factory function.' % module.__name__)


def prepare_exec_for_file(filename):
    """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.
    """
    module = []

    # Chop off file extensions or package markers
    if os.path.split(filename)[1] == '__init__.py':
        filename = os.path.dirname(filename)
    elif filename.endswith('.py'):
        filename = filename[:-3]
    else:
        raise NoAppException('The file provided (%s) does exist but is not a '
                             'valid Python file.  This means that it cannot '
                             'be used as application.  Please change the '
                             'extension to .py' % filename)
    filename = os.path.realpath(filename)

    dirpath = filename
    while 1:
        dirpath, extra = os.path.split(dirpath)
        module.append(extra)
        if not os.path.isfile(os.path.join(dirpath, '__init__.py')):
            break

    sys.path.insert(0, dirpath)
    return '.'.join(module[::-1])


def locate_app(app_id):
    """Attempts to locate the application."""
    __traceback_hide__ = True
    if ':' in app_id:
        module, app_obj = app_id.split(':', 1)
    else:
        module = app_id
        app_obj = None

    __import__(module)
    mod = sys.modules[module]
    if app_obj is None:
        app = find_best_app(mod)
    else:
        app = getattr(mod, app_obj, None)
        if app is None:
            raise RuntimeError('Failed to find application in module "%s"'
                               % module)

    return app


def find_default_import_path():
    app = os.environ.get('FLASK_APP')
    if app is None:
        return
    if os.path.isfile(app):
        return prepare_exec_for_file(app)
    return app


def get_version(ctx, param, value):
    if not value or ctx.resilient_parsing:
        return
    message = 'Flask %(version)s\nPython %(python_version)s'
    click.echo(message % {
        'version': __flask_version__,
        'python_version': sys.version,
    }, color=ctx.color)
    ctx.exit()

version_option = click.Option(['--version'],
                              help='Show the flask version',
                              expose_value=False,
                              callback=get_version,
                              is_flag=True, is_eager=True)


class DispatchingApp(object):
    """Special application that dispatches to a flask application which
    is imported by name in a background thread.  If an error happens
    it is is recorded and shows as part of the WSGI handling which in case
    of the Werkzeug debugger means that it shows up in the browser.
    """

    def __init__(self, loader, use_eager_loading=False):
        self.loader = loader
        self._app = None
        self._lock = Lock()
        self._bg_loading_exc_info = None
        if use_eager_loading:
            self._load_unlocked()
        else:
            self._load_in_background()

    def _load_in_background(self):
        def _load_app():
            __traceback_hide__ = True
            with self._lock:
                try:
                    self._load_unlocked()
                except Exception:
                    self._bg_loading_exc_info = sys.exc_info()
        t = Thread(target=_load_app, args=())
        t.start()

    def _flush_bg_loading_exception(self):
        __traceback_hide__ = True
        exc_info = self._bg_loading_exc_info
        if exc_info is not None:
            self._bg_loading_exc_info = None
            reraise(*exc_info)

    def _load_unlocked(self):
        __traceback_hide__ = True
        self._app = rv = self.loader()
        self._bg_loading_exc_info = None
        return rv

    def __call__(self, environ, start_response):
        __traceback_hide__ = True
        if self._app is not None:
            return self._app(environ, start_response)
        self._flush_bg_loading_exception()
        with self._lock:
            if self._app is not None:
                rv = self._app
            else:
                rv = self._load_unlocked()
            return rv(environ, start_response)


class ScriptInfo(object):
    """Help 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.
    """
    def __init__(self, app_import_path=None, create_app=None):
        if create_app is None:
            if app_import_path is None:
                app_import_path = find_default_import_path()
            self.app_import_path = app_import_path
        else:
            app_import_path = None

        #: Optionally the import path for the Flask application.
        self.app_import_path = app_import_path
        #: Optionally a function that is passed the script info to create
        #: the instance of the application.
        self.create_app = create_app
        #: A dictionary with arbitrary data that can be associated with
        #: this script info.
        self.data = {}
        self._loaded_app = None

    def load_app(self):
        """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.
        """
        __traceback_hide__ = True
        if self._loaded_app is not None:
            return self._loaded_app
        if self.create_app is not None:
            rv = self.create_app(self)
        else:
            if not self.app_import_path:
                raise NoAppException(
                    'Could not locate Flask application. You did not provide '
                    'the FLASK_APP environment variable.\n\nFor more '
                    'information see '
                    'http://flask.pocoo.org/docs/latest/quickstart/')
            rv = locate_app(self.app_import_path)
        debug = get_debug_flag()
        if debug is not None:
            rv.debug = debug
        self._loaded_app = rv
        return rv


pass_script_info = click.make_pass_decorator(ScriptInfo, ensure=True)


def with_appcontext(f):
    """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.
    """
    @click.pass_context
    def decorator(__ctx, *args, **kwargs):
        with __ctx.ensure_object(ScriptInfo).load_app().app_context():
            return __ctx.invoke(f, *args, **kwargs)
    return update_wrapper(decorator, f)


class AppGroup(click.Group):
    """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`.
    """

    def command(self, *args, **kwargs):
        """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``.
        """
        wrap_for_ctx = kwargs.pop('with_appcontext', True)
        def decorator(f):
            if wrap_for_ctx:
                f = with_appcontext(f)
            return click.Group.command(self, *args, **kwargs)(f)
        return decorator

    def group(self, *args, **kwargs):
        """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`.
        """
        kwargs.setdefault('cls', AppGroup)
        return click.Group.group(self, *args, **kwargs)


class FlaskGroup(AppGroup):
    """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 wil be added.
    :param add_version_option: adds the :option:`--version` option.
    :param create_app: an optional callback that is passed the script info
                       and returns the loaded app.
    """

    def __init__(self, add_default_commands=True, create_app=None,
                 add_version_option=True, **extra):
        params = list(extra.pop('params', None) or ())

        if add_version_option:
            params.append(version_option)

        AppGroup.__init__(self, params=params, **extra)
        self.create_app = create_app

        if add_default_commands:
            self.add_command(run_command)
            self.add_command(shell_command)

        self._loaded_plugin_commands = False

    def _load_plugin_commands(self):
        if self._loaded_plugin_commands:
            return
        try:
            import pkg_resources
        except ImportError:
            self._loaded_plugin_commands = True
            return

        for ep in pkg_resources.iter_entry_points('flask.commands'):
            self.add_command(ep.load(), ep.name)
        self._loaded_plugin_commands = True

    def get_command(self, ctx, name):
        self._load_plugin_commands()

        # We load built-in commands first as these should always be the
        # same no matter what the app does.  If the app does want to
        # override this it needs to make a custom instance of this group
        # and not attach the default commands.
        #
        # This also means that the script stays functional in case the
        # application completely fails.
        rv = AppGroup.get_command(self, ctx, name)
        if rv is not None:
            return rv

        info = ctx.ensure_object(ScriptInfo)
        try:
            rv = info.load_app().cli.get_command(ctx, name)
            if rv is not None:
                return rv
        except NoAppException:
            pass

    def list_commands(self, ctx):
        self._load_plugin_commands()

        # The commands available is the list of both the application (if
        # available) plus the builtin commands.
        rv = set(click.Group.list_commands(self, ctx))
        info = ctx.ensure_object(ScriptInfo)
        try:
            rv.update(info.load_app().cli.list_commands(ctx))
        except Exception:
            # Here we intentionally swallow all exceptions as we don't
            # want the help page to break if the app does not exist.
            # If someone attempts to use the command we try to create
            # the app again and this will give us the error.
            pass
        return sorted(rv)

    def main(self, *args, **kwargs):
        obj = kwargs.get('obj')
        if obj is None:
            obj = ScriptInfo(create_app=self.create_app)
        kwargs['obj'] = obj
        kwargs.setdefault('auto_envvar_prefix', 'FLASK')
        return AppGroup.main(self, *args, **kwargs)


@click.command('run', short_help='Runs a development server.')
@click.option('--host', '-h', default='127.0.0.1',
              help='The interface to bind to.')
@click.option('--port', '-p', default=5000,
              help='The port to bind to.')
@click.option('--reload/--no-reload', default=None,
              help='Enable or disable the reloader.  By default the reloader '
              'is active if debug is enabled.')
@click.option('--debugger/--no-debugger', default=None,
              help='Enable or disable the debugger.  By default the debugger '
              'is active if debug is enabled.')
@click.option('--eager-loading/--lazy-loader', default=None,
              help='Enable or disable eager loading.  By default eager '
              'loading is enabled if the reloader is disabled.')
@click.option('--with-threads/--without-threads', default=False,
              help='Enable or disable multithreading.')
@pass_script_info
def run_command(info, host, port, reload, debugger, eager_loading,
                with_threads):
    """Runs a local development server for the Flask application.

    This local server is recommended for development purposes only but it
    can also be used for simple intranet deployments.  By default it will
    not support any sort of concurrency at all to simplify debugging.  This
    can be changed with the --with-threads option which will enable basic
    multithreading.

    The reloader and debugger are by default enabled if the debug flag of
    Flask is enabled and disabled otherwise.
    """
    from werkzeug.serving import run_simple

    debug = get_debug_flag()
    if reload is None:
        reload = bool(debug)
    if debugger is None:
        debugger = bool(debug)
    if eager_loading is None:
        eager_loading = not reload

    app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)

    # Extra startup messages.  This depends a but on Werkzeug internals to
    # not double execute when the reloader kicks in.
    if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':
        # If we have an import path we can print it out now which can help
        # people understand what's being served.  If we do not have an
        # import path because the app was loaded through a callback then
        # we won't print anything.
        if info.app_import_path is not None:
            print(' * Serving Flask app "%s"' % info.app_import_path)
        if debug is not None:
            print(' * Forcing debug mode %s' % (debug and 'on' or 'off'))

    run_simple(host, port, app, use_reloader=reload,
               use_debugger=debugger, threaded=with_threads)


@click.command('shell', short_help='Runs a shell in the app context.')
@with_appcontext
def shell_command():
    """Runs 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 configuring the application.
    """
    import code
    from flask.globals import _app_ctx_stack
    app = _app_ctx_stack.top.app
    banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (
        sys.version,
        sys.platform,
        app.import_name,
        app.debug and ' [debug]' or '',
        app.instance_path,
    )
    ctx = {}

    # Support the regular Python interpreter startup script if someone
    # is using it.
    startup = os.environ.get('PYTHONSTARTUP')
    if startup and os.path.isfile(startup):
        with open(startup, 'r') as f:
            eval(compile(f.read(), startup, 'exec'), ctx)

    ctx.update(app.make_shell_context())

    code.interact(banner=banner, local=ctx)


cli = FlaskGroup(help="""\
This shell command acts as general utility script for Flask applications.

It loads the application configured (either through the FLASK_APP environment
variable) and then provides commands either provided by the application or
Flask itself.

The most useful commands are the "run" and "shell" command.

Example usage:

\b
  %(prefix)s%(cmd)s FLASK_APP=hello.py
  %(prefix)s%(cmd)s FLASK_DEBUG=1
  %(prefix)sflask run
""" % {
    'cmd': os.name == 'posix' and 'export' or 'set',
    'prefix': os.name == 'posix' and '$ ' or '',
})


def main(as_module=False):
    this_module = __package__ + '.cli'
    args = sys.argv[1:]

    if as_module:
        if sys.version_info >= (2, 7):
            name = 'python -m ' + this_module.rsplit('.', 1)[0]
        else:
            name = 'python -m ' + this_module

        # This module is always executed as "python -m flask.run" and as such
        # we need to ensure that we restore the actual command line so that
        # the reloader can properly operate.
        sys.argv = ['-m', this_module] + sys.argv[1:]
    else:
        name = None

    cli.main(args=args, prog_name=name)


if __name__ == '__main__':
    main(as_module=True)

1	# -- coding: utf-8 --
2	"""	12✔
3	flask.cli
4	~~~~~~~~~
5
6	A simple command line application to run flask apps.
7
8	:copyright: (c) 2015 by Armin Ronacher.
9	:license: BSD, see LICENSE for more details.
10	"""
11
12	import os	12✔
13	import sys	12✔
14	from functools import update_wrapper	12✔
15	from threading import Lock, Thread	12✔
16
17	import click	12✔
18	from flask import __version__ as __flask_version__	12✔
19
20	from ._compat import iteritems, reraise	12✔
21	from .helpers import get_debug_flag	12✔
22
23
24	class NoAppException(click.UsageError):	12✔
25	"""Raised if an application cannot be found or loaded."""
26
27
28	def find_best_app(module):	12✔
29	"""Given a module instance this tries to find the best possible
30	application in the module or raises an exception.
31	"""
32	from flask import Flask	12✔
33
34	# Search for the most common names first.
35	for attr_name in 'app', 'application':	12✔
36	app = getattr(module, attr_name, None)	12✔
37	if app is not None and isinstance(app, Flask):	12✔
38	return app	12✔
39
40	# Otherwise find the only object that is a Flask instance.
41	matches = [v for k, v in iteritems(module.__dict__)	12✔
42	if isinstance(v, Flask)]
43
44	if len(matches) == 1:	12✔
45	return matches[0]	12✔
46	raise NoAppException('Failed to find application in module "%s". Are '	12✔
47	'you sure it contains a Flask application? Maybe '
48	'you wrapped it in a WSGI middleware or you are '
49	'using a factory function.' % module.__name__)
50
51
52	def prepare_exec_for_file(filename):	12✔
53	"""Given a filename this will try to calculate the python path, add it
54	to the search path and return the actual module name that is expected.
55	"""
56	module = []	12✔
57
58	# Chop off file extensions or package markers
59	if os.path.split(filename)[1] == '__init__.py':	12✔
60	filename = os.path.dirname(filename)	12✔
61	elif filename.endswith('.py'):	12✔
62	filename = filename[:-3]	12✔
63	else:
64	raise NoAppException('The file provided (%s) does exist but is not a '	12✔
65	'valid Python file. This means that it cannot '
66	'be used as application. Please change the '
67	'extension to .py' % filename)
68	filename = os.path.realpath(filename)	12✔
69
70	dirpath = filename	12✔
71	while 1:	12✔
72	dirpath, extra = os.path.split(dirpath)	12✔
73	module.append(extra)	12✔
74	if not os.path.isfile(os.path.join(dirpath, '__init__.py')):	12✔
75	break	12✔
76
77	sys.path.insert(0, dirpath)	12✔
78	return '.'.join(module[::-1])	12✔
79
80
81	def locate_app(app_id):	12✔
82	"""Attempts to locate the application."""
83	__traceback_hide__ = True	12✔
84	if ':' in app_id:	12✔
85	module, app_obj = app_id.split(':', 1)	12✔
86	else:
87	module = app_id	12✔
88	app_obj = None	12✔
89
90	__import__(module)	12✔
91	mod = sys.modules[module]	12✔
92	if app_obj is None:	12✔
93	app = find_best_app(mod)	12✔
94	else:
95	app = getattr(mod, app_obj, None)	12✔
96	if app is None:	12✔
97	raise RuntimeError('Failed to find application in module "%s"'	12✔
98	% module)
99
100	return app	12✔
101
102
103	def find_default_import_path():	12✔
104	app = os.environ.get('FLASK_APP')	×
105	if app is None:	×
106	return	×
107	if os.path.isfile(app):	×
108	return prepare_exec_for_file(app)	×
109	return app	×
110
111
112	def get_version(ctx, param, value):	12✔
113	if not value or ctx.resilient_parsing:	12✔
114	return	12✔
115	message = 'Flask %(version)s\nPython %(python_version)s'	×
116	click.echo(message % {	×
117	'version': __flask_version__,
118	'python_version': sys.version,
119	}, color=ctx.color)
120	ctx.exit()	×
121
122	version_option = click.Option(['--version'],	12✔
123	help='Show the flask version',
124	expose_value=False,
125	callback=get_version,
126	is_flag=True, is_eager=True)
127
128
129	class DispatchingApp(object):	12✔
130	"""Special application that dispatches to a flask application which
131	is imported by name in a background thread. If an error happens
132	it is is recorded and shows as part of the WSGI handling which in case
133	of the Werkzeug debugger means that it shows up in the browser.
134	"""
135
136	def __init__(self, loader, use_eager_loading=False):	12✔
137	self.loader = loader	×
138	self._app = None	×
139	self._lock = Lock()	×
140	self._bg_loading_exc_info = None	×
141	if use_eager_loading:	×
142	self._load_unlocked()	×
143	else:
144	self._load_in_background()	×
145
146	def _load_in_background(self):	12✔
147	def _load_app():	×
148	__traceback_hide__ = True	×
149	with self._lock:	×
150	try:	×
151	self._load_unlocked()	×
152	except Exception:	×
153	self._bg_loading_exc_info = sys.exc_info()	×
154	t = Thread(target=_load_app, args=())	×
155	t.start()	×
156
157	def _flush_bg_loading_exception(self):	12✔
158	__traceback_hide__ = True	×
159	exc_info = self._bg_loading_exc_info	×
160	if exc_info is not None:	×
161	self._bg_loading_exc_info = None	×
162	reraise(*exc_info)	×
163
164	def _load_unlocked(self):	12✔
165	__traceback_hide__ = True	×
166	self._app = rv = self.loader()	×
167	self._bg_loading_exc_info = None	×
168	return rv	×
169
170	def __call__(self, environ, start_response):	12✔
171	__traceback_hide__ = True	×
172	if self._app is not None:	×
173	return self._app(environ, start_response)	×
174	self._flush_bg_loading_exception()	×
175	with self._lock:	×
176	if self._app is not None:	×
177	rv = self._app	×
178	else:
179	rv = self._load_unlocked()	×
180	return rv(environ, start_response)	×
181
182
183	class ScriptInfo(object):	12✔
184	"""Help object to deal with Flask applications. This is usually not
185	necessary to interface with as it's used internally in the dispatching
186	to click. In future versions of Flask this object will most likely play
187	a bigger role. Typically it's created automatically by the
188	:class:`FlaskGroup` but you can also manually create it and pass it
189	onwards as click object.
190	"""
191	def __init__(self, app_import_path=None, create_app=None):	12✔
192	if create_app is None:	12✔
193	if app_import_path is None:	12✔
194	app_import_path = find_default_import_path()	×
195	self.app_import_path = app_import_path	12✔
196	else:
197	app_import_path = None	12✔
198
199	#: Optionally the import path for the Flask application.
200	self.app_import_path = app_import_path	12✔
201	#: Optionally a function that is passed the script info to create
202	#: the instance of the application.
203	self.create_app = create_app	12✔
204	#: A dictionary with arbitrary data that can be associated with
205	#: this script info.
206	self.data = {}	12✔
207	self._loaded_app = None	12✔
208
209	def load_app(self):	12✔
210	"""Loads the Flask app (if not yet loaded) and returns it. Calling
211	this multiple times will just result in the already loaded app to
212	be returned.
213	"""
214	__traceback_hide__ = True	12✔
215	if self._loaded_app is not None:	12✔
216	return self._loaded_app	12✔
217	if self.create_app is not None:	12✔
218	rv = self.create_app(self)	12✔
219	else:
220	if not self.app_import_path:	12✔
221	raise NoAppException(	×
222	'Could not locate Flask application. You did not provide '
223	'the FLASK_APP environment variable.\n\nFor more '
224	'information see '
225	'http://flask.pocoo.org/docs/latest/quickstart/')
226	rv = locate_app(self.app_import_path)	12✔
227	debug = get_debug_flag()	12✔
228	if debug is not None:	12✔
229	rv.debug = debug	×
230	self._loaded_app = rv	12✔
231	return rv	12✔
232
233
234	pass_script_info = click.make_pass_decorator(ScriptInfo, ensure=True)	12✔
235
236
237	def with_appcontext(f):	12✔
238	"""Wraps a callback so that it's guaranteed to be executed with the
239	script's application context. If callbacks are registered directly
240	to the ``app.cli`` object then they are wrapped with this function
241	by default unless it's disabled.
242	"""
243	@click.pass_context	12✔
244	def decorator(__ctx, args, *kwargs):
245	with __ctx.ensure_object(ScriptInfo).load_app().app_context():	12✔
246	return __ctx.invoke(f, args, *kwargs)	12✔
247	return update_wrapper(decorator, f)	12✔
248
249
250	class AppGroup(click.Group):	12✔
251	"""This works similar to a regular click :class:`~click.Group` but it
252	changes the behavior of the :meth:`command` decorator so that it
253	automatically wraps the functions in :func:`with_appcontext`.
254
255	Not to be confused with :class:`FlaskGroup`.
256	"""
257
258	def command(self, args, *kwargs):	12✔
259	"""This works exactly like the method of the same name on a regular
260	:class:`click.Group` but it wraps callbacks in :func:`with_appcontext`
261	unless it's disabled by passing ``with_appcontext=False``.
262	"""
263	wrap_for_ctx = kwargs.pop('with_appcontext', True)	12✔
264	def decorator(f):	12✔
265	if wrap_for_ctx:	12✔
266	f = with_appcontext(f)	12✔
267	return click.Group.command(self, args, *kwargs)(f)	12✔
268	return decorator	12✔
269
270	def group(self, args, *kwargs):	12✔
271	"""This works exactly like the method of the same name on a regular
272	:class:`click.Group` but it defaults the group class to
273	:class:`AppGroup`.
274	"""
275	kwargs.setdefault('cls', AppGroup)	12✔
276	return click.Group.group(self, args, *kwargs)	12✔
277
278
279	class FlaskGroup(AppGroup):	12✔
280	"""Special subclass of the :class:`AppGroup` group that supports
281	loading more commands from the configured Flask app. Normally a
282	developer does not have to interface with this class but there are
283	some very advanced use cases for which it makes sense to create an
284	instance of this.
285
286	For information as of why this is useful see :ref:`custom-scripts`.
287
288	:param add_default_commands: if this is True then the default run and
289	shell commands wil be added.
290	:param add_version_option: adds the :option:`--version` option.
291	:param create_app: an optional callback that is passed the script info
292	and returns the loaded app.
293	"""
294
295	def __init__(self, add_default_commands=True, create_app=None,	12✔
296	add_version_option=True, **extra):
297	params = list(extra.pop('params', None) or ())	12✔
298
299	if add_version_option:	12✔
300	params.append(version_option)	12✔
301
302	AppGroup.__init__(self, params=params, **extra)	12✔
303	self.create_app = create_app	12✔
304
305	if add_default_commands:	12✔
306	self.add_command(run_command)	12✔
307	self.add_command(shell_command)	12✔
308
309	self._loaded_plugin_commands = False	12✔
310
311	def _load_plugin_commands(self):	12✔
312	if self._loaded_plugin_commands:	12✔
313	return	×
314	try:	12✔
315	import pkg_resources	12✔
316	except ImportError:	×
317	self._loaded_plugin_commands = True	×
318	return	×
319
320	for ep in pkg_resources.iter_entry_points('flask.commands'):	12✔
321	self.add_command(ep.load(), ep.name)	×
322	self._loaded_plugin_commands = True	12✔
323
324	def get_command(self, ctx, name):	12✔
325	self._load_plugin_commands()	12✔
326
327	# We load built-in commands first as these should always be the
328	# same no matter what the app does. If the app does want to
329	# override this it needs to make a custom instance of this group
330	# and not attach the default commands.
331	#
332	# This also means that the script stays functional in case the
333	# application completely fails.
334	rv = AppGroup.get_command(self, ctx, name)	12✔
335	if rv is not None:	12✔
336	return rv	12✔
337
338	info = ctx.ensure_object(ScriptInfo)	×
339	try:	×
340	rv = info.load_app().cli.get_command(ctx, name)	×
341	if rv is not None:	×
342	return rv	×
343	except NoAppException:	×
344	pass	×
345
346	def list_commands(self, ctx):	12✔
347	self._load_plugin_commands()	×
348
349	# The commands available is the list of both the application (if
350	# available) plus the builtin commands.
351	rv = set(click.Group.list_commands(self, ctx))	×
352	info = ctx.ensure_object(ScriptInfo)	×
353	try:	×
354	rv.update(info.load_app().cli.list_commands(ctx))	×
355	except Exception:	×
356	# Here we intentionally swallow all exceptions as we don't
357	# want the help page to break if the app does not exist.
358	# If someone attempts to use the command we try to create
359	# the app again and this will give us the error.
360	pass	×
361	return sorted(rv)	×
362
363	def main(self, args, *kwargs):	12✔
364	obj = kwargs.get('obj')	12✔
365	if obj is None:	12✔
366	obj = ScriptInfo(create_app=self.create_app)	12✔
367	kwargs['obj'] = obj	12✔
368	kwargs.setdefault('auto_envvar_prefix', 'FLASK')	12✔
369	return AppGroup.main(self, args, *kwargs)	12✔
370
371
372	@click.command('run', short_help='Runs a development server.')	12✔
373	@click.option('--host', '-h', default='127.0.0.1',	12✔
374	help='The interface to bind to.')
375	@click.option('--port', '-p', default=5000,	12✔
376	help='The port to bind to.')
377	@click.option('--reload/--no-reload', default=None,	12✔
378	help='Enable or disable the reloader. By default the reloader '
379	'is active if debug is enabled.')
380	@click.option('--debugger/--no-debugger', default=None,	12✔
381	help='Enable or disable the debugger. By default the debugger '
382	'is active if debug is enabled.')
383	@click.option('--eager-loading/--lazy-loader', default=None,	12✔
384	help='Enable or disable eager loading. By default eager '
385	'loading is enabled if the reloader is disabled.')
386	@click.option('--with-threads/--without-threads', default=False,	12✔
387	help='Enable or disable multithreading.')
388	@pass_script_info	12✔
389	def run_command(info, host, port, reload, debugger, eager_loading,
390	with_threads):
391	"""Runs a local development server for the Flask application.
392
393	This local server is recommended for development purposes only but it
394	can also be used for simple intranet deployments. By default it will
395	not support any sort of concurrency at all to simplify debugging. This
396	can be changed with the --with-threads option which will enable basic
397	multithreading.
398
399	The reloader and debugger are by default enabled if the debug flag of
400	Flask is enabled and disabled otherwise.
401	"""
402	from werkzeug.serving import run_simple	×
403
404	debug = get_debug_flag()	×
405	if reload is None:	×
406	reload = bool(debug)	×
407	if debugger is None:	×
408	debugger = bool(debug)	×
409	if eager_loading is None:	×
410	eager_loading = not reload	×
411
412	app = DispatchingApp(info.load_app, use_eager_loading=eager_loading)	×
413
414	# Extra startup messages. This depends a but on Werkzeug internals to
415	# not double execute when the reloader kicks in.
416	if os.environ.get('WERKZEUG_RUN_MAIN') != 'true':	×
417	# If we have an import path we can print it out now which can help
418	# people understand what's being served. If we do not have an
419	# import path because the app was loaded through a callback then
420	# we won't print anything.
421	if info.app_import_path is not None:	×
422	print(' * Serving Flask app "%s"' % info.app_import_path)	×
423	if debug is not None:	×
424	print(' * Forcing debug mode %s' % (debug and 'on' or 'off'))	×
425
426	run_simple(host, port, app, use_reloader=reload,	×
427	use_debugger=debugger, threaded=with_threads)
428
429
430	@click.command('shell', short_help='Runs a shell in the app context.')	12✔
431	@with_appcontext	12✔
432	def shell_command():
433	"""Runs an interactive Python shell in the context of a given
434	Flask application. The application will populate the default
435	namespace of this shell according to it's configuration.
436
437	This is useful for executing small snippets of management code
438	without having to manually configuring the application.
439	"""
440	import code	×
441	from flask.globals import _app_ctx_stack	×
442	app = _app_ctx_stack.top.app	×
443	banner = 'Python %s on %s\nApp: %s%s\nInstance: %s' % (	×
444	sys.version,
445	sys.platform,
446	app.import_name,
447	app.debug and ' [debug]' or '',
448	app.instance_path,
449	)
450	ctx = {}	×
451
452	# Support the regular Python interpreter startup script if someone
453	# is using it.
454	startup = os.environ.get('PYTHONSTARTUP')	×
455	if startup and os.path.isfile(startup):	×
456	with open(startup, 'r') as f:	×
457	eval(compile(f.read(), startup, 'exec'), ctx)	×
458
459	ctx.update(app.make_shell_context())	×
460
461	code.interact(banner=banner, local=ctx)	×
462
463
464	cli = FlaskGroup(help="""\	12✔
465	This shell command acts as general utility script for Flask applications.
466
467	It loads the application configured (either through the FLASK_APP environment
468	variable) and then provides commands either provided by the application or
469	Flask itself.
470
471	The most useful commands are the "run" and "shell" command.
472
473	Example usage:
474
475	\b
476	%(prefix)s%(cmd)s FLASK_APP=hello.py
477	%(prefix)s%(cmd)s FLASK_DEBUG=1
478	%(prefix)sflask run
479	""" % {
480	'cmd': os.name == 'posix' and 'export' or 'set',
481	'prefix': os.name == 'posix' and '$ ' or '',
482	})
483
484
485	def main(as_module=False):	12✔
486	this_module = __package__ + '.cli'	×
487	args = sys.argv[1:]	×
488
489	if as_module:	×
490	if sys.version_info >= (2, 7):	×
491	name = 'python -m ' + this_module.rsplit('.', 1)[0]	×
492	else:
493	name = 'python -m ' + this_module	×
494
495	# This module is always executed as "python -m flask.run" and as such
496	# we need to ensure that we restore the actual command line so that
497	# the reloader can properly operate.
498	sys.argv = ['-m', this_module] + sys.argv[1:]	×
499	else:
500	name = None	×
501
502	cli.main(args=args, prog_name=name)	×
503
504
505	if __name__ == '__main__':	12✔
506	main(as_module=True)	×

inveniosoftware / flask-cli / 57

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous