snowflake-cli 3.11.0__py3-none-any.whl → 3.12.0__py3-none-any.whl

snowflake/cli/_plugins/dcm/commands.py

@@ -14,29 +14,23 @@
 from typing import List, Optional
 
 import typer
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import (
-    DCMProjectEntityModel,
-)
 from snowflake.cli._plugins.dcm.manager import DCMProjectManager
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli._plugins.object.manager import ObjectManager
-from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
-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.flags import (
     IfExistsOption,
     IfNotExistsOption,
     OverrideableOption,
-    entity_argument,
     identifier_argument,
     like_option,
     variables_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.commands.utils import get_entity_for_operation
 from snowflake.cli.api.console.console import cli_console
-from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.constants import (
+    ObjectType,
+)
 from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
@@ -45,7 +39,7 @@ from snowflake.cli.api.output.types import (
     QueryJsonValueResult,
     QueryResult,
 )
-from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.utils.path_utils import is_stage_path
 
 app = SnowTyperFactory(
     name="dcm",
@@ -63,18 +57,10 @@ configuration_flag = typer.Option(
     help="Configuration of the DCM Project to use. If not specified default configuration is used.",
     show_default=False,
 )
-from_option = OverrideableOption(
+from_option = typer.Option(
     None,
     "--from",
-    mutually_exclusive=["prune"],
-    show_default=False,
-)
-
-prune_option = OverrideableOption(
-    False,
-    "--prune",
-    help="Remove unused artifacts from the stage during sync. Mutually exclusive with --from.",
-    mutually_exclusive=["from_stage"],
+    help="Source location: stage path (starting with '@') or local directory path. Omit to use current directory.",
     show_default=False,
 )
 
@@ -122,61 +108,65 @@ add_object_command_aliases(
 @app.command(requires_connection=True)
 def deploy(
     identifier: FQN = dcm_identifier,
-    from_stage: Optional[str] = from_option(
-        help="Deploy DCM Project deployment from a given stage."
-    ),
+    from_location: Optional[str] = from_option,
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
     alias: Optional[str] = alias_option,
-    prune: bool = prune_option(),
     **options,
 ):
     """
     Applies changes defined in DCM Project to Snowflake.
     """
-    result = DCMProjectManager().execute(
-        project_name=identifier,
-        configuration=configuration,
-        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
-        variables=variables,
-        alias=alias,
-        output_path=None,
-    )
+    manager = DCMProjectManager()
+    effective_stage = _get_effective_stage(identifier, from_location)
+
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Deploying dcm project {identifier}", total=None)
+        result = manager.execute(
+            project_identifier=identifier,
+            configuration=configuration,
+            from_stage=effective_stage,
+            variables=variables,
+            alias=alias,
+            output_path=None,
+        )
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
 def plan(
     identifier: FQN = dcm_identifier,
-    from_stage: Optional[str] = from_option(
-        help="Plan DCM Project deployment from a given stage."
-    ),
+    from_location: Optional[str] = from_option,
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
-    prune: bool = prune_option(),
     output_path: Optional[str] = output_path_option(
-        help="Stage path where the deployment plan output will be stored."
+        help="Path where the deployment plan output will be stored. Can be a stage path (starting with '@') or a local directory path."
     ),
     **options,
 ):
     """
     Plans a DCM Project deployment (validates without executing).
     """
-    result = DCMProjectManager().execute(
-        project_name=identifier,
-        configuration=configuration,
-        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
-        dry_run=True,
-        variables=variables,
-        output_path=output_path,
-    )
+    manager = DCMProjectManager()
+    effective_stage = _get_effective_stage(identifier, from_location)
+
+    with cli_console.spinner() as spinner:
+        spinner.add_task(description=f"Planning dcm project {identifier}", total=None)
+        result = manager.execute(
+            project_identifier=identifier,
+            configuration=configuration,
+            from_stage=effective_stage,
+            dry_run=True,
+            variables=variables,
+            output_path=output_path,
+        )
+
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
-@with_project_definition()
 def create(
-    entity_id: str = entity_argument("dcm"),
+    identifier: FQN = dcm_identifier,
     if_not_exists: bool = IfNotExistsOption(
         help="Do nothing if the project already exists."
     ),
@@ -185,28 +175,18 @@ def create(
     """
     Creates a DCM Project in Snowflake.
     """
-    cli_context = get_cli_context()
-    project: DCMProjectEntityModel = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=entity_id,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
     om = ObjectManager()
-    if om.object_exists(object_type="dcm", fqn=project.fqn):
-        message = f"DCM Project '{project.fqn}' already exists."
+    if om.object_exists(object_type="dcm", fqn=identifier):
+        message = f"DCM Project '{identifier}' already exists."
         if if_not_exists:
             return MessageResult(message)
         raise CliError(message)
 
-    if om.object_exists(object_type="stage", fqn=FQN.from_stage(project.stage)):
-        raise CliError(f"Stage '{project.stage}' already exists.")
-
     dpm = DCMProjectManager()
-    with cli_console.phase(f"Creating DCM Project '{project.fqn}'"):
-        dpm.create(project=project)
+    with cli_console.phase(f"Creating DCM Project '{identifier}'"):
+        dpm.create(project_identifier=identifier)
 
-    return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
+    return MessageResult(f"DCM Project '{identifier}' successfully created.")
 
 
 @app.command(requires_connection=True)
@@ -218,56 +198,51 @@ def list_deployments(
     Lists deployments of given DCM Project.
     """
     pm = DCMProjectManager()
-    results = pm.list_versions(project_name=identifier)
+    results = pm.list_deployments(project_identifier=identifier)
     return QueryResult(results)
 
 
 @app.command(requires_connection=True)
 def drop_deployment(
     identifier: FQN = dcm_identifier,
-    version_name: str = typer.Argument(
-        help="Name or alias of the version to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
+    deployment_name: str = typer.Argument(
+        help="Name or alias of the deployment to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'DEPLOYMENT$1').",
         show_default=False,
     ),
-    if_exists: bool = IfExistsOption(help="Do nothing if the version does not exist."),
+    if_exists: bool = IfExistsOption(
+        help="Do nothing if the deployment does not exist."
+    ),
     **options,
 ):
     """
-    Drops a version from the DCM Project.
+    Drops a deployment from the DCM Project.
     """
     # Detect potential shell expansion issues
-    if version_name and version_name.upper() == "VERSION":
+    if deployment_name and deployment_name.upper() == "DEPLOYMENT":
         cli_console.warning(
-            f"Version name '{version_name}' might be truncated due to shell expansion. "
-            f"If you meant to use a version like 'VERSION$1', try using single quotes: 'VERSION$1'."
+            f"Deployment name '{deployment_name}' might be truncated due to shell expansion. "
+            f"If you meant to use a deployment like 'DEPLOYMENT$1', try using single quotes: 'DEPLOYMENT$1'."
         )
 
     dpm = DCMProjectManager()
     dpm.drop_deployment(
-        project_name=identifier,
-        version_name=version_name,
+        project_identifier=identifier,
+        deployment_name=deployment_name,
         if_exists=if_exists,
     )
     return MessageResult(
-        f"Version '{version_name}' dropped from DCM Project '{identifier}'."
+        f"Deployment '{deployment_name}' dropped from DCM Project '{identifier}'."
     )
 
 
-def _sync_local_files(prune: bool = False) -> str:
-    cli_context = get_cli_context()
-    project_entity = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=None,
-        project_definition=cli_context.project_definition,
-        entity_type="dcm",
-    )
-
-    with cli_console.phase("Syncing local files to stage"):
-        sync_artifacts_with_stage(
-            project_paths=ProjectPaths(project_root=cli_context.project_root),
-            stage_root=project_entity.stage,
-            artifacts=project_entity.artifacts,
-            prune=prune,
+def _get_effective_stage(identifier: FQN, from_location: Optional[str]):
+    manager = DCMProjectManager()
+    if not from_location:
+        from_stage = manager.sync_local_files(project_identifier=identifier)
+    elif is_stage_path(from_location):
+        from_stage = from_location
+    else:
+        from_stage = manager.sync_local_files(
+            project_identifier=identifier, source_directory=from_location
         )
-
-    return project_entity.stage
+    return from_stage

snowflake/cli/_plugins/dcm/manager.py

@@ -11,21 +11,75 @@
 # 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 contextlib import contextmanager, nullcontext
+from pathlib import Path
+from typing import Generator, List
 
-from typing import List
-
-from snowflake.cli._plugins.dcm.dcm_project_entity_model import DCMProjectEntityModel
+import yaml
 from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 from snowflake.cli.api.commands.utils import parse_key_value_variables
+from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.constants import (
+    DEFAULT_SIZE_LIMIT_MB,
+    ObjectType,
+    PatternMatchingType,
+)
+from snowflake.cli.api.exceptions import CliError
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.project_paths import ProjectPaths
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
+from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.cli.api.stage_path import StagePath
+from snowflake.cli.api.utils.path_utils import is_stage_path
+
+MANIFEST_FILE_NAME = "manifest.yml"
+DCM_PROJECT_TYPE = "dcm_project"
 
 
 class DCMProjectManager(SqlExecutionMixin):
+    @contextmanager
+    def _collect_output(
+        self, project_identifier: FQN, output_path: str
+    ) -> Generator[str, None, None]:
+        """
+        Context manager for handling output path - creates temporary stage for local paths,
+        downloads files after execution, and ensures proper cleanup.
+
+        Args:
+            project_identifier: The DCM project identifier
+            output_path: Either a stage path (@stage/path) or local directory path
+
+        Yields:
+            str: The effective output path to use in the DCM command
+        """
+        temp_stage_for_local_output = None
+        stage_manager = StageManager()
+
+        if should_download_files := not is_stage_path(output_path):
+            temp_stage_fqn = FQN.from_resource(
+                ObjectType.DCM_PROJECT, project_identifier, "OUTPUT_TMP_STAGE"
+            )
+            stage_manager.create(temp_stage_fqn, temporary=True)
+            effective_output_path = StagePath.from_stage_str(temp_stage_fqn.identifier)
+            temp_stage_for_local_output = (temp_stage_fqn.identifier, Path(output_path))
+        else:
+            effective_output_path = StagePath.from_stage_str(output_path)
+
+        yield effective_output_path.absolute_path()
+
+        if should_download_files:
+            assert temp_stage_for_local_output is not None
+            stage_path, local_path = temp_stage_for_local_output
+            stage_manager.get_recursive(stage_path=stage_path, dest_path=local_path)
+            cli_console.step(f"Plan output saved to: {local_path.resolve()}")
+        else:
+            cli_console.step(f"Plan output saved to: {output_path}")
+
     def execute(
         self,
-        project_name: FQN,
+        project_identifier: FQN,
         from_stage: str,
         configuration: str | None = None,
         variables: List[str] | None = None,
@@ -33,64 +87,97 @@ class DCMProjectManager(SqlExecutionMixin):
         alias: str | None = None,
         output_path: str | None = None,
     ):
+        with self._collect_output(project_identifier, output_path) if (
+            output_path and dry_run
+        ) else nullcontext() as output_stage:
+            query = f"EXECUTE DCM PROJECT {project_identifier.sql_identifier}"
+            if dry_run:
+                query += " PLAN"
+            else:
+                query += " DEPLOY"
+                if alias:
+                    query += f' AS "{alias}"'
+            if configuration or variables:
+                query += f" USING"
+            if configuration:
+                query += f" CONFIGURATION {configuration}"
+            if variables:
+                query += StageManager.parse_execute_variables(
+                    parse_key_value_variables(variables)
+                ).removeprefix(" using")
+            stage_path = StagePath.from_stage_str(from_stage)
+            query += f" FROM {stage_path.absolute_path()}"
+            if output_stage is not None:
+                query += f" OUTPUT_PATH {output_stage}"
+            result = self.execute_query(query=query)
 
-        query = f"EXECUTE DCM PROJECT {project_name.sql_identifier}"
-        if dry_run:
-            query += " PLAN"
-        else:
-            query += " DEPLOY"
-            if alias:
-                query += f" AS {alias}"
-        if configuration or variables:
-            query += f" USING"
-        if configuration:
-            query += f" CONFIGURATION {configuration}"
-        if variables:
-            query += StageManager.parse_execute_variables(
-                parse_key_value_variables(variables)
-            ).removeprefix(" using")
-        stage_path = StagePath.from_stage_str(from_stage)
-        query += f" FROM {stage_path.absolute_path()}"
-        if output_path:
-            output_stage_path = StagePath.from_stage_str(output_path)
-            query += f" OUTPUT_PATH {output_stage_path.absolute_path()}"
-        return self.execute_query(query=query)
+        return result
 
-    def create(self, project: DCMProjectEntityModel) -> None:
-        query = f"CREATE DCM PROJECT {project.fqn.sql_identifier}"
+    def create(self, project_identifier: FQN) -> None:
+        query = f"CREATE DCM PROJECT {project_identifier.sql_identifier}"
         self.execute_query(query)
 
-    def _create_version(
-        self,
-        project_name: FQN,
-        from_stage: str,
-        alias: str | None = None,
-        comment: str | None = None,
-    ):
-        stage_path = StagePath.from_stage_str(from_stage)
-        query = f"ALTER DCM PROJECT {project_name.identifier} ADD VERSION"
-        if alias:
-            query += f" IF NOT EXISTS {alias}"
-        query += f" FROM {stage_path.absolute_path(at_prefix=True)}"
-        if comment:
-            query += f" COMMENT = '{comment}'"
-        return self.execute_query(query=query)
-
-    def list_versions(self, project_name: FQN):
-        query = f"SHOW VERSIONS IN DCM PROJECT {project_name.identifier}"
+    def list_deployments(self, project_identifier: FQN):
+        query = f"SHOW DEPLOYMENTS IN DCM PROJECT {project_identifier.identifier}"
         return self.execute_query(query=query)
 
     def drop_deployment(
         self,
-        project_name: FQN,
-        version_name: str,
+        project_identifier: FQN,
+        deployment_name: str,
         if_exists: bool = False,
     ):
         """
-        Drops a version from the DCM Project.
+        Drops a deployment from the DCM Project.
         """
-        query = f"ALTER DCM PROJECT {project_name.identifier} DROP VERSION"
+        query = f"ALTER DCM PROJECT {project_identifier.identifier} DROP DEPLOYMENT"
         if if_exists:
             query += " IF EXISTS"
-        query += f" {version_name}"
+        query += f' "{deployment_name}"'
         return self.execute_query(query=query)
+
+    @staticmethod
+    def sync_local_files(
+        project_identifier: FQN, source_directory: str | None = None
+    ) -> str:
+        source_path = (
+            SecurePath(source_directory).resolve()
+            if source_directory
+            else SecurePath.cwd()
+        )
+
+        dcm_manifest_file = source_path / MANIFEST_FILE_NAME
+        if not dcm_manifest_file.exists():
+            raise CliError(
+                f"{MANIFEST_FILE_NAME} was not found in directory {source_path.path}"
+            )
+
+        with dcm_manifest_file.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
+            dcm_manifest = yaml.safe_load(fd)
+            object_type = dcm_manifest.get("type") if dcm_manifest else None
+            if object_type is None:
+                raise CliError(
+                    f"Manifest file type is undefined. Expected {DCM_PROJECT_TYPE}"
+                )
+            if object_type.lower() != DCM_PROJECT_TYPE:
+                raise CliError(
+                    f"Manifest file is defined for type {object_type}. Expected {DCM_PROJECT_TYPE}"
+                )
+
+            definitions = list(dcm_manifest.get("include_definitions", list()))
+            if MANIFEST_FILE_NAME not in definitions:
+                definitions.append(MANIFEST_FILE_NAME)
+
+        with cli_console.phase(f"Uploading definition files"):
+            stage_fqn = FQN.from_resource(
+                ObjectType.DCM_PROJECT, project_identifier, "TMP_STAGE"
+            )
+            sync_artifacts_with_stage(
+                project_paths=ProjectPaths(project_root=source_path.path),
+                stage_root=stage_fqn.identifier,
+                use_temporary_stage=True,
+                artifacts=[PathMapping(src=definition) for definition in definitions],
+                pattern_type=PatternMatchingType.REGEX,
+            )
+
+        return stage_fqn.identifier

snowflake/cli/_plugins/logs/commands.py

@@ -48,6 +48,11 @@ def get_logs(
         "--log-level",
         help="The log level to filter by. If not provided, INFO will be used",
     ),
+    partial_match: bool = typer.Option(
+        False,
+        "--partial",
+        help="Enable partial, case-insensitive matching for object names",
+    ),
     **options,
 ):
     """
@@ -75,6 +80,7 @@ def get_logs(
             refresh_time=refresh_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
         logs = itertools.chain(
             (MessageResult(log.log_message) for logs in logs_stream for log in logs)
@@ -87,6 +93,7 @@ def get_logs(
             to_time=to_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
         logs = (MessageResult(log.log_message) for log in logs_iterable)  # type: ignore
 

snowflake/cli/_plugins/logs/manager.py

@@ -11,6 +11,7 @@ from snowflake.cli._plugins.logs.utils import (
 )
 from snowflake.cli._plugins.object.commands import NameArgument, ObjectArgument
 from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.project.util import escape_like_pattern
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 
@@ -24,6 +25,7 @@ class LogsManager(SqlExecutionMixin):
         from_time: Optional[datetime] = None,
         event_table: Optional[str] = None,
         log_level: Optional[str] = "INFO",
+        partial_match: bool = False,
     ) -> Iterable[List[LogsQueryRow]]:
         try:
             previous_end = from_time
@@ -36,6 +38,7 @@ class LogsManager(SqlExecutionMixin):
                     to_time=None,
                     event_table=event_table,
                     log_level=log_level,
+                    partial_match=partial_match,
                 ).fetchall()
 
                 if raw_logs:
@@ -56,6 +59,7 @@ class LogsManager(SqlExecutionMixin):
         to_time: Optional[datetime] = None,
         event_table: Optional[str] = None,
         log_level: Optional[str] = "INFO",
+        partial_match: bool = False,
     ) -> Iterable[LogsQueryRow]:
         """
         Basic function to get a single batch of logs from the server
@@ -68,6 +72,7 @@ class LogsManager(SqlExecutionMixin):
             to_time=to_time,
             event_table=event_table,
             log_level=log_level,
+            partial_match=partial_match,
         )
 
         return sanitize_logs(logs)
@@ -80,10 +85,25 @@ class LogsManager(SqlExecutionMixin):
         to_time: Optional[datetime] = None,
         event_table: Optional[str] = None,
         log_level: Optional[str] = "INFO",
+        partial_match: bool = False,
     ) -> SnowflakeCursor:
 
         table = event_table if event_table else "SNOWFLAKE.TELEMETRY.EVENTS"
 
+        # Escape single quotes in object_name to prevent SQL injection
+        escaped_object_name = str(object_name).replace("'", "''")
+
+        # Build the object name condition based on partial_match flag
+        if partial_match:
+            # Use ILIKE for case-insensitive partial matching with wildcards
+            escaped_pattern = escape_like_pattern(
+                escaped_object_name, escape_sequence="\\"
+            )
+            object_condition = f"object_name ILIKE '%{escaped_pattern}%'"
+        else:
+            # Use exact match (original behavior)
+            object_condition = f"object_name = '{escaped_object_name}'"
+
         query = dedent(
             f"""
             SELECT
@@ -96,7 +116,7 @@ class LogsManager(SqlExecutionMixin):
             FROM {table}
             WHERE record_type = 'LOG'
             AND (record:severity_text IN ({parse_log_levels_for_query((log_level))}) or record:severity_text is NULL )
-            AND object_name = '{object_name}'
+            AND {object_condition}
             {get_timestamp_query(from_time, to_time)}
             ORDER BY timestamp;
 """

snowflake/cli/_plugins/nativeapp/sf_sql_facade.py

@@ -632,6 +632,7 @@ class SnowflakeSQLFacade:
         role: str | None = None,
         database: str | None = None,
         schema: str | None = None,
+        temporary: bool = False,
     ):
         """
         Creates a stage.
@@ -641,13 +642,14 @@ class SnowflakeSQLFacade:
         @param [Optional] role: Role to switch to while running this script. Current role will be used if no role is passed in.
         @param [Optional] database: Database to use while running this script, unless the stage name is database-qualified.
         @param [Optional] schema: Schema to use while running this script, unless the stage name is schema-qualified.
+        @param [Optional] temporary: determines if stage should be temporary. Default is false.
         """
         fqn = FQN.from_string(name)
         identifier = to_identifier(fqn.name)
         database = fqn.database or database
         schema = fqn.schema or schema
 
-        query = f"create stage if not exists {identifier}"
+        query = f"create{' temporary' if temporary else ''} stage if not exists {identifier}"
         if encryption_type:
             query += f" encryption = (type = '{encryption_type}')"
         if enable_directory:

snowflake/cli/_plugins/snowpark/common.py

@@ -349,6 +349,7 @@ def user_to_sql_type_mapper(user_provided_type: str) -> str:
             "FLOAT4",
             "FLOAT8",
         ),
+        ("DECFLOAT", ""): ("DECFLOAT",),
         ("TIMESTAMP_NTZ", ""): ("TIMESTAMP_NTZ", "TIMESTAMPNTZ", "DATETIME"),
         ("TIMESTAMP_LTZ", ""): ("TIMESTAMP_LTZ", "TIMESTAMPLTZ"),
         ("TIMESTAMP_TZ", ""): ("TIMESTAMP_TZ", "TIMESTAMPTZ"),

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

@@ -153,13 +153,37 @@ class AnacondaPackages:
     ):
         """Saves requirements to a file in format accepted by Snowflake SQL commands."""
         log.info("Writing requirements into file %s", file_path.path)
-        formatted_requirements = []
+
+        # Deduplicate requirements by package name, keeping the first occurrence
+        seen_packages = set()
+        deduplicated_requirements = []
+        duplicate_packages = set()
+
         for requirement in requirements:
             if requirement.name and requirement.name in self._packages:
-                snowflake_name = self._packages[requirement.name].snowflake_name
-                formatted_requirements.append(
-                    snowflake_name + requirement.formatted_specs
-                )
+                if requirement.name in seen_packages:
+                    duplicate_packages.add(requirement.name)
+                    log.warning(
+                        "Duplicate package '%s' found in Anaconda requirements. "
+                        "Ignoring: %s",
+                        requirement.name,
+                        requirement.name_and_version,
+                    )
+                else:
+                    seen_packages.add(requirement.name)
+                    deduplicated_requirements.append(requirement)
+
+        if duplicate_packages:
+            log.warning(
+                "Found duplicate Anaconda packages: %s. "
+                "Consider consolidating package versions in requirements.txt.",
+                ", ".join(sorted(duplicate_packages)),
+            )
+
+        formatted_requirements = []
+        for requirement in deduplicated_requirements:
+            snowflake_name = self._packages[requirement.name].snowflake_name
+            formatted_requirements.append(snowflake_name + requirement.formatted_specs)
 
         if formatted_requirements:
             file_path.write_text("\n".join(formatted_requirements))