应用¶
sanic.app¶
-
class
sanic.app.Sanic(name, config=None, ctx=None, router=None, signal_router=None, error_handler=None, env_prefix='SANIC_', request_class=None, strict_slashes=False, log_config=None, configure_logging=True, dumps=None, loads=None, inspector=False, inspector_class=None, certloader_class=None)¶ 基类：
Generic[sanic.app.config_type,sanic.app.ctx_type],sanic.mixins.static.StaticHandleMixin,sanic.base.root.BaseSanic,sanic.mixins.startup.StartupMixin主应用程序实例
-
ack()¶ 向服务器管理器发送确认消息的快捷方式。
通常，这通常不需要手动调用。它用于告诉管理器进程正在运行并准备开始运行。
- 返回类型:
None
-
add_route(handler, uri, methods=frozenset({'GET'}), host=None, strict_slashes=None, version=None, name=None, stream=False, version_prefix='/v', error_format=None, unquote=False, **ctx_kwargs)¶ 用于注册基于类的视图的帮助器方法，或用作应用程序URL路由的处理程序。
- 参数：
Handler(RouteHandler)：用作路由处理程序的函数或基于类的视图。URI(Str)：URL的路径。方法(可迭代 [str] )：允许的方法列表或元组；如果使用HTTPMethodView，则覆盖这些方法。主机(可选 [Union[str, List[str] ]])：与此路由匹配的一个或多个主机名。严格斜杠(可选 [bool] )：如果设置，路线的斜杠将是严格的。例如。 /foo 将不匹配 /foo/ 。版本(可选 [Union[int, str, float] ])：该路由的接口版本。名称(可选 [str] )：用户定义的路由名称 url_for 。Stream(Bool)：指定处理程序是否为流处理程序的布尔值。Version_Prefix(Str)：URL路径，应在版本值之前；默认：
/v。ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。UNQUOTE(Bool)：指定处理程序是否需要取消引号的布尔值。Ctx_kwargs(Any)：以 ctx_* 前缀将附加到路由上下文 (route.ctx)。请参见下面的示例。- 返回：
RouteHandler：路由处理程序。
- 例如：
``` 来自Sanic的Python导入Sanic，文本
App=Sanic(“测试”)
- 异步定义处理程序(请求)：
返回文本(“OK”)
App.addroute(处理程序，“/test”，方法= ["GET", "POST"] ) ```
您可以使用 ctx_kwargs 要将自定义上下文添加到路由，请执行以下操作。当想要将元数据添加到可由应用程序的其他部分(如中间件)使用的路由时，这通常很有用。
``` 来自Sanic的Python导入Sanic，文本
App=Sanic(“测试”)
- 异步定义处理程序(请求)：
返回文本(“OK”)
- 异步定义自定义中间件(请求)：
- 如果请求.route.ctx.monitor：
DO_SOME_MONCENTING()
App.addroute(处理程序，“/test”，方法= ["GET", "POST"] ，ctx_monitor=True)app.Register_Midleware(CUSTOM_MIDDLEWARE)
- 参数:
handler (Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]) --
uri (str) --
methods (Iterable[str]) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
stream (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
unquote (bool) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
add_signal(handler, event, condition=None, exclusive=True)¶ 为特定事件注册信号处理程序。
- 参数：
- 处理程序(可选 [Callable[..., Any] ])：要调用的函数
当事件发生时。如果未提供，则默认为noop。
Event(Str)：要侦听的事件的名称。条件(可选 [Dict[str, Any] ])：要过滤的可选条件
事件触发。默认为 None 。
- 独占(Bool)：处理程序是否独占。什么时候
True 时，才能调度信号。 condition 已经被满足了。 This is inapplicable to blueprint signals, which are * *ALWAYS * non-exclusive.* 默认为 True 。
- 返回：
可调用 [..., Any] ：已注册的处理程序。
- 参数:
handler (Optional[Callable[[..], Any], None]) --
event (str) --
condition (Optional[Dict[str, Any], None]) --
exclusive (bool) --
- 返回类型:
Callable[[..], Any]
-
add_task(task, *, name=None, register=True)¶ 安排一个任务在循环开始后稍后运行。
虽然这有点类似于 asyncio.create_task ，它可以在循环启动之前使用(在这种情况下，它将在循环在 before_server_start 收听者)。
命名任务是一种很好的做法，因为它允许您稍后取消它们，并允许Sanic在服务器停止时管理它们(如果需要)。
[See user guide re: background tasks] (/en/指南/基础/任务#背景-任务)
- 参数：
- 任务(联合 [Future[Any] 、Coroutine [Any, Any, Any] 、可等待 [Any] ])：
未来的、协同的或可等待时间表的。
- 名称(可选 [str] ，可选)：任务的名称，如果需要
稍后参考。默认为 None 。
- Register(bool，可选)：是否注册任务。缺省值
至 True 。
- 返回：
任选 [Task[Any] ]：计划的任务(如果适用)。
- 参数:
task (Union[_asyncio.Future[Any], Coroutine[Any, Any, Any], Awaitable[Any]]) --
name (Optional[str, None]) --
register (bool) --
- 返回类型:
Optional[_asyncio.Task[Any], None]
-
add_websocket_route(handler, uri, host=None, strict_slashes=None, subprotocols=None, version=None, name=None, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 将函数注册为WebSocket路由的帮助器方法。
- 参数：
- 处理程序(Callable)：类的可调用函数或实例
可以处理WebSocket请求的。
URI(Str)：将映射到WebSocket处理程序的URL路径。主机(可选 [Union[str, List[str] ]])：主机IP或FQDN详细信息。严格斜杠(可选 [bool] )：如果API端点需要
以一个 "/" 或者不去。
- 子协议(可选 [List[str] ])：与一起使用的子协议
WebSocket握手。
版本(可选 [Union[int, str, float] ])：版本信息。名称(可选 [str] )：分配给URL的唯一名称。Version_Prefix(Str)：版本值之前的URL路径。
默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：错误处理的格式。 **ctx_kwargs (Any): Keyword arguments beginning with `ctx_* `
前缀将附加到路由上下文 (route.ctx )。
- 返回：
Callable：作为处理程序传递的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
-
after_reload_trigger(listener)¶ 用于为AFTER_RELOAD_TRIGGER事件注册侦听器的修饰器。
此事件仅在重新加载过程中激发，并且 NOT 在任何工作进程上。此事件在重新加载过程触发重新加载后激发。已检测到更改事件，并已触发重新加载过程。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_After_ReLoad_Trigger(应用程序：SANIC，CHANGED：SET)上进行同步定义 [str] )：
Print(“重新加载触发器后，更改的文件：”，更改)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
after_server_start(listener)¶ 用于为AFTER_SERVER_START事件注册侦听器的修饰器。
此事件在所有工作进程上激发。通常应使用此事件来运行后台任务，或执行与处理请求没有直接关系的其他操作。理论上，可能会在激发此事件之前处理某些请求，因此不应使用此事件来初始化处理请求所需的资源。
此事件的一个常见用例是启动一个后台任务，该任务定期执行某些操作，例如清除缓存或执行运行状况检查。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` PYTHON@app.After_SERVER_START异步定义ON_After_SERVER_START(APP：SANIC)：
打印(“服务器启动后”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
after_server_stop(listener)¶ 用于为AFTER_SERVER_STOP事件注册侦听器的修饰器。
此事件在所有工作进程上激发。此事件在服务器停止关闭且所有请求都已处理后激发。通常应使用此事件清除在BEFORE_SERVER_START事件中初始化的资源。
此事件的常见用例是关闭数据库连接池或关闭缓存客户端。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_After_SERVER_STOP(应用程序：SANIC)上的PYTHON@app.AFTER_SERVER_STOP异步定义：
打印(“服务器停止后”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
all_exceptions(handler)¶ 为了方便起见，启用创建全局异常处理程序的过程。
以下两个示例是等价的：
``` PYTHON@APP.EXCEPTION(异常)异步数据处理程序(REQUEST：REQUEST，EXCEPTION：EXCEPTION)->HTTPResponse：
返回文本(f“引发异常：{异常}”)
``` Python@app.all_Exceptions异步数据处理程序(REQUEST：REQUEST，EXCEPTION：EXCEPTION)->HTTPResponse：
返回文本(f“引发异常：{异常}”)
- 参数：
处理程序(可调用 [..., Any] )：处理异常的协程函数。
- 返回：
- 可调用 [..., Any] ：处理全局异常的修饰方法
根据本蓝图登记的任何路线。
- 参数:
handler (Callable[[..], Any]) --
- 返回类型:
Callable[[..], Any]
-
amend()¶ 上下文管理器，允许在应用程序启动后对其进行更改。
通常，一旦应用程序启动并运行，您就不能进行某些更改，如添加路由、中间件或信号。此上下文管理器允许您进行这些更改，然后在上下文管理器退出时再次完成应用程序。
- 返回类型:
Iterator[None]
-
before_reload_trigger(listener)¶ 用于为BEFORE_RELOAD_TRIGGER事件注册侦听器的修饰器。
此事件仅在重新加载过程中激发，并且 NOT 在任何工作进程上。此事件在重新加载过程触发重新加载之前激发。已检测到更改事件，即将触发重新加载过程。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_BEFORE_RELOAD_TRIGGER(APP：SANIC)上执行PYTHON@APP.BEFORE_RELOAD_TRIGGER异步定义：
Print(“重新加载触发器前”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
before_server_start(listener)¶ 用于为BEFORE_SERVER_START事件注册侦听器的修饰器。
此事件在所有工作进程上激发。通常应使用此事件来初始化本质上是全局的资源，或将在请求和应用程序的不同部分之间共享的资源。
此事件的常见用例是初始化数据库连接池或初始化缓存客户端。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` PYTHON@APP.BEFORE_SERVER_START异步定义ON_BEFORE_SERVER_START(应用程序：SANIC)：
打印(“服务器启动前”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
before_server_stop(listener)¶ 用于为BEFORE_SERVER_STOP事件注册侦听器的修饰器。
此事件在所有工作进程上激发。此事件在服务器开始关闭之前激发。不应使用此事件执行处理请求所需的任何操作，因为激发此事件后可能会继续处理某些请求。
此事件的一个常见用例是停止在AFTER_SERVER_START事件中启动的后台任务。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_BEFORE_SERVER_STOP(应用程序：SANIC)上执行PYTHON@APP.BEFORE_SERVER_STOP异步定义：
打印(“服务器停止前”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
blueprint(blueprint, *, url_prefix=None, version=None, strict_slashes=None, version_prefix=None, name_prefix=None)¶ 在应用程序上注册蓝图。
看见 [Blueprints] (/en/指南/最佳实践/蓝图)了解更多信息。
- 参数：
蓝图(联合 [Blueprint, Iterable[Blueprint] ，BlueprintGroup])：蓝图对象或其(列表，元组)。Url_prefix(可选 [str] )：绑定到蓝图的所有URL的前缀。默认为 None 。版本(可选 [Union[int, float, str] ])：URL的版本前缀。默认为 None 。严格斜杠(可选 [bool] )：强制执行尾部斜杠。默认为 None 。Version_Prefix(可选 [str] )：版本的前缀。默认为 None 。名称_前缀(可选 [str] )：蓝图名称的前缀。默认为 None 。
- 示例：
``` Python app=Sanic(“TestApp”)BP=Blueprint(‘TestBP’)
@bp.route(‘/route’)def处理程序(请求)：
返回文本(‘Hello，Blueprint！’)
- 参数:
blueprint (Union[sanic.blueprints.Blueprint, Iterable[sanic.blueprints.Blueprint], sanic.blueprints.BlueprintGroup]) --
url_prefix (Optional[str, None]) --
version (Optional[Union[int, float, str]]) --
strict_slashes (Optional[bool, None]) --
version_prefix (Optional[str, None]) --
name_prefix (Optional[str, None]) --
- 返回类型:
None
-
async
cancel_task(name, msg=None, *, raise_exception=True)¶ 取消命名任务。
此方法用于按任务名称取消任务。或者，您可以提供一条消息，说明取消任务的原因，并控制在未找到任务时是否应引发异常。
- 参数：
Name(Str)：要取消的任务的名称。味精(可选 [str] )：描述任务取消原因的可选消息。默认为无。RAISE_EXCEPTION(Bool)：如果为True，则在未找到任务时将引发异常。默认为True。
- 示例：
``` Python Async def my_TASK()：
- 尝试：
等待异步者。睡眠(10)
- 除Ayncio外。取消错误为e：
CURRENT_TASK=asyncio.CURRENT_TASK()print(f“任务{Current_task.get_name()}已取消。{e}”)#TASK SELEPY_TASK已取消。不能再睡了！
@app.pre_server_start async def之前_start(App)：
App.add_ASTASK(MY_TASK，NAME=“SLEEPY_TASK”)等待asyncio.sleep(1)等待APP.CANCEL_TASK(“Sleepy_TASK”，msg=“不再睡眠！”)
- 参数:
name (str) --
msg (Optional[str, None]) --
raise_exception (bool) --
- 返回类型:
None
-
catch_exception(handler)¶ 注册用于记录或处理的异常处理程序。
此方法允许注册自定义异常处理程序以捕获和处理应用程序中发生的异常。与可能修改对客户端的响应的典型异常处理程序不同，这是为了捕获异常以进行日志记录或其他内部处理，例如将其发送到错误报告实用程序。
- 参数：
- Handler(Callable)：接受应用程序的协程函数
实例和异常作为参数。它将在应用程序的生命周期内发生异常时被调用。
- 示例：
``` Python app=Sanic(“TestApp”)
@app.Catch_Exception Async def REPORT_EXCEPTION(APP：SANIC，EXCEPTION：EXCEPTION)：
Logging.error(f“发生异常：{异常}”)
#发送到错误报告服务等待Error_Serice.report(异常)
- 参数:
handler (Callable[[sanic.mixins.signals.SignalMixin, Exception], Coroutine[Any, Any, None]]) --
- 返回类型:
None
-
async
create_server(host=None, port=None, *, debug=False, ssl=None, sock=None, protocol=None, backlog=100, access_log=None, unix=None, return_asyncio_server=True, asyncio_server_kwargs=None, noisy_exceptions=None)¶ 用于创建Sanic服务器实例的低级API。
此方法将创建一个Sanic Server实例，但不会启动它。这对于将Sanic集成到其他系统很有用。但是，您在使用它时要小心，因为它是一个低级API，不执行任何生命周期事件。
备注
这不支持多处理，也不是运行Sanic应用程序的首选方式。谨慎行事。
您需要自己启动服务器，如下例所示。您负责服务器的生命周期，包括使用 await app.startup() 。不会为您触发任何事件，因此如果需要，您需要自己触发它们。
- 参数：
主机(可选 [str] )：要在其上托管的地址。端口(可选 [int] )：要托管的端口。调试(Bool)：启用调试输出(降低服务器速度)。SSL(联合 [None, SSLContext, dict, str, list, tuple] )：SSLContext，
或工人SSLEncryption的证书和密钥位置(S)。
- 袜子(可选 [socket] )：服务器可以接受的套接字
连接自。
- 协议(可选 [Type[Protocol] ])：的子类
asyncio.Protocol 班级。
- Backlog(Int)：系统未接受的连接数
将在拒绝新连接之前允许。
- ACCESS_LOG(可选 [bool] )：启用写入访问日志
(降低服务器速度)。
返回_asyncio_服务器(Bool)： _DEPRECATED_ Asyncio_server_kwargs(可选 [Dict[str, Any] ])：key-Value
Asyncio/uvloop的参数 create_server 方法。
- 噪音异常(可选 [bool] )：记录正常情况下
被认为是安静的/沉默的。
- 返回：
- 任选 [AsyncioServer] ：AsyncioServer IF return_asyncio_server
是 True 其他 None 。
- 例如：
``` 从Sanic导入Sanic的Python导入Asyncio导入uvloop，响应
App=Sanic(“Example”)
@app.route(“/”)异步def测试(请求)：
返回Response.json({“Answer”：“42”})
- Async def Main()：
等待服务器。创建服务器()等待服务器。启动()等待服务器。服务永远()
- 如果 __name__ ==“__Main__”：
Asyncio.set_event_loop(uvloop.new_event_loop())Asyncio.run(Main())
- 参数:
host (Optional[str, None]) --
port (Optional[int, None]) --
debug (bool) --
ssl (Union[None, ssl.SSLContext, dict, str, list, tuple]) --
sock (Optional[socket.socket, None]) --
protocol (Optional[Type[asyncio.protocols.Protocol], None]) --
backlog (int) --
access_log (Optional[bool, None]) --
unix (Optional[str, None]) --
return_asyncio_server (bool) --
asyncio_server_kwargs (Optional[Dict[str, Any], None]) --
noisy_exceptions (Optional[bool, None]) --
- 返回类型:
Optional[sanic.server.async_server.AsyncioServer, None]
-
delete(uri, host=None, strict_slashes=None, version=None, name=None, ignore_body=False, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 DELETE HTTP方法。
- 参数：
URI(Str)：要标记到HTTP的Delete方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
《路线》。
- IGNORE_BODY(Bool)：是否忽略
请求。默认为 False 。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。 **ctx_kwargs (Any): Keyword arguments that begin with a `ctx_* `
前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
ignore_body (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
dispatch(event, *, condition=None, context=None, fail_not_found=True, inline=False, reverse=False)¶ 将事件调度到信号路由器。
- 参数：
Event(Str)：要调度的事件的名称。条件(可选 [Dict[str, str] ])：的条件
事件调度。
上下文(可选 [Dict[str, Any] ])：事件调度的上下文。FAIL_NOT_FOUND(Bool)：如果没有找到事件，是否失败。
缺省值为 True 。
- Inline(Bool)：IF True 直接返回结果。如果 False ，
返回一个 Task 。缺省值为 False 。
- 反转(Bool)：是否反转派工单。
缺省值为 False 。
- 返回：
- 科鲁廷 [Any, Any, Awaitable[Union[Task, Any] ]]：一个可以等待的
，则直接返回结果，如果 inline=True ，或一个 Task 如果 inline=False 。
- 例如：
``` PYTHON@APP.SIGNAL(“user.Registration.Created”)Async def SEND_REGISTION_EMAIL(**上下文)：
等待发送电子邮件(CONTEXT ["email"] ，模板=“注册”)
@app.post(“/Register”)异步def句柄_注册(REQUEST)：
ALWAY DO_REGISTION(REQUEST)等待REQUEST.APP.DISPATION(
“user.Registration.Created”，上下文={“Email”：quest.json.mail}
})
- 参数:
event (str) --
condition (Optional[Dict[str, str], None]) --
context (Optional[Dict[str, Any], None]) --
fail_not_found (bool) --
inline (bool) --
reverse (bool) --
- 返回类型:
Coroutine[Any, Any, Awaitable[Union[_asyncio.Task, Any]]]
-
static
dispatch_delayed_tasks(app, loop)¶ 用于调度延迟任务的信号处理程序。
它用于分派在循环开始之前添加的任务，并将在循环开始后被调用。它通常不会直接使用。
- 参数：
App(Sanic)：Sanic应用程序实例。Loop(AbstractEventLoop)：任务在其中的事件循环
正在奔跑。
- 返回：
没有
- 参数:
app (sanic.app.Sanic) --
loop (asyncio.events.AbstractEventLoop) --
- 返回类型:
None
-
enable_websocket(enable=True)¶ 启用或禁用对WebSocket的支持。
如果将WebSocket路由添加到应用程序，则会自动启用WebSocket。这通常不需要手动调用。
- 参数：
- Enable(bool，可选)：如果设置为 True ，启用WebSocket
支持。如果设置为 False ，则禁用WebSocket支持。默认为 True 。
- 返回：
没有
- 参数:
enable (bool) --
- 返回类型:
None
-
async
event(event, timeout=None)¶ 等待触发特定事件。
此方法等待触发命名事件，并可与信号系统结合使用以等待特定信号。如果未找到该事件，并且启用了事件的自动注册，则将注册该事件，然后等待。如果未找到该事件且未启用自动注册，则会引发 NotFound 引发异常。
自动注册可以通过设置 EVENT_AUTOREGISTER 配置值为 True 。
`python app.config.EVENT_AUTOREGISTER = True `- 参数：
事件(Str)：要等待的事件的名称。超时(可选 [Union[int, float] ])：可选的超时值
在几秒钟内。如果提供，则在到达超时时将终止等待。默认为 None ，意味着不会超时。
- 产生：
- NotFound：如果未找到该事件并自动注册
未启用事件。
- 返回：
没有
- 例如：
``` Python异步定义WAIT_FOR_EVENT(APP)：
- 当为True时：
Print(“>Waiting”)等待app.Event(“foo.bar.baz”)print(“>Event Found”)
@app.AFTER_SERVER_START Async def After_SERVER_START(app，loop)：
APP.ADD_TASK(Wait_for_Event(App))
- 参数:
event (str) --
timeout (Optional[Union[int, float]]) --
- 返回类型:
None
-
exception(*exceptions, apply=True)¶ 用于为当前应用程序或蓝图实例注册异常处理程序的修饰器。
此方法允许您为可能在此蓝图的路线内引发的特定异常定义处理程序。您可以指定要捕获的一个或多个异常类型，处理程序将应用于这些异常。
在蓝图上使用时，处理程序将仅应用于在该蓝图下注册的路线。这意味着它们只适用于匹配的请求，异常在该路由的处理程序函数(或中间件)中引发。
一般的例外情况，如 NotFound 应该只在应用程序实例上注册，而不是在蓝图上注册。
看见 [Exceptions] (/en/Guide/Best-Practices/Exeptions.html)了解更多信息。
- 参数：
- 例外情况(联合 [Type[Exception] ，列表 [Type[Exception] ]])：列表
处理程序要捕获的Python异常。
- Apply(bool，可选)：异常处理程序是否应为
已申请。默认为True。
- 返回：
- Callable：用于处理任何路由的全局异常的修饰方法
在这个蓝图下注册的。
- 示例：
``` 来自Sanic的Python导入蓝图，文本
BP=Blueprint(‘My_Blueprint’)
@bp.EXCEPTION(异常)def HANDLE_EXCEPTION(REQUEST，EXCEPT)：
返回文本(“哎呀，出问题了！”，状态=500)
``` 来自Sanic的Python导入Sanic，NotFound，Text
App=Sanic(‘MyApp’)
@app.ception(NotFound)def Ignore_404s(请求，异常)：
返回文本(f“是的，我完全找到了页面：{quest.url}”)
- 参数:
exceptions (Union[Type[Exception], List[Type[Exception]]]) --
apply (bool) --
- 返回类型:
Callable
-
extend(*, extensions=None, built_in_extensions=True, config=None, **kwargs)¶ 使用Sanic扩展功能扩展Sanic。
使用此方法可以将一个或多个Sanic扩展添加到当前的Sanic实例。它允许对扩展对象进行更多控制，例如启用或禁用内置扩展或提供定制配置。
- 看见 [Sanic Extensions] (/en/plugins/sanic-ext/Growing-Started)
了解更多细节。
- 参数：
- 扩展模块(可选 [List[Type[Extension] ]]，可选)：
要添加的扩展。默认为 None ，这意味着只添加了内置扩展。
- 内置扩展(bool，可选)：是否开启内置
分机。默认为 True 。
- 配置(可选 [Union[Config, Dict[str, Any] ]]，可选)：
扩展的可选自定义配置。默认为 None 。
- **kwargs：可能需要的其他关键字参数
特定的扩展名。
- 返回：
扩展：Sanic扩展实例。
- 产生：
- 运行错误：如果尝试在扩展Sanic之后扩展Sanic
已设置扩展。
- 例如：
- 典型的用例可能是添加自定义扩展以及
内置的。
``` PYTHON APP.EXTEND(
分机= [MyCustomExtension] ，内置扩展=True
- 参数:
extensions (Optional[List[Type[Extension]]]) --
built_in_extensions (bool) --
config (Optional[Union[Config, Dict[str, Any]]]) --
- 返回类型:
Extend
-
finalize()¶ 最终确定Sanic应用程序的路由配置。
该方法通过调用路由器的Finalize方法来完成路由设置，并最终确定已添加到应用程序中的任何中间件。如果应用程序未处于测试模式，则将引发任何终止错误。
完成包括确定已定义的路线和优化Sanic的性能以满足应用程序的特定需求。如果要手动添加路线，则在Sanic启动后，通常需要使用 amend 上下文管理器，而不是直接调用此方法。
备注
此方法通常在服务器设置过程中在内部调用，通常不需要手动调用。
- 产生：
- FinalizationError：如果在结束过程中出现错误
进程，并且应用程序未处于测试模式。
- 示例：
`python app.finalize() `
- 返回类型:
None
-
finalize_middleware()¶ 完成Sanic应用程序的中间件配置。
此方法完成了应用程序的中间件设置。Sanic中的中间件用于在请求到达单独的路由之前或在处理完路由之后对请求进行全局处理。
完成包括确定已定义的路线和优化Sanic的性能以满足应用程序的特定需求。如果要手动添加路线，则在Sanic启动后，通常需要使用 amend 上下文管理器，而不是直接调用此方法。
备注
此方法通常在服务器设置过程中在内部调用，通常不需要手动调用。
- 示例：
`python app.finalize_middleware() `
- 返回类型:
None
-
get(uri, host=None, strict_slashes=None, version=None, name=None, ignore_body=True, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 GET HTTP方法。
- 参数：
URI(Str)：要标记到HTTP的GET方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
路线。
- IGNORE_BODY(Bool)：处理程序是否应该忽略请求
尸体。这意味着，请求的正文如果发送，将不会被使用。在这种情况下，您将在日志中看到一条警告。默认为 True 这意味着不会消耗身体。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**ctx_kwargs(Any)：以
ctx_* prefix 将被追加到路径上下文中 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
ignore_body (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
static
get_address(host, port, version=<HTTP.VERSION_1: 1>, auto_tls=False)¶ 检索主机地址和端口，并根据给定参数使用默认值。
- 参数：
主机(可选 [str] )：要使用的服务的主机IP或FQDN。默认为 "127.0.0.1" 。端口(可选 [int] )：端口号。默认为 8443 如果版本为3或 auto_tls=True 、其他 8000 Version(HTTPVersion，可选)：HTTP版本。默认为 HTTP.VERSION_1 (http/1.1)。AUTO_TLS(bool，可选)：自动TLS标志。默认为 False 。
- 返回：
元组 [str, int] ：包含主机和端口的元组
- 参数:
host (Optional[str, None]) --
port (Optional[int, None]) --
version (Union[sanic.http.constants.HTTP, Literal[1], Literal[3]]) --
auto_tls (bool) --
- 返回类型:
Tuple[str, int]
-
classmethod
get_app(name=None, *, force_create=False)¶ 按名称检索实例化的Sanic实例。
当需要访问应用程序的另一部分中已定义的应用程序实例时，最好使用此方法。
警告
在全局作用域中使用此方法时要小心，因为如果导入的全局作用域在创建应用程序实例之前运行，则运行的导入路径可能会导致它出错。
它通常最适合在创建应用程序实例后调用的函数或方法中使用。
``` Python def setup_routes()：
App=Sanic.get_app()app.addroute(HANDLER_1，‘/route1’)app.addroute(HANDLER_2，‘/route2’)
- 参数：
- 名称(可选 [str] ，可选)：应用实例的名称
去找回。未指定时，如果只有一个应用程序实例，它将返回唯一的应用程序实例。如果未指定，并且存在多个应用程序实例，则将引发异常。默认为 None 。
- Force_create(bool，可选)：if True 命名的应用程序就是这样
不存在，将创建一个新实例。默认为 False 。
- 返回：
Sanic：请求的Sanic应用程序实例。
- 产生：
- 如果找到多个Sanic应用程序或未找到任何应用程序，则抛出
如果未找到指定的名称，则返回。
- 示例：
`python app1 = Sanic("app1") app2 = Sanic.get_app("app1") # app2 is the same instance as app1 `
- 参数:
name (Optional[str, None]) --
force_create (bool) --
- 返回类型:
-
get_motd_data(server_settings=None)¶ 检索当日消息(MOTD)数据。
- 参数：
- SERVER_SETTINGS(可选 [Dict[str, Any] ]，可选)：设置
服务器。默认为 None 。
- 返回：
- 元组 [Dict[str, Any] ，Dict [str, Any] ]：包含两个
带有相关MOTD数据的词典。
- 参数:
server_settings (Optional[Dict[str, Any], None]) --
- 返回类型:
Tuple[Dict[str, Any], Dict[str, Any]]
-
static
get_server_location(server_settings=None)¶ 使用服务器设置，检索服务器位置。
- 参数：
- SERVER_SETTINGS(可选 [Dict[str, Any] ]，可选)：设置
服务器。默认为 None 。
- 返回：
Str：服务器位置。
- 参数:
server_settings (Optional[Dict[str, Any], None]) --
- 返回类型:
str
-
get_task(name, *, raise_exception=True)¶ 获取命名任务。
此方法用于按名称获取任务。或者，您可以控制在未找到任务时是否应引发异常。
- 参数：
Name(Str)：要检索的任务的名称。RAISE_EXCEPTION(Bool)：如果 True ，将在以下情况下引发异常
找不到该任务。默认为 True 。
- 返回：
任选 [Task] ：任务(如果找到)。
- 参数:
name (str) --
raise_exception (bool) --
- 返回类型:
Optional[_asyncio.Task, None]
-
async
handle_exception(request, exception, run_middleware=True)¶ 捕获特定异常并输出响应的处理程序。
备注
此方法通常在内部使用，您不需要直接调用它。
- 参数：
请求(Request)：当前请求对象。异常(BaseException)：引发的异常。Run_Midleware(Bool)：是否运行中间件。缺省值
至 True 。
- 产生：
服务器错误：响应500。
- 参数:
request (sanic.request.types.Request) --
exception (BaseException) --
run_middleware (bool) --
- 返回类型:
None
-
async
handle_request(request)¶ 通过将请求调度到适当的处理程序来处理请求。
备注
此方法通常在内部使用，您不需要直接调用它。
- 参数：
请求(Request)：当前请求对象。
- 产生：
服务器错误：响应500。
- 参数:
request (sanic.request.types.Request) --
- 返回类型:
None
-
head(uri, host=None, strict_slashes=None, version=None, name=None, ignore_body=True, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 HEAD HTTP方法。
- 参数：
URI(Str)：要标记到HTTP的Head方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
路线。
- IGNORE_BODY(Bool)：处理程序是否应该忽略请求
尸体。这意味着，请求的正文如果发送，将不会被使用。在这种情况下，您将在日志中看到一条警告。默认为 True 这意味着不会消耗身体。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**ctx_kwargs(Any)：以
ctx_* 前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
ignore_body (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
listener(listener_or_event, event_or_none=None, apply=True)¶ 为应用程序生命周期中的特定事件创建侦听器。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
备注
重载签名允许以不同的方式调用此方法，具体取决于参数的类型。
通常，最好使用方便的方法之一，例如 before_server_start 或 after_server_stop 而不是直接调用此方法。
``` PYTHON@APP.BEVER_START Async def prefered_method(_) ：
..。
@app.listener(“BEFORE_SERVER_START”)异步定义 not_prefered_method(_) ：
..。
- 参数：
Listener_or_Event(联合 [ListenerType[Sanic] ，str])：侦听器函数或事件名称。EVENT_OR_NONE(可选 [str] )：要侦听的事件名称，如果 listener_or_event 是一个函数。默认为 None 。Apply(Bool)：是否立即应用监听器。默认为 True 。
- 返回：
友联市 [ListenerType[Sanic] ，可调用 [[ListenerType[Sanic] ]、ListenerType [Sanic] ]]：侦听器或接受侦听器的可调用对象。
- 示例：
下面的代码片段显示了如何将此方法用作修饰符：
``` Python@bp.listener(“BEFORE_SERVER_START”)async def BEFORE_SERVER_START(app，loop)：
..。
- 参数:
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]], Callable[[Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]], Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]]]
-
main_process_ready(listener)¶ 用于注册Main_Process_Ready事件的侦听器的修饰器。
此事件仅在主进程上激发，并且 NOT 在任何工作进程上。它是在主进程启动并且Worker Manager初始化后触发的(即，您将有权访问 app.manager 实例)。此事件的典型用例是将托管进程添加到Worker Manager。
看见 [Running custom processes] (/en/guide/deployment/manager.html#running-custom-processes)和 [Listeners] (/en/Guide/basics/listeners.html)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_Main_Process_Ready(APP：SANIC)上定义PYTHON@app.main_Process_Ready异步定义：
打印(“主进程就绪”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
main_process_start(listener)¶ 用于注册Main_Process_Start事件的侦听器的修饰器。
此事件仅在主进程上激发，并且 NOT 在任何工作进程上。通常应使用此事件来初始化在辅助进程之间共享的资源，或初始化在辅助进程中初始化不安全的资源。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_Main_Process_Start(APP：SANIC)上执行PYTHON@app.main_process_start异步定义：
Print(“主进程已启动”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
main_process_stop(listener)¶ 用于注册Main_Process_Stop事件的侦听器的修饰器。
此事件仅在主进程上激发，并且 NOT 在任何工作进程上。通常应使用此事件清除在Main_Process_Start事件中初始化的资源。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` 在_MAIN_PROCESS_STOP(APP：SANIC)上定义PYTHON@app.main_Process_Stop异步定义：
Print(“主进程已停止”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
make_coffee(*args, **kwargs)¶ 你自己试试吧！ sanic server:app --coffee
``` ▄████████▄
████▀▀▄███████████████████████▄▄▀
-
middleware(middleware_or_request, attach_to='request', apply=True, *, priority=0)¶ 用于注册中间件的装饰器。
在处理请求之前或创建响应之后修饰和注册要调用的中间件。可以被调用为 @app.middleware 或 @app.middleware('request') 。尽管如此，建议使用 @app.on_request 或 @app.on_response 取而代之的是为了清晰和方便。
看见 [Middleware] (/Guide/Basics/Midleware)了解更多信息。
- 参数：
- 中间件_或_请求(UNION [Callable, str] )：中间件功能
或关键字‘请求’或‘响应’。
- Attach_to(str，可选)：何时应用中间件；
‘REQUEST’(在处理请求之前)或‘RESPONSE’(在创建响应之后)。默认为 'request' 。
- Apply(bool，可选)：是否应用中间件。
默认为 True 。
- 优先级(int，可选)：中间件的优先级。
较小的数字将首先执行。默认为 0 。
- 返回：
- 友联市 [Callable, Callable[[Callable] ，可调用]]：被授勋的
中间件函数或部分函数，具体取决于方法的调用方式。
- 示例：
``` Python@app.midleware(‘REQUEST’)Async def CUSTOM_MIDDLEWARE(REQUEST)：
..。
- 参数:
middleware_or_request (Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], str]) --
attach_to (str) --
apply (bool) --
priority (int) --
- 返回类型:
Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]]]], Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]]]]]
-
motd(server_settings=None)¶ 输出当日消息(MOTD)。
它通常在每个进程中只能调用一次，通常由 run 方法在主过程中进行。
- 参数：
- SERVER_SETTINGS(可选 [Dict[str, Any] ]，可选)：设置
服务器。默认为 None 。
- 返回：
没有
- 参数:
server_settings (Optional[Dict[str, Any], None]) --
- 返回类型:
None
-
on_request(middleware=None, *, priority=0)¶ 在处理请求之前注册要调用的中间件。
这与 @app.middleware('request') 。
- 参数：
- 中间件(可调用的，可选的)：可调用的，接受
请求。默认为 None 。
- 返回：
- Callable：修饰的中间件函数或分部函数
具体取决于该方法的调用方式。
- 例如：
``` PYTHON@app.on_REQUEST Async def CUSTOM_MIDDLEWARE(请求)：
Quest.ctx.Custom=‘Value’
- 返回类型:
Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]]]
-
on_response(middleware=None, *, priority=0)¶ 注册要在创建响应后调用的中间件。
这与 @app.middleware('response') 。
- 参数：
- 中间件(可调用的，可选的)：可调用的，接受
请求和响应。默认为 None 。
- 返回：
- Callable：修饰的中间件函数或分部函数
具体取决于该方法的调用方式。
- 例如：
``` PYTHON@app.on_Response异步定义定制中间件(Request，Response)：
response.headers ['X-Server'] =‘Sanic’
-
options(uri, host=None, strict_slashes=None, version=None, name=None, ignore_body=True, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 OPTIONS HTTP方法。
- 参数：
URI(Str)：要标记到HTTP的Options方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
路线。
- IGNORE_BODY(Bool)：处理程序是否应该忽略请求
尸体。这意味着，请求的正文如果发送，将不会被使用。在这种情况下，您将在日志中看到一条警告。默认为 True 这意味着不会消耗身体。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**ctx_kwargs(Any)：以
ctx_* 前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
ignore_body (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
patch(uri, host=None, strict_slashes=None, stream=False, version=None, name=None, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 PATCH HTTP方法。
- 参数：
URI(Str)：要标记到HTTP的补丁方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
- Stream(Bool)：设置为 True 如果需要完全请求流传输，
False 否则的话。默认为 False 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
路线。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**ctx_kwargs(Any)：以
ctx_* 前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
post(uri, host=None, strict_slashes=None, stream=False, version=None, name=None, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 POST HTTP方法。
- 参数：
URI(Str)：要标记到HTTP的POST方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
- Stream(Bool)：是否对请求正文进行流处理。
默认为 False 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
路线。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**ctx_kwargs(Any)：以
ctx_* 前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
stream (bool) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
prepare(host=None, port=None, *, dev=False, debug=False, auto_reload=None, version=<HTTP.VERSION_1: 1>, ssl=None, sock=None, workers=1, protocol=None, backlog=100, register_sys_signals=True, access_log=None, unix=None, loop=None, reload_dir=None, noisy_exceptions=None, motd=True, fast=False, verbosity=0, motd_display=None, coffee=False, auto_tls=False, single_process=False)¶ 准备要同时提供服务的一个或多个Sanic应用程序。
当您需要同时运行多个Sanic应用程序时，通常会使用此低级API。一旦做好准备， Sanic.serve() 应在 if __name__ == "__main__" 阻止。
备注
具有此功能的“准备”和“服务”相当于使用 app.run 对于单个实例。只有在同时运行多个应用程序时才应使用此选项。
- 参数：
主机(可选 [str] ，可选)：要监听的主机名。默认为 None 。端口(可选 [int] ，可选)：监听端口。默认为 None 。Dev(bool，可选)：开发模式。默认为 False 。DEBUG(bool，可选)：调试模式。默认为 False 。自动重新加载(可选)(_R [bool] ，可选)：自动重新加载功能。默认为 None 。Version(HTTPVersion，可选)：要使用的HTTP版本。默认为 HTTP.VERSION_1 。SSL(联合 [None, SSLContext, dict, str, list, tuple] ，可选)：SSL配置。默认为 None 。袜子(可选 [socket] ，可选)：要绑定到的套接字。默认为 None 。Worker(int，可选)：工作进程数。默认为 1 。协议(可选 [Type[Protocol] ]，可选)：自定义协议类。默认为 None 。Backlog(int，可选)：挂起连接的最大数量。默认为 100 。REGISTER_SYS_SIGNAL(bool，可选)：注册系统信号。默认为 True 。ACCESS_LOG(可选 [bool] ，可选)：访问日志。默认为 None 。Unix(可选 [str] ，可选)：Unix套接字。默认为 None 。循环(可选 [AbstractEventLoop] ，可选)：事件循环。默认为 None 。重新加载目录(可选 [Union[List[str] ，str]]，可选)：重新加载目录。默认为 None 。噪音异常(可选 [bool] ，可选)：显示例外。默认为 None 。Motd(bool，可选)：显示当天的消息。默认为 True 。FAST(bool，可选)：快速模式。默认为 False 。详细级别(int，可选)：详细级别。默认为 0 。MOTD_DISPLAY(可选 [Dict[str, str] ]，可选)：定制MOTD显示。默认为 None 。咖啡(bool，可选)：咖啡模式。默认为 False 。AUTO_TLS(bool，可选)：自动TLS。默认为 False 。Single_Process(bool，可选)：单进程模式。默认为 False 。
- 产生：
运行错误：在尝试将HTTP/3作为辅助服务器提供服务时引发。RuntimeError：尝试同时使用两者时引发 fast 和 workers 。运行错误：尝试使用时引发 single_process 使用 fast ， workers ，或 auto_reload 。TypeError：尝试使用时引发 loop 使用 create_server 。ValueError：在以下情况下引发 PROXIES_COUNT 是阴性的。
- 例如：
``` 如果是Python If __name__ ==“__Main__”：
App.preparate()app.Serve()
- 参数:
host (Optional[str, None]) --
port (Optional[int, None]) --
dev (bool) --
debug (bool) --
auto_reload (Optional[bool, None]) --
version (Union[sanic.http.constants.HTTP, Literal[1], Literal[3]]) --
ssl (Union[None, ssl.SSLContext, dict, str, list, tuple]) --
sock (Optional[socket.socket, None]) --
workers (int) --
protocol (Optional[Type[asyncio.protocols.Protocol], None]) --
backlog (int) --
register_sys_signals (bool) --
access_log (Optional[bool, None]) --
unix (Optional[str, None]) --
loop (Optional[asyncio.events.AbstractEventLoop, None]) --
reload_dir (Optional[Union[List[str], str]]) --
noisy_exceptions (Optional[bool, None]) --
motd (bool) --
fast (bool) --
verbosity (int) --
motd_display (Optional[Dict[str, str], None]) --
coffee (bool) --
auto_tls (bool) --
single_process (bool) --
- 返回类型:
None
-
purge_tasks()¶ 从任务注册表中清除已完成和已取消的任务。
此方法循环访问任务注册表，标识任何已完成或已取消的任务，然后移除这些任务，只在注册表中保留挂起的任务。
- 返回类型:
None
-
put(uri, host=None, strict_slashes=None, stream=False, version=None, name=None, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰函数处理程序以使用 PUT HTTP方法。
- 参数：
URI(Str)：要标记到http的PUT方法的URL。主机(可选 [Union[str, List[str] ]])：主机IP或完全限定的域名
要使用的服务。
- 严格斜杠(可选 [bool] )：指示Sanic检查是否
请求URL需要以 / 。
- Stream(Bool)：是否对请求正文进行流处理。
默认为 False 。
版本(可选 [Union[int, str, float] ])：接口版本。名称(可选 [str] )：可用于标识的唯一名称
路线。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**ctx_kwargs(Any)：以
ctx_* 前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteHandler：用路由方法修饰的对象。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
stream (bool) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]
-
refresh(passthru=None)¶ 刷新应用程序实例。 This is used internally by Sanic 。
警告
此方法仅供内部使用，不应直接调用。
- 参数：
- 直通(可选 [Dict[str, Any] ]，可选)：可选词典
要传递给新实例的属性的。默认为 None 。
- 返回：
SANIC：刷新的应用程序实例。
- 参数:
passthru (Optional[Dict[str, Any], None]) --
- 返回类型:
-
classmethod
register_app(app)¶ 在类注册表中注册一个Sanic实例。
此方法将一个Sanic应用程序实例添加到类注册表，该注册表用于跟踪该应用程序的所有实例。它通常在内部使用，但也可用于注册可能在类注册表外创建的应用程序。
- 参数：
App(Sanic)：要注册的Sanic实例。
- 产生：
- 如果应用程序不是Sanic的实例，或者如果
应用程序的名称已在使用中(除非在测试模式下)。
- 例如：
`python Sanic.register_app(my_app) `
- 参数:
app (sanic.app.Sanic) --
- 返回类型:
None
-
register_listener(listener, event)¶ 注册给定事件的侦听器。
- 参数：
Listener(Callable)：要注册的侦听器。Event(Str)：要侦听的事件。
- 返回：
Callable：已注册的监听程序。
-
register_middleware(middleware, attach_to='request', *, priority=<Default>)¶ 在处理请求之前注册要调用的中间件。
- 参数：
中间件(Callleware)：接受请求的Callable。Attach_to(Str)：是附加到请求还是响应。
默认为 'request' 。
- 优先级(Int)：中间件的优先级。
较小的数字将首先执行。默认为 0 。
- 返回：
- 友联市 [Callable, Callable[[Callable] ，可调用]]：被授勋的
中间件函数或部分函数，具体取决于方法的调用方式。
- 参数:
middleware (Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], sanic.middleware.Middleware]) --
attach_to (str) --
priority (Union[sanic.helpers.Default, int]) --
- 返回类型:
Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], sanic.middleware.Middleware]
-
register_named_middleware(middleware, route_names, attach_to='request', *, priority=<Default>)¶ 用于注册命名中间件(通常在蓝图上的中间件)
- 参数：
中间件(Callleware)：接受请求的Callable。ROUTE_NAMES(可重复 [str] )：要附加到
中间件到。
- Attach_to(Str)：是附加到请求还是响应。
默认为 'request' 。
- 优先级(Int)：中间件的优先级。
较小的数字将首先执行。默认为 0 。
- 返回：
- 友联市 [Callable, Callable[[Callable] ，可调用]]：被授勋的
中间件函数或部分函数，具体取决于方法的调用方式。
- 参数:
middleware (Union[Callable[[Request], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Callable[[Request, sanic.response.types.BaseHTTPResponse], Union[sanic.response.types.HTTPResponse, None, Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]]]) --
route_names (Iterable[str]) --
attach_to (str) --
priority (Union[sanic.helpers.Default, int]) --
-
reload_process_start(listener)¶ 用于为RELOAD_PROCESS_START事件注册侦听器的修饰器。
此事件仅在重新加载过程中激发，并且 NOT 在任何工作进程上。这类似于Main_Process_Start事件，不同之处在于它仅在重新加载进程启动时触发。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` Python@app.reload_process_start async def on_reload_process_start(app：sanic)：
Print(“重新加载进程已开始”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
reload_process_stop(listener)¶ 用于为RELOAD_PROCESS_STOP事件注册侦听器的修饰器。
此事件仅在重新加载过程中激发，并且 NOT 在任何工作进程上。这类似于Main_Process_Stop事件，不同之处在于它仅在重新加载进程停止时触发。
看见 [Listeners] (/en/Guide/basics/listeners)了解更多详细信息。
- 参数：
监听器(ListenerType [Sanic] )：要附加的侦听器处理程序。
- 例如：
``` PYTHON@app.reLoad_Process_Stop Async def on_reLoad_Process_Stop(app：sanic)：
Print(“重新加载进程已停止”)
- 参数:
listener (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]) --
- 返回类型:
Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]]]
-
report_exception(handler)¶ 注册处理程序以报告异常。
一种方便的方法，用于为发生异常时发出的信号注册处理程序。它通常用于向外部服务报告异常。
它相当于：
``` PYTHON@APP.SIGNAL(Event.SERVER_EXCEPTION_REPORT)异步解码报告(异常)：
等待带有错误的DO_SOURE_WITH(异常)
- 参数：
- 处理程序(可调用 [[Sanic, Exception] 、Coroutine [Any, Any, None] ])：
要注册的处理程序。
- 返回：
- 可调用 [[Sanic, Exception] 、Coroutine [Any, Any, None] ]：
已注册的处理程序。
- 参数:
handler (Callable[[sanic.app.Sanic, Exception], Coroutine[Any, Any, None]]) --
- 返回类型:
Callable[[Exception], Coroutine[Any, Any, None]]
-
route(uri, methods=None, host=None, strict_slashes=None, stream=False, version=None, name=None, ignore_body=False, apply=True, subprotocols=None, websocket=False, unquote=False, static=False, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 装饰要注册为路由的函数。
- 参数：
URI(Str)：URL的路径。方法(可选 [Iterable[str] ])：列表或元组
允许的方法。
主机(可选 [Union[str, List[str] ]])：东道主，如果需要的话。严格斜杠(可选 [bool] )：是否应用严格的斜杠
去那条路线。
Stream(Bool)：是否允许请求流式传输其正文。版本(可选 [Union[int, str, float] ])：具体路线
版本化。
名称(可选 [str] )：url_for的用户自定义路由名称。IGNORE_BODY(Bool)：处理程序是否应该忽略请求
正文(例如 GET 请求)。
Apply(Bool)：将中间件应用于路由。子协议(可选 [List[str] ])：子协议列表。WebSocket(Bool)：启用WebSocket支持。无引号(Bool)：URL路径中的特殊字符不带引号。静态(Bool)：启用静态路由。Version_Prefix(Str)：应该在版本之前的URL路径
值；默认值： "/v" 。
ERROR_FORMAT(可选 [str] )：路线的错误格式。Ctx_kwargs(Any)：以 ctx_*
前缀将附加到路由上下文 (route.ctx )。
- 返回：
RouteWrapper：路由数组，修饰函数。
- 例如：
使用方法定义GET终结点：
``` Python@app.route(“/Hello”)async def Hello(REQUEST：REQUEST)：
返回文本(“Hello，World！”)
将上下文Kwarg添加到路由：
``` Python@app.route(“/greet”，ctx_name=“World”)async def greet(REQUEST：REQUEST)：
Name=quest.route.ctx.name返回文本(f“Hello，{name}！”)
- 参数:
uri (str) --
methods (Optional[Iterable[str], None]) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
stream (bool) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
ignore_body (bool) --
apply (bool) --
subprotocols (Optional[List[str], None]) --
websocket (bool) --
unquote (bool) --
static (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
- 返回类型:
Callable[[Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]], Union[Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]], Tuple[sanic_routing.route.Route, Callable[[..], Coroutine[Any, Any, Optional[sanic.response.types.HTTPResponse, None]]]]]]
-
run(host=None, port=None, *, dev=False, debug=False, auto_reload=None, version=<HTTP.VERSION_1: 1>, ssl=None, sock=None, workers=1, protocol=None, backlog=100, register_sys_signals=True, access_log=None, unix=None, loop=None, reload_dir=None, noisy_exceptions=None, motd=True, fast=False, verbosity=0, motd_display=None, auto_tls=False, single_process=False)¶ 运行HTTP服务器并监听，直到键盘中断或终端信号。在终端上，在关闭之前排空连接。
备注
当您需要控制运行Sanic实例时，这是可以使用的方法。但是，在大多数情况下，首选方法是使用CLI命令：
`sh sanic server:app` `如果使用此方法运行Sanic，请确保执行以下操作：
使用 if __name__ == "__main__" 守卫密码。
做 NOT 中定义应用程序实例。 if 阻止。
看见 [Dynamic Applications] 有关第二点的更多信息，请参见(/en/Guide/Deploy/app-loader)。
- 参数：
主机(可选 [str] )：要在其上托管的地址。端口(可选 [int] )：要托管的端口。Dev(Bool)：以开发模式运行服务器。调试(Bool)：启用调试输出(降低服务器速度)。自动重新加载(可选)(_R [bool] )：当应用程序的源代码发生更改时，重新加载应用程序。
在调试模式下默认使能。
版本(HTTPVersion)：HTTP版本。SSL(联合 [None, SSLContext, dict, str, list, tuple] )：SSLContext，或证书和密钥的位置
用于工人的SSL加密(S)。
袜子(可选 [socket] )：服务器接受其连接的套接字。Worker(Int)：在它被尊重之前收到的进程数。协议(可选 [Type[Protocol] ])：Ayncio协议类的子类。Backlog(Int)：系统将允许的未接受的连接数
在拒绝新连接之前。
REGISTER_SYS_SIGNAL(Bool)：注册SIG*事件。ACCESS_LOG(可选 [bool] )：允许写入访问日志(降低服务器速度)。Unix(可选 [str] )：要侦听的Unix套接字，而不是TCP端口。循环(可选 [AbstractEventLoop] )：AsyncIO事件循环。重新加载目录(可选 [Union[List[str] ，str]])：如果AUTO_RELOAD为True，则监视代码更改的目录。噪音异常(可选 [bool] )：记录通常被视为静默/静默的异常。Motd(Bool)：显示当天的消息。FAST(Bool)：启用快速模式。详细级别(Int)：详细级别。MOTD_DISPLAY(可选 [Dict[str, str] ])：定制每日消息显示。AUTO_TLS(Bool)：启用自动TLS证书处理。Single_Process(Bool)：开启单进程模式。
- 返回：
没有
- 产生：
运行错误：在尝试将HTTP/3作为辅助服务器提供服务时引发。RuntimeError：尝试同时使用两者时引发 fast 和 workers 。运行错误：尝试使用时引发 single_process 使用 fast ， workers ，或 auto_reload 。TypeError：尝试使用时引发 loop 使用 create_server 。ValueError：在以下情况下引发 PROXIES_COUNT 是阴性的。
- 例如：
``` 来自Sanic的Python导入Sanic，请求，json
App=Sanic(“TestApp”)
@app.get(“/”)异步def处理器(REQUEST：REQUEST)：
返回json({“foo”：“bar”})
- 如果 __name__ ==“__Main__”：
App.run(port=9999，dev=True)
- 参数:
host (Optional[str, None]) --
port (Optional[int, None]) --
dev (bool) --
debug (bool) --
auto_reload (Optional[bool, None]) --
version (Union[sanic.http.constants.HTTP, Literal[1], Literal[3]]) --
ssl (Union[None, ssl.SSLContext, dict, str, list, tuple]) --
sock (Optional[socket.socket, None]) --
workers (int) --
protocol (Optional[Type[asyncio.protocols.Protocol], None]) --
backlog (int) --
register_sys_signals (bool) --
access_log (Optional[bool, None]) --
unix (Optional[str, None]) --
loop (Optional[asyncio.events.AbstractEventLoop, None]) --
reload_dir (Optional[Union[List[str], str]]) --
noisy_exceptions (Optional[bool, None]) --
motd (bool) --
fast (bool) --
verbosity (int) --
motd_display (Optional[Dict[str, str], None]) --
auto_tls (bool) --
single_process (bool) --
- 返回类型:
None
-
static
run_delayed_task(app, loop, task)¶ 在给定应用程序和循环的上下文中执行延迟的任务。
此方法通过调用应用程序的私有 _prep_task 方法，然后等待准备好的任务的执行。
- 参数：
- App(Any)：任务将在其上运行的应用程序实例
被处死。
- Loop(AbstractEventLoop)：任务将在其中执行的事件循环
被安排好。
- 任务(任务 [Any] )：将准备的任务功能
并被处死。
- 返回：
没有
- 参数:
app (sanic.app.Sanic) --
loop (asyncio.events.AbstractEventLoop) --
task (_asyncio.Task[Any]) --
- 返回类型:
None
-
classmethod
serve(primary=None, *, app_loader=None, factory=None)¶ 服务于一个或多个Sanic应用程序。
这是运行Sanic应用程序的主要入口点。它应该在 if __name__ == "__main__" 阻止。
- 参数：
- 主要(可选 [Sanic] ，可选)：主Sanic应用程序
去服务。默认为 None 。
- App_loader(可选 [AppLoader] ，可选)：AppLoader实例
用于加载应用程序。默认为 None 。
- 工厂(可选 [Callable[[] ，Sanic]]，可选)：工厂
用于加载应用程序的函数。默认为 None 。
- 产生：
RounmeError：在未找到任何应用程序时引发。对象的服务器信息时引发
主要应用程序。
- 运行错误：尝试使用时引发 loop 使用
create_server.
- 运行错误：尝试使用时引发 single_process 使用
fast ， workers ，或 auto_reload 。
- 运行错误：在尝试将HTTP/3作为
备用服务器。
- RuntimeError：尝试同时使用两者时引发 fast 和
workers 。
- TypeError：尝试使用时引发 loop 使用
create_server.
ValueError：在以下情况下引发 PROXIES_COUNT 是阴性的。
- 例如：
``` 如果是Python If __name__ ==“__Main__”：
App.preparate()Sanic.Serve()
-
classmethod
serve_single(primary=None)¶ 为Sanic应用程序的单个进程提供服务。
类似于 serve ，但只服务于单个进程。使用时，某些功能将被禁用，例如 fast ， workers ， multiplexer ， auto_reload ，和督察。几乎不需要直接使用此方法。相反，您应该使用CLI：
`sh sanic app.sanic:app --single-process `或者，如果需要以编程方式完成此操作，则应使用 single_process 的论点 run ：
`python app.run(single_process=True) `- 参数：
- 主要(可选 [Sanic] ，可选)：主Sanic应用程序
去服务。默认为 None 。
- 产生：
RounmeError：在未找到任何应用程序时引发。对象的服务器信息时引发
主要应用程序。
- 运行错误：在尝试将HTTP/3作为
备用服务器。
- RuntimeError：尝试同时使用两者时引发 fast 和
workers 。
ValueError：在以下情况下引发 PROXIES_COUNT 是阴性的。
- 参数:
primary (Optional[Sanic]) --
- 返回类型:
None
-
setup_loop()¶ 设置事件循环。
一个内部方法，用于将事件循环设置为uvloop(如果可能)，或者设置为Windows选择器循环(如果在Windows上)。
- 返回：
没有
- 返回类型:
None
-
classmethod
should_auto_reload()¶ 检查是否有任何应用程序启用了自动重新加载。
- 返回：
- 布尔： True 如果任何应用程序启用了自动重新加载，则为
False 。
- 返回类型:
bool
-
shutdown_tasks(timeout=None, increment=0.1)¶ 取消除服务器任务之外的所有任务。
此方法用于取消除服务器任务之外的所有任务。它遍历任务注册表，取消除服务器任务之外的所有任务，然后等待任务完成。或者，您可以提供超时和增量来控制该方法等待任务完成的时间。
- 参数：
- 超时(可选 [float] )：等待任务的时间量
来完成。默认为 None 。
- Increment(Float)：两次检查之间等待的时间量
任务是否已完成。默认为 0.1 。
- 参数:
timeout (Optional[float, None]) --
increment (float) --
- 返回类型:
None
-
signal(event, *, apply=True, condition=None, exclusive=True)¶ 用于创建信号处理程序，类似于路由处理程序的使用：
@app.signal("foo.bar.<thing>") async def signal_handler(thing, **kwargs): print(f"[signal_handler] {thing=}", kwargs)
- 参数:
event (str) -- 中事件的表示形式
one.two.three表格apply (bool, optional) -- 对于延迟计算，默认为
Truecondition (Dict[str, Any], optional) -- 用于与
condition调度筛选中的参数，默认为Noneexclusive (bool) -- 什么时候
True，只有在满足条件时才能发送信号。什么时候False，信号可以在有或没有它的情况下发送。 THIS IS INAPPLICABLE TO BLUEPRINT SIGNALS. THEY ARE ALWAYS NON-EXCLUSIVE ，默认为True
- 返回类型:
Callable[[Callable[[..], Coroutine[Any, Any, None]]], Callable[[..], Coroutine[Any, Any, None]]]
-
signalize(allow_fail_builtin=True)¶ 完成Sanic应用程序的信号处理配置。
该方法通过调用信号路由器的Finalize方法来完成信号处理设置。如果应用程序未处于测试模式，则将引发任何终止错误。
最终确定包括确定已定义的信号和优化Sanic的性能以满足应用程序的特定需求。如果要手动添加信号，则在Sanic启动后，通常需要使用 amend 上下文管理器，而不是直接调用此方法。
备注
此方法通常在服务器设置过程中在内部调用，通常不需要手动调用。
- 参数：
- ALLOW_FAIL_BUILTIN(bool，可选)：如果设置为 True ，将允许
内置信号在定稿过程中失败。默认为 True 。
- 产生：
- FinalizationError：如果信号过程中出现错误
正在完成过程，并且应用程序未处于测试模式。
- 示例：
`python app.signalize(allow_fail_builtin=False) `
- 参数:
allow_fail_builtin (bool) --
- 返回类型:
None
-
static(uri, file_or_directory, pattern='/?.+', use_modified_since=True, use_content_range=False, stream_large_files=False, name='static', host=None, strict_slashes=None, content_type=None, apply=True, resource_type=None, index=None, directory_view=False, directory_handler=None)¶ 注册要从中提供文件的根目录。输入可以是文件，也可以是目录。
此方法提供了一种简单易用的方法来设置提供静态文件所需的路径。
- 参数：
URI(Str)：用于提供静态内容的URL路径。文件或目录(联合 [PathLike, str] )：静态文件的路径
或包含静态文件的目录。
- Pattery(str，可选)：标识有效的正则表达式模式
静态文件。默认为 r"/?.+" 。
- USE_MODIFIED_SIMPLE(bool，可选)：如果为True，则发送修改的文件
如果浏览器的时间与服务器的时间匹配，则返回Not Modify。默认为 True 。
- USE_CONTENT_RANGE(bool，可选)：如果为真，则为
范围请求并发送所请求的文件部分。默认为 False 。
- STREAM_LARGE_FILES(联合 [bool, int] ，可选)：如果 True ，使用
这个 StreamingHTTPResponse.file_stream 处理程序而不是 HTTPResponse.file handler 来发送文件。如果这是一个整数，则表示要切换到的阈值大小 StreamingHTTPResponse.file_stream 。默认为 False ，这意味着响应将不会被流传输。
- 名称(str，可选)：用于url_for的用户定义名称。
默认为 "static" 。
- 主机(可选 [str] ，可选)：主机IP或FQDN
要使用的服务。
- 严格斜杠(可选 [bool] ，可选)：指示Sanic
检查请求URL是否需要以斜杠结束。
- Content_type(可选 [str] ，可选)：用户定义的内容类型
对于标题。
- Apply(bool，可选)：如果为True，将注册路由
立刻。默认为 True 。
- Resource_type(可选 [str] ，可选)：显式声明一个
资源将成为 "file" 或者是 "dir" 。
- 索引(可选 [Union[str, Sequence[str] ]]，可选)：何时
相对于目录，index是将用作默认文件的名称。当传递多个文件名时，将按顺序尝试它们。
- DIRECTORY_VIEW(bool，可选)：是否回退到显示
公开目录时的目录查看器。默认为 False 。
- DIRECTORY_HANDER(可选 [DirectoryHandler] ，可选)：一个
DirectoryHandler的实例，可用于显式控制默认目录处理程序的行为并将其派生为子类。
- 返回：
明细表 [sanic.router.Route] ：路由器上注册的路由。
- 例如：
为单个文件提供服务： ``python app.static('/foo', 'path/to/static/file.txt') ` `
为目录中的所有文件提供服务： ``python app.static('/static', 'path/to/static/directory') ` `
服务具有特定阈值的大文件： ``python app.static('/static', 'path/to/large/files', stream_large_files=1000000) ` `
- 参数:
uri (str) --
file_or_directory (Union[os.PathLike, str]) --
pattern (str) --
use_modified_since (bool) --
use_content_range (bool) --
stream_large_files (Union[bool, int]) --
name (str) --
host (Optional[str, None]) --
strict_slashes (Optional[bool, None]) --
content_type (Optional[str, None]) --
apply (bool) --
resource_type (Optional[str, None]) --
index (Optional[Union[str, Sequence[str]]]) --
directory_view (bool) --
directory_handler (Optional[sanic.handlers.directory.DirectoryHandler, None]) --
-
stop(terminate=True, unregister=False)¶ 这会杀死Sanic服务器，并自行清理。
- 参数：
- Terminate(Bool)：强制立即终止所有请求
让他们完成处理。
取消注册(Bool)：从全局注册表中取消注册应用程序。
- 返回：
没有
- 参数:
terminate (bool) --
unregister (bool) --
- 返回类型:
None
-
classmethod
unregister_app(app)¶ 从类注册表中注销一个Sanic实例。
此方法从类注册表中删除以前注册的Sanic应用程序实例。这对于清理目的很有用，特别是在测试或不再需要应用程序实例时。但是，它通常在内部使用，在大多数情况下不应该需要。
- 参数：
App(Sanic)：要注销的Sanic实例。
- 产生：
如果应用程序不是Sanic的实例，则抛出。
- 例如：
`python Sanic.unregister_app(my_app) `
- 参数:
app (sanic.app.Sanic) --
- 返回类型:
None
-
update_config(config)¶ 更新应用程序配置。
此方法用于更新应用程序配置。它可以接受配置对象、词典或指向包含配置对象或词典的文件的路径。
看见 [Configuration] (/en/指南/部署/配置)了解详细信息。
- 参数：
- CONFIG(联合 [bytes, str, dict, Any] )：配置对象，
字典或配置文件的路径。
- 参数:
config (Union[bytes, str, dict, Any]) --
- 返回类型:
None
-
url_for(view_name, **kwargs)¶ 基于视图名称和提供的值生成URL。
此方法为给定的视图名称构造URL，并考虑可用于修改结果URL的各种特殊关键字参数。它可以处理内部路由以及具有不同方案的外部URL。
有几个特殊的关键字参数可用于修改构建的URL。它们每个都以下划线开头。它们是：
_anchor
_external
_host
_server
_scheme
- 参数：
View_name(Str)：引用视图名称的字符串。？_SCHEME(Str)：应为“http”或“https”，默认为“http”。_EXTERNAL(Bool)：返回路径还是带方案和主机的完整URL。_host(Str)：当为某个路由定义了一个或多个主机以告知Sanic使用哪个主机时使用。_SERVER(Str)：如果不使用“_host”，将用于定义URL的主机名。**kwargs：用于构建请求参数和
查询字符串参数。
- 产生：
URLBuildError：如果构造URL有问题。
- 返回：
Str：构建的URL。
- 例如：
使用参数构建特定视图的URL： ``python url_for('view_name', param1='value1', param2='value2') # /view-name?param1=value1¶m2=value2 ` `
使用特定方案和锚点创建外部URL： ``python url_for('view_name', _scheme='https', _external=True, _anchor='section1') # https://example.com/view-name#section1 ` `
使用特定主机创建URL： ``` Python url_for(‘视图名’，_HOST=‘subdomain.example.com’)#http://subdomain.example.com/view-name
- 参数:
view_name (str) --
-
websocket(uri, host=None, strict_slashes=None, subprotocols=None, version=None, name=None, apply=True, version_prefix='/v', error_format=None, **ctx_kwargs)¶ 修饰要注册为WebSocket路由的函数。
- 参数：
URI(Str)：URL的路径。主机(可选 [Union[str, List[str] ]])：主机IP或FQDN详细信息。严格斜杠(可选 [bool] )：如果API端点需要
以一个 "/" 或者不去。
- 子协议(可选 [List[str] ])：可选的字符串列表
支持的子协议。
- 版本(可选 [Union[int, str, float] ])：WebSocket
协议版本。
- 名称(可选 [str] )：分配给URL的唯一名称，以便
可以与url_for一起使用。
- Apply(Bool)：如果设置为False，则不会将路由应用于
应用程序。缺省值为 True 。
- Version_Prefix(Str)：应该在版本之前的URL路径
价值。默认为 "/v" 。
ERROR_FORMAT(可选 [str] )：自定义错误格式字符串。**CTX_kwargs(Any)：以开头的关键字参数
一个 ctx_* prefix 将被追加到路径上下文中 (route.ctx )。
- 返回：
元组：路由元组，修饰函数。
- 参数:
uri (str) --
host (Optional[Union[str, List[str]]]) --
strict_slashes (Optional[bool, None]) --
subprotocols (Optional[List[str], None]) --
version (Optional[Union[int, str, float]]) --
name (Optional[str, None]) --
apply (bool) --
version_prefix (str) --
error_format (Optional[str, None]) --
ctx_kwargs (Any) --
-
property
asgi¶ 应用程序是否在ASGI模式下运行。
-
property
asgi_client¶ 使用ASGI进入应用程序以执行处理程序的测试客户端。
此属性在以下情况下可用 sanic-testing 程序包已安装。
看见 [Test Clients] 有关详细信息，请访问(/en/plugins/sanic-testing/clients#asgi-async-client-sanicasgitestclient)。
- 返回：
SanicASGITestClient：来自 sanic-testing 包裹。
-
property
auto_reload¶ 应用程序是否在自动重新加载模式下运行。
-
property
debug¶ 应用程序是否在调试模式下运行。
-
property
ext¶ 用于访问Sanic扩展的便利性属性。
此属性在以下情况下可用 sanic-ext 程序包已安装。
- 看见 [Sanic Extensions] (/en/plugins/sanic-ext/Growing-Started)
了解更多细节。
- 返回：
扩展：Sanic扩展实例。
- 例如：
一个典型的用例可能是注册依赖项注入。 ``python app.ext.dependency(SomeObject()) ` `
-
property
inspector¶ 用于访问应用程序状态的Inspector实例。
这只能从工作进程访问，并且只有在启用检查器的情况下才能访问。
看见 [Inspector] (/en/指南/部署/检查员)了解详细信息。
- 返回：
检查员：检查员的一个实例。
-
property
loop¶ 与asyncio.get_event_loop（）同义。
备注
仅在使用时支持 app.run 方法。
- 返回：
AbstractEventLoop：应用程序的事件循环。
- 产生：
如果应用程序没有运行，则抛出。
-
property
m¶ 用于与工作进程交互的接口
这是一条快捷方式 app.multiplexer 。它仅在使用SANIC服务器的工作进程中可用。它允许您与工作进程交互，例如发送消息和命令。
看见 [Access to the multiplexer] 有关更多信息，请访问(/en/guide/deployment/manager#access-to-the-multiplexer)。
- 返回：
WorkerMultiplexer：Worker多路复用器实例
- 例如：
``` Python app.m.art()#重新启动辅助进程app.m.Terminate()#终止辅助进程app.m.scale(4)#将辅助进程的数量扩展到4个
-
property
manager¶ 属性以访问WorkerManager实例。
此属性提供对控制辅助进程的WorkerManager对象的访问。它只能从主进程访问。
备注
请确保仅从主进程访问此属性，因为尝试从辅助进程访问此属性将导致异常。
看见 [WorkerManager] (/en/指南/部署/管理器)了解详细信息。
- 返回：
- WorkerManager：负责管理的经理
工作进程。
- 产生：
- 如果试图访问管理器，则抛出
如果管理器未初始化，则从工作进程返回。
- 示例：
`python app.manager.manage(...) `
-
property
reload_dirs¶ 为自动重新加载而监视的目录。
- 返回：
- 集 [str] ：要监视的目录集
自动重新加载。
-
property
serve_location¶ 检索服务器位置。
- 返回：
Str：服务器位置。
-
property
state¶ 应用程序状态。
- 返回：
ApplicationState：应用程序的当前状态。
-
property
tasks¶ 当前在应用程序中注册的任务。
- 返回：
- 可重复的 [Task[Any] ]：当前注册的任务
应用程序。
-
property
test_client¶ 使用HTTPX和实时运行的服务器进入应用程序以执行处理程序的测试客户端。
此属性在以下情况下可用 sanic-testing 程序包已安装。
看见 [Test Clients] 有关详细信息，请访问(/en/plugins/sanic-testing/clients#wsgi-client-sanictestclient)。
- 返回：
SanicTestClient：来自 sanic-testing 包裹。
sanic.config¶
-
class
sanic.config.Config(defaults=None, env_prefix='SANIC_', keep_alive=None, *, converters=None)¶ 基类：
dictSanic的配置对象。
您可以使用该对象：(1)配置Sanic的操作方式，以及(2)管理应用程序的自定义配置值。
-
load(config)¶ 更新应用程序配置.
备注
仅考虑大写设置
看见 [Configuration] (/en/指南/部署/配置)了解更多详细信息。
- 参数：
- CONFIG(联合 [bytes, str, dict, Any] )：py文件存放的路径
设置、词典保存设置或任何对象保存设置。
- 例如：
您可以通过提供py文件保存设置的路径来上载应用程序配置。
`python # /some/py/file A = 1 B = 2 ``python config.update_config("${some}/py/file") `是的，您可以将环境变量放在此处，但必须以以下格式提供：
${some_env_var}，并记住这一点$some_env_var被视为普通字符串。您可以通过提供dict保持设置来上载应用程序配置。
`python d = {"A": 1, "B": 2} config.update_config(d) `您可以通过提供任何保存设置的对象来上载应用程序配置，但在这种情况下 config.__dict__ 将用作dict保持设置。
``` PythonC类：
A=1 B=2
- 参数:
config (Union[bytes, str, dict, Any]) --
-
load_environment_vars(prefix='SANIC_')¶ 将环境变量加载到配置中。
查找带前缀的环境变量并将其应用于配置(如果存在)。当Sanic启动以将环境变量加载到配置中时，会自动调用此函数。环境变量应该以定义的前缀开头，并且应该只包含大写字母。
它将自动补充以下类型的水分：
intfloatbool
任何其他内容都将作为
str。如果要将其他类型添加到此列表中，可以使用sanic.config.Config.register_type()。只需确保在实例化应用程序之前注册了它们。您可能不需要直接调用此方法。
看见 [Configuration] (/en/指南/部署/配置)了解更多详细信息。
-
register_type(converter)¶ 注册一个自定义类型转换器。
允许添加自定义函数以从字符串值转换为任何其他类型。如果ValueError不是正确的类型，则函数应引发ValueError。
- 参数：
- 转换器(可调用 [[str] ，any])：接受字符串的函数
并返回任何类型的值。
- 例如：
``` Python def my_Converter(值：str)->任意：
#做一些事情来转换值返回值
- 参数:
converter (Callable[[str], Any]) --
- 返回类型:
None
-
update(*other, **kwargs)¶ 使用新值更新配置。
此方法将使用提供的 other 对象，然后使用提供的 kwargs 。这个 other 对象可以是任何可以转换为字典的对象，如 dict ， Config 对象，或 str 指向Python文件的路径。这个 kwargs 必须是键-值对的字典。
备注
仅考虑大写设置
- 参数：
- *Other：可以转换为
字典。
**kwargs：任意数量的键值对。
- 产生：
AttributeError：如果密钥不在配置中。
- 例如：
``` PYTHON CONFIG.UPDATE(
{“A”：1，“B”：2}，{“C”：3，“D”：4}，E=5，F=6，
- 参数:
other (Any) --
kwargs (Any) --
- 返回类型:
None
-
update_config(config)¶ 更新应用程序配置.
备注
仅考虑大写设置
看见 [Configuration] (/en/指南/部署/配置)了解更多详细信息。
- 参数：
- CONFIG(联合 [bytes, str, dict, Any] )：py文件存放的路径
设置、词典保存设置或任何对象保存设置。
- 例如：
您可以通过提供py文件保存设置的路径来上载应用程序配置。
`python # /some/py/file A = 1 B = 2 ``python config.update_config("${some}/py/file") `是的，您可以将环境变量放在此处，但必须以以下格式提供：
${some_env_var}，并记住这一点$some_env_var被视为普通字符串。您可以通过提供dict保持设置来上载应用程序配置。
`python d = {"A": 1, "B": 2} config.update_config(d) `您可以通过提供任何保存设置的对象来上载应用程序配置，但在这种情况下 config.__dict__ 将用作dict保持设置。
``` PythonC类：
A=1 B=2
- 参数:
config (Union[bytes, str, dict, Any]) --
-
class
sanic.config.DescriptorMeta(name, bases, namespace, /, **kwargs)¶ 基类：
abc.ABCMeta配置的元类。
sanic.application.constants¶
-
enum
sanic.application.constants.Mode(value)¶ 基类：
sanic.application.constants.StrEnum服务器模式。
- 成员类型:
str
有效值如下所示：
-
PRODUCTION= <Mode.PRODUCTION: 'production'>¶
-
DEBUG= <Mode.DEBUG: 'debug'>¶
这个
Enum其成员也有以下方法：-
capitalize()¶ 返回字符串的大写版本。
更具体地说，使第一个字符大写，其余字符小写。
-
casefold()¶ 返回适合无大小写比较的字符串版本。
-
center(width, fillchar=' ', /)¶ 返回长度和宽度居中的字符串。
填充使用指定的填充字符(默认为空格)。
-
count(sub[, start[, end]]) → int¶ 返回子字符串子串SUB在字符串S中的非重叠出现次数 [start:end] 。可选参数START和END被解释为切片表示法。
-
encode(encoding='utf-8', errors='strict')¶ 使用注册进行编码的编解码器对字符串进行编码。
- 编码
对字符串进行编码的编码。
- 错误
用于编码错误的错误处理方案。缺省值为‘Strong’，表示编码错误会引发UnicodeEncodeError。其他可能的值是‘Ignore’、‘Replace’和‘xmlcharrefreplace’，以及可以处理UnicodeEncodeErrors的任何其他注册到编解码器的名称。
-
endswith(suffix[, start[, end]]) → bool¶ 如果S以指定的后缀结尾，则返回True，否则返回False。在可选启动的情况下，从该位置开始测试S。在可选结束的情况下，停止在那个位置比较S。后缀也可以是要尝试的字符串元组。
-
expandtabs(tabsize=8)¶ 返回一个副本，其中所有制表符都使用空格展开。
如果未给出制表符大小，则假定制表符大小为8个字符。
-
find(sub[, start[, end]]) → int¶ 返回子字符串SUB在S中的最低索引，这样SUB就包含在S中 [start:end] 。可选参数START和END被解释为切片表示法。
失败时返回-1。
-
format(*args, **kwargs) → str¶ 使用args和kwargs中的替换，返回S的格式化版本。替换用大括号(‘{’和‘}’)标识。
-
format_map(mapping) → str¶ 使用映射中的替换，返回S的格式化版本。替换用大括号(‘{’和‘}’)标识。
-
index(sub[, start[, end]]) → int¶ 返回子字符串SUB在S中的最低索引，这样SUB就包含在S中 [start:end] 。可选参数START和END被解释为切片表示法。
找不到子字符串时引发ValueError。
-
isalnum()¶ 如果字符串是字母数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是字母数字，并且字符串中至少有一个字符，则该字符串是字母数字的。
-
isalpha()¶ 如果字符串是字母字符串，则返回True，否则返回False。
如果字符串中的所有字符都是字母，并且字符串中至少有一个字符，则该字符串是字母顺序的。
-
isascii()¶ 如果字符串中的所有字符都是ASCII，则返回True，否则返回False。
ASCII字符的码位范围为U+0000-U+007F。空字符串也是ASCII。
-
isdecimal()¶ 如果字符串是十进制字符串，则返回True，否则返回False。
如果字符串中的所有字符都是小数，并且字符串中至少有一个字符，则该字符串是十进制字符串。
-
isdigit()¶ 如果字符串是数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是数字，并且字符串中至少有一个字符，则该字符串是数字字符串。
-
isidentifier()¶ 如果字符串是有效的Python标识符，则返回True，否则返回False。
调用Keyword.isKeyword(S)测试字符串S是否为保留标识，如def或class。
-
islower()¶ 如果字符串是小写字符串，则返回True，否则返回False。
如果字符串中的所有大小写字符都是小写，并且字符串中至少有一个大小写字符，则该字符串为小写。
-
isnumeric()¶ 如果字符串是数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是数字，并且字符串中至少有一个字符，则该字符串是数字的。
-
isprintable()¶ 如果字符串可打印，则返回True，否则返回False。
如果一个字符串的所有字符在epr()中都被认为是可打印的，或者它是空的，则该字符串是可打印的。
-
isspace()¶ 如果字符串是空白字符串，则返回True，否则返回False。
如果字符串中的所有字符都是空格并且字符串中至少有一个字符，则该字符串为空格。
-
istitle()¶ 如果字符串是按标题大小写的字符串，则返回True，否则返回False。
在标题大小写的字符串中，大写和标题大小写字符只能跟在非大小写字符之后，小写字符只能跟在大小写字符之后。
-
isupper()¶ 如果字符串是大写字符串，则返回True，否则返回False。
如果字符串中的所有大小写字符都是大写的，并且字符串中至少有一个大小写字符，则该字符串为大写。
-
join(iterable, /)¶ 连接任意数量的字符串。
其方法被调用的字符串被插入到每个给定字符串之间。结果以新字符串的形式返回。
示例：‘.’.Join( ['ab', 'pq', 'rs'] )->‘ab.pq.rs’
-
ljust(width, fillchar=' ', /)¶ 返回长宽左对齐的字符串。
填充使用指定的填充字符(默认为空格)。
-
lower()¶ 返回转换为小写的字符串的副本。
-
lstrip(chars=None, /)¶ 返回删除了前导空格的字符串的副本。
如果已提供字符，而不是无字符，则改为删除字符中的字符。
-
static
maketrans()¶ 返回可用于str.Translate()的转换表。
如果只有一个参数，则必须是将Unicode序号(整数)或字符映射到Unicode序号、字符串或无的字典。然后，字符键将被转换为序号。如果有两个参数，它们必须是长度相等的字符串，并且在生成的词典中，x中的每个字符都将映射到y中相同位置的字符。如果有第三个参数，则它必须是一个字符串，其字符在结果中将映射为None。
-
partition(sep, /)¶ 使用给定的分隔符将字符串划分为三个部分。
这将在字符串中搜索分隔符。如果找到分隔符，则返回包含分隔符之前的部分、分隔符本身和分隔符之后的部分的三元组。
如果找不到分隔符，则返回一个包含原始字符串和两个空字符串的三元组。
-
removeprefix(prefix, /)¶ 如果存在，则返回删除了给定前缀字符串的字符串。
如果字符串以前缀字符串开头，则返回字符串 [len(prefix):] 。否则，返回原始字符串的副本。
-
removesuffix(suffix, /)¶ 如果存在，则返回删除了给定后缀字符串的字符串。
如果字符串以后缀字符串结尾并且该后缀不为空，则返回字符串 [:-len(suffix)] 。否则，返回原始字符串的副本。
-
replace(old, new, count=- 1, /)¶ 返回一个副本，将所有出现的子字符串old替换为new。
- 计数
要替换的最大匹配数。(缺省值)表示替换所有匹配项。
如果给出了可选的参数count，则只替换出现的第一个计数。
-
rfind(sub[, start[, end]]) → int¶ 返回S中找到子串SUB的最高索引，这样SUB就包含在S内部 [start:end] 。可选参数START和END被解释为切片表示法。
失败时返回-1。
-
rindex(sub[, start[, end]]) → int¶ 返回S中找到子串SUB的最高索引，这样SUB就包含在S内部 [start:end] 。可选参数START和END被解释为切片表示法。
找不到子字符串时引发ValueError。
-
rjust(width, fillchar=' ', /)¶ 返回一个长宽右对齐的字符串。
填充使用指定的填充字符(默认为空格)。
-
rpartition(sep, /)¶ 使用给定的分隔符将字符串划分为三个部分。
这将搜索字符串中的分隔符，从末尾开始。如果找到分隔符，则返回包含分隔符之前的部分、分隔符本身和分隔符之后的部分的三元组。
如果找不到分隔符，则返回包含两个空字符串和原始字符串的三元组。
-
rsplit(sep=None, maxsplit=- 1)¶ 使用Sep作为分隔符字符串，返回字符串中的子字符串列表。
- 塞普
用于拆分字符串的分隔符。
When set to None (the default value), will split on any whitespace character (including \n \r \t \f and spaces) and will discard empty strings from the result.
- 最大拆分
最大拆分数(从左开始)。(缺省值)表示没有限制。
拆分从字符串的末尾开始，一直到前面。
-
rstrip(chars=None, /)¶ 返回删除了尾随空格的字符串的副本。
如果已提供字符，而不是无字符，则改为删除字符中的字符。
-
split(sep=None, maxsplit=- 1)¶ 使用Sep作为分隔符字符串，返回字符串中的子字符串列表。
- 塞普
用于拆分字符串的分隔符。
When set to None (the default value), will split on any whitespace character (including \n \r \t \f and spaces) and will discard empty strings from the result.
- 最大拆分
最大拆分数(从左开始)。(缺省值)表示没有限制。
注意，str.plit()主要用于故意分隔的数据。对于包含标点符号的自然文本，请考虑使用正则表达式模块。
-
splitlines(keepends=False)¶ 返回字符串中行的列表，在行边界处换行。
结果列表中不包括换行符，除非给定了Keep Ends且为True。
-
startswith(prefix[, start[, end]]) → bool¶ 如果S以指定的前缀开头，则返回True，否则返回False。在可选启动的情况下，从该位置开始测试S。在可选结束的情况下，停止在那个位置比较S。前缀也可以是要尝试的字符串元组。
-
strip(chars=None, /)¶ 返回删除了前导空格和尾随空格的字符串副本。
如果已提供字符，而不是无字符，则改为删除字符中的字符。
-
swapcase()¶ 将大写字符转换为小写，将小写字符转换为大写。
-
title()¶ 返回字符串的一个版本，其中每个单词都带有标题。
更具体地说，单词以大写字符开头，其余所有大小写字符均为小写。
-
translate(table, /)¶ 使用给定的转换表替换字符串中的每个字符。
- 表格
转换表，必须是Unicode序号到Unicode序号、字符串或无的映射。
表必须通过以下方式实现查找/索引 __getitem__, 例如词典或列表。如果此操作引发LookupError，则角色保持不变。映射到无的字符将被删除。
-
upper()¶ 返回转换为大写的字符串的副本。
-
zfill(width, /)¶ 在左侧用零填充数字字符串，以填充给定宽度的字段。
字符串永远不会被截断。
-
enum
sanic.application.constants.Server(value)¶ 基类：
sanic.application.constants.StrEnum服务器类型。
- 成员类型:
str
有效值如下所示：
-
SANIC= <Server.SANIC: 'sanic'>¶
-
ASGI= <Server.ASGI: 'asgi'>¶
这个
Enum其成员也有以下方法：-
capitalize()¶ 返回字符串的大写版本。
更具体地说，使第一个字符大写，其余字符小写。
-
casefold()¶ 返回适合无大小写比较的字符串版本。
-
center(width, fillchar=' ', /)¶ 返回长度和宽度居中的字符串。
填充使用指定的填充字符(默认为空格)。
-
count(sub[, start[, end]]) → int¶ 返回子字符串子串SUB在字符串S中的非重叠出现次数 [start:end] 。可选参数START和END被解释为切片表示法。
-
encode(encoding='utf-8', errors='strict')¶ 使用注册进行编码的编解码器对字符串进行编码。
- 编码
对字符串进行编码的编码。
- 错误
用于编码错误的错误处理方案。缺省值为‘Strong’，表示编码错误会引发UnicodeEncodeError。其他可能的值是‘Ignore’、‘Replace’和‘xmlcharrefreplace’，以及可以处理UnicodeEncodeErrors的任何其他注册到编解码器的名称。
-
endswith(suffix[, start[, end]]) → bool¶ 如果S以指定的后缀结尾，则返回True，否则返回False。在可选启动的情况下，从该位置开始测试S。在可选结束的情况下，停止在那个位置比较S。后缀也可以是要尝试的字符串元组。
-
expandtabs(tabsize=8)¶ 返回一个副本，其中所有制表符都使用空格展开。
如果未给出制表符大小，则假定制表符大小为8个字符。
-
find(sub[, start[, end]]) → int¶ 返回子字符串SUB在S中的最低索引，这样SUB就包含在S中 [start:end] 。可选参数START和END被解释为切片表示法。
失败时返回-1。
-
format(*args, **kwargs) → str¶ 使用args和kwargs中的替换，返回S的格式化版本。替换用大括号(‘{’和‘}’)标识。
-
format_map(mapping) → str¶ 使用映射中的替换，返回S的格式化版本。替换用大括号(‘{’和‘}’)标识。
-
index(sub[, start[, end]]) → int¶ 返回子字符串SUB在S中的最低索引，这样SUB就包含在S中 [start:end] 。可选参数START和END被解释为切片表示法。
找不到子字符串时引发ValueError。
-
isalnum()¶ 如果字符串是字母数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是字母数字，并且字符串中至少有一个字符，则该字符串是字母数字的。
-
isalpha()¶ 如果字符串是字母字符串，则返回True，否则返回False。
如果字符串中的所有字符都是字母，并且字符串中至少有一个字符，则该字符串是字母顺序的。
-
isascii()¶ 如果字符串中的所有字符都是ASCII，则返回True，否则返回False。
ASCII字符的码位范围为U+0000-U+007F。空字符串也是ASCII。
-
isdecimal()¶ 如果字符串是十进制字符串，则返回True，否则返回False。
如果字符串中的所有字符都是小数，并且字符串中至少有一个字符，则该字符串是十进制字符串。
-
isdigit()¶ 如果字符串是数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是数字，并且字符串中至少有一个字符，则该字符串是数字字符串。
-
isidentifier()¶ 如果字符串是有效的Python标识符，则返回True，否则返回False。
调用Keyword.isKeyword(S)测试字符串S是否为保留标识，如def或class。
-
islower()¶ 如果字符串是小写字符串，则返回True，否则返回False。
如果字符串中的所有大小写字符都是小写，并且字符串中至少有一个大小写字符，则该字符串为小写。
-
isnumeric()¶ 如果字符串是数字字符串，则返回True，否则返回False。
如果字符串中的所有字符都是数字，并且字符串中至少有一个字符，则该字符串是数字的。
-
isprintable()¶ 如果字符串可打印，则返回True，否则返回False。
如果一个字符串的所有字符在epr()中都被认为是可打印的，或者它是空的，则该字符串是可打印的。
-
isspace()¶ 如果字符串是空白字符串，则返回True，否则返回False。
如果字符串中的所有字符都是空格并且字符串中至少有一个字符，则该字符串为空格。
-
istitle()¶ 如果字符串是按标题大小写的字符串，则返回True，否则返回False。
在标题大小写的字符串中，大写和标题大小写字符只能跟在非大小写字符之后，小写字符只能跟在大小写字符之后。
-
isupper()¶ 如果字符串是大写字符串，则返回True，否则返回False。
如果字符串中的所有大小写字符都是大写的，并且字符串中至少有一个大小写字符，则该字符串为大写。
-
join(iterable, /)¶ 连接任意数量的字符串。
其方法被调用的字符串被插入到每个给定字符串之间。结果以新字符串的形式返回。
示例：‘.’.Join( ['ab', 'pq', 'rs'] )->‘ab.pq.rs’
-
ljust(width, fillchar=' ', /)¶ 返回长宽左对齐的字符串。
填充使用指定的填充字符(默认为空格)。
-
lower()¶ 返回转换为小写的字符串的副本。
-
lstrip(chars=None, /)¶ 返回删除了前导空格的字符串的副本。
如果已提供字符，而不是无字符，则改为删除字符中的字符。
-
static
maketrans()¶ 返回可用于str.Translate()的转换表。
如果只有一个参数，则必须是将Unicode序号(整数)或字符映射到Unicode序号、字符串或无的字典。然后，字符键将被转换为序号。如果有两个参数，它们必须是长度相等的字符串，并且在生成的词典中，x中的每个字符都将映射到y中相同位置的字符。如果有第三个参数，则它必须是一个字符串，其字符在结果中将映射为None。
-
partition(sep, /)¶ 使用给定的分隔符将字符串划分为三个部分。
这将在字符串中搜索分隔符。如果找到分隔符，则返回包含分隔符之前的部分、分隔符本身和分隔符之后的部分的三元组。
如果找不到分隔符，则返回一个包含原始字符串和两个空字符串的三元组。
-
removeprefix(prefix, /)¶ 如果存在，则返回删除了给定前缀字符串的字符串。
如果字符串以前缀字符串开头，则返回字符串 [len(prefix):] 。否则，返回原始字符串的副本。
-
removesuffix(suffix, /)¶ 如果存在，则返回删除了给定后缀字符串的字符串。
如果字符串以后缀字符串结尾并且该后缀不为空，则返回字符串 [:-len(suffix)] 。否则，返回原始字符串的副本。
-
replace(old, new, count=- 1, /)¶ 返回一个副本，将所有出现的子字符串old替换为new。
- 计数
要替换的最大匹配数。(缺省值)表示替换所有匹配项。
如果给出了可选的参数count，则只替换出现的第一个计数。
-
rfind(sub[, start[, end]]) → int¶ 返回S中找到子串SUB的最高索引，这样SUB就包含在S内部 [start:end] 。可选参数START和END被解释为切片表示法。
失败时返回-1。
-
rindex(sub[, start[, end]]) → int¶ 返回S中找到子串SUB的最高索引，这样SUB就包含在S内部 [start:end] 。可选参数START和END被解释为切片表示法。
找不到子字符串时引发ValueError。
-
rjust(width, fillchar=' ', /)¶ 返回一个长宽右对齐的字符串。
填充使用指定的填充字符(默认为空格)。
-
rpartition(sep, /)¶ 使用给定的分隔符将字符串划分为三个部分。
这将搜索字符串中的分隔符，从末尾开始。如果找到分隔符，则返回包含分隔符之前的部分、分隔符本身和分隔符之后的部分的三元组。
如果找不到分隔符，则返回包含两个空字符串和原始字符串的三元组。
-
rsplit(sep=None, maxsplit=- 1)¶ 使用Sep作为分隔符字符串，返回字符串中的子字符串列表。
- 塞普
用于拆分字符串的分隔符。
When set to None (the default value), will split on any whitespace character (including \n \r \t \f and spaces) and will discard empty strings from the result.
- 最大拆分
最大拆分数(从左开始)。(缺省值)表示没有限制。
拆分从字符串的末尾开始，一直到前面。
-
rstrip(chars=None, /)¶ 返回删除了尾随空格的字符串的副本。
如果已提供字符，而不是无字符，则改为删除字符中的字符。
-
split(sep=None, maxsplit=- 1)¶ 使用Sep作为分隔符字符串，返回字符串中的子字符串列表。
- 塞普
用于拆分字符串的分隔符。
When set to None (the default value), will split on any whitespace character (including \n \r \t \f and spaces) and will discard empty strings from the result.
- 最大拆分
最大拆分数(从左开始)。(缺省值)表示没有限制。
注意，str.plit()主要用于故意分隔的数据。对于包含标点符号的自然文本，请考虑使用正则表达式模块。
-
splitlines(keepends=False)¶ 返回字符串中行的列表，在行边界处换行。
结果列表中不包括换行符，除非给定了Keep Ends且为True。
-
startswith(prefix[, start[, end]]) → bool¶ 如果S以指定的前缀开头，则返回True，否则返回False。在可选启动的情况下，从该位置开始测试S。在可选结束的情况下，停止在那个位置比较S。前缀也可以是要尝试的字符串元组。
-
strip(chars=None, /)¶ 返回删除了前导空格和尾随空格的字符串副本。
如果已提供字符，而不是无字符，则改为删除字符中的字符。
-
swapcase()¶ 将大写字符转换为小写，将小写字符转换为大写。
-
title()¶ 返回字符串的一个版本，其中每个单词都带有标题。
更具体地说，单词以大写字符开头，其余所有大小写字符均为小写。
-
translate(table, /)¶ 使用给定的转换表替换字符串中的每个字符。
- 表格
转换表，必须是Unicode序号到Unicode序号、字符串或无的映射。
表必须通过以下方式实现查找/索引 __getitem__, 例如词典或列表。如果此操作引发LookupError，则角色保持不变。映射到无的字符将被删除。
-
upper()¶ 返回转换为大写的字符串的副本。
-
zfill(width, /)¶ 在左侧用零填充数字字符串，以填充给定宽度的字段。
字符串永远不会被截断。
-
enum
sanic.application.constants.ServerStage(value)¶ 基类：
enum.IntEnum服务器阶段。
- 成员类型:
int
有效值如下所示：
-
STOPPED= <ServerStage.STOPPED: 1>¶
-
PARTIAL= <ServerStage.PARTIAL: 2>¶
-
SERVING= <ServerStage.SERVING: 3>¶
这个
Enum其成员也有以下方法：-
as_integer_ratio()¶ 返回整数比率。
返回一对整数，其比率恰好等于原始int且分母为正。
>>> (10).as_integer_ratio() (10, 1) >>> (-10).as_integer_ratio() (-10, 1) >>> (0).as_integer_ratio() (0, 1)
-
bit_count()¶ 自我绝对值的二进制表示中的1的个数。
也被称为人口统计。
>>> bin(13) '0b1101' >>> (13).bit_count() 3
-
bit_length()¶ 以二进制表示自身所需的位数。
>>> bin(37) '0b100101' >>> (37).bit_length() 6
-
conjugate()¶ 返回self，它是任何int的复数共轭。
-
from_bytes(byteorder='big', *, signed=False)¶ 返回由给定字节数组表示的整数。
- 字节数
保存要转换的字节数组。该参数必须支持缓冲区协议，或者是产生字节的可迭代对象。字节和字节数组是支持缓冲区协议的内置对象的示例。
- 字节顺序
用于表示整数的字节顺序。如果byteorder为‘BIG’，则最高有效字节位于字节数组的开头。如果byteorder为‘Little’，则最高有效字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用`sys.byteorder‘作为字节顺序值。默认情况下，使用“BIG”。
- 签名
指示是否使用二的补码来表示整数。
-
to_bytes(length=1, byteorder='big', *, signed=False)¶ 返回表示整数的字节数组。
- 长度
要使用的字节长度对象。如果整数不能用给定的字节数表示，则会引发Overflow Error。默认长度为1。
- 字节顺序
用于表示整数的字节顺序。如果byteorder为‘BIG’，则最高有效字节位于字节数组的开头。如果byteorder为‘Little’，则最高有效字节位于字节数组的末尾。要请求主机系统的本机字节顺序，请使用`sys.byteorder‘作为字节顺序值。默认情况下，使用“BIG”。
- 签名
确定是否使用二的补码来表示整数。如果符号为FALSE并且给出了一个负整数，则会引发Overflow Error。
-
denominator¶ 最小项中有理数的分母
-
imag¶ 复数的虚部
-
numerator¶ 最小项中有理数的分子
-
real¶ 复数的实部
sanic.application.state¶
-
class
sanic.application.state.ApplicationServerInfo(settings, stage=<ServerStage.STOPPED: 1>, server=None)¶ 基类：
object有关服务器实例的信息。
-
class
sanic.application.state.ApplicationState(app, asgi=False, coffee=False, fast=False, host='', port=0, ssl=None, sock=None, unix=None, mode=<Mode.PRODUCTION: 'production'>, reload_dirs=<factory>, auto_reload=False, server=<Server.SANIC: 'sanic'>, is_running=False, is_started=False, is_stopping=False, verbosity=0, workers=0, primary=True, server_info=<factory>, _init=False)¶ 基类：
object应用程序状态。
此类用于存储应用程序的状态。它由应用程序实例化，并可作为 app.state 。
-
set_verbosity(value)¶ 设置详细级别。
- 参数：
值(Int)：详细级别。
- 参数:
value (int) --
- 返回类型:
None
-
property
is_debug¶ 检查应用程序是否处于调试模式。
- 返回：
- 布尔： True 如果应用程序处于调试模式， False
否则的话。
-
property
stage¶ 获得服务器阶段。
- 返回：
ServerStage：服务器阶段。
-
-
-