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

snowflake/cli/app/commands_registration/typer_registration.py

@@ -1,153 +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 logging
-from typing import List
-
-import click
-from snowflake.cli.api.plugins.command import CommandSpec, CommandType
-from snowflake.cli.app.commands_registration import LoadedCommandPlugin
-from snowflake.cli.app.commands_registration.exception_logging import exception_logging
-from typer.core import TyperGroup
-
-log = logging.getLogger(__name__)
-log_exception = exception_logging(log)
-
-
-class TyperCommandsRegistration:
-    def __init__(self, plugins: List[LoadedCommandPlugin]):
-        self._plugins = plugins
-        self._main_typer_command_group = (
-            self._get_main_typer_command_group_from_click_context()
-        )
-
-    def register_commands(self):
-        for plugin in self._plugins:
-            try:
-                self._add_plugin_to_typer(plugin.command_spec)
-            except Exception as ex:
-                log_exception(
-                    f"Cannot register plugin [{plugin.plugin_name}]: {ex.__str__()}", ex
-                )
-
-    @staticmethod
-    def _get_main_typer_command_group_from_click_context() -> TyperGroup:
-        main_typer_command_group = click.get_current_context().command
-        if isinstance(main_typer_command_group, TyperGroup):
-            return main_typer_command_group
-        else:
-            raise RuntimeError(
-                "Invalid main top-level command type. It should be a TyperGroup but it is not."
-            )
-
-    def _add_plugin_to_typer(
-        self,
-        command_spec: CommandSpec,
-    ) -> None:
-        command_spec = self._adjust_command_spec_if_required(command_spec)
-        parent_group = self._find_typer_group_at_path(
-            current_level_group=self._main_typer_command_group,
-            remaining_parent_path_segments=command_spec.parent_command_path.path_segments,
-            command_spec=command_spec,
-        )
-        self._validate_command_spec(command_spec, parent_group)
-        parent_group.add_command(command_spec.command)
-
-    def _adjust_command_spec_if_required(
-        self,
-        command_spec: CommandSpec,
-    ) -> CommandSpec:
-        command_spec = self._add_empty_callback_to_command_spec_if_required(
-            command_spec
-        )
-        return command_spec
-
-    @staticmethod
-    def _add_empty_callback_to_command_spec_if_required(
-        command_spec: CommandSpec,
-    ) -> CommandSpec:
-        new_command_spec = command_spec
-        is_specified_as_command_group = (
-            command_spec.command_type == CommandType.COMMAND_GROUP
-        )
-        is_typer_group = isinstance(command_spec.command, TyperGroup)
-        if is_specified_as_command_group and not is_typer_group:
-            typer_instance = command_spec.typer_instance
-            typer_instance.callback()(lambda: None)
-            new_command_spec = CommandSpec(
-                parent_command_path=command_spec.parent_command_path,
-                command_type=command_spec.command_type,
-                typer_instance=typer_instance,
-            )
-        return new_command_spec
-
-    @staticmethod
-    def _validate_command_spec(
-        command_spec: CommandSpec,
-        parent_group: TyperGroup,
-    ) -> None:
-        command = command_spec.command
-        command_type = command_spec.command_type
-        is_typer_group = isinstance(command, TyperGroup)
-        if command.name in parent_group.commands:
-            raise RuntimeError(
-                f"Cannot add command [{command_spec.full_command_path}] because it already exists."
-            )
-        if command_type == CommandType.SINGLE_COMMAND and is_typer_group:
-            raise RuntimeError(
-                f"Cannot add command [{command_spec.full_command_path}] "
-                + f"because its command type is {CommandType.SINGLE_COMMAND} "
-                + f"while its implementation contains elements "
-                + f"making it a TyperGroup ({CommandType.COMMAND_GROUP}) "
-                + f"(a callback or multiple nested commands)."
-            )
-        if command_type == CommandType.COMMAND_GROUP and not is_typer_group:
-            raise RuntimeError(
-                f"Cannot add command [{command_spec.full_command_path}] "
-                + f"because its command type is {CommandType.COMMAND_GROUP} "
-                + f"while its implementation is not a TyperGroup."
-            )
-
-    def _find_typer_group_at_path(
-        self,
-        current_level_group: TyperGroup,
-        remaining_parent_path_segments: List[str],
-        command_spec: CommandSpec,
-    ) -> TyperGroup:
-        if remaining_parent_path_segments:
-            expected_name = remaining_parent_path_segments[0]
-            matching_subgroups = [
-                subgroup
-                for subgroup in current_level_group.commands.values()
-                if isinstance(subgroup, TyperGroup) and subgroup.name == expected_name
-            ]
-            if matching_subgroups:
-                return self._find_typer_group_at_path(
-                    current_level_group=matching_subgroups[0],
-                    remaining_parent_path_segments=remaining_parent_path_segments[1:],
-                    command_spec=command_spec,
-                )
-            else:
-                raise RuntimeError(
-                    f"Invalid command path [{command_spec.full_command_path}]. "
-                    f"Command group [{expected_name}] does not exist."
-                )
-        else:
-            return current_level_group
-
-
-def register_commands_from_plugins(plugins: List[LoadedCommandPlugin]) -> None:
-    return TyperCommandsRegistration(plugins).register_commands()

snowflake/cli/app/constants.py

@@ -1,19 +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 typing import Literal
-
-PARAM_APPLICATION_NAME: Literal["snowcli"] = "snowcli"

snowflake/cli/app/dev/__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/app/dev/commands_structure.py

@@ -1,48 +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, field
-from typing import Dict
-
-from click import Command
-
-
-@dataclass
-class _Node:
-    name: str
-    children: Dict[str, _Node] = field(default_factory=dict)
-    level: int = 0
-
-    def print_node(self):
-        print("    " * self.level, self.name)
-        for ch in self.children.values():
-            ch.print_node()
-
-
-def generate_commands_structure(command: Command, root: _Node | None = None):
-    """
-    Iterates recursively through commands info. Creates tree-like structure
-    of commands.
-    """
-    if not root:
-        root = _Node(name="snow")
-
-    if hasattr(command, "commands"):
-        for command_name, command_info in command.commands.items():
-            if command_name not in root.children:
-                root.children[command_name] = _Node(command_name, level=root.level + 1)
-            generate_commands_structure(command_info, root.children[command_name])
-    return root

snowflake/cli/app/dev/docs/__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/app/dev/docs/commands_docs_generator.py

@@ -1,100 +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 logging
-from typing import List, Optional
-
-from click import Command
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.app.dev.docs.template_utils import get_template_environment
-from typer.core import TyperArgument
-
-log = logging.getLogger(__name__)
-
-CMD_USAGE_TMPL = "usage.rst.jinja2"
-OVERVIEW_TMPL = "overview.rst.jinja2"
-
-
-def generate_command_docs(
-    root: SecurePath, command: Command, cmd_parts: Optional[List] = None
-):
-    """
-    Iterates recursively through commands info. Creates a file structure resembling
-    commands structure. For each terminal command creates a "usage" rst file.
-    """
-    if getattr(command, "hidden", False):
-        return
-
-    root.mkdir(exist_ok=True)
-    if cmd_parts is None:
-        _render_command_usage(command, root, cmd_parts, template_name=OVERVIEW_TMPL)
-
-    cmd_parts = cmd_parts or []
-    if hasattr(command, "commands"):
-        for command_name, command_info in command.commands.items():
-            path = root / command.name if command.name != "default" else root
-            generate_command_docs(path, command_info, [*cmd_parts, command_name])
-    else:
-        _render_command_usage(command, root, cmd_parts)
-
-
-def get_main_option(options: List[str]) -> str:
-    long_options = [option for option in options if option.startswith("--")]
-    if long_options:
-        return long_options[0]
-
-    short_options = [option for option in options if option.startswith("-")]
-    if short_options:
-        return short_options[0]
-
-    return ""
-
-
-def _render_command_usage(
-    command: Command,
-    root: SecurePath,
-    path: Optional[List] = None,
-    template_name: str = CMD_USAGE_TMPL,
-):
-    # This is end command
-    command_name = command.name
-    env = get_template_environment()
-    env.filters[get_main_option.__name__] = get_main_option
-    template = env.get_template(template_name)
-    arguments = []
-    options = []
-    for param in command.params:
-        if isinstance(param, TyperArgument):
-            arguments.append(param)
-        else:
-            options.append(param)
-
-    # RST files are presumed to be standalone pages in the docs with a matching item in the left nav.
-    # Included files, which these are, need to use the .txt extension.
-    file_path = root / f"usage-{command_name}.txt"
-    log.info("Creating %s", file_path)
-    with file_path.open("w+") as fh:
-        fh.write(
-            template.render(
-                {
-                    "help": command.help,
-                    "name": command_name,
-                    "options": options,
-                    "arguments": arguments,
-                    "path": path,
-                }
-            )
-        )

snowflake/cli/app/dev/docs/generator.py

@@ -1,35 +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 logging
-
-from click import Command
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.app.dev.docs.commands_docs_generator import generate_command_docs
-from snowflake.cli.app.dev.docs.project_definition_docs_generator import (
-    generate_project_definition_docs,
-)
-
-log = logging.getLogger(__name__)
-
-
-def generate_docs(root: SecurePath, command: Command):
-    """
-    Generates documentation for each command, its options and for the project definition.
-    """
-    root.mkdir(exist_ok=True)
-    generate_command_docs(root / "commands", command)
-    generate_project_definition_docs(root / "project_definition")

snowflake/cli/app/dev/docs/project_definition_docs_generator.py

@@ -1,58 +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 logging
-from typing import Any, Dict
-
-from pydantic.json_schema import model_json_schema
-from snowflake.cli.api.project.schemas.project_definition import DefinitionV11
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.app.dev.docs.project_definition_generate_json_schema import (
-    ProjectDefinitionGenerateJsonSchema,
-)
-from snowflake.cli.app.dev.docs.template_utils import get_template_environment
-
-log = logging.getLogger(__name__)
-
-DEFINITION_DESCRIPTION = "definition_description.rst.jinja2"
-
-
-def generate_project_definition_docs(root: SecurePath):
-    """
-    Recursively traverses the generated project definition schema,
-    creating a file for each section that mirrors the YAML structure.
-    Each file contains the definition for every field within that section.
-    """
-
-    root.mkdir(exist_ok=True)
-    list_of_sections = model_json_schema(
-        DefinitionV11, schema_generator=ProjectDefinitionGenerateJsonSchema
-    )["result"]
-    for section in list_of_sections:
-        _render_definition_description(root, section)
-    return
-
-
-def _render_definition_description(root: SecurePath, section: Dict[str, Any]) -> None:
-    env = get_template_environment()
-
-    # RST files are presumed to be standalone pages in the docs with a matching item in the left nav.
-    # Included files, which these are, need to use the .txt extension.
-    file_path = root / f"definition_{section['name']}.txt"
-    log.info("Creating %s", file_path)
-    template = env.get_template(DEFINITION_DESCRIPTION)
-    with file_path.open("w+") as fh:
-        fh.write(template.render(section))

snowflake/cli/app/dev/docs/project_definition_generate_json_schema.py

@@ -1,227 +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 asdict, dataclass
-from typing import Any, Dict, List, Tuple
-
-from pydantic.json_schema import GenerateJsonSchema
-
-
-@dataclass
-class ProjectDefinitionProperty:
-    """
-    Class for storing data of properties to be used in project definition generators.
-    """
-
-    path: str
-    title: str
-    indents: int
-    item_index: int
-    required: bool
-    name: str
-    description: str
-    add_types: bool
-    types: str
-
-
-class ProjectDefinitionGenerateJsonSchema(GenerateJsonSchema):
-    def __init__(self, by_alias: bool = False, ref_template: str = ""):
-        super().__init__(by_alias, "{model}")
-        self._remapped_definitions: Dict[str, Any] = {}
-
-    def generate(self, schema, mode="validation"):
-        """
-        Transforms the generated json from the model to a list of project definition sections with its properties.
-        For example:
-        {
-            "result": [
-                {
-                    "title": "Native app definitions for the project",
-                    "name": "native_app",
-                    "properties": [
-                        {
-                            "path": "Version of the project definition schema, which is currently 1",
-                            "title": "Title of field A",
-                            "indents": 0,
-                            "item_index": 0,
-                            "required": True,
-                            "name": "definition_version",
-                            "add_types": True,
-                            "types": "string | integer",
-                        },
-                        {
-                            "path": "native_app.name",
-                            "title": "Project identifier",
-                            "indents": 1,
-                            "item_index": 0,
-                            "required": True,
-                            "name": "name",
-                            "add_types": True,
-                            "types": "string",
-                        }
-                    ]
-                }
-            ]
-        }
-        """
-        json_schema = super().generate(schema, mode=mode)
-        self._remapped_definitions = json_schema["$defs"]
-        return {"result": self._get_definition_sections(json_schema)}
-
-    def _get_definition_sections(
-        self, current_definition: Dict[str, Any]
-    ) -> List[Dict[str, Any]]:
-        required_properties: List[Dict[str, Any]] = []
-        sections: List[Dict[str, Any]] = []
-
-        for property_name, property_model in current_definition["properties"].items():
-            is_required = (
-                "required" in current_definition
-                and property_name in current_definition["required"]
-            )
-            children_properties = self._get_children_properties(
-                property_model, property_name
-            )
-
-            new_property = ProjectDefinitionProperty(
-                path=property_name,
-                title=property_model.get("title", ""),
-                description=property_model.get("description", ""),
-                indents=0,
-                item_index=0,
-                required=is_required,
-                name=property_name,
-                add_types=len(children_properties) == 0,
-                types=" | ".join(self._get_property_types(property_model)),
-            )
-            properties = [asdict(new_property)] + children_properties
-
-            if is_required:
-                required_properties.extend(properties)
-            else:
-                sections.append(
-                    {
-                        "properties": properties,
-                        "title": property_model["title"],
-                        "name": property_name,
-                    }
-                )
-
-        for section in sections:
-            section["properties"] = required_properties + section["properties"]
-
-        return sections
-
-    def _get_section_properties(
-        self,
-        current_definition: Dict[str, Any],
-        current_path: str = "",
-        depth: int = 0,
-        is_array_item: bool = False,
-    ) -> List[Dict[str, Any]]:
-        required_properties: List[Dict[str, Any]] = []
-        optional_properties: List[Dict[str, Any]] = []
-        item_index = 0
-
-        for property_name, property_model in current_definition["properties"].items():
-            item_index += 1 if is_array_item else 0
-            is_required = (
-                "required" in current_definition
-                and property_name in current_definition["required"]
-            )
-            new_current_path = (
-                property_name
-                if current_path == ""
-                else current_path + "." + property_name
-            )
-            children_properties = self._get_children_properties(
-                property_model, new_current_path, depth
-            )
-            new_property = ProjectDefinitionProperty(
-                path=new_current_path,
-                title=property_model.get("title", ""),
-                description=property_model.get("description", ""),
-                indents=depth,
-                item_index=item_index,
-                required=is_required,
-                name=property_name,
-                add_types=len(children_properties) == 0,
-                types=" | ".join(self._get_property_types(property_model)),
-            )
-            properties = [asdict(new_property)] + children_properties
-            if is_required:
-                required_properties.extend(properties)
-            else:
-                optional_properties.extend(properties)
-        return required_properties + optional_properties
-
-    def _get_children_properties(
-        self,
-        property_model: Dict[str, Any],
-        current_path: str,
-        depth: int = 0,
-    ) -> List[Dict[str, Any]]:
-        child_properties: List[Dict[str, Any]] = []
-        references: List[Tuple[str, bool]] = self._get_property_references(
-            property_model
-        )
-        for reference, is_array_item in references:
-            child_properties.extend(
-                self._get_section_properties(
-                    self._remapped_definitions[reference],
-                    current_path,
-                    depth + 1,
-                    is_array_item,
-                )
-            )
-
-        return child_properties
-
-    def _get_property_references(
-        self,
-        model_with_type: Dict[str, Any],
-        is_array_item: bool = False,
-    ) -> list[tuple[str, bool]]:
-        result: List[Tuple[str, bool]] = []
-
-        if "$ref" in model_with_type:
-            return [(model_with_type["$ref"], is_array_item)]
-
-        if "type" in model_with_type and model_with_type["type"] == "array":
-            result.extend(self._get_property_references(model_with_type["items"], True))
-
-        if "anyOf" in model_with_type:
-            for property_type in model_with_type["anyOf"]:
-                result.extend(
-                    self._get_property_references(property_type, is_array_item)
-                )
-        return result
-
-    def _get_property_types(self, model_with_type: Dict[str, Any]) -> list[str]:
-        types_result: List[str] = []
-        if "type" in model_with_type:
-            if model_with_type["type"] == "array":
-                items_types = self._get_property_types(model_with_type["items"])
-                if len(items_types) > 0:
-                    types_result.append(f"array[{' | '.join(items_types)}]")
-
-            elif model_with_type["type"] != "null":
-                types_result.append(model_with_type["type"])
-        elif "anyOf" in model_with_type:
-            for property_type in model_with_type["anyOf"]:
-                types = self._get_property_types(property_type)
-                types_result.extend(types)
-        return types_result