cloudinary 1.45.0__tar.gz → 1.46.0__tar.gz

{cloudinary-1.45.0/cloudinary.egg-info → cloudinary-1.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudinary
-Version: 1.45.0
+Version: 1.46.0
 Summary: Python and Django SDK for Cloudinary
 Author-email: Cloudinary <info@cloudinary.com>
 License: Released under the MIT license.

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/__init__.py

@@ -38,7 +38,7 @@ CL_BLANK = "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAA
 URI_SCHEME = "cloudinary"
 API_VERSION = "v1_1"
 
-VERSION = "1.45.0"
+VERSION = "1.46.0"
 
 _USER_PLATFORM_DETAILS = "; ".join((platform(), "Python {}".format(python_version())))
 

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/api.py

@@ -1323,6 +1323,189 @@ def update_streaming_profile(name, **options):
     return call_json_api('PUT', uri, params, **options)
 
 
+def triggers(**options):
+    """
+    Lists all notification triggers.
+
+    :param options: Additional options.
+    :keyword str event_type: Restricts the list to triggers of a single event type.
+    :return: A dictionary with a "triggers" key and a "total" count.
+    :rtype: Response
+    """
+    params = {"event_type": options.pop("event_type", None)}
+    return call_json_api("get", ["triggers"], params, **options)
+
+
+def create_trigger(uri, event_type, uri_type=None, **options):
+    """
+    Creates a notification trigger.
+
+    :param uri: The destination of the notification. An https:// webhook URL, or a
+                poll:// destination when uri_type is "poll" - either "poll://<channel>"
+                for a named channel or "poll://*" for an anonymous one addressed by batch_id.
+    :type uri: str
+    :param event_type: The event that fires the trigger. One of:
+                       "all", "access_control_changed", "bulk_refresh_auto_fetch",
+                       "create_folder", "delete", "delete_by_token", "delete_folder",
+                       "eager", "error", "explode", "generate_archive", "info",
+                       "invalidate_custom_cdn", "moderation", "moderation_summary",
+                       "move", "move_or_rename_asset_folder", "multi", "publish",
+                       "rename", "report", "resource_context_changed",
+                       "resource_display_name_changed", "resource_metadata_changed",
+                       "resource_tags_changed", "restore_asset_version", "sprite",
+                       "upload".
+                       The server owns this list and may extend it; values are passed
+                       through unvalidated.
+    :type event_type: str
+    :param uri_type: How the notification is delivered:
+                     - "webhook" (the default): delivers the notification as an HTTP POST
+                       to the destination URL.
+                     - "flow": dispatches the notification to a Cloudinary flow.
+                     - "poll": buffers the notification for retrieval with `notifications`
+                       instead of an outbound HTTP request.
+    :type uri_type: str, optional
+    :param options: Additional options.
+    :return: The created trigger.
+    :rtype: Response
+    """
+    params = {"uri": uri, "event_type": event_type, "uri_type": uri_type}
+    return call_json_api("post", ["triggers"], params, **options)
+
+
+def update_trigger(trigger_id, new_uri, **options):
+    """
+    Updates the destination URI of an existing trigger.
+
+    :param trigger_id: The ID of the trigger to update.
+    :type trigger_id: str
+    :param new_uri: The new destination URI.
+    :type new_uri: str
+    :param options: Additional options.
+    :return: A dictionary with a "message" key.
+    :rtype: Response
+    """
+    return call_json_api("put", ["triggers", trigger_id], {"new_uri": new_uri}, **options)
+
+
+def delete_trigger(trigger_id, **options):
+    """
+    Deletes a notification trigger.
+
+    :param trigger_id: The ID of the trigger to delete.
+    :type trigger_id: str
+    :param options: Additional options.
+    :return: A dictionary with a "message" key.
+    :rtype: Response
+    """
+    return call_json_api("delete", ["triggers", trigger_id], {}, **options)
+
+
+def test_trigger(trigger_id, sample_data=None, **options):
+    """
+    Evaluates a trigger's filter against sample data, without delivering a notification.
+
+    :param trigger_id: The ID of the trigger to test.
+    :type trigger_id: str
+    :param sample_data: The sample notification payload to evaluate the filter against.
+    :type sample_data: dict, optional
+    :param options: Additional options.
+    :return: A dictionary with "trigger_id", "filter_present" and "filter_result" keys.
+    :rtype: Response
+    """
+    params = {"sample_data": sample_data}
+    return call_json_api("post", ["triggers", trigger_id, "test"], params, **options)
+
+
+def notifications(channel=None, batch_id=None, max_messages=None, wait_seconds=None,
+                  visibility_timeout=None, **options):
+    """
+    Gets notifications buffered for a poll destination.
+
+    Long-polls exactly one addressing dimension - a named channel or a batch_id. Holds the
+    connection up to wait_seconds, returning as soon as messages are claimed. A claimed
+    message stays invisible for visibility_timeout seconds and is then redelivered, unless
+    it is acknowledged with `ack_notifications` first.
+
+    Each message carries the parsed notification as "payload" and the byte-exact signed
+    bytes, base64url encoded, as "signed_payload". Verify signatures against
+    signed_payload, never against a re-serialization of payload::
+
+        raw = cloudinary.utils.base64url_decode(message["signed_payload"])
+        cloudinary.utils.verify_notification_signature(
+            raw, message["timestamp"], message["signature"])
+
+    :param channel: The named channel to drain ("poll://<channel>" destinations).
+                    Mutually exclusive with batch_id.
+    :type channel: str, optional
+    :param batch_id: The batch to drain ("poll://*" anonymous destinations).
+                     Mutually exclusive with channel.
+    :type batch_id: str, optional
+    :param max_messages: The maximum number of messages to return. 1-100, default 10.
+    :type max_messages: int, optional
+    :param wait_seconds: The maximum seconds to hold the long-poll open when empty.
+                         0-60, default 20.
+    :type wait_seconds: int, optional
+    :param visibility_timeout: The seconds a claimed message stays invisible before
+                               redelivery. 1-600, default 30.
+    :type visibility_timeout: int, optional
+    :param options: Additional options.
+    :keyword int timeout: The HTTP timeout, also configurable via `cloudinary.config(timeout=...)`.
+                          When set, it must exceed wait_seconds, or the long poll is cut off
+                          client-side before the server answers.
+    :return: Zero or more claimed messages, as {"messages": [...]}. The "messages" key is
+             absent when nothing is buffered - read it with .get("messages", []).
+    :rtype: Response
+    :raises ValueError: If neither or both of channel and batch_id are given.
+    """
+    if bool(channel) == bool(batch_id):
+        raise ValueError("Supply exactly one of 'channel' or 'batch_id'")
+
+    params = {
+        "channel": channel,
+        "batch_id": batch_id,
+        "max_messages": max_messages,
+        "wait_seconds": wait_seconds,
+        "visibility_timeout": visibility_timeout,
+    }
+
+    return __call_notifications_api("get", ["messages"], params, **options)
+
+
+def ack_notifications(receipt_handles, **options):
+    """
+    Acknowledges claimed notifications, deleting them from the buffer.
+
+    Unacknowledged notifications are redelivered once their visibility timeout expires.
+
+    :param receipt_handles: The receipt handles of the notifications to acknowledge, as
+                            returned by `notifications`. A single handle may be passed as a
+                            string. Maximum 100 per call.
+    :type receipt_handles: list[str] or str
+    :param options: Additional options.
+    :return: The result of the call.
+    :rtype: Response
+    """
+    if isinstance(receipt_handles, string_types):
+        receipt_handles = [receipt_handles]
+
+    return __call_notifications_api("post", ["messages", "ack"],
+                                    {"receipt_handles": receipt_handles}, **options)
+
+
+def __call_notifications_api(method, uri, params, **options):
+    """
+    Private function that assists with performing an API call to the notifications module.
+
+    :param method: The HTTP method. Valid methods: get, post, put, delete
+    :param uri: REST endpoint of the API (without 'notifications' or the cloud name)
+    :param params: Query/body parameters passed to the method
+    :param options: Additional options
+    :rtype: Response
+    :internal
+    """
+    return _call_v2_api(method, uri, params, module="notifications", **options)
+
+
 def only(source, *keys):
     """
     Returns a dictionary containing only the specified keys from the source.
@@ -1384,7 +1567,7 @@ def __delete_resource_params(options, **params):
     :internal
     """
     p = dict(transformations=utils.build_eager(options.get('transformations')),
-             **only(options, "keep_original", "next_cursor", "invalidate"))
+             **only(options, "keep_original", "next_cursor", "invalidate", "batch_id"))
     p.update(params)
     return p
 

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/api_client/call_account_api.py

@@ -1,7 +1,7 @@
 import cloudinary
 from cloudinary.api_client.execute_request import execute_request
 from cloudinary.provisioning.account_config import account_config
-from cloudinary.utils import get_http_connector, normalize_params
+from cloudinary.utils import get_http_connector, json_body, normalize_params
 
 PROVISIONING_SUB_PATH = "provisioning"
 ACCOUNT_SUB_PATH = "accounts"
@@ -46,9 +46,15 @@ def _execute_account_request(method, uri, auth, params=None, headers=None, **opt
     api_version = options.pop("api_version", cloudinary.API_VERSION)
     provisioning_api_url = "/".join([prefix, api_version, PROVISIONING_SUB_PATH] + uri)
 
+    params = normalize_params(params)
+
+    if method.upper() != "GET":
+        options["body"], headers = json_body(params, headers)
+        params = None
+
     return execute_request(http_connector=_http,
                            method=method,
-                           params=normalize_params(params),
+                           params=params,
                            headers=headers,
                            auth=auth,
                            api_url=provisioning_api_url,

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/api_client/call_api.py

@@ -2,7 +2,7 @@ import json
 
 import cloudinary
 from cloudinary.api_client.execute_request import execute_request
-from cloudinary.utils import get_http_connector, normalize_params
+from cloudinary.utils import get_http_connector, json_body, normalize_params
 
 logger = cloudinary.logger
 _http = get_http_connector(cloudinary.config(), cloudinary.CERT_KWARGS)
@@ -35,23 +35,50 @@ def call_metadata_rules_api(method, uri, params, **options):
 
 
 def call_json_api(method, uri, params, **options):
-    data=None
+    data = None
+    headers = {'Content-Type': 'application/json'}
     if method.upper() != 'GET':
-        data = json.dumps(params).encode('utf-8')
+        data, headers = json_body(params)
         params = None
 
-    return _call_api(method, uri, params=params, body=data, headers={'Content-Type': 'application/json'}, **options)
+    return _call_api(method, uri, params=params, body=data, headers=headers, **options)
 
 
-def _call_v2_api(method, uri, params, **options):
-    return call_json_api(method, uri, params=params, api_version='v2', **options)
+def _call_v2_api(method, uri, params, module=None, **options):
+    """Private function that assists with performing a v2 API call.
+
+    :param method: The HTTP method. Valid methods: get, post, put, delete
+    :param uri: REST endpoint of the API (without the module or the cloud name)
+    :param params: Query/body parameters passed to the method
+    :param module: The v2 module the endpoint belongs to, for module-first endpoints
+                   (`/v2/{module}/{cloud_name}/...`). Omit for context-first endpoints
+                   (`/v2/{cloud_name}/...`).
+    :param options: Additional options
+    :rtype: Response
+    """
+    return call_json_api(method, uri, params=params, api_version='v2', module=module, **options)
 
 
 def call_api(method, uri, params, **options):
     return _call_api(method, uri, params=params, **options)
 
 
-def _call_api(method, uri, params=None, body=None, headers=None, extra_headers=None, **options):
+def _call_api(method, uri, params=None, body=None, headers=None, extra_headers=None, module=None, **options):
+    """
+    Performs an API call.
+
+    :param method: The HTTP method. Valid methods: get, post, put, delete
+    :param uri: REST endpoint of the API, as a list of path segments
+    :param params: Query/body parameters passed to the method
+    :param body: An already serialized request body
+    :param headers: Request headers
+    :param extra_headers: Additional headers, merged into headers
+    :param module: The API module the endpoint belongs to. When given, the module precedes
+                   the cloud name in the URL (`/{api_version}/{module}/{cloud_name}/...`),
+                   which is the v2 API convention. When omitted, the cloud name comes first.
+    :param options: Additional options
+    :rtype: Response
+    """
     prefix = options.pop("upload_prefix",
                          cloudinary.config().upload_prefix) or "https://api.cloudinary.com"
     cloud_name = options.pop("cloud_name", cloudinary.config().cloud_name)
@@ -66,7 +93,7 @@ def _call_api(method, uri, params=None, body=None, headers=None, extra_headers=N
     auth = {"key": api_key, "secret": api_secret, "oauth_token": oauth_token}
 
     api_version = options.pop("api_version", cloudinary.API_VERSION)
-    api_url = "/".join([prefix, api_version, cloud_name] + uri)
+    api_url = "/".join(filter(None, [prefix, api_version, module, cloud_name] + uri))
 
     if body is not None:
         options["body"] = body

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/api_client/execute_request.py

@@ -26,7 +26,8 @@ EXCEPTION_CODES = {
     409: AlreadyExists,
     420: RateLimited,
     429: RateLimited,
-    500: GeneralError
+    500: GeneralError,
+    503: GeneralError
 }
 
 
@@ -38,6 +39,7 @@ class Response(dict):
         self.rate_limit_allowed = safe_cast(response.headers.get("x-featureratelimit-limit"), int)
         self.rate_limit_reset_at = safe_cast(response.headers.get("x-featureratelimit-reset"), email.utils.parsedate)
         self.rate_limit_remaining = safe_cast(response.headers.get("x-featureratelimit-remaining"), int)
+        self.request_id = response.headers.get("x-request-id")
 
 
 def execute_request(http_connector, method, params, headers, auth, api_url, **options):
@@ -58,8 +60,9 @@ def execute_request(http_connector, method, params, headers, auth, api_url, **op
 
     api_url = smart_escape(unquote(api_url))
     kw = {}
-    if "timeout" in options:
-        kw["timeout"] = options["timeout"]
+    timeout = options.get("timeout", cloudinary.config().timeout)
+    if timeout is not None:
+        kw["timeout"] = timeout
     if "body" in options:
         kw["body"] = options["body"]
 

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/provisioning/__init__.py

@@ -1,5 +1,5 @@
 from .account_config import AccountConfig, account_config, reset_config
-from .account import (create_agent_account,
+from .account import (create_agent_account, create_cloud,
                       sub_accounts, create_sub_account, delete_sub_account, sub_account, update_sub_account,
                       user_groups, create_user_group, update_user_group, delete_user_group, user_group,
                       add_user_to_group, remove_user_from_group, user_group_users, user_in_user_groups,

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/provisioning/account.py

@@ -2,6 +2,7 @@ from cloudinary.api_client.call_account_api import _call_account_api, _call_publ
 from cloudinary.utils import encode_list
 
 AGENTS_SUB_PATH = "agents"
+CLOUDS_SUB_PATH = "clouds"
 SUB_ACCOUNTS_SUB_PATH = "sub_accounts"
 USERS_SUB_PATH = "users"
 USER_GROUPS_SUB_PATH = "user_groups"
@@ -60,6 +61,61 @@ def create_agent_account(email, agent_framework, agent_llm_model, agent_goal, sd
     return _call_public_account_api("POST", uri, params=params, **options)
 
 
+def create_cloud(delivery_ips=None, email=None, agent_framework=None, agent_llm_model=None, agent_goal=None,
+                 sdk_framework=None, **options):
+    """
+    Create a Claimable Cloud, intended for use by AI agents.
+
+    Creates a temporary cloud whose credentials work immediately, with media delivery restricted
+    to an IP allow-list. No verification email is sent. Unless a human claims it via the returned
+    claim_url, the cloud is disabled when it expires; claiming makes it permanent, keeps the
+    credentials and assets, and lifts the IP restriction.
+
+    Creation only: a cloud cannot be read, updated or deleted, so the delivery IPs are fixed for
+    its lifetime. If they are wrong, create another cloud or claim this one.
+
+    The restriction covers media delivery only, not the Upload and Admin APIs, so it is not a
+    confidentiality control. Uploads succeeding while delivery fails with `x-cld-error: ACL deny`
+    is the expected symptom of it.
+
+    This endpoint is public and unauthenticated, and is rate-limited per IP address.
+
+    :param delivery_ips:    Up to three additional IP addresses permitted to deliver media, for
+                            hosts other than the caller. The caller's own resolved address is
+                            always appended, so omitting this is the usual call; the literal
+                            "requester_ip" is replaced by that address. IPv4 and IPv6 are
+                            accepted, CIDR ranges are not. Non-public addresses are dropped and
+                            the call fails unless at least one public address remains, so read
+                            delivery_ips back from the response rather than assuming the list
+                            sent was stored.
+    :type delivery_ips:     list[str], optional
+    :param email:           Email address to associate the claim with. Not verified, and no mail
+                            is sent to it; a placeholder is generated when omitted.
+    :type email:            str, optional
+    :param agent_framework: The name of the agent framework used to create the cloud.
+    :type agent_framework:  str, optional
+    :param agent_llm_model: The LLM model powering the agent.
+    :type agent_llm_model:  str, optional
+    :param agent_goal:      A short description of what the agent is trying to achieve.
+    :type agent_goal:       str, optional
+    :param sdk_framework:   The Cloudinary SDK framework the agent intends to use.
+    :type sdk_framework:    str, optional
+    :param options:         Generic advanced options dict, see online documentation
+    :type options:          dict, optional
+    :return:                The created Claimable Cloud, including working credentials,
+                            the claim URL and the expiry time
+    :rtype:                 dict
+    """
+    uri = [CLOUDS_SUB_PATH]
+    params = {"delivery_ips": delivery_ips,
+              "email": email,
+              "agent_framework": agent_framework,
+              "agent_llm_model": agent_llm_model,
+              "agent_goal": agent_goal,
+              "sdk_framework": sdk_framework}
+    return _call_public_account_api("POST", uri, params=params, **options)
+
+
 def sub_accounts(enabled=None, ids=None, prefix=None, **options):
     """
     List all sub accounts
@@ -163,7 +219,7 @@ def update_sub_account(sub_account_id, name=None, cloud_name=None, custom_attrib
     return _call_account_api("put", uri, params=params, **options)
 
 
-def users(user_ids=None, sub_account_id=None, pending=None, prefix=None, last_login=None, from_date=None, to_date=None,
+def users(user_ids=None, sub_account_id=None, status=None, prefix=None, last_login=None, from_date=None, to_date=None,
           **options):
     """
     List all users
@@ -171,10 +227,10 @@ def users(user_ids=None, sub_account_id=None, pending=None, prefix=None, last_lo
     :type user_ids:         list, optional
     :param sub_account_id:  The id of a sub account
     :type sub_account_id:   str, optional
-    :param pending:         Limit results to pending users (True),
-                            users that are not pending (False),
-                            or all users (None, the default).
-    :type pending:          bool, optional
+    :param status:          Limit results to users of this status: "pending" for users who have not yet
+                            set a password, otherwise a user status such as "active". All users when
+                            omitted.
+    :type status:           str, optional
     :param prefix:          User prefix
     :type prefix:           str, optional
     :param last_login:      Return only users that last logged in in the specified range of dates (true), 
@@ -193,7 +249,7 @@ def users(user_ids=None, sub_account_id=None, pending=None, prefix=None, last_lo
     user_ids = encode_list(user_ids)
     params = {"ids": user_ids,
               "sub_account_id": sub_account_id,
-              "pending": pending,
+              "status": status,
               "prefix": prefix,
               "last_login": last_login,
               "from": from_date,

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/uploader.py

@@ -157,6 +157,8 @@ def upload(file, **options):
         If True, performs analysis for cinemagraph creation.
     :keyword bool accessibility_analysis:
         If True, performs accessibility (image alt text) analysis.
+    :keyword str batch_id:
+        The batch identifier used to retrieve notifications from a `poll://*` destination.
     :keyword int timestamp:
         A UNIX timestamp to sign the request. Defaults to now().
     :keyword dict or list transformation:
@@ -934,18 +936,27 @@ def call_api(action, params, http_headers=None, return_error=False, unsigned=Fal
     except socket.error as e:
         raise Error("Socket error: {0!r}".format(e))
 
+    request_id = response.headers.get("x-request-id")
+
     try:
         result = json.loads(response.data.decode('utf-8'))
     except Exception as e:
-        raise Error("Error parsing server response ({0}) - {1}. Got - {2}"
-                    .format(response.status, response.data, e))
+        message = "Error parsing server response ({0}) - {1}. Got - {2}".format(
+            response.status, response.data, e)
+        if request_id:
+            message += ". Request ID: {0}".format(request_id)
+        raise Error(message)
 
     if "error" in result:
         if return_error:
             result["error"]["http_code"] = response.status
+            result["error"]["request_id"] = request_id
             return result
 
         exception_class = EXCEPTION_CODES.get(response.status) or Error
         raise exception_class(result["error"]["message"])
 
+    if request_id:
+        result["request_id"] = request_id
+
     return result

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary/utils.py

@@ -122,6 +122,7 @@ __SIMPLE_UPLOAD_PARAMS = [
     "cinemagraph_analysis",
     "accessibility_analysis",
     "auto_chaptering",
+    "batch_id",
 ]
 
 __SERIALIZED_UPLOAD_PARAMS = [
@@ -613,6 +614,20 @@ def normalize_params(params):
     return dict([(k, __bool_string(v)) for (k, v) in params.items() if v is not None and not v == ""])
 
 
+def json_body(params, headers=None):
+    """
+    Encodes params as a JSON request body with the matching Content-Type.
+
+    :param params:  Params to serialize.
+    :param headers: Headers to extend. A Content-Type already present is kept.
+    :return:        Tuple of the encoded body and the resulting headers.
+    """
+    headers = dict(headers or {})
+    headers.setdefault("Content-Type", "application/json")
+
+    return json.dumps(params).encode("utf-8"), headers
+
+
 def sign_request(params, options):
     api_key = options.get("api_key", cloudinary.config().api_key)
     if not api_key:
@@ -1092,6 +1107,7 @@ def archive_params(**options):
     params = {
         "allow_missing": options.get("allow_missing"),
         "async": options.get("async"),
+        "batch_id": options.get("batch_id"),
         "expires_at": options.get("expires_at"),
         "flatten_folders": options.get("flatten_folders"),
         "flatten_transformations": options.get("flatten_transformations"),
@@ -1234,6 +1250,7 @@ def build_multi_and_sprite_params(**options):
         "mode": options.get("mode"),
         "timestamp": now(),
         "async": options.get("async"),
+        "batch_id": options.get("batch_id"),
         "notification_url": options.get("notification_url"),
         "tag": tag,
         "urls": urls,
@@ -1555,6 +1572,17 @@ def base64url_encode(data):
     return to_string(base64.urlsafe_b64encode(to_bytes(data)))
 
 
+def base64url_decode(data):
+    """
+    Url safe version of urlsafe_b64decode that restores the `=` padding if it was stripped.
+
+    :param data: Base64 URL safe encoded string, padded or not
+
+    :return: Decoded string
+    """
+    return to_string(base64.urlsafe_b64decode(to_bytes(data + "=" * (-len(data) % 4))))
+
+
 def encode_unicode_url(url_str):
     """
     Quote and encode possible unicode url string (applicable for python2)
@@ -1645,7 +1673,9 @@ def verify_notification_signature(body, timestamp, signature, valid_for=7200, al
     Verifies the authenticity of a notification signature
 
     :param body: Json of the request's body
-    :param timestamp: Unix timestamp. Can be retrieved from the X-Cld-Timestamp header
+    :param timestamp: Unix timestamp. Can be retrieved from the X-Cld-Timestamp header, or from
+                      the `timestamp` of a notification returned by `api.notifications`. Both
+                      deliver it as a string, which is accepted here.
     :param signature: Actual signature. Can be retrieved from the X-Cld-Signature header
     :param valid_for: The desired time in seconds for considering the request valid
     :param algorithm: Name of hashing algorithm to use for calculation of HMACs.
@@ -1656,7 +1686,7 @@ def verify_notification_signature(body, timestamp, signature, valid_for=7200, al
     if not cloudinary.config().api_secret:
         raise Exception('Api secret key is empty')
 
-    if timestamp < time.time() - valid_for:
+    if int(timestamp) < time.time() - valid_for:
         return False
 
     if not isinstance(body, str):
@@ -1667,6 +1697,31 @@ def verify_notification_signature(body, timestamp, signature, valid_for=7200, al
         algorithm or cloudinary.config().signature_algorithm)
 
 
+def verify_notification(message, valid_for=7200, algorithm=None):
+    """
+    Verifies the authenticity of a signed notification message.
+
+    :param message: Signed message, with `signed_payload`, `signature` and `timestamp` keys
+    :type message: dict
+    :param valid_for: The desired time in seconds for considering the message valid
+    :param algorithm: Name of hashing algorithm to use for calculation of HMACs.
+                      By default, uses `cloudinary.config().signature_algorithm`
+
+    :return: Boolean result of the validation
+    :raises ValueError: If the message is missing signed_payload, signature or timestamp
+    """
+    missing = [key for key in ("signed_payload", "signature", "timestamp") if key not in message]
+    if missing:
+        raise ValueError("Message is missing required key(s): {}".format(", ".join(missing)))
+
+    return verify_notification_signature(
+        base64url_decode(message["signed_payload"]),
+        message["timestamp"],
+        message["signature"],
+        valid_for=valid_for,
+        algorithm=algorithm)
+
+
 def get_http_connector(conf, options):
     """
     Used to create http connector, depends on api_proxy and disable_tcp_keep_alive configuration parameters.

{cloudinary-1.45.0 → cloudinary-1.46.0/cloudinary.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudinary
-Version: 1.45.0
+Version: 1.46.0
 Summary: Python and Django SDK for Cloudinary
 Author-email: Cloudinary <info@cloudinary.com>
 License: Released under the MIT license.

{cloudinary-1.45.0 → cloudinary-1.46.0}/cloudinary.egg-info/SOURCES.txt

@@ -66,9 +66,12 @@ test/test_http_client.py
 test/test_image.py
 test/test_metadata.py
 test/test_metadata_rules.py
+test/test_notifications.py
 test/test_provisioning_api.py
+test/test_request_id.py
 test/test_search.py
 test/test_streaming_profiles.py
+test/test_triggers.py
 test/test_uploader.py
 test/test_utils.py
 test/test_video.py

{cloudinary-1.45.0 → cloudinary-1.46.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "cloudinary"
 description = "Python and Django SDK for Cloudinary"
-version = "1.45.0"
+version = "1.46.0"
 
 authors = [{ name = "Cloudinary", email = "info@cloudinary.com" }]
 license = { file = "LICENSE.txt" }

{cloudinary-1.45.0 → cloudinary-1.46.0}/setup.py

@@ -7,7 +7,7 @@ if version_info[0] >= 3:
 else:
     # Following code is legacy (Python 2.7 compatibility) and will be removed in the future!
     # TODO: Remove in next major update (when dropping Python 2.7 compatibility)
-    version = "1.45.0"
+    version = "1.46.0"
 
     with open('README.md') as file:
         long_description = file.read()