sunholo 0.67.8__py3-none-any.whl → 0.68.0__py3-none-any.whl

sunholo/agents/flask/qna_routes.py

@@ -258,7 +258,12 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
             # the header forwarded
             auth_header = request.headers.get('X-Forwarded-Authorization')
             if auth_header:
-                api_key = auth_header.split(' ')[1]  # Assuming "Bearer <api_key>"
+                
+                if auth_header.startswith('Bearer '):
+                    api_key = auth_header.split(' ')[1]  # Assuming "Bearer <api_key>"
+                else:
+                    return jsonify({'error': 'Invalid authorization header does not start with "Bearer " - got: {auth_header}'}), 401
+                
                 endpoints_host = os.getenv('_ENDPOINTS_HOST')
                 if not endpoints_host:
                     return jsonify({'error': '_ENDPOINTS_HOST environment variable not found'}), 401
@@ -425,8 +430,9 @@ def register_qna_routes(app, stream_interpreter, vac_interpreter):
                 return make_openai_response(user_message, vector_name, 'ERROR: could not find an answer')
 
         except Exception as err:
-            log.error(f"OpenAI response error: {err}")
-            return jsonify({'error': f'QNA_ERROR: An error occurred: {str(err)} traceback: {traceback.format_exc()}'}), 500
+            log.error(f"OpenAI response error: {str(err)} traceback: {traceback.format_exc()}")
+            
+            return make_openai_response(user_message, vector_name, f'ERROR: {str(err)}')
 
 
 def create_langfuse_trace(request, vector_name):

sunholo/components/retriever.py

@@ -53,11 +53,16 @@ def pick_retriever(vector_name, embeddings=None):
                     continue
 
                 embeddings = embeddings or get_embeddings(vector_name)
-                read_only = value.get('readonly')
-                vectorstore = pick_vectorstore(vectorstore, 
-                                               vector_name=vector_name, 
-                                               embeddings=embeddings, 
-                                               read_only=read_only)
+                read_only = value.get('read_only')
+                try:
+                    vectorstore = pick_vectorstore(vectorstore, 
+                                                vector_name=vector_name, 
+                                                embeddings=embeddings, 
+                                                read_only=read_only)
+                except Exception as e:
+                    log.error(f"Failed to pick_vectorstore {vectorstore} for {vector_name} - {str(e)} - skipping")
+                    continue
+                
                 k_override = value.get('k', 3)
                 vs_retriever = vectorstore.as_retriever(search_kwargs=dict(k=k_override))
                 retriever_list.append(vs_retriever)
@@ -103,7 +108,7 @@ def metadata_retriever(metadata: dict, key: str, vector_name:str, embeddings=Non
                     if key not in metadata:
                         raise ValueError(f"Missing {key} in {metadata}")
                     the_id = metadata[key]
-                    read_only = value.get('readonly')
+                    read_only = value.get('read_only')
                     embeddings = embeddings or get_embeddings(vector_name)
                     vectorstore = pick_vectorstore(vectorstore, 
                                                    vector_name=the_id, 

sunholo/database/alloydb.py

@@ -1,10 +1,7 @@
 import os
 try:
-    import pg8000
-    import sqlalchemy
     from sqlalchemy.exc import DatabaseError, ProgrammingError
     from asyncpg.exceptions import DuplicateTableError
-    from google.cloud.alloydb.connector import Connector
     from langchain_google_alloydb_pg import AlloyDBEngine, Column, AlloyDBLoader, AlloyDBDocumentSaver
     from google.cloud.alloydb.connector import IPTypes
 except ImportError:
@@ -12,9 +9,12 @@ except ImportError:
     pass
 
 from .database import get_vector_size
+from .alloydb_client import AlloyDBClient
+
 from ..logging import log
 from ..utils.config import load_config_key
 
+
 def create_alloydb_engine(vector_name):
 
     if not AlloyDBEngine:
@@ -49,183 +49,6 @@ def create_alloydb_engine(vector_name):
 
     return engine
 
-class AlloyDBClient:
-    """
-    A class to manage interactions with an AlloyDB instance.
-
-    Example Usage:
-
-    ```python
-    client = AlloyDBClient(
-        project_id="your-project-id",
-        region="your-region",
-        cluster_name="your-cluster-name",
-        instance_name="your-instance-name",
-        user="your-db-user",
-        password="your-db-password"
-    )
-
-    # Create a database
-    client.execute_sql("CREATE DATABASE my_database")
-
-    # Execute other SQL statements
-    client.execute_sql("CREATE TABLE my_table (id INT, name VARCHAR(50))")
-    ```
-    """
-
-    def __init__(self, 
-                 project_id: str, 
-                 region: str, 
-                 cluster_name:str, 
-                 instance_name:str, 
-                 user:str, 
-                 password=None, 
-                 db="postgres"):
-        """Initializes the AlloyDB client.
-         - project_id (str): GCP project ID where the AlloyDB instance resides.
-         - region (str): The region where the AlloyDB instance is located.
-         - cluster_name (str): The name of the AlloyDB cluster.
-         - instance_name (str): The name of the AlloyDB instance.
-         - user (str): The database user name.
-         - password (str): The database user's password.
-         - db_name (str): The name of the database.
-        """
-        self.connector = Connector()
-        self.inst_uri = self._build_instance_uri(project_id, region, cluster_name, instance_name)
-        self.engine = self._create_engine(self.inst_uri, user, password, db)
-
-    def _build_instance_uri(self, project_id, region, cluster_name, instance_name):
-        return f"projects/{project_id}/locations/{region}/clusters/{cluster_name}/instances/{instance_name}"
-
-    def _create_engine(self, inst_uri, user, password, db):
-        def getconn() -> pg8000.dbapi.Connection:
-            conn = self.connector.connect(
-                inst_uri,
-                "pg8000",
-                user=user,
-                password=password,
-                db=db,
-                enable_iam_auth=True,
-            )
-            return conn
-
-        engine = sqlalchemy.create_engine(
-            "postgresql+pg8000://", 
-            isolation_level="AUTOCOMMIT", 
-            creator=getconn
-        )
-        engine.dialect.description_encoding = None
-        log.info(f"Created AlloyDB engine for {inst_uri} and user: {user}")
-        return engine
-
-    def execute_sql(self, sql_statement):
-        """Executes a given SQL statement with error handling.
-
-         - sql_statement (str): The SQL statement to execute.
-         - Returns: The result of the execution, if any.
-        """
-        sql_ = sqlalchemy.text(sql_statement)
-        result = None
-        with self.engine.connect() as conn:
-            try:
-                log.info(f"Executing SQL statement: {sql_}")
-                result = conn.execute(sql_)
-            except DatabaseError as e:
-                if "already exists" in str(e):
-                    log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
-                else:
-                    raise  
-            finally:
-                conn.close()
-
-        return result
-
-    @staticmethod
-    def _and_or_ilike(sources, search_type="OR", operator="ILIKE"):
-        unique_sources = set(sources)
-        # Choose the delimiter based on the search_type argument
-        delimiter = ' AND ' if search_type.upper() == "AND" else ' OR '
-
-        # Build the conditional expressions based on the chosen delimiter
-        conditions = delimiter.join(f"TRIM(source) {operator} '%{source}%'" for source in unique_sources)
-        if not conditions:
-            log.warning("Alloydb doc query found no like_patterns")
-            return []
-        
-        return conditions
-
-    def delete_sources_from_alloydb(self, sources, vector_name):
-        """
-        Deletes from both vectorstore and docstore
-        """
-
-        vector_length = get_vector_size(vector_name)
-
-        conditions = self._and_or_ilike(sources, operator="=")
-
-        if not conditions:
-            log.warning("No conditions were specified, not deleting whole table!")
-            return False
-
-        query = f"""
-            DELETE FROM {vector_name}_docstore
-            WHERE {conditions};
-            DELETE FROM {vector_name}_vectorstore_{vector_length}
-            WHERE {conditions}
-        """
-
-        return self.execute_sql(query)
-
-    def create_database(self, database_name):
-        self.execute_sql(f'CREATE DATABASE "{database_name}"')
-
-    def fetch_owners(self):
-        owners = self.execute_sql('SELECT table_schema, table_name, privilege_type FROM information_schema.table_privileges')
-        for row in owners:
-            print(f"Schema: {row[0]}, Table: {row[1]}, Privilege: {row[2]}")
-        return owners
-
-    def create_schema(self, schema_name="public"):
-        self.execute_sql(f'CREATE SCHEMA IF NOT EXISTS {schema_name};')
-
-    def grant_permissions(self, schema_name, users):
-        for user in users:
-            self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA {schema_name} TO "{user}";')
-            self.execute_sql(f'GRANT USAGE, CREATE ON SCHEMA {schema_name} TO "{user}";')
-            self.execute_sql(f'ALTER DEFAULT PRIVILEGES IN SCHEMA {schema_name} GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "{user}";')
-            self.execute_sql(f'GRANT USAGE ON SCHEMA information_schema TO "{user}";')
-            self.execute_sql(f'GRANT SELECT ON information_schema.columns TO "{user}";')
-
-    def create_docstore_tables(self, vector_names, users):
-        for vector_name in vector_names:
-            table_name = f"{vector_name}_docstore"
-            sql = f'''
-            CREATE TABLE IF NOT EXISTS "{table_name}" 
-            (page_content TEXT, doc_id UUID, source TEXT, images_gsurls JSONB, chunk_metadata JSONB, langchain_metadata JSONB)
-            '''
-            self.execute_sql(sql)
-
-            for user in users:
-                self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";')
-
-            vectorstore_id = f"{vector_name}_vectorstore_1536"
-            sql = f'''
-            CREATE TABLE IF NOT EXISTS "{vectorstore_id}" (
-            langchain_id UUID NOT NULL,
-            content TEXT NOT NULL,
-            embedding vector NOT NULL,
-            source TEXT,
-            langchain_metadata JSONB,
-            docstore_doc_id UUID,
-            eventTime TIMESTAMPTZ
-            );
-            '''
-            self.execute_sql(sql)
-
-            for user in users:
-                self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE {vectorstore_id} TO "{user}";')
-
-
 alloydb_table_cache = {}  # Our cache, initially empty  # noqa: F841
 def create_alloydb_table(vector_name, engine, type = "vectorstore", alloydb_config=None, username=None):
     global alloydb_table_cache
@@ -240,9 +63,6 @@ def create_alloydb_table(vector_name, engine, type = "vectorstore", alloydb_conf
 
                 return table_name
             
-            alloydb_table_cache[table_name] = True 
-            return table_name
-            
             log.info(f"# Creating AlloyDB table {table_name}")
             try:
                 engine.init_vectorstore_table(

sunholo/database/alloydb_client.py

@@ -0,0 +1,196 @@
+try:
+    import pg8000
+    import sqlalchemy
+    from sqlalchemy.exc import DatabaseError, ProgrammingError
+    from google.cloud.alloydb.connector import Connector
+except ImportError:
+    AlloyDBEngine = None
+    pass
+
+from .database import get_vector_size
+from ..logging import log
+
+class AlloyDBClient:
+    """
+    A class to manage interactions with an AlloyDB instance.
+
+    Example Usage:
+
+    ```python
+    client = AlloyDBClient(
+        project_id="your-project-id",
+        region="your-region",
+        cluster_name="your-cluster-name",
+        instance_name="your-instance-name",
+        user="your-db-user",
+        password="your-db-password"
+    )
+
+    # Create a database
+    client.execute_sql("CREATE DATABASE my_database")
+
+    # Execute other SQL statements
+    client.execute_sql("CREATE TABLE my_table (id INT, name VARCHAR(50))")
+    ```
+    """
+
+    def __init__(self, 
+                 project_id: str, 
+                 region: str, 
+                 cluster_name:str, 
+                 instance_name:str, 
+                 user:str, 
+                 password=None, 
+                 db="postgres"):
+        """Initializes the AlloyDB client.
+         - project_id (str): GCP project ID where the AlloyDB instance resides.
+         - region (str): The region where the AlloyDB instance is located.
+         - cluster_name (str): The name of the AlloyDB cluster.
+         - instance_name (str): The name of the AlloyDB instance.
+         - user (str): The database user name.
+         - password (str): The database user's password.
+         - db_name (str): The name of the database.
+        """
+        self.connector = Connector()
+        self.inst_uri = self._build_instance_uri(project_id, region, cluster_name, instance_name)
+        self.engine = self._create_engine(self.inst_uri, user, password, db)
+
+    def _build_instance_uri(self, project_id, region, cluster_name, instance_name):
+        return f"projects/{project_id}/locations/{region}/clusters/{cluster_name}/instances/{instance_name}"
+
+    def _create_engine(self, inst_uri, user, password, db):
+        def getconn() -> pg8000.dbapi.Connection:
+            conn = self.connector.connect(
+                inst_uri,
+                "pg8000",
+                user=user,
+                password=password,
+                db=db,
+                enable_iam_auth=True,
+            )
+            return conn
+
+        engine = sqlalchemy.create_engine(
+            "postgresql+pg8000://", 
+            isolation_level="AUTOCOMMIT", 
+            creator=getconn
+        )
+        engine.dialect.description_encoding = None
+        log.info(f"Created AlloyDB engine for {inst_uri} and user: {user}")
+        return engine
+
+    def execute_sql(self, sql_statement):
+        """Executes a given SQL statement with error handling.
+
+         - sql_statement (str): The SQL statement to execute.
+         - Returns: The result of the execution, if any.
+        """
+        sql_ = sqlalchemy.text(sql_statement)
+        result = None
+        with self.engine.connect() as conn:
+            try:
+                log.info(f"Executing SQL statement: {sql_}")
+                result = conn.execute(sql_)
+            except DatabaseError as e:
+                if "already exists" in str(e):
+                    log.warning(f"Error ignored: {str(e)}. Assuming object already exists.")
+                else:
+                    raise  
+            finally:
+                conn.close()
+
+        return result
+
+    @staticmethod
+    def _and_or_ilike(sources, search_type="OR", operator="ILIKE"):
+        unique_sources = set(sources)
+        # Choose the delimiter based on the search_type argument
+        delimiter = ' AND ' if search_type.upper() == "AND" else ' OR '
+
+        # Build the conditional expressions based on the chosen delimiter
+        conditions = delimiter.join(f"TRIM(source) {operator} '%{source}%'" for source in unique_sources)
+        if not conditions:
+            log.warning("Alloydb doc query found no like_patterns")
+            return []
+        
+        return conditions
+
+    def delete_sources_from_alloydb(self, sources, vector_name):
+        """
+        Deletes from both vectorstore and docstore
+        """
+
+        vector_length = get_vector_size(vector_name)
+
+        conditions = self._and_or_ilike(sources, operator="=")
+
+        if not conditions:
+            log.warning("No conditions were specified, not deleting whole table!")
+            return False
+
+        query = f"""
+            DELETE FROM {vector_name}_docstore
+            WHERE {conditions};
+            DELETE FROM {vector_name}_vectorstore_{vector_length}
+            WHERE {conditions}
+        """
+
+        return self.execute_sql(query)
+
+    def create_database(self, database_name):
+        self.execute_sql(f'CREATE DATABASE "{database_name}"')
+
+    def fetch_owners(self):
+        owners = self.execute_sql('SELECT table_schema, table_name, privilege_type FROM information_schema.table_privileges')
+        for row in owners:
+            print(f"Schema: {row[0]}, Table: {row[1]}, Privilege: {row[2]}")
+        return owners
+
+    def create_schema(self, schema_name="public"):
+        self.execute_sql(f'CREATE SCHEMA IF NOT EXISTS {schema_name};')
+
+    def grant_schema_permissions(self, schema_name, users):
+        for user in users:
+            self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA {schema_name} TO "{user}";')
+            self.execute_sql(f'GRANT USAGE, CREATE ON SCHEMA {schema_name} TO "{user}";')
+            self.execute_sql(f'ALTER DEFAULT PRIVILEGES IN SCHEMA {schema_name} GRANT SELECT, INSERT, UPDATE, DELETE ON TABLES TO "{user}";')
+            self.execute_sql(f'GRANT USAGE ON SCHEMA information_schema TO "{user}";')
+            self.execute_sql(f'GRANT SELECT ON information_schema.columns TO "{user}";')
+    
+    def grant_table_permissions(self, table_name, users):
+        for user in users:
+            self.execute_sql(f'GRANT SELECT, INSERT, UPDATE, DELETE ON TABLE "{table_name}" TO "{user}";')
+    
+    def create_tables(self, vector_name, users):
+        self.create_docstore_table(vector_name, users)
+        self.create_vectorstore_table(vector_name, users)
+
+    def create_docstore_table(self, vector_name: str, users):
+        table_name = f"{vector_name}_vectorstore"
+        sql = f'''
+        CREATE TABLE IF NOT EXISTS "{table_name}" 
+        (page_content TEXT, doc_id UUID, source TEXT, images_gsurls JSONB, chunk_metadata JSONB, langchain_metadata JSONB)
+        '''
+        self.execute_sql(sql)
+
+        self.grant_table_permissions(table_name, users)
+
+    def create_vectorstore_table(self, vector_name: str, users):
+        from .database import get_vector_size
+        vector_size = get_vector_size(vector_name)
+        vectorstore_id = f"{vector_name}_{type}_{vector_size}"
+
+        sql = f'''
+        CREATE TABLE IF NOT EXISTS "{vectorstore_id}" (
+        langchain_id UUID NOT NULL,
+        content TEXT NOT NULL,
+        embedding vector NOT NULL,
+        source TEXT,
+        langchain_metadata JSONB,
+        docstore_doc_id UUID,
+        eventTime TIMESTAMPTZ
+        );
+        '''
+        self.execute_sql(sql)
+
+        self.grant_table_permissions(vectorstore_id, users)

sunholo/gcs/add_file.py

@@ -26,6 +26,10 @@ from ..utils.config import load_config_key
 
 
 def handle_base64_image(base64_data, vector_name):
+    model = load_config_key("llm", vector_name, "vacConfig")
+    if model.startswith("openai"): # pass it to gpt directly
+        return base64_data, base64_data.split(",",1)
+    
     try:
         header, encoded = base64_data.split(",", 1)
         data = base64.b64decode(encoded)

{sunholo-0.67.8.dist-info → sunholo-0.68.0.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.67.8
+Version: 0.68.0
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.67.8.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.68.0.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.67.8.dist-info → sunholo-0.68.0.dist-info}/RECORD

@@ -13,7 +13,7 @@ sunholo/agents/fastapi/base.py,sha256=clk76cHbUAvU0OYJrRfCWX_5f0ACbhDsIzYBhI3wyo
 sunholo/agents/fastapi/qna_routes.py,sha256=DgK4Btu5XriOC1JaRQ4G_nWEjJfnQ0J5pyLanF6eF1g,3857
 sunholo/agents/flask/__init__.py,sha256=uqfHNw2Ru3EJ4dJEcbp86h_lkquBQPMxZbjhV_xe3rs,72
 sunholo/agents/flask/base.py,sha256=FgSaCODyoTtlstJtsqlLPScdgRUtv9_plxftdzHdVFo,809
-sunholo/agents/flask/qna_routes.py,sha256=tEsJRnnGoz_cOEaPtPpCCD920jZpLypLK58UzIxe1Ac,21659
+sunholo/agents/flask/qna_routes.py,sha256=oDZzI0FllRD5GZI_C8EbKvvBSrgRlvmpwQc7lp54Krs,21926
 sunholo/archive/__init__.py,sha256=qNHWm5rGPVOlxZBZCpA1wTYPbalizRT7f8X4rs2t290,31
 sunholo/archive/archive.py,sha256=C-UhG5x-XtZ8VheQp92IYJqgD0V3NFQjniqlit94t18,1197
 sunholo/auth/__init__.py,sha256=4owDjSaWYkbTlPK47UHTOC0gCWbZsqn4ZIEw5NWZTlg,28
@@ -44,10 +44,11 @@ sunholo/cli/sun_rich.py,sha256=UpMqeJ0C8i0pkue1AHnnyyX0bFJ9zZeJ7HBR6yhuA8A,54
 sunholo/cli/swagger.py,sha256=absYKAU-7Yd2eiVNUY-g_WLl2zJfeRUNdWQ0oH8M_HM,1564
 sunholo/components/__init__.py,sha256=IDoylb74zFKo6NIS3RQqUl0PDFBGVxM1dfUmO7OJ44U,176
 sunholo/components/llm.py,sha256=T4we3tGmqUj4tPwxQr9M6AXv_BALqZV_dRSvINan-oU,10374
-sunholo/components/retriever.py,sha256=8_qA7IZvhWWbTplZK3A6x4DlBsGGAaF_NYX6Fn9QGug,6147
+sunholo/components/retriever.py,sha256=jltG91N5r2P9RWKPW8A8tU3ilghciBczxapauW83Ir8,6377
 sunholo/components/vectorstore.py,sha256=BxtMF_wX8Zrexr67P07OTSJPjucTewmcPM5OQwIXHPM,5630
 sunholo/database/__init__.py,sha256=Zz0Shcq-CtStf9rJGIYB_Ybzb8rY_Q9mfSj-nviM490,241
-sunholo/database/alloydb.py,sha256=UeWbk_DAqivquMGibX_tz8v1Jza9qnf4SWThNBG2Dh4,17327
+sunholo/database/alloydb.py,sha256=d9W0pbZB0jTVIGF5OVaQ6kXHo-X3-6e9NpWNmV5e9UY,10464
+sunholo/database/alloydb_client.py,sha256=AYA0SSaBy-1XEfeZI97sMGehfrwnfbwZ8sE0exzI2E0,7254
 sunholo/database/database.py,sha256=UDHkceiEvJmS3esQX2LYEjEMrHcogN_JHuJXoVWCH3M,7354
 sunholo/database/lancedb.py,sha256=2rAbJVusMrm5TPtVTsUtmwn0z1iZ_wvbKhc6eyT6ClE,708
 sunholo/database/static_dbs.py,sha256=aOyU3AJ-Dzz3qSNjbuN2293cfYw5PhkcQuQxdwPMJ4w,435
@@ -61,7 +62,7 @@ sunholo/database/sql/sb/setup.sql,sha256=CvoFvZQev2uWjmFa3aj3m3iuPFzAAJZ0S7Qi3L3
 sunholo/embedder/__init__.py,sha256=sI4N_CqgEVcrMDxXgxKp1FsfsB4FpjoXgPGkl4N_u4I,44
 sunholo/embedder/embed_chunk.py,sha256=P744zUQJgqrjILunzaqtTerB9AwoXFU6tXBtz4rjWgQ,6673
 sunholo/gcs/__init__.py,sha256=DtVw_AZwQn-IguR5BJuIi2XJeF_FQXizhJikzRNrXiE,50
-sunholo/gcs/add_file.py,sha256=ILU3Nq-rYjL0Ini9op6jBYtXCDl3iTO61ZA1q2zykJQ,5537
+sunholo/gcs/add_file.py,sha256=y2s7ZZBiJD3pu1TqRAy0s1SRGvHvzJqSDaYD-MFFh1c,5717
 sunholo/gcs/download_url.py,sha256=8XSEf8byfubqs5CMQeF_tn9wxqwUTq3n9mo5mLNIUTA,4801
 sunholo/gcs/metadata.py,sha256=C9sMPsHsq1ETetdQCqB3EBs3Kws8b8QHS9L7ei_v5aw,891
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -105,9 +106,9 @@ sunholo/vertex/__init__.py,sha256=JvHcGFuv6R_nAhY2AdoqqhMpJ5ugeWPZ_svGhWrObBk,13
 sunholo/vertex/init.py,sha256=JDMUaBRdednzbKF-5p33qqLit2LMsvgvWW-NRz0AqO0,1801
 sunholo/vertex/memory_tools.py,sha256=8F1iTWnqEK9mX4W5RzCVKIjydIcNp6OFxjn_dtQ3GXo,5379
 sunholo/vertex/safety.py,sha256=3meAX0HyGZYrH7rXPUAHxtI_3w_zoy_RX7Shtkoa660,1275
-sunholo-0.67.8.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.67.8.dist-info/METADATA,sha256=ykhSJT_lwZb0G5IkCAlUPzUcUKOvi8Qhcb0riHi0NYI,6155
-sunholo-0.67.8.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
-sunholo-0.67.8.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.67.8.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.67.8.dist-info/RECORD,,
+sunholo-0.68.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.68.0.dist-info/METADATA,sha256=G2k3HIbR1aD0HK5mrD_Rr8E_jusewG5z8dgW_DCsmiA,6155
+sunholo-0.68.0.dist-info/WHEEL,sha256=mguMlWGMX-VHnMpKOjjQidIo1ssRlCFu4a4mBpz1s2M,91
+sunholo-0.68.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.68.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.68.0.dist-info/RECORD,,