snowflake-cli 3.1.0__py3-none-any.whl → 3.2.0__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/entities/models/event_sharing_telemetry.py

@@ -0,0 +1,58 @@
+# 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 typing import List, Optional
+
+from click import ClickException
+from pydantic import Field, field_validator, model_validator
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+
+
+class EventSharingTelemetry(UpdatableModel):
+    share_mandatory_events: Optional[bool] = Field(
+        title="Indicates whether Snowflake is authorized to share application usage data with the application package provider. When enabled, mandatory events will be shared automatically.",
+        default=None,
+    )
+    optional_shared_events: Optional[List[str]] = Field(
+        title="A list of optional telemetry events that the application owner consents to share with the application package provider.",
+        default=None,
+    )
+
+    @model_validator(mode="after")
+    @classmethod
+    def validate_telemetry_event_sharing(
+        cls, value: "EventSharingTelemetry"
+    ) -> "EventSharingTelemetry":
+        if value.optional_shared_events and not value.share_mandatory_events:
+            raise ClickException(
+                "'telemetry.share_mandatory_events' must be set to 'true' when sharing optional events through 'telemetry.optional_shared_events'."
+            )
+        return value
+
+    @field_validator("optional_shared_events")
+    @classmethod
+    def validate_optional_shared_events(
+        cls, original_shared_events: Optional[List[str]]
+    ) -> Optional[List[str]]:
+        if original_shared_events is None:
+            return None
+
+        # make sure each event is non-empty String:
+        for event in original_shared_events:
+            if not event:
+                raise ClickException(
+                    "Events listed in 'telemetry.optional_shared_events' must not be blank"
+                )
+
+        return original_shared_events

snowflake/cli/_plugins/nativeapp/same_account_install_method.py

@@ -7,8 +7,6 @@ from snowflake.cli._plugins.nativeapp.constants import (
 from snowflake.cli._plugins.nativeapp.exceptions import (
     ApplicationCreatedExternallyError,
 )
-
-# from snowflake.cli._plugins.nativeapp.project_model import NativeAppProjectModel
 from snowflake.cli._plugins.stage.manager import StageManager
 
 

snowflake/cli/_plugins/nativeapp/sf_facade.py

@@ -0,0 +1,30 @@
+# 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 contextvars import ContextVar
+
+from snowflake.cli._plugins.nativeapp.sf_sql_facade import SnowflakeSQLFacade
+
+_SNOWFLAKE_FACADE: ContextVar[SnowflakeSQLFacade | None] = ContextVar(
+    "snowflake_sql_facade", default=None
+)
+
+
+def get_snowflake_facade() -> SnowflakeSQLFacade:
+    """Returns a Snowflake Facade"""
+    facade = _SNOWFLAKE_FACADE.get()
+    if not facade:
+        facade = SnowflakeSQLFacade()
+        _SNOWFLAKE_FACADE.set(facade)
+    return facade

snowflake/cli/_plugins/nativeapp/sf_facade_constants.py

@@ -0,0 +1,25 @@
+# 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 UseObjectType(Enum):
+    DATABASE = "database"
+    ROLE = "role"
+    SCHEMA = "schema"
+    WAREHOUSE = "warehouse"
+
+    def __str__(self):
+        return self.value

snowflake/cli/_plugins/nativeapp/sf_facade_exceptions.py

@@ -0,0 +1,117 @@
+# 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 typing import NoReturn
+
+from click import ClickException
+from snowflake.cli._plugins.nativeapp.sf_facade_constants import UseObjectType
+from snowflake.connector import DatabaseError, Error, ProgrammingError
+
+
+def handle_unclassified_error(err: Error | Exception, context: str) -> NoReturn:
+    """
+    Handles exceptions that are not caught by categorized exceptions in SQLFacade
+    @param err: connector error or base exception
+    @param context: message to add context to exception
+    """
+    message = f"{context} {str(err)}"
+    if isinstance(err, ProgrammingError):
+        raise InvalidSQLError(message) from err
+
+    if isinstance(err, DatabaseError):
+        raise UnknownSQLError(message) from err
+
+    if isinstance(err, Error):
+        raise UnknownConnectorError(message) from err
+
+    # Not a connector error
+    raise Exception(message) from err
+
+
+class _BaseFacadeError(Exception):
+    """Base class for SnowflakeFacade Exceptions"""
+
+    def __init__(self, msg):
+        self.msg = msg
+        super().__init__(self.msg)
+
+    def __str__(self):
+        return self.msg
+
+
+class InvalidSQLError(_BaseFacadeError):
+    """Raised when Snowflake executed a SQL command but encountered an error, for example due to syntax or logical errors"""
+
+    def __init__(self, msg):
+        super().__init__(f"Invalid SQL error occurred. {msg}")
+
+
+class UnknownSQLError(_BaseFacadeError):
+    """Raised when Snowflake could not execute the SQL command"""
+
+    def __init__(self, msg):
+        super().__init__(f"Unknown SQL error occurred. {msg}")
+
+
+class UnknownConnectorError(_BaseFacadeError):
+    """Raised when there was a problem reaching Snowflake to execute a SQL command"""
+
+    def __init__(self, msg):
+        super().__init__(f"Unknown error occurred. {msg}")
+
+
+class UnexpectedResultError(_BaseFacadeError):
+    """Raised when an unexpected result was returned from execution of a SQL command"""
+
+    def __init__(self, msg):
+        super().__init__(f"Received unexpected result from query. {msg}")
+
+
+class UserScriptError(ClickException):
+    """Exception raised when user-provided scripts fail."""
+
+    def __init__(self, script_name, msg):
+        super().__init__(f"Failed to run script {script_name}. {msg}")
+
+
+class UserInputError(ClickException):
+    """Exception raised when execution of SQL with user input fails."""
+
+    pass
+
+
+class CouldNotUseObjectError(UserInputError):
+    def __init__(self, object_type: UseObjectType, name: str):
+        super().__init__(
+            f"Could not use {object_type} {name}. Object does not exist, or operation cannot be performed."
+        )
+
+
+class InsufficientPrivilegesError(ClickException):
+    """Raised when user does not have sufficient privileges to perform an operation"""
+
+    def __init__(
+        self,
+        message,
+        *,
+        role: str | None = None,
+        database: str | None = None,
+        schema: str | None = None,
+    ):
+        if schema:
+            message += f" in schema: {schema}"
+        if database:
+            message += f" in database: {database}"
+        if role:
+            message += f" using role: {role}"
+        super().__init__(message)