def save_message(message: Message) -> Response: response = Response(HTTP_302, content="", headers={ "location": app.reverse_uri("index"), }) response.set_cookie(Cookie("message", message.message)) return response
def test_responses_can_set_cookies(): # Given that I have a Response instance response = Response(HTTP_200) # When I call set_cookie on it with a couple valid cookies response.set_cookie(Cookie("a", "b")) response.set_cookie(Cookie("c", "d")) # Then both cookies should be added to its headers assert response.headers.get_all("set-cookie") == ["a=b", "c=d"]
def test_responses_get_content_length_does_not_change_the_streams_position(): # Given that I have a Response instance with some data in it response = Response(HTTP_200, content="ABCD") # When I read one byte from that data response.stream.read(1) # And get the content length assert response.get_content_length() == 4 # And read one byte again # Then it should pick up where it left off assert response.stream.read(1) == b"B"
def send_message(params: QueryParams, mail: Mail): """Emails an email address provided in the query string""" addresses = params.get_all("email") if not addresses: return Response( HTTP_400, content="Provide emails in the query params to send a welcome message", ) msg = Message( subject="Welcome to Molten!", body="Welcome to Molten! Glad to have you here.", recipients=addresses, ) mail.send(msg) return Response(HTTP_204, content="")
def handle( resolver: DependencyResolver, request: Request, environ: Environ, route: Optional[Route], ) -> Response: if route is None or not getattr(route.handler, "supports_ws", False): return handler() try: connection = request.headers["connection"] upgrade = request.headers["upgrade"] websocket_key = request.headers["sec-websocket-key"] websocket_version = request.headers["sec-websocket-version"] except HeaderMissing as e: raise HTTPError( HTTP_400, {"errors": { str(e): "this header is required" }}) try: origin = request.headers["origin"] except HeaderMissing: origin = "" if self.origin_re and not self.origin_re.match(origin): raise HTTPError(HTTP_400, {"error": "invalid origin"}) if "upgrade" not in connection.lower( ) or "websocket" not in upgrade.lower(): raise HTTPError(HTTP_400, {"error": "invalid upgrade request"}) if websocket_version not in SUPPORTED_VERSIONS: return Response( HTTP_426, headers={"sec-websocket-version": SUPPORTED_VERSIONS_STR}) # TODO: Implement extension handling. # TODO: Implement subprotocol handling. stream = _BufferedStream(environ["gunicorn.socket"]) stream.write( UPGRADE_RESPONSE_TEMPLATE % { b"websocket_accept": b64encode(sha1(f"{websocket_key}{PSK}".encode()).digest()), }) websocket = Websocket(stream) resolver.add_component(_WebsocketComponent(websocket)) try: handler() except Exception as e: handle_exception = resolver.resolve(self.handle_exception) handle_exception(exception=e) finally: websocket.close(CloseMessage()) raise RequestHandled("websocket request was upgraded")
def template_handler(mail_templates: MailTemplates) -> Response: mail.send_message( subject="Test email", html=mail_templates.render("test_template.html", name="Molten"), recipients=["*****@*****.**"], ) return Response(HTTP_204, content="")
def test_responses_are_representable(): # Given that I have a Response instance response = Response(HTTP_200) # When I call repr on it # Then I should get back a valid repr assert repr(response)
def render(self, status: str, response_data: Any) -> Response: content = packb(response_data, use_bin_type=True, default=self.default) return Response(status, stream=BytesIO(content), headers={ "content-type": "application/x-msgpack", })
def get_countries() -> Response: return Response(HTTP_200, stream=open(path_to("fixtures", "example.json"), mode="rb"), headers={ "content-type": "application/json", })
def login(login: Login, auth: AuthProvider, user_manager: UserProvider) -> Response: user = auth.get_user_from_token(login.token) if user is None: return Response(HTTP_401, content='{}') user = user_manager.get_user_from_external(user) token = auth.get_user_token(user) return Response( HTTP_200, content=json.dumps({'token': token}), headers={ 'Content-Type': 'application/json', }, )
def middleware() -> Any: try: return handler() except errors.ArtemisHTTPError as error: return Response( status=error.status, content=json.dumps(error.response), headers=error.headers)
def expose_metrics_multiprocess() -> Response: # pragma: no cover """Expose prometheus metrics from the current set of processes. Use this instead of expose_metrics if you're using a multi-process server. """ registry = CollectorRegistry() multiprocess.MultiProcessCollector(registry) return Response(HTTP_200, headers=_HEADERS, stream=BytesIO(generate_latest(registry)))
def sign_up(signup: Signup, mail: Mail, templates: MailTemplates): """Handler that simulates a basic async sending of an html templated welcome email""" msg = Message( subject="Welcome to Molten!", body="This is a body that gets shown if html can't", html=templates.render("welcome_mail.html", name=signup.first_name), recipients=[signup.email], ) Thread(target=send_async_email, args=(mail, msg)).start() return Response(HTTP_204, content="")
def middleware(authorization: Optional[Header], auth_provider: AuthProvider, user_provider: UserProvider) -> Any: if getattr(handler, 'exclude_auth', False): return handler() if not authorization: return Response(HTTP_403, content='{}') if not authorization.startswith('Bearer '): return Response(HTTP_403, content='{}') token = authorization.split(' ')[1] if not token or not auth_provider.verify_user_token(token): return Response(HTTP_403, content='{}') user_provider.load_user(auth_provider.verify_user_token(token)) return handler()
def render(self, template_name: str, **context: Any) -> Response: """Find a template and render it. Parameters: template_name: The name of the template to render. **context: Bindings passed to the template. """ template = self.environment.get_template(template_name) rendered_template = template.render(**context) return Response(HTTP_200, content=rendered_template, headers={ "content-type": "text/html", })
def send_envelope(envelope: Envelope) -> Response: if envelope.recipient != "*": try: MAILBOXES[envelope.recipient].put(envelope) except KeyError: raise HTTPError(HTTP_404, {"error": f"user {envelope.recipient} not found"}) else: for mailbox in MAILBOXES.values(): mailbox.put(envelope) return Response(HTTP_204)
def render(self, status: str, response_data: Any) -> Response: if response_data is not None: try: response_data = dump_schema(response_data) except TypeError: pass # TODO - fix hack to prevent camel casing openAPI data if type(response_data) == dict: if not response_data.get('openapi'): response_data = parse_keys(response_data, types='camel') content = json.dumps(response_data, default=self.default) return Response(status, content=content, headers={ "content-type": "application/json; charset=utf-8", })
def index() -> Response: return Response(HTTP_200)
def render(self, status: str, response_data: Any) -> Response: content = json.dumps(response_data, default=self.default) return Response(status, content=content, headers={"content-type": "text/plain"})
def index(request: Request) -> Response: return Response(HTTP_200, content="Hello!")
def params(params: QueryParams) -> Response: return Response(HTTP_200, content=repr(params))
def no_content() -> Response: return Response(HTTP_204)
def named_headers(content_type: Header) -> Response: return Response(HTTP_200, content=f"{content_type}")
def named_optional_headers(content_type: Optional[Header]) -> Response: return Response(HTTP_200, content=f"{content_type}")
def get_paste(paste_id: str) -> Response: try: paste = open(relative_path("uploads", paste_id), "rb") return Response(HTTP_200, stream=paste) except FileNotFoundError: return Response(HTTP_404, content="Paste not found.")
def index() -> Response: return Response(HTTP_200, content=__doc__, headers={ "content-type": "text/plain", })
def named_params(x: QueryParam, y: QueryParam) -> Response: return Response(HTTP_200, content=f"x: {x}, y: {y}")
def named_optional_params(x: Optional[QueryParam]) -> Response: return Response(HTTP_200, content=f"{x}")
def test_auth(jwt: JWT): cookie_name = "molten_auth_cookie" cookie_value = jwt.encode({"sub": 123456, "name": "spiderman"}) auth_response = Response(HTTP_200) auth_response.set_cookie(Cookie(cookie_name, cookie_value)) return auth_response
def parser(data: RequestData) -> Response: return Response(HTTP_200)