tinybird 0.0.1.dev35__tar.gz → 0.0.1.dev36__tar.gz

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev35
+Version: 0.0.1.dev36
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/prompts.py

@@ -641,6 +641,7 @@ The previous instructions are explanations of how things work in Tinybird. Answe
 
 datasource_instructions = """
 <datasource_file_instructions>
+    - Content cannot be empty.
     - The datasource names must be unique.
     - No indentation is allowed for property names: DESCRIPTION, SCHEMA, ENGINE, ENGINE_PARTITION_KEY, ENGINE_SORTING_KEY, etc.
     - Use MergeTree engine by default.
@@ -701,6 +702,7 @@ sql_instructions = """
     </valid_query_with_parameters_with_%_on_top>
     - The Parameter functions like this one {{{{String(my_param_name,default_value)}}}} can be one of the following: String, DateTime, Date, Float32, Float64, Int, Integer, UInt8, UInt16, UInt32, UInt64, UInt128, UInt256, Int8, Int16, Int32, Int64, Int128, Int256
     - Parameter names must be different from column names. Pass always the param name and a default value to the function.
+    - Use ALWAYS hardcoded values for default values for parameters.
     - Code inside the template {{{{template_expression}}}} follows the rules of Tornado templating language so no module is allowed to be imported. So for example you can't use now() as default value for a DateTime parameter. You need an if else block like this:
     <invalid_condition_with_now>
     AND timestamp BETWEEN {{DateTime(start_date, now() - interval 30 day)}} AND {{DateTime(end_date, now())}}

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/__cli__.py

@@ -4,5 +4,5 @@ __description__ = 'Tinybird Command Line Tool'
 __url__ = 'https://www.tinybird.co/docs/cli/introduction.html'
 __author__ = 'Tinybird'
 __author_email__ = 'support@tinybird.co'
-__version__ = '0.0.1.dev35'
-__revision__ = '5046116'
+__version__ = '0.0.1.dev36'
+__revision__ = '5ad3ab4'

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/build.py

@@ -2,6 +2,7 @@ import asyncio
 import glob
 import json
 import logging
+import os
 import threading
 import time
 from pathlib import Path
@@ -13,6 +14,7 @@ import requests
 from tinybird.client import TinyB
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import push_data
+from tinybird.tb.modules.datafile.fixture import build_fixture_name, get_fixture_dir
 from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.local_common import get_tinybird_local_client
 from tinybird.tb.modules.shell import Shell
@@ -20,7 +22,7 @@ from tinybird.tb.modules.watch import watch_project
 
 
 @cli.command()
-@click.option("--folder", type=str, default=".")
+@click.option("--folder", type=str, default=os.getcwd())
 @click.option("--watch", is_flag=True, default=False, help="Watch for changes and rebuild automatically")
 def build(folder: str, watch: bool) -> None:
     """
@@ -30,11 +32,13 @@ def build(folder: str, watch: bool) -> None:
     tb_client = asyncio.run(get_tinybird_local_client(folder))
     click.echo(FeedbackManager.highlight(message="\n» Building project..."))
 
+    time_start = time.time()
+
     def process() -> None:
         build_project(folder, tb_client)
 
-    time_start = time.time()
     process()
+
     time_end = time.time()
     elapsed_time = time_end - time_start
     click.echo(FeedbackManager.success(message=f"\n✓ Build completed in {elapsed_time:.1f}s"))
@@ -112,6 +116,20 @@ def build_project(folder: str, tb_client: TinyB) -> None:
                     pipe_path = pipe_path.replace(f"{folder}/", "")
                     click.echo(FeedbackManager.info(message=f"✓ {pipe_path} created"))
 
+            for filename in project_files:
+                if filename.endswith(".datasource"):
+                    ds_path = Path(filename)
+                    ds_name = ds_path.stem
+                    name = build_fixture_name(filename, ds_name, ds_path.read_text())
+                    fixture_folder = get_fixture_dir(folder)
+                    fixture_path = fixture_folder / f"{name}.ndjson"
+
+                    if not fixture_path.exists():
+                        fixture_path = fixture_folder / f"{ds_name}.ndjson"
+
+                    if fixture_path.exists():
+                        append_fixture(tb_client, ds_name, str(fixture_path))
+
         elif build_result == "failed":
             click.echo(FeedbackManager.error(message="Build failed"))
             build_errors = result.get("errors")
@@ -121,24 +139,27 @@ def build_project(folder: str, tb_client: TinyB) -> None:
                 click.echo(FeedbackManager.error(message=error_msg))
         else:
             click.echo(FeedbackManager.error(message=f"Unknown build result. Error: {result.get('error')}"))
+
     except Exception as e:
-        click.echo(FeedbackManager.error_exception(error="Error building project: " + str(e)))
+        click.echo(FeedbackManager.error_exception(error="Error: " + str(e)))
     finally:
         for fd in fds:
             fd.close()
 
 
-async def append_fixture(
+def append_fixture(
     tb_client: TinyB,
     datasource_name: str,
     url: str,
 ):
-    await tb_client.datasource_truncate(datasource_name)
-    await push_data(
-        tb_client,
-        datasource_name,
-        url,
-        mode="append",
-        concurrency=1,
-        silent=True,
+    asyncio.run(tb_client.datasource_truncate(datasource_name))
+    asyncio.run(
+        push_data(
+            tb_client,
+            datasource_name,
+            url,
+            mode="append",
+            concurrency=1,
+            silent=True,
+        )
     )

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/cli.py

@@ -67,58 +67,13 @@ VERSION = f"{__cli__.__version__} (rev {__cli__.__revision__})"
 )
 @click.option("--token", help="Use auth token, defaults to TB_TOKEN envvar, then to the .tinyb file")
 @click.option("--host", help="Use custom host, defaults to TB_HOST envvar, then to https://api.tinybird.co")
-@click.option("--gcp-project-id", help="The Google Cloud project ID", hidden=True)
-@click.option(
-    "--gcs-bucket", help="The Google Cloud Storage bucket to write temp files when using the connectors", hidden=True
-)
-@click.option(
-    "--google-application-credentials",
-    envvar="GOOGLE_APPLICATION_CREDENTIALS",
-    help="Set GOOGLE_APPLICATION_CREDENTIALS",
-    hidden=True,
-)
-@click.option("--sf-account", help="The Snowflake Account (e.g. your-domain.west-europe.azure)", hidden=True)
-@click.option("--sf-warehouse", help="The Snowflake warehouse name", hidden=True)
-@click.option("--sf-database", help="The Snowflake database name", hidden=True)
-@click.option("--sf-schema", help="The Snowflake schema name", hidden=True)
-@click.option("--sf-role", help="The Snowflake role name", hidden=True)
-@click.option("--sf-user", help="The Snowflake user name", hidden=True)
-@click.option("--sf-password", help="The Snowflake password", hidden=True)
-@click.option(
-    "--sf-storage-integration",
-    help="The Snowflake GCS storage integration name (leave empty to auto-generate one)",
-    hidden=True,
-)
-@click.option("--sf-stage", help="The Snowflake GCS stage name (leave empty to auto-generate one)", hidden=True)
-@click.option(
-    "--with-headers", help="Flag to enable connector to export with headers", is_flag=True, default=False, hidden=True
-)
 @click.option("--show-tokens", is_flag=True, default=False, help="Enable the output of tokens")
-@click.option("--prod/--local", is_flag=True, default=False, help="Run against production or local")
+@click.option("--show-tokens", is_flag=True, default=False, help="Enable the output of tokens")
+@click.option("--prod", is_flag=True, default=False, help="Run against production")
 @click.version_option(version=VERSION)
 @click.pass_context
 @coro
-async def cli(
-    ctx: Context,
-    debug: bool,
-    token: str,
-    host: str,
-    gcp_project_id: str,
-    gcs_bucket: str,
-    google_application_credentials: str,
-    sf_account: str,
-    sf_warehouse: str,
-    sf_database: str,
-    sf_schema: str,
-    sf_role: str,
-    sf_user: str,
-    sf_password: str,
-    sf_storage_integration: str,
-    sf_stage,
-    with_headers: bool,
-    show_tokens: bool,
-    prod: bool,
-) -> None:
+async def cli(ctx: Context, debug: bool, token: str, host: str, show_tokens: bool, prod: bool) -> None:
     """
     Use `OBFUSCATE_REGEX_PATTERN` and `OBFUSCATE_PATTERN_SEPARATOR` environment variables to define a regex pattern and a separator (in case of a single string with multiple regex) to obfuscate secrets in the CLI output.
     """
@@ -166,51 +121,9 @@ async def cli(
 
     ctx.ensure_object(dict)["config"] = config
 
-    if ctx.invoked_subcommand == "auth":
-        return
-
-    from tinybird.connectors import create_connector
-
-    if gcp_project_id and gcs_bucket and google_application_credentials and not sf_account:
-        bq_config = {
-            "project_id": gcp_project_id,
-            "bucket_name": gcs_bucket,
-            "service_account": google_application_credentials,
-            "with_headers": with_headers,
-        }
-        ctx.ensure_object(dict)["bigquery"] = create_connector("bigquery", bq_config)
-    if (
-        sf_account
-        and sf_warehouse
-        and sf_database
-        and sf_schema
-        and sf_role
-        and sf_user
-        and sf_password
-        and gcs_bucket
-        and google_application_credentials
-        and gcp_project_id
-    ):
-        sf_config = {
-            "account": sf_account,
-            "warehouse": sf_warehouse,
-            "database": sf_database,
-            "schema": sf_schema,
-            "role": sf_role,
-            "user": sf_user,
-            "password": sf_password,
-            "storage_integration": sf_storage_integration,
-            "stage": sf_stage,
-            "bucket_name": gcs_bucket,
-            "service_account": google_application_credentials,
-            "project_id": gcp_project_id,
-            "with_headers": with_headers,
-        }
-        ctx.ensure_object(dict)["snowflake"] = create_connector("snowflake", sf_config)
-
     logging.debug("debug enabled")
 
-    skip_client = ctx.invoked_subcommand in ["login", "workspace", "local", "build"]
+    skip_client = ctx.invoked_subcommand in ["auth", "login", "workspace", "local", "build"]
     client = await create_ctx_client(config, prod, skip_client)
 
     if client:
@@ -487,7 +400,7 @@ async def sql(
 
 @cli.command(hidden=True)
 @click.argument("prompt")
-@click.option("--folder", default=".", help="The folder to use for the project")
+@click.option("--folder", default=os.getcwd(), help="The folder to use for the project")
 @coro
 async def ask(prompt: str, folder: str) -> None:
     """Ask things about your data project."""
@@ -529,8 +442,8 @@ async def ask(prompt: str, folder: str) -> None:
         )
 
         client = config.get_client()
-        llm = LLM(user_token=user_token, client=client)
-        click.echo(await llm.ask(system_prompt=ask_prompt(resources_xml), prompt=prompt))
+        llm = LLM(user_token=user_token, host=client.host)
+        click.echo(llm.ask(system_prompt=ask_prompt(resources_xml), prompt=prompt))
     except Exception as e:
         raise CLIException(FeedbackManager.error_exception(error=e))
 

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/create.py

@@ -103,13 +103,13 @@ async def create(
                 datasource_files = [f for f in os.listdir(Path(folder) / "datasources") if f.endswith(".datasource")]
                 for datasource_file in datasource_files:
                     datasource_path = Path(folder) / "datasources" / datasource_file
-                    llm = LLM(user_token=user_token, client=tb_client)
+                    llm = LLM(user_token=user_token, host=tb_client.host)
                     datasource_name = datasource_path.stem
                     datasource_content = datasource_path.read_text()
                     has_json_path = "`json:" in datasource_content
                     if has_json_path:
                         prompt = f"<datasource_schema>{datasource_content}</datasource_schema>\n<user_input>{prompt}</user_input>"
-                        response = await llm.ask(system_prompt=mock_prompt(rows), prompt=prompt)
+                        response = llm.ask(system_prompt=mock_prompt(rows), prompt=prompt)
                         sql = extract_xml(response, "sql")
                         sql = sql.split("FORMAT")[0]
                         result = await local_client.query(f"{sql} FORMAT JSON")
@@ -205,8 +205,8 @@ TYPE ENDPOINT
                 ]
             ]
         )
-        llm = LLM(user_token=user_token, client=tb_client)
-        result = await llm.ask(system_prompt=create_prompt(resources_xml), prompt=prompt)
+        llm = LLM(user_token=user_token, host=tb_client.host)
+        result = llm.ask(system_prompt=create_prompt(resources_xml), prompt=prompt)
         result = extract_xml(result, "response")
         resources = parse_xml(result, "resource")
         datasources = []

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/datafile/build.py

@@ -44,7 +44,7 @@ from tinybird.tb.modules.datafile.exceptions import AlreadyExistsException, Incl
 from tinybird.tb.modules.datafile.parse_datasource import parse_datasource
 from tinybird.tb.modules.datafile.parse_pipe import parse_pipe
 from tinybird.tb.modules.feedback_manager import FeedbackManager
-from tinybird.tb.modules.local_common import get_client_config_for_build
+from tinybird.tb.modules.local_common import get_tinybird_local_config
 
 
 async def folder_build(
@@ -58,7 +58,7 @@ async def folder_build(
     local_ws: Optional[Dict[str, Any]] = None,
     watch: bool = False,
 ):
-    config = await get_client_config_for_build(folder)
+    config = await get_tinybird_local_config(folder)
     build = True
     dry_run = False
     force = True

tinybird-0.0.1.dev36/tinybird/tb/modules/llm.py

@@ -0,0 +1,32 @@
+import requests
+
+
+class LLM:
+    def __init__(
+        self,
+        host: str,
+        user_token: str,
+    ):
+        self.host = host
+        self.user_token = user_token
+
+    def ask(self, system_prompt: str, prompt: str) -> str:
+        """
+        Calls the model with the given prompt and returns the response.
+
+        Args:
+            system_prompt (str): The system prompt to send to the model.
+            prompt (str): The user prompt to send to the model.
+
+        Returns:
+            str: The response from the language model.
+        """
+
+        data = {"system": system_prompt, "prompt": prompt}
+
+        response = requests.post(
+            f"{self.host}/v0/llm",
+            headers={"Authorization": f"Bearer {self.user_token}"},
+            data=data,
+        )
+        return response.json().get("result", "")

tinybird-0.0.1.dev36/tinybird/tb/modules/llm_utils.py

@@ -0,0 +1,111 @@
+import re
+from typing import List
+
+
+def extract_xml(text: str, tag: str) -> str:
+    """
+    Extracts the content of the specified XML tag from the given text. Used for parsing structured responses
+
+    Args:
+        text (str): The text containing the XML.
+        tag (str): The XML tag to extract content from.
+
+    Returns:
+        str: The content of the specified XML tag, or an empty string if the tag is not found.
+    """
+    match = re.search(f"<{tag}>(.*?)</{tag}>", text, re.DOTALL)
+    return match.group(1) if match else ""
+
+
+def parse_xml(text: str, tag: str) -> List[str]:
+    """
+    Parses the text for the specified XML tag and returns a list of the contents of each tag.
+    """
+    return re.findall(f"<{tag}.*?>(.*?)</{tag}>", text, re.DOTALL)
+
+
+def generate(llm_call, task: str, context: str = "") -> tuple[str, str]:
+    """Generate and improve a solution based on feedback."""
+    task = f"<task>\n{task}\n</task>"
+    full_prompt = (
+        f"{generator_prompt}\n<context>\n{context}\n</context>\n{task}" if context else f"{generator_prompt}\n{task}"
+    )
+    response = llm_call(full_prompt)
+    thoughts = extract_xml(response, "thoughts")
+    result = extract_xml(response, "response")
+
+    return thoughts, result
+
+
+def evaluate(llm_call, content: str, task: str) -> tuple[str, str]:
+    """Evaluate if a solution meets requirements."""
+    full_prompt = f"{evaluator_prompt}\n<original_task>\n{task}\n</original_task>\n<content_to_evaluate>\n{content}\n</content_to_evaluate>"
+    response = llm_call(full_prompt)
+    evaluation = extract_xml(response, "evaluation")
+    feedback = extract_xml(response, "feedback")
+
+    return evaluation, feedback
+
+
+def loop(llm_call, task: str) -> str:
+    """Keep generating and evaluating until requirements are met."""
+    memory = []
+    chain_of_thought = []
+
+    thoughts, result = generate(llm_call, task)
+    memory.append(result)
+    chain_of_thought.append({"thoughts": thoughts, "result": result})
+
+    attempts = 0
+    while True:
+        if attempts > 5:
+            raise Exception("Failed to generate a valid solution")
+
+        evaluation, feedback = evaluate(llm_call, result, task)
+        if evaluation == "PASS":
+            return result
+
+        context = "\n".join(
+            [
+                "Previous attempts:",
+                *[f"- {m}" for m in memory],
+                f"\nFeedback: {feedback}",
+            ]
+        )
+
+        thoughts, result = generate(llm_call, task, context)
+        memory.append(result)
+        chain_of_thought.append({"thoughts": thoughts, "result": result})
+
+        attempts += 1
+
+
+evaluator_prompt = """
+Evaluate this following code implementation for code correctness taking into account the user prompt and the instructions provided.
+
+You should be evaluating only and not attemping to solve the task.
+Only output "PASS" if all criteria are met and the code won't fail at runtime.
+Output your evaluation concisely in the following format:
+
+<evaluation>PASS or FAIL</evaluation>
+<feedback>
+[What is wrong with the code and how to fix it]
+</feedback>
+"""
+
+generator_prompt = """
+Your goal is to complete the task based on <task> tag. If there are feedback 
+from your previous generations, you should reflect on them to improve your solution
+
+Output your answer concisely in the following format: 
+
+<thoughts>
+[Your understanding of the task and feedback and how you plan to improve]
+</thoughts>
+
+<response>
+[Your code implementation here]
+</response>
+
+The code implementation should not be wrapped in any markdown format.
+"""

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/local_common.py

@@ -17,11 +17,11 @@ TB_LOCAL_HOST = f"http://localhost:{TB_LOCAL_PORT}"
 
 async def get_tinybird_local_client(path: Optional[str] = None) -> TinyB:
     """Get a Tinybird client connected to the local environment."""
-    config = await get_client_config_for_build(path)
+    config = await get_tinybird_local_config(path)
     return config.get_client(host=TB_LOCAL_HOST)
 
 
-async def get_client_config_for_build(path: Optional[str] = None) -> CLIConfig:
+async def get_tinybird_local_config(path: Optional[str] = None) -> CLIConfig:
     """Craft a client config with a workspace name based on the path of the project files
 
     It uses the tokens from tinybird local

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/mock.py

@@ -24,7 +24,7 @@ from tinybird.tb.modules.local_common import get_tinybird_local_client
     default="Use the datasource schema to generate sample data",
     help="Extra context to use for data generation",
 )
-@click.option("--folder", type=str, default=".", help="Folder where datafiles will be placed")
+@click.option("--folder", type=str, default=os.getcwd(), help="Folder where datafiles will be placed")
 @coro
 async def mock(datasource: str, rows: int, prompt: str, folder: str) -> None:
     """Load sample data into a Data Source.
@@ -67,11 +67,10 @@ async def mock(datasource: str, rows: int, prompt: str, folder: str) -> None:
         except Exception:
             click.echo(FeedbackManager.error(message="This action requires authentication. Run 'tb login' first."))
             return
-        user_client.token = user_token
-        llm = LLM(user_token=user_token, client=user_client)
+        llm = LLM(user_token=user_token, host=user_client.host)
         tb_client = await get_tinybird_local_client(os.path.abspath(folder))
         prompt = f"<datasource_schema>{datasource_content}</datasource_schema>\n<user_input>{prompt}</user_input>"
-        response = await llm.ask(system_prompt=mock_prompt(rows), prompt=prompt)
+        response = llm.ask(system_prompt=mock_prompt(rows), prompt=prompt)
         sql = extract_xml(response, "sql")
         if os.environ.get("TB_DEBUG", "") != "":
             logging.debug(sql)

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/test.py

@@ -111,9 +111,9 @@ async def test_create(name_or_filename: str, prompt: str, folder: str) -> None:
         user_token = config.get_user_token()
         if not user_token:
             raise CLIException(FeedbackManager.error(message="No user token found"))
-        llm = LLM(user_token=user_token, client=config.get_client())
+        llm = LLM(user_token=user_token, host=config.get_client().host)
 
-        response_llm = await llm.ask(system_prompt=system_prompt, prompt=prompt)
+        response_llm = llm.ask(system_prompt=system_prompt, prompt=prompt)
         response_xml = extract_xml(response_llm, "response")
         tests_content = parse_xml(response_xml, "test")
 

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird/tb/modules/update.py

@@ -65,13 +65,13 @@ async def update(
             datasource_files = [f for f in os.listdir(Path(folder) / "datasources") if f.endswith(".datasource")]
             for datasource_file in datasource_files:
                 datasource_path = Path(folder) / "datasources" / datasource_file
-                llm = LLM(user_token=user_token, client=tb_client)
+                llm = LLM(user_token=user_token, host=tb_client.host)
                 datasource_name = datasource_path.stem
                 datasource_content = datasource_path.read_text()
                 has_json_path = "`json:" in datasource_content
                 if has_json_path:
                     prompt = f"<datasource_schema>{datasource_content}</datasource_schema>\n<user_input>{prompt}</user_input>"
-                    response = await llm.ask(system_prompt=mock_prompt(rows=20), prompt=prompt)
+                    response = llm.ask(system_prompt=mock_prompt(rows=20), prompt=prompt)
                     sql = extract_xml(response, "sql")
                     sql = sql.split("FORMAT")[0]
                     result = await local_client.query(f"{sql} FORMAT JSON")
@@ -116,8 +116,8 @@ async def update_resources(
             ]
         ]
     )
-    llm = LLM(user_token=user_token, client=tb_client)
-    result = await llm.ask(system_prompt=update_prompt(resources_xml), prompt=prompt)
+    llm = LLM(user_token=user_token, host=tb_client.host)
+    result = llm.ask(system_prompt=update_prompt(resources_xml), prompt=prompt)
     result = extract_xml(result, "response")
     resources = parse_xml(result, "resource")
     datasources = []

{tinybird-0.0.1.dev35 → tinybird-0.0.1.dev36}/tinybird.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tinybird
-Version: 0.0.1.dev35
+Version: 0.0.1.dev36
 Summary: Tinybird Command Line Tool
 Home-page: https://www.tinybird.co/docs/cli/introduction.html
 Author: Tinybird

tinybird-0.0.1.dev35/tinybird/tb/modules/llm.py

@@ -1,38 +0,0 @@
-from copy import deepcopy
-from typing import Optional
-
-from tinybird.client import TinyB
-
-
-class LLM:
-    def __init__(
-        self,
-        user_token: str,
-        client: TinyB,
-    ):
-        self.user_client = deepcopy(client)
-        self.user_client.token = user_token
-
-    async def ask(self, system_prompt: str, prompt: Optional[str] = None) -> str:
-        """
-        Calls the model with the given prompt and returns the response.
-
-        Args:
-            system_prompt (str): The system prompt to send to the model.
-            prompt (str): The user prompt to send to the model.
-
-        Returns:
-            str: The response from the language model.
-        """
-
-        data = {"system": system_prompt}
-
-        if prompt:
-            data["prompt"] = prompt
-
-        response = await self.user_client._req(
-            "/v0/llm",
-            method="POST",
-            data=data,
-        )
-        return response.get("result", "")

tinybird-0.0.1.dev35/tinybird/tb/modules/llm_utils.py

@@ -1,24 +0,0 @@
-import re
-from typing import List
-
-
-def extract_xml(text: str, tag: str) -> str:
-    """
-    Extracts the content of the specified XML tag from the given text. Used for parsing structured responses
-
-    Args:
-        text (str): The text containing the XML.
-        tag (str): The XML tag to extract content from.
-
-    Returns:
-        str: The content of the specified XML tag, or an empty string if the tag is not found.
-    """
-    match = re.search(f"<{tag}>(.*?)</{tag}>", text, re.DOTALL)
-    return match.group(1) if match else ""
-
-
-def parse_xml(text: str, tag: str) -> List[str]:
-    """
-    Parses the text for the specified XML tag and returns a list of the contents of each tag.
-    """
-    return re.findall(f"<{tag}.*?>(.*?)</{tag}>", text, re.DOTALL)