Remove hard cap and honor configured retry intervals

.pubnub.yml

@@ -1,5 +1,5 @@
 name: python
-version: 10.6.2
+version: 10.6.3
 schema: 1
 scm: github.com/pubnub/python
 sdks:
@@ -18,7 +18,7 @@ sdks:
         distributions:
           - distribution-type: library
             distribution-repository: package
-            package-name: pubnub-10.6.2
+            package-name: pubnub-10.6.3
             location: https://pypi.org/project/pubnub/
             supported-platforms:
               supported-operating-systems:
@@ -94,8 +94,8 @@ sdks:
           -
             distribution-type: library
             distribution-repository: git release
-            package-name: pubnub-10.6.2
-            location: https://github.com/pubnub/python/releases/download/10.6.2/pubnub-10.6.2.tar.gz
+            package-name: pubnub-10.6.3
+            location: https://github.com/pubnub/python/releases/download/10.6.3/pubnub-10.6.3.tar.gz
             supported-platforms:
               supported-operating-systems:
                 Linux:
@@ -169,6 +169,15 @@ sdks:
                 license-url: https://github.com/encode/httpx/blob/master/LICENSE.md
                 is-required: Required
 changelog:
+  - date: 2026-04-20
+    version: 10.6.3
+    changes:
+      - type: bug
+        text: "The retry limit was silently clamped to the policy default, configured intervals were ignored by delay calculators, and the async reconnection loop never checked the limit or advanced its counter — fix all three and add a `maximum_reconnection_interval` config option."
+      - type: improvement
+        text: "`seqn` is not required by PubNub REST API, so remove `PublishSequenceManager`, all its subclasses, `MAX_SEQUENCE`, and `seqn` injection."
+      - type: improvement
+        text: "Cover `LinearDelay`, `ExponentialDelay`, `ReconnectionManager`, `ReconnectEffect`, and `HeartbeatDelayedEffect` with deterministic assertions for default, custom, and edge cases."
   - date: 2026-03-26
     version: 10.6.2
     changes:

CHANGELOG.md

@@ -1,3 +1,13 @@
+## 10.6.3
+April 20 2026
+
+#### Fixed
+- The retry limit was silently clamped to the policy default, configured intervals were ignored by delay calculators, and the async reconnection loop never checked the limit or advanced its counter — fix all three and add a `maximum_reconnection_interval` config option.
+
+#### Modified
+- `seqn` is not required by PubNub REST API, so remove `PublishSequenceManager`, all its subclasses, `MAX_SEQUENCE`, and `seqn` injection.
+- Cover `LinearDelay`, `ExponentialDelay`, `ReconnectionManager`, `ReconnectEffect`, and `HeartbeatDelayedEffect` with deterministic assertions for default, custom, and edge cases.
+
 ## 10.6.2
 March 26 2026
 

pubnub/event_engine/effects.py

@@ -154,6 +154,7 @@ def __init__(self, pubnub_instance, event_engine_instance,
         super().__init__(pubnub_instance, event_engine_instance, invocation)
         self.reconnection_policy = pubnub_instance.config.reconnect_policy
         self.interval = pubnub_instance.config.reconnection_interval
+        self.maximum_interval = pubnub_instance.config.maximum_reconnection_interval
 
         if self.reconnection_policy is PNReconnectionPolicy.EXPONENTIAL:
             self.max_retry_attempts = ExponentialDelay.MAX_RETRIES
@@ -177,11 +178,10 @@ def success(self, timetoken: str, region: Optional[int] = None, **kwargs):
 
     def calculate_reconnection_delay(self, attempts):
         if self.reconnection_policy is PNReconnectionPolicy.EXPONENTIAL:
-            delay = ExponentialDelay.calculate(attempts)
-        elif self.interval is None:
-            delay = LinearDelay.calculate(attempts)
+            delay = ExponentialDelay.calculate(
+                attempts, minimum_delay=self.interval, maximum_delay=self.maximum_interval)
         else:
-            delay = self.interval
+            delay = LinearDelay.calculate(attempts, delay=self.interval)
 
         return delay
 
@@ -367,6 +367,7 @@ def __init__(self, pubnub_instance, event_engine_instance,
         super().__init__(pubnub_instance, event_engine_instance, invocation)
         self.reconnection_policy = pubnub_instance.config.reconnect_policy
         self.interval = pubnub_instance.config.reconnection_interval
+        self.maximum_interval = pubnub_instance.config.maximum_reconnection_interval
 
         if self.reconnection_policy is PNReconnectionPolicy.EXPONENTIAL:
             self.max_retry_attempts = ExponentialDelay.MAX_RETRIES
@@ -387,11 +388,10 @@ def _should_give_up(self, attempts):
 
     def calculate_reconnection_delay(self, attempts):
         if self.reconnection_policy is PNReconnectionPolicy.EXPONENTIAL:
-            delay = ExponentialDelay.calculate(attempts)
-        elif self.interval is None:
-            delay = LinearDelay.calculate(attempts)
+            delay = ExponentialDelay.calculate(
+                attempts, minimum_delay=self.interval, maximum_delay=self.maximum_interval)
         else:
-            delay = self.interval
+            delay = LinearDelay.calculate(attempts, delay=self.interval)
 
         return delay
 

pubnub/managers.py

@@ -19,20 +19,6 @@
 logger = logging.getLogger("pubnub")
 
 
-class PublishSequenceManager:
-    def __init__(self, provided_max_sequence):
-        self.max_sequence = provided_max_sequence
-        self.next_sequence = 0
-
-    @abstractmethod
-    def get_next_sequence(self):
-        if self.max_sequence == self.next_sequence:
-            self.next_sequence = 1
-        else:
-            self.next_sequence += 1
-        return self.next_sequence
-
-
 class BasePathManager(object):
     MAX_SUBDOMAIN = 20
     DEFAULT_SUBDOMAIN = "pubsub"
@@ -64,12 +50,14 @@ def set_reconnection_listener(self, reconnection_callback):
     def _recalculate_interval(self):
         policy = self._pubnub.config.reconnect_policy
         interval = self._pubnub.config.reconnection_interval
-        if policy == PNReconnectionPolicy.LINEAR and interval is not None:
-            self._timer_interval = interval
-        elif policy == PNReconnectionPolicy.LINEAR:
-            self._timer_interval = LinearDelay.calculate(self._connection_errors)
+        if policy == PNReconnectionPolicy.LINEAR:
+            self._timer_interval = LinearDelay.calculate(self._connection_errors, delay=interval)
         else:
-            self._timer_interval = ExponentialDelay.calculate(self._connection_errors)
+            self._timer_interval = ExponentialDelay.calculate(
+                self._connection_errors,
+                minimum_delay=interval,
+                maximum_delay=self._pubnub.config.maximum_reconnection_interval
+            )
 
     def _retry_limit_reached(self):
         user_limit = self._pubnub.config.maximum_reconnection_retries
@@ -83,7 +71,7 @@ def _retry_limit_reached(self):
         policy_limit = (LinearDelay.MAX_RETRIES if policy == PNReconnectionPolicy.LINEAR
                         else ExponentialDelay.MAX_RETRIES)
         if user_limit is not None:
-            return self._connection_errors >= min(user_limit, policy_limit)
+            return self._connection_errors >= user_limit
         return self._connection_errors > policy_limit
 
     @abstractmethod
@@ -101,8 +89,9 @@ class LinearDelay:
     MAX_RETRIES = 10
 
     @classmethod
-    def calculate(cls, attempt: int):
-        return cls.INTERVAL + round(random.random(), 3)
+    def calculate(cls, attempt: int, delay=None):
+        base = delay if delay is not None else cls.INTERVAL
+        return base + round(random.random(), 3)
 
 
 class ExponentialDelay:
@@ -112,8 +101,10 @@ class ExponentialDelay:
     MAX_BACKOFF = 150
 
     @classmethod
-    def calculate(cls, attempt: int) -> int:
-        return min(cls.MAX_BACKOFF, cls.MIN_DELAY * (2 ** attempt)) + round(random.random(), 3)
+    def calculate(cls, attempt: int, minimum_delay=None, maximum_delay=None) -> float:
+        min_delay = minimum_delay if minimum_delay is not None else cls.MIN_DELAY
+        max_backoff = maximum_delay if maximum_delay is not None else cls.MAX_BACKOFF
+        return min(max_backoff, min_delay * (2 ** attempt)) + round(random.random(), 3)
 
 
 class StateManager:

pubnub/pnconfiguration.py

@@ -41,7 +41,8 @@ def __init__(self,
         self.heartbeat_notification_options = PNHeartbeatNotificationOptions.FAILURES
         self.reconnect_policy = PNReconnectionPolicy.EXPONENTIAL
         self.maximum_reconnection_retries = None  # -1 means unlimited/ 0 means no retries
-        self.reconnection_interval = None  # if None is left the default value from LinearDelay is used
+        self.reconnection_interval = None  # if None is left the default value from LinearDelay/ExponentialDelay is used
+        self.maximum_reconnection_interval = None  # if None the default value from ExponentialDelay is used
         self.daemon = False
         self.use_random_initialization_vector = True
         self.suppress_leave_events = False

pubnub/pubnub.py

@@ -8,7 +8,6 @@
     - PubNub: Main class for interacting with PubNub services
     - NativeSubscriptionManager: Handles channel subscriptions and message processing
     - NativeReconnectionManager: Manages network reconnection strategies
-    - NativePublishSequenceManager: Manages message sequence numbers for publishing
     - SubscribeListener: Helper class for handling subscription events
     - NonSubscribeListener: Helper class for handling non-subscription operations
 
@@ -40,7 +39,7 @@
     - The SDK uses multiple threads for different operations
     - SubscribeMessageWorker runs in a daemon thread
     - Heartbeat and reconnection timers run in separate threads
-    - Thread-safe implementations for sequence management and message queuing
+    - Thread-safe implementations for message queuing
 
 Error Handling:
     - Automatic retry mechanisms for failed operations
@@ -70,7 +69,7 @@
 from pubnub.endpoints.presence.leave import Leave
 from pubnub.endpoints.pubsub.subscribe import Subscribe
 from pubnub.enums import PNStatusCategory, PNHeartbeatNotificationOptions, PNOperationType, PNReconnectionPolicy
-from pubnub.managers import SubscriptionManager, PublishSequenceManager, ReconnectionManager
+from pubnub.managers import SubscriptionManager, ReconnectionManager
 from pubnub.models.consumer.common import PNStatus
 from pubnub.pnconfiguration import PNConfiguration
 from pubnub.pubnub_core import PubNubCore
@@ -124,8 +123,6 @@ def __init__(self, config: PNConfiguration, *, custom_request_handler: Type[Base
         if self.config.enable_subscribe:
             self._subscription_manager = NativeSubscriptionManager(self)
 
-        self._publish_sequence_manager = PublishSequenceManager(PubNubCore.MAX_SEQUENCE)
-
     def sdk_platform(self) -> str:
         """Get the SDK platform identifier.
 
@@ -205,12 +202,7 @@ def request_async(self, endpoint_name, endpoint_call_options, callback, cancella
         )
 
     def merge_in_params(self, options):
-        params_to_merge_in = {}
-
-        if options.operation_type == PNOperationType.PNPublishOperation:
-            params_to_merge_in['seqn'] = self._publish_sequence_manager.get_next_sequence()
-
-        options.merge_params_in(params_to_merge_in)
+        options.merge_params_in({})
 
     def stop(self):
         """Stop all subscriptions and clean up resources.
@@ -305,21 +297,6 @@ def stop_heartbeat_timer(self):
             self._timer.cancel()
 
 
-class NativePublishSequenceManager(PublishSequenceManager):
-    def __init__(self, provided_max_sequence):
-        super(NativePublishSequenceManager, self).__init__(provided_max_sequence)
-        self._lock = threading.Lock()
-
-    def get_next_sequence(self):
-        with self._lock:
-            if self.max_sequence == self.next_sequence:
-                self.next_sequence = 1
-            else:
-                self.next_sequence += 1
-
-            return self.next_sequence
-
-
 class NativeSubscriptionManager(SubscriptionManager):
     """Manages channel subscriptions and message processing.
 

pubnub/pubnub_asyncio.py

@@ -9,8 +9,6 @@
     - AsyncioSubscriptionManager: Async implementation of subscription handling
     - EventEngineSubscriptionManager: Event-driven subscription management
     - AsyncioReconnectionManager: Async network reconnection handling
-    - AsyncioPublishSequenceManager: Async message sequence management
-
 Features:
     - Asynchronous publish/subscribe messaging
     - Non-blocking network operations
@@ -72,7 +70,7 @@ async def main():
 from pubnub.request_handlers.base import BaseRequestHandler
 from pubnub.request_handlers.async_httpx import AsyncHttpxRequestHandler, WallClockTimeoutError
 from pubnub.workers import SubscribeMessageWorker
-from pubnub.managers import SubscriptionManager, PublishSequenceManager, ReconnectionManager
+from pubnub.managers import SubscriptionManager, ReconnectionManager
 from pubnub import utils
 from pubnub.enums import PNStatusCategory, PNHeartbeatNotificationOptions, PNOperationType, PNReconnectionPolicy
 from pubnub.callbacks import SubscribeCallback, ReconnectionCallback
@@ -153,8 +151,6 @@ def __init__(self, config, custom_event_loop=None, subscription_manager=None, *,
         if self.config.enable_subscribe:
             self._subscription_manager = subscription_manager(self)
 
-        self._publish_sequence_manager = AsyncioPublishSequenceManager(self.event_loop, PubNubCore.MAX_SEQUENCE)
-
     @property
     def _connector(self):
         return self._request_handler._connector
@@ -317,6 +313,13 @@ async def _register_heartbeat_timer(self):
         reconnection attempt based on the current state.
         """
         while True:
+            if self._retry_limit_reached():
+                logger.warning("Reconnection retry limit reached. Disconnecting.")
+                disconnect_status = PNStatus()
+                disconnect_status.category = PNStatusCategory.PNDisconnectedCategory
+                self._pubnub._subscription_manager._listener_manager.announce_status(disconnect_status)
+                break
+
             self._recalculate_interval()
             await asyncio.sleep(self._timer_interval)
             logger.debug("reconnect loop at: %s" % utils.datetime_now())
@@ -327,9 +330,8 @@ async def _register_heartbeat_timer(self):
                 self._callback.on_reconnect()
                 break
             except Exception:
-                if self._pubnub.config.reconnect_policy == PNReconnectionPolicy.EXPONENTIAL:
-                    logger.debug("reconnect interval increment at: %s" % utils.datetime_now())
-                    self._connection_errors += 1
+                logger.debug("reconnect interval increment at: %s" % utils.datetime_now())
+                self._connection_errors += 1
 
     def start_polling(self):
         """Start the reconnection polling process."""
@@ -345,22 +347,6 @@ def stop_polling(self):
             self._task.cancel()
 
 
-class AsyncioPublishSequenceManager(PublishSequenceManager):
-    def __init__(self, ioloop, provided_max_sequence):
-        super(AsyncioPublishSequenceManager, self).__init__(provided_max_sequence)
-        self._lock = asyncio.Lock()
-        self._event_loop = ioloop
-
-    async def get_next_sequence(self):
-        async with self._lock:
-            if self.max_sequence == self.next_sequence:
-                self.next_sequence = 1
-            else:
-                self.next_sequence += 1
-
-            return self.next_sequence
-
-
 class AsyncioSubscriptionManager(SubscriptionManager):
     """Manages channel subscriptions and message processing.
 

pubnub/pubnub_core.py

@@ -165,7 +165,6 @@ class PubNubCore:
     SDK_NAME: str = "PubNub-Python"
 
     TIMESTAMP_DIVIDER: int = 1000
-    MAX_SEQUENCE: int = 65535
 
     __metaclass__ = ABCMeta
     __crypto: Optional[PubNubCryptoModule] = None
@@ -190,7 +189,6 @@ def __init__(self, config: PNConfiguration) -> None:
         }
 
         self._subscription_manager = None
-        self._publish_sequence_manager = None
         self._base_path_manager = BasePathManager(config)
         self._token_manager = TokenManager()
         self._subscription_registry = PNSubscriptionRegistry(self)

pubnub/request_handlers/async_aiohttp.py

@@ -6,7 +6,7 @@
 
 from asyncio import Event
 from pubnub import utils
-from pubnub.enums import PNOperationType, PNStatusCategory
+from pubnub.enums import PNStatusCategory
 from pubnub.errors import PNERR_CLIENT_ERROR, PNERR_JSON_DECODING_FAILED, PNERR_SERVER_ERROR
 from pubnub.exceptions import PubNubException
 from pubnub.models.envelopes import AsyncioEnvelope
@@ -73,12 +73,7 @@ async def async_request(self, options_func, cancellation_event):
         create_status = options.create_status
         create_exception = options.create_exception
 
-        params_to_merge_in = {}
-
-        if options.operation_type == PNOperationType.PNPublishOperation:
-            params_to_merge_in['seqn'] = await self.pubnub._publish_sequence_manager.get_next_sequence()
-
-        options.merge_params_in(params_to_merge_in)
+        options.merge_params_in({})
 
         if options.use_base_path:
             url = utils.build_url(self.pubnub.config.scheme(), self.pubnub.base_origin, options.path,

pubnub/request_handlers/async_httpx.py

@@ -7,7 +7,7 @@
 import urllib
 
 from pubnub import utils
-from pubnub.enums import PNOperationType, PNStatusCategory
+from pubnub.enums import PNStatusCategory
 from pubnub.errors import PNERR_CLIENT_ERROR, PNERR_JSON_DECODING_FAILED, PNERR_SERVER_ERROR
 from pubnub.exceptions import PubNubException
 from pubnub.models.envelopes import AsyncioEnvelope
@@ -115,12 +115,7 @@ async def async_request(self, options_func, cancellation_event):
         create_status = options.create_status
         create_exception = options.create_exception
 
-        params_to_merge_in = {}
-
-        if options.operation_type == PNOperationType.PNPublishOperation:
-            params_to_merge_in['seqn'] = await self.pubnub._publish_sequence_manager.get_next_sequence()
-
-        options.merge_params_in(params_to_merge_in)
+        options.merge_params_in({})
 
         if options.use_base_path:
             url = utils.build_url(self.pubnub.config.scheme(), self.pubnub.base_origin, options.path,