def load(self):
assert not self.loaded
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(
HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.wsgi:
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
self.loaded = True
def load(self):
assert not self.loaded
encoded_headers = [
(key.lower().encode("latin1"), value.encode("latin1"))
for key, value in self.headers
]
self.encoded_headers = (
encoded_headers
if b"server" in dict(encoded_headers)
else [(b"server", b"uvicorn")] + encoded_headers
) # type: List[Tuple[bytes, bytes]]
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi2":
self.loaded_app = ASGI2Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
self.loaded = True
def load(self):
assert not self.loaded
if self.logger is None:
self.logger_instance = get_logger(self.log_level)
else:
self.logger_instance = self.logger
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.wsgi:
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
if self.ssl_keyfile or self.ssl_certfile:
self.ssl = create_ssl_context(
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
ssl_version=self.ssl_version,
cert_reqs=self.ssl_cert_reqs,
ca_certs=self.ssl_ca_certs,
ciphers=self.ssl_ciphers,
)
else:
self.ssl = None
self.loaded = True
def dev_server(app_path, host, port, **kwargs):
config = importer.import_from_string(app_path).config
run_server(app_path,
host=host or config["dev_host"],
port=port or config["dev_port"],
loop="uvloop",
**kwargs)
def load(self):
assert not self.loaded
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(
HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
self.logger_instance.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi3":
self.loaded_app = ASGI3Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if self.logger_instance.level <= logging.DEBUG:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(self.loaded_app)
self.loaded = True
def dev_start(path, host, port, **kwargs):
kwargs["reload"] = not kwargs.pop("no_reload")
kwargs["debug"] = not kwargs.pop("no_debug")
config = importer.import_from_string(path).config
run_server(path,
host=host or config["dev_host"],
port=port or config["dev_port"],
loop="uvloop",
log_level="debug" if kwargs["debug"] else "info",
**kwargs)
def settings(self) -> BaseSettings:
settings = getattr(self, '_settings', None)
if settings is None:
settings_path = os.environ['foxglove_settings_path']
try:
settings_cls = import_from_string(settings_path)
except ImportFromStringError as exc:
raise ImportError(
f'unable to import "{settings_path}", {exc.__class__.__name__}: {exc}'
)
if not isinstance(settings_cls, type) or not issubclass(
settings_cls, PydanticBaseSettings):
raise ImportError(
f'settings "{settings_cls}" (from "{settings_path}"), is not a valid Settings class'
)
settings = self._settings = settings_cls()
return settings
def _worker():
"""
Run the worker command from settings.worker_func.
"""
try:
import uvloop
except ImportError:
pass
else:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
if settings.worker_func:
logger.info('running worker...')
worker_func: Callable[...,
None] = import_from_string(settings.worker_func)
# wait_for_services(settings)
worker_func(settings=settings)
else:
raise CliError("settings.worker_func not set, can't run the worker")
def cmd_test(application: str, args: typing.List[str], path: str):
app: Index = import_from_string(application)
pytest_args = [
f"--rootdir={os.getcwd()}",
"--override-ini=python_files=views/*.py",
"--override-ini=python_classes=Test",
"--override-ini=python_functions=test_*",
]
pytest_args.extend(args)
if path:
if ".py" in path:
pytest_args.append(path)
elif "::" in path:
pathlist = path.split("::")
pathlist[0] = app.indexfile.get_filepath_from_path(pathlist[0])
pytest_args.append("::".join(pathlist))
else:
pytest_args.append(app.indexfile.get_filepath_from_path(path))
with _TestClient(app):
pytest.main(pytest_args)
def test_no_import_needed():
from tempfile import TemporaryFile
instance = import_from_string(TemporaryFile)
assert instance == TemporaryFile
def test_valid_import():
instance = import_from_string("tempfile:TemporaryFile")
from tempfile import TemporaryFile
assert instance == TemporaryFile
def test_internal_import_error():
with pytest.raises(ImportError) as exc:
import_from_string("tests.importer.raise_import_error:myattr")
def test_invalid_attr():
with pytest.raises(ImportFromStringError) as exc:
import_from_string("tempfile:attr_does_not_exist")
expected = 'Attribute "attr_does_not_exist" not found in module "tempfile".'
assert expected in str(exc)
def create_app(self) -> Starlette:
return import_from_string(self.app)
def run(
app,
host="127.0.0.1",
port=8000,
uds=None,
fd=None,
loop="auto",
http="auto",
ws="auto",
log_level="info",
access_log=True,
wsgi=False,
debug=False,
proxy_headers=False,
root_path="",
limit_concurrency=None,
limit_max_requests=None,
timeout_keep_alive=5,
install_signal_handlers=True,
ready_event=None,
):
if fd is None:
sock = None
else:
host = None
port = None
sock = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
logger = get_logger(log_level)
http_protocol_class = import_from_string(HTTP_PROTOCOLS[http])
ws_protocol_class = import_from_string(WS_PROTOCOLS[ws])
if isinstance(loop, str):
loop_setup = import_from_string(LOOP_SETUPS[loop])
loop = loop_setup()
try:
app = import_from_string(app)
except ImportFromStringError as exc:
click.echo("Error loading ASGI app. %s" % exc)
sys.exit(1)
if wsgi:
app = WSGIMiddleware(app)
ws_protocol_class = None
if debug:
app = DebugMiddleware(app)
if logger.level <= logging.DEBUG:
app = MessageLoggerMiddleware(app)
if proxy_headers:
app = ProxyHeadersMiddleware(app)
connections = set()
tasks = set()
state = {"total_requests": 0}
def create_protocol():
return http_protocol_class(
app=app,
loop=loop,
logger=logger,
access_log=access_log,
connections=connections,
tasks=tasks,
state=state,
ws_protocol_class=ws_protocol_class,
root_path=root_path,
limit_concurrency=limit_concurrency,
timeout_keep_alive=timeout_keep_alive,
)
server = Server(
app=app,
host=host,
port=port,
uds=uds,
sock=sock,
logger=logger,
loop=loop,
connections=connections,
tasks=tasks,
state=state,
limit_max_requests=limit_max_requests,
create_protocol=create_protocol,
on_tick=http_protocol_class.tick,
install_signal_handlers=install_signal_handlers,
ready_event=ready_event,
)
server.run()
def test_invalid_format():
with pytest.raises(ImportFromStringError) as exc:
import_from_string("example:")
expected = 'Import string "example:" must be in format "<module>:<attribute>".'
assert expected in str(exc)
def load(self):
assert not self.loaded
if self.is_ssl:
self.ssl = create_ssl_context(
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
password=self.ssl_keyfile_password,
ssl_version=self.ssl_version,
cert_reqs=self.ssl_cert_reqs,
ca_certs=self.ssl_ca_certs,
ciphers=self.ssl_ciphers,
)
else:
self.ssl = None
encoded_headers = [
(key.lower().encode("latin1"), value.encode("latin1"))
for key, value in self.headers
]
self.encoded_headers = (
encoded_headers
if b"server" in dict(encoded_headers)
else [(b"server", b"uvicorn")] + encoded_headers
) # type: List[Tuple[bytes, bytes]]
if isinstance(self.http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
logger.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi2":
self.loaded_app = ASGI2Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if logger.level <= TRACE_LOG_LEVEL:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(
self.loaded_app, trusted_hosts=self.forwarded_allow_ips
)
self.loaded = True
def load(self) -> None:
assert not self.loaded
if self.is_ssl:
assert self.ssl_certfile
self.ssl: Optional[ssl.SSLContext] = create_ssl_context(
keyfile=self.ssl_keyfile,
certfile=self.ssl_certfile,
password=self.ssl_keyfile_password,
ssl_version=self.ssl_version,
cert_reqs=self.ssl_cert_reqs,
ca_certs=self.ssl_ca_certs,
ciphers=self.ssl_ciphers,
)
else:
self.ssl = None
encoded_headers = [(key.lower().encode("latin1"),
value.encode("latin1"))
for key, value in self.headers]
self.encoded_headers = ([(b"server", b"uvicorn")] + encoded_headers
if b"server" not in dict(encoded_headers)
and self.server_header else encoded_headers)
if isinstance(self.http, str):
http_protocol_class = import_from_string(HTTP_PROTOCOLS[self.http])
self.http_protocol_class: Type[
asyncio.Protocol] = http_protocol_class
else:
self.http_protocol_class = self.http
if isinstance(self.ws, str):
ws_protocol_class = import_from_string(WS_PROTOCOLS[self.ws])
self.ws_protocol_class: Optional[Type[
asyncio.Protocol]] = ws_protocol_class
else:
self.ws_protocol_class = self.ws
self.lifespan_class = import_from_string(LIFESPAN[self.lifespan])
try:
self.loaded_app = import_from_string(self.app)
except ImportFromStringError as exc:
logger.error("Error loading ASGI app. %s" % exc)
sys.exit(1)
try:
self.loaded_app = self.loaded_app()
except TypeError as exc:
if self.factory:
logger.error("Error loading ASGI app factory: %s", exc)
sys.exit(1)
else:
if not self.factory:
logger.warning(
"ASGI app factory detected. Using it, "
"but please consider setting the --factory flag explicitly."
)
if self.interface == "auto":
if inspect.isclass(self.loaded_app):
use_asgi_3 = hasattr(self.loaded_app, "__await__")
elif inspect.isfunction(self.loaded_app):
use_asgi_3 = asyncio.iscoroutinefunction(self.loaded_app)
else:
call = getattr(self.loaded_app, "__call__", None)
use_asgi_3 = asyncio.iscoroutinefunction(call)
self.interface = "asgi3" if use_asgi_3 else "asgi2"
if self.interface == "wsgi":
self.loaded_app = WSGIMiddleware(self.loaded_app)
self.ws_protocol_class = None
elif self.interface == "asgi2":
self.loaded_app = ASGI2Middleware(self.loaded_app)
if self.debug:
self.loaded_app = DebugMiddleware(self.loaded_app)
if logger.level <= TRACE_LOG_LEVEL:
self.loaded_app = MessageLoggerMiddleware(self.loaded_app)
if self.proxy_headers:
self.loaded_app = ProxyHeadersMiddleware(
self.loaded_app, trusted_hosts=self.forwarded_allow_ips)
self.loaded = True
def setup_event_loop(self):
loop_setup = import_from_string(LOOP_SETUPS[self.loop])
if loop_setup is not None:
loop_setup()
def setup_event_loop(self) -> None:
loop_setup: Optional[Callable] = import_from_string(
LOOP_SETUPS[self.loop])
if loop_setup is not None:
loop_setup(reload=self.reload)
def __init__(
self,
app,
host="127.0.0.1",
port=8000,
uds=None,
fd=None,
loop="auto",
http="auto",
ws="auto",
log_level="info",
logger=None,
access_log=True,
wsgi=False,
debug=False,
proxy_headers=False,
root_path="",
limit_concurrency=None,
limit_max_requests=None,
disable_lifespan=False,
timeout_keep_alive=5,
install_signal_handlers=True,
):
self.app = app
self.host = host
self.port = port
self.uds = uds
self.fd = fd
self.loop = loop
self.http = http
self.ws = ws
self.log_level = log_level
self.logger = logger
self.access_log = access_log
self.wsgi = wsgi
self.debug = debug
self.proxy_headers = proxy_headers
self.root_path = root_path
self.limit_concurrency = limit_concurrency
self.limit_max_requests = limit_max_requests
self.disable_lifespan = disable_lifespan
self.timeout_keep_alive = timeout_keep_alive
self.install_signal_handlers = install_signal_handlers
if fd is None:
self.sock = None
else:
self.host = None
self.port = None
self.sock = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
if self.logger is None:
self.logger = get_logger(log_level)
else:
assert log_level == "info", "Cannot set both 'logger' and 'log_level'"
if isinstance(http, str):
self.http_protocol_class = import_from_string(HTTP_PROTOCOLS[http])
else:
self.http_protocol_class = http
if isinstance(ws, str):
self.ws_protocol_class = import_from_string(WS_PROTOCOLS[ws])
else:
self.ws_protocol_class = ws
if isinstance(self.loop, str):
loop_setup = import_from_string(LOOP_SETUPS[loop])
self.loop = loop_setup()
try:
self.app = import_from_string(self.app)
except ImportFromStringError as exc:
click.echo("Error loading ASGI app. %s" % exc)
sys.exit(1)
if self.wsgi:
self.app = WSGIMiddleware(self.app)
self.ws_protocol_class = None
if self.debug:
self.app = DebugMiddleware(self.app)
if self.logger.level <= logging.DEBUG:
self.app = MessageLoggerMiddleware(self.app)
if self.proxy_headers:
self.app = ProxyHeadersMiddleware(self.app)
def test_invalid_module():
with pytest.raises(ImportFromStringError) as exc:
import_from_string("module_does_not_exist:myattr")
expected = 'Could not import module "module_does_not_exist".'
assert expected in str(exc)
