snowflake-cli-labs 2.8.1__py3-none-any.whl → 3.0.0__py3-none-any.whl

snowflake/cli/api/project/schemas/entities/common.py

@@ -15,18 +15,24 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Generic, List, Optional, TypeVar
+from typing import Dict, Generic, List, Optional, TypeVar, Union
 
-from pydantic import Field
-from snowflake.cli.api.project.schemas.native_app.application import (
-    PostDeployHook,
-)
+from pydantic import Field, PrivateAttr, field_validator
+from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
     UpdatableModel,
 )
 
 
+class SqlScriptHookType(UpdatableModel):
+    sql_script: str = Field(title="SQL file path relative to the project root")
+
+
+# Currently sql_script is the only supported hook type. Change to a Union once other hook types are added
+PostDeployHook = SqlScriptHookType
+
+
 class MetaField(UpdatableModel):
     warehouse: Optional[str] = IdentifierField(
         title="Warehouse used to run the scripts", default=None
@@ -39,26 +45,59 @@ class MetaField(UpdatableModel):
         title="Actions that will be executed after the application object is created/upgraded",
         default=None,
     )
-
-
-class DefaultsField(UpdatableModel):
-    schema_: Optional[str] = Field(
-        title="Schema.",
-        alias="schema",
-        default=None,
-    )
-    stage: Optional[str] = Field(
-        title="Stage.",
+    use_mixins: Optional[List[str]] = Field(
+        title="Name of the mixin used to fill the entity fields",
         default=None,
     )
 
+    @field_validator("use_mixins", mode="before")
+    @classmethod
+    def ensure_use_mixins_is_a_list(
+        cls, mixins: Optional[str | List[str]]
+    ) -> Optional[List[str]]:
+        if isinstance(mixins, str):
+            return [mixins]
+        return mixins
+
 
-class EntityBase(ABC, UpdatableModel):
+class Identifier(UpdatableModel):
+    name: str = Field(title="Entity name")
+    schema_: Optional[str] = Field(title="Entity schema", alias="schema", default=None)
+    database: Optional[str] = Field(title="Entity database", default=None)
+
+
+class EntityModelBase(ABC, UpdatableModel):
     @classmethod
     def get_type(cls) -> str:
         return cls.model_fields["type"].annotation.__args__[0]
 
     meta: Optional[MetaField] = Field(title="Meta fields", default=None)
+    identifier: Optional[Union[Identifier | str]] = Field(
+        title="Entity identifier", default=None
+    )
+    # Set by parent model in post validation. To reference it use `entity_id`.
+    _entity_id: str = PrivateAttr(default=None)
+
+    @property
+    def entity_id(self):
+        return self._entity_id
+
+    def set_entity_id(self, value: str):
+        self._entity_id = value
+
+    def validate_identifier(self):
+        """Helper that's used by ProjectDefinition validator."""
+        if not self._entity_id and not self.identifier:
+            raise ValueError("Missing entity identifier")
+
+    @property
+    def fqn(self) -> FQN:
+        if isinstance(self.identifier, str):
+            return FQN.from_string(self.identifier)
+        if isinstance(self.identifier, Identifier):
+            return FQN.from_identifier_model_v2(self.identifier)
+        if self.entity_id:
+            return FQN.from_string(self.entity_id)
 
 
 TargetType = TypeVar("TargetType")
@@ -76,3 +115,39 @@ class TargetField(UpdatableModel, Generic[TargetType]):
         them in __pydantic_generic_metadata__
         """
         return self.__pydantic_generic_metadata__["args"][0]
+
+
+class ImportsBaseModel:
+    imports: Optional[List[str]] = Field(
+        title="Stage and path to previously uploaded files you want to import",
+        default=[],
+    )
+
+    def get_imports_sql(self) -> str | None:
+        if not self.imports:
+            return None
+        imports = ", ".join(f"'{i}'" for i in self.imports)
+        return f"IMPORTS = ({imports})"
+
+
+class ExternalAccessBaseModel:
+    external_access_integrations: Optional[List[str]] = Field(
+        title="Names of external access integrations needed for this entity to access external networks",
+        default=[],
+    )
+    secrets: Optional[Dict[str, str]] = Field(
+        title="Assigns the names of secrets to variables so that you can use the variables to reference the secrets",
+        default={},
+    )
+
+    def get_external_access_integrations_sql(self) -> str | None:
+        if not self.external_access_integrations:
+            return None
+        external_access_integration_name = ", ".join(self.external_access_integrations)
+        return f"external_access_integrations=({external_access_integration_name})"
+
+    def get_secrets_sql(self) -> str | None:
+        if not self.secrets:
+            return None
+        secrets = ", ".join(f"'{key}'={value}" for key, value in self.secrets.items())
+        return f"secrets=({secrets})"

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

@@ -14,17 +14,48 @@
 
 from __future__ import annotations
 
-from typing import Union, get_args
+from typing import Dict, List, Union, get_args
 
-from snowflake.cli.api.project.schemas.entities.application_entity import (
+from snowflake.cli._plugins.nativeapp.entities.application import (
     ApplicationEntity,
+    ApplicationEntityModel,
 )
-from snowflake.cli.api.project.schemas.entities.application_package_entity import (
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
+    ApplicationPackageEntityModel,
+)
+from snowflake.cli._plugins.snowpark.snowpark_entity import (
+    FunctionEntity,
+    ProcedureEntity,
+)
+from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
+    FunctionEntityModel,
+    ProcedureEntityModel,
+)
+from snowflake.cli._plugins.streamlit.streamlit_entity import StreamlitEntity
+from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
+    StreamlitEntityModel,
 )
 
-Entity = Union[ApplicationEntity, ApplicationPackageEntity]
+Entity = Union[
+    ApplicationEntity,
+    ApplicationPackageEntity,
+    StreamlitEntity,
+    ProcedureEntity,
+    FunctionEntity,
+]
+EntityModel = Union[
+    ApplicationEntityModel,
+    ApplicationPackageEntityModel,
+    StreamlitEntityModel,
+    FunctionEntityModel,
+    ProcedureEntityModel,
+]
 
-ALL_ENTITIES = [*get_args(Entity)]
+ALL_ENTITIES: List[Entity] = [*get_args(Entity)]
+ALL_ENTITY_MODELS: List[EntityModel] = [*get_args(EntityModel)]
 
-v2_entity_types_map = {e.get_type(): e for e in ALL_ENTITIES}
+v2_entity_model_types_map = {e.get_type(): e for e in ALL_ENTITY_MODELS}
+v2_entity_model_to_entity_map: Dict[EntityModel, Entity] = {
+    e.get_entity_model_type(): e for e in ALL_ENTITIES
+}

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

@@ -15,33 +15,32 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from packaging.version import Version
 from pydantic import Field, ValidationError, field_validator, model_validator
-from snowflake.cli.api.feature_flags import FeatureFlag
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
 from snowflake.cli.api.project.errors import SchemaValidationError
-from snowflake.cli.api.project.schemas.entities.application_entity import (
-    ApplicationEntity,
-)
 from snowflake.cli.api.project.schemas.entities.common import (
-    DefaultsField,
     TargetField,
 )
 from snowflake.cli.api.project.schemas.entities.entities import (
-    Entity,
-    v2_entity_types_map,
+    EntityModel,
+    v2_entity_model_types_map,
 )
-from snowflake.cli.api.project.schemas.native_app.native_app import (
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.native_app.native_app import (
     NativeApp,
     NativeAppV11,
 )
-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.project.schemas.v1.snowpark.snowpark import Snowpark
+from snowflake.cli.api.project.schemas.v1.streamlit.streamlit import Streamlit
 from snowflake.cli.api.utils.types import Context
 from typing_extensions import Annotated
 
+AnnotatedEntity = Annotated[EntityModel, Field(discriminator="type")]
+scalar = str | int | float | bool
+
 
 @dataclass
 class ProjectProperties:
@@ -61,6 +60,11 @@ class ProjectProperties:
     project_context: Context
 
 
+@dataclass
+class YamlOverride:
+    data: dict | list
+
+
 class _ProjectDefinitionBase(UpdatableModel):
     def __init__(self, *args, **kwargs):
         try:
@@ -111,46 +115,43 @@ class DefinitionV11(DefinitionV10):
 
 
 class DefinitionV20(_ProjectDefinitionBase):
-    entities: Dict[str, Annotated[Entity, Field(discriminator="type")]] = Field(
-        title="Entity definitions."
-    )
+    entities: Dict[str, AnnotatedEntity] = Field(title="Entity definitions.")
 
-    @model_validator(mode="before")
-    @classmethod
-    def apply_defaults(cls, data: Dict) -> Dict:
-        """
-        Applies default values that exist on the model but not specified in yml
-        """
-        if "defaults" in data and "entities" in data:
-            for key, entity in data["entities"].items():
-                entity_type = entity["type"]
-                if entity_type not in v2_entity_types_map:
-                    continue
-                entity_model = v2_entity_types_map[entity_type]
-                for default_key, default_value in data["defaults"].items():
-                    if (
-                        default_key in entity_model.model_fields
-                        and default_key not in entity
-                    ):
-                        entity[default_key] = default_value
-        return data
+    @model_validator(mode="after")
+    def validate_entities_identifiers(self):
+        for key, entity in self.entities.items():
+            entity.set_entity_id(key)
+            entity.validate_identifier()
+        return self
 
     @field_validator("entities", mode="after")
     @classmethod
-    def validate_entities(cls, entities: Dict[str, Entity]) -> Dict[str, Entity]:
+    def validate_entities(
+        cls, entities: Dict[str, AnnotatedEntity]
+    ) -> Dict[str, AnnotatedEntity]:
         for key, entity in entities.items():
             # TODO Automatically detect TargetFields to validate
-            if entity.type == ApplicationEntity.get_type():
-                if isinstance(entity.from_, TargetField):
-                    target_key = entity.from_.target
-                    target_object = entity.from_
-                    target_type = target_object.get_type()
-                    cls._validate_target_field(target_key, target_type, entities)
+            if isinstance(entity, list):
+                for e in entity:
+                    cls._validate_single_entity(e, entities)
+            else:
+                cls._validate_single_entity(entity, entities)
         return entities
 
+    @classmethod
+    def _validate_single_entity(
+        cls, entity: EntityModel, entities: Dict[str, AnnotatedEntity]
+    ):
+        if entity.type == ApplicationEntityModel.get_type():
+            if isinstance(entity.from_, TargetField):
+                target_key = entity.from_.target
+                target_object = entity.from_
+                target_type = target_object.get_type()
+                cls._validate_target_field(target_key, target_type, entities)
+
     @classmethod
     def _validate_target_field(
-        cls, target_key: str, target_type: Entity, entities: Dict[str, Entity]
+        cls, target_key: str, target_type: EntityModel, entities: Dict[str, EntityModel]
     ):
         if target_key not in entities:
             raise ValueError(f"No such target: {target_key}")
@@ -162,16 +163,114 @@ class DefinitionV20(_ProjectDefinitionBase):
                 f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
             )
 
-    defaults: Optional[DefaultsField] = Field(
-        title="Default key/value entity values that are merged recursively for each entity.",
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
         default=None,
     )
 
-    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
-        title="Default environment specification for this project.",
+    mixins: Optional[Dict[str, Dict]] = Field(
+        title="Mixins to apply to entities",
         default=None,
     )
 
+    @model_validator(mode="before")
+    @classmethod
+    def apply_mixins(cls, data: Dict) -> Dict:
+        """
+        Applies mixins to those entities, whose meta field contains the mixin name.
+        """
+        if "mixins" not in data or "entities" not in data:
+            return data
+
+        entities = data["entities"]
+        for entity_name, entity in entities.items():
+            entity_mixins = entity_mixins_to_list(
+                entity.get("meta", {}).get("use_mixins")
+            )
+
+            merged_values = cls._merge_mixins_with_entity(
+                entity_id=entity_name,
+                entity=entity,
+                entity_mixins_names=entity_mixins,
+                mixin_defs=data["mixins"],
+            )
+            entities[entity_name] = merged_values
+        return data
+
+    @classmethod
+    def _merge_mixins_with_entity(
+        cls,
+        entity_id: str,
+        entity: dict,
+        entity_mixins_names: list,
+        mixin_defs: dict,
+    ) -> dict:
+        # Validate mixins
+        for mixin_name in entity_mixins_names:
+            if mixin_name not in mixin_defs:
+                raise ValueError(f"Mixin {mixin_name} not defined")
+
+        # Build object override data from mixins
+        data: dict = {}
+        for mx_name in entity_mixins_names:
+            data = cls._merge_data(data, mixin_defs[mx_name])
+
+        for key, override_value in data.items():
+            if key not in get_allowed_fields_for_entity(entity):
+                raise ValueError(
+                    f"Unsupported key '{key}' for entity {entity_id} of type {entity['type']} "
+                )
+
+            entity_value = entity.get(key)
+            if (
+                entity_value is not None
+                and not isinstance(entity_value, YamlOverride)
+                and not isinstance(entity_value, type(override_value))
+            ):
+                raise ValueError(
+                    f"Value from mixins for property {key} is of type '{type(override_value).__name__}' "
+                    f"while entity {entity_id} expects value of type '{type(entity_value).__name__}'"
+                )
+
+        # Apply entity data on top of mixins
+        data = cls._merge_data(data, entity)
+        return data
+
+    @classmethod
+    def _merge_data(
+        cls,
+        left: dict | list | scalar | None,
+        right: dict | list | scalar | None | YamlOverride,
+    ):
+        """
+        Merges right data into left. Right and left is expected to be of the same type, if not right is returned.
+        If left is sequence then missing elements from right are appended.
+        If left is dictionary then we update it with data from right. The update is done recursively key by key.
+        """
+        if isinstance(right, YamlOverride):
+            return right.data
+
+        if left is None:
+            return right
+
+        # At that point left and right are of the same type
+        if isinstance(left, dict) and isinstance(right, dict):
+            data = dict(left)
+            for key in right:
+                data[key] = cls._merge_data(left=data.get(key), right=right[key])
+            return data
+
+        if isinstance(left, list) and isinstance(right, list):
+            return _unique_extend(left, right)
+
+        if not isinstance(right, type(left)):
+            raise ValueError(f"Could not merge {type(right)} and {type(left)}.")
+
+        return right
+
+    def get_entities_by_type(self, entity_type: str):
+        return {i: e for i, e in self.entities.items() if e.get_type() == entity_type}
+
 
 def build_project_definition(**data) -> ProjectDefinition:
     """
@@ -193,7 +292,39 @@ ProjectDefinition = Union[ProjectDefinitionV1, ProjectDefinitionV2]
 
 
 def get_version_map():
-    version_map = {"1": DefinitionV10, "1.1": DefinitionV11}
-    if FeatureFlag.ENABLE_PROJECT_DEFINITION_V2.is_enabled():
-        version_map["2"] = DefinitionV20
+    version_map = {"1": DefinitionV10, "1.1": DefinitionV11, "2": DefinitionV20}
     return version_map
+
+
+def entity_mixins_to_list(entity_mixins: Optional[str | List[str]]) -> List[str]:
+    """
+    Convert an optional string or a list of strings to a list of strings.
+    """
+    if entity_mixins is None:
+        return []
+    if isinstance(entity_mixins, str):
+        return [entity_mixins]
+    return entity_mixins
+
+
+def get_allowed_fields_for_entity(entity: Dict[str, Any]) -> List[str]:
+    """
+    Get the allowed fields for the given entity.
+    """
+    entity_type = entity.get("type")
+    if entity_type is None:
+        raise ValueError("Entity is missing type declaration.")
+
+    if entity_type not in v2_entity_model_types_map:
+        return []
+
+    entity_model = v2_entity_model_types_map[entity_type]
+    return entity_model.model_fields
+
+
+def _unique_extend(list_a: List, list_b: List) -> List:
+    new_list = list(list_a)
+    for item in list_b:
+        if item not in list_a:
+            new_list.append(item)
+    return new_list

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

@@ -117,6 +117,7 @@ class UpdatableModel(BaseModel):
         # all the values of the class attributes. We go in reverse order so that
         # values in subclasses overrides values from parent classes in case of field overrides.
 
+        private_attrs = set()
         for class_ in reversed(cls.__mro__):
             class_dict = class_.__dict__
             field_annotations.update(class_dict.get("__annotations__", {}))
@@ -128,10 +129,15 @@ class UpdatableModel(BaseModel):
             else:
                 # If Pydantic did not process this class yet, get the values from class_dict directly
                 field_values.update(class_dict)
+            for pa in class_dict.get("__private_attributes__", []):
+                private_attrs.add(pa)
 
         # Add Pydantic validation wrapper around all fields except `DiscriminatorField`s
         for field_name in field_annotations:
-            if not cls._is_entity_type_field(field_values.get(field_name)):
+            if field_name in private_attrs:
+                continue
+            field = field_values.get(field_name)
+            if not cls._is_entity_type_field(field):
                 cls._add_validator(field_name)
 
     @classmethod
@@ -154,7 +160,8 @@ class UpdatableModel(BaseModel):
 
         setattr(
             cls,
-            f"_field_validator_with_verbose_name_to_avoid_name_conflict_{field_name}",
+            # Unique name so that subclasses get a unique instance of this validator
+            f"_{cls.__module__}.{cls.__name__}_validate_{field_name}",
             field_validator(field_name, mode="wrap")(validator_skipping_templated_str),
         )
 
@@ -187,7 +194,8 @@ def DiscriminatorField(*args, **kwargs):  # noqa N802
     When this `DiscriminatorField` is used on a pydantic attribute,
     we will not allow templating on it.
     """
-    return Field(is_discriminator_field=True, *args, **kwargs)
+    extra = dict(is_discriminator_field=True)
+    return Field(json_schema_extra=extra, *args, **kwargs)
 
 
 def IdentifierField(*args, **kwargs):  # noqa N802

snowflake/cli/api/project/schemas/{identifier_model.py → v1/identifier_model.py}

@@ -17,7 +17,9 @@ from __future__ import annotations
 from typing import Optional, cast
 
 from pydantic import Field
-from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
+from snowflake.cli.api.project.schemas.updatable_model import (
+    IdentifierField,
+)
 
 
 class ObjectIdentifierBaseModel:

snowflake/cli/api/project/schemas/{native_app → v1/native_app}/application.py

@@ -16,19 +16,13 @@ from __future__ import annotations
 
 from typing import List, Optional
 
-from pydantic import Field
+from pydantic import Field, field_validator
+from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
     UpdatableModel,
 )
-
-
-class SqlScriptHookType(UpdatableModel):
-    sql_script: str = Field(title="SQL file path relative to the project root")
-
-
-# Currently sql_script is the only supported hook type. Change to a Union once other hook types are added
-PostDeployHook = SqlScriptHookType
+from snowflake.cli.api.project.util import append_test_resource_suffix
 
 
 class Application(UpdatableModel):
@@ -53,6 +47,11 @@ class Application(UpdatableModel):
         default=None,
     )
 
+    @field_validator("name")
+    @classmethod
+    def append_test_resource_suffix_to_name(cls, input_value: str) -> str:
+        return append_test_resource_suffix(input_value)
+
 
 class ApplicationV11(Application):
     # Templated defaults only supported in v1.1+

snowflake/cli/api/project/schemas/{native_app → v1/native_app}/native_app.py

@@ -18,13 +18,13 @@ import re
 from typing import List, Optional, Union
 
 from pydantic import Field, field_validator
-from snowflake.cli.api.project.schemas.native_app.application import (
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.native_app.application import (
     Application,
     ApplicationV11,
 )
-from snowflake.cli.api.project.schemas.native_app.package import Package, PackageV11
-from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.native_app.package import Package, PackageV11
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import (
     SCHEMA_AND_NAME,
 )

snowflake/cli/api/project/schemas/{native_app → v1/native_app}/package.py

@@ -17,11 +17,12 @@ from __future__ import annotations
 from typing import List, Literal, Optional
 
 from pydantic import Field, field_validator, model_validator
-from snowflake.cli.api.project.schemas.native_app.application import PostDeployHook
+from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
     UpdatableModel,
 )
+from snowflake.cli.api.project.util import append_test_resource_suffix
 
 DistributionOptions = Literal["internal", "external", "INTERNAL", "EXTERNAL"]
 
@@ -50,6 +51,11 @@ class Package(UpdatableModel):
         default=None,
     )
 
+    @field_validator("name")
+    @classmethod
+    def append_test_resource_suffix_to_name(cls, input_value: str) -> str:
+        return append_test_resource_suffix(input_value)
+
     @field_validator("scripts")
     @classmethod
     def validate_scripts(cls, input_list):

snowflake/cli/api/project/schemas/{snowpark → v1/snowpark}/callable.py

@@ -17,9 +17,9 @@ 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 UpdatableModel
+from snowflake.cli.api.project.schemas.v1.identifier_model import ObjectIdentifierModel
+from snowflake.cli.api.project.schemas.v1.snowpark.argument import Argument
 
 
 class _CallableBase(UpdatableModel):

snowflake/cli/api/project/schemas/{snowpark → v1/snowpark}/snowpark.py

@@ -17,11 +17,11 @@ from __future__ import annotations
 from typing import List, Optional
 
 from pydantic import Field
-from snowflake.cli.api.project.schemas.snowpark.callable import (
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.snowpark.callable import (
     FunctionSchema,
     ProcedureSchema,
 )
-from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 
 
 class Snowpark(UpdatableModel):

snowflake/cli/api/project/schemas/{streamlit → v1/streamlit}/streamlit.py

@@ -18,8 +18,8 @@ from pathlib import Path
 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
+from snowflake.cli.api.project.schemas.v1.identifier_model import ObjectIdentifierModel
 
 
 class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):  # type: ignore
@@ -44,3 +44,4 @@ class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):
     title: Optional[str] = Field(
         title="Human-readable title for the Streamlit dashboard", default=None
     )
+    comment: Optional[str] = Field(title="Comment for the Streamlit app", default=None)