tinybird 0.0.1.dev43__py3-none-any.whl → 0.0.1.dev46__py3-none-any.whl

tinybird/tb/modules/create.py

@@ -7,7 +7,7 @@ from typing import Optional
 import click
 
 from tinybird.client import TinyB
-from tinybird.prompts import create_prompt, cursorrules_prompt, mock_prompt
+from tinybird.prompts import create_prompt, mock_prompt, rules_prompt
 from tinybird.tb.modules.cicd import init_cicd
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import _generate_datafile, check_user_token_with_client, coro, generate_datafile
@@ -18,6 +18,7 @@ from tinybird.tb.modules.feedback_manager import FeedbackManager
 from tinybird.tb.modules.llm import LLM
 from tinybird.tb.modules.llm_utils import extract_xml, parse_xml
 from tinybird.tb.modules.local_common import get_tinybird_local_client
+from tinybird.tb.modules.project import Project
 
 
 @cli.command()
@@ -35,28 +36,33 @@ from tinybird.tb.modules.local_common import get_tinybird_local_client
 )
 @click.option(
     "--folder",
-    default=".",
+    default="",
     type=click.Path(exists=False, file_okay=False),
     help="Folder where datafiles will be placed",
 )
 @click.option("--rows", type=int, default=10, help="Number of events to send")
 @click.option("--cursor", default=False, is_flag=True, help="Create .cursorrules file with Tinybird rules")
+@click.option("--source", type=str, default="tb", help="Source of the command")
+@click.pass_context
 @coro
 async def create(
+    ctx: click.Context,
     data: Optional[str],
     prompt: Optional[str],
     folder: Optional[str],
     rows: int,
     cursor: bool,
+    source: str,
 ) -> None:
     """Initialize a new project."""
+    project: Project = ctx.ensure_object(dict)["project"]
     folder = folder or getcwd()
     folder_path = Path(folder)
     if not folder_path.exists():
         folder_path.mkdir()
 
     try:
-        config = CLIConfig.get_project_config(folder)
+        config = CLIConfig.get_project_config(str(project.path))
         tb_client = config.get_client()
         user_token: Optional[str] = None
         if prompt:
@@ -79,9 +85,11 @@ async def create(
             create_project_structure(folder)
             click.echo(FeedbackManager.success(message="✓ Scaffolding completed!\n"))
 
-        click.echo(FeedbackManager.highlight(message="\n» Creating resources..."))
-        datasources_created = await create_resources(local_client, tb_client, user_token, data, prompt, folder)
-        click.echo(FeedbackManager.success(message="✓ Done!\n"))
+        result = ""
+        if data or prompt:
+            click.echo(FeedbackManager.highlight(message="\n» Creating resources..."))
+            result = await create_resources(local_client, tb_client, user_token, data, prompt, folder)
+            click.echo(FeedbackManager.success(message="✓ Done!\n"))
 
         if not already_has_cicd(folder):
             click.echo(FeedbackManager.highlight(message="\n» Creating CI/CD files for GitHub and GitLab..."))
@@ -89,7 +97,7 @@ async def create(
             await init_cicd(data_project_dir=os.path.relpath(folder))
             click.echo(FeedbackManager.success(message="✓ Done!\n"))
 
-        if validate_fixtures(folder) and datasources_created:
+        if should_generate_fixtures(result):
             click.echo(FeedbackManager.highlight(message="\n» Generating fixtures..."))
 
             if data:
@@ -110,12 +118,12 @@ async def create(
                     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>"
+                        prompt = f"<datasource_schema>{datasource_content}</datasource_schema>"
                         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")
-                        data = result.get("data", [])
+                        query_result = await local_client.query(f"{sql} FORMAT JSON")
+                        data = query_result.get("data", [])
                         fixture_name = build_fixture_name(
                             datasource_path.absolute().as_posix(), datasource_name, datasource_content
                         )
@@ -123,9 +131,9 @@ async def create(
                             persist_fixture(fixture_name, data, folder)
                             click.echo(FeedbackManager.info(message=f"✓ /fixtures/{datasource_name}"))
 
-        if cursor and not already_has_cursorrules(folder):
+        if cursor:
             click.echo(FeedbackManager.highlight(message="\n» Creating .cursorrules..."))
-            create_cursorrules(folder)
+            create_rules(folder, source, "cursor")
             click.echo(FeedbackManager.success(message="✓ Done!\n"))
 
     except Exception as e:
@@ -139,9 +147,10 @@ def validate_project_structure(folder: str) -> bool:
     return all((Path(folder) / path).exists() for path in PROJECT_PATHS)
 
 
-def validate_fixtures(folder: str) -> bool:
-    datasource_files = [f for f in os.listdir(Path(folder) / "datasources") if f.endswith(".datasource")]
-    return len(datasource_files) > 0
+def should_generate_fixtures(result: str) -> bool:
+    if not result:
+        return False
+    return "<type>datasource</type>" in result
 
 
 def already_has_cicd(folder: str) -> bool:
@@ -168,12 +177,12 @@ async def create_resources(
     prompt: Optional[str],
     folder: str,
 ):
-    force = True
+    result = ""
     folder_path = Path(folder)
     if data:
         path = folder_path / data
         format = path.suffix.lstrip(".")
-        await _generate_datafile(str(path), local_client, format=format, force=force)
+        await _generate_datafile(str(path), local_client, format=format, force=True)
         name = data.split(".")[0]
         generate_pipe_file(
             f"{name}_endpoint",
@@ -185,7 +194,10 @@ TYPE ENDPOINT
             """,
             folder,
         )
-        return True
+        result = (
+            f"<response><resource><type>datasource</type><name>{name}</name><content></content></resource></response>"
+        )
+
     elif prompt and user_token:
         datasource_paths = [
             Path(folder) / "datasources" / f
@@ -212,41 +224,74 @@ TYPE ENDPOINT
             ]
         )
         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 = []
-        pipes = []
-        for resource_xml in resources:
-            resource_type = extract_xml(resource_xml, "type")
-            name = extract_xml(resource_xml, "name")
-            content = extract_xml(resource_xml, "content")
-            resource = {
-                "name": name,
-                "content": content,
-            }
-            if resource_type.lower() == "datasource":
-                datasources.append(resource)
-            elif resource_type.lower() == "pipe":
-                pipes.append(resource)
-
-        for ds in datasources:
-            content = ds["content"].replace("```", "")
-            filename = f"{ds['name']}.datasource"
-            generate_datafile(
-                content,
-                filename=filename,
-                data=None,
-                _format="ndjson",
-                force=force,
-                folder=folder,
-            )
-
-        for pipe in pipes:
-            content = pipe["content"].replace("```", "")
-            generate_pipe_file(pipe["name"], content, folder)
-
-        return len(datasources) > 0
+        result = ""
+        iterations = 0
+        history = ""
+        generated_paths: list[Path] = []
+
+        while iterations < 10:
+            feedback = ""
+            if iterations > 0:
+                feedback = click.prompt("\nFollow-up instructions or continue", default="continue")
+            if iterations > 0 and (not feedback or feedback in ("continue", "ok", "exit", "quit", "q")):
+                break
+            else:
+                if iterations > 0:
+                    click.echo(FeedbackManager.highlight(message="\n» Creating resources..."))
+                    for path in generated_paths:
+                        path.unlink()
+                    generated_paths = []
+
+                save_context(prompt, feedback)
+                result = llm.ask(system_prompt=create_prompt(resources_xml, feedback, history), prompt=prompt)
+                result = extract_xml(result, "response")
+                history = (
+                    history
+                    + f"""
+                <result_iteration_{iterations}>
+                    {result}
+                </result_iteration_{iterations}>
+                """
+                )
+                resources = parse_xml(result, "resource")
+                datasources = []
+                pipes = []
+                for resource_xml in resources:
+                    resource_type = extract_xml(resource_xml, "type")
+                    name = extract_xml(resource_xml, "name")
+                    content = extract_xml(resource_xml, "content")
+                    resource = {
+                        "name": name,
+                        "content": content,
+                    }
+                    if resource_type.lower() == "datasource":
+                        datasources.append(resource)
+                    elif resource_type.lower() == "pipe":
+                        pipes.append(resource)
+
+                for ds in datasources:
+                    content = ds["content"].replace("```", "")
+                    filename = f"{ds['name']}.datasource"
+                    datasource_path = generate_datafile(
+                        content,
+                        filename=filename,
+                        data=None,
+                        _format="ndjson",
+                        force=True,
+                        folder=folder,
+                    )
+                    generated_paths.append(datasource_path)
+                for pipe in pipes:
+                    content = pipe["content"].replace("```", "")
+                    pipe_path = generate_pipe_file(pipe["name"], content, folder)
+                    generated_paths.append(pipe_path)
+
+                iterations += 1
+
+        if iterations == 10:
+            click.echo(FeedbackManager.info(message="Too many iterations. Change the prompt and try again."))
+
+        return result
 
 
 def init_git(folder: str):
@@ -266,7 +311,7 @@ def init_git(folder: str):
         raise CLIException(f"Error initializing Git: {e}")
 
 
-def generate_pipe_file(name: str, content: str, folder: str):
+def generate_pipe_file(name: str, content: str, folder: str) -> Path:
     def is_copy(content: str) -> bool:
         return re.search(r"TYPE copy", content, re.IGNORECASE) is not None
 
@@ -292,12 +337,42 @@ def generate_pipe_file(name: str, content: str, folder: str):
     with open(f"{f}", "w") as file:
         file.write(content)
     click.echo(FeedbackManager.info_file_created(file=f.relative_to(folder)))
+    return f.relative_to(folder)
+
+
+def create_rules(folder: str, source: str, agent: str):
+    if agent == "cursor":
+        extension = ".cursorrules"
+    elif agent == "windsurf":
+        extension = ".windsurfrules"
+    else:
+        extension = ".txt"
+    rules_file = Path(folder) / extension
+    rules_file.write_text(rules_prompt(source))
+
+
+def get_context_file() -> Path:
+    context_file = Path(os.path.expanduser("~/.tb_create_context"))
+    if not context_file.exists():
+        context_file.touch()
+    return context_file
+
+
+def get_context() -> str:
+    context_file = get_context_file()
+    return context_file.read_text()
 
 
-def already_has_cursorrules(folder: str) -> bool:
-    return (Path(folder) / ".cursorrules").exists()
+def save_context(prompt: str, feedback: str):
+    context_file = get_context_file()
+    context_file.write_text(f"- {prompt}\n{feedback}")
 
 
-def create_cursorrules(folder: str):
-    cursorrules_file = Path(folder) / ".cursorrules"
-    cursorrules_file.write_text(cursorrules_prompt)
+@cli.command("rules")
+@click.option("--agent", type=str, default="cursor", help="Agent to use for rules")
+@click.option("--source", type=str, default="tb", help="Source of the command")
+@click.pass_context
+def rules(ctx: click.Context, agent: str, source: str):
+    """Create agent rules for the project."""
+    project: Project = ctx.ensure_object(dict)["project"]
+    create_rules(str(project.path), source, agent)

tinybird/tb/modules/datafile/build.py

@@ -15,14 +15,12 @@ from tinybird.client import TinyB
 from tinybird.sql import parse_table_structure, schema_to_sql_columns
 from tinybird.sql_template import get_used_tables_in_template, render_sql_template
 from tinybird.tb.modules.common import get_ca_pem_content
-from tinybird.tb.modules.datafile.build_common import update_tags_in_resource
-from tinybird.tb.modules.datafile.build_datasource import is_datasource, new_ds
+from tinybird.tb.modules.datafile.build_datasource import is_datasource
 from tinybird.tb.modules.datafile.build_pipe import (
     get_target_materialized_data_source_name,
     is_endpoint,
     is_endpoint_with_no_dependencies,
     is_materialized,
-    new_pipe,
 )
 from tinybird.tb.modules.datafile.common import (
     DEFAULT_CRON_PERIOD,
@@ -44,95 +42,32 @@ 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_tinybird_local_config
+from tinybird.tb.modules.local_common import get_tinybird_local_client
+from tinybird.tb.modules.project import Project
 
 
 async def folder_build(
-    tb_client: TinyB,
+    project: Project,
     filenames: Optional[List[str]] = None,
-    folder: str = ".",
-    ignore_sql_errors: bool = False,
     is_internal: bool = False,
     is_vendor: bool = False,
     current_ws: Optional[Dict[str, Any]] = None,
     local_ws: Optional[Dict[str, Any]] = None,
     watch: bool = False,
 ):
-    config = await get_tinybird_local_config(folder)
     build = True
     dry_run = False
     force = True
     only_changes = True
     debug = False
-    check = True
-    populate = False
-    populate_subset = None
-    populate_condition = None
-    tests_to_run = 0
-    override_datasource = False
-    skip_confirmation = True
-    wait = False
-    unlink_on_populate_error = False
-    only_response_times = False
     run_tests = False
     verbose = False
-    as_standard = False
     raise_on_exists = False
     fork_downstream = True
     fork = False
     release_created = False
-    tests_relative_change = 0.01
-    tests_sample_by_params = 0
-    tests_filter_by = None
-    tests_failfast = False
-    tests_ignore_order = False
-    tests_validate_processed_bytes = False
-    tests_check_requests_from_branch = False
-    vendor_paths = []
-
-    vendor_path = Path("vendor")
-    user_token = config.get_user_token()
-    user_client = deepcopy(tb_client)
-
-    if user_token:
-        user_client.token = user_token
-
-    vendor_workspaces = []
-
-    if vendor_path.exists() and not is_vendor and not watch:
-        user_workspaces = await user_client.user_workspaces()
-        for x in vendor_path.iterdir():
-            if x.is_dir() and x.name:
-                if user_token:
-                    try:
-                        ws_to_delete = next((ws for ws in user_workspaces["workspaces"] if ws["name"] == x.name), None)
-                        if ws_to_delete:
-                            await user_client.delete_workspace(ws_to_delete["id"], hard_delete_confirmation=x.name)
-                    except Exception:
-                        pass
-                    vendor_ws = await user_client.create_workspace(x.name, template=None)
-                    vendor_workspaces.append(vendor_ws)
-                vendor_paths.append((x.name, str(x)))
-
-    workspaces: List[Dict[str, Any]] = (await user_client.user_workspaces()).get("workspaces", [])
-
-    if not is_vendor:
-        local_workspace = await tb_client.workspace_info()
-        local_ws_id = local_workspace.get("id")
-        local_ws = next((ws for ws in workspaces if ws["id"] == local_ws_id), {})
-
-    current_ws = current_ws or local_ws
-
-    for vendor_ws in [ws for ws in workspaces if ws["name"] in [ws["name"] for ws in vendor_workspaces]]:
-        ws_client = deepcopy(tb_client)
-        ws_client.token = vendor_ws["token"]
-        shared_ws_path = Path(folder) / "vendor" / vendor_ws["name"]
-
-        if shared_ws_path.exists() and not is_vendor and not watch:
-            await folder_build(
-                ws_client, folder=shared_ws_path.as_posix(), is_vendor=True, current_ws=vendor_ws, local_ws=local_ws
-            )
-
+    folder = str(project.path)
+    tb_client = await get_tinybird_local_client(folder)
     datasources: List[Dict[str, Any]] = await tb_client.datasources()
     pipes: List[Dict[str, Any]] = await tb_client.pipes(dependencies=True)
 
@@ -150,7 +85,7 @@ async def folder_build(
         dir_path=folder,
         process_dependencies=True,
         skip_connectors=True,
-        vendor_paths=vendor_paths,
+        vendor_paths=[],
         current_ws=current_ws,
         only_changes=only_changes,
         fork_downstream=fork_downstream,
@@ -191,63 +126,14 @@ async def folder_build(
             resource = to_run[name]["resource"]
             if not dry_run:
                 if should_push_file(name, remote_resource_names, force, run_tests):
-                    click.echo(FeedbackManager.info_processing_new_resource(name=name, version=""))
-                    try:
-                        await exec_file(
-                            to_run[name],
-                            tb_client,
-                            force,
-                            check,
-                            debug and verbose,
-                            populate,
-                            populate_subset,
-                            populate_condition,
-                            unlink_on_populate_error,
-                            wait,
-                            user_token,
-                            override_datasource,
-                            ignore_sql_errors,
-                            skip_confirmation,
-                            only_response_times,
-                            run_tests,
-                            as_standard,
-                            tests_to_run,
-                            tests_relative_change,
-                            tests_sample_by_params,
-                            tests_filter_by,
-                            tests_failfast,
-                            tests_ignore_order,
-                            tests_validate_processed_bytes,
-                            tests_check_requests_from_branch,
-                            current_ws,
-                            local_ws,
-                            fork_downstream,
-                            fork,
-                            build,
-                            is_vendor,
-                        )
-                        if not run_tests:
-                            click.echo(
-                                FeedbackManager.success_create(
-                                    name=(
-                                        name
-                                        if to_run[name]["version"] is None
-                                        else f'{name}__v{to_run[name]["version"]}'
-                                    )
-                                )
-                            )
-                    except Exception as e:
-                        filename = to_run[name]["filename"]
-                        exception = FeedbackManager.error_push_file_exception(
-                            filename=filename,
-                            error=e,
-                        )
-                        raise click.ClickException(exception)
+                    filename = to_run[name]["filename"]
+                    filename = filename.replace(f"{folder}/", "")
+                    click.echo(FeedbackManager.info(message=f"✓ {filename}"))
                 else:
                     if raise_on_exists:
                         raise AlreadyExistsException(
                             FeedbackManager.warning_name_already_exists(
-                                name=name if to_run[name]["version"] is None else f'{name}__v{to_run[name]["version"]}'
+                                name=name if to_run[name]["version"] is None else f"{name}__v{to_run[name]['version']}"
                             )
                         )
                     else:
@@ -262,7 +148,7 @@ async def folder_build(
                                     name=(
                                         name
                                         if to_run[name]["version"] is None
-                                        else f'{name}__v{to_run[name]["version"]}'
+                                        else f"{name}__v{to_run[name]['version']}"
                                     )
                                 )
                             )
@@ -304,19 +190,6 @@ async def folder_build(
         # We need to deploy the datasources from left to right as some datasources might have MV that depend on the column types of previous datasources. Ex: `test_change_column_type_landing_datasource` test
         groups = [group for group in toposort(dependencies_graph_fork_downstream)]
 
-        for group in groups:
-            for name in group:
-                is_vendor = resources_to_run_fork_downstream.get(name, {}).get("filename", "").startswith("vendor/")
-                if not is_vendor:
-                    try:
-                        await tb_client.datasource_delete(name, force=True)
-                    except Exception:
-                        pass
-                    try:
-                        await tb_client.pipe_delete(name)
-                    except Exception:
-                        pass
-
         groups.reverse()
         for group in groups:
             for name in group:
@@ -433,88 +306,6 @@ async def name_matches_existing_resource(resource: str, name: str, tb_client: Ti
     return False
 
 
-async def exec_file(
-    r: Dict[str, Any],
-    tb_client: TinyB,
-    force: bool,
-    check: bool,
-    debug: bool,
-    populate: bool,
-    populate_subset,
-    populate_condition,
-    unlink_on_populate_error,
-    wait_populate,
-    user_token: Optional[str],
-    override_datasource: bool = False,
-    ignore_sql_errors: bool = False,
-    skip_confirmation: bool = False,
-    only_response_times: bool = False,
-    run_tests=False,
-    as_standard=False,
-    tests_to_run: int = 0,
-    tests_relative_change: float = 0.01,
-    tests_to_sample_by_params: int = 0,
-    tests_filter_by: Optional[List[str]] = None,
-    tests_failfast: bool = False,
-    tests_ignore_order: bool = False,
-    tests_validate_processed_bytes: bool = False,
-    tests_check_requests_from_branch: bool = False,
-    current_ws: Optional[Dict[str, Any]] = None,
-    local_ws: Optional[Dict[str, Any]] = None,
-    fork_downstream: Optional[bool] = False,
-    fork: Optional[bool] = False,
-    build: Optional[bool] = False,
-    is_vendor: Optional[bool] = False,
-):
-    if debug:
-        click.echo(FeedbackManager.debug_running_file(file=pp.pformat(r)))
-    if r["resource"] == "pipes":
-        await new_pipe(
-            r,
-            tb_client,
-            force,
-            check,
-            populate,
-            populate_subset,
-            populate_condition,
-            unlink_on_populate_error,
-            wait_populate,
-            ignore_sql_errors=ignore_sql_errors,
-            only_response_times=only_response_times,
-            run_tests=run_tests,
-            as_standard=as_standard,
-            tests_to_run=tests_to_run,
-            tests_relative_change=tests_relative_change,
-            tests_to_sample_by_params=tests_to_sample_by_params,
-            tests_filter_by=tests_filter_by,
-            tests_failfast=tests_failfast,
-            tests_ignore_order=tests_ignore_order,
-            tests_validate_processed_bytes=tests_validate_processed_bytes,
-            override_datasource=override_datasource,
-            tests_check_requests_from_branch=tests_check_requests_from_branch,
-            fork_downstream=fork_downstream,
-            fork=fork,
-        )
-        await update_tags_in_resource(r, "pipe", tb_client)
-    elif r["resource"] == "datasources":
-        await new_ds(
-            r,
-            tb_client,
-            user_token,
-            force,
-            skip_confirmation=skip_confirmation,
-            current_ws=current_ws,
-            local_ws=local_ws,
-            fork_downstream=fork_downstream,
-            fork=fork,
-            build=build,
-            is_vendor=is_vendor,
-        )
-        await update_tags_in_resource(r, "datasource", tb_client)
-    else:
-        raise click.ClickException(FeedbackManager.error_unknown_resource(resource=r["resource"]))
-
-
 def get_remote_resource_name_without_version(remote_resource_name: str) -> str:
     """
     >>> get_remote_resource_name_without_version("r__datasource")

tinybird/tb/modules/datafile/common.py

@@ -526,7 +526,7 @@ def format_parse_error(
         message += f" found at position {adjusted_position - len(keyword)}"
     else:
         message += (
-            f" found {repr(table_structure[i]) if len(table_structure)>i else 'EOF'} at position {adjusted_position}"
+            f" found {repr(table_structure[i]) if len(table_structure) > i else 'EOF'} at position {adjusted_position}"
         )
     return message
 

tinybird/tb/modules/datafile/format_datasource.py

@@ -148,7 +148,7 @@ async def format_engine(
     else:
         if node.get("engine", None):
             empty = '""'
-            file_parts.append(f'ENGINE {node["engine"]["type"]}' if node.get("engine", {}).get("type") else empty)
+            file_parts.append(f"ENGINE {node['engine']['type']}" if node.get("engine", {}).get("type") else empty)
             file_parts.append(DATAFILE_NEW_LINE)
             for arg in sorted(node["engine"].get("args", [])):
                 elem = ", ".join([x.strip() for x in arg[1].split(",")])

tinybird/tb/modules/datafile/format_pipe.py

@@ -42,7 +42,7 @@ async def format_node_type(file_parts: List[str], node: Dict[str, Any]) -> List[
     if node_type == PipeNodeTypes.MATERIALIZED:
         file_parts.append(node_type_upper)
         file_parts.append(DATAFILE_NEW_LINE)
-        file_parts.append(f'DATASOURCE {node["datasource"]}')
+        file_parts.append(f"DATASOURCE {node['datasource']}")
         file_parts.append(DATAFILE_NEW_LINE)
         await format_engine(file_parts, node)
 
@@ -50,10 +50,10 @@ async def format_node_type(file_parts: List[str], node: Dict[str, Any]) -> List[
     if node_type == PipeNodeTypes.COPY:
         file_parts.append(node_type_upper)
         file_parts.append(DATAFILE_NEW_LINE)
-        file_parts.append(f'TARGET_DATASOURCE {node["target_datasource"]}')
+        file_parts.append(f"TARGET_DATASOURCE {node['target_datasource']}")
         if node.get("mode"):
             file_parts.append(DATAFILE_NEW_LINE)
-            file_parts.append(f'COPY_MODE {node.get("mode")}')
+            file_parts.append(f"COPY_MODE {node.get('mode')}")
 
         if node.get(CopyParameters.COPY_SCHEDULE):
             is_ondemand = node[CopyParameters.COPY_SCHEDULE].lower() == ON_DEMAND
@@ -112,7 +112,7 @@ async def format_node(
     if item and not unroll_includes:
         return
 
-    file_parts.append(f'NODE {node["name"].strip()}')
+    file_parts.append(f"NODE {node['name'].strip()}")
     file_parts.append(DATAFILE_NEW_LINE)
 
     from collections import namedtuple