NRL-1798 Add output file

Author: sandyforresternhs

scripts/delete_pointers_by_id.py

@@ -1,5 +1,7 @@
 #!/usr/bin/env python
 import json
+import os
+import tempfile
 from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List
 
@@ -156,11 +158,53 @@ def _batch_delete_pointers(
     return pointers_deleted, sorted(failed_deletes_set)
 
 
+def _write_result_file(result: Dict[str, Any], output_file: str) -> None:
+    """
+    Atomically write result dict to output_file as JSON.
+    Raises on failure.
+    """
+    out_dir = os.path.dirname(os.path.abspath(output_file)) or "."
+    with tempfile.NamedTemporaryFile(
+        "w", delete=False, dir=out_dir, prefix=".tmp_delete_results_", suffix=".json"
+    ) as tf:
+        json.dump(result, tf, indent=2)
+        tf.flush()
+        os.fsync(tf.fileno())
+    os.replace(tf.name, output_file)
+
+
+def _print_summary(result: Dict[str, Any]) -> None:
+    """
+    Print a concise summary of the result to stdout.
+    """
+
+    def count_from(field):
+        val = result.get(field)
+        if isinstance(val, dict):
+            return val.get("count", 0)
+        if isinstance(val, list):
+            return len(val)
+        return 0
+
+    print("Summary:")
+    print(f"  pointers_to_delete: {result.get('pointers_to_delete')}")
+    print(f"  ods_code_matched:   {count_from('ods_code_matched')}")
+    print(f"  ods_code_mismatched:{count_from('ods_code_mismatched')}")
+    print(f"  pointer_not_found:  {count_from('pointer_not_found')}")
+    print(f"  deleted_pointers:   {count_from('deleted_pointers')}")
+    print(f"  failed_deletes:     {count_from('failed_deletes')}")
+    if "_output_error" in result:
+        print(f"  output_error:       {result['_output_error']}")
+    if "deletes-took-secs" in result:
+        print(f"  deletes-took-secs:  {result.get('deletes-took-secs')}")
+
+
 def _delete_pointers_by_id(
     table_name: str,
     ods_code: str,
     pointers_to_delete: List[str] | None = None,
     pointers_file: str | None = None,
+    output_file: str | None = None,
 ) -> Dict[str, Any]:
     """
     Delete pointers from DynamoDB table.
@@ -175,6 +219,7 @@ def _delete_pointers_by_id(
     - ods_code: ODS code of the organisation that the pointers belong to
     - pointers_to_delete: list of pointer ids to delete
     - pointers_file: path to JSON file (array of objects with "id" field) or text file (one id per line)
+    - output_file: optional path to write the result JSON to (atomic replace)
     """
     if pointers_to_delete is None and pointers_file is None:
         raise ValueError("Provide either pointers_to_delete or pointers_file")
@@ -187,16 +232,25 @@ def _delete_pointers_by_id(
         pointers_to_delete = _load_pointers_from_file(pointers_file)
 
     if len(pointers_to_delete) == 0:
-        return {
+        result = {
             "pointers_to_delete": 0,
             "ods_code": ods_code,
-            "ods_code_matched": [],
-            "ods_code_mismatched": [],
-            "pointer_not_found": [],
-            "deleted_pointers": [],
-            "failed_deletes": [],
+            "ods_code_matched": {"count": 0, "ids": []},
+            "ods_code_mismatched": {"count": 0, "ids": []},
+            "pointer_not_found": {"count": 0, "ids": []},
+            "deleted_pointers": {"count": 0, "ids": []},
+            "failed_deletes": {"count": 0, "ids": []},
             "deletes-took-secs": 0,
         }
+        if output_file:
+            try:
+                _write_result_file(result, output_file)
+            except Exception as exc:
+                result["_output_error"] = (
+                    f"Failed to write output_file {output_file}: {exc}"
+                )
+        _print_summary(result)
+        return result
 
     start_time = datetime.now(tz=timezone.utc)
 
@@ -214,7 +268,7 @@ def _delete_pointers_by_id(
     if len(matched_pointers) == 0:
         print(f"None of the pointer IDs are a match for ODS code {ods_code}. Exiting.")
         end_time = datetime.now(tz=timezone.utc)
-        return {
+        result = {
             "pointers_to_delete": len(pointers_to_delete),
             "ods_code": ods_code,
             "ods_code_matched": {
@@ -225,20 +279,20 @@ def _delete_pointers_by_id(
                 "count": len(mismatched_pointers),
                 "ids": mismatched_pointers,
             },
-            "pointer_not_found": {
-                "count": 0,
-                "ids": [],
-            },
-            "deleted_pointers": {
-                "count": 0,
-                "ids": [],
-            },
-            "failed_deletes": {
-                "count": 0,
-                "ids": [],
-            },
+            "pointer_not_found": {"count": 0, "ids": []},
+            "deleted_pointers": {"count": 0, "ids": []},
+            "failed_deletes": {"count": 0, "ids": []},
             "deletes-took-secs": timedelta.total_seconds(end_time - start_time),
         }
+        if output_file:
+            try:
+                _write_result_file(result, output_file)
+            except Exception as exc:
+                result["_output_error"] = (
+                    f"Failed to write output_file {output_file}: {exc}"
+                )
+        _print_summary(result)
+        return result
 
     print(f"Checking existence of {len(matched_pointers)} pointers in {table_name}...")
     existing_pointers, not_found_pointers = _batch_get_existing_pointers(
@@ -252,7 +306,7 @@ def _delete_pointers_by_id(
     if len(existing_pointers) == 0:
         print("No pointers found to delete. Exiting.")
         end_time = datetime.now(tz=timezone.utc)
-        return {
+        result = {
             "pointers_to_delete": len(pointers_to_delete),
             "ods_code": ods_code,
             "ods_code_matched": {
@@ -267,16 +321,19 @@ def _delete_pointers_by_id(
                 "count": len(not_found_pointers),
                 "ids": not_found_pointers,
             },
-            "deleted_pointers": {
-                "count": 0,
-                "ids": [],
-            },
-            "failed_deletes": {
-                "count": 0,
-                "ids": [],
-            },
+            "deleted_pointers": {"count": 0, "ids": []},
+            "failed_deletes": {"count": 0, "ids": []},
             "deletes-took-secs": timedelta.total_seconds(end_time - start_time),
         }
+        if output_file:
+            try:
+                _write_result_file(result, output_file)
+            except Exception as exc:
+                result["_output_error"] = (
+                    f"Failed to write output_file {output_file}: {exc}"
+                )
+        _print_summary(result)
+        return result
 
     # Proceed with deletion using BatchWriteItem
     pointers_deleted, failed_deletes = _batch_delete_pointers(
@@ -285,14 +342,10 @@ def _delete_pointers_by_id(
 
     end_time = datetime.now(tz=timezone.utc)
 
-    print(" Done")
-    return {
+    result = {
         "pointers_to_delete": len(pointers_to_delete),
         "ods_code": ods_code,
-        "ods_code_matched": {
-            "count": len(matched_pointers),
-            "ids": matched_pointers,
-        },
+        "ods_code_matched": {"count": len(matched_pointers), "ids": matched_pointers},
         "ods_code_mismatched": {
             "count": len(mismatched_pointers),
             "ids": mismatched_pointers,
@@ -301,17 +354,23 @@ def _delete_pointers_by_id(
             "count": len(not_found_pointers),
             "ids": not_found_pointers,
         },
-        "deleted_pointers": {
-            "count": len(pointers_deleted),
-            "ids": pointers_deleted,
-        },
-        "failed_deletes": {
-            "count": len(failed_deletes),
-            "ids": failed_deletes,
-        },
+        "deleted_pointers": {"count": len(pointers_deleted), "ids": pointers_deleted},
+        "failed_deletes": {"count": len(failed_deletes), "ids": failed_deletes},
         "deletes-took-secs": timedelta.total_seconds(end_time - start_time),
     }
 
+    if output_file:
+        try:
+            _write_result_file(result, output_file)
+        except Exception as exc:
+            result["_output_error"] = (
+                f"Failed to write output_file {output_file}: {exc}"
+            )
+
+    _print_summary(result)
+    print(" Done")
+    return result
+
 
 if __name__ == "__main__":
     fire.Fire(_delete_pointers_by_id)