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

snowflake/cli/api/cli_global_context.py

@@ -17,8 +17,9 @@ from __future__ import annotations
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass, field, replace
+from functools import wraps
 from pathlib import Path
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING, Iterator, Optional
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
 from snowflake.cli.api.exceptions import MissingConfiguration
@@ -157,7 +158,7 @@ class _CliGlobalContextAccess:
         return self._manager.enable_tracebacks
 
     @property
-    def metrics(self):
+    def metrics(self) -> CLIMetrics:
         return self._manager.metrics
 
     @property
@@ -195,6 +196,19 @@ class _CliGlobalContextAccess:
         """Computes whether cli_console output should be muted."""
         return self._manager.output_format == OutputFormat.JSON
 
+    @property
+    def snow_api_root(
+        self,
+    ) -> Optional[
+        object
+    ]:  # Should be Optional[Root], but we need local import for performance reasons
+        from snowflake.core import Root
+
+        if self.connection:
+            return Root(self.connection)
+        else:
+            return None
+
 
 _CLI_CONTEXT_MANAGER: ContextVar[_CliGlobalContextManager | None] = ContextVar(
     "cli_context", default=None
@@ -213,6 +227,26 @@ def get_cli_context() -> _CliGlobalContextAccess:
     return _CliGlobalContextAccess(get_cli_context_manager())
 
 
+def span(span_name: str):
+    """
+    Decorator to start a command metrics span that encompasses a whole function
+
+    Must be used instead of directly calling @get_cli_context().metrics.span(span_name)
+    as a decorator to ensure that the cli context is grabbed at run time instead of at
+    module load time, which would not reflect forking
+    """
+
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            with get_cli_context().metrics.span(span_name):
+                return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
 @contextmanager
 def fork_cli_context(
     connection_overrides: dict | None = None,

snowflake/cli/api/commands/flags.py

@@ -95,7 +95,7 @@ TemporaryConnectionOption = typer.Option(
     False,
     "--temporary-connection",
     "-x",
-    help="Uses connection defined with command line parameters, instead of one defined in config",
+    help="Uses a connection defined with command line parameters, instead of one defined in config",
     callback=_connection_callback("temporary_connection"),
     is_flag=True,
     rich_help_panel=_CONNECTION_SECTION,
@@ -383,6 +383,12 @@ ReplaceOption = OverrideableOption(
     mutually_exclusive=CREATE_MODE_OPTION_NAMES,
 )
 
+ForceReplaceOption = OverrideableOption(
+    False,
+    "--force-replace",
+    help="Replace this object, even if the state didn't change",
+)
+
 OnErrorOption = typer.Option(
     OnErrorType.BREAK.value,
     "--on-error",
@@ -531,8 +537,8 @@ def project_definition_option(is_optional: bool):
         None,
         "-p",
         "--project",
-        help=f"Path where Snowflake project resides. "
-        f"Defaults to current working directory.",
+        help=f"Path where the Snowflake project is stored. "
+        f"Defaults to the current working directory.",
         callback=project_path_callback,
         show_default=False,
     )
@@ -551,7 +557,7 @@ def project_env_overrides_option():
     return typer.Option(
         [],
         "--env",
-        help="String in format of key=value. Overrides variables from env section used for templates.",
+        help="String in the format key=value. Overrides variables from the env section used for templates.",
         callback=project_env_overrides_callback,
         show_default=False,
     )

snowflake/cli/api/commands/utils.py

@@ -1,7 +1,9 @@
-from typing import List, Optional
+from typing import Dict, List, Optional
 
-from click import ClickException
+from click import ClickException, UsageError
 from snowflake.cli.api.commands.common import Variable
+from snowflake.cli.api.exceptions import NoProjectDefinitionError
+from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
 
 
 def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
@@ -16,3 +18,27 @@ def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
         key, value = p.split("=", 1)
         result.append(Variable(key.strip(), value.strip()))
     return result
+
+
+def get_entity_for_operation(
+    cli_context,
+    entity_id: str | None,
+    project_definition,
+    entity_type: str,
+):
+    entities: Dict[str, EntityModelBase] = project_definition.get_entities_by_type(
+        entity_type=entity_type
+    )
+    if not entities:
+        raise NoProjectDefinitionError(
+            project_type=entity_type, project_root=cli_context.project_root
+        )
+    if entity_id and entity_id not in entities:
+        raise UsageError(f"No '{entity_id}' entity in project definition file.")
+    if len(entities.keys()) == 1:
+        entity_id = list(entities.keys())[0]
+    if entity_id is None:
+        raise UsageError(
+            f"Multiple entities of type {entity_type} found. Please provide entity id for the operation."
+        )
+    return entities[entity_id]

snowflake/cli/api/config.py

@@ -286,8 +286,12 @@ def get_config_value(*path, key: str, default: Optional[Any] = Empty) -> Any:
         raise
 
 
-def get_config_bool_value(*path, key: str, default: Optional[Any] = Empty) -> bool:
-    value = get_config_value(*path, key=key, default=default)
+def get_config_bool_value(*path, key: str, default: Optional[bool]) -> Optional[bool]:
+    value = get_config_value(*path, key=key, default=None)
+
+    if value is None:
+        return default
+
     try:
         return try_cast_to_bool(value)
     except ValueError:

snowflake/cli/api/connections.py

@@ -79,6 +79,17 @@ class ConnectionContext:
                 raise KeyError(f"{key} is not a field of {self.__class__.__name__}")
             setattr(self, key, value)
 
+    def merge_with_config(self, **updates) -> ConnectionContext:
+        """
+        Updates missing fields from the config, but does not overwrite existing.
+        """
+        field_map = {field.name for field in fields(self)}
+        for key, value in updates.items():
+            if key in field_map and getattr(self, key) is None:
+                setattr(self, key, value)
+
+        return self
+
     def update_from_config(self) -> ConnectionContext:
         connection_config = get_connection_dict(connection_name=self.connection_name)
         if "private_key_path" in connection_config:
@@ -87,7 +98,7 @@ class ConnectionContext:
             ]
             del connection_config["private_key_path"]
 
-        self.update(**connection_config)
+        self.merge_with_config(**connection_config)
         return self
 
     def __repr__(self) -> str:

snowflake/cli/api/constants.py

@@ -45,6 +45,7 @@ class ObjectType(Enum):
     )
     # JOB = ObjectNames("job", "job", "jobs")
     NETWORK_RULE = ObjectNames("network-rule", "network rule", "network rules")
+    NOTEBOOK = ObjectNames("notebook", "notebook", "notebooks")
     PROCEDURE = ObjectNames("procedure", "procedure", "procedures")
     ROLE = ObjectNames("role", "role", "roles")
     SCHEMA = ObjectNames("schema", "schema", "schemas")
@@ -62,6 +63,10 @@ class ObjectType(Enum):
         "image-repository", "image repository", "image repositories"
     )
     GIT_REPOSITORY = ObjectNames("git-repository", "git repository", "git repositories")
+    APPLICATION = ObjectNames("application", "application", "applications")
+    APPLICATION_PACKAGE = ObjectNames(
+        "application-package", "application package", "application packages"
+    )
 
     def __str__(self):
         """This makes using this Enum easier in formatted string"""
@@ -69,7 +74,11 @@ class ObjectType(Enum):
 
 
 OBJECT_TO_NAMES = {o.value.cli_name: o.value for o in ObjectType}
-SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys())
+UNSUPPORTED_OBJECTS = {
+    ObjectType.APPLICATION.value.cli_name,
+    ObjectType.APPLICATION_PACKAGE.value.cli_name,
+}
+SUPPORTED_OBJECTS = sorted(OBJECT_TO_NAMES.keys() - UNSUPPORTED_OBJECTS)
 
 # Scope names here must replace spaces with '-'. For example 'compute pool' is 'compute-pool'.
 VALID_SCOPES = ["database", "schema", "compute-pool"]

snowflake/cli/api/entities/common.py

@@ -1,23 +1,42 @@
-from enum import Enum
+import functools
+from pathlib import Path
 from typing import Generic, Type, TypeVar, get_args
 
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
+from snowflake.cli.api.cli_global_context import get_cli_context, span
+from snowflake.cli.api.entities.resolver import DependencyResolver
+from snowflake.cli.api.entities.utils import EntityActions, get_sql_executor
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.sql_execution import SqlExecutor
+from snowflake.connector import SnowflakeConnection
+from snowflake.connector.cursor import SnowflakeCursor
 
+T = TypeVar("T")
 
-class EntityActions(str, Enum):
-    BUNDLE = "action_bundle"
-    DEPLOY = "action_deploy"
-    DROP = "action_drop"
-    VALIDATE = "action_validate"
-    EVENTS = "action_events"
 
-    VERSION_LIST = "action_version_list"
-    VERSION_CREATE = "action_version_create"
-    VERSION_DROP = "action_version_drop"
+def attach_spans_to_entity_actions(entity_name: str):
+    """
+    Class decorator for EntityBase subclasses to automatically wrap
+    every implemented entity action method with a metrics span
 
+    Args:
+        entity_name (str): Custom name for entity type to be displayed in metrics
+    """
 
-T = TypeVar("T")
+    def decorator(cls: type[T]) -> type[T]:
+        for attr_name, attr_value in vars(cls).items():
+            is_entity_action = attr_name in [
+                enum_member for enum_member in EntityActions
+            ]
+
+            if is_entity_action and callable(attr_value):
+                attr_name_without_action_prefix = attr_name.partition("_")[2]
+                span_name = f"action.{entity_name}.{attr_name_without_action_prefix}"
+                action_with_span = span(span_name)(attr_value)
+                setattr(cls, attr_name, action_with_span)
+        return cls
+
+    return decorator
 
 
 class EntityBase(Generic[T]):
@@ -28,6 +47,11 @@ class EntityBase(Generic[T]):
     def __init__(self, entity_model: T, workspace_ctx: WorkspaceContext):
         self._entity_model = entity_model
         self._workspace_ctx = workspace_ctx
+        self.dependency_resolver = DependencyResolver(entity_model)
+
+    @property
+    def entity_id(self) -> str:
+        return self._entity_model.entity_id  # type: ignore
 
     @classmethod
     def get_entity_model_type(cls) -> Type[T]:
@@ -49,10 +73,53 @@ class EntityBase(Generic[T]):
     ):
         """
         Performs the requested action.
+        This is a preferred way to perform actions on entities, over calling actions directly,
+        as it will also call the dependencies in the correct order.
         """
+        self.dependency_resolver.perform_for_dep(action, action_ctx, *args, **kwargs)
         return getattr(self, action)(action_ctx, *args, **kwargs)
 
+    @property
+    def root(self) -> Path:
+        return self._workspace_ctx.project_root
+
+    @property
+    def identifier(self) -> str:
+        return self.model.fqn.sql_identifier
+
+    @property
+    def fqn(self) -> FQN:
+        return self._entity_model.fqn  # type: ignore[attr-defined]
+
+    @functools.cached_property
+    def _sql_executor(
+        self,
+    ) -> SqlExecutor:
+        return get_sql_executor()
+
+    def _execute_query(self, sql: str) -> SnowflakeCursor:
+        return self._sql_executor.execute_query(sql)
+
+    @functools.cached_property
+    def _conn(self) -> SnowflakeConnection:
+        return self._sql_executor._conn  # noqa
+
+    @property
+    def snow_api_root(self):
+        return get_cli_context().snow_api_root
+
+    @property
+    def model(self):
+        return self._entity_model
+
+    def dependent_entities(self, action_ctx: ActionContext):
+        return self.dependency_resolver.depends_on(action_ctx)
+
+    def get_usage_grant_sql(self, app_role: str) -> str:
+        return f"GRANT USAGE ON {self.model.type.upper()} {self.identifier} TO ROLE {app_role};"
+
+    def get_describe_sql(self) -> str:
+        return f"DESCRIBE {self.model.type.upper()} {self.identifier};"
 
-def get_sql_executor() -> SqlExecutor:
-    """Returns an SQL Executor that uses the connection from the current CLI context"""
-    return SqlExecutor()
+    def get_drop_sql(self) -> str:
+        return f"DROP {self.model.type.upper()} {self.identifier};"

snowflake/cli/api/entities/resolver.py

@@ -0,0 +1,160 @@
+from dataclasses import dataclass
+from typing import Any, Dict, List, Tuple
+
+from snowflake.cli._plugins.workspace.context import ActionContext
+from snowflake.cli.api.entities.utils import EntityActions
+from snowflake.cli.api.exceptions import CycleDetectedError
+from snowflake.cli.api.project.schemas.entities.common import EntityModelBase
+from snowflake.cli.api.utils.graph import Graph, Node
+
+
+@dataclass
+class Dependency:
+    entity_id: str
+    call_arguments: Dict[str, Any]
+
+    def __eq__(self, other):
+        return self.entity_id == other.entity_id
+
+    def __hash__(self):
+        return hash(self.entity_id)
+
+
+class DependencyResolver:
+    """
+    Base class for resolving dependencies logic.
+    Any logic for resolving dependencies, calling their actions or validating them should be implemented here.
+    If an entity uses it's specific logic, it should implement its own resolver, inheriting from this one
+    """
+
+    def __init__(self, model: EntityModelBase):
+        self.entity_model = model
+        self.dependencies: List[Dependency] = []
+
+    def depends_on(self, action_ctx: ActionContext) -> List[Dependency]:
+        """
+        Returns a list of entities that this entity depends on.
+        The list is sorted in order they should be called- last one depends on all the previous.
+        """
+        if not self.dependencies:
+            graph = self._create_dependency_graph(action_ctx)
+            self.dependencies = self._check_and_sort_dependencies(graph)
+
+        return self.dependencies
+
+    def perform_for_dep(
+        self, action: EntityActions, action_ctx: ActionContext, *args, **kwargs
+    ):
+        """
+        Method used to perform selected
+        """
+        for dependency in self.depends_on(action_ctx):
+            entity = action_ctx.get_entity(dependency.entity_id)
+            if entity.supports(action):
+                arguments = dependency.call_arguments.get(action.get_action_name, {})
+                getattr(entity, action)(action_ctx, **arguments)
+
+    def _create_dependency_graph(self, action_ctx: ActionContext) -> Graph[Dependency]:
+        """
+        Creates a graph for dependencies. We need the graph, instead of a simple list, because we need to check if
+        calling dependencies actions in selected order is possible.
+        """
+        graph = Graph()
+        depends_on = self.entity_model.meta.depends_on if self.entity_model.meta else []  # type: ignore
+        self_dependency = Dependency(entity_id=self.entity_model.entity_id, call_arguments={})  # type: ignore
+        resolved_nodes = set()
+
+        graph.add(Node(key=self_dependency.entity_id, data=self_dependency))
+
+        def _resolve_dependencies(parent_id: str, dependency_id: str) -> None:
+
+            (
+                child_dependencies,
+                call_arguments,
+            ) = self._get_child_dependencies_and_call_arguments(
+                dependency_id=dependency_id, action_ctx=action_ctx
+            )
+
+            if not graph.contains_node(dependency_id):
+                dependency_node = Node(
+                    key=dependency_id,
+                    data=Dependency(
+                        entity_id=dependency_id, call_arguments=call_arguments
+                    ),
+                )
+                graph.add(dependency_node)
+
+            graph.add_directed_edge(parent_id, dependency_id)
+
+            resolved_nodes.add(dependency_node.key)
+
+            for child_dependency in child_dependencies:
+                if child_dependency not in resolved_nodes:
+                    _resolve_dependencies(dependency_node.key, child_dependency)
+                else:
+                    graph.add_directed_edge(dependency_node.key, child_dependency)
+
+        for dependency in depends_on:
+            _resolve_dependencies(self_dependency.entity_id, dependency)
+
+        return graph
+
+    @staticmethod
+    def _check_and_sort_dependencies(
+        graph: Graph[Dependency],
+    ) -> List[Dependency]:
+        """
+        This function is used to check and organize the dependency list.
+        The check has two stages:
+         * Cycle detection in dependency
+         * Clearing duplicate
+
+        In the first stage, if cycle is detected, it raises CycleDetectedError with node causing it specified.
+        The result list, shows entities this one depends on, in order they should be called.
+        Duplicates are removed in a way, that preserves earliest possible call.
+        Last item is removed from the result list, as it is this entity itself.
+        """
+        result = []
+
+        def _on_cycle(node: Node[Dependency]) -> None:
+            raise CycleDetectedError(
+                f"Cycle detected in entity dependencies: {node.key}"
+            )
+
+        def _on_visit(node: Node[Dependency]) -> None:
+            result.append(node.data)
+
+        graph.dfs(on_cycle_action=_on_cycle, visit_action=_on_visit)
+
+        return clear_duplicates_from_list(result)[:-1]
+
+    @staticmethod
+    def _get_child_dependencies_and_call_arguments(
+        dependency_id: str, action_ctx: ActionContext
+    ) -> Tuple[List[str], Dict[str, Any]]:
+        child_dependency = action_ctx.get_entity(dependency_id)
+
+        if not child_dependency:
+            raise ValueError(f"Entity with id {dependency_id} not found in project")
+
+        if child_dependency.model.meta:
+            return (
+                child_dependency.model.meta.depends_on,
+                child_dependency.model.meta.action_arguments,
+            )
+
+        else:
+            return [], {}
+
+    @staticmethod
+    def get_action_name(action: EntityActions) -> str:
+
+        return action.value.split("_")[1]
+
+
+def clear_duplicates_from_list(input_list: list[Any]) -> list[Any]:
+    """
+    Removes duplicates from the input list, preserving the first occurrence.
+    """
+    seen = set()
+    return [x for x in input_list if not (x in seen or seen.add(x))]  # type: ignore

snowflake/cli/api/entities/utils.py

@@ -1,13 +1,10 @@
 import os
+from enum import Enum
 from pathlib import Path
 from typing import Any, List, NoReturn, Optional
 
 import jinja2
 from click import ClickException
-from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
-    resolve_without_follow,
-)
 from snowflake.cli._plugins.nativeapp.exceptions import (
     InvalidTemplateInFileError,
     MissingScriptError,
@@ -22,10 +19,11 @@ from snowflake.cli._plugins.stage.diff import (
     sync_local_diff_with_stage,
     to_stage_path,
 )
+from snowflake.cli._plugins.stage.manager import DefaultStagePathParts
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
-from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
+from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.console.abc import AbstractConsole
-from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.errno import (
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
@@ -41,8 +39,9 @@ from snowflake.cli.api.rendering.sql_templates import (
     choose_sql_jinja_env_based_on_template_syntax,
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.cli.api.sql_execution import SqlExecutor
+from snowflake.cli.api.utils.path_utils import resolve_without_follow
 from snowflake.connector import ProgrammingError
-from snowflake.connector.cursor import SnowflakeCursor
 
 
 def generic_sql_error_handler(err: ProgrammingError) -> NoReturn:
@@ -76,16 +75,16 @@ def _get_stage_paths_to_sync(
     return stage_paths
 
 
+@span("sync_deploy_root_with_stage")
 def sync_deploy_root_with_stage(
     console: AbstractConsole,
     deploy_root: Path,
     package_name: str,
-    stage_schema: str,
     bundle_map: BundleMap,
     role: str,
     prune: bool,
     recursive: bool,
-    stage_fqn: str,
+    stage_path: DefaultStagePathParts,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
 ) -> DiffResult:
@@ -98,32 +97,37 @@ def sync_deploy_root_with_stage(
         role (str): The name of the role to use for queries and commands.
         prune (bool): Whether to prune artifacts from the stage that don't exist locally.
         recursive (bool): Whether to traverse directories recursively.
-        stage_fqn (str): The name of the stage to diff against and upload to.
+        stage_path (DefaultStagePathParts): stage path object.
+
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
-         local paths. Note that providing an empty list here is equivalent to None.
+        local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
 
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-
     sql_facade = get_snowflake_facade()
+    schema = stage_path.schema
+    stage_fqn = stage_path.stage
     # Does a stage already exist within the application package, or we need to create one?
     # Using "if not exists" should take care of either case.
     console.step(
         f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
     )
     if not sql_facade.stage_exists(stage_fqn):
-        sql_facade.create_schema(stage_schema, database=package_name)
+        sql_facade.create_schema(schema, database=package_name)
         sql_facade.create_stage(stage_fqn)
 
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
         console.step(
-            "Performing a diff between the Snowflake stage and your local deploy_root ('%s') directory."
-            % deploy_root.resolve()
+            f"Performing a diff between the Snowflake stage: {stage_path.path} and your local deploy_root: {deploy_root.resolve()}."
         )
-    diff: DiffResult = compute_stage_diff(deploy_root, stage_fqn)
+
+    diff: DiffResult = compute_stage_diff(
+        local_root=deploy_root,
+        stage_path=stage_path,
+    )
 
     if local_paths_to_sync:
         # Deploying specific files/directories
@@ -184,7 +188,7 @@ def sync_deploy_root_with_stage(
             role=role,
             deploy_root_path=deploy_root,
             diff_result=diff,
-            stage_fqn=stage_fqn,
+            stage_full_path=stage_path.full_path,
         )
     return diff
 
@@ -212,7 +216,10 @@ def execute_post_deploy_hooks(
 
     get_cli_context().metrics.set_counter(CLICounterField.POST_DEPLOY_SCRIPTS, 1)
 
-    with console.phase(f"Executing {deployed_object_type} post-deploy actions"):
+    with (
+        console.phase(f"Executing {deployed_object_type} post-deploy actions"),
+        get_cli_context().metrics.span("post_deploy_hooks"),
+    ):
         sql_scripts_paths = []
         display_paths = []
         for hook in post_deploy_hooks:
@@ -321,17 +328,52 @@ def drop_generic_object(
         console.message(f"Dropped {object_type} {object_name} successfully.")
 
 
-def print_messages(
-    console: AbstractConsole, create_or_upgrade_cursor: Optional[SnowflakeCursor]
-):
+def print_messages(console: AbstractConsole, cursor_results: list[tuple[str]]):
     """
     Shows messages in the console returned by the CREATE or UPGRADE
     APPLICATION command.
     """
-    if not create_or_upgrade_cursor:
+    if not cursor_results:
         return
 
-    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
+    messages = [row[0] for row in cursor_results]
     for message in messages:
         console.warning(message)
     console.message("")
+
+
+def get_sql_executor() -> SqlExecutor:
+    """Returns an SQL Executor that uses the connection from the current CLI context"""
+    return SqlExecutor()
+
+
+class EntityActions(str, Enum):
+    BUNDLE = "action_bundle"
+    DEPLOY = "action_deploy"
+    DROP = "action_drop"
+    VALIDATE = "action_validate"
+    EVENTS = "action_events"
+    DIFF = "action_diff"
+
+    VERSION_LIST = "action_version_list"
+    VERSION_CREATE = "action_version_create"
+    VERSION_DROP = "action_version_drop"
+
+    RELEASE_DIRECTIVE_UNSET = "action_release_directive_unset"
+    RELEASE_DIRECTIVE_SET = "action_release_directive_set"
+    RELEASE_DIRECTIVE_LIST = "action_release_directive_list"
+    RELEASE_DIRECTIVE_ADD_ACCOUNTS = "action_release_directive_add_accounts"
+    RELEASE_DIRECTIVE_REMOVE_ACCOUNTS = "action_release_directive_remove_accounts"
+
+    RELEASE_CHANNEL_LIST = "action_release_channel_list"
+    RELEASE_CHANNEL_ADD_ACCOUNTS = "action_release_channel_add_accounts"
+    RELEASE_CHANNEL_REMOVE_ACCOUNTS = "action_release_channel_remove_accounts"
+    RELEASE_CHANNEL_ADD_VERSION = "action_release_channel_add_version"
+    RELEASE_CHANNEL_REMOVE_VERSION = "action_release_channel_remove_version"
+    RELEASE_CHANNEL_SET_ACCOUNTS = "action_release_channel_set_accounts"
+
+    PUBLISH = "action_publish"
+
+    @property
+    def get_action_name(self):
+        return self.value.replace("action_", "")