V2.0 Definition for snowpark

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

@@ -52,6 +52,11 @@ class DefaultsField(UpdatableModel):
         default=None,
     )
 
+    project_name: Optional[str] = Field(
+        title="Name of the project.",
+        default=None,
+    )
+
 
 class EntityBase(ABC, UpdatableModel):
     @classmethod

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

@@ -22,9 +22,19 @@
 from snowflake.cli.api.project.schemas.entities.application_package_entity import (
     ApplicationPackageEntity,
 )
+from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
+    FunctionEntity,
+    ProcedureEntity,
+)
 from snowflake.cli.api.project.schemas.entities.streamlit_entity import StreamlitEntity
 
-Entity = Union[ApplicationEntity, ApplicationPackageEntity, StreamlitEntity]
+Entity = Union[
+    ApplicationEntity,
+    ApplicationPackageEntity,
+    StreamlitEntity,
+    ProcedureEntity,
+    FunctionEntity,
+]
 
 ALL_ENTITIES = [*get_args(Entity)]
 

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

@@ -0,0 +1,73 @@
+# 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 Dict, List, Literal, Optional, Union
+
+from pydantic import Field, field_validator
+from snowflake.cli.api.project.schemas.entities.common import EntityBase
+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 DiscriminatorField
+
+
+class SnowparkEntity(EntityBase):
+    handler: str = Field(
+        title="Function’s or procedure’s implementation of the object inside source module",
+        examples=["functions.hello_function"],
+    )
+    returns: str = Field(
+        title="Type of the result"
+    )  # TODO: again, consider Literal/Enum
+    signature: Union[str, List[Argument]] = Field(
+        title="The signature parameter describes consecutive arguments passed to the object"
+    )
+    runtime: Optional[Union[str, float]] = Field(
+        title="Python version to use when executing ", default=None
+    )
+    external_access_integrations: Optional[List[str]] = Field(
+        title="Names of external access integrations needed for this procedure’s handler code 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={},
+    )
+    imports: Optional[List[str]] = Field(
+        title="Stage and path to previously uploaded files you want to import",
+        default=[],
+    )
+    stage: str = Field(title="Stage in which artifacts will be stored")
+    src: str = Field(title="Folder where your code should be located")
+
+    @field_validator("runtime")
+    @classmethod
+    def convert_runtime(cls, runtime_input: Union[str, float]) -> str:
+        if isinstance(runtime_input, float):
+            return str(runtime_input)
+        return runtime_input
+
+
+class ProcedureEntity(SnowparkEntity, ObjectIdentifierModel("procedure")):  # type: ignore
+    type: Literal["procedure"] = DiscriminatorField()  # noqa: A003
+    execute_as_caller: Optional[bool] = Field(
+        title="Determine whether the procedure is executed with the privileges of "
+        "the owner (you) or with the privileges of the caller",
+        default=False,
+    )
+
+
+class FunctionEntity(SnowparkEntity, ObjectIdentifierModel("function")):  # type: ignore
+    type: Literal["function"] = DiscriminatorField()  # noqa: A003

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

@@ -42,6 +42,8 @@
 from snowflake.cli.api.utils.types import Context
 from typing_extensions import Annotated
 
+AnnotatedEntity = Annotated[Entity, Field(discriminator="type")]
+
 
 @dataclass
 class ProjectProperties:
@@ -111,8 +113,16 @@ 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.")
+
+    defaults: Optional[DefaultsField] = Field(
+        title="Default key/value entity values that are merged recursively for each entity.",
+        default=None,
+    )
+
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
+        default=None,
     )
 
     @model_validator(mode="before")
@@ -137,17 +147,29 @@ def apply_defaults(cls, data: Dict) -> Dict:
 
     @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: Entity, entities: Dict[str, AnnotatedEntity]
+    ):
+        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)
+
     @classmethod
     def _validate_target_field(
         cls, target_key: str, target_type: Entity, entities: Dict[str, Entity]
@@ -162,16 +184,6 @@ def _validate_target_field(
                 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.",
-        default=None,
-    )
-
-    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
-        title="Default environment specification for this project.",
-        default=None,
-    )
-
     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}