From 1b1a35e20662fd8a503509b86b37aeed940d174e Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Fri, 8 May 2026 16:30:12 +0200 Subject: [PATCH 1/4] [pika] Update to 1.4.* --- stubs/pika/@tests/stubtest_allowlist.txt | 8 ++ stubs/pika/METADATA.toml | 2 +- stubs/pika/pika/__init__.pyi | 14 ++++ stubs/pika/pika/adapters/__init__.pyi | 3 + .../pika/pika/adapters/asyncio_connection.pyi | 58 ++++++++----- stubs/pika/pika/adapters/base_connection.pyi | 12 +-- .../pika/adapters/blocking_connection.pyi | 84 ++++++++++++------- .../pika/pika/adapters/select_connection.pyi | 18 +++- .../pika/pika/adapters/twisted_connection.pyi | 31 ++++--- stubs/pika/pika/amqp_object.pyi | 4 +- stubs/pika/pika/callback.pyi | 20 ++--- stubs/pika/pika/compat.pyi | 37 +++----- stubs/pika/pika/connection.pyi | 3 +- stubs/pika/pika/diagnostic_utils.pyi | 4 +- 14 files changed, 183 insertions(+), 115 deletions(-) diff --git a/stubs/pika/@tests/stubtest_allowlist.txt b/stubs/pika/@tests/stubtest_allowlist.txt index 36bfaf0983d5..30b2bf8aeb3c 100644 --- a/stubs/pika/@tests/stubtest_allowlist.txt +++ b/stubs/pika/@tests/stubtest_allowlist.txt @@ -1,6 +1,14 @@ +# Behind a TYPE_CHECKING guard at runtime. +pika.adapters.select_connection.SELECT_ERROR_T +pika.adapters.select_connection.POLLER_PARAMS + # The implementation has defaults for the arguments that would make the # created instances unusable, so we require the arguments in the stub. pika.spec.Queue.DeclareOk.__init__ +# Type hackary that is unnecessary in the stubs. +pika.connection.ConnectionParameters.DefaultT +pika.connection.ConnectionParameters.T + # Arguments have a sentinel default, which is not reflected in the stubs. pika.connection.ConnectionParameters.__init__ diff --git a/stubs/pika/METADATA.toml b/stubs/pika/METADATA.toml index a8d7d10908ab..d1f0f47d68cd 100644 --- a/stubs/pika/METADATA.toml +++ b/stubs/pika/METADATA.toml @@ -1,4 +1,4 @@ -version = "1.3.*" +version = "1.4.*" upstream-repository = "https://github.com/pika/pika" stub-distribution = "types-pika-ts" # https://github.com/python/typeshed/issues/9246 extra-description = """\ diff --git a/stubs/pika/pika/__init__.pyi b/stubs/pika/pika/__init__.pyi index 75e955d3b14f..17e07499aa60 100644 --- a/stubs/pika/pika/__init__.pyi +++ b/stubs/pika/pika/__init__.pyi @@ -13,3 +13,17 @@ from pika.delivery_mode import DeliveryMode as DeliveryMode from pika.spec import BasicProperties as BasicProperties __version__: Final[str] + +__all__ = [ + "adapters", + "AMQPConnectionWorkflow", + "BaseConnection", + "BasicProperties", + "BlockingConnection", + "ConnectionParameters", + "DeliveryMode", + "PlainCredentials", + "SelectConnection", + "SSLOptions", + "URLParameters", +] diff --git a/stubs/pika/pika/adapters/__init__.pyi b/stubs/pika/pika/adapters/__init__.pyi index 218d5aae586b..803376324d51 100644 --- a/stubs/pika/pika/adapters/__init__.pyi +++ b/stubs/pika/pika/adapters/__init__.pyi @@ -1,3 +1,6 @@ +from pika.adapters.asyncio_connection import AsyncioConnection as AsyncioConnection from pika.adapters.base_connection import BaseConnection as BaseConnection from pika.adapters.blocking_connection import BlockingConnection as BlockingConnection from pika.adapters.select_connection import IOLoop as IOLoop, SelectConnection as SelectConnection + +__all__ = ["AsyncioConnection", "BaseConnection", "BlockingConnection", "SelectConnection", "IOLoop"] diff --git a/stubs/pika/pika/adapters/asyncio_connection.pyi b/stubs/pika/pika/adapters/asyncio_connection.pyi index 802b06d80197..3665ddc1a4f4 100644 --- a/stubs/pika/pika/adapters/asyncio_connection.pyi +++ b/stubs/pika/pika/adapters/asyncio_connection.pyi @@ -1,11 +1,14 @@ -from asyncio import AbstractEventLoop -from collections.abc import Callable +from _typeshed import Incomplete +from asyncio import AbstractEventLoop, Future, Handle +from collections.abc import Callable, Sequence from logging import Logger from typing_extensions import Self -from ..connection import Parameters +from ..connection import Connection, Parameters from .base_connection import BaseConnection -from .utils import connection_workflow, io_services_utils, nbio_interface +from .utils import io_services_utils +from .utils.connection_workflow import AbstractAMQPConnectionWorkflow, AMQPConnectorException +from .utils.nbio_interface import AbstractFileDescriptorServices, AbstractIOReference, AbstractIOServices, AbstractTimerReference LOGGER: Logger @@ -22,35 +25,44 @@ class AsyncioConnection(BaseConnection): @classmethod def create_connection( cls, - connection_configs, - on_done, + connection_configs: Sequence[Parameters], + on_done: Callable[[Connection | AMQPConnectorException], object], custom_ioloop: AbstractEventLoop | None = None, - workflow: connection_workflow.AbstractAMQPConnectionWorkflow | None = None, - ): ... + workflow: AbstractAMQPConnectionWorkflow | None = None, + ) -> AbstractAMQPConnectionWorkflow: ... class _AsyncioIOServicesAdapter( io_services_utils.SocketConnectionMixin, io_services_utils.StreamingConnectionMixin, - nbio_interface.AbstractIOServices, - nbio_interface.AbstractFileDescriptorServices, + AbstractIOServices, + AbstractFileDescriptorServices, ): def __init__(self, loop: AbstractEventLoop | None = None) -> None: ... - def get_native_ioloop(self): ... + def get_native_ioloop(self) -> AbstractEventLoop: ... def close(self) -> None: ... def run(self) -> None: ... def stop(self) -> None: ... - def add_callback_threadsafe(self, callback) -> None: ... - def call_later(self, delay, callback): ... - def getaddrinfo(self, host, port, on_done, family: int = 0, socktype: int = 0, proto: int = 0, flags: int = 0): ... - def set_reader(self, fd, on_readable) -> None: ... - def remove_reader(self, fd): ... - def set_writer(self, fd, on_writable) -> None: ... - def remove_writer(self, fd): ... + def add_callback_threadsafe(self, callback: Callable[[], object]) -> None: ... + def call_later(self, delay: float, callback: Callable[[], object]) -> _TimerHandle: ... + def getaddrinfo( + self, + host: str, + port: int, + on_done: Callable[..., object], + family: int = 0, + socktype: int = 0, + proto: int = 0, + flags: int = 0, + ) -> AbstractIOReference: ... + def set_reader(self, fd: int, on_readable: Callable[[], object]) -> None: ... + def remove_reader(self, fd: int) -> bool: ... + def set_writer(self, fd: int, on_writable: Callable[[], object]) -> None: ... + def remove_writer(self, fd: int) -> bool: ... -class _TimerHandle(nbio_interface.AbstractTimerReference): - def __init__(self, handle) -> None: ... +class _TimerHandle(AbstractTimerReference): + def __init__(self, handle: Handle) -> None: ... def cancel(self) -> None: ... -class _AsyncioIOReference(nbio_interface.AbstractIOReference): - def __init__(self, future, on_done) -> None: ... - def cancel(self): ... +class _AsyncioIOReference(AbstractIOReference): + def __init__(self, future: Future[Incomplete], on_done: Callable[[BaseConnection | BaseException], object]) -> None: ... + def cancel(self) -> bool: ... diff --git a/stubs/pika/pika/adapters/base_connection.pyi b/stubs/pika/pika/adapters/base_connection.pyi index b8fb59831335..71468c334ed2 100644 --- a/stubs/pika/pika/adapters/base_connection.pyi +++ b/stubs/pika/pika/adapters/base_connection.pyi @@ -4,20 +4,20 @@ from collections.abc import Callable from logging import Logger from typing_extensions import Self -from ..adapters.utils import nbio_interface -from ..connection import Connection +from ..adapters.utils.nbio_interface import AbstractIOServices, AbstractStreamProtocol +from ..connection import Connection, Parameters LOGGER: Logger class BaseConnection(Connection, metaclass=abc.ABCMeta): def __init__( self, - parameters, + parameters: Parameters | None, on_open_callback: Callable[[Self], object] | None, on_open_error_callback: Callable[[Self, BaseException], object] | None, on_close_callback: Callable[[Self, BaseException], object] | None, - nbio, - internal_connection_workflow: bool, + nbio: AbstractIOServices, + internal_connection_workflow: bool = True, ) -> None: ... @classmethod @abc.abstractmethod @@ -25,7 +25,7 @@ class BaseConnection(Connection, metaclass=abc.ABCMeta): @property def ioloop(self): ... -class _StreamingProtocolShim(nbio_interface.AbstractStreamProtocol): +class _StreamingProtocolShim(AbstractStreamProtocol): connection_made: Incomplete connection_lost: Incomplete eof_received: Incomplete diff --git a/stubs/pika/pika/adapters/blocking_connection.pyi b/stubs/pika/pika/adapters/blocking_connection.pyi index 48c9ad9316a1..69506ad7aafe 100644 --- a/stubs/pika/pika/adapters/blocking_connection.pyi +++ b/stubs/pika/pika/adapters/blocking_connection.pyi @@ -1,14 +1,16 @@ from _typeshed import Incomplete, Unused -from collections.abc import Generator, Sequence +from collections.abc import Callable, Generator, Sequence from logging import Logger from types import TracebackType -from typing import NamedTuple +from typing import Any, NamedTuple, TypeVar from typing_extensions import Self from ..connection import Parameters -from ..data import _ArgumentMapping from ..exchange_type import ExchangeType -from ..spec import BasicProperties +from ..frame import Method +from ..spec import Basic, BasicProperties, Connection, Exchange, Queue, Tx + +T = TypeVar("T", bound=Connection.Blocked | Connection.Unblocked) LOGGER: Logger @@ -189,19 +191,33 @@ class BlockingChannel: def add_on_cancel_callback(self, callback) -> None: ... def add_on_return_callback(self, callback): ... def basic_consume( - self, queue, on_message_callback, auto_ack: bool = False, exclusive: bool = False, consumer_tag=None, arguments=None - ): ... - def basic_cancel(self, consumer_tag): ... + self, + queue: str, + on_message_callback: Callable[[BlockingChannel, Basic.Deliver, BasicProperties, bytes], object], + auto_ack: bool = False, + exclusive: bool = False, + consumer_tag: str | None = None, + arguments: dict[str, Any] | None = None, + ) -> str: ... + def basic_cancel(self, consumer_tag: str) -> Sequence[tuple[Basic.Deliver, BasicProperties, bytes]]: ... def start_consuming(self) -> None: ... - def stop_consuming(self, consumer_tag=None) -> None: ... + def stop_consuming(self, consumer_tag: str | None = None) -> None: ... def consume( - self, queue, auto_ack: bool = False, exclusive: bool = False, arguments=None, inactivity_timeout=None - ) -> Generator[Incomplete]: ... - def get_waiting_message_count(self): ... - def cancel(self): ... + self, + queue: str, + auto_ack: bool = False, + exclusive: bool = False, + arguments: dict[str, Any] | None = None, + inactivity_timeout: float | None = None, + consumer_tag: str | None = None, + ) -> Generator[tuple[Basic.Deliver | None, BasicProperties | None, bytes | None]]: ... + def get_waiting_message_count(self) -> int: ... + def cancel(self) -> int: ... def basic_ack(self, delivery_tag: int = 0, multiple: bool = False) -> None: ... def basic_nack(self, delivery_tag: int = 0, multiple: bool = False, requeue: bool = True) -> None: ... - def basic_get(self, queue, auto_ack: bool = False): ... + def basic_get( + self, queue: str, auto_ack: bool = False + ) -> tuple[Basic.GetOk | None, BasicProperties | None, bytes | None]: ... def basic_publish( self, exchange: str, @@ -222,24 +238,36 @@ class BlockingChannel: durable: bool = False, auto_delete: bool = False, internal: bool = False, - arguments: _ArgumentMapping | None = None, - ): ... - def exchange_delete(self, exchange: str | None = None, if_unused: bool = False): ... - def exchange_bind(self, destination, source, routing_key: str = "", arguments=None): ... - def exchange_unbind(self, destination=None, source=None, routing_key: str = "", arguments=None): ... + arguments: dict[str, Any] | None = None, + ) -> None: ... + def exchange_delete(self, exchange: str | None = None, if_unused: bool = False) -> Method[Exchange.DeleteOk]: ... + def exchange_bind( + self, destination: str, source: str, routing_key: str = "", arguments: dict[str, Any] | None = None + ) -> Method[Exchange.BindOk]: ... + def exchange_unbind( + self, + destination: str | None = None, + source: str | None = None, + routing_key: str = "", + arguments: dict[str, Any] | None = None, + ) -> Method[Exchange.UnbindOk]: ... def queue_declare( self, - queue, + queue: str, passive: bool = False, durable: bool = False, exclusive: bool = False, auto_delete: bool = False, - arguments=None, - ): ... - def queue_delete(self, queue, if_unused: bool = False, if_empty: bool = False): ... - def queue_purge(self, queue): ... - def queue_bind(self, queue, exchange, routing_key=None, arguments=None): ... - def queue_unbind(self, queue, exchange=None, routing_key=None, arguments=None): ... - def tx_select(self): ... - def tx_commit(self): ... - def tx_rollback(self): ... + arguments: dict[str, Any] | None = None, + ) -> Method[Queue.DeclareOk]: ... + def queue_delete(self, queue: str, if_unused: bool = False, if_empty: bool = False) -> Method[Queue.DeleteOk]: ... + def queue_purge(self, queue: str) -> Method[Queue.PurgeOk]: ... + def queue_bind( + self, queue: str, exchange: str, routing_key: str | None = None, arguments: dict[str, Any] | None = None + ) -> Method[Queue.BindOk]: ... + def queue_unbind( + self, queue: str, exchange: str, routing_key: str | None = None, arguments: dict[str, Any] | None = None + ) -> Method[Queue.UnbindOk]: ... + def tx_select(self) -> Method[Tx.SelectOk]: ... + def tx_commit(self) -> Method[Tx.CommitOk]: ... + def tx_rollback(self) -> Method[Tx.RollbackOk]: ... diff --git a/stubs/pika/pika/adapters/select_connection.pyi b/stubs/pika/pika/adapters/select_connection.pyi index 8b3309410e20..86ef12c83e88 100644 --- a/stubs/pika/pika/adapters/select_connection.pyi +++ b/stubs/pika/pika/adapters/select_connection.pyi @@ -1,13 +1,22 @@ import abc +import select from _typeshed import Incomplete +from collections.abc import Callable from logging import Logger +from typing import Final, Literal, TypeAlias, TypedDict import pika.compat from pika.adapters.base_connection import BaseConnection from pika.adapters.utils.selector_ioloop_adapter import AbstractSelectorIOLoop +SELECT_ERROR_T: TypeAlias = OSError | InterruptedError | select.error + +class POLLER_PARAMS(TypedDict): + get_wait_seconds: Callable[[], float | None] + process_timeouts: Callable[[], object] + LOGGER: Logger -SELECT_TYPE: Incomplete +SELECT_TYPE: Literal["epoll", "kqueue", "poll"] | None class SelectConnection(BaseConnection): def __init__( @@ -43,9 +52,10 @@ class _Timer: def process_timeouts(self) -> None: ... class PollEvents: - READ: Incomplete - WRITE: Incomplete - ERROR: Incomplete + READ: Final[int] + WRITE: Final[int] + ERROR: Final[int] + HANGUP: Final[int] class IOLoop(AbstractSelectorIOLoop): READ: Incomplete diff --git a/stubs/pika/pika/adapters/twisted_connection.pyi b/stubs/pika/pika/adapters/twisted_connection.pyi index 78bb62565ef4..d36435905cbc 100644 --- a/stubs/pika/pika/adapters/twisted_connection.pyi +++ b/stubs/pika/pika/adapters/twisted_connection.pyi @@ -2,11 +2,11 @@ # We don't want to force it as a dependency but that means we also can't test it with type-checkers given the current setup. from _typeshed import Incomplete +from collections.abc import Callable from logging import Logger -from typing import Generic, NamedTuple, TypeVar +from typing import Any, Generic, NamedTuple, TypeVar -import pika.connection -from pika.adapters.utils import nbio_interface +from pika.adapters.utils.nbio_interface import AbstractTimerReference from twisted.internet.base import DelayedCall # type: ignore[import-not-found] # pyright: ignore[reportMissingImports] from twisted.internet.defer import ( # type: ignore[import-not-found] # pyright: ignore[reportMissingImports] Deferred, @@ -16,6 +16,8 @@ from twisted.internet.interfaces import ITransport # type: ignore[import-not-fo from twisted.internet.protocol import Protocol # type: ignore[import-not-found] # pyright: ignore[reportMissingImports] from twisted.python.failure import Failure # type: ignore[import-not-found] # pyright: ignore[reportMissingImports] +from ..connection import Connection, Parameters + _T = TypeVar("_T") LOGGER: Logger @@ -93,13 +95,9 @@ class TwistedChannel: self, exchange: Incomplete | None = ..., if_unused: bool = ... ) -> Deferred[Incomplete | Failure | BaseException | None]: ... def exchange_unbind( - self, - destination: Incomplete | None = ..., - source: Incomplete | None = ..., - routing_key: str = ..., - arguments: Incomplete | None = ..., + self, destination: str, source: str, routing_key: str = "", arguments: dict[str, Any] | None = None ) -> Deferred[Incomplete | Failure | BaseException | None]: ... - def flow(self, active) -> Deferred[Incomplete | Failure | BaseException | None]: ... + def flow(self, active: bool = True) -> Deferred[Incomplete | Failure | BaseException | None]: ... def open(self): ... def queue_bind( self, queue, exchange, routing_key: Incomplete | None = ..., arguments: Incomplete | None = ... @@ -118,14 +116,21 @@ class TwistedChannel: ) -> Deferred[Incomplete | Failure | BaseException | None]: ... def queue_purge(self, queue) -> Deferred[Incomplete | Failure | BaseException | None]: ... def queue_unbind( - self, queue, exchange: Incomplete | None = ..., routing_key: Incomplete | None = ..., arguments: Incomplete | None = ... + self, queue: str, exchange: str | None, routing_key: str | None = None, arguments: dict[str, Any] | None = None ) -> Deferred[Incomplete | Failure | BaseException | None]: ... def tx_commit(self) -> Deferred[Incomplete | Failure | BaseException | None]: ... def tx_rollback(self) -> Deferred[Incomplete | Failure | BaseException | None]: ... def tx_select(self) -> Deferred[Incomplete | Failure | BaseException | None]: ... -class _TwistedConnectionAdapter(pika.connection.Connection): - def __init__(self, parameters, on_open_callback, on_open_error_callback, on_close_callback, custom_reactor) -> None: ... +class _TwistedConnectionAdapter(Connection): + def __init__( + self, + parameters: Parameters | None, + on_open_callback: Callable[[Connection], object] | None, + on_open_error_callback: Callable[[Connection, Exception], object] | None, + on_close_callback: Callable[[Connection, Exception], object] | None, + custom_reactor: Incomplete | None = None, + ) -> None: ... def connection_made(self, transport: ITransport) -> None: ... def connection_lost(self, error: Exception) -> None: ... def data_received(self, data) -> None: ... @@ -145,6 +150,6 @@ class TwistedProtocolConnection(Protocol): # pyright: ignore[reportUntypedBaseC def makeConnection(self, transport: ITransport) -> None: ... def connectionReady(self): ... -class _TimerHandle(nbio_interface.AbstractTimerReference): +class _TimerHandle(AbstractTimerReference): def __init__(self, handle: DelayedCall) -> None: ... def cancel(self) -> None: ... diff --git a/stubs/pika/pika/amqp_object.pyi b/stubs/pika/pika/amqp_object.pyi index 7236b7a080f2..9f412173e43a 100644 --- a/stubs/pika/pika/amqp_object.pyi +++ b/stubs/pika/pika/amqp_object.pyi @@ -13,6 +13,8 @@ class Method(AMQPObject): @property def synchronous(self) -> bool: ... def get_properties(self) -> Properties: ... - def get_body(self) -> str: ... + def get_body(self) -> bytes: ... + def encode(self) -> list[bytes]: ... + def decode(self, encoded: bytes, offset: int = 0) -> Method: ... class Properties(AMQPObject): ... diff --git a/stubs/pika/pika/callback.pyi b/stubs/pika/pika/callback.pyi index 5acaca3cb5d8..06c25f1c1dde 100644 --- a/stubs/pika/pika/callback.pyi +++ b/stubs/pika/pika/callback.pyi @@ -1,13 +1,15 @@ from _typeshed import Incomplete from collections.abc import Callable from logging import Logger -from typing import Literal +from typing import Literal, TypeAlias -from pika import amqp_object, frame +from .amqp_object import AMQPObject + +AMQPValue: TypeAlias = type[AMQPObject] | AMQPObject | int | str LOGGER: Logger -def name_or_value(value: amqp_object.AMQPObject | frame.Frame | int | str) -> str: ... +def name_or_value(value: AMQPValue) -> str: ... def sanitize_prefix(function): ... def check_for_prefix_and_key(function): ... @@ -22,7 +24,7 @@ class CallbackManager: def add( self, prefix: str | int, - key: str | object, + key: AMQPValue, callback: Callable[[Incomplete], Incomplete], one_shot: bool = True, only_caller: object | None = None, @@ -31,12 +33,8 @@ class CallbackManager: def clear(self) -> None: ... def cleanup(self, prefix: str | int) -> bool: ... def pending(self, prefix: str | int, key: str | object) -> int | None: ... - def process(self, prefix: str | int, key: str | object, caller, *args, **keywords) -> bool: ... + def process(self, prefix: str | int, key: AMQPValue, caller, *args, **keywords) -> bool: ... def remove( - self, - prefix: str | int, - key: str | object, - callback_value: Callable[[Incomplete], Incomplete] | None = None, - arguments=None, + self, prefix: str | int, key: AMQPValue, callback_value: Callable[[Incomplete], Incomplete] | None = None, arguments=None ) -> Literal[True]: ... - def remove_all(self, prefix: str | int, key: str | object) -> None: ... + def remove_all(self, prefix: str | int, key: AMQPValue) -> None: ... diff --git a/stubs/pika/pika/compat.pyi b/stubs/pika/pika/compat.pyi index 92494ec7f3f0..19237f6be186 100644 --- a/stubs/pika/pika/compat.pyi +++ b/stubs/pika/pika/compat.pyi @@ -1,19 +1,9 @@ +import socket +import sys from abc import ABCMeta -from collections.abc import ItemsView, Mapping, ValuesView -from io import StringIO as StringIO from re import Pattern -from typing import Any, Final, SupportsIndex, TypeGuard, TypeVar -from urllib.parse import parse_qs, quote, unquote, urlencode as urlencode, urlparse as urlparse +from typing import Final, SupportsIndex -_KT = TypeVar("_KT") -_VT_co = TypeVar("_VT_co", covariant=True) - -url_quote = quote -url_unquote = unquote -url_parse_qs = parse_qs - -PY2: Final = False -PY3: Final = True RE_NUM: Final[Pattern[str]] ON_LINUX: Final[bool] ON_OSX: Final[bool] @@ -23,26 +13,23 @@ class AbstractBase(metaclass=ABCMeta): ... SOCKET_ERROR = OSError SOL_TCP: Final[int] -basestring: Final[tuple[type[str]]] +HAVE_SIGNAL: Final[bool] str_or_bytes: Final[tuple[type[str], type[bytes]]] -xrange = range -unicode_type = str def time_now() -> float: ... -def dictkeys(dct: Mapping[_KT, Any]) -> list[_KT]: ... -def dictvalues(dct: Mapping[Any, _VT_co]) -> list[_VT_co]: ... -def dict_iteritems(dct: Mapping[_KT, _VT_co]) -> ItemsView[_KT, _VT_co]: ... -def dict_itervalues(dct: Mapping[Any, _VT_co]) -> ValuesView[_VT_co]: ... def byte(*args: SupportsIndex) -> bytes: ... class long(int): ... -def canonical_str(value: object) -> str: ... -def is_integer(value: object) -> TypeGuard[int]: ... def as_bytes(value: str | bytes) -> bytes: ... def to_digit(value: str) -> int: ... def get_linux_version(release_str: str) -> tuple[int, int, int]: ... -HAVE_SIGNAL: Final[bool] -EINTR_IS_EXPOSED: Final = False -LINUX_VERSION: tuple[int, int, int] | None +if sys.platform == "linux": + LINUX_VERSION: Final[tuple[int, int, int]] +else: + LINUX_VERSION: Final[None] + +def nonblocking_socketpair( + family: int = socket.AF_INET, socket_type: int = socket.SOCK_STREAM, proto: int = 0 +) -> tuple[socket.socket, socket.socket]: ... diff --git a/stubs/pika/pika/connection.pyi b/stubs/pika/pika/connection.pyi index c8725542f6d5..551bed550798 100644 --- a/stubs/pika/pika/connection.pyi +++ b/stubs/pika/pika/connection.pyi @@ -125,10 +125,11 @@ class Parameters: class ConnectionParameters(Parameters): __slots__ = () + def __init__( self, host: str = ..., - port: int | str = ..., + port: int = ..., virtual_host: str = ..., credentials: _Credentials = ..., channel_max: int = ..., diff --git a/stubs/pika/pika/diagnostic_utils.pyi b/stubs/pika/pika/diagnostic_utils.pyi index 7e05c48794cd..ff40cbd1d3cc 100644 --- a/stubs/pika/pika/diagnostic_utils.pyi +++ b/stubs/pika/pika/diagnostic_utils.pyi @@ -2,6 +2,6 @@ from collections.abc import Callable from logging import Logger from typing import Any, TypeVar -_F = TypeVar("_F", bound=Callable[..., Any]) +F = TypeVar("F", bound=Callable[..., Any]) # exists at runtime -def create_log_exception_decorator(logger: Logger) -> Callable[[_F], _F]: ... +def create_log_exception_decorator(logger: Logger) -> Callable[[F], F]: ... From 6de6af12131183e72e21c3e4dd7d47fc6c2ef392 Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Fri, 8 May 2026 16:35:12 +0200 Subject: [PATCH 2/4] Fix/silence ruff errors --- stubs/pika/pika/adapters/blocking_connection.pyi | 2 +- stubs/pika/pika/adapters/twisted_connection.pyi | 2 +- stubs/pika/pika/diagnostic_utils.pyi | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/stubs/pika/pika/adapters/blocking_connection.pyi b/stubs/pika/pika/adapters/blocking_connection.pyi index 69506ad7aafe..9aabeb7befa8 100644 --- a/stubs/pika/pika/adapters/blocking_connection.pyi +++ b/stubs/pika/pika/adapters/blocking_connection.pyi @@ -10,7 +10,7 @@ from ..exchange_type import ExchangeType from ..frame import Method from ..spec import Basic, BasicProperties, Connection, Exchange, Queue, Tx -T = TypeVar("T", bound=Connection.Blocked | Connection.Unblocked) +T = TypeVar("T", bound=Connection.Blocked | Connection.Unblocked) # noqa: Y001 LOGGER: Logger diff --git a/stubs/pika/pika/adapters/twisted_connection.pyi b/stubs/pika/pika/adapters/twisted_connection.pyi index d36435905cbc..9d8d90ef333e 100644 --- a/stubs/pika/pika/adapters/twisted_connection.pyi +++ b/stubs/pika/pika/adapters/twisted_connection.pyi @@ -129,7 +129,7 @@ class _TwistedConnectionAdapter(Connection): on_open_callback: Callable[[Connection], object] | None, on_open_error_callback: Callable[[Connection, Exception], object] | None, on_close_callback: Callable[[Connection, Exception], object] | None, - custom_reactor: Incomplete | None = None, + custom_reactor=None, ) -> None: ... def connection_made(self, transport: ITransport) -> None: ... def connection_lost(self, error: Exception) -> None: ... diff --git a/stubs/pika/pika/diagnostic_utils.pyi b/stubs/pika/pika/diagnostic_utils.pyi index ff40cbd1d3cc..0c46e0f8eb33 100644 --- a/stubs/pika/pika/diagnostic_utils.pyi +++ b/stubs/pika/pika/diagnostic_utils.pyi @@ -2,6 +2,6 @@ from collections.abc import Callable from logging import Logger from typing import Any, TypeVar -F = TypeVar("F", bound=Callable[..., Any]) # exists at runtime +F = TypeVar("F", bound=Callable[..., Any]) # noqa: Y001 def create_log_exception_decorator(logger: Logger) -> Callable[[F], F]: ... From 09fc52198b203b252e75e8c0036844c652dc68cd Mon Sep 17 00:00:00 2001 From: Sebastian Rittau Date: Sat, 9 May 2026 11:11:29 +0200 Subject: [PATCH 3/4] Fix callback types Co-authored-by: Jelle Zijlstra --- stubs/pika/pika/callback.pyi | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/stubs/pika/pika/callback.pyi b/stubs/pika/pika/callback.pyi index 06c25f1c1dde..2f06ec52308b 100644 --- a/stubs/pika/pika/callback.pyi +++ b/stubs/pika/pika/callback.pyi @@ -25,7 +25,8 @@ class CallbackManager: self, prefix: str | int, key: AMQPValue, - callback: Callable[[Incomplete], Incomplete], + # Parameter type must match arguments passed to process() + callback: Callable[..., object], one_shot: bool = True, only_caller: object | None = None, arguments=None, @@ -35,6 +36,6 @@ class CallbackManager: def pending(self, prefix: str | int, key: str | object) -> int | None: ... def process(self, prefix: str | int, key: AMQPValue, caller, *args, **keywords) -> bool: ... def remove( - self, prefix: str | int, key: AMQPValue, callback_value: Callable[[Incomplete], Incomplete] | None = None, arguments=None + self, prefix: str | int, key: AMQPValue, callback_value: Callable[..., object] | None = None, arguments=None ) -> Literal[True]: ... def remove_all(self, prefix: str | int, key: AMQPValue) -> None: ... From 391c088cd63bfc5b5cdb5749303eee2fdd1ada18 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 9 May 2026 09:13:27 +0000 Subject: [PATCH 4/4] [pre-commit.ci] auto fixes from pre-commit.com hooks --- stubs/pika/pika/callback.pyi | 1 - 1 file changed, 1 deletion(-) diff --git a/stubs/pika/pika/callback.pyi b/stubs/pika/pika/callback.pyi index 2f06ec52308b..c5fe764fafce 100644 --- a/stubs/pika/pika/callback.pyi +++ b/stubs/pika/pika/callback.pyi @@ -1,4 +1,3 @@ -from _typeshed import Incomplete from collections.abc import Callable from logging import Logger from typing import Literal, TypeAlias