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

Chiusa
  • Qualcosa non va?
#2,063 0 commenti 0 reazioni 1 assegnatario Vedi su GitHub

I maintainer di solito rispondono entro 1 giorno

@VegetarianOrc ci sta già lavorando.

Dal 2/11/2026.

  • #2065 di @VegetarianOrc — aperta

Valutazione

Questa issue non è ancora stata valutata.

Descrizione

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.

Lingua principale
Python
Stelle
1.2k
Fork
285
Merge medio
1g 23h
PR unite (30g)
89

Preparare l'ambiente

Come iniziare

  1. Leggi tutta la issue e poi la guida ai contributi del progetto.
  2. Commenta sulla issue per dire che te ne occupi tu — evita che due persone facciano lo stesso lavoro.
  3. Fai un fork del repository e lavora su un branch.
  4. Apri una pull request che faccia riferimento al numero della issue.

Altre issue di temporalio/sdk-python

Tutte le issue di temporalio/sdk-python

Issue simili

Altre issue su Python

Ricevi le nuove issue nella tua casella

Un breve riepilogo di issue GitHub adatte ai principianti.