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

Fechada
  • Algo errado?
#2,063 0 comentários 0 reações 1 responsável Ver no GitHub

Mantenedores costumam responder em até 1 dia

@VegetarianOrc já está trabalhando nisso.

Desde 2/11/2026.

  • #2065 de @VegetarianOrc — aberto

Avaliação

Esta issue ainda não foi avaliada.

Descrição

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.

Linguagem predominante
Python
Estrelas
1.2k
Forks
285
Merge médio
1d 23h
PRs com merge (30d)
89

Preparar o ambiente

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de temporalio/sdk-python

Todas as issues de temporalio/sdk-python

Issues semelhantes

Mais issues de Python

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.