snowflake-cli-labs 2.3.1__py3-none-any.whl → 2.4.0rc1__py3-none-any.whl

snowflake/cli/__about__.py

@@ -1,3 +1,3 @@
 from __future__ import annotations
 
-VERSION = "2.3.1"
+VERSION = "2.4.0rc1"

snowflake/cli/api/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Optional
 
 from snowflake.cli.api.plugins.plugin_config import PluginConfigProvider

snowflake/cli/api/cli_global_context.py

@@ -1,9 +1,12 @@
+from __future__ import annotations
+
 import re
 from pathlib import Path
 from typing import Dict, Optional
 
 from snowflake.cli.api.exceptions import InvalidSchemaError
 from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
 from snowflake.connector import SnowflakeConnection
 
 schema_pattern = re.compile(r".+\..+")
@@ -280,6 +283,10 @@ class _CliGlobalContextAccess:
     def connection(self) -> SnowflakeConnection:
         return self._manager.connection
 
+    @property
+    def connection_context(self) -> _ConnectionContext:
+        return self._manager.connection_context
+
     @property
     def enable_tracebacks(self) -> bool:
         return self._manager.enable_tracebacks
@@ -297,7 +304,7 @@ class _CliGlobalContextAccess:
         return self._manager.experimental
 
     @property
-    def project_definition(self):
+    def project_definition(self) -> ProjectDefinition | None:
         return self._manager.project_definition
 
     @property

snowflake/cli/api/commands/decorators.py

@@ -29,7 +29,7 @@ from snowflake.cli.api.commands.flags import (
     VerboseOption,
     WarehouseOption,
     experimental_option,
-    project_definition_option,
+    project_type_option,
 )
 from snowflake.cli.api.exceptions import CommandReturnTypeError
 from snowflake.cli.api.output.formats import OutputFormat
@@ -67,7 +67,7 @@ def with_project_definition(project_name: str):
                     "project_definition",
                     inspect.Parameter.KEYWORD_ONLY,
                     annotation=Optional[str],
-                    default=project_definition_option(project_name),
+                    default=project_type_option(project_name),
                 )
             ],
         )

snowflake/cli/api/commands/flags.py

@@ -12,6 +12,7 @@ import typer
 from click import ClickException
 from snowflake.cli.api.cli_global_context import cli_context_manager
 from snowflake.cli.api.console import cli_console
+from snowflake.cli.api.exceptions import MissingConfiguration
 from snowflake.cli.api.output.formats import OutputFormat
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
@@ -416,7 +417,6 @@ VariablesOption = typer.Option(
     "--variable",
     "-D",
     help="Variables for the template. For example: `-D \"<key>=<value>\"`, string values must be in `''`.",
-    hidden=True,
     show_default=False,
 )
 
@@ -469,17 +469,21 @@ def experimental_option(
 
 def identifier_argument(sf_object: str, example: str) -> typer.Argument:
     return typer.Argument(
-        ..., help=f"Identifier of the {sf_object}. For example: {example}"
+        ...,
+        help=f"Identifier of the {sf_object}. For example: {example}",
+        show_default=False,
     )
 
 
 def execution_identifier_argument(sf_object: str, example: str) -> typer.Argument:
     return typer.Argument(
-        ..., help=f"Execution identifier of the {sf_object}. For example: {example}"
+        ...,
+        help=f"Execution identifier of the {sf_object}. For example: {example}",
+        show_default=False,
     )
 
 
-def project_definition_option(project_name: str):
+def project_type_option(project_name: str):
     from snowflake.cli.api.exceptions import NoProjectDefinitionError
     from snowflake.cli.api.project.definition_manager import DefinitionManager
 
@@ -515,6 +519,47 @@ def project_definition_option(project_name: str):
     )
 
 
+def project_definition_option(optional: bool = False):
+    from snowflake.cli.api.project.definition_manager import DefinitionManager
+
+    def _callback(project_path: Optional[str]):
+        try:
+            dm = DefinitionManager(project_path)
+            project_definition = dm.project_definition
+            project_root = dm.project_root
+        except MissingConfiguration:
+            if optional:
+                project_definition = None
+                project_root = None
+            else:
+                raise
+        cli_context_manager.set_project_definition(project_definition)
+        cli_context_manager.set_project_root(project_root)
+        return project_definition
+
+    return typer.Option(
+        None,
+        "-p",
+        "--project",
+        help=f"Path where Snowflake project resides. Defaults to current working directory.",
+        callback=_callback,
+        show_default=False,
+    )
+
+
+def readable_file_option(param_name: str, help_str: str) -> typer.Option:
+    return typer.Option(
+        None,
+        param_name,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        readable=True,
+        help=help_str,
+        show_default=False,
+    )
+
+
 def deprecated_flag_callback(msg: str):
     def _warning_callback(ctx: click.Context, param: click.Parameter, value: Any):
         if ctx.get_parameter_source(param.name) != click.core.ParameterSource.DEFAULT:  # type: ignore[attr-defined]

snowflake/cli/api/commands/snow_typer.py

@@ -22,6 +22,8 @@ class SnowTyper(typer.Typer):
             **kwargs,
             context_settings=DEFAULT_CONTEXT_SETTINGS,
             pretty_exceptions_show_locals=False,
+            no_args_is_help=True,
+            add_completion=True,
         )
 
     @wraps(typer.Typer.command)

snowflake/cli/api/console/abc.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
 from typing import Callable, Iterator, Optional

snowflake/cli/api/console/console.py

@@ -57,11 +57,12 @@ class CliConsole(AbstractConsole):
         self._print(self._format_message(enter_message, Output.PHASE))
         self._in_phase = True
 
-        yield self.step
-
-        self._in_phase = False
-        if exit_message:
-            self._print(self._format_message(exit_message, Output.PHASE))
+        try:
+            yield self.step
+        finally:
+            self._in_phase = False
+            if exit_message:
+                self._print(self._format_message(exit_message, Output.PHASE))
 
     def step(self, message: str):
         """Displays a message to output.

snowflake/cli/api/constants.py

@@ -23,6 +23,11 @@ class ObjectType(Enum):
     DATABASE = ObjectNames("database", "database", "databases")
     FUNCTION = ObjectNames("function", "function", "functions")
     INTEGRATION = ObjectNames("integration", "integration", "integrations")
+    EXTERNAL_ACCESS_INTEGRATION = ObjectNames(
+        "external-access-integration",
+        "external access integration",
+        "external access integrations",
+    )
     # JOB = ObjectNames("job", "job", "jobs")
     NETWORK_RULE = ObjectNames("network-rule", "network rule", "network rules")
     PROCEDURE = ObjectNames("procedure", "procedure", "procedures")

snowflake/cli/api/exceptions.py

@@ -128,3 +128,15 @@ class SchemaNotProvidedError(ClickException):
         super().__init__(
             "Schema not specified. Please update connection to add `schema` parameter, or re-run command using `--schema` option. Use `snow connection list` to list existing connections."
         )
+
+
+class FQNNameError(ClickException):
+    def __init__(self, name: str):
+        super().__init__(f"Specified name '{name}' is not valid name.")
+
+
+class FQNInconsistencyError(ClickException):
+    def __init__(self, part: str, name: str):
+        super().__init__(
+            f"{part.capitalize()} provided but name '{name}' is fully qualified name."
+        )

snowflake/cli/api/identifiers.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import re
+
+from click import ClickException
+from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.exceptions import FQNInconsistencyError, FQNNameError
+from snowflake.cli.api.project.schemas.identifier_model import ObjectIdentifierBaseModel
+from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, unquote_identifier
+
+
+class FQN:
+    """
+    Class representing an identifier and supporting fully qualified names.
+
+    The instance supports builder pattern that allows updating the identifier with database and
+    schema from different sources. For example:
+
+    fqn = FQN.from_string("my_schema.object").using_connection(conn)
+    fqn = FQN.from_identifier_model(cli_context.project_definition.streamlit).using_context()
+    fqn = FQN.from_string("my_name").set_database("db").set_schema("foo")
+    """
+
+    def __init__(self, database: str | None, schema: str | None, name: str):
+        self._database = database
+        self._schema = schema
+        self._name = name
+
+    @property
+    def database(self) -> str | None:
+        return self._database
+
+    @property
+    def schema(self) -> str | None:
+        return self._schema
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def identifier(self) -> str:
+        if self.database:
+            return f"{self.database}.{self.schema if self.schema else 'PUBLIC'}.{self.name}"
+        if self.schema:
+            return f"{self.schema}.{self.name}"
+        return self.name
+
+    @property
+    def url_identifier(self) -> str:
+        return ".".join(unquote_identifier(part) for part in self.identifier.split("."))
+
+    def __str__(self):
+        return self.identifier
+
+    def __eq__(self, other):
+        return self.identifier == other.identifier
+
+    @classmethod
+    def from_string(cls, identifier: str) -> "FQN":
+        """
+        Takes in an object name in the form [[database.]schema.]name. Returns a FQN instance.
+        """
+        qualifier_pattern = rf"(?:(?P<first_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?:(?P<second_qualifier>{VALID_IDENTIFIER_REGEX})\.)?(?P<name>{VALID_IDENTIFIER_REGEX})(?P<signature>\(.*\))?"
+        result = re.fullmatch(qualifier_pattern, identifier)
+
+        if result is None:
+            raise FQNNameError(identifier)
+
+        unqualified_name = result.group("name")
+        if result.group("second_qualifier") is not None:
+            database = result.group("first_qualifier")
+            schema = result.group("second_qualifier")
+        else:
+            database = None
+            schema = result.group("first_qualifier")
+        if signature := result.group("signature"):
+            unqualified_name = unqualified_name + signature
+        return cls(name=unqualified_name, schema=schema, database=database)
+
+    @classmethod
+    def from_identifier_model(cls, model: ObjectIdentifierBaseModel) -> "FQN":
+        """Create an instance from object model."""
+        if not isinstance(model, ObjectIdentifierBaseModel):
+            raise ClickException(
+                f"Expected {type(ObjectIdentifierBaseModel)}, got {model}."
+            )
+
+        fqn = cls.from_string(model.name)
+
+        if fqn.database and model.database:
+            raise FQNInconsistencyError("database", model.name)
+        if fqn.schema and model.schema_name:
+            raise FQNInconsistencyError("schema", model.name)
+
+        return fqn.set_database(model.database).set_schema(model.schema_name)
+
+    def set_database(self, database: str | None) -> "FQN":
+        if database:
+            self._database = database
+        return self
+
+    def set_schema(self, schema: str | None) -> "FQN":
+        if schema:
+            self._schema = schema
+        return self
+
+    def set_name(self, name: str) -> "FQN":
+        self._name = name
+        return self
+
+    def using_connection(self, conn) -> "FQN":
+        """Update the instance with database and schema from connection."""
+        # Update the identifier only it if wasn't already a qualified name
+        if conn.database and not self.database:
+            self.set_database(conn.database)
+        if conn.schema and not self.schema:
+            self.set_schema(conn.schema)
+        return self
+
+    def using_context(self) -> "FQN":
+        """Update the instance with database and schema from connection in current cli context."""
+        return self.using_connection(cli_context.connection)

snowflake/cli/api/plugins/command/__init__.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from enum import Enum
 from functools import cached_property

snowflake/cli/api/plugins/plugin_config.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from typing import Any, Dict, List
 

snowflake/cli/api/project/definition.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from pathlib import Path
 from typing import List
 

snowflake/cli/api/project/errors.py

@@ -6,14 +6,14 @@ from pydantic import ValidationError
 class SchemaValidationError(Exception):
     generic_message = "For field {loc} you provided '{loc}'. This caused: {msg}"
     message_templates = {
-        "string_type": "{msg} for field '{loc}', you provided '{input}'",
-        "extra_forbidden": "{msg}. You provided field '{loc}' with value '{input}' that is not present in the schema",
+        "string_type": "{msg} for field '{loc}', you provided '{input}'.",
+        "extra_forbidden": "{msg}. You provided field '{loc}' with value '{input}' that is not supported in given version.",
         "missing": "Your project definition is missing following fields: {loc}",
     }
 
     def __init__(self, error: ValidationError):
         errors = error.errors()
-        message = f"During evaluation of {error.title} schema following errors were encountered:\n"
+        message = f"During evaluation of {error.title} in project definition following errors were encountered:\n"
         message += "\n".join(
             [
                 self.message_templates.get(e["type"], self.generic_message).format(**e)

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

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Optional, cast
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
+
+
+class ObjectIdentifierBaseModel:
+    """
+    Type representing a base class defining object that can be identified by fully qualified name (db.schema.name).
+    This is not a Pydantic model and the purpose of this class is to provide typing support to Pydantic models
+    generated using a factory class ObjectIdentifierModel.
+    """
+
+    name: str
+    database: Optional[str]
+    schema_name: Optional[str]
+
+
+def ObjectIdentifierModel(object_name: str) -> ObjectIdentifierBaseModel:  # noqa: N802
+    """Generates ObjectIdentifierBaseModel but with object specific descriptions."""
+
+    class _ObjectIdentifierModel(ObjectIdentifierBaseModel):
+        name: str = Field(title=f"{object_name} name")
+        database: Optional[str] = IdentifierField(
+            title=f"Name of the database for the {object_name}", default=None
+        )
+        schema_name: Optional[str] = IdentifierField(
+            title=f"Name of the schema for the {object_name}",
+            default=None,
+            alias="schema",
+        )
+
+    return cast(ObjectIdentifierBaseModel, _ObjectIdentifierModel)

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

@@ -24,6 +24,10 @@ class NativeApp(UpdatableModel):
         title="Folder at the root of your project where the build step copies the artifacts.",
         default="output/deploy/",
     )
+    generated_root: Optional[str] = Field(
+        title="Subdirectory of the deploy root where files generated by the Snowflake CLI will be written.",
+        default="__generated/",
+    )
     source_stage: Optional[str] = Field(
         title="Identifier of the stage that stores the application artifacts.",
         default="app_src.stage",

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

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Union
 
-from pydantic import Field
+from pydantic import Field, field_validator
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 
 
-class AnnotationProcessor(UpdatableModel):
+class ProcessorMapping(UpdatableModel):
     name: str = Field(
         title="Name of a processor to invoke on a collection of artifacts."
     )
@@ -19,4 +19,22 @@ class AnnotationProcessor(UpdatableModel):
 class PathMapping(UpdatableModel):
     src: str
     dest: Optional[str] = None
-    processors: Optional[List[Union[str, AnnotationProcessor]]] = None
+    processors: Optional[List[Union[str, ProcessorMapping]]] = []
+
+    @field_validator("processors")
+    @classmethod
+    def transform_processors(
+        cls, input_values: Optional[List[Union[str, Dict, 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

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

@@ -1,20 +1,36 @@
 from __future__ import annotations
 
-from typing import Optional
+from typing import Any, Dict, Optional, Union
 
-from pydantic import Field
+from packaging.version import Version
+from pydantic import Field, field_validator
 from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
 from snowflake.cli.api.project.schemas.snowpark.snowpark import Snowpark
 from snowflake.cli.api.project.schemas.streamlit.streamlit import Streamlit
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.utils.models import EnvironWithDefinedDictFallback
 
 
-class ProjectDefinition(UpdatableModel):
-    definition_version: int = Field(
+class _BaseDefinition(UpdatableModel):
+    definition_version: Union[str, int] = Field(
         title="Version of the project definition schema, which is currently 1",
-        ge=1,
-        le=1,
     )
+
+    @field_validator("definition_version")
+    @classmethod
+    def _is_supported_version(cls, version: str) -> str:
+        version = str(version)
+        if version not in _version_map:
+            raise ValueError(
+                f'Version {version} is not supported. Supported versions: {", ".join(_version_map)}'
+            )
+        return version
+
+    def meets_version_requirement(self, required_version: str) -> bool:
+        return Version(self.definition_version) >= Version(required_version)
+
+
+class _DefinitionV10(_BaseDefinition):
     native_app: Optional[NativeApp] = Field(
         title="Native app definitions for the project", default=None
     )
@@ -25,3 +41,39 @@ class ProjectDefinition(UpdatableModel):
     streamlit: Optional[Streamlit] = Field(
         title="Streamlit definitions for the project", default=None
     )
+
+
+class _DefinitionV11(_DefinitionV10):
+    env: Optional[Dict] = Field(
+        title="Environment specification for this project.",
+        default=None,
+        validation_alias="env",
+    )
+
+    @field_validator("env")
+    @classmethod
+    def _convert_env(cls, env: Optional[Dict]) -> EnvironWithDefinedDictFallback:
+        variables = EnvironWithDefinedDictFallback(env if env else {})
+        return variables
+
+
+class ProjectDefinition(_DefinitionV11):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._validate(kwargs)
+
+    @staticmethod
+    def _validate(data: Any):
+        if not isinstance(data, dict):
+            return
+        if version := str(data.get("definition_version")):
+            version_model = _version_map.get(version)
+            if not version_model:
+                raise ValueError(
+                    f"Unknown schema version: {version}. Supported version: {_supported_version}"
+                )
+            version_model(**data)
+
+
+_version_map = {"1": _DefinitionV10, "1.1": _DefinitionV11}
+_supported_version = tuple(_version_map.keys())

snowflake/cli/api/project/schemas/snowpark/argument.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Optional
 
 from pydantic import Field

snowflake/cli/api/project/schemas/snowpark/callable.py

@@ -1,26 +1,16 @@
+from __future__ import annotations
+
 from typing import Dict, List, Optional, Union
 
 from pydantic import Field, field_validator
+from snowflake.cli.api.project.schemas.identifier_model import ObjectIdentifierModel
 from snowflake.cli.api.project.schemas.snowpark.argument import Argument
 from snowflake.cli.api.project.schemas.updatable_model import (
-    IdentifierField,
     UpdatableModel,
 )
 
 
-class Callable(UpdatableModel):
-    name: str = Field(
-        title="Object identifier"
-    )  # TODO: implement validator. If a name is filly qualified, database and schema cannot be specified
-    database: Optional[str] = IdentifierField(
-        title="Name of the database for the function or procedure", default=None
-    )
-
-    schema_name: Optional[str] = IdentifierField(
-        title="Name of the schema for the function or procedure",
-        default=None,
-        alias="schema",
-    )
+class _CallableBase(UpdatableModel):
     handler: str = Field(
         title="Function’s or procedure’s implementation of the object inside source module",
         examples=["functions.hello_function"],
@@ -55,12 +45,13 @@ class Callable(UpdatableModel):
         return runtime_input
 
 
-class FunctionSchema(Callable):
+class FunctionSchema(_CallableBase, ObjectIdentifierModel(object_name="function")):  # type: ignore
     pass
 
 
-class ProcedureSchema(Callable):
+class ProcedureSchema(_CallableBase, ObjectIdentifierModel(object_name="procedure")):  # type: ignore
     execute_as_caller: Optional[bool] = Field(
-        title="Determine whether the procedure is executed with the privileges of the owner (you) or with the privileges of the caller",
+        title="Determine whether the procedure is executed with the privileges of "
+        "the owner (you) or with the privileges of the caller",
         default=False,
     )

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

@@ -3,11 +3,11 @@ from __future__ import annotations
 from typing import List, Optional
 
 from pydantic import Field
+from snowflake.cli.api.project.schemas.identifier_model import ObjectIdentifierModel
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 
 
-class Streamlit(UpdatableModel):
-    name: str = Field(title="App identifier")
+class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):  # type: ignore
     stage: Optional[str] = Field(
         title="Stage in which the app’s artifacts will be stored", default="streamlit"
     )

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

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from typing import Any, Dict
 
 from pydantic import BaseModel, ConfigDict, Field, ValidationError

snowflake/cli/api/project/util.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import codecs
 import os
 import re

snowflake/cli/api/secure_path.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import errno
 import logging
 import os