snowflake-cli-labs 2.3.1__py3-none-any.whl → 2.4.0rc1__py3-none-any.whl

snowflake/cli/api/sql_execution.py

@@ -14,12 +14,12 @@ from snowflake.cli.api.exceptions import (
     SchemaNotProvidedError,
     SnowflakeSQLExecutionError,
 )
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.util import (
     identifier_to_show_like_pattern,
     unquote_identifier,
 )
 from snowflake.cli.api.utils.cursor import find_first_row
-from snowflake.cli.api.utils.naming_utils import from_qualified_name
 from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
@@ -128,56 +128,22 @@ class SqlExecutionMixin:
         """
         Checks if a database and schema are provided, either through the connection context or a qualified name.
         """
-        if name:
-            _, schema, database = from_qualified_name(name)
-        else:
-            schema, database = None, None
-        schema = schema or self._conn.schema
-        database = database or self._conn.database
-        if not database:
+        fqn = FQN.from_string(name).using_connection(self._conn)
+        if not fqn.database:
             raise DatabaseNotProvidedError()
-        if not schema:
+        if not fqn.schema:
             raise SchemaNotProvidedError()
 
-    def to_fully_qualified_name(
-        self, name: str, database: Optional[str] = None, schema: Optional[str] = None
-    ):
-        current_parts = name.split(".")
-        if len(current_parts) == 3:
-            # already fully qualified name
-            return name.upper()
-
-        if not database:
-            if not self._conn.database:
-                raise DatabaseNotProvidedError()
-            database = self._conn.database
-
-        if len(current_parts) == 2:
-            # we assume name is in form of `schema.object`
-            return f"{database}.{name}".upper()
-
-        schema = schema or self._conn.schema or "public"
-        database = database or self._conn.database
-        return f"{database}.{schema}.{name}".upper()
-
-    @staticmethod
-    def get_name_from_fully_qualified_name(name):
-        """
-        Returns name of the object from the fully-qualified name.
-        Assumes that [name] is in format [[database.]schema.]name
-        """
-        return from_qualified_name(name)[0]
-
     @staticmethod
-    def _qualified_name_to_in_clause(name: str) -> Tuple[str, Optional[str]]:
-        unqualified_name, schema, database = from_qualified_name(name)
-        if database:
-            in_clause = f"in schema {database}.{schema}"
-        elif schema:
-            in_clause = f"in schema {schema}"
+    def _qualified_name_to_in_clause(identifier: FQN) -> Tuple[str, Optional[str]]:
+        if identifier.database:
+            schema = identifier.schema or "PUBLIC"
+            in_clause = f"in schema {identifier.database}.{schema}"
+        elif identifier.schema:
+            in_clause = f"in schema {identifier.schema}"
         else:
             in_clause = None
-        return unqualified_name, in_clause
+        return identifier.name, in_clause
 
     class InClauseWithQualifiedNameError(ValueError):
         def __init__(self):
@@ -202,7 +168,9 @@ class SqlExecutionMixin:
         the connection or a qualified name, before executing the query.
         """
 
-        unqualified_name, name_in_clause = self._qualified_name_to_in_clause(name)
+        unqualified_name, name_in_clause = self._qualified_name_to_in_clause(
+            FQN.from_string(name)
+        )
         if in_clause and name_in_clause:
             raise self.InClauseWithQualifiedNameError()
         elif name_in_clause:
@@ -230,11 +198,3 @@ class SqlExecutionMixin:
             lambda row: row[name_col] == unquote_identifier(unqualified_name),
         )
         return show_obj_row
-
-    def qualified_name_for_url(
-        self, object_name: str, database: str | None = None, schema: str | None = None
-    ):
-        fqn = self.to_fully_qualified_name(
-            object_name, database=database, schema=schema
-        )
-        return ".".join(unquote_identifier(part) for part in fqn.split("."))

snowflake/cli/api/utils/cursor.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Callable, List, Optional
 
 from snowflake.connector.cursor import DictCursor

snowflake/cli/api/utils/models.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import os
+from typing import Any, Dict
+
+
+class EnvironWithDefinedDictFallback(Dict):
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError as e:
+            raise AttributeError(e)
+
+    def __getitem__(self, item):
+        if item in os.environ:
+            return os.environ[item]
+        return super().__getitem__(item)
+
+    def __contains__(self, item):
+        return item in os.environ or super().__contains__(item)
+
+    def update_from_dict(self, update_values: Dict[str, Any]):
+        return super().update(update_values)

snowflake/cli/api/utils/naming_utils.py

@@ -1,27 +0,0 @@
-import re
-from typing import Optional, Tuple
-
-from snowflake.cli.api.project.util import (
-    VALID_IDENTIFIER_REGEX,
-)
-
-
-def from_qualified_name(name: str) -> Tuple[str, Optional[str], Optional[str]]:
-    """
-    Takes in an object name in the form [[database.]schema.]name. Returns a tuple (name, [schema], [database])
-    """
-    # TODO: Use regex to match object name to a valid identifier or valid identifier (args). Second case is for sprocs and UDFs
-    qualifier_pattern = rf"(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>.*)"
-    result = re.fullmatch(qualifier_pattern, name)
-
-    if result is None:
-        raise ValueError(f"'{name}' is not a valid qualified name")
-
-    unqualified_name = result.group("name")
-    if result.group("second_qualifier") is not None:
-        database = result.group("first_qualifier")
-        schema = result.group("second_qualifier")
-    else:
-        database = None
-        schema = result.group("first_qualifier")
-    return unqualified_name, schema, database

snowflake/cli/api/utils/rendering.py

@@ -1,13 +1,24 @@
 from __future__ import annotations
 
-import os
+import re
+from collections import defaultdict, deque
 from pathlib import Path
 from textwrap import dedent
-from typing import Dict, Optional
+from typing import Dict, List, Optional, Set, cast
 
 import jinja2
-from jinja2 import Environment, StrictUndefined, loaders
+from click import ClickException
+from jinja2 import Environment, StrictUndefined, UndefinedError, loaders
+from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.project.schemas.project_definition import (
+    ProjectDefinition,
+)
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.cli.api.utils.models import EnvironWithDefinedDictFallback
+
+_CONTEXT_KEY = "ctx"
+_YML_TEMPLATE_START = "<%"
+_YML_TEMPLATE_END = "%>"
 
 
 def read_file_content(file_name: str):
@@ -45,6 +56,21 @@ def _env_bootstrap(env: Environment) -> Environment:
 
 
 def get_snowflake_cli_jinja_env():
+    _random_block = "___very___unique___block___to___disable___logic___blocks___"
+    return _env_bootstrap(
+        Environment(
+            loader=loaders.BaseLoader(),
+            keep_trailing_newline=True,
+            variable_start_string=_YML_TEMPLATE_START,
+            variable_end_string=_YML_TEMPLATE_END,
+            block_start_string=_random_block,
+            block_end_string=_random_block,
+            undefined=StrictUndefined,
+        )
+    )
+
+
+def get_sql_cli_jinja_env():
     _random_block = "___very___unique___block___to___disable___logic___blocks___"
     return _env_bootstrap(
         Environment(
@@ -61,9 +87,9 @@ def get_snowflake_cli_jinja_env():
 
 def jinja_render_from_file(
     template_path: Path, data: Dict, output_file_path: Optional[Path] = None
-):
+) -> Optional[str]:
     """
-    Create a file from a jinja template.
+    Renders a jinja template and outputs either the rendered contents as string or writes to a file.
 
     Args:
         template_path (Path): Path to the template
@@ -71,7 +97,7 @@ def jinja_render_from_file(
         output_file_path (Optional[Path]): If provided then rendered template will be written to this file
 
     Returns:
-        None
+        None if file path is provided, else returns the rendered string.
     """
     env = _env_bootstrap(
         Environment(
@@ -84,28 +110,157 @@ def jinja_render_from_file(
     rendered_result = loaded_template.render(**data)
     if output_file_path:
         SecurePath(output_file_path).write_text(rendered_result)
+        return None
     else:
-        print(rendered_result)
+        return rendered_result
+
+
+def _add_project_context(project_definition: ProjectDefinition) -> Dict:
+    """
+    Updates the external data with variables from snowflake.yml definition file.
+    """
+    context_data = _resolve_variables_in_project(project_definition)
+    return context_data
+
+
+def _remove_ctx_env_prefix(text: str) -> str:
+    prefix = "ctx.env."
+    if text.startswith(prefix):
+        return text[len(prefix) :]
+    return text
+
+
+def string_includes_template(text: str) -> bool:
+    return bool(re.search(rf"{_YML_TEMPLATE_START}.+{_YML_TEMPLATE_END}", text))
+
+
+def _resolve_variables_in_project(project_definition: ProjectDefinition):
+    # If there's project definition file then resolve variables from it
+    if not project_definition or not project_definition.meets_version_requirement(
+        "1.1"
+    ):
+        return {_CONTEXT_KEY: {"env": EnvironWithDefinedDictFallback({})}}
+
+    variables_data: EnvironWithDefinedDictFallback = cast(
+        EnvironWithDefinedDictFallback, project_definition.env
+    )
+
+    env_with_unresolved_keys: List[str] = _get_variables_with_dependencies(
+        variables_data
+    )
+    other_env = set(variables_data) - set(env_with_unresolved_keys)
+    env = get_snowflake_cli_jinja_env()
+    context_data = {_CONTEXT_KEY: project_definition}
+
+    # Resolve env section dependencies
+    while env_with_unresolved_keys:
+        key = env_with_unresolved_keys.pop()
+        value = variables_data[key]
+        if not isinstance(value, str):
+            continue
+        try:  # try to evaluate the template given current state of know variables
+            variables_data[key] = env.from_string(value).render(context_data)
+            if string_includes_template(variables_data[key]):
+                env_with_unresolved_keys.append(key)
+        except UndefinedError:
+            env_with_unresolved_keys.append(key)
+
+    # Resolve templates in variables without references, for example
+    for key in other_env:
+        variable_value = variables_data[key]
+        if not isinstance(variable_value, str):
+            continue
+        variables_data[key] = env.from_string(variable_value).render(context_data)
+
+    return context_data
+
+
+def _check_for_cycles(nodes: defaultdict):
+    nodes = nodes.copy()
+    for key in list(nodes):
+        q = deque([key])
+        visited: List[str] = []
+        while q:
+            curr = q.popleft()
+            if curr in visited:
+                raise ClickException(
+                    "Cycle detected between variables: {}".format(" -> ".join(visited))
+                )
+            # Only nodes that have references can cause cycles
+            if curr in nodes:
+                visited.append(curr)
+                q.extendleft(nodes[curr])
+
+
+def _get_variables_with_dependencies(variables_data: EnvironWithDefinedDictFallback):
+    """
+    Checks consistency of provided dictionary by
+    1. checking reference cycles
+    2. checking for missing variables
+    """
+    # Variables that are not specified in env section
+    missing_variables: Set[str] = set()
+    # Variables that require other variables
+    variables_with_dependencies = defaultdict(list)
 
+    for key, value in variables_data.items():
+        # Templates are reserved only to string variables
+        if not isinstance(value, str):
+            continue
 
-class _AttrGetter:
-    def __init__(self, data_dict):
-        self._data_dict = data_dict
+        required_variables = _search_for_required_variables(value)
 
-    def __getattr__(self, item):
-        if item not in self._data_dict:
-            raise AttributeError(f"No attribute {item}")
-        return self._data_dict[item]
+        if required_variables:
+            variables_with_dependencies[key] = required_variables
 
+        for variable in required_variables:
+            if variable not in variables_data:
+                missing_variables.add(variable)
 
-def _add_project_context(data: Dict):
-    context_key = "ctx"
-    if context_key in data:
-        raise ValueError(f"{context_key} in user defined data")
-    context_data = {context_key: {"env": _AttrGetter(os.environ)}}
-    return {**data, **context_data}
+    # If there are unknown env variables then we raise an error
+    if missing_variables:
+        raise ClickException(
+            "The following variables are used in environment definition but are not defined: {}".format(
+                ", ".join(missing_variables)
+            )
+        )
+
+    # Look for cycles between variables
+    _check_for_cycles(variables_with_dependencies)
+
+    # Sort by number of dependencies
+    return sorted(
+        list(variables_with_dependencies.keys()),
+        key=lambda k: len(variables_with_dependencies[k]),
+    )
+
+
+def _search_for_required_variables(variable_value: str):
+    """
+    Look for pattern in  variable value. Returns a list of env variables required
+    to expand this template.`
+    """
+    ctx_env_prefix = f"{_CONTEXT_KEY}.env."
+    found_variables = re.findall(
+        rf"({_YML_TEMPLATE_START}([\.\w ]+){_YML_TEMPLATE_END})+", variable_value
+    )
+    required_variables = []
+    for _, variable in found_variables:
+        var: str = variable.strip()
+        if var.startswith(ctx_env_prefix):
+            required_variables.append(var[len(ctx_env_prefix) :])
+    return required_variables
 
 
-def snowflake_cli_jinja_render(content: str, data: Dict | None = None) -> str:
-    data = _add_project_context(data or dict())
-    return get_snowflake_cli_jinja_env().from_string(content).render(**data)
+def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
+    data = data or {}
+    if _CONTEXT_KEY in data:
+        raise ClickException(
+            f"{_CONTEXT_KEY} in user defined data. The `{_CONTEXT_KEY}` variable is reserved for CLI usage."
+        )
+
+    context_data = _add_project_context(
+        project_definition=cli_context.project_definition
+    )
+    context_data.update(data)
+    return get_sql_cli_jinja_env().from_string(content).render(**context_data)

snowflake/cli/app/api_impl/plugin/plugin_config_provider_impl.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import List
 
 from snowflake.cli.api import PluginConfigProvider

snowflake/cli/app/cli_app.py

@@ -132,8 +132,9 @@ def _info_callback(value: bool):
 def app_factory() -> SnowCliMainTyper:
     app = SnowCliMainTyper()
 
-    @app.callback()
+    @app.callback(invoke_without_command=True)
     def default(
+        ctx: typer.Context,
         version: bool = typer.Option(
             None,
             "--version",
@@ -217,6 +218,8 @@ def app_factory() -> SnowCliMainTyper:
         """
         Snowflake CLI tool for developers.
         """
+        if not ctx.invoked_subcommand:
+            typer.echo(ctx.get_help())
         setup_pycharm_remote_debugger_if_provided(
             pycharm_debug_library_path=pycharm_debug_library_path,
             pycharm_debug_server_host=pycharm_debug_server_host,

snowflake/cli/app/commands_registration/builtin_plugins.py

@@ -1,8 +1,14 @@
 from snowflake.cli.plugins.connection import plugin_spec as connection_plugin_spec
+from snowflake.cli.plugins.cortex import plugin_spec as cortex_plugin_spec
 from snowflake.cli.plugins.git import plugin_spec as git_plugin_spec
 from snowflake.cli.plugins.nativeapp import plugin_spec as nativeapp_plugin_spec
 from snowflake.cli.plugins.notebook import plugin_spec as notebook_plugin_spec
 from snowflake.cli.plugins.object import plugin_spec as object_plugin_spec
+
+# TODO 3.0: remove this import
+from snowflake.cli.plugins.object_stage_deprecated import (
+    plugin_spec as object_stage_deprecated_plugin_spec,
+)
 from snowflake.cli.plugins.snowpark import plugin_spec as snowpark_plugin_spec
 from snowflake.cli.plugins.spcs import plugin_spec as spcs_plugin_spec
 from snowflake.cli.plugins.sql import plugin_spec as sql_plugin_spec
@@ -23,6 +29,8 @@ def get_builtin_plugin_name_to_plugin_spec():
         "streamlit": streamlit_plugin_spec,
         "git": git_plugin_spec,
         "notebook": notebook_plugin_spec,
+        "object-stage-deprecated": object_stage_deprecated_plugin_spec,
+        "cortex": cortex_plugin_spec,
     }
 
     return plugin_specs

snowflake/cli/app/commands_registration/command_plugins_loader.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from typing import Dict, List, Optional
 

snowflake/cli/app/commands_registration/commands_registration_with_callbacks.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Callable, List
 

snowflake/cli/app/commands_registration/typer_registration.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 from typing import List
 

snowflake/cli/app/dev/pycharm_remote_debug.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Optional
 
 from click import ClickException

snowflake/cli/app/loggers.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import logging
 import logging.config
 from dataclasses import asdict, dataclass, field

snowflake/cli/app/main_typer.py

@@ -29,7 +29,7 @@ class SnowCliMainTyper(typer.Typer):
         super().__init__(
             context_settings=DEFAULT_CONTEXT_SETTINGS,
             pretty_exceptions_show_locals=False,
-            add_completion=False,
+            add_completion=True,
         )
 
     def __call__(self, *args, **kwargs):

snowflake/cli/app/printing.py

@@ -84,7 +84,9 @@ def print_structured(result: CommandResult):
     if isinstance(result, MultipleResults):
         _stream_json(result)
     else:
-        return json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
+        json.dump(result, sys.stdout, cls=CustomJSONEncoder, indent=4)
+    # Adds empty line at the end
+    print()
 
 
 def _stream_json(result):

snowflake/cli/app/snow_connector.py

@@ -157,8 +157,8 @@ def _update_connection_application_name(connection_parameters: Dict):
     """Update version and name of app handling connection."""
     connection_application_params = {
         "application_name": PARAM_APPLICATION_NAME,
-        "_internal_application_name": PARAM_INTERNAL_APPLICATION_NAME,
-        "_internal_application_version": VERSION,
+        "internal_application_name": PARAM_INTERNAL_APPLICATION_NAME,
+        "internal_application_version": VERSION,
     }
     connection_parameters.update(connection_application_params)
 

snowflake/cli/plugins/connection/commands.py

@@ -9,11 +9,6 @@ from click.types import StringParamType
 from snowflake.cli.api.cli_global_context import cli_context
 from snowflake.cli.api.commands.flags import (
     PLAIN_PASSWORD_MSG,
-    ConnectionOption,
-    DiagAllowlistPathOption,
-    DiagLogPathOption,
-    EnableDiagOption,
-    MfaPasscodeOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyper
 from snowflake.cli.api.config import (
@@ -237,13 +232,8 @@ def add(
     )
 
 
-@app.command(requires_connection=False)
+@app.command(requires_connection=True)
 def test(
-    connection: str = ConnectionOption,
-    mfa_passcode: str = MfaPasscodeOption,
-    enable_diag: bool = EnableDiagOption,
-    diag_log_path: str = DiagLogPathOption,
-    diag_allowlist_path: str = DiagAllowlistPathOption,
     **options,
 ) -> CommandResult:
     """
@@ -272,8 +262,9 @@ def test(
     except ProgrammingError as err:
         raise ClickException(str(err))
 
+    conn_ctx = cli_context.connection_context
     result = {
-        "Connection name": connection,
+        "Connection name": conn_ctx.connection_name,
         "Status": "OK",
         "Host": conn.host,
         "Account": conn.account,
@@ -283,10 +274,10 @@ def test(
         "Warehouse": f'{conn.warehouse or "not set"}',
     }
 
-    if enable_diag:
+    if conn_ctx.enable_diag:
         result[
             "Diag Report Location"
-        ] = f"{diag_log_path}/SnowflakeConnectionTestReport.txt"
+        ] = f"{conn_ctx.diag_log_path}/SnowflakeConnectionTestReport.txt"
 
     return ObjectResult(result)
 

snowflake/cli/plugins/connection/util.py

@@ -37,7 +37,7 @@ def is_regionless_redirect(conn: SnowflakeConnection) -> bool:
         return cursor.fetchone()["REGIONLESS"].lower() == "true"
     except:
         # by default, assume that
-        log.exception("Cannot determine regionless redirect; assuming True.")
+        log.warning("Cannot determine regionless redirect; assuming True.")
         return True