WSGI (Web Server Gateway Interface)

HTTPConnection

class baize.wsgi.HTTPConnection(environ: MutableMapping[str, Any], start_response: Optional[StartResponse] = None)

A base class for incoming HTTP connections.

It is a valid Mapping type that allows you to directly access the values in any WSGI environ dictionary.

property client: Address

Client’s IP and Port.

Note that this depends on the REMOTE_ADDR and REMOTE_PORT values given by the WSGI Server, and is not necessarily accurate.

property url: URL

The full URL of this request.

property path_params: Dict[str, Any]

The path parameters parsed by the framework.

property query_params: QueryParams

Query parameter. It is a multi-value mapping.

property headers: Headers

A read-only case-independent mapping.

Note that in its internal storage, all keys are in lower case.

property accepted_types: List[MediaType]

Request’s accepted types

accepts(media_type: str) bool

e.g. request.accepts("application/json")

property content_length: Optional[int]

Request’s content-length

property content_type: ContentType

Request’s content-type

property cookies: Dict[str, str]

Returns cookies in as a dict.

NOTE: Modifications to this dictionary will not affect the response value. In fact, this value should not be modified.

property date: Optional[datetime]

The sending time of the request.

NOTE: The datetime object is timezone-aware.

get(k[, d]) D[k] if k in D, else d.  d defaults to None.
items() a set-like object providing a view on D's items
keys() a set-like object providing a view on D's keys
property referrer: Optional[URL]

The Referer HTTP request header contains an absolute or partial address of the page making the request.

values() an object providing a view on D's values

Request

class baize.wsgi.Request(environ: MutableMapping[str, Any], start_response: Optional[StartResponse] = None)
property method: str

HTTP method. Uppercase string.

stream(chunk_size: int = 65536) Iterator[bytes]

Streaming read request body. e.g. for chunk in request.stream(): ...

If you access .stream() then the byte chunks are provided without storing the entire body to memory. Any subsequent calls to .body, .form, or .json will raise an error.

property body: bytes

Read all the contents of the request body into the memory and return it.

property json: Any

Call self.body and use json.loads parse it.

If content_type is not equal to application/json, an HTTPExcption exception will be thrown.

property form: FormData

Parse the data in the form format and return it as a multi-value mapping.

If content_type is equal to multipart/form-data, it will directly perform streaming analysis, and subsequent calls to self.body or self.json will raise errors.

If content_type is not equal to multipart/form-data or application/x-www-form-urlencoded, an HTTPExcption exception will be thrown.

close() None

Close all temporary files in the self.form.

This can always be called, regardless of whether you use form or not.

Response

class baize.wsgi.Response(status_code: int = 200, headers: Optional[Mapping[str, str]] = None)

The parent class of all responses, whose objects can be used directly as WSGI application.

SmallResponse

class baize.wsgi.SmallResponse(content: _ContentType, status_code: int = 200, headers: Optional[Mapping[str, str]] = None, media_type: Optional[str] = None, charset: Optional[str] = None)

Bases: Response, ABC, Generic[_ContentType]

Abstract base class for small response objects.

PlainTextResponse

class baize.wsgi.PlainTextResponse(content: _ContentType, status_code: int = 200, headers: Optional[Mapping[str, str]] = None, media_type: Optional[str] = None, charset: Optional[str] = None)

Bases: SmallResponse[Union[bytes, str]]

HTMLResponse

class baize.wsgi.HTMLResponse(content: _ContentType, status_code: int = 200, headers: Optional[Mapping[str, str]] = None, media_type: Optional[str] = None, charset: Optional[str] = None)

Bases: PlainTextResponse

JSONResponse

class baize.wsgi.JSONResponse(content: Any, status_code: int = 200, headers: Optional[Mapping[str, str]] = None, **kwargs: Any)

Bases: SmallResponse[Any]

**kwargs is used to accept all the parameters that json.loads can accept.

RedirectResponse

class baize.wsgi.RedirectResponse(url: Union[str, URL], status_code: int = 307, headers: Optional[Mapping[str, str]] = None)

Bases: Response

StreamResponse

class baize.wsgi.StreamResponse(iterable: Iterable[bytes], status_code: int = 200, headers: Optional[Mapping[str, str]] = None, content_type: str = 'application/octet-stream')

Bases: Response

FileResponse

class baize.wsgi.FileResponse(filepath: str, headers: Optional[Mapping[str, str]] = None, content_type: Optional[str] = None, download_name: Optional[str] = None, stat_result: Optional[stat_result] = None, chunk_size: int = 262144)

Bases: Response, FileResponseMixin

File response.

It will automatically determine whether to send only headers and the range of files that need to be sent.

SendEventResponse

class baize.wsgi.SendEventResponse(generator: Generator[ServerSentEvent, None, None], status_code: int = 200, headers: Optional[Mapping[str, str]] = None, *, ping_interval: float = 3, charset: str = 'utf-8')

Bases: Response

Server-sent events response.

When the cilent closes the connection, the generator will be closed. Use try-finally to clean up resources.

def generator():
    try:
        while True:
            yield ServerSentEvent()
    finally:
        print("generator closed")

response = SendEventResponse(generator())

Router

class baize.wsgi.Router(*routes: Tuple[str, Interface])

A router to assign different paths to different WSGI applications.

applications = Router(
    ("/static/{filepath:any}", static_files),
    ("/api/{_:any}", api_app),
    ("/about/{name}", about_page),
    ("/", homepage),
)

Use {} to mark path parameters, the format is {name[:type]}. If type is not explicitly specified, it defaults to str.

The built-in types are str, int, decimal, uuid, date, any. Among them, str can match all strings except /, and any can match all strings.

If the built-in types are not enough, then you only need to write a class that inherits baize.routing.Convertor and register it in baize.routing.CONVERTOR_TYPES.

Subpaths

class baize.wsgi.Subpaths(*routes: Tuple[str, Interface])

A router allocates different prefix requests to different WSGI applications.

NOTE: This will change the values of environ["SCRIPT_NAME"] and environ["PATH_INFO"].

applications = Subpaths(
    ("/static", static_files),
    ("/api", api_app),
    ("", default_app),
)

Hosts

class baize.wsgi.Hosts(*hosts: Tuple[str, Interface])

A router that distributes requests to different WSGI applications based on Host.

applications = Hosts(
    (r"static\.example\.com", static_files),
    (r"api\.example\.com", api_app),
    (r"(www\.)?example\.com", default_app),
)

Shortcut functions

request_response

baize.wsgi.request_response(view: Callable[[Request], Response]) Callable[[MutableMapping[str, Any], StartResponse], Iterable[bytes]]

This can turn a callable object into a WSGI application.

@request_response
def f(request: Request) -> Response:
    ...

decorator

baize.wsgi.decorator(handler: Callable[[Request, Callable[[Request], Response]], Response]) Callable[[Callable[[Request], Response]], Callable[[Request], Response]]

This can turn a callable object into a decorator for view.

@decorator
def m(request: Request, next_call: Callable[[Request], Response]) -> Response:
    ...
    response = next_call(request)
    ...
    return response

@request_response
@m
def v(request: Request) -> Response:
    ...

Files

class baize.wsgi.Files(directory: Union[str, PathLike[str]], package: Optional[str] = None, *, handle_404: Optional[Interface] = None, cacheability: Literal['public', 'private', 'no-cache', 'no-store'] = 'public', max_age: int = 600)

Provide the WSGI application to download files in the specified path or the specified directory under the specified package.

Support request range and cache (304 status code).

Pages

class baize.wsgi.Pages(directory: Union[str, PathLike[str]], package: Optional[str] = None, *, handle_404: Optional[Interface] = None, cacheability: Literal['public', 'private', 'no-cache', 'no-store'] = 'public', max_age: int = 600)

Provide the WSGI application to download files in the specified path or the specified directory under the specified package. Unlike Files, when you visit a directory, it will try to return the content of the file named index.html in that directory. Or if the pathname.html is exist, it will return the content of that file.

Support request range and cache (304 status code).