PubNub SDK v4.6.0 release.

Author: client-engineering-bot

.pubnub.yml

@@ -1,8 +1,14 @@
 name: python
-version: 4.5.4
+version: 4.6.0
 schema: 1
 scm: github.com/pubnub/python
 changelog:
+  - version: v4.6.0
+    date: Oct 22, 2020
+    changes:
+      -
+        text: "File Upload added to the Python SDK."
+        type: feature
   - version: v4.5.4
     date: Sep 29, 2020
     changes:
@@ -16,7 +22,7 @@ changelog:
     date: Aug 10, 2020
     changes:
       -
-        text: "Allocating separate thread that basically waits certain amount of time to clean telemetry data is a waste of memory/OS data strucutres. Clening mentioned data can be incorporated into regular logic."
+        text: "Allocating separate thread that basically waits a certain amount of time to clean telemetry data is a waste of memory/OS data structures. Cleaning mentioned data can be incorporated into regular logic."
         type: improvement
   - version: v4.5.2
     date: May 29, 2020
@@ -62,7 +68,7 @@ changelog:
     date: Dec 24, 2019
     changes:
       - type: improvement
-        text: Introduced delete permission to Grant endpoint. Migrated to v2 enpdoints for old PAM methods.
+        text: Introduced delete permission to Grant endpoint. Migrated to v2 endpoints for old PAM methods.
       - type: feature
         text: Added TokenManager and GrantToken method.
       - type: improvement
@@ -121,7 +127,7 @@ changelog:
     date: Jun 14, 2017
     changes:
       - type: improvement
-        text: Added deamon option for PNConfig
+        text: Added daemon option for PNConfig
   - version: v4.0.12
     date:
     changes:
@@ -191,7 +197,7 @@ changelog:
       - type: improvement
         text: Adjusting maximum pool size for requests installations
       - type: improvement
-        text: Adding Publsher UUID
+        text: Adding Publisher UUID
   - version: v4.0.1
     date: Nov 8, 2016
     changes:

CHANGELOG.md

@@ -1,3 +1,10 @@
+## [v4.6.0](https://github.com/pubnub/python/releases/tag/v4.6.0)
+
+[Full Changelog](https://github.com/pubnub/python/compare/v4.5.4...v4.6.0)
+
+- 🌟️ File Upload added to the Python SDK. 
+- ⭐️️ Fix spelling typos in `.pubnub.yml` file. Addresses the following PRs from [@samiahmedsiddiqui](https://github.com/samiahmedsiddiqui): [#92](https://github.com/pubnub/python/pull/92).
+
 ## [v4.5.4](https://github.com/pubnub/python/releases/tag/v4.5.4)
 
 [Full Changelog](https://github.com/pubnub/python/compare/v4.5.3...v4.5.4)

pubnub/callbacks.py

@@ -37,6 +37,9 @@ def membership(self, pubnub, membership):
     def message_action(self, pubnub, message_action):
         pass
 
+    def file(self, pubnub, file_message):
+        pass
+
 
 class ReconnectionCallback(object):
     @abstractmethod

pubnub/crypto.py

@@ -1,9 +1,11 @@
 import hashlib
 import json
 import sys
+import random
 
 from .crypto_core import PubNubCrypto
 from Cryptodome.Cipher import AES
+from Cryptodome.Util.Padding import pad, unpad
 
 Initial16bytes = '0123456789012345'
 
@@ -26,31 +28,67 @@
 
 
 class PubNubCryptodome(PubNubCrypto):
-    def encrypt(self, key, msg):
+    def __init__(self, pubnub_config):
+        self.pubnub_configuration = pubnub_config
+
+    def encrypt(self, key, msg, use_random_iv=False):
         secret = self.get_secret(key)
+        initialization_vector = self.get_initialization_vector(use_random_iv)
 
         if v == 3:
-            cipher = AES.new(bytes(secret[0:32], 'utf-8'), AES.MODE_CBC, bytes(Initial16bytes, 'utf-8'))
-            return encodebytes(cipher.encrypt(self.pad(msg.encode('utf-8')))).decode('utf-8').replace("\n", "")
+            cipher = AES.new(bytes(secret[0:32], 'utf-8'), AES.MODE_CBC, bytes(initialization_vector, 'utf-8'))
+            encrypted_message = cipher.encrypt(self.pad(msg.encode('utf-8')))
+            msg_with_iv = self.append_random_iv(encrypted_message, use_random_iv, bytes(initialization_vector, "utf-8"))
+
+            return encodebytes(msg_with_iv).decode('utf-8').replace("\n", "")
+
         else:
-            cipher = AES.new(secret[0:32], AES.MODE_CBC, Initial16bytes)
-            return encodestring(cipher.encrypt(self.pad(msg))).replace("\n", "")
+            cipher = AES.new(secret[0:32], AES.MODE_CBC, initialization_vector)
+            encrypted_message = cipher.encrypt(self.pad(msg))
+            msg_with_iv = self.append_random_iv(encrypted_message, use_random_iv, initialization_vector)
+            return encodestring(msg_with_iv).replace("\n", "")
 
-    def decrypt(self, key, msg):
+    def decrypt(self, key, msg, use_random_iv=False):
         secret = self.get_secret(key)
 
         if v == 3:
-            cipher = AES.new(bytes(secret[0:32], 'utf-8'), AES.MODE_CBC, bytes(Initial16bytes, 'utf-8'))
-            plain = self.depad((cipher.decrypt(decodebytes(msg.encode('utf-8')))).decode('utf-8'))
+            decoded_message = decodebytes(msg.encode("utf-8"))
+            initialization_vector, extracted_message = self.extract_random_iv(decoded_message, use_random_iv)
+            cipher = AES.new(bytes(secret[0:32], "utf-8"), AES.MODE_CBC, initialization_vector)
+            plain = self.depad((cipher.decrypt(extracted_message)).decode('utf-8'))
+
         else:
-            cipher = AES.new(secret[0:32], AES.MODE_CBC, Initial16bytes)
-            plain = self.depad(cipher.decrypt(decodestring(msg)))
+            decoded_message = decodestring(msg)
+            initialization_vector, extracted_message = self.extract_random_iv(decoded_message, use_random_iv)
+            cipher = AES.new(secret[0:32], AES.MODE_CBC, initialization_vector)
+            plain = self.depad(cipher.decrypt(extracted_message))
 
         try:
             return json.loads(plain)
         except Exception:
             return plain
 
+    def append_random_iv(self, message, use_random_iv, initialization_vector):
+        if self.pubnub_configuration.use_random_initialization_vector or use_random_iv:
+            return initialization_vector + message
+        else:
+            return message
+
+    def extract_random_iv(self, message, use_random_iv):
+        if self.pubnub_configuration.use_random_initialization_vector or use_random_iv:
+            return message[0:16], message[16:]
+        else:
+            if v == 3:
+                return bytes(Initial16bytes, "utf-8"), message
+            else:
+                return Initial16bytes, message
+
+    def get_initialization_vector(self, use_random_iv):
+        if self.pubnub_configuration.use_random_initialization_vector or use_random_iv:
+            return "{0:016}".format(random.randint(0, 9999999999999999))
+        else:
+            return Initial16bytes
+
     def pad(self, msg, block_size=16):
         padding = block_size - (len(msg) % block_size)
 
@@ -67,3 +105,32 @@ def get_secret(self, key):
             return hashlib.sha256(key.encode("utf-8")).hexdigest()
         else:
             return hashlib.sha256(key).hexdigest()
+
+
+class PubNubFileCrypto(PubNubCryptodome):
+    def encrypt(self, key, file):
+        secret = self.get_secret(key)
+        initialization_vector = self.get_initialization_vector(use_random_iv=True)
+
+        if v == 3:
+            cipher = AES.new(bytes(secret[0:32], "utf-8"), AES.MODE_CBC, bytes(initialization_vector, 'utf-8'))
+            initialization_vector = bytes(initialization_vector, 'utf-8')
+        else:
+            cipher = AES.new(secret[0:32], AES.MODE_CBC, initialization_vector)
+
+        return self.append_random_iv(
+            cipher.encrypt(pad(file, 16)),
+            use_random_iv=True,
+            initialization_vector=initialization_vector
+        )
+
+    def decrypt(self, key, file):
+        secret = self.get_secret(key)
+        initialization_vector, extracted_file = self.extract_random_iv(file, use_random_iv=True)
+
+        if v == 3:
+            cipher = AES.new(bytes(secret[0:32], "utf-8"), AES.MODE_CBC, initialization_vector)
+        else:
+            cipher = AES.new(secret[0:32], AES.MODE_CBC, initialization_vector)
+
+        return unpad(cipher.decrypt(extracted_file), 16)

pubnub/endpoints/endpoint.py

@@ -4,8 +4,11 @@
 
 from pubnub import utils
 from pubnub.enums import PNStatusCategory, PNOperationType
-from pubnub.errors import PNERR_SUBSCRIBE_KEY_MISSING, PNERR_PUBLISH_KEY_MISSING, PNERR_CHANNEL_OR_GROUP_MISSING, \
-    PNERR_SECRET_KEY_MISSING, PNERR_CHANNEL_MISSING
+from pubnub.errors import (
+    PNERR_SUBSCRIBE_KEY_MISSING, PNERR_PUBLISH_KEY_MISSING, PNERR_CHANNEL_OR_GROUP_MISSING,
+    PNERR_SECRET_KEY_MISSING, PNERR_CHANNEL_MISSING, PNERR_FILE_OBJECT_MISSING,
+    PNERR_FILE_ID_MISSING, PNERR_FILE_NAME_MISSING
+)
 from pubnub.exceptions import PubNubException
 from pubnub.models.consumer.common import PNStatus
 from pubnub.models.consumer.pn_error_data import PNErrorData
@@ -78,6 +81,24 @@ def affected_channels(self):
     def affected_channels_groups(self):
         return None
 
+    def allow_redirects(self):
+        return True
+
+    def use_base_path(self):
+        return True
+
+    def request_headers(self):
+        if self.http_method() == "POST":
+            return {"Content-type": "application/json"}
+        else:
+            return {}
+
+    def build_file_upload_request(self):
+        return
+
+    def non_json_response(self):
+        return False
+
     def options(self):
         return RequestOptions(
             path=self.build_path(),
@@ -90,7 +111,13 @@ def options(self):
             create_exception=self.create_exception,
             operation_type=self.operation_type(),
             data=self.build_data(),
-            sort_arguments=self._sort_params)
+            files=self.build_file_upload_request(),
+            sort_arguments=self._sort_params,
+            allow_redirects=self.allow_redirects(),
+            use_base_path=self.use_base_path(),
+            request_headers=self.request_headers(),
+            non_json_response=self.non_json_response()
+        )
 
     def sync(self):
         self.validate_params()
@@ -202,6 +229,18 @@ def validate_publish_key(self):
         if self.pubnub.config.publish_key is None or len(self.pubnub.config.publish_key) == 0:
             raise PubNubException(pn_error=PNERR_PUBLISH_KEY_MISSING)
 
+    def validate_file_object(self):
+        if not self._file_object:
+            raise PubNubException(pn_error=PNERR_FILE_OBJECT_MISSING)
+
+    def validate_file_name(self):
+        if not self._file_name:
+            raise PubNubException(pn_error=PNERR_FILE_NAME_MISSING)
+
+    def validate_file_id(self):
+        if not self._file_id:
+            raise PubNubException(pn_error=PNERR_FILE_ID_MISSING)
+
     def create_status(self, category, response, response_info, exception):
         if response_info is not None:
             assert isinstance(response_info, ResponseInfo)

pubnub/endpoints/file_operations/__init__.py

@@ -0,0 +1,53 @@
+from pubnub.endpoints.file_operations.file_based_endpoint import FileOperationEndpoint
+from pubnub.enums import HttpMethod, PNOperationType
+from pubnub import utils
+from pubnub.models.consumer.file import PNDeleteFileResult
+
+
+class DeleteFile(FileOperationEndpoint):
+    DELETE_FILE_URL = "/v1/files/%s/channels/%s/files/%s/%s"
+
+    def __init__(self, pubnub):
+        FileOperationEndpoint.__init__(self, pubnub)
+        self._file_id = None
+        self._file_name = None
+
+    def build_path(self):
+        return DeleteFile.DELETE_FILE_URL % (
+            self.pubnub.config.subscribe_key,
+            utils.url_encode(self._channel),
+            self._file_id,
+            self._file_name
+        )
+
+    def file_id(self, file_id):
+        self._file_id = file_id
+        return self
+
+    def file_name(self, file_name):
+        self._file_name = file_name
+        return self
+
+    def http_method(self):
+        return HttpMethod.DELETE
+
+    def custom_params(self):
+        return {}
+
+    def is_auth_required(self):
+        return True
+
+    def validate_params(self):
+        self.validate_subscribe_key()
+        self.validate_channel()
+        self.validate_file_name()
+        self.validate_file_id()
+
+    def create_response(self, envelope):
+        return PNDeleteFileResult(envelope)
+
+    def operation_type(self):
+        return PNOperationType.PNDeleteFileOperation
+
+    def name(self):
+        return "Delete file"