蓝图¶

sanic.blueprints¶

class sanic.blueprints.Blueprint(name, url_prefix=None, host=None, version=None, strict_slashes=None, version_prefix='/v')¶

基类：sanic.base.root.BaseSanic

由相似逻辑域组成的URL的逻辑集合。

Blueprint对象是对功能和类似端点进行分组的主要工具。它允许开发人员将路由、异常处理程序、中间件和其他Web功能组织到单独的模块化组中。

看见 [Blueprints] (/en/指南/最佳实践/蓝图)了解更多信息。

参数：: 名称(Str)：蓝图的名称。Url_prefix(可选 [str] )：本蓝图中定义的所有路线的URL前缀。主机(可选 [Union[List[str] ，str]])：此蓝图应响应的主机或主机列表。版本(可选 [Union[int, str, float] ])：本蓝图实现的接口版本号。严格斜杠(可选 [bool] )：URL是否应以斜杠结尾。Version_Prefix(Str)：版本的前缀。默认为“/v”。

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_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]

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]]]

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

copy(name, url_prefix=<Default>, version=<Default>, version_prefix=<Default>, allow_route_overwrite=<Default>, strict_slashes=<Default>, with_registration=True, with_ctx=False)¶

复制一个带有一些可选参数的BluePrint实例，以覆盖旧实例中的属性值。

参数：: 名称(Str)：蓝图的唯一名称。Url_prefix(可选 [Union[str, Default] ])：在所有路由URL之前添加前缀的URL。版本(可选 [Union[int, str, float, Default] ])：蓝图版本。Version_Prefix(联合 [str, Default] )：URL中显示的版本号前缀。ALLOW_ROUTE_OVERWRITE(联合 [bool, Default] )：是否允许覆盖路由。严格斜杠(可选 [Union[bool, Default] ])：强制接口地址以“/*”结尾。WITH_REGISTION(Bool)：是否向旧实例注册的Sanic应用程序注册新的BluePrint实例。缺省值为 True 。With_ctx(Bool)：是否 ctx 是否会被复制。缺省值为 False 。
返回：: Blueprint：具有指定属性的新Blueprint实例。

参数:

name (str) --
url_prefix (Optional[Union[str, sanic.helpers.Default]]) --
version (Optional[Union[int, str, float, sanic.helpers.Default]]) --
version_prefix (Union[str, sanic.helpers.Default]) --
allow_route_overwrite (Union[bool, sanic.helpers.Default]) --
strict_slashes (Optional[Union[bool, sanic.helpers.Default]]) --
with_registration (bool) --
with_ctx (bool) --

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]]]

async dispatch(*args, **kwargs)¶

调度信号事件

参数：: *args: Arguments to be passed to the signal event. * *kwargs：要传递给信号事件的关键字参数。

event(event, timeout=None)¶

等待调度信号事件。

参数：: Event(Str)：信号事件的名称。超时(可选 [Union[int, float] ])：事件超时

出动了。
返回：: 可等待：可等待要调度的事件。

参数:

event (str) --
timeout (Optional[Union[int, float]]) --

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

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 group(*blueprints, url_prefix=None, version=None, strict_slashes=None, version_prefix='/v', name_prefix='')¶

将多个蓝图(或其他蓝图组)组合在一起。

分组蓝图是一种模块化和组织应用程序代码的方法。对于创建可重用组件、逻辑构建应用程序代码以及轻松批量维护路由定义而言，这是一个强大的工具。

这是将多个蓝图组合在一起的首选方式。

参数：

《蓝图(联盟)》 [Blueprint, BlueprintGroup] )：蓝图待定: 注册为一个团体。
Url_prefix(可选 [str] )：将URL路由添加到所有: 子前缀。缺省值为 None 。
版本(可选 [Union[int, str, float] ])：API版本待定: 用于Blueprint组。缺省值为 None 。
严格斜杠(可选 [bool] )：表示严格的斜杠: URL的终止行为。缺省值为 None 。
Version_Prefix(Str)：要用于: URL。默认为“/v”。
名称_前缀(可选 [str] )：要用于名称的前缀: 小组中的蓝图。默认为空字符串。

返回：

Blueprint组：一组蓝图。

示例：

生成的组将具有URL前缀 '/v2/bp1' 和 '/v2/bp2' 分别用于bp1和bp2。 ``python bp1 = Blueprint('bp1', url_prefix='/bp1') bp2 = Blueprint('bp2', url_prefix='/bp2') group = group(bp1, bp2, version=2) ` `

参数:

blueprints (Union[sanic.blueprints.Blueprint, sanic.blueprints.BlueprintGroup]) --
url_prefix (Optional[str, None]) --
version (Optional[Union[int, float, str]]) --
strict_slashes (Optional[bool, None]) --
version_prefix (str) --
name_prefix (Optional[str, None]) --

返回类型:

sanic.blueprints.BlueprintGroup

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)：

..。

```

参数:

listener_or_event (Union[Callable[[Sanic], Optional[Coroutine[Any, Any, None], None]], Callable[[Sanic, asyncio.events.AbstractEventLoop], Optional[Coroutine[Any, Any, None], None]], str]) --
event_or_none (Optional[str, None]) --
apply (bool) --

返回类型:

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]]]

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]]]]]]]

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]]]

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]]]

register(app, options)¶

将蓝图注册到sanic应用程序。

参数：: 应用程序(Sanic)：要将蓝图注册到的Sanic应用程序。选项(DICT)：要传递给蓝图的选项。

static register_futures(apps, bp, futures)¶

在应用程序中注册期货。

参数：: 应用程序(设置 [Sanic] )：要将期货注册到的应用程序集。BP(蓝图)：未来属于的蓝图。期货(序列 [Tuple[Any, ...] ])：期货顺序为

登记在案。

参数:

apps (Set[Sanic]) --
bp (Blueprint) --
futures (Sequence[Tuple[Any, ..]]) --

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]]]

reset()¶

将蓝图重置为其初始状态。

返回类型:: 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]]]]]]

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) -- 对于延迟计算，默认为 True
condition (Dict[str, Any], optional) -- 用于与 condition 调度筛选中的参数，默认为 None
exclusive (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]]]

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]) --

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 apps¶

获取此蓝图注册到的应用集。

返回：

集 [Sanic] ：此蓝图注册到的应用程序集。

产生：

如果蓝图尚未注册到: 一款应用程序。

property registered¶

检查蓝图是否已注册到应用程序。

返回：

布尔： True 如果蓝图已注册到应用程序，: False 否则的话。

class sanic.blueprints.BlueprintGroup(url_prefix=None, version=None, strict_slashes=None, version_prefix='/v', name_prefix='')¶

基类：collections.abc.MutableSequence[sanic.blueprints.Blueprint]

此类提供了实现Blueprint Group的机制。

这个 BlueprintGroup 类允许在公共URL前缀、版本和其他共享属性下对蓝图进行分组。它与Sanic的Blueprint系统集成，提供了一个定制迭代器来将此类的对象视为列表/元组。

虽然可以直接实例化一个组，但建议使用 Blueprint.group 方法来创建一组蓝图。

参数：

Url_prefix(可选 [str] )：要在所有: 蓝图前缀。缺省值为 None 。
版本(可选 [Union[int, str, float] ])：API版本: Blueprint组，由每个Blueprint继承。缺省值为 None 。
严格斜杠(可选 [bool] )：URL严格斜杠行为: 指示器。缺省值为 None 。
Version_Prefix(Str)：URL中版本的前缀。: 缺省值为 "/v" 。
名称_前缀(可选 [str] )：蓝图名称的前缀: 在这群人中。默认为空字符串。

例如：

``` Python bp1=Blueprint(“bp1”，url_prefix=“/bp1”)bp2=Blueprint(“bp2”，url_prefix=“/bp2”)

Bp3=Blueprint(“bp3”，url_prefix=“/bp4”)bp4=Blueprint(“bp3”，url_prefix=“/bp4”)

Group1=Blueprint t.group(bp1，bp2)group2=Blueprint t.group(bp3，bp4，Version_Prefix=“/api/v”，Version=“1”)

@bp1.on_REQUEST异步定义bp1_ONLY_MIDDLEWARE(请求)：

Print(“仅适用于蓝图：BP1”)

@bp1.route(“/”)async def bp1_route(请求)：

返回文本(“bp1”)

@bp2.route(“/<param>”)async def bp2_ROUTE(请求，参数)：

返回文本(参数)

@bp3.route(“/”)async def bp3_route(请求)：

返回文本(“BP3”)

@bp4.route(“/<param>”)async def bp4_ROUTE(请求，参数)：

返回文本(参数)

@group1.on_REQUEST异步定义GROUP_MIDDLEWARE(REQUEST)：

Print(“适用于bp1和bp2的通用中间件”)

#在app app.Blueprint(Group1)app.Blueprint(Group2)下注册Blueprint群组 ```

append(value)¶

将新的Blueprint对象添加到组中。

抽象类 MutableSequence 利用此Append方法执行 BlueprintGroup.append 手术。

参数：: 价值(蓝图)：新 Blueprint 对象。
返回：: 没有

参数:: value (sanic.blueprints.Blueprint) --
返回类型:: None

clear() → None -- remove all items from S¶

count(value) → integer -- return number of occurrences of value¶

exception(*exceptions, **kwargs)¶

修饰一个函数以处理组中所有蓝图的异常。

对于嵌套的Blueprint组，相同的处理程序递归地应用于每个蓝图。

参数：

*exceptions (Exception): Exceptions to handle * *kwargs(Dict)：用于中间件的可选关键字arg

返回：

应用中间件的部分功能

例如：

``` Python bp1=Blueprint(“bp1”，url_prefix=“/bp1”)bp2=Blueprint(“bp2”，url_prefix=“/bp2”)group1=Blueprint t.group(bp1，bp2)

@group1.ception(异常)def处理程序(请求，异常)：

返回文本(“捕获到异常”)

```

参数:: exceptions (Exception) --
返回类型:: Callable

extend(values)¶: 扩展(Iterable)--通过附加可迭代元素来扩展序列

index(value[, start[, stop]]) → integer -- return first index of value.¶

如果值不存在，则引发ValueError。

支持启动和停止参数是可选的，但建议这样做。

insert(index, item)¶

将新的Blueprint对象插入到组的指定索引处。

抽象类 MutableSequence 利用此插入方法执行 BlueprintGroup.append 操作。

参数：: Index(Int)：用于删除新的Blueprint项的索引(Blueprint)：New Blueprint 对象。
返回：: 没有

参数:

index (int) --
item (sanic.blueprints.Blueprint) --

返回类型:

None

middleware(*args, **kwargs)¶

可用于实现组中所有蓝图的中间件的装饰器。

对于嵌套的蓝图组，相同的中间件递归地应用于每个蓝图。

参数：: *args (Optional): Optional positional Parameters to be use middleware * *kwargs(可选)：用于中间件的可选关键字arg
返回：: 应用中间件的部分功能

on_request(middleware=None)¶

为组中的所有蓝图注册请求中间件的便捷方法。

参数：: 中间件(可选)：使用中间件的可选位置参数
返回：: 应用中间件的部分功能

on_response(middleware=None)¶

为组中的所有蓝图注册响应中间件的便捷方法。

参数：: 中间件(可选)：使用中间件的可选位置参数
返回：: 应用中间件的部分功能

pop([index]) → item -- remove and return item at index (default last).¶: 如果列表为空或索引超出范围，则引发IndexError。

remove(value)¶: S.Remove(值)--删除值的第一个匹配项。如果值不存在，则引发ValueError。

reverse()¶: S.Reverse()--Reverse IN PLACE

property blueprints¶

此组下所有可用设计图的列表。

返回：

明细表 [Blueprint] ：下列所有可用的设计图的列表: 这群人。

property name_prefix¶

Blueprint Group的名称前缀。

这主要是在复制蓝图以避免名称冲突时需要的。

返回：: 任选 [str] ：Blueprint Group的名称前缀。

property strict_slashes¶

是否对Blueprint Group实施严格的斜杠。

返回：: 任选 [bool] ：是否对

property url_prefix¶

Blueprint Group的URL前缀。

返回：

任选 [Union[int, str, float] ]：蓝图的URL前缀: 组。

property version¶

Blueprint Group的API版本(如果有)。

返回：: 任选 [Union[str, int, float] ]：蓝图的API版本

property version_prefix¶

Blueprint Group的版本前缀。

返回：: Str：Blueprint Group的版本前缀。

sanic.blueprints.lazy(func, as_decorator=True)¶

用来注册稍后要调用的函数的修饰符。

参数：: 函数(可调用)：稍后调用的函数。As_decorator(Bool)：是否应该调用该函数

不管是不是马上。

sanic.blueprint_group¶

class sanic.blueprint_group.BlueprintGroup(url_prefix=None, version=None, strict_slashes=None, version_prefix='/v', name_prefix='')¶

此类提供了实现Blueprint Group的机制。

这个 BlueprintGroup 类允许在公共URL前缀、版本和其他共享属性下对蓝图进行分组。它与Sanic的Blueprint系统集成，提供了一个定制迭代器来将此类的对象视为列表/元组。

虽然可以直接实例化一个组，但建议使用 Blueprint.group 方法来创建一组蓝图。

参数：

Url_prefix(可选 [str] )：要在所有: 蓝图前缀。缺省值为 None 。
版本(可选 [Union[int, str, float] ])：API版本: Blueprint组，由每个Blueprint继承。缺省值为 None 。
严格斜杠(可选 [bool] )：URL严格斜杠行为: 指示器。缺省值为 None 。
Version_Prefix(Str)：URL中版本的前缀。: 缺省值为 "/v" 。
名称_前缀(可选 [str] )：蓝图名称的前缀: 在这群人中。默认为空字符串。

例如：

``` Python bp1=Blueprint(“bp1”，url_prefix=“/bp1”)bp2=Blueprint(“bp2”，url_prefix=“/bp2”)

Bp3=Blueprint(“bp3”，url_prefix=“/bp4”)bp4=Blueprint(“bp3”，url_prefix=“/bp4”)

Group1=Blueprint t.group(bp1，bp2)group2=Blueprint t.group(bp3，bp4，Version_Prefix=“/api/v”，Version=“1”)

@bp1.on_REQUEST异步定义bp1_ONLY_MIDDLEWARE(请求)：

Print(“仅适用于蓝图：BP1”)

@bp1.route(“/”)async def bp1_route(请求)：

返回文本(“bp1”)

@bp2.route(“/<param>”)async def bp2_ROUTE(请求，参数)：

返回文本(参数)

@bp3.route(“/”)async def bp3_route(请求)：

返回文本(“BP3”)

@bp4.route(“/<param>”)async def bp4_ROUTE(请求，参数)：

返回文本(参数)

@group1.on_REQUEST异步定义GROUP_MIDDLEWARE(REQUEST)：

Print(“适用于bp1和bp2的通用中间件”)

#在app app.Blueprint(Group1)app.Blueprint(Group2)下注册Blueprint群组 ```

__delitem__(index)¶

删除指定索引处的Blueprint对象。

实现的抽象方法将 BlueprintGroup 类添加到类似列表的对象中，以支持所有现有行为。

此方法用于从蓝图组列表中删除项目，就像它可以在带有索引的常规列表上执行一样。

参数：: Index(Int)：用于删除新Blueprint项的索引
返回：: 没有
产生：: IndexError：如果索引超出范围。

参数:: index (Union[int, slice]) --
返回类型:: None

__getitem__(item)¶

获取指定索引处的Blueprint对象。

此方法返回由索引值指定的组内的蓝图。这将允许对蓝图组进行索引、拼接和切片，就像我们可以对常规列表/元组所做的那样。

提供此方法是为了确保向后兼容任何可能中断的预先存在的用法。

返回：: BluePrint：指定索引处的BluePrint对象。
产生：: IndexError：如果索引超出范围。

参数:: item (Union[int, slice]) --
返回类型:: Union[sanic.blueprints.Blueprint, collections.abc.MutableSequence[sanic.blueprints.Blueprint]]

__init__(url_prefix=None, version=None, strict_slashes=None, version_prefix='/v', name_prefix='')¶

初始化Self。有关准确的签名，请参阅帮助(键入(Self))。

参数:

url_prefix (Optional[str, None]) --
version (Optional[Union[int, float, str]]) --
strict_slashes (Optional[bool, None]) --
version_prefix (str) --
name_prefix (Optional[str, None]) --

__iter__()¶

遍历组中的设计图列表。

返回：: 迭代器 [Blueprint] ：中设计图列表的迭代器

返回类型:: Iterator[sanic.blueprints.Blueprint]

__len__()¶

获取蓝图组对象的长度。

返回：: Int：蓝图组对象的长度。

返回类型:: int

__setitem__(index, item)¶

在指定索引处设置Blueprint对象。

实现的抽象方法将 BlueprintGroup 类添加到类似列表的对象中，以支持所有现有行为。

此方法用于执行列表的索引设置器操作。

参数：: Index(Int)：用于删除新的Blueprint项的索引(Blueprint)：New Blueprint 对象。
返回：: 没有
产生：: IndexError：如果索引超出范围。

参数:

index (Union[int, slice]) --
item (Union[sanic.blueprints.Blueprint, Iterable[sanic.blueprints.Blueprint]]) --

返回类型:

None

append(value)¶

将新的Blueprint对象添加到组中。

抽象类 MutableSequence 利用此Append方法执行 BlueprintGroup.append 手术。

参数：: 价值(蓝图)：新 Blueprint 对象。
返回：: 没有

参数:: value (sanic.blueprints.Blueprint) --
返回类型:: None

exception(*exceptions, **kwargs)¶

修饰一个函数以处理组中所有蓝图的异常。

对于嵌套的Blueprint组，相同的处理程序递归地应用于每个蓝图。

参数：

*exceptions (Exception): Exceptions to handle * *kwargs(Dict)：用于中间件的可选关键字arg

返回：

应用中间件的部分功能

例如：

``` Python bp1=Blueprint(“bp1”，url_prefix=“/bp1”)bp2=Blueprint(“bp2”，url_prefix=“/bp2”)group1=Blueprint t.group(bp1，bp2)

@group1.ception(异常)def处理程序(请求，异常)：

返回文本(“捕获到异常”)

```

参数:: exceptions (Exception) --
返回类型:: Callable

insert(index, item)¶

将新的Blueprint对象插入到组的指定索引处。

抽象类 MutableSequence 利用此插入方法执行 BlueprintGroup.append 操作。

参数：: Index(Int)：用于删除新的Blueprint项的索引(Blueprint)：New Blueprint 对象。
返回：: 没有

参数:

index (int) --
item (sanic.blueprints.Blueprint) --

返回类型:

None

middleware(*args, **kwargs)¶

可用于实现组中所有蓝图的中间件的装饰器。

对于嵌套的蓝图组，相同的中间件递归地应用于每个蓝图。

参数：: *args (Optional): Optional positional Parameters to be use middleware * *kwargs(可选)：用于中间件的可选关键字arg
返回：: 应用中间件的部分功能

on_request(middleware=None)¶

为组中的所有蓝图注册请求中间件的便捷方法。

参数：: 中间件(可选)：使用中间件的可选位置参数
返回：: 应用中间件的部分功能

on_response(middleware=None)¶

为组中的所有蓝图注册响应中间件的便捷方法。

参数：: 中间件(可选)：使用中间件的可选位置参数
返回：: 应用中间件的部分功能

property blueprints¶

此组下所有可用设计图的列表。

返回：

明细表 [Blueprint] ：下列所有可用的设计图的列表: 这群人。

property name_prefix¶

Blueprint Group的名称前缀。

这主要是在复制蓝图以避免名称冲突时需要的。

返回：: 任选 [str] ：Blueprint Group的名称前缀。

property strict_slashes¶

是否对Blueprint Group实施严格的斜杠。

返回：: 任选 [bool] ：是否对

property url_prefix¶

Blueprint Group的URL前缀。

返回：

任选 [Union[int, str, float] ]：蓝图的URL前缀: 组。

property version¶

Blueprint Group的API版本(如果有)。

返回：: 任选 [Union[str, int, float] ]：蓝图的API版本

property version_prefix¶

Blueprint Group的版本前缀。

返回：: Str：Blueprint Group的版本前缀。