snowflake-cli-labs 3.0.0rc4__py3-none-any.whl → 3.0.1__py3-none-any.whl

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

@@ -1,249 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-from __future__ import annotations
-
-import json
-import logging
-import os.path
-from pathlib import Path
-from typing import List, Optional
-
-import yaml
-from click import ClickException
-from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
-    find_manifest_file,
-    find_setup_script_file,
-)
-from snowflake.cli._plugins.nativeapp.codegen.artifact_processor import (
-    ArtifactProcessor,
-    is_python_file_artifact,
-)
-from snowflake.cli._plugins.nativeapp.codegen.sandbox import (
-    ExecutionEnvironmentType,
-    SandboxEnvBuilder,
-    execute_script_in_sandbox,
-)
-from snowflake.cli._plugins.stage.diff import to_stage_path
-from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import (
-    PathMapping,
-    ProcessorMapping,
-)
-
-DEFAULT_TIMEOUT = 30
-DRIVER_PATH = Path(__file__).parent / "setup_driver.py.source"
-
-log = logging.getLogger(__name__)
-
-
-def safe_set(d: dict, *keys: str, **kwargs) -> None:
-    """
-    Sets a value in a nested dictionary structure, creating intermediate dictionaries as needed.
-    Sample usage:
-
-      d = {}
-      safe_set(d, "a", "b", "c", value=42)
-
-    d is now:
-      {
-        "a": {
-          "b": {
-            "c": 42
-          }
-        }
-      }
-    """
-    curr = d
-    for k in keys[:-1]:
-        curr = curr.setdefault(k, {})
-
-    curr[keys[-1]] = kwargs.get("value")
-
-
-class NativeAppSetupProcessor(ArtifactProcessor):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def process(
-        self,
-        artifact_to_process: PathMapping,
-        processor_mapping: Optional[ProcessorMapping],
-        **kwargs,
-    ) -> None:
-        """
-        Processes a Python setup script and generates the corresponding SQL commands.
-        """
-        bundle_map = BundleMap(
-            project_root=self._bundle_ctx.project_root,
-            deploy_root=self._bundle_ctx.deploy_root,
-        )
-        bundle_map.add(artifact_to_process)
-
-        self._create_or_update_sandbox()
-
-        cc.step("Processing Python setup files")
-
-        files_to_process = []
-        for src_file, dest_file in bundle_map.all_mappings(
-            absolute=True, expand_directories=True, predicate=is_python_file_artifact
-        ):
-            cc.message(
-                f"Found Python setup file: {src_file.relative_to(self._bundle_ctx.project_root)}"
-            )
-            files_to_process.append(src_file)
-
-        result = self._execute_in_sandbox(files_to_process)
-        if not result:
-            return  # nothing to do
-
-        logs = result.get("logs", [])
-        for msg in logs:
-            log.debug(msg)
-
-        warnings = result.get("warnings", [])
-        for msg in warnings:
-            cc.warning(msg)
-
-        schema_version = result.get("schema_version")
-        if schema_version != "1":
-            raise ClickException(
-                f"Unsupported schema version returned from snowflake-app-python library: {schema_version}"
-            )
-
-        setup_script_mods = [
-            mod
-            for mod in result.get("modifications", [])
-            if mod.get("target") == "native_app:setup_script"
-        ]
-        if setup_script_mods:
-            self._edit_setup_sql(setup_script_mods)
-
-        manifest_mods = [
-            mod
-            for mod in result.get("modifications", [])
-            if mod.get("target") == "native_app:manifest"
-        ]
-        if manifest_mods:
-            self._edit_manifest(manifest_mods)
-
-    def _execute_in_sandbox(self, py_files: List[Path]) -> dict:
-        file_count = len(py_files)
-        cc.step(f"Processing {file_count} setup file{'s' if file_count > 1 else ''}")
-
-        manifest_path = find_manifest_file(deploy_root=self._bundle_ctx.deploy_root)
-
-        generated_root = self._bundle_ctx.generated_root
-        generated_root.mkdir(exist_ok=True, parents=True)
-
-        env_vars = {
-            "_SNOWFLAKE_CLI_PROJECT_PATH": str(self._bundle_ctx.project_root),
-            "_SNOWFLAKE_CLI_SETUP_FILES": os.pathsep.join(map(str, py_files)),
-            "_SNOWFLAKE_CLI_APP_NAME": str(self._bundle_ctx.package_name),
-            "_SNOWFLAKE_CLI_SQL_DEST_DIR": str(generated_root),
-            "_SNOWFLAKE_CLI_MANIFEST_PATH": str(manifest_path),
-        }
-
-        try:
-            result = execute_script_in_sandbox(
-                script_source=DRIVER_PATH.read_text(),
-                env_type=ExecutionEnvironmentType.VENV,
-                cwd=self._bundle_ctx.bundle_root,
-                timeout=DEFAULT_TIMEOUT,
-                path=self.sandbox_root,
-                env_vars=env_vars,
-            )
-        except Exception as e:
-            raise ClickException(
-                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}"
-            )
-
-    def _edit_setup_sql(self, modifications: List[dict]) -> None:
-        cc.step("Patching setup script")
-        setup_file_path = find_setup_script_file(
-            deploy_root=self._bundle_ctx.deploy_root
-        )
-
-        with self.edit_file(setup_file_path) as f:
-            prepended = []
-            appended = []
-
-            for mod in modifications:
-                for inst in mod.get("instructions", []):
-                    if inst.get("type") == "insert":
-                        default_loc = inst.get("default_location")
-                        if default_loc == "end":
-                            appended.append(self._setup_mod_instruction_to_sql(inst))
-                        elif default_loc == "start":
-                            prepended.append(self._setup_mod_instruction_to_sql(inst))
-
-            if prepended or appended:
-                f.edited_contents = "\n".join(prepended + [f.contents] + appended)
-
-    def _edit_manifest(self, modifications: List[dict]) -> None:
-        cc.step("Patching manifest")
-        manifest_path = find_manifest_file(deploy_root=self._bundle_ctx.deploy_root)
-
-        with self.edit_file(manifest_path) as f:
-            manifest = yaml.safe_load(f.contents)
-
-            for mod in modifications:
-                for inst in mod.get("instructions", []):
-                    if inst.get("type") == "set":
-                        payload = inst.get("payload")
-                        if payload:
-                            key = payload.get("key")
-                            value = payload.get("value")
-                            safe_set(manifest, *key.split("."), value=value)
-            f.edited_contents = yaml.safe_dump(manifest, sort_keys=False)
-
-    def _setup_mod_instruction_to_sql(self, mod_inst: dict) -> str:
-        payload = mod_inst.get("payload")
-        if not payload:
-            raise ClickException("Unsupported instruction received: no payload found")
-
-        payload_type = payload.get("type")
-        if payload_type == "execute immediate":
-            file_path = payload.get("file_path")
-            if file_path:
-                sql_file_path = self._bundle_ctx.generated_root / file_path
-                return f"EXECUTE IMMEDIATE FROM '/{to_stage_path(sql_file_path.relative_to(self._bundle_ctx.deploy_root))}';"
-
-        raise ClickException(f"Unsupported instruction type received: {payload_type}")
-
-    @property
-    def sandbox_root(self):
-        return self._bundle_ctx.bundle_root / "venv"
-
-    def _create_or_update_sandbox(self):
-        sandbox_root = self.sandbox_root
-        env_builder = SandboxEnvBuilder(sandbox_root, with_pip=True)
-        if sandbox_root.exists():
-            cc.step("Virtual environment found")
-        else:
-            cc.step(
-                f"Creating virtual environment in {sandbox_root.relative_to(self._bundle_ctx.project_root)}"
-            )
-        env_builder.ensure_created()
-
-        # Temporarily fetch the library from a location specified via env vars
-        env_builder.pip_install(os.environ["SNOWFLAKE_APP_PYTHON_LOC"])

snowflake/cli/_plugins/nativeapp/codegen/setup/setup_driver.py.source

@@ -1,59 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.
-
-import contextlib
-import os
-import sys
-from pathlib import Path
-
-import snowflake.app.context as ctx
-from snowflake.app.sql import SQLGenerator
-
-ctx.configure("project_path", os.environ.get("_SNOWFLAKE_CLI_PROJECT_PATH", None))
-ctx.configure("manifest_path", os.environ.get("_SNOWFLAKE_CLI_MANIFEST_PATH", None))
-ctx.configure("current_app_name", os.environ.get("_SNOWFLAKE_CLI_APP_NAME", None))
-ctx.configure("enable_sql_generation", True)
-
-__snowflake_internal_py_files = os.environ["_SNOWFLAKE_CLI_SETUP_FILES"].split(
-    os.pathsep
-)
-__snowflake_internal_sql_dest_dir = os.environ["_SNOWFLAKE_CLI_SQL_DEST_DIR"]
-
-try:
-    import importlib
-
-    with contextlib.redirect_stdout(None):
-        with contextlib.redirect_stderr(None):
-            for __snowflake_internal_py_file in __snowflake_internal_py_files:
-                __snowflake_internal_spec = importlib.util.spec_from_file_location(
-                    "<string>", __snowflake_internal_py_file
-                )
-                __snowflake_internal_module = importlib.util.module_from_spec(
-                    __snowflake_internal_spec
-                )
-                __snowflake_internal_spec.loader.exec_module(
-                    __snowflake_internal_module
-                )
-except Exception as exc:  # Catch any error
-    print("An exception occurred while executing file: ", exc, file=sys.stderr)
-    sys.exit(1)
-
-
-import json
-
-output_dir = Path(__snowflake_internal_sql_dest_dir)
-output_dir.mkdir(exist_ok=True, parents=True)
-path_mappings = SQLGenerator(dest_dir=output_dir).generate()
-
-print(json.dumps(path_mappings, default=str))

snowflake/cli/_plugins/nativeapp/codegen/snowpark/callback_source.py.jinja

@@ -1,181 +0,0 @@
-import contextlib
-import functools
-import inspect
-import sys
-from typing import Callable, Tuple
-
-try:
-    import snowflake.snowpark
-except ModuleNotFoundError as exc:
-    print(
-        "An exception occurred while importing snowflake-snowpark-python package: ",
-        exc,
-        file=sys.stderr,
-    )
-    sys.exit(1)
-
-__snowflake_internal_found_correct_version = hasattr(
-    snowflake.snowpark.context, "_is_execution_environment_sandboxed_for_client"
-) and hasattr(snowflake.snowpark.context, "_should_continue_registration")
-
-if not __snowflake_internal_found_correct_version:
-    print(
-        "Did not find the minimum required version for snowflake-snowpark-python package. Please upgrade to v1.15.0 or higher.",
-        file=sys.stderr,
-    )
-    sys.exit(1)
-
-__snowflake_global_collected_extension_fn_json = []
-
-def __snowflake_internal_create_extension_fn_registration_callback():
-    def __snowflake_internal_try_extract_lineno(extension_fn):
-        try:
-            return inspect.getsourcelines(extension_fn)[1]
-        except Exception:
-            return None
-
-    def __snowflake_internal_extract_extension_fn_name(extension_fn):
-        try:
-            import snowflake.snowpark._internal.utils as snowpark_utils
-
-            if hasattr(snowpark_utils, 'TEMP_OBJECT_NAME_PREFIX'):
-                if extension_fn.object_name.startswith(snowpark_utils.TEMP_OBJECT_NAME_PREFIX):
-                    # The object name is a generated one, don't use it
-                    return None
-
-        except Exception:
-            # ignore any exception and fall back to using the object name reported from Snowpark
-            pass
-
-        return extension_fn.object_name
-
-    def __snowflake_internal_create_package_list(extension_fn):
-        if not extension_fn.all_packages.strip():
-            return []
-        return [pkg_spec.strip() for pkg_spec in extension_fn.all_packages.split(",")]
-
-    def __snowflake_internal_make_extension_fn_signature(extension_fn):
-        # Try to fetch the original argument names from the extension function
-        try:
-            args_spec = inspect.getfullargspec(extension_fn.func)
-            original_arg_names = args_spec[0]
-            start_index = len(original_arg_names) - len(extension_fn.input_sql_types)
-            signature = []
-            defaults_start_index = len(original_arg_names) - len(args_spec.defaults or [])
-            for i in range(len(extension_fn.input_sql_types)):
-                arg = {
-                    'name': original_arg_names[start_index + i],
-                    'type': extension_fn.input_sql_types[i]
-                }
-                if i >= defaults_start_index:
-                    arg['default'] = args_spec.defaults[defaults_start_index + i]
-                signature.append(arg)
-
-            return signature
-        except Exception as e:
-            msg = str(e)
-            pass # ignore, we'll use the fallback strategy
-
-        # Failed to extract the original arguments through reflection, fall back to alternative approach
-        return [
-            {"name": input_arg.name, "type": input_type}
-            for (input_arg, input_type) in zip(extension_fn.input_args, extension_fn.input_sql_types)
-        ]
-
-    def __snowflake_internal_to_extension_fn_type(object_type):
-        if object_type.name == "AGGREGATE_FUNCTION":
-            return "aggregate function"
-        if object_type.name == "TABLE_FUNCTION":
-            return "table function"
-        return object_type.name.lower()
-
-    def __snowflake_internal_imports_union_to_str_type(raw_imports):
-        final_imports = []
-        if raw_imports:
-            for raw_import in raw_imports:
-                if isinstance(raw_import, str):
-                    final_imports.append(raw_import)
-                else:
-                    final_imports.append(raw_import[0])
-        return final_imports
-
-
-    def __snowflake_internal_extension_fn_to_json(extension_fn):
-        if not (isinstance(extension_fn.func, Callable) or isinstance(extension_fn.func, Tuple)):
-            return
-
-        if extension_fn.anonymous:
-            # unsupported, native application extension functions need to be explicitly named
-            return
-
-        # Collect basic properties of the extension function
-        extension_fn_json = {
-            "type": __snowflake_internal_to_extension_fn_type(extension_fn.object_type),
-            "lineno": __snowflake_internal_try_extract_lineno(extension_fn.func),
-            "name": __snowflake_internal_extract_extension_fn_name(extension_fn),
-            "handler": extension_fn.func.__name__,
-            "imports": __snowflake_internal_imports_union_to_str_type(extension_fn.raw_imports),
-            "packages": __snowflake_internal_create_package_list(extension_fn),
-            "runtime": extension_fn.runtime_version,
-            "returns": extension_fn.return_sql.upper().replace("RETURNS ", "").strip(),
-            "signature": __snowflake_internal_make_extension_fn_signature(extension_fn),
-            "external_access_integrations": extension_fn.external_access_integrations or [],
-            "secrets": extension_fn.secrets or {},
-        }
-
-        if extension_fn.object_type.name == "PROCEDURE" and extension_fn.execute_as is not None:
-            extension_fn_json['execute_as_caller'] = (extension_fn.execute_as == 'caller')
-
-        if extension_fn.native_app_params is not None:
-            schema = extension_fn.native_app_params.get("schema")
-            if schema is not None:
-                extension_fn_json["schema"] = schema
-            app_roles = extension_fn.native_app_params.get("application_roles")
-            if app_roles is not None:
-                extension_fn_json["application_roles"] = app_roles
-
-        return extension_fn_json
-
-    def __snowflake_internal_collect_extension_fn(
-        collected_extension_fn_json_list, extension_function_properties
-    ):
-        extension_fn_json = __snowflake_internal_extension_fn_to_json(extension_function_properties)
-        if extension_fn_json: # Do not append if extension_fn_json is None
-            collected_extension_fn_json_list.append(extension_fn_json)
-        return False
-
-    return functools.partial(
-        __snowflake_internal_collect_extension_fn,
-        __snowflake_global_collected_extension_fn_json,
-    )
-
-snowflake.snowpark.context._is_execution_environment_sandboxed_for_client = (  # noqa: SLF001
-    True
-)
-snowflake.snowpark.context._should_continue_registration = (  # noqa: SLF001
-    __snowflake_internal_create_extension_fn_registration_callback()
-)
-snowflake.snowpark.session._is_execution_environment_sandboxed_for_client = (  # noqa: SLF001
-    True
-)
-
-for global_key in list(globals().keys()):
-    if global_key.startswith("__snowflake_internal"):
-        del globals()[global_key]
-
-del globals()["global_key"] # make sure to clean up the loop variable as well
-
-try:
-    import importlib
-    with contextlib.redirect_stdout(None):
-        with contextlib.redirect_stderr(None):
-            __snowflake_internal_spec = importlib.util.spec_from_file_location("<string>", r"{{py_file}}")
-            __snowflake_internal_module = importlib.util.module_from_spec(__snowflake_internal_spec)
-            __snowflake_internal_spec.loader.exec_module(__snowflake_internal_module)
-except Exception as exc:  # Catch any error
-    print("An exception occurred while executing file: ", exc, file=sys.stderr)
-    sys.exit(1)
-
-
-import json
-print(json.dumps(__snowflake_global_collected_extension_fn_json))