Merge pull request #28 from developmentseed/moarOutputType

add csv / JSON / GeoJSONSeq output types

Author: vincentsarago

tests/routes/test_endpoints.py

@@ -15,6 +15,49 @@ def test_landing(app):
     assert "text/html" in response.headers["content-type"]
     assert "TiFeatures" in response.text
 
+    # Check accept headers
+    response = app.get("/", headers={"accept": "text/html"})
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+    assert "TiFeatures" in response.text
+
+    # accept quality
+    response = app.get(
+        "/", headers={"accept": "application/json;q=0.9, text/html;q=1.0"}
+    )
+    assert response.status_code == 200
+    assert "text/html" in response.headers["content-type"]
+    assert "TiFeatures" in response.text
+
+    # accept quality but only json is available
+    response = app.get("/", headers={"accept": "text/csv;q=1.0, application/json"})
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert body["title"] == "TiFeatures"
+
+    # accept quality but only json is available
+    response = app.get("/", headers={"accept": "text/csv;q=1.0, */*"})
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert body["title"] == "TiFeatures"
+
+    # Invalid accept, return default
+    response = app.get("/", headers={"accept": "text/htm"})
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert body["title"] == "TiFeatures"
+    assert body["links"]
+
+    # make sure `?f=` has priority over headers
+    response = app.get("/?f=json", headers={"accept": "text/html"})
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert body["title"] == "TiFeatures"
+
 
 def test_docs(app):
     """Test /api endpoint."""

tests/routes/test_item.py

@@ -16,6 +16,15 @@ def test_item(app):
     assert "text/html" in response.headers["content-type"]
     assert "Collection Item: 1" in response.text
 
+    # json output
+    response = app.get("/collections/public.landsat_wrs/items/1?f=json")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    feat = response.json()
+    assert ["collectionId", "itemId", "id", "pr", "row", "path", "ogc_fid"] == list(
+        feat.keys()
+    )
+
     # not found
     response = app.get("/collections/public.landsat_wrs/items/50000")
     assert response.status_code == 404

tests/routes/test_items.py

@@ -1,4 +1,5 @@
 """Test /items endpoints."""
+
 import json
 
 
@@ -469,7 +470,6 @@ def test_items_geometry_return_options(app):
     assert body["numberReturned"] == 1
     assert body["features"][0]["id"] == "1"
     assert body["features"][0]["properties"]["ogc_fid"] == 1
-    print(body["features"][0]["geometry"])
     assert body["features"][0]["geometry"] == {
         "coordinates": [
             [
@@ -483,3 +483,118 @@ def test_items_geometry_return_options(app):
         ],
         "type": "Polygon",
     }
+
+
+def test_output_response_type(app):
+    """Make sure /items returns wanted output response type."""
+    # CSV output
+    response = app.get("/collections/public.landsat_wrs/items?f=csv")
+    assert response.status_code == 200
+    assert "text/csv" in response.headers["content-type"]
+    body = response.text.splitlines()
+    assert len(body) == 11
+    assert body[0] == "collectionId,itemId,id,pr,row,path,ogc_fid,geometry"
+
+    # we only accept csv
+    response = app.get(
+        "/collections/public.landsat_wrs/items", headers={"accept": "text/csv"}
+    )
+    assert response.status_code == 200
+    assert "text/csv" in response.headers["content-type"]
+
+    # we accept csv or json (CSV should be returned)
+    response = app.get(
+        "/collections/public.landsat_wrs/items",
+        headers={"accept": "text/csv;q=1.0, application/json;q=0.4"},
+    )
+    assert response.status_code == 200
+    assert "text/csv" in response.headers["content-type"]
+
+    # the first preference is geo+json
+    response = app.get(
+        "/collections/public.landsat_wrs/items",
+        headers={"accept": "application/geo+json, text/csv;q=0.1"},
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/geo+json"
+
+    # geojsonseq output
+    response = app.get("/collections/public.landsat_wrs/items?f=geojsonseq")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/geo+json-seq"
+    body = response.text.splitlines()
+    assert len(body) == 10
+    assert json.loads(body[0])["type"] == "Feature"
+
+    response = app.get(
+        "/collections/public.landsat_wrs/items",
+        headers={"accept": "application/geo+json-seq"},
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/geo+json-seq"
+    body = response.text.splitlines()
+    assert len(body) == 10
+    assert json.loads(body[0])["type"] == "Feature"
+
+    # json output
+    response = app.get("/collections/public.landsat_wrs/items?f=json")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert len(body) == 10
+    feat = body[0]
+    assert [
+        "collectionId",
+        "itemId",
+        "id",
+        "pr",
+        "row",
+        "path",
+        "ogc_fid",
+        "geometry",
+    ] == list(feat.keys())
+
+    # json output no geometry
+    response = app.get("/collections/public.landsat_wrs/items?f=json&geom-column=none")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert len(body) == 10
+    feat = body[0]
+    assert "geometry" not in feat.keys()
+
+    response = app.get(
+        "/collections/public.landsat_wrs/items",
+        headers={"accept": "application/json"},
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/json"
+    body = response.json()
+    assert len(body) == 10
+
+    # ndjson output
+    response = app.get("/collections/public.landsat_wrs/items?f=ndjson")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/ndjson"
+    body = response.text.splitlines()
+    assert len(body) == 10
+    feat = json.loads(body[0])
+    assert [
+        "collectionId",
+        "itemId",
+        "id",
+        "pr",
+        "row",
+        "path",
+        "ogc_fid",
+        "geometry",
+    ] == list(feat.keys())
+
+    response = app.get(
+        "/collections/public.landsat_wrs/items",
+        headers={"accept": "application/ndjson"},
+    )
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "application/ndjson"
+    body = response.text.splitlines()
+    assert len(body) == 10

tifeatures/dbmodel.py

@@ -18,6 +18,9 @@ def json_type(self) -> str:
         """Return JSON field type."""
         pgtype = self.type
 
+        if pgtype.endswith("[]"):
+            return "array"
+
         if any(
             [
                 pgtype.startswith("int"),
@@ -30,9 +33,6 @@ def json_type(self) -> str:
         if pgtype.startswith("bool"):
             return "boolean"
 
-        if pgtype.endswith("[]"):
-            return "array"
-
         if any([pgtype.startswith("json"), pgtype.startswith("geo")]):
             return "object"
 

tifeatures/dependencies.py

@@ -10,7 +10,7 @@
 from tifeatures.errors import InvalidBBox
 from tifeatures.layer import CollectionLayer
 from tifeatures.layer import Table as TableLayer
-from tifeatures.resources.enums import AcceptType, FilterLang, ResponseType
+from tifeatures.resources import enums
 
 from fastapi import HTTPException, Path, Query
 
@@ -50,19 +50,115 @@ def CollectionParams(
     )
 
 
+def accept_media_type(
+    accept: str, mediatypes: List[enums.MediaType]
+) -> Optional[enums.MediaType]:
+    """Return MediaType based on accept header and available mediatype.
+
+    Links:
+    - https://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
+    - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept
+
+    """
+    accept_values = {}
+    for m in accept.replace(" ", "").split(","):
+        values = m.split(";")
+        if len(values) == 1:
+            name = values[0]
+            quality = 1.0
+        else:
+            name = values[0]
+            groups = dict([param.split("=") for param in values[1:]])  # type: ignore
+            try:
+                q = groups.get("q")
+                quality = float(q) if q else 1.0
+            except ValueError:
+                quality = 0
+
+        # if quality is 0 we ignore encoding
+        if quality:
+            accept_values[name] = quality
+
+    # Create Preference matrix
+    media_preference = {
+        v: [n for (n, q) in accept_values.items() if q == v]
+        for v in sorted({q for q in accept_values.values()}, reverse=True)
+    }
+
+    # Loop through available compression and encoding preference
+    for _, pref in media_preference.items():
+        for media in mediatypes:
+            if media.value in pref:
+                return media
+
+    # If no specified encoding is supported but "*" is accepted,
+    # take one of the available compressions.
+    if "*" in accept_values and mediatypes:
+        return mediatypes[0]
+
+    return None
+
+
 def OutputType(
     request: Request,
-    f: Optional[ResponseType] = Query(None, description="Response MediaType."),
-) -> Optional[ResponseType]:
-    """Output Response type."""
+    f: Optional[enums.ResponseType] = Query(
+        None,
+        description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header.",
+    ),
+) -> Optional[enums.MediaType]:
+    """Output MediaType: json or html."""
     if f:
-        return f
+        return enums.MediaType[f.name]
 
-    accept_header = request.headers.get("accept", "")
-    if accept_header in AcceptType.__members__.values():
-        return ResponseType[AcceptType(accept_header).name]
+    accepted_media = [enums.MediaType[v] for v in enums.ResponseType.__members__]
+    return accept_media_type(request.headers.get("accept", ""), accepted_media)
 
-    return None
+
+def QueryablesOutputType(
+    request: Request,
+    f: Optional[enums.QueryablesResponseType] = Query(
+        None,
+        description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header.",
+    ),
+) -> Optional[enums.MediaType]:
+    """Output MediaType: json or html."""
+    if f:
+        return enums.MediaType[f.name]
+
+    accepted_media = [
+        enums.MediaType[v] for v in enums.QueryablesResponseType.__members__
+    ]
+    return accept_media_type(request.headers.get("accept", ""), accepted_media)
+
+
+def ItemsOutputType(
+    request: Request,
+    f: Optional[enums.ItemsResponseType] = Query(
+        None,
+        description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header.",
+    ),
+) -> Optional[enums.MediaType]:
+    """Output MediaType: json or html."""
+    if f:
+        return enums.MediaType[f.name]
+
+    accepted_media = [enums.MediaType[v] for v in enums.ItemsResponseType.__members__]
+    return accept_media_type(request.headers.get("accept", ""), accepted_media)
+
+
+def ItemOutputType(
+    request: Request,
+    f: Optional[enums.ItemResponseType] = Query(
+        None,
+        description="Response MediaType. Defaults to endpoint's default or value defined in `accept` header.",
+    ),
+) -> Optional[enums.MediaType]:
+    """Output MediaType: json or html."""
+    if f:
+        return enums.MediaType[f.name]
+
+    accepted_media = [enums.MediaType[v] for v in enums.ItemResponseType.__members__]
+    return accept_media_type(request.headers.get("accept", ""), accepted_media)
 
 
 def bbox_query(
@@ -130,17 +226,18 @@ def properties_query(
 
 def filter_query(
     query: Optional[str] = Query(None, description="CQL2 Filter", alias="filter"),
-    filter_lang: Optional[FilterLang] = Query(
-        FilterLang.cql2_text,
-        description="CQL2 Language (cql2-text, cql2-json)",
+    filter_lang: Optional[enums.FilterLang] = Query(
+        None,
+        description="CQL2 Language (cql2-text, cql2-json). Defaults to cql2-text.",
         alias="filter-lang",
     ),
 ) -> Optional[AstType]:
     """Parse Filter Query."""
     if query is not None:
-        if filter_lang == FilterLang.cql2_json:
+        if filter_lang == enums.FilterLang.cql2_json:
             return cql2_json_parser(query)
-        else:
-            return cql2_text_parser(query)
+
+        # default to cql2-text
+        return cql2_text_parser(query)
 
     return None