snowflake-cli 3.0.2__py3-none-any.whl → 3.2.0__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "3.0.2"
+VERSION = "3.2.0"

snowflake/cli/_app/cli_app.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import logging
+import os
 import platform
 import sys
 from dataclasses import dataclass
@@ -141,6 +142,7 @@ def _info_callback(value: bool):
                 {"key": "python_version", "value": sys.version},
                 {"key": "system_info", "value": platform.platform()},
                 {"key": "feature_flags", "value": get_feature_flags_section()},
+                {"key": "SNOWFLAKE_HOME", "value": os.getenv("SNOWFLAKE_HOME")},
             ],
         )
         print_result(result, output_format=OutputFormat.JSON)
@@ -155,6 +157,7 @@ def app_factory() -> SnowCliMainTyper:
         invoke_without_command=True,
         epilog=new_version_msg,
         result_callback=show_new_version_banner_callback(new_version_msg),
+        help=f"Snowflake CLI tool for developers [v{__about__.VERSION}]",
     )
     def default(
         ctx: typer.Context,

snowflake/cli/_app/dev/docs/templates/overview.rst.jinja2

@@ -5,5 +5,5 @@ Global options
 ===============================================================================
 {% for param in options if not param.hidden %}
 :samp:`{% for p in param.opts %}{{ p }}{{ ", " if not loop.last }}{% endfor %}{% if not param.is_flag %} {{ '{' }}{{ param.name }}{{ '}' }}{% endif %}`
-{% if param.help %}{{ "  " + param.help | replace("`", "``") }}{% if param.help[-1] != '.' %}.{% endif %}{% else %}  TBD{% endif %}
+{% if param.help %}{{ "  " + param.help}}{% if param.help[-1] != '.' %}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor %}

snowflake/cli/_app/dev/docs/templates/usage.rst.jinja2

@@ -26,7 +26,7 @@ Arguments
         {{ param.make_metavar().replace("[", "").replace("]", "").lower() }}
     {%- endif -%}
     {{ '}' }}`
-{% if param.help %}{{ "  " + param.help | replace("`", "``") | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
+{% if param.help %}{{ "  " + param.help | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor %}
 {% else %}
 
@@ -48,7 +48,7 @@ Options
         {%- if param.type.name != "choice" %}{{ ' {' }}{% else %} {% endif %}{{ param.make_metavar() }}{% if param.type.name != "choice" %}{{ '}' }}
         {%- endif %}
     {%- endif %}`
-{% if param.help %}{{ "  " + param.help | replace("`", "``") | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default is not none %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
+{% if param.help %}{{ "  " + param.help | replace("\n", " ") }}{% if param.help[-1] != '.' %}.{% endif %}{% if param.default is not none and param.default != "" %} Default: {{ param.default }}.{% endif %}{% else %}  TBD{% endif %}
 {% endfor -%}
 {% else %}
 

snowflake/cli/_app/telemetry.py

@@ -14,12 +14,14 @@
 
 from __future__ import annotations
 
+import os
 import platform
 import sys
 from enum import Enum, unique
 from typing import Any, Dict, Union
 
 import click
+import typer
 from snowflake.cli.__about__ import VERSION
 from snowflake.cli._app.constants import PARAM_APPLICATION_NAME
 from snowflake.cli.api.cli_global_context import (
@@ -30,6 +32,7 @@ from snowflake.cli.api.commands.execution_metadata import ExecutionMetadata
 from snowflake.cli.api.config import get_feature_flags_section
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.utils.error_handling import ignore_exceptions
+from snowflake.connector import ProgrammingError
 from snowflake.connector.telemetry import (
     TelemetryData,
     TelemetryField,
@@ -59,6 +62,7 @@ class CLITelemetryField(Enum):
     COMMAND_RESULT_STATUS = "command_result_status"
     COMMAND_OUTPUT_TYPE = "command_output_type"
     COMMAND_EXECUTION_TIME = "command_execution_time"
+    COMMAND_CI_ENVIRONMENT = "command_ci_environment"
     # Configuration
     CONFIG_FEATURE_FLAGS = "config_feature_flags"
     # Metrics
@@ -67,6 +71,9 @@ class CLITelemetryField(Enum):
     EVENT = "event"
     ERROR_MSG = "error_msg"
     ERROR_TYPE = "error_type"
+    ERROR_CODE = "error_code"
+    ERROR_CAUSE = "error_cause"
+    SQL_STATE = "sql_state"
     IS_CLI_EXCEPTION = "is_cli_exception"
     # Project context
     PROJECT_DEFINITION_VERSION = "project_definition_version"
@@ -81,6 +88,43 @@ class TelemetryEvent(Enum):
 TelemetryDict = Dict[Union[CLITelemetryField, TelemetryField], Any]
 
 
+def _is_cli_exception(exception: Exception) -> bool:
+    return isinstance(
+        exception,
+        (
+            click.ClickException,
+            typer.Exit,
+            typer.Abort,
+            BrokenPipeError,
+            KeyboardInterrupt,
+        ),
+    )
+
+
+def _get_additional_exception_information(exception: Exception) -> TelemetryDict:
+    """
+    Attach the errno and sqlstate if the exception or the
+    cause of the exception is a ProgrammingError
+    """
+    additional_info = {}
+
+    if isinstance(exception, ProgrammingError):
+        additional_info[CLITelemetryField.ERROR_CODE] = exception.errno
+        additional_info[CLITelemetryField.SQL_STATE] = exception.sqlstate
+
+    if exception.__cause__:
+        cause = exception.__cause__
+        additional_info[CLITelemetryField.ERROR_CAUSE] = type(cause).__name__
+
+        if isinstance(cause, ProgrammingError):
+            if not additional_info.get(CLITelemetryField.ERROR_CODE):
+                additional_info[CLITelemetryField.ERROR_CODE] = cause.errno
+            if not additional_info.get(CLITelemetryField.SQL_STATE):
+                additional_info[CLITelemetryField.SQL_STATE] = cause.sqlstate
+
+    return additional_info
+
+
 def _get_command_metrics() -> TelemetryDict:
     cli_context = get_cli_context()
 
@@ -110,9 +154,14 @@ def _find_command_info() -> TelemetryDict:
 
 
 def _get_definition_version() -> str | None:
-    cli_context = get_cli_context()
-    if cli_context.project_definition:
-        return cli_context.project_definition.definition_version
+    try:
+        cli_context = get_cli_context()
+        if cli_context.project_definition:
+            return cli_context.project_definition.definition_version
+    except Exception:
+        # Don't let an invalid project definition file break telemetry
+        # (especially for commands that don't normally load it)
+        pass
     return None
 
 
@@ -122,6 +171,20 @@ def _get_installation_source() -> CLIInstallationSource:
     return CLIInstallationSource.PYPI
 
 
+def _get_ci_environment_type() -> str:
+    if "GITHUB_ACTIONS" in os.environ:
+        return "GITHUB_ACTIONS"
+    if "GITLAB_CI" in os.environ:
+        return "GITLAB_CI"
+    if "CIRCLECI" in os.environ:
+        return "CIRCLECI"
+    if "JENKINS_URL" in os.environ or "HUDSON_URL" in os.environ:
+        return "JENKINS"
+    if "TF_BUILD" in os.environ:
+        return "AZURE_DEVOPS"
+    return "UNKNOWN"
+
+
 def command_info() -> str:
     info = _find_command_info()
     command = ".".join(info[CLITelemetryField.COMMAND])
@@ -148,6 +211,7 @@ class CLITelemetryClient:
             CLITelemetryField.VERSION_CLI: VERSION,
             CLITelemetryField.VERSION_OS: platform.platform(),
             CLITelemetryField.VERSION_PYTHON: python_version(),
+            CLITelemetryField.COMMAND_CI_ENVIRONMENT: _get_ci_environment_type(),
             CLITelemetryField.CONFIG_FEATURE_FLAGS: {
                 k: str(v) for k, v in get_feature_flags_section().items()
             },
@@ -202,7 +266,7 @@ def log_command_result(execution: ExecutionMetadata):
 @ignore_exceptions()
 def log_command_execution_error(exception: Exception, execution: ExecutionMetadata):
     exception_type: str = type(exception).__name__
-    is_cli_exception: bool = issubclass(exception.__class__, click.ClickException)
+    is_cli_exception: bool = _is_cli_exception(exception)
     _telemetry.send(
         {
             TelemetryField.KEY_TYPE: TelemetryEvent.CMD_EXECUTION_ERROR.value,
@@ -210,6 +274,7 @@ def log_command_execution_error(exception: Exception, execution: ExecutionMetada
             CLITelemetryField.ERROR_TYPE: exception_type,
             CLITelemetryField.IS_CLI_EXCEPTION: is_cli_exception,
             CLITelemetryField.COMMAND_EXECUTION_TIME: execution.get_duration(),
+            **_get_additional_exception_information(exception),
             **_get_command_metrics(),
         }
     )

snowflake/cli/_plugins/connection/commands.py

@@ -16,19 +16,38 @@ from __future__ import annotations
 
 import logging
 import os.path
+from pathlib import Path
+from typing import Optional
 
 import typer
-from click import ClickException, Context, Parameter  # type: ignore
+from click import (  # type: ignore
+    ClickException,
+    Context,
+    Parameter,
+    UsageError,
+)
 from click.core import ParameterSource  # type: ignore
-from click.types import StringParamType
+from snowflake import connector
 from snowflake.cli._plugins.connection.util import (
-    strip_and_check_if_exists,
     strip_if_value_present,
 )
 from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.flags import (
     PLAIN_PASSWORD_MSG,
+    AccountOption,
+    AuthenticatorOption,
+    DatabaseOption,
+    HostOption,
+    NoInteractiveOption,
+    PasswordOption,
+    PortOption,
+    PrivateKeyPathOption,
+    RoleOption,
+    SchemaOption,
+    TokenFilePathOption,
+    UserOption,
+    WarehouseOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.config import (
@@ -63,11 +82,6 @@ class EmptyInput:
         return "optional"
 
 
-class OptionalPrompt(StringParamType):
-    def convert(self, value, param, ctx):
-        return None if isinstance(value, EmptyInput) else value
-
-
 def _mask_password(connection_params: dict):
     if "password" in connection_params:
         connection_params["password"] = "****"
@@ -100,7 +114,7 @@ def list_connections(**options) -> CommandResult:
 
 
 def require_integer(field_name: str):
-    def callback(value: str):
+    def callback(ctx: Context, param: Parameter, value: str):
         if value is None:
             return None
         if value.strip().isdigit():
@@ -123,130 +137,91 @@ def add(
         None,
         "--connection-name",
         "-n",
-        prompt="Name for this connection",
         help="Name of the new connection.",
         show_default=False,
-        callback=strip_if_value_present,
     ),
     account: str = typer.Option(
         None,
-        "--account",
         "-a",
-        "--accountname",
-        prompt="Snowflake account name",
+        *AccountOption.param_decls,
         help="Account name to use when authenticating with Snowflake.",
         show_default=False,
-        callback=strip_if_value_present,
     ),
     user: str = typer.Option(
         None,
-        "--user",
         "-u",
-        "--username",
-        prompt="Snowflake username",
+        *UserOption.param_decls,
         show_default=False,
         help="Username to connect to Snowflake.",
-        callback=strip_if_value_present,
     ),
-    password: str = typer.Option(
-        EmptyInput(),
-        "--password",
+    password: Optional[str] = typer.Option(
+        None,
         "-p",
-        click_type=OptionalPrompt(),
+        *PasswordOption.param_decls,
         callback=_password_callback,
-        prompt="Snowflake password",
         help="Snowflake password.",
         hide_input=True,
     ),
-    role: str = typer.Option(
-        EmptyInput(),
-        "--role",
+    role: Optional[str] = typer.Option(
+        None,
         "-r",
-        click_type=OptionalPrompt(),
-        prompt="Role for the connection",
+        *RoleOption.param_decls,
         help="Role to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    warehouse: str = typer.Option(
-        EmptyInput(),
-        "--warehouse",
+    warehouse: Optional[str] = typer.Option(
+        None,
         "-w",
-        click_type=OptionalPrompt(),
-        prompt="Warehouse for the connection",
+        *WarehouseOption.param_decls,
         help="Warehouse to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    database: str = typer.Option(
-        EmptyInput(),
-        "--database",
+    database: Optional[str] = typer.Option(
+        None,
         "-d",
-        click_type=OptionalPrompt(),
-        prompt="Database for the connection",
+        *DatabaseOption.param_decls,
         help="Database to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    schema: str = typer.Option(
-        EmptyInput(),
-        "--schema",
+    schema: Optional[str] = typer.Option(
+        None,
         "-s",
-        click_type=OptionalPrompt(),
-        prompt="Schema for the connection",
+        *SchemaOption.param_decls,
         help="Schema to use on Snowflake.",
-        callback=strip_if_value_present,
     ),
-    host: str = typer.Option(
-        EmptyInput(),
-        "--host",
+    host: Optional[str] = typer.Option(
+        None,
         "-h",
-        click_type=OptionalPrompt(),
-        prompt="Connection host",
+        *HostOption.param_decls,
         help="Host name the connection attempts to connect to Snowflake.",
-        callback=strip_if_value_present,
     ),
-    port: int = typer.Option(
-        EmptyInput(),
-        "--port",
+    port: Optional[int] = typer.Option(
+        None,
         "-P",
-        click_type=OptionalPrompt(),
-        prompt="Connection port",
+        *PortOption.param_decls,
         help="Port to communicate with on the host.",
-        callback=require_integer(field_name="port"),
     ),
-    region: str = typer.Option(
-        EmptyInput(),
+    region: Optional[str] = typer.Option(
+        None,
         "--region",
         "-R",
-        click_type=OptionalPrompt(),
-        prompt="Snowflake region",
         help="Region name if not the default Snowflake deployment.",
-        callback=strip_if_value_present,
     ),
-    authenticator: str = typer.Option(
-        EmptyInput(),
-        "--authenticator",
+    authenticator: Optional[str] = typer.Option(
+        None,
         "-A",
-        click_type=OptionalPrompt(),
-        prompt="Authentication method",
+        *AuthenticatorOption.param_decls,
         help="Chosen authenticator, if other than password-based",
     ),
-    private_key_file: str = typer.Option(
-        EmptyInput(),
+    private_key_file: Optional[str] = typer.Option(
+        None,
         "--private-key",
-        "--private-key-path",
         "-k",
-        click_type=OptionalPrompt(),
-        prompt="Path to private key file",
+        *PrivateKeyPathOption.param_decls,
         help="Path to file containing private key",
-        callback=strip_and_check_if_exists,
     ),
-    token_file_path: str = typer.Option(
-        EmptyInput(),
-        "--token-file-path",
+    token_file_path: Optional[str] = typer.Option(
+        None,
         "-t",
-        click_type=OptionalPrompt(),
-        prompt="Path to token file",
+        *TokenFilePathOption.param_decls,
         help="Path to file with an OAuth token that should be used when connecting to Snowflake",
-        callback=strip_and_check_if_exists,
     ),
     set_as_default: bool = typer.Option(
         False,
@@ -254,29 +229,62 @@ def add(
         is_flag=True,
         help="If provided the connection will be configured as default connection.",
     ),
+    no_interactive: bool = NoInteractiveOption,
     **options,
 ) -> CommandResult:
     """Adds a connection to configuration file."""
+    connection_options = {
+        "connection_name": connection_name,
+        "account": account,
+        "user": user,
+        "password": password,
+        "role": role,
+        "warehouse": warehouse,
+        "database": database,
+        "schema": schema,
+        "host": host,
+        "port": port,
+        "region": region,
+        "authenticator": authenticator,
+        "private_key_file": private_key_file,
+        "token_file_path": token_file_path,
+    }
+
+    if not no_interactive:
+        for option in connection_options:
+            if connection_options[option] is None:
+                connection_options[option] = typer.prompt(
+                    f"Enter {option.replace('_', ' ')}",
+                    default="",
+                    value_proc=lambda x: None if not x else x,
+                    hide_input=option == "password",
+                    show_default=False,
+                )
+            if isinstance(connection_options[option], str):
+                connection_options[option] = strip_if_value_present(
+                    connection_options[option]
+                )
+
+    if (value := connection_options["port"]) is not None:
+        connection_options["port"] = int(value)
+
+    if (path := connection_options["private_key_file"]) is not None:
+        if not Path(str(path)).exists():
+            raise UsageError(f"Path {path} does not exist.")
+
+    if (path := connection_options["token_file_path"]) is not None:
+        if not Path(str(path)).exists():
+            raise UsageError(f"Path {path} does not exist.")
+
+    connection_name = str(connection_options["connection_name"])
+    del connection_options["connection_name"]
+
     if connection_exists(connection_name):
-        raise ClickException(f"Connection {connection_name} already exists")
+        raise UsageError(f"Connection {connection_name} already exists")
 
     connections_file = add_connection_to_proper_file(
         connection_name,
-        ConnectionConfig(
-            account=account,
-            user=user,
-            password=password,
-            host=host,
-            region=region,
-            port=port,
-            database=database,
-            schema=schema,
-            warehouse=warehouse,
-            role=role,
-            authenticator=authenticator,
-            private_key_file=private_key_file,
-            token_file_path=token_file_path,
-        ),
+        ConnectionConfig(**connection_options),
     )
     if set_as_default:
         set_config_value(
@@ -342,7 +350,7 @@ def test(
 @app.command(requires_connection=False)
 def set_default(
     name: str = typer.Argument(
-        help="Name of the connection, as defined in your `config.toml`",
+        help="Name of the connection, as defined in your `config.toml` file",
         show_default=False,
     ),
     **options,
@@ -351,3 +359,48 @@ def set_default(
     get_connection_dict(connection_name=name)
     set_config_value(section=None, key="default_connection_name", value=name)
     return MessageResult(f"Default connection set to: {name}")
+
+
+@app.command(requires_connection=True)
+def generate_jwt(
+    **options,
+) -> CommandResult:
+    """Generate a JWT token, which will be printed out and displayed.."""
+    connection_details = get_cli_context().connection_context.update_from_config()
+
+    msq_template = (
+        "{} is not set in the connection context, but required for JWT generation."
+    )
+    if not connection_details.user:
+        raise UsageError(msq_template.format("User"))
+    if not connection_details.account:
+        raise UsageError(msq_template.format("Account"))
+    if not connection_details.private_key_file:
+        raise UsageError(msq_template.format("Private key file"))
+
+    passphrase = os.getenv("PRIVATE_KEY_PASSPHRASE", None)
+
+    def _decrypt(passphrase: str | None):
+        return connector.auth.get_token_from_private_key(
+            user=connection_details.user,
+            account=connection_details.account,
+            privatekey_path=connection_details.private_key_file,
+            key_password=passphrase,
+        )
+
+    try:
+        if passphrase is None:
+            try:
+                token = _decrypt(passphrase=None)
+                return MessageResult(token)
+            except TypeError:
+                passphrase = typer.prompt(
+                    "Enter private key file password (press enter for empty)",
+                    hide_input=True,
+                    type=str,
+                    default="",
+                )
+        token = _decrypt(passphrase=passphrase)
+        return MessageResult(token)
+    except (ValueError, TypeError) as err:
+        raise ClickException(str(err))

snowflake/cli/_plugins/connection/util.py

@@ -17,7 +17,10 @@ from __future__ import annotations
 import json
 import logging
 import os
-from typing import Optional
+from enum import Enum
+from functools import lru_cache
+from textwrap import dedent
+from typing import Any, Dict, Optional
 
 from click.exceptions import ClickException
 from snowflake.connector import SnowflakeConnection
@@ -25,12 +28,6 @@ from snowflake.connector.cursor import DictCursor
 
 log = logging.getLogger(__name__)
 
-REGIONLESS_QUERY = """
-    select value['value'] as REGIONLESS from table(flatten(
-        input => parse_json(SYSTEM$BOOTSTRAP_DATA_REQUEST()),
-        path => 'clientParamsInfo'
-    )) where value['name'] = 'UI_SNOWSIGHT_ENABLE_REGIONLESS_REDIRECT';
-"""
 
 ALLOWLIST_QUERY = "SELECT SYSTEM$ALLOWLIST()"
 SNOWFLAKE_DEPLOYMENT = "SNOWFLAKE_DEPLOYMENT"
@@ -54,6 +51,50 @@ class MissingConnectionRegionError(ClickException):
         )
 
 
+class UIParameter(Enum):
+    NA_ENABLE_REGIONLESS_REDIRECT = "UI_SNOWSIGHT_ENABLE_REGIONLESS_REDIRECT"
+    NA_EVENT_SHARING_V2 = "ENABLE_EVENT_SHARING_V2_IN_THE_SAME_ACCOUNT"
+    NA_ENFORCE_MANDATORY_FILTERS = (
+        "ENFORCE_MANDATORY_FILTERS_FOR_SAME_ACCOUNT_INSTALLATION"
+    )
+
+
+def get_ui_parameter(
+    conn: SnowflakeConnection, parameter: UIParameter, default: Any
+) -> str:
+    """
+    Returns the value of a single UI parameter.
+    If the parameter is not found, the default value is returned.
+    """
+
+    ui_parameters = get_ui_parameters(conn)
+    return ui_parameters.get(parameter, default)
+
+
+@lru_cache()
+def get_ui_parameters(conn: SnowflakeConnection) -> Dict[UIParameter, Any]:
+    """
+    Returns the UI parameters from the SYSTEM$BOOTSTRAP_DATA_REQUEST function
+    """
+
+    parameters_to_fetch = sorted([param.value for param in UIParameter])
+
+    query = dedent(
+        f"""
+        select value['value']::string as PARAM_VALUE, value['name']::string as PARAM_NAME from table(flatten(
+            input => parse_json(SYSTEM$BOOTSTRAP_DATA_REQUEST()),
+            path => 'clientParamsInfo'
+        )) where value['name'] in ('{"', '".join(parameters_to_fetch)}');
+        """
+    )
+
+    *_, cursor = conn.execute_string(query, cursor_class=DictCursor)
+
+    return {
+        UIParameter(row["PARAM_NAME"]): row["PARAM_VALUE"] for row in cursor.fetchall()
+    }
+
+
 def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
     """
     Determines if the deployment this connection refers to uses
@@ -62,8 +103,12 @@ def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
     assume it's regionless, as this is true for most production deployments.
     """
     try:
-        *_, cursor = conn.execute_string(REGIONLESS_QUERY, cursor_class=DictCursor)
-        return cursor.fetchone()["REGIONLESS"].lower() == "true"
+        return (
+            get_ui_parameter(
+                conn, UIParameter.NA_ENABLE_REGIONLESS_REDIRECT, "true"
+            ).lower()
+            == "true"
+        )
     except:
         log.warning(
             "Cannot determine regionless redirect; assuming True.", exc_info=True

snowflake/cli/_plugins/cortex/manager.py

@@ -180,7 +180,7 @@ class CortexManager(SqlExecutionMixin):
 
     def _query_cortex_result_str(self, query: str) -> str:
         try:
-            cursor = self._execute_query(query, cursor_class=DictCursor)
+            cursor = self.execute_query(query, cursor_class=DictCursor)
             if cursor.rowcount is None:
                 raise SnowflakeSQLExecutionError(query)
             return str(cursor.fetchone()["CORTEX_RESULT"])

snowflake/cli/_plugins/git/commands.py

@@ -333,12 +333,15 @@ def execute(
     **options,
 ):
     """
-    Execute immediate all files from the repository path. Files can be filtered with glob like pattern,
+    Execute immediate all files from the repository path. Files can be filtered with a glob-like pattern,
     e.g. `@my_repo/branches/main/*.sql`, `@my_repo/branches/main/dev/*`. Only files with `.sql`
-    extension will be executed.
+    or `.py` extension will be executed.
     """
     results = GitManager().execute(
-        stage_path=repository_path, on_error=on_error, variables=variables
+        stage_path_str=repository_path,
+        on_error=on_error,
+        variables=variables,
+        requires_temporary_stage=True,
     )
     return CollectionResult(results)