# Request Methods Received JSON {Body}
# Follow Thread https://github.com/encode/starlette/issues/493
async def firerecv(request):
    if request.method == 'GET':
        return PlainTextResponse("Received GET Method")
    if request.method == 'POST':
        body_bytes = await request.body()
        if body_bytes:
            json = await request.json()
            return JSONResponse(json)
        # print(json.dumps(data))
        return PlainTextResponse("Received POST Method")


routes = [
    Route("/", endpoint=homepage),
    Route("/about", endpoint=about),
    Route("/fire", endpoint=firerecv, methods=['GET', 'POST']),
    Route("/users", endpoint=user),  # Main Route
    Route("/users/{user_id:int}", endpoint=user),  # Sub Route to Main Route
    Mount("/submex",
          routes=[
              Route('/{username:str}', endpoint=submountex),
              Route('/', endpoint=submountex)
          ])  # Mounting Multiple SubRoutes after Main Route.
]

app = Starlette(routes=routes)
Beispiel #2
0
from starlette.routing import Route, Mount
from starlette.responses import JSONResponse
from models import Tournament


async def homepage(request):
    if request.method == 'POST':
        form = await request.form()
        await Tournament.create(name=form['name'])
    data = await Tournament.all()
    return JSONResponse([d.name for d in data])


routes = [Route('/', homepage, methods=['GET', 'POST'])]
Beispiel #3
0
from starlette.routing import Route, Router
from ads.views import (ads_all, ad, ad_create, ad_edit, ad_delete, ad_images,
                       upload, image_edit, image_delete, edit_upload,
                       review_create, review_edit, review_delete, search,
                       filter_search, maps)

ads_routes = Router([
    Route("/", endpoint=ads_all, methods=["GET", "POST"], name="ads_all"),
    Route("/create",
          endpoint=ad_create,
          methods=["GET", "POST"],
          name="ad_create"),
    Route("/edit/{id:int}",
          endpoint=ad_edit,
          methods=["GET", "POST"],
          name="ad_edit"),
    Route("/delete/{id:int}",
          endpoint=ad_delete,
          methods=["GET", "POST"],
          name="ad_delete"),
    Route("/image-edit/{id:int}",
          endpoint=image_edit,
          methods=["GET", "POST"],
          name="image_edit"),
    Route("/image-delete/{id:int}",
          endpoint=image_delete,
          methods=["POST"],
          name="image_delete"),
    Route("/edit-upload/{aid:int}",
          endpoint=edit_upload,
          methods=["POST"],
Beispiel #4
0
        await ws.send_json({"msgtype": "pong"})

    async def on_quit(self, ws, msg):
        await ws.send_json({"msgtype": "goodbye"})
        await ws.close()

    async def on_exec(self, ws, msg):
        runtime = msg['runtime']
        code = msg['code']
        env = msg.get('env') or {}

        k = Kernel(ws, runtime)
        await k.execute(code, env)
        await ws.close()

    async def on_unknown_message(self, ws, msg):
        msgtype = msg.get("msgtype")
        await ws.send_json({
            "msgtype": "error",
            "error": f"Unknown message type: {msgtype}",
            "msg": msg
        })



app = Starlette(routes=[
    Route('/', home),
    WebSocketRoute("/livecode", LiveCode),
    Mount('/static', app=StaticFiles(directory=static_dir), name="static"),
])
        await websocket.close()


async def call_webhook(body: Dict, id: str, url: str):
    # background job to execute a webhook
    signature = make_signature(SECRET, json.dumps(body).encode())
    headers = {
        "WebHook-ID": id,
        "WebHook-Signature": signature,
        "WebHook-Timestamp": f"{datetime.now(tz=timezone.utc).timestamp()}",
    }
    async with httpx.AsyncClient() as client:
        r = await client.post(url, json=body, headers=headers)
        try:
            body = r.json()
        except ValueError:
            body = r.text
        log.info(body)
        if (r.status_code // 100) > 3:
            raise HTTPException("Error, request failed")


routes = [
    Route("/healthz", health, methods=["GET"]),
    Route("/trigger", trigger, methods=["GET"]),
    Route("/webhook", incoming_webhook, methods=["GET", "POST"]),
    WebSocketRoute("/ws", websocket_endpoint),
]

app = Starlette(debug=True, routes=routes)
Beispiel #6
0
template_dir = Path(__file__).parent.joinpath("static").resolve()
TEMPLATES = Jinja2Templates(directory=[template_dir])


async def landing(request):
    """ Show a human-readable landing page when the base URL is accessed. """

    meta = meta_values(str(request.url), 1, 1, more_data_available=False)

    major_version = __api_version__.split(".")[0]
    versioned_url = (f"{request.url}"
                     if f"v{major_version}" in f"{request.url.path}" else
                     f"{request.url}v{major_version}/")

    context = {
        "request": request,
        "request_url": request.url,
        "api_version": __api_version__,
        "implementation": meta.implementation,
        "versioned_url": versioned_url,
        "provider": meta.provider,
        "index_base_url": CONFIG.index_base_url,
        "endpoints": list(ENTRY_COLLECTIONS.keys()) + ["info"],
    }

    return TEMPLATES.TemplateResponse("landing_page.html", context)


router = Router(routes=[Route("/", endpoint=landing)])
Beispiel #7
0
from typing import List, Optional
from starlette.requests import Request
from starlette.routing import Route, Mount
from starlette.endpoints import HTTPEndpoint
from starlette.responses import UJSONResponse
from api.validators.members import MemberLoginValidator
from infrastructures.logging import meteor_logman
from packages.webargs import parse_requests


class MemberLoginAPIResource(HTTPEndpoint):
    async def get(self, request: Request) -> UJSONResponse:
        return UJSONResponse({"path": "Members"})

    @parse_requests(MemberLoginValidator())
    async def post(self, request: Request, reqargs: dict) -> UJSONResponse:
        return UJSONResponse({"member_id": "MEM2019112613551501"})


member_auth_routes = Mount("/auth",
                           routes=[Route("/login", MemberLoginAPIResource)])
Beispiel #8
0
        body = await fetch(session, url)

    return UJSONResponse([body] + parse_chinese_name())


async def multiple_database_queries(request):
    seconds = 1.5
    body_list = []

    url = f'http://{GO_SLEEP_ADDRESS}/?seconds={seconds}'
    async with aiohttp.ClientSession(connector=_connector,
                                     connector_owner=False) as session:
        body = await fetch(session, url)
    body_list.append(body)

    url = f'http://{GO_SLEEP_ADDRESS}/?seconds={seconds}'
    async with aiohttp.ClientSession(connector=_connector,
                                     connector_owner=False) as session:
        body = await fetch(session, url)
    body_list.append(body)

    return UJSONResponse('\n'.join(body_list))


routes = [
    Route('/single', single_database_query),
    Route('/multiple', multiple_database_queries),
]

app = Starlette(routes=routes)
Beispiel #9
0
async def stream(scope, receive, send):
    message = await receive()
    camera = Camera()

    if message["type"] == "http.request":
        await send({
            "type":
            "http.response.start",
            "status":
            200,
            "headers":
            [[b"Content-Type", b"multipart/x-mixed-replace; boundary=frame"]],
        })
        while True:
            async for frame in camera.frames():
                data = b"".join([
                    b"--frame\r\n",
                    b"Content-Type: image/jpeg\r\n\r\n",
                    frame,
                    b"\r\n",
                ])
                await send({
                    "type": "http.response.body",
                    "body": data,
                    "more_body": True
                })


routes = [Route("/", endpoint=homepage), Mount("/stream/", stream)]
app = Starlette(debug=True, routes=routes)
Beispiel #10
0
# can enhance the security of your web application
# by enabling browser security policies.
# more on https://secure.readthedocs.io/en/latest/headers.html
secure_headers = SecureHeaders()


async def index(request):
    results = "Home page"
    return templates.TemplateResponse("index.html", {
        "request": request,
        "results": results
    })


routes = [
    Route("/", index),
]

app = Starlette(debug=True, routes=routes)
app.mount("/static", StaticFiles(directory="static"), name="static")
app.mount("/accounts", accounts_routes)
app.mount("/questions", questions_routes)
app.add_middleware(AuthenticationMiddleware, backend=UserAuthentication())
app.add_middleware(SessionMiddleware, secret_key=SECRET_KEY)


# middleware for secure headers
@app.middleware("http")
async def set_secure_headers(request, call_next):
    response = await call_next(request)
    secure_headers.starlette(response)
Beispiel #11
0
from fastapi import Depends, FastAPI
from fastapi.middleware.cors import CORSMiddleware
from piccolo.engine import engine_finder
from piccolo_admin.endpoints import create_admin
from piccolo_api.crud.endpoints import PiccoloCRUD
from piccolo_api.fastapi.endpoints import FastAPIKwargs, FastAPIWrapper
from starlette.routing import Mount, Route

from accounts.endpoints import oauth2_scheme, router
from forum.tables import Category, Reply, Topic
from home.endpoints import HomeEndpoint

app = FastAPI(
    title="Simple headless forum",
    routes=[
        Route("/", HomeEndpoint),
        Mount(
            "/admin/",
            create_admin(
                tables=[Category, Reply, Topic],
                # Required when running under HTTPS:
                # allowed_hosts=['my_site.com']
            ),
        ),
    ],
)

origins = [
    "http://localhost:8080",
]
Beispiel #12
0
async def delete_version(request: Request, *args, **kwargs):
    form_data = await request.form()
    logger.info(f'Processing form data {form_data}')
    if not form_data:
        return RedirectResponse('/')
    documentation_version = schemas.BasePackageVersion(
        name=form_data['packageName'], version=form_data['version'])
    methods.delete_version(documentation_version,
                           provided_permissions=request.auth.scopes)
    return RedirectResponse(url='/', status_code=303)


@authenticator.auth_required()
async def delete_package(request: Request, *args, **kwargs):
    form_data = await request.form()
    logger.info(f'Processing form data {form_data}')
    if not form_data:
        return RedirectResponse('/')
    package = schemas.BasePackage(name=form_data['packageName'])
    methods.delete_package(package, provided_permissions=request.auth.scopes)
    return RedirectResponse(url='/', status_code=303)


routes = [
    Route("/", endpoint=index, methods=['GET', 'POST']),
    Route("/packages/", endpoint=index, methods=['GET']),
    Route("/_upload", endpoint=upload, methods=['POST']),
    Route("/_delete/package", endpoint=delete_package, methods=['POST']),
    Route("/_delete/version", endpoint=delete_version, methods=['POST'])
]
Beispiel #13
0
        model = query_params["model"]

        models = {
            "sample": search_sample,
            "project": search_project,
            "session": search_session,
        }
        if model == "all":
            sql_fn = search_total
            query_res = db.exec_sql_query(fn=sql_fn, params=params)

            json_res = [dict(model=x, data=y) for x, y in query_res]
            json_res.reverse()

            return JSONResponse(json_res)
        else:
            for key, value in models.items():
                if model == key:
                    sql_fn = value
                    schema = getattr(db.interface, key)(many=True)

        query_res = db.exec_sql_query(fn=sql_fn, params=params)

        json_res = [dict(r) for r in query_res]

        return APIResponse(json_res, total_count=len(json_res), schema=schema)


OpenSearchAPI = Router(
    [Route("/query", endpoint=OpenSearchEndpoint, methods=["GET"])])
 def test_read_only(self):
     app = Router(routes=[Route("/", register(read_only=True))])
     client = TestClient(app)
     response = client.post("/")
     self.assertTrue(response.status_code, 405)
     self.assertTrue(response.content, "Running in read only mode.")
Beispiel #15
0
    """Generate text and return the parsed result as a dict."""
    if request.method == 'GET':
        params = request.query_params
    elif request.method == 'POST':
        params = await request.json()
    elif request.method == 'HEAD':
        return JSONResponse({'text': ''}, headers=response_header)
    logging.info(params)
    return JSONResponse(parse_text(generate_text(params)),
                        headers=response_header)


async def homepage(request):
    """Return HTML homepage."""
    return templates.TemplateResponse('index.html', {'request': request})


routes = [
    Route("/", endpoint=homepage),
    Route("/generate", endpoint=generate, methods=["GET", "POST"]),
]

app = Starlette(routes=routes, debug=True)
app.mount('/static', StaticFiles(directory='app/static'))
templates = Jinja2Templates(directory='app/templates')

if __name__ == "__main__":
    uvicorn.run(app,
                host='0.0.0.0',
                port=int(os.environ.get('PORT', 5000)),
                log_level="info")
Beispiel #16
0
    url = request.url_for("redirect2")
    return RedirectResponse(url)


async def redirect2(request):
    url = request.url_for("redirect3")
    return RedirectResponse(url)


async def redirect3(request):
    return JSONResponse({"hello": "world"})


routes = [
    Route("/",
          echo_request,
          methods=["GET", "DELETE", "OPTIONS", "POST", "PUT", "PATCH"]),
    Route("/echo_form_data", echo_form_data, methods=["POST", "PUT", "PATCH"]),
    Route("/echo_json", echo_json, methods=["POST", "PUT", "PATCH"]),
    Route("/echo_headers", echo_headers),
    Route("/redirect1", redirect1, name="redirect1"),
    Route("/redirect2", redirect2, name="redirect2"),
    Route("/redirect3", redirect3, name="redirect3"),
]

app = Starlette(routes=routes)


@pytest.fixture
async def server():
    config = Config(app=app, lifespan="off")
Beispiel #17
0
@dataclasses.dataclass
class RegisterUserInput:
    service_name: str
    user: t.Dict

    @classmethod
    async def parse(cls, a: Accessor) -> RegisterUserInput:
        # check header
        # check queries
        name = a.paths["name"]

        payload = t.cast(t.Mapping[str, t.Any], await a.jsondata())
        user = UserSchema().load(payload)
        return RegisterUserInput(
            service_name=name,
            user=user,
        )


async def register(request: Request):
    input: RegisterUserInput = await parse(RegisterUserInput.parse, request)
    return JSONResponse(UserSchema().dump(input.user))


app = Starlette(
    debug=True,
    routes=[
        Route("/services/{name}/users", register, methods=["POST"]),
    ],
)
Beispiel #18
0
def users(request):
    return Response("All users", media_type="text/plain")


def user(request):
    content = "User " + request.path_params["username"]
    return Response(content, media_type="text/plain")


def staticfiles(request):
    return Response("xxxxx", media_type="image/png")


app = Router(
    [
        Route("/", endpoint=homepage, methods=["GET"]),
        Mount(
            "/users",
            app=Router(
                [Route("", endpoint=users), Route("/{username}", endpoint=user)]
            ),
        ),
        Mount("/static", app=staticfiles),
    ]
)


@app.route("/func")
def func_homepage(request):
    return Response("Hello, world!", media_type="text/plain")
Beispiel #19
0
from app.endpoints.home import Home
from starlette.routing import Route

routes = [Route("/", endpoint=Home, methods=["GET"])]
Beispiel #20
0
def test_cors_allow_origin_regex(test_client_factory):
    def homepage(request):
        return PlainTextResponse("Homepage", status_code=200)

    app = Starlette(
        routes=[Route("/", endpoint=homepage)],
        middleware=[
            Middleware(
                CORSMiddleware,
                allow_headers=["X-Example", "Content-Type"],
                allow_origin_regex="https://.*",
                allow_credentials=True,
            )
        ],
    )

    client = test_client_factory(app)

    # Test standard response
    headers = {"Origin": "https://example.org"}
    response = client.get("/", headers=headers)
    assert response.status_code == 200
    assert response.text == "Homepage"
    assert response.headers["access-control-allow-origin"] == "https://example.org"
    assert response.headers["access-control-allow-credentials"] == "true"

    # Test standard credentialed response
    headers = {"Origin": "https://example.org", "Cookie": "star_cookie=sugar"}
    response = client.get("/", headers=headers)
    assert response.status_code == 200
    assert response.text == "Homepage"
    assert response.headers["access-control-allow-origin"] == "https://example.org"
    assert response.headers["access-control-allow-credentials"] == "true"

    # Test disallowed standard response
    # Note that enforcement is a browser concern. The disallowed-ness is reflected
    # in the lack of an "access-control-allow-origin" header in the response.
    headers = {"Origin": "http://example.org"}
    response = client.get("/", headers=headers)
    assert response.status_code == 200
    assert response.text == "Homepage"
    assert "access-control-allow-origin" not in response.headers

    # Test pre-flight response
    headers = {
        "Origin": "https://another.com",
        "Access-Control-Request-Method": "GET",
        "Access-Control-Request-Headers": "X-Example, content-type",
    }
    response = client.options("/", headers=headers)
    assert response.status_code == 200
    assert response.text == "OK"
    assert response.headers["access-control-allow-origin"] == "https://another.com"
    assert response.headers["access-control-allow-headers"] == (
        "Accept, Accept-Language, Content-Language, Content-Type, X-Example"
    )
    assert response.headers["access-control-allow-credentials"] == "true"

    # Test disallowed pre-flight response
    headers = {
        "Origin": "http://another.com",
        "Access-Control-Request-Method": "GET",
        "Access-Control-Request-Headers": "X-Example",
    }
    response = client.options("/", headers=headers)
    assert response.status_code == 400
    assert response.text == "Disallowed CORS origin"
    assert "access-control-allow-origin" not in response.headers
Beispiel #21
0
async def kek(req):
    return JSONResponse(f"kek")


async def horde(req):
    return PlainTextResponse(f"ты прав!")


async def aliance(req):
    username = req.path_params['username']
    return JSONResponse(f"Сам ты, {username}, сосед!")


routes = [
    Route("/", endpoint=homepage),
    Route("/about", endpoint=about),
    Route('/users/{username}', user),
    Route('/kek', kek, methods=["POST"]),
    Mount('/lol',
          routes=[
              Route('/ordasosed', horde),
              Route('/alyanssosed/{username}', aliance)
          ])
]

HTML_404_PAGE = "not found"
HTML_500_PAGE = "server error"


async def not_found(request, exc):
Beispiel #22
0
def add_doc_route(
    app: Starlette,
    prefix: str = "/",
    pin_code: str = "",
    title: str = "Pait Doc",
    open_api_tag_list: Optional[List[Dict[str, Any]]] = None,
) -> None:
    if pin_code:
        logging.info(f"doc route start pin code:{pin_code}")

    def _get_request_pin_code(request: Request) -> Optional[str]:
        r_pin_code: Optional[str] = request.query_params.get("pin_code", None)
        if pin_code:
            if r_pin_code != pin_code:
                raise HTTPException(
                    status_code=404,
                    detail=
                    ("The requested URL was not found on the server. If you entered"
                     " the URL manually please check your spelling and try again."
                     ),
                )
        return r_pin_code

    def _get_open_json_url(request: Request) -> str:
        r_pin_code: Optional[str] = _get_request_pin_code(request)
        openapi_json_url: str = (
            f"http://{request.url.hostname}:{request.url.port}{'/'.join(request.url.path.split('/')[:-1])}/openapi.json"
        )
        if r_pin_code:
            openapi_json_url += f"?pin_code={r_pin_code}"
        return openapi_json_url

    def get_redoc_html(request: Request) -> HTMLResponse:
        return HTMLResponse(_get_redoc_html(_get_open_json_url(request),
                                            title))

    def get_swagger_ui_html(request: Request) -> HTMLResponse:
        return HTMLResponse(
            _get_swagger_ui_html(_get_open_json_url(request), title))

    def openapi_route(request: Request) -> JSONResponse:
        _get_request_pin_code(request)
        pait_dict: Dict[str, PaitCoreModel] = load_app(request.app)
        pait_openapi: PaitOpenApi = PaitOpenApi(
            pait_dict,
            title=title,
            open_api_server_list=[{
                "url": f"http://{request.url.hostname}:{request.url.port}",
                "description": ""
            }],
            open_api_tag_list=open_api_tag_list,
        )
        return JSONResponse(pait_openapi.open_api_dict)

    route: Mount = Mount(
        prefix,
        name="api doc",
        routes=[
            Route("/redoc", get_redoc_html, methods=["GET"]),
            Route("/swagger", get_swagger_ui_html, methods=["GET"]),
            Route("/openapi.json", openapi_route, methods=["GET"]),
        ],
    )
    app.routes.append(route)
Beispiel #23
0
    def __init__(self,
                 enablePiCamera=False,
                 stabilize=False,
                 source=None,
                 camera_num=0,
                 stream_mode=False,
                 backend=0,
                 colorspace=None,
                 resolution=(640, 480),
                 framerate=25,
                 logging=False,
                 time_delay=0,
                 **options):
        """
        This constructor method initializes the object state and attributes of the WebGear_RTC class.

        Parameters:
            enablePiCamera (bool): provide access to PiGear(if True) or CamGear(if False) APIs respectively.
            stabilize (bool): enable access to Stabilizer Class for stabilizing frames.
            camera_num (int): selects the camera module index which will be used as Rpi source.
            resolution (tuple): sets the resolution (i.e. `(width,height)`) of the Rpi source.
            framerate (int/float): sets the framerate of the Rpi source.
            source (based on input): defines the source for the input stream.
            stream_mode (bool): controls the exclusive YouTube Mode.
            backend (int): selects the backend for OpenCV's VideoCapture class.
            colorspace (str): selects the colorspace of the input stream.
            logging (bool): enables/disables logging.
            time_delay (int): time delay (in sec) before start reading the frames.
            options (dict): provides ability to alter Tweak Parameters of WebGear_RTC, CamGear, PiGear & Stabilizer.
        """
        # raise error(s) for critical Class imports
        import_dependency_safe("starlette" if starlette is None else "")
        import_dependency_safe("aiortc" if aiortc is None else "")

        # initialize global params
        self.__logging = logging

        custom_data_location = ""  # path to save data-files to custom location
        data_path = ""  # path to WebGear_RTC data-files
        overwrite_default = False
        self.__relay = None  # act as broadcaster

        # reformat dictionary
        options = {str(k).strip(): v for k, v in options.items()}

        # assign values to global variables if specified and valid
        if options:
            if "custom_data_location" in options:
                value = options["custom_data_location"]
                if isinstance(value, str):
                    assert os.access(
                        value, os.W_OK
                    ), "[WebGear_RTC:ERROR] :: Permission Denied!, cannot write WebGear_RTC data-files to '{}' directory!".format(
                        value)
                    assert os.path.isdir(
                        os.path.abspath(value)
                    ), "[WebGear_RTC:ERROR] :: `custom_data_location` value must be the path to a directory and not to a file!"
                    custom_data_location = os.path.abspath(value)
                else:
                    logger.warning(
                        "Skipped invalid `custom_data_location` value!")
                del options["custom_data_location"]  # clean

            if "overwrite_default_files" in options:
                value = options["overwrite_default_files"]
                if isinstance(value, bool):
                    overwrite_default = value
                else:
                    logger.warning(
                        "Skipped invalid `overwrite_default_files` value!")
                del options["overwrite_default_files"]  # clean

            if "enable_live_broadcast" in options:
                value = options["enable_live_broadcast"]
                if isinstance(value, bool):
                    if value:
                        self.__relay = MediaRelay()
                        options[
                            "enable_infinite_frames"] = True  # enforce infinite frames
                        logger.critical(
                            "Enabled live broadcasting for Peer connection(s)."
                        )
                    else:
                        None
                else:
                    logger.warning(
                        "Skipped invalid `enable_live_broadcast` value!")
                del options["enable_live_broadcast"]  # clean

        # check if custom certificates path is specified
        if custom_data_location:
            data_path = generate_webdata(
                custom_data_location,
                c_name="webgear_rtc",
                overwrite_default=overwrite_default,
                logging=logging,
            )
        else:
            # otherwise generate suitable path
            data_path = generate_webdata(
                os.path.join(expanduser("~"), ".vidgear"),
                c_name="webgear_rtc",
                overwrite_default=overwrite_default,
                logging=logging,
            )

        # log it
        self.__logging and logger.debug(
            "`{}` is the default location for saving WebGear_RTC data-files.".
            format(data_path))

        # define Jinja2 templates handler
        self.__templates = Jinja2Templates(
            directory="{}/templates".format(data_path))

        # define custom exception handlers
        self.__exception_handlers = {
            404: self.__not_found,
            500: self.__server_error
        }
        # define routing tables
        self.routes = [
            Route("/", endpoint=self.__homepage),
            Route("/offer", self.__offer, methods=["GET", "POST"]),
            Mount(
                "/static",
                app=StaticFiles(directory="{}/static".format(data_path)),
                name="static",
            ),
        ]

        # define middleware support
        self.middleware = []

        # Handle RTC video server
        if source is None:
            self.config = {"server": None}
            self.__default_rtc_server = None
            self.__logging and logger.warning("Given source is of NoneType!")
        else:
            # Handle video source
            self.__default_rtc_server = RTC_VideoServer(
                enablePiCamera=enablePiCamera,
                stabilize=stabilize,
                source=source,
                camera_num=camera_num,
                stream_mode=stream_mode,
                backend=backend,
                colorspace=colorspace,
                resolution=resolution,
                framerate=framerate,
                logging=logging,
                time_delay=time_delay,
                **options)
            # define default frame generator in configuration
            self.config = {"server": self.__default_rtc_server}
            # add exclusive reset connection node
            self.routes.append(
                Route("/close_connection",
                      self.__reset_connections,
                      methods=["POST"]))
        # copying original routing tables for further validation
        self.__rt_org_copy = self.routes[:]
        # collects peer RTC connections
        self.__pcs = set()
from starlette.routing import Route, Mount

from source import views
from source.staticfiles import statics
from source.auth.routes import routes as auth_routes
from source.users.routes import routes as users_routes
from source.resources.routes import routes as resources_routes

routes = [
    Route("/", views.index, name="home"),
    Route("/about", views.about, name="about"),
    Route("/search", views.search, name="search"),
    Route("/welcome", views.welcome, name="welcome"),
    Route("/video", views.video, name="video"),
    Route("/image", views.image, name="image"),
    Route("/clear-session", views.clear, name="clear-session"),
    Mount("/resources", routes=resources_routes),
    Mount("/users", routes=users_routes),
    Mount("/auth", routes=auth_routes),
    Mount("/static", statics, name="static"),
]
Beispiel #25
0
        with instrument('awaiting_task'):
            await asyncio.sleep(0.1)
            return "done"

    task = asyncio.create_task(awaiting_task())
    await task
    return PlainTextResponse("Awaited task.")


async def error(request, exc):
    # Always raise exceptions, rather than convert them into pages
    raise exc


app = Starlette(routes=[
    Route("/", home),
    Route("/hello/", HelloEndpoint),
    Route("/crash/", crash),
    Route("/background-jobs/", background_jobs),
    Route("/await-task/", await_task),
],
                exception_handlers={
                    500: error,
                })

# Installation instructions
Config.set(
    key=os.environ["SCOUT_KEY"],
    name="Test Starlette App",
    monitor=True,
)
Beispiel #26
0
                media_type=media_type,
            )

        else:
            ctx = {"request": request, "form": form}
            return templates.TemplateResponse("index.html", ctx)


async def http_exception(
    request: Request, e: HTTPException
) -> Jinja2Templates.TemplateResponse:
    ctx = {
        "request": request,
        "title": e.status_code,
        "status_code": e.status_code,
        "message": e.detail,
    }
    return templates.TemplateResponse("exceptions.html", ctx)


routes = [
    Route("/", Index, name="index"),
    Mount("/static", app=StaticFiles(directory="static"), name="static"),
]


exception_handlers = {HTTPException: http_exception}


app = Starlette(routes=routes, exception_handlers=exception_handlers)
Beispiel #27
0
from starlette.routing import Route
from views import homepage, about
routes = [
    Route("/", endpoint=homepage),
    Route("/home", endpoint=homepage),
    Route("/about", endpoint=about),
]
from starlette.applications import Starlette
from starlette.responses import JSONResponse, Response
from starlette.routing import Route
from datetime import datetime


async def homepage(request):
    now = datetime.now()
    ts = now.isoformat()
    return JSONResponse({'hello': 'world', 'ts': ts})


app = Starlette(debug=True, routes=[
    Route('/', homepage),
])

# async def app(scope, receive, send):
#    #assert scope['type'] == 'http'
#    response = Response('Hello, world!', media_type='text/plain')
#    await response(scope, receive, send)
Beispiel #29
0
    raise HTTPException(status_code=406)


def not_modified(request):
    raise HTTPException(status_code=304)


class HandledExcAfterResponse:
    async def __call__(self, scope, receive, send):
        response = PlainTextResponse("OK", status_code=200)
        await response(scope, receive, send)
        raise HTTPException(status_code=406)


router = Router(routes=[
    Route("/runtime_error", endpoint=raise_runtime_error),
    Route("/not_acceptable", endpoint=not_acceptable),
    Route("/not_modified", endpoint=not_modified),
    Route("/handled_exc_after_response", endpoint=HandledExcAfterResponse()),
    WebSocketRoute("/runtime_error", endpoint=raise_runtime_error),
])

app = ExceptionMiddleware(router)


@pytest.fixture
def client(test_client_factory):
    with test_client_factory(app) as client:
        yield client

Beispiel #30
0
def startup():
    print("Ready to go")
    # add tasks on startup
    scheduled_tasks.start_jobs()


def shutdown():

    # remove scheduled tasks on shutdown
    scheduled_tasks.shut_down_schedule()
    print("and we are done")


routes = [
    Route("/", homepage),
    Route("/math", math_page),
    # WebSocketRoute("/ws", websocket_endpoint),
    # Mount("/static", StaticFiles(directory="static")),
]

app = Starlette(debug=True,
                routes=routes,
                on_startup=[startup],
                on_shutdown=[shutdown])

if __name__ == "__main__":
    import uvicorn

    # APScheduler is limited to running on a single worker at this this time (v3.6.3)
    # see https://github.com/agronholm/apscheduler/issues/218#issuecomment-559951948 for more information