def test_import_app_py_ext(monkeypatch):
monkeypatch.chdir(os.path.dirname(__file__))
with pytest.raises(ImportError) as exc_info:
util.import_app("support.py")
assert "did you mean" in str(exc_info.value)
def test_import_app():
assert util.import_app('support:app')
with pytest.raises(ImportError) as err:
util.import_app('a:app')
assert 'No module' in str(err)
with pytest.raises(AppImportError) as err:
util.import_app('support:wrong_app')
msg = "Failed to find application object 'wrong_app' in 'support'"
assert msg in str(err)
def test_import_app():
assert util.import_app('support:app')
with pytest.raises(ImportError) as err:
util.import_app('a:app')
assert 'No module' in str(err)
with pytest.raises(AppImportError) as err:
util.import_app('support:wrong_app')
msg = "Failed to find application object 'wrong_app' in 'support'"
assert msg in str(err)
def load(self):
""" Attempt an import of the specified application """
if isinstance(self.application,str):
return util.import_app(self.application)
else:
return self.application
def run():
""" CLI endpoint. """
sys.path.insert(0, os.getcwd())
parser = argparse.ArgumentParser(description="Manage Application")
parser.add_argument('app', metavar='app',
type=str, help='Application module path')
parser.add_argument('--config', type=str, help='Path to configuration.')
parser.add_argument('--version', action="version", version=__version__)
args_ = [_ for _ in sys.argv[1:] if _ not in ["--help", "-h"]]
args_, unknown = parser.parse_known_args(args_)
if args_.config:
os.environ[CONFIGURATION_ENVIRON_VARIABLE] = args_.config
from gunicorn.util import import_app
try:
app_uri = args_.app
if ':' not in app_uri:
app_uri += ':app'
app = import_app(app_uri)
app.logger.info('Application is loaded: %s' % app.name)
except Exception as e:
print(e)
raise sys.exit(1)
app.manage()
def run():
"""CLI endpoint."""
sys.path.insert(0, os.getcwd())
logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
parser = argparse.ArgumentParser(description="Manage Application", add_help=False)
parser.add_argument('app', metavar='app',
type=str, help='Application module path')
parser.add_argument('--config', type=str, help='Path to configuration.')
parser.add_argument('--version', action="version", version=__version__)
args_, subargs_ = parser.parse_known_args(sys.argv[1:])
if args_.config:
os.environ[CONFIGURATION_ENVIRON_VARIABLE] = args_.config
from gunicorn.util import import_app
app_uri = args_.app
if ':' not in app_uri:
app_uri += ':app'
try:
app = import_app(app_uri)
app.uri = app_uri
app.logger.info('Application is loaded: %s' % app.name)
except Exception as exc:
logging.exception(exc)
raise sys.exit(1)
app.manage(*subargs_, prog='muffin %s' % args_.app)
def load(self):
try:
djangoapp.make_default_env(self.cfg)
except RuntimeError:
# ignore silently error while loading non django apps.
pass
return util.import_app(self.app_uri)
def load(self):
""" Attempt an import of the specified application """
if isinstance(self.application, str):
return util.import_app(self.application)
else:
return self.application
def run():
""" CLI endpoint. """
sys.path.insert(0, os.getcwd())
parser = argparse.ArgumentParser(description="Manage Application")
parser.add_argument('app',
metavar='app',
type=str,
help='Application module path')
parser.add_argument('--config', type=str, help='Path to configuration.')
parser.add_argument('--version', action="version", version=__version__)
args_ = [_ for _ in sys.argv[1:] if _ not in ["--help", "-h"]]
args_, unknown = parser.parse_known_args(args_)
if args_.config:
os.environ[CONFIGURATION_ENVIRON_VARIABLE] = args_.config
from gunicorn.util import import_app
try:
app_uri = args_.app
if ':' not in app_uri:
app_uri += ':app'
app = import_app(app_uri)
app.logger.info('Application is loaded: %s' % app.name)
except Exception as e:
print(e)
raise sys.exit(1)
app.manage()
def load(self):
brightsky_mods = [
mod for name, mod in sys.modules.items()
if name.startswith('brightsky.')]
for mod in brightsky_mods:
importlib.reload(mod)
return import_app(self.app_uri)
def run():
"""CLI endpoint."""
sys.path.insert(0, os.getcwd())
logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
parser = argparse.ArgumentParser(description="Manage Application",
add_help=False)
parser.add_argument('app',
metavar='app',
type=str,
help='Application module path')
parser.add_argument('--config', type=str, help='Path to configuration.')
parser.add_argument('--version', action="version", version=__version__)
args_, subargs_ = parser.parse_known_args(sys.argv[1:])
if args_.config:
os.environ[CONFIGURATION_ENVIRON_VARIABLE] = args_.config
from gunicorn.util import import_app
app_uri = args_.app
if ':' not in app_uri:
app_uri += ':app'
try:
app = import_app(app_uri)
app.uri = app_uri
app.logger.info('Application is loaded: %s' % app.name)
except Exception as exc:
logging.exception(exc)
raise sys.exit(1)
app.manage(*subargs_, prog='muffin %s' % args_.app)
def load(self):
try:
djangoapp.make_default_env(self.cfg)
except RuntimeError:
# ignore silently error while loading non django apps.
pass
return util.import_app(self.app_uri)
def app(pytestconfig, request):
""" Provide an example application. """
if pytestconfig.app:
return util.import_app(pytestconfig.app)
logging.warn(
'Improperly configured. Please set ``muffin_app`` in your pytest config. '
'Or use ``--muffin-app`` command option.')
return None
def app(pytestconfig, request):
""" Provide an example application. """
if pytestconfig.app:
return util.import_app(pytestconfig.app)
logging.warn(
'Improperly configured. Please set ``muffin_app`` in your pytest config. '
'Or use ``--muffin-app`` command option.')
return None
def load(self):
"""Return our application to be run."""
app = util.import_app("dallinger.experiment_server.sockets:app")
app.secret_key = app.config["SECRET_KEY"] = os.environ.get(
"FLASK_SECRET_KEY")
if self.options.get("mode") == "debug":
app.debug = True
else:
app = ProxyFix(app)
return app
def load(self):
"""Load a Muffin application."""
# Fix paths
os.chdir(self.cfg.chdir)
sys.path.insert(0, self.cfg.chdir)
app = self.app_uri
if not isinstance(app, Application):
app = import_app(app)
return app
def load(self):
'''load method
Imports our application and returns it to be run.
FORMAT: <module>:<WSGI object>
If the WSGI object is not named 'application', it must
be included in the function parameter.
'''
return util.import_app("resultapp.main:app")
def load(self):
""" Load a Muffin application. """
# Fix paths
os.chdir(self.cfg.chdir)
sys.path.insert(0, self.cfg.chdir)
app = self.app_uri
if not isinstance(app, Application):
app = import_app(app)
return app
def get_app(parser, opts, args):
if len(args) != 1:
parser.error("No application module specified.")
opts.default_proc_name = args[0]
try:
return util.import_app(args[0])
except:
parser.error("Failed to import application module.")
def load(self):
'''load method
Imports our application and returns it to be run.
FORMAT: <module>:<WSGI object>
If the WSGI object is not named 'application', it must
be included in the function parameter.
'''
return util.import_app("resultapp.main:app")
def load(self):
if self._app:
app = self._app
if isinstance(app, str):
app = import_app(self._app)
else:
app = self._load_app()
if hasattr(app, "load_conf"):
app.load_conf(self._app_conf)
return app
def load(self):
"""Reload modules."""
if not app.uri:
return app
module, *_ = app.uri.split(':', 1)
if module in sys.modules:
sys.modules.pop(module)
paths = [
p for p in sys.modules
if p.startswith('%s.' % module)
]
for path in paths:
sys.modules.pop(path)
return import_app(app.uri)
def load(self):
"""Load a Muffin application."""
# Fix paths
os.chdir(self.cfg.chdir)
sys.path.insert(0, self.cfg.chdir)
app = self.app_uri
if not isinstance(app, Application):
module, *_ = self.app_uri.split(':', 1)
if module in sys.modules:
sys.modules.pop(module)
paths = [p for p in sys.modules if p.startswith('%s.' % module)]
for path in paths:
sys.modules.pop(path)
app = import_app(app)
return app
def app(pytestconfig, request):
""" Provide an example application. """
from muffin.utils import to_coroutine
from gunicorn import util
if pytestconfig.app:
app = util.import_app(pytestconfig.app)
loop = asyncio.get_event_loop()
for plugin in app.ps.values():
if not hasattr(plugin, 'conftest'):
continue
loop.run_until_complete(to_coroutine(plugin.conftest)())
return app
logging.warn(
'Improperly configured. Please set ``muffin_app`` in your pytest config. '
'Or use ``--muffin-app`` command option.')
return None
def load(self):
'''load method
Imports our application and returns it to be run.
'''
return util.import_app("dhbox:app")
def load(self):
self.chdir()
if self.app_uri:
return import_app(self.app_uri)
return self._app
def load(self):
return util.import_app(self.options.get("module_path"))
def load_wsgiapp(self):
self.chdir()
# load the app
return util.import_app(self.app_uri)
def load(self):
return util.import_app(self.app_uri)
def load(self):
'''load method
Imports our application and returns it to be run.
'''
return util.import_app("psiturk.experiment:app")
def load(self):
self.chdir()
if self.app_uri:
return import_app(self.app_uri)
return self._app
def make_app(self, config):
return util.import_app(config['wsgi_app'])
def load(self):
"""Return our application to be run."""
app = util.import_app("dallinger.experiment_server.sockets:app")
if self.options.get('mode') == 'debug':
app.debug = True
return app
def load_wsgiapp(self):
self.chdir()
# load the flask
return util.import_app(self.app_uri)
from __future__ import absolute_import
from gunicorn.app.base import Application
from gunicorn import util
import multiprocessing
from dallinger.config import get_config
import logging
logger = logging.getLogger(__file__)
app = util.import_app("dallinger.experiment_server.experiment_server:app")
def when_ready(arbiter):
# Signal to parent process that server has started.
print('Ready.')
class StandaloneServer(Application):
loglevels = ["debug", "info", "warning", "error", "critical"]
def __init__(self):
"""__init__ method
Load the base config and assign some core attributes.
"""
self.usage = None
self.cfg = None
self.callable = None
self.prog = None
self.logger = None
def load(self):
"""Return our application to be run."""
return util.import_app("dallinger.experiment_server.sockets:app")
def load(self):
return util.import_app("todos:app")
def make_app(self, config):
handle = util.import_app(config['websocket'])
app = WebSocketWSGI(handle)
return app
def make_app(self, config):
return util.import_app(config['wsgi_app'])
def app(self): return import_app(self.path) # Re-import to support live reloading
def load_wsgiapp(self):
self.chdir()
# load the app
# wsgiapp 采用import的方式加载
return util.import_app(self.app_uri)
def load(self):
self.chdir()
# load the app
return util.import_app(self.app_uri)
def load(self):
return util.import_app(self.app_uri)
def load(self):
return import_app('api.app:create_app(wsgi=True,collect_transactions=True)')
def load_wsgiapp(self):
# load the app
return util.import_app(self.app_uri)
def load(self):
return util.import_app("wsgi")
def load(self):
'''load method
Imports our application and returns it to be run.
'''
return util.import_app("psiturk.experiment:app")
def load(self):
djangoapp.make_default_env(self.cfg)
return util.import_app(self.app_uri)
