cloudinary 1.44.4__tar.gz → 1.46.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cloudinary
-Version: 1.44.4
+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.44.4 → 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.44.4"
+VERSION = "1.46.0"
 
 _USER_PLATFORM_DETAILS = "; ".join((platform(), "Python {}".format(python_version())))
 

{cloudinary-1.44.4 → 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.46.0/cloudinary/api_client/call_account_api.py

@@ -0,0 +1,61 @@
+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, json_body, normalize_params
+
+PROVISIONING_SUB_PATH = "provisioning"
+ACCOUNT_SUB_PATH = "accounts"
+_http = get_http_connector(account_config(), cloudinary.CERT_KWARGS)
+
+
+# Account-scoped, authenticated call: provisioning/accounts/{account_id}/...
+def _call_account_api(method, uri, params=None, headers=None, **options):
+    account_uri = [ACCOUNT_SUB_PATH, _account_id(options)] + uri
+    return _execute_account_request(method, account_uri, _account_auth(options),
+                                    params=params, headers=headers, **options)
+
+
+# Public, unauthenticated call: provisioning/... with no account_id or credentials
+def _call_public_account_api(method, uri, params=None, headers=None, **options):
+    return _execute_account_request(method, uri, {"anonymous": True},
+                                    params=params, headers=headers, **options)
+
+
+def _account_id(options):
+    account_id = options.pop("account_id", account_config().account_id)
+    if not account_id:
+        raise Exception("Must supply account_id")
+    return account_id
+
+
+def _account_auth(options):
+    provisioning_api_key = options.pop("provisioning_api_key", account_config().provisioning_api_key)
+    if not provisioning_api_key:
+        raise Exception("Must supply provisioning_api_key")
+    provisioning_api_secret = options.pop("provisioning_api_secret", account_config().provisioning_api_secret)
+    if not provisioning_api_secret:
+        raise Exception("Must supply provisioning_api_secret")
+    return {"key": provisioning_api_key, "secret": provisioning_api_secret}
+
+
+# Core transport: builds the provisioning URL and dispatches with the resolved auth.
+# The API version can be overridden via the "api_version" option (defaults to cloudinary.API_VERSION).
+def _execute_account_request(method, uri, auth, params=None, headers=None, **options):
+    prefix = options.pop("upload_prefix",
+                         cloudinary.config().upload_prefix) or "https://api.cloudinary.com"
+    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=params,
+                           headers=headers,
+                           auth=auth,
+                           api_url=provisioning_api_url,
+                           **options)

{cloudinary-1.44.4 → 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.44.4 → 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,17 +39,18 @@ 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):
-    # authentication
+    anonymous = auth.get("anonymous")
     key = auth.get("key")
     secret = auth.get("secret")
     oauth_token = auth.get("oauth_token")
-    req_headers = urllib3.make_headers(
-        user_agent=cloudinary.get_user_agent()
-    )
-    if oauth_token:
+    req_headers = urllib3.make_headers(user_agent=cloudinary.get_user_agent())
+    if anonymous:
+        pass
+    elif oauth_token:
         req_headers["authorization"] = "Bearer {}".format(oauth_token)
     else:
         req_headers.update(urllib3.make_headers(basic_auth="{0}:{1}".format(key, secret)))
@@ -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.44.4 → cloudinary-1.46.0}/cloudinary/provisioning/__init__.py

@@ -1,5 +1,6 @@
 from .account_config import AccountConfig, account_config, reset_config
-from .account import (sub_accounts, create_sub_account, delete_sub_account, sub_account, update_sub_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,
                       users, create_user, delete_user, user, update_user, access_keys, generate_access_key,

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

@@ -1,6 +1,8 @@
-from cloudinary.api_client.call_account_api import _call_account_api
+from cloudinary.api_client.call_account_api import _call_account_api, _call_public_account_api, ACCOUNT_SUB_PATH
 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"
@@ -20,6 +22,100 @@ class Role(object):
     MEDIA_LIBRARY_USER = "media_library_user"
 
 
+def create_agent_account(email, agent_framework, agent_llm_model, agent_goal, sdk_framework=None, **options):
+    """
+    Create a Cloudinary account on behalf of a human, intended for use by AI agents.
+
+    Creates a Free-plan account with a single, initially disabled product environment and sends a
+    verification email so the human can set a password and activate the account. The returned
+    credentials are inert until the email is verified.
+
+    This endpoint is public and unauthenticated, and is rate-limited per IP address.
+
+    :param email:           The email address of the human on whose behalf the account is created.
+                            A verification email is sent to this address.
+    :type email:            str
+    :param agent_framework: The name of the agent framework used to create the account.
+                            Must be between 2 and 100 characters.
+    :type agent_framework:  str
+    :param agent_llm_model: The LLM model powering the agent. Must be between 2 and 100 characters.
+    :type agent_llm_model:  str
+    :param agent_goal:      A short description of what the agent is trying to achieve.
+                            Must be between 2 and 300 characters.
+    :type agent_goal:       str
+    :param sdk_framework:   The Cloudinary SDK framework the agent intends to use.
+                            Must be between 2 and 100 characters.
+    :type sdk_framework:    str, optional
+    :param options:         Generic advanced options dict, see online documentation
+    :type options:          dict, optional
+    :return:                The created agent account, including inert credentials for its
+                            single product environment
+    :rtype:                 dict
+    """
+    uri = [AGENTS_SUB_PATH, ACCOUNT_SUB_PATH]
+    params = {"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 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
@@ -123,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
@@ -131,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), 
@@ -153,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.44.4 → 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