snowflake-cli 2.8.2__py3-none-any.whl

snowflake/cli/api/project/errors.py

@@ -0,0 +1,56 @@
+# 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 textwrap import dedent
+
+from click import ClickException
+from pydantic import ValidationError
+
+
+class SchemaValidationError(ClickException):
+    generic_message = "For field {location} you provided '{input}'. This caused: {msg}"
+    message_templates = {
+        "string_type": "{msg} for field '{location}', you provided '{input}'.",
+        "extra_forbidden": "{msg}. You provided field '{location}' with value '{input}' that is not supported in given version.",
+        "missing": "Your project definition is missing the following field: '{location}'",
+    }
+
+    def __init__(self, error: ValidationError):
+        errors = error.errors()
+        message = f"During evaluation of {error.title} in project definition following errors were encountered:\n"
+
+        def calculate_location(e):
+            if e["loc"] is None:
+                return None
+
+            # show numbers as list indexes and strings as dictionary keys. Example: key1[0].key2
+            result = "".join(
+                f"[{item}]" if isinstance(item, int) else f".{item}"
+                for item in e["loc"]
+            )
+
+            # remove leading dot from the string if any:
+            return result[1:] if result.startswith(".") else result
+
+        message += "\n".join(
+            [
+                self.message_templates.get(e["type"], self.generic_message).format(
+                    **e,
+                    location=calculate_location(e),
+                )
+                for e in errors
+            ]
+        )
+
+        super().__init__(dedent(message))

snowflake/cli/api/project/project_verification.py

@@ -0,0 +1,23 @@
+# 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 snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.exceptions import NoProjectDefinitionError
+
+
+def assert_project_type(project_type: str):
+    if not getattr(cli_context.project_definition, project_type, None):
+        raise NoProjectDefinitionError(
+            project_type=project_type, project_file=cli_context.project_root
+        )

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

@@ -0,0 +1,13 @@
+# 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.

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

@@ -0,0 +1,44 @@
+# 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 Literal, Optional
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityBase,
+    TargetField,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    DiscriminatorField,
+)
+
+
+class ApplicationEntity(EntityBase):
+    type: Literal["application"] = DiscriminatorField()  # noqa A003
+    name: str = Field(
+        title="Name of the application created when this entity is deployed"
+    )
+    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,
+    )

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

@@ -0,0 +1,66 @@
+# 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 pathlib import Path
+from typing import List, Literal, Optional, Union
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityBase,
+)
+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 (
+    DiscriminatorField,
+    IdentifierField,
+)
+
+
+class ApplicationPackageEntity(EntityBase):
+    type: Literal["application package"] = DiscriminatorField()  # noqa: A003
+    name: str = Field(
+        title="Name of the application package created when this entity is deployed"
+    )
+    artifacts: List[Union[PathMapping, Path]] = Field(
+        title="List of paths or file source/destination pairs to add to the deploy root",
+    )
+    bundle_root: Optional[Path] = Field(
+        title="Folder at the root of your project where artifacts necessary to perform the bundle step are stored.",
+        default=Path("output/bundle/"),
+    )
+    deploy_root: Optional[Path] = Field(
+        title="Folder at the root of your project where the build step copies the artifacts",
+        default=Path("output/deploy/"),
+    )
+    generated_root: Optional[Path] = Field(
+        title="Subdirectory of the deploy root where files generated by the Snowflake CLI will be written.",
+        default=Path("__generated/"),
+    )
+    stage: Optional[str] = IdentifierField(
+        title="Identifier of the stage that stores the application artifacts.",
+        default="app_src.stage",
+    )
+    scratch_stage: Optional[str] = IdentifierField(
+        title="Identifier of the stage that stores temporary scratch data used by the Snowflake CLI.",
+        default="app_src.stage_snowflake_cli_scratch",
+    )
+    distribution: Optional[DistributionOptions] = Field(
+        title="Distribution of the application package created by the Snowflake CLI",
+        default="internal",
+    )
+    manifest: Path = Field(
+        title="Path to manifest.yml",
+    )

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

@@ -0,0 +1,78 @@
+# 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 abc import ABC
+from typing import Generic, List, Optional, TypeVar
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.native_app.application import (
+    PostDeployHook,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    IdentifierField,
+    UpdatableModel,
+)
+
+
+class MetaField(UpdatableModel):
+    warehouse: Optional[str] = IdentifierField(
+        title="Warehouse used to run the scripts", default=None
+    )
+    role: Optional[str] = IdentifierField(
+        title="Role to use when creating the entity object",
+        default=None,
+    )
+    post_deploy: Optional[List[PostDeployHook]] = Field(
+        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.",
+        default=None,
+    )
+
+
+class EntityBase(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)
+
+
+TargetType = TypeVar("TargetType")
+
+
+class TargetField(UpdatableModel, Generic[TargetType]):
+    target: str = Field(
+        title="Reference to a target entity",
+    )
+
+    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/entities/entities.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 __future__ import annotations
+
+from typing import Union, get_args
+
+from snowflake.cli.api.project.schemas.entities.application_entity import (
+    ApplicationEntity,
+)
+from snowflake.cli.api.project.schemas.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
+
+Entity = Union[ApplicationEntity, ApplicationPackageEntity]
+
+ALL_ENTITIES = [*get_args(Entity)]
+
+v2_entity_types_map = {e.get_type(): e for e in ALL_ENTITIES}

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

@@ -0,0 +1,49 @@
+# 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 Optional, cast
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
+
+
+class ObjectIdentifierBaseModel:
+    """
+    Type representing a base class defining object that can be identified by fully qualified name (db.schema.name).
+    This is not a Pydantic model and the purpose of this class is to provide typing support to Pydantic models
+    generated using a factory class ObjectIdentifierModel.
+    """
+
+    name: str
+    database: Optional[str]
+    schema_name: Optional[str]
+
+
+def ObjectIdentifierModel(object_name: str) -> ObjectIdentifierBaseModel:  # noqa: N802
+    """Generates ObjectIdentifierBaseModel but with object specific descriptions."""
+
+    class _ObjectIdentifierModel(ObjectIdentifierBaseModel):
+        name: str = Field(title=f"{object_name.capitalize()} name")
+        database: Optional[str] = IdentifierField(
+            title=f"Name of the database for the {object_name}", default=None
+        )
+        schema_name: Optional[str] = IdentifierField(
+            title=f"Name of the schema for the {object_name}",
+            default=None,
+            alias="schema",
+        )
+
+    return cast(ObjectIdentifierBaseModel, _ObjectIdentifierModel)

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

@@ -0,0 +1,13 @@
+# 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.

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

@@ -0,0 +1,62 @@
+# 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 List, Optional
+
+from pydantic import Field
+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 Application(UpdatableModel):
+    role: Optional[str] = Field(
+        title="Role to use when creating the application object and consumer-side objects",
+        default=None,
+    )
+    name: Optional[str] = Field(
+        title="Name of the application object created when you run the snow app run command",
+        default=None,
+    )
+    warehouse: Optional[str] = IdentifierField(
+        title="Name of the application object created when you run the snow app run command",
+        default=None,
+    )
+    debug: Optional[bool] = Field(
+        title="When set, forces debug_mode on/off for the deployed application object",
+        default=None,
+    )
+    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

@@ -0,0 +1,93 @@
+# 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
+
+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,
+    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 (
+    SCHEMA_AND_NAME,
+)
+
+
+class NativeApp(UpdatableModel):
+    name: str = Field(
+        title="Project identifier",
+    )
+    artifacts: List[Union[PathMapping, str]] = Field(
+        title="List of file source and destination pairs to add to the deploy root",
+    )
+    bundle_root: Optional[str] = Field(
+        title="Folder at the root of your project where artifacts necessary to perform the bundle step are stored.",
+        default="output/bundle/",
+    )
+    deploy_root: Optional[str] = Field(
+        title="Folder at the root of your project where the bundle step copies the artifacts.",
+        default="output/deploy/",
+    )
+    generated_root: Optional[str] = Field(
+        title="Subdirectory of the deploy root where files generated by the Snowflake CLI will be written.",
+        default="__generated/",
+    )
+    source_stage: Optional[str] = Field(
+        title="Identifier of the stage that stores the application artifacts.",
+        default="app_src.stage",
+    )
+    scratch_stage: Optional[str] = Field(
+        title="Identifier of the stage that stores temporary scratch data used by the Snowflake CLI.",
+        default="app_src.stage_snowflake_cli_scratch",
+    )
+    package: Optional[Package] = Field(title="PackageSchema", default=None)
+    application: Optional[Application] = Field(title="Application info", default=None)
+
+    @field_validator("source_stage")
+    @classmethod
+    def validate_source_stage(cls, input_value: str):
+        if not re.match(SCHEMA_AND_NAME, input_value):
+            raise ValueError("Incorrect value for source_stage value of native_app")
+        return input_value
+
+    @field_validator("artifacts")
+    @classmethod
+    def transform_artifacts(
+        cls, orig_artifacts: List[Union[PathMapping, str]]
+    ) -> List[PathMapping]:
+        transformed_artifacts = []
+        if orig_artifacts is None:
+            return transformed_artifacts
+
+        for artifact in orig_artifacts:
+            if isinstance(artifact, PathMapping):
+                transformed_artifacts.append(artifact)
+            else:
+                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

@@ -0,0 +1,78 @@
+# 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 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.updatable_model import (
+    IdentifierField,
+    UpdatableModel,
+)
+
+DistributionOptions = Literal["internal", "external", "INTERNAL", "EXTERNAL"]
+
+
+class Package(UpdatableModel):
+    scripts: Optional[List[str]] = Field(
+        title="List of SQL file paths relative to the project root", default=None
+    )
+    role: Optional[str] = IdentifierField(
+        title="Role to use when creating the application package and provider-side objects",
+        default=None,
+    )
+    name: Optional[str] = IdentifierField(
+        title="Name of the application package created when you run the snow app run command",
+        default=None,
+    )
+    warehouse: Optional[str] = IdentifierField(
+        title="Warehouse used to run the scripts", default=None
+    )
+    distribution: Optional[DistributionOptions] = Field(
+        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
+    def validate_scripts(cls, input_list):
+        if len(input_list) != len(set(input_list)):
+            raise ValueError(
+                "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/native_app/path_mapping.py

@@ -0,0 +1,65 @@
+# 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 Any, Dict, List, Optional, Union
+
+from pydantic import Field, field_validator
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+
+
+class ProcessorMapping(UpdatableModel):
+    name: str = Field(
+        title="Name of a processor to invoke on a collection of artifacts."
+    )
+    properties: Optional[Dict[str, Any]] = Field(
+        title="A set of key-value pairs used to configure the output of the processor. Consult a specific processor's documentation for more details on the supported properties.",
+        default=None,
+    )
+
+
+class PathMapping(UpdatableModel):
+    src: str = Field(
+        title="Source path or glob pattern (relative to project root)", default=None
+    )
+
+    dest: Optional[str] = Field(
+        title="Destination path on stage",
+        description="Paths are relative to stage root; paths ending with a slash indicate that the destination is a directory which source files should be copied into.",
+        default=None,
+    )
+
+    processors: Optional[List[Union[str, ProcessorMapping]]] = Field(
+        title="List of processors to apply to matching source files during bundling.",
+        default=[],
+    )
+
+    @field_validator("processors")
+    @classmethod
+    def transform_processors(
+        cls, input_values: Optional[List[Union[str, Dict, ProcessorMapping]]]
+    ) -> List[ProcessorMapping]:
+        if input_values is None:
+            return []
+
+        transformed_processors: List[ProcessorMapping] = []
+        for input_processor in input_values:
+            if isinstance(input_processor, str):
+                transformed_processors.append(ProcessorMapping(name=input_processor))
+            elif isinstance(input_processor, Dict):
+                transformed_processors.append(ProcessorMapping(**input_processor))
+            else:
+                transformed_processors.append(input_processor)
+        return transformed_processors