Move extension replacement to ElasticPath.

Author: rhysrevans3

stac_fastapi/core/stac_fastapi/core/models/patch.py

@@ -1,9 +1,62 @@
 """patch helpers."""
 
-from typing import Any, Optional, Union
+import re
+from typing import Any, Dict, Optional, Union
 
 from pydantic import BaseModel, computed_field, model_validator
 
+regex = re.compile(r"([^.' ]*:[^.' ]*)\.?")
+
+
+class ESCommandSet:
+    """Uses dictionary keys to behaviour of ordered set.
+
+    Yields:
+        str: Elasticsearch commands
+    """
+
+    dict_: Dict[str, None] = {}
+
+    def add(self, value: str):
+        """Add command.
+
+        Args:
+            value (str): value to be added
+        """
+        self.dict_[value] = None
+
+    def remove(self, value: str):
+        """Remove command.
+
+        Args:
+            value (str): value to be removed
+        """
+        del self.dict_[value]
+
+    def __iter__(self):
+        """Iterate Elasticsearch commands.
+
+        Yields:
+            str: Elasticsearch command
+        """
+        yield from self.dict_.keys()
+
+
+def to_es(string: str):
+    """Convert patch operation key to Elasticsearch key.
+
+    Args:
+        string (str): string to be converted
+
+    Returns:
+        _type_: converted string
+    """
+    if matches := regex.findall(string):
+        for match in set(matches):
+            string = re.sub(rf"\.?{match}", f"['{match}']", string)
+
+    return string
+
 
 class ElasticPath(BaseModel):
     """Converts a JSON path to an Elasticsearch path.
@@ -17,6 +70,11 @@ class ElasticPath(BaseModel):
     nest: Optional[str] = None
     partition: Optional[str] = None
     key: Optional[str] = None
+
+    es_path: Optional[str] = None
+    es_nest: Optional[str] = None
+    es_key: Optional[str] = None
+
     index_: Optional[int] = None
 
     @model_validator(mode="before")
@@ -35,6 +93,10 @@ def validate_model(cls, data: Any):
             data["path"] = f"{data['nest']}[{data['index_']}]"
             data["nest"], data["partition"], data["key"] = data["nest"].rpartition(".")
 
+        data["es_path"] = to_es(data["path"])
+        data["es_nest"] = to_es(data["nest"])
+        data["es_key"] = to_es(data["key"])
+
         return data
 
     @computed_field  # type: ignore[misc]
@@ -43,7 +105,7 @@ def index(self) -> Union[int, str, None]:
         """Compute location of path.
 
         Returns:
-            str: path location
+            str: path index
         """
         if self.index_ and self.index_ < 0:
 
@@ -60,3 +122,30 @@ def location(self) -> str:
             str: path location
         """
         return self.nest + self.partition + self.key
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def es_location(self) -> str:
+        """Compute location of path.
+
+        Returns:
+            str: path location
+        """
+        if self.es_key and ":" in self.es_key:
+            return self.es_nest + self.es_key
+        return self.es_nest + self.partition + self.es_key
+
+    @computed_field  # type: ignore[misc]
+    @property
+    def variable_name(self) -> str:
+        """Variable name for scripting.
+
+        Returns:
+            str: variable name
+        """
+        if self.index is not None:
+            return f"{self.location.replace('.','_').replace(':','_')}_{self.index}"
+
+        return (
+            f"{self.nest.replace('.','_').replace(':','_')}_{self.key.replace(':','_')}"
+        )

stac_fastapi/core/stac_fastapi/core/utilities.py

@@ -4,10 +4,9 @@
 such as converting bounding boxes to polygon representations.
 """
 
-import re
 from typing import Any, Dict, List, Optional, Set, Union
 
-from stac_fastapi.core.models.patch import ElasticPath
+from stac_fastapi.core.models.patch import ElasticPath, ESCommandSet
 from stac_fastapi.types.stac import (
     Item,
     PatchAddReplaceTest,
@@ -173,7 +172,7 @@ def merge_to_operations(data: Dict) -> List:
 
 
 def check_commands(
-    commands: List[str],
+    commands: ESCommandSet,
     op: str,
     path: ElasticPath,
     from_path: bool = False,
@@ -188,28 +187,28 @@ def check_commands(
 
     """
     if path.nest:
-        commands.append(
+        commands.add(
             f"if (!ctx._source.containsKey('{path.nest}'))"
             f"{{Debug.explain('{path.nest} does not exist');}}"
         )
 
     if path.index or op in ["remove", "replace", "test"] or from_path:
-        commands.append(
-            f"if (!ctx._source.{path.nest}.containsKey('{path.key}'))"
+        commands.add(
+            f"if (!ctx._source.{path.es_nest}.containsKey('{path.key}'))"
             f"{{Debug.explain('{path.key}  does not exist in {path.nest}');}}"
         )
 
     if from_path and path.index is not None:
-        commands.append(
-            f"if ((ctx._source.{path.location} instanceof ArrayList"
-            f" && ctx._source.{path.location}.size() < {path.index})"
+        commands.add(
+            f"if ((ctx._source.{path.es_location} instanceof ArrayList"
+            f" && ctx._source.{path.es_location}.size() < {path.index})"
             f" || (!(ctx._source.properties.hello instanceof ArrayList)"
-            f" && !ctx._source.{path.location}.containsKey('{path.index}')))"
+            f" && !ctx._source.{path.es_location}.containsKey('{path.index}')))"
             f"{{Debug.explain('{path.path} does not exist');}}"
         )
 
 
-def remove_commands(commands: List[str], path: ElasticPath) -> None:
+def remove_commands(commands: ESCommandSet, path: ElasticPath) -> None:
     """Remove value at path.
 
     Args:
@@ -218,14 +217,18 @@ def remove_commands(commands: List[str], path: ElasticPath) -> None:
 
     """
     if path.index is not None:
-        commands.append(f"def temp = ctx._source.{path.location}.remove({path.index});")
+        commands.add(
+            f"def {path.variable_name} = ctx._source.{path.es_location}.remove({path.index});"
+        )
 
     else:
-        commands.append(f"def temp = ctx._source.{path.nest}.remove('{path.key}');")
+        commands.add(
+            f"def {path.variable_name} = ctx._source.{path.es_nest}.remove('{path.key}');"
+        )
 
 
 def add_commands(
-    commands: List[str],
+    commands: ESCommandSet,
     operation: PatchOperation,
     path: ElasticPath,
     from_path: ElasticPath,
@@ -239,23 +242,27 @@ def add_commands(
 
     """
     if from_path is not None:
-        value = "temp" if operation.op == "move" else f"ctx._source.{from_path.path}"
+        value = (
+            from_path.variable_name
+            if operation.op == "move"
+            else f"ctx._source.{from_path.es_path}"
+        )
     else:
         value = operation.json_value
 
     if path.index is not None:
-        commands.append(
-            f"if (ctx._source.{path.location} instanceof ArrayList)"
-            f"{{ctx._source.{path.location}.{'add' if operation.op in ['add', 'move'] else 'set'}({path.index}, {value})}}"
-            f"else{{ctx._source.{path.path} = {value}}}"
+        commands.add(
+            f"if (ctx._source.{path.es_location} instanceof ArrayList)"
+            f"{{ctx._source.{path.es_location}.{'add' if operation.op in ['add', 'move'] else 'set'}({path.index}, {value})}}"
+            f"else{{ctx._source.{path.es_path} = {value}}}"
         )
 
     else:
-        commands.append(f"ctx._source.{path.path} = {value};")
+        commands.add(f"ctx._source.{path.es_path} = {value};")
 
 
 def test_commands(
-    commands: List[str], operation: PatchOperation, path: ElasticPath
+    commands: ESCommandSet, operation: PatchOperation, path: ElasticPath
 ) -> None:
     """Test value at path.
 
@@ -264,10 +271,10 @@ def test_commands(
         operation (PatchOperation): operation to run
         path (ElasticPath): path for value to be tested
     """
-    commands.append(
-        f"if (ctx._source.{path.location} != {operation.json_value})"
-        f"{{Debug.explain('Test failed for: {path.path} | "
-        f"{operation.json_value} != ' + ctx._source.{path.location});}}"
+    commands.add(
+        f"if (ctx._source.{path.es_path} != {operation.json_value})"
+        f"{{Debug.explain('Test failed `{path.path}` | "
+        f"{operation.json_value} != ' + ctx._source.{path.es_path});}}"
     )
 
 
@@ -282,18 +289,13 @@ def commands_to_source(commands: List[str]) -> str:
     """
     seen: Set[str] = set()
     seen_add = seen.add
-    regex = re.compile(r"([^.' ]*:[^.' ]*)[. ]")
+    # regex = re.compile(r"([^.' ]*:[^.' ]*)[. ;]")
     source = ""
 
     # filter duplicate lines
     for command in commands:
         if command not in seen:
             seen_add(command)
-            # extension terms with using `:` must be swapped out
-            if matches := regex.findall(command):
-                for match in matches:
-                    command = command.replace(f".{match}", f"['{match}']")
-
             source += command
 
     return source
@@ -308,7 +310,7 @@ def operations_to_script(operations: List) -> Dict:
     Returns:
         Dict: elasticsearch update script.
     """
-    commands: List = []
+    commands: ESCommandSet = ESCommandSet()
     for operation in operations:
         path = ElasticPath(path=operation.path)
         from_path = (
@@ -333,7 +335,7 @@ def operations_to_script(operations: List) -> Dict:
         if operation.op == "test":
             test_commands(commands=commands, operation=operation, path=path)
 
-        source = commands_to_source(commands=commands)
+        source = "".join(commands)
 
     return {
         "source": source,

stac_fastapi/tests/clients/test_elasticsearch.py

@@ -323,7 +323,7 @@ async def test_json_patch_item_replace(ctx, core_client, txn_client):
             {"op": "replace", "path": "/properties/proj:epsg", "value": "world"}
         ),
         PatchAddReplaceTest.model_validate(
-            {"op": "replace", "path": "/properties/area/1", "value": "50"}
+            {"op": "replace", "path": "/properties/area/1", "value": 50}
         ),
     ]
 
@@ -339,7 +339,7 @@ async def test_json_patch_item_replace(ctx, core_client, txn_client):
     )
 
     assert updated_item["properties"]["gsd"] == 100
-    assert updated_item["properties"]["proj:epsg"] == 100
+    assert updated_item["properties"]["proj:epsg"] == "world"
     assert updated_item["properties"]["area"] == [2500, 50]
 
 
@@ -356,7 +356,7 @@ async def test_json_patch_item_test(ctx, core_client, txn_client):
             {"op": "test", "path": "/properties/proj:epsg", "value": 32756}
         ),
         PatchAddReplaceTest.model_validate(
-            {"op": "test", "path": "/properties/area/1", "value": -100}
+            {"op": "test", "path": "/properties/area/1", "value": -200}
         ),
     ]
 
@@ -373,7 +373,7 @@ async def test_json_patch_item_test(ctx, core_client, txn_client):
 
     assert updated_item["properties"]["gsd"] == 15
     assert updated_item["properties"]["proj:epsg"] == 32756
-    assert updated_item["properties"]["area"][1] == -100
+    assert updated_item["properties"]["area"][1] == -200
 
 
 @pytest.mark.asyncio
@@ -389,7 +389,7 @@ async def test_json_patch_item_move(ctx, core_client, txn_client):
             {"op": "move", "path": "/properties/bar", "from": "/properties/proj:epsg"}
         ),
         PatchMoveCopy.model_validate(
-            {"op": "move", "path": "/properties/hello", "from": "/properties/area/1"}
+            {"op": "move", "path": "/properties/area/0", "from": "/properties/area/1"}
         ),
     ]
 
@@ -408,8 +408,7 @@ async def test_json_patch_item_move(ctx, core_client, txn_client):
     assert "gsd" not in updated_item["properties"]
     assert updated_item["properties"]["bar"] == 32756
     assert "proj:epsg" not in updated_item["properties"]
-    assert updated_item["properties"]["hello"] == [-100]
-    assert updated_item["properties"]["area"] == [2500]
+    assert updated_item["properties"]["area"] == [-200, 2500]
 
 
 @pytest.mark.asyncio
@@ -425,7 +424,7 @@ async def test_json_patch_item_copy(ctx, core_client, txn_client):
             {"op": "copy", "path": "/properties/bar", "from": "/properties/proj:epsg"}
         ),
         PatchMoveCopy.model_validate(
-            {"op": "copy", "path": "/properties/hello", "from": "/properties/area/1"}
+            {"op": "copy", "path": "/properties/area/0", "from": "/properties/area/1"}
         ),
     ]
 
@@ -442,7 +441,9 @@ async def test_json_patch_item_copy(ctx, core_client, txn_client):
 
     assert updated_item["properties"]["foo"] == updated_item["properties"]["gsd"]
     assert updated_item["properties"]["bar"] == updated_item["properties"]["proj:epsg"]
-    assert updated_item["properties"]["hello"] == updated_item["properties"]["area"][1]
+    assert (
+        updated_item["properties"]["area"][0] == updated_item["properties"]["area"][1]
+    )
 
 
 @pytest.mark.asyncio