Add explicit kwargs to Celery.__init__, _task_from_fun, and Signature.apply_async

Restore explicit keyword arguments for better IDE autocomplete support:

- Celery.__init__: Add config kwargs (imports, broker_*, result_*, task_*, worker_*)
- Celery._task_from_fun: Add autoretry and task option kwargs
- Signature.apply_async: Add options kwargs (task_id, producer, link, countdown, etc.)

Use keyword-only syntax (*,) to satisfy stubtest while still providing
typed kwargs for IDE support.

Author: oliverhaas

celery-stubs/app/base.pyi

@@ -100,6 +100,44 @@ class Celery(Generic[_T_Global]):
         autofinalize: bool = True,
         namespace: str | None = None,
         strict_typing: bool = True,
+        *,
+        # Config kwargs that can be passed directly (captured by **kwargs at runtime)
+        imports: list[str] | tuple[str, ...] | None = ...,
+        broker_connection_retry: bool = ...,
+        broker_connection_max_retries: int = ...,
+        broker_channel_error_retry: bool = ...,
+        broker_login_method: str = ...,
+        broker_transport_options: dict[str, Any] = ...,
+        broker_connection_retry_on_startup: bool = ...,
+        broker_connection_timeout: float = ...,
+        result_backend_transport_options: dict[str, Any] | None = ...,
+        result_extended: bool = ...,
+        result_expires: datetime.timedelta = ...,
+        beat_schedule: dict[str, Any] | None = ...,
+        task_queues: list[kombu.Queue] | None = ...,
+        task_default_queue: str = ...,
+        task_default_exchange: str = ...,
+        task_default_exchange_type: str = ...,
+        task_default_routing_key: str = ...,
+        task_default_delivery_mode: str = ...,
+        task_create_missing_queues: bool = ...,
+        task_routes: dict[Any, Any] | Sequence[Any] = ...,
+        task_acks_late: bool = ...,
+        task_time_limit: int = ...,
+        task_soft_time_limit: int = ...,
+        task_track_started: bool = ...,
+        task_serializer: str = ...,
+        worker_prefetch_multiplier: int = ...,
+        worker_max_tasks_per_child: int = ...,
+        worker_concurrency: int = ...,
+        worker_max_memory_per_child: int = ...,
+        worker_disable_rate_limits: bool = ...,
+        worker_cancel_long_running_tasks_on_connection_loss: bool = ...,
+        worker_hijack_root_logger: bool = ...,
+        worker_log_format: str = ...,
+        worker_task_log_format: str = ...,
+        worker_redirect_stdouts: bool = ...,
+        worker_redirect_stdouts_level: str = ...,
         **kwargs: Any,
     ) -> None: ...
     def _task_from_fun(
@@ -108,10 +146,44 @@ class Celery(Generic[_T_Global]):
         name: str | None = None,
         base: type[_T_Global] | None = None,
         bind: bool = False,
+        # pydantic options (new in celery 5.4+)
         pydantic: bool = False,
         pydantic_strict: bool = False,
         pydantic_context: dict[str, Any] | None = None,
         pydantic_dump_kwargs: dict[str, Any] | None = None,
+        *,
+        # autoretry options (captured by **options at runtime)
+        autoretry_for: Sequence[type[BaseException]] = ...,
+        dont_autoretry_for: Sequence[type[BaseException]] = ...,
+        retry_kwargs: dict[str, Any] = ...,
+        retry_backoff: bool | int = ...,
+        retry_backoff_max: int = ...,
+        retry_jitter: bool = ...,
+        # task options
+        typing: bool = ...,
+        max_retries: int | None = ...,
+        default_retry_delay: int = ...,
+        rate_limit: str | None = ...,
+        ignore_result: bool = ...,
+        trail: bool = ...,
+        send_events: bool = ...,
+        store_errors_even_if_ignored: bool = ...,
+        serializer: str = ...,
+        time_limit: int | None = ...,
+        soft_time_limit: int | None = ...,
+        autoregister: bool = ...,
+        track_started: bool = ...,
+        acks_late: bool = ...,
+        acks_on_failure_or_timeout: bool = ...,
+        reject_on_worker_lost: bool = ...,
+        throws: tuple[type[Exception], ...] = ...,
+        expires: float | datetime.datetime | None = ...,
+        priority: int | None = ...,
+        resultrepr_maxsize: int = ...,
+        request_stack: _LocalStack[Context] = ...,
+        abstract: bool = ...,
+        after_return: Callable[..., Any] = ...,
+        on_retry: Callable[..., Any] = ...,
         **options: Any,
     ) -> _T_Global: ...
     def on_init(self) -> None: ...

celery-stubs/canvas.pyi

@@ -88,6 +88,28 @@ class Signature(dict[str, Any], Generic[_R_co]):
         args: tuple[Any, ...] | None = ...,
         kwargs: dict[str, Any] | None = ...,
         route_name: str | None = ...,
+        *,
+        # options (captured by **options at runtime)
+        task_id: str | None = ...,
+        producer: kombu.Producer | None = ...,
+        link: Signature[Any] | list[Signature[Any]] | None = ...,
+        link_error: Signature[Any] | list[Signature[Any]] | None = ...,
+        shadow: str | None = ...,
+        # apply_async options
+        countdown: float = ...,
+        eta: datetime | None = ...,
+        expires: float | datetime = ...,
+        retry: bool = ...,
+        retry_policy: Mapping[str, Any] = ...,
+        queue: str | kombu.Queue = ...,
+        exchange: str | kombu.Exchange = ...,
+        routing_key: str = ...,
+        priority: int = ...,
+        serializer: str = ...,
+        compression: str = ...,
+        add_to_parent: bool = ...,
+        publisher: kombu.Producer = ...,
+        headers: dict[str, str] = ...,
         **options: Any,
     ) -> celery.result.AsyncResult[_R_co]: ...
     def clone(