Support python 2/3, and Django 1.7/1.9

* `assertEquals`, `assertRaisesRegexp` have been deprecated in python 3
* `iteritems` is not supported in python 3
* `str` and `bytes` are handled separately in python 3
* `xrange` is not supported in python 3
* `mark_safe` is required in Django 1.9 to add tags to HTML

Author: tocker

cloudinary/compat.py

@@ -15,6 +15,7 @@
     to_bytearray = lambda s: bytearray(s, 'utf8')
     to_string = lambda b: b.decode('utf8')
     string_types = (str)
+
 else:
     import httplib
     from httplib import NotConnected
@@ -29,6 +30,12 @@
     to_string = str
     string_types = (str, unicode)
 
+try:
+    cldrange = xrange
+except NameError:
+    def cldrange(*args, **kwargs):
+        return iter(range(*args, **kwargs))
+
 try:
     advance_iterator = next
 except NameError:

cloudinary/poster/encode.py

@@ -56,7 +56,13 @@ def encode_and_quote(data):
     def _strify(s):
         if s is None:
             return None
-        return to_bytes(s)
+        elif isinstance(s, bytes):
+            return s
+        else:
+            try:
+                return to_bytes(s)
+            except AttributeError:
+                return to_bytes(str(s))
 else:
     def _strify(s):
         """If s is a unicode string, encode it to UTF-8 and return the results, otherwise return str(s), or None if s is None"""
@@ -236,10 +242,10 @@ def encode(self, boundary):
         else:
             value = self.value
 
-        if re.search("^--%s$" % re.escape(boundary), value, re.M):
+        if re.search(to_bytes("^--%s$" % re.escape(boundary)), value, re.M):
             raise ValueError("boundary found in encoded string")
 
-        return "%s%s\r\n" % (self.encode_hdr(boundary), value)
+        return to_bytes(self.encode_hdr(boundary)) + value + b"\r\n"
 
     def iter_encode(self, boundary, blocksize=4096):
         """Yields the encoding of this parameter
@@ -248,7 +254,7 @@ def iter_encode(self, boundary, blocksize=4096):
         total = self.get_size(boundary)
         current = 0
         if self.value is not None:
-            block = to_bytes(self.encode(boundary))
+            block = self.encode(boundary)
             current += len(block)
             yield block
             if self.cb:

cloudinary/templatetags/cloudinary.py

@@ -4,6 +4,7 @@
 
 from django import template
 from django.forms import Form
+from django.utils.safestring import mark_safe
 
 import cloudinary
 from cloudinary import CloudinaryResource, utils, uploader
@@ -34,7 +35,7 @@ def cloudinary_tag(context, image, options_dict={}, **options):
         pass
     if not isinstance(image, CloudinaryResource):
         image = CloudinaryResource(image)
-    return image.image(**options)
+    return mark_safe(image.image(**options))
 
 @register.simple_tag
 def cloudinary_direct_upload_field(field_name="image", request=None):

cloudinary/utils.py

@@ -11,7 +11,7 @@
 
 RANGE_VALUE_RE = r'^(?P<value>(\d+\.)?\d+)(?P<modifier>[%pP])?$'
 RANGE_RE = r'^(\d+\.)?\d+[%pP]?\.\.(\d+\.)?\d+[%pP]?$'
-__LAYER_KEYWORD_PARAMS = dict(font_weight = "normal", font_style = "normal", text_decoration = "none", text_align = None, stroke = "none")
+__LAYER_KEYWORD_PARAMS = [("font_weight", "normal"), ("font_style", "normal"), ("text_decoration", "none"), ("text_align", None), ("stroke", "none")]
 
 def build_array(arg):
     if isinstance(arg, list):
@@ -222,7 +222,7 @@ def generate_responsive_breakpoints_string(breakpoints):
     if breakpoints is None:
         return None
     breakpoints = build_array(breakpoints)
-    return json.dumps(map(breakpoint_settings_mapper, breakpoints))
+    return json.dumps(list(map(breakpoint_settings_mapper, breakpoints)))
 
 def finalize_source(source, format, url_suffix):
     source = re.sub(r'([^:])/+', r'\1/', source)
@@ -512,7 +512,7 @@ def __process_text_options(layer, layer_parameter):
     font_family = layer.get("font_family")
     font_size = layer.get("font_size")
     keywords = []
-    for attr, default_value in __LAYER_KEYWORD_PARAMS.iteritems():
+    for attr, default_value in __LAYER_KEYWORD_PARAMS:
         attr_value =layer.get(attr)
         if (attr_value != default_value and attr_value is not None):
             keywords.append(attr_value)

tests/api_test.py

@@ -6,6 +6,11 @@
 class ApiTest(unittest.TestCase):
     initialized = False
     def setUp(self):
+        try:
+            self.assertRaisesRegex
+        except AttributeError:
+            self.assertRaisesRegex = self.assertRaisesRegexp
+
         if ApiTest.initialized: return
         ApiTest.initialized = True
         cloudinary.reset_config()
@@ -14,13 +19,17 @@ def setUp(self):
             api.delete_resources(["api_test", "api_test2", "api_test3"])
         except:
             pass
-        for transformation in ["api_test_transformation", "api_test_transformation2", "api_test_transformation3",
-                               "api_test_upload_preset", "api_test_upload_preset2", "api_test_upload_preset3",
-                               "api_test_upload_preset4"]:          
+        for transformation in ["api_test_transformation", "api_test_transformation2", "api_test_transformation3"]:
           try:
               api.delete_transformation(transformation)
           except:
               pass
+        for transformation in ["api_test_upload_preset", "api_test_upload_preset2", "api_test_upload_preset3",
+                               "api_test_upload_preset4"]:
+          try:
+              api.delete_upload_preset(transformation)
+          except:
+              pass
         ApiTest.timestamp_tag = "api_test_tag_{0}".format(utils.now())
         uploader.upload("tests/logo.png", public_id="api_test", tags=["api_test_tag", self.timestamp_tag], context="key=value", eager=[{"width": 100,"crop": "scale"}])
         uploader.upload("tests/logo.png", public_id="api_test2", tags=["api_test_tag", self.timestamp_tag], context="key=value", eager=[{"width": 100,"crop": "scale"}])
@@ -267,25 +276,25 @@ def test20_manual_moderation(self):
     def test22_raw_conversion(self):
         """ should support requesting raw_convert """ 
         resource = uploader.upload("tests/docx.docx", resource_type="raw")
-        with self.assertRaisesRegexp(api.BadRequest, 'Illegal value'): 
+        with self.assertRaisesRegex(api.BadRequest, 'Illegal value'): 
             api.update(resource["public_id"], raw_convert="illegal", resource_type="raw")
 
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
     def test23_categorization(self):
         """ should support requesting categorization """
-        with self.assertRaisesRegexp(api.BadRequest, 'Illegal value'): 
+        with self.assertRaisesRegex(api.BadRequest, 'Illegal value'): 
             api.update("api_test", categorization="illegal")
 
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
     def test24_detection(self):
         """ should support requesting detection """
-        with self.assertRaisesRegexp(api.BadRequest, 'Illegal value'): 
+        with self.assertRaisesRegex(api.BadRequest, 'Illegal value'): 
             api.update("api_test", detection="illegal")
 
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
     def test26_auto_tagging(self):
         """ should support requesting auto_tagging """
-        with self.assertRaisesRegexp(api.BadRequest, 'Must use'): 
+        with self.assertRaisesRegex(api.BadRequest, 'Must use'): 
             api.update("api_test", auto_tagging=0.5)
 
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
@@ -358,7 +367,7 @@ def test31_update_upload_presets(self):
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
     def test32_background_removal(self):
         """ should support requesting background_removal """
-        with self.assertRaisesRegexp(api.BadRequest, 'Illegal value'): 
+        with self.assertRaisesRegex(api.BadRequest, 'Illegal value'): 
             api.update("api_test", background_removal="illegal")
 
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
@@ -377,7 +386,7 @@ def test_folder_listing(self):
         result = api.subfolders("test_folder1")
         self.assertEqual(result["folders"][0]["path"], "test_folder1/test_subfolder1")
         self.assertEqual(result["folders"][1]["path"], "test_folder1/test_subfolder2")
-        with self.assertRaisesRegexp(api.NotFound): 
+        with self.assertRaisesRegex(api.NotFound): 
             api.subfolders("test_folder")
         api.delete_resources_by_prefix("test_folder")
 
@@ -390,7 +399,7 @@ def test_CloudinaryImage_len(self):
                 "signature": "5678",
                 }
         myCloudinaryImage = cloudinary.CloudinaryImage(metadata=metadata)
-        self.assertEquals(len(myCloudinaryImage), len(metadata["public_id"]))
+        self.assertEqual(len(myCloudinaryImage), len(metadata["public_id"]))
 
     @unittest.skipUnless(cloudinary.config().api_secret, "requires api_key/api_secret")
     def test_restore(self):

tests/utils_test.py

@@ -2,6 +2,7 @@
 import unittest
 import re
 from fractions import Fraction
+from cloudinary.compat import cldrange
 
 DEFAULT_ROOT_PATH = 'http://res.cloudinary.com/test123/'
 DEFAULT_UPLOAD_PATH = 'http://res.cloudinary.com/test123/image/upload/'
@@ -471,11 +472,11 @@ def test_overlay_options(self):
             dict(resource_type = "subtitles",public_id = "sample_sub_he.srt", font_family = "Arial", font_size = 40),"subtitles:Arial_40:sample_sub_he.srt"
         ]
 
-        for i in xrange(0, len(tests), 2):
+        for i in cldrange(0, len(tests), 2):
             options = tests[i]
             expected = tests[i + 1]
             result = cloudinary.utils.process_layer(options, "overlay")
-            self.assertEqual(result, expected)
+            self.assertEqual(expected, result)
 
     def test_overlay_error_1(self):
         """ Must supply font_family for text in overlay """