Upload to_mongo_4326reproj.py

to_mongo_4326reproj.py

@@ -0,0 +1,231 @@
+import asyncio
+import json
+import os
+import random
+import uuid
+from collections.abc import MutableMapping
+from glob import glob
+from typing import AsyncGenerator
+
+import aiofiles
+import nest_asyncio
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo.server_api import ServerApi
+from pyproj import CRS, Proj, Transformer
+from pyproj.exceptions import CRSError
+from shapely.errors import GEOSException
+from shapely.geometry import Polygon
+
+nest_asyncio.apply()
+
+
+def create_uuid(input_str: str) -> str:
+    # Consistent random UUIDs based on input string
+    # https://nathanielknight.ca/articles/consistent_random_uuids_in_python.html
+    random.seed(input_str)
+    return str(
+        uuid.UUID(bytes=bytes(random.getrandbits(8) for _ in range(16)), version=4),
+    )
+
+
+async def reproject_to_4326_and_convert_to_geojson(
+    bbox: dict,
+) -> dict:
+    """
+    Reprojects a bounding box from EPSG:102100 (3857) to EPSG:4326 and converts it to GeoJSON.
+
+    Parameters:
+    bbox (dict): A dictionary containing the keys 'xmin', 'ymin', 'xmax', 'ymax', and 'spatialReference'.
+
+    Returns:
+    dict: A GeoJSON object representing the reprojected bounding box.
+    """
+
+    # Define the source and destination coordinate systems
+    def get_src_proj() -> Proj:
+        sr = bbox["spatialReference"]
+        for wkid in ["latestWkid", "wkid"]:
+            if wkid in sr:
+                for authority in ["EPSG", "ESRI"]:
+                    try:
+                        return Proj(f"{authority}:{sr[wkid]}")
+                    except CRSError:
+                        pass
+        if "wkt" in sr:
+            return Proj(CRS.from_wkt(sr["wkt"]))
+        raise ValueError("no spatialReference found")
+
+    src_proj = get_src_proj()
+    dst_proj = Proj("epsg:4326")
+    transformer = Transformer.from_proj(src_proj, dst_proj)
+
+    # Extract coordinates
+    xmin, ymin, xmax, ymax = bbox["xmin"], bbox["ymin"], bbox["xmax"], bbox["ymax"]
+
+    # Transform the coordinates
+    xmin_trans, ymin_trans = transformer.transform(xmin, ymin)
+    xmax_trans, ymax_trans = transformer.transform(xmax, ymax)
+
+    # Create a polygon from the transformed coordinates
+    # Ensure that the polygon is closed by repeating the first point at the end
+    polygon = Polygon(
+        [
+            (xmin_trans, ymin_trans),
+            (xmax_trans, ymin_trans),
+            (xmax_trans, ymax_trans),
+            (xmin_trans, ymax_trans),
+            (xmin_trans, ymin_trans),
+        ],
+    )
+    # Convert the polygon to GeoJSON format
+    geojson = {
+        "type": "Polygon",
+        "coordinates": [list(polygon.exterior.coords)],
+    }
+
+    return geojson
+
+
+async def process_nested_entries_v2(
+    input_data: dict,
+) -> dict:
+    required_keys = {"xmin", "ymin", "xmax", "ymax", "spatialReference"}
+
+    if not isinstance(input_data, (dict, list)):
+        raise ValueError("Input data must be a dictionary or list")
+
+    stack = [(None, input_data, None)]  # (parent, current, key/index)
+
+    while stack:
+        parent, current, key = stack.pop()
+
+        if (
+            isinstance(current, dict)
+            and required_keys.issubset(current.keys())
+            and not any(
+                str(current.get(coord, "nan")).lower() == "nan"
+                for coord in ["xmin", "ymin", "xmax", "ymax"]
+            )
+        ):
+            try:
+                result = await reproject_to_4326_and_convert_to_geojson(current)
+            except (ValueError, GEOSException, CRSError) as e:
+                print(current, e)
+                result = current  # Optionally keep the original item on error
+            if parent is not None:
+                if isinstance(parent, MutableMapping):
+                    parent[key] = result
+                else:  # List
+                    parent[key] = result
+        elif isinstance(current, MutableMapping):
+            for k, v in current.items():
+                stack.append((current, v, k))  # type: ignore
+        elif isinstance(current, list):
+            for i, item in enumerate(current):
+                stack.append((current, item, i))
+
+    return input_data
+
+
+def process_metadata(metadata: dict, additional_fields: dict = {}) -> dict:
+    # Process metadata and add any additional fields
+    processed_md = {
+        k: v for k, v in metadata.items() if k not in ["folders", "services", "layers"]
+    }
+    processed_md.update(additional_fields)
+    processed_md["original_id"] = processed_md.get("id", None)
+    processed_md["id"] = processed_md["hash"]
+    del processed_md["hash"]
+
+    return processed_md
+
+
+def get_type(layer: dict) -> str:
+    return layer.get("type", "unknown").lower().replace(" ", "_").strip()
+
+
+async def read_data(jsonfiles: list[str]) -> AsyncGenerator:
+    # Async generator to yield file content one by one
+    for f in jsonfiles:
+        async with aiofiles.open(f, "r") as infile:
+            content = await infile.read()
+            yield json.loads(content)
+
+
+async def process_server(server, services_collection, db):
+    server_services = server.pop("services")
+    server = await process_nested_entries_v2(server)
+    server_md = process_metadata(
+        server["metadata"],
+        {
+            "url": server["metadata"]["url"],
+            "hash": create_uuid(server["metadata"]["url"]),
+        },
+    )
+
+    services_to_insert = []
+    layer_insert_tasks = []
+
+    for service in server_services:
+        service_layers = service["metadata"].pop("layers")
+        service = await process_nested_entries_v2(service)
+
+        service_md = process_metadata(
+            service["metadata"],
+            {
+                "url": service["url"],
+                "hash": create_uuid(service["url"]),
+                "server": server_md,
+            },
+        )
+        service_md["layers"] = []
+
+        layer_dict = {}
+
+        for layer in service_layers:
+            layer = await process_nested_entries_v2(layer)
+            layer_md = process_metadata(
+                layer,
+                {
+                    "url": layer["url"],
+                    "hash": create_uuid(layer["url"]),
+                    "service": service_md["id"],
+                },
+            )
+            layer_type = get_type(layer)
+            service_md["layers"].append(
+                dict(type=layer_type, layer_id=layer_md["id"]),
+            )
+            if layer_type not in layer_dict:
+                layer_dict[layer_type] = []
+            layer_dict[layer_type].append(layer_md)
+
+        services_to_insert.append(service_md)
+
+        for layer_type, layers in layer_dict.items():
+            if layers:
+                layer_insert_tasks.append(db[layer_type].insert_many(layers))
+
+    # Insert services in batch
+    if services_to_insert:
+        await services_collection.insert_many(services_to_insert)
+
+    # Wait for all layer insert tasks to complete
+    await asyncio.gather(*layer_insert_tasks)
+
+
+async def main() -> None:
+    output_dir = os.path.abspath("./output_tryagain")
+    jsonfiles = glob(os.path.join(output_dir, "*.json"))
+
+    client = AsyncIOMotorClient(
+        r"mongodb://root:example@mongo:27017/",
+        server_api=ServerApi("1"),
+    )
+
+    db = client["govgis-nov2023"]
+    services_collection = db.services
+
+    # Process each server concurrently
+    async for server in read_data(jsonfiles):
+        await process_server(server, services_collection, db)