From dcd49c8d818b803f226f6bebe8f8868f1290462e Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Tue, 30 Apr 2024 12:27:49 +0300 Subject: [PATCH 1/7] Cleanup long line --- tests/#test_response.py# | 994 +++++++++++++++++++++++++++++++++++++++ tests/test_response.py | 5 +- 2 files changed, 998 insertions(+), 1 deletion(-) create mode 100644 tests/#test_response.py# diff --git a/tests/#test_response.py# b/tests/#test_response.py# new file mode 100644 index 0000000000..926d308e44 --- /dev/null +++ b/tests/#test_response.py# @@ -0,0 +1,994 @@ +import asyncio +import inspect +import os +import time + +from collections import namedtuple +from datetime import datetime, timedelta +from email.utils import formatdate, parsedate_to_datetime +from logging import ERROR, LogRecord +from mimetypes import guess_type +from pathlib import Path +from random import choice +from typing import Callable, List, Union +from urllib.parse import unquote + +import pytest + +from aiofiles import os as async_os +from pytest import LogCaptureFixture + +from sanic import Request, Sanic +from sanic.compat import Header +from sanic.constants import DEFAULT_HTTP_CONTENT_TYPE +from sanic.cookies import CookieJar +from sanic.response import ( + HTTPResponse, + ResponseStream, + empty, + file, + file_stream, + json, + raw, + text, +) + + +JSON_DATA = {"ok": True} + + +@pytest.mark.filterwarnings("ignore:Types other than str will be") +def test_response_body_not_a_string(app): + """Test when a response body sent from the application is not a string""" + random_num = choice(range(1000)) + + @app.route("/hello") + async def hello_route(request: Request): + return text(random_num) + + request, response = app.test_client.get("/hello") + assert response.status == 500 + assert b"Internal Server Error" in response.body + + +async def sample_streaming_fn(request, response=None): + if not response: + response = await request.respond(content_type="text/csv") + await response.send("foo,") + await asyncio.sleep(0.001) + await response.send("bar") + await response.eof() + + +def test_method_not_allowed(): + app = Sanic("app") + + @app.get("/") + async def test_get(request: Request): + return response.json({"hello": "world"}) + + request, response = app.test_client.head("/") + assert set(response.headers["Allow"].split(", ")) == { + "GET", + } + + request, response = app.test_client.post("/") + assert set(response.headers["Allow"].split(", ")) == { + "GET", + } + + app.router.reset() + + @app.post("/") + async def test_post(request: Request): + return response.json({"hello": "world"}) + + request, response = app.test_client.head("/") + assert response.status == 405 + assert set(response.headers["Allow"].split(", ")) == { + "GET", + "POST", + } + assert response.headers["Content-Length"] == "0" + + request, response = app.test_client.patch("/") + assert response.status == 405 + assert set(response.headers["Allow"].split(", ")) == { + "GET", + "POST", + } + assert response.headers["Content-Length"] == "0" + + +def test_response_header(app): + @app.get("/") + async def test(request: Request): + return json({"ok": True}, headers={"CONTENT-TYPE": "application/json"}) + + request, response = app.test_client.get("/") + for key, value in { + "connection": "keep-alive", + "content-length": "11", + "content-type": "application/json", + }.items(): + assert response.headers[key] == value + + +def test_response_content_length(app): + @app.get("/response_with_space") + async def response_with_space(request: Request): + return json( + {"message": "Data", "details": "Some Details"}, + headers={"CONTENT-TYPE": "application/json"}, + ) + + @app.get("/response_without_space") + async def response_without_space(request: Request): + return json( + {"message": "Data", "details": "Some Details"}, + headers={"CONTENT-TYPE": "application/json"}, + ) + + _, response = app.test_client.get("/response_with_space") + content_length_for_response_with_space = response.headers.get( + "Content-Length" + ) + + _, response = app.test_client.get("/response_without_space") + content_length_for_response_without_space = response.headers.get( + "Content-Length" + ) + + assert ( + content_length_for_response_with_space + == content_length_for_response_without_space + ) + + assert content_length_for_response_with_space == "43" + + +def test_response_content_length_with_different_data_types(app): + @app.get("/") + async def get_data_with_different_types(request: Request): + # Indentation issues in the Response is intentional. Please do not fix + return json( + {"bool": True, "none": None, "string": "string", "number": -1}, + headers={"CONTENT-TYPE": "application/json"}, + ) + + _, response = app.test_client.get("/") + assert response.headers.get("Content-Length") == "55" + + +@pytest.fixture +def json_app(app): + @app.route("/") + async def test(request: Request): + return json(JSON_DATA) + + @app.get("/no-content") + async def no_content_handler(request: Request): + return json(JSON_DATA, status=204) + + @app.get("/no-content/unmodified") + async def no_content_unmodified_handler(request: Request): + return json(None, status=304) + + @app.get("/unmodified") + async def unmodified_handler(request: Request): + return json(JSON_DATA, status=304) + + @app.delete("/") + async def delete_handler(request: Request): + return json(None, status=204) + + return app + + +def test_json_response(json_app): + from sanic.response import json_dumps + + request, response = json_app.test_client.get("/") + assert response.status == 200 + assert response.text == json_dumps(JSON_DATA) + assert response.json == JSON_DATA + + +def test_no_content(json_app): + request, response = json_app.test_client.get("/no-content") + assert response.status == 204 + assert response.text == "" + assert "Content-Length" not in response.headers + + request, response = json_app.test_client.get("/no-content/unmodified") + assert response.status == 304 + assert response.text == "" + assert "Content-Length" not in response.headers + assert "Content-Type" not in response.headers + + request, response = json_app.test_client.get("/unmodified") + assert response.status == 304 + assert response.text == "" + assert "Content-Length" not in response.headers + assert "Content-Type" not in response.headers + + request, response = json_app.test_client.delete("/") + assert response.status == 204 + assert response.text == "" + assert "Content-Length" not in response.headers + + +@pytest.fixture +def streaming_app(app): + @app.route("/") + async def test(request: Request): + await sample_streaming_fn(request) + + return app + + +@pytest.fixture +def non_chunked_streaming_app(app): + @app.route("/") + async def test(request: Request): + response = await request.respond( + headers={"Content-Length": "7"}, + content_type="text/csv", + ) + await sample_streaming_fn(request, response) + + return app + + +def test_chunked_streaming_adds_correct_headers(streaming_app): + request, response = streaming_app.test_client.get("/") + assert response.headers["Transfer-Encoding"] == "chunked" + assert response.headers["Content-Type"] == "text/csv" + # Content-Length is not allowed by HTTP/1.1 specification + # when "Transfer-Encoding: chunked" is used + assert "Content-Length" not in response.headers + + +def test_chunked_streaming_returns_correct_content(streaming_app): + request, response = streaming_app.test_client.get("/") + assert response.text == "foo,bar" + + +@pytest.mark.asyncio +async def test_chunked_streaming_returns_correct_content_asgi(streaming_app): + request, response = await streaming_app.asgi_client.get("/") + assert response.body == b"foo,bar" + + +def test_non_chunked_streaming_adds_correct_headers(non_chunked_streaming_app): + request, response = non_chunked_streaming_app.test_client.get("/") + + assert "Transfer-Encoding" not in response.headers + assert response.headers["Content-Type"] == "text/csv" + assert response.headers["Content-Length"] == "7" + + +@pytest.mark.asyncio +async def test_non_chunked_streaming_adds_correct_headers_asgi( + non_chunked_streaming_app, +): + request, response = await non_chunked_streaming_app.asgi_client.get("/") + assert "Transfer-Encoding" not in response.headers + assert response.headers["Content-Type"] == "text/csv" + assert response.headers["Content-Length"] == "7" + + +def test_non_chunked_streaming_returns_correct_content( + non_chunked_streaming_app, +): + request, response = non_chunked_streaming_app.test_client.get("/") + assert response.text == "foo,bar" + + +def test_stream_response_with_cookies(app): + @app.route("/") + async def test(request: Request): + headers = Header() + cookies = CookieJar(headers) + cookies["test"] = "modified" + cookies["test"] = "pass" + response = await request.respond( + content_type="text/csv", headers=headers + ) + + await response.send("foo,") + await asyncio.sleep(0.001) + await response.send("bar") + + request, response = app.test_client.get("/") + assert response.cookies["test"] == "pass" + + +def test_stream_response_without_cookies(app): + @app.route("/") + async def test(request: Request): + await sample_streaming_fn(request) + + request, response = app.test_client.get("/") + assert response.cookies == {} + + +@pytest.fixture +def static_file_directory(): + """The static directory to serve""" + current_file = inspect.getfile(inspect.currentframe()) + current_directory = os.path.dirname(os.path.abspath(current_file)) + static_directory = os.path.join(current_directory, "static") + return static_directory + + +def path_str_to_path_obj(static_file_directory: Union[Path, str]): + if isinstance(static_file_directory, str): + static_file_directory = Path(static_file_directory) + return static_file_directory + + +def get_file_content(static_file_directory: Union[Path, str], file_name: str): + """The content of the static file to check""" + static_file_directory = path_str_to_path_obj(static_file_directory) + with open(static_file_directory / file_name, "rb") as file: + return file.read() + + +def get_file_last_modified_timestamp( + static_file_directory: Union[Path, str], file_name: str +): + """The content of the static file to check""" + static_file_directory = path_str_to_path_obj(static_file_directory) + return (static_file_directory / file_name).stat().st_mtime + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +@pytest.mark.parametrize("status", [200, 401]) +def test_file_response(app: Sanic, file_name, static_file_directory, status): + @app.route("/files/", methods=["GET"]) + def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + return file( + file_path, + status=status, + mime_type=guess_type(file_path)[0] or "text/plain", + ) + + request, response = app.test_client.get(f"/files/{file_name}") + assert response.status == status + assert response.body == get_file_content(static_file_directory, file_name) + assert "Content-Disposition" not in response.headers + + +@pytest.mark.parametrize( + "source,dest", + [ + ("test.file", "my_file.txt"), + ("decode me.txt", "readme.md"), + ("python.png", "logo.png"), + ], +) +def test_file_response_custom_filename( + app: Sanic, source, dest, static_file_directory +): + @app.route("/files/", methods=["GET"]) + def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + return file(file_path, filename=dest) + + request, response = app.test_client.get(f"/files/{source}") + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, source) + assert ( + response.headers["Content-Disposition"] + == f'attachment; filename="{dest}"' + ) + + +@pytest.mark.parametrize("file_name", ["test.file", "decode me.txt"]) +def test_file_head_response(app: Sanic, file_name, static_file_directory): + @app.route("/files/", methods=["GET", "HEAD"]) + async def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + stats = await async_os.stat(file_path) + headers = {} + headers["Accept-Ranges"] = "bytes" + headers["Content-Length"] = str(stats.st_size) + if request.method == "HEAD": + return HTTPResponse( + headers=headers, + content_type=guess_type(file_path)[0] or "text/plain", + ) + else: + return file( + file_path, + headers=headers, + mime_type=guess_type(file_path)[0] or "text/plain", + ) + + request, response = app.test_client.head(f"/files/{file_name}") + assert response.status == 200 + assert "Accept-Ranges" in response.headers + assert "Content-Length" in response.headers + assert int(response.headers["Content-Length"]) == len( + get_file_content(static_file_directory, file_name) + ) + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +def test_file_stream_response(app: Sanic, file_name, static_file_directory): + @app.route("/files/", methods=["GET"]) + def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + return file_stream( + file_path, + chunk_size=32, + mime_type=guess_type(file_path)[0] or "text/plain", + ) + + request, response = app.test_client.get(f"/files/{file_name}") + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, file_name) + assert "Content-Disposition" not in response.headers + + +@pytest.mark.parametrize( + "source,dest", + [ + ("test.file", "my_file.txt"), + ("decode me.txt", "readme.md"), + ("python.png", "logo.png"), + ], +) +def test_file_stream_response_custom_filename( + app: Sanic, source, dest, static_file_directory +): + @app.route("/files/", methods=["GET"]) + def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + return file_stream(file_path, chunk_size=32, filename=dest) + + request, response = app.test_client.get(f"/files/{source}") + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, source) + assert ( + response.headers["Content-Disposition"] + == f'attachment; filename="{dest}"' + ) + + +@pytest.mark.parametrize("file_name", ["test.file", "decode me.txt"]) +def test_file_stream_head_response( + app: Sanic, file_name, static_file_directory +): + @app.route("/files/", methods=["GET", "HEAD"]) + async def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + headers = {} + headers["Accept-Ranges"] = "bytes" + if request.method == "HEAD": + # Return a normal HTTPResponse, not a + # StreamingHTTPResponse for a HEAD request + stats = await async_os.stat(file_path) + headers["Content-Length"] = str(stats.st_size) + return HTTPResponse( + headers=headers, + content_type=guess_type(file_path)[0] or "text/plain", + ) + else: + return file_stream( + file_path, + chunk_size=32, + headers=headers, + mime_type=guess_type(file_path)[0] or "text/plain", + ) + + request, response = app.test_client.head(f"/files/{file_name}") + assert response.status == 200 + # A HEAD request should never be streamed/chunked. + if "Transfer-Encoding" in response.headers: + assert response.headers["Transfer-Encoding"] != "chunked" + assert "Accept-Ranges" in response.headers + # A HEAD request should get the Content-Length too + assert "Content-Length" in response.headers + assert int(response.headers["Content-Length"]) == len( + get_file_content(static_file_directory, file_name) + ) + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +@pytest.mark.parametrize( + "size,start,end", [(1024, 0, 1024), (4096, 1024, 8192)] +) +def test_file_stream_response_range( + app: Sanic, file_name, static_file_directory, size, start, end +): + Range = namedtuple("Range", ["size", "start", "end", "total"]) + total = len(get_file_content(static_file_directory, file_name)) + range = Range(size=size, start=start, end=end, total=total) + + @app.route("/files/", methods=["GET"]) + def file_route(request, filename): + file_path = os.path.join(static_file_directory, filename) + file_path = os.path.abspath(unquote(file_path)) + return file_stream( + file_path, + chunk_size=32, + mime_type=guess_type(file_path)[0] or "text/plain", + _range=range, + ) + + request, response = app.test_client.get(f"/files/{file_name}") + assert response.status == 206 + assert "Content-Range" in response.headers + assert ( + response.headers["Content-Range"] + == f"bytes {range.start}-{range.end}/{range.total}" + ) + + +def test_raw_response(app): + @app.get("/test") + def handler(request: Request): + return raw(b"raw_response") + + request, response = app.test_client.get("/test") + assert response.content_type == DEFAULT_HTTP_CONTENT_TYPE + assert response.body == b"raw_response" + + +def test_empty_response(app): + @app.get("/test") + def handler(request: Request): + return empty() + + request, response = app.test_client.get("/test") + assert response.content_type is None + assert response.body == b"" + + +def test_direct_response_stream(app: Sanic): + @app.route("/") + async def test(request: Request): + response = await request.respond(content_type="text/csv") + await response.send("foo,") + await response.send("bar") + await response.eof() + + _, response = app.test_client.get("/") + assert response.text == "foo,bar" + assert response.headers["Transfer-Encoding"] == "chunked" + assert response.headers["Content-Type"] == "text/csv" + assert "Content-Length" not in response.headers + + +@pytest.mark.asyncio +async def test_direct_response_stream_asgi(app: Sanic): + @app.route("/") + async def test(request: Request): + response = await request.respond(content_type="text/csv") + await response.send("foo,") + await response.send("bar") + await response.eof() + + _, response = await app.asgi_client.get("/") + assert response.text == "foo,bar" + assert response.headers["Content-Type"] == "text/csv" + assert "Content-Length" not in response.headers + + +def test_multiple_responses( + app: Sanic, + caplog: LogCaptureFixture, + message_in_records: Callable[[List[LogRecord], str], bool], +): + @app.route("/1") + async def handler1(request: Request): + response = await request.respond() + await response.send("foo") + response = await request.respond() + + @app.route("/2") + async def handler2(request: Request): + response = await request.respond() + response = await request.respond() + await response.send("foo") + + @app.get("/3") + async def handler3(request: Request): + response = await request.respond() + await response.send("foo,") + response = await request.respond() + await response.send("bar") + + @app.get("/4") + async def handler4(request: Request): + await request.respond(headers={"one": "one"}) + return json({"foo": "bar"}, headers={"one": "two"}) + + @app.get("/5") + async def handler5(request: Request): + response = await request.respond(headers={"one": "one"}) + await response.send("foo") + return json({"foo": "bar"}, headers={"one": "two"}) + + @app.get("/6") + async def handler6(request: Request): + response = await request.respond(headers={"one": "one"}) + await response.send("foo, ") + json_response = json({"foo": "bar"}, headers={"one": "two"}) + await response.send("bar") + return json_response + + error_msg0 = "Second respond call is not allowed." + + error_msg1 = ( + "The error response will not be sent to the client for the following " + 'exception:"Second respond call is not allowed.". A previous ' + "response has at least partially been sent." + ) + + error_msg2 = ( + "The response object returned by the route handler " + "will not be sent to client. The request has already " + "been responded to." + ) + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/1") + assert response.status == 200 + assert message_in_records(caplog.records, error_msg0) + assert message_in_records(caplog.records, error_msg1) + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/2") + assert response.status == 500 + assert "500 β€” Internal Server Error" in response.text + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/3") + assert response.status == 200 + assert "foo," in response.text + assert message_in_records(caplog.records, error_msg0) + assert message_in_records(caplog.records, error_msg1) + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/4") + assert response.status == 200 + assert "foo" not in response.text + assert "one" in response.headers + assert response.headers["one"] == "one" + + assert message_in_records(caplog.records, error_msg2) + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/5") + assert response.status == 200 + assert "foo" in response.text + assert "one" in response.headers + assert response.headers["one"] == "one" + assert message_in_records(caplog.records, error_msg2) + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/6") + assert "foo, bar" in response.text + assert "one" in response.headers + assert response.headers["one"] == "one" + assert message_in_records(caplog.records, error_msg2) + + +def test_send_response_after_eof_should_fail( + app: Sanic, + caplog: LogCaptureFixture, + message_in_records: Callable[[List[LogRecord], str], bool], +): + @app.get("/") + async def handler(request: Request): + response = await request.respond() + await response.send("foo, ") + await response.eof() + await response.send("bar") + + error_msg1 = ( + "The error response will not be sent to the client for the following " + 'exception:"Response stream was ended, no more response ' + 'data is allowed to be sent.". A previous ' + "response has at least partially been sent." + ) + + error_msg2 = "Response stream was ended, no more response data is allowed to be sent." + + with caplog.at_level(ERROR): + _, response = app.test_client.get("/") + assert "foo, " in response.text + assert message_in_records(caplog.records, error_msg1) + assert message_in_records(caplog.records, error_msg2) + + +@pytest.mark.asyncio +async def test_send_response_after_eof_should_fail_asgi( + app: Sanic, + caplog: LogCaptureFixture, + message_in_records: Callable[[List[LogRecord], str], bool], +): + @app.get("/") + async def handler(request: Request): + response = await request.respond() + await response.send("foo, ") + await response.eof() + await response.send("bar") + + error_msg1 =( + + "The error response will not be sent to the client for the " + 'following exception:"There is no request to respond to, ' + "either the response has already been sent or the request " + 'has not been received yet.". A previous response has ' + "at least partially been sent." + ) + + error_msg2 = ( + "There is no request to respond to, either the response has " + "already been sent or the request has not been received yet." + ) + + with caplog.at_level(ERROR): + _, response = await app.asgi_client.get("/") + assert "foo, " in response.text + assert message_in_records(caplog.records, error_msg1) + assert message_in_records(caplog.records, error_msg2) + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +def test_file_response_headers( + app: Sanic, file_name: str, static_file_directory: str +): + test_last_modified = datetime.now() + test_max_age = 10 + test_expires = test_last_modified.timestamp() + test_max_age + + @app.route("/files/cached/", methods=["GET"]) + def file_route_cache(request: Request, filename: str): + file_path = ( + Path(static_file_directory) / unquote(filename) + ).absolute() + return file( + file_path, max_age=test_max_age, last_modified=test_last_modified + ) + + @app.route( + "/files/cached_default_last_modified/", methods=["GET"] + ) + def file_route_cache_default_last_modified( + request: Request, filename: str + ): + file_path = ( + Path(static_file_directory) / unquote(filename) + ).absolute() + return file(file_path, max_age=test_max_age) + + @app.route("/files/no_cache/", methods=["GET"]) + def file_route_no_cache(request: Request, filename: str): + file_path = ( + Path(static_file_directory) / unquote(filename) + ).absolute() + return file(file_path) + + @app.route("/files/no_store/", methods=["GET"]) + def file_route_no_store(request: Request, filename: str): + file_path = ( + Path(static_file_directory) / unquote(filename) + ).absolute() + return file(file_path, no_store=True) + + _, response = app.test_client.get(f"/files/cached/{file_name}") + assert response.body == get_file_content(static_file_directory, file_name) + headers = response.headers + assert ( + "cache-control" in headers + and f"max-age={test_max_age}" in headers.get("cache-control") + and "public" in headers.get("cache-control") + ) + assert ( + "expires" in headers + and headers.get("expires")[:-6] + == formatdate(test_expires, usegmt=True)[:-6] + # [:-6] to allow at most 1 min difference + # It's minimal for cases like: + # Thu, 26 May 2022 05:36:59 GMT + # AND + # Thu, 26 May 2022 05:37:00 GMT + ) + assert response.status == 200 + assert "last-modified" in headers and headers.get( + "last-modified" + ) == formatdate(test_last_modified.timestamp(), usegmt=True) + + _, response = app.test_client.get( + f"/files/cached_default_last_modified/{file_name}" + ) + file_last_modified = get_file_last_modified_timestamp( + static_file_directory, file_name + ) + headers = response.headers + assert "last-modified" in headers and headers.get( + "last-modified" + ) == formatdate(file_last_modified, usegmt=True) + assert response.status == 200 + + _, response = app.test_client.get(f"/files/no_cache/{file_name}") + headers = response.headers + assert "cache-control" in headers and "no-cache" == headers.get( + "cache-control" + ) + assert response.status == 200 + + _, response = app.test_client.get(f"/files/no_store/{file_name}") + headers = response.headers + assert "cache-control" in headers and "no-store" == headers.get( + "cache-control" + ) + assert response.status == 200 + + +def test_file_validate(app: Sanic, static_file_directory: str): + file_name = "test_validate.txt" + static_file_directory = Path(static_file_directory) + file_path = static_file_directory / file_name + file_path = file_path.absolute() + test_max_age = 10 + + with open(file_path, "w+") as f: + f.write("foo\n") + + @app.route("/validate", methods=["GET"]) + def file_route_cache(request: Request): + return file( + file_path, + request_headers=request.headers, + max_age=test_max_age, + validate_when_requested=True, + ) + + _, response = app.test_client.get("/validate") + assert response.status == 200 + assert response.body == b"foo\n" + last_modified = response.headers["Last-Modified"] + + time.sleep(1) + with open(file_path, "a") as f: + f.write("bar\n") + _, response = app.test_client.get( + "/validate", headers={"If-Modified-Since": last_modified} + ) + + assert response.status == 200 + assert response.body == b"foo\nbar\n" + + last_modified = response.headers["Last-Modified"] + _, response = app.test_client.get( + "/validate", headers={"if-modified-since": last_modified} + ) + assert response.status == 304 + assert response.body == b"" + + file_path.unlink() + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +def test_file_validating_invalid_header( + app: Sanic, file_name: str, static_file_directory: str +): + @app.route("/files/", methods=["GET"]) + def file_route(request: Request, filename: str): + handler_file_path = ( + Path(static_file_directory) / unquote(filename) + ).absolute() + + return file( + handler_file_path, + request_headers=request.headers, + validate_when_requested=True, + ) + + _, response = app.test_client.get(f"/files/{file_name}") + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, file_name) + + _, response = app.test_client.get( + f"/files/{file_name}", headers={"if-modified-since": "invalid-value"} + ) + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, file_name) + + _, response = app.test_client.get( + f"/files/{file_name}", headers={"if-modified-since": ""} + ) + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, file_name) + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +def test_file_validating_304_response_file_route( + app: Sanic, file_name: str, static_file_directory: str +): + @app.route("/files/", methods=["GET"]) + def file_route(request: Request, filename: str): + handler_file_path = ( + Path(static_file_directory) / unquote(filename) + ).absolute() + + return file( + handler_file_path, + request_headers=request.headers, + validate_when_requested=True, + ) + + _, response = app.test_client.get(f"/files/{file_name}") + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, file_name) + + _, response = app.test_client.get( + f"/files/{file_name}", + headers={"if-modified-since": response.headers["Last-Modified"]}, + ) + assert response.status == 304 + assert response.body == b"" + + +@pytest.mark.parametrize( + "file_name", ["test.file", "decode me.txt", "python.png"] +) +def test_file_validating_304_response( + app: Sanic, file_name: str, static_file_directory: str +): + app.static("static", Path(static_file_directory) / file_name) + + _, response = app.test_client.get("/static") + assert response.status == 200 + assert response.body == get_file_content(static_file_directory, file_name) + last_modified = parsedate_to_datetime(response.headers["Last-Modified"]) + last_modified += timedelta(seconds=1) + _, response = app.test_client.get( + "/static", + headers={ + "if-modified-since": formatdate( + last_modified.timestamp(), usegmt=True + ) + }, + ) + assert response.status == 304 + assert response.body == b"" + + +def test_stream_response_with_default_headers(app: Sanic): + async def sample_streaming_fn(response_): + await response_.write("foo") + + @app.route("/") + async def test(request: Request): + return ResponseStream(sample_streaming_fn, content_type="text/csv") + + _, response = app.test_client.get("/") + assert response.text == "foo" + assert response.headers["Transfer-Encoding"] == "chunked" + assert response.headers["Content-Type"] == "text/csv" diff --git a/tests/test_response.py b/tests/test_response.py index 49665229b9..faf9556d0f 100644 --- a/tests/test_response.py +++ b/tests/test_response.py @@ -709,7 +709,10 @@ async def handler(request: Request): "response has at least partially been sent." ) - error_msg2 = "Response stream was ended, no more response data is allowed to be sent." + error_msg2 = ( + "Response stream was ended, " + "no more response data is allowed to be sent." + ) with caplog.at_level(ERROR): _, response = app.test_client.get("/") From 699ff7991f9f7aee58ec4dfe57dc67d55347de6e Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Tue, 30 Apr 2024 13:25:58 +0300 Subject: [PATCH 2/7] Release 24.4 --- guide/config/en/sidebar.yaml | 4 +++ guide/content/en/guide/basics/listeners.md | 4 +-- guide/content/en/guide/running/development.md | 13 ++++----- guide/content/en/guide/running/manager.md | 17 ++++------- guide/content/en/release-notes/changelog.md | 29 +++++++++++++++++-- guide/public/assets/style.css | 13 ++++++++- guide/style/theme.scss | 10 +++++++ sanic/__version__.py | 2 +- 8 files changed, 64 insertions(+), 28 deletions(-) diff --git a/guide/config/en/sidebar.yaml b/guide/config/en/sidebar.yaml index f10b3f1a28..964addd25f 100644 --- a/guide/config/en/sidebar.yaml +++ b/guide/config/en/sidebar.yaml @@ -143,6 +143,10 @@ root: path: plugins/sanic-testing/clients.html - label: Release Notes items: + - label: "2024" + items: + - label: Sanic 24.4 + path: release-notes/2024/v24.4.html - label: "2023" items: - label: Sanic 23.12 diff --git a/guide/content/en/guide/basics/listeners.md b/guide/content/en/guide/basics/listeners.md index 3e600ad255..84fc20c9e1 100644 --- a/guide/content/en/guide/basics/listeners.md +++ b/guide/content/en/guide/basics/listeners.md @@ -238,9 +238,7 @@ Given the following setup, we should expect to see this in the console if we run ### Priority -.. new:: v23.12 - - In v23.12, the `priority` keyword argument was added to listeners. This allows for fine-tuning the order of execution of listeners. The default priority is `0`. Listeners with a higher priority will be executed first. Listeners with the same priority will be executed in the order they were registered. Furthermore, listeners attached to the `app` instance will be executed before listeners attached to a `Blueprint` instance. +In v23.12, the `priority` keyword argument was added to listeners. This allows for fine-tuning the order of execution of listeners. The default priority is `0`. Listeners with a higher priority will be executed first. Listeners with the same priority will be executed in the order they were registered. Furthermore, listeners attached to the `app` instance will be executed before listeners attached to a `Blueprint` instance. Overall the rules for deciding the order of execution are as follows: diff --git a/guide/content/en/guide/running/development.md b/guide/content/en/guide/running/development.md index f0fcda8a46..09d2415392 100644 --- a/guide/content/en/guide/running/development.md +++ b/guide/content/en/guide/running/development.md @@ -70,9 +70,7 @@ sanic server:app --host=0.0.0.0 --port=1234 --debug ## Development REPL -.. new:: v23.12 - - The Sanic CLI comes with a REPL (aka "read-eval-print loop") that can be used to interact with your application. This is useful for debugging and testing. A REPL is the interactive shell that you get when you run `python` without any arguments. +The Sanic CLI comes with a REPL (aka "read-eval-print loop") that can be used to interact with your application. This is useful for debugging and testing. A REPL is the interactive shell that you get when you run `python` without any arguments. .. column:: @@ -202,7 +200,7 @@ Or, by destructuring the tuple: .. column:: - If you would like to be in debug mode **and** have the Automatic Reloader running, you can pass `dev=True`. This is equivalent to **debug + auto reload**. + If you would like to be in debug mode **and** have the Automatic Reloader running, you can pass `dev=True`. This is equivalent to **debug + auto reload + REPL**. *Added in v22.3* @@ -216,11 +214,10 @@ Or, by destructuring the tuple: sanic path.to:app -d ``` -.. new:: v23.12 - - Added to the `--dev` flag in v23.12 is the ability to start a REPL. See the [Development REPL](./development.md#development-repl) section for more information. +Added to the `--dev` flag in v23.12 is the ability to start a REPL. See the [Development REPL](./development.md#development-repl) section for more information. - As of v23.12, the `--dev` flag is roughly equivalent to `--debug --reload --repl`. Using `--dev` will require you to expressly begin the REPL by hitting "ENTER", while passing the `--repl` flag explicitly starts it. +As of v23.12, the `--dev` flag is roughly equivalent to `--debug --reload --repl`. Using `--dev` will require you to expressly begin the REPL by hitting "ENTER", while passing the `--repl` flag explicitly starts it. +Before v23.12, the `--dev` flag is more similar to `--debug --reload`. .. column:: diff --git a/guide/content/en/guide/running/manager.md b/guide/content/en/guide/running/manager.md index c021170ce6..021369f41e 100644 --- a/guide/content/en/guide/running/manager.md +++ b/guide/content/en/guide/running/manager.md @@ -360,15 +360,12 @@ To run a managed custom process on Sanic, you must create a callable. If that pr ### Tracked v. untracked processes -.. new:: v23.12 +Out of the box, Sanic will track the state of all processes. This means that you can access the state of the process from the [multiplexer](./manager#access-to-the-multiplexer) object, or from the [Inspector](./manager#inspector). - Out of the box, Sanic will track the state of all processes. This means that you can access the state of the process from the [multiplexer](./manager#access-to-the-multiplexer) object, or from the [Inspector](./manager#inspector). +See [worker state](./manager#worker-state) for more information. - See [worker state](./manager#worker-state) for more information. +Sometimes it is helpful to run background processes that are not long-running. You run them once until completion and then they exit. Upon completion, they will either be in `FAILED` or `COMPLETED` state. - Sometimes it is helpful to run background processes that are not long-running. You run them once until completion and then they exit. Upon completion, they will either be in `FAILED` or `COMPLETED` state. - - .. column:: When you are running a non-long-running process, you can opt out of tracking it by setting `tracked=False` in the `manage` method. This means that upon completion of the process it will be removed from the list of tracked processes. You will only be able to check the state of the process while it is running. @@ -390,9 +387,7 @@ To run a managed custom process on Sanic, you must create a callable. If that pr ### Restartable custom processes -.. new:: v23.12 - - A custom process that is transient will **always** be restartable. That means the auto-restart will work as expected. However, what if you want to be able to *manually* restart a process, but not have it be restarted by the auto-reloader? +A custom process that is transient will **always** be restartable. That means the auto-restart will work as expected. However, what if you want to be able to *manually* restart a process, but not have it be restarted by the auto-reloader? .. column:: @@ -428,9 +423,7 @@ To run a managed custom process on Sanic, you must create a callable. If that pr ### On the fly process management -.. new:: v23.12 - - Custom processes are usually added in the `main_process_ready` listener. However, there may be times when you want to add a process after the application has started. For example, you may want to add a process from a request handler. The multiplexer provides a method for doing this. +Custom processes are usually added in the `main_process_ready` listener. However, there may be times when you want to add a process after the application has started. For example, you may want to add a process from a request handler. The multiplexer provides a method for doing this. .. column:: diff --git a/guide/content/en/release-notes/changelog.md b/guide/content/en/release-notes/changelog.md index 797e8603fa..bfb8199fbe 100644 --- a/guide/content/en/release-notes/changelog.md +++ b/guide/content/en/release-notes/changelog.md @@ -8,10 +8,35 @@ content_class: changelog πŸ”· In support LTS release -## Version 23.12.0 πŸ”ΆπŸ”· +## Version 24.4.0 πŸ”Ά _Current version_ +### Features +- [#2850](https://github.com/sanic-org/sanic/pull/2850) Unix sockets can now use `pathlib.Path` +- [#2931](https://github.com/sanic-org/sanic/pull/2931) Logging improvements + +### Bugfixes +- [#2919](https://github.com/sanic-org/sanic/pull/2919) Remove deprecation notice in websockets +- [#2937](https://github.com/sanic-org/sanic/pull/2937) Resolve response streaming error when in ASGI mode + +### Deprecations and Removals +- [#2899](https://github.com/sanic-org/sanic/pull/2899) Remove erroneous line from REPL impacting environments without HTTPX + +### Developer infrastructure +- [#2882](https://github.com/sanic-org/sanic/pull/2882) [#2896](https://github.com/sanic-org/sanic/pull/2896) Apply dynamic port fixture for improving tests with port selection +- [#2887](https://github.com/sanic-org/sanic/pull/2887) Updates to docker image builds +- [#2932](https://github.com/sanic-org/sanic/pull/2932) Cleanup code base with Ruff + +### Improved Documentation +- [#2924](https://github.com/sanic-org/sanic/pull/2924) Cleanup markdown on html5tagger page +- [#2930](https://github.com/sanic-org/sanic/pull/2930) Cleanup typo on Sanic Extensions README.md +- [#2934](https://github.com/sanic-org/sanic/pull/2934) Add more context to the health check documents +- [#2936](https://github.com/sanic-org/sanic/pull/2936) Improve worker manager documentation + + +## Version 23.12.0 πŸ”· + ### Features - [#2775](https://github.com/sanic-org/sanic/pull/2775) Start and restart arbitrary processes - [#2811](https://github.com/sanic-org/sanic/pull/2811) Cleaner process management in shutdown @@ -33,8 +58,6 @@ _Current version_ ### Bugfixes - [#2803](https://github.com/sanic-org/sanic/pull/2803) Fix MOTD display for extra data -### Deprecations and Removals - ### Developer infrastructure - [#2796](https://github.com/sanic-org/sanic/pull/2796) Refactor unit test cases - [#2801](https://github.com/sanic-org/sanic/pull/2801) Fix `test_fast` when there is only one CPU diff --git a/guide/public/assets/style.css b/guide/public/assets/style.css index 36b3952791..bb04702800 100644 --- a/guide/public/assets/style.css +++ b/guide/public/assets/style.css @@ -12598,7 +12598,18 @@ a.has-text-danger-dark:hover, a.has-text-danger-dark:focus { .c1 { color: #4a4a4a; } .introduction-table .table tbody tr:last-child td { - border-bottom-width: 1px; } } + border-bottom-width: 1px; } + ::-webkit-scrollbar { + width: 12px; + height: 12px; } + ::-webkit-scrollbar-track { + background: #242424; } + ::-webkit-scrollbar-thumb { + background: #121212; + border-radius: 6px; + border: 3px solid #242424; } + ::-webkit-scrollbar-thumb:hover { + background: #0a0a0a; } } .burger { display: none; diff --git a/guide/style/theme.scss b/guide/style/theme.scss index 6ee2503d0a..0e6acc7ff4 100644 --- a/guide/style/theme.scss +++ b/guide/style/theme.scss @@ -62,4 +62,14 @@ $background-image-size: 270px; .nc { color: #{$yellow}; } .c1 { color: #{$grey-dark}; } .introduction-table .table tbody tr:last-child td { border-bottom-width: 1px; } + + $scrollbar-width: 12px; + ::-webkit-scrollbar { width: $scrollbar-width; height: $scrollbar-width; } + ::-webkit-scrollbar-track { background: #{$black-ter}; } + ::-webkit-scrollbar-thumb { + background: #{$black-bis}; + border-radius: 6px; + border: 3px solid #{$black-ter}; + } + ::-webkit-scrollbar-thumb:hover { background: #{$black}; } } diff --git a/sanic/__version__.py b/sanic/__version__.py index ba95260d83..b43269d5d3 100644 --- a/sanic/__version__.py +++ b/sanic/__version__.py @@ -1 +1 @@ -__version__ = "24.3.0.dev" +__version__ = "24.4.0" From 59e2a00334f18e97b2acb2257ff065f81da4a6d9 Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Fri, 3 May 2024 08:55:44 +0300 Subject: [PATCH 3/7] Add release notes --- guide/content/en/release-notes/2024/v24.4.md | 91 ++ guide/public/assets/images/logging-dev.png | Bin 0 -> 146338 bytes guide/public/assets/images/logging-prod.png | Bin 0 -> 120089 bytes tests/#test_response.py# | 994 ------------------- 4 files changed, 91 insertions(+), 994 deletions(-) create mode 100644 guide/content/en/release-notes/2024/v24.4.md create mode 100644 guide/public/assets/images/logging-dev.png create mode 100644 guide/public/assets/images/logging-prod.png delete mode 100644 tests/#test_response.py# diff --git a/guide/content/en/release-notes/2024/v24.4.md b/guide/content/en/release-notes/2024/v24.4.md new file mode 100644 index 0000000000..bced248a30 --- /dev/null +++ b/guide/content/en/release-notes/2024/v24.4.md @@ -0,0 +1,91 @@ +--- +title: Version 24.4 +--- + +# Version 24.4 + +.. toc:: + + +## Introduction + +This is the first release of the version 24 [release cycle](../../organization/policies.md#release-schedule). The release cadence for v24 may be slightly alrered from years past. Make sure to stay up to date in the Discord server for latest updates. If you run into any issues, please raise a concern on [GitHub](https://github.com/sanic-org/sanic/issues/new/choose). + +## What to know + +More details in the [Changelog](../changelog.html). Notable new or breaking features, and what to upgrade: + +### Logging improvements + +The default logging patterns have been cleaned up to make them much more developer-friendly when viewing from a terminal session. This includes the use of color and less verbose formatting. + +Sanic will select between two slight variations depending upon whether your server is in DEBUG mode. You can always opt to remove colors by using: + +```python +app.config.NO_COLOR = True +``` + +The color will automatically be stripped out from logs not in TTY terminal. + +Sanic will switch between the DEBUG and PROD formatters automatically using `sanic.logging.formatter.AutoFormatter` and `sanic.logging.formatter.AutoAccessFormatter`. Of course, you can force one version or the other using the appropriately named formatters + +#### In DEBUG mode + +```python +sanic.logging.formatter.DebugFormatter +sanic.logging.formatter.DebugAccessFormatter +``` + +![](/assets/images/logging-dev.png) + +#### In PROD mode + + +```python +sanic.logging.formatter.ProdFormatter +sanic.logging.formatter.ProdAccessFormatter +``` + +![](/assets/images/logging-prod.png) + +#### Legacy + +If you prefer the old-style of logging, these have been preserved for you as logging formatters: `sanic.logging.formatter.LegacyFormatter` and `sanic.logging.formatter.LegacyAccessFormatter`. + +One way to implement these formatters: + +```python +from sanic.log import LOGGING_CONFIG_DEFAULTS + +LOGGING_CONFIG_DEFAULTS["formatters"] = { + "generic": { + "class": "sanic.logging.formatter.LegacyFormatter" + }, + "access": { + "class": "sanic.logging.formatter.LegacyAccessFormatter" + }, +} +``` + +### Using Paths in unix sockets + +When creating a unix socket for your server, you can now perform that by passing a `pathlib.Path` object instead of just a string-based path + +## Thank you + +Thank you to everyone that participated in this release: :clap: + +[@ahopkins](https://github.com/ahopkins) +[@ChihweiLHBird](https://github.com/ChihweiLHBird) +[@DeJayDev](https://github.com/DeJayDev) +[@Huy-Ngo](https://github.com/Huy-Ngo) +[@iAndriy](https://github.com/iAndriy) +[@jakkaz](https://github.com/jakkaz) +[@Nano112](https://github.com/Nano112) +[@prryplatypus](https://github.com/prryplatypus) +[@razodactyl](https://github.com/razodactyl) +[@Tronic](https://github.com/Tronic) + +--- + +If you enjoy the project, please consider contributing. Of course we love code contributions, but we also love contributions in any form. Consider writing some documentation, showing off use cases, joining conversations and making your voice known, and if you are able: [financial contributions](https://opencollective.com/sanic-org/). diff --git a/guide/public/assets/images/logging-dev.png b/guide/public/assets/images/logging-dev.png new file mode 100644 index 0000000000000000000000000000000000000000..038eb81790b02ce5134116fb00d25d59553338eb GIT binary patch literal 146338 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

cc@qU7 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

@ls6o5RAL2?L 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

IO| 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", methods=["GET"]) - def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - return file( - file_path, - status=status, - mime_type=guess_type(file_path)[0] or "text/plain", - ) - - request, response = app.test_client.get(f"/files/{file_name}") - assert response.status == status - assert response.body == get_file_content(static_file_directory, file_name) - assert "Content-Disposition" not in response.headers - - -@pytest.mark.parametrize( - "source,dest", - [ - ("test.file", "my_file.txt"), - ("decode me.txt", "readme.md"), - ("python.png", "logo.png"), - ], -) -def test_file_response_custom_filename( - app: Sanic, source, dest, static_file_directory -): - @app.route("/files/", methods=["GET"]) - def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - return file(file_path, filename=dest) - - request, response = app.test_client.get(f"/files/{source}") - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, source) - assert ( - response.headers["Content-Disposition"] - == f'attachment; filename="{dest}"' - ) - - -@pytest.mark.parametrize("file_name", ["test.file", "decode me.txt"]) -def test_file_head_response(app: Sanic, file_name, static_file_directory): - @app.route("/files/", methods=["GET", "HEAD"]) - async def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - stats = await async_os.stat(file_path) - headers = {} - headers["Accept-Ranges"] = "bytes" - headers["Content-Length"] = str(stats.st_size) - if request.method == "HEAD": - return HTTPResponse( - headers=headers, - content_type=guess_type(file_path)[0] or "text/plain", - ) - else: - return file( - file_path, - headers=headers, - mime_type=guess_type(file_path)[0] or "text/plain", - ) - - request, response = app.test_client.head(f"/files/{file_name}") - assert response.status == 200 - assert "Accept-Ranges" in response.headers - assert "Content-Length" in response.headers - assert int(response.headers["Content-Length"]) == len( - get_file_content(static_file_directory, file_name) - ) - - -@pytest.mark.parametrize( - "file_name", ["test.file", "decode me.txt", "python.png"] -) -def test_file_stream_response(app: Sanic, file_name, static_file_directory): - @app.route("/files/", methods=["GET"]) - def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - return file_stream( - file_path, - chunk_size=32, - mime_type=guess_type(file_path)[0] or "text/plain", - ) - - request, response = app.test_client.get(f"/files/{file_name}") - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, file_name) - assert "Content-Disposition" not in response.headers - - -@pytest.mark.parametrize( - "source,dest", - [ - ("test.file", "my_file.txt"), - ("decode me.txt", "readme.md"), - ("python.png", "logo.png"), - ], -) -def test_file_stream_response_custom_filename( - app: Sanic, source, dest, static_file_directory -): - @app.route("/files/", methods=["GET"]) - def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - return file_stream(file_path, chunk_size=32, filename=dest) - - request, response = app.test_client.get(f"/files/{source}") - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, source) - assert ( - response.headers["Content-Disposition"] - == f'attachment; filename="{dest}"' - ) - - -@pytest.mark.parametrize("file_name", ["test.file", "decode me.txt"]) -def test_file_stream_head_response( - app: Sanic, file_name, static_file_directory -): - @app.route("/files/", methods=["GET", "HEAD"]) - async def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - headers = {} - headers["Accept-Ranges"] = "bytes" - if request.method == "HEAD": - # Return a normal HTTPResponse, not a - # StreamingHTTPResponse for a HEAD request - stats = await async_os.stat(file_path) - headers["Content-Length"] = str(stats.st_size) - return HTTPResponse( - headers=headers, - content_type=guess_type(file_path)[0] or "text/plain", - ) - else: - return file_stream( - file_path, - chunk_size=32, - headers=headers, - mime_type=guess_type(file_path)[0] or "text/plain", - ) - - request, response = app.test_client.head(f"/files/{file_name}") - assert response.status == 200 - # A HEAD request should never be streamed/chunked. - if "Transfer-Encoding" in response.headers: - assert response.headers["Transfer-Encoding"] != "chunked" - assert "Accept-Ranges" in response.headers - # A HEAD request should get the Content-Length too - assert "Content-Length" in response.headers - assert int(response.headers["Content-Length"]) == len( - get_file_content(static_file_directory, file_name) - ) - - -@pytest.mark.parametrize( - "file_name", ["test.file", "decode me.txt", "python.png"] -) -@pytest.mark.parametrize( - "size,start,end", [(1024, 0, 1024), (4096, 1024, 8192)] -) -def test_file_stream_response_range( - app: Sanic, file_name, static_file_directory, size, start, end -): - Range = namedtuple("Range", ["size", "start", "end", "total"]) - total = len(get_file_content(static_file_directory, file_name)) - range = Range(size=size, start=start, end=end, total=total) - - @app.route("/files/", methods=["GET"]) - def file_route(request, filename): - file_path = os.path.join(static_file_directory, filename) - file_path = os.path.abspath(unquote(file_path)) - return file_stream( - file_path, - chunk_size=32, - mime_type=guess_type(file_path)[0] or "text/plain", - _range=range, - ) - - request, response = app.test_client.get(f"/files/{file_name}") - assert response.status == 206 - assert "Content-Range" in response.headers - assert ( - response.headers["Content-Range"] - == f"bytes {range.start}-{range.end}/{range.total}" - ) - - -def test_raw_response(app): - @app.get("/test") - def handler(request: Request): - return raw(b"raw_response") - - request, response = app.test_client.get("/test") - assert response.content_type == DEFAULT_HTTP_CONTENT_TYPE - assert response.body == b"raw_response" - - -def test_empty_response(app): - @app.get("/test") - def handler(request: Request): - return empty() - - request, response = app.test_client.get("/test") - assert response.content_type is None - assert response.body == b"" - - -def test_direct_response_stream(app: Sanic): - @app.route("/") - async def test(request: Request): - response = await request.respond(content_type="text/csv") - await response.send("foo,") - await response.send("bar") - await response.eof() - - _, response = app.test_client.get("/") - assert response.text == "foo,bar" - assert response.headers["Transfer-Encoding"] == "chunked" - assert response.headers["Content-Type"] == "text/csv" - assert "Content-Length" not in response.headers - - -@pytest.mark.asyncio -async def test_direct_response_stream_asgi(app: Sanic): - @app.route("/") - async def test(request: Request): - response = await request.respond(content_type="text/csv") - await response.send("foo,") - await response.send("bar") - await response.eof() - - _, response = await app.asgi_client.get("/") - assert response.text == "foo,bar" - assert response.headers["Content-Type"] == "text/csv" - assert "Content-Length" not in response.headers - - -def test_multiple_responses( - app: Sanic, - caplog: LogCaptureFixture, - message_in_records: Callable[[List[LogRecord], str], bool], -): - @app.route("/1") - async def handler1(request: Request): - response = await request.respond() - await response.send("foo") - response = await request.respond() - - @app.route("/2") - async def handler2(request: Request): - response = await request.respond() - response = await request.respond() - await response.send("foo") - - @app.get("/3") - async def handler3(request: Request): - response = await request.respond() - await response.send("foo,") - response = await request.respond() - await response.send("bar") - - @app.get("/4") - async def handler4(request: Request): - await request.respond(headers={"one": "one"}) - return json({"foo": "bar"}, headers={"one": "two"}) - - @app.get("/5") - async def handler5(request: Request): - response = await request.respond(headers={"one": "one"}) - await response.send("foo") - return json({"foo": "bar"}, headers={"one": "two"}) - - @app.get("/6") - async def handler6(request: Request): - response = await request.respond(headers={"one": "one"}) - await response.send("foo, ") - json_response = json({"foo": "bar"}, headers={"one": "two"}) - await response.send("bar") - return json_response - - error_msg0 = "Second respond call is not allowed." - - error_msg1 = ( - "The error response will not be sent to the client for the following " - 'exception:"Second respond call is not allowed.". A previous ' - "response has at least partially been sent." - ) - - error_msg2 = ( - "The response object returned by the route handler " - "will not be sent to client. The request has already " - "been responded to." - ) - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/1") - assert response.status == 200 - assert message_in_records(caplog.records, error_msg0) - assert message_in_records(caplog.records, error_msg1) - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/2") - assert response.status == 500 - assert "500 β€” Internal Server Error" in response.text - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/3") - assert response.status == 200 - assert "foo," in response.text - assert message_in_records(caplog.records, error_msg0) - assert message_in_records(caplog.records, error_msg1) - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/4") - assert response.status == 200 - assert "foo" not in response.text - assert "one" in response.headers - assert response.headers["one"] == "one" - - assert message_in_records(caplog.records, error_msg2) - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/5") - assert response.status == 200 - assert "foo" in response.text - assert "one" in response.headers - assert response.headers["one"] == "one" - assert message_in_records(caplog.records, error_msg2) - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/6") - assert "foo, bar" in response.text - assert "one" in response.headers - assert response.headers["one"] == "one" - assert message_in_records(caplog.records, error_msg2) - - -def test_send_response_after_eof_should_fail( - app: Sanic, - caplog: LogCaptureFixture, - message_in_records: Callable[[List[LogRecord], str], bool], -): - @app.get("/") - async def handler(request: Request): - response = await request.respond() - await response.send("foo, ") - await response.eof() - await response.send("bar") - - error_msg1 = ( - "The error response will not be sent to the client for the following " - 'exception:"Response stream was ended, no more response ' - 'data is allowed to be sent.". A previous ' - "response has at least partially been sent." - ) - - error_msg2 = "Response stream was ended, no more response data is allowed to be sent." - - with caplog.at_level(ERROR): - _, response = app.test_client.get("/") - assert "foo, " in response.text - assert message_in_records(caplog.records, error_msg1) - assert message_in_records(caplog.records, error_msg2) - - -@pytest.mark.asyncio -async def test_send_response_after_eof_should_fail_asgi( - app: Sanic, - caplog: LogCaptureFixture, - message_in_records: Callable[[List[LogRecord], str], bool], -): - @app.get("/") - async def handler(request: Request): - response = await request.respond() - await response.send("foo, ") - await response.eof() - await response.send("bar") - - error_msg1 =( - - "The error response will not be sent to the client for the " - 'following exception:"There is no request to respond to, ' - "either the response has already been sent or the request " - 'has not been received yet.". A previous response has ' - "at least partially been sent." - ) - - error_msg2 = ( - "There is no request to respond to, either the response has " - "already been sent or the request has not been received yet." - ) - - with caplog.at_level(ERROR): - _, response = await app.asgi_client.get("/") - assert "foo, " in response.text - assert message_in_records(caplog.records, error_msg1) - assert message_in_records(caplog.records, error_msg2) - - -@pytest.mark.parametrize( - "file_name", ["test.file", "decode me.txt", "python.png"] -) -def test_file_response_headers( - app: Sanic, file_name: str, static_file_directory: str -): - test_last_modified = datetime.now() - test_max_age = 10 - test_expires = test_last_modified.timestamp() + test_max_age - - @app.route("/files/cached/", methods=["GET"]) - def file_route_cache(request: Request, filename: str): - file_path = ( - Path(static_file_directory) / unquote(filename) - ).absolute() - return file( - file_path, max_age=test_max_age, last_modified=test_last_modified - ) - - @app.route( - "/files/cached_default_last_modified/", methods=["GET"] - ) - def file_route_cache_default_last_modified( - request: Request, filename: str - ): - file_path = ( - Path(static_file_directory) / unquote(filename) - ).absolute() - return file(file_path, max_age=test_max_age) - - @app.route("/files/no_cache/", methods=["GET"]) - def file_route_no_cache(request: Request, filename: str): - file_path = ( - Path(static_file_directory) / unquote(filename) - ).absolute() - return file(file_path) - - @app.route("/files/no_store/", methods=["GET"]) - def file_route_no_store(request: Request, filename: str): - file_path = ( - Path(static_file_directory) / unquote(filename) - ).absolute() - return file(file_path, no_store=True) - - _, response = app.test_client.get(f"/files/cached/{file_name}") - assert response.body == get_file_content(static_file_directory, file_name) - headers = response.headers - assert ( - "cache-control" in headers - and f"max-age={test_max_age}" in headers.get("cache-control") - and "public" in headers.get("cache-control") - ) - assert ( - "expires" in headers - and headers.get("expires")[:-6] - == formatdate(test_expires, usegmt=True)[:-6] - # [:-6] to allow at most 1 min difference - # It's minimal for cases like: - # Thu, 26 May 2022 05:36:59 GMT - # AND - # Thu, 26 May 2022 05:37:00 GMT - ) - assert response.status == 200 - assert "last-modified" in headers and headers.get( - "last-modified" - ) == formatdate(test_last_modified.timestamp(), usegmt=True) - - _, response = app.test_client.get( - f"/files/cached_default_last_modified/{file_name}" - ) - file_last_modified = get_file_last_modified_timestamp( - static_file_directory, file_name - ) - headers = response.headers - assert "last-modified" in headers and headers.get( - "last-modified" - ) == formatdate(file_last_modified, usegmt=True) - assert response.status == 200 - - _, response = app.test_client.get(f"/files/no_cache/{file_name}") - headers = response.headers - assert "cache-control" in headers and "no-cache" == headers.get( - "cache-control" - ) - assert response.status == 200 - - _, response = app.test_client.get(f"/files/no_store/{file_name}") - headers = response.headers - assert "cache-control" in headers and "no-store" == headers.get( - "cache-control" - ) - assert response.status == 200 - - -def test_file_validate(app: Sanic, static_file_directory: str): - file_name = "test_validate.txt" - static_file_directory = Path(static_file_directory) - file_path = static_file_directory / file_name - file_path = file_path.absolute() - test_max_age = 10 - - with open(file_path, "w+") as f: - f.write("foo\n") - - @app.route("/validate", methods=["GET"]) - def file_route_cache(request: Request): - return file( - file_path, - request_headers=request.headers, - max_age=test_max_age, - validate_when_requested=True, - ) - - _, response = app.test_client.get("/validate") - assert response.status == 200 - assert response.body == b"foo\n" - last_modified = response.headers["Last-Modified"] - - time.sleep(1) - with open(file_path, "a") as f: - f.write("bar\n") - _, response = app.test_client.get( - "/validate", headers={"If-Modified-Since": last_modified} - ) - - assert response.status == 200 - assert response.body == b"foo\nbar\n" - - last_modified = response.headers["Last-Modified"] - _, response = app.test_client.get( - "/validate", headers={"if-modified-since": last_modified} - ) - assert response.status == 304 - assert response.body == b"" - - file_path.unlink() - - -@pytest.mark.parametrize( - "file_name", ["test.file", "decode me.txt", "python.png"] -) -def test_file_validating_invalid_header( - app: Sanic, file_name: str, static_file_directory: str -): - @app.route("/files/", methods=["GET"]) - def file_route(request: Request, filename: str): - handler_file_path = ( - Path(static_file_directory) / unquote(filename) - ).absolute() - - return file( - handler_file_path, - request_headers=request.headers, - validate_when_requested=True, - ) - - _, response = app.test_client.get(f"/files/{file_name}") - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, file_name) - - _, response = app.test_client.get( - f"/files/{file_name}", headers={"if-modified-since": "invalid-value"} - ) - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, file_name) - - _, response = app.test_client.get( - f"/files/{file_name}", headers={"if-modified-since": ""} - ) - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, file_name) - - -@pytest.mark.parametrize( - "file_name", ["test.file", "decode me.txt", "python.png"] -) -def test_file_validating_304_response_file_route( - app: Sanic, file_name: str, static_file_directory: str -): - @app.route("/files/", methods=["GET"]) - def file_route(request: Request, filename: str): - handler_file_path = ( - Path(static_file_directory) / unquote(filename) - ).absolute() - - return file( - handler_file_path, - request_headers=request.headers, - validate_when_requested=True, - ) - - _, response = app.test_client.get(f"/files/{file_name}") - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, file_name) - - _, response = app.test_client.get( - f"/files/{file_name}", - headers={"if-modified-since": response.headers["Last-Modified"]}, - ) - assert response.status == 304 - assert response.body == b"" - - -@pytest.mark.parametrize( - "file_name", ["test.file", "decode me.txt", "python.png"] -) -def test_file_validating_304_response( - app: Sanic, file_name: str, static_file_directory: str -): - app.static("static", Path(static_file_directory) / file_name) - - _, response = app.test_client.get("/static") - assert response.status == 200 - assert response.body == get_file_content(static_file_directory, file_name) - last_modified = parsedate_to_datetime(response.headers["Last-Modified"]) - last_modified += timedelta(seconds=1) - _, response = app.test_client.get( - "/static", - headers={ - "if-modified-since": formatdate( - last_modified.timestamp(), usegmt=True - ) - }, - ) - assert response.status == 304 - assert response.body == b"" - - -def test_stream_response_with_default_headers(app: Sanic): - async def sample_streaming_fn(response_): - await response_.write("foo") - - @app.route("/") - async def test(request: Request): - return ResponseStream(sample_streaming_fn, content_type="text/csv") - - _, response = app.test_client.get("/") - assert response.text == "foo" - assert response.headers["Transfer-Encoding"] == "chunked" - assert response.headers["Content-Type"] == "text/csv" From c7f071384f7d923a50cf8413d1350b3e5592e1d4 Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Fri, 3 May 2024 09:03:14 +0300 Subject: [PATCH 4/7] Cleanup typing and linting --- sanic/request/types.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/sanic/request/types.py b/sanic/request/types.py index ec4c2a822d..808f92f099 100644 --- a/sanic/request/types.py +++ b/sanic/request/types.py @@ -81,9 +81,12 @@ sanic_type = TypeVar( "sanic_type", bound=Sanic, default=Sanic[Config, SimpleNamespace] ) + ctx_type = TypeVar( + "ctx_type", bound=SimpleNamespace, default=SimpleNamespace + ) else: sanic_type = TypeVar("sanic_type") -ctx_type = TypeVar("ctx_type") + ctx_type = TypeVar("ctx_type") class Request(Generic[sanic_type, ctx_type]): From 51b343d98a19b365d408b7007ede4945b5d15288 Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Sun, 23 Jun 2024 17:07:26 +0300 Subject: [PATCH 5/7] Begin Release PR --- guide/public/assets/style.css | 9 +++++++++ guide/style/elements.scss | 9 +++++++++ guide/webapp/display/layouts/home.py | 15 ++++++++++++++- 3 files changed, 32 insertions(+), 1 deletion(-) diff --git a/guide/public/assets/style.css b/guide/public/assets/style.css index 36b3952791..3ee5a84460 100644 --- a/guide/public/assets/style.css +++ b/guide/public/assets/style.css @@ -13107,6 +13107,15 @@ h3 + .code-block { .changelog .ol .li, .changelog .ol .list-item, .changelog .ul .li, .changelog .ul .list-item, .changelog .list .li, .changelog .list .list-item { padding: 0; } +.sponsors { + display: flex; + flex-wrap: wrap; + justify-content: center; + text-align: center; + padding: 0.25rem 0; } + .sponsors .button { + margin-left: 1rem; } + @media screen and (min-width: 769px) { .hero.is-large .hero-body { padding: 18rem 6rem 3rem; } } diff --git a/guide/style/elements.scss b/guide/style/elements.scss index dc2d4e9f70..28368fddad 100644 --- a/guide/style/elements.scss +++ b/guide/style/elements.scss @@ -387,3 +387,12 @@ h3 + .code-block { margin-top: 1rem; } .li, .list-item { padding: 0; } } } + +.sponsors { + display: flex; + flex-wrap: wrap; + justify-content: center; + text-align: center; + padding: 0.25rem 0; + .button { margin-left: 1rem; } +} diff --git a/guide/webapp/display/layouts/home.py b/guide/webapp/display/layouts/home.py index bf937d2b19..947eabee0d 100644 --- a/guide/webapp/display/layouts/home.py +++ b/guide/webapp/display/layouts/home.py @@ -3,7 +3,7 @@ from contextlib import contextmanager from typing import Generator -from html5tagger import Builder, E +from html5tagger import Builder, E, HTML from sanic import Request from webapp.display.layouts.elements.footer import do_footer @@ -16,6 +16,7 @@ class HomeLayout(BaseLayout): def layout( self, request: Request, full: bool = True ) -> Generator[None, None, None]: + self._sponsors() self._hero(request.ctx.language) with self.builder.div(class_="home container"): yield @@ -52,6 +53,18 @@ def _do_buttons(self, language: str) -> Builder: ) return builder + def _sponsors(self) -> None: + with self.builder.section(class_="sponsors"): + self.builder( + "Secure, auto-document, and monetize your Sanic API with Zuplo", + E.a( + "Start free", + href="https://zuplo.com", + target="_blank", + class_="button is-primary is-small", + ), + ) + def _footer(self, request: Request) -> None: do_footer( self.builder, From 4f77727e0e114c0af48d060c38cd02257d3b854b Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Sun, 30 Jun 2024 11:23:30 +0300 Subject: [PATCH 6/7] Add to docs --- guide/content/en/release-notes/2024/v24.4.md | 91 -------------------- guide/content/en/release-notes/changelog.md | 4 +- 2 files changed, 3 insertions(+), 92 deletions(-) delete mode 100644 guide/content/en/release-notes/2024/v24.4.md diff --git a/guide/content/en/release-notes/2024/v24.4.md b/guide/content/en/release-notes/2024/v24.4.md deleted file mode 100644 index bced248a30..0000000000 --- a/guide/content/en/release-notes/2024/v24.4.md +++ /dev/null @@ -1,91 +0,0 @@ ---- -title: Version 24.4 ---- - -# Version 24.4 - -.. toc:: - - -## Introduction - -This is the first release of the version 24 [release cycle](../../organization/policies.md#release-schedule). The release cadence for v24 may be slightly alrered from years past. Make sure to stay up to date in the Discord server for latest updates. If you run into any issues, please raise a concern on [GitHub](https://github.com/sanic-org/sanic/issues/new/choose). - -## What to know - -More details in the [Changelog](../changelog.html). Notable new or breaking features, and what to upgrade: - -### Logging improvements - -The default logging patterns have been cleaned up to make them much more developer-friendly when viewing from a terminal session. This includes the use of color and less verbose formatting. - -Sanic will select between two slight variations depending upon whether your server is in DEBUG mode. You can always opt to remove colors by using: - -```python -app.config.NO_COLOR = True -``` - -The color will automatically be stripped out from logs not in TTY terminal. - -Sanic will switch between the DEBUG and PROD formatters automatically using `sanic.logging.formatter.AutoFormatter` and `sanic.logging.formatter.AutoAccessFormatter`. Of course, you can force one version or the other using the appropriately named formatters - -#### In DEBUG mode - -```python -sanic.logging.formatter.DebugFormatter -sanic.logging.formatter.DebugAccessFormatter -``` - -![](/assets/images/logging-dev.png) - -#### In PROD mode - - -```python -sanic.logging.formatter.ProdFormatter -sanic.logging.formatter.ProdAccessFormatter -``` - -![](/assets/images/logging-prod.png) - -#### Legacy - -If you prefer the old-style of logging, these have been preserved for you as logging formatters: `sanic.logging.formatter.LegacyFormatter` and `sanic.logging.formatter.LegacyAccessFormatter`. - -One way to implement these formatters: - -```python -from sanic.log import LOGGING_CONFIG_DEFAULTS - -LOGGING_CONFIG_DEFAULTS["formatters"] = { - "generic": { - "class": "sanic.logging.formatter.LegacyFormatter" - }, - "access": { - "class": "sanic.logging.formatter.LegacyAccessFormatter" - }, -} -``` - -### Using Paths in unix sockets - -When creating a unix socket for your server, you can now perform that by passing a `pathlib.Path` object instead of just a string-based path - -## Thank you - -Thank you to everyone that participated in this release: :clap: - -[@ahopkins](https://github.com/ahopkins) -[@ChihweiLHBird](https://github.com/ChihweiLHBird) -[@DeJayDev](https://github.com/DeJayDev) -[@Huy-Ngo](https://github.com/Huy-Ngo) -[@iAndriy](https://github.com/iAndriy) -[@jakkaz](https://github.com/jakkaz) -[@Nano112](https://github.com/Nano112) -[@prryplatypus](https://github.com/prryplatypus) -[@razodactyl](https://github.com/razodactyl) -[@Tronic](https://github.com/Tronic) - ---- - -If you enjoy the project, please consider contributing. Of course we love code contributions, but we also love contributions in any form. Consider writing some documentation, showing off use cases, joining conversations and making your voice known, and if you are able: [financial contributions](https://opencollective.com/sanic-org/). diff --git a/guide/content/en/release-notes/changelog.md b/guide/content/en/release-notes/changelog.md index bfb8199fbe..0f0d58806a 100644 --- a/guide/content/en/release-notes/changelog.md +++ b/guide/content/en/release-notes/changelog.md @@ -8,7 +8,7 @@ content_class: changelog πŸ”· In support LTS release -## Version 24.4.0 πŸ”Ά +## Version 24.6.0 πŸ”Ά _Current version_ @@ -19,6 +19,8 @@ _Current version_ ### Bugfixes - [#2919](https://github.com/sanic-org/sanic/pull/2919) Remove deprecation notice in websockets - [#2937](https://github.com/sanic-org/sanic/pull/2937) Resolve response streaming error when in ASGI mode +- [#2970](https://github.com/sanic-org/sanic/pull/2970) [#2978](https://github.com/sanic-org/sanic/pull/2978) Fix missing dependencies for 3.12 +- [#2976](https://github.com/sanic-org/sanic/pull/2976) Fix deleting a cookie that was created with `secure=False` ### Deprecations and Removals - [#2899](https://github.com/sanic-org/sanic/pull/2899) Remove erroneous line from REPL impacting environments without HTTPX From 17fd9f4647ae98a3ce6bed70fe76dc0eb1a1388b Mon Sep 17 00:00:00 2001 From: Adam Hopkins Date: Sun, 30 Jun 2024 15:03:53 +0300 Subject: [PATCH 7/7] Add docs for release --- guide/config/en/general.yaml | 2 +- guide/config/en/sidebar.yaml | 4 +- guide/content/en/release-notes/changelog.md | 14 +++- .../display/layouts/elements/sidebar.py | 14 ++++ sanic/__version__.py | 2 +- sanic/cookies/request.py | 4 +- sanic/cookies/response.py | 66 +++++++++---------- 7 files changed, 65 insertions(+), 41 deletions(-) diff --git a/guide/config/en/general.yaml b/guide/config/en/general.yaml index 19afeacea6..0b074eff74 100644 --- a/guide/config/en/general.yaml +++ b/guide/config/en/general.yaml @@ -1 +1 @@ -current_version: "23.6" +current_version: "24.6" diff --git a/guide/config/en/sidebar.yaml b/guide/config/en/sidebar.yaml index 964addd25f..000c4beafc 100644 --- a/guide/config/en/sidebar.yaml +++ b/guide/config/en/sidebar.yaml @@ -145,8 +145,8 @@ root: items: - label: "2024" items: - - label: Sanic 24.4 - path: release-notes/2024/v24.4.html + - label: Sanic 24.6 + path: release-notes/2024/v24.6.html - label: "2023" items: - label: Sanic 23.12 diff --git a/guide/content/en/release-notes/changelog.md b/guide/content/en/release-notes/changelog.md index 0f0d58806a..bbf3192ece 100644 --- a/guide/content/en/release-notes/changelog.md +++ b/guide/content/en/release-notes/changelog.md @@ -13,17 +13,27 @@ content_class: changelog _Current version_ ### Features +- [#2838](https://github.com/sanic-org/sanic/pull/2838) Simplify request cookies `getlist` - [#2850](https://github.com/sanic-org/sanic/pull/2850) Unix sockets can now use `pathlib.Path` -- [#2931](https://github.com/sanic-org/sanic/pull/2931) Logging improvements +- [#2931](https://github.com/sanic-org/sanic/pull/2931) [#2958](https://github.com/sanic-org/sanic/pull/2958) Logging improvements +- [#2947](https://github.com/sanic-org/sanic/pull/2947) Make the .message field on exceptions non-empty +- [#2961](https://github.com/sanic-org/sanic/pull/2961) [#2964](https://github.com/sanic-org/sanic/pull/2964) Allow for custom name generation ### Bugfixes - [#2919](https://github.com/sanic-org/sanic/pull/2919) Remove deprecation notice in websockets - [#2937](https://github.com/sanic-org/sanic/pull/2937) Resolve response streaming error when in ASGI mode +- [#2959](https://github.com/sanic-org/sanic/pull/2959) Resolve Python 3.12 deprecation notic +- [#2960](https://github.com/sanic-org/sanic/pull/2960) Ensure proper intent for noisy exceptions - [#2970](https://github.com/sanic-org/sanic/pull/2970) [#2978](https://github.com/sanic-org/sanic/pull/2978) Fix missing dependencies for 3.12 +- [#2971](https://github.com/sanic-org/sanic/pull/2971) Fix middleware exceptions on Not Found routes with error in middleware +- [#2973](https://github.com/sanic-org/sanic/pull/2973) Resolve cheduling logic for `transport.close` and `transport.abort` - [#2976](https://github.com/sanic-org/sanic/pull/2976) Fix deleting a cookie that was created with `secure=False` +- [#2979](https://github.com/sanic-org/sanic/pull/2979) Throw error on bad body length +- [#2980](https://github.com/sanic-org/sanic/pull/2980) Throw error on bad body encoding ### Deprecations and Removals - [#2899](https://github.com/sanic-org/sanic/pull/2899) Remove erroneous line from REPL impacting environments without HTTPX +- [#2962](https://github.com/sanic-org/sanic/pull/2962) Merge entity header removal ### Developer infrastructure - [#2882](https://github.com/sanic-org/sanic/pull/2882) [#2896](https://github.com/sanic-org/sanic/pull/2896) Apply dynamic port fixture for improving tests with port selection @@ -35,7 +45,7 @@ _Current version_ - [#2930](https://github.com/sanic-org/sanic/pull/2930) Cleanup typo on Sanic Extensions README.md - [#2934](https://github.com/sanic-org/sanic/pull/2934) Add more context to the health check documents - [#2936](https://github.com/sanic-org/sanic/pull/2936) Improve worker manager documentation - +- [#2955](https://github.com/sanic-org/sanic/pull/2955) Fixed wrong formatting in `request.md` ## Version 23.12.0 πŸ”· diff --git a/guide/webapp/display/layouts/elements/sidebar.py b/guide/webapp/display/layouts/elements/sidebar.py index dbf91ec567..6686eddf83 100644 --- a/guide/webapp/display/layouts/elements/sidebar.py +++ b/guide/webapp/display/layouts/elements/sidebar.py @@ -36,6 +36,20 @@ def _menu_items(request: Request) -> list[Builder]: .a("sanicbook.com", href="https://sanicbook.com", target="_blank") .br.img(src="https://sanicbook.com/images/SanicCoverFinal.png"), E.br.small("Book proceeds fund our journey"), + E.hr(), + E.p("Secure, auto-document, and monetize your Sanic API with:").a( + E.img( + src="/assets/images/zuplo.svg", + alt=( + "Zuplo - Secure, auto-document, " + "and monetize your Sanic API" + ), + style="width: 90%;", + ), + href="https://zuplo.com", + target="_blank", + rel="nofollow noopener noreferrer", + ), ] diff --git a/sanic/__version__.py b/sanic/__version__.py index b43269d5d3..a7f5098aa0 100644 --- a/sanic/__version__.py +++ b/sanic/__version__.py @@ -1 +1 @@ -__version__ = "24.4.0" +__version__ = "24.6.0" diff --git a/sanic/cookies/request.py b/sanic/cookies/request.py index ca8ae0691a..3b8b3f15e0 100644 --- a/sanic/cookies/request.py +++ b/sanic/cookies/request.py @@ -128,13 +128,13 @@ class CookieRequestParameters(RequestParameters): def __getitem__(self, key: str) -> Optional[str]: deprecation( f"You are accessing cookie key '{key}', which is currently in " - "compat mode returning a single cookie value. Starting in v24.3 " + "compat mode returning a single cookie value. Starting in v24.9 " "accessing a cookie value like this will return a list of values. " "To avoid this behavior and continue accessing a single value, " f"please upgrade from request.cookies['{key}'] to " f"request.cookies.get('{key}'). See more details: " "https://sanic.dev/en/guide/release-notes/v23.3.html#request-cookies", # noqa - 24.3, + 24.9, ) try: value = self._get_prefixed_cookie(key) diff --git a/sanic/cookies/response.py b/sanic/cookies/response.py index e84a24d820..1c710d20e0 100644 --- a/sanic/cookies/response.py +++ b/sanic/cookies/response.py @@ -51,7 +51,7 @@ def _quote(str): # no cov _is_legal_key = re.compile("[%s]+" % re.escape(LEGAL_CHARS)).fullmatch -# In v24.3, we should remove this as being a subclass of dict +# In v24.9, we should remove this as being a subclass of dict class CookieJar(dict): """A container to manipulate cookies. @@ -111,82 +111,82 @@ def __getitem__(self, key: str) -> Cookie: def __iter__(self): # no cov deprecation( "Iterating over the CookieJar has been deprecated and will be " - "removed in v24.3. To learn more, please see: " + "removed in v24.9. To learn more, please see: " "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies", # noqa - 24.3, + 24.9, ) return super().__iter__() def keys(self): # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "Accessing CookieJar.keys() has been deprecated and will be " - "removed in v24.3. To learn more, please see: " + "removed in v24.9. To learn more, please see: " "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies", # noqa - 24.3, + 24.9, ) return super().keys() def values(self): # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "Accessing CookieJar.values() has been deprecated and will be " - "removed in v24.3. To learn more, please see: " + "removed in v24.9. To learn more, please see: " "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies", # noqa - 24.3, + 24.9, ) return super().values() def items(self): # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "Accessing CookieJar.items() has been deprecated and will be " - "removed in v24.3. To learn more, please see: " + "removed in v24.9. To learn more, please see: " "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies", # noqa - 24.3, + 24.9, ) return super().items() def get(self, *args, **kwargs): # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "Accessing cookies from the CookieJar using get is deprecated " - "and will be removed in v24.3. You should instead use the " + "and will be removed in v24.9. You should instead use the " "cookies.get_cookie method. To learn more, please see: " "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies", # noqa - 24.3, + 24.9, ) return super().get(*args, **kwargs) def pop(self, key, *args, **kwargs): # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "Using CookieJar.pop() has been deprecated and will be " - "removed in v24.3. To learn more, please see: " + "removed in v24.9. To learn more, please see: " "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies", # noqa - 24.3, + 24.9, ) self.delete(key) return super().pop(key, *args, **kwargs) @property def header_key(self): # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "The CookieJar.header_key property has been deprecated and will " - "be removed in version 24.3. Use CookieJar.HEADER_KEY. ", - 24.3, + "be removed in version 24.9. Use CookieJar.HEADER_KEY. ", + 24.9, ) return CookieJar.HEADER_KEY @property def cookie_headers(self) -> Dict[str, str]: # no cov - """Deprecated in v24.3""" + """Deprecated in v24.9""" deprecation( "The CookieJar.coookie_headers property has been deprecated " - "and will be removed in version 24.3. If you need to check if a " + "and will be removed in version 24.9. If you need to check if a " "particular cookie key has been set, use CookieJar.has_cookie.", - 24.3, + 24.9, ) return {key: self.header_key for key in self} @@ -352,7 +352,7 @@ def add_cookie( ) self.headers.add(self.HEADER_KEY, cookie) - # This should be removed in v24.3 + # This should be removed in v24.9 super().__setitem__(key, cookie) return cookie @@ -413,7 +413,7 @@ def delete_cookie( self.headers.add(self.HEADER_KEY, cookie) elif existing_cookie is None: existing_cookie = cookie - # This should be removed in v24.3 + # This should be removed in v24.9 try: super().__delitem__(key) except KeyError: @@ -449,7 +449,7 @@ def delete_cookie( ) -# In v24.3, we should remove this as being a subclass of dict +# In v24.9, we should remove this as being a subclass of dict # Instead, it should be an object with __slots__ # All of the current property accessors should be removed in favor # of actual slotted properties. @@ -583,14 +583,14 @@ def __init__( def __setitem__(self, key, value): deprecation( "Setting values on a Cookie object as a dict has been deprecated. " - "This feature will be removed in v24.3. You should instead set " + "This feature will be removed in v24.9. You should instead set " f"values on cookies as object properties: cookie.{key}=... ", - 24.3, + 24.9, ) self._set_value(key, value) # This is a temporary method for backwards compat and should be removed - # in v24.3 when this is no longer a dict + # in v24.9 when this is no longer a dict def _set_value(self, key: str, value: Any) -> None: if key not in self._keys: raise KeyError("Unknown cookie property: %s=%s" % (key, value)) @@ -619,7 +619,7 @@ def encode(self, encoding: str) -> bytes: the cookies. .. warning:: - Direct encoding of a Cookie object has been deprecated and will be removed in v24.3. + Direct encoding of a Cookie object has been deprecated and will be removed in v24.9. Args: encoding (str): The encoding type to be used. @@ -629,8 +629,8 @@ def encode(self, encoding: str) -> bytes: """ # noqa: E501 deprecation( "Direct encoding of a Cookie object has been deprecated and will " - "be removed in v24.3.", - 24.3, + "be removed in v24.9.", + 24.9, ) return str(self).encode(encoding)