sunholo 0.119.4__tar.gz → 0.119.7__tar.gz

{sunholo-0.119.4/src/sunholo.egg-info → sunholo-0.119.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sunholo
-Version: 0.119.4
+Version: 0.119.7
 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.119.4 → sunholo-0.119.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sunholo"
-version = "0.119.4"
+version = "0.119.7"
 description = "Large Language Model DevOps - a package to help deploy LLMs to the Cloud."
 readme = "README.md"
 requires-python = ">=3.10"

{sunholo-0.119.4 → sunholo-0.119.7}/src/sunholo/cli/cli.py

@@ -15,6 +15,7 @@ from ..excel import setup_excel_subparser
 from ..terraform import setup_tfvarseditor_subparser
 from ..senses.stream_voice import setup_tts_subparser
 from ..mcp.cli import setup_mcp_subparser
+from ..discovery_engine.cli import setup_discovery_engine_subparser
 
 from ..utils import ConfigManager
 from ..utils.version import sunholo_version
@@ -105,6 +106,8 @@ def main(args=None):
     setup_tts_subparser(subparsers)
     # anthropic MCP
     setup_mcp_subparser(subparsers)
+    # discovery engine
+    setup_discovery_engine_subparser(subparsers)
 
     #TODO: add database setup commands: alloydb and supabase
 

{sunholo-0.119.4 → sunholo-0.119.7}/src/sunholo/discovery_engine/chunker_handler.py

@@ -5,7 +5,7 @@ from ..components import load_memories
 
 from .discovery_engine_client import DiscoveryEngineClient
 from .create_new import create_new_discovery_engine
-    
+from ..embedder.embed_metadata import audit_metadata
 
 def do_discovery_engine(message_data:str, metadata:dict, config:ConfigManager=None):
     """
@@ -65,6 +65,7 @@ def do_discovery_engine(message_data:str, metadata:dict, config:ConfigManager=No
             return None
         for corp in corpuses:
             try:
+                metadata = audit_metadata(metadata, chunk_length=500)
                 response = corp.import_document_with_metadata(
                     gcs_uri=message_data,
                     metadata=metadata

sunholo-0.119.7/src/sunholo/discovery_engine/cli.py

@@ -0,0 +1,245 @@
+import json
+
+try:
+    from ..cli.sun_rich import console
+except ImportError:
+    console = None
+
+from ..custom_logging import log
+
+# Make sure to adjust the relative import path if needed
+from .discovery_engine_client import DiscoveryEngineClient  
+
+def discovery_engine_command(args):
+    """
+    Handles the `discovery-engine` command and its subcommands.
+    """
+    if args.subcommand == 'create-datastore':
+        create_datastore_command(args)
+    elif args.subcommand == 'import-documents':
+        import_documents_command(args)
+    elif args.subcommand == 'import-documents-with-metadata':
+        import_documents_with_metadata_command(args)
+    elif args.subcommand == 'import-document-with-metadata':
+        import_document_with_metadata_command(args)
+    elif args.subcommand == 'search':
+        search_command(args)
+    elif args.subcommand == 'search-by-id-and-or-date':
+        search_by_id_and_or_date_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.
+    """
+    try:
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            data_store_id=args.data_store_id,
+            location=args.location
+        )
+        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]")
+    except Exception as e:
+        console.print(f"[bold red]Error creating datastore: {e}[/bold red]")
+
+def import_documents_command(args):
+    """
+    Handles the `discovery-engine import-documents` subcommand.
+    """
+    try:
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            data_store_id=args.data_store_id,
+            location=args.location
+        )
+        operation_name = client.import_documents(
+            gcs_uri=args.gcs_uri,
+            data_schema=args.data_schema,
+            branch=args.branch,
+            bigquery_dataset=args.bigquery_dataset,
+            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]")
+    except Exception as e:
+        console.print(f"[bold red]Error importing documents: {e}[/bold red]")
+
+def import_documents_with_metadata_command(args):
+    """
+    Handles the `discovery-engine import-documents-with-metadata` subcommand.
+    """
+    try:
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            data_store_id=args.data_store_id,
+            location=args.location
+        )
+        operation_name = client.import_documents_with_metadata(
+            gcs_uri=args.gcs_uri,
+            data_schema=args.data_schema,
+            branch=args.branch
+        )
+        console.print(f"[bold green]Document import with metadata initiated. Operation name: {operation_name}[/bold green]")
+    except Exception as e:
+        console.print(f"[bold red]Error importing documents with metadata: {e}[/bold red]")
+
+def import_document_with_metadata_command(args):
+    """
+    Handles the `discovery-engine import-document-with-metadata` subcommand.
+    """
+    try:
+        # Load metadata from JSON file or string
+        if args.metadata_file:
+            with open(args.metadata_file, 'r') as f:
+                metadata = json.load(f)
+        elif args.metadata_string:
+            metadata = json.loads(args.metadata_string)
+        else:
+            console.print("[bold red]Error: Must provide either --metadata-file or --metadata-string[/bold red]")
+            return
+
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            data_store_id=args.data_store_id,
+            location=args.location
+        )
+        operation_name = client.import_document_with_metadata(
+            gcs_uri=args.gcs_uri,
+            metadata=metadata,
+            branch=args.branch
+        )
+        console.print(f"[bold green]Document import with metadata initiated. Operation name: {operation_name}[/bold green]")
+    except Exception as e:
+        console.print(f"[bold red]Error importing document with metadata: {e}[/bold red]")
+
+def search_command(args):
+    """
+    Handles the `discovery-engine search` subcommand.
+    """
+    try:
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            data_store_id=args.data_store_id,
+            location=args.location
+        )
+        results = client.get_chunks(
+            query=args.query,
+            num_previous_chunks=args.num_previous_chunks,
+            num_next_chunks=args.num_next_chunks,
+            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
+        )
+
+        if args.parse_chunks_to_string:
+            console.print(results)  # Print the combined string
+        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}")
+    except Exception as e:
+        console.print(f"[bold red]Error searching: {e}[/bold red]")
+
+def search_by_id_and_or_date_command(args):
+    """
+    Handles the `discovery-engine search-by-id-and-or-date` subcommand.
+    """
+    try:
+        client = DiscoveryEngineClient(
+            project_id=args.project,
+            data_store_id=args.data_store_id,
+            location=args.location
+        )
+        results = 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,
+            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
+        )
+
+        if args.parse_chunks_to_string:
+            console.print(results)  # Print the combined string
+        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}")
+    except Exception as e:
+        console.print(f"[bold red]Error searching by ID and/or date: {e}[/bold red]")
+
+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)
+
+    # 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.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_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')
+    search_parser.add_argument('--query', required=True, help='The search query')
+    search_parser.add_argument('--num-previous-chunks', type=int, default=3, help='Number of previous chunks to return for context')
+    search_parser.add_argument('--num-next-chunks', type=int, default=3, help='Number of next chunks to return for context')
+    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('--data-store-ids', nargs='+', help='List of data store IDs to search (optional)')
+    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)

{sunholo-0.119.4 → sunholo-0.119.7}/src/sunholo/discovery_engine/discovery_engine_client.py

@@ -177,6 +177,15 @@ class DiscoveryEngineClient:
 
         return operation.operation.name
 
+    def _search_data_store_path(self, 
+                                data_store_id: str, 
+                                collection_id: str = "default_collection", 
+                                serving_config: str = "default_serving_config"):
+        if data_store_id.startswith("projects/"):
+            return data_store_id  # Already a full path
+        
+        return f"projects/{self.project_id}/locations/{self.location}/collections/{collection_id}/dataStores/{data_store_id}"
+        
     def get_chunks(
         self,
         query: str,
@@ -185,6 +194,7 @@ class DiscoveryEngineClient:
         page_size: int = 10,
         parse_chunks_to_string: bool = True,
         serving_config: str = "default_serving_config",
+        data_store_ids: Optional[List[str]] = None,
     ):
         """Retrieves chunks or documents based on a query.
 
@@ -196,6 +206,7 @@ class DiscoveryEngineClient:
             page_size (int, optional): The maximum number of results to return per page (default is 10).
             parse_chunks_to_string: If True will put chunks in one big string, False will return object
             serving_config: The resource name of the Search serving config 
+            data_store_ids: If you want to search over many data stores, not just the one that was used to init the class. They should be of the format projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}
 
         Returns:
             discoveryengine.SearchResponse: The search response object containing the search results.
@@ -216,7 +227,6 @@ class DiscoveryEngineClient:
             serving_config
         )
 
-
         search_request = discoveryengine.SearchRequest(
             serving_config=serving_config_path,
             query=query,
@@ -230,9 +240,21 @@ class DiscoveryEngineClient:
             ),
         )
 
-        log.info(f"Discovery engine request: {search_request=}")
-        search_response = self.search_client.search(search_request)
-        
+        if data_store_ids:
+            search_request.data_store_specs = [
+                discoveryengine.SearchRequest.DataStoreSpec(
+                    data_store=self._search_data_store_path(data_store_id, serving_config=serving_config)
+                )
+                for data_store_id in data_store_ids
+            ]
+
+        try:
+            log.info(f"Discovery engine request: {search_request=}")
+            search_response = self.search_client.search(search_request)
+        except Exception as err:
+            log.warning(f"Error searching {search_request=} - no results found? {str(err)}")
+            search_response = []
+
         if parse_chunks_to_string:
 
             big_string = self.process_chunks(search_response)
@@ -251,6 +273,7 @@ class DiscoveryEngineClient:
         page_size: int = 10,
         parse_chunks_to_string: bool = True,
         serving_config: str = "default_serving_config",
+        data_store_ids: Optional[List[str]] = None,
     ):
         """Retrieves chunks or documents based on a query.
 
@@ -262,6 +285,7 @@ class DiscoveryEngineClient:
             page_size (int, optional): The maximum number of results to return per page (default is 10).
             parse_chunks_to_string: If True will put chunks in one big string, False will return object
             serving_config: The resource name of the Search serving config 
+            data_store_ids: If you want to search over many data stores, not just the one that was used to init the class. They should be of the format projects/{project}/locations/{location}/collections/{collection_id}/dataStores/{data_store_id}
 
         Returns:
             discoveryengine.SearchResponse: The search response object containing the search results.
@@ -296,9 +320,19 @@ class DiscoveryEngineClient:
             ),
         )
 
-        log.info(f"Discovery engine async request: {search_request=}")
-        search_response = await self.async_search_client.search(search_request)
-        log.info(f"Discovery engine async response: {search_response=}")
+        if data_store_ids:
+            search_request.data_store_specs = [
+                discoveryengine.SearchRequest.DataStoreSpec(data_store=data_store_id)
+                for data_store_id in data_store_ids
+            ]
+
+        try:
+            log.info(f"Discovery engine request: {search_request=}")
+            search_response = self.async_search_client.search(search_request)
+        except Exception as err:
+            log.warning(f"Error searching {search_request=} - no results found? {str(err)}")
+            search_response = []
+
         if parse_chunks_to_string:
 
             big_string = await self.async_process_chunks(search_response)
@@ -623,8 +657,91 @@ class DiscoveryEngineClient:
     def get_mime_type(self, uri:str):
         return guess_mime_type(uri)
     
-    def search_with_filters(self, query, folder=None, date=None,
+    def search_with_filters(self, query, filter_str=None,
                         num_previous_chunks=3, num_next_chunks=3, 
                         page_size=10, parse_chunks_to_string=True, 
-                        serving_config="default_serving_config"):
-        pass
+                        serving_config="default_serving_config",
+                        data_store_ids: Optional[List[str]] = None):
+        """
+        Searches with a generic filter string.
+
+        Args:
+            query (str): The search query.
+            filter_str (str, optional): The filter string to apply (e.g., "source LIKE 'my_source' AND eventTime > TIMESTAMP('2024-01-01')").
+            #... other parameters from get_chunks
+
+        Returns:
+            discoveryengine.SearchResponse or str: The search response object or string of chunks.
+        """
+
+        serving_config_path = self.search_client.serving_config_path(
+            self.project_id,
+            self.location,
+            self.data_store_id,
+            serving_config
+        )
+
+        search_request = discoveryengine.SearchRequest(
+            serving_config=serving_config_path,
+            query=query,
+            page_size=page_size, 
+            content_search_spec=discoveryengine.SearchRequest.ContentSearchSpec(
+                search_result_mode="CHUNKS", 
+                chunk_spec=discoveryengine.SearchRequest.ContentSearchSpec.ChunkSpec(
+                    num_previous_chunks=num_previous_chunks,
+                    num_next_chunks=num_next_chunks,
+                ),
+            ),
+            filter=filter_str # name:'ANY("king kong")'
+        )
+
+        if data_store_ids:
+            search_request.data_store_specs = [
+                discoveryengine.SearchRequest.DataStoreSpec(
+                    data_store=self._search_data_store_path(data_store_id, serving_config=serving_config)
+                )
+                for data_store_id in data_store_ids
+            ]
+
+
+
+        log.info(f"Discovery engine request with filter: {search_request=}")
+        try:
+            search_response = self.search_client.search(search_request)
+        except Exception as e:
+            log.info(f"No results {search_request.data_store_specs=}: {str(e)}")
+            return None
+        
+        if parse_chunks_to_string:
+            big_string = self.process_chunks(search_response)
+            log.info(f"Discovery engine chunks string sample: {big_string[:100]}")
+            return big_string
+        
+        log.info("Discovery engine response object")
+        return search_response
+
+    def search_by_objectId_and_or_date(self, query, objectId=None, date=None, **kwargs):
+        """
+        Searches and filters by objectId (exact match) and/or date.
+
+        Args:
+            query (str): The search query.
+            objectId (str, optional): The exact objectId to filter by.
+            date (str, optional): The literal_iso_8601_datetime_format date to filter by e.g. 2025-02-24T12:25:30.123Z
+            **kwargs: Additional keyword arguments to pass to `search_with_filters`.
+
+        Returns:
+            list: A list of search results.
+        """
+        filter_clauses = []
+        if objectId:
+            filter_clauses.append(f'objectId: ANY("{objectId}")')
+        if date:
+            filter_clauses.append(f'eventTime >= "{date}"')
+
+        if filter_clauses:
+            filter_str = " AND ".join(filter_clauses)  # Combine with AND
+            return self.search_with_filters(query, filter_str, **kwargs)
+        else:
+            # No filters, perform regular search
+            return self.search_with_filters(query, **kwargs)

{sunholo-0.119.4 → sunholo-0.119.7}/src/sunholo/embedder/embed_chunk.py

@@ -26,6 +26,7 @@ from ..components import get_embeddings, pick_vectorstore, load_memories, pick_e
 from ..custom_logging import log
 from ..database.uuid import generate_uuid_from_object_id
 from ..utils import ConfigManager
+from .embed_metadata import audit_metadata
 
 def embed_pubsub_chunk(data: dict):
     """Triggered from a message on a Cloud Pub/Sub topic "embed_chunk" topic
@@ -75,25 +76,7 @@ def embed_pubsub_chunk(data: dict):
     
     log.info(f"Embedding: {vector_name} page_content: {page_content[:30]}...[{len(page_content)}] - {metadata}")
 
-    if 'eventTime' not in metadata:
-        metadata['eventTime'] = datetime.datetime.now().isoformat(timespec='microseconds') + "Z"
-    metadata['eventtime'] = metadata['eventTime']
-
-    if 'source' not in metadata:
-        if 'objectId' in metadata:
-            metadata['source'] = metadata['objectId']
-        elif 'url' in metadata:
-            metadata['source'] = metadata['url']
-        else:
-            log.warning(f"No source found in metadata: {metadata}")
-    
-    if 'original_source' not in metadata:
-        metadata['original_source'] = metadata.get('source')
-    else:
-        metadata['source'] = metadata['original_source']
-    
-    if 'chunk_length' not in metadata:
-        metadata['chunk_length'] = len(page_content)
+    metadata = audit_metadata(metadata, chunk_length=len(page_content))
     
     if 'doc_id' not in metadata:
         log.warning(f"No doc_id found in metadata for {metadata['source']}- creating one")

sunholo-0.119.7/src/sunholo/embedder/embed_metadata.py

@@ -0,0 +1,27 @@
+
+import datetime
+from ..custom_logging import log
+
+def audit_metadata(metadata, chunk_length=None):
+    
+    if 'eventTime' not in metadata:
+        metadata['eventTime'] = datetime.datetime.now().isoformat(timespec='microseconds') + "Z"
+    metadata['eventtime'] = metadata['eventTime']
+
+    if 'source' not in metadata:
+        if 'objectId' in metadata:
+            metadata['source'] = metadata['objectId']
+        elif 'url' in metadata:
+            metadata['source'] = metadata['url']
+        else:
+            log.warning(f"No source found in metadata: {metadata}")
+    
+    if 'original_source' not in metadata:
+        metadata['original_source'] = metadata.get('source')
+    else:
+        metadata['source'] = metadata['original_source']
+    
+    if 'chunk_length' not in metadata:
+        metadata['chunk_length'] = chunk_length
+    
+    return metadata

{sunholo-0.119.4 → sunholo-0.119.7/src/sunholo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sunholo
-Version: 0.119.4
+Version: 0.119.7
 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.119.4 → sunholo-0.119.7}/src/sunholo.egg-info/SOURCES.txt

@@ -83,11 +83,13 @@ src/sunholo/database/sql/sb/return_sources.sql
 src/sunholo/database/sql/sb/setup.sql
 src/sunholo/discovery_engine/__init__.py
 src/sunholo/discovery_engine/chunker_handler.py
+src/sunholo/discovery_engine/cli.py
 src/sunholo/discovery_engine/create_new.py
 src/sunholo/discovery_engine/discovery_engine_client.py
 src/sunholo/discovery_engine/get_ai_search_chunks.py
 src/sunholo/embedder/__init__.py
 src/sunholo/embedder/embed_chunk.py
+src/sunholo/embedder/embed_metadata.py
 src/sunholo/excel/__init__.py
 src/sunholo/excel/plugin.py
 src/sunholo/gcs/__init__.py