datahub-agent-context 1.3.1.10rc1__py3-none-any.whl → 1.4.0rc2__py3-none-any.whl

datahub_agent_context/snowflake/udfs/add_glossary_terms.py

@@ -0,0 +1,61 @@
+"""ADD_GLOSSARY_TERMS UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_add_glossary_terms_udf() -> str:
+    """Generate ADD_GLOSSARY_TERMS UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.add_glossary_terms() to add
+    glossary terms to multiple DataHub entities or their columns.
+
+    Parameters:
+        term_urns (STRING): JSON array of glossary term URNs
+        entity_urns (STRING): JSON array of entity URNs to annotate
+        column_paths (STRING): Optional JSON array of column names (use NULL for entity-level)
+
+    Returns:
+        VARIANT: Dictionary with success status and message
+
+    Examples:
+        - Add terms: ADD_GLOSSARY_TERMS('["urn:li:glossaryTerm:CustomerData"]', '["urn:li:dataset:(...)"]', NULL)
+        - Add to columns: ADD_GLOSSARY_TERMS('["urn:li:glossaryTerm:Email"]', '["urn:li:dataset:(...)"]', '["email"]')
+    """
+    function_body = """from datahub_agent_context.mcp_tools import add_glossary_terms
+import json
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    term_urn_list = json.loads(term_urns) if isinstance(term_urns, str) else term_urns
+    entity_urn_list = json.loads(entity_urns) if isinstance(entity_urns, str) else entity_urns
+    column_path_list = json.loads(column_paths) if column_paths and isinstance(column_paths, str) else None
+
+    with DataHubContext(graph):
+        return add_glossary_terms(
+            term_urns=term_urn_list,
+            entity_urns=entity_urn_list,
+            column_paths=column_path_list
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e)
+    }"""
+
+    return generate_python_udf_code(
+        function_name="ADD_GLOSSARY_TERMS",
+        parameters=[
+            ("term_urns", "STRING"),
+            ("entity_urns", "STRING"),
+            ("column_paths", "STRING"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/add_owners.py

@@ -0,0 +1,59 @@
+"""ADD_OWNERS UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_add_owners_udf() -> str:
+    """Generate ADD_OWNERS UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.add_owners() to add owners
+    to multiple DataHub entities.
+
+    Parameters:
+        owner_urns (STRING): JSON array of owner URNs (CorpUser or CorpGroup)
+        entity_urns (STRING): JSON array of entity URNs to assign ownership
+        ownership_type_urn (STRING): Optional ownership type URN (use NULL for default)
+
+    Returns:
+        VARIANT: Dictionary with success status and message
+
+    Example:
+        - Add owners: ADD_OWNERS('["urn:li:corpuser:john"]', '["urn:li:dataset:(...)"]', NULL)
+    """
+    function_body = """from datahub_agent_context.mcp_tools import add_owners
+import json
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    owner_urn_list = json.loads(owner_urns) if isinstance(owner_urns, str) else owner_urns
+    entity_urn_list = json.loads(entity_urns) if isinstance(entity_urns, str) else entity_urns
+
+    with DataHubContext(graph):
+        return add_owners(
+            owner_urns=owner_urn_list,
+            entity_urns=entity_urn_list,
+            ownership_type_urn=ownership_type_urn if ownership_type_urn else None
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e)
+    }"""
+
+    return generate_python_udf_code(
+        function_name="ADD_OWNERS",
+        parameters=[
+            ("owner_urns", "STRING"),
+            ("entity_urns", "STRING"),
+            ("ownership_type_urn", "STRING"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/add_structured_properties.py

@@ -0,0 +1,57 @@
+"""ADD_STRUCTURED_PROPERTIES UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_add_structured_properties_udf() -> str:
+    """Generate ADD_STRUCTURED_PROPERTIES UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.add_structured_properties() to
+    add structured properties with values to multiple DataHub entities.
+
+    Parameters:
+        property_values (STRING): JSON object mapping property URNs to value arrays
+                                 (e.g., '{"urn:li:structuredProperty:retentionTime": ["90"]}')
+        entity_urns (STRING): JSON array of entity URNs to assign properties to
+
+    Returns:
+        VARIANT: Dictionary with success status and message
+
+    Example:
+        - Add property: ADD_STRUCTURED_PROPERTIES('{"urn:li:structuredProperty:retentionTime": ["90"]}', '["urn:li:dataset:(...)"]')
+    """
+    function_body = """from datahub_agent_context.mcp_tools import add_structured_properties
+import json
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    property_values_dict = json.loads(property_values) if isinstance(property_values, str) else property_values
+    entity_urn_list = json.loads(entity_urns) if isinstance(entity_urns, str) else entity_urns
+
+    with DataHubContext(graph):
+        return add_structured_properties(
+            property_values=property_values_dict,
+            entity_urns=entity_urn_list
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e)
+    }"""
+
+    return generate_python_udf_code(
+        function_name="ADD_STRUCTURED_PROPERTIES",
+        parameters=[
+            ("property_values", "STRING"),
+            ("entity_urns", "STRING"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/add_tags.py

@@ -0,0 +1,61 @@
+"""ADD_TAGS UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_add_tags_udf() -> str:
+    """Generate ADD_TAGS UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.add_tags() to add tags to
+    multiple DataHub entities or their columns in a single operation.
+
+    Parameters:
+        tag_urns (STRING): JSON array of tag URNs (e.g., '["urn:li:tag:PII", "urn:li:tag:Sensitive"]')
+        entity_urns (STRING): JSON array of entity URNs to tag
+        column_paths (STRING): Optional JSON array of column names (use NULL for entity-level tags)
+
+    Returns:
+        VARIANT: Dictionary with success status and message
+
+    Examples:
+        - Tag datasets: ADD_TAGS('["urn:li:tag:PII"]', '["urn:li:dataset:(...)"]', NULL)
+        - Tag columns: ADD_TAGS('["urn:li:tag:PII"]', '["urn:li:dataset:(...)"]', '["email"]')
+    """
+    function_body = """from datahub_agent_context.mcp_tools import add_tags
+import json
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    tag_urn_list = json.loads(tag_urns) if isinstance(tag_urns, str) else tag_urns
+    entity_urn_list = json.loads(entity_urns) if isinstance(entity_urns, str) else entity_urns
+    column_path_list = json.loads(column_paths) if column_paths and isinstance(column_paths, str) else None
+
+    with DataHubContext(graph):
+        return add_tags(
+            tag_urns=tag_urn_list,
+            entity_urns=entity_urn_list,
+            column_paths=column_path_list
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e)
+    }"""
+
+    return generate_python_udf_code(
+        function_name="ADD_TAGS",
+        parameters=[
+            ("tag_urns", "STRING"),
+            ("entity_urns", "STRING"),
+            ("column_paths", "STRING"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/base.py

@@ -0,0 +1,45 @@
+"""Base utilities for generating Snowflake UDFs."""
+
+import textwrap
+
+
+def generate_python_udf_code(
+    function_name: str,
+    parameters: list[tuple[str, str]],
+    return_type: str,
+    function_body: str,
+) -> str:
+    """
+    Generate the SQL CREATE FUNCTION statement for a Python UDF.
+
+    Args:
+        function_name: Name of the UDF to create
+        parameters: List of (param_name, param_type) tuples
+        return_type: Return type of the function (e.g., 'VARIANT', 'STRING')
+        function_body: Python code for the function body (without def statement)
+
+    Returns:
+        Complete SQL CREATE FUNCTION statement
+    """
+    param_signature = ", ".join(f"{name} {type_}" for name, type_ in parameters)
+    py_param_names = ", ".join(name for name, _ in parameters)
+
+    udf_template = f"""CREATE OR REPLACE FUNCTION {function_name}({param_signature})
+RETURNS {return_type}
+LANGUAGE PYTHON
+RUNTIME_VERSION = '3.10'
+ARTIFACT_REPOSITORY = snowflake.snowpark.pypi_shared_repository
+PACKAGES = ('datahub-agent-context>=1.3.1.8')
+SECRETS = ('datahub_url_secret' = datahub_url, 'datahub_token_secret' = datahub_token)
+EXTERNAL_ACCESS_INTEGRATIONS = (datahub_access)
+HANDLER = '{function_name.lower()}'
+AS $$
+import _snowflake
+from datahub.ingestion.graph.client import DataHubGraph, DatahubClientConfig
+from datahub_agent_context.context import DataHubContext
+
+def {function_name.lower()}({py_param_names}):
+{textwrap.indent(function_body, "    ")}
+$$;"""
+
+    return udf_template

datahub_agent_context/snowflake/udfs/get_dataset_queries.py

@@ -0,0 +1,68 @@
+"""GET_DATASET_QUERIES UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_get_dataset_queries_udf() -> str:
+    """Generate GET_DATASET_QUERIES UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.get_dataset_queries() to retrieve
+    SQL queries associated with a dataset or column to understand usage patterns.
+
+    Useful for understanding how data is used, common JOIN patterns, typical filters,
+    and aggregation logic. Can filter by query source (MANUAL vs SYSTEM).
+
+    Parameters:
+        urn (STRING): Dataset URN
+        column_name (STRING): Optional column name to filter queries (use NULL for all dataset queries)
+        source (STRING): Filter by query origin - 'MANUAL', 'SYSTEM', or NULL for both
+        count (NUMBER): Number of queries to return (default: 10)
+
+    Returns:
+        VARIANT: Dictionary with:
+                - total: Total number of queries matching criteria
+                - queries: Array of query objects with SQL statements and metadata
+                - start: Starting offset
+                - count: Number of results returned
+
+    Examples:
+        - Manual queries: GET_DATASET_QUERIES(urn, NULL, 'MANUAL', 10)
+        - System queries: GET_DATASET_QUERIES(urn, NULL, 'SYSTEM', 20)
+        - Column queries: GET_DATASET_QUERIES(urn, 'customer_id', 'MANUAL', 5)
+    """
+    function_body = """from datahub_agent_context.mcp_tools import get_dataset_queries
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    with DataHubContext(graph):
+        return get_dataset_queries(
+            urn=urn,
+            column=column_name if column_name else None,
+            source=source if source else None,
+            count=int(count) if count else 10
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e),
+        'urn': urn
+    }"""
+
+    return generate_python_udf_code(
+        function_name="GET_DATASET_QUERIES",
+        parameters=[
+            ("urn", "STRING"),
+            ("column_name", "STRING"),
+            ("source", "STRING"),
+            ("count", "NUMBER"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/get_entities.py

@@ -0,0 +1,47 @@
+"""GET_ENTITIES UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_get_entities_udf() -> str:
+    """Generate GET_ENTITIES UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.get_entities() to retrieve
+    detailed information about entities by their DataHub URNs from Snowflake.
+
+    The underlying function accepts arrays of URNs for efficient batch retrieval,
+    but this UDF is simplified to accept a single URN string.
+
+    Parameters:
+        entity_urn (STRING): Entity URN (e.g., "urn:li:dataset:(...)")
+
+    Returns:
+        VARIANT: Dictionary with entity details including schema metadata, ownership,
+                tags, glossary terms, and other metadata aspects
+    """
+    function_body = """from datahub_agent_context.mcp_tools import get_entities
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    with DataHubContext(graph):
+        return get_entities([entity_urn])
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e),
+        'urn': entity_urn
+    }"""
+
+    return generate_python_udf_code(
+        function_name="GET_ENTITIES",
+        parameters=[("entity_urn", "STRING")],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/get_lineage.py

@@ -0,0 +1,61 @@
+"""GET_LINEAGE UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_get_lineage_udf() -> str:
+    """Generate GET_LINEAGE UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.get_lineage() to get upstream
+    or downstream lineage for any entity from Snowflake.
+
+    Parameters:
+        urn (STRING): Entity URN
+        column_name (STRING): Optional column name for column-level lineage (use NULL for entity-level)
+        upstream (NUMBER): 1 for upstream lineage, 0 for downstream lineage
+        max_hops (NUMBER): Maximum number of hops (1-3+, default: 1)
+        max_results (NUMBER): Maximum number of results to return (default: 30)
+
+    Returns:
+        VARIANT: Dictionary with upstreams or downstreams field containing lineage entities,
+                facets, and metadata. For column-level lineage, includes lineageColumns showing
+                which columns have relationships.
+    """
+    function_body = """from datahub_agent_context.mcp_tools import get_lineage
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    with DataHubContext(graph):
+        return get_lineage(
+            urn=urn,
+            column=column_name if column_name else None,
+            upstream=bool(upstream),
+            max_hops=int(max_hops) if max_hops else 1,
+            max_results=int(max_results) if max_results else 30
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e),
+        'urn': urn
+    }"""
+
+    return generate_python_udf_code(
+        function_name="GET_LINEAGE",
+        parameters=[
+            ("urn", "STRING"),
+            ("column_name", "STRING"),
+            ("upstream", "NUMBER"),
+            ("max_hops", "NUMBER"),
+            ("max_results", "NUMBER"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/get_lineage_paths_between.py

@@ -0,0 +1,69 @@
+"""GET_LINEAGE_PATHS_BETWEEN UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_get_lineage_paths_between_udf() -> str:
+    """Generate GET_LINEAGE_PATHS_BETWEEN UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.get_lineage_paths_between() to get
+    detailed lineage paths between two specific entities or columns.
+
+    Returns the paths array showing the exact transformation chain(s) including
+    intermediate entities and transformation query URNs.
+
+    Parameters:
+        source_urn (STRING): URN of the source dataset
+        target_urn (STRING): URN of the target dataset
+        source_column (STRING): Optional column name in source dataset (use NULL for dataset-level)
+        target_column (STRING): Optional column name in target dataset (use NULL for dataset-level)
+
+    Returns:
+        VARIANT: Dictionary with:
+                - source: Source entity/column info
+                - target: Target entity/column info
+                - paths: Array of path objects showing transformation chains
+                - pathCount: Number of paths found
+                - metadata: Query metadata including direction and path type
+
+    Examples:
+        - Dataset-level: GET_LINEAGE_PATHS_BETWEEN(source_urn, target_urn, NULL, NULL)
+        - Column-level: GET_LINEAGE_PATHS_BETWEEN(source_urn, target_urn, 'user_id', 'customer_id')
+    """
+    function_body = """from datahub_agent_context.mcp_tools import get_lineage_paths_between
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    with DataHubContext(graph):
+        return get_lineage_paths_between(
+            source_urn=source_urn,
+            target_urn=target_urn,
+            source_column=source_column if source_column else None,
+            target_column=target_column if target_column else None
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e),
+        'source_urn': source_urn,
+        'target_urn': target_urn
+    }"""
+
+    return generate_python_udf_code(
+        function_name="GET_LINEAGE_PATHS_BETWEEN",
+        parameters=[
+            ("source_urn", "STRING"),
+            ("target_urn", "STRING"),
+            ("source_column", "STRING"),
+            ("target_column", "STRING"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/get_me.py

@@ -0,0 +1,51 @@
+"""GET_ME UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_get_me_udf() -> str:
+    """Generate GET_ME UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.get_me() to get information
+    about the currently authenticated user.
+
+    Returns user profile information, platform privileges, group memberships,
+    and user settings.
+
+    Parameters:
+        None
+
+    Returns:
+        VARIANT: Dictionary with:
+                - success: Boolean indicating if operation succeeded
+                - data: User information including corpUser details
+                - message: Success or error message
+
+    Example:
+        - Get current user: SELECT GET_ME()
+    """
+    function_body = """from datahub_agent_context.mcp_tools import get_me
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    with DataHubContext(graph):
+        return get_me()
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e)
+    }"""
+
+    return generate_python_udf_code(
+        function_name="GET_ME",
+        parameters=[],
+        return_type="VARIANT",
+        function_body=function_body,
+    )

datahub_agent_context/snowflake/udfs/grep_documents.py

@@ -0,0 +1,70 @@
+"""GREP_DOCUMENTS UDF generator."""
+
+from datahub_agent_context.snowflake.udfs.base import generate_python_udf_code
+
+
+def generate_grep_documents_udf() -> str:
+    """Generate GREP_DOCUMENTS UDF using datahub-agent-context.
+
+    This UDF wraps datahub_agent_context.mcp_tools.grep_documents() to search within
+    document content using regex patterns (similar to ripgrep/grep).
+
+    Use SEARCH_DOCUMENTS first to find relevant document URNs, then use this tool
+    to search within their content.
+
+    Parameters:
+        urns (STRING): JSON array of document URNs to search within (e.g., '["urn:li:document:doc1"]')
+        pattern (STRING): Regex pattern to search for (e.g., 'kubernetes', '(?i)deploy.*production')
+        context_chars (NUMBER): Characters to show before/after matches (default: 200)
+        max_matches_per_doc (NUMBER): Maximum matches per document (default: 5)
+
+    Returns:
+        VARIANT: Dictionary with:
+                - results: List of documents with matching excerpts
+                - total_matches: Total matches across all documents
+                - documents_with_matches: Number of documents containing matches
+
+    Examples:
+        - Find kubectl commands: GREP_DOCUMENTS('["urn:li:document:runbook1"]', 'kubectl apply', 300, 5)
+        - Case insensitive: GREP_DOCUMENTS('["urn:li:document:doc1"]', '(?i)error|exception', 200, 10)
+    """
+    function_body = """from datahub_agent_context.mcp_tools import grep_documents
+import json
+try:
+    datahub_url = _snowflake.get_generic_secret_string('datahub_url_secret')
+    datahub_token = _snowflake.get_generic_secret_string('datahub_token_secret')
+    datahub_url = datahub_url.rstrip('/')
+
+    graph = DataHubGraph(
+        config=DatahubClientConfig(server=datahub_url, token=datahub_token)
+    )
+
+    urn_list = json.loads(urns) if isinstance(urns, str) else urns
+
+    with DataHubContext(graph):
+        return grep_documents(
+            urns=urn_list,
+            pattern=pattern,
+            context_chars=int(context_chars) if context_chars else 200,
+            max_matches_per_doc=int(max_matches_per_doc) if max_matches_per_doc else 5
+        )
+
+except Exception as e:
+    return {
+        'success': False,
+        'error': str(e),
+        'urns': urns,
+        'pattern': pattern
+    }"""
+
+    return generate_python_udf_code(
+        function_name="GREP_DOCUMENTS",
+        parameters=[
+            ("urns", "STRING"),
+            ("pattern", "STRING"),
+            ("context_chars", "NUMBER"),
+            ("max_matches_per_doc", "NUMBER"),
+        ],
+        return_type="VARIANT",
+        function_body=function_body,
+    )