cloudinary 1.44.3__tar.gz → 1.45.0__tar.gz

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

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

{cloudinary-1.44.3 → cloudinary-1.45.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.3"
+VERSION = "1.45.0"
 
 _USER_PLATFORM_DETAILS = "; ".join((platform(), "Python {}".format(python_version())))
 

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

@@ -8,22 +8,43 @@ 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):
-    prefix = options.pop("upload_prefix",
-                         cloudinary.config().upload_prefix) or "https://api.cloudinary.com"
+    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)
+    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")
-    provisioning_api_url = "/".join(
-        [prefix, cloudinary.API_VERSION, PROVISIONING_SUB_PATH, ACCOUNT_SUB_PATH, account_id] + uri)
-    auth = {"key": provisioning_api_key, "secret": 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)
 
     return execute_request(http_connector=_http,
                            method=method,

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

@@ -41,14 +41,14 @@ class Response(dict):
 
 
 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)))

{cloudinary-1.44.3 → cloudinary-1.45.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,
+                      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.3 → cloudinary-1.45.0}/cloudinary/provisioning/account.py

@@ -1,6 +1,7 @@
-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"
 SUB_ACCOUNTS_SUB_PATH = "sub_accounts"
 USERS_SUB_PATH = "users"
 USER_GROUPS_SUB_PATH = "user_groups"
@@ -20,6 +21,45 @@ 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 sub_accounts(enabled=None, ids=None, prefix=None, **options):
     """
     List all sub accounts

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

@@ -642,6 +642,8 @@ def api_sign_request(params_to_sign, api_secret, algorithm=SIGNATURE_SHA1, signa
         - Version 2+: Includes parameter encoding to prevent parameter smuggling
     :return: Computed signature
     """
+    if not api_secret:
+        raise ValueError("Must supply api_secret")
     to_sign = api_string_to_sign(params_to_sign, signature_version)
     return compute_hex_hash(to_sign + api_secret, algorithm)
 
@@ -875,6 +877,8 @@ def cloudinary_url(source, **options):
 
     signature = None
     if sign_url and (not auth_token or auth_token.pop('set_url_signature', False)):
+        if not api_secret:
+            raise ValueError("Must supply api_secret")
         to_sign = "/".join(__compact([transformation, source_to_sign]))
         if long_url_signature:
             # Long signature forces SHA256

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

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

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

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

{cloudinary-1.44.3 → cloudinary-1.45.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.44.3"
+    version = "1.45.0"
 
     with open('README.md') as file:
         long_description = file.read()

{cloudinary-1.44.3 → cloudinary-1.45.0}/test/test_provisioning_api.py

@@ -1,3 +1,4 @@
+import json
 import unittest
 from datetime import datetime
 
@@ -8,7 +9,8 @@ import cloudinary.provisioning.account
 from cloudinary.provisioning import account_config, reset_config
 from cloudinary.exceptions import AuthorizationRequired, NotFound
 
-from test.helper_test import UNIQUE_SUB_ACCOUNT_ID, UNIQUE_TEST_ID
+from test.helper_test import (UNIQUE_SUB_ACCOUNT_ID, UNIQUE_TEST_ID, URLLIB3_REQUEST, patch, api_response_mock,
+                              get_uri, get_method, get_params, get_headers)
 
 disable_warnings()
 
@@ -85,6 +87,7 @@ class AccountApiTest(unittest.TestCase):
     @unittest.skipUnless(cloudinary.provisioning.account_config().provisioning_api_secret,
                          "requires provisioning_api_key/provisioning_api_secret")
     def test_get_all_sub_accounts(self):
+
         res = cloudinary.provisioning.sub_accounts(True)
 
         sub_account_by_id = [sub_account for sub_account in res["sub_accounts"]
@@ -264,5 +267,93 @@ class AccountApiTest(unittest.TestCase):
         self.assertEqual("ok", named_key_del_res["message"])
 
 
+class CreateAgentAccountTest(unittest.TestCase):
+    """
+    The create agent account endpoint is public, unauthenticated and rate limited per IP,
+    so it is verified against a mocked transport rather than the live API.
+    """
+
+    def test_create_agent_account(self):
+        with patch(URLLIB3_REQUEST) as mocker:
+            mocker.return_value = api_response_mock()
+            cloudinary.provisioning.create_agent_account(
+                "jane@example.com",
+                agent_framework="langchain",
+                agent_llm_model="claude-opus-4-8",
+                agent_goal="Build a product image gallery",
+                sdk_framework="python",
+            )
+
+        self.assertEqual("POST", get_method(mocker))
+        self.assertTrue(get_uri(mocker).endswith("/provisioning/agents/accounts"))
+
+        params = get_params(mocker)
+        self.assertEqual("jane@example.com", params["email"])
+        self.assertEqual("langchain", params["agent_framework"])
+        self.assertEqual("claude-opus-4-8", params["agent_llm_model"])
+        self.assertEqual("Build a product image gallery", params["agent_goal"])
+        self.assertEqual("python", params["sdk_framework"])
+
+    def test_create_agent_account_is_unauthenticated(self):
+        with patch(URLLIB3_REQUEST) as mocker:
+            mocker.return_value = api_response_mock()
+            cloudinary.provisioning.create_agent_account(
+                "jane@example.com",
+                agent_framework="langchain",
+                agent_llm_model="claude-opus-4-8",
+                agent_goal="Build a product image gallery",
+            )
+
+        # The endpoint is public - no authorization header must be sent.
+        headers = get_headers(mocker)
+        self.assertNotIn("authorization", {k.lower() for k in headers})
+
+    def test_create_agent_account_omits_unset_sdk_framework(self):
+        with patch(URLLIB3_REQUEST) as mocker:
+            mocker.return_value = api_response_mock()
+            cloudinary.provisioning.create_agent_account(
+                "jane@example.com",
+                agent_framework="langchain",
+                agent_llm_model="claude-opus-4-8",
+                agent_goal="Build a product image gallery",
+            )
+
+        self.assertNotIn("sdk_framework", get_params(mocker))
+
+    def test_create_agent_account_parses_response(self):
+        body = json.dumps({
+            "external_id": "0aaaaa1bbbbb2ccccc3ddddd4eeeee5f",
+            "email": "jane@example.com",
+            "plan_name": "free",
+            "product_environments": [{
+                "external_id": "abcde1fghij2klmno3pqrst4uvwxy5z",
+                "cloud_name": "product1",
+                "api_key": "123456789012345",
+                "api_secret": "asdf1JKL2xyz3ABc4s3c5reT01DfaKez",
+                "api_environment_variable":
+                    "CLOUDINARY_URL=cloudinary://123456789012345:asdf1JKL2xyz3ABc4s3c5reT01DfaKez@product1",
+            }],
+            "guidance": "A verification email has been sent to the supplied email address.",
+        })
+        with patch(URLLIB3_REQUEST) as mocker:
+            mocker.return_value = api_response_mock(body)
+            res = cloudinary.provisioning.create_agent_account(
+                "jane@example.com",
+                agent_framework="langchain",
+                agent_llm_model="claude-opus-4-8",
+                agent_goal="Build a product image gallery",
+            )
+
+        self.assertEqual("free", res["plan_name"])
+        self.assertEqual("jane@example.com", res["email"])
+        self.assertEqual(1, len(res["product_environments"]))
+        product_environment = res["product_environments"][0]
+        self.assertEqual("product1", product_environment["cloud_name"])
+        self.assertEqual("123456789012345", product_environment["api_key"])
+        self.assertEqual("asdf1JKL2xyz3ABc4s3c5reT01DfaKez", product_environment["api_secret"])
+        self.assertIn("CLOUDINARY_URL=cloudinary://", product_environment["api_environment_variable"])
+        self.assertIn("guidance", res)
+
+
 if __name__ == '__main__':
     unittest.main()

{cloudinary-1.44.3 → cloudinary-1.45.0}/test/test_utils.py

@@ -21,6 +21,7 @@ from cloudinary.utils import (
     encode_unicode_url,
     base64url_encode,
     patch_fetch_format,
+    cloudinary_url,
     cloudinary_scaled_url,
     chain_transformations,
     generate_transformation_string,
@@ -1591,6 +1592,54 @@ class TestUtils(unittest.TestCase):
         self.assertEqual(signed_params_v1['signature'], expected_sig_v1)
         self.assertEqual(signed_params_v2['signature'], expected_sig_v2)
 
+    def test_cloudinary_url_sign_without_secret_raises(self):
+        """Signing without a secret should raise ValueError"""
+        cloudinary.config(cloud_name="test123", api_secret=None)
+        with self.assertRaises(ValueError) as context:
+            cloudinary_url("sample", sign_url=True)
+        self.assertEqual(str(context.exception), "Must supply api_secret")
+
+    def test_cloudinary_url_unsigned_without_secret_works(self):
+        """Unsigned URL should work without a secret"""
+        cloudinary.config(cloud_name="test123", api_secret=None)
+        url, _ = cloudinary_url("sample")
+        self.assertIn("test123", url)
+        self.assertNotIn("s--", url)
+
+    def test_cloudinary_url_sign_with_secret_works(self):
+        """Signing with a secret should work and include signature"""
+        cloudinary.config(cloud_name="test123", api_key="key", api_secret="secret")
+        url, _ = cloudinary_url("sample", sign_url=True)
+        self.assertIn("s--", url)
+        self.assertIn("test123", url)
+
+    def test_cloudinary_url_per_call_secret_override(self):
+        """Per-call api_secret override should sign successfully"""
+        cloudinary.config(cloud_name="test123", api_secret=None)
+        url, _ = cloudinary_url("sample", sign_url=True, api_secret="override_secret")
+        self.assertIn("s--", url)
+        self.assertIn("test123", url)
+
+    def test_api_sign_request_without_secret_raises(self):
+        """api_sign_request with None secret should raise ValueError"""
+        params = {"a": "b"}
+        with self.assertRaises(ValueError) as context:
+            api_sign_request(params, None)
+        self.assertEqual(str(context.exception), "Must supply api_secret")
+
+    def test_api_sign_request_with_empty_string_raises(self):
+        """api_sign_request with empty string secret should raise ValueError"""
+        params = {"a": "b"}
+        with self.assertRaises(ValueError) as context:
+            api_sign_request(params, "")
+        self.assertEqual(str(context.exception), "Must supply api_secret")
+
+    def test_api_sign_request_with_secret_works(self):
+        """api_sign_request with a real secret should work"""
+        params = dict(cloud_name=API_SIGN_REQUEST_CLOUD_NAME, timestamp=1568810420, username="user@cloudinary.com")
+        signature = api_sign_request(params, API_SIGN_REQUEST_TEST_SECRET)
+        self.assertEqual(signature, "14c00ba6d0dfdedbc86b316847d95b9e6cd46d94")
+
 
 if __name__ == '__main__':
     unittest.main()