tinybird 0.0.1.dev291__py3-none-any.whl → 1.0.5__py3-none-any.whl

tinybird/tb/modules/mock_common.py

@@ -1,12 +1,5 @@
-from typing import Any, Dict, List
-
-from tinybird.prompts import mock_prompt
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.common import push_data
-from tinybird.tb.modules.config import CLIConfig
-from tinybird.tb.modules.datafile.fixture import persist_fixture_sql
-from tinybird.tb.modules.llm import LLM
-from tinybird.tb.modules.llm_utils import extract_xml
 
 
 def append_mock_data(
@@ -22,50 +15,3 @@ def append_mock_data(
         concurrency=1,
         silent=True,
     )
-
-
-def create_mock_data(
-    datasource_name: str,
-    datasource_content: str,
-    rows: int,
-    prompt: str,
-    config: CLIConfig,
-    ctx_config: Dict[str, Any],
-    user_token: str,
-    tb_client: TinyB,
-    format_: str,
-    folder: str,
-) -> List[Dict[str, Any]]:
-    user_client = config.get_client(token=ctx_config.get("token"), host=ctx_config.get("host"))
-    llm = LLM(user_token=user_token, host=user_client.host)
-    prompt = f"<datasource_schema>{datasource_content}</datasource_schema>\n<user_input>{prompt}</user_input>"
-    sql = ""
-    attempts = 0
-    data = []
-    error = ""
-    sql_path = None
-    while True:
-        try:
-            response = llm.ask(system_prompt=mock_prompt(rows, error), prompt=prompt, feature="tb_mock")
-            sql = extract_xml(response, "sql")
-            sql_path = persist_fixture_sql(datasource_name, sql, folder)
-            sql_format = "JSON" if format_ == "ndjson" else "CSV"
-            result = tb_client.query(f"SELECT * FROM ({sql}) LIMIT {rows} FORMAT {sql_format}")
-            if sql_format == "JSON":
-                data = result.get("data", [])[:rows]
-                error_response = result.get("error", None)
-                if error_response:
-                    raise Exception(error_response)
-            else:
-                data = result
-            break
-        except Exception as e:
-            error = str(e)
-            attempts += 1
-            if attempts > 5:
-                raise Exception(
-                    f"Failed to generate a valid solution. Check {str(sql_path or '.sql path')} and try again."
-                )
-            else:
-                continue
-    return data

tinybird/tb/modules/open.py

@@ -7,7 +7,6 @@ from tinybird.tb.config import get_display_cloud_host
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.exceptions import CLIException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
-from tinybird.tb.modules.local_common import get_build_workspace_name
 
 
 @cli.command()
@@ -21,12 +20,12 @@ def open(ctx: Context, workspace: str):
 
     config = ctx.ensure_object(dict)["config"]
     client = ctx.ensure_object(dict)["client"]
-    env = ctx.ensure_object(dict)["env"]
+    branch = ctx.ensure_object(dict)["branch"]
 
     url_host = get_display_cloud_host(client.host)
 
     if not workspace:
-        workspace = get_build_workspace_name(config.get("path")) if env == "build" else config.get("name")
+        workspace = config.get("name")
 
     if not workspace:
         raise CLIException(
@@ -35,7 +34,13 @@ def open(ctx: Context, workspace: str):
             )
         )
 
-    click.echo(FeedbackManager.highlight(message=f"» Opening workspace {workspace} in the browser"))
+    if branch:
+        click.echo(
+            FeedbackManager.highlight(message=f"» Opening branch {branch} of workspace {workspace} in the browser")
+        )
+        auth_url = f"{url_host}/{workspace}~{branch}"
+    else:
+        click.echo(FeedbackManager.highlight(message=f"» Opening workspace {workspace} in the browser"))
+        auth_url = f"{url_host}/{workspace}"
 
-    auth_url = f"{url_host}/{workspace}"
     webbrowser.open(auth_url)

tinybird/tb/modules/project.py

@@ -130,7 +130,7 @@ class Project:
 
     @property
     def connections(self) -> List[str]:
-        return sorted([Path(f).stem for f in self.get_connection_files()])
+        return sorted([Path(f).stem for f in self._get_connection_files()])
 
     def get_datasource_files(self) -> List[str]:
         return self.get_files("datasource")
@@ -138,17 +138,26 @@ class Project:
     def get_pipe_files(self) -> List[str]:
         return self.get_files("pipe")
 
-    def get_connection_files(self) -> List[str]:
+    def _get_connection_files(self) -> List[str]:
         return self.get_files("connection")
 
+    def get_connection_files(self, connection_type: Optional[str] = None) -> List[str]:
+        if connection_type == "kafka":
+            return self.get_kafka_connection_files()
+        if connection_type == "s3":
+            return self.get_s3_connection_files()
+        if connection_type == "gcs":
+            return self.get_gcs_connection_files()
+        return self._get_connection_files()
+
     def get_kafka_connection_files(self) -> List[str]:
-        return [f for f in self.get_connection_files() if self.is_kafka_connection(Path(f).read_text())]
+        return [f for f in self._get_connection_files() if self.is_kafka_connection(Path(f).read_text())]
 
     def get_s3_connection_files(self) -> List[str]:
-        return [f for f in self.get_connection_files() if self.is_s3_connection(Path(f).read_text())]
+        return [f for f in self._get_connection_files() if self.is_s3_connection(Path(f).read_text())]
 
     def get_gcs_connection_files(self) -> List[str]:
-        return [f for f in self.get_connection_files() if self.is_gcs_connection(Path(f).read_text())]
+        return [f for f in self._get_connection_files() if self.is_gcs_connection(Path(f).read_text())]
 
     def get_pipe_datafile(self, filename: str) -> Optional[Datafile]:
         try:

tinybird/tb/modules/shell.py

@@ -1,7 +1,7 @@
 import os
 import subprocess
 import sys
-from typing import List
+from typing import List, Optional
 
 import click
 import humanfriendly
@@ -192,11 +192,14 @@ def _(event):
 
 
 class Shell:
-    def __init__(self, project: Project, tb_client: TinyB, playground: bool = False):
+    def __init__(self, project: Project, tb_client: TinyB, playground=False, branch: Optional[str] = None):
         self.history = self.get_history()
         self.project = project
         self.tb_client = tb_client
-        self.env = "cloud" if playground else "local"
+        if playground:
+            self.env = "--cloud"
+        else:
+            self.env = f"--branch={branch}" if branch else "--local"
         self.prompt_message = "\ntb » "
         self.session: PromptSession = PromptSession(
             completer=DynamicCompleter(project),
@@ -245,6 +248,8 @@ class Shell:
             self.handle_auth()
         elif cmd == "workspace":
             self.handle_workspace()
+        elif cmd == "branch":
+            self.handle_branch()
         elif cmd == "deploy":
             self.handle_deploy()
         elif cmd == "mock":
@@ -264,13 +269,16 @@ class Shell:
     def handle_workspace(self):
         click.echo(FeedbackManager.error(message="'tb workspace' is not available in the dev shell"))
 
+    def handle_branch(self):
+        click.echo(FeedbackManager.error(message="'tb branch' is not available in the dev shell"))
+
     def handle_deploy(self):
         click.echo(FeedbackManager.error(message="'tb deploy' is not available in the dev shell"))
 
     def handle_mock(self, arg):
         if "mock" in arg.strip().lower():
             arg = arg.replace("mock", "")
-        subprocess.run(f"tb --{self.env} mock {arg}", shell=True, text=True)
+        subprocess.run(f"tb {self.env} mock {arg}", shell=True, text=True)
 
     def handle_tb(self, argline):
         click.echo("")
@@ -287,14 +295,14 @@ class Shell:
             need_skip = ("mock", "test create", "create")
             if any(arg.startswith(cmd) for cmd in need_skip):
                 argline = f"{argline}"
-            subprocess.run(f"tb --{self.env} {argline}", shell=True, text=True)
+            subprocess.run(f"tb {self.env} {argline}", shell=True, text=True)
 
     def default(self, argline):
         click.echo("")
         arg = argline.strip().lower()
         if not arg:
             return
-        if arg.startswith("with") or arg.startswith("select"):
+        if arg.startswith(("with", "select")):
             self.run_sql(argline)
         elif len(arg.split()) == 1 and arg in self.project.pipes + self.project.datasources:
             self.run_sql(f"select * from {argline}")
@@ -302,7 +310,7 @@ class Shell:
             need_skip = ("mock", "test create", "create")
             if any(arg.startswith(cmd) for cmd in need_skip):
                 argline = f"{argline}"
-            subprocess.run(f"tb --{self.env} {argline}", shell=True, text=True)
+            subprocess.run(f"tb {self.env} {argline}", shell=True, text=True)
 
     def run_sql(self, query, rows_limit=20):
         try:

tinybird/tb/modules/sink.py

@@ -11,6 +11,7 @@ from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.common import echo_safe_humanfriendly_tables_format_smart_table, wait_job
 from tinybird.tb.modules.exceptions import CLIPipeException
 from tinybird.tb.modules.feedback_manager import FeedbackManager
+from tinybird.tb.modules.job_common import echo_job_url
 
 
 @cli.group()
@@ -84,12 +85,13 @@ def sink_run(ctx: click.Context, pipe_name_or_id: str, wait: bool, mode: str, pa
     params = dict(key_value.split("=") for key_value in param) if param else {}
     click.echo(FeedbackManager.highlight(message=f"\n» Running sink '{pipe_name_or_id}'"))
     client: TinyB = ctx.ensure_object(dict)["client"]
+    config = ctx.ensure_object(dict)["config"]
 
     try:
         response = client.pipe_run(pipe_name_or_id, "sink", params, mode)
         job_id = response["job"]["id"]
         job_url = response["job"]["job_url"]
-        click.echo(FeedbackManager.gray(message="Job URL: ") + FeedbackManager.info(message=f"{job_url}"))
+        echo_job_url(client.token, client.host, config.get("name") or "", job_url)
         click.echo(FeedbackManager.success(message="✓ Sink job created"))
 
         if wait:

tinybird/tb/modules/telemetry.py

@@ -42,8 +42,11 @@ def get_ci_product_name() -> Optional[str]:
 
 
 def is_ci_environment() -> bool:
-    ci_product: Optional[str] = get_ci_product_name()
-    return ci_product is not None
+    try:
+        ci_product: Optional[str] = get_ci_product_name()
+        return ci_product is not None
+    except Exception:
+        return False
 
 
 def silence_errors(f: Callable) -> Callable:
@@ -86,7 +89,7 @@ class TelemetryHelper:
         tb_host: Optional[str] = None,
         max_enqueued_events: int = 5,
     ) -> None:
-        self.tb_host = tb_host or os.getenv("TB_CLI_TELEMETRY_HOST", "https://api.tinybird.co")
+        self.tb_host = tb_host or os.getenv("TB_CLI_TELEMETRY_HOST", "https://api.europe-west2.gcp.tinybird.co")
         self.max_enqueued_events: int = max_enqueued_events
 
         self.enabled: bool = True
@@ -133,6 +136,7 @@ class TelemetryHelper:
         event_dict["event"] = event
         event_dict["event_data"] = json.dumps(event_data)
         event_dict["timestamp"] = datetime.utcnow().isoformat()
+        event_dict["cli"] = "forward"
 
         self.events.append(event_dict)
         if len(self.events) >= self.max_enqueued_events:
@@ -284,6 +288,10 @@ def add_telemetry_sysinfo_event() -> None:
 
     cli_args = sys.argv[1:] if len(sys.argv) > 1 else []
 
+    # we don't track login commands because we track them explicitly
+    if "login" in cli_args:
+        return
+
     is_secret_command = "secret" in cli_args
     if is_secret_command:
         need_to_obfuscate = "set" in cli_args

tinybird/tb/modules/test.py

@@ -3,14 +3,15 @@
 # - If it makes sense and only when strictly necessary, you can create utility functions in this file.
 # - But please, **do not** interleave utility functions and command definitions.
 
-from typing import Tuple
+from typing import Any, Tuple
 
 import click
 
 from tinybird.tb.client import TinyB
+from tinybird.tb.modules.agent import run_agent
 from tinybird.tb.modules.cli import cli
 from tinybird.tb.modules.project import Project
-from tinybird.tb.modules.test_common import create_test, run_tests, update_test
+from tinybird.tb.modules.test_common import run_tests, update_test
 
 
 @cli.group()
@@ -24,17 +25,18 @@ def test(ctx: click.Context) -> None:
     help="Create a test for an existing pipe",
 )
 @click.argument("name_or_filename", type=str)
-@click.option(
-    "--prompt", type=str, default="Create a test for the selected pipe", help="Prompt to be used to create the test"
-)
+@click.option("--prompt", type=str, default="", help="Prompt to be used to create the test")
 @click.pass_context
 def test_create(ctx: click.Context, name_or_filename: str, prompt: str) -> None:
     """
     Create a test for an existing pipe
     """
     project: Project = ctx.ensure_object(dict)["project"]
-    client: TinyB = ctx.ensure_object(dict)["client"]
-    create_test(name_or_filename, prompt, project, client)
+    config: dict[str, Any] = ctx.ensure_object(dict)["config"]
+    prompt = (
+        f"""Create tests for the following pipe: {name_or_filename}. Extra context: {prompt or "No extra context."}"""
+    )
+    run_agent(config, project, True, prompt=prompt, feature="tb_test_create")
 
 
 @test.command(
@@ -46,7 +48,8 @@ def test_create(ctx: click.Context, name_or_filename: str, prompt: str) -> None:
 def test_update(ctx: click.Context, pipe: str) -> None:
     client: TinyB = ctx.ensure_object(dict)["client"]
     project: Project = ctx.ensure_object(dict)["project"]
-    update_test(pipe, project, client)
+    config: dict[str, Any] = ctx.ensure_object(dict)["config"]
+    update_test(pipe, project, client, config=config)
 
 
 @test.command(
@@ -58,4 +61,5 @@ def test_update(ctx: click.Context, pipe: str) -> None:
 def run_tests_command(ctx: click.Context, name: Tuple[str, ...]) -> None:
     client: TinyB = ctx.ensure_object(dict)["client"]
     project: Project = ctx.ensure_object(dict)["project"]
-    run_tests(name, project, client)
+    config: dict[str, Any] = ctx.ensure_object(dict)["config"]
+    run_tests(name, project, client, config=config)

tinybird/tb/modules/test_common.py

@@ -14,15 +14,11 @@ import click
 import yaml
 from requests import Response
 
-from tinybird.prompts import test_create_prompt
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.build_common import process as build_project
 from tinybird.tb.modules.common import sys_exit
-from tinybird.tb.modules.config import CLIConfig
 from tinybird.tb.modules.exceptions import CLITestException
 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_local_tokens, get_test_workspace_name
 from tinybird.tb.modules.project import Project
 
@@ -54,85 +50,6 @@ def generate_test_file(pipe_name: str, tests: List[Dict[str, Any]], folder: Opti
     return path
 
 
-def create_test(
-    name_or_filename: str, prompt: str, project: Project, client: TinyB, preview: bool = False
-) -> list[dict[str, Any]]:
-    """
-    Create a test for an existing pipe
-    """
-    tests: List[Dict[str, Any]] = []
-
-    try:
-        click.echo(FeedbackManager.highlight(message="\n» Building test environment"))
-        build_error = build_project(project=project, tb_client=client, watch=False, silent=True, exit_on_error=False)
-        if build_error:
-            raise Exception(build_error)
-        click.echo(FeedbackManager.info(message="✓ Done!\n"))
-        config = CLIConfig.get_project_config()
-        folder = project.folder
-        pipe_path = get_pipe_path(name_or_filename, folder)
-        pipe_name = pipe_path.stem
-        click.echo(FeedbackManager.highlight(message=f"» Creating tests for {pipe_name} endpoint..."))
-        pipe_content = pipe_path.read_text()
-        pipe = client._req(f"/v0/pipes/{pipe_name}")
-        parameters = set([param["name"] for node in pipe["nodes"] for param in node["params"]])
-
-        system_prompt = test_create_prompt.format(
-            name=pipe_name,
-            content=pipe_content,
-            parameters=parameters or "No parameters",
-        )
-        user_token = config.get_user_token()
-        if not user_token:
-            raise Exception("No user token found")
-
-        llm = LLM(user_token=user_token, host=config.get_client().host)
-        response_llm = llm.ask(system_prompt=system_prompt, prompt=prompt, feature="tb_test_create")
-        response_xml = extract_xml(response_llm, "response")
-        tests_content = parse_xml(response_xml, "test")
-
-        for test_content in tests_content:
-            test: Dict[str, Any] = {}
-            test["name"] = extract_xml(test_content, "name")
-            test["description"] = extract_xml(test_content, "description")
-            parameters_api = extract_xml(test_content, "parameters")
-            test["parameters"] = parameters_api.split("?")[1] if "?" in parameters_api else parameters_api
-            test["expected_result"] = ""
-
-            response = None
-            try:
-                response = get_pipe_data(client, pipe_name=pipe_name, test_params=test["parameters"])
-            except Exception:
-                pass
-
-            if response:
-                if response.status_code >= 400:
-                    test["expected_http_status"] = response.status_code
-                    test["expected_result"] = response.json()["error"]
-                else:
-                    test.pop("expected_http_status", None)
-                    test["expected_result"] = response.text or ""
-
-            tests.append(test)
-
-        if not preview:
-            if len(tests) > 0:
-                generate_test_file(pipe_name, tests, folder, mode="a")
-                for test in tests:
-                    test_name = test["name"]
-                    click.echo(FeedbackManager.info(message=f"✓ {test_name} created"))
-            else:
-                click.echo(FeedbackManager.info(message="* No tests created"))
-
-            click.echo(FeedbackManager.success(message="✓ Done!\n"))
-    except Exception as e:
-        raise CLITestException(FeedbackManager.error(message=str(e)))
-    finally:
-        cleanup_test_workspace(client, project.folder)
-
-    return tests
-
-
 def parse_tests(tests_content: str) -> List[Dict[str, Any]]:
     return yaml.safe_load(tests_content)
 
@@ -142,11 +59,13 @@ def dump_tests(tests: List[Dict[str, Any]]) -> str:
     return yaml_str.replace("- name:", "\n- name:")
 
 
-def update_test(pipe: str, project: Project, client: TinyB) -> None:
+def update_test(pipe: str, project: Project, client: TinyB, config: dict[str, Any]) -> None:
     try:
         folder = project.folder
         click.echo(FeedbackManager.highlight(message="\n» Building test environment"))
-        build_error = build_project(project=project, tb_client=client, watch=False, silent=True, exit_on_error=False)
+        build_error = build_project(
+            project=project, tb_client=client, watch=False, silent=True, exit_on_error=False, config=config
+        )
         if build_error:
             raise Exception(build_error)
 
@@ -190,11 +109,18 @@ def update_test(pipe: str, project: Project, client: TinyB) -> None:
         cleanup_test_workspace(client, project.folder)
 
 
-def run_tests(name: Tuple[str, ...], project: Project, client: TinyB) -> Optional[str]:
+def run_tests(name: Tuple[str, ...], project: Project, client: TinyB, config: dict[str, Any]) -> Optional[str]:
     full_error = ""
     try:
         click.echo(FeedbackManager.highlight(message="\n» Building test environment"))
-        build_error = build_project(project=project, tb_client=client, watch=False, silent=True, exit_on_error=False)
+        build_error = build_project(
+            project=project,
+            tb_client=client,
+            watch=False,
+            silent=True,
+            exit_on_error=False,
+            config=config,
+        )
         if build_error:
             raise Exception(build_error)
         click.echo(FeedbackManager.info(message="✓ Done!"))

tinybird/tb/modules/tinyunit/tinyunit.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, Iterable, List, Optional
 import click
 import yaml
 from humanfriendly.tables import format_smart_table
-from typing_extensions import override
 
 from tinybird.tb.client import TinyB
 from tinybird.tb.modules.common import CLIException
@@ -118,19 +117,6 @@ class TestResult:
             return PASS_OVER_TIME
         return PASS
 
-    @override
-    def __dict__(self):
-        return {
-            "name": self.name,
-            "data": self.data,
-            "elapsed_time": self.elapsed_time,
-            "read_bytes": self.read_bytes,
-            "max_elapsed_time": self.max_elapsed_time,
-            "max_bytes_read": self.max_bytes_read,
-            "error": self.error,
-            "status": self.status.name,
-        }
-
 
 @dataclass()
 class TestSummaryResults:

tinybird/tb/modules/tinyunit/tinyunit_lib.py

@@ -3,8 +3,6 @@ from collections import namedtuple
 from json import JSONEncoder
 from typing import Optional
 
-from typing_extensions import override
-
 
 class MyJSONEncoder(JSONEncoder):
     # def default(self, in_obj):
@@ -56,10 +54,6 @@ class DataUnitTest:
     def __str__(self):
         return json.dumps(dict(self), ensure_ascii=False)
 
-    @override
-    def __dict__(self):
-        return dict(self)
-
     def __repr__(self):
         return self.__str__()
 

tinybird/tb/modules/watch.py

@@ -33,9 +33,10 @@ class WatchProjectHandler(PatternMatchingEventHandler):
         ".env.local",
     ]
 
-    def __init__(self, shell: Shell, project: Project, process: Callable):
+    def __init__(self, shell: Shell, project: Project, config: dict[str, Any], process: Callable):
         self.shell = shell
         self.project = project
+        self.config = config
         self.process = process
         self.datafiles = project.get_project_datafiles()
         patterns = [f"**/*{ext}" for ext in self.valid_extensions]
@@ -58,7 +59,7 @@ class WatchProjectHandler(PatternMatchingEventHandler):
 
     def _process(self, path: Optional[str] = None) -> None:
         click.echo(FeedbackManager.highlight(message="» Rebuilding project..."))
-        self.process(watch=True, file_changed=path, diff=self.diff(path))
+        self.process(watch=True, file_changed=path, diff=self.diff(path), config=self.config)
         self.shell.reprint_prompt()
 
     def diff(self, path: Optional[str] = None) -> Optional[str]:
@@ -137,8 +138,9 @@ def watch_project(
     shell: Shell,
     process: Callable[[bool, Optional[str], Optional[str]], None],
     project: Project,
+    config: dict[str, Any],
 ) -> None:
-    event_handler = WatchProjectHandler(shell=shell, project=project, process=process)
+    event_handler = WatchProjectHandler(shell=shell, project=project, process=process, config=config)
     observer = Observer()
     observer.schedule(event_handler, path=str(project.path), recursive=True)
     observer.start()

tinybird/tb_cli_modules/common.py

@@ -1042,7 +1042,7 @@ def get_format_from_filename_or_url(filename_or_url: str) -> str:
     'csv'
     """
     filename_or_url = filename_or_url.lower()
-    if filename_or_url.endswith("json") or filename_or_url.endswith("ndjson"):
+    if filename_or_url.endswith(("json", "ndjson")):
         return "ndjson"
     if filename_or_url.endswith("parquet"):
         return "parquet"
@@ -1050,7 +1050,7 @@ def get_format_from_filename_or_url(filename_or_url: str) -> str:
         return "csv"
     try:
         parsed = urlparse(filename_or_url)
-        if parsed.path.endswith("json") or parsed.path.endswith("ndjson"):
+        if parsed.path.endswith(("json", "ndjson")):
             return "ndjson"
         if parsed.path.endswith("parquet"):
             return "parquet"

tinybird/tb_cli_modules/telemetry.py

@@ -81,7 +81,7 @@ def _hide_tokens(text: str) -> str:
 
 class TelemetryHelper:
     def __init__(self, tb_host: Optional[str] = None, max_enqueued_events: int = 5) -> None:
-        self.tb_host = tb_host or os.getenv("TB_CLI_TELEMETRY_HOST", "https://api.tinybird.co")
+        self.tb_host = tb_host or os.getenv("TB_CLI_TELEMETRY_HOST", "https://api.europe-west2.gcp.tinybird.co")
         self.max_enqueued_events: int = max_enqueued_events
 
         self.enabled: bool = True

tinybird/tornado_template.py

@@ -289,12 +289,11 @@ class Template:
         if whitespace is None:
             if loader and loader.whitespace:
                 whitespace = loader.whitespace
-            else:
+            elif name.endswith((".html", ".js")):
                 # Whitespace defaults by filename.
-                if name.endswith(".html") or name.endswith(".js"):
-                    whitespace = "single"
-                else:
-                    whitespace = "all"
+                whitespace = "single"
+            else:
+                whitespace = "all"
         # Validate the whitespace setting.
         filter_whitespace(whitespace, "")
 
@@ -1169,7 +1168,7 @@ def check_valid_expr(expr):
                 check_valid_expr(expr.slice.lower)
             if expr.slice.upper is not None:
                 check_valid_expr(expr.slice.upper)
-        elif isinstance(expr.slice, ast.Constant) or isinstance(expr.slice, ast.Subscript):
+        elif isinstance(expr.slice, (ast.Constant, ast.Subscript)):
             check_valid_expr(expr.slice)
         else:
             raise SecurityException(f"Invalid Slice expression: {ast.dump(expr.slice)}")
@@ -1178,7 +1177,7 @@ def check_valid_expr(expr):
             check_valid_expr(key)
         for value in expr.values:
             check_valid_expr(value)
-    elif isinstance(expr, ast.Tuple) or isinstance(expr, ast.List) or isinstance(expr, ast.Set):
+    elif isinstance(expr, (ast.Tuple, ast.List, ast.Set)):
         for x in expr.elts:
             check_valid_expr(x)
     elif isinstance(expr, ast.JoinedStr):