[Bug] An activity method with an annotated `self` receives its arguments without their types

Geschlossen
  • Stimmt etwas nicht?
#2,063 0 Kommentare 0 Reaktionen 1 zugewiesene Person Auf GitHub ansehen

Maintainer antworten meist innerhalb von 1 Tag

@VegetarianOrc arbeitet bereits daran.

Seit 02.11.2026.

  • #2065 von @VegetarianOrc — offen

Bewertung

Dieses Issue wurde noch nicht bewertet.

Beschreibung

bug sdk-python

Package: temporalio 1.35.0, the latest release, and main (d488ff5).

What happens

An activity defined as a method, async def m(self, loc: Loc), receives loc as a Loc. The same method with an annotated receiver, such as self: Self in a module with from __future__ import annotations, receives loc as a plain dict.

_type_hints_from_func in temporalio/common.py skips the first parameter only when it is named self and is unannotated, or its annotation's text is typing.Self:

if (
    index == 0
    and value.name == "self"
    and (
        value.annotation is inspect.Parameter.empty
        or str(value.annotation) == "typing.Self"
    )
):
    continue

Under postponed annotations the text is Self, so arg_types gets an entry for the receiver. The Worker then has two types for one argument, and worker/_activity.py falls back to decoding without types (arg_types is not None and len(arg_types) != len(start.input)). The same holds for self: T with a TypeVar bound to the class, self: "Svc", and typing_extensions.Self on Python 3.10. It affects workflow.execute_activity_method and anything else that runs a registered bound method.

Reproduction

One file. It uses a local dev server (temporal CLI on PATH) and exits 1 when the method annotated self: Self receives a dict.

"""An activity method whose `self` is annotated receives its other arguments without their types.

Exits 1 when the method annotated `self: Self` receives a dict instead of a `Loc`.
"""

from __future__ import annotations

import asyncio
import dataclasses
import shutil
import sys
import uuid
from datetime import timedelta
from typing import Self

from temporalio import activity, workflow
from temporalio.testing import WorkflowEnvironment
from temporalio.worker import UnsandboxedWorkflowRunner, Worker


@dataclasses.dataclass
class Loc:
    city: str


class Svc:
    @activity.defn
    async def plain(self, loc: Loc) -> str:
        return type(loc).__name__

    @activity.defn
    async def annotated(self: Self, loc: Loc) -> str:
        return type(loc).__name__


@workflow.defn
class LocWorkflow:
    @workflow.run
    async def run(self) -> list[str]:
        timeout = timedelta(seconds=10)
        return [
            await workflow.execute_activity_method(
                Svc.plain, Loc("Rome"), start_to_close_timeout=timeout
            ),
            await workflow.execute_activity_method(
                Svc.annotated, Loc("Rome"), start_to_close_timeout=timeout
            ),
        ]


async def main() -> None:
    svc = Svc()
    async with await WorkflowEnvironment.start_local(
        dev_server_existing_path=shutil.which("temporal")
    ) as env:
        async with Worker(
            env.client,
            task_queue="tq",
            workflows=[LocWorkflow],
            activities=[svc.plain, svc.annotated],
            workflow_runner=UnsandboxedWorkflowRunner(),
        ):
            plain, annotated = await env.client.execute_workflow(
                LocWorkflow.run, id=str(uuid.uuid4()), task_queue="tq"
            )
    print(f"plain(self, loc: Loc) received: {plain}")
    print(f"annotated(self: Self, loc: Loc) received: {annotated}")
    sys.exit(0 if annotated == "Loc" else 1)


if __name__ == "__main__":
    asyncio.run(main())

Output:

Python 3.13.16 temporalio 1.35.0
$ python annotated_self.py
plain(self, loc: Loc) received: Loc
annotated(self: Self, loc: Loc) received: dict
exit 1

Expected

The Worker registers the method bound to an instance, which supplies self however it is annotated. So annotated should receive a Loc, as plain does.

Proposed fix

When the first parameter is named self, skip it whatever its annotation, as for an unannotated self.

Found while reviewing temporalio/ai-integrations#206, which builds agent tools from activity methods.

Vorherrschende Sprache
Python
Sterne
1.2k
Forks
285
Ø Merge
1 T. 23 Std.
Gemergte PRs (30 T.)
89

Entwicklungsumgebung

Erste Schritte

  1. Lesen Sie das ganze Issue und danach den Beitragsleitfaden des Projekts.
  2. Schreiben Sie ins Issue, dass Sie es übernehmen — das erspart doppelte Arbeit.
  3. Forken Sie das Repository und arbeiten Sie in einem Branch.
  4. Öffnen Sie einen Pull Request, der die Issue-Nummer nennt.

Mehr aus temporalio/sdk-python

Alle Issues in temporalio/sdk-python

Ähnliche Issues

Weitere Issues zu Python

Neue Issues direkt in Ihr Postfach

Eine kurze Übersicht über anfängerfreundliche GitHub-Issues.