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

snowflake/cli/_plugins/nativeapp/v2_conversions/{v2_to_v1_decorator.py → compat.py}

@@ -29,14 +29,40 @@ from snowflake.cli.api.cli_global_context import (
     get_cli_context_manager,
 )
 from snowflake.cli.api.commands.decorators import _options_decorator_factory
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
+)
 from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
 from snowflake.cli.api.project.schemas.project_definition import (
     DefinitionV11,
     DefinitionV20,
+    ProjectDefinition,
+    ProjectDefinitionV1,
 )
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.utils.definition_rendering import render_definition_template
 
+APP_AND_PACKAGE_OPTIONS = [
+    inspect.Parameter(
+        "package_entity_id",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=typer.Option(
+            default="",
+            help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
+        ),
+    ),
+    inspect.Parameter(
+        "app_entity_id",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=typer.Option(
+            default="",
+            help="The ID of the application entity on which to operate when definition_version is 2 or higher.",
+        ),
+    ),
+]
+
 
 def _convert_v2_artifact_to_v1_dict(
     v2_artifact: Union[PathMapping, str]
@@ -58,45 +84,12 @@ def _pdf_v2_to_v1(
 ) -> DefinitionV11:
     pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
 
-    # Determine the application entity to convert, there can be zero or one
-    app_definition = find_entity(
-        v2_definition,
-        ApplicationEntityModel,
-        app_entity_id,
-        disambiguation_option="--app-entity-id",
-        required=app_required,
-    )
-
-    # Infer or verify the package if we have an app entity to convert
-    if app_definition:
-        target_package = app_definition.from_.target
-        if package_entity_id:
-            # If the user specified a package entity ID,
-            # check that the app entity targets the user-specified package entity
-            # if the app entity is used by the command being run
-            if target_package != package_entity_id and app_required:
-                raise ClickException(
-                    f"The application entity {app_definition.entity_id} does not "
-                    f"target the application package entity {package_entity_id}. Either"
-                    f"use --package-entity-id {target_package} to target the correct package entity, "
-                    f"or omit the --package-entity-id flag to automatically use the package entity "
-                    f"that the application entity targets."
-                )
-        elif target_package in v2_definition.get_entities_by_type(
-            ApplicationPackageEntityModel.get_type()
-        ):
-            # If the user didn't target a specific package entity, use the one the app entity targets
-            package_entity_id = target_package
-
-    # Determine the package entity to convert, there must be one
-    app_package_definition = find_entity(
-        v2_definition,
-        ApplicationPackageEntityModel,
-        package_entity_id,
-        disambiguation_option="--package-entity-id",
-        required=True,
+    app_definition, app_package_definition = _find_app_and_package_entities(
+        v2_definition=v2_definition,
+        package_entity_id=package_entity_id,
+        app_entity_id=app_entity_id,
+        app_required=app_required,
     )
-    assert app_package_definition is not None  # satisfy mypy
 
     # NativeApp
     if app_definition and app_definition.fqn.identifier:
@@ -156,6 +149,52 @@ def _pdf_v2_to_v1(
     return result.project_definition
 
 
+def _find_app_and_package_entities(
+    v2_definition: DefinitionV20,
+    package_entity_id: str,
+    app_entity_id: str,
+    app_required: bool,
+):
+    # Determine the application entity to convert, there can be zero or one
+    app_definition = find_entity(
+        v2_definition,
+        ApplicationEntityModel,
+        app_entity_id,
+        disambiguation_option="--app-entity-id",
+        required=app_required,
+    )
+    # Infer or verify the package if we have an app entity to convert
+    if app_definition:
+        target_package = app_definition.from_.target
+        if package_entity_id:
+            # If the user specified a package entity ID,
+            # check that the app entity targets the user-specified package entity
+            # if the app entity is used by the command being run
+            if target_package != package_entity_id and app_required:
+                raise ClickException(
+                    f"The application entity {app_definition.entity_id} does not "
+                    f"target the application package entity {package_entity_id}. Either"
+                    f"use --package-entity-id {target_package} to target the correct package entity, "
+                    f"or omit the --package-entity-id flag to automatically use the package entity "
+                    f"that the application entity targets."
+                )
+        elif target_package in v2_definition.get_entities_by_type(
+            ApplicationPackageEntityModel.get_type()
+        ):
+            # If the user didn't target a specific package entity, use the one the app entity targets
+            package_entity_id = target_package
+    # Determine the package entity to convert, there must be one
+    app_package_definition = find_entity(
+        v2_definition,
+        ApplicationPackageEntityModel,
+        package_entity_id,
+        disambiguation_option="--package-entity-id",
+        required=True,
+    )
+    assert app_package_definition is not None  # satisfy mypy
+    return app_definition, app_package_definition
+
+
 T = TypeVar("T", bound=EntityModelBase)
 
 
@@ -209,54 +248,74 @@ def find_entity(
     return entity
 
 
-def nativeapp_definition_v2_to_v1(*, app_required: bool = False):
+def force_project_definition_v2(
+    *, single_app_and_package: bool = True, app_required: bool = False
+):
     """
-    A command decorator that attempts to automatically convert a native app project from
-    definition v2 to v1.1. Assumes with_project_definition() has already been called.
-    The definition object in CliGlobalContext will be replaced with the converted object.
-    Exactly one application package entity type is expected, and up to one application
-    entity type is expected.
+    A command decorator that forces the project definition to be converted to v2.
+
+    If a v1 definition is found, it is converted to v2 in-memory and the global context
+    is updated with the new definition object.
+
+    If a v2 definition is already found, it is used as-is, optionally limiting the number
+    of application and package entities to one each (true by default).
+
+    Assumes with_project_definition() has already been called.
     """
 
     def decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
-            original_pdf: Optional[DefinitionV20] = get_cli_context().project_definition
+            cli_context = get_cli_context()
+            original_pdf: Optional[ProjectDefinition] = cli_context.project_definition
             if not original_pdf:
                 raise ValueError(
-                    "Project definition could not be found. The nativeapp_definition_v2_to_v1 command decorator assumes with_project_definition() was called before it."
+                    "Project definition could not be found. "
+                    "The single_app_and_package() command decorator assumes "
+                    "that with_project_definition() was called before it."
+                )
+            if isinstance(original_pdf, ProjectDefinitionV1):
+                pdfv2 = convert_project_definition_to_v2(
+                    cli_context.project_root,
+                    original_pdf,
+                    accept_templates=False,  # Templates should all be rendered by now
+                    template_context=None,  # Force inclusion of all fields
+                    in_memory=True,  # Convert the definition knowing it will be used immediately
                 )
-            if original_pdf.definition_version == "2":
+                for entity_id, entity in pdfv2.entities.items():
+                    # Backfill kwargs for the command to use,
+                    # there can only be one entity of each type
+                    is_package = isinstance(entity, ApplicationPackageEntityModel)
+                    key = "package_entity_id" if is_package else "app_entity_id"
+                    kwargs[key] = entity_id
+
+                cm = get_cli_context_manager()
+
+                # Override the project definition so that the command operates on the new entities
+                cm.override_project_definition = pdfv2
+            elif single_app_and_package:
                 package_entity_id = kwargs.get("package_entity_id", "")
                 app_entity_id = kwargs.get("app_entity_id", "")
-                pdfv1 = _pdf_v2_to_v1(
+                app_definition, app_package_definition = _find_app_and_package_entities(
                     original_pdf, package_entity_id, app_entity_id, app_required
                 )
-                get_cli_context_manager().override_project_definition = pdfv1
+                entities_to_keep = {app_package_definition.entity_id}
+                kwargs["package_entity_id"] = app_package_definition.entity_id
+                if app_definition:
+                    entities_to_keep.add(app_definition.entity_id)
+                    kwargs["app_entity_id"] = app_definition.entity_id
+                for entity_id in list(original_pdf.entities):
+                    if entity_id not in entities_to_keep:
+                        # This happens after templates are rendered,
+                        # so we can safely remove the entity
+                        del original_pdf.entities[entity_id]
             return func(*args, **kwargs)
 
-        return _options_decorator_factory(
-            wrapper,
-            additional_options=[
-                inspect.Parameter(
-                    "package_entity_id",
-                    inspect.Parameter.KEYWORD_ONLY,
-                    annotation=Optional[str],
-                    default=typer.Option(
-                        default="",
-                        help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
-                    ),
-                ),
-                inspect.Parameter(
-                    "app_entity_id",
-                    inspect.Parameter.KEYWORD_ONLY,
-                    annotation=Optional[str],
-                    default=typer.Option(
-                        default="",
-                        help="The ID of the application entity on which to operate when definition_version is 2 or higher.",
-                    ),
-                ),
-            ],
-        )
+        if single_app_and_package:
+            # Add the --app-entity-id and --package-entity-id options to the command
+            return _options_decorator_factory(
+                wrapper, additional_options=APP_AND_PACKAGE_OPTIONS
+            )
+        return wrapper
 
     return decorator

snowflake/cli/_plugins/nativeapp/version/commands.py

@@ -20,21 +20,17 @@ from typing import Optional
 import typer
 from click import MissingParameter
 from snowflake.cli._plugins.nativeapp.common_flags import ForceOption, InteractiveOption
-from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
-from snowflake.cli._plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
-    nativeapp_definition_v2_to_v1,
-)
-from snowflake.cli._plugins.nativeapp.version.version_processor import (
-    NativeAppVersionCreateProcessor,
-    NativeAppVersionDropProcessor,
+from snowflake.cli._plugins.nativeapp.v2_conversions.compat import (
+    force_project_definition_v2,
 )
+from snowflake.cli._plugins.workspace.manager import WorkspaceManager
 from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.commands.decorators import (
     with_project_definition,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.entities.common import EntityActions
 from snowflake.cli.api.output.types import CommandResult, MessageResult, QueryResult
-from snowflake.cli.api.project.project_verification import assert_project_type
 
 app = SnowTyperFactory(
     name="version",
@@ -46,7 +42,7 @@ log = logging.getLogger(__name__)
 
 @app.command(requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def create(
     version: Optional[str] = typer.Argument(
         None,
@@ -71,18 +67,18 @@ def create(
     """
     Adds a new patch to the provided version defined in your application package. If the version does not exist, creates a version with patch 0.
     """
-
-    assert_project_type("native_app")
-
     if version is None and patch is not None:
         raise MissingParameter("Cannot provide a patch without version!")
 
     cli_context = get_cli_context()
-    processor = NativeAppVersionCreateProcessor(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    processor.process(
+    package_id = options["package_entity_id"]
+    ws.perform_action(
+        package_id,
+        EntityActions.VERSION_CREATE,
         version=version,
         patch=patch,
         force=force,
@@ -94,28 +90,29 @@ def create(
 
 @app.command("list", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def version_list(
     **options,
 ) -> CommandResult:
     """
     Lists all versions defined in an application package.
     """
-
-    assert_project_type("native_app")
-
     cli_context = get_cli_context()
-    processor = NativeAppRunProcessor(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    cursor = processor.get_all_existing_versions()
+    package_id = options["package_entity_id"]
+    cursor = ws.perform_action(
+        package_id,
+        EntityActions.VERSION_LIST,
+    )
     return QueryResult(cursor)
 
 
 @app.command(requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1()
+@force_project_definition_v2()
 def drop(
     version: Optional[str] = typer.Argument(
         None,
@@ -129,13 +126,17 @@ def drop(
     Drops a version defined in your application package. Versions can either be passed in as an argument to the command or read from the `manifest.yml` file.
     Dropping patches is not allowed.
     """
-
-    assert_project_type("native_app")
-
     cli_context = get_cli_context()
-    processor = NativeAppVersionDropProcessor(
-        project_definition=cli_context.project_definition.native_app,
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
         project_root=cli_context.project_root,
     )
-    processor.process(version, force, interactive)
+    package_id = options["package_entity_id"]
+    ws.perform_action(
+        package_id,
+        EntityActions.VERSION_DROP,
+        version=version,
+        interactive=interactive,
+        force=force,
+    )
     return MessageResult(f"Version drop is now complete.")

snowflake/cli/_plugins/nativeapp/version/version_processor.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Optional
 
 from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
@@ -24,52 +24,10 @@ from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
 )
-from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
 
 
-class NativeAppVersionCreateProcessor(NativeAppRunProcessor):
-    def __init__(self, project_definition: Dict, project_root: Path):
-        super().__init__(project_definition, project_root)
-
-    def process(
-        self,
-        version: Optional[str],
-        patch: Optional[int],
-        force: bool,
-        interactive: bool,
-        skip_git_check: bool,
-        *args,
-        **kwargs,
-    ):
-        return ApplicationPackageEntity.version_create(
-            console=cc,
-            project_root=self.project_root,
-            deploy_root=self.deploy_root,
-            bundle_root=self.bundle_root,
-            generated_root=self.generated_root,
-            artifacts=self.artifacts,
-            package_name=self.package_name,
-            package_role=self.package_role,
-            package_distribution=self.package_distribution,
-            prune=True,
-            recursive=True,
-            paths=None,
-            print_diff=True,
-            validate=True,
-            stage_fqn=self.stage_fqn,
-            package_warehouse=self.package_warehouse,
-            post_deploy_hooks=self.package_post_deploy_hooks,
-            package_scripts=self.package_scripts,
-            version=version,
-            patch=patch,
-            force=force,
-            interactive=interactive,
-            skip_git_check=skip_git_check,
-        )
-
-
 class NativeAppVersionDropProcessor(NativeAppManager, NativeAppCommandProcessor):
     def __init__(self, project_definition: NativeApp, project_root: Path):
         super().__init__(project_definition, project_root)

snowflake/cli/_plugins/snowpark/common.py

@@ -158,10 +158,8 @@ def _check_if_replace_is_required(
         )
         return True
 
-    if (
-        resource_json["handler"].lower() != entity.handler.lower()
-        or _sql_to_python_return_type_mapper(resource_json["returns"]).lower()
-        != entity.returns.lower()
+    if resource_json["handler"].lower() != entity.handler.lower() or not same_type(
+        resource_json["returns"], entity.returns
     ):
         log.info(
             "Return type or handler types do not match. Replacing the %s.", object_type
@@ -216,24 +214,68 @@ def _snowflake_dependencies_differ(
     return _standardize(old_dependencies) != _standardize(new_dependencies)
 
 
-def _sql_to_python_return_type_mapper(resource_return_type: str) -> str:
-    """
-    Some of the Python data types get converted to SQL types, when function/procedure is created.
-    So, to properly compare types, we use mapping based on:
-    https://docs.snowflake.com/en/developer-guide/udf-stored-procedure-data-type-mapping#sql-python-data-type-mappings
+def same_type(sf_type: str, local_type: str) -> bool:
+    sf_type, local_type = sf_type.upper(), local_type.upper()
 
-    Mind you, this only applies to cases, in which Snowflake accepts Python type as return.
-    Ie. if function returns list, it has to be declared as 'array' during creation,
-    therefore any conversion is not necessary
-    """
+    # 1. Types are equal out of the box
+    if sf_type == local_type:
+        return True
+
+    # 2. Local type is alias for Snowflake type
+    local_type = user_to_sql_type_mapper(local_type).upper()
+    if sf_type == local_type:
+        return True
+
+    # 3. Local type is a subset of Snowflake type, e.g. VARCHAR(N) == VARCHAR
+    # We solved for local VARCHAR(N) in point 1 & 2 as those are explicit types
+    if sf_type.startswith(local_type):
+        return True
+
+    # 4. Snowflake types is subset of local type
+    if local_type.startswith(sf_type):
+        return True
+
+    return False
+
+
+def user_to_sql_type_mapper(user_provided_type: str) -> str:
     mapping = {
-        "number(38,0)": "int",
-        "timestamp_ntz(9)": "datetime",
-        "timestamp_tz(9)": "datetime",
-        "varchar(16777216)": "string",
+        ("VARCHAR", "(16777216)"): ("CHAR", "TEXT", "STRING"),
+        ("BINARY", "(8388608)"): ("BINARY", "VARBINARY"),
+        ("NUMBER", "(38,0)"): (
+            "NUMBER",
+            "DECIMAL",
+            "INT",
+            "INTEGER",
+            "BIGINT",
+            "SMALLINT",
+            "TINYINT",
+            "BYTEINT",
+        ),
+        ("FLOAT", ""): (
+            "FLOAT",
+            "DOUBLE",
+            "DOUBLE PRECISION",
+            "REAL",
+            "FLOAT",
+            "FLOAT4",
+            "FLOAT8",
+        ),
+        ("TIMESTAMP_NTZ", ""): ("TIMESTAMP_NTZ", "TIMESTAMPNTZ", "DATETIME"),
+        ("TIMESTAMP_LTZ", ""): ("TIMESTAMP_LTZ", "TIMESTAMPLTZ"),
+        ("TIMESTAMP_TZ", ""): ("TIMESTAMP_TZ", "TIMESTAMPTZ"),
     }
 
-    return mapping.get(resource_return_type.lower(), resource_return_type.lower())
+    user_provided_type = user_provided_type.upper()
+    for (cast_type, default), matching_types in mapping.items():
+        for type_ in matching_types:
+            if user_provided_type == type_:
+                # TEXT -> VARCHAR(16777216)
+                return cast_type + default
+            if user_provided_type.startswith(type_):
+                # TEXT(30) -> VARCHAR(30)
+                return user_provided_type.replace(type_, cast_type + default)
+    return user_provided_type
 
 
 def _compare_imports(

snowflake/cli/_plugins/snowpark/package/anaconda_packages.py

@@ -169,7 +169,7 @@ class AnacondaPackagesManager(SqlExecutionMixin):
 
     def find_packages_available_in_snowflake_anaconda(self) -> AnacondaPackages:
         """
-        Finds python packages available in Snowflake to use in functions and stored procedures.
+        Finds Python packages available in Snowflake to use in functions and stored procedures.
         It tries to get the list of packages using SQL query
         but if the try fails then the fallback is to parse JSON containing info about Snowflake's Anaconda channel.
         """
@@ -178,7 +178,7 @@ class AnacondaPackagesManager(SqlExecutionMixin):
 
     def _query_snowflake_for_available_packages(self) -> dict[str, AvailablePackage]:
         cursor = self._execute_query(
-            "select package_name, version from information_schema.packages where language = 'python'",
+            "select package_name, version from snowflake.information_schema.packages where language = 'python'",
             cursor_class=DictCursor,
         )
         if cursor.rowcount is None or cursor.rowcount == 0:

snowflake/cli/_plugins/spcs/image_repository/commands.py

@@ -39,6 +39,7 @@ from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.types import (
     CollectionResult,
     MessageResult,
+    QueryResult,
     SingleQueryResult,
 )
 from snowflake.cli.api.project.util import is_valid_object_name
@@ -99,44 +100,10 @@ def list_images(
     **options,
 ) -> CollectionResult:
     """Lists images in the given repository."""
-    repository_manager = ImageRepositoryManager()
-    database = repository_manager.get_database()
-    schema = repository_manager.get_schema()
-    url = repository_manager.get_repository_url(name.identifier)
-    api_url = repository_manager.get_repository_api_url(url)
-    bearer_login = RegistryManager().login_to_registry(api_url)
-    repos = []
-    query: Optional[str] = f"{api_url}/_catalog?n=10"
-
-    while query:
-        # Make paginated catalog requests
-        response = requests.get(
-            query, headers={"Authorization": f"Bearer {bearer_login}"}
-        )
-
-        if response.status_code != 200:
-            raise ClickException(f"Call to the registry failed {response.text}")
-
-        data = json.loads(response.text)
-        if "repositories" in data:
-            repos.extend(data["repositories"])
-
-        if "Link" in response.headers:
-            # There are more results
-            query = f"{api_url}/_catalog?n=10&last={repos[-1]}"
-        else:
-            query = None
-
-    images = []
-    for repo in repos:
-        prefix = f"/{database}/{schema}/{name}/"
-        repo = repo.replace("baserepo/", prefix)
-        images.append({"image": repo})
-
-    return CollectionResult(images)
+    return QueryResult(ImageRepositoryManager().list_images(name.identifier))
 
 
-@app.command("list-tags", requires_connection=True)
+@app.command("list-tags", requires_connection=True, deprecated=True)
 def list_tags(
     name: FQN = REPO_NAME_ARGUMENT,
     image_name: str = typer.Option(
@@ -149,7 +116,7 @@ def list_tags(
     ),
     **options,
 ) -> CollectionResult:
-    """Lists tags for the given image in a repository."""
+    """Lists tags for the given image in a repository. This command is deprecated and will be removed in a future release. Use `list-images` instead."""
 
     repository_manager = ImageRepositoryManager()
     url = repository_manager.get_repository_url(name.identifier)

snowflake/cli/_plugins/spcs/image_repository/manager.py

@@ -18,6 +18,7 @@ from snowflake.cli._plugins.spcs.common import handle_object_already_exists
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
 
@@ -32,7 +33,6 @@ class ImageRepositoryManager(SqlExecutionMixin):
         return self._conn.role
 
     def get_repository_url(self, repo_name: str, with_scheme: bool = True):
-
         repo_row = self.show_specific_object(
             "image repositories", repo_name, check_schema=True
         )
@@ -82,3 +82,6 @@ class ImageRepositoryManager(SqlExecutionMixin):
             handle_object_already_exists(
                 e, ObjectType.IMAGE_REPOSITORY, name, replace_available=True
             )
+
+    def list_images(self, repo_name: str) -> SnowflakeCursor:
+        return self._execute_query(f"show images in image repository {repo_name}")