tinybird 0.0.1.dev29__py3-none-any.whl → 0.0.1.dev30__py3-none-any.whl

tinybird/client.py

@@ -112,7 +112,7 @@ class TinyB:
         retries: int = LIMIT_RETRIES,
         use_token: Optional[str] = None,
         **kwargs,
-    ):
+    ) -> Response:
         url = f"{self.host.strip('/')}/{endpoint.strip('/')}"
 
         token_to_use = use_token if use_token else self.token

tinybird/prompts.py

@@ -358,91 +358,75 @@ aggregate_functions = [
 ]
 
 
-create_project_prompt = """
-You are a Tinybird expert. You will be given a prompt describing a data project and you will generate all the associated datasources and pipes.
-<datasource>
-    name: The name of the datasource.
-    content: The content of the datasource datafile in the following format:
+test_create_prompt = """
+You are a Tinybird expert. You will be given a pipe containing different nodes with SQL and Tinybird templating syntax. You will generate URLs to test it with different parameters combinations.
+<pipe>
+    <name>{name}</name>
+    <content>{content}</content>
+    <parameters>{parameters}</parameters>
+</pipe>
 
-    ```
-DESCRIPTION >
-    Some meaningful description of the datasource
+<instructions>
+    - Every test name must be unique.
+    - The test command must be a valid Tinybird command that can be run in the terminal.
+    - The test command can have as many parameters as are needed to test the pipe.
+    - The parameter within Tinybird templating syntax looks like this one {{String(my_param_name, default_value)}}.
+    - If there are no parameters, you can omit parameters and generate a single test command.
+    - The format of the parameters is the following: ?param1=value1&param2=value2&param3=value3
+</instructions>
 
-SCHEMA >
-    `<column_name_1>` <clickhouse_tinybird_compatible_data_type> `json:$.<column_name_1>`,
-    `<column_name_2>` <clickhouse_tinybird_compatible_data_type> `json:$.<column_name_2>`,
-    ...
-    `<column_name_n>` <clickhouse_tinybird_compatible_data_type> `json:$.<column_name_n>`
+Follow the instructions and generate the following response with no additional text:
 
-ENGINE "MergeTree"
-ENGINE_PARTITION_KEY "<partition_key>"
-ENGINE_SORTING_KEY "<sorting_key_1, sorting_key_2, ...>"
-    ```
-</datasource>
-<pipe>
-    name: The name of the pipe.
-    content: The content of the pipe datafile in the following format:
-    ```
-DESCRIPTION >
-    Some meaningful description of the pipe
+<response>
+    <test>
+        <name>[test name here]</name>
+        <description>[test description here]</description>
+        <parameters>[parameters here]</parameters>
+    </test>
+</response>
+"""
 
-NODE node_1
-SQL >
-    <sql_query_using_clickhouse_syntax_and_tinybird_templating_syntax>
 
-...
+def create_prompt(existing_resources: str) -> str:
+    return """
+You are a Tinybird expert. You will be given a prompt to generate Tinybird resources: datasources and/or pipes.
+<existing_resources>{existing_resources}</existing_resources>
+{datasource_instructions}
+{pipe_instructions}
+{sql_instructions}
+{datasource_example}
+{pipe_example}
+{copy_pipe_instructions}
+{materialized_pipe_instructions}
+Use the following format to generate the response and do not wrap it in any other text, including the <response> tag.
+<response>
+    <resource>
+        <type>[datasource or pipe]</type>
+        <name>[resource name here]</name>
+        <content>[resource content here]</content>
+    </resource>
+</response>
 
-NODE node_n
-SQL >
-    <sql_query_using_clickhouse_syntax_and_tinybird_templating_syntax>
-    ```
-</pipe>
-<instructions>
-    - The datasource name must be unique.
-    - The pipe name must be unique.
-    - The datasource will be the landing table for the data.
-    - Create multiple pipes to show different use cases over the same datasource.
-    - The SQL query must be a valid ClickHouse SQL query that mixes ClickHouse syntax and Tinybird templating syntax.
-    - If you use dynamic parameters you MUST start ALWAYS the whole sql query with "%" symbol on top. e.g: SQL >\n    %\n SELECT * FROM <table> WHERE <condition> LIMIT 10
-    - 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.
-    - Code inside the template {{code}} is python code but 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:
-    ```
-    (...)
-    AND timestamp BETWEEN {{DateTime(start_date, now() - interval 30 day)}} AND {{DateTime(end_date, now())}} --this is not valid
+""".format(
+        existing_resources=existing_resources,
+        datasource_instructions=datasource_instructions,
+        pipe_instructions=pipe_instructions,
+        sql_instructions=sql_instructions,
+        datasource_example=datasource_example,
+        pipe_example=pipe_example,
+        copy_pipe_instructions=copy_pipe_instructions,
+        materialized_pipe_instructions=materialized_pipe_instructions,
+    )
 
-    {%if not defined(start_date)%}
-    timestamp BETWEEN now() - interval 30 day
-    {%else%}
-    timestamp BETWEEN {{DateTime(start_date)}} 
-    {%end%}
-    {%if not defined(end_date)%}
-    AND now()
-    {%else%}
-    AND {{DateTime(end_date)}} 
-    {%end%} --this is valid
-    ```
-    - Nodes can't have the same exact name as the Pipe they belong to.
-    - Endpoints can export Prometehus format, Node sql must have name two columns: 
-        name (String): The name of the metric 
-        value (Number): The numeric value for the metric. 
-      and then some optional columns:
-        help (String): A description of the metric.
-        timestamp (Number): A Unix timestamp for the metric.
-        type (String): Defines the metric type (counter, gauge, histogram, summary, untyped, or empty).
-        labels (Map(String, String)): A set of key-value pairs providing metric dimensions.
-    - Use prometheus format when you are asked to monitor something
-    - Nodes do NOT use the same name as the Pipe they belong to. So if the pipe name is "my_pipe", the nodes must be named "my_pipe_node_1", "my_pipe_node_2", etc.
-</instructions>
-"""
 
-generate_sql_mock_data_prompt = """
+def mock_prompt(rows: int) -> str:
+    return f"""
 Given the schema for a Tinybird datasource, return a can you create a clickhouse sql query to generate some random data that matches that schema.
 
 Response format MUST be just a valid clickhouse sql query.
 
-# Example input:
-
+<example>
+    <example_datasource_schema>
 SCHEMA >
     experience_gained Int16 `json:$.experience_gained`,
     level Int16 `json:$.level`,
@@ -451,9 +435,8 @@ SCHEMA >
     pvp_kills Int16 `json:$.pvp_kills`,
     quest_completions Int16 `json:$.quest_completions`,
     timestamp DateTime `json:$.timestamp`
-
-
-# Example output:
+    </example_datasource_schema>
+    <example_output>
 
 SELECT
     rand() % 1000 AS experience_gained, -- Random experience gained between 0 and 999
@@ -464,19 +447,27 @@ SELECT
     rand() % 200 AS quest_completions,  -- Random quest completions between 0 and 199
     now() - rand() % 86400 AS timestamp -- Random timestamp within the last day
 FROM numbers({rows})
+    </example_output>
+</example>
 
-# Instructions:
-
+<instructions>
 - The query MUST return a random sample of data that matches the schema.
 - The query MUST return a valid clickhouse sql query.
 - The query MUST return a sample of EXACTLY {rows} rows.
 - The query MUST be valid for clickhouse and Tinybird.
-- Return JUST the sql query, without any other text or symbols. 
-- Do NOT include ```clickhouse or ```sql or any other wrapping text.
+- FROM numbers({rows}) part is mandatory.
+- Do NOT include ```clickhouse or ```sql or any other wrapping text to the sql query.
 - Do NOT use any of these functions: elementAt
 - Do NOT add a semicolon at the end of the query
 - Do NOT add any FORMAT at the end of the query, because it will be added later by Tinybird.
+- General functions supported are: {general_functions}
+- Character insensitive functions supported are: {general_functions_insensitive}
+- Aggregate functions supported are: {aggregate_functions}
+- Do not use any function that is not present in the list of general functions, character insensitive functions and aggregate functions.
+- If the function is not present in the list, the sql query will fail, so avoid at all costs to use any function that is not present in the list.
+</instructions>
 
+<more_examples>
 # Examples with different schemas, like an array field or a nested JSON field:
 
 ## Example schema with an array field:
@@ -491,13 +482,13 @@ SCHEMA >
     `items` Array(String) `json:$.items[:]` // This is an array field 
 
 ### Desired final output of the query:
-{
+{{
   "order_id": 123456,
   "customer_id": 7890,
   "order_date": "2024-11-30T10:30:00.000Z",
   "total_amount": 150.0,
   "items": ["item1", "item2", "item3"]
-}
+}}
 
 ### Example SQL output with an array field:
 
@@ -526,32 +517,32 @@ SCHEMA >
 Note that the important part is generating the nested fields:
 json:$.request.options.max_tokens > this means that the max_tokens field is nested inside the options field inside the request field.
 
-{
+{{
   "request_id": "req_abc123",
   "timestamp": "2024-11-30T10:30:00.000Z",
-  "request": {
+  "request": {{
     "model": "gpt-4",
-    "options": {
+    "options": {{
       "temperature": 0.7,
       "max_tokens": 1000,
       "stream": false
-    }
-  }
-}
+    }}
+  }}
+}}
 
 ### Example SQL output with nested fields:
 
 SELECT
     request_id,
     timestamp,
-    CAST(concat('{
+    CAST(concat('{{
         "model": "', model, '",
-        "options": {
+        "options": {{
             "temperature": ', temperature, ',
             "max_tokens": ', max_tokens, ',
             "stream": ', IF(stream = 1, 'true', 'false'), '
-        }
-    }'), 'JSON') AS request
+        }}
+    }}'), 'JSON') AS request
 FROM
 (
     SELECT
@@ -563,90 +554,139 @@ FROM
         rand() % 2 AS stream
     FROM numbers(ROWS)
 )
+</more_examples>
 
-# Extra context:
-{context}
-
+Follow the instructions and generate the following response with no additional text in the following format:
+<response>
+    <sql>[raw sql query here]</sql>
+</response>
 """
 
-create_test_prompt = """
-You are a Tinybird expert. You will be given a pipe endpoint containing different nodes with SQL and Tinybird templating syntax. You will generate URLs to test it with different parameters combinations.
-
-<test>
-    <test_1>:
-        name: <test_name_1>
-        description: <description_1>
-        parameters: <url_encoded_parameters_1>
-    <test_2>:
-        name: <test_name_2>
-        description: <description_2>
-        parameters: <url_encoded_parameters_2>
-</test>
-<instructions>
-    - The test name must be unique.
-    - The test command must be a valid Tinybird command that can be run in the terminal.
-    - The test command can have as many parameters as are needed to test the pipe.
-    - The parameter within Tinybird templating syntax looks like this one {{String(my_param_name, default_value)}}.
-    - If there are no parameters in the , you can omit parametrs and generate a single test command.
-    - Extra context: {prompt}
-</instructions>
-"""
 
-test_create_prompt = """
-You are a Tinybird expert. You will be given a pipe containing different nodes with SQL and Tinybird templating syntax. You will generate URLs to test it with different parameters combinations.
-<pipe>
-    <name>{name}</name>
-    <content>{content}</content>
-    <parameters>{parameters}</parameters>
-</pipe>
+copy_pipe_instructions = """
+<copy_pipe_instructions>
+- Do not create copy pipes by default, unless the user asks for it.
+- In a .pipe file you can define how to export the result of a Pipe to a Data Source, optionally with a schedule.
+- Do not include COPY_SCHEDULE in the .pipe file if it is not requested by the user.
+- COPY_SCHEDULE is a cron expression that defines the schedule of the copy pipe.
+- COPY_SCHEDULE is optional and if not provided, the copy pipe will be executed only once.
+- TARGET_DATASOURCE is the name of the Data Source to export the result to.
+- TYPE COPY is the type of the pipe and it is mandatory for copy pipes.
+- If the copy pipe uses parameters, you must include the % character and a newline on top of every query to be able to use the parameters.
+- The content of the .pipe file must follow this format:
+DESCRIPTION Copy Pipe to export sales hour every hour to the sales_hour_copy Data Source
+
+NODE daily_sales
+SQL >
+    %
+    SELECT toStartOfDay(starting_date) day, country, sum(sales) as total_sales
+    FROM teams
+    WHERE
+    day BETWEEN toStartOfDay(now()) - interval 1 day AND toStartOfDay(now())
+    and country = {{ String(country, 'US')}}
+    GROUP BY day, country
+
+TYPE COPY
+TARGET_DATASOURCE sales_hour_copy
+COPY_SCHEDULE 0 * * * *
+</copy_pipe_instructions>
+"""
 
-<instructions>
-    - Every test name must be unique.
-    - The test command must be a valid Tinybird command that can be run in the terminal.
-    - The test command can have as many parameters as are needed to test the pipe.
-    - The parameter within Tinybird templating syntax looks like this one {{String(my_param_name, default_value)}}.
-    - If there are no parameters, you can omit parameters and generate a single test command.
-    - The format of the parameters is the following: ?param1=value1&param2=value2&param3=value3
-</instructions>
+materialized_pipe_instructions = """
+<materialized_pipe_instructions>
+- Do not create materialized pipes by default, unless the user asks for it.
+- In a .pipe file you can define how to materialize each row ingested in the earliest Data Source in the Pipe query to a materialized Data Source. Materialization happens at ingest.
+- DATASOURCE: Required when TYPE is MATERIALIZED. Sets the destination Data Source for materialized nodes.
+- TYPE MATERIALIZED is the type of the pipe and it is mandatory for materialized pipes.
+- The content of the .pipe file must follow this format:
+DESCRIPTION Materialized Pipe to aggregate sales per hour in the sales_by_hour Data Source
 
-Follow the instructions and generate the following response with no additional text:
+NODE daily_sales
+SQL >
+    SELECT toStartOfDay(starting_date) day, country, sum(sales) as total_sales
+    FROM teams
+    GROUP BY day, country
 
-<response>
-    <test>
-        <name>[test name here]</name>
-        <description>[test description here]</description>
-        <parameters>[parameters here]</parameters>
-    </test>
-</response>
+TYPE MATERIALIZED
+DATASOURCE sales_by_hour
+</materialized_pipe_instructions>
 """
 
 
-def create_prompt(existing_resources: str) -> str:
+def ask_prompt(existing_resources: str) -> str:
     return """
-You are a Tinybird expert. You will be given a prompt to generate Tinybird resources: datasources and/or pipes.
-<existing_resources>
-{existing_resources}
-</existing_resources>
+You are a Tinybird expert. You will be given a prompt to ask questions about Tinybird resources.
+<existing_resources>{existing_resources}</existing_resources>
+{datasource_instructions}
+{pipe_instructions}
+{sql_instructions}
+{datasource_example}
+{pipe_example}
+{copy_pipe_instructions}
+{materialized_pipe_instructions}
+
+The previous instructions are explanations of how things work in Tinybird. Answer in natural language.
+
+""".format(
+        existing_resources=existing_resources,
+        datasource_instructions=datasource_instructions,
+        datasource_example=datasource_example,
+        pipe_instructions=pipe_instructions,
+        pipe_example=pipe_example,
+        sql_instructions=sql_instructions,
+        copy_pipe_instructions=copy_pipe_instructions,
+        materialized_pipe_instructions=materialized_pipe_instructions,
+    )
+
+
+datasource_instructions = """
 <datasource_file_instructions>
     - The datasource names must be unique.
     - No indentation is allowed for property names: DESCRIPTION, SCHEMA, ENGINE, ENGINE_PARTITION_KEY, ENGINE_SORTING_KEY, etc.
 </datasource_file_instructions>
+"""
+
+datasource_example = """
+<datasource_content>
+DESCRIPTION >
+    Some meaningful description of the datasource
+
+SCHEMA >
+    `column_name_1` clickhouse_tinybird_compatible_data_type `json:$.column_name_1`,
+    `column_name_2` clickhouse_tinybird_compatible_data_type `json:$.column_name_2`,
+    ...
+    `column_name_n` clickhouse_tinybird_compatible_data_type `json:$.column_name_n`
+
+ENGINE "MergeTree"
+ENGINE_PARTITION_KEY "partition_key"
+ENGINE_SORTING_KEY "sorting_key_1, sorting_key_2, ..."
+</datasource_content>
+"""
+
+pipe_example = """
+<pipe_content>
+DESCRIPTION >
+    Some meaningful description of the pipe
+
+NODE node_1
+SQL >
+    [sql query using clickhouse syntax and tinybird templating syntax and starting always with SELECT or %\nSELECT]
+
+</pipe_content>
+"""
+
+pipe_instructions = """
 <pipe_file_instructions>
     - The pipe names must be unique.
     - Nodes do NOT use the same name as the Pipe they belong to. So if the pipe name is "my_pipe", the nodes must be named different like "my_pipe_node_1", "my_pipe_node_2", etc.
     - Nodes can't have the same exact name as the Pipe they belong to.
     - Avoid more than one node per pipe unless it is really necessary or requested by the user.
     - No indentation is allowed for property names: DESCRIPTION, NODE, SQL, TYPE, etc.
-    - Endpoints can export Prometehus format, Node sql must have name two columns: 
-        - name (String): The name of the metric 
-        - value (Number): The numeric value for the metric. 
-    - and then some optional columns:
-        - help (String): A description of the metric.
-        - timestamp (Number): A Unix timestamp for the metric.
-        - type (String): Defines the metric type (counter, gauge, histogram, summary, untyped, or empty).
-        - labels (Map(String, String)): A set of key-value pairs providing metric dimensions.
-    - Use prometheus format when you are asked to monitor something
+    - Allowed TYPE values are: endpoint, copy, materialized, sink
 </pipe_file_instructions>
+"""
+
+sql_instructions = """
 <sql_instructions>
     - The SQL query must be a valid ClickHouse SQL query that mixes ClickHouse syntax and Tinybird templating syntax (Tornado templating language under the hood).
     - SQL queries with parameters must start with "%" character and a newline on top of every query to be able to use the parameters. Examples:
@@ -693,33 +733,26 @@ You are a Tinybird expert. You will be given a prompt to generate Tinybird resou
     - General functions and aggregate functions are case sensitive.
     - Character insensitive functions are case insensitive.
 </sql_instructions>
+""".format(
+    general_functions=general_functions,
+    general_functions_insensitive=general_functions_insensitive,
+    aggregate_functions=aggregate_functions,
+)
 
-<datasource_content>
-DESCRIPTION >
-    Some meaningful description of the datasource
-
-SCHEMA >
-    `column_name_1` clickhouse_tinybird_compatible_data_type `json:$.column_name_1`,
-    `column_name_2` clickhouse_tinybird_compatible_data_type `json:$.column_name_2`,
-    ...
-    `column_name_n` clickhouse_tinybird_compatible_data_type `json:$.column_name_n`
-
-ENGINE "MergeTree"
-ENGINE_PARTITION_KEY "partition_key"
-ENGINE_SORTING_KEY "sorting_key_1, sorting_key_2, ..."
-</datasource_content>
-<pipe_content>
-DESCRIPTION >
-    Some meaningful description of the pipe
-
-NODE node_1
-SQL >
-    [sql query using clickhouse syntax and tinybird templating syntax and starting always with SELECT or %\nSELECT]
-
-</pipe_content>
 
+def update_prompt(existing_resources: str) -> str:
+    return """
+You are a Tinybird expert. You will be given a prompt to update the existing Tinybird resources: datasources and/or pipes. 
+You will return the resources that need to be updated.
+<existing_resources>{existing_resources}</existing_resources>
+{datasource_instructions}
+{pipe_instructions}
+{sql_instructions}
+{datasource_example}
+{pipe_example}
+{copy_pipe_instructions}
+{materialized_pipe_instructions}
 Use the following format to generate the response and do not wrap it in any other text, including the <response> tag.
-
 <response>
     <resource>
         <type>[datasource or pipe]</type>
@@ -730,151 +763,11 @@ Use the following format to generate the response and do not wrap it in any othe
 
 """.format(
         existing_resources=existing_resources,
-        general_functions=general_functions,
-        general_functions_insensitive=general_functions_insensitive,
-        aggregate_functions=aggregate_functions,
+        datasource_instructions=datasource_instructions,
+        pipe_instructions=pipe_instructions,
+        sql_instructions=sql_instructions,
+        datasource_example=datasource_example,
+        pipe_example=pipe_example,
+        copy_pipe_instructions=copy_pipe_instructions,
+        materialized_pipe_instructions=materialized_pipe_instructions,
     )
-
-
-def mock_prompt(rows: int) -> str:
-    return f"""
-Given the schema for a Tinybird datasource, return a can you create a clickhouse sql query to generate some random data that matches that schema.
-
-Response format MUST be just a valid clickhouse sql query.
-
-<example>
-    <example_datasource_schema>
-SCHEMA >
-    experience_gained Int16 `json:$.experience_gained`,
-    level Int16 `json:$.level`,
-    monster_kills Int16 `json:$.monster_kills`,
-    player_id String `json:$.player_id`,
-    pvp_kills Int16 `json:$.pvp_kills`,
-    quest_completions Int16 `json:$.quest_completions`,
-    timestamp DateTime `json:$.timestamp`
-    </example_datasource_schema>
-    <example_output>
-
-SELECT
-    rand() % 1000 AS experience_gained, -- Random experience gained between 0 and 999
-    1 + rand() % 100 AS level,          -- Random level between 1 and 100
-    rand() % 500 AS monster_kills,      -- Random monster kills between 0 and 499
-    concat('player_', toString(rand() % 10000)) AS player_id, -- Random player IDs like "player_1234"
-    rand() % 50 AS pvp_kills,           -- Random PvP kills between 0 and 49
-    rand() % 200 AS quest_completions,  -- Random quest completions between 0 and 199
-    now() - rand() % 86400 AS timestamp -- Random timestamp within the last day
-FROM numbers({rows})
-    </example_output>
-</example>
-
-<instructions>
-- The query MUST return a random sample of data that matches the schema.
-- The query MUST return a valid clickhouse sql query.
-- The query MUST return a sample of EXACTLY {rows} rows.
-- The query MUST be valid for clickhouse and Tinybird.
-- FROM numbers({rows}) part is mandatory.
-- Do NOT include ```clickhouse or ```sql or any other wrapping text to the sql query.
-- Do NOT use any of these functions: elementAt
-- Do NOT add a semicolon at the end of the query
-- Do NOT add any FORMAT at the end of the query, because it will be added later by Tinybird.
-- General functions supported are: {general_functions}
-- Character insensitive functions supported are: {general_functions_insensitive}
-- Aggregate functions supported are: {aggregate_functions}
-- Do not use any function that is not present in the list of general functions, character insensitive functions and aggregate functions.
-- If the function is not present in the list, the sql query will fail, so avoid at all costs to use any function that is not present in the list.
-</instructions>
-
-<more_examples>
-# Examples with different schemas, like an array field or a nested JSON field:
-
-## Example schema with an array field:
-
-### Schema:
-
-SCHEMA >
-    `order_id` UInt64 `json:$.order_id`,
-    `customer_id` UInt64 `json:$.customer_id`,
-    `order_date` DateTime `json:$.order_date`,
-    `total_amount` Float64 `json:$.total_amount`,
-    `items` Array(String) `json:$.items[:]` // This is an array field 
-
-### Desired final output of the query:
-{{
-  "order_id": 123456,
-  "customer_id": 7890,
-  "order_date": "2024-11-30T10:30:00.000Z",
-  "total_amount": 150.0,
-  "items": ["item1", "item2", "item3"]
-}}
-
-### Example SQL output with an array field:
-
-SELECT
-  concat('ord_', toString(rand() % 10000)) AS order_id,
-  concat('cust_', toString(rand() % 10000)) AS customer_id,
-  now() - rand() % 86400 AS order_date,
-  rand() % 1000 AS total_amount,
-  arrayMap(x -> concat('item_', toString(x)), range(1, rand() % 5 + 1)) AS items
-FROM numbers(ROWS)
-
-## Example schema with a nested JSON field:
-
-### Schema:
-
-SCHEMA >
-    `request_id` String `json:$.request_id`,
-    `timestamp` DateTime `json:$.timestamp`,
-    `model` String `json:$.request.model`,
-    `temperature` Float32 `json:$.request.options.temperature`,
-    `max_tokens` UInt32 `json:$.request.options.max_tokens`,
-    `stream` UInt8 `json:$.request.options.stream`
-
-### Desired final output of the query:
-
-Note that the important part is generating the nested fields:
-json:$.request.options.max_tokens > this means that the max_tokens field is nested inside the options field inside the request field.
-
-{{
-  "request_id": "req_abc123",
-  "timestamp": "2024-11-30T10:30:00.000Z",
-  "request": {{
-    "model": "gpt-4",
-    "options": {{
-      "temperature": 0.7,
-      "max_tokens": 1000,
-      "stream": false
-    }}
-  }}
-}}
-
-### Example SQL output with nested fields:
-
-SELECT
-    request_id,
-    timestamp,
-    CAST(concat('{{
-        "model": "', model, '",
-        "options": {{
-            "temperature": ', temperature, ',
-            "max_tokens": ', max_tokens, ',
-            "stream": ', IF(stream = 1, 'true', 'false'), '
-        }}
-    }}'), 'JSON') AS request
-FROM
-(
-    SELECT
-        concat('req_', lower(hex(randomString(6)))) AS request_id,
-        (now() - toIntervalDay(rand() % 30)) + toIntervalSecond(rand() % 86400) AS timestamp,
-        ['gpt-4', 'gpt-3.5-turbo', 'gpt-4-turbo'][(rand() % 3) + 1] AS model,
-        round(rand() / 10, 2) AS temperature,
-        500 + (rand() % 2500) AS max_tokens,
-        rand() % 2 AS stream
-    FROM numbers(ROWS)
-)
-</more_examples>
-
-Follow the instructions and generate the following response with no additional text in the following format:
-<response>
-    <sql>[raw sql query here]</sql>
-</response>
-"""

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.dev29'
-__revision__ = '1ff2823'
+__version__ = '0.0.1.dev30'
+__revision__ = 'f7bc1dc'