def test_get_prep_value(self): res = CloudinaryResource(metadata=self.uploaded) value = "image/upload/v{version}/{id}.{format}".format( version=self.uploaded["version"], id=self.uploaded["public_id"], format=self.uploaded["format"]) self.assertEqual(value, res.get_prep_value())
def test_get_presigned(self): res = CloudinaryResource(metadata=self.uploaded) value = "image/upload/v{version}/{id}.{format}#{signature}".format(version=self.uploaded["version"], id=self.uploaded["public_id"], format=self.uploaded["format"], signature=self.uploaded["signature"]) self.assertEqual(value, res.get_presigned())
def test_to_python(self): c = CloudinaryField('image') res = CloudinaryResource(public_id=API_TEST_ID, format='jpg') # Can't compare the objects, so compare url instead self.assertEqual( c.to_python('{}.jpg'.format(API_TEST_ID)).build_url(), res.build_url())
def test_image(self): res = CloudinaryResource(metadata=self.uploaded) image = res.image() self.assertRegexpMatches(image, '[^-]src="{url}'.format(url=res.url)) self.assertNotRegexpMatches(image, 'data-src="{url}'.format(url=res.url)) image = res.image(responsive=True, width="auto", crop="scale") self.assertNotRegexpMatches(image, '[^-]src="{url}'.format(url=res.build_url(width="auto", crop="scale"))) self.assertRegexpMatches(image, 'data-src="{url}'.format(url=res.build_url(width="auto", crop="scale")))
def cloudinary_tag(context, image, options_dict={}, **options): options = dict(options_dict, **options) try: if context['request'].is_secure() and 'secure' not in options: options['secure'] = True except KeyError: pass if not isinstance(image, CloudinaryResource): image = CloudinaryResource(image) return image.image(**options)
def cloudinary_url(context, source, options_dict={}, **options): options = dict(options_dict, **options) try: if context['request'].is_secure() and 'secure' not in options: options['secure'] = True except KeyError: pass if not isinstance(source, CloudinaryResource): source = CloudinaryResource(source) return source.build_url(**options)
def cloudinary_static(context, image, options_dict={}, **options): options = dict(options_dict, **options) try: if context['request'].is_secure() and 'secure' not in options: options['secure'] = True except KeyError: pass if not isinstance(image, CloudinaryResource): image = staticfiles_storage.stored_name(image) image = CloudinaryResource(image) return mark_safe(image.image(**options))
def to_python(self, value): """Convert to CloudinaryResource""" if not value: return None if value.split("/")[0] != "image": return None m = re.search(r'^([^/]+)/([^/]+)/v(\d+)/([^#]+)#([^/]+)$', value) if not m: raise forms.ValidationError("Invalid format") resource_type = m.group(1) upload_type = m.group(2) version = m.group(3) filename = m.group(4) signature = m.group(5) m = re.search(r'(.*)\.(.*)', filename) if not m: raise forms.ValidationError("Invalid file name") public_id = m.group(1) image_format = m.group(2) return CloudinaryResource(public_id, format=image_format, version=version, signature=signature, type=upload_type, resource_type=resource_type)
def test_empty_class(self): """An empty CloudinaryResource""" self.shortDescription() res = CloudinaryResource() self.assertFalse(res, "should be 'False'") self.assertEqual(len(res), 0, "should have zero len()") self.assertIsNone(res.url, "should have None url")
def parse_cloudinary_resource(self, value): m = re.match(CLOUDINARY_FIELD_DB_RE, value) resource_type = m.group('resource_type') or self.resource_type upload_type = m.group('type') or self.type return CloudinaryResource(type=upload_type, resource_type=resource_type, version=m.group('version'), public_id=m.group('public_id'), format=m.group('format'))
def to_python(self, value): if isinstance(value, CloudinaryResource): return value elif isinstance(value, UploadedFile): return value elif not value: return value else: m = re.match(CLOUDINARY_FIELD_DB_RE, value) resource_type = m.group('resource_type') or self.resource_type type = m.group('type') or self.type return CloudinaryResource(type=type,resource_type=resource_type,version=m.group('version'),public_id=m.group('public_id'),format=m.group('format'))
def _attach_file(self, file: File, **options): cloudinary_options = self.get_cloudinary_options() cloudinary_options.update(options.get('cloudinary', {})) if file.size >= 100 * 1024 * 1024: upload = uploader.upload_large else: upload = uploader.upload file_field = self.get_file_field() try: result = upload( file, type=file_field.type, resource_type=file_field.resource_type, **cloudinary_options, ) except cloudinary.exceptions.Error as e: if e.args and 'Unsupported file type' in e.args[0]: raise exceptions.UnsupportedFileError( _('File `%s` is not an image') % file.name) else: raise ValidationError(*e.args) # fix difference between `public_id` in response # and `public_id` in CloudinaryField file_format = result.get("format") if file_format: public_id = result["public_id"] else: public_id, file_format = posixpath.splitext(result["public_id"]) file_format = file_format.lstrip('.') resource = CloudinaryResource( public_id, version=str(result["version"]), format=file_format, type=result["type"], resource_type=result["resource_type"], metadata=result, ) self.set_file(resource) self.basename = helpers.get_filename(file.name) self.extension = file_format or '' return result
def photo(self, request, pk=None): file = request.data.get('image') u = cloudinary_uploader.upload(file) instance = self.get_object() instance.avatar = CloudinaryResource(u['public_id'], u['format'], u['version'], u['signature'], type=u['type'], resource_type=u['resource_type']) instance.save() serializer = self.get_read_serializer(instance) return Response(serializer.data)
def photo(self, request, pk=None): file = request.data.get('image') u = cloudinary_uploader.upload(file) employee = self.queryset.get(id=pk) employee.profile_img = CloudinaryResource( u['public_id'], u['format'], u['version'], u['signature'], type=u['type'], resource_type=u['resource_type']) employee.save() return Response({'url': u['url']}, status=status.HTTP_200_OK)
def _rename_file(self, new_name: str, **options): # TODO: Cloudinary can't copy files. We dont't want to do it manually cloudinary_options = self.get_cloudinary_options() cloudinary_options.update(options.get('cloudinary', {})) old_name = self.name file_field = self.get_file_field() folder, basename = posixpath.split(old_name) if file_field.resource_type != 'raw': # video and image have no extension base, ext = posixpath.splitext(new_name) new_name = base new_name = posixpath.join(folder, new_name) try: result = uploader.rename(old_name, new_name, type=file_field.type, resource_type=file_field.resource_type, **cloudinary_options) except cloudinary.exceptions.Error as e: raise ValidationError(*e.args) # fix difference between `public_id` in response # and `public_id` in CloudinaryField file_format = result.get("format") if file_format: public_id = result["public_id"] else: public_id, file_format = posixpath.splitext(result["public_id"]) file_format = file_format.lstrip('.') resource = CloudinaryResource( public_id, version=str(result["version"]), format=file_format, type=result["type"], resource_type=result["resource_type"], metadata=result, ) self.set_file(resource) self.basename = helpers.get_filename(new_name) self.extension = file_format or '' return result
def test_uploaded_metadata(self, storage): resource = CloudinaryResource(storage.resource.public_id, type=self.type, resource_type=self.resource_type) file = CloudinaryFieldFile(resource, checksum=self.resource_checksum) meta = file.metadata assert 'asset_id' in meta assert 'public_id' in meta assert 'version' in meta assert 'version_id' in meta assert 'signature' in meta assert 'resource_type' in meta assert 'created_at' in meta assert 'bytes' in meta assert 'type' in meta assert 'url' in meta assert 'secure_url' in meta
def test_url(self): res = CloudinaryResource(metadata=self.uploaded) self.assertEqual(res.url, self.uploaded["url"])
def setUp(self): self.res = CloudinaryResource(metadata=self.uploaded)
class TestCloudinaryResource(TestCase): mocked_response = http_response_mock('{"breakpoints": [50, 500, 1000]}') mocked_breakpoints = [50, 500, 1000] expected_transformation = "c_scale,w_auto:breakpoints_50_1000_20_20:json" crop_transformation = {'crop': 'crop', 'width': 100} crop_transformation_str = 'c_crop,w_100' @classmethod def setUpClass(cls): cloudinary.reset_config() cls.uploaded = uploader.upload(TEST_IMAGE, public_id=TEST_ID, tags=TEST_TAG) @classmethod def tearDownClass(cls): api.delete_resources_by_tag(TEST_TAG) def setUp(self): self.res = CloudinaryResource(metadata=self.uploaded) def test_empty_class(self): """An empty CloudinaryResource""" self.shortDescription() res = CloudinaryResource() self.assertFalse(res, "should be 'False'") self.assertEqual(len(res), 0, "should have zero len()") self.assertIsNone(res.url, "should have None url") def test_validate(self): self.assertTrue(self.res.validate()) self.assertTrue(self.res) self.assertGreater(len(self.res), 0) def test_get_prep_value(self): value = "image/upload/v{version}/{id}.{format}".format( version=self.uploaded["version"], id=self.uploaded["public_id"], format=self.uploaded["format"]) self.assertEqual(value, self.res.get_prep_value()) def test_get_presigned(self): value = "image/upload/v{version}/{id}.{format}#{signature}".format( version=self.uploaded["version"], id=self.uploaded["public_id"], format=self.uploaded["format"], signature=self.uploaded["signature"]) self.assertEqual(value, self.res.get_presigned()) def test_url(self): self.assertEqual(self.res.url, self.uploaded["url"]) def test_image(self): image = self.res.image() self.assertIn(' src="{url}'.format(url=self.res.url), image) self.assertNotIn('data-src="{url}'.format(url=self.res.url), image) image = self.res.image(responsive=True, width="auto", crop="scale") self.assertNotIn( ' src="{url}'.format( url=self.res.build_url(width="auto", crop="scale")), image) self.assertIn( 'data-src="{url}'.format( url=self.res.build_url(width="auto", crop="scale")), image) @mock.patch('urllib3.request.RequestMethods.request', return_value=mocked_response) def test_fetch_breakpoints(self, mocked_request): """Should retrieve responsive breakpoints from cloudinary resource (mocked)""" actual_breakpoints = self.res._fetch_breakpoints() self.assertEqual(self.mocked_breakpoints, actual_breakpoints) self.assertIn(self.expected_transformation, get_request_url(mocked_request)) @mock.patch('urllib3.request.RequestMethods.request', return_value=mocked_response) def test_fetch_breakpoints_with_transformation(self, mocked_request): """Should retrieve responsive breakpoints from cloudinary resource with custom transformation (mocked)""" srcset = {"transformation": self.crop_transformation} actual_breakpoints = self.res._fetch_breakpoints(srcset) self.assertEqual(self.mocked_breakpoints, actual_breakpoints) self.assertIn( self.crop_transformation_str + "/" + self.expected_transformation, get_request_url(mocked_request)) def test_fetch_breakpoints_real(self): """Should retrieve responsive breakpoints from cloudinary resource (real request)""" actual_breakpoints = self.res._fetch_breakpoints() self.assertIsInstance(actual_breakpoints, list) self.assertGreater(len(actual_breakpoints), 0)
def test_to_python(self): c = CloudinaryField('image') res = CloudinaryResource(public_id='sample', format='jpg') # Can't compare the objects, so compare url instead self.assertEqual(c.to_python('sample.jpg').build_url(), res.build_url())
def test_to_python(self): c = CloudinaryField('image') res = CloudinaryResource(public_id=API_TEST_ID, format='jpg') # Can't compare the objects, so compare url instead self.assertEqual(c.to_python('{}.jpg'.format(API_TEST_ID)).build_url(), res.build_url())
def test_uploaded_format(self, storage): resource = CloudinaryResource(storage.resource.public_id, type=self.type, resource_type=self.resource_type) file = CloudinaryFieldFile(resource, checksum=self.resource_checksum) assert file.format == 'mp3'
def test_to_python(self): c = CloudinaryField('image') res = CloudinaryResource(public_id='sample', format='jpg') # Can't compare the objects, so compare url instead self.assertEqual( c.to_python('sample.jpg').build_url(), res.build_url())
def post(self, request): form = ConstructorForm(request.POST, request.FILES) if form.is_valid(): im = Image.open("static/img/template-{}.png".format(form.cleaned_data["sex"])) is_pattern = form.cleaned_data["is_pattern"] print(is_pattern) bg = form.cleaned_data["background"] if is_pattern: imP = Image.open(form.cleaned_data["file"]) width, height = imP.size # Get dimensions left = (width - 1000) / 2 top = (height - 1000) / 2 right = (width + 1000) / 2 bottom = (height + 1000) / 2 imP = imP.crop((left, top, right, bottom)) else: imP = Image.new("RGBA", size=(1000, 1000), color=(int(bg[1:3], 16), int(bg[3:5], 16), int(bg[5:7], 16), 255)) imP.paste(im, (0, 0), im) im = imP.copy() if not is_pattern and form.cleaned_data["file"]: imPR = Image.open(form.cleaned_data["file"]) ratio = (imPR.size[0] / 250) r_imPR = imPR.resize((250, int(imPR.size[1] / ratio))) pos = (500 - r_imPR.size[0] // 2, 500 - r_imPR.size[1] // 2) im.paste(r_imPR, pos) im.save("temp/temp.png") resp = cloudinary.uploader.upload('temp/temp.png') result = CloudinaryResource( public_id=resp['public_id'], type=resp['type'], resource_type=resp['resource_type'], version=resp['version'], format=resp['format'], ) str_result = result.get_prep_value() if request.FILES: resp2 = cloudinary.uploader.upload(File.open(request.FILES["file"], "rb")) result2 = CloudinaryResource( public_id=resp2['public_id'], type=resp2['type'], resource_type=resp2['resource_type'], version=resp2['version'], format=resp2['format'], ) str_result2 = result2.get_prep_value() else: str_result2 = None tshirt = TShirt.objects.create( user=request.user, name=form.cleaned_data["name"], description=form.cleaned_data["description"], image=str_result, sex=form.cleaned_data["sex"], uploaded_image=str_result2, background=form.cleaned_data["background"], is_pattern=form.cleaned_data["is_pattern"], ) tshirt.topic.set(form.cleaned_data["topic"]) tshirt.tag.set(form.cleaned_data["tag"]) return redirect('design_view', tshirt_id=tshirt.id) else: data = { "form": form, } return render(request, "core/constructor.html", context=data)
class TestCloudinaryResource(TestCase): mocked_response = http_response_mock('{"breakpoints": [50, 500, 1000]}') mocked_breakpoints = [50, 500, 1000] expected_transformation = "c_scale,w_auto:breakpoints_50_1000_20_20:json" crop_transformation = {'crop': 'crop', 'width': 100} crop_transformation_str = 'c_crop,w_100' @classmethod def setUpClass(cls): cloudinary.reset_config() cls.uploaded = uploader.upload(TEST_IMAGE, public_id=TEST_ID, tags=TEST_TAG) @classmethod def tearDownClass(cls): cleanup_test_resources_by_tag([(TEST_TAG,)]) def setUp(self): self.res = CloudinaryResource(metadata=self.uploaded) def test_empty_class(self): """An empty CloudinaryResource""" self.shortDescription() res = CloudinaryResource() self.assertFalse(res, "should be 'False'") self.assertEqual(len(res), 0, "should have zero len()") self.assertIsNone(res.url, "should have None url") def test_validate(self): self.assertTrue(self.res.validate()) self.assertTrue(self.res) self.assertGreater(len(self.res), 0) def test_get_prep_value(self): value = "image/upload/v{version}/{id}.{format}".format( version=self.uploaded["version"], id=self.uploaded["public_id"], format=self.uploaded["format"]) self.assertEqual(value, self.res.get_prep_value()) def test_get_presigned(self): value = "image/upload/v{version}/{id}.{format}#{signature}".format( version=self.uploaded["version"], id=self.uploaded["public_id"], format=self.uploaded["format"], signature=self.uploaded["signature"]) self.assertEqual(value, self.res.get_presigned()) def test_url(self): self.assertEqual(self.res.url, self.uploaded["url"]) def test_image(self): image = self.res.image() self.assertIn(' src="{url}'.format(url=self.res.url), image) self.assertNotIn('data-src="{url}'.format(url=self.res.url), image) image = self.res.image(responsive=True, width="auto", crop="scale") self.assertNotIn(' src="{url}'.format(url=self.res.build_url(width="auto", crop="scale")), image) self.assertIn('data-src="{url}'.format(url=self.res.build_url(width="auto", crop="scale")), image) @mock.patch('urllib3.request.RequestMethods.request', return_value=mocked_response) def test_fetch_breakpoints(self, mocked_request): """Should retrieve responsive breakpoints from cloudinary resource (mocked)""" actual_breakpoints = self.res._fetch_breakpoints() self.assertEqual(self.mocked_breakpoints, actual_breakpoints) self.assertIn(self.expected_transformation, get_request_url(mocked_request)) @mock.patch('urllib3.request.RequestMethods.request', return_value=mocked_response) def test_fetch_breakpoints_with_transformation(self, mocked_request): """Should retrieve responsive breakpoints from cloudinary resource with custom transformation (mocked)""" srcset = {"transformation": self.crop_transformation} actual_breakpoints = self.res._fetch_breakpoints(srcset) self.assertEqual(self.mocked_breakpoints, actual_breakpoints) self.assertIn(self.crop_transformation_str + "/" + self.expected_transformation, get_request_url(mocked_request)) def test_fetch_breakpoints_real(self): """Should retrieve responsive breakpoints from cloudinary resource (real request)""" actual_breakpoints = self.res._fetch_breakpoints() self.assertIsInstance(actual_breakpoints, list) self.assertGreater(len(actual_breakpoints), 0)
def test_validate(self): res = CloudinaryResource(metadata=self.uploaded) self.assertTrue(res.validate()) self.assertTrue(res) self.assertGreater(len(res), 0)