chalkpy 2.166.1__tar.gz → 2.167.0__tar.gz

{chalkpy-2.166.1 → chalkpy-2.167.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chalkpy
-Version: 2.166.1
+Version: 2.167.0
 Summary: Python SDK for Chalk
 Author: Chalk AI, Inc.
 Project-URL: Homepage, https://chalk.ai
@@ -189,7 +189,7 @@ Requires-Dist: sqlalchemy[asyncio]<2,>=1.4.26; extra == "postgresql"
 Requires-Dist: sqlglot<21.2.0,>=19.0.0; extra == "postgresql"
 Provides-Extra: snowflake
 Requires-Dist: snowflake-connector-python<5,>=3.12.4; extra == "snowflake"
-Requires-Dist: snowflake-sqlalchemy<1.11,>=1.5.0; extra == "snowflake"
+Requires-Dist: snowflake-sqlalchemy<1.12,>=1.5.0; extra == "snowflake"
 Requires-Dist: adlfs; extra == "snowflake"
 Requires-Dist: duckdb<1.2.0,>=0.6; python_version < "3.14" and extra == "snowflake"
 Requires-Dist: duckdb<1.6,>=1.4.4; python_version >= "3.14" and extra == "snowflake"
@@ -353,7 +353,7 @@ Requires-Dist: python-json-logger<4.0.0,>=3.0.0; extra == "all"
 Requires-Dist: redshift_connector<2.3,>=2.0.909; extra == "all"
 Requires-Dist: s3fs>=2024.2.0; extra == "all"
 Requires-Dist: snowflake-connector-python<5,>=3.12.4; extra == "all"
-Requires-Dist: snowflake-sqlalchemy<1.11,>=1.5.0; extra == "all"
+Requires-Dist: snowflake-sqlalchemy<1.12,>=1.5.0; extra == "all"
 Requires-Dist: sqlalchemy-bigquery<1.12,>=1.5.0; extra == "all"
 Requires-Dist: sqlalchemy-spanner<1.12.0; extra == "all"
 Requires-Dist: sqlalchemy[asyncio]<2,>=1.4.26; extra == "all"

chalkpy-2.167.0/chalk/_version.py

@@ -0,0 +1 @@
+__version__ = "2.167.0"

chalkpy-2.167.0/chalk/workflows/__init__.py

@@ -0,0 +1,36 @@
+from chalk.workflows._children import current_workflow_id, parent_workflow_id, start_child
+from chalk.workflows._context import ChildWorkflowHandle, TaskHandle
+from chalk.workflows._definitions import (
+    TASK_REGISTRY,
+    WORKFLOW_REGISTRY,
+    TaskDefinition,
+    WorkflowDefinition,
+    task,
+    workflow,
+)
+from chalk.workflows._messages import (
+    WorkflowMessage,
+    WorkflowMessageTimeoutError,
+    local_messages,
+    send_message,
+    wait_for_message,
+)
+
+__all__ = (
+    "ChildWorkflowHandle",
+    "TASK_REGISTRY",
+    "WORKFLOW_REGISTRY",
+    "TaskDefinition",
+    "TaskHandle",
+    "WorkflowDefinition",
+    "WorkflowMessage",
+    "WorkflowMessageTimeoutError",
+    "current_workflow_id",
+    "local_messages",
+    "parent_workflow_id",
+    "send_message",
+    "start_child",
+    "task",
+    "wait_for_message",
+    "workflow",
+)

chalkpy-2.167.0/chalk/workflows/_children.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import inspect
+from typing import Any, Mapping, TypeVar, overload
+
+from chalk.workflows._context import ChildWorkflowHandle, current_orchestrator
+from chalk.workflows._definitions import WorkflowDefinition
+
+R = TypeVar("R")
+
+
+def current_workflow_id() -> str:
+    """Return the id of the running workflow, from inside a `@workflow`.
+
+    It is the id `ChalkClient.trigger_workflow` returned (or the child's id, in a workflow
+    started with `start_child`), which other workflows can pass to `send_message`. A workflow
+    run directly in this process gets a generated `local-...` id.
+    """
+    orchestrator = current_orchestrator()
+    if orchestrator is None:
+        raise RuntimeError("current_workflow_id can only be called inside a @workflow")
+    return orchestrator.current_workflow_id()
+
+
+def parent_workflow_id() -> str | None:
+    """Return the id of the workflow that started this one with `start_child`, from inside a
+    `@workflow`, or `None` if it was not started as a child.
+
+    A child can use it to message its parent without waiting to hear from it first:
+
+    >>> from chalk.workflows import current_workflow_id, parent_workflow_id, send_message, workflow
+    >>> @workflow
+    ... async def sub_agent() -> None:
+    ...     parent_id = parent_workflow_id()
+    ...     if parent_id is not None:
+    ...         await send_message(parent_id, "ready", {"agent": current_workflow_id()})
+    """
+    orchestrator = current_orchestrator()
+    if orchestrator is None:
+        raise RuntimeError("parent_workflow_id can only be called inside a @workflow")
+    return orchestrator.parent_workflow_id()
+
+
+@overload
+async def start_child(
+    workflow: WorkflowDefinition[..., R], input: Mapping[str, Any] | None = None, *, workflow_id: str | None = None
+) -> ChildWorkflowHandle[R]: ...
+
+
+@overload
+async def start_child(
+    workflow: str, input: Mapping[str, Any] | None = None, *, workflow_id: str | None = None
+) -> ChildWorkflowHandle[Any]: ...
+
+
+async def start_child(
+    workflow: WorkflowDefinition[..., Any] | str,
+    input: Mapping[str, Any] | None = None,
+    *,
+    workflow_id: str | None = None,
+) -> ChildWorkflowHandle[Any]:
+    """Start another workflow as a child of the calling `@workflow`, and return a handle to it.
+
+    The child runs as its own workflow, on the same workers as the parent, with its own
+    history; await the handle for its result and use `handle.send_message(...)` to message
+    it. The workflow lineage view shows it as a child of the calling workflow.
+
+    A child's lifetime is bounded by its parent's: if the parent completes, fails or is
+    cancelled while the child is still running, the child is cancelled. It receives the
+    cancellation like any cancelled workflow, so its `finally` blocks still run (for example
+    to release a sandbox). Await every child before returning from the parent.
+
+    Like a workflow started with `ChalkClient.trigger_workflow`, the child is not retried as
+    a whole; retries are configured per `@task`.
+
+    Parameters
+    ----------
+    workflow
+        The child `@workflow`, or the name of one served by this workflow's workers.
+    input
+        The child's keyword arguments, by name, as for `ChalkClient.trigger_workflow`. Must
+        be JSON-serializable. `None` starts a child that takes no arguments.
+    workflow_id
+        The child's workflow id. Defaults to one derived from the parent's id and the child's
+        name. Starting a child with the id of a workflow that is still running fails.
+
+    Examples
+    --------
+    >>> from chalk.workflows import start_child, workflow
+    >>> @workflow
+    ... async def score_segment(segment: str) -> float:
+    ...     return 0.5
+    >>> @workflow
+    ... async def score_all(segments: list[str]) -> list[float]:
+    ...     children = [await start_child(score_segment, {"segment": s}) for s in segments]
+    ...     return [await child for child in children]
+    """
+    orchestrator = current_orchestrator()
+    if orchestrator is None:
+        raise RuntimeError("start_child can only be called inside a @workflow")
+    kwargs = dict(input) if input is not None else {}
+    if isinstance(workflow, WorkflowDefinition):
+        # Fail in the parent, where the mistake is, rather than in a child that cannot start.
+        try:
+            inspect.signature(workflow.fn).bind(**kwargs)
+        except TypeError as e:
+            raise TypeError(f"Invalid input for child workflow {workflow.name!r}: {e}") from None
+    return await orchestrator.start_child(workflow, kwargs, workflow_id)

chalkpy-2.167.0/chalk/workflows/_context.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import uuid
+from datetime import timedelta
+from typing import TYPE_CHECKING, Any, Awaitable, Callable, Generator, Generic, Mapping, Protocol, Sequence, TypeVar
+
+if TYPE_CHECKING:
+    from chalk.workflows._definitions import TaskDefinition, WorkflowDefinition
+    from chalk.workflows._messages import WorkflowMessage
+
+R = TypeVar("R")
+
+
+class TaskHandle(Generic[R]):
+    """A handle to a task submitted with `task.submit(...)` inside a workflow.
+
+    Await the handle to obtain the task's result:
+
+    >>> handle = my_task.submit(1)  # doctest: +SKIP
+    >>> result = await handle  # doctest: +SKIP
+    """
+
+    def __init__(self, awaitable: Awaitable[R]):
+        super().__init__()
+        self._awaitable = awaitable
+
+    def __await__(self) -> Generator[Any, None, R]:
+        return self._awaitable.__await__()
+
+
+class ChildWorkflowHandle(Generic[R]):
+    """A handle to a child workflow started with `chalk.workflows.start_child(...)`.
+
+    Await the handle to obtain the child's result, and use `send_message` to message it:
+
+    >>> child = await start_child(review_account, {"account_id": "acct-1"})  # doctest: +SKIP
+    >>> await child.send_message("review", {"approved": True})  # doctest: +SKIP
+    >>> result = await child  # doctest: +SKIP
+    """
+
+    def __init__(
+        self,
+        workflow_id: str,
+        result: Awaitable[R],
+        send_message: Callable[[str, Any], Awaitable[None]],
+    ):
+        super().__init__()
+        self.workflow_id = workflow_id
+        self._result = result
+        self._send_message = send_message
+
+    def __await__(self) -> Generator[Any, None, R]:
+        return self._result.__await__()
+
+    async def send_message(self, name: str, payload: Any) -> None:
+        """Send the child a message, which it receives with `wait_for_message(name)`.
+        Equivalent to `chalk.workflows.send_message(handle.workflow_id, name, payload)`."""
+        await self._send_message(name, payload)
+
+
+class WorkflowOrchestrator(Protocol):
+    """Backend that executes task invocations made inside a running workflow.
+
+    Implementations: `LocalOrchestrator` (in-process asyncio) and the Temporal-backed
+    orchestrator in `chalk.workflows._temporal`. User code never sees this type.
+    """
+
+    def run_task(
+        self,
+        task: TaskDefinition[Any, Any],
+        args: Sequence[Any],
+        kwargs: Mapping[str, Any],
+    ) -> Awaitable[Any]: ...
+
+    def submit_task(
+        self,
+        task: TaskDefinition[Any, Any],
+        args: Sequence[Any],
+        kwargs: Mapping[str, Any],
+    ) -> TaskHandle[Any]: ...
+
+    def wait_for_message(self, name: str, timeout: timedelta | None) -> Awaitable[WorkflowMessage]: ...
+
+    def start_child(
+        self,
+        workflow: WorkflowDefinition[Any, Any] | str,
+        kwargs: Mapping[str, Any],
+        workflow_id: str | None,
+    ) -> Awaitable[ChildWorkflowHandle[Any]]: ...
+
+    def send_message(self, workflow_id: str, name: str, payload: Any) -> Awaitable[None]: ...
+
+    def current_workflow_id(self) -> str: ...
+
+    def parent_workflow_id(self) -> str | None: ...
+
+
+# Messages queued by `chalk.workflows.local_messages` for workflows run by a LocalOrchestrator.
+local_messages_var: contextvars.ContextVar[list[WorkflowMessage] | None] = contextvars.ContextVar(
+    "chalk_workflow_local_messages", default=None
+)
+
+current_orchestrator_var: contextvars.ContextVar[WorkflowOrchestrator | None] = contextvars.ContextVar(
+    "chalk_workflow_orchestrator", default=None
+)
+
+
+def current_orchestrator() -> WorkflowOrchestrator | None:
+    return current_orchestrator_var.get()
+
+
+def local_workflow_id(name: str) -> str:
+    return f"local-{name}-{uuid.uuid4().hex[:12]}"
+
+
+class LocalOrchestrator:
+    """Executes tasks in-process. Used when a workflow function is invoked directly
+    (local runs and unit tests) rather than under a durable execution backend."""
+
+    def __init__(self, workflow_id: str, parent_workflow_id: str | None = None):
+        super().__init__()
+        self.workflow_id = workflow_id
+        self._parent_workflow_id = parent_workflow_id
+        # This invocation's running children, by id; a child leaves when it finishes.
+        self._children: dict[str, asyncio.Future[Any]] = {}
+
+    def current_workflow_id(self) -> str:
+        return self.workflow_id
+
+    def parent_workflow_id(self) -> str | None:
+        return self._parent_workflow_id
+
+    async def _execute(
+        self,
+        task: TaskDefinition[Any, Any],
+        args: Sequence[Any],
+        kwargs: Mapping[str, Any],
+    ) -> Any:
+        attempts = task.retries + 1
+        last_error: BaseException | None = None
+        for attempt in range(attempts):
+            try:
+                if task.is_async:
+                    return await task.fn(*args, **kwargs)
+                # Sync tasks run in a thread so local workflows can still make progress
+                # on other submitted tasks, mirroring how sync tasks execute in a
+                # worker thread pool under a durable backend.
+                return await asyncio.to_thread(task.fn, *args, **kwargs)
+            except Exception as e:  # noqa: PERF203
+                last_error = e
+                if attempt + 1 < attempts and task.retry_delay is not None:
+                    await asyncio.sleep(task.retry_delay.total_seconds())
+        assert last_error is not None
+        raise last_error
+
+    def run_task(
+        self,
+        task: TaskDefinition[Any, Any],
+        args: Sequence[Any],
+        kwargs: Mapping[str, Any],
+    ) -> Awaitable[Any]:
+        return self._execute(task, args, kwargs)
+
+    def submit_task(
+        self,
+        task: TaskDefinition[Any, Any],
+        args: Sequence[Any],
+        kwargs: Mapping[str, Any],
+    ) -> TaskHandle[Any]:
+        return TaskHandle(asyncio.ensure_future(self._execute(task, args, kwargs)))
+
+    async def wait_for_message(self, name: str, timeout: timedelta | None) -> WorkflowMessage:
+        # A direct local run has no address anyone could send to, so it only sees messages
+        # queued in advance; waiting would hang forever.
+        queued = local_messages_var.get()
+        if queued is not None:
+            for i, message in enumerate(queued):
+                if message.name == name:
+                    return queued.pop(i)
+        raise RuntimeError(
+            f"No local message named {name!r}. A workflow run directly in this process only receives "
+            + "messages queued with chalk.workflows.local_messages(...); run it on the workflow orchestrator "
+            + "(ChalkClient.trigger_workflow or run_workflow) to receive messages sent to it."
+        )
+
+    async def start_child(
+        self,
+        workflow: WorkflowDefinition[Any, Any] | str,
+        kwargs: Mapping[str, Any],
+        workflow_id: str | None,
+    ) -> ChildWorkflowHandle[Any]:
+        if isinstance(workflow, str):
+            from chalk.workflows._definitions import WORKFLOW_REGISTRY
+
+            definition = WORKFLOW_REGISTRY.get(workflow)
+            if definition is None:
+                raise ValueError(f"No workflow named {workflow!r} is defined in this process")
+        else:
+            definition = workflow
+
+        child_id = workflow_id if workflow_id is not None else local_workflow_id(definition.name)
+        # The orchestrator refuses to start a workflow whose id is still running.
+        if child_id in self._children:
+            raise RuntimeError(f"Cannot start child workflow {child_id!r}: a child with that id is still running")
+
+        async def run_child() -> Any:
+            # The child runs in its own task (and so its own context): messages queued with
+            # local_messages(...) are the parent's, not the child's.
+            local_messages_var.set(None)
+            orchestrator = LocalOrchestrator(child_id, parent_workflow_id=self.workflow_id)
+            current_orchestrator_var.set(orchestrator)
+            try:
+                return await definition.fn(**kwargs)
+            finally:
+                await orchestrator.close()
+
+        child = asyncio.ensure_future(run_child())
+        self._children[child_id] = child
+        child.add_done_callback(lambda _: self._children.pop(child_id, None))
+        return ChildWorkflowHandle(
+            child_id,
+            child,
+            lambda name, payload: self.send_message(child_id, name, payload),
+        )
+
+    async def close(self) -> None:
+        """Cancel the children still running when this invocation exits, and wait for their
+        `finally` blocks, as the orchestrator does for a child whose parent closes first."""
+        children = list(self._children.values())
+        for child in children:
+            child.cancel()
+        await asyncio.gather(*children, return_exceptions=True)
+
+    async def send_message(self, workflow_id: str, name: str, payload: Any) -> None:
+        raise RuntimeError(
+            f"Cannot send message {name!r} to workflow {workflow_id!r}: a workflow run directly in this process "
+            + "has no orchestrator to deliver messages between workflows. Run it on the workflow orchestrator "
+            + "(ChalkClient.trigger_workflow or run_workflow) to message other workflows."
+        )

{chalkpy-2.166.1 → chalkpy-2.167.0}/chalk/workflows/_definitions.py

@@ -8,7 +8,13 @@ from typing import Any, Callable, Coroutine, Generic, Mapping, Sequence, TypeVar
 from typing_extensions import ParamSpec
 
 from chalk.utils.duration import Duration, parse_chalk_duration
-from chalk.workflows._context import LocalOrchestrator, TaskHandle, current_orchestrator, current_orchestrator_var
+from chalk.workflows._context import (
+    LocalOrchestrator,
+    TaskHandle,
+    current_orchestrator,
+    current_orchestrator_var,
+    local_workflow_id,
+)
 
 P = ParamSpec("P")
 R = TypeVar("R")
@@ -118,11 +124,13 @@ class WorkflowDefinition(Generic[P, R]):
             # Calling one workflow from another: run it inline in the caller's
             # orchestration context, so its tasks remain durable task invocations.
             return await self.fn(*args, **kwargs)
-        token: contextvars.Token[Any] = current_orchestrator_var.set(LocalOrchestrator())
+        orchestrator = LocalOrchestrator(local_workflow_id(self.name))
+        token: contextvars.Token[Any] = current_orchestrator_var.set(orchestrator)
         try:
             return await self.fn(*args, **kwargs)
         finally:
             current_orchestrator_var.reset(token)
+            await orchestrator.close()
 
     def __repr__(self) -> str:
         return f"chalk.workflows.workflow(name={self.name!r})"

{chalkpy-2.166.1 → chalkpy-2.167.0}/chalk/workflows/_messages.py

@@ -16,10 +16,15 @@ WORKFLOW_MESSAGE_SIGNAL = "chalk.workflow_message"
 class WorkflowMessage:
     """A message delivered to a running workflow, e.g. a reviewer's decision.
 
-    `sender_kind` and `sender_id` identify who sent it, as authenticated by the Chalk API
-    server (for example `"user"` and a user id, or `"service_token"` and a token id). They
-    cannot be set by the sender, so a workflow can use them to decide whose decisions to
-    accept.
+    `sender_kind` and `sender_id` identify who sent it. For a message sent through the Chalk
+    API server (`ChalkClient.send_workflow_message`), they are authenticated by the server
+    (for example `"user"` and a user id, or `"service_token"` and a token id) and cannot be
+    set by the sender, so a workflow can use them to decide whose decisions to accept.
+
+    A message sent by another workflow with `chalk.workflows.send_message` has `sender_kind`
+    `"workflow"` and the sending workflow's id as `sender_id`. Those are written by the
+    sending workflow itself and do not pass through the API server, so they are not
+    authenticated: do not use them to authorize a decision.
     """
 
     name: str
@@ -79,6 +84,46 @@ async def wait_for_message(name: str, *, timeout: timedelta | None = None) -> Wo
     return await orchestrator.wait_for_message(name, timeout)
 
 
+async def send_message(workflow_id: str, name: str, payload: Any) -> None:
+    """Send a message from inside a `@workflow` to another running workflow.
+
+    The receiving workflow gets it from `wait_for_message(name)`, with `sender_kind`
+    `"workflow"` and this workflow's id as `sender_id`. Use it, for example, for a child
+    started with `start_child` to report back to its parent (see `parent_workflow_id`), or to
+    reply to the `sender_id` of a message from another workflow.
+
+    The message is delivered by the workflow orchestrator directly, not through the Chalk API
+    server, and is recorded in this workflow's history, so the workflow lineage view shows it
+    as a message edge from this workflow to `workflow_id`. Because it does not pass through
+    the API server, the sender is self-declared rather than authenticated as it is for
+    `ChalkClient.send_workflow_message`; see `WorkflowMessage`.
+
+    Parameters
+    ----------
+    workflow_id
+        The id of the running workflow to message.
+    name
+        The message name the receiver waits for.
+    payload
+        The message body. Must be JSON-serializable.
+
+    Examples
+    --------
+    >>> from chalk.workflows import send_message, wait_for_message, workflow
+    >>> @workflow
+    ... async def echo() -> None:
+    ...     ping = await wait_for_message("ping")
+    ...     await send_message(ping.sender_id, "pong", ping.payload)
+    """
+    orchestrator = current_orchestrator()
+    if orchestrator is None:
+        raise RuntimeError(
+            "chalk.workflows.send_message can only be called inside a @workflow; "
+            + "use ChalkClient.send_workflow_message to message a workflow from outside one"
+        )
+    await orchestrator.send_message(workflow_id, name, payload)
+
+
 @contextlib.contextmanager
 def local_messages(messages: Sequence[tuple[str, Any]]) -> Iterator[None]:
     """Queue messages for workflows invoked directly in this process, such as in unit tests.

{chalkpy-2.166.1 → chalkpy-2.167.0}/chalk/workflows/_temporal/runtime.py

@@ -12,8 +12,9 @@ from temporalio import workflow as temporal_workflow
 from temporalio.client import Client, WorkflowExecutionStatus, WorkflowHandle
 from temporalio.common import RetryPolicy
 from temporalio.worker import Worker
+from temporalio.workflow import ParentClosePolicy
 
-from chalk.workflows._context import TaskHandle, current_orchestrator_var
+from chalk.workflows._context import ChildWorkflowHandle, TaskHandle, current_orchestrator_var
 from chalk.workflows._definitions import TASK_REGISTRY, WORKFLOW_REGISTRY, TaskDefinition, WorkflowDefinition
 from chalk.workflows._messages import (
     WORKFLOW_MESSAGE_SIGNAL,
@@ -70,6 +71,23 @@ def _start_task_activity(
     )
 
 
+# A child is cancelled, not terminated, when its parent closes first, so its `finally` blocks
+# can still release what it holds (e.g. a sandbox). Abandoning it would leave it running with
+# no one to await or message it.
+_CHILD_PARENT_CLOSE_POLICY = ParentClosePolicy.REQUEST_CANCEL
+
+
+def _workflow_message_envelope(name: str, payload: Any) -> dict[str, Any]:
+    # The envelope go-api-server's SendWorkflowMessage writes, but with a sender the sending
+    # workflow declares itself: workflow-to-workflow signals do not pass through the API server.
+    return {
+        "name": name,
+        "payload": payload,
+        "sender": {"kind": "workflow", "id": temporal_workflow.info().workflow_id},
+        "sent_at": temporal_workflow.now().isoformat(),
+    }
+
+
 class _TemporalOrchestrator:
     """Routes task invocations made inside a compiled workflow to Temporal activities."""
 
@@ -95,6 +113,47 @@ class _TemporalOrchestrator:
                 raise WorkflowMessageTimeoutError(f"No {name!r} message arrived within {timeout}") from None
         return message_from_envelope(queue.popleft())
 
+    async def start_child(
+        self,
+        workflow: WorkflowDefinition[Any, Any] | str,
+        kwargs: Mapping[str, Any],
+        workflow_id: str | None,
+    ) -> ChildWorkflowHandle[Any]:
+        name = workflow if isinstance(workflow, str) else workflow.name
+        info = temporal_workflow.info()
+        handle = await temporal_workflow.start_child_workflow(
+            name,
+            dict(kwargs),
+            # uuid4 is replay-safe: it is seeded from the workflow's history.
+            id=(
+                workflow_id
+                if workflow_id is not None
+                else f"{info.workflow_id}.{name}.{temporal_workflow.uuid4().hex[:12]}"
+            ),
+            task_queue=info.task_queue,
+            retry_policy=_NO_WORKFLOW_RETRIES,
+            parent_close_policy=_CHILD_PARENT_CLOSE_POLICY,
+        )
+
+        async def send(message_name: str, payload: Any) -> None:
+            await handle.signal(WORKFLOW_MESSAGE_SIGNAL, _workflow_message_envelope(message_name, payload))
+
+        return ChildWorkflowHandle(handle.id, handle, send)
+
+    async def send_message(self, workflow_id: str, name: str, payload: Any) -> None:
+        # A signal sent by this workflow (not a client signal) is recorded in its history as
+        # SignalExternalWorkflowExecutionInitiated, which the lineage view draws as a message edge.
+        await temporal_workflow.get_external_workflow_handle(workflow_id).signal(
+            WORKFLOW_MESSAGE_SIGNAL, _workflow_message_envelope(name, payload)
+        )
+
+    def current_workflow_id(self) -> str:
+        return temporal_workflow.info().workflow_id
+
+    def parent_workflow_id(self) -> str | None:
+        parent = temporal_workflow.info().parent
+        return parent.workflow_id if parent is not None else None
+
     def _start(self, task: TaskDefinition[Any, Any], args: Sequence[Any], kwargs: Mapping[str, Any]) -> Any:
         if task.task_queue is None:
             return _start_task_activity(task, args, kwargs)

{chalkpy-2.166.1 → chalkpy-2.167.0}/chalkpy.egg-info/SOURCES.txt

@@ -1317,6 +1317,7 @@ chalk/utils/pydanticutil/__init__.py
 chalk/utils/pydanticutil/pydantic_compat.py
 chalk/utils/pydanticutil/sdk.py
 chalk/workflows/__init__.py
+chalk/workflows/_children.py
 chalk/workflows/_context.py
 chalk/workflows/_definitions.py
 chalk/workflows/_messages.py

{chalkpy-2.166.1 → chalkpy-2.167.0}/pyproject.toml

@@ -284,7 +284,7 @@ postgresql = [
 
 snowflake = [
     "snowflake-connector-python>=3.12.4,<5",
-    "snowflake-sqlalchemy>=1.5.0,<1.11",
+    "snowflake-sqlalchemy>=1.5.0,<1.12",
     # And the sql dependencies
     # [[[cog
     # import pathlib, tomli
@@ -535,7 +535,7 @@ all = [
     "redshift_connector>=2.0.909,<2.3",
     "s3fs>=2024.2.0",
     "snowflake-connector-python>=3.12.4,<5",
-    "snowflake-sqlalchemy>=1.5.0,<1.11",
+    "snowflake-sqlalchemy>=1.5.0,<1.12",
     "sqlalchemy-bigquery>=1.5.0,<1.12",
     "sqlalchemy-spanner<1.12.0",
     "sqlalchemy[asyncio]>=1.4.26,<2",

chalkpy-2.166.1/chalk/_version.py

@@ -1 +0,0 @@
-__version__ = "2.166.1"

chalkpy-2.166.1/chalk/workflows/__init__.py

@@ -1,24 +0,0 @@
-from chalk.workflows._context import TaskHandle
-from chalk.workflows._definitions import (
-    TASK_REGISTRY,
-    WORKFLOW_REGISTRY,
-    TaskDefinition,
-    WorkflowDefinition,
-    task,
-    workflow,
-)
-from chalk.workflows._messages import WorkflowMessage, WorkflowMessageTimeoutError, local_messages, wait_for_message
-
-__all__ = (
-    "TASK_REGISTRY",
-    "WORKFLOW_REGISTRY",
-    "TaskDefinition",
-    "TaskHandle",
-    "WorkflowDefinition",
-    "WorkflowMessage",
-    "WorkflowMessageTimeoutError",
-    "local_messages",
-    "task",
-    "wait_for_message",
-    "workflow",
-)