snowflake-cli-labs 2.8.0rc1__py3-none-any.whl → 2.8.2__py3-none-any.whl

snowflake/cli/plugins/nativeapp/codegen/setup/native_app_setup_processor.py

@@ -1,172 +0,0 @@
-# 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 json
-import os.path
-from pathlib import Path
-from typing import List, Optional
-
-from click import ClickException
-from snowflake.cli.api.console import cli_console as cc
-from snowflake.cli.api.project.schemas.native_app.path_mapping import (
-    PathMapping,
-    ProcessorMapping,
-)
-from snowflake.cli.plugins.nativeapp.artifacts import BundleMap, find_setup_script_file
-from snowflake.cli.plugins.nativeapp.codegen.artifact_processor import (
-    ArtifactProcessor,
-    is_python_file_artifact,
-)
-from snowflake.cli.plugins.nativeapp.codegen.sandbox import (
-    ExecutionEnvironmentType,
-    SandboxEnvBuilder,
-    execute_script_in_sandbox,
-)
-from snowflake.cli.plugins.nativeapp.project_model import NativeAppProjectModel
-from snowflake.cli.plugins.stage.diff import to_stage_path
-
-DEFAULT_TIMEOUT = 30
-DRIVER_PATH = Path(__file__).parent / "setup_driver.py.source"
-
-
-class NativeAppSetupProcessor(ArtifactProcessor):
-    def __init__(
-        self,
-        na_project: NativeAppProjectModel,
-    ):
-        super().__init__(na_project=na_project)
-
-    def process(
-        self,
-        artifact_to_process: PathMapping,
-        processor_mapping: Optional[ProcessorMapping],
-        **kwargs,
-    ) -> None:
-        """
-        Processes a Python setup script and generates the corresponding SQL commands.
-        """
-        bundle_map = BundleMap(
-            project_root=self._na_project.project_root,
-            deploy_root=self._na_project.deploy_root,
-        )
-        bundle_map.add(artifact_to_process)
-
-        self._create_or_update_sandbox()
-
-        cc.phase("Processing Python setup files")
-
-        files_to_process = []
-        for src_file, dest_file in bundle_map.all_mappings(
-            absolute=True, expand_directories=True, predicate=is_python_file_artifact
-        ):
-            cc.message(
-                f"Found Python setup file: {src_file.relative_to(self._na_project.project_root)}"
-            )
-            files_to_process.append(src_file)
-
-        sql_files_mapping = self._execute_in_sandbox(files_to_process)
-        self._generate_setup_sql(sql_files_mapping)
-
-    def _execute_in_sandbox(self, py_files: List[Path]) -> dict:
-        file_count = len(py_files)
-        cc.step(f"Processing {file_count} setup file{'s' if file_count > 1 else ''}")
-
-        env_vars = {
-            "_SNOWFLAKE_CLI_PROJECT_PATH": str(self._na_project.project_root),
-            "_SNOWFLAKE_CLI_SETUP_FILES": os.pathsep.join(map(str, py_files)),
-            "_SNOWFLAKE_CLI_APP_NAME": str(self._na_project.package_name),
-            "_SNOWFLAKE_CLI_SQL_DEST_DIR": str(self.generated_root),
-        }
-
-        try:
-            result = execute_script_in_sandbox(
-                script_source=DRIVER_PATH.read_text(),
-                env_type=ExecutionEnvironmentType.VENV,
-                cwd=self._na_project.bundle_root,
-                timeout=DEFAULT_TIMEOUT,
-                path=self.sandbox_root,
-                env_vars=env_vars,
-            )
-        except Exception as e:
-            raise ClickException(
-                f"Exception while executing python setup script logic: {e}"
-            )
-
-        if result.returncode == 0:
-            sql_file_mappings = json.loads(result.stdout)
-            return sql_file_mappings
-        else:
-            raise ClickException(
-                f"Failed to execute python setup script logic: {result.stderr}"
-            )
-
-    def _generate_setup_sql(self, sql_file_mappings: dict) -> None:
-        if not sql_file_mappings:
-            # Nothing to generate
-            return
-
-        generated_root = self.generated_root
-        generated_root.mkdir(exist_ok=True, parents=True)
-
-        cc.step("Patching setup script")
-        setup_file_path = find_setup_script_file(
-            deploy_root=self._na_project.deploy_root
-        )
-        with self.edit_file(setup_file_path) as f:
-            new_contents = [f.contents]
-
-            if sql_file_mappings["schemas"]:
-                schemas_file = generated_root / sql_file_mappings["schemas"]
-                new_contents.insert(
-                    0,
-                    f"EXECUTE IMMEDIATE FROM '/{to_stage_path(schemas_file.relative_to(self._na_project.deploy_root))}';",
-                )
-
-            if sql_file_mappings["compute_pools"]:
-                compute_pools_file = generated_root / sql_file_mappings["compute_pools"]
-                new_contents.append(
-                    f"EXECUTE IMMEDIATE FROM '/{to_stage_path(compute_pools_file.relative_to(self._na_project.deploy_root))}';"
-                )
-
-            if sql_file_mappings["services"]:
-                services_file = generated_root / sql_file_mappings["services"]
-                new_contents.append(
-                    f"EXECUTE IMMEDIATE FROM '/{to_stage_path(services_file.relative_to(self._na_project.deploy_root))}';"
-                )
-
-            f.edited_contents = "\n".join(new_contents)
-
-    @property
-    def sandbox_root(self):
-        return self._na_project.bundle_root / "setup_py_venv"
-
-    @property
-    def generated_root(self):
-        return self._na_project.generated_root / "setup_py"
-
-    def _create_or_update_sandbox(self):
-        sandbox_root = self.sandbox_root
-        env_builder = SandboxEnvBuilder(sandbox_root, with_pip=True)
-        if sandbox_root.exists():
-            cc.step("Virtual environment found")
-        else:
-            cc.step(
-                f"Creating virtual environment in {sandbox_root.relative_to(self._na_project.project_root)}"
-            )
-        env_builder.ensure_created()
-
-        # Temporarily fetch the library from a location specified via env vars
-        env_builder.pip_install(os.environ["SNOWFLAKE_APP_PYTHON_LOC"])

snowflake/cli/plugins/nativeapp/codegen/setup/setup_driver.py.source

@@ -1,56 +0,0 @@
-# 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.
-
-import contextlib
-import os
-import sys
-from pathlib import Path
-
-import snowflake.app.context as ctx
-from snowflake.app.sql import SQLGenerator
-
-ctx._project_path = os.environ["_SNOWFLAKE_CLI_PROJECT_PATH"]
-ctx._current_app_name = os.environ["_SNOWFLAKE_CLI_APP_NAME"]
-__snowflake_internal_py_files = os.environ["_SNOWFLAKE_CLI_SETUP_FILES"].split(
-    os.pathsep
-)
-__snowflake_internal_sql_dest_dir = os.environ["_SNOWFLAKE_CLI_SQL_DEST_DIR"]
-
-try:
-    import importlib
-
-    with contextlib.redirect_stdout(None):
-        with contextlib.redirect_stderr(None):
-            for __snowflake_internal_py_file in __snowflake_internal_py_files:
-                __snowflake_internal_spec = importlib.util.spec_from_file_location(
-                    "<string>", __snowflake_internal_py_file
-                )
-                __snowflake_internal_module = importlib.util.module_from_spec(
-                    __snowflake_internal_spec
-                )
-                __snowflake_internal_spec.loader.exec_module(
-                    __snowflake_internal_module
-                )
-except Exception as exc:  # Catch any error
-    print("An exception occurred while executing file: ", exc, file=sys.stderr)
-    sys.exit(1)
-
-
-import json
-
-output_dir = Path(__snowflake_internal_sql_dest_dir)
-output_dir.mkdir(exist_ok=True, parents=True)
-path_mappings = SQLGenerator(dest_dir=output_dir).generate()
-
-print(json.dumps(path_mappings, default=str))

snowflake/cli/plugins/nativeapp/codegen/snowpark/callback_source.py.jinja

@@ -1,181 +0,0 @@
-import contextlib
-import functools
-import inspect
-import sys
-from typing import Callable, Tuple
-
-try:
-    import snowflake.snowpark
-except ModuleNotFoundError as exc:
-    print(
-        "An exception occurred while importing snowflake-snowpark-python package: ",
-        exc,
-        file=sys.stderr,
-    )
-    sys.exit(1)
-
-__snowflake_internal_found_correct_version = hasattr(
-    snowflake.snowpark.context, "_is_execution_environment_sandboxed_for_client"
-) and hasattr(snowflake.snowpark.context, "_should_continue_registration")
-
-if not __snowflake_internal_found_correct_version:
-    print(
-        "Did not find the minimum required version for snowflake-snowpark-python package. Please upgrade to v1.15.0 or higher.",
-        file=sys.stderr,
-    )
-    sys.exit(1)
-
-__snowflake_global_collected_extension_fn_json = []
-
-def __snowflake_internal_create_extension_fn_registration_callback():
-    def __snowflake_internal_try_extract_lineno(extension_fn):
-        try:
-            return inspect.getsourcelines(extension_fn)[1]
-        except Exception:
-            return None
-
-    def __snowflake_internal_extract_extension_fn_name(extension_fn):
-        try:
-            import snowflake.snowpark._internal.utils as snowpark_utils
-
-            if hasattr(snowpark_utils, 'TEMP_OBJECT_NAME_PREFIX'):
-                if extension_fn.object_name.startswith(snowpark_utils.TEMP_OBJECT_NAME_PREFIX):
-                    # The object name is a generated one, don't use it
-                    return None
-
-        except Exception:
-            # ignore any exception and fall back to using the object name reported from Snowpark
-            pass
-
-        return extension_fn.object_name
-
-    def __snowflake_internal_create_package_list(extension_fn):
-        if not extension_fn.all_packages.strip():
-            return []
-        return [pkg_spec.strip() for pkg_spec in extension_fn.all_packages.split(",")]
-
-    def __snowflake_internal_make_extension_fn_signature(extension_fn):
-        # Try to fetch the original argument names from the extension function
-        try:
-            args_spec = inspect.getfullargspec(extension_fn.func)
-            original_arg_names = args_spec[0]
-            start_index = len(original_arg_names) - len(extension_fn.input_sql_types)
-            signature = []
-            defaults_start_index = len(original_arg_names) - len(args_spec.defaults or [])
-            for i in range(len(extension_fn.input_sql_types)):
-                arg = {
-                    'name': original_arg_names[start_index + i],
-                    'type': extension_fn.input_sql_types[i]
-                }
-                if i >= defaults_start_index:
-                    arg['default'] = args_spec.defaults[defaults_start_index + i]
-                signature.append(arg)
-
-            return signature
-        except Exception as e:
-            msg = str(e)
-            pass # ignore, we'll use the fallback strategy
-
-        # Failed to extract the original arguments through reflection, fall back to alternative approach
-        return [
-            {"name": input_arg.name, "type": input_type}
-            for (input_arg, input_type) in zip(extension_fn.input_args, extension_fn.input_sql_types)
-        ]
-
-    def __snowflake_internal_to_extension_fn_type(object_type):
-        if object_type.name == "AGGREGATE_FUNCTION":
-            return "aggregate function"
-        if object_type.name == "TABLE_FUNCTION":
-            return "table function"
-        return object_type.name.lower()
-
-    def __snowflake_internal_imports_union_to_str_type(raw_imports):
-        final_imports = []
-        if raw_imports:
-            for raw_import in raw_imports:
-                if isinstance(raw_import, str):
-                    final_imports.append(raw_import)
-                else:
-                    final_imports.append(raw_import[0])
-        return final_imports
-
-
-    def __snowflake_internal_extension_fn_to_json(extension_fn):
-        if not (isinstance(extension_fn.func, Callable) or isinstance(extension_fn.func, Tuple)):
-            return
-
-        if extension_fn.anonymous:
-            # unsupported, native application extension functions need to be explicitly named
-            return
-
-        # Collect basic properties of the extension function
-        extension_fn_json = {
-            "type": __snowflake_internal_to_extension_fn_type(extension_fn.object_type),
-            "lineno": __snowflake_internal_try_extract_lineno(extension_fn.func),
-            "name": __snowflake_internal_extract_extension_fn_name(extension_fn),
-            "handler": extension_fn.func.__name__,
-            "imports": __snowflake_internal_imports_union_to_str_type(extension_fn.raw_imports),
-            "packages": __snowflake_internal_create_package_list(extension_fn),
-            "runtime": extension_fn.runtime_version,
-            "returns": extension_fn.return_sql.upper().replace("RETURNS ", "").strip(),
-            "signature": __snowflake_internal_make_extension_fn_signature(extension_fn),
-            "external_access_integrations": extension_fn.external_access_integrations or [],
-            "secrets": extension_fn.secrets or {},
-        }
-
-        if extension_fn.object_type.name == "PROCEDURE" and extension_fn.execute_as is not None:
-            extension_fn_json['execute_as_caller'] = (extension_fn.execute_as == 'caller')
-
-        if extension_fn.native_app_params is not None:
-            schema = extension_fn.native_app_params.get("schema")
-            if schema is not None:
-                extension_fn_json["schema"] = schema
-            app_roles = extension_fn.native_app_params.get("application_roles")
-            if app_roles is not None:
-                extension_fn_json["application_roles"] = app_roles
-
-        return extension_fn_json
-
-    def __snowflake_internal_collect_extension_fn(
-        collected_extension_fn_json_list, extension_function_properties
-    ):
-        extension_fn_json = __snowflake_internal_extension_fn_to_json(extension_function_properties)
-        if extension_fn_json: # Do not append if extension_fn_json is None
-            collected_extension_fn_json_list.append(extension_fn_json)
-        return False
-
-    return functools.partial(
-        __snowflake_internal_collect_extension_fn,
-        __snowflake_global_collected_extension_fn_json,
-    )
-
-snowflake.snowpark.context._is_execution_environment_sandboxed_for_client = (  # noqa: SLF001
-    True
-)
-snowflake.snowpark.context._should_continue_registration = (  # noqa: SLF001
-    __snowflake_internal_create_extension_fn_registration_callback()
-)
-snowflake.snowpark.session._is_execution_environment_sandboxed_for_client = (  # noqa: SLF001
-    True
-)
-
-for global_key in list(globals().keys()):
-    if global_key.startswith("__snowflake_internal"):
-        del globals()[global_key]
-
-del globals()["global_key"] # make sure to clean up the loop variable as well
-
-try:
-    import importlib
-    with contextlib.redirect_stdout(None):
-        with contextlib.redirect_stderr(None):
-            __snowflake_internal_spec = importlib.util.spec_from_file_location("<string>", r"{{py_file}}")
-            __snowflake_internal_module = importlib.util.module_from_spec(__snowflake_internal_spec)
-            __snowflake_internal_spec.loader.exec_module(__snowflake_internal_module)
-except Exception as exc:  # Catch any error
-    print("An exception occurred while executing file: ", exc, file=sys.stderr)
-    sys.exit(1)
-
-
-import json
-print(json.dumps(__snowflake_global_collected_extension_fn_json))

snowflake/cli/plugins/nativeapp/codegen/snowpark/extension_function_utils.py

@@ -1,217 +0,0 @@
-# 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 ast
-from typing import (
-    List,
-    Optional,
-    Sequence,
-    Union,
-)
-
-from click.exceptions import ClickException
-from snowflake.cli.api.project.schemas.snowpark.argument import Argument
-from snowflake.cli.api.project.util import (
-    is_valid_identifier,
-    is_valid_string_literal,
-    to_identifier,
-    to_string_literal,
-)
-from snowflake.cli.plugins.nativeapp.codegen.snowpark.models import (
-    ExtensionFunctionTypeEnum,
-    NativeAppExtensionFunction,
-)
-
-ASTDefNode = Union[ast.FunctionDef, ast.ClassDef]
-
-
-class MalformedExtensionFunctionError(ClickException):
-    """Required extension function attribute is missing."""
-
-    def __init__(self, message: str):
-        super().__init__(message=message)
-
-
-def get_sql_object_type(extension_fn: NativeAppExtensionFunction) -> Optional[str]:
-    if extension_fn.function_type == ExtensionFunctionTypeEnum.PROCEDURE:
-        return "PROCEDURE"
-    elif extension_fn.function_type in (
-        ExtensionFunctionTypeEnum.FUNCTION,
-        ExtensionFunctionTypeEnum.TABLE_FUNCTION,
-    ):
-        return "FUNCTION"
-    elif extension_fn.function_type == extension_fn.function_type.AGGREGATE_FUNCTION:
-        return "AGGREGATE FUNCTION"
-    else:
-        return None
-
-
-def get_sql_argument_signature(arg: Argument) -> str:
-    formatted = f"{arg.name} {arg.arg_type}"
-    if arg.default is not None:
-        formatted = f"{formatted} DEFAULT {arg.default}"
-    return formatted
-
-
-def get_function_type_signature_for_grant(
-    extension_fn: NativeAppExtensionFunction,
-) -> str:
-    """
-    Returns the type signature for the specified function, e.g. "int, varchar", suitable for inclusion in a GRANT statement.
-    """
-    return ", ".join([arg.arg_type for arg in extension_fn.signature])
-
-
-def get_qualified_object_name(extension_fn: NativeAppExtensionFunction) -> str:
-    qualified_name = to_identifier(extension_fn.name)
-    if extension_fn.schema_name:
-        if is_valid_identifier(extension_fn.schema_name):
-            qualified_name = f"{extension_fn.schema_name}.{qualified_name}"
-        else:
-            full_schema = ".".join(
-                [
-                    to_identifier(schema_part)
-                    for schema_part in extension_fn.schema_name.split(".")
-                ]
-            )
-            qualified_name = f"{full_schema}.{qualified_name}"
-
-    return qualified_name
-
-
-def ensure_string_literal(value: str) -> str:
-    """
-    Returns the string literal representation of the given value, or the value itself if
-    it was already a valid string literal.
-    """
-    if is_valid_string_literal(value):
-        return value
-    return to_string_literal(value)
-
-
-def ensure_all_string_literals(values: Sequence[str]) -> List[str]:
-    """
-    Ensures that all provided values are valid string literals.
-
-    Returns:
-        A list with all values transformed to be valid string literals (as necessary).
-    """
-    return [ensure_string_literal(value) for value in values]
-
-
-class _SnowparkHandlerAccumulator(ast.NodeVisitor):
-    """
-    A NodeVisitor that collects AST nodes corresponding to a provided list of Snowpark external functions.
-    The returned nodes are filtered using the handlers provided for each of the Snowpark functions.
-    Returned definitions can be either function definition or class definition AST nodes.
-    """
-
-    def __init__(self, functions: Sequence[NativeAppExtensionFunction]):
-        self._wanted_handlers_by_name = {
-            fn.handler.split(".")[-1]: fn for fn in functions
-        }
-        self.definitions: List[ASTDefNode] = []
-
-    def visit_FunctionDef(self, node: ast.FunctionDef):  # noqa: N802
-        if self._want(node):
-            self.definitions.append(node)
-        self.generic_visit(node)
-
-    def visit_ClassDef(self, node: ast.ClassDef):  # noqa: N802
-        if self._want(node):
-            self.definitions.append(node)
-        self.generic_visit(node)
-
-    def _want(self, node: ASTDefNode) -> bool:
-        if not node.decorator_list:
-            # No decorators for this definition, ignore it
-            return False
-
-        return node.name in self._wanted_handlers_by_name
-
-
-def _get_decorator_id(node: ast.AST) -> Optional[str]:
-    """
-    Returns the fully qualified identifier for a decorator, e.g. "foo" or "foo.bar".
-    """
-    if isinstance(node, ast.Name):
-        return node.id
-    elif isinstance(node, ast.Attribute):
-        return f"{_get_decorator_id(node.value)}.{node.attr}"
-    elif isinstance(node, ast.Call):
-        return _get_decorator_id(node.func)
-    else:
-        return None
-
-
-def _collect_ast_handler_definitions(
-    tree: ast.AST, extension_functions: Sequence[NativeAppExtensionFunction]
-) -> Sequence[ASTDefNode]:
-    accumulator = _SnowparkHandlerAccumulator(extension_functions)
-    accumulator.visit(tree)
-    return accumulator.definitions
-
-
-def deannotate_module_source(
-    module_source: str,
-    extension_functions: Sequence[NativeAppExtensionFunction],
-    annotations_to_preserve: Sequence[str] = (),
-) -> str:
-    """
-    Removes annotations from a set of specified extension functions.
-
-    Arguments:
-        module_source (str): The source code of the module to deannotate.
-        extension_functions (Sequence[NativeAppExtensionFunction]): The list of extension functions
-         to deannotate. Other functions encountered will be ignored.
-        annotations_to_preserve (Sequence[str], optional): The list of annotations to preserve. The
-         names should appear as they are found in the source code, e.g. "foo" for @foo or
-         "annotations.bar" for @annotations.bar.
-
-    Returns:
-        A de-annotated version of the module source if any match was found. In order to preserve
-        line numbers, annotations are simply commented out instead of completely removed.
-    """
-
-    tree = ast.parse(module_source)
-
-    definitions = _collect_ast_handler_definitions(tree, extension_functions)
-    if not definitions:
-        return module_source
-
-    module_lines = module_source.splitlines()
-    for definition in definitions:
-        # Comment out all decorators. As per the python grammar, decorators must be terminated by a
-        # new line, so the line ranges can't overlap.
-        for decorator in definition.decorator_list:
-            decorator_id = _get_decorator_id(decorator)
-            if decorator_id is None:
-                continue
-            if annotations_to_preserve and decorator_id in annotations_to_preserve:
-                continue
-
-            # AST indices are 1-based
-            start_lineno = decorator.lineno - 1
-            if decorator.end_lineno is not None:
-                end_lineno = decorator.end_lineno - 1
-            else:
-                end_lineno = start_lineno
-
-            for lineno in range(start_lineno, end_lineno + 1):
-                module_lines[lineno] = "#: " + module_lines[lineno]
-
-    # we're writing files in text mode, so we should use '\n' regardless of the platform
-    return "\n".join(module_lines)

snowflake/cli/plugins/nativeapp/codegen/snowpark/models.py

@@ -1,61 +0,0 @@
-# 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 enum import Enum
-from typing import List, Optional
-
-from pydantic import Field
-from snowflake.cli.api.project.schemas.snowpark.callable import _CallableBase
-from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
-
-
-class ExtensionFunctionTypeEnum(str, Enum):
-    PROCEDURE = "procedure"
-    FUNCTION = "function"
-    TABLE_FUNCTION = "table function"
-    AGGREGATE_FUNCTION = "aggregate function"
-
-
-class NativeAppExtensionFunction(_CallableBase):
-    function_type: ExtensionFunctionTypeEnum = Field(
-        title="The type of extension function, one of 'procedure', 'function', 'table function' or 'aggregate function'",
-        alias="type",
-    )
-    lineno: Optional[int] = Field(
-        title="The starting line number of the extension function (1-based)",
-        default=None,
-    )
-    name: Optional[str] = Field(
-        title="The name of the extension function", default=None
-    )
-    packages: Optional[List[str]] = Field(
-        title="List of packages (with optional version constraints) to be loaded for the function",
-        default=[],
-    )
-    schema_name: Optional[str] = IdentifierField(
-        title=f"Name of the schema for the function",
-        default=None,
-        alias="schema",
-    )
-    application_roles: Optional[List[str]] = Field(
-        title="Application roles granted usage to the function",
-        default=[],
-    )
-    execute_as_caller: Optional[bool] = Field(
-        title="Determine whether the procedure is executed with the privileges of "
-        "the owner or with the privileges of the caller",
-        default=False,
-    )