udata-hydra-csvapi 0.3.2.dev9__py3-none-any.whl → 0.3.2.dev10__py3-none-any.whl

api_tabular/config_default.toml

@@ -7,7 +7,8 @@ PAGE_SIZE_DEFAULT = 20
 PAGE_SIZE_MAX = 50
 BATCH_SIZE = 50000
 DOC_PATH = "/api/doc"
-ALLOW_AGGREGATION = [
+ALLOW_AGGREGATION = false
+ALLOW_AGGREGATION_EXCEPTIONS = [
     "dddddddd-7777-eeee-8888-ffffffffffff",  # without indexes
     "aaaaaaaa-9999-bbbb-1010-cccccccccccc",  # with indexes
 ]  # list of resource_ids

api_tabular/core/cors.py

@@ -0,0 +1,24 @@
+from aiohttp import web
+
+
+@web.middleware
+async def cors_middleware(request, handler):
+    """
+    Middleware to handle CORS and the OPTIONS preflight.
+    """
+    if request.method == "OPTIONS":
+        # Handle cases of preflight OPTIONS requests (was managed by aiohttp_cors before)
+        response = web.Response(status=204)
+    else:
+        response = await handler(request)
+
+    # Add CORS headers to the response
+    # Using "*" ensures the Nginx cache remains consistent for all origins
+    response.headers["Access-Control-Allow-Origin"] = "*"
+    response.headers["Access-Control-Allow-Methods"] = "GET, OPTIONS"
+    response.headers["Access-Control-Allow-Headers"] = (
+        "Content-Type, Authorization, X-Requested-With"
+    )
+    response.headers["Access-Control-Expose-Headers"] = "*"
+
+    return response

api_tabular/core/health.py

@@ -1,5 +1,3 @@
-from datetime import datetime, timezone
-
 from aiohttp import web
 from aiohttp.web_request import Request
 
@@ -15,9 +13,10 @@ async def check_health(request: Request, url: str):
                 "DB unavailable",
                 "postgREST has not started yet",
             )
-    start_time = request.app["start_time"]
-    current_time = datetime.now(timezone.utc)
-    uptime_seconds = (current_time - start_time).total_seconds()
     return web.json_response(
-        {"status": "ok", "version": request.app["app_version"], "uptime_seconds": uptime_seconds}
+        {
+            "status": "ok",
+            "version": request.app["app_version"],
+            "uptime_since": request.app["started_at"].isoformat(),
+        }
     )

api_tabular/core/query.py

@@ -1,3 +1,4 @@
+import re
 from collections import defaultdict
 
 from api_tabular.core.utils import is_aggregation_allowed
@@ -14,6 +15,10 @@ def build_sql_query_string(
     aggregators = defaultdict(list)
     sorted = False
     for arg in request_arg:
+        if arg.startswith("or=("):
+            # top level "and=(...)" should not happen
+            sql_query.append(parse_operator(query=arg, operator="or", top_level=True))
+            continue
         _split = arg.split("=")
         # filters are expected to have the syntax `<column_name>__<operator>=<value>`
         if len(_split) == 2:
@@ -72,39 +77,52 @@ def get_column_and_operator(argument: str) -> tuple[str, str]:
     return column, normalized_comparator
 
 
-def add_filter(argument: str, value: str | None) -> tuple[str | None, bool]:
+def add_filter(
+    argument: str,
+    value: str | None,
+    *,
+    in_operator: bool = False,
+) -> tuple[str | None, bool]:
     if argument in ["page", "page_size"]:  # processed differently
+        if in_operator:
+            raise ValueError(f"Argument `{argument}` can't be set within an operator")
         return None, False
     if argument == "columns":
+        if in_operator:
+            raise ValueError(f"Argument `{argument}` can't be set within an operator")
         return f"select={value}", False
     if "__" in argument:
         column, normalized_comparator = get_column_and_operator(argument)
+        # when encapsulated in an OR statement, the syntax is `col.eq.val` instead of `col=eq.val`
+        op = "." if in_operator else "="
         if normalized_comparator == "sort":
+            if in_operator:
+                raise ValueError(f"Argument `{argument}` can't be set within an operator")
             return f"order={column}.{value}", True
         elif normalized_comparator == "exact":
-            return f"{column}=eq.{value}", False
+            return f"{column}{op}eq.{value}", False
         elif normalized_comparator == "differs":
-            return f"{column}=isdistinct.{value}", False
+            return f"{column}{op}isdistinct.{value}", False
         elif normalized_comparator == "isnull":
-            return f"{column}=is.null", False
+            return f"{column}{op}is.null", False
         elif normalized_comparator == "isnotnull":
-            return f"{column}=not.is.null", False
+            return f"{column}{op}not.is.null", False
         elif normalized_comparator == "contains":
-            return f"{column}=ilike.*{value}*", False
+            return f"{column}{op}ilike.*{value}*", False
         elif normalized_comparator == "notcontains":
-            return f"{column}=not.ilike.*{value}*", False
+            return f"{column}{op}not.ilike.*{value}*", False
         elif normalized_comparator == "in":
-            return f"{column}=in.({value})", False
+            return f"{column}{op}in.({value})", False
         elif normalized_comparator == "notin":
-            return f"{column}=not.in.({value})", False
+            return f"{column}{op}not.in.({value})", False
         elif normalized_comparator == "less":
-            return f"{column}=lte.{value}", False
+            return f"{column}{op}lte.{value}", False
         elif normalized_comparator == "greater":
-            return f"{column}=gte.{value}", False
+            return f"{column}{op}gte.{value}", False
         elif normalized_comparator == "strictly_less":
-            return f"{column}=lt.{value}", False
+            return f"{column}{op}lt.{value}", False
         elif normalized_comparator == "strictly_greater":
-            return f"{column}=gt.{value}", False
+            return f"{column}{op}gt.{value}", False
     raise ValueError(f"argument '{argument}={value}' could not be parsed")
 
 
@@ -118,6 +136,91 @@ def add_aggregator(argument: str, indexes: set | None) -> tuple[str, str]:
     raise ValueError(f"argument '{argument}' could not be parsed")
 
 
+def split_top_level(s: str) -> list[str]:
+    # we can't .split(",") as there may be commas within the params (if nested)
+    # so we need a custom "split by ',' if ',' not within parentheses"
+    parts = []
+    current = ""
+    depth = 0
+    for char in s:
+        if char == "(":
+            depth += 1
+            current += char
+        elif char == ")":
+            depth -= 1
+            current += char
+        elif char == "," and depth == 0:
+            parts.append(current)
+            current = ""
+        else:
+            current += char
+    if current:
+        parts.append(current)
+    return parts
+
+
+def find_arg_val(param: str) -> tuple[str, str]:
+    if param.count('"') not in {0, 2, 4}:
+        raise ValueError(f"argument '{param}' could not be parsed")
+    column_operator_pattern = r'^"[^"]*"__[a-z]+'
+    value_pattern = r'\."[^"]*"$'
+    if param.count('"') == 0:
+        # no quote, we expect col__op.val
+        _split = param.split(".")
+        if len(_split) != 2:
+            raise ValueError(f"argument '{param}' could not be parsed")
+        return tuple[str, str](_split)  # ty: ignore[invalid-argument-type]
+    elif param.count('"') == 4:
+        # 4 quotes, we expect "col.umn"__op."val.ue"
+        col_op = re.findall(column_operator_pattern, param)
+        val = re.findall(value_pattern, param)
+        if len(col_op) != 1 or len(val) != 1:
+            raise ValueError(f"argument '{param}' could not be parsed")
+        # we drop the double quotes around the column as they will be added back in get_column_and_operator
+        # the dot is included in the value result, we pop it in the result
+        return col_op[0].replace('"', ""), val[0][1:]
+    else:
+        # we have any of "col.umn"__op.val, col__op."val.ue"
+        col_op = re.findall(column_operator_pattern, param)
+        val = re.findall(value_pattern, param)
+        if not col_op:
+            # case col__op."val.ue"
+            return param.split(".")[0], val[0][1:]
+        else:
+            # case "col.umn"__op.val
+            return col_op[0].replace('"', ""), param.split(".")[-1]
+
+
+def parse_operator(query: str, operator: str, top_level: bool = False):
+    # only the top level operator has an "=", nested operators are "or(...)" and "and(...)"
+    if not query.endswith(")"):
+        raise ValueError(f"argument '{query}' could not be parsed")
+    postgrest_params = []
+    # we can safely assume that there will be one result for the regex
+    params = split_top_level(
+        re.findall(rf"^{operator}{'=' if top_level else ''}\((.*)\)$", query)[0]
+    )
+    for param in params:
+        if param.startswith(("and(", "or(")):
+            # recursively adding the nested conditions
+            postgrest_params.append(parse_operator(query=param, operator=param.split("(")[0]))
+        else:
+            if param.endswith(("__isnull", "__isnotnull")):
+                postgrest_params.append(
+                    add_filter(
+                        param.replace('"', ""),
+                        None,
+                        in_operator=True,
+                    )[0]
+                )
+            else:
+                # if a special character is in the column name and/or value, the problematic item should be encapsulated in double quotes
+                # so we have 4 possibles cases: col__op.val, "col.umn"__op.val, col__op."val.ue" and "col.umn"__op."val.ue"
+                argument, value = find_arg_val(param)
+                postgrest_params.append(add_filter(argument, value, in_operator=True)[0])
+    return f"{operator}{'=' if top_level else ''}({','.join(postgrest_params)})"
+
+
 def raise_if_not_index(column_name: str, indexes: set | None) -> None:
     if indexes is None:
         return

api_tabular/core/swagger.py

@@ -188,6 +188,13 @@ def swagger_parameters(resource_columns: dict, resource_id: str) -> list:
             "style": "form",
             "explode": False,
         },
+        {
+            "name": "or",
+            "in": "query",
+            "description": "Encapsulates filters to be joined with the `OR` operator. Allows to build complex queries with nested `or(...)` and `and(...)` operators. Inner filters syntax must be `<column>.<operation>.<value>` (or `<column>.<operation>` for `is(not)null`), separated with commas.",
+            "required": False,
+            "schema": {"type": "string"},
+        },
     ]
     # expected python types are: string, float, int, bool, date, datetime, json
     # see cast for db here: https://github.com/datagouv/csv-detective/blob/master/csv_detective/output/dataframe.py

api_tabular/core/utils.py

@@ -6,7 +6,7 @@ from api_tabular.core.error import QueryException
 
 
 def is_aggregation_allowed(resource_id: str) -> bool:
-    return resource_id in config.ALLOW_AGGREGATION
+    return config.ALLOW_AGGREGATION or resource_id in config.ALLOW_AGGREGATION_EXCEPTIONS
 
 
 def process_total(res: Response | ClientResponse) -> int:

api_tabular/metrics/app.py

@@ -1,13 +1,13 @@
 import os
 from datetime import datetime, timezone
 
-import aiohttp_cors
 import sentry_sdk
 import yaml
 from aiohttp import ClientSession, web
 from aiohttp_swagger import setup_swagger
 
 from api_tabular import config
+from api_tabular.core.cors import cors_middleware
 from api_tabular.core.data import stream_data
 from api_tabular.core.error import QueryException, handle_exception
 from api_tabular.core.health import check_health
@@ -99,7 +99,7 @@ async def get_health(request):
 async def app_factory():
     async def on_startup(app):
         app["csession"] = ClientSession()
-        app["start_time"] = datetime.now(timezone.utc)
+        app["started_at"] = datetime.now(timezone.utc)
         app["app_version"] = await get_app_version()
 
         with open("metrics_swagger.yaml", "r") as f:
@@ -111,22 +111,11 @@ async def app_factory():
     async def on_cleanup(app):
         await app["csession"].close()
 
-    app = web.Application()
+    app = web.Application(middlewares=[cors_middleware])
     app.add_routes(routes)
     app.on_startup.append(on_startup)
     app.on_cleanup.append(on_cleanup)
 
-    cors = aiohttp_cors.setup(
-        app,
-        defaults={
-            "*": aiohttp_cors.ResourceOptions(
-                allow_credentials=True, expose_headers="*", allow_headers="*"
-            )
-        },
-    )
-    for route in list(app.router.routes()):
-        cors.add(route)
-
     return app
 
 

api_tabular/tabular/app.py

@@ -1,13 +1,13 @@
 import os
 from datetime import datetime, timezone
 
-import aiohttp_cors
 import sentry_sdk
 import yaml
 from aiohttp import ClientSession, web
 from aiohttp_swagger import setup_swagger
 
 from api_tabular import config
+from api_tabular.core.cors import cors_middleware
 from api_tabular.core.health import check_health
 from api_tabular.core.sentry import get_sentry_kwargs
 from api_tabular.core.swagger import build_swagger_file
@@ -149,13 +149,17 @@ async def get_health(request):
 @routes.get(r"/api/aggregation-exceptions/")
 async def get_aggregation_exceptions(request):
     """Return the list of resources for which aggregation queries are allowed"""
-    return web.json_response(config.ALLOW_AGGREGATION)
+    body = {
+        "allowed": config.ALLOW_AGGREGATION,
+        "exceptions": config.ALLOW_AGGREGATION_EXCEPTIONS,
+    }
+    return web.json_response(body)
 
 
 async def app_factory():
     async def on_startup(app):
         app["csession"] = ClientSession()
-        app["start_time"] = datetime.now(timezone.utc)
+        app["started_at"] = datetime.now(timezone.utc)
         app["app_version"] = await get_app_version()
 
         with open("tabular_swagger.yaml", "r") as f:
@@ -172,22 +176,11 @@ async def app_factory():
     async def on_cleanup(app):
         await app["csession"].close()
 
-    app = web.Application()
+    app = web.Application(middlewares=[cors_middleware])
     app.add_routes(routes)
     app.on_startup.append(on_startup)
     app.on_cleanup.append(on_cleanup)
 
-    cors = aiohttp_cors.setup(
-        app,
-        defaults={
-            "*": aiohttp_cors.ResourceOptions(
-                allow_credentials=True, expose_headers="*", allow_headers="*"
-            )
-        },
-    )
-    for route in list(app.router.routes()):
-        cors.add(route)
-
     return app
 
 

{udata_hydra_csvapi-0.3.2.dev9.dist-info → udata_hydra_csvapi-0.3.2.dev10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: udata-hydra-csvapi
-Version: 0.3.2.dev9
+Version: 0.3.2.dev10
 Summary: API for CSV converted by udata-hydra
 Author-email: "data.gouv.fr" <opendatateam@data.gouv.fr>
 License-Expression: MIT
@@ -8,7 +8,6 @@ Requires-Python: <3.14,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp<4.0.0,>=3.13.3
-Requires-Dist: aiohttp-cors<1.0.0,>=0.8.1
 Requires-Dist: aiohttp-swagger<2.0.0,>=1.0.16
 Requires-Dist: gunicorn<24.0.0,>=23.0.0
 Requires-Dist: sentry-sdk<3.0.0,>=2.49.0
@@ -323,7 +322,9 @@ column_name__sort=desc
 ```
 
 #### Aggregation Operators
-> ⚠️ **WARNING**: Aggregation requests are only available for resources that are listed in the `ALLOW_AGGREGATION` list of the config file, which can be seen at the `/api/aggregation-exceptions/` endpoint, and on columns that have an index.
+> ⚠️ **WARNING**: Aggregation requests are disabled by default.
+> You can allow or disallow it for all resources with the `ALLOW_AGGREGATION` config. If `ALLOW_AGGREGATION` is set to `false`, you can specify allow exceptions by listing these in the `ALLOW_AGGREGATION_EXCEPTIONS` list.
+> You can get the current status and exceptions at `/api/aggregation-exceptions/` endpoint.
 
 ```
 # group by values
@@ -403,6 +404,22 @@ curl http://localhost:8005/api/resources/aaaaaaaa-1111-bbbb-2222-cccccccccccc/da
   }
 }
 ```
+Top level parameters are considered joined with the `AND` operator. It is possible to add nested conditions with the following syntax:
+```
+or=(<column1>__<operator1>.<value1>,<column2>__<operator2>.<value2>,...)
+```
+> **Note**: the conditions within an `OR` have a `.` instead of a `=` between the operator and the value.
+
+> **Note**: the syntax for `isnull` and `isnotnull` is `<column1>__is(not)null` (no value is needed, like outisde of `OR` groups)
+
+This scales as much as needed, but the inner operators should be `or(...)` and `and(...)` (without the `=`), like:
+```
+decompte__less=10&or=(is_true__exact.true,birth__greater.1980,and(score__strictly_less.5,liste__isnotnull,or(...)))
+```
+> **Note**: if the column name and/or the value of the filter contains special characters (including dots), the item should be wrapped within double quotes:
+```
+or=("is true"__exact.true,and(score__strictly_less."0.1","avg.views"__greater."15.5"))
+```
 
 #### Aggregation with Filtering
 With filters and aggregators (filtering is always done **before** aggregation, no matter the order in the parameters):
@@ -479,7 +496,8 @@ Configuration is handled through TOML files and environment variables. The defau
 | `PAGE_SIZE_MAX` | `50` | Maximum allowed page size |
 | `BATCH_SIZE` | `50000` | Batch size for streaming |
 | `DOC_PATH` | `/api/doc` | Swagger documentation path |
-| `ALLOW_AGGREGATION` | `["dddddddd-7777-eeee-8888-ffffffffffff", "aaaaaaaa-9999-bbbb-1010-cccccccccccc"]` | List of resource IDs allowed for aggregation |
+| `ALLOW_AGGREGATION` | `False` | Whether aggregation queries are allowed (`column__groupby`). If False, it can still be explicitly allowed with `ALLOW_AGGREGATION_EXCEPTIONS` |
+| `ALLOW_AGGREGATION_EXCEPTIONS` | `["dddddddd-7777-eeee-8888-ffffffffffff", "aaaaaaaa-9999-bbbb-1010-cccccccccccc"]` | List of resource IDs allowed for aggregation |
 
 ### Environment Variables
 

udata_hydra_csvapi-0.3.2.dev10.dist-info/RECORD

@@ -0,0 +1,23 @@
+api_tabular/__init__.py,sha256=sYG6CMz-twob-QLyfsPYRc6cWDtqWXvq_N5Dxk-U5qA,2263
+api_tabular/config_default.toml,sha256=cX506NdqHW7gK_2aZjzLiz0Z4gMSl1tU_tI4i4BvuXs,421
+api_tabular/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api_tabular/core/cors.py,sha256=QY006pAnR1fMBMJJTAeRGcopL_4LkY7YoA3y8KYk4dI,825
+api_tabular/core/data.py,sha256=5j-3d_el7LMoHpn6V__UdhYHD6GiJbwdH67jrnOYWZQ,1459
+api_tabular/core/error.py,sha256=xRt6fkQfsiupv0tWWzdX0DJjAKbw1n0tRxFyt15VBLA,1062
+api_tabular/core/health.py,sha256=NeFT1C00onvm3CbgesFAcN1N8bmelbQdEYFbmmftICQ,647
+api_tabular/core/query.py,sha256=aI_lqb7LGAC-EQUVfP-q90KxcWFkDTuKmW8I7yCTvO4,10067
+api_tabular/core/sentry.py,sha256=fN5MrDZszLnzLXF3b_nUymPVB0ffNn4PI7xS1GtJNyE,948
+api_tabular/core/swagger.py,sha256=eSCAu0TQsT2tlQiW7i-ueZB14qTd8TfHbUypZeeB-0w,14640
+api_tabular/core/url.py,sha256=af7VKfrMtKMzlHrGgtLDLuRBim4qFv7xlt2PYxAyW2g,761
+api_tabular/core/utils.py,sha256=VTxPiNWE3FF6f2aX5Q21XPezCL3sVZ_KICIrGBJRm_E,1071
+api_tabular/core/version.py,sha256=OKLg0l1CpDRHV2hsqVgtSihoo3tg0aMG6kzMILtQ-bY,250
+api_tabular/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api_tabular/metrics/app.py,sha256=JY7GZSqCsihEcQy7SFTiKqvoyxfGRFaJ48CovNQTq4Y,4408
+api_tabular/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+api_tabular/tabular/app.py,sha256=tbf1Ni_r_bbeivxlMNllVKRoqpajZId6SiurCn1hTas,6645
+api_tabular/tabular/utils.py,sha256=BL2nl04-3imBQG-RZiYvVMjxoBORi4lwrKq8NiWecLY,4487
+udata_hydra_csvapi-0.3.2.dev10.dist-info/licenses/LICENSE,sha256=fb-HAYw94ffh--z1cZrWbpk6YKM0p9WFG7kdd0K7uGQ,1062
+udata_hydra_csvapi-0.3.2.dev10.dist-info/METADATA,sha256=TdT5xw8FivU386X-NZPhMeoiosJCaj1JfGj7JJc-TZw,20386
+udata_hydra_csvapi-0.3.2.dev10.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+udata_hydra_csvapi-0.3.2.dev10.dist-info/top_level.txt,sha256=MAaK09hxwPhIBBC0i1TdEBAgdu3W_gXnAZqk767gVak,12
+udata_hydra_csvapi-0.3.2.dev10.dist-info/RECORD,,

udata_hydra_csvapi-0.3.2.dev9.dist-info/RECORD

@@ -1,22 +0,0 @@
-api_tabular/__init__.py,sha256=sYG6CMz-twob-QLyfsPYRc6cWDtqWXvq_N5Dxk-U5qA,2263
-api_tabular/config_default.toml,sha256=3zQMpzr87qwd23dG_scGUptj0T3IUOjaHecI4ppJBqY,384
-api_tabular/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-api_tabular/core/data.py,sha256=5j-3d_el7LMoHpn6V__UdhYHD6GiJbwdH67jrnOYWZQ,1459
-api_tabular/core/error.py,sha256=xRt6fkQfsiupv0tWWzdX0DJjAKbw1n0tRxFyt15VBLA,1062
-api_tabular/core/health.py,sha256=5VAgsu2t1Ave9n3YduzM3E7aUflBJ3pY1LUrrjT-d6w,775
-api_tabular/core/query.py,sha256=m98cO16mVkz0cSNICesgjC8MNVEfDW_645sz-DTd2Pw,5576
-api_tabular/core/sentry.py,sha256=fN5MrDZszLnzLXF3b_nUymPVB0ffNn4PI7xS1GtJNyE,948
-api_tabular/core/swagger.py,sha256=0RZFu941CD3qWt2R6e3nnlcrkYjjAHU5eOFl4jH2liA,14188
-api_tabular/core/url.py,sha256=af7VKfrMtKMzlHrGgtLDLuRBim4qFv7xlt2PYxAyW2g,761
-api_tabular/core/utils.py,sha256=SWU1gVkOq728-eZHmZzlyA3pQg6kelEf3SMlL-uEbns,1032
-api_tabular/core/version.py,sha256=OKLg0l1CpDRHV2hsqVgtSihoo3tg0aMG6kzMILtQ-bY,250
-api_tabular/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-api_tabular/metrics/app.py,sha256=5kZXzAiFh1tSNYO5GEz67m4zTsTVyoIkgcelDGyT1zE,4637
-api_tabular/tabular/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-api_tabular/tabular/app.py,sha256=JgqL1svglQ_fD5ndhft_Cm7HmTh5FuyoxYUPGS1_l-o,6771
-api_tabular/tabular/utils.py,sha256=BL2nl04-3imBQG-RZiYvVMjxoBORi4lwrKq8NiWecLY,4487
-udata_hydra_csvapi-0.3.2.dev9.dist-info/licenses/LICENSE,sha256=fb-HAYw94ffh--z1cZrWbpk6YKM0p9WFG7kdd0K7uGQ,1062
-udata_hydra_csvapi-0.3.2.dev9.dist-info/METADATA,sha256=70xGNtnDPIZYktyfsrYw4bhn6SDDBASB6jUQCgpHRrk,19156
-udata_hydra_csvapi-0.3.2.dev9.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-udata_hydra_csvapi-0.3.2.dev9.dist-info/top_level.txt,sha256=MAaK09hxwPhIBBC0i1TdEBAgdu3W_gXnAZqk767gVak,12
-udata_hydra_csvapi-0.3.2.dev9.dist-info/RECORD,,