snowflake-cli 3.3.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

snowflake/cli/api/project/schemas/entities/common.py

@@ -15,9 +15,10 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Dict, Generic, List, Optional, TypeVar, Union
+from typing import Any, Dict, Generic, List, Optional, TypeVar, Union
 
 from pydantic import Field, PrivateAttr, field_validator
+from pydantic_core.core_schema import ValidationInfo
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
@@ -61,6 +62,15 @@ class MetaField(UpdatableModel):
         default=None,
     )
 
+    depends_on: Optional[List[str]] = Field(
+        title="Entities that need to be deployed before this one", default_factory=list
+    )
+
+    action_arguments: Optional[Dict[str, Dict[str, Union[int, bool, str]]]] = Field(
+        title="Arguments that will be used, when this entity is called as a dependency of other entity",
+        default_factory=dict,
+    )
+
     @field_validator("use_mixins", mode="before")
     @classmethod
     def ensure_use_mixins_is_a_list(
@@ -70,6 +80,35 @@ class MetaField(UpdatableModel):
             return [mixins]
         return mixins
 
+    @field_validator("action_arguments", mode="before")
+    @classmethod
+    def arguments_validator(cls, arguments: Dict, info: ValidationInfo) -> Dict:
+        duplicated_run = (
+            info.context.get("is_duplicated_run", False) if info.context else False
+        )
+        if not duplicated_run:
+            for argument_dict in arguments.values():
+                for k, v in argument_dict.items():
+                    argument_dict[k] = cls._cast_value(v)
+
+        return arguments
+
+    @staticmethod
+    def _cast_value(value: str) -> Union[int, bool, str]:
+        if value.lower() in ["true", "false"]:
+            return value.lower() == "true"
+
+        try:
+            return int(value)
+        except ValueError:
+            return value
+
+    def __eq__(self, other):
+        return self.entity_id == other.entity_id
+
+    def __hash__(self):
+        return hash(self.entity_id)
+
 
 class Identifier(UpdatableModel):
     name: str = Field(title="Entity name")
@@ -141,6 +180,23 @@ class ImportsBaseModel:
         return f"IMPORTS = ({imports})"
 
 
+class Grant(UpdatableModel):
+    privilege: str = Field(title="Required privileges")
+    role: str = Field(title="Role to which the privileges will be granted")
+
+    def get_grant_sql(self, entity_model: EntityModelBase) -> str:
+        return f"GRANT {self.privilege} ON {entity_model.get_type().upper()} {entity_model.fqn.sql_identifier} TO ROLE {self.role}"
+
+
+class GrantBaseModel(UpdatableModel):
+    grants: Optional[List[Grant]] = Field(title="List of grants", default=None)
+
+    def get_grant_sqls(self) -> list[str]:
+        return (
+            [grant.get_grant_sql(self) for grant in self.grants] if self.grants else []
+        )
+
+
 class ExternalAccessBaseModel:
     external_access_integrations: Optional[List[str]] = Field(
         title="Names of external access integrations needed for this entity to access external networks",
@@ -162,3 +218,76 @@ class ExternalAccessBaseModel:
             return None
         secrets = ", ".join(f"'{key}'={value}" for key, value in self.secrets.items())
         return f"secrets=({secrets})"
+
+
+class ProcessorMapping(UpdatableModel):
+    name: str = Field(
+        title="Name of a processor to invoke on a collection of artifacts."
+    )
+    properties: Optional[Dict[str, Any]] = Field(
+        title="A set of key-value pairs used to configure the output of the processor. Consult a specific processor's documentation for more details on the supported properties.",
+        default=None,
+    )
+
+
+class PathMapping(UpdatableModel):
+    src: str = Field(
+        title="Source path or glob pattern (relative to project root)", default=None
+    )
+
+    dest: Optional[str] = Field(
+        title="Destination path on stage",
+        description="Paths are relative to stage root; paths ending with a slash indicate that the destination is a directory which source files should be copied into.",
+        default=None,
+    )
+
+    processors: Optional[List[Union[str, ProcessorMapping]]] = Field(
+        title="List of processors to apply to matching source files during bundling.",
+        default=[],
+    )
+
+    @field_validator("processors")
+    @classmethod
+    def transform_processors(
+        cls, input_values: Optional[List[Union[str, Dict, ProcessorMapping]]]
+    ) -> List[ProcessorMapping]:
+        if input_values is None:
+            return []
+
+        transformed_processors: List[ProcessorMapping] = []
+        for input_processor in input_values:
+            if isinstance(input_processor, str):
+                transformed_processors.append(ProcessorMapping(name=input_processor))
+            elif isinstance(input_processor, Dict):
+                transformed_processors.append(ProcessorMapping(**input_processor))
+            else:
+                transformed_processors.append(input_processor)
+        return transformed_processors
+
+
+Artifacts = List[Union[PathMapping, str]]
+
+
+class EntityModelBaseWithArtifacts(EntityModelBase):
+    artifacts: Artifacts = Field(
+        title="List of paths or file source/destination pairs to add to the deploy root",
+    )
+    deploy_root: Optional[str] = Field(
+        title="Folder at the root of your project where the build step copies the artifacts",
+        default="output/deploy/",
+    )
+
+    @field_validator("artifacts")
+    @classmethod
+    def transform_artifacts(cls, orig_artifacts: Artifacts) -> List[PathMapping]:
+        transformed_artifacts: List[PathMapping] = []
+        if orig_artifacts is None:
+            return transformed_artifacts
+
+        for artifact in orig_artifacts:
+            if isinstance(artifact, PathMapping):
+                transformed_artifacts.append(artifact)
+            else:
+                transformed_artifacts.append(PathMapping(src=artifact))
+
+        return transformed_artifacts

snowflake/cli/api/project/schemas/entities/entities.py

@@ -24,6 +24,8 @@ from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
     ApplicationPackageEntityModel,
 )
+from snowflake.cli._plugins.notebook.notebook_entity import NotebookEntity
+from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
 from snowflake.cli._plugins.snowpark.snowpark_entity import (
     FunctionEntity,
     ProcedureEntity,
@@ -43,6 +45,7 @@ Entity = Union[
     StreamlitEntity,
     ProcedureEntity,
     FunctionEntity,
+    NotebookEntity,
 ]
 EntityModel = Union[
     ApplicationEntityModel,
@@ -50,6 +53,7 @@ EntityModel = Union[
     StreamlitEntityModel,
     FunctionEntityModel,
     ProcedureEntityModel,
+    NotebookEntityModel,
 ]
 
 ALL_ENTITIES: List[Entity] = [*get_args(Entity)]

snowflake/cli/api/project/schemas/project_definition.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass
 from types import UnionType
 from typing import Any, Dict, List, Optional, Union, get_args, get_origin
@@ -262,6 +263,21 @@ class DefinitionV20(_ProjectDefinitionBase):
         data = cls._merge_data(data, entity)
         return data
 
+    @model_validator(mode="after")
+    def validate_dependencies(self):
+        """
+        Checks if entities listed in depends_on section exist in the project
+        """
+        missing_dependencies = defaultdict(list)
+        for entity_id, entity in self.entities.items():
+            if entity.meta:
+                for dependency in entity.meta.depends_on:
+                    if dependency not in self.entities:
+                        missing_dependencies[entity_id].append(dependency)
+
+        if missing_dependencies:
+            raise ValueError(_get_missing_dependencies_message(missing_dependencies))
+
     @classmethod
     def _merge_data(
         cls,
@@ -354,3 +370,14 @@ def _unique_extend(list_a: List, list_b: List) -> List:
         if all(item != x for x in list_a):
             new_list.append(item)
     return new_list
+
+
+def _get_missing_dependencies_message(
+    missing_dependencies: Dict[str, List[str]]
+) -> str:
+    missing_dependencies_message = []
+    for entity_id, dependencies in missing_dependencies.items():
+        missing_dependencies_message.append(
+            f"\n Entity {entity_id} depends on non-existing entities: {', '.join(dependencies)}"
+        )
+    return "".join(missing_dependencies_message)

snowflake/cli/api/project/schemas/updatable_model.py

@@ -122,10 +122,10 @@ class UpdatableModel(BaseModel):
             class_dict = class_.__dict__
             field_annotations.update(class_dict.get("__annotations__", {}))
 
-            if "model_fields" in class_dict:
+            if "model_fields" in class_dict and class_.model_fields:
                 # This means the class dict has already been processed by Pydantic
                 # All fields should properly be populated in model_fields
-                field_values.update(class_dict["model_fields"])
+                field_values.update(class_.model_fields)
             else:
                 # If Pydantic did not process this class yet, get the values from class_dict directly
                 field_values.update(class_dict)

snowflake/cli/api/project/schemas/v1/native_app/native_app.py

@@ -15,16 +15,16 @@
 from __future__ import annotations
 
 import re
-from typing import List, Optional, Union
+from typing import List, Optional
 
 from pydantic import Field, field_validator
+from snowflake.cli.api.project.schemas.entities.common import Artifacts, PathMapping
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 from snowflake.cli.api.project.schemas.v1.native_app.application import (
     Application,
     ApplicationV11,
 )
 from snowflake.cli.api.project.schemas.v1.native_app.package import Package, PackageV11
-from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import (
     SCHEMA_AND_NAME,
 )
@@ -34,7 +34,7 @@ class NativeApp(UpdatableModel):
     name: str = Field(
         title="Project identifier",
     )
-    artifacts: List[Union[PathMapping, str]] = Field(
+    artifacts: Artifacts = Field(
         title="List of file source and destination pairs to add to the deploy root",
     )
     bundle_root: Optional[str] = Field(
@@ -69,10 +69,8 @@ class NativeApp(UpdatableModel):
 
     @field_validator("artifacts")
     @classmethod
-    def transform_artifacts(
-        cls, orig_artifacts: List[Union[PathMapping, str]]
-    ) -> List[PathMapping]:
-        transformed_artifacts = []
+    def transform_artifacts(cls, orig_artifacts: Artifacts) -> List[PathMapping]:
+        transformed_artifacts: List[PathMapping] = []
         if orig_artifacts is None:
             return transformed_artifacts
 

snowflake/cli/api/secure_path.py

@@ -104,6 +104,12 @@ class SecurePath:
         """
         return self._path.is_file()
 
+    def glob(self, pattern: str):
+        """
+        Return a generator yielding Path objects that match the given pattern.
+        """
+        return self._path.glob(pattern)
+
     @property
     def name(self) -> str:
         """A string representing the final path component."""

snowflake/cli/api/sql_execution.py

@@ -92,7 +92,11 @@ class BaseSqlExecutor:
 
     def execute_queries(self, queries: str, **kwargs):
         """Executes multiple SQL queries (passed as one string) and returns the results as a list"""
-        return list(self._execute_string(dedent(queries), **kwargs))
+
+        # Without remove_comments=True, connectors might throw an error if there is a comment at the end of the file
+        return list(
+            self._execute_string(dedent(queries), remove_comments=True, **kwargs)
+        )
 
 
 class SqlExecutor(BaseSqlExecutor):

snowflake/cli/api/stage_path.py

@@ -41,6 +41,10 @@ class StagePath:
     def stage(self) -> str:
         return self._stage_name
 
+    @property
+    def stage_fqn(self) -> FQN:
+        return FQN.from_stage(self.stage)
+
     @property
     def path(self) -> PurePosixPath:
         return self._path
@@ -156,10 +160,11 @@ class StagePath:
     def joinpath(self, path: str | Path) -> StagePath:
         if self.is_file():
             raise ValueError("Cannot join path to a file")
-
+        if isinstance(path, Path):
+            path = str(PurePosixPath(path))
         return StagePath(
             stage_name=self._stage_name,
-            path=PurePosixPath(self._path) / str(path).lstrip("/"),
+            path=PurePosixPath(self._path) / path.lstrip("/"),
             git_ref=self._git_ref,
         )
 

snowflake/cli/api/utils/graph.py

@@ -51,6 +51,9 @@ class Graph(Generic[T]):
     def get_all_nodes(self) -> set[Node[T]]:
         return set(self._graph_nodes_map.values())
 
+    def contains_node(self, key: str) -> bool:
+        return self.__contains__(key)
+
     def add(self, node: Node[T]) -> None:
         if node.key in self._graph_nodes_map:
             raise KeyError(f"Node key {node.key} already exists")

snowflake/cli/api/utils/path_utils.py

@@ -14,7 +14,11 @@
 
 from __future__ import annotations
 
+import os
 import sys
+from pathlib import Path
+
+from snowflake.cli.api.secure_path import SecurePath
 
 BUFFER_SIZE = 4096
 
@@ -34,3 +38,23 @@ def path_resolver(path_to_file: str) -> str:
 
 def is_stage_path(path: str) -> bool:
     return path.startswith("@") or path.startswith("snow://")
+
+
+def delete(path: Path) -> None:
+    """
+    Obliterates whatever is at the given path, or is a no-op if the
+    given path does not represent a file or directory that exists.
+    """
+    spath = SecurePath(path)
+    if spath.path.is_file():
+        spath.unlink()  # remove the file
+    elif spath.path.is_dir():
+        spath.rmdir(recursive=True)  # remove dir and all contains
+
+
+def resolve_without_follow(path: Path) -> Path:
+    """
+    Resolves a Path to an absolute version of itself, without following
+    symlinks like Path.resolve() does.
+    """
+    return Path(os.path.abspath(path))

{snowflake_cli-3.3.0.dist-info → snowflake_cli-3.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-cli
-Version: 3.3.0
+Version: 3.4.1
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -217,32 +217,31 @@ Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Database
 Requires-Python: >=3.10
-Requires-Dist: click==8.1.7
-Requires-Dist: gitpython==3.1.43
+Requires-Dist: gitpython==3.1.44
 Requires-Dist: jinja2==3.1.5
 Requires-Dist: packaging
 Requires-Dist: pip
 Requires-Dist: pluggy==1.5.0
-Requires-Dist: pydantic==2.9.2
+Requires-Dist: pydantic==2.10.4
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: requests==2.32.3
 Requires-Dist: requirements-parser==0.11.0
 Requires-Dist: rich==13.9.4
-Requires-Dist: setuptools==75.6.0
-Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.4
+Requires-Dist: setuptools==75.8.0
+Requires-Dist: snowflake-connector-python[secure-local-storage]==3.13.2
 Requires-Dist: snowflake-core==1.0.2; python_version < '3.12'
 Requires-Dist: snowflake-snowpark-python<1.26.0,>=1.15.0; python_version < '3.12'
 Requires-Dist: tomlkit==0.13.2
 Requires-Dist: typer==0.12.5
-Requires-Dist: urllib3<2.3,>=1.24.3
+Requires-Dist: urllib3<2.4,>=1.24.3
 Provides-Extra: development
 Requires-Dist: coverage==7.6.10; extra == 'development'
 Requires-Dist: factory-boy==3.3.1; extra == 'development'
-Requires-Dist: faker==33.1.0; extra == 'development'
+Requires-Dist: faker==35.2.0; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
 Requires-Dist: pytest-randomly==3.16.0; extra == 'development'
 Requires-Dist: pytest==8.3.4; extra == 'development'
-Requires-Dist: syrupy==4.8.0; extra == 'development'
+Requires-Dist: syrupy==4.8.1; extra == 'development'
 Provides-Extra: packaging
 Requires-Dist: pyinstaller~=6.10; extra == 'packaging'
 Description-Content-Type: text/markdown