deltacat 2.0.0b11__py3-none-any.whl → 2.0.0b12__py3-none-any.whl

deltacat/examples/experimental/iceberg/converter/beam/app.py

@@ -0,0 +1,226 @@
+from typing import Optional
+import apache_beam as beam
+from apache_beam.options.pipeline_options import PipelineOptions
+from apache_beam import Row
+import os
+import pyarrow.fs as pafs
+from deltacat.experimental.converter_agent.beam.managed import (
+    write as deltacat_beam_managed_write,
+)
+from deltacat.examples.experimental.iceberg.converter.beam.utils.common import (
+    generate_random_suffix,
+    verify_duplicate_resolution,
+    wait_for_deltacat_jobs,
+)
+from deltacat.examples.experimental.iceberg.converter.beam.utils.spark import (
+    SparkSQLIcebergRead,
+    SparkSQLIcebergRewrite,
+)
+
+# Monkey-patch beam.managed.Write and beam.managed.Read
+beam.managed.Write = deltacat_beam_managed_write
+
+
+def run(
+    beam_options: Optional[PipelineOptions] = None,
+    mode: str = "write",  # 'write' to write data, 'read' to read data
+    rest_catalog_uri: str = "http://localhost:8181",  # REST catalog server URI
+    warehouse_path: Optional[str] = None,  # Optional custom warehouse path
+    table_name: Optional[str] = None,  # Table name with namespace
+    deltacat_converter_interval: float = 5.0,  # Converter monitoring interval
+    ray_inactivity_timeout: int = 20,  # Ray cluster shutdown timeout
+    max_converter_parallelism: int = 1,  # Maximum converter task parallelism
+    filesystem: Optional[pafs.FileSystem] = None,  # Optional PyArrow filesystem
+) -> None:
+    """
+    Run the pipeline in either 'write' or 'read' mode using Iceberg REST Catalog.
+
+    Prerequisites:
+    - Start the Iceberg REST catalog server:
+      docker run -d -p 8181:8181 --name iceberg-rest-catalog tabulario/iceberg-rest:1.6.0
+    - For read mode: Install PySpark:
+      pip install pyspark
+
+    Args:
+        beam_options: Apache Beam pipeline options
+        mode: 'write' to write data, 'read' to read data
+        rest_catalog_uri: URI of the REST catalog server (default: http://localhost:8181)
+        warehouse_path: Custom warehouse path (default: temporary directory)
+        table_name: Name of the Iceberg table (default: None -  generates a random table name)
+        deltacat_converter_interval: Interval for DeltaCat optimizer monitoring
+        ray_inactivity_timeout: Timeout for shutting down Ray cluster
+        max_converter_parallelism: Maximum number of concurrent converter tasks
+        filesystem: PyArrow filesystem instance (default: LocalFileSystem)
+
+    Pipeline Operations:
+    - 'write': Write sample data to the Iceberg table with merge-on-read functionality.
+      Uses job-based table monitoring for better scalability and resource management.
+    - 'read': Read deduplicated data from the Iceberg table using Spark SQL.
+      Uses Spark SQL instead of Beam's native Iceberg I/O to properly handle positional deletes.
+    """
+    # Use custom warehouse path or create a temporary one
+    if warehouse_path is None:
+        warehouse_path = os.path.join("/tmp", "iceberg_rest_warehouse")
+        os.makedirs(warehouse_path, exist_ok=True)
+
+    # Use provided filesystem or create a LocalFileSystem by default
+    if filesystem is None:
+        filesystem = pafs.LocalFileSystem()
+
+    # Generate unique table name if using default to avoid conflicts
+    if not table_name:
+        random_suffix = generate_random_suffix()
+        table_name = f"default.demo_table_{random_suffix}"
+        print(f"📋 Generated unique table name: {table_name}")
+
+    # Define catalog configuration for REST catalog (simplified, table creation handled separately)
+    catalog_config = {
+        "catalog_properties": {
+            "warehouse": warehouse_path,
+            "catalog-impl": "org.apache.iceberg.rest.RESTCatalog",
+            "uri": rest_catalog_uri,
+        },
+        "deltacat_converter_properties": {
+            "deltacat_converter_interval": deltacat_converter_interval,
+            "merge_keys": ["id"],  # Configure merge keys for duplicate detection
+            "ray_inactivity_timeout": ray_inactivity_timeout,
+            "filesystem": filesystem,  # Pass filesystem to DeltaCAT converter
+            "max_converter_parallelism": max_converter_parallelism,
+        },
+    }
+
+    # Ensure table name includes namespace
+    if "." not in table_name:
+        full_table_name = f"default.{table_name}"
+    else:
+        full_table_name = table_name
+
+    print(f"🔧 Using Iceberg REST Catalog")
+    print(f"   REST Server: {rest_catalog_uri}")
+    print(f"   Warehouse: {warehouse_path}")
+    print(f"   Mode: {mode}")
+    print(f"   Table: {full_table_name}")
+    print(f"   Filesystem: {type(filesystem).__name__}")
+
+    # Remind user about prerequisites
+    if mode == "write":
+        print("📋 Prerequisites:")
+        print("   Make sure the Iceberg REST catalog server is running:")
+        print(
+            "   docker run -d -p 8181:8181 --name iceberg-rest-catalog tabulario/iceberg-rest:1.6.0"
+        )
+        print()
+        with beam.Pipeline(options=beam_options) as p:
+            # Step 1: Write initial data to create the table
+            initial_data = p | "Create initial data" >> beam.Create(
+                [
+                    Row(id=1, name="Alice", value=100, version=1),
+                    Row(id=2, name="Bob", value=200, version=1),
+                    Row(id=3, name="Charlie", value=300, version=1),
+                    Row(id=4, name="David", value=400, version=1),
+                    Row(id=5, name="Eve", value=500, version=1),
+                    Row(id=6, name="Frank", value=600, version=1),
+                    Row(id=7, name="Grace", value=700, version=1),
+                    Row(id=8, name="Henry", value=800, version=1),
+                    Row(
+                        id=2, name="Robert", value=201, version=2
+                    ),  # Update Bob's record
+                    Row(
+                        id=3, name="Charles", value=301, version=2
+                    ),  # Update Charlie's record
+                    Row(id=9, name="Ivy", value=900, version=1),  # Add a new record
+                ]
+            )
+
+            initial_data | "Write initial data to Iceberg" >> beam.managed.Write(
+                beam.managed.ICEBERG,
+                config={
+                    "table": full_table_name,  # Use fully qualified table name for REST catalog
+                    "write_mode": "append",
+                    **catalog_config,
+                },
+            )
+
+        # Wait for the DeltaCAT converter job to complete and shutdown
+        wait_for_deltacat_jobs(
+            full_table_name, warehouse_path, ray_inactivity_timeout * 2
+        )
+
+        print(f"\n📝 Data writing completed with DeltaCAT optimization enabled.")
+        print(f"   - Table monitoring interval: {deltacat_converter_interval} seconds")
+        print(f"   - Ray cluster shutdown timeout: {ray_inactivity_timeout} seconds")
+        print(f"   - Automatic duplicate detection and resolution")
+        print(f"   - Position delete creation for duplicate resolution")
+        print(f"   - Job-based table monitoring with Ray")
+        print(f"   - Filesystem: {type(filesystem).__name__}")
+        print(
+            f"🔍 Read the table with: `python main.py --mode read --table-name {full_table_name}`"
+        )
+
+    elif mode == "read":
+        with beam.Pipeline(options=beam_options) as p:
+            # Read from the Iceberg table using Spark SQL
+            # Note: We use Spark SQL instead of beam.managed.Read because Beam's native Iceberg I/O
+            # cannot handle positional delete files created by DeltaCAT converter sessions.
+
+            print(f"📖 Reading from Iceberg table '{full_table_name}' using Spark SQL")
+
+            # Create a trigger element to start the read
+            trigger = p | "Create read trigger" >> beam.Create([None])
+
+            # Read from Iceberg table using Spark SQL
+            elements = trigger | "Read with Spark SQL" >> beam.ParDo(
+                SparkSQLIcebergRead(
+                    table_name=full_table_name,
+                    catalog_uri=rest_catalog_uri,
+                    warehouse=warehouse_path,
+                )
+            )
+
+            # Display the data read (after positional deletes are applied)
+            elements | "Print deduplicated data" >> beam.Map(
+                lambda row: print(f"📋 Record: {row}")
+            )
+
+            # Count records for summary
+            def count_and_display(elements_list):
+                print(f"\n📊 Read Summary:")
+                print(f"   - Total records: {len(elements_list)}")
+                return elements_list
+
+            # Collect all elements for counting
+            elements | "Count records" >> beam.combiners.ToList() | "Display summary" >> beam.Map(
+                count_and_display
+            )
+
+            # Verify that the data was correctly merged by ID
+            verify_duplicate_resolution(full_table_name, warehouse_path)
+
+    elif mode == "rewrite":
+        with beam.Pipeline(options=beam_options) as p:
+            # Rewrite table data files to materialize positional deletes
+            print(f"🔄 Rewriting Iceberg table to materialize positional deletes")
+            print(f"   - Table: {full_table_name}")
+            print(f"   - Purpose: Remove positional deletes to enable Beam writes")
+            print(f"   - Method: Spark rewrite_data_files procedure")
+
+            # Create a trigger element to start the rewrite
+            trigger = p | "Create rewrite trigger" >> beam.Create(
+                [f"rewrite_{full_table_name}"]
+            )
+
+            # Use Spark SQL to rewrite the table
+            rewrite_results = trigger | "Rewrite table with Spark SQL" >> beam.ParDo(
+                SparkSQLIcebergRewrite(
+                    catalog_uri=rest_catalog_uri,
+                    warehouse_path=warehouse_path,
+                    table_name=full_table_name,
+                )
+            )
+
+            # Log the results
+            rewrite_results | "Log rewrite results" >> beam.Map(
+                lambda result: print(f"📋 Rewrite result: {result}")
+            )
+    else:
+        raise ValueError(f"Unknown mode: {mode}. Use 'write', 'read', or 'rewrite'.")

deltacat/examples/experimental/iceberg/converter/beam/main.py

@@ -0,0 +1,133 @@
+import pyarrow.fs as pafs
+import argparse
+import logging
+
+from apache_beam.options.pipeline_options import PipelineOptions
+
+from deltacat.examples.experimental.iceberg.converter.beam import app
+
+
+if __name__ == "__main__":
+    logging.getLogger().setLevel(logging.INFO)
+    parser = argparse.ArgumentParser(
+        description="DeltaCat Beam Iceberg Converter Example using REST Catalog",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Start REST catalog server first (Iceberg 1.6.0):
+  docker run -d -p 8181:8181 --name iceberg-rest-catalog tabulario/iceberg-rest:1.6.0
+
+  # Install PySpark for read and rewrite modes:
+  pip install pyspark
+
+  # Write sample data with DeltaCAT data file converter (automatic merge by key):
+  python main.py --mode write --table-name "deltacat.hello_world"
+
+  # Read data back (uses Spark SQL to read positional deletes):
+  python main.py --mode read --table-name "deltacat.hello_world"
+
+  # Rewrite table to materialize positional deletes:
+  python main.py --mode rewrite --table-name "deltacat.hello_world"
+
+  # Use custom REST catalog server:
+  python main.py --mode write --rest-uri http://localhost:9000 --table-name "deltacat.hello_world"
+
+  # Use custom warehouse path:
+  python main.py --mode write --warehouse-path /tmp/my_warehouse --table-name "deltacat.hello_world"
+        """,
+    )
+
+    parser.add_argument(
+        "--mode",
+        default="write",
+        choices=["write", "read", "rewrite"],
+        help="Pipeline mode: 'write' to write data, 'read' to read data, 'rewrite' to materialize positional deletes (default: write). "
+        "   Note: Beam writes may fail on tables processed by external tools.",
+    )
+
+    parser.add_argument(
+        "--rest-uri",
+        default="http://localhost:8181",
+        help="REST catalog server URI (default: http://localhost:8181).",
+    )
+
+    parser.add_argument(
+        "--warehouse-path",
+        default=None,
+        help="Custom warehouse path (default: temporary directory).",
+    )
+
+    parser.add_argument(
+        "--table-name",
+        default=None,
+        help="Table name to use (default: autogenerated table name).",
+    )
+
+    parser.add_argument(
+        "--deltacat-converter-interval",
+        type=float,
+        default=5.0,
+        help="DeltaCat converter monitoring interval in seconds (default: 5.0).",
+    )
+
+    parser.add_argument(
+        "--ray-inactivity-timeout",
+        type=int,
+        default=20,
+        help="Ray cluster shutdown timeout after inactivity in seconds (default: 20).",
+    )
+
+    parser.add_argument(
+        "--max-converter-parallelism",
+        type=int,
+        default=1,
+        help="Maximum converter task parallelism - number of concurrent converter tasks (default: 1).",
+    )
+
+    args, beam_args = parser.parse_known_args()
+
+    beam_options = PipelineOptions(
+        beam_args,
+        save_main_session=True,
+    )
+
+    print("DeltaCAT Beam Iceberg Upsert Example")
+    print("=" * 50)
+    print(f"Mode: {args.mode}")
+    print(f"REST Catalog URI: {args.rest_uri}")
+    print(f"Warehouse Path: {args.warehouse_path or 'temporary directory'}")
+    print(f"Table Name: {args.table_name}")
+    print(f"Converter Interval: {args.deltacat_converter_interval}s")
+    print(f"Ray Inactivity Timeout: {args.ray_inactivity_timeout}s")
+    print(f"Max Converter Parallelism: {args.max_converter_parallelism}")
+    print()
+
+    # Remind user about prerequisites
+    if args.mode == "write":
+        print("Prerequisites:")
+        print("   Make sure the Iceberg REST catalog server is running:")
+        print(
+            "   docker run -d -p 8181:8181 --name iceberg-rest-catalog tabulario/iceberg-rest:1.6.0"
+        )
+        print()
+    elif args.mode in ["read", "rewrite"]:
+        print("Prerequisites:")
+        print("   Make sure the Iceberg REST catalog server is running:")
+        print(
+            "   docker run -d -p 8181:8181 --name iceberg-rest-catalog tabulario/iceberg-rest:1.6.0"
+        )
+        print("   PySpark is required for this mode:")
+        print("   pip install pyspark")
+        print()
+
+    app.run(
+        beam_options=beam_options,
+        mode=args.mode,
+        rest_catalog_uri=args.rest_uri,
+        warehouse_path=args.warehouse_path,
+        table_name=args.table_name,
+        deltacat_converter_interval=args.deltacat_converter_interval,
+        ray_inactivity_timeout=args.ray_inactivity_timeout,
+        filesystem=pafs.LocalFileSystem(),
+        max_converter_parallelism=args.max_converter_parallelism,
+    )

deltacat/examples/experimental/iceberg/converter/beam/test_workflow.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""
+Quick test script to demonstrate the REST catalog workflow.
+This script shows the complete write → read cycle with DeltaCAT monitoring and conversion.
+"""
+
+import subprocess
+import sys
+from deltacat.examples.experimental.iceberg.converter.beam.utils.common import (
+    generate_random_suffix,
+    check_rest_catalog,
+)
+from deltacat.examples.experimental.iceberg.converter.beam.utils.common import (
+    verify_duplicate_resolution,
+)
+
+
+def run_example(mode, table_name, input_text="Workflow Test"):
+    """Run the example in the specified mode."""
+    print(f"\n🚀 Running example in {mode} mode with table: {table_name}")
+    cmd = [
+        sys.executable,
+        "main.py",
+        "--mode",
+        mode,
+        "--input-text",
+        input_text,
+        "--table-name",
+        table_name,
+    ]
+
+    try:
+        result = subprocess.run(
+            cmd, capture_output=True, text=True, timeout=120
+        )  # Increased timeout for converter
+        if result.returncode == 0:
+            print(f"✅ {mode.capitalize()} operation completed successfully")
+            if mode == "read":
+                # Show sample data from the output
+                lines = result.stdout.split("\n")
+                data_lines = [line for line in lines if "BeamSchema" in line]
+                if data_lines:
+                    print(f"📊 Found {len(data_lines)} records in table")
+                    print("Sample records:")
+                    for line in data_lines[:5]:  # Show first 5 records
+                        print(f"  {line}")
+                    if len(data_lines) > 5:
+                        print(f"  ... and {len(data_lines) - 5} more records")
+            return True
+        else:
+            print(f"❌ {mode.capitalize()} operation failed:")
+            print(result.stderr)
+            return False
+    except subprocess.TimeoutExpired:
+        print(f"⏰ {mode.capitalize()} operation timed out")
+        return False
+    except Exception as e:
+        print(f"❌ Error running {mode} operation: {e}")
+        return False
+
+
+def main():
+    """Main workflow test."""
+    print("🧪 DeltaCAT Beam Iceberg REST Catalog Workflow Test")
+    print("=" * 60)
+
+    # Generate unique table name to avoid conflicts
+    random_suffix = generate_random_suffix()
+    table_name = f"default.demo_table_{random_suffix}"
+    print(f"📋 Generated unique table name: {table_name}")
+
+    # Step 1: Check prerequisites
+    if not check_rest_catalog():
+        sys.exit(1)
+
+    # Step 2: Write data (creates table with duplicates and triggers converter)
+    print(f"\n📋 Phase 1: Writing data and triggering DeltaCAT converter")
+    if not run_example("write", table_name, "Workflow Demo User"):
+        print("❌ Write test failed")
+        sys.exit(1)
+
+    # Step 3: Verify upsert merge worked as expected
+    print(f"\n📋 Phase 2: Direct verification of duplicate resolution")
+    verification_success = verify_duplicate_resolution(table_name)
+
+    # Step 4: Read data back to show final state
+    print(f"\n📋 Phase 3: Reading final table state")
+    if not run_example("read", table_name):
+        print("❌ Read test failed")
+        sys.exit(1)
+
+    # Final summary
+    print("\n🎉 Workflow test completed!")
+
+    if verification_success:
+        print("\n✅ SUCCESS:")
+        print("  ✅ Table creation and writes")
+        print("  ✅ DeltaCAT monitoring merged duplicates")
+        print("  ✅ Read operations correctly read merged data")
+    else:
+        print("\n⚠️  PARTIAL SUCCESS:")
+        print("  ✅ Table creation and writes")
+        print("  ❓ Converter may still be processing or failed")
+        print("  📝 Check logs for converter execution details")
+
+    print("\n📚 What happened:")
+    print("  1. Beam wrote data creating duplicates (IDs 2,3)")
+    print("  2. DeltaCAT monitoring merged duplicates")
+    print("  3. Table now contains merged data")
+
+
+if __name__ == "__main__":
+    main()

deltacat/examples/experimental/iceberg/converter/beam/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+Utility modules for the Iceberg converter example.
+"""

deltacat/examples/experimental/iceberg/converter/beam/utils/common.py

@@ -0,0 +1,174 @@
+"""
+Common utility functions for the Iceberg converter example.
+"""
+
+import random
+import string
+import time
+from pyiceberg.catalog import load_catalog
+import requests
+from deltacat import local_job_client
+from deltacat.constants import DEFAULT_NAMESPACE
+from deltacat.experimental.converter_agent.table_monitor import _generate_job_name
+
+
+def generate_random_suffix(length=8):
+    """Generate a random string of specified length using letters and digits."""
+    return "".join(random.choices(string.ascii_lowercase + string.digits, k=length))
+
+
+def check_rest_catalog():
+    """Check if REST catalog is running."""
+    try:
+        response = requests.get("http://localhost:8181/v1/config", timeout=5)
+        if response.status_code == 200:
+            print("✅ REST catalog is running")
+            return True
+    except requests.exceptions.RequestException:
+        pass
+
+    print("❌ REST catalog is not running")
+    print(
+        "📋 Start it with: docker run -d -p 8181:8181 --name iceberg-rest-catalog tabulario/iceberg-rest:1.6.0"
+    )
+    return False
+
+
+def wait_for_deltacat_jobs(
+    table_name, warehouse_path="/tmp/iceberg_rest_warehouse", timeout=120
+):
+    """
+    Wait for DeltaCAT converter jobs to complete by checking job status.
+
+    Args:
+        table_name: Full table name (e.g., "default.demo_table_abc123")
+        warehouse_path: Warehouse path used for job tracking
+        timeout: Maximum seconds to wait for job completion
+
+    Returns:
+        True if all jobs completed, False if timeout
+    """
+    print(f"\n⏳ Monitoring DeltaCAT converter jobs for table: {table_name}")
+
+    # Parse table name to get namespace and table name
+    if "." in table_name:
+        namespace, actual_table_name = table_name.split(".", 1)
+    else:
+        namespace = DEFAULT_NAMESPACE
+        actual_table_name = table_name
+
+    # Create job key matching the format used in managed.py
+    job_name = _generate_job_name(
+        warehouse_path=warehouse_path, namespace=namespace, table_name=actual_table_name
+    )
+
+    start_time = time.time()
+
+    try:
+        # Get the job client
+        client = local_job_client(ray_init_args={"local_mode": True})
+
+        while time.time() - start_time < timeout:
+            job_details_list = client.list_jobs()
+            print(f"🔍 Job details list: {job_details_list}")
+            job_submission_ids = [
+                job_details.submission_id for job_details in job_details_list
+            ]
+
+            # Check if we have any tracked jobs for this table
+            print(f"🔍 Looking for submission ID: {job_name} in {job_submission_ids}")
+            if job_name in job_submission_ids:
+                # Check job status with Ray
+                try:
+                    job_status = client.get_job_status(job_name)
+                    print(f"📊 Job {job_name} status: {job_status}")
+                    # Check if job is still running
+                    if job_status and str(job_status) in ["PENDING", "RUNNING"]:
+                        time.sleep(2)  # Short polling interval
+                        continue
+                    else:
+                        print(f"✅ Job {job_name} completed with status: {job_status}")
+                        return True
+
+                except Exception as e:
+                    print(f"⚠️  Could not check job status for {job_name}: {e}")
+                    # If we can't check status, assume job is done
+                    return True
+            time.sleep(1)
+        print(f"⏰ Timeout waiting for DeltaCAT job completion after {timeout} seconds")
+        return False
+
+    except Exception as e:
+        print(f"❌ Error monitoring DeltaCAT jobs: {e}")
+        # Fall back to short sleep if monitoring fails
+        print(f"🔄 Falling back to {timeout}-second wait...")
+        time.sleep(timeout)
+        return True
+
+
+def verify_duplicate_resolution(
+    table_name, warehouse_path="/tmp/iceberg_rest_warehouse"
+):
+    """
+    Verify that the DeltaCAT converter successfully resolved duplicates.
+    """
+    try:
+        print(f"\n🔍 Verifying duplicate resolution for table: {table_name}")
+
+        # Create PyIceberg catalog to check results
+        verification_catalog = load_catalog(
+            "workflow_verification_catalog",
+            **{
+                "type": "rest",
+                "warehouse": warehouse_path,
+                "uri": "http://localhost:8181",
+            },
+        )
+
+        # Load the table and scan its contents
+        table_identifier = table_name
+        tbl = verification_catalog.load_table(table_identifier)
+        scan_result = tbl.scan().to_arrow().to_pydict()
+
+        # Check the results
+        result_ids = sorted(scan_result["id"])
+        unique_ids = sorted(set(result_ids))
+
+        print(f"📊 Final verification results:")
+        print(f"  - Total records: {len(result_ids)}")
+        print(f"  - Unique IDs: {len(unique_ids)}")
+        print(f"  - IDs found: {result_ids}")
+
+        # Check if duplicates were resolved
+        expected_unique_ids = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+        if result_ids == expected_unique_ids:
+            # Verify that the latest versions were preserved
+            names_by_id = {}
+            versions_by_id = {}
+            for i, id_val in enumerate(scan_result["id"]):
+                names_by_id[id_val] = scan_result["name"][i]
+                versions_by_id[id_val] = scan_result["version"][i]
+
+            if (
+                names_by_id.get(2) == "Robert"
+                and names_by_id.get(3) == "Charles"
+                and versions_by_id.get(2) == 2
+                and versions_by_id.get(3) == 2
+            ):
+                print(f"✅ Duplicate resolution SUCCESSFUL!")
+                print(f"  - All 9 IDs are unique")
+                print(f"  - Latest versions preserved (Bob→Robert, Charlie→Charles)")
+                print(f"  - Version numbers correct (v2 for updated records)")
+                return True
+            else:
+                print(f"❌ Latest versions not preserved correctly")
+        else:
+            print(f"❌ Duplicates still present or unexpected record count")
+            print(f"  - Expected: {expected_unique_ids}")
+            print(f"  - Got: {result_ids}")
+
+        return False
+
+    except Exception as e:
+        print(f"❌ Error during verification: {e}")
+        return False