vanna 0.3.3__tar.gz → 0.3.4__tar.gz

{vanna-0.3.3 → vanna-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vanna
-Version: 0.3.3
+Version: 0.3.4
 Summary: Generate SQL queries from natural language
 Author-email: Zain Hoda <zain@vanna.ai>
 Requires-Python: >=3.9

{vanna-0.3.3 → vanna-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "vanna"
-version = "0.3.3"
+version = "0.3.4"
 authors = [
   { name="Zain Hoda", email="zain@vanna.ai" },
 ]

{vanna-0.3.3 → vanna-0.3.4}/src/vanna/ZhipuAI/ZhipuAI_Chat.py

@@ -40,7 +40,7 @@ class ZhipuAI_Chat(VannaBase):
         initial_prompt: str, ddl_list: List[str], max_tokens: int = 14000
     ) -> str:
         if len(ddl_list) > 0:
-            initial_prompt += f"\nYou may use the following DDL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
+            initial_prompt += "\nYou may use the following DDL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
 
             for ddl in ddl_list:
                 if (
@@ -57,7 +57,7 @@ class ZhipuAI_Chat(VannaBase):
         initial_prompt: str, documentation_List: List[str], max_tokens: int = 14000
     ) -> str:
         if len(documentation_List) > 0:
-            initial_prompt += f"\nYou may use the following documentation as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
+            initial_prompt += "\nYou may use the following documentation as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
 
             for documentation in documentation_List:
                 if (
@@ -74,7 +74,7 @@ class ZhipuAI_Chat(VannaBase):
         initial_prompt: str, sql_List: List[str], max_tokens: int = 14000
     ) -> str:
         if len(sql_List) > 0:
-            initial_prompt += f"\nYou may use the following SQL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
+            initial_prompt += "\nYou may use the following SQL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
 
             for question in sql_List:
                 if (

{vanna-0.3.3 → vanna-0.3.4}/src/vanna/base/base.py

@@ -124,6 +124,18 @@ class VannaBase(ABC):
         return self.extract_sql(llm_response)
 
     def extract_sql(self, llm_response: str) -> str:
+        # If the llm_response is not markdown formatted, extract sql by finding select and ; in the response
+        sql = re.search(r"SELECT.*?;", llm_response, re.DOTALL)
+        if sql:
+            self.log(f"Output from LLM: {llm_response} \nExtracted SQL: {sql.group(0)}"
+            )
+            return sql.group(0)
+
+        # If the llm_response contains a CTE (with clause), extract the sql bewteen WITH and ;
+        sql = re.search(r"WITH.*?;", llm_response, re.DOTALL)
+        if sql:
+            self.log(f"Output from LLM: {llm_response} \nExtracted SQL: {sql.group(0)}")
+            return sql.group(0)
         # If the llm_response contains a markdown code block, with or without the sql tag, extract the sql from it
         sql = re.search(r"```sql\n(.*)```", llm_response, re.DOTALL)
         if sql:
@@ -363,7 +375,7 @@ class VannaBase(ABC):
         self, initial_prompt: str, ddl_list: list[str], max_tokens: int = 14000
     ) -> str:
         if len(ddl_list) > 0:
-            initial_prompt += f"\nYou may use the following DDL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
+            initial_prompt += "\nYou may use the following DDL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
 
             for ddl in ddl_list:
                 if (
@@ -382,7 +394,7 @@ class VannaBase(ABC):
         max_tokens: int = 14000,
     ) -> str:
         if len(documentation_list) > 0:
-            initial_prompt += f"\nYou may use the following documentation as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
+            initial_prompt += "\nYou may use the following documentation as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
 
             for documentation in documentation_list:
                 if (
@@ -398,7 +410,7 @@ class VannaBase(ABC):
         self, initial_prompt: str, sql_list: list[str], max_tokens: int = 14000
     ) -> str:
         if len(sql_list) > 0:
-            initial_prompt += f"\nYou may use the following SQL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
+            initial_prompt += "\nYou may use the following SQL statements as a reference for what tables might be available. Use responses to past questions also to guide you:\n\n"
 
             for question in sql_list:
                 if (
@@ -890,6 +902,94 @@ class VannaBase(ABC):
         self.run_sql_is_set = True
         self.run_sql = run_sql_mysql
 
+    def connect_to_oracle(
+    self,
+    user: str = None,
+    password: str = None,
+    dsn: str = None,
+    ):
+
+        """
+        Connect to an Oracle db using oracledb package. This is just a helper function to set [`vn.run_sql`][vanna.base.base.VannaBase.run_sql]
+        **Example:**
+        ```python
+        vn.connect_to_oracle(
+        user="username",
+        password="password",
+        dns="host:port/sid",
+        )
+        ```
+        Args:
+            USER (str): Oracle db user name.
+            PASSWORD (str): Oracle db user password.
+            DSN (str): Oracle db host ip - host:port/sid.
+        """
+
+        try:
+            import oracledb
+        except ImportError:
+
+            raise DependencyError(
+                "You need to install required dependencies to execute this method,"
+                " run command: \npip install oracledb"
+            )
+
+        if not dsn:
+            dsn = os.getenv("DSN")
+
+        if not dsn:
+            raise ImproperlyConfigured("Please set your Oracle dsn which should include host:port/sid")
+
+        if not user:
+            user = os.getenv("USER")
+
+        if not user:
+            raise ImproperlyConfigured("Please set your Oracle db user")
+
+        if not password:
+            password = os.getenv("PASSWORD")
+
+        if not password:
+            raise ImproperlyConfigured("Please set your Oracle db password")
+
+        conn = None
+
+        try:
+            conn = oracledb.connect(
+                user=user,
+                password=password,
+                dsn=dsn,
+                )
+        except oracledb.Error as e:
+            raise ValidationError(e)
+
+        def run_sql_oracle(sql: str) -> Union[pd.DataFrame, None]:
+            if conn:
+                try:
+                    sql = sql.rstrip()
+                    if sql.endswith(';'): #fix for a known problem with Oracle db where an extra ; will cause an error.
+                        sql = sql[:-1]
+
+                    cs = conn.cursor()
+                    cs.execute(sql)
+                    results = cs.fetchall()
+
+                    # Create a pandas dataframe from the results
+                    df = pd.DataFrame(
+                        results, columns=[desc[0] for desc in cs.description]
+                    )
+                    return df
+
+                except oracledb.Error as e:
+                    conn.rollback()
+                    raise ValidationError(e)
+
+                except Exception as e:
+                    conn.rollback()
+                    raise e
+
+        self.run_sql_is_set = True
+        self.run_sql = run_sql_oracle
 
     def connect_to_bigquery(self, cred_file_path: str = None, project_id: str = None):
         """
@@ -1238,7 +1338,7 @@ class VannaBase(ABC):
         """
 
         if question and not sql:
-            raise ValidationError(f"Please also provide a SQL query")
+            raise ValidationError("Please also provide a SQL query")
 
         if documentation:
             print("Adding documentation....")

{vanna-0.3.3 → vanna-0.3.4}/src/vanna/chromadb/chromadb_vector.py

@@ -1,5 +1,4 @@
 import json
-import uuid
 from typing import List
 
 import chromadb
@@ -16,17 +15,14 @@ default_ef = embedding_functions.DefaultEmbeddingFunction()
 class ChromaDB_VectorStore(VannaBase):
     def __init__(self, config=None):
         VannaBase.__init__(self, config=config)
+        if config is None:
+            config = {}
 
-        if config is not None:
-            path = config.get("path", ".")
-            self.embedding_function = config.get("embedding_function", default_ef)
-            curr_client = config.get("client", "persistent")
-            self.n_results = config.get("n_results", 10)
-        else:
-            path = "."
-            self.embedding_function = default_ef
-            curr_client = "persistent"  # defaults to persistent storage
-            self.n_results = 10  # defaults to 10 documents
+        path = config.get("path", ".")
+        self.embedding_function = config.get("embedding_function", default_ef)
+        curr_client = config.get("client", "persistent")
+        collection_metadata = config.get("collection_metadata", None)
+        self.n_results = config.get("n_results", 10)
 
         if curr_client == "persistent":
             self.chroma_client = chromadb.PersistentClient(
@@ -43,13 +39,19 @@ class ChromaDB_VectorStore(VannaBase):
             raise ValueError(f"Unsupported client was set in config: {curr_client}")
 
         self.documentation_collection = self.chroma_client.get_or_create_collection(
-            name="documentation", embedding_function=self.embedding_function
+            name="documentation",
+            embedding_function=self.embedding_function,
+            metadata=collection_metadata,
         )
         self.ddl_collection = self.chroma_client.get_or_create_collection(
-            name="ddl", embedding_function=self.embedding_function
+            name="ddl",
+            embedding_function=self.embedding_function,
+            metadata=collection_metadata,
         )
         self.sql_collection = self.chroma_client.get_or_create_collection(
-            name="sql", embedding_function=self.embedding_function
+            name="sql",
+            embedding_function=self.embedding_function,
+            metadata=collection_metadata,
         )
 
     def generate_embedding(self, data: str, **kwargs) -> List[float]:

{vanna-0.3.3 → vanna-0.3.4}/src/vanna/flask/__init__.py

@@ -525,7 +525,7 @@ class VannaFlaskApp:
         # Proxy the /vanna.svg file to the remote server
         @self.flask_app.route("/vanna.svg")
         def proxy_vanna_svg():
-            remote_url = f"https://vanna.ai/img/vanna.svg"
+            remote_url = "https://vanna.ai/img/vanna.svg"
             response = requests.get(remote_url, stream=True)
 
             # Check if the request to the remote URL was successful

vanna-0.3.4/src/vanna/remote.py

@@ -0,0 +1,77 @@
+import dataclasses
+import json
+from io import StringIO
+from typing import Callable, List, Tuple, Union
+
+import pandas as pd
+import requests
+
+from .base import VannaBase
+from .types import (
+  AccuracyStats,
+  ApiKey,
+  DataFrameJSON,
+  DataResult,
+  Explanation,
+  FullQuestionDocument,
+  NewOrganization,
+  NewOrganizationMember,
+  Organization,
+  OrganizationList,
+  PlotlyResult,
+  Question,
+  QuestionCategory,
+  QuestionId,
+  QuestionList,
+  QuestionSQLPair,
+  QuestionStringList,
+  SQLAnswer,
+  Status,
+  StatusWithId,
+  StringData,
+  TrainingData,
+  UserEmail,
+  UserOTP,
+  Visibility,
+)
+from .vannadb import VannaDB_VectorStore
+
+
+class VannaDefault(VannaDB_VectorStore):
+    def __init__(self, model: str, api_key: str, config=None):
+        VannaBase.__init__(self, config=config)
+        VannaDB_VectorStore.__init__(self, vanna_model=model, vanna_api_key=api_key, config=config)
+
+        self._model = model
+        self._api_key = api_key
+
+        self._endpoint = (
+            "https://ask.vanna.ai/rpc"
+            if config is None or "endpoint" not in config
+            else config["endpoint"]
+        )
+
+    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 submit_prompt(self, prompt, **kwargs) -> str:
+        # JSON-ify the prompt
+        json_prompt = json.dumps(prompt)
+
+        params = [StringData(data=json_prompt)]
+
+        d = self._rpc_call(method="submit_prompt", params=params)
+
+        if "result" not in d:
+            return None
+
+        # Load the result into a dataclass
+        results = StringData(**d["result"])
+
+        return results.data

{vanna-0.3.3 → vanna-0.3.4}/src/vanna/vannadb/vannadb_vector.py

@@ -7,14 +7,17 @@ import requests
 
 from ..base import VannaBase
 from ..types import (
-    DataFrameJSON,
-    Question,
-    QuestionSQLPair,
-    Status,
-    StatusWithId,
-    StringData,
-    TrainingData,
+  DataFrameJSON,
+  NewOrganization,
+  OrganizationList,
+  Question,
+  QuestionSQLPair,
+  Status,
+  StatusWithId,
+  StringData,
+  TrainingData,
 )
+from ..utils import sanitize_model_name
 
 
 class VannaDB_VectorStore(VannaBase):
@@ -29,27 +32,8 @@ class VannaDB_VectorStore(VannaBase):
             if config is None or "endpoint" not in config
             else config["endpoint"]
         )
-        self._unauthenticated_endpoint = (
-            "https://ask.vanna.ai/unauthenticated_rpc"
-            if config is None or "unauthenticated_endpoint" not in config
-            else config["unauthenticated_endpoint"]
-        )
         self.related_training_data = {}
 
-    def _unauthenticated_rpc_call(self, method, params):
-        headers = {
-            "Content-Type": "application/json",
-        }
-        data = {
-            "method": method,
-            "params": [self._dataclass_to_dict(obj) for obj in params],
-        }
-
-        response = requests.post(
-            self._unauthenticated_endpoint, headers=headers, data=json.dumps(data)
-        )
-        return response.json()
-
     def _rpc_call(self, method, params):
         if method != "list_orgs":
             headers = {
@@ -75,6 +59,53 @@ class VannaDB_VectorStore(VannaBase):
     def _dataclass_to_dict(self, obj):
         return dataclasses.asdict(obj)
 
+    def create_model(self, model: str, **kwargs) -> bool:
+        """
+        **Example:**
+        ```python
+        success = vn.create_model("my_model")
+        ```
+        Create a new model.
+
+        Args:
+            model (str): The name of the model to create.
+
+        Returns:
+            bool: True if the model was created, False otherwise.
+        """
+        model = sanitize_model_name(model)
+        params = [NewOrganization(org_name=model, db_type="")]
+
+        d = self._rpc_call(method="create_org", params=params)
+
+        if "result" not in d:
+            return False
+
+        status = Status(**d["result"])
+
+        return status.success
+
+    def get_models(self) -> list:
+        """
+        **Example:**
+        ```python
+        models = vn.get_models()
+        ```
+
+        List the models that belong to the user.
+
+        Returns:
+            List[str]: A list of model names.
+        """
+        d = self._rpc_call(method="list_my_models", params=[])
+
+        if "result" not in d:
+            return []
+
+        orgs = OrganizationList(**d["result"])
+
+        return orgs.organizations
+
     def generate_embedding(self, data: str, **kwargs) -> list[float]:
         # This is done server-side
         pass
@@ -141,7 +172,7 @@ class VannaDB_VectorStore(VannaBase):
         d = self._rpc_call(method="remove_training_data", params=params)
 
         if "result" not in d:
-            raise Exception(f"Error removing training data")
+            raise Exception("Error removing training data")
 
         status = Status(**d["result"])
 

vanna-0.3.3/src/vanna/remote.py

@@ -1,455 +0,0 @@
-import dataclasses
-import json
-from io import StringIO
-from typing import Callable, List, Tuple, Union
-
-import pandas as pd
-import requests
-
-from .base import VannaBase
-from .types import (
-  AccuracyStats,
-  ApiKey,
-  DataFrameJSON,
-  DataResult,
-  Explanation,
-  FullQuestionDocument,
-  NewOrganization,
-  NewOrganizationMember,
-  Organization,
-  OrganizationList,
-  PlotlyResult,
-  Question,
-  QuestionCategory,
-  QuestionId,
-  QuestionList,
-  QuestionSQLPair,
-  QuestionStringList,
-  SQLAnswer,
-  Status,
-  StatusWithId,
-  StringData,
-  TrainingData,
-  UserEmail,
-  UserOTP,
-  Visibility,
-)
-
-
-class VannaDefault(VannaBase):
-    def __init__(self, model: str, api_key: str, config=None):
-        VannaBase.__init__(self, config=config)
-
-        self._model = model
-        self._api_key = api_key
-
-        self._endpoint = (
-            "https://ask.vanna.ai/rpc"
-            if config is None or "endpoint" not in config
-            else config["endpoint"]
-        )
-        self._unauthenticated_endpoint = (
-            "https://ask.vanna.ai/unauthenticated_rpc"
-            if config is None or "unauthenticated_endpoint" not in config
-            else config["unauthenticated_endpoint"]
-        )
-
-    def _unauthenticated_rpc_call(self, method, params):
-        headers = {
-            "Content-Type": "application/json",
-        }
-        data = {
-            "method": method,
-            "params": [self._dataclass_to_dict(obj) for obj in params],
-        }
-
-        response = requests.post(
-            self._unauthenticated_endpoint, headers=headers, data=json.dumps(data)
-        )
-        return response.json()
-
-    def _rpc_call(self, method, params):
-        if method != "list_orgs":
-            headers = {
-                "Content-Type": "application/json",
-                "Vanna-Key": self._api_key,
-                "Vanna-Org": self._model,
-            }
-        else:
-            headers = {
-                "Content-Type": "application/json",
-                "Vanna-Key": self._api_key,
-                "Vanna-Org": "demo-tpc-h",
-            }
-
-        data = {
-            "method": method,
-            "params": [self._dataclass_to_dict(obj) for obj in params],
-        }
-
-        response = requests.post(self._endpoint, headers=headers, data=json.dumps(data))
-        return response.json()
-
-    def _dataclass_to_dict(self, obj):
-        return dataclasses.asdict(obj)
-
-    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 get_training_data(self, **kwargs) -> pd.DataFrame:
-        """
-        Get the training data for the current model
-
-        **Example:**
-        ```python
-        training_data = vn.get_training_data()
-        ```
-
-        Returns:
-            pd.DataFrame or None: The training data, or None if an error occurred.
-
-        """
-        params = []
-
-        d = self._rpc_call(method="get_training_data", params=params)
-
-        if "result" not in d:
-            return None
-
-        # Load the result into a dataclass
-        training_data = DataFrameJSON(**d["result"])
-
-        df = pd.read_json(StringIO(training_data.data))
-
-        return df
-
-    def remove_training_data(self, id: str, **kwargs) -> bool:
-        """
-        Remove training data from the model
-
-        **Example:**
-        ```python
-        vn.remove_training_data(id="1-ddl")
-        ```
-
-        Args:
-            id (str): The ID of the training data to remove.
-        """
-        params = [StringData(data=id)]
-
-        d = self._rpc_call(method="remove_training_data", params=params)
-
-        if "result" not in d:
-            raise Exception(f"Error removing training data")
-
-        status = Status(**d["result"])
-
-        if not status.success:
-            raise Exception(f"Error removing training data: {status.message}")
-
-        return status.success
-
-    def generate_questions(self) -> list[str]:
-        """
-        **Example:**
-        ```python
-        vn.generate_questions()
-        # ['What is the average salary of employees?', 'What is the total salary of employees?', ...]
-        ```
-
-        Generate questions using the Vanna.AI API.
-
-        Returns:
-            List[str] or None: The questions, or None if an error occurred.
-        """
-        d = self._rpc_call(method="generate_questions", params=[])
-
-        if "result" not in d:
-            return None
-
-        # Load the result into a dataclass
-        question_string_list = QuestionStringList(**d["result"])
-
-        return question_string_list.questions
-
-    def add_ddl(self, ddl: str, **kwargs) -> str:
-        """
-        Adds a DDL statement to the model's training data
-
-        **Example:**
-        ```python
-        vn.add_ddl(
-            ddl="CREATE TABLE employees (id INT, name VARCHAR(255), salary INT)"
-        )
-        ```
-
-        Args:
-            ddl (str): The DDL statement to store.
-
-        Returns:
-            str: The ID of the DDL statement.
-        """
-        params = [StringData(data=ddl)]
-
-        d = self._rpc_call(method="add_ddl", params=params)
-
-        if "result" not in d:
-            raise Exception("Error adding DDL", d)
-
-        status = StatusWithId(**d["result"])
-
-        return status.id
-
-    def add_documentation(self, documentation: str, **kwargs) -> str:
-        """
-        Adds documentation to the model's training data
-
-        **Example:**
-        ```python
-        vn.add_documentation(
-            documentation="Our organization's definition of sales is the discount price of an item multiplied by the quantity sold."
-        )
-        ```
-
-        Args:
-            documentation (str): The documentation string to store.
-
-        Returns:
-            str: The ID of the documentation string.
-        """
-        params = [StringData(data=documentation)]
-
-        d = self._rpc_call(method="add_documentation", params=params)
-
-        if "result" not in d:
-            raise Exception("Error adding documentation", d)
-
-        status = StatusWithId(**d["result"])
-
-        return status.id
-
-    def add_question_sql(self, question: str, sql: str, **kwargs) -> str:
-        """
-        Adds a question and its corresponding SQL query to the model's training data. The preferred way to call this is to use [`vn.train(sql=...)`][vanna.train].
-
-        **Example:**
-        ```python
-        vn.add_sql(
-            question="What is the average salary of employees?",
-            sql="SELECT AVG(salary) FROM employees"
-        )
-        ```
-
-        Args:
-            question (str): The question to store.
-            sql (str): The SQL query to store.
-            tag (Union[str, None]): A tag to associate with the question and SQL query.
-
-        Returns:
-            str: The ID of the question and SQL query.
-        """
-        if "tag" in kwargs:
-            tag = kwargs["tag"]
-        else:
-            tag = "Manually Trained"
-
-        params = [QuestionSQLPair(question=question, sql=sql, tag=tag)]
-
-        d = self._rpc_call(method="add_sql", params=params)
-
-        if "result" not in d:
-            raise Exception("Error adding question and SQL pair", d)
-
-        status = StatusWithId(**d["result"])
-
-        return status.id
-
-    def generate_embedding(self, data: str, **kwargs) -> list[float]:
-        """
-        Not necessary for remote models as embeddings are generated on the server side.
-        """
-        pass
-
-    def generate_plotly_code(
-        self, question: str = None, sql: str = None, df_metadata: str = None, **kwargs
-    ) -> str:
-        """
-        **Example:**
-        ```python
-        vn.generate_plotly_code(
-            question="What is the average salary of employees?",
-            sql="SELECT AVG(salary) FROM employees",
-            df_metadata=df.dtypes
-        )
-        # fig = px.bar(df, x="name", y="salary")
-        ```
-        Generate Plotly code using the Vanna.AI API.
-
-        Args:
-            question (str): The question to generate Plotly code for.
-            sql (str): The SQL query to generate Plotly code for.
-            df (pd.DataFrame): The dataframe to generate Plotly code for.
-            chart_instructions (str): Optional instructions for how to plot the chart.
-
-        Returns:
-            str or None: The Plotly code, or None if an error occurred.
-        """
-        if kwargs is not None and "chart_instructions" in kwargs:
-            if question is not None:
-                question = (
-                    question
-                    + " -- When plotting, follow these instructions: "
-                    + kwargs["chart_instructions"]
-                )
-            else:
-                question = (
-                    "When plotting, follow these instructions: "
-                    + kwargs["chart_instructions"]
-                )
-
-        params = [
-            DataResult(
-                question=question,
-                sql=sql,
-                table_markdown=df_metadata,
-                error=None,
-                correction_attempts=0,
-            )
-        ]
-
-        d = self._rpc_call(method="generate_plotly_code", params=params)
-
-        if "result" not in d:
-            return None
-
-        # Load the result into a dataclass
-        plotly_code = PlotlyResult(**d["result"])
-
-        return plotly_code.plotly_code
-
-    def generate_question(self, sql: str, **kwargs) -> str:
-        """
-
-        **Example:**
-        ```python
-        vn.generate_question(sql="SELECT * FROM students WHERE name = 'John Doe'")
-        # 'What is the name of the student?'
-        ```
-
-        Generate a question from an SQL query using the Vanna.AI API.
-
-        Args:
-            sql (str): The SQL query to generate a question for.
-
-        Returns:
-            str or None: The question, or None if an error occurred.
-
-        """
-        params = [
-            SQLAnswer(
-                raw_answer="",
-                prefix="",
-                postfix="",
-                sql=sql,
-            )
-        ]
-
-        d = self._rpc_call(method="generate_question", params=params)
-
-        if "result" not in d:
-            return None
-
-        # Load the result into a dataclass
-        question = Question(**d["result"])
-
-        return question.question
-
-    def get_sql_prompt(
-        self,
-        question: str,
-        question_sql_list: list,
-        ddl_list: list,
-        doc_list: list,
-        **kwargs,
-    ):
-        """
-        Not necessary for remote models as prompts are generated on the server side.
-        """
-
-    def get_followup_questions_prompt(
-        self,
-        question: str,
-        df: pd.DataFrame,
-        question_sql_list: list,
-        ddl_list: list,
-        doc_list: list,
-        **kwargs,
-    ):
-        """
-        Not necessary for remote models as prompts are generated on the server side.
-        """
-
-    def submit_prompt(self, prompt, **kwargs) -> str:
-        # JSON-ify the prompt
-        json_prompt = json.dumps(prompt)
-
-        params = [StringData(data=json_prompt)]
-
-        d = self._rpc_call(method="submit_prompt", params=params)
-
-        if "result" not in d:
-            return None
-
-        # Load the result into a dataclass
-        results = StringData(**d["result"])
-
-        return results.data
-
-    def get_similar_question_sql(self, question: str, **kwargs) -> list:
-        """
-        Not necessary for remote models as similar questions are generated on the server side.
-        """
-
-    def get_related_ddl(self, question: str, **kwargs) -> list:
-        """
-        Not necessary for remote models as related DDL statements are generated on the server side.
-        """
-
-    def get_related_documentation(self, question: str, **kwargs) -> list:
-        """
-        Not necessary for remote models as related documentation is generated on the server side.
-        """
-
-    def generate_sql(self, question: str, **kwargs) -> str:
-        """
-        **Example:**
-        ```python
-        vn.generate_sql_from_question(question="What is the average salary of employees?")
-        # SELECT AVG(salary) FROM employees
-        ```
-
-        Generate an SQL query using the Vanna.AI API.
-
-        Args:
-            question (str): The question to generate an SQL query for.
-
-        Returns:
-            str or None: The SQL query, or None if an error occurred.
-        """
-        params = [Question(question=question)]
-
-        d = self._rpc_call(method="generate_sql_from_question", params=params)
-
-        if "result" not in d:
-            return None
-
-        # Load the result into a dataclass
-        sql_answer = SQLAnswer(**d["result"])
-
-        return sql_answer.sql