vanna 0.7.5__py3-none-any.whl → 0.7.7__py3-none-any.whl

vanna/base/base.py

@@ -306,7 +306,7 @@ class VannaBase(ABC):
 
         message_log = [
             self.system_message(
-                f"You are a helpful data assistant. The user asked the question: '{question}'\n\nThe SQL query for this question was: {sql}\n\nThe following is a pandas DataFrame with the results of the query: \n{df.to_markdown()}\n\n"
+                f"You are a helpful data assistant. The user asked the question: '{question}'\n\nThe SQL query for this question was: {sql}\n\nThe following is a pandas DataFrame with the results of the query: \n{df.head(25).to_markdown()}\n\n"
             ),
             self.user_message(
                 f"Generate a list of {n_questions} followup questions that the user might ask about this data. Respond with a list of questions, one per line. Do not answer with any explanations -- just the questions. Remember that there should be an unambiguous SQL query that can be generated from the question. Prefer questions that are answerable outside of the context of this conversation. Prefer questions that are slight modifications of the SQL query that was generated that allow digging deeper into the data. Each question will be turned into a button that the user can click to generate a new SQL query so don't use 'example' type questions. Each question must have a one-to-one correspondence with an instantiated SQL query." +
@@ -689,6 +689,9 @@ class VannaBase(ABC):
         return response
 
     def _extract_python_code(self, markdown_string: str) -> str:
+        # Strip whitespace to avoid indentation errors in LLM-generated code
+        markdown_string = markdown_string.strip()
+
         # Regex pattern to match Python code blocks
         pattern = r"```[\w\s]*python\n([\s\S]*?)```|```([\s\S]*?)```"
 
@@ -1167,7 +1170,7 @@ class VannaBase(ABC):
         vn.connect_to_oracle(
         user="username",
         password="password",
-        dns="host:port/sid",
+        dsn="host:port/sid",
         )
         ```
         Args:

vanna/cohere/__init__.py

@@ -0,0 +1,2 @@
+from .cohere_chat import Cohere_Chat
+from .cohere_embeddings import Cohere_Embeddings 

vanna/cohere/cohere_chat.py

@@ -0,0 +1,94 @@
+import os
+
+from openai import OpenAI
+
+from ..base import VannaBase
+
+
+class Cohere_Chat(VannaBase):
+    def __init__(self, client=None, config=None):
+        VannaBase.__init__(self, config=config)
+
+        # default parameters - can be overridden using config
+        self.temperature = 0.2  # Lower temperature for more precise SQL generation
+        self.model = "command-a-03-2025"  # Cohere's default model
+
+        if config is not None:
+            if "temperature" in config:
+                self.temperature = config["temperature"]
+            if "model" in config:
+                self.model = config["model"]
+
+        if client is not None:
+            self.client = client
+            return
+
+        # Check for API key in environment variable
+        api_key = os.getenv("COHERE_API_KEY")
+        
+        # Check for API key in config
+        if config is not None and "api_key" in config:
+            api_key = config["api_key"]
+            
+        # Validate API key
+        if not api_key:
+            raise ValueError("Cohere API key is required. Please provide it via config or set the COHERE_API_KEY environment variable.")
+            
+        # Initialize client with validated API key
+        self.client = OpenAI(
+            base_url="https://api.cohere.ai/compatibility/v1",
+            api_key=api_key,
+        )
+
+    def system_message(self, message: str) -> any:
+        return {"role": "developer", "content": message}  # Cohere uses 'developer' for system role
+
+    def user_message(self, message: str) -> any:
+        return {"role": "user", "content": message}
+
+    def assistant_message(self, message: str) -> any:
+        return {"role": "assistant", "content": message}
+
+    def submit_prompt(self, prompt, **kwargs) -> str:
+        if prompt is None:
+            raise Exception("Prompt is None")
+
+        if len(prompt) == 0:
+            raise Exception("Prompt is empty")
+
+        # Count the number of tokens in the message log
+        # Use 4 as an approximation for the number of characters per token
+        num_tokens = 0
+        for message in prompt:
+            num_tokens += len(message["content"]) / 4
+
+        # Use model from kwargs, config, or default
+        model = kwargs.get("model", self.model)
+        if self.config is not None and "model" in self.config and model == self.model:
+            model = self.config["model"]
+
+        print(f"Using model {model} for {num_tokens} tokens (approx)")
+        try:
+            response = self.client.chat.completions.create(
+                model=model,
+                messages=prompt,
+                temperature=self.temperature,
+            )
+            
+            # Check if response has expected structure
+            if not response or not hasattr(response, 'choices') or not response.choices:
+                raise ValueError("Received empty or malformed response from API")
+                
+            if not response.choices[0] or not hasattr(response.choices[0], 'message'):
+                raise ValueError("Response is missing expected 'message' field")
+                
+            if not hasattr(response.choices[0].message, 'content'):
+                raise ValueError("Response message is missing expected 'content' field")
+                
+            return response.choices[0].message.content
+            
+        except Exception as e:
+            # Log the error and raise a more informative exception
+            error_msg = f"Error processing Cohere chat response: {str(e)}"
+            print(error_msg)
+            raise Exception(error_msg) 

vanna/cohere/cohere_embeddings.py

@@ -0,0 +1,71 @@
+import os
+
+from openai import OpenAI
+
+from ..base import VannaBase
+
+
+class Cohere_Embeddings(VannaBase):
+    def __init__(self, client=None, config=None):
+        VannaBase.__init__(self, config=config)
+        
+        # Default embedding model
+        self.model = "embed-multilingual-v3.0"
+        
+        if config is not None and "model" in config:
+            self.model = config["model"]
+
+        if client is not None:
+            self.client = client
+            return
+
+        # Check for API key in environment variable
+        api_key = os.getenv("COHERE_API_KEY")
+        
+        # Check for API key in config
+        if config is not None and "api_key" in config:
+            api_key = config["api_key"]
+            
+        # Validate API key
+        if not api_key:
+            raise ValueError("Cohere API key is required. Please provide it via config or set the COHERE_API_KEY environment variable.")
+            
+        # Initialize client with validated API key
+        self.client = OpenAI(
+            base_url="https://api.cohere.ai/compatibility/v1",
+            api_key=api_key,
+        )
+
+    def generate_embedding(self, data: str, **kwargs) -> list[float]:
+        if not data:
+            raise ValueError("Cannot generate embedding for empty input data")
+            
+        # Use model from kwargs, config, or default
+        model = kwargs.get("model", self.model)
+        if self.config is not None and "model" in self.config and model == self.model:
+            model = self.config["model"]
+        
+        try:    
+            embedding = self.client.embeddings.create(
+                model=model,
+                input=data,
+                encoding_format="float",  # Ensure we get float values
+            )
+            
+            # Check if response has expected structure
+            if not embedding or not hasattr(embedding, 'data') or not embedding.data:
+                raise ValueError("Received empty or malformed embedding response from API")
+                
+            if not embedding.data[0] or not hasattr(embedding.data[0], 'embedding'):
+                raise ValueError("Embedding response is missing expected 'embedding' field")
+                
+            if not embedding.data[0].embedding:
+                raise ValueError("Received empty embedding vector")
+                
+            return embedding.data[0].embedding
+            
+        except Exception as e:
+            # Log the error and raise a more informative exception
+            error_msg = f"Error generating embedding with Cohere: {str(e)}"
+            print(error_msg)
+            raise Exception(error_msg) 

vanna/deepseek/__init__.py

@@ -0,0 +1 @@
+from .deepseek_chat import DeepSeekChat

vanna/deepseek/deepseek_chat.py

@@ -0,0 +1,60 @@
+import os
+
+from openai import OpenAI
+
+from ..base import VannaBase
+
+
+
+# from vanna.chromadb import ChromaDB_VectorStore
+
+# class DeepSeekVanna(ChromaDB_VectorStore, DeepSeekChat):
+#     def __init__(self, config=None):
+#         ChromaDB_VectorStore.__init__(self, config=config)
+#         DeepSeekChat.__init__(self, config=config)
+
+# vn = DeepSeekVanna(config={"api_key": "sk-************", "model": "deepseek-chat"})
+
+
+class DeepSeekChat(VannaBase):
+    def __init__(self, config=None):
+        if config is None:
+            raise ValueError(
+                "For DeepSeek, config must be provided with an api_key and model"
+            )
+        if "api_key" not in config:
+            raise ValueError("config must contain a DeepSeek api_key")
+
+        if "model" not in config:
+            raise ValueError("config must contain a DeepSeek model")
+    
+        api_key = config["api_key"]
+        model = config["model"]
+        self.model = model
+        self.client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com/v1")
+        
+    def system_message(self, message: str) -> any:
+        return {"role": "system", "content": message}
+
+    def user_message(self, message: str) -> any:
+        return {"role": "user", "content": message}
+
+    def assistant_message(self, message: str) -> any:
+        return {"role": "assistant", "content": message}
+
+    def generate_sql(self, question: str, **kwargs) -> str:
+        # 使用父类的 generate_sql
+        sql = super().generate_sql(question, **kwargs)
+        
+        # 替换 "\_" 为 "_"
+        sql = sql.replace("\\_", "_")
+        
+        return sql
+
+    def submit_prompt(self, prompt, **kwargs) -> str:
+        chat_response = self.client.chat.completions.create(
+            model=self.model,
+            messages=prompt,
+        )
+        
+        return chat_response.choices[0].message.content

vanna/google/gemini_chat.py

@@ -1,4 +1,5 @@
 import os
+
 from ..base import VannaBase
 
 
@@ -30,8 +31,29 @@ class GoogleGeminiChat(VannaBase):
             self.chat_model = genai.GenerativeModel(model_name)
         else:
             # Authenticate using VertexAI
+            import google.auth
+            import vertexai
             from vertexai.generative_models import GenerativeModel
-            self.chat_model = GenerativeModel(model_name)
+
+            json_file_path = config.get("google_credentials")  # Assuming the JSON file path is provided in the config
+
+            if not json_file_path or not os.path.exists(json_file_path):
+                raise FileNotFoundError(f"JSON credentials file not found at: {json_file_path}")
+
+            try:
+                # Validate and set the JSON file path for GOOGLE_APPLICATION_CREDENTIALS
+                os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = json_file_path
+
+                # Initialize VertexAI with the credentials
+                credentials, _ = google.auth.default()
+                vertexai.init(credentials=credentials)
+                self.chat_model = GenerativeModel(model_name)
+            except google.auth.exceptions.DefaultCredentialsError as e:
+                raise RuntimeError(f"Default credentials error: {e}")
+            except google.auth.exceptions.TransportError as e:
+                raise RuntimeError(f"Transport error during authentication: {e}")
+            except Exception as e:
+                raise RuntimeError(f"Failed to authenticate using JSON file: {e}")
 
     def system_message(self, message: str) -> any:
         return message

vanna/ollama/ollama.py

@@ -91,7 +91,7 @@ class Ollama(VannaBase):
       f"model={self.model},\n"
       f"options={self.ollama_options},\n"
       f"keep_alive={self.keep_alive}")
-    self.log(f"Prompt Content:\n{json.dumps(prompt)}")
+    self.log(f"Prompt Content:\n{json.dumps(prompt, ensure_ascii=False)}")
     response_dict = self.ollama_client.chat(model=self.model,
                                             messages=prompt,
                                             stream=False,

vanna/opensearch/__init__.py

@@ -1 +1,2 @@
 from .opensearch_vector import OpenSearch_VectorStore
+from .opensearch_vector_semantic import OpenSearch_Semantic_VectorStore

vanna/opensearch/opensearch_vector_semantic.py

@@ -0,0 +1,175 @@
+import json
+
+import pandas as pd
+from langchain_community.vectorstores import OpenSearchVectorSearch
+
+from ..base import VannaBase
+from ..utils import deterministic_uuid
+
+
+class OpenSearch_Semantic_VectorStore(VannaBase):
+  def __init__(self, config=None):
+    VannaBase.__init__(self, config=config)
+    if config is None:
+      config = {}
+
+    if "embedding_function" in config:
+      self.embedding_function = config.get("embedding_function")
+    else:
+      from langchain_huggingface import HuggingFaceEmbeddings
+      self.embedding_function = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+
+    self.n_results_sql = config.get("n_results_sql", config.get("n_results", 10))
+    self.n_results_documentation = config.get("n_results_documentation", config.get("n_results", 10))
+    self.n_results_ddl = config.get("n_results_ddl", config.get("n_results", 10))
+
+    self.document_index = config.get("es_document_index", "vanna_document_index")
+    self.ddl_index = config.get("es_ddl_index", "vanna_ddl_index")
+    self.question_sql_index = config.get("es_question_sql_index", "vanna_questions_sql_index")
+
+    self.log(f"OpenSearch_Semantic_VectorStore initialized with document_index: {self.document_index}, ddl_index: {self.ddl_index}, question_sql_index: {self.question_sql_index}")
+
+    es_urls = config.get("es_urls", "https://localhost:9200")
+    ssl = config.get("es_ssl", True)
+    verify_certs = config.get("es_verify_certs", True)
+
+    if "es_user" in config:
+      auth = (config["es_user"], config["es_password"])
+    else:
+      auth = None
+
+    headers = config.get("es_headers", None)
+    timeout = config.get("es_timeout", 60)
+    max_retries = config.get("es_max_retries", 10)
+
+    common_args = {
+        "opensearch_url": es_urls,
+        "embedding_function": self.embedding_function,
+        "engine": "faiss",
+        "http_auth": auth,
+        "use_ssl": ssl,
+        "verify_certs": verify_certs,
+        "timeout": timeout,
+        "max_retries": max_retries,
+        "retry_on_timeout": True,
+        "headers": headers,
+    }
+
+    self.documentation_store = OpenSearchVectorSearch(index_name=self.document_index, **common_args)
+    self.ddl_store = OpenSearchVectorSearch(index_name=self.ddl_index, **common_args)
+    self.sql_store = OpenSearchVectorSearch(index_name=self.question_sql_index, **common_args)
+
+  def add_ddl(self, ddl: str, **kwargs) -> str:
+    _id = deterministic_uuid(ddl) + "-ddl"
+    self.ddl_store.add_texts(texts=[ddl], ids=[_id], **kwargs)
+    return _id
+
+  def add_documentation(self, documentation: str, **kwargs) -> str:
+    _id = deterministic_uuid(documentation) + "-doc"
+    self.documentation_store.add_texts(texts=[documentation], ids=[_id], **kwargs)
+    return _id
+
+  def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+    question_sql_json = json.dumps(
+      {
+        "question": question,
+        "sql": sql,
+      },
+      ensure_ascii=False,
+    )
+
+    _id = deterministic_uuid(question_sql_json) + "-sql"
+    self.sql_store.add_texts(texts=[question_sql_json], ids=[_id], **kwargs)
+    return _id
+
+  def get_related_ddl(self, question: str, **kwargs) -> list:
+    documents = self.ddl_store.similarity_search(query=question, k=self.n_results_ddl)
+    return [document.page_content for document in documents]
+
+  def get_related_documentation(self, question: str, **kwargs) -> list:
+    documents = self.documentation_store.similarity_search(query=question, k=self.n_results_documentation)
+    return [document.page_content for document in documents]
+
+  def get_similar_question_sql(self, question: str, **kwargs) -> list:
+    documents = self.sql_store.similarity_search(query=question, k=self.n_results_sql)
+    return [json.loads(document.page_content) for document in documents]
+
+  def get_training_data(self, **kwargs) -> pd.DataFrame:
+    data = []
+    query = {
+      "query": {
+        "match_all": {}
+      }
+    }
+
+    indices = [
+      {"index": self.document_index, "type": "documentation"},
+      {"index": self.question_sql_index, "type": "sql"},
+      {"index": self.ddl_index, "type": "ddl"},
+    ]
+
+    # Use documentation_store.client consistently for search on all indices
+    opensearch_client = self.documentation_store.client
+
+    for index_info in indices:
+      index_name = index_info["index"]
+      training_data_type = index_info["type"]
+      scroll = '1m'  # keep scroll context for 1 minute
+      response = opensearch_client.search(
+        index=index_name,
+        ignore_unavailable=True,
+        body=query,
+        scroll=scroll,
+        size=1000
+      )
+
+      scroll_id = response.get('_scroll_id')
+
+      while scroll_id:
+        hits = response['hits']['hits']
+        if not hits:
+          break  # No more hits, exit loop
+
+        for hit in hits:
+          source = hit['_source']
+          if training_data_type == "sql":
+            try:
+              doc_dict = json.loads(source['text'])
+              content = doc_dict.get("sql")
+              question = doc_dict.get("question")
+            except json.JSONDecodeError as e:
+              self.log(f"Skipping row with custom_id {hit['_id']} due to JSON parsing error: {e}","Error")
+              continue
+          else:  # documentation or ddl
+            content = source['text']
+            question = None
+
+          data.append({
+            "id": hit["_id"],
+            "training_data_type": training_data_type,
+            "question": question,
+            "content": content,
+          })
+
+        # Get next batch of results, using documentation_store.client.scroll
+        response = opensearch_client.scroll(scroll_id=scroll_id, scroll=scroll)
+        scroll_id = response.get('_scroll_id')
+
+    return pd.DataFrame(data)
+
+  def remove_training_data(self, id: str, **kwargs) -> bool:
+    try:
+      if id.endswith("-sql"):
+        return self.sql_store.delete(ids=[id], **kwargs)
+      elif id.endswith("-ddl"):
+        return self.ddl_store.delete(ids=[id], **kwargs)
+      elif id.endswith("-doc"):
+        return self.documentation_store.delete(ids=[id], **kwargs)
+      else:
+        return False
+    except Exception as e:
+      self.log(f"Error deleting training dataError deleting training data: {e}", "Error")
+      return False
+
+  def generate_embedding(self, data: str, **kwargs) -> list[float]:
+    pass

vanna/oracle/__init__.py

@@ -0,0 +1 @@
+from .oracle_vector import Oracle_VectorStore

vanna/oracle/oracle_vector.py

@@ -0,0 +1,585 @@
+import json
+import uuid
+from typing import List, Optional, Tuple
+
+import oracledb
+import pandas as pd
+from chromadb.utils import embedding_functions
+
+from ..base import VannaBase
+
+default_ef = embedding_functions.DefaultEmbeddingFunction()
+
+
+class Oracle_VectorStore(VannaBase):
+  def __init__(self, config=None):
+    VannaBase.__init__(self, config=config)
+
+    if config is not None:
+      self.embedding_function = config.get(
+        "embedding_function",
+        default_ef
+      )
+      self.pre_delete_collection = config.get("pre_delete_collection",
+                                              False)
+      self.cmetadata = config.get("cmetadata", {"created_by": "oracle"})
+    else:
+      self.embedding_function = default_ef
+      self.pre_delete_collection = False
+      self.cmetadata = {"created_by": "oracle"}
+
+    self.oracle_conn = oracledb.connect(dsn=config.get("dsn"))
+    self.oracle_conn.call_timeout = 30000
+    self.documentation_collection = "documentation"
+    self.ddl_collection = "ddl"
+    self.sql_collection = "sql"
+    self.n_results = config.get("n_results", 10)
+    self.n_results_ddl = config.get("n_results_ddl", self.n_results)
+    self.n_results_sql = config.get("n_results_sql", self.n_results)
+    self.n_results_documentation = config.get("n_results_documentation",
+                                              self.n_results)
+    self.create_tables_if_not_exists()
+    self.create_collections_if_not_exists(self.documentation_collection)
+    self.create_collections_if_not_exists(self.ddl_collection)
+    self.create_collections_if_not_exists(self.sql_collection)
+
+  def generate_embedding(self, data: str, **kwargs) -> List[float]:
+    embeddings = self.embedding_function([data])
+    if len(embeddings) == 1:
+      return list(embeddings[0].astype(float))
+    return list(embeddings.astype(float))
+
+  def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
+    cmetadata = self.cmetadata.copy()
+    collection = self.get_collection(self.sql_collection)
+    question_sql_json = json.dumps(
+      {
+        "question": question,
+        "sql": sql,
+      },
+      ensure_ascii=False,
+    )
+    id = str(uuid.uuid4())
+    embeddings = self.generate_embedding(question)
+    custom_id = id + "-sql"
+
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+          INSERT INTO oracle_embedding (
+              collection_id,
+              embedding,
+              document,
+              cmetadata,
+              custom_id,
+              uuid
+          ) VALUES (
+              :1,
+              TO_VECTOR(:2),
+              :3,
+              :4,
+              :5,
+              :6
+          )
+      """, [
+        collection["uuid"],
+        embeddings,
+        question_sql_json,
+        json.dumps(cmetadata),
+        custom_id,
+        id
+      ]
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return id
+
+  def add_ddl(self, ddl: str, **kwargs) -> str:
+    collection = self.get_collection(self.ddl_collection)
+    question_ddl_json = json.dumps(
+      {
+        "question": None,
+        "ddl": ddl,
+      },
+      ensure_ascii=False,
+    )
+    id = str(uuid.uuid4())
+    custom_id = id + "-ddl"
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+      INSERT INTO oracle_embedding (
+          collection_id,
+          embedding,
+          document,
+          cmetadata,
+          custom_id,
+          uuid
+      ) VALUES (
+          :1,
+          TO_VECTOR(:2),
+          :3,
+          :4,
+          :5,
+          :6
+      )
+      """, [
+        collection["uuid"],
+        self.generate_embedding(ddl),
+        question_ddl_json,
+        json.dumps(self.cmetadata),
+        custom_id,
+        id
+      ]
+    )
+    self.oracle_conn.commit()
+    cursor.close()
+    return id
+
+  def add_documentation(self, documentation: str, **kwargs) -> str:
+    collection = self.get_collection(self.documentation_collection)
+    question_documentation_json = json.dumps(
+      {
+        "question": None,
+        "documentation": documentation,
+      },
+      ensure_ascii=False,
+    )
+    id = str(uuid.uuid4())
+    custom_id = id + "-doc"
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+      INSERT INTO oracle_embedding (
+          collection_id,
+          embedding,
+          document,
+          cmetadata,
+          custom_id,
+          uuid
+      ) VALUES (
+          :1,
+          TO_VECTOR(:2),
+          :3,
+          :4,
+          :5,
+          :6
+      )
+      """, [
+        collection["uuid"],
+        self.generate_embedding(documentation),
+        question_documentation_json,
+        json.dumps(self.cmetadata),
+        custom_id,
+        id
+      ]
+    )
+    self.oracle_conn.commit()
+    cursor.close()
+    return id
+
+  def get_training_data(self, **kwargs) -> pd.DataFrame:
+    df = pd.DataFrame()
+
+    cursor = self.oracle_conn.cursor()
+    sql_collection = self.get_collection(self.sql_collection)
+    cursor.execute(
+      """
+                    SELECT
+                        document,
+                        uuid
+                    FROM oracle_embedding
+                    WHERE
+                        collection_id = :1
+                  """, [
+        sql_collection["uuid"]
+      ]
+    )
+    sql_data = cursor.fetchall()
+
+    if sql_data is not None:
+      # Extract the documents and ids
+      documents = [row_data[0] for row_data in sql_data]
+      ids = [row_data[1] for row_data in sql_data]
+
+      # Create a DataFrame
+      df_sql = pd.DataFrame(
+        {
+          "id": ids,
+          "question": [
+            json.loads(doc)["question"] if isinstance(doc,
+                                                      str) else
+            doc[
+              "question"] for doc in documents],
+          "content": [
+            json.loads(doc)["sql"] if isinstance(doc, str) else
+            doc["sql"] for
+            doc in documents],
+        }
+      )
+      df_sql["training_data_type"] = "sql"
+      df = pd.concat([df, df_sql])
+
+    ddl_collection = self.get_collection(self.ddl_collection)
+    cursor.execute(
+      """
+          SELECT
+              document,
+              uuid
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+      """, [ddl_collection["uuid"]])
+    ddl_data = cursor.fetchall()
+
+    if ddl_data is not None:
+      # Extract the documents and ids
+      documents = [row_data[0] for row_data in ddl_data]
+      ids = [row_data[1] for row_data in ddl_data]
+
+      # Create a DataFrame
+      df_ddl = pd.DataFrame(
+        {
+          "id": ids,
+          "question": [None for _ in documents],
+          "content": [
+            json.loads(doc)["ddl"] if isinstance(doc, str) else
+            doc["ddl"] for
+            doc in documents],
+        }
+      )
+      df_ddl["training_data_type"] = "ddl"
+      df = pd.concat([df, df_ddl])
+
+    doc_collection = self.get_collection(self.documentation_collection)
+    cursor.execute(
+      """
+          SELECT
+              document,
+              uuid
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+      """, [doc_collection["uuid"]])
+    doc_data = cursor.fetchall()
+
+    if doc_data is not None:
+      # Extract the documents and ids
+      documents = [row_data[0] for row_data in doc_data]
+      ids = [row_data[1] for row_data in doc_data]
+
+      # Create a DataFrame
+      df_doc = pd.DataFrame(
+        {
+          "id": ids,
+          "question": [None for _ in documents],
+          "content": [
+            json.loads(doc)["documentation"] if isinstance(doc,
+                                                           str) else
+            doc[
+              "documentation"] for
+            doc in documents],
+        }
+      )
+      df_doc["training_data_type"] = "documentation"
+      df = pd.concat([df, df_doc])
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return df
+
+  def remove_training_data(self, id: str, **kwargs) -> bool:
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          DELETE
+          FROM
+              oracle_embedding
+          WHERE
+          uuid  = :1
+      """, [id])
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return True
+
+  def update_training_data(self, id: str, train_type: str, question: str,
+                           **kwargs) -> bool:
+    print(f"{train_type=}")
+    update_content = kwargs["content"]
+    if train_type == 'sql':
+      update_json = json.dumps(
+        {
+          "question": question,
+          "sql": update_content,
+        }
+      )
+    elif train_type == 'ddl':
+      update_json = json.dumps(
+        {
+          "question": None,
+          "ddl": update_content,
+        }
+      )
+    elif train_type == 'documentation':
+      update_json = json.dumps(
+        {
+          "question": None,
+          "documentation": update_content,
+        }
+      )
+    else:
+      update_json = json.dumps(
+        {
+          "question": question,
+          "sql": update_content,
+        }
+      )
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(oracledb.DB_TYPE_VECTOR, oracledb.DB_TYPE_JSON)
+    cursor.execute(
+      """
+                  UPDATE
+                      oracle_embedding
+                  SET
+                      embedding = TO_VECTOR(:1),
+                      document = JSON_MERGEPATCH(document, :2)
+                  WHERE
+                  uuid  = :3
+                  """, [
+        self.generate_embedding(update_content),
+        update_json,
+        id
+      ]
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return True
+
+  @staticmethod
+  def _extract_documents(query_results) -> list:
+    """
+    Static method to extract the documents from the results of a query.
+
+    Args:
+        query_results (pd.DataFrame): The dataframe to use.
+
+    Returns:
+        List[str] or None: The extracted documents, or an empty list or single document if an error occurred.
+    """
+    if query_results is None or len(query_results) == 0:
+      return []
+
+    documents = [
+      json.loads(row_data[0]) if isinstance(row_data[0], str) else
+      row_data[0]
+      for row_data in query_results]
+
+    return documents
+
+  def get_similar_question_sql(self, question: str, **kwargs) -> list:
+    embeddings = self.generate_embedding(question)
+    collection = self.get_collection(self.sql_collection)
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR,
+                         oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+      SELECT document
+      FROM oracle_embedding
+      WHERE collection_id = :1
+      ORDER BY VECTOR_DISTANCE(embedding, TO_VECTOR(:2), COSINE)
+      FETCH FIRST :3 ROWS ONLY
+      """, [
+        collection["uuid"],
+        embeddings,
+        self.n_results_sql
+      ]
+    )
+    results = cursor.fetchall()
+    cursor.close()
+    return self._extract_documents(results)
+
+  def get_related_ddl(self, question: str, **kwargs) -> list:
+    collection = self.get_collection(self.ddl_collection)
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+          SELECT
+              document
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+          ORDER BY VECTOR_DISTANCE(embedding, TO_VECTOR(:2), COSINE)
+          FETCH FIRST :top_k ROWS ONLY
+      """, [
+        collection["uuid"],
+        self.generate_embedding(question),
+        100
+      ]
+    )
+    results = cursor.fetchall()
+
+    self.oracle_conn.commit()
+    cursor.close()
+    return Oracle_VectorStore._extract_documents(results)
+
+  def search_tables_metadata(self,
+                             engine: str = None,
+                             catalog: str = None,
+                             schema: str = None,
+                             table_name: str = None,
+                             ddl: str = None,
+                             size: int = 10,
+                             **kwargs) -> list:
+    pass
+
+  def get_related_documentation(self, question: str, **kwargs) -> list:
+    collection = self.get_collection(self.documentation_collection)
+    cursor = self.oracle_conn.cursor()
+    cursor.setinputsizes(None, oracledb.DB_TYPE_VECTOR)
+    cursor.execute(
+      """
+          SELECT
+              document
+          FROM oracle_embedding
+          WHERE
+              collection_id = :1
+          ORDER BY VECTOR_DISTANCE(embedding, TO_VECTOR(:2), DOT)
+          FETCH FIRST :top_k ROWS ONLY
+      """, [
+        collection["uuid"],
+        self.generate_embedding(question),
+        100
+      ]
+    )
+    results = cursor.fetchall()
+
+    self.oracle_conn.commit()
+    cursor.close()
+
+    return Oracle_VectorStore._extract_documents(results)
+
+  def create_tables_if_not_exists(self) -> None:
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          CREATE TABLE IF NOT EXISTS oracle_collection (
+              name      VARCHAR2(200) NOT NULL,
+              cmetadata json NOT NULL,
+              uuid      VARCHAR2(200) NOT NULL,
+              CONSTRAINT oc_key_uuid PRIMARY KEY ( uuid )
+          )
+      """
+    )
+
+    cursor.execute(
+      """
+          CREATE TABLE IF NOT EXISTS oracle_embedding (
+              collection_id VARCHAR2(200) NOT NULL,
+              embedding     vector NOT NULL,
+              document      json NOT NULL,
+              cmetadata     json NOT NULL,
+              custom_id     VARCHAR2(200) NOT NULL,
+              uuid          VARCHAR2(200) NOT NULL,
+              CONSTRAINT oe_key_uuid PRIMARY KEY ( uuid )
+          )
+      """
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+
+  def create_collections_if_not_exists(
+    self,
+    name: str,
+    cmetadata: Optional[dict] = None,
+  ) -> Tuple[dict, bool]:
+    """
+    Get or create a collection.
+    Returns [Collection, bool] where the bool is True if the collection was created.
+    """
+    if self.pre_delete_collection:
+      self.delete_collection(name)
+    created = False
+    collection = self.get_collection(name)
+    if collection:
+      return collection, created
+
+    cmetadata = json.dumps(
+      self.cmetadata) if cmetadata is None else json.dumps(cmetadata)
+    collection_id = str(uuid.uuid4())
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          INSERT INTO oracle_collection(name, cmetadata, uuid)
+          VALUES (:1, :2, :3)
+      """, [
+        name,
+        cmetadata,
+        str(collection_id)
+      ]
+    )
+
+    self.oracle_conn.commit()
+    cursor.close()
+
+    collection = {"name": name, "cmetadata": cmetadata,
+                  "uuid": collection_id}
+    created = True
+    return collection, created
+
+  def get_collection(self, name) -> Optional[dict]:
+    return self.get_by_name(name)
+
+  def get_by_name(self, name: str) -> Optional[dict]:
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          SELECT
+              name,
+              cmetadata,
+              uuid
+          FROM
+              oracle_collection
+          WHERE
+              name = :1
+          FETCH FIRST 1 ROWS ONLY
+      """, [name])
+
+    for row in cursor:
+      return {"name": row[0], "cmetadata": row[1], "uuid": row[2]}
+
+    return  # type: ignore
+
+  def delete_collection(self, name) -> None:
+    collection = self.get_collection(name)
+    if not collection:
+      return
+
+    cursor = self.oracle_conn.cursor()
+    cursor.execute(
+      """
+          DELETE
+          FROM
+              oracle_embedding
+          WHERE
+          collection_id = ( SELECT uuid FROM oracle_collection WHERE name = :1 )
+      """, [name])
+    cursor.execute(
+      """
+          DELETE
+          FROM
+              oracle_collection
+          WHERE
+              name = :1
+      """, [name])
+
+    self.oracle_conn.commit()
+    cursor.close()

vanna/remote.py

@@ -62,7 +62,7 @@ class VannaDefault(VannaDB_VectorStore):
 
     def submit_prompt(self, prompt, **kwargs) -> str:
         # JSON-ify the prompt
-        json_prompt = json.dumps(prompt)
+        json_prompt = json.dumps(prompt, ensure_ascii=False)
 
         params = [StringData(data=json_prompt)]
 

{vanna-0.7.5.dist-info → vanna-0.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: vanna
-Version: 0.7.5
+Version: 0.7.7
 Summary: Generate SQL queries from natural language
 Author-email: Zain Hoda <zain@vanna.ai>
 Requires-Python: >=3.9
@@ -8,6 +8,7 @@ Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+License-File: LICENSE
 Requires-Dist: requests
 Requires-Dist: tabulate
 Requires-Dist: plotly
@@ -40,7 +41,7 @@ Requires-Dist: httpx ; extra == "all"
 Requires-Dist: opensearch-py ; extra == "all"
 Requires-Dist: opensearch-dsl ; extra == "all"
 Requires-Dist: transformers ; extra == "all"
-Requires-Dist: pinecone-client ; extra == "all"
+Requires-Dist: pinecone ; extra == "all"
 Requires-Dist: pymilvus[model] ; extra == "all"
 Requires-Dist: weaviate-client ; extra == "all"
 Requires-Dist: azure-search-documents ; extra == "all"
@@ -52,6 +53,8 @@ Requires-Dist: boto3 ; extra == "all"
 Requires-Dist: botocore ; extra == "all"
 Requires-Dist: langchain_core ; extra == "all"
 Requires-Dist: langchain_postgres ; extra == "all"
+Requires-Dist: langchain-community ; extra == "all"
+Requires-Dist: langchain-huggingface ; extra == "all"
 Requires-Dist: xinference-client ; extra == "all"
 Requires-Dist: anthropic ; extra == "anthropic"
 Requires-Dist: azure-search-documents ; extra == "azuresearch"
@@ -79,8 +82,12 @@ Requires-Dist: httpx ; extra == "ollama"
 Requires-Dist: openai ; extra == "openai"
 Requires-Dist: opensearch-py ; extra == "opensearch"
 Requires-Dist: opensearch-dsl ; extra == "opensearch"
+Requires-Dist: langchain-community ; extra == "opensearch"
+Requires-Dist: langchain-huggingface ; extra == "opensearch"
+Requires-Dist: oracledb ; extra == "oracle"
+Requires-Dist: chromadb ; extra == "oracle"
 Requires-Dist: langchain-postgres>=0.0.12 ; extra == "pgvector"
-Requires-Dist: pinecone-client ; extra == "pinecone"
+Requires-Dist: pinecone ; extra == "pinecone"
 Requires-Dist: fastembed ; extra == "pinecone"
 Requires-Dist: psycopg2-binary ; extra == "postgres"
 Requires-Dist: db-dtypes ; extra == "postgres"
@@ -115,6 +122,7 @@ Provides-Extra: mysql
 Provides-Extra: ollama
 Provides-Extra: openai
 Provides-Extra: opensearch
+Provides-Extra: oracle
 Provides-Extra: pgvector
 Provides-Extra: pinecone
 Provides-Extra: postgres
@@ -129,9 +137,9 @@ Provides-Extra: zhipuai
 
 
 
-| GitHub | PyPI | Documentation |
-| ------ | ---- | ------------- |
-| [![GitHub](https://img.shields.io/badge/GitHub-vanna-blue?logo=github)](https://github.com/vanna-ai/vanna) | [![PyPI](https://img.shields.io/pypi/v/vanna?logo=pypi)](https://pypi.org/project/vanna/) | [![Documentation](https://img.shields.io/badge/Documentation-vanna-blue?logo=read-the-docs)](https://vanna.ai/docs/) |
+| GitHub | PyPI | Documentation | Gurubase |
+| ------ | ---- | ------------- | -------- |
+| [![GitHub](https://img.shields.io/badge/GitHub-vanna-blue?logo=github)](https://github.com/vanna-ai/vanna) | [![PyPI](https://img.shields.io/pypi/v/vanna?logo=pypi)](https://pypi.org/project/vanna/) | [![Documentation](https://img.shields.io/badge/Documentation-vanna-blue?logo=read-the-docs)](https://vanna.ai/docs/) | [![Gurubase](https://img.shields.io/badge/Gurubase-Ask%20Vanna%20Guru-006BFF)](https://gurubase.io/g/vanna) |
 
 # Vanna
 Vanna is an MIT-licensed open-source Python RAG (Retrieval-Augmented Generation) framework for SQL generation and related functionality.
@@ -164,6 +172,46 @@ These are some of the user interfaces that we've built using Vanna. You can use
 - [vanna-ai/vanna-flask](https://github.com/vanna-ai/vanna-flask)
 - [vanna-ai/vanna-slack](https://github.com/vanna-ai/vanna-slack)
 
+## Supported LLMs
+
+- [OpenAI](https://github.com/vanna-ai/vanna/tree/main/src/vanna/openai)
+- [Anthropic](https://github.com/vanna-ai/vanna/tree/main/src/vanna/anthropic)
+- [Gemini](https://github.com/vanna-ai/vanna/blob/main/src/vanna/google/gemini_chat.py)
+- [HuggingFace](https://github.com/vanna-ai/vanna/blob/main/src/vanna/hf/hf.py)
+- [AWS Bedrock](https://github.com/vanna-ai/vanna/tree/main/src/vanna/bedrock)
+- [Ollama](https://github.com/vanna-ai/vanna/tree/main/src/vanna/ollama)
+- [Qianwen](https://github.com/vanna-ai/vanna/tree/main/src/vanna/qianwen)
+- [Qianfan](https://github.com/vanna-ai/vanna/tree/main/src/vanna/qianfan)
+- [Zhipu](https://github.com/vanna-ai/vanna/tree/main/src/vanna/ZhipuAI)
+
+## Supported VectorStores
+
+- [AzureSearch](https://github.com/vanna-ai/vanna/tree/main/src/vanna/azuresearch)
+- [Opensearch](https://github.com/vanna-ai/vanna/tree/main/src/vanna/opensearch)
+- [PgVector](https://github.com/vanna-ai/vanna/tree/main/src/vanna/pgvector)
+- [PineCone](https://github.com/vanna-ai/vanna/tree/main/src/vanna/pinecone)
+- [ChromaDB](https://github.com/vanna-ai/vanna/tree/main/src/vanna/chromadb)
+- [FAISS](https://github.com/vanna-ai/vanna/tree/main/src/vanna/faiss)
+- [Marqo](https://github.com/vanna-ai/vanna/tree/main/src/vanna/marqo)
+- [Milvus](https://github.com/vanna-ai/vanna/tree/main/src/vanna/milvus)
+- [Qdrant](https://github.com/vanna-ai/vanna/tree/main/src/vanna/qdrant)
+- [Weaviate](https://github.com/vanna-ai/vanna/tree/main/src/vanna/weaviate)
+- [Oracle](https://github.com/vanna-ai/vanna/tree/main/src/vanna/oracle)
+
+## Supported Databases
+
+- [PostgreSQL](https://www.postgresql.org/)
+- [MySQL](https://www.mysql.com/)
+- [PrestoDB](https://prestodb.io/)
+- [Apache Hive](https://hive.apache.org/)
+- [ClickHouse](https://clickhouse.com/)
+- [Snowflake](https://www.snowflake.com/en/)
+- [Oracle](https://www.oracle.com/)
+- [Microsoft SQL Server](https://www.microsoft.com/en-us/sql-server/sql-server-downloads)
+- [BigQuery](https://cloud.google.com/bigquery)
+- [SQLite](https://www.sqlite.org/)
+- [DuckDB](https://duckdb.org/)
+
 
 ## Getting started
 See the [documentation](https://vanna.ai/docs/) for specifics on your desired database, LLM, etc.

{vanna-0.7.5.dist-info → vanna-0.7.7.dist-info}/RECORD

@@ -1,6 +1,6 @@
 vanna/__init__.py,sha256=4zz2kSkVZenjwJQg-ETWsIVYdz3gio275i9DMa_aHxM,9248
 vanna/local.py,sha256=U5s8ybCRQhBUizi8I69o3jqOpTeu_6KGYY6DMwZxjG4,313
-vanna/remote.py,sha256=CcScbeEkqYlzBZJMeMLDlLgmaFcG0QSUQUZybFI3Y28,1856
+vanna/remote.py,sha256=3SGyXBmNWofkZL3vGevypvMAhqAYru0KzoUCpX2N6Vc,1876
 vanna/utils.py,sha256=cs0B_0MwhmPI2nWjVHifDYCmCR0kkddylQ2vloaPDSw,2247
 vanna/ZhipuAI/ZhipuAI_Chat.py,sha256=WtZKUBIwlNH0BGbb4lZbVR7pTWIrn7b4RLIk-7u0SuQ,8725
 vanna/ZhipuAI/ZhipuAI_embeddings.py,sha256=lUqzJg9fOx7rVFhjdkFjXcDeVGV4aAB5Ss0oERsa8pE,2849
@@ -11,11 +11,16 @@ vanna/anthropic/anthropic_chat.py,sha256=7X3x8SYwDY28aGyBnt0YNRMG8YY1p_t-foMfKGj
 vanna/azuresearch/__init__.py,sha256=tZfvsrCJESiL3EnxA4PrOc5NoO8MXEzCfHX_hnj8n-c,58
 vanna/azuresearch/azuresearch_vector.py,sha256=_-t53PUnJM914GYbTYlyee06ocfu7l2NkZerBQtlJcs,9566
 vanna/base/__init__.py,sha256=Sl-HM1RRYzAZoSqmL1CZQmF3ZF-byYTCFQP3JZ2A5MU,28
-vanna/base/base.py,sha256=j5xQmK-MeFKAuPjgYLSl1ThCHZieG-ab-RFFSkDlbiw,73679
+vanna/base/base.py,sha256=dGSOuidPBCUOuKxCJ9U_B9qSQ7w5Y4XIM0olox9RCYY,73816
 vanna/bedrock/__init__.py,sha256=hRT2bgJbHEqViLdL-t9hfjSfFdIOkPU2ADBt-B1En-8,46
 vanna/bedrock/bedrock_converse.py,sha256=Nx5kYm-diAfYmsWAnTP5xnv7V84Og69-AP9b3seIe0E,2869
 vanna/chromadb/__init__.py,sha256=-iL0nW_g4uM8nWKMuWnNePfN4nb9uk8P3WzGvezOqRg,50
 vanna/chromadb/chromadb_vector.py,sha256=eKyPck99Y6Jt-BNWojvxLG-zvAERzLSm-3zY-bKXvaA,8792
+vanna/cohere/__init__.py,sha256=QqNQXEixwkrQ4MIAadmg8hTrWDCHFzZoOMF9tim9Pw0,86
+vanna/cohere/cohere_chat.py,sha256=f7kmhhkqoy61AGkBJBXBjVQ2AQkmLQkYnRGNTiZpfYw,3572
+vanna/cohere/cohere_embeddings.py,sha256=RsbZLPVVFIqxbN4t05YM8sc7X0gmA455dhpdU9iB6x8,2646
+vanna/deepseek/__init__.py,sha256=7SVY3DGJcNH7GTk7Uq922QM8yZKu3-5IO33WQ_-bgCM,40
+vanna/deepseek/deepseek_chat.py,sha256=dbTIfVSNmPKYJVI8YeJu3a2Du8U6VqDHdT0gOeqISTc,1878
 vanna/exceptions/__init__.py,sha256=dJ65xxxZh1lqBeg6nz6Tq_r34jLVmjvBvPO9Q6hFaQ8,685
 vanna/faiss/__init__.py,sha256=MXuojmLPt4kUtkES9XKWJcCDHVa4L5a6YF5gebhmKLw,24
 vanna/faiss/faiss.py,sha256=HLUO5PQdnJio9OXJiJcgmRuxVWXvg_XRBnnohS21Z0w,8304
@@ -24,7 +29,7 @@ vanna/flask/assets.py,sha256=af-vact_5HSftltugBpPxzLkAI14Z0lVWcObyVe6eKE,453462
 vanna/flask/auth.py,sha256=UpKxh7W5cd43W0LGch0VqhncKwB78L6dtOQkl1JY5T0,1246
 vanna/google/__init__.py,sha256=6D8rDBjKJJm_jpVn9b4Vc2NR-R779ed_bnHhWmxCJXE,92
 vanna/google/bigquery_vector.py,sha256=mHggjvCsWMt4HK6Y4dAZUPgHi1uytxp2AEQ696TSsJA,9315
-vanna/google/gemini_chat.py,sha256=9xHvxArxHr7OWXHnDRz7wX7KTGbuy6xXxHMLkhOMkis,1568
+vanna/google/gemini_chat.py,sha256=Tm4S0uywQNuZ5y0eQsE0-rv0NkAw_IhlyMiQqiqn8ro,2683
 vanna/hf/__init__.py,sha256=vD0bIhfLkA1UsvVSF4MAz3Da8aQunkQo3wlDztmMuj0,19
 vanna/hf/hf.py,sha256=N8N5g3xvKDBt3dez2r_U0qATxbl2pN8SVLTZK9CSRA0,3020
 vanna/marqo/__init__.py,sha256=GaAWtJ0B-H5rTY607iLCCrLD7T0zMYM5qWIomEB9gLk,37
@@ -38,12 +43,15 @@ vanna/mock/embedding.py,sha256=ggnP7KuPh6dlqeUFtoN8t0J0P7_yRNtn9rIq6h8g8-w,250
 vanna/mock/llm.py,sha256=WpG9f1pKZftPBHqgIYdARKB2Z9DZhOALYOJWoOjjFEc,518
 vanna/mock/vectordb.py,sha256=h45znfYMUnttE2BBC8v6TKeMaA58pFJL-5B3OGeRNFI,2681
 vanna/ollama/__init__.py,sha256=4xyu8aHPdnEHg5a-QAMwr5o0ns5wevsp_zkI-ndMO2k,27
-vanna/ollama/ollama.py,sha256=yD7UHn4GNzWfQMi2OHlfWwIEJ_sTDzpPcgv_MCGRp6E,3871
+vanna/ollama/ollama.py,sha256=pqHkh2UEIAwBqxRebsLVmmkpiF30yRwCwO_92WY4p0E,3891
 vanna/openai/__init__.py,sha256=tGkeQ7wTIPsando7QhoSHehtoQVdYLwFbKNlSmCmNeQ,86
 vanna/openai/openai_chat.py,sha256=KU6ynOQ5v7vwrQQ13phXoUXeQUrH6_vmhfiPvWddTrQ,4427
 vanna/openai/openai_embeddings.py,sha256=g4pNh9LVcYP9wOoO8ecaccDFWmCUYMInebfHucAa2Gc,1260
-vanna/opensearch/__init__.py,sha256=0unDevWOTs7o8S79TOHUKF1mSiuQbBUVm-7k9jV5WW4,54
+vanna/opensearch/__init__.py,sha256=dc9fNtIrOOpkSGp_JKOhGOk26ffyK6W1bm_Cdn9X09I,126
 vanna/opensearch/opensearch_vector.py,sha256=VhIcrSyNzWR9ZrqrJnyGFOyuQZs3swfbhr8QyVGI0eI,12226
+vanna/opensearch/opensearch_vector_semantic.py,sha256=XV0ApIMXTj_dc3tnmTg4vkQXMaUxsh2Npk_JBEGIj1Q,6325
+vanna/oracle/__init__.py,sha256=lE9IB9nK4wsAQ0KdAqoidMoLH80QBsB1HRbI0GQJh8c,46
+vanna/oracle/oracle_vector.py,sha256=uWcDFs5uhdKdjdEhFXy4RouTOiS-XMFmaUFuuOLtqho,15974
 vanna/pgvector/__init__.py,sha256=7Wvu9qcNdNvZu26Dn53jhO9YXELm0_YsrwBab4BdgVM,37
 vanna/pgvector/pgvector.py,sha256=dJfm8rswYZvbaIbnjmyRjL071iw4siE0INibsZtaLXY,9919
 vanna/pinecone/__init__.py,sha256=eO5l8aX8vKL6aIUMgAXGPt1jdqKxB_Hic6cmoVAUrD0,90
@@ -65,6 +73,7 @@ vanna/weaviate/__init__.py,sha256=HL6PAl7ePBAkeG8uln-BmM7IUtWohyTPvDfcPzSGSCg,46
 vanna/weaviate/weaviate_vector.py,sha256=tUJIZjEy2mda8CB6C8zeN2SKkEO-UJdLsIqy69skuF0,7584
 vanna/xinference/__init__.py,sha256=EFW_sz-BSB2XgmjACOTZmneeIk3I2EiWgue-VVJpnB0,35
 vanna/xinference/xinference.py,sha256=2PI-f7XoBUyL_jfuXPqxCsd0W72h8j6CtEDneFw1AtI,1876
-vanna-0.7.5.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-vanna-0.7.5.dist-info/METADATA,sha256=ps3MrKa5oG8XfjgG6C5u71v3OExvket22gu8uMwtufs,13048
-vanna-0.7.5.dist-info/RECORD,,
+vanna-0.7.7.dist-info/licenses/LICENSE,sha256=VYiPMMDqj9BcxUkAYqrAzJpn5tCFXCrnglfRqS5l9Rk,1065
+vanna-0.7.7.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+vanna-0.7.7.dist-info/METADATA,sha256=45kbhCcgYmsi7bDQESvhAwPg96c92NW6qwlIDouIpiQ,15608
+vanna-0.7.7.dist-info/RECORD,,

{vanna-0.7.5.dist-info → vanna-0.7.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: flit 3.9.0
+Generator: flit 3.12.0
 Root-Is-Purelib: true
 Tag: py3-none-any

vanna-0.7.7.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Vanna.AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.