sunholo 0.130.2__py3-none-any.whl → 0.131.2__py3-none-any.whl

sunholo/discovery_engine/cli.py

@@ -1,19 +1,41 @@
 import json
+import argparse
+import traceback # For detailed error logging
 
+# --- Standard library imports first ---
+# --- Third-party imports ---
 try:
+    # Assuming sun_rich is in your project structure relative to this file
     from ..cli.sun_rich import console
 except ImportError:
-    console = None
+    # Fallback if rich is not available or path is wrong
+    class ConsoleFallback:
+        def print(self, *args, **kwargs):
+            print(*args)
+    console = ConsoleFallback()
+    print("Warning: rich console not found, using basic print.")
 
-from ..custom_logging import log
+# --- Local application imports ---
+# Assuming custom_logging is available
+# from ..custom_logging import log # Not explicitly used in CLI functions here
 
-# Make sure to adjust the relative import path if needed
-from .discovery_engine_client import DiscoveryEngineClient  
+# Make sure to adjust the relative import path if needed for your project structure
+from .discovery_engine_client import DiscoveryEngineClient, _DISCOVERYENGINE_AVAILABLE
+
+# Import necessary types only if library is available, for mapping CLI args
+if _DISCOVERYENGINE_AVAILABLE:
+    from .discovery_engine_client import discoveryengine # Get the imported module
+else:
+    discoveryengine = None # Set to None if import failed
+
+
+# --- Command Handler Functions ---
 
 def discovery_engine_command(args):
     """
     Handles the `discovery-engine` command and its subcommands.
     """
+    # Dispatch based on subcommand
     if args.subcommand == 'create-datastore':
         create_datastore_command(args)
     elif args.subcommand == 'import-documents':
@@ -22,40 +44,46 @@ def discovery_engine_command(args):
         import_documents_with_metadata_command(args)
     elif args.subcommand == 'import-document-with-metadata':
         import_document_with_metadata_command(args)
-    elif args.subcommand == 'search':
+    elif args.subcommand == 'search': # Existing chunk search
         search_command(args)
-    elif args.subcommand == 'search-by-id-and-or-date':
+    elif args.subcommand == 'search-by-id-and-or-date': # Existing chunk search
         search_by_id_and_or_date_command(args)
+    elif args.subcommand == 'search-engine': # NEW engine search
+        search_engine_command(args)
+    # Add elif for create-engine if needed
+    # elif args.subcommand == 'create-engine':
+    #    create_engine_command(args)
     else:
         console.print(f"[bold red]Unknown Discovery Engine subcommand: {args.subcommand}[/bold red]")
 
 def create_datastore_command(args):
-    """
-    Handles the `discovery-engine create-datastore` subcommand.
-    """
+    """Handles the `discovery-engine create-datastore` subcommand."""
+    console.print(f"[cyan]Initiating datastore creation for ID: {args.data_store_id}...[/cyan]")
     try:
         client = DiscoveryEngineClient(
             project_id=args.project,
-            data_store_id=args.data_store_id,
+            data_store_id=args.data_store_id, # ID for the one being created
             location=args.location
         )
+        # Assuming create_data_store exists and takes these args
         operation_name = client.create_data_store(
             type=args.type,
             chunk_size=args.chunk_size,
             collection=args.collection
         )
         console.print(f"[bold green]Datastore creation initiated. Operation name: {operation_name}[/bold green]")
+        console.print("[yellow]Note: Creation is asynchronous. Check operation status in Google Cloud Console.[/yellow]")
     except Exception as e:
         console.print(f"[bold red]Error creating datastore: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
 
 def import_documents_command(args):
-    """
-    Handles the `discovery-engine import-documents` subcommand.
-    """
+    """Handles the `discovery-engine import-documents` subcommand."""
+    console.print(f"[cyan]Initiating document import into datastore: {args.data_store_id}...[/cyan]")
     try:
         client = DiscoveryEngineClient(
             project_id=args.project,
-            data_store_id=args.data_store_id,
+            data_store_id=args.data_store_id, # Target datastore
             location=args.location
         )
         operation_name = client.import_documents(
@@ -66,39 +94,50 @@ def import_documents_command(args):
             bigquery_table=args.bigquery_table,
             bigquery_project_id=args.bigquery_project_id
         )
-        console.print(f"[bold green]Document import initiated. Operation name: {operation_name}[/bold green]")
+        if operation_name:
+            console.print(f"[bold green]Document import initiated. Operation name: {operation_name}[/bold green]")
+            console.print("[yellow]Note: Import is asynchronous. Check operation status in Google Cloud Console.[/yellow]")
+        else:
+             console.print("[bold yellow]Document import command executed, but no operation name returned (may indicate skipped due to existing data or other non-fatal issue). Check logs.[/bold yellow]")
     except Exception as e:
         console.print(f"[bold red]Error importing documents: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
 
 def import_documents_with_metadata_command(args):
-    """
-    Handles the `discovery-engine import-documents-with-metadata` subcommand.
-    """
+    """Handles the `discovery-engine import-documents-with-metadata` subcommand."""
+    console.print(f"[cyan]Initiating document import with metadata from {args.gcs_uri} into datastore: {args.data_store_id}...[/cyan]")
     try:
         client = DiscoveryEngineClient(
             project_id=args.project,
             data_store_id=args.data_store_id,
             location=args.location
         )
+        # Ensure the method exists in your client class
         operation_name = client.import_documents_with_metadata(
             gcs_uri=args.gcs_uri,
-            data_schema=args.data_schema,
+            # data_schema=args.data_schema, # This method might not need data_schema explicitly
             branch=args.branch
         )
-        console.print(f"[bold green]Document import with metadata initiated. Operation name: {operation_name}[/bold green]")
+        if operation_name:
+            console.print(f"[bold green]Document import with metadata initiated. Operation name: {operation_name}[/bold green]")
+            console.print("[yellow]Note: Import is asynchronous.[/yellow]")
+        else:
+             console.print("[bold yellow]Document import command executed, but no operation name returned.[/bold yellow]")
     except Exception as e:
         console.print(f"[bold red]Error importing documents with metadata: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
 
 def import_document_with_metadata_command(args):
-    """
-    Handles the `discovery-engine import-document-with-metadata` subcommand.
-    """
+    """Handles the `discovery-engine import-document-with-metadata` subcommand."""
+    console.print(f"[cyan]Initiating single document import with metadata for {args.gcs_uri} into datastore: {args.data_store_id}...[/cyan]")
+    metadata = None
     try:
-        # Load metadata from JSON file or string
         if args.metadata_file:
+            console.print(f"Loading metadata from file: {args.metadata_file}")
             with open(args.metadata_file, 'r') as f:
                 metadata = json.load(f)
         elif args.metadata_string:
+            console.print("Loading metadata from string.")
             metadata = json.loads(args.metadata_string)
         else:
             console.print("[bold red]Error: Must provide either --metadata-file or --metadata-string[/bold red]")
@@ -114,131 +153,355 @@ def import_document_with_metadata_command(args):
             metadata=metadata,
             branch=args.branch
         )
-        console.print(f"[bold green]Document import with metadata initiated. Operation name: {operation_name}[/bold green]")
+        if operation_name:
+            console.print(f"[bold green]Single document import initiated. Operation name: {operation_name}[/bold green]")
+            console.print("[yellow]Note: Import is asynchronous.[/yellow]")
+        else:
+             console.print("[bold yellow]Single document import command executed, but no operation name returned.[/bold yellow]")
+
+    except FileNotFoundError:
+         console.print(f"[bold red]Error: Metadata file not found at {args.metadata_file}[/bold red]")
+    except json.JSONDecodeError as e:
+         console.print(f"[bold red]Error decoding metadata JSON: {e}[/bold red]")
     except Exception as e:
         console.print(f"[bold red]Error importing document with metadata: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
 
 def search_command(args):
-    """
-    Handles the `discovery-engine search` subcommand.
-    """
+    """Handles the `discovery-engine search` subcommand (Data Store Chunks)."""
+    console.print(f"[cyan]Searching data store '{args.data_store_id}' for query: '{args.query}' (mode: chunks)[/cyan]")
     try:
         client = DiscoveryEngineClient(
             project_id=args.project,
-            data_store_id=args.data_store_id,
+            data_store_id=args.data_store_id, # Target datastore
             location=args.location
         )
-        results = client.get_chunks(
+        # This calls get_chunks which returns string or pager
+        results_data = client.get_chunks(
             query=args.query,
-            num_previous_chunks=args.num_previous_chunks,
-            num_next_chunks=args.num_next_chunks,
+            # num_previous_chunks=args.num_previous_chunks, # Ensure these args are added to parser if needed
+            # num_next_chunks=args.num_next_chunks, # Ensure these args are added to parser if needed
             page_size=args.page_size,
             parse_chunks_to_string=args.parse_chunks_to_string,
             serving_config=args.serving_config,
-            data_store_ids=args.data_store_ids
+            # data_store_ids=args.data_store_ids # Ensure these args are added to parser if needed
         )
 
         if args.parse_chunks_to_string:
-            console.print(results)  # Print the combined string
+            console.print("\n[bold magenta]--- Combined Chunk String ---[/bold magenta]")
+            console.print(results_data if results_data else "[yellow]No results found or error occurred.[/yellow]")
+        elif results_data: # It's a pager object
+            console.print("\n[bold magenta]--- Individual Chunks ---[/bold magenta]")
+            chunk_count = 0
+            try:
+                 # Iterate through the pager returned by get_chunks
+                 for page in results_data.pages:
+                     if not hasattr(page, 'results') or not page.results: continue
+                     for result in page.results:
+                          # Ensure the result structure is as expected by get_chunks
+                          if hasattr(result, 'chunk'):
+                               chunk_count += 1
+                               console.print(f"\n[bold]Chunk {chunk_count}:[/bold]")
+                               # Use the client's formatter if available
+                               console.print(client.chunk_format(result.chunk))
+                          elif hasattr(result, 'document') and hasattr(result.document, 'chunks'):
+                               # Fallback if structure is different (e.g., document with chunks)
+                               for chunk in result.document.chunks:
+                                    chunk_count += 1
+                                    console.print(f"\n[bold]Chunk {chunk_count} (from doc {result.document.id}):[/bold]")
+                                    console.print(f"  Content: {getattr(chunk, 'content', 'N/A')}")
+                                    console.print(f"  Doc Name: {getattr(chunk, 'document_metadata', {}).get('name', 'N/A')}") # Example access
+
+                 if chunk_count == 0:
+                     console.print("[yellow]No chunks found in the results.[/yellow]")
+
+            except Exception as page_err:
+                 console.print(f"[bold red]Error processing search results pager: {page_err}[/bold red]")
+                 console.print(f"[red]{traceback.format_exc()}[/red]")
         else:
-            # Process and print the results (assuming it's a SearchResponse object)
-            for result in results.results:
-                for chunk in result.document.chunks:
-                    console.print(f"Chunk: {chunk.snippet}, document name: {chunk.document_name}")
+            console.print("[yellow]No results found or error occurred.[/yellow]")
+
     except Exception as e:
-        console.print(f"[bold red]Error searching: {e}[/bold red]")
+        console.print(f"[bold red]Error during data store search: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
+
 
 def search_by_id_and_or_date_command(args):
-    """
-    Handles the `discovery-engine search-by-id-and-or-date` subcommand.
-    """
+    """Handles the `discovery-engine search-by-id-and-or-date` subcommand (Data Store Chunks)."""
+    console.print(f"[cyan]Searching data store '{args.data_store_id}' by ID/Date for query: '{args.query}' (mode: chunks)[/cyan]")
+    # Similar implementation to search_command, but calls search_by_objectId_and_or_date
     try:
         client = DiscoveryEngineClient(
             project_id=args.project,
-            data_store_id=args.data_store_id,
+            data_store_id=args.data_store_id, # Target datastore
             location=args.location
         )
-        results = client.search_by_objectId_and_or_date(
+        results_data = client.search_by_objectId_and_or_date(
             query=args.query,
             objectId=args.object_id,
             date=args.date,
-            num_previous_chunks=args.num_previous_chunks,
-            num_next_chunks=args.num_next_chunks,
+            # num_previous_chunks=args.num_previous_chunks, # Pass these through
+            # num_next_chunks=args.num_next_chunks, # Pass these through
             page_size=args.page_size,
             parse_chunks_to_string=args.parse_chunks_to_string,
             serving_config=args.serving_config,
             data_store_ids=args.data_store_ids
         )
 
+        # Output processing identical to search_command
         if args.parse_chunks_to_string:
-            console.print(results)  # Print the combined string
+            console.print("\n[bold magenta]--- Combined Chunk String (Filtered) ---[/bold magenta]")
+            console.print(results_data if results_data else "[yellow]No results found or error occurred.[/yellow]")
+        elif results_data:
+            console.print("\n[bold magenta]--- Individual Chunks (Filtered) ---[/bold magenta]")
+            chunk_count = 0
+            # ... (pager iteration identical to search_command) ...
+            try:
+                 for page in results_data.pages:
+                     # ... iterate results and chunks ...
+                      pass # Replace with actual iteration and printing
+                 if chunk_count == 0:
+                     console.print("[yellow]No chunks found in the filtered results.[/yellow]")
+            except Exception as page_err:
+                 console.print(f"[bold red]Error processing filtered search results pager: {page_err}[/bold red]")
+        else:
+            console.print("[yellow]No results found or error occurred.[/yellow]")
+
+    except Exception as e:
+        console.print(f"[bold red]Error during filtered data store search: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
+
+
+# --- NEW Search Engine Command ---
+def search_engine_command(args):
+    """Handles the `discovery-engine search-engine` subcommand."""
+    if not _DISCOVERYENGINE_AVAILABLE:
+        console.print("[bold red]Error: google-cloud-discoveryengine library is required but not installed.[/bold red]")
+        return
+
+    console.print(f"[cyan]Searching engine '{args.engine_id}' for query: '{args.query}'[/cyan]")
+
+    try:
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            # data_store_id is required by __init__ but less relevant here.
+            # Provide a default or the primary one associated with the project/engine.
+            data_store_id=args.data_store_id_for_init,
+            location=args.location
+        )
+
+        # --- Map CLI string args to Enums ---
+        query_expansion_map = {
+            "AUTO": discoveryengine.SearchRequest.QueryExpansionSpec.Condition.AUTO,
+            "DISABLED": discoveryengine.SearchRequest.QueryExpansionSpec.Condition.DISABLED,
+        }
+        spell_correction_map = {
+            "AUTO": discoveryengine.SearchRequest.SpellCorrectionSpec.Mode.AUTO,
+            "SUGGEST": discoveryengine.SearchRequest.SpellCorrectionSpec.Mode.SUGGESTION_ONLY,
+        }
+
+        query_expansion_level = query_expansion_map.get(args.query_expansion, discoveryengine.SearchRequest.QueryExpansionSpec.Condition.AUTO)
+        spell_correction_mode = spell_correction_map.get(args.spell_correction, discoveryengine.SearchRequest.SpellCorrectionSpec.Mode.AUTO)
+
+        # --- Call the search_engine method ---
+        pager = client.search_engine(
+            search_query=args.query,
+            engine_id=args.engine_id,
+            serving_config_id=args.serving_config_id,
+            collection_id=args.collection_id,
+            page_size=args.page_size,
+            return_snippet=args.return_snippet,
+            summary_result_count=args.summary_count,
+            include_citations=args.include_citations,
+            custom_prompt=args.custom_prompt,
+            model_version=args.model_version,
+            query_expansion_level=query_expansion_level,
+            spell_correction_mode=spell_correction_mode,
+            filter_str=args.filter,
+            user_pseudo_id=args.user_id,
+            # boost_spec, params, custom_fine_tuning_spec could be added here if parsed from args
+        )
+
+        # --- Process and Print Results ---
+        if pager:
+            console.print("\n[bold magenta]--- Search Engine Results ---[/bold magenta]")
+            results_found_on_any_page = False
+            page_num = 0
+            try:
+                for page in pager.pages:
+                    page_num += 1
+                    results_found_on_this_page = False
+                    console.print(f"\n[bold]--- Page {page_num} ---[/bold]")
+
+                    # Print Summary (available on the page level)
+                    if hasattr(page, 'summary') and page.summary and page.summary.summary_text:
+                        results_found_on_any_page = True
+                        results_found_on_this_page = True
+                        console.print("\n[bold green]Search Summary:[/bold green]")
+                        console.print(page.summary.summary_text)
+                        if args.include_citations and hasattr(page.summary, 'summary_with_metadata') and page.summary.summary_with_metadata:
+                             citations = page.summary.summary_with_metadata.citations
+                             if citations:
+                                  console.print("[bold cyan]Citations:[/bold cyan]")
+                                  for i, citation in enumerate(citations):
+                                       source_info = ", ".join([f"'{s.citation_source}'" for s in citation.sources]) if citation.sources else "N/A"
+                                       console.print(f"  [{i+1}] Sources: {source_info}")
+                             references = page.summary.summary_with_metadata.references
+                             if references:
+                                 console.print("[bold cyan]References:[/bold cyan]")
+                                 for ref in references:
+                                     console.print(f"  - Title: {getattr(ref, 'title', 'N/A')}, URI: {getattr(ref, 'uri', 'N/A')}") # Adjust based on actual reference structure
+
+                        console.print("-" * 20)
+
+
+                    # Print Document Results (available on the page level)
+                    if hasattr(page, 'results') and page.results:
+                         console.print(f"[bold blue]Documents Found ({len(page.results)} on this page):[/bold blue]")
+                         for i, result in enumerate(page.results):
+                              results_found_on_any_page = True
+                              results_found_on_this_page = True
+                              console.print(f"\n[bold]Result {i+1}:[/bold]")
+                              doc = result.document
+                              console.print(f"  ID: {doc.id}")
+                              console.print(f"  Name: {doc.name}")
+                              # Display structData if present
+                              if doc.struct_data:
+                                   try:
+                                       # Convert Struct to dict for nice printing
+                                       struct_dict = dict(doc.struct_data)
+                                       console.print(f"  Metadata: {json.dumps(struct_dict, indent=2)}")
+                                   except Exception:
+                                       console.print(f"  Metadata: {doc.struct_data}") # Fallback
+
+                              # Display Snippets if requested and available
+                              if args.return_snippet and 'snippets' in doc.derived_struct_data:
+                                   console.print("[bold cyan]  Snippets:[/bold cyan]")
+                                   for snippet in doc.derived_struct_data['snippets']:
+                                        console.print(f"    - {snippet.get('snippet', 'N/A').strip()}") # Adjust key if needed
+                              elif args.return_snippet:
+                                   console.print("[yellow]  (Snippets requested but not found in result)[/yellow]")
+                              console.print("-" * 5)
+                         console.print("-" * 20) # End of results list for page
+
+                    if not results_found_on_this_page:
+                         console.print("[yellow](No summary or document results on this page)[/yellow]")
+
+
+                if not results_found_on_any_page:
+                    console.print("[yellow]No results found for the search query.[/yellow]")
+
+            except Exception as page_err:
+                 console.print(f"[bold red]Error processing results pager: {page_err}[/bold red]")
+                 console.print(f"[red]{traceback.format_exc()}[/red]")
+
         else:
-            # Process and print the results (assuming it's a SearchResponse object)
-            for result in results.results:
-                for chunk in result.document.chunks:
-                    console.print(f"Chunk: {chunk.snippet}, document name: {chunk.document_name}")
+            console.print("[yellow]Search call did not return a result object (check logs for errors).[/yellow]")
+
     except Exception as e:
-        console.print(f"[bold red]Error searching by ID and/or date: {e}[/bold red]")
+        console.print(f"[bold red]Error during engine search: {e}[/bold red]")
+        console.print(f"[red]{traceback.format_exc()}[/red]")
+
+
+# --- Argparse Setup ---
 
 def setup_discovery_engine_subparser(subparsers):
     """
     Sets up the `discovery-engine` subparser and its subcommands.
     """
     discovery_engine_parser = subparsers.add_parser('discovery-engine', help='Interact with Google Cloud Discovery Engine')
-    discovery_engine_subparsers = discovery_engine_parser.add_subparsers(dest='subcommand', required=True)
+    # Add arguments common to most discovery engine commands
+    discovery_engine_parser.add_argument('--project', required=True, help='Google Cloud project ID')
+    discovery_engine_parser.add_argument('--location', default='global', help='Location (e.g., global, us, eu)')
+    # data_store_id is required by many commands, make it common if possible, else add per-command
+    # For simplicity here, adding it per command where needed or as a specific arg for client init
 
-    # Create Datastore subcommand
+    discovery_engine_subparsers = discovery_engine_parser.add_subparsers(dest='subcommand', required=True, title='Discovery Engine Subcommands')
+
+    # --- Create Datastore subcommand ---
     create_datastore_parser = discovery_engine_subparsers.add_parser('create-datastore', help='Create a new Discovery Engine datastore')
-    create_datastore_parser.add_argument('--data-store-id', required=True, help='The ID of the datastore')
-    create_datastore_parser.add_argument('--type', choices=['chunk'], default='chunk', help='The type of datastore to create')
-    create_datastore_parser.add_argument('--chunk-size', type=int, default=500, help='The size of the chunks for documents (if applicable)')
-    create_datastore_parser.add_argument('--collection', default='default_collection', help='The collection to create the datastore in')
+    create_datastore_parser.add_argument('--data-store-id', required=True, help='The ID for the new datastore')
+    create_datastore_parser.add_argument('--type', choices=['chunk'], default='chunk', help='The type of datastore (currently only chunk)')
+    create_datastore_parser.add_argument('--chunk-size', type=int, default=500, help='Chunk size for layout-based chunking (100-500)')
+    create_datastore_parser.add_argument('--collection', default='default_collection', help='Collection ID')
     create_datastore_parser.set_defaults(func=discovery_engine_command)
 
-    # Import Documents subcommand
-    import_documents_parser = discovery_engine_subparsers.add_parser('import-documents', help='Import documents into a Discovery Engine datastore')
-    import_documents_parser.add_argument('--gcs-uri', required=True, help='The GCS URI of the documents to import')
-    import_documents_parser.add_argument('--data-schema', default='content', help='The schema of the data to import')
-    import_documents_parser.add_argument('--branch', default='default_branch', help='The branch to import the documents into')
-    import_documents_parser.add_argument('--bigquery-dataset', help='The BigQuery dataset ID (if applicable)')
-    import_documents_parser.add_argument('--bigquery-table', help='The BigQuery table ID (if applicable)')
-    import_documents_parser.add_argument('--bigquery-project-id', help='The project ID of the BigQuery dataset (if applicable)')
+    # --- Import Documents subcommand ---
+    import_documents_parser = discovery_engine_subparsers.add_parser('import-documents', help='Import documents into a datastore')
+    import_documents_parser.add_argument('--data-store-id', required=True, help='The ID of the target datastore')
+    import_grp = import_documents_parser.add_mutually_exclusive_group(required=True)
+    import_grp.add_argument('--gcs-uri', help='GCS URI of documents (gs://bucket/...) or pattern (gs://bucket/*.json)')
+    import_grp.add_argument('--bigquery-source', nargs=2, metavar=('DATASET_ID', 'TABLE_ID'), help='BigQuery dataset and table ID')
+    import_documents_parser.add_argument('--data-schema', default='content', help='Data schema (content, document, custom, csv, user_event)')
+    import_documents_parser.add_argument('--branch', default='default_branch', help='Target branch')
+    import_documents_parser.add_argument('--bigquery-project-id', help='Project ID for BigQuery source (defaults to --project)')
     import_documents_parser.set_defaults(func=discovery_engine_command)
 
-    # Import Documents with Metadata subcommand
-    import_documents_with_metadata_parser = discovery_engine_subparsers.add_parser('import-documents-with-metadata', help='Import documents with metadata into a Discovery Engine datastore')
-    import_documents_with_metadata_parser.add_argument('--gcs-uri', required=True, help='The GCS URI of the documents to import (JSONL format with metadata)')
-    import_documents_with_metadata_parser.add_argument('--data-schema', default='content', help='The schema of the data to import')
-    import_documents_with_metadata_parser.add_argument('--branch', default='default_branch', help='The branch to import the documents into')
-    import_documents_with_metadata_parser.set_defaults(func=discovery_engine_command)
-
-    # Import Document with Metadata subcommand
-    import_document_with_metadata_parser = discovery_engine_subparsers.add_parser('import-document-with-metadata', help='Import a single document with metadata into a Discovery Engine datastore')
-    import_document_with_metadata_parser.add_argument('--gcs-uri', required=True, help='The GCS URI of the document to import')
-    import_document_with_metadata_parser.add_argument('--metadata-file', help='The path to a JSON file containing the metadata')
-    import_document_with_metadata_parser.add_argument('--metadata-string', help='A JSON string containing the metadata')
-    import_document_with_metadata_parser.add_argument('--branch', default='default_branch', help='The branch to import the document into')
-    import_document_with_metadata_parser.set_defaults(func=discovery_engine_command)
-
-    # Search subcommand
-    search_parser = discovery_engine_subparsers.add_parser('search', help='Search a Discovery Engine datastore')
+    # --- Import Documents with Metadata (JSONL) subcommand ---
+    import_docs_meta_parser = discovery_engine_subparsers.add_parser('import-documents-with-metadata', help='Import documents via JSONL metadata file')
+    import_docs_meta_parser.add_argument('--data-store-id', required=True, help='The ID of the target datastore')
+    import_docs_meta_parser.add_argument('--gcs-uri', required=True, help='GCS URI of the JSONL metadata file')
+    import_docs_meta_parser.add_argument('--branch', default='default_branch', help='Target branch')
+    # data_schema might not be needed if using inline source via metadata file
+    # import_docs_meta_parser.add_argument('--data-schema', default='content', help='Data schema')
+    import_docs_meta_parser.set_defaults(func=discovery_engine_command)
+
+    # --- Import Single Document with Metadata subcommand ---
+    import_doc_meta_parser = discovery_engine_subparsers.add_parser('import-document-with-metadata', help='Import a single document with metadata')
+    import_doc_meta_parser.add_argument('--data-store-id', required=True, help='The ID of the target datastore')
+    import_doc_meta_parser.add_argument('--gcs-uri', required=True, help='GCS URI of the document content')
+    meta_grp = import_doc_meta_parser.add_mutually_exclusive_group(required=True)
+    meta_grp.add_argument('--metadata-file', help='Path to a local JSON file containing metadata')
+    meta_grp.add_argument('--metadata-string', help='JSON string containing metadata')
+    import_doc_meta_parser.add_argument('--branch', default='default_branch', help='Target branch')
+    import_doc_meta_parser.set_defaults(func=discovery_engine_command)
+
+    # --- Search Data Store (Chunks) subcommand ---
+    search_parser = discovery_engine_subparsers.add_parser('search', help='Search a datastore (fetches chunks)')
     search_parser.add_argument('--query', required=True, help='The search query')
     search_parser.add_argument('--data-store-id', required=True, help='Data store ID to search')
-    search_parser.add_argument('--page-size', type=int, default=10, help='The maximum number of results to return per page')
-    search_parser.add_argument('--parse-chunks-to-string', action='store_true', help='Combine chunks into a single string')
-    search_parser.add_argument('--serving-config', default='default_serving_config', help='The serving configuration to use')
-
+    search_parser.add_argument('--page-size', type=int, default=10, help='Max results per page')
+    search_parser.add_argument('--parse-chunks-to-string', action='store_true', help='Output results as one formatted string')
+    search_parser.add_argument('--serving-config', default='default_config', help='Serving config ID for the data store')
+    # Add arguments for num_previous_chunks, num_next_chunks, data_store_ids if needed
+    # search_parser.add_argument('--num-previous-chunks', type=int, default=3)
+    # search_parser.add_argument('--num-next-chunks', type=int, default=3)
+    # search_parser.add_argument('--data-store-ids', nargs='+', help='Search across multiple data stores')
     search_parser.set_defaults(func=discovery_engine_command)
 
-    # Search by ID and/or Date subcommand
-    search_by_id_and_or_date_parser = discovery_engine_subparsers.add_parser('search-by-id-and-or-date', help='Search a Discovery Engine datastore by object ID and/or date')
-    search_by_id_and_or_date_parser.add_argument('--query', required=True, help='The search query')
-    search_by_id_and_or_date_parser.add_argument('--object-id', help='The exact object ID to filter by')
-    search_by_id_and_or_date_parser.add_argument('--date', help='The date to filter by (YYYY-MM-DD)')
-    search_by_id_and_or_date_parser.add_argument('--num-previous-chunks', type=int, default=3, help='Number of previous chunks to return for context')
-    search_by_id_and_or_date_parser.add_argument('--num-next-chunks', type=int, default=3, help='Number of next chunks to return for context')
-    search_by_id_and_or_date_parser.add_argument('--page-size', type=int, default=10, help='The maximum number of results to return per page')
-    search_by_id_and_or_date_parser.add_argument('--parse-chunks-to-string', action='store_true', help='Combine chunks into a single string')
-    search_by_id_and_or_date_parser.add_argument('--serving-config', default='default_serving_config', help='The serving configuration to use')
-    search_by_id_and_or_date_parser.add_argument('--data-store-ids', nargs='+', help='List of data store IDs to search (optional)')
-    search_by_id_and_or_date_parser.set_defaults(func=discovery_engine_command)
+    # --- Search Data Store By ID/Date (Chunks) subcommand ---
+    search_by_id_parser = discovery_engine_subparsers.add_parser('search-by-id-and-or-date', help='Search a datastore by ID/date (fetches chunks)')
+    search_by_id_parser.add_argument('--query', required=True, help='The search query')
+    search_by_id_parser.add_argument('--data-store-id', required=True, help='Data store ID to search')
+    search_by_id_parser.add_argument('--object-id', help='Object ID to filter by (exact match)')
+    search_by_id_parser.add_argument('--date', help='Date filter (YYYY-MM-DDTHH:MM:SSZ or similar ISO format)')
+    search_by_id_parser.add_argument('--page-size', type=int, default=10, help='Max results per page')
+    search_by_id_parser.add_argument('--parse-chunks-to-string', action='store_true', help='Output results as one formatted string')
+    search_by_id_parser.add_argument('--serving-config', default='default_config', help='Serving config ID')
+    # Add arguments for num_previous_chunks, num_next_chunks, data_store_ids if needed
+    # search_by_id_parser.add_argument('--num-previous-chunks', type=int, default=3)
+    # search_by_id_parser.add_argument('--num-next-chunks', type=int, default=3)
+    search_by_id_parser.add_argument('--data-store-ids', nargs='+', help='Search across multiple data stores (optional)')
+    search_by_id_parser.set_defaults(func=discovery_engine_command)
+
+    # --- NEW: Search Engine subcommand ---
+    search_engine_parser = discovery_engine_subparsers.add_parser('search-engine', help='Search a Discovery Engine (fetches documents/summary)')
+    search_engine_parser.add_argument('--query', required=True, help='The search query')
+    search_engine_parser.add_argument('--engine-id', required=True, help='Engine ID to search')
+    # Add data_store_id needed for client init, maybe make it optional if client handles it?
+    search_engine_parser.add_argument('--data-store-id-for-init', required=True, help='A primary data store ID associated with the project/engine (for client init)')
+    search_engine_parser.add_argument('--serving-config-id', default='default_config', help='Serving config ID for the engine')
+    search_engine_parser.add_argument('--collection-id', default='default_collection', help='Collection ID for the engine path')
+    search_engine_parser.add_argument('--page-size', type=int, default=10, help='Max results per page')
+    search_engine_parser.add_argument('--no-snippet', action='store_false', dest='return_snippet', help='Disable fetching snippets')
+    search_engine_parser.add_argument('--summary-count', type=int, default=5, help='Number of results for summary (0 to disable)')
+    search_engine_parser.add_argument('--no-citations', action='store_false', dest='include_citations', help='Disable citations in summary')
+    search_engine_parser.add_argument('--custom-prompt', help='Custom preamble for summary generation')
+    search_engine_parser.add_argument('--model-version', default='stable', help='Summary model version')
+    search_engine_parser.add_argument('--query-expansion', choices=['AUTO', 'DISABLED'], default='AUTO', help='Query expansion level')
+    search_engine_parser.add_argument('--spell-correction', choices=['AUTO', 'SUGGEST'], default='AUTO', help='Spell correction mode')
+    search_engine_parser.add_argument('--filter', help='Filter string to apply')
+    search_engine_parser.add_argument('--user-id', help='User pseudo ID for personalization/analytics')
+    search_engine_parser.set_defaults(func=discovery_engine_command)
+
+    # Add other subparsers for create-engine, etc. if needed

sunholo/discovery_engine/discovery_engine_client.py

@@ -1,22 +1,30 @@
+from ..custom_logging import log
+from typing import Optional, List, Dict, Any
+
+import asyncio
+import json
+import uuid
+from ..utils.mime import guess_mime_type
+import traceback
+
+_DISCOVERYENGINE_AVAILABLE = False
 try:
     from google.api_core.client_options import ClientOptions
     from google.cloud import discoveryengine
     from google.api_core.retry import Retry, if_exception_type
     from google.api_core.exceptions import ResourceExhausted, AlreadyExists
-    from google.cloud.discoveryengine_v1alpha import SearchResponse, Chunk
+    from google.api_core.exceptions import GoogleAPIError
+    from google.cloud.discoveryengine_v1 import SearchResponse, Chunk
+    from google.cloud.discoveryengine_v1.services.search_service.pagers import SearchPager, SearchAsyncPager
+    _DISCOVERYENGINE_AVAILABLE = True
 except ImportError:
     ClientOptions = None
     discoveryengine = None
     Chunk = None
     SearchResponse = None
+    SearchAsyncPager = None
+    SearchPager = None
 
-from ..custom_logging import log
-from typing import Optional, List
-import asyncio
-import json
-import uuid
-from ..utils.mime import guess_mime_type
-import traceback
 
 class DiscoveryEngineClient:
     """
@@ -848,4 +856,302 @@ class DiscoveryEngineClient:
             return await self.async_search_with_filters(query, filter_str, **kwargs)
         else:
             # No filters, perform regular search
-            return await self.async_search_with_filters(query, **kwargs)
+            return await self.async_search_with_filters(query, **kwargs)
+
+    # --- NEW ENGINE SEARCH METHODS ---
+    def search_engine(
+        self,
+        search_query: str,
+        engine_id: str,
+        serving_config_id: str = "default_config",
+        page_size: int = 10,
+        return_snippet: bool = True,
+        summary_result_count: int = 5,
+        include_citations: bool = True,
+        custom_prompt: Optional[str] = None,
+        model_version: str = "stable",
+        query_expansion_level: "discoveryengine.SearchRequest.QueryExpansionSpec.Condition" # type: ignore
+             # Default value assignment MUST be conditional
+             = discoveryengine.SearchRequest.QueryExpansionSpec.Condition.AUTO if _DISCOVERYENGINE_AVAILABLE else None,
+
+        spell_correction_mode: "discoveryengine.SearchRequest.SpellCorrectionSpec.Mode" # type: ignore
+             # Default value assignment MUST be conditional
+             = discoveryengine.SearchRequest.SpellCorrectionSpec.Mode.AUTO if _DISCOVERYENGINE_AVAILABLE else None,
+        filter_str: Optional[str] = None,
+        boost_spec: Optional["discoveryengine.SearchRequest.BoostSpec"] = None, # Okay if default is None # type: ignore
+        params: Optional[Dict[str, Any]] = None,
+        user_pseudo_id: Optional[str] = None,
+        custom_fine_tuning_spec: Optional["discoveryengine.SearchRequest.CustomFineTuningSpec"] = None, # Okay if default is None # type: ignore
+        collection_id: str = "default_collection" # Needed for engine path
+    ):
+        """
+        Performs a search against a specified Discovery Engine Search Engine.
+
+        Allows configuration for snippets, summaries, query expansion, spell correction, etc.
+
+        Args:
+            search_query: The user's search query string.
+            engine_id: The ID of the search engine to query.
+            serving_config_id: The ID of the specific serving config for the engine.
+            page_size: Maximum number of results per page.
+            return_snippet: Whether to request snippets in the results.
+            summary_result_count: Number of results to use for generating a summary.
+                                  Set to 0 to disable summaries.
+            include_citations: Whether summaries should include citations.
+            custom_prompt: A custom preamble text to guide the summary generation model.
+            model_version: The version of the summary generation model (e.g., "stable").
+            query_expansion_level: Level of query expansion to apply (AUTO, DISABLED).
+            spell_correction_mode: Mode for spell correction (AUTO, SUGGEST).
+            filter_str: An optional filter string to apply to the search.
+            boost_spec: Optional boost specification object.
+            params: Optional dictionary of custom parameters.
+            user_pseudo_id: Optional unique identifier for the user/session.
+            custom_fine_tuning_spec: Optional spec to use a fine-tuned model.
+            collection_id: The collection ID associated with the engine.
+
+        Returns:
+            A SearchPager object to iterate through results, or None if an error occurs.
+        
+        Example:
+        client = DiscoveryEngineClient(
+            project_id=PROJECT_ID,
+            data_store_id=DATA_STORE_ID,
+            location=LOCATION
+        )
+
+        # --- Example: Searching an Engine ---
+        search_query_engine = "tell me about search engines"
+        log.info(f"\n--- Searching Engine: {ENGINE_ID} ---")
+        engine_pager = client.search_engine(
+            search_query=search_query_engine,
+            engine_id=ENGINE_ID,
+            summary_result_count=3 # Request a summary for 3 results
+        )
+
+        if engine_pager:
+            results_found = False
+            # Iterate through pages to get summary/results
+            for page in engine_pager.pages:
+                 results_found = True
+                 if page.summary:
+                      print(f"\nSearch Summary:\n{page.summary.summary_text}\n")
+                      # Citations are part of the summary object if requested
+                      if page.summary.summary_with_metadata:
+                           print("Summary Metadata/Citations:")
+                           for citation in page.summary.summary_with_metadata.citations:
+                                print(f"  - Citation Source: {citation.sources}")
+                           # Access references etc. if needed
+
+                 print("Results on this page:")
+                 for result in page.results:
+                      print(f"  ID: {result.document.id}")
+                      print(f"  Name: {result.document.name}")
+                      # Access snippet if available in result.document.derived_struct_data['snippets']
+                      # Access other document fields as needed (struct_data, etc.)
+                      # print(f"  Raw Result: {result}") # For detailed inspection
+                 print("-" * 10)
+
+            if not results_found:
+                 print("No results found for the engine search.")
+        else:
+            print(f"Engine search failed for query: '{search_query_engine}'")
+
+        """
+
+        if not _DISCOVERYENGINE_AVAILABLE:
+            log.error("Discovery Engine library not available at runtime.")
+            return None
+        
+        try:
+            # Construct the serving config path for an ENGINE
+            # Note: The client library path helper is for data stores/serving configs within them.
+            # We need the path for an engine's serving config.
+            serving_config_path = (
+                f"projects/{self.project_id}/locations/{self.location}/"
+                f"collections/{collection_id}/engines/{engine_id}/"
+                f"servingConfigs/{serving_config_id}"
+            )
+            log.info(f"Using Engine Serving Config Path: {serving_config_path}")
+
+            # --- Build ContentSearchSpec ---
+            snippet_spec = None
+            if return_snippet:
+                snippet_spec = discoveryengine.SearchRequest.ContentSearchSpec.SnippetSpec(
+                    return_snippet=True
+                )
+
+            summary_spec = None
+            if summary_result_count > 0:
+                model_prompt_spec = None
+                if custom_prompt:
+                    model_prompt_spec = discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec.ModelPromptSpec(
+                        preamble=custom_prompt
+                    )
+
+                summary_spec = discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec(
+                    summary_result_count=summary_result_count,
+                    include_citations=include_citations,
+                    ignore_adversarial_query=True,  # Default from original sample
+                    ignore_non_summary_seeking_query=True, # Default from original sample
+                    model_prompt_spec=model_prompt_spec,
+                    model_spec=discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec.ModelSpec(
+                        version=model_version
+                    ),
+                )
+
+            content_search_spec = discoveryengine.SearchRequest.ContentSearchSpec(
+                snippet_spec=snippet_spec,
+                summary_spec=summary_spec,
+                # Unlike get_chunks, don't specify search_result_mode or chunk_spec here
+                # unless specifically needed for a document/snippet search use case.
+            )
+
+            # --- Build other Specs ---
+            query_expansion_spec = discoveryengine.SearchRequest.QueryExpansionSpec(
+                condition=query_expansion_level
+            )
+
+            spell_correction_spec = discoveryengine.SearchRequest.SpellCorrectionSpec(
+                mode=spell_correction_mode
+            )
+
+            # --- Build SearchRequest ---
+            request = discoveryengine.SearchRequest(
+                serving_config=serving_config_path,
+                query=search_query,
+                page_size=page_size,
+                content_search_spec=content_search_spec,
+                query_expansion_spec=query_expansion_spec,
+                spell_correction_spec=spell_correction_spec,
+                filter=filter_str,
+                boost_spec=boost_spec,
+                params=params,
+                user_pseudo_id=user_pseudo_id,
+                custom_fine_tuning_spec=custom_fine_tuning_spec,
+                # Add other relevant fields like facet_specs if needed
+            )
+
+            log.info(f"Searching engine '{engine_id}' with request: {request}")
+            response_pager = self.search_client.search(request)
+            log.info(f"Search successful for query '{search_query}' against engine '{engine_id}'.")
+            return response_pager
+
+        except GoogleAPIError as e:
+            log.error(f"API error searching engine '{engine_id}': {e}")
+            return None
+        except Exception as e:
+            log.error(f"Unexpected error searching engine '{engine_id}': {e}\n{traceback.format_exc()}")
+            return None
+
+    async def async_search_engine(
+        self,
+        search_query: str,
+        engine_id: str,
+        serving_config_id: str = "default_config",
+        page_size: int = 10,
+        return_snippet: bool = True,
+        summary_result_count: int = 5,
+        include_citations: bool = True,
+        custom_prompt: Optional[str] = None,
+        model_version: str = "stable",
+        query_expansion_level: "discoveryengine.SearchRequest.QueryExpansionSpec.Condition" # type: ignore
+             # Default value assignment MUST be conditional
+             = discoveryengine.SearchRequest.QueryExpansionSpec.Condition.AUTO if _DISCOVERYENGINE_AVAILABLE else None,
+
+        spell_correction_mode: "discoveryengine.SearchRequest.SpellCorrectionSpec.Mode" # type: ignore
+             # Default value assignment MUST be conditional
+             = discoveryengine.SearchRequest.SpellCorrectionSpec.Mode.AUTO if _DISCOVERYENGINE_AVAILABLE else None,
+        filter_str: Optional[str] = None,
+        boost_spec: Optional["discoveryengine.SearchRequest.BoostSpec"] = None, # Okay if default is None # type: ignore
+        params: Optional[Dict[str, Any]] = None,
+        user_pseudo_id: Optional[str] = None,
+        custom_fine_tuning_spec: Optional["discoveryengine.SearchRequest.CustomFineTuningSpec"] = None, # Okay if default is None # type: ignore
+        collection_id: str = "default_collection"
+    ):
+        """
+        Performs an asynchronous search against a specified Discovery Engine Search Engine.
+
+        Allows configuration for snippets, summaries, query expansion, spell correction, etc.
+
+        Args:
+            (Same arguments as the synchronous search_engine method)
+
+        Returns:
+            An SearchAsyncPager object to iterate through results asynchronously,
+            or None if an error occurs or the async client is not available.
+        """
+        if not self.async_search_client:
+             log.error("Cannot call async_search_engine: Async client not initialized.")
+             raise RuntimeError("Async client not initialized. Ensure class is instantiated within an async context.")
+
+        try:
+            # Construct the serving config path for an ENGINE (same as sync)
+            serving_config_path = (
+                f"projects/{self.project_id}/locations/{self.location}/"
+                f"collections/{collection_id}/engines/{engine_id}/"
+                f"servingConfigs/{serving_config_id}"
+            )
+            log.info(f"Using Async Engine Serving Config Path: {serving_config_path}")
+
+            # --- Build Specs (same logic as sync version) ---
+            snippet_spec = None
+            if return_snippet:
+                snippet_spec = discoveryengine.SearchRequest.ContentSearchSpec.SnippetSpec(...)
+            summary_spec = None
+            if summary_result_count > 0:
+                model_prompt_spec = None
+                if custom_prompt:
+                    model_prompt_spec = discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec.ModelPromptSpec(
+                        preamble=custom_prompt
+                    )
+                summary_spec = discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec(
+                    summary_result_count=summary_result_count,
+                    include_citations=include_citations,
+                    ignore_adversarial_query=True,  # Default from original sample
+                    ignore_non_summary_seeking_query=True, # Default from original sample
+                    model_prompt_spec=model_prompt_spec,
+                    model_spec=discoveryengine.SearchRequest.ContentSearchSpec.SummarySpec.ModelSpec(
+                        version=model_version
+                    ),
+                )
+
+            content_search_spec = discoveryengine.SearchRequest.ContentSearchSpec(
+                snippet_spec=snippet_spec,
+                summary_spec=summary_spec,
+            )
+            query_expansion_spec = discoveryengine.SearchRequest.QueryExpansionSpec(
+                condition=query_expansion_level
+            )
+
+            spell_correction_spec = discoveryengine.SearchRequest.SpellCorrectionSpec(
+                mode=spell_correction_mode
+            )
+
+            # --- Build SearchRequest (same logic as sync version) ---
+            request = discoveryengine.SearchRequest(
+                serving_config=serving_config_path,
+                query=search_query,
+                page_size=page_size,
+                content_search_spec=content_search_spec,
+                query_expansion_spec=query_expansion_spec,
+                spell_correction_spec=spell_correction_spec,
+                filter=filter_str,
+                boost_spec=boost_spec,
+                params=params,
+                user_pseudo_id=user_pseudo_id,
+                custom_fine_tuning_spec=custom_fine_tuning_spec,
+            )
+
+            log.info(f"Async searching engine '{engine_id}' with request: {request}")
+            response_pager = await self.async_search_client.search(request)
+            log.info(f"Async search successful for query '{search_query}' against engine '{engine_id}'.")
+            return response_pager
+
+        except GoogleAPIError as e:
+            log.error(f"Async API error searching engine '{engine_id}': {e}")
+            return None
+        except Exception as e:
+            log.error(f"Async unexpected error searching engine '{engine_id}': {e}\n{traceback.format_exc()}")
+            return None
+
+# --- End of DiscoveryEngineClient class ---

{sunholo-0.130.2.dist-info → sunholo-0.131.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sunholo
-Version: 0.130.2
+Version: 0.131.2
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Author-email: Holosun ApS <multivac@sunholo.com>
 License: Apache License, Version 2.0

{sunholo-0.130.2.dist-info → sunholo-0.131.2.dist-info}/RECORD

@@ -73,9 +73,9 @@ sunholo/database/sql/sb/return_sources.sql,sha256=89KAnxfK8n_qGK9jy1OQT8f9n4uYUt
 sunholo/database/sql/sb/setup.sql,sha256=CvoFvZQev2uWjmFa3aj3m3iuPFzAAJZ0S7Qi3L3-zZI,89
 sunholo/discovery_engine/__init__.py,sha256=hLgqRDJ22Aov9o2QjAEfsVgnL3kMdM-g5p8RJ9OyKdQ,130
 sunholo/discovery_engine/chunker_handler.py,sha256=wkvXl4rFtYfN6AZUKdW9_QD49Whf77BukDbO82UwlAg,7480
-sunholo/discovery_engine/cli.py,sha256=KGVle5rkLL49oF9TQhrGI--8017IvvLOEoYur545Qb0,12790
+sunholo/discovery_engine/cli.py,sha256=FegPb2BgD6Dg_K4SI6E6zxbQFcHJyyU7V6lH6axK5iU,30107
 sunholo/discovery_engine/create_new.py,sha256=WUi4_xh_dFaGX3xA9jkNKZhaR6LCELjMPeRb0hyj4FU,1226
-sunholo/discovery_engine/discovery_engine_client.py,sha256=0KhKRFKCvqvtkUOIrCXNk5353t9duuEtUQDhQnN2B24,37335
+sunholo/discovery_engine/discovery_engine_client.py,sha256=-Q6RjzMcHruXjg_WsCaqNuytHmlI4Ds3uYre9HhJduk,52195
 sunholo/discovery_engine/get_ai_search_chunks.py,sha256=I6Dt1CznqEvE7XIZ2PkLqopmjpO96iVEWJJqL5cJjOU,5554
 sunholo/embedder/__init__.py,sha256=sI4N_CqgEVcrMDxXgxKp1FsfsB4FpjoXgPGkl4N_u4I,44
 sunholo/embedder/embed_chunk.py,sha256=did2pKkWM2o0KkRcb0H9l2x_WjCq6OyuHDxGbITFKPM,6530
@@ -168,9 +168,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.130.2.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.130.2.dist-info/METADATA,sha256=Jzlwyc-jOKQkE8eUDs0iyFCd0vj6n2axdv8Usa5rxus,10084
-sunholo-0.130.2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-sunholo-0.130.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.130.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.130.2.dist-info/RECORD,,
+sunholo-0.131.2.dist-info/licenses/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.131.2.dist-info/METADATA,sha256=ZUbMnOZD_qeGDP10xyZaMxhHwv9w7AxCN7K89_50tB0,10084
+sunholo-0.131.2.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+sunholo-0.131.2.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.131.2.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.131.2.dist-info/RECORD,,

{sunholo-0.130.2.dist-info → sunholo-0.131.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.0)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any