Add Custom Message Type

.pubnub.yml

@@ -1,5 +1,5 @@
 name: python
-version: 9.0.0
+version: 9.1.0
 schema: 1
 scm: github.com/pubnub/python
 sdks:
@@ -18,7 +18,7 @@ sdks:
         distributions:
           - distribution-type: library
             distribution-repository: package
-            package-name: pubnub-9.0.0
+            package-name: pubnub-9.1.0
             location: https://pypi.org/project/pubnub/
             supported-platforms:
               supported-operating-systems:
@@ -97,8 +97,8 @@ sdks:
           -
             distribution-type: library
             distribution-repository: git release
-            package-name: pubnub-9.0.0
-            location: https://github.com/pubnub/python/releases/download/v9.0.0/pubnub-9.0.0.tar.gz
+            package-name: pubnub-9.1.0
+            location: https://github.com/pubnub/python/releases/download/v9.1.0/pubnub-9.1.0.tar.gz
             supported-platforms:
               supported-operating-systems:
                 Linux:
@@ -169,6 +169,11 @@ sdks:
                 license-url: https://github.com/aio-libs/aiohttp/blob/master/LICENSE.txt
                 is-required: Required
 changelog:
+  - date: 2024-11-19
+    version: v9.1.0
+    changes:
+      - type: feature
+        text: "Add custom message type support for the following APIs: Publish, signal, share file, subscribe and history."
   - date: 2024-10-02
     version: v9.0.0
     changes:

CHANGELOG.md

@@ -1,3 +1,9 @@
+## v9.1.0
+November 19 2024
+
+#### Added
+- Add custom message type support for the following APIs: Publish, signal, share file, subscribe and history.
+
 ## v9.0.0
 October 02 2024
 

pubnub/endpoints/fetch_messages.py

@@ -33,7 +33,8 @@ class FetchMessages(Endpoint):
 
     def __init__(self, pubnub, channels: Union[str, List[str]] = None, start: int = None, end: int = None,
                  count: int = None, include_meta: bool = None, include_message_actions: bool = None,
-                 include_message_type: bool = None, include_uuid: bool = None, decrypt_messages: bool = False):
+                 include_message_type: bool = None, include_uuid: bool = None, decrypt_messages: bool = False,
+                 include_custom_message_type: bool = None):
         Endpoint.__init__(self, pubnub)
         self._channels = []
         if channels:
@@ -46,6 +47,7 @@ def __init__(self, pubnub, channels: Union[str, List[str]] = None, start: int =
         self._include_message_type = include_message_type
         self._include_uuid = include_uuid
         self._decrypt_messages = decrypt_messages
+        self._include_custom_message_type = include_custom_message_type
 
     def channels(self, channels: Union[str, List[str]]) -> 'FetchMessages':
         utils.extend_list(self._channels, channels)
@@ -84,6 +86,11 @@ def include_message_type(self, include_message_type: bool) -> 'FetchMessages':
         self._include_message_type = include_message_type
         return self
 
+    def include_custom_message_type(self, include_custom_message_type: bool) -> 'FetchMessages':
+        assert isinstance(include_custom_message_type, bool)
+        self._include_custom_message_type = include_custom_message_type
+        return self
+
     def include_uuid(self, include_uuid: bool) -> 'FetchMessages':
         assert isinstance(include_uuid, bool)
         self._include_uuid = include_uuid
@@ -108,6 +115,9 @@ def custom_params(self):
         if self._include_message_type is not None:
             params['include_message_type'] = "true" if self._include_message_type else "false"
 
+        if self._include_custom_message_type is not None:
+            params['include_custom_message_type'] = "true" if self._include_custom_message_type else "false"
+
         if self.include_message_actions and self._include_uuid is not None:
             params['include_uuid'] = "true" if self._include_uuid else "false"
 

pubnub/endpoints/file_operations/publish_file_message.py

@@ -22,6 +22,7 @@ def __init__(self, pubnub):
         self._cipher_key = None
         self._replicate = None
         self._ptto = None
+        self._custom_message_type = None
 
     def meta(self, meta):
         self._meta = meta
@@ -53,6 +54,10 @@ def file_name(self, file_name):
         self._file_name = file_name
         return self
 
+    def custom_message_type(self, custom_message_type: str) -> 'PublishFileMessage':
+        self._custom_message_type = custom_message_type
+        return self
+
     def _encrypt_message(self, message):
         if self._cipher_key:
             return PubNubCryptodome(self._pubnub.config).encrypt(self._cipher_key, utils.write_value_as_string(message))
@@ -90,6 +95,10 @@ def custom_params(self):
             "ttl": self._ttl,
             "store": 1 if self._should_store else 0
         })
+
+        if self._custom_message_type:
+            params['custom_message_type'] = utils.url_encode(self._custom_message_type)
+
         return params
 
     def is_auth_required(self):

pubnub/endpoints/file_operations/send_file.py

@@ -24,11 +24,16 @@ def __init__(self, pubnub):
         self._file_object = None
         self._replicate = None
         self._ptto = None
+        self._custom_message_type = None
 
     def file_object(self, fd):
         self._file_object = fd
         return self
 
+    def custom_message_type(self, custom_message_type: str):
+        self._custom_message_type = custom_message_type
+        return self
+
     def build_params_callback(self):
         return lambda a: {}
 
@@ -124,23 +129,24 @@ def name(self):
         return "Send file to S3"
 
     def sync(self):
-        self._file_upload_envelope = FetchFileUploadS3Data(self._pubnub).\
-            channel(self._channel).\
-            file_name(self._file_name).sync()
+        self._file_upload_envelope = FetchFileUploadS3Data(self._pubnub) \
+            .channel(self._channel) \
+            .file_name(self._file_name).sync()
 
         response_envelope = super(SendFileNative, self).sync()
 
-        publish_file_response = PublishFileMessage(self._pubnub).\
-            channel(self._channel).\
-            meta(self._meta).\
-            message(self._message).\
-            file_id(response_envelope.result.file_id).\
-            file_name(response_envelope.result.name).\
-            should_store(self._should_store).\
-            ttl(self._ttl).\
-            replicate(self._replicate).\
-            ptto(self._ptto).\
-            cipher_key(self._cipher_key).sync()
+        publish_file_response = PublishFileMessage(self._pubnub) \
+            .channel(self._channel) \
+            .meta(self._meta) \
+            .message(self._message) \
+            .file_id(response_envelope.result.file_id) \
+            .file_name(response_envelope.result.name) \
+            .should_store(self._should_store) \
+            .ttl(self._ttl) \
+            .replicate(self._replicate) \
+            .ptto(self._ptto) \
+            .custom_message_type(self._custom_message_type) \
+            .cipher_key(self._cipher_key).sync()
 
         response_envelope.result.timestamp = publish_file_response.result.timestamp
         return response_envelope

pubnub/endpoints/pubsub/publish.py

@@ -29,16 +29,17 @@ class Publish(Endpoint, TimeTokenOverrideMixin):
     _ptto: Optional[int]
     _ttl: Optional[int]
 
-    def __init__(self, pubnub, channel: str = None, message: any = None,
-                 should_store: Optional[bool] = None, use_post: Optional[bool] = None, meta: Optional[any] = None,
-                 replicate: Optional[bool] = None, ptto: Optional[int] = None, ttl: Optional[int] = None):
+    def __init__(self, pubnub, channel: str = None, message: any = None, should_store: Optional[bool] = None,
+                 use_post: Optional[bool] = None, meta: Optional[any] = None, replicate: Optional[bool] = None,
+                 ptto: Optional[int] = None, ttl: Optional[int] = None, custom_message_type: Optional[str] = None):
 
         super(Publish, self).__init__(pubnub)
         self._channel = channel
         self._message = message
         self._should_store = should_store
         self._use_post = use_post
         self._meta = meta
+        self._custom_message_type = custom_message_type
         self._replicate = replicate
         self._ptto = ptto
         self._ttl = ttl
@@ -70,6 +71,10 @@ def meta(self, meta: any) -> 'Publish':
         self._meta = meta
         return self
 
+    def custom_message_type(self, custom_message_type: str) -> 'Publish':
+        self._custom_message_type = custom_message_type
+        return self
+
     def ttl(self, ttl: int) -> 'Publish':
         self._ttl = ttl
         return self
@@ -105,6 +110,9 @@ def custom_params(self):
         if self._meta:
             params['meta'] = utils.write_value_as_string(self._meta)
 
+        if self._custom_message_type:
+            params['custom_message_type'] = utils.url_encode(self._custom_message_type)
+
         if self._should_store is not None:
             if self._should_store:
                 params["store"] = "1"

pubnub/endpoints/signal.py

@@ -1,3 +1,4 @@
+from typing import Optional
 from pubnub import utils
 from pubnub.endpoints.endpoint import Endpoint
 from pubnub.enums import HttpMethod, PNOperationType
@@ -17,10 +18,11 @@ class Signal(Endpoint):
     _channel: str
     _message: any
 
-    def __init__(self, pubnub, channel: str = None, message: any = None):
+    def __init__(self, pubnub, channel: str = None, message: any = None, custom_message_type: Optional[str] = None):
         Endpoint.__init__(self, pubnub)
         self._channel = channel
         self._message = message
+        self._custom_message_type = custom_message_type
 
     def channel(self, channel) -> 'Signal':
         self._channel = str(channel)
@@ -30,6 +32,10 @@ def message(self, message) -> 'Signal':
         self._message = message
         return self
 
+    def custom_message_type(self, custom_message_type: str) -> 'Signal':
+        self._custom_message_type = custom_message_type
+        return self
+
     def build_path(self):
         stringified_message = utils.write_value_as_string(self._message)
         msg = utils.url_encode(stringified_message)
@@ -39,7 +45,11 @@ def build_path(self):
         )
 
     def custom_params(self):
-        return {}
+        params = {}
+        if self._custom_message_type:
+            params['custom_message_type'] = utils.url_encode(self._custom_message_type)
+
+        return params
 
     def http_method(self):
         return HttpMethod.GET

pubnub/models/consumer/pubsub.py

@@ -2,7 +2,8 @@
 
 
 class PNMessageResult(object):
-    def __init__(self, message, subscription, channel, timetoken, user_metadata=None, publisher=None, error=None):
+    def __init__(self, message, subscription, channel, timetoken, user_metadata=None, publisher=None,
+                 error=None, custom_message_type=None):
 
         if subscription is not None:
             assert isinstance(subscription, str)
@@ -30,6 +31,7 @@ def __init__(self, message, subscription, channel, timetoken, user_metadata=None
         self.user_metadata = user_metadata
         self.publisher = publisher
         self.error = error
+        self.custom_message_type = custom_message_type
 
 
 class PNSignalMessageResult(PNMessageResult):

pubnub/models/server/subscribe.py

@@ -30,6 +30,7 @@ def __init__(self):
         self.publish_metadata = None
         self.only_channel_subscription = False
         self.type = 0
+        self.custom_message_type = None
 
     @classmethod
     def from_json(cls, json_input):
@@ -49,6 +50,8 @@ def from_json(cls, json_input):
         message.publish_metadata = PublishMetadata.from_json(json_input['p'])
         if 'e' in json_input:
             message.type = json_input['e']
+        if 'cmt' in json_input:
+            message.custom_message_type = json_input['cmt']
         return message
 
 

pubnub/pubnub_core.py

@@ -94,7 +94,7 @@
 
 class PubNubCore:
     """A base class for PubNub Python API implementations"""
-    SDK_VERSION = "9.0.0"
+    SDK_VERSION = "9.1.0"
     SDK_NAME = "PubNub-Python"
 
     TIMESTAMP_DIVIDER = 1000
@@ -215,12 +215,13 @@ def where_now(self, user_id: Optional[str] = None):
 
     def publish(self, channel: str = None, message: any = None, should_store: Optional[bool] = None,
                 use_post: Optional[bool] = None, meta: Optional[any] = None, replicate: Optional[bool] = None,
-                ptto: Optional[int] = None, ttl: Optional[int] = None) -> Publish:
+                ptto: Optional[int] = None, ttl: Optional[int] = None, custom_message_type: Optional[str] = None
+                ) -> Publish:
         """ Sends a message to all channel subscribers. A successfully published message is replicated across PubNub's
         points of presence and sent simultaneously to all subscribed clients on a channel.
         """
         return Publish(self, channel=channel, message=message, should_store=should_store, use_post=use_post, meta=meta,
-                       replicate=replicate, ptto=ptto, ttl=ttl)
+                       replicate=replicate, ptto=ptto, ttl=ttl, custom_message_type=custom_message_type)
 
     def grant(self):
         """ Deprecated. Use grant_token instead """
@@ -274,8 +275,8 @@ def fire(self, channel: str = None, message: any = None, use_post: Optional[bool
              meta: Optional[any] = None) -> Fire:
         return Fire(self, channel=channel, message=message, use_post=use_post, meta=meta)
 
-    def signal(self, channel: str = None, message: any = None) -> Signal:
-        return Signal(self, channel=channel, message=message)
+    def signal(self, channel: str = None, message: any = None, custom_message_type: Optional[str] = None) -> Signal:
+        return Signal(self, channel=channel, message=message, custom_message_type=custom_message_type)
 
     def set_uuid_metadata(self, uuid: str = None, include_custom: bool = None, custom: dict = None,
                           include_status: bool = True, include_type: bool = True, status: str = None, type: str = None,

setup.py

@@ -2,7 +2,7 @@
 
 setup(
     name='pubnub',
-    version='9.0.0',
+    version='9.1.0',
     description='PubNub Real-time push service in the cloud',
     author='PubNub',
     author_email='[email protected]',