Upload to_mongo_4326reproj.py

to_mongo_4326reproj.py

@@ -3,13 +3,13 @@ import json
 import os
 import random
 import uuid
-from collections.abc import MutableMapping
 from glob import glob
-from typing import AsyncGenerator
+from typing import AsyncGenerator, Optional
 
 import aiofiles
 import nest_asyncio
 from motor.motor_asyncio import AsyncIOMotorClient
+from motor.motor_tornado import MotorCollection
 from pymongo.server_api import ServerApi
 from pyproj import CRS, Proj, Transformer
 from pyproj.exceptions import CRSError
@@ -19,6 +19,25 @@ from shapely.geometry import Polygon
 nest_asyncio.apply()
 
 
+async def safe_insert_many(collection: MotorCollection, documents: list[dict]) -> None:
+    if len(documents) > 0:
+        try:
+            # Attempt to insert the documents
+            await collection.insert_many(documents)
+        except OverflowError:
+            # If an OverflowError occurs, split the batch
+            if len(documents) > 1:
+                mid = len(documents) // 2
+                # Recursively attempt to insert each half
+                await safe_insert_many(collection, documents[:mid])
+                await safe_insert_many(collection, documents[mid:])
+            else:
+                # Handle the case where a single document is too large
+                raise ValueError(
+                    "A document exceeds the maximum BSON size or dtype conflict.",
+                )
+
+
 def create_uuid(input_str: str) -> str:
     # Consistent random UUIDs based on input string
     # https://nathanielknight.ca/articles/consistent_random_uuids_in_python.html
@@ -28,7 +47,7 @@ def create_uuid(input_str: str) -> str:
     )
 
 
-async def reproject_to_4326_and_convert_to_geojson(
+def reproject_to_4326_and_convert_to_geojson(
     bbox: dict,
 ) -> dict:
     """
@@ -45,14 +64,14 @@ async def reproject_to_4326_and_convert_to_geojson(
     def get_src_proj() -> Proj:
         sr = bbox["spatialReference"]
         for wkid in ["latestWkid", "wkid"]:
-            if wkid in sr:
+            if (sr_wkid := sr.get(wkid)) is not None:
                 for authority in ["EPSG", "ESRI"]:
                     try:
-                        return Proj(f"{authority}:{sr[wkid]}")
+                        return Proj(f"{authority}:{sr_wkid}")
                     except CRSError:
                         pass
-        if "wkt" in sr:
-            return Proj(CRS.from_wkt(sr["wkt"]))
+        if (sr_wkt := sr.get("wkt")) is not None:
+            return Proj(CRS.from_wkt(sr_wkt))
         raise ValueError("no spatialReference found")
 
     src_proj = get_src_proj()
@@ -86,48 +105,37 @@ async def reproject_to_4326_and_convert_to_geojson(
     return geojson
 
 
-async def process_nested_entries_v2(
-    input_data: dict,
+keepkeys = {
+    "id",
+    "associatedlayers",
+    "domains",
+    "copyrighttext",
+    "description",
+    "documentinfo",
+    "fields",
+    "mapname",
+    "name",
+    "parentlayer",
+    "servicedescription",
+    "subLayers",
+    "tables",
+    "version",
+    "currentversion",
+    "geometrytype",
+    "extent",
+    "type",
+    "url",
+    "server",
+    "layers",
+    "service",
+}
+
+
+async def process_metadata(
+    metadata: dict,
+    additional_fields: Optional[dict] = None,
 ) -> 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:
+    additional_fields = additional_fields or {}
     # Process metadata and add any additional fields
     processed_md = {
         k: v for k, v in metadata.items() if k not in ["folders", "services", "layers"]
@@ -137,6 +145,17 @@ def process_metadata(metadata: dict, additional_fields: dict = {}) -> dict:
     processed_md["id"] = processed_md["hash"]
     del processed_md["hash"]
 
+    processed_md = {k: v for k, v in processed_md.items() if k in keepkeys}
+
+    if (
+        (extent := processed_md.get("extent")) is not None
+        and extent.get("spatialReference") is not None
+        and not any(str(v).lower() in {"nan", "none", "null"} for v in extent.values())
+    ):
+        try:
+            processed_md["extent"] = reproject_to_4326_and_convert_to_geojson(extent)
+        except (ValueError, GEOSException, CRSError) as e:
+            print(extent, e)
     return processed_md
 
 
@@ -144,7 +163,7 @@ def get_type(layer: dict) -> str:
     return layer.get("type", "unknown").lower().replace(" ", "_").strip()
 
 
-async def read_data(jsonfiles: list[str]) -> AsyncGenerator:
+async def read_data(jsonfiles: list[str]) -> AsyncGenerator[dict, None]:
     # Async generator to yield file content one by one
     for f in jsonfiles:
         async with aiofiles.open(f, "r") as infile:
@@ -152,10 +171,10 @@ async def read_data(jsonfiles: list[str]) -> AsyncGenerator:
             yield json.loads(content)
 
 
-async def process_server(server, services_collection, db):
+# Modified process_server function
+async def process_server(server: dict, layers_collection: MotorCollection):
     server_services = server.pop("services")
-    server = await process_nested_entries_v2(server)
-    server_md = process_metadata(
+    server_md = await process_metadata(
         server["metadata"],
         {
             "url": server["metadata"]["url"],
@@ -163,14 +182,9 @@ async def process_server(server, services_collection, db):
         },
     )
 
-    services_to_insert = []
-    layer_insert_tasks = []
-
+    layer_tasks = []
     for service in server_services:
-        service_layers = service["metadata"].pop("layers")
-        service = await process_nested_entries_v2(service)
-
-        service_md = process_metadata(
+        service_md = await process_metadata(
             service["metadata"],
             {
                 "url": service["url"],
@@ -178,70 +192,43 @@ async def process_server(server, services_collection, db):
                 "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)
-
-        async def insert_layer(lyr_type: str, lyrs: list[dict]) -> None:
-            if len(lyrs) > 0:
-                try:
-                    await db[lyr_type].insert_many(lyrs)
-                except OverflowError:
-                    for layer in lyrs:
-                        try:
-                            await db[lyr_type].insert_one(layer)
-                        except OverflowError:
-                            for c in ["drawingInfo", "classBreakInfos"]:
-                                if c in layer:
-                                    del layer[c]
-                            await db[lyr_type].insert_one(layer)
-
-        for layer_type, layers in layer_dict.items():
-            if layers:
-                layer_insert_tasks.append(
-                    insert_layer(lyr_type=layer_type, lyrs=layers),
-                )
+        for layer in service["metadata"].pop("layers"):
+            task = asyncio.create_task(process_layer(layer, service_md))
+            layer_tasks.append(task)
 
-    # Insert services in batch
-    if services_to_insert:
-        await services_collection.insert_many(services_to_insert)
+    layers_md = await asyncio.gather(*layer_tasks)
+    await safe_insert_many(layers_collection, layers_md)
 
-    # Wait for all layer insert tasks to complete
-    await asyncio.gather(*layer_insert_tasks)
+
+# Modified process_layer function
+async def process_layer(layer: dict, service: dict) -> dict:
+    # Embed service metadata into layer
+    layer_md = await process_metadata(
+        layer,
+        {
+            "url": layer["url"],
+            "hash": create_uuid(layer["url"]),
+            "service": {**service},
+        },
+    )
+    return layer_md
 
 
 async def main() -> None:
-    output_dir = os.path.abspath("./output_tryagain")
+    output_dir = os.path.abspath("/home/appuser/restgdf_api/lab/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
+    layers = db.layers
 
     # Process each server concurrently
     async for server in read_data(jsonfiles):
-        await process_server(server, services_collection, db)
+        await process_server(server, layers)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())