snowflake-cli-labs 2.8.0rc1__py3-none-any.whl → 2.8.2__py3-none-any.whl

snowflake/cli/api/identifiers.py

@@ -1,154 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 __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, identifier_for_url
-
-
-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 prefix(self) -> str:
-        if self.database:
-            return f"{self.database}.{self.schema if self.schema else 'PUBLIC'}"
-        if self.schema:
-            return f"{self.schema}"
-        return ""
-
-    @property
-    def identifier(self) -> str:
-        if self.prefix:
-            return f"{self.prefix}.{self.name}"
-        return self.name
-
-    @property
-    def url_identifier(self) -> str:
-        return ".".join(identifier_for_url(part) for part in self.identifier.split("."))
-
-    @property
-    def sql_identifier(self) -> str:
-        return f"IDENTIFIER('{self.identifier}')"
-
-    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_stage(cls, stage: str) -> "FQN":
-        name = stage
-        if stage.startswith("@"):
-            name = stage[1:]
-        return cls.from_string(name)
-
-    @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/output/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.

snowflake/cli/api/output/formats.py

@@ -1,20 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 enum import Enum
-
-
-class OutputFormat(Enum):
-    TABLE = "TABLE"
-    JSON = "JSON"

snowflake/cli/api/output/types.py

@@ -1,118 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 __future__ import annotations
-
-import json
-import typing as t
-
-from snowflake.connector import DictCursor
-from snowflake.connector.cursor import SnowflakeCursor
-
-
-class CommandResult:
-    @property
-    def result(self):
-        raise NotImplementedError()
-
-
-class ObjectResult(CommandResult):
-    def __init__(self, element: t.Dict):
-        self._element = element
-
-    @property
-    def result(self):
-        return self._element
-
-
-class CollectionResult(CommandResult):
-    def __init__(self, elements: t.Iterable[t.Dict]):
-        self._elements = elements
-
-    @property
-    def result(self):
-        yield from self._elements
-
-
-class MultipleResults(CommandResult):
-    def __init__(self, elements: t.Iterable[CommandResult] | None = None):
-        self._elements = elements or []
-
-    def add(self, element: CommandResult):
-        self._elements.append(element)  # type: ignore
-
-    @property
-    def result(self):
-        return (element for element in self._elements)
-
-
-class StreamResult(CommandResult):
-    def __init__(self, generator: t.Generator[CommandResult, None, None]):
-        self._generator = generator
-
-    @property
-    def result(self):
-        return self._generator
-
-
-class QueryResult(CollectionResult):
-    def __init__(self, cursor: SnowflakeCursor | DictCursor):
-        self.column_names = [col.name for col in cursor.description]
-        super().__init__(elements=self._prepare_payload(cursor))
-        self._query = cursor.query
-
-    def _prepare_payload(self, cursor: SnowflakeCursor | DictCursor):
-        if isinstance(cursor, DictCursor):
-            return (k for k in cursor)
-        return ({k: v for k, v in zip(self.column_names, row)} for row in cursor)
-
-    @property
-    def query(self):
-        return self._query
-
-
-class SingleQueryResult(ObjectResult):
-    def __init__(self, cursor: SnowflakeCursor):
-        super().__init__(element=self._prepare_payload(cursor))
-
-    def _prepare_payload(self, cursor):
-        results = list(QueryResult(cursor).result)
-        if results:
-            return results[0]
-        return None
-
-
-class QueryJsonValueResult(QueryResult):
-    def __init__(self, cursor: SnowflakeCursor):
-        super().__init__(cursor)
-
-    def _prepare_payload(self, cursor):
-        results = list(QueryResult(cursor).result)
-        if results:
-            # Return value of the first tuple
-            return json.loads(list(results[0].items())[0][1])
-        return None
-
-
-class MessageResult(CommandResult):
-    def __init__(self, message: str):
-        self._message = message
-
-    @property
-    def message(self):
-        return self._message
-
-    @property
-    def result(self):
-        return {"message": self._message}

snowflake/cli/api/plugins/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.

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

@@ -1,72 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 __future__ import annotations
-
-from dataclasses import dataclass
-from enum import Enum
-from functools import cached_property
-from typing import List
-
-import click
-import pluggy
-from typer import Typer
-from typer.main import get_command
-
-SNOWCLI_COMMAND_PLUGIN_NAMESPACE = "snowflake.cli.plugin.command"
-
-plugin_hook_spec = pluggy.HookspecMarker(SNOWCLI_COMMAND_PLUGIN_NAMESPACE)
-plugin_hook_impl = pluggy.HookimplMarker(SNOWCLI_COMMAND_PLUGIN_NAMESPACE)
-
-
-class CommandPath:
-    def __init__(self, path_segments: List[str]):
-        self._path_segments = tuple(path_segments)
-
-    @property
-    def path_segments(self) -> List[str]:
-        return list(self._path_segments)
-
-    def __hash__(self):
-        return hash(self._path_segments)
-
-    def __eq__(self, other):
-        return self._path_segments == other._path_segments
-
-    def __str__(self) -> str:
-        return "snow " + " ".join(self.path_segments)
-
-
-SNOWCLI_ROOT_COMMAND_PATH = CommandPath(path_segments=[])
-
-
-class CommandType(Enum):
-    SINGLE_COMMAND = "SINGLE_COMMAND"
-    COMMAND_GROUP = "COMMAND_GROUP"
-
-
-@dataclass(frozen=True)
-class CommandSpec:
-    parent_command_path: CommandPath
-    command_type: CommandType
-    typer_instance: Typer
-
-    @cached_property
-    def command(self) -> click.Command:
-        self.typer_instance._add_completion = False  # noqa: SLF001
-        return get_command(self.typer_instance)
-
-    @cached_property
-    def full_command_path(self) -> CommandPath:
-        return CommandPath(self.parent_command_path.path_segments + [self.command.name])

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

@@ -1,21 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 snowflake.cli.api.plugins.command import plugin_hook_spec
-
-
-@plugin_hook_spec
-def command_spec():
-    """Command spec"""
-    pass

snowflake/cli/api/plugins/plugin_config.py

@@ -1,32 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Any, Dict, List
-
-
-@dataclass
-class PluginConfig:
-    is_plugin_enabled: bool
-    internal_config: Dict[str, Any]
-
-
-class PluginConfigProvider:
-    def get_enabled_plugin_names(self) -> List[str]:
-        raise NotImplementedError()
-
-    def get_config(self, plugin_name: str) -> PluginConfig:
-        raise NotImplementedError()

snowflake/cli/api/project/__init__.py

@@ -1,13 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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.

snowflake/cli/api/project/definition.py

@@ -1,84 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 __future__ import annotations
-
-from pathlib import Path
-from typing import List, Optional
-
-import yaml
-from snowflake.cli.api.cli_global_context import cli_context
-from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.project.schemas.project_definition import (
-    ProjectProperties,
-)
-from snowflake.cli.api.project.util import (
-    append_to_identifier,
-    get_env_username,
-    sanitize_identifier,
-    to_identifier,
-)
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.utils.definition_rendering import render_definition_template
-from snowflake.cli.api.utils.dict_utils import deep_merge_dicts
-from snowflake.cli.api.utils.types import Context, Definition
-
-DEFAULT_USERNAME = "unknown_user"
-
-
-def _get_merged_definitions(paths: List[Path]) -> Optional[Definition]:
-    spaths: List[SecurePath] = [SecurePath(p) for p in paths]
-    if len(spaths) == 0:
-        return None
-
-    with spaths[0].open("r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as base_yml:
-        definition = yaml.load(base_yml.read(), Loader=yaml.loader.BaseLoader) or {}
-
-    for override_path in spaths[1:]:
-        with override_path.open(
-            "r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB
-        ) as override_yml:
-            overrides = (
-                yaml.load(override_yml.read(), Loader=yaml.loader.BaseLoader) or {}
-            )
-            deep_merge_dicts(definition, overrides)
-
-    return definition
-
-
-def load_project(
-    paths: List[Path], context_overrides: Optional[Context] = None
-) -> ProjectProperties:
-    """
-    Loads project definition, optionally overriding values. Definition values
-    are merged in left-to-right order (increasing precedence).
-    Templating is also applied after the merging process.
-    """
-    merged_definitions = _get_merged_definitions(paths)
-    return render_definition_template(merged_definitions, context_overrides or {})
-
-
-def default_app_package(project_name: str):
-    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
-    return append_to_identifier(to_identifier(project_name), f"_pkg_{user}")
-
-
-def default_role():
-    conn = cli_context.connection
-    return conn.role
-
-
-def default_application(project_name: str):
-    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
-    return append_to_identifier(to_identifier(project_name), f"_{user}")

snowflake/cli/api/project/definition_manager.py

@@ -1,134 +0,0 @@
-# Copyright (c) 2024 Snowflake Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# 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 __future__ import annotations
-
-import functools
-import os
-from pathlib import Path
-from typing import List, Optional
-
-from snowflake.cli.api.project.definition import ProjectProperties, load_project
-from snowflake.cli.api.project.schemas.project_definition import ProjectDefinitionV1
-from snowflake.cli.api.utils.types import Context
-
-
-def _compat_is_mount(path: Path):
-    try:
-        return path.is_mount()
-    except NotImplementedError:
-        # If we can't figure out if path is mount then let's assume it is
-        # Windows support added in Python 3.12
-        return True
-
-
-class DefinitionManager:
-    BASE_DEFINITION_FILENAME = "snowflake.yml"
-    USER_DEFINITION_FILENAME = "snowflake.local.yml"
-
-    project_root: Path
-    _project_config_paths: List[Path]
-
-    def __init__(
-        self,
-        project_arg: Optional[str] = None,
-        context_overrides: Optional[Context] = None,
-    ) -> None:
-        project_root = Path(
-            os.path.abspath(project_arg) if project_arg else os.getcwd()
-        )
-
-        self.project_root = project_root
-        self._project_config_paths = self._find_definition_files(self.project_root)
-        self._context_overrides = context_overrides
-
-    @functools.cached_property
-    def has_definition_file(self):
-        return len(self._project_config_paths) > 0
-
-    @staticmethod
-    def _find_definition_files(project_root: Path) -> List[Path]:
-        base_config_file_path = DefinitionManager._base_definition_file_if_available(
-            project_root
-        )
-        user_config_file_path = DefinitionManager._user_definition_file_if_available(
-            project_root
-        )
-
-        definition_files: List[Path] = []
-        if base_config_file_path:
-            definition_files.append(base_config_file_path)
-            if user_config_file_path:
-                definition_files.append(user_config_file_path)
-
-        return definition_files
-
-    @staticmethod
-    def find_project_root(search_path: Path) -> Optional[Path]:
-        """
-        Recurse up the directory tree from the given search path until we find
-        a directory that contains a snowflake.yml file. We'll stop if we cross
-        a filesystem boundary or hit the user's HOME directory.
-        """
-        current_path = search_path
-        starting_mount = _compat_is_mount(search_path)
-        while current_path:
-            if (
-                _compat_is_mount(current_path) != starting_mount
-                or current_path.parent == current_path
-                or current_path == Path.home()
-            ):
-                return None
-
-            if (
-                DefinitionManager._base_definition_file_if_available(current_path)
-                is not None
-            ):
-                # found snowflake.yml, end the search here
-                return current_path
-
-            current_path = current_path.parent
-
-        return None
-
-    @staticmethod
-    def _definition_if_available(filename, project_path: Path) -> Optional[Path]:
-        file_path = Path(project_path) / filename
-        if file_path.is_file():
-            return file_path
-        return None
-
-    @staticmethod
-    def _base_definition_file_if_available(project_path: Path) -> Optional[Path]:
-        return DefinitionManager._definition_if_available(
-            DefinitionManager.BASE_DEFINITION_FILENAME, project_path
-        )
-
-    @staticmethod
-    def _user_definition_file_if_available(project_path: Path) -> Optional[Path]:
-        return DefinitionManager._definition_if_available(
-            DefinitionManager.USER_DEFINITION_FILENAME, project_path
-        )
-
-    @functools.cached_property
-    def _project_properties(self) -> ProjectProperties:
-        return load_project(self._project_config_paths, self._context_overrides)
-
-    @functools.cached_property
-    def project_definition(self) -> ProjectDefinitionV1:
-        return self._project_properties.project_definition
-
-    @functools.cached_property
-    def template_context(self) -> Context:
-        return self._project_properties.project_context