2

I am so sorry if this is a duplicate question but I barely see it anywhere except this one website. This website originally helps people to make queries in Google Sheet through REST API. Their links go like this example:

spreadsheetID/sheetName?filter[ColumnName]=aiman

I just wonder how to do it in FastAPI especially for params filter[columnName]. The columnName is also a variable which according name of column. I've already read this but cannot figure out it well. Any language also I appreciate.

davidism
  • 121,510
  • 29
  • 395
  • 339
Mohamad Aiman
  • 43
  • 1
  • 11
  • so you need the param as `filter[ColumnName]` or you need `filter` as a `dict` with the key as `ColumnName` and value as `aiman`? – Shod Dec 04 '21 at 16:27
  • It would be like this https://sheety.co/docs/requests.html. I am sorry I dont get you. My English is quite terrible. :( – Mohamad Aiman Dec 05 '21 at 05:27
  • 1
    Does this answer your question? [How to allow any arbitrary query parameters using FastAPI and Swagger?](https://stackoverflow.com/questions/68821077/how-to-allow-any-arbitrary-query-parameters-using-fastapi-and-swagger) – Chris Nov 26 '22 at 11:18
  • See related answers [here](https://stackoverflow.com/a/71039241/17865804) and [here](https://stackoverflow.com/a/73831142/17865804). – Chris Nov 26 '22 at 11:21

2 Answers2

4

the straightforward way is to use the Query dependency with an alias:

from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/sheetname")
def get_sheet(column_name: str = Query(default=None, alias="filter[ColumnName]"):
   print(column_name)
jsp
  • 41
  • 1
2

There is nothing built into the FastAPI to achieve that, but we can write it! We need function that parse parameter:

import re

def parse_param(param, value):
    regex = r"(?P<op>.*)\[(?P<col>.*)\]"
    if m := re.search(r, param):
        return {"op": m.group("op"), "col": m.group("col"), "val": value}
    return {param: value}

Now it's time to use it, the simplest way would be use underlying Starlete request and parse url

from fastapi import Request

@app.get("/sheetName")
def endpoint(r: Request):
    k, v = next(iter(r.query_params.items())) # Assuming there is only one parameter
    print(parse_param(k, v))

If you would like to some FastAPI magic, you have another two options

  1. The middleware
@app.middleware("http")
async def preprocess(request: Request, call_next):
    k, v = next(iter(request.query_params.items()))
    request._query_params = QueryParams(parse_param(k, v))
    request.scope["query_string"] = str(request._query_params).encode("ascii")
    response = await call_next(request)
    return response
  1. Custom request
from fastapi.routing import APIRoute
from starlette.datastructures import QueryParams

class BracketRequest(Request):
    @property
    def query_params(self):
        k, v = next(iter(super().query_params.items()))
        return QueryParams(parse_param(k, v))


class BracketRoute(APIRoute):
    def get_route_handler(self):
        original_route_handler = super().get_route_handler()

        async def custom_route_handler(request: Request):
            request = BracketRequest(request.scope, request.receive)
            return await original_route_handler(request)

        return custom_route_handler

app.router.route_class = BracketRoute

Second solution allows you to assign such logic only for specific routers. In both cases you can use your endpoint with help of FastAPI validation now:

@app.get("/sheetName")
def endpoint(op: str, col: str, val: Any):
    print(op, col, val)

This approach has limitations (like what if there can be more parameters? Or more parameters with brackets?) and exact solutions depends on specific needs, but they should give you enough insight how to solve them.

kosciej16
  • 6,294
  • 1
  • 18
  • 29