From 27bdce262e82d43ee0567e2cc33cea67eac6361b Mon Sep 17 00:00:00 2001 From: Cristian Jensen Date: Tue, 10 Nov 2026 15:04:17 +0000 Subject: [PATCH 1/4] Replace lakeflow-integrations template examples with integration catalog Replaces the template's examples with five ready-to-use integrations from the Lakeflow integration catalog, so generated projects (and assistants working in them) follow current best practices: send_slack_message, wait_for_slack_reaction, create_jira_issue, call_rest_api, and wait_for_rest_api. The old slack.py and wait_for_run_sensor.py examples and the jobs that ran them are removed. The new examples use HttpUcConnectionParameter, ParameterMetadata, and PollResult, which need databricks-lakeflow-integrations 0.0.6, so the template's pin moves to >=0.0.6,<0.1 and the vendored wheel is bumped to 0.0.6. Co-authored-by: Isaac --- .../lakeflow-integrations/output.txt | 13 +- .../output/my_lakeflow_integrations/README.md | 15 +- .../my_lakeflow_integrations/pyproject.toml | 2 +- .../resources/send_slack_message.job.yml | 24 -- .../resources/wait_for_run_sensor.job.yml | 20 -- .../examples/call_rest_api.py | 111 ++++++++ .../examples/create_jira_issue.py | 117 +++++++++ .../examples/send_slack_message.py | 91 +++++++ .../examples/slack.py | 27 -- .../examples/wait_for_rest_api.py | 244 ++++++++++++++++++ .../examples/wait_for_run_sensor.py | 28 -- .../examples/wait_for_slack_reaction.py | 127 +++++++++ .../templates/lakeflow-integrations/script | 11 +- .../src/databricks/sdk/runtime/__init__.py | 1 - .../src/databricks/sdk/service}/__init__.py | 0 .../src/databricks/sdk/service/serving.py | 9 + .../stub-wheels/requests/pyproject.toml | 11 - .../template/{{.project_name}}/README.md.tmpl | 15 +- .../{{.project_name}}/pyproject.toml.tmpl | 2 +- .../resources/send_slack_message.job.yml.tmpl | 24 -- .../wait_for_run_sensor.job.yml.tmpl | 20 -- .../examples/call_rest_api.py | 111 ++++++++ .../examples/create_jira_issue.py | 117 +++++++++ .../examples/send_slack_message.py | 91 +++++++ .../src/{{.project_name}}/examples/slack.py | 27 -- .../examples/wait_for_rest_api.py | 244 ++++++++++++++++++ .../examples/wait_for_run_sensor.py | 28 -- .../examples/wait_for_slack_reaction.py | 127 +++++++++ ...keflow_integrations-0.0.3-py3-none-any.whl | Bin 20117 -> 0 bytes ...keflow_integrations-0.0.6-py3-none-any.whl | Bin 0 -> 28737 bytes 30 files changed, 1423 insertions(+), 234 deletions(-) delete mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/send_slack_message.job.yml delete mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/wait_for_run_sensor.job.yml create mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/call_rest_api.py create mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/create_jira_issue.py create mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/send_slack_message.py delete mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/slack.py create mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_rest_api.py delete mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_run_sensor.py create mode 100644 acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_slack_reaction.py delete mode 100644 acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/runtime/__init__.py rename acceptance/bundle/templates/lakeflow-integrations/stub-wheels/{requests/src/requests => databricks-sdk/src/databricks/sdk/service}/__init__.py (100%) create mode 100644 acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/service/serving.py delete mode 100644 acceptance/bundle/templates/lakeflow-integrations/stub-wheels/requests/pyproject.toml delete mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/send_slack_message.job.yml.tmpl delete mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/wait_for_run_sensor.job.yml.tmpl create mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/call_rest_api.py create mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/create_jira_issue.py create mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/send_slack_message.py delete mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/slack.py create mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_rest_api.py delete mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_run_sensor.py create mode 100644 libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_slack_reaction.py delete mode 100644 libs/vendored_py_packages/databricks_lakeflow_integrations-0.0.3-py3-none-any.whl create mode 100644 libs/vendored_py_packages/databricks_lakeflow_integrations-0.0.6-py3-none-any.whl diff --git a/acceptance/bundle/templates/lakeflow-integrations/output.txt b/acceptance/bundle/templates/lakeflow-integrations/output.txt index 2a4e773c907..91176baa582 100644 --- a/acceptance/bundle/templates/lakeflow-integrations/output.txt +++ b/acceptance/bundle/templates/lakeflow-integrations/output.txt @@ -30,11 +30,12 @@ Validation OK! >>> [CLI] bundle deploy -t dev Building lakeflow_integrations_yaml... Building python_artifact... -Uploading __generated__/my_lakeflow_integrations.examples.slack.send_slack_message.yml... -Uploading __generated__/my_lakeflow_integrations.examples.wait_for_run_sensor.WaitForRunSensor.yml... +Uploading __generated__/my_lakeflow_integrations.examples.call_rest_api.call_rest_api.yml... +Uploading __generated__/my_lakeflow_integrations.examples.create_jira_issue.create_jira_issue.yml... +Uploading __generated__/my_lakeflow_integrations.examples.send_slack_message.send_slack_message.yml... +Uploading __generated__/my_lakeflow_integrations.examples.wait_for_rest_api.WaitForRestApi.yml... +Uploading __generated__/my_lakeflow_integrations.examples.wait_for_slack_reaction.WaitForSlackReaction.yml... Uploading dist/my_lakeflow_integrations-0.0.1-py3-none-any.whl... Uploading bundle files to /Workspace/Users/[USERNAME]/.bundle/my_lakeflow_integrations/dev/files... -Created jobs.send_slack_message -Created jobs.wait_for_run_sensor -Files: 11 uploaded, 0 deleted -Resources: 2 created, 0 changed, 0 deleted, 0 unchanged +Files: 12 uploaded, 0 deleted +Resources: 0 created, 0 changed, 0 deleted, 0 unchanged diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md index 671ad41f535..7b5ecc1b269 100644 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md @@ -2,20 +2,25 @@ A Declarative Automation Bundles project that extends Lakeflow Jobs with custom integrations. -This bundle ships with runnable examples under `src/my_lakeflow_integrations/examples/` and -corresponding job definitions under `resources/`: +This bundle ships with examples under `src/my_lakeflow_integrations/examples/` that call external +services through Unity Catalog connections: | Example | Type | What it does | | --- | --- | --- | -| `slack.send_slack_message` | Function | Posts a message to Slack through a Unity Catalog connection. | -| `wait_for_run_sensor.WaitForRunSensor` | Sensor | Polls a job run until it reaches a terminal state. | +| `send_slack_message.send_slack_message` | Function | Posts a message to a Slack channel or direct message, with optional rich formatting. | +| `wait_for_slack_reaction.WaitForSlackReaction` | Sensor | Waits until someone reacts to a Slack message. | +| `create_jira_issue.create_jira_issue` | Function | Creates a Jira issue. | +| `call_rest_api.call_rest_api` | Function | Sends a request to a REST API and saves the response as task values. | +| `wait_for_rest_api.WaitForRestApi` | Sensor | Polls a REST API until its response meets a condition. | + +Define jobs that run them under `resources/`. ## Getting started 1. Open this bundle in a Databricks workspace. 2. Click the **deployments rocket** 🚀 in the left sidebar to open the **Deployments** panel, then click **Deploy**. -3. To run a deployed job, hover over the resource in the **Deployments** panel +3. After you add a job under `resources/` and deploy it, run it: hover over the resource in the **Deployments** panel and click **Run**. ## Documentation diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml index ad46ab6ebd4..8fc0b94eea5 100644 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml @@ -6,7 +6,7 @@ requires-python = ">=3.12,<3.13" dependencies = [ # Any dependencies for jobs and pipelines in this project can be added here # See also https://docs.databricks.com/dev-tools/bundles/library-dependencies - "databricks-lakeflow-integrations>=0.0.3,<0.1", + "databricks-lakeflow-integrations>=0.0.6,<0.1", ] [tool.hatch.build.targets.wheel] diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/send_slack_message.job.yml b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/send_slack_message.job.yml deleted file mode 100644 index bb64af9d278..00000000000 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/send_slack_message.job.yml +++ /dev/null @@ -1,24 +0,0 @@ -resources: - jobs: - send_slack_message: - name: "[example] send_slack_message" - - tasks: - - task_key: slack - environment_key: my_lakeflow_integrations_environment - python_operator_task: - main: my_lakeflow_integrations.examples.slack.send_slack_message - parameters: - - name: "conn_id" - value: "CHANGEME" - - name: "text" - value: "Hello, World" - - name: "channel" - value: "CHANGEME" - - environments: - - environment_key: my_lakeflow_integrations_environment - spec: - environment_version: "5" - dependencies: - - ../dist/*.whl diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/wait_for_run_sensor.job.yml b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/wait_for_run_sensor.job.yml deleted file mode 100644 index ed340fb7e92..00000000000 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/resources/wait_for_run_sensor.job.yml +++ /dev/null @@ -1,20 +0,0 @@ -resources: - jobs: - wait_for_run_sensor: - name: "[example] wait_for_run_sensor" - - tasks: - - task_key: wait_for_run_sensor - environment_key: my_lakeflow_integrations_environment - python_operator_task: - main: my_lakeflow_integrations.examples.wait_for_run_sensor.WaitForRunSensor - parameters: - - name: "run_id" - value: "CHANGEME" - - environments: - - environment_key: my_lakeflow_integrations_environment - spec: - environment_version: "5" - dependencies: - - ../dist/*.whl diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/call_rest_api.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/call_rest_api.py new file mode 100644 index 00000000000..3f678a8662c --- /dev/null +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/call_rest_api.py @@ -0,0 +1,111 @@ +import json +from typing import Any, Optional +from urllib.parse import unquote, urlsplit + +from databricks.lakeflow.integrations import ( + HttpUcConnectionParameter, + integration, + ParameterMetadata, + TextAreaParameter, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod as Method + +PREVIEW_LENGTH = 2000 + + +@integration( + display_name="Call REST API", + description="Sends a request through a UC connection, saving the response as task values", + icon="globe", + promoted_parameter="path", + parameters=dict( + connection=ParameterMetadata(display_name="Connection", description="Unity Catalog connection to the API."), + path=ParameterMetadata( + display_name="Path", description="Path after the connection's base path. For example, jobs/42/refresh." + ), + method=ParameterMetadata(display_name="Method", description="HTTP method of the request."), + query_params=ParameterMetadata( + display_name="Query parameters", + description="Added to the request URL. For example, limit with 10 adds ?limit=10.", + ), + headers=ParameterMetadata(display_name="Headers", description="Extra headers to send with the request."), + body=ParameterMetadata(display_name="Body", description="Request body, in JSON."), + output_mappings=ParameterMetadata( + display_name="Output mappings", + description="Each key is a task value name and each value is its path in the response. For example, " + "job_id with id, or first_id with items[0].id.", + ), + ), +) +def call_rest_api( + connection: HttpUcConnectionParameter, + path: str, + method: Method = Method.GET, + query_params: Optional[dict[str, str]] = None, + headers: Optional[dict[str, str]] = None, + body: Optional[TextAreaParameter] = None, + output_mappings: Optional[dict[str, str]] = None, +) -> None: + if ".." in unquote(urlsplit(path).path).split("/"): + raise ValueError(f"path can't contain '..' segments, got: {path}") + json_body = parse_json_body(body) + + workspace = WorkspaceClient() + print(f"Sending {method.value} {path}") + response = workspace.serving_endpoints.http_request( + conn=connection, method=method, path=path, params=query_params, headers=headers, json=json_body + ) + print(f"Response: {preview(response.text)}") + + outputs = extract_outputs(parse_response(response), output_mappings or {}) + for name, value in outputs.items(): + workspace.dbutils.jobs.taskValues.set(key=name, value=value) + print(f"Saved task value {name}: {preview(json.dumps(value))}") + + +def parse_json_body(body: Optional[str]) -> Any: + try: + return json.loads(body) if body else None + except json.JSONDecodeError as error: + raise ValueError(f"body must be valid JSON: {error}") from None + + +def parse_response(response: Any) -> Any: + try: + return response.json() + except ValueError: + return response.text + + +def preview(text: str) -> str: + if not text: + return "(empty)" + if len(text) > PREVIEW_LENGTH: + return f"{text[:PREVIEW_LENGTH]}... (truncated)" + return text + + +def extract_outputs(response: Any, mappings: dict[str, str]) -> dict[str, Any]: + outputs = {} + for name, response_path in mappings.items(): + value = extract_nested_value(response, response_path) + if value is None: + raise RuntimeError(f"The response has no value at {response_path}") + + outputs[name] = value + return outputs + + +def extract_nested_value(response: Any, response_path: str) -> Any: + # result.items[0].id becomes the keys result, items, 0, and id. A leading [0] indexes a list response. + normalized_path = response_path.replace("[", ".").replace("]", "").lstrip(".") + value = response + for key in normalized_path.split("."): + if isinstance(value, dict): + value = value.get(key) + elif isinstance(value, list) and key.isdigit() and int(key) < len(value): + value = value[int(key)] + else: + return None + return value diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/create_jira_issue.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/create_jira_issue.py new file mode 100644 index 00000000000..91db7bf7fd0 --- /dev/null +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/create_jira_issue.py @@ -0,0 +1,117 @@ +import json +from typing import Annotated, Any, Optional + +from databricks.lakeflow.integrations import ( + HttpConnectionFilter, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + TextAreaParameter, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod + +JiraConnection = Annotated[HttpUcConnectionParameter, HttpConnectionFilter(host="https://api.atlassian.com")] + + +@integration( + display_name="Create Jira issue", + description="Creates a Jira issue", + icon="plus-circle", + promoted_parameter="project_key", + parameters=dict( + connection=ParameterMetadata( + display_name="Connection", description="Unity Catalog connection to the Jira Cloud REST API." + ), + project_key=ParameterMetadata(display_name="Project key", description="For example, DATA."), + summary=ParameterMetadata(display_name="Summary", description="Title of the issue."), + issue_type=ParameterMetadata(display_name="Issue type", description="For example, Bug."), + description=ParameterMetadata(display_name="Description", description="Body of the issue, in plain text."), + assignee_email=ParameterMetadata(display_name="Assignee email", description="For example, ana@example.com."), + labels=ParameterMetadata(display_name="Labels", description="For example, pipeline."), + priority=ParameterMetadata(display_name="Priority", description="For example, High."), + fields=ParameterMetadata( + display_name="Other fields", + description="More Jira fields to set, as a JSON object of field IDs and values. " + 'For example, {"customfield_10000": "data-eng"}. The fields above take precedence.', + ), + ), +) +def create_jira_issue( + connection: JiraConnection, + project_key: str, + summary: str, + issue_type: str = "Task", + description: Optional[TextAreaParameter] = None, + assignee_email: Optional[str] = None, + labels: Optional[list[str]] = None, + priority: Optional[str] = None, + fields: Optional[TextAreaParameter] = None, +) -> None: + workspace = WorkspaceClient() + assignee_id = find_account_id_by_email(workspace, connection, assignee_email) if assignee_email else None + optional_fields = { + "description": plain_text_to_jira_document(description) if description else None, + "assignee": {"accountId": assignee_id} if assignee_id else None, + "labels": labels, + "priority": {"name": priority} if priority else None, + } + issue_fields: dict[str, Any] = { + **parse_other_fields(fields), + "project": {"key": project_key}, + "summary": summary, + "issuetype": {"name": issue_type}, + **{key: value for key, value in optional_fields.items() if value}, + } + + result = send_jira_request( + workspace, connection, ExternalFunctionRequestHttpMethod.POST, "issue", {"fields": issue_fields} + ) + print(f"Created issue {result['key']}") + workspace.dbutils.jobs.taskValues.set(key="issue_key", value=result["key"]) + + +def find_account_id_by_email(workspace: WorkspaceClient, connection: str, email: str) -> str: + users = send_jira_request( + workspace, connection, ExternalFunctionRequestHttpMethod.GET, "user/search", None, params={"query": email} + ) + # Jira searches by prefix and returns a null email for users with a private profile. + matches = [user for user in users if (user.get("emailAddress") or "").lower() == email.lower()] + if len(matches) != 1: + raise ValueError(f"Found {len(matches)} Jira users with email {email}. Enter the email of exactly one user.") + return matches[0]["accountId"] + + +def parse_other_fields(fields: Optional[str]) -> dict[str, Any]: + try: + parsed = json.loads(fields) if fields else {} + except json.JSONDecodeError as error: + raise ValueError(f"Other fields must be a JSON object: {error}") from None + if not isinstance(parsed, dict): + raise ValueError("Other fields must be a JSON object, not a list or a single value") + return parsed + + +def send_jira_request( + workspace: WorkspaceClient, + connection: str, + method: ExternalFunctionRequestHttpMethod, + path: str, + body: Optional[dict[str, Any]], + params: Optional[dict[str, str]] = None, +) -> Any: + response = workspace.serving_endpoints.http_request( + conn=connection, method=method, path=path, json=body, params=params + ) + try: + return response.json() + except ValueError: + raise RuntimeError(f"Jira returned a non-JSON response: {response.text}") from None + + +def plain_text_to_jira_document(text: str) -> dict[str, Any]: + # Jira's v3 API only takes rich text as an Atlassian Document Format document. + paragraphs = [ + {"type": "paragraph", "content": [{"type": "text", "text": line}]} for line in text.splitlines() if line.strip() + ] + return {"type": "doc", "version": 1, "content": paragraphs} diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/send_slack_message.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/send_slack_message.py new file mode 100644 index 00000000000..734f277ace5 --- /dev/null +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/send_slack_message.py @@ -0,0 +1,91 @@ +import json +from typing import Annotated, Any, Optional + +from databricks.lakeflow.integrations import ( + HttpConnectionFilter, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + TextAreaParameter, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod + +SlackConnection = Annotated[HttpUcConnectionParameter, HttpConnectionFilter(host="https://slack.com", base_path="/api")] + + +@integration( + display_name="Send Slack message", + description="Posts a message to a Slack channel or direct message with optional rich formatting", + icon="send", + promoted_parameter="channel", + parameters=dict( + connection=ParameterMetadata( + display_name="Connection", + description="Unity Catalog connection to the Slack API. Its bot token needs the chat:write scope.", + ), + channel=ParameterMetadata(display_name="Channel", description="Channel name or ID. For example, #alerts."), + message=ParameterMetadata( + display_name="Message", + description="Text to post, in plain text or Slack markdown. Notifications show it when you also set blocks.", + ), + blocks=ParameterMetadata( + display_name="Blocks", description="Slack Block Kit layout, in JSON, for richer formatting." + ), + thread_ts=ParameterMetadata( + display_name="Thread timestamp", description="Timestamp of the message to reply to in its thread." + ), + username=ParameterMetadata( + display_name="Username", + description="Bot name shown on the message. Needs the chat:write.customize scope.", + ), + icon_url=ParameterMetadata( + display_name="Icon URL", + description="Image shown as the bot's avatar. Needs the chat:write.customize scope.", + ), + icon_emoji=ParameterMetadata( + display_name="Icon emoji", + description="Emoji shown as the bot's avatar. For example, :robot_face:. Needs the chat:write.customize scope.", + ), + ), +) +def send_slack_message( + connection: SlackConnection, + channel: str, + message: TextAreaParameter, + blocks: Optional[TextAreaParameter] = None, + thread_ts: Optional[str] = None, + username: Optional[str] = None, + icon_url: Optional[str] = None, + icon_emoji: Optional[str] = None, +) -> None: + optional_fields = { + "blocks": json.loads(blocks) if blocks else None, + "thread_ts": thread_ts, + "username": username, + "icon_emoji": icon_emoji, + "icon_url": None if icon_emoji else icon_url, + } + payload: dict[str, Any] = {"channel": channel, "text": message} + payload |= {key: value for key, value in optional_fields.items() if value} + + workspace = WorkspaceClient() + response = workspace.serving_endpoints.http_request( + conn=connection, + method=ExternalFunctionRequestHttpMethod.POST, + path="chat.postMessage", + json=payload, + ) + + try: + result = response.json() + except ValueError: + raise RuntimeError(f"Slack returned a non-JSON response: {response.text}") from None + + # Slack reports API errors with HTTP 200 and ok=false. + if not result.get("ok"): + raise RuntimeError(f"Slack API error: {result.get('error')}") + + print(f"Posted message {result['ts']} to channel {result['channel']}") + workspace.dbutils.jobs.taskValues.set(key="ts", value=result["ts"]) + workspace.dbutils.jobs.taskValues.set(key="channel_id", value=result["channel"]) diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/slack.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/slack.py deleted file mode 100644 index 8834a752e4f..00000000000 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/slack.py +++ /dev/null @@ -1,27 +0,0 @@ -import requests -from databricks.sdk import WorkspaceClient -from databricks.lakeflow.integrations import integration - - -@integration(display_name="Send Slack message") -def send_slack_message( - text: str, - conn_id: str, - channel: str, # Example: "C0A874NCL8N" -): - w = WorkspaceClient() - - response = requests.post( - f"{w.config.host}/api/2.0/unity-catalog/connections/{conn_id}/proxy/chat.postMessage", - headers={ - **w.config.authenticate(), - "Accept": "application/json", - "Content-Type": "application/json", - "Accept-Encoding": "identity", # ask for no compression - }, - json={ - "channel": channel, - "text": text, - }, - ) - print(response.json()) diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_rest_api.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_rest_api.py new file mode 100644 index 00000000000..608d415b3fc --- /dev/null +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_rest_api.py @@ -0,0 +1,244 @@ +import json +import re +import time +from dataclasses import dataclass +from datetime import timedelta +from typing import Any, Optional +from urllib.parse import unquote, urlsplit + +from databricks.lakeflow.integrations import ( + Context, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + PollResult, + Sensor, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod as Method + +CONDITION = re.compile(r"(?P[\w.\[\]-]+)\s*(?P==|!=|\bin\b)\s*(?P.+)") +PREVIEW_LENGTH = 2000 + + +@dataclass(frozen=True) +class Condition: + text: str + response_path: str + operator: str + expected: Any + + +@dataclass(frozen=True) +class WaitSettings: + success_condition: Condition + failure_condition: Optional[Condition] + poll_interval_seconds: int + poll_timeout_seconds: int + output_mappings: dict[str, str] + + +@dataclass(frozen=True) +class Defer: + status: str + + +@dataclass(frozen=True) +class Complete: + outputs: dict[str, Any] + + +@integration( + display_name="Wait for REST API", + description="Polls a REST API until its response meets a condition, releasing compute between polls", + icon="clock", + promoted_parameter="path", + parameters=dict( + connection=ParameterMetadata(display_name="Connection", description="Unity Catalog connection to the API."), + path=ParameterMetadata( + display_name="Path", description="Status path after the connection's base path. For example, jobs/42." + ), + success_condition=ParameterMetadata( + display_name="Success condition", + description='Condition that ends the wait, using ==, !=, or in. For example, status == "done".', + ), + failure_condition=ParameterMetadata( + display_name="Failure condition", + description='Condition that fails the task. For example, status == "failed".', + ), + method=ParameterMetadata(display_name="Method", description="HTTP method of each poll."), + query_params=ParameterMetadata( + display_name="Query parameters", + description="Added to the status URL. For example, run_id with 42 adds ?run_id=42.", + ), + headers=ParameterMetadata(display_name="Headers", description="Extra headers to send with each poll."), + poll_interval_seconds=ParameterMetadata( + display_name="Poll interval in seconds", description="Wait between polls." + ), + poll_timeout_seconds=ParameterMetadata( + display_name="Timeout in seconds", description="How long to keep polling before the task fails." + ), + output_mappings=ParameterMetadata( + display_name="Output mappings", + description="Each key is a task value name and each value is its path in the final response. For " + "example, rows with result.rows.", + ), + ), +) +class WaitForRestApi(Sensor): + def __init__( + self, + connection: HttpUcConnectionParameter, + path: str, + success_condition: str, + failure_condition: Optional[str] = None, + method: Method = Method.GET, + query_params: Optional[dict[str, str]] = None, + headers: Optional[dict[str, str]] = None, + poll_interval_seconds: int = 30, + poll_timeout_seconds: int = 3600, + output_mappings: Optional[dict[str, str]] = None, + ) -> None: + if poll_interval_seconds < 0 or poll_timeout_seconds < 0: + raise ValueError("poll_interval_seconds and poll_timeout_seconds cannot be negative") + if ".." in unquote(urlsplit(path).path).split("/"): + raise ValueError(f"path can't contain '..' segments, got: {path}") + self.settings = WaitSettings( + success_condition=parse_condition("success_condition", success_condition, 'status == "done"'), + failure_condition=( + parse_condition("failure_condition", failure_condition, 'status == "failed"') + if failure_condition + else None + ), + poll_interval_seconds=poll_interval_seconds, + poll_timeout_seconds=poll_timeout_seconds, + output_mappings=output_mappings or {}, + ) + self.request = dict(conn=connection, method=method, path=path, params=query_params, headers=headers) + + def poll(self, ctx: Context) -> PollResult: + waited_seconds = time.time() - get_or_save_start_time(ctx) + + workspace = WorkspaceClient() + response = workspace.serving_endpoints.http_request(**self.request) + decision = decide_poll( + self.settings, + response=parse_response(response), + response_text=response.text, + waited_seconds=waited_seconds, + ) + + match decision: + case Defer(status): + print(status) + print(f"Polling again in {self.settings.poll_interval_seconds}s.") + return PollResult.deferred(timedelta(seconds=self.settings.poll_interval_seconds)) + case Complete(outputs): + print(f"{self.settings.success_condition.text} is met") + print(f"Response: {preview(response.text)}") + for name, value in outputs.items(): + workspace.dbutils.jobs.taskValues.set(key=name, value=value) + print(f"Saved task value {name}: {preview(json.dumps(value))}") + return PollResult.completed() + + +def decide_poll(settings: WaitSettings, response: Any, response_text: str, waited_seconds: float) -> Defer | Complete: + failure = settings.failure_condition + if failure and satisfies_condition(response, failure): + raise RuntimeError(f"failure_condition met: {failure.text}. Response: {preview(response_text)}") + + success = settings.success_condition + if satisfies_condition(response, success): + return Complete(extract_outputs(response, settings.output_mappings)) + + current_value = json.dumps(extract_nested_value(response, success.response_path)) + status = f"{success.text} is not met, {success.response_path} is {current_value}" + if waited_seconds + settings.poll_interval_seconds > settings.poll_timeout_seconds: + raise RuntimeError( + f"Timed out after {settings.poll_timeout_seconds}s. {status}. Response: {preview(response_text)}" + ) + + return Defer(status) + + +def get_or_save_start_time(ctx: Context) -> float: + # Deferring releases the compute, so the time the wait started is kept in a task value. + start_time = ctx.get_task_value("start_time", default=0) + if not start_time: + start_time = time.time() + ctx.set_task_value("start_time", start_time) + + return start_time + + +def parse_condition(name: str, text: str, example: str) -> Condition: + error = ValueError(f"{name} must look like {example}, got: {text}") + match = CONDITION.fullmatch(text.strip()) + if not match: + raise error + + try: + expected = json.loads(match["expected"]) + except json.JSONDecodeError: + raise error from None + + if match["operator"] == "in" and not isinstance(expected, list): + raise error + + return Condition(text, match["path"], match["operator"], expected) + + +def satisfies_condition(response: Any, condition: Condition) -> bool: + actual = extract_nested_value(response, condition.response_path) + # A missing field only meets a condition on null, so the wait goes on until the field appears. + if actual is None and condition.expected is not None: + return False + + candidates = condition.expected if condition.operator == "in" else [condition.expected] + found = any(json_equal(actual, candidate) for candidate in candidates) + return not found if condition.operator == "!=" else found + + +def json_equal(left: Any, right: Any) -> bool: + # Python treats True as 1, but JSON true and 1 are different values. + return left == right and isinstance(left, bool) == isinstance(right, bool) + + +def parse_response(response: Any) -> Any: + try: + return response.json() + except ValueError: + return response.text + + +def preview(text: str) -> str: + if not text: + return "(empty)" + if len(text) > PREVIEW_LENGTH: + return f"{text[:PREVIEW_LENGTH]}... (truncated)" + return text + + +def extract_outputs(response: Any, mappings: dict[str, str]) -> dict[str, Any]: + outputs = {} + for name, response_path in mappings.items(): + value = extract_nested_value(response, response_path) + if value is None: + raise RuntimeError(f"The response has no value at {response_path}") + + outputs[name] = value + return outputs + + +def extract_nested_value(response: Any, response_path: str) -> Any: + # result.items[0].id becomes the keys result, items, 0, and id. A leading [0] indexes a list response. + normalized_path = response_path.replace("[", ".").replace("]", "").lstrip(".") + value = response + for key in normalized_path.split("."): + if isinstance(value, dict): + value = value.get(key) + elif isinstance(value, list) and key.isdigit() and int(key) < len(value): + value = value[int(key)] + else: + return None + return value diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_run_sensor.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_run_sensor.py deleted file mode 100644 index 35e2c945d4a..00000000000 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_run_sensor.py +++ /dev/null @@ -1,28 +0,0 @@ -import datetime - -from databricks.lakeflow.integrations import integration, Context, Sensor, SensorResult -from databricks.sdk import WorkspaceClient - - -@integration(display_name="Wait for run") -class WaitForRunSensor(Sensor): - run_id: str - - def __init__(self, run_id: str): - self.run_id = run_id - - def poll(self, ctx: Context) -> SensorResult: - from databricks.sdk.runtime import dbutils - - w = WorkspaceClient() - - run = w.jobs.get_run(run_id=int(self.run_id)) - result_state = run.state.result_state if run.state else None - - if result_state is not None: - dbutils.jobs.taskValues.set("result_state", result_state.name) - return SensorResult.completed() - else: - print("Running", run.run_page_url) - print("Waiting for a minute...") - return SensorResult.deferred(duration=datetime.timedelta(minutes=1)) diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_slack_reaction.py b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_slack_reaction.py new file mode 100644 index 00000000000..17306cc2340 --- /dev/null +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/src/my_lakeflow_integrations/examples/wait_for_slack_reaction.py @@ -0,0 +1,127 @@ +import datetime +from typing import Annotated, Any, Optional + +from databricks.lakeflow.integrations import ( + Context, + HttpConnectionFilter, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + PollResult, + Sensor, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod + +SlackConnection = Annotated[HttpUcConnectionParameter, HttpConnectionFilter(host="https://slack.com", base_path="/api")] + +MAX_RETRIES = 5 + + +@integration( + display_name="Wait for Slack reaction", + description="Pause until someone reacts to a Slack message", + icon="clock", + promoted_parameter="message_ts", + parameters=dict( + connection=ParameterMetadata( + display_name="Connection", + description="Unity Catalog connection to the Slack API. Its bot token needs the reactions:read scope.", + ), + channel_id=ParameterMetadata( + display_name="Channel ID", + description="For example, {{tasks.send_slack_message.values.channel_id}} from a Send Slack message task.", + ), + message_ts=ParameterMetadata( + display_name="Message timestamp", + description="Slack's ID for the message. For example, {{tasks.send_slack_message.values.ts}} from a Send Slack message task.", + ), + emojis=ParameterMetadata( + display_name="Emojis", + description="Slack emoji names. For example, white_check_mark. Leave empty for any reaction.", + ), + poll_interval_seconds=ParameterMetadata( + display_name="Poll interval (seconds)", description="How often to check for reactions." + ), + ), +) +class WaitForSlackReaction(Sensor): + def __init__( + self, + connection: SlackConnection, + channel_id: str, + message_ts: str, + emojis: Optional[list[str]] = None, + poll_interval_seconds: int = 60, + ): + if poll_interval_seconds < 0: + raise ValueError(f"Poll interval must be 0 seconds or more, got {poll_interval_seconds}.") + + self.connection = connection + self.channel_id = channel_id + self.message_ts = message_ts + self.emojis = {emoji_base_name(emoji.strip(":")) for emoji in emojis or [] if emoji.strip(":")} + self.poll_interval_seconds = poll_interval_seconds + + def poll(self, ctx: Context) -> PollResult: + workspace = WorkspaceClient() + try: + reactions = self.get_reactions(workspace) + except Exception as error: + return self.retry_or_fail(ctx, error) + + ctx.set_task_value("failed_polls", 0) + + reaction = find_matching_reaction(reactions, self.emojis) + if reaction is None: + print(f"No matching reaction yet, checking again in {self.poll_interval_seconds} seconds") + return PollResult.deferred(datetime.timedelta(seconds=self.poll_interval_seconds)) + + emoji, user_id = emoji_base_name(reaction["name"]), reaction["users"][0] + print(f"Found reaction :{emoji}: by user {user_id}") + workspace.dbutils.jobs.taskValues.set(key="reaction", value=emoji) + workspace.dbutils.jobs.taskValues.set(key="user_id", value=user_id) + return PollResult.completed() + + def get_reactions(self, workspace: WorkspaceClient) -> list[dict[str, Any]]: + response = workspace.serving_endpoints.http_request( + conn=self.connection, + method=ExternalFunctionRequestHttpMethod.GET, + path="reactions.get", + params={"channel": self.channel_id, "timestamp": self.message_ts, "full": "true"}, + ) + + try: + result = response.json() + except ValueError: + raise RuntimeError(f"Slack returned a non-JSON response: {response.text}") from None + + # Slack reports API errors with HTTP 200 and ok=false. + if not result.get("ok"): + raise RuntimeError( + f"Slack API error for message {self.message_ts} in channel {self.channel_id}: {result.get('error')}" + ) + return result["message"].get("reactions", []) + + def retry_or_fail(self, ctx: Context, error: Exception) -> PollResult: + failed_polls = ctx.get_task_value("failed_polls", 0) + 1 + if failed_polls > MAX_RETRIES: + raise RuntimeError(f"Checking for reactions failed {failed_polls} times in a row: {error}") from error + + ctx.set_task_value("failed_polls", failed_polls) + print( + f"Checking for reactions failed, retry {failed_polls} of {MAX_RETRIES} in {self.poll_interval_seconds} seconds: {error}" + ) + return PollResult.deferred(datetime.timedelta(seconds=self.poll_interval_seconds)) + + +def emoji_base_name(emoji: str) -> str: + return emoji.split("::")[0] + + +def find_matching_reaction(reactions: list[dict[str, Any]], emojis: set[str]) -> Optional[dict[str, Any]]: + # Slack lists reactions in the order they were first added, so the earliest match wins. + for reaction in reactions: + if not emojis or emoji_base_name(reaction["name"]) in emojis: + return reaction + return None diff --git a/acceptance/bundle/templates/lakeflow-integrations/script b/acceptance/bundle/templates/lakeflow-integrations/script index 0b0925e7cfc..79e8feabfea 100644 --- a/acceptance/bundle/templates/lakeflow-integrations/script +++ b/acceptance/bundle/templates/lakeflow-integrations/script @@ -8,16 +8,15 @@ cleanup() { rm -rf "$WHEELS_DIR" } -# The example modules import `requests` and `databricks.sdk` at module top level, -# but the acceptance harness runs uv offline against a fixed find-links dir that -# only has databricks-lakeflow-integrations. Build stub wheels for these two -# packages from `stub-wheels/` into a per-test find-links dir that also -# symlinks the real vendored wheels, and point UV_FIND_LINKS at it. +# The example modules import `databricks.sdk` at module top level, but the +# acceptance harness runs uv offline against a fixed find-links dir that only +# has databricks-lakeflow-integrations. Build a stub wheel for it from +# `stub-wheels/` into a per-test find-links dir that also symlinks the real +# vendored wheels, and point UV_FIND_LINKS at it. mkdir -p "$WHEELS_DIR" for whl in "$VENDORED_PY_PACKAGES"/*.whl; do ln -sf "$whl" "$WHEELS_DIR/$(basename "$whl")" done -uv build --wheel --quiet --out-dir "$WHEELS_DIR" "$STUB_WHEELS_SRC/requests" uv build --wheel --quiet --out-dir "$WHEELS_DIR" "$STUB_WHEELS_SRC/databricks-sdk" export UV_FIND_LINKS="$WHEELS_DIR" diff --git a/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/runtime/__init__.py b/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/runtime/__init__.py deleted file mode 100644 index beb784ac061..00000000000 --- a/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/runtime/__init__.py +++ /dev/null @@ -1 +0,0 @@ -dbutils = None diff --git a/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/requests/src/requests/__init__.py b/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/service/__init__.py similarity index 100% rename from acceptance/bundle/templates/lakeflow-integrations/stub-wheels/requests/src/requests/__init__.py rename to acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/service/__init__.py diff --git a/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/service/serving.py b/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/service/serving.py new file mode 100644 index 00000000000..7990c6a7c27 --- /dev/null +++ b/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/databricks-sdk/src/databricks/sdk/service/serving.py @@ -0,0 +1,9 @@ +from enum import Enum + + +class ExternalFunctionRequestHttpMethod(Enum): + DELETE = "DELETE" + GET = "GET" + PATCH = "PATCH" + POST = "POST" + PUT = "PUT" diff --git a/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/requests/pyproject.toml b/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/requests/pyproject.toml deleted file mode 100644 index db7519a09be..00000000000 --- a/acceptance/bundle/templates/lakeflow-integrations/stub-wheels/requests/pyproject.toml +++ /dev/null @@ -1,11 +0,0 @@ -[project] -name = "requests" -version = "0.0.0" -requires-python = ">=3.10" - -[build-system] -requires = ["hatchling"] -build-backend = "hatchling.build" - -[tool.hatch.build.targets.wheel] -packages = ["src/requests"] diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl index f1914db34d2..d326820fd78 100644 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl @@ -2,20 +2,25 @@ A Declarative Automation Bundles project that extends Lakeflow Jobs with custom integrations. -This bundle ships with runnable examples under `src/{{.project_name}}/examples/` and -corresponding job definitions under `resources/`: +This bundle ships with examples under `src/{{.project_name}}/examples/` that call external +services through Unity Catalog connections: | Example | Type | What it does | | --- | --- | --- | -| `slack.send_slack_message` | Function | Posts a message to Slack through a Unity Catalog connection. | -| `wait_for_run_sensor.WaitForRunSensor` | Sensor | Polls a job run until it reaches a terminal state. | +| `send_slack_message.send_slack_message` | Function | Posts a message to a Slack channel or direct message, with optional rich formatting. | +| `wait_for_slack_reaction.WaitForSlackReaction` | Sensor | Waits until someone reacts to a Slack message. | +| `create_jira_issue.create_jira_issue` | Function | Creates a Jira issue. | +| `call_rest_api.call_rest_api` | Function | Sends a request to a REST API and saves the response as task values. | +| `wait_for_rest_api.WaitForRestApi` | Sensor | Polls a REST API until its response meets a condition. | + +Define jobs that run them under `resources/`. ## Getting started 1. Open this bundle in a Databricks workspace. 2. Click the **deployments rocket** 🚀 in the left sidebar to open the **Deployments** panel, then click **Deploy**. -3. To run a deployed job, hover over the resource in the **Deployments** panel +3. After you add a job under `resources/` and deploy it, run it: hover over the resource in the **Deployments** panel and click **Run**. ## Documentation diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl index df79b0849be..3ce2636eb4a 100644 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl @@ -6,7 +6,7 @@ requires-python = ">=3.12,<3.13" dependencies = [ # Any dependencies for jobs and pipelines in this project can be added here # See also https://docs.databricks.com/dev-tools/bundles/library-dependencies - "databricks-lakeflow-integrations>=0.0.3,<0.1", + "databricks-lakeflow-integrations>=0.0.6,<0.1", ] [tool.hatch.build.targets.wheel] diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/send_slack_message.job.yml.tmpl b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/send_slack_message.job.yml.tmpl deleted file mode 100644 index e34209ec0c1..00000000000 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/send_slack_message.job.yml.tmpl +++ /dev/null @@ -1,24 +0,0 @@ -resources: - jobs: - send_slack_message: - name: "[example] send_slack_message" - - tasks: - - task_key: slack - environment_key: {{.project_name}}_environment - python_operator_task: - main: {{.project_name}}.examples.slack.send_slack_message - parameters: - - name: "conn_id" - value: "CHANGEME" - - name: "text" - value: "Hello, World" - - name: "channel" - value: "CHANGEME" - - environments: - - environment_key: {{.project_name}}_environment - spec: - environment_version: "5" - dependencies: - - ../dist/*.whl diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/wait_for_run_sensor.job.yml.tmpl b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/wait_for_run_sensor.job.yml.tmpl deleted file mode 100644 index 148c20d2135..00000000000 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/resources/wait_for_run_sensor.job.yml.tmpl +++ /dev/null @@ -1,20 +0,0 @@ -resources: - jobs: - wait_for_run_sensor: - name: "[example] wait_for_run_sensor" - - tasks: - - task_key: wait_for_run_sensor - environment_key: {{.project_name}}_environment - python_operator_task: - main: {{.project_name}}.examples.wait_for_run_sensor.WaitForRunSensor - parameters: - - name: "run_id" - value: "CHANGEME" - - environments: - - environment_key: {{.project_name}}_environment - spec: - environment_version: "5" - dependencies: - - ../dist/*.whl diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/call_rest_api.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/call_rest_api.py new file mode 100644 index 00000000000..3f678a8662c --- /dev/null +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/call_rest_api.py @@ -0,0 +1,111 @@ +import json +from typing import Any, Optional +from urllib.parse import unquote, urlsplit + +from databricks.lakeflow.integrations import ( + HttpUcConnectionParameter, + integration, + ParameterMetadata, + TextAreaParameter, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod as Method + +PREVIEW_LENGTH = 2000 + + +@integration( + display_name="Call REST API", + description="Sends a request through a UC connection, saving the response as task values", + icon="globe", + promoted_parameter="path", + parameters=dict( + connection=ParameterMetadata(display_name="Connection", description="Unity Catalog connection to the API."), + path=ParameterMetadata( + display_name="Path", description="Path after the connection's base path. For example, jobs/42/refresh." + ), + method=ParameterMetadata(display_name="Method", description="HTTP method of the request."), + query_params=ParameterMetadata( + display_name="Query parameters", + description="Added to the request URL. For example, limit with 10 adds ?limit=10.", + ), + headers=ParameterMetadata(display_name="Headers", description="Extra headers to send with the request."), + body=ParameterMetadata(display_name="Body", description="Request body, in JSON."), + output_mappings=ParameterMetadata( + display_name="Output mappings", + description="Each key is a task value name and each value is its path in the response. For example, " + "job_id with id, or first_id with items[0].id.", + ), + ), +) +def call_rest_api( + connection: HttpUcConnectionParameter, + path: str, + method: Method = Method.GET, + query_params: Optional[dict[str, str]] = None, + headers: Optional[dict[str, str]] = None, + body: Optional[TextAreaParameter] = None, + output_mappings: Optional[dict[str, str]] = None, +) -> None: + if ".." in unquote(urlsplit(path).path).split("/"): + raise ValueError(f"path can't contain '..' segments, got: {path}") + json_body = parse_json_body(body) + + workspace = WorkspaceClient() + print(f"Sending {method.value} {path}") + response = workspace.serving_endpoints.http_request( + conn=connection, method=method, path=path, params=query_params, headers=headers, json=json_body + ) + print(f"Response: {preview(response.text)}") + + outputs = extract_outputs(parse_response(response), output_mappings or {}) + for name, value in outputs.items(): + workspace.dbutils.jobs.taskValues.set(key=name, value=value) + print(f"Saved task value {name}: {preview(json.dumps(value))}") + + +def parse_json_body(body: Optional[str]) -> Any: + try: + return json.loads(body) if body else None + except json.JSONDecodeError as error: + raise ValueError(f"body must be valid JSON: {error}") from None + + +def parse_response(response: Any) -> Any: + try: + return response.json() + except ValueError: + return response.text + + +def preview(text: str) -> str: + if not text: + return "(empty)" + if len(text) > PREVIEW_LENGTH: + return f"{text[:PREVIEW_LENGTH]}... (truncated)" + return text + + +def extract_outputs(response: Any, mappings: dict[str, str]) -> dict[str, Any]: + outputs = {} + for name, response_path in mappings.items(): + value = extract_nested_value(response, response_path) + if value is None: + raise RuntimeError(f"The response has no value at {response_path}") + + outputs[name] = value + return outputs + + +def extract_nested_value(response: Any, response_path: str) -> Any: + # result.items[0].id becomes the keys result, items, 0, and id. A leading [0] indexes a list response. + normalized_path = response_path.replace("[", ".").replace("]", "").lstrip(".") + value = response + for key in normalized_path.split("."): + if isinstance(value, dict): + value = value.get(key) + elif isinstance(value, list) and key.isdigit() and int(key) < len(value): + value = value[int(key)] + else: + return None + return value diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/create_jira_issue.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/create_jira_issue.py new file mode 100644 index 00000000000..91db7bf7fd0 --- /dev/null +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/create_jira_issue.py @@ -0,0 +1,117 @@ +import json +from typing import Annotated, Any, Optional + +from databricks.lakeflow.integrations import ( + HttpConnectionFilter, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + TextAreaParameter, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod + +JiraConnection = Annotated[HttpUcConnectionParameter, HttpConnectionFilter(host="https://api.atlassian.com")] + + +@integration( + display_name="Create Jira issue", + description="Creates a Jira issue", + icon="plus-circle", + promoted_parameter="project_key", + parameters=dict( + connection=ParameterMetadata( + display_name="Connection", description="Unity Catalog connection to the Jira Cloud REST API." + ), + project_key=ParameterMetadata(display_name="Project key", description="For example, DATA."), + summary=ParameterMetadata(display_name="Summary", description="Title of the issue."), + issue_type=ParameterMetadata(display_name="Issue type", description="For example, Bug."), + description=ParameterMetadata(display_name="Description", description="Body of the issue, in plain text."), + assignee_email=ParameterMetadata(display_name="Assignee email", description="For example, ana@example.com."), + labels=ParameterMetadata(display_name="Labels", description="For example, pipeline."), + priority=ParameterMetadata(display_name="Priority", description="For example, High."), + fields=ParameterMetadata( + display_name="Other fields", + description="More Jira fields to set, as a JSON object of field IDs and values. " + 'For example, {"customfield_10000": "data-eng"}. The fields above take precedence.', + ), + ), +) +def create_jira_issue( + connection: JiraConnection, + project_key: str, + summary: str, + issue_type: str = "Task", + description: Optional[TextAreaParameter] = None, + assignee_email: Optional[str] = None, + labels: Optional[list[str]] = None, + priority: Optional[str] = None, + fields: Optional[TextAreaParameter] = None, +) -> None: + workspace = WorkspaceClient() + assignee_id = find_account_id_by_email(workspace, connection, assignee_email) if assignee_email else None + optional_fields = { + "description": plain_text_to_jira_document(description) if description else None, + "assignee": {"accountId": assignee_id} if assignee_id else None, + "labels": labels, + "priority": {"name": priority} if priority else None, + } + issue_fields: dict[str, Any] = { + **parse_other_fields(fields), + "project": {"key": project_key}, + "summary": summary, + "issuetype": {"name": issue_type}, + **{key: value for key, value in optional_fields.items() if value}, + } + + result = send_jira_request( + workspace, connection, ExternalFunctionRequestHttpMethod.POST, "issue", {"fields": issue_fields} + ) + print(f"Created issue {result['key']}") + workspace.dbutils.jobs.taskValues.set(key="issue_key", value=result["key"]) + + +def find_account_id_by_email(workspace: WorkspaceClient, connection: str, email: str) -> str: + users = send_jira_request( + workspace, connection, ExternalFunctionRequestHttpMethod.GET, "user/search", None, params={"query": email} + ) + # Jira searches by prefix and returns a null email for users with a private profile. + matches = [user for user in users if (user.get("emailAddress") or "").lower() == email.lower()] + if len(matches) != 1: + raise ValueError(f"Found {len(matches)} Jira users with email {email}. Enter the email of exactly one user.") + return matches[0]["accountId"] + + +def parse_other_fields(fields: Optional[str]) -> dict[str, Any]: + try: + parsed = json.loads(fields) if fields else {} + except json.JSONDecodeError as error: + raise ValueError(f"Other fields must be a JSON object: {error}") from None + if not isinstance(parsed, dict): + raise ValueError("Other fields must be a JSON object, not a list or a single value") + return parsed + + +def send_jira_request( + workspace: WorkspaceClient, + connection: str, + method: ExternalFunctionRequestHttpMethod, + path: str, + body: Optional[dict[str, Any]], + params: Optional[dict[str, str]] = None, +) -> Any: + response = workspace.serving_endpoints.http_request( + conn=connection, method=method, path=path, json=body, params=params + ) + try: + return response.json() + except ValueError: + raise RuntimeError(f"Jira returned a non-JSON response: {response.text}") from None + + +def plain_text_to_jira_document(text: str) -> dict[str, Any]: + # Jira's v3 API only takes rich text as an Atlassian Document Format document. + paragraphs = [ + {"type": "paragraph", "content": [{"type": "text", "text": line}]} for line in text.splitlines() if line.strip() + ] + return {"type": "doc", "version": 1, "content": paragraphs} diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/send_slack_message.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/send_slack_message.py new file mode 100644 index 00000000000..734f277ace5 --- /dev/null +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/send_slack_message.py @@ -0,0 +1,91 @@ +import json +from typing import Annotated, Any, Optional + +from databricks.lakeflow.integrations import ( + HttpConnectionFilter, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + TextAreaParameter, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod + +SlackConnection = Annotated[HttpUcConnectionParameter, HttpConnectionFilter(host="https://slack.com", base_path="/api")] + + +@integration( + display_name="Send Slack message", + description="Posts a message to a Slack channel or direct message with optional rich formatting", + icon="send", + promoted_parameter="channel", + parameters=dict( + connection=ParameterMetadata( + display_name="Connection", + description="Unity Catalog connection to the Slack API. Its bot token needs the chat:write scope.", + ), + channel=ParameterMetadata(display_name="Channel", description="Channel name or ID. For example, #alerts."), + message=ParameterMetadata( + display_name="Message", + description="Text to post, in plain text or Slack markdown. Notifications show it when you also set blocks.", + ), + blocks=ParameterMetadata( + display_name="Blocks", description="Slack Block Kit layout, in JSON, for richer formatting." + ), + thread_ts=ParameterMetadata( + display_name="Thread timestamp", description="Timestamp of the message to reply to in its thread." + ), + username=ParameterMetadata( + display_name="Username", + description="Bot name shown on the message. Needs the chat:write.customize scope.", + ), + icon_url=ParameterMetadata( + display_name="Icon URL", + description="Image shown as the bot's avatar. Needs the chat:write.customize scope.", + ), + icon_emoji=ParameterMetadata( + display_name="Icon emoji", + description="Emoji shown as the bot's avatar. For example, :robot_face:. Needs the chat:write.customize scope.", + ), + ), +) +def send_slack_message( + connection: SlackConnection, + channel: str, + message: TextAreaParameter, + blocks: Optional[TextAreaParameter] = None, + thread_ts: Optional[str] = None, + username: Optional[str] = None, + icon_url: Optional[str] = None, + icon_emoji: Optional[str] = None, +) -> None: + optional_fields = { + "blocks": json.loads(blocks) if blocks else None, + "thread_ts": thread_ts, + "username": username, + "icon_emoji": icon_emoji, + "icon_url": None if icon_emoji else icon_url, + } + payload: dict[str, Any] = {"channel": channel, "text": message} + payload |= {key: value for key, value in optional_fields.items() if value} + + workspace = WorkspaceClient() + response = workspace.serving_endpoints.http_request( + conn=connection, + method=ExternalFunctionRequestHttpMethod.POST, + path="chat.postMessage", + json=payload, + ) + + try: + result = response.json() + except ValueError: + raise RuntimeError(f"Slack returned a non-JSON response: {response.text}") from None + + # Slack reports API errors with HTTP 200 and ok=false. + if not result.get("ok"): + raise RuntimeError(f"Slack API error: {result.get('error')}") + + print(f"Posted message {result['ts']} to channel {result['channel']}") + workspace.dbutils.jobs.taskValues.set(key="ts", value=result["ts"]) + workspace.dbutils.jobs.taskValues.set(key="channel_id", value=result["channel"]) diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/slack.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/slack.py deleted file mode 100644 index 8834a752e4f..00000000000 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/slack.py +++ /dev/null @@ -1,27 +0,0 @@ -import requests -from databricks.sdk import WorkspaceClient -from databricks.lakeflow.integrations import integration - - -@integration(display_name="Send Slack message") -def send_slack_message( - text: str, - conn_id: str, - channel: str, # Example: "C0A874NCL8N" -): - w = WorkspaceClient() - - response = requests.post( - f"{w.config.host}/api/2.0/unity-catalog/connections/{conn_id}/proxy/chat.postMessage", - headers={ - **w.config.authenticate(), - "Accept": "application/json", - "Content-Type": "application/json", - "Accept-Encoding": "identity", # ask for no compression - }, - json={ - "channel": channel, - "text": text, - }, - ) - print(response.json()) diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_rest_api.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_rest_api.py new file mode 100644 index 00000000000..608d415b3fc --- /dev/null +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_rest_api.py @@ -0,0 +1,244 @@ +import json +import re +import time +from dataclasses import dataclass +from datetime import timedelta +from typing import Any, Optional +from urllib.parse import unquote, urlsplit + +from databricks.lakeflow.integrations import ( + Context, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + PollResult, + Sensor, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod as Method + +CONDITION = re.compile(r"(?P[\w.\[\]-]+)\s*(?P==|!=|\bin\b)\s*(?P.+)") +PREVIEW_LENGTH = 2000 + + +@dataclass(frozen=True) +class Condition: + text: str + response_path: str + operator: str + expected: Any + + +@dataclass(frozen=True) +class WaitSettings: + success_condition: Condition + failure_condition: Optional[Condition] + poll_interval_seconds: int + poll_timeout_seconds: int + output_mappings: dict[str, str] + + +@dataclass(frozen=True) +class Defer: + status: str + + +@dataclass(frozen=True) +class Complete: + outputs: dict[str, Any] + + +@integration( + display_name="Wait for REST API", + description="Polls a REST API until its response meets a condition, releasing compute between polls", + icon="clock", + promoted_parameter="path", + parameters=dict( + connection=ParameterMetadata(display_name="Connection", description="Unity Catalog connection to the API."), + path=ParameterMetadata( + display_name="Path", description="Status path after the connection's base path. For example, jobs/42." + ), + success_condition=ParameterMetadata( + display_name="Success condition", + description='Condition that ends the wait, using ==, !=, or in. For example, status == "done".', + ), + failure_condition=ParameterMetadata( + display_name="Failure condition", + description='Condition that fails the task. For example, status == "failed".', + ), + method=ParameterMetadata(display_name="Method", description="HTTP method of each poll."), + query_params=ParameterMetadata( + display_name="Query parameters", + description="Added to the status URL. For example, run_id with 42 adds ?run_id=42.", + ), + headers=ParameterMetadata(display_name="Headers", description="Extra headers to send with each poll."), + poll_interval_seconds=ParameterMetadata( + display_name="Poll interval in seconds", description="Wait between polls." + ), + poll_timeout_seconds=ParameterMetadata( + display_name="Timeout in seconds", description="How long to keep polling before the task fails." + ), + output_mappings=ParameterMetadata( + display_name="Output mappings", + description="Each key is a task value name and each value is its path in the final response. For " + "example, rows with result.rows.", + ), + ), +) +class WaitForRestApi(Sensor): + def __init__( + self, + connection: HttpUcConnectionParameter, + path: str, + success_condition: str, + failure_condition: Optional[str] = None, + method: Method = Method.GET, + query_params: Optional[dict[str, str]] = None, + headers: Optional[dict[str, str]] = None, + poll_interval_seconds: int = 30, + poll_timeout_seconds: int = 3600, + output_mappings: Optional[dict[str, str]] = None, + ) -> None: + if poll_interval_seconds < 0 or poll_timeout_seconds < 0: + raise ValueError("poll_interval_seconds and poll_timeout_seconds cannot be negative") + if ".." in unquote(urlsplit(path).path).split("/"): + raise ValueError(f"path can't contain '..' segments, got: {path}") + self.settings = WaitSettings( + success_condition=parse_condition("success_condition", success_condition, 'status == "done"'), + failure_condition=( + parse_condition("failure_condition", failure_condition, 'status == "failed"') + if failure_condition + else None + ), + poll_interval_seconds=poll_interval_seconds, + poll_timeout_seconds=poll_timeout_seconds, + output_mappings=output_mappings or {}, + ) + self.request = dict(conn=connection, method=method, path=path, params=query_params, headers=headers) + + def poll(self, ctx: Context) -> PollResult: + waited_seconds = time.time() - get_or_save_start_time(ctx) + + workspace = WorkspaceClient() + response = workspace.serving_endpoints.http_request(**self.request) + decision = decide_poll( + self.settings, + response=parse_response(response), + response_text=response.text, + waited_seconds=waited_seconds, + ) + + match decision: + case Defer(status): + print(status) + print(f"Polling again in {self.settings.poll_interval_seconds}s.") + return PollResult.deferred(timedelta(seconds=self.settings.poll_interval_seconds)) + case Complete(outputs): + print(f"{self.settings.success_condition.text} is met") + print(f"Response: {preview(response.text)}") + for name, value in outputs.items(): + workspace.dbutils.jobs.taskValues.set(key=name, value=value) + print(f"Saved task value {name}: {preview(json.dumps(value))}") + return PollResult.completed() + + +def decide_poll(settings: WaitSettings, response: Any, response_text: str, waited_seconds: float) -> Defer | Complete: + failure = settings.failure_condition + if failure and satisfies_condition(response, failure): + raise RuntimeError(f"failure_condition met: {failure.text}. Response: {preview(response_text)}") + + success = settings.success_condition + if satisfies_condition(response, success): + return Complete(extract_outputs(response, settings.output_mappings)) + + current_value = json.dumps(extract_nested_value(response, success.response_path)) + status = f"{success.text} is not met, {success.response_path} is {current_value}" + if waited_seconds + settings.poll_interval_seconds > settings.poll_timeout_seconds: + raise RuntimeError( + f"Timed out after {settings.poll_timeout_seconds}s. {status}. Response: {preview(response_text)}" + ) + + return Defer(status) + + +def get_or_save_start_time(ctx: Context) -> float: + # Deferring releases the compute, so the time the wait started is kept in a task value. + start_time = ctx.get_task_value("start_time", default=0) + if not start_time: + start_time = time.time() + ctx.set_task_value("start_time", start_time) + + return start_time + + +def parse_condition(name: str, text: str, example: str) -> Condition: + error = ValueError(f"{name} must look like {example}, got: {text}") + match = CONDITION.fullmatch(text.strip()) + if not match: + raise error + + try: + expected = json.loads(match["expected"]) + except json.JSONDecodeError: + raise error from None + + if match["operator"] == "in" and not isinstance(expected, list): + raise error + + return Condition(text, match["path"], match["operator"], expected) + + +def satisfies_condition(response: Any, condition: Condition) -> bool: + actual = extract_nested_value(response, condition.response_path) + # A missing field only meets a condition on null, so the wait goes on until the field appears. + if actual is None and condition.expected is not None: + return False + + candidates = condition.expected if condition.operator == "in" else [condition.expected] + found = any(json_equal(actual, candidate) for candidate in candidates) + return not found if condition.operator == "!=" else found + + +def json_equal(left: Any, right: Any) -> bool: + # Python treats True as 1, but JSON true and 1 are different values. + return left == right and isinstance(left, bool) == isinstance(right, bool) + + +def parse_response(response: Any) -> Any: + try: + return response.json() + except ValueError: + return response.text + + +def preview(text: str) -> str: + if not text: + return "(empty)" + if len(text) > PREVIEW_LENGTH: + return f"{text[:PREVIEW_LENGTH]}... (truncated)" + return text + + +def extract_outputs(response: Any, mappings: dict[str, str]) -> dict[str, Any]: + outputs = {} + for name, response_path in mappings.items(): + value = extract_nested_value(response, response_path) + if value is None: + raise RuntimeError(f"The response has no value at {response_path}") + + outputs[name] = value + return outputs + + +def extract_nested_value(response: Any, response_path: str) -> Any: + # result.items[0].id becomes the keys result, items, 0, and id. A leading [0] indexes a list response. + normalized_path = response_path.replace("[", ".").replace("]", "").lstrip(".") + value = response + for key in normalized_path.split("."): + if isinstance(value, dict): + value = value.get(key) + elif isinstance(value, list) and key.isdigit() and int(key) < len(value): + value = value[int(key)] + else: + return None + return value diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_run_sensor.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_run_sensor.py deleted file mode 100644 index 35e2c945d4a..00000000000 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_run_sensor.py +++ /dev/null @@ -1,28 +0,0 @@ -import datetime - -from databricks.lakeflow.integrations import integration, Context, Sensor, SensorResult -from databricks.sdk import WorkspaceClient - - -@integration(display_name="Wait for run") -class WaitForRunSensor(Sensor): - run_id: str - - def __init__(self, run_id: str): - self.run_id = run_id - - def poll(self, ctx: Context) -> SensorResult: - from databricks.sdk.runtime import dbutils - - w = WorkspaceClient() - - run = w.jobs.get_run(run_id=int(self.run_id)) - result_state = run.state.result_state if run.state else None - - if result_state is not None: - dbutils.jobs.taskValues.set("result_state", result_state.name) - return SensorResult.completed() - else: - print("Running", run.run_page_url) - print("Waiting for a minute...") - return SensorResult.deferred(duration=datetime.timedelta(minutes=1)) diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_slack_reaction.py b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_slack_reaction.py new file mode 100644 index 00000000000..17306cc2340 --- /dev/null +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/src/{{.project_name}}/examples/wait_for_slack_reaction.py @@ -0,0 +1,127 @@ +import datetime +from typing import Annotated, Any, Optional + +from databricks.lakeflow.integrations import ( + Context, + HttpConnectionFilter, + HttpUcConnectionParameter, + integration, + ParameterMetadata, + PollResult, + Sensor, +) +from databricks.sdk import WorkspaceClient +from databricks.sdk.service.serving import ExternalFunctionRequestHttpMethod + +SlackConnection = Annotated[HttpUcConnectionParameter, HttpConnectionFilter(host="https://slack.com", base_path="/api")] + +MAX_RETRIES = 5 + + +@integration( + display_name="Wait for Slack reaction", + description="Pause until someone reacts to a Slack message", + icon="clock", + promoted_parameter="message_ts", + parameters=dict( + connection=ParameterMetadata( + display_name="Connection", + description="Unity Catalog connection to the Slack API. Its bot token needs the reactions:read scope.", + ), + channel_id=ParameterMetadata( + display_name="Channel ID", + description="For example, {{tasks.send_slack_message.values.channel_id}} from a Send Slack message task.", + ), + message_ts=ParameterMetadata( + display_name="Message timestamp", + description="Slack's ID for the message. For example, {{tasks.send_slack_message.values.ts}} from a Send Slack message task.", + ), + emojis=ParameterMetadata( + display_name="Emojis", + description="Slack emoji names. For example, white_check_mark. Leave empty for any reaction.", + ), + poll_interval_seconds=ParameterMetadata( + display_name="Poll interval (seconds)", description="How often to check for reactions." + ), + ), +) +class WaitForSlackReaction(Sensor): + def __init__( + self, + connection: SlackConnection, + channel_id: str, + message_ts: str, + emojis: Optional[list[str]] = None, + poll_interval_seconds: int = 60, + ): + if poll_interval_seconds < 0: + raise ValueError(f"Poll interval must be 0 seconds or more, got {poll_interval_seconds}.") + + self.connection = connection + self.channel_id = channel_id + self.message_ts = message_ts + self.emojis = {emoji_base_name(emoji.strip(":")) for emoji in emojis or [] if emoji.strip(":")} + self.poll_interval_seconds = poll_interval_seconds + + def poll(self, ctx: Context) -> PollResult: + workspace = WorkspaceClient() + try: + reactions = self.get_reactions(workspace) + except Exception as error: + return self.retry_or_fail(ctx, error) + + ctx.set_task_value("failed_polls", 0) + + reaction = find_matching_reaction(reactions, self.emojis) + if reaction is None: + print(f"No matching reaction yet, checking again in {self.poll_interval_seconds} seconds") + return PollResult.deferred(datetime.timedelta(seconds=self.poll_interval_seconds)) + + emoji, user_id = emoji_base_name(reaction["name"]), reaction["users"][0] + print(f"Found reaction :{emoji}: by user {user_id}") + workspace.dbutils.jobs.taskValues.set(key="reaction", value=emoji) + workspace.dbutils.jobs.taskValues.set(key="user_id", value=user_id) + return PollResult.completed() + + def get_reactions(self, workspace: WorkspaceClient) -> list[dict[str, Any]]: + response = workspace.serving_endpoints.http_request( + conn=self.connection, + method=ExternalFunctionRequestHttpMethod.GET, + path="reactions.get", + params={"channel": self.channel_id, "timestamp": self.message_ts, "full": "true"}, + ) + + try: + result = response.json() + except ValueError: + raise RuntimeError(f"Slack returned a non-JSON response: {response.text}") from None + + # Slack reports API errors with HTTP 200 and ok=false. + if not result.get("ok"): + raise RuntimeError( + f"Slack API error for message {self.message_ts} in channel {self.channel_id}: {result.get('error')}" + ) + return result["message"].get("reactions", []) + + def retry_or_fail(self, ctx: Context, error: Exception) -> PollResult: + failed_polls = ctx.get_task_value("failed_polls", 0) + 1 + if failed_polls > MAX_RETRIES: + raise RuntimeError(f"Checking for reactions failed {failed_polls} times in a row: {error}") from error + + ctx.set_task_value("failed_polls", failed_polls) + print( + f"Checking for reactions failed, retry {failed_polls} of {MAX_RETRIES} in {self.poll_interval_seconds} seconds: {error}" + ) + return PollResult.deferred(datetime.timedelta(seconds=self.poll_interval_seconds)) + + +def emoji_base_name(emoji: str) -> str: + return emoji.split("::")[0] + + +def find_matching_reaction(reactions: list[dict[str, Any]], emojis: set[str]) -> Optional[dict[str, Any]]: + # Slack lists reactions in the order they were first added, so the earliest match wins. + for reaction in reactions: + if not emojis or emoji_base_name(reaction["name"]) in emojis: + return reaction + return None diff --git a/libs/vendored_py_packages/databricks_lakeflow_integrations-0.0.3-py3-none-any.whl b/libs/vendored_py_packages/databricks_lakeflow_integrations-0.0.3-py3-none-any.whl deleted file mode 100644 index d3179c0096e7b05be4c81080cf46390a3c065df3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 20117 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

$?z&#T6?ahbMXb!BHE|5Mocy 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 Tz~Y&KK^zDzfkEcx2I2t#rAcF@ diff --git a/libs/vendored_py_packages/databricks_lakeflow_integrations-0.0.6-py3-none-any.whl b/libs/vendored_py_packages/databricks_lakeflow_integrations-0.0.6-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f2b8159bff8f4d861f9e62efd144ae955c0fa707 GIT binary patch literal 28737 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 z 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 literal 0 HcmV?d00001 From f938ba48d8fdd5917eb0bae3f3202e91649f03d0 Mon Sep 17 00:00:00 2001 From: Cristian Jensen Date: Tue, 10 Nov 2026 15:59:04 +0000 Subject: [PATCH 2/4] Drop unused requests dev dependency from lakeflow-integrations template No example imports requests anymore, and the acceptance test no longer provides a stub for it, so uv failed to resolve it offline on CI. Co-authored-by: Isaac --- .../output/my_lakeflow_integrations/pyproject.toml | 1 - .../template/{{.project_name}}/pyproject.toml.tmpl | 1 - 2 files changed, 2 deletions(-) diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml index 8fc0b94eea5..52895555c95 100644 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/pyproject.toml @@ -17,7 +17,6 @@ packages = [ [dependency-groups] dev = [ # libraries part of serverless environment - "requests", "databricks-sdk" ] diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl index 3ce2636eb4a..6ecb229655d 100644 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/pyproject.toml.tmpl @@ -17,7 +17,6 @@ packages = [ [dependency-groups] dev = [ # libraries part of serverless environment - "requests", "databricks-sdk" ] From ff8ad5fa29ed205fd20b344424effcfd21b8eb54 Mon Sep 17 00:00:00 2001 From: Cristian Perez Jensen Date: Wed, 11 Nov 2026 10:49:03 +0100 Subject: [PATCH 3/4] Revise README with integration setup instructions Updated README to include instructions for adding integrations to the task palette. --- .../output/my_lakeflow_integrations/README.md | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md index 7b5ecc1b269..4a4345a25d3 100644 --- a/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md +++ b/acceptance/bundle/templates/lakeflow-integrations/output/my_lakeflow_integrations/README.md @@ -20,8 +20,11 @@ Define jobs that run them under `resources/`. 1. Open this bundle in a Databricks workspace. 2. Click the **deployments rocket** 🚀 in the left sidebar to open the **Deployments** panel, then click **Deploy**. -3. After you add a job under `resources/` and deploy it, run it: hover over the resource in the **Deployments** panel - and click **Run**. +3. To make the deployed integrations appear in the task palette, add them to `/Workspace/Users//.lakeflow_integrations.yml`. For example: + ```yaml + integrations: + - '/Workspace/Users//.bundle//dev/artifacts/.internal/*.yml' + ``` ## Documentation From bd3c03da21c2dc40747d0eeb68cf9ea3b6433343 Mon Sep 17 00:00:00 2001 From: Cristian Perez Jensen Date: Wed, 11 Nov 2026 11:05:38 +0100 Subject: [PATCH 4/4] Revise deployment instructions in README template Updated instructions for deploying integrations and added configuration example for task palette. --- .../template/{{.project_name}}/README.md.tmpl | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl index d326820fd78..68da9075889 100644 --- a/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl +++ b/libs/template/templates/lakeflow-integrations/template/{{.project_name}}/README.md.tmpl @@ -20,8 +20,11 @@ Define jobs that run them under `resources/`. 1. Open this bundle in a Databricks workspace. 2. Click the **deployments rocket** 🚀 in the left sidebar to open the **Deployments** panel, then click **Deploy**. -3. After you add a job under `resources/` and deploy it, run it: hover over the resource in the **Deployments** panel - and click **Run**. +3. To make the deployed integrations appear in the task palette, add them to `/Workspace/Users//.lakeflow_integrations.yml`. For example: + ```yaml + integrations: + - '/Workspace/Users//.bundle//dev/artifacts/.internal/*.yml' + ``` ## Documentation