snowflake-cli 3.1.0__tar.gz → 3.2.0__tar.gz

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli
-Version: 3.1.0
+Version: 3.2.0
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -206,7 +206,6 @@ License:                                  Apache License
            WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
            See the License for the specific language governing permissions and
            limitations under the License.
-License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -226,20 +225,20 @@ Requires-Dist: pydantic==2.9.2
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: requests==2.32.3
 Requires-Dist: requirements-parser==0.11.0
-Requires-Dist: rich==13.9.2
-Requires-Dist: setuptools==75.1.0
-Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.2
+Requires-Dist: rich==13.9.4
+Requires-Dist: setuptools==75.3.0
+Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.3
 Requires-Dist: snowflake-core==0.12.1; python_version < '3.12'
 Requires-Dist: snowflake-snowpark-python>=1.15.0; python_version < '3.12'
 Requires-Dist: tomlkit==0.13.2
 Requires-Dist: typer==0.12.5
 Requires-Dist: urllib3<2.3,>=1.24.3
 Provides-Extra: development
-Requires-Dist: coverage==7.6.3; extra == 'development'
+Requires-Dist: coverage==7.6.4; extra == 'development'
 Requires-Dist: factory-boy==3.3.1; extra == 'development'
-Requires-Dist: faker==30.3.0; extra == 'development'
+Requires-Dist: faker==30.8.2; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
-Requires-Dist: pytest-randomly==3.15.0; extra == 'development'
+Requires-Dist: pytest-randomly==3.16.0; extra == 'development'
 Requires-Dist: pytest==8.3.3; extra == 'development'
 Requires-Dist: syrupy==4.7.2; extra == 'development'
 Provides-Extra: packaging

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/RELEASE-NOTES.md

@@ -13,9 +13,48 @@
  See the License for the specific language governing permissions and
  limitations under the License.
  -->
-# v3.1.0
+# Unreleased version
 ## Backward incompatibility
 
+## Deprecations
+
+## New additions
+
+## Fixes and improvements
+
+# v3.2.0
+
+## Deprecations
+* `manifest` field of `application package` entity is now optional. This field does not have any functionality.
+## New additions
+* Added `--retain-comments` option to `snow sql` command to allow passing comments to Snowflake.
+* Added `--replace` and `--if-not-exists` options to `snow object create` command.
+* Added support for event sharing, which now can be specified under the `telemetry` section of an application entity. Two fields are supported: `share_mandatory_events` and `optional_shared_events`.
+* `snow stage copy` supports `--recursive` flag to copy local files and subdirectories recursively to stage. Including
+  glob support.
+* `snow helpers v1-to-v2` now converts v1 template references to v2 in Native App artifacts that use the `templates` processor.
+* Added `--label` option to `snow app version create` command to allow adding labels to versions and patches.
+* Enhanced `snow spcs service logs` command with new parameters for improved log retrieval and monitoring.
+  * `--previous-logs`: Retrieve logs from the last terminated container.
+  * `--since`: Start log retrieval from a specified UTC timestamp.
+  * `--include-timestamps`: Include timestamps in log entries for log streaming.
+  * `--follow`: Stream logs in real-time.
+  * `--follow-interval`: Set custom polling intervals during log streaming.
+* `snow connection add` supports `--no-interactive` flag to skip interactive prompts.
+
+## Fixes and improvements
+* `snow --info` callback returns information about `SNOWFLAKE_HOME` variable.
+* Removed requirement of existence of any `requirements.txt` file for Python code execution via `snow git execute` command.
+  Before the fix the file (even empty) was required to make the execution working.
+* Fixed saving of the config file updates when `connections.toml` exists.
+  Removed incorrect copying of connections from `connections.toml` to `config.toml`.
+* Fixes `snow connection generate-jwt` to work with keys with no passphrase.
+* The privilege to create a schema or stage is no longer required to run `snow app version create` if the schema and stage already exist.
+* Fix Windows permissions error on files created by CLI when owner is a part of custom group with granted
+  default permissions.
+
+# v3.1.0
+
 ## Deprecations
 * Added deprecation warning in the description of `snow spcs service status` and `snow spcs image-repository list-tags`.
 * Completely removed the `snow app init` as it was replaced with `snow init` in Snowflake CLI 3.0
@@ -28,11 +67,8 @@
 ## Fixes and improvements
 * Fixed a bug that would cause the `deploy_root`, `bundle_root`, and `generated_root` directories to be created in the current working directory instead of the project root when invoking commands with the `--project` flag from a different directory.
 * Align variables for `snow stage|git execute`. For Python files variables are stripped of leading and trailing quotes.
-* `snow spcs image-repository list-images` now displays image tag and digest.
+* `snow spcs service list-images` now displays image tag and digest.
 * Fix `snow stage list-files` for paths with directories.
-* `snow --info` callback returns information about `SNOWFLAKE_HOME` variable.
-* Removed requirement of existence of any `requirements.txt` file for Python code execution via `snow git execute` command.
-  Before the fix the file (even empty) was required to make the execution working.
 * Fix for list fields in mixins applied twice
 
 # v3.0.2

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/pyproject.toml

@@ -29,12 +29,12 @@ dependencies = [
   "pluggy==1.5.0",
   "PyYAML==6.0.2",
   "packaging",
-  "rich==13.9.2",
+  "rich==13.9.4",
   "requests==2.32.3",
   "requirements-parser==0.11.0",
-  "setuptools==75.1.0",
+  "setuptools==75.3.0",
   'snowflake.core==0.12.1; python_version < "3.12"',
-  "snowflake-connector-python[secure-local-storage]==3.12.2",
+  "snowflake-connector-python[secure-local-storage]==3.12.3",
   'snowflake-snowpark-python>=1.15.0;python_version < "3.12"',
   "tomlkit==0.13.2",
   "typer==0.12.5",
@@ -57,13 +57,13 @@ classifiers = [
 
 [project.optional-dependencies]
 development = [
-  "coverage==7.6.3",
+  "coverage==7.6.4",
   "pre-commit>=3.5.0",
   "pytest==8.3.3",
-  "pytest-randomly==3.15.0",
+  "pytest-randomly==3.16.0",
   "syrupy==4.7.2",
   "factory-boy==3.3.1",
-  "Faker==30.3.0",
+  "Faker==30.8.2",
 ]
 packaging = ["pyinstaller~=6.10"]
 

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/scripts/main.py

@@ -50,11 +50,14 @@ def main():
         release_notes = REPO_ROOT / "RELEASE-NOTES.md"
         with release_notes.open("r") as fh:
             current_content = fh.readlines()
-        current_content[0] = f"# v{new_version}\n"
+
+        license_txt = current_content[:15]
+        current_content[16] = f"# v{new_version}\n"
         new_content = [
+            *license_txt,
             *EMPTY_RELEASE_NOTES.splitlines(keepends=True),
             "\n",
-            *current_content,
+            *current_content[16:],
         ]
         with release_notes.open("w+") as fh:
             fh.writelines(new_content)

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/snyk/requirements.txt

@@ -2,12 +2,12 @@ jinja2==3.1.4
 pluggy==1.5.0
 PyYAML==6.0.2
 packaging
-rich==13.9.2
+rich==13.9.4
 requests==2.32.3
 requirements-parser==0.11.0
-setuptools==75.1.0
+setuptools==75.3.0
 snowflake.core==0.12.1; python_version < "3.12"
-snowflake-connector-python[secure-local-storage]==3.12.2
+snowflake-connector-python[secure-local-storage]==3.12.3
 snowflake-snowpark-python>=1.15.0;python_version < "3.12"
 tomlkit==0.13.2
 typer==0.12.5
@@ -15,10 +15,10 @@ urllib3>=1.24.3,<2.3
 GitPython==3.1.43
 pip
 pydantic==2.9.2
-coverage==7.6.3
+coverage==7.6.4
 pre-commit>=3.5.0
 pytest==8.3.3
-pytest-randomly==3.15.0
+pytest-randomly==3.16.0
 syrupy==4.7.2
 factory-boy==3.3.1
-Faker==30.3.0
+Faker==30.8.2

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/src/snowflake/cli/__about__.py

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

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/src/snowflake/cli/_app/dev/docs/templates/usage.rst.jinja2

@@ -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("\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-3.1.0 → snowflake_cli-3.2.0}/src/snowflake/cli/_plugins/connection/commands.py

@@ -16,20 +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, UsageError  # 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 (
@@ -64,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"] = "****"
@@ -101,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():
@@ -124,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,
@@ -255,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(
@@ -358,7 +365,7 @@ def set_default(
 def generate_jwt(
     **options,
 ) -> CommandResult:
-    """Generate and display a JWT token."""
+    """Generate a JWT token, which will be printed out and displayed.."""
     connection_details = get_cli_context().connection_context.update_from_config()
 
     msq_template = (
@@ -370,22 +377,30 @@ def generate_jwt(
         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)
-    if not passphrase:
-        passphrase = typer.prompt(
-            "Enter private key file password (Press enter if none)",
-            hide_input=True,
-            type=str,
-            default="",
-        )
 
-    try:
-        token = connector.auth.get_token_from_private_key(
+    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 as err:
+    except (ValueError, TypeError) as err:
         raise ClickException(str(err))

{snowflake_cli-3.1.0 → snowflake_cli-3.2.0}/src/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-3.1.0 → snowflake_cli-3.2.0}/src/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"])