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

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

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import inspect
 from functools import wraps
-from typing import Any, Dict, Optional, Type, TypeVar, Union
+from typing import Optional, Type, TypeVar
 
 import typer
 from click import ClickException
@@ -29,35 +29,44 @@ 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
-
-
-def _convert_v2_artifact_to_v1_dict(
-    v2_artifact: Union[PathMapping, str]
-) -> Union[Dict, str]:
-    if isinstance(v2_artifact, PathMapping):
-        return {
-            "src": v2_artifact.src,
-            "dest": v2_artifact.dest,
-            "processors": v2_artifact.processors,
-        }
-    return v2_artifact
 
-
-def _pdf_v2_to_v1(
+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 _find_app_and_package_entities(
     v2_definition: DefinitionV20,
-    package_entity_id: str = "",
-    app_entity_id: str = "",
-    app_required: bool = False,
-) -> DefinitionV11:
-    pdfv1: Dict[str, Any] = {"definition_version": "1.1", "native_app": {}}
-
+    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,
@@ -66,7 +75,6 @@ def _pdf_v2_to_v1(
         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
@@ -87,7 +95,6 @@ def _pdf_v2_to_v1(
         ):
             # 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,
@@ -97,63 +104,7 @@ def _pdf_v2_to_v1(
         required=True,
     )
     assert app_package_definition is not None  # satisfy mypy
-
-    # NativeApp
-    if app_definition and app_definition.fqn.identifier:
-        pdfv1["native_app"]["name"] = app_definition.fqn.identifier
-    else:
-        pdfv1["native_app"]["name"] = app_package_definition.fqn.identifier.split(
-            "_pkg_"
-        )[0]
-    pdfv1["native_app"]["artifacts"] = [
-        _convert_v2_artifact_to_v1_dict(a) for a in app_package_definition.artifacts
-    ]
-    pdfv1["native_app"]["source_stage"] = app_package_definition.stage
-    pdfv1["native_app"]["bundle_root"] = app_package_definition.bundle_root
-    pdfv1["native_app"]["generated_root"] = app_package_definition.generated_root
-    pdfv1["native_app"]["deploy_root"] = app_package_definition.deploy_root
-    pdfv1["native_app"]["scratch_stage"] = app_package_definition.scratch_stage
-
-    # Package
-    pdfv1["native_app"]["package"] = {}
-    pdfv1["native_app"]["package"]["name"] = app_package_definition.fqn.identifier
-    if app_package_definition.distribution:
-        pdfv1["native_app"]["package"][
-            "distribution"
-        ] = app_package_definition.distribution
-    if app_package_definition.meta and app_package_definition.meta.post_deploy:
-        pdfv1["native_app"]["package"][
-            "post_deploy"
-        ] = app_package_definition.meta.post_deploy
-    if app_package_definition.meta:
-        if app_package_definition.meta.role:
-            pdfv1["native_app"]["package"]["role"] = app_package_definition.meta.role
-        if app_package_definition.meta.warehouse:
-            pdfv1["native_app"]["package"][
-                "warehouse"
-            ] = app_package_definition.meta.warehouse
-
-    # Application
-    if app_definition:
-        pdfv1["native_app"]["application"] = {}
-        pdfv1["native_app"]["application"]["name"] = app_definition.fqn.identifier
-        if app_definition.debug:
-            pdfv1["native_app"]["application"]["debug"] = app_definition.debug
-        if app_definition.meta:
-            if app_definition.meta.role:
-                pdfv1["native_app"]["application"]["role"] = app_definition.meta.role
-            if app_definition.meta.warehouse:
-                pdfv1["native_app"]["application"][
-                    "warehouse"
-                ] = app_definition.meta.warehouse
-            if app_definition.meta.post_deploy:
-                pdfv1["native_app"]["application"][
-                    "post_deploy"
-                ] = app_definition.meta.post_deploy
-
-    result = render_definition_template(pdfv1, {})
-    # Override the definition object in global context
-    return result.project_definition
+    return app_definition, app_package_definition
 
 
 T = TypeVar("T", bound=EntityModelBase)
@@ -209,54 +160,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 original_pdf.definition_version == "2":
+            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
+                )
+                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

@@ -18,23 +18,18 @@ import logging
 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 +41,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,
@@ -58,6 +53,11 @@ def create(
         help=f"""The patch number you want to create for an existing version.
         Defaults to undefined if it is not set, which means the Snowflake CLI either uses the patch specified in the `manifest.yml` file or automatically generates a new patch number.""",
     ),
+    label: Optional[str] = typer.Option(
+        None,
+        "--label",
+        help="A label for the version that is displayed to consumers. If unset, the version label specified in `manifest.yml` file is used.",
+    ),
     skip_git_check: Optional[bool] = typer.Option(
         False,
         "--skip-git-check",
@@ -72,19 +72,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,
+        label=label,
         force=force,
         interactive=interactive,
         skip_git_check=skip_git_check,
@@ -94,28 +93,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 +129,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/notebook/manager.py

@@ -26,7 +26,7 @@ from snowflake.cli.api.sql_execution import SqlExecutionMixin
 class NotebookManager(SqlExecutionMixin):
     def execute(self, notebook_name: FQN):
         query = f"EXECUTE NOTEBOOK {notebook_name.sql_identifier}()"
-        return self._execute_query(query=query)
+        return self.execute_query(query=query)
 
     def get_url(self, notebook_name: FQN):
         fqn = notebook_name.using_connection(self._conn)
@@ -64,7 +64,7 @@ class NotebookManager(SqlExecutionMixin):
             ALTER NOTEBOOK {notebook_fqn.identifier} ADD LIVE VERSION FROM LAST;
             """
         )
-        self._execute_queries(queries=queries)
+        self.execute_queries(queries=queries)
 
         return make_snowsight_url(
             self._conn, f"/#/notebooks/{notebook_fqn.url_identifier}"

snowflake/cli/_plugins/object/commands.py

@@ -21,6 +21,8 @@ from click import ClickException
 from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli.api.commands.flags import (
     IdentifierType,
+    IfNotExistsOption,
+    ReplaceOption,
     like_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
@@ -145,6 +147,8 @@ def create(
     object_type: str = ObjectArgument,
     object_attributes: Optional[List[str]] = ObjectAttributesArgument,
     object_json: str = ObjectDefinitionJsonOption,
+    if_not_exists: bool = IfNotExistsOption(),
+    replace: bool = ReplaceOption(),
     **options,
 ):
     """
@@ -176,5 +180,10 @@ def create(
             "Provide either list of object attributes, or object definition in JSON format"
         )
 
-    result = ObjectManager().create(object_type=object_type, object_data=object_data)
+    result = ObjectManager().create(
+        object_type=object_type,
+        object_data=object_data,
+        if_not_exists=if_not_exists,
+        replace=replace,
+    )
     return MessageResult(result)

snowflake/cli/_plugins/object/manager.py

@@ -52,11 +52,11 @@ class ObjectManager(SqlExecutionMixin):
             query += f" like '{like}'"
         if scope[0] is not None:
             query += f" in {scope[0].replace('-', ' ')} {scope[1]}"
-        return self._execute_query(query, **kwargs)
+        return self.execute_query(query, **kwargs)
 
     def drop(self, *, object_type: str, fqn: FQN) -> SnowflakeCursor:
         object_name = _get_object_names(object_type).sf_name
-        return self._execute_query(f"drop {object_name} {fqn.sql_identifier}")
+        return self.execute_query(f"drop {object_name} {fqn.sql_identifier}")
 
     def describe(self, *, object_type: str, fqn: FQN):
         # Image repository is the only supported object that does not have a DESCRIBE command.
@@ -65,7 +65,7 @@ class ObjectManager(SqlExecutionMixin):
                 f"Describe is currently not supported for object of type image-repository"
             )
         object_name = _get_object_names(object_type).sf_name
-        return self._execute_query(f"describe {object_name} {fqn.sql_identifier}")
+        return self.execute_query(f"describe {object_name} {fqn.sql_identifier}")
 
     def object_exists(self, *, object_type: str, fqn: FQN):
         try:
@@ -74,9 +74,17 @@ class ObjectManager(SqlExecutionMixin):
         except ProgrammingError:
             return False
 
-    def create(self, object_type: str, object_data: Dict[str, Any]) -> str:
+    def create(
+        self,
+        object_type: str,
+        object_data: Dict[str, Any],
+        replace: bool = False,
+        if_not_exists: bool = False,
+    ) -> str:
         rest = RestApi(self._conn)
-        url = rest.determine_url_for_create_query(object_type=object_type)
+        url = rest.determine_url_for_create_query(
+            object_type=object_type, replace=replace, if_not_exists=if_not_exists
+        )
         try:
             response = rest.send_rest_request(url=url, method="post", data=object_data)
         except Exception as err:

snowflake/cli/_plugins/snowpark/common.py

@@ -58,9 +58,9 @@ class SnowparkObjectManager(SqlExecutionMixin):
         self, execution_identifier: str, object_type: SnowparkObject
     ) -> SnowflakeCursor:
         if object_type == SnowparkObject.FUNCTION:
-            return self._execute_query(f"select {execution_identifier}")
+            return self.execute_query(f"select {execution_identifier}")
         if object_type == SnowparkObject.PROCEDURE:
-            return self._execute_query(f"call {execution_identifier}")
+            return self.execute_query(f"call {execution_identifier}")
         raise UsageError(f"Unknown object type: {object_type}.")
 
     def create_or_replace(
@@ -95,7 +95,7 @@ class SnowparkObjectManager(SqlExecutionMixin):
         if isinstance(entity, ProcedureEntityModel) and entity.execute_as_caller:
             query.append("execute as caller")
 
-        return self._execute_query("\n".join(query))
+        return self.execute_query("\n".join(query))
 
     def deploy_entity(
         self,
@@ -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.
         """
@@ -177,8 +177,8 @@ class AnacondaPackagesManager(SqlExecutionMixin):
         return AnacondaPackages(packages)
 
     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'",
+        cursor = self.execute_query(
+            "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/common.py

@@ -95,5 +95,34 @@ def handle_object_already_exists(
         raise error
 
 
+def filter_log_timestamp(log: str, include_timestamps: bool) -> str:
+    if include_timestamps:
+        return log
+    else:
+        return log.split(" ", 1)[1] if " " in log else log
+
+
+def new_logs_only(prev_log_records: list[str], new_log_records: list[str]) -> list[str]:
+    # Sort the log records, we get time-ordered logs
+    # due to ISO 8601 timestamp format in the log content
+    # eg: 2024-10-22T01:12:29.873896187Z Count: 1
+    new_log_records_sorted = sorted(new_log_records)
+
+    # Get the first new log record to establish the overlap point
+    first_new_log_record = new_log_records_sorted[0]
+
+    # Traverse previous logs in reverse and remove duplicates from new logs
+    for prev_log in reversed(prev_log_records):
+        # Stop if the previous log is earlier than the first new log
+        if prev_log < first_new_log_record:
+            break
+
+        # Remove matching previous logs from the new logs list
+        if prev_log in new_log_records_sorted:
+            new_log_records_sorted.remove(prev_log)
+
+    return new_log_records_sorted
+
+
 class NoPropertiesProvidedError(ClickException):
     pass