Add limit and offset configuration options (#224)

feat(here-now): add `limit` and `offset` configuration options
    
Add `limit` (default `1000`) and `offset` parameters for `here_now` to fetch presence in portions.

fix(subscribe-heartbeat): fix duplicated channels issue

Fix issue because of which it was possible to add duplicated entries of `channels` and `groups` to the `subscribe`, `heartbeat`, and `leave` requests.

feat(push-notifications): push type changes

Add FCM push type support with GCM deprecation, and remove MPNS support due to its end of life.

---------

Co-authored-by: jguz-pubnub <jakub.guz@pubnub.com>

Author: parfeon

.github/workflows/run-tests.yml

@@ -87,7 +87,7 @@ jobs:
 
           pip3 install --user --ignore-installed -r requirements-dev.txt
           behave --junit tests/acceptance/pam
-          behave --junit tests/acceptance/encryption/cryptor-module.feature -t=~na=python -k
+          behave --junit tests/acceptance/encryption/cryptor-module.feature -t=~na=python
           behave --junit tests/acceptance/subscribe
       - name: Expose acceptance tests reports
         uses: actions/upload-artifact@v4

.pubnub.yml

@@ -1,5 +1,5 @@
 name: python
-version: 10.4.1
+version: 10.5.0
 schema: 1
 scm: github.com/pubnub/python
 sdks:
@@ -18,7 +18,7 @@ sdks:
         distributions:
           - distribution-type: library
             distribution-repository: package
-            package-name: pubnub-10.4.1
+            package-name: pubnub-10.5.0
             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.4.1
-            location: https://github.com/pubnub/python/releases/download/10.4.1/pubnub-10.4.1.tar.gz
+            package-name: pubnub-10.5.0
+            location: https://github.com/pubnub/python/releases/download/10.5.0/pubnub-10.5.0.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: 2025-12-02
+    version: 10.5.0
+    changes:
+      - type: feature
+        text: "Add `limit` (default `1000`) and `offset` parameters for `here_now` to fetch presence in portions."
+      - type: feature
+        text: "Add FCM push type support with GCM deprecation, and remove MPNS support due to its end of life."
+      - type: bug
+        text: "Fix issue because of which it was possible to add duplicated entries of `channels` and `groups` to the `subscribe`, `heartbeat`, and `leave` requests."
   - date: 2025-06-05
     version: 10.4.1
     changes:

CHANGELOG.md

@@ -1,3 +1,13 @@
+## 10.5.0
+December 02 2025
+
+#### Added
+- Add `limit` (default `1000`) and `offset` parameters for `here_now` to fetch presence in portions.
+- Add FCM push type support with GCM deprecation, and remove MPNS support due to its end of life.
+
+#### Fixed
+- Fix issue because of which it was possible to add duplicated entries of `channels` and `groups` to the `subscribe`, `heartbeat`, and `leave` requests.
+
 ## 10.4.1
 June 05 2025
 

pubnub/endpoints/presence/heartbeat.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Union, List
+from typing import Dict, Optional, Union, List, Set
 from pubnub import utils
 from pubnub.endpoints.endpoint import Endpoint
 from pubnub.enums import HttpMethod, PNOperationType
@@ -13,22 +13,22 @@ class Heartbeat(Endpoint):
     def __init__(self, pubnub, channels: Union[str, List[str]] = None, channel_groups: Union[str, List[str]] = None,
                  state: Optional[Dict[str, any]] = None):
         super(Heartbeat, self).__init__(pubnub)
-        self._channels = []
-        self._groups = []
+        self._channels: Set[str] = set()
+        self._groups: Set[str] = set()
         if channels:
-            utils.extend_list(self._channels, channels)
+            utils.update_set(self._channels, channels)
 
         if channel_groups:
-            utils.extend_list(self._groups, channel_groups)
+            utils.update_set(self._groups, channel_groups)
 
         self._state = state
 
     def channels(self, channels: Union[str, List[str]]) -> 'Heartbeat':
-        utils.extend_list(self._channels, channels)
+        utils.update_set(self._channels, channels)
         return self
 
     def channel_groups(self, channel_groups: Union[str, List[str]]) -> 'Heartbeat':
-        utils.extend_list(self._groups, channel_groups)
+        utils.update_set(self._groups, channel_groups)
         return self
 
     def state(self, state: Dict[str, any]) -> 'Heartbeat':
@@ -46,14 +46,14 @@ def validate_params(self):
             raise PubNubException(pn_error=PNERR_CHANNEL_OR_GROUP_MISSING)
 
     def build_path(self):
-        channels = utils.join_channels(self._channels)
+        channels = utils.join_channels(self._channels, True)
         return Heartbeat.HEARTBEAT_PATH % (self.pubnub.config.subscribe_key, channels)
 
     def custom_params(self):
         params = {'heartbeat': str(self.pubnub.config.presence_timeout)}
 
         if len(self._groups) > 0:
-            params['channel-group'] = utils.join_items(self._groups)
+            params['channel-group'] = utils.join_items(self._groups, True)
 
         if self._state is not None and len(self._state) > 0:
             params['state'] = utils.url_write(self._state)

pubnub/endpoints/presence/here_now.py

@@ -29,6 +29,8 @@ def __init__(self, pubnub, channels: Union[str, List[str]] = None, channel_group
 
         self._include_state = include_state
         self._include_uuids = include_uuids
+        self._offset = None
+        self._limit = 1000
 
     def channels(self, channels: Union[str, List[str]]) -> 'HereNow':
         utils.extend_list(self._channels, channels)
@@ -46,8 +48,16 @@ def include_uuids(self, include_uuids) -> 'HereNow':
         self._include_uuids = include_uuids
         return self
 
+    def limit(self, limit: int) -> 'HereNow':
+        self._limit = limit
+        return self
+
+    def offset(self, offset: int) -> 'HereNow':
+        self._offset = offset
+        return self
+
     def custom_params(self):
-        params = {}
+        params = {'limit': self._limit}
 
         if len(self._channel_groups) > 0:
             params['channel-group'] = utils.join_items_and_encode(self._channel_groups)
@@ -58,6 +68,9 @@ def custom_params(self):
         if not self._include_uuids:
             params['disable_uuids'] = "1"
 
+        if self._offset is not None:
+            params['offset'] = self._offset
+
         return params
 
     def build_path(self):

pubnub/endpoints/presence/leave.py

@@ -1,3 +1,5 @@
+from typing import Set, Union, List
+
 from pubnub import utils
 from pubnub.endpoints.endpoint import Endpoint
 from pubnub.errors import PNERR_CHANNEL_OR_GROUP_MISSING
@@ -11,38 +13,30 @@ class Leave(Endpoint):
 
     def __init__(self, pubnub):
         Endpoint.__init__(self, pubnub)
-        self._channels = []
-        self._groups = []
-
-    def channels(self, channels):
-        if isinstance(channels, (list, tuple)):
-            self._channels.extend(channels)
-        else:
-            self._channels.extend(utils.split_items(channels))
+        self._channels: Set[str] = set()
+        self._groups: Set[str] = set()
 
+    def channels(self, channels: Union[str, List[str]]) -> 'Leave':
+        utils.update_set(self._channels, channels)
         return self
 
-    def channel_groups(self, channel_groups):
-        if isinstance(channel_groups, (list, tuple)):
-            self._groups.extend(channel_groups)
-        else:
-            self._groups.extend(utils.split_items(channel_groups))
-
+    def channel_groups(self, channel_groups: Union[str, List[str]]) -> 'Leave':
+        utils.update_set(self._groups, channel_groups)
         return self
 
     def custom_params(self):
         params = {}
 
         if len(self._groups) > 0:
-            params['channel-group'] = utils.join_items(self._groups)
+            params['channel-group'] = utils.join_items(self._groups, True)
 
         if hasattr(self.pubnub, '_subscription_manager'):
             params.update(self.pubnub._subscription_manager.get_custom_params())
 
         return params
 
     def build_path(self):
-        return Leave.LEAVE_PATH % (self.pubnub.config.subscribe_key, utils.join_channels(self._channels))
+        return Leave.LEAVE_PATH % (self.pubnub.config.subscribe_key, utils.join_channels(self._channels, True))
 
     def http_method(self):
         return HttpMethod.GET
@@ -60,10 +54,10 @@ def is_auth_required(self):
         return True
 
     def affected_channels(self):
-        return self._channels
+        return sorted(self._channels)
 
     def affected_channels_groups(self):
-        return self._groups
+        return sorted(self._groups)
 
     def request_timeout(self):
         return self.pubnub.config.non_subscribe_request_timeout

pubnub/endpoints/pubsub/subscribe.py

@@ -1,4 +1,4 @@
-from typing import Optional, Union, List
+from typing import Optional, Union, List, Set
 from pubnub import utils
 from pubnub.endpoints.endpoint import Endpoint
 from pubnub.enums import HttpMethod, PNOperationType
@@ -25,12 +25,12 @@ def __init__(self, pubnub, channels: Union[str, List[str]] = None,
                  with_presence: Optional[str] = None, state: Optional[str] = None):
 
         super(Subscribe, self).__init__(pubnub)
-        self._channels = []
+        self._channels: Set[str] = set()
+        self._groups: Set[str] = set()
         if channels:
-            utils.extend_list(self._channels, channels)
-        self._groups = []
+            utils.update_set(self._channels, channels)
         if groups:
-            utils.extend_list(self._groups, groups)
+            utils.update_set(self._groups, groups)
 
         self._region = region
         self._filter_expression = filter_expression
@@ -39,11 +39,11 @@ def __init__(self, pubnub, channels: Union[str, List[str]] = None,
         self._state = state
 
     def channels(self, channels: Union[str, List[str]]) -> 'Subscribe':
-        utils.extend_list(self._channels, channels)
+        utils.update_set(self._channels, channels)
         return self
 
     def channel_groups(self, groups: Union[str, List[str]]) -> 'Subscribe':
-        utils.extend_list(self._groups, groups)
+        utils.update_set(self._groups, groups)
         return self
 
     def timetoken(self, timetoken) -> 'Subscribe':
@@ -72,14 +72,14 @@ def validate_params(self):
             raise PubNubException(pn_error=PNERR_CHANNEL_OR_GROUP_MISSING)
 
     def build_path(self):
-        channels = utils.join_channels(self._channels)
+        channels = utils.join_channels(self._channels, True)
         return Subscribe.SUBSCRIBE_PATH % (self.pubnub.config.subscribe_key, channels)
 
     def custom_params(self):
         params = {}
 
         if len(self._groups) > 0:
-            params['channel-group'] = utils.join_items_and_encode(self._groups)
+            params['channel-group'] = utils.join_items_and_encode(self._groups, True)
 
         if self._filter_expression is not None and len(self._filter_expression) > 0:
             params['filter-expr'] = utils.url_encode(self._filter_expression)
@@ -108,10 +108,10 @@ def is_auth_required(self):
         return True
 
     def affected_channels(self):
-        return self._channels
+        return sorted(self._channels)
 
     def affected_channels_groups(self):
-        return self._groups
+        return sorted(self._groups)
 
     def request_timeout(self):
         return self.pubnub.config.subscribe_request_timeout

pubnub/enums.py

@@ -143,9 +143,9 @@ class PNReconnectionPolicy(object):
 
 class PNPushType(object):
     APNS = 1
-    MPNS = 2
-    GCM = 3
+    GCM = 3  # Deprecated: Use FCM instead. GCM has been replaced by FCM (Firebase Cloud Messaging)
     APNS2 = 4
+    FCM = 5
 
 
 class PNResourceType(object):

pubnub/event_engine/effects.py

@@ -88,7 +88,7 @@ async def handshake_async(self, channels, groups, stop_event, timetoken: int = 0
             self.logger.warning(f'Handshake failed: {response.status.error_data.__dict__}')
             handshake_failure = events.HandshakeFailureEvent(response.status.error_data, 1, timetoken=timetoken)
             self.event_engine.trigger(handshake_failure)
-        else:
+        elif 't' in response.result:
             cursor = response.result['t']
             timetoken = timetoken if timetoken > 0 else cursor['t']
             region = cursor['r']
@@ -134,7 +134,7 @@ async def receive_messages_async(self, channels, groups, timetoken, region):
             self.logger.warning(f'Recieve messages failed: {response.status.error_data.__dict__}')
             recieve_failure = events.ReceiveFailureEvent(response.status.error_data, 1, timetoken=timetoken)
             self.event_engine.trigger(recieve_failure)
-        else:
+        elif 't' in response.result:
             cursor = response.result['t']
             timetoken = cursor['t']
             region = cursor['r']

pubnub/event_engine/models/states.py

@@ -568,7 +568,7 @@ def reconnect_failure(self, event: events.ReceiveReconnectFailureEvent, context:
         return PNTransition(
             state=ReceiveReconnectingState,
             context=self._context,
-            invocation=invocations.EmitStatusInvocation(PNStatusCategory.UnexpectedDisconnectCategory,
+            invocation=invocations.EmitStatusInvocation(PNStatusCategory.PNUnexpectedDisconnectCategory,
                                                         operation=PNOperationType.PNSubscribeOperation,
                                                         context=self._context)
         )