snowflake-cli-labs 2.7.0rc4__py3-none-any.whl → 2.8.0rc0__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "2.7.0rc4"
+VERSION = "2.8.0rc0"

snowflake/cli/api/project/definition.py

@@ -21,13 +21,12 @@ import yaml
 from snowflake.cli.api.cli_global_context import cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.project_definition import (
-    ProjectDefinition,
     ProjectProperties,
 )
 from snowflake.cli.api.project.util import (
     append_to_identifier,
-    clean_identifier,
     get_env_username,
+    sanitize_identifier,
     to_identifier,
 )
 from snowflake.cli.api.secure_path import SecurePath
@@ -70,40 +69,8 @@ def load_project(
     return render_definition_template(merged_definitions, context_overrides or {})
 
 
-def generate_local_override_yml(
-    project: ProjectDefinition,
-) -> ProjectDefinition:
-    """
-    Generates defaults for optional keys in the same YAML structure as the project
-    schema. The returned YAML object can be saved directly to a file, if desired.
-    A connection is made using global context to resolve current role and warehouse.
-    """
-    conn = cli_context.connection
-    user = clean_identifier(get_env_username() or DEFAULT_USERNAME)
-    role = conn.role
-    warehouse = conn.warehouse
-
-    local: dict = {}
-    if project.native_app:
-        name = clean_identifier(project.native_app.name)
-        app_identifier = to_identifier(name)
-        user_app_identifier = append_to_identifier(app_identifier, f"_{user}")
-        package_identifier = append_to_identifier(app_identifier, f"_pkg_{user}")
-        local["native_app"] = {
-            "application": {
-                "name": user_app_identifier,
-                "role": role,
-                "debug": True,
-                "warehouse": warehouse,
-            },
-            "package": {"name": package_identifier, "role": role},
-        }
-
-    return project.update_from_dict(local)
-
-
 def default_app_package(project_name: str):
-    user = clean_identifier(get_env_username() or DEFAULT_USERNAME)
+    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
     return append_to_identifier(to_identifier(project_name), f"_pkg_{user}")
 
 
@@ -113,5 +80,5 @@ def default_role():
 
 
 def default_application(project_name: str):
-    user = clean_identifier(get_env_username() or DEFAULT_USERNAME)
+    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
     return append_to_identifier(to_identifier(project_name), f"_{user}")

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

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from typing import Literal, Optional
 
-from pydantic import AliasChoices, Field
+from pydantic import Field
 from snowflake.cli.api.project.schemas.entities.application_package_entity import (
     ApplicationPackageEntity,
 )
@@ -25,26 +25,20 @@ from snowflake.cli.api.project.schemas.entities.common import (
     TargetField,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
-    UpdatableModel,
+    DiscriminatorField,
 )
 
 
 class ApplicationEntity(EntityBase):
-    type: Literal["application"]  # noqa: A003
+    type: Literal["application"] = DiscriminatorField()  # noqa A003
     name: str = Field(
         title="Name of the application created when this entity is deployed"
     )
-    from_: ApplicationFromField = Field(
-        validation_alias=AliasChoices("from"),
+    from_: TargetField[ApplicationPackageEntity] = Field(
+        alias="from",
         title="An application package this entity should be created from",
     )
     debug: Optional[bool] = Field(
         title="Whether to enable debug mode when using a named stage to create an application object",
         default=None,
     )
-
-
-class ApplicationFromField(UpdatableModel):
-    target: TargetField[ApplicationPackageEntity] = Field(
-        title="Reference to an application package entity",
-    )

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

@@ -23,11 +23,14 @@ from snowflake.cli.api.project.schemas.entities.common import (
 )
 from snowflake.cli.api.project.schemas.native_app.package import DistributionOptions
 from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
+from snowflake.cli.api.project.schemas.updatable_model import (
+    DiscriminatorField,
+    IdentifierField,
+)
 
 
 class ApplicationPackageEntity(EntityBase):
-    type: Literal["application package"]  # noqa: A003
+    type: Literal["application package"] = DiscriminatorField()  # noqa: A003
     name: str = Field(
         title="Name of the application package created when this entity is deployed"
     )

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

@@ -17,10 +17,9 @@ from __future__ import annotations
 from abc import ABC
 from typing import Generic, List, Optional, TypeVar
 
-from pydantic import AliasChoices, Field, GetCoreSchemaHandler, ValidationInfo
-from pydantic_core import core_schema
+from pydantic import Field
 from snowflake.cli.api.project.schemas.native_app.application import (
-    ApplicationPostDeployHook,
+    PostDeployHook,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
@@ -36,7 +35,7 @@ class MetaField(UpdatableModel):
         title="Role to use when creating the entity object",
         default=None,
     )
-    post_deploy: Optional[List[ApplicationPostDeployHook]] = Field(
+    post_deploy: Optional[List[PostDeployHook]] = Field(
         title="Actions that will be executed after the application object is created/upgraded",
         default=None,
     )
@@ -45,7 +44,7 @@ class MetaField(UpdatableModel):
 class DefaultsField(UpdatableModel):
     schema_: Optional[str] = Field(
         title="Schema.",
-        validation_alias=AliasChoices("schema"),
+        alias="schema",
         default=None,
     )
     stage: Optional[str] = Field(
@@ -65,21 +64,15 @@ class EntityBase(ABC, UpdatableModel):
 TargetType = TypeVar("TargetType")
 
 
-class TargetField(Generic[TargetType]):
-    def __init__(self, entity_target_key: str):
-        self.value = entity_target_key
-
-    def __repr__(self):
-        return self.value
-
-    @classmethod
-    def validate(cls, value: str, info: ValidationInfo) -> TargetField:
-        return cls(value)
+class TargetField(UpdatableModel, Generic[TargetType]):
+    target: str = Field(
+        title="Reference to a target entity",
+    )
 
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls, source_type, handler: GetCoreSchemaHandler
-    ) -> core_schema.CoreSchema:
-        return core_schema.with_info_after_validator_function(
-            cls.validate, handler(str), field_name=handler.field_name
-        )
+    def get_type(self) -> type:
+        """
+        Returns the generic type of this class, indicating the entity type.
+        Pydantic extracts Generic annotations, and populates
+        them in __pydantic_generic_metadata__
+        """
+        return self.__pydantic_generic_metadata__["args"][0]

snowflake/cli/api/project/schemas/native_app/application.py

@@ -28,7 +28,7 @@ class SqlScriptHookType(UpdatableModel):
 
 
 # Currently sql_script is the only supported hook type. Change to a Union once other hook types are added
-ApplicationPostDeployHook = SqlScriptHookType
+PostDeployHook = SqlScriptHookType
 
 
 class Application(UpdatableModel):
@@ -48,7 +48,15 @@ class Application(UpdatableModel):
         title="When set, forces debug_mode on/off for the deployed application object",
         default=None,
     )
-    post_deploy: Optional[List[ApplicationPostDeployHook]] = Field(
+    post_deploy: Optional[List[PostDeployHook]] = Field(
         title="Actions that will be executed after the application object is created/upgraded",
         default=None,
     )
+
+
+class ApplicationV11(Application):
+    # Templated defaults only supported in v1.1+
+    name: Optional[str] = Field(
+        title="Name of the application object created when you run the snow app run command",
+        default="<% fn.concat_ids(ctx.native_app.name, '_', fn.sanitize_id(fn.get_username('unknown_user')) | lower) %>",
+    )

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

@@ -18,8 +18,11 @@ import re
 from typing import List, Optional, Union
 
 from pydantic import Field, field_validator
-from snowflake.cli.api.project.schemas.native_app.application import Application
-from snowflake.cli.api.project.schemas.native_app.package import Package
+from snowflake.cli.api.project.schemas.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.util import (
@@ -80,3 +83,11 @@ class NativeApp(UpdatableModel):
                 transformed_artifacts.append(PathMapping(src=artifact))
 
         return transformed_artifacts
+
+
+class NativeAppV11(NativeApp):
+    # templated defaults are only supported with version 1.1+
+    package: Optional[PackageV11] = Field(title="PackageSchema", default=PackageV11())
+    application: Optional[ApplicationV11] = Field(
+        title="Application info", default=ApplicationV11()
+    )

snowflake/cli/api/project/schemas/native_app/package.py

@@ -16,7 +16,8 @@ from __future__ import annotations
 
 from typing import List, Literal, Optional
 
-from pydantic import Field, field_validator
+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.updatable_model import (
     IdentifierField,
     UpdatableModel,
@@ -44,6 +45,10 @@ class Package(UpdatableModel):
         title="Distribution of the application package created by the Snowflake CLI",
         default="internal",
     )
+    post_deploy: Optional[List[PostDeployHook]] = Field(
+        title="Actions that will be executed after the application package object is created/updated",
+        default=None,
+    )
 
     @field_validator("scripts")
     @classmethod
@@ -53,3 +58,21 @@ class Package(UpdatableModel):
                 "package.scripts field should contain unique values. Check the list for duplicates and try again"
             )
         return input_list
+
+    @model_validator(mode="after")
+    @classmethod
+    def validate_no_scripts_and_post_deploy(cls, value: Package):
+        if value.scripts and value.post_deploy:
+            raise ValueError(
+                "package.scripts and package.post_deploy fields cannot be used together. "
+                "We recommend using package.post_deploy for all post package deploy scripts"
+            )
+        return value
+
+
+class PackageV11(Package):
+    # Templated defaults only supported in v1.1+
+    name: Optional[str] = IdentifierField(
+        title="Name of the application package created when you run the snow app run command",
+        default="<% fn.concat_ids(ctx.native_app.name, '_pkg_', fn.sanitize_id(fn.get_username('unknown_user')) | lower) %>",
+    )

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

@@ -32,11 +32,13 @@ from snowflake.cli.api.project.schemas.entities.entities import (
     Entity,
     v2_entity_types_map,
 )
-from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
+from snowflake.cli.api.project.schemas.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.utils.models import ProjectEnvironment
 from snowflake.cli.api.utils.types import Context
 from typing_extensions import Annotated
 
@@ -99,22 +101,14 @@ class DefinitionV10(_ProjectDefinitionBase):
 
 
 class DefinitionV11(DefinitionV10):
-    env: Union[Dict[str, str], ProjectEnvironment, None] = Field(
-        title="Environment specification for this project.",
+    native_app: Optional[NativeAppV11] = Field(
+        title="Native app definitions for the project", default=None
+    )
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
         default=None,
-        validation_alias="env",
-        union_mode="smart",
     )
 
-    @field_validator("env")
-    @classmethod
-    def _convert_env(
-        cls, env: Union[Dict, ProjectEnvironment, None]
-    ) -> ProjectEnvironment:
-        if isinstance(env, ProjectEnvironment):
-            return env
-        return ProjectEnvironment(default_env=(env or {}), override_env={})
-
 
 class DefinitionV20(_ProjectDefinitionBase):
     entities: Dict[str, Annotated[Entity, Field(discriminator="type")]] = Field(
@@ -147,10 +141,10 @@ class DefinitionV20(_ProjectDefinitionBase):
         for key, entity in entities.items():
             # TODO Automatically detect TargetFields to validate
             if entity.type == ApplicationEntity.get_type():
-                if isinstance(entity.from_.target, TargetField):
-                    target_key = str(entity.from_.target)
-                    target_class = entity.from_.__class__.model_fields["target"]
-                    target_type = target_class.annotation.__args__[0]
+                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)
         return entities
 
@@ -160,37 +154,26 @@ class DefinitionV20(_ProjectDefinitionBase):
     ):
         if target_key not in entities:
             raise ValueError(f"No such target: {target_key}")
-        else:
-            # Validate the target type
-            actual_target_type = entities[target_key].__class__
-            if target_type and target_type is not actual_target_type:
-                raise ValueError(
-                    f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
-                )
+
+        # Validate the target type
+        actual_target_type = entities[target_key].__class__
+        if target_type and target_type is not actual_target_type:
+            raise ValueError(
+                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: Union[Dict[str, str], ProjectEnvironment, None] = Field(
-        title="Environment specification for this project.",
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
         default=None,
-        validation_alias="env",
-        union_mode="smart",
     )
 
-    @field_validator("env")
-    @classmethod
-    def _convert_env(
-        cls, env: Union[Dict, ProjectEnvironment, None]
-    ) -> ProjectEnvironment:
-        if isinstance(env, ProjectEnvironment):
-            return env
-        return ProjectEnvironment(default_env=(env or {}), override_env={})
-
 
-def build_project_definition(**data):
+def build_project_definition(**data) -> ProjectDefinition:
     """
     Returns a ProjectDefinition instance with a version matching the provided definition_version value
     """

snowflake/cli/api/project/schemas/snowpark/callable.py

@@ -19,9 +19,7 @@ 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.updatable_model import UpdatableModel
 
 
 class _CallableBase(UpdatableModel):

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

@@ -14,17 +14,149 @@
 
 from __future__ import annotations
 
-from typing import Any, Dict
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Iterator, Optional
 
-from pydantic import BaseModel, ConfigDict, Field
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    ValidationInfo,
+    field_validator,
+)
+from pydantic.fields import FieldInfo
 from snowflake.cli.api.project.util import IDENTIFIER_NO_LENGTH
 
+PROJECT_TEMPLATE_START = "<%"
+
+
+def _is_templated(info: ValidationInfo, value: Any) -> bool:
+    return (
+        info.context
+        and info.context.get("skip_validation_on_templates", False)
+        and isinstance(value, str)
+        and PROJECT_TEMPLATE_START in value
+    )
+
+
+_initial_context: ContextVar[Optional[Dict[str, Any]]] = ContextVar(
+    "_init_context_var", default=None
+)
+
+
+@contextmanager
+def context(value: Dict[str, Any]) -> Iterator[None]:
+    """
+    Thread safe context for Pydantic.
+    By using `with context()`, you ensure context changes apply
+    to the with block only
+    """
+    token = _initial_context.set(value)
+    try:
+        yield
+    finally:
+        _initial_context.reset(token)
+
 
 class UpdatableModel(BaseModel):
     model_config = ConfigDict(validate_assignment=True, extra="forbid")
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(**kwargs)
+    def __init__(self, /, **data: Any) -> None:
+        """
+        Pydantic provides 2 options to pass in context:
+        1) Through `model_validate()` as a second argument.
+        2) Through a custom init method and the use of ContextVar
+
+        We decided not to use 1) because it silently stops working
+        if someone adds a pass through __init__ to any of the Pydantic models.
+
+        We decided to go with 2) as the safer approach.
+        Calling validate_python() in the __init__ is how we can pass context
+        on initialization according to Pydantic's documentation:
+        https://docs.pydantic.dev/latest/concepts/validators/#using-validation-context-with-basemodel-initialization
+        """
+        self.__pydantic_validator__.validate_python(
+            data,
+            self_instance=self,
+            context=_initial_context.get(),
+        )
+
+    @classmethod
+    def _is_entity_type_field(cls, field: Any) -> bool:
+        """
+        Checks if a field is of type `DiscriminatorField`
+        """
+        if not isinstance(field, FieldInfo) or not field.json_schema_extra:
+            return False
+
+        return (
+            "is_discriminator_field" in field.json_schema_extra
+            and field.json_schema_extra["is_discriminator_field"]
+        )
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        """
+        This method will collect all the Pydantic annotations for the class
+        currently being initialized (any subclass of `UpdatableModel`).
+
+        It will add a field validator wrapper for every Pydantic field
+        in order to skip validation when templates are found.
+
+        It will apply this to all Pydantic fields, except for fields
+        marked as `DiscriminatorField`. These will be skipped because
+        Pydantic does not support validators for discriminator field types.
+        """
+
+        super().__init_subclass__(**kwargs)
+
+        field_annotations = {}
+        field_values = {}
+        # Go through the inheritance classes and collect all the annotations and
+        # 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.
+
+        for class_ in reversed(cls.__mro__):
+            class_dict = class_.__dict__
+            field_annotations.update(class_dict.get("__annotations__", {}))
+
+            if "model_fields" in class_dict:
+                # This means the class dict has already been processed by Pydantic
+                # All fields should properly be populated in model_fields
+                field_values.update(class_dict["model_fields"])
+            else:
+                # If Pydantic did not process this class yet, get the values from class_dict directly
+                field_values.update(class_dict)
+
+        # 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)):
+                cls._add_validator(field_name)
+
+    @classmethod
+    def _add_validator(cls, field_name: str):
+        """
+        Adds a Pydantic validator with mode=wrap for the provided `field_name`.
+        During validation, this will check if the field is templated (not expanded yet)
+        and in that case, it will skip all the remaining Pydantic validation on that field.
+
+        Since this validator is added last, it will skip all the other field validators
+        defined in the subclasses when templates are found.
+
+        This logic on templates only applies when context contains `skip_validation_on_templates` flag.
+        """
+
+        def validator_skipping_templated_str(cls, value, handler, info: ValidationInfo):
+            if _is_templated(info, value):
+                return value
+            return handler(value)
+
+        setattr(
+            cls,
+            f"_field_validator_with_verbose_name_to_avoid_name_conflict_{field_name}",
+            field_validator(field_name, mode="wrap")(validator_skipping_templated_str),
+        )
 
     def update_from_dict(self, update_values: Dict[str, Any]):
         """
@@ -47,5 +179,16 @@ class UpdatableModel(BaseModel):
         return self
 
 
-def IdentifierField(*args, **kwargs):  # noqa
+def DiscriminatorField(*args, **kwargs):  # noqa N802
+    """
+    Use this type for discriminator fields used for differentiating
+    between different entity types.
+
+    When this `DiscriminatorField` is used on a pydantic attribute,
+    we will not allow templating on it.
+    """
+    return Field(is_discriminator_field=True, *args, **kwargs)
+
+
+def IdentifierField(*args, **kwargs):  # noqa N802
     return Field(max_length=254, pattern=IDENTIFIER_NO_LENGTH, *args, **kwargs)

snowflake/cli/api/project/util.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import codecs
 import os
 import re
-from typing import Optional
+from typing import List, Optional
 from urllib.parse import quote
 
 IDENTIFIER = r'((?:"[^"]*(?:""[^"]*)*")|(?:[A-Za-z_][\w$]{0,254}))'
@@ -42,12 +42,20 @@ def encode_uri_component(s: str) -> str:
     return quote(s, safe="!~*'()")
 
 
-def clean_identifier(input_: str):
+def sanitize_identifier(input_: str):
     """
-    Removes characters that cannot be used in an unquoted identifier,
-    converting to lowercase as well.
+    Removes characters that cannot be used in an unquoted identifier.
+    If the identifier does not start with a letter or underscore, prefix it with an underscore.
+    Limits the identifier to 255 characters.
     """
-    return re.sub(r"[^a-z0-9_$]", "", f"{input_}".lower())
+    value = re.sub(r"[^a-zA-Z0-9_$]", "", f"{input_}")
+
+    # if it does not start with a letter or underscore, prefix it with an underscore
+    if not value or not re.match(r"[a-zA-Z_]", value[0]):
+        value = f"_{value}"
+
+    # limit it to 255 characters
+    return value[:255]
 
 
 def is_valid_unquoted_identifier(identifier: str) -> bool:
@@ -88,6 +96,18 @@ def is_valid_object_name(name: str, max_depth=2, allow_quoted=True) -> bool:
     return re.fullmatch(pattern, name) is not None
 
 
+def to_quoted_identifier(input_value: str) -> str:
+    """
+    Turn the input into a valid quoted identifier.
+    If it is already a valid quoted identifier,
+    return it as is.
+    """
+    if is_valid_quoted_identifier(input_value):
+        return input_value
+
+    return '"' + input_value.replace('"', '""') + '"'
+
+
 def to_identifier(name: str) -> str:
     """
     Converts a name to a valid Snowflake identifier. If the name is already a valid
@@ -96,8 +116,15 @@ def to_identifier(name: str) -> str:
     if is_valid_identifier(name):
         return name
 
-    # double quote the identifier
-    return '"' + name.replace('"', '""') + '"'
+    return to_quoted_identifier(name)
+
+
+def identifier_to_str(identifier: str) -> str:
+    if is_valid_quoted_identifier(identifier):
+        unquoted_id = identifier[1:-1]
+        return unquoted_id.replace('""', '"')
+
+    return identifier
 
 
 def append_to_identifier(identifier: str, suffix: str) -> str:
@@ -183,6 +210,27 @@ def get_env_username() -> Optional[str]:
     return first_set_env("USER", "USERNAME", "LOGNAME")
 
 
+def concat_identifiers(identifiers: list[str]) -> str:
+    """
+    Concatenate multiple identifiers.
+    If any of them is quoted identifier or contains unsafe characters, quote the result.
+    Otherwise, the resulting identifier will be unquoted.
+    """
+    quotes_found = False
+    stringified_identifiers: List[str] = []
+
+    for identifier in identifiers:
+        if is_valid_quoted_identifier(identifier):
+            quotes_found = True
+        stringified_identifiers.append(identifier_to_str(identifier))
+
+    concatenated_ids_str = "".join(stringified_identifiers)
+    if quotes_found:
+        return to_quoted_identifier(concatenated_ids_str)
+
+    return to_identifier(concatenated_ids_str)
+
+
 SUPPORTED_VERSIONS = [1]