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

snowflake/cli/_plugins/git/manager.py

@@ -26,6 +26,7 @@ from snowflake.cli._plugins.stage.manager import (
     UserStagePathParts,
 )
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.stage_path import StagePath
 from snowflake.connector.cursor import SnowflakeCursor
 
 # Replace magic numbers with constants
@@ -78,14 +79,18 @@ class GitStagePathParts(StagePathParts):
 
 
 class GitManager(StageManager):
+    @staticmethod
+    def build_path(stage_path: str) -> StagePathParts:
+        return StagePath.from_git_str(stage_path)
+
     def show_branches(self, repo_name: str, like: str) -> SnowflakeCursor:
-        return self._execute_query(f"show git branches like '{like}' in {repo_name}")
+        return self.execute_query(f"show git branches like '{like}' in {repo_name}")
 
     def show_tags(self, repo_name: str, like: str) -> SnowflakeCursor:
-        return self._execute_query(f"show git tags like '{like}' in {repo_name}")
+        return self.execute_query(f"show git tags like '{like}' in {repo_name}")
 
     def fetch(self, fqn: FQN) -> SnowflakeCursor:
-        return self._execute_query(f"alter git repository {fqn} fetch")
+        return self.execute_query(f"alter git repository {fqn} fetch")
 
     def create(
         self, repo_name: FQN, api_integration: str, url: str, secret: str
@@ -99,7 +104,7 @@ class GitManager(StageManager):
         )
         if secret is not None:
             query += f"git_credentials = {secret}\n"
-        return self._execute_query(query)
+        return self.execute_query(query)
 
     @staticmethod
     def get_stage_from_path(path: str):

snowflake/cli/_plugins/nativeapp/artifacts.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 
 import itertools
 import os
+from collections import namedtuple
 from pathlib import Path
 from textwrap import dedent
 from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union
@@ -164,7 +165,7 @@ class _ArtifactPathMap:
         if src_is_dir:
             # mark all subdirectories of this source as directories so that we can
             # detect accidental clobbering
-            for (root, _, files) in os.walk(absolute_src, followlinks=True):
+            for root, _, files in os.walk(absolute_src, followlinks=True):
                 canonical_subdir = Path(root).relative_to(absolute_src)
                 canonical_dest_subdir = dest / canonical_subdir
                 self._update_dest_is_dir(canonical_dest_subdir, is_dir=True)
@@ -225,9 +226,7 @@ class _ArtifactPathMap:
 
         current_is_dir = self._dest_is_dir.get(dest, None)
         if current_is_dir is not None and current_is_dir != is_dir:
-            raise ArtifactError(
-                "Conflicting type for destination path: {canonical_dest}"
-            )
+            raise ArtifactError(f"Conflicting type for destination path: {dest}")
 
         parent = dest.parent
         if parent != dest:
@@ -240,9 +239,21 @@ class BundleMap:
     """
     Computes the mapping between project directory artifacts (aka source artifacts) to their deploy root location
     (aka destination artifact). This information is primarily used when bundling a native applications project.
+
+    :param project_root: The root directory of the project and base for all relative paths. Must be an absolute path.
+    :param deploy_root: The directory where artifacts should be copied to. Must be an absolute path.
     """
 
     def __init__(self, *, project_root: Path, deploy_root: Path):
+        # If a relative path ends up here, it's a bug in the app and can lead to other
+        # subtle bugs as paths would be resolved relative to the current working directory.
+        assert (
+            project_root.is_absolute()
+        ), f"Project root {project_root} must be an absolute path."
+        assert (
+            deploy_root.is_absolute()
+        ), f"Deploy root {deploy_root} must be an absolute path."
+
         self._project_root: Path = resolve_without_follow(project_root)
         self._deploy_root: Path = resolve_without_follow(deploy_root)
         self._artifact_map = _ArtifactPathMap(project_root=self._project_root)
@@ -373,7 +384,7 @@ class BundleMap:
         if absolute_src.is_dir() and expand_directories:
             # both src and dest are directories, and expanding directories was requested. Traverse src, and map each
             # file to the dest directory
-            for (root, subdirs, files) in os.walk(absolute_src, followlinks=True):
+            for root, subdirs, files in os.walk(absolute_src, followlinks=True):
                 relative_root = Path(root).relative_to(absolute_src)
                 for name in itertools.chain(subdirs, files):
                     src_file_for_output = src_for_output / relative_root / name
@@ -664,16 +675,27 @@ def build_bundle(
     if resolved_root.exists():
         delete(resolved_root)
 
-    bundle_map = BundleMap(project_root=project_root, deploy_root=deploy_root)
-    for artifact in artifacts:
-        bundle_map.add(artifact)
-
+    bundle_map = bundle_artifacts(project_root, deploy_root, artifacts)
     if bundle_map.is_empty():
         raise ArtifactError(
             "No artifacts mapping found in project definition, nothing to do."
         )
 
-    for (absolute_src, absolute_dest) in bundle_map.all_mappings(
+    return bundle_map
+
+
+def bundle_artifacts(
+    project_root: Path, deploy_root: Path, artifacts: list[PathMapping]
+):
+    """
+    Internal implementation of build_bundle that assumes
+    that validation is being done by the caller.
+    """
+    bundle_map = BundleMap(project_root=project_root, deploy_root=deploy_root)
+    for artifact in artifacts:
+        bundle_map.add(artifact)
+
+    for absolute_src, absolute_dest in bundle_map.all_mappings(
         absolute=True, expand_directories=False
     ):
         symlink_or_copy(absolute_src, absolute_dest, deploy_root=deploy_root)
@@ -706,7 +728,7 @@ def find_and_read_manifest_file(deploy_root: Path) -> Dict[str, Any]:
         "r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
     ) as file:
         manifest_content = safe_load(file.read())
-    return manifest_content
+    return manifest_content or {}
 
 
 def find_setup_script_file(deploy_root: Path) -> Path:
@@ -733,19 +755,24 @@ def find_setup_script_file(deploy_root: Path) -> Path:
         )
 
 
+VersionInfo = namedtuple("VersionInfo", ["version_name", "patch_number", "label"])
+
+
 def find_version_info_in_manifest_file(
     deploy_root: Path,
-) -> Tuple[Optional[str], Optional[int]]:
+) -> VersionInfo:
     """
     Find version and patch, if available, in the manifest.yml file.
     """
     name_field = "name"
     patch_field = "patch"
+    label_field = "label"
 
     manifest_content = find_and_read_manifest_file(deploy_root=deploy_root)
 
     version_name: Optional[str] = None
     patch_number: Optional[int] = None
+    label: Optional[str] = None
 
     version_info = manifest_content.get("version", None)
     if version_info:
@@ -753,5 +780,42 @@ def find_version_info_in_manifest_file(
             version_name = to_identifier(str(version_info[name_field]))
         if patch_field in version_info:
             patch_number = int(version_info[patch_field])
+        if label_field in version_info:
+            label = str(version_info[label_field])
+
+    return VersionInfo(version_name, patch_number, label)
+
+
+def find_events_definitions_in_manifest_file(
+    deploy_root: Path,
+) -> List[Dict[str, str]]:
+    """
+    Find events definitions, if available, in the manifest.yml file.
+    Events definitions can be found under this section in the manifest.yml file:
+
+    configuration:
+        telemetry_event_definitions:
+            - type: ERRORS_AND_WARNINGS
+              sharing: MANDATORY
+            - type: DEBUG_LOGS
+              sharing: OPTIONAL
+    """
+    manifest_content = find_and_read_manifest_file(deploy_root=deploy_root)
+
+    configuration_section = manifest_content.get("configuration", None)
+    events_definitions = []
+    if configuration_section and isinstance(configuration_section, dict):
+        telemetry_section = configuration_section.get("telemetry_event_definitions", [])
+        if isinstance(telemetry_section, list):
+            for event in telemetry_section:
+                if isinstance(event, dict):
+                    event_type = event.get("type", "")
+                    events_definitions.append(
+                        {
+                            "name": f"SNOWFLAKE${event_type}",
+                            "type": event_type,
+                            "sharing": event.get("sharing", ""),
+                        }
+                    )
 
-    return version_name, patch_number
+    return events_definitions

snowflake/cli/_plugins/nativeapp/codegen/artifact_processor.py

@@ -36,7 +36,7 @@ class UnsupportedArtifactProcessorError(ClickException):
 
 
 def is_python_file_artifact(src: Path, _: Path):
-    """Determines whether the provided source path is an existing python file."""
+    """Determines whether the provided source path is an existing Python file."""
     return src.is_file() and src.suffix == ".py"
 
 

snowflake/cli/_plugins/nativeapp/codegen/compiler.py

@@ -65,10 +65,17 @@ class NativeAppCompiler:
         self,
         bundle_ctx: BundleContext,
     ):
+        self._assert_absolute_paths(bundle_ctx)
         self._bundle_ctx = bundle_ctx
         # dictionary of all processors created and shared between different artifact objects.
         self.cached_processors: Dict[str, ArtifactProcessor] = {}
 
+    @staticmethod
+    def _assert_absolute_paths(bundle_ctx: BundleContext):
+        for name in ["Project", "Deploy", "Bundle", "Generated"]:
+            path = getattr(bundle_ctx, f"{name.lower()}_root")
+            assert path.is_absolute(), f"{name} root {path} must be an absolute path."
+
     def compile_artifacts(self):
         """
         Go through every artifact object in the project definition of a native app, and execute processors in order of specification for each of the artifact object.

snowflake/cli/_plugins/nativeapp/codegen/sandbox.py

@@ -29,10 +29,10 @@ EnvVars = Mapping[str, str]  # Only support str -> str for cross-platform compat
 
 
 class SandboxExecutionError(ClickException):
-    """An error occurred while executing a python script."""
+    """An error occurred while executing a Python script."""
 
     def __init__(self, error: str):
-        super().__init__(f"Failed to execute python script. {error}")
+        super().__init__(f"Failed to execute Python script. {error}")
 
 
 def _get_active_venv_dir() -> Optional[str]:
@@ -63,7 +63,7 @@ def _execute_python_interpreter(
     env_vars: Optional[EnvVars],
 ) -> subprocess.CompletedProcess:
     if not python_executable:
-        raise SandboxExecutionError("No python executable found")
+        raise SandboxExecutionError("No Python executable found")
 
     if isinstance(python_executable, str) or isinstance(python_executable, Path):
         args = [python_executable]
@@ -106,7 +106,7 @@ def _execute_in_venv(
             f"venv path must be an existing directory: {resolved_venv_path}"
         )
 
-    # find the python interpreter for this environment. There is no need to activate environment prior to invoking the
+    # find the Python interpreter for this environment. There is no need to activate environment prior to invoking the
     # interpreter, as venv maintains the invariant that invoking any of the scripts will set up the virtual environment
     # correctly. activation scripts are only used for convenience in interactive shells.
     if _is_ms_windows():
@@ -116,7 +116,7 @@ def _execute_in_venv(
 
     if not python_executable.is_file():
         raise SandboxExecutionError(
-            f"No venv python executable found: {resolved_venv_path}"
+            f"No venv Python executable found: {resolved_venv_path}"
         )
 
     return _execute_python_interpreter(
@@ -189,14 +189,14 @@ def execute_script_in_sandbox(
     **kwargs,
 ) -> subprocess.CompletedProcess:
     """
-    Executes a python script in a sandboxed environment, and returns its output. The script is executed in a different
+    Executes a Python script in a sandboxed environment, and returns its output. The script is executed in a different
     process. The execution environment is determined by the `env_type` argument. By default, the logic will attempt
     to auto-detect the correct environment by looking for an active venv or conda environment. If none can be found, it
-    will use the system's default python executable, as determined by the user's path. As a last resort, the current
-    python execution environment will be used (still in a subprocess).
+    will use the system's default Python executable, as determined by the user's path. As a last resort, the current
+    Python execution environment will be used (still in a subprocess).
 
     Parameters:
-        script_source (str): The python script to be executed, as a string.
+        script_source (str): The Python script to be executed, as a string.
         env_type: The type of execution environment to use (default: ExecutionEnvironmentType.AUTO_DETECT).
         cwd (Optional[Union[str, Path]]): An optional path to use as the current directory when executing the script.
         timeout (Optional[int]): An optional timeout in seconds when executing the script. Defaults to no timeout.
@@ -248,7 +248,7 @@ def execute_script_in_sandbox(
 class SandboxEnvBuilder(EnvBuilder):
     """
     A virtual environment builder that can be used to build an environment suitable for
-    executing user-provided python scripts in an isolated sandbox.
+    executing user-provided Python scripts in an isolated sandbox.
     """
 
     def __init__(self, path: Path, **kwargs) -> None:

snowflake/cli/_plugins/nativeapp/codegen/setup/native_app_setup_processor.py

@@ -167,14 +167,14 @@ class NativeAppSetupProcessor(ArtifactProcessor):
             )
         except Exception as e:
             raise ClickException(
-                f"Exception while executing python setup script logic: {e}"
+                f"Exception while executing Python setup script logic: {e}"
             )
 
         if result.returncode == 0:
             return json.loads(result.stdout)
         else:
             raise ClickException(
-                f"Failed to execute python setup script logic: {result.stderr}"
+                f"Failed to execute Python setup script logic: {result.stderr}"
             )
 
     def _edit_setup_sql(self, modifications: List[dict]) -> None:

snowflake/cli/_plugins/nativeapp/codegen/snowpark/extension_function_utils.py

@@ -194,7 +194,7 @@ def deannotate_module_source(
 
     module_lines = module_source.splitlines()
     for definition in definitions:
-        # Comment out all decorators. As per the python grammar, decorators must be terminated by a
+        # Comment out all decorators. As per the Python grammar, decorators must be terminated by a
         # new line, so the line ranges can't overlap.
         for decorator in definition.decorator_list:
             decorator_id = _get_decorator_id(decorator)

snowflake/cli/_plugins/nativeapp/codegen/snowpark/python_processor.py

@@ -132,12 +132,12 @@ def _execute_in_sandbox(
         )
     except SandboxExecutionError as sdbx_err:
         cc.warning(
-            f"Could not fetch Snowpark objects from {py_file} due to {sdbx_err}, continuing execution for the rest of the python files."
+            f"Could not fetch Snowpark objects from {py_file} due to {sdbx_err}, continuing execution for the rest of the Python files."
         )
         return None
     except Exception as err:
         cc.warning(
-            f"Could not fetch Snowpark objects from {py_file} due to {err}, continuing execution for the rest of the python files."
+            f"Could not fetch Snowpark objects from {py_file} due to {err}, continuing execution for the rest of the Python files."
         )
         return None
 
@@ -145,22 +145,22 @@ def _execute_in_sandbox(
         cc.warning(
             f"Could not fetch Snowpark objects from {py_file} due to the following error:\n {completed_process.stderr}"
         )
-        cc.warning("Continuing execution for the rest of the python files.")
+        cc.warning("Continuing execution for the rest of the Python files.")
         return None
 
     try:
         return json.loads(completed_process.stdout)
     except Exception as exc:
         cc.warning(
-            f"Could not load JSON into python due to the following exception: {exc}"
+            f"Could not load JSON into Python due to the following exception: {exc}"
         )
-        cc.warning(f"Continuing execution for the rest of the python files.")
+        cc.warning(f"Continuing execution for the rest of the Python files.")
         return None
 
 
 class SnowparkAnnotationProcessor(ArtifactProcessor):
     """
-    Built-in Processor to discover Snowpark-annotated objects in a given set of python files,
+    Built-in Processor to discover Snowpark-annotated objects in a given set of Python files,
     and generate SQL code for creation of extension functions based on those discovered objects.
     """
 
@@ -174,7 +174,7 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
         **kwargs,
     ) -> None:
         """
-        Collects code annotations from Snowpark python files containing extension functions and augments the existing
+        Collects code annotations from Snowpark Python files containing extension functions and augments the existing
         setup script with generated SQL that registers these functions.
         """
 
@@ -360,7 +360,7 @@ class SnowparkAnnotationProcessor(ArtifactProcessor):
 
     def generate_new_sql_file_name(self, py_file: Path) -> Path:
         """
-        Generates a SQL filename for the generated root from the python file, and creates its parent directories.
+        Generates a SQL filename for the generated root from the Python file, and creates its parent directories.
         """
         relative_py_file = py_file.relative_to(self._bundle_ctx.deploy_root)
         sql_file = Path(

snowflake/cli/_plugins/nativeapp/codegen/templates/templates_processor.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
+from typing import Any, Optional
 
 import jinja2
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
@@ -49,7 +49,9 @@ class TemplatesProcessor(ArtifactProcessor):
     Processor class to perform template expansion on all relevant artifacts (specified in the project definition file).
     """
 
-    def expand_templates_in_file(self, src: Path, dest: Path) -> None:
+    def expand_templates_in_file(
+        self, src: Path, dest: Path, template_context: dict[str, Any] | None = None
+    ) -> None:
         """
         Expand templates in the file.
         """
@@ -74,7 +76,7 @@ class TemplatesProcessor(ArtifactProcessor):
                         else get_client_side_jinja_env()
                     )
                     expanded_template = jinja_env.from_string(file.contents).render(
-                        get_cli_context().template_context
+                        template_context or get_cli_context().template_context
                     )
 
                 # For now, we are printing the source file path in the error message