Example #1
0
    def test_closing_of_filenames(self):
        """
        get_image_dimensions() called with a filename should closed the file.
        """
        # We need to inject a modified open() builtin into the images module
        # that checks if the file was closed properly if the function is
        # called with a filename instead of an file object.
        # get_image_dimensions will call our catching_open instead of the
        # regular builtin one.

        class FileWrapper(object):
            _closed = []
            def __init__(self, f):
                self.f = f
            def __getattr__(self, name):
                return getattr(self.f, name)
            def close(self):
                self._closed.append(True)
                self.f.close()

        def catching_open(*args):
            return FileWrapper(open(*args))

        from django.core.files import images
        images.open = catching_open
        try:
            get_image_dimensions(os.path.join(os.path.dirname(__file__), "test1.png"))
        finally:
            del images.open
        self.assertTrue(FileWrapper._closed)
Example #2
0
    def save(self, force_insert=False, force_update=False, **kwargs):
        """Overrides models.Model.save.

        - Generates slug.
        - Saves image file.
        """

        # prefill the slug with the ID, it requires double save
        if not self.id:
            if isinstance(self.image, UploadedFile):
                # due to PIL has read several bytes from image, position in file has to be reset
                self.image.seek(0)
            super(Photo, self).save(force_insert, force_update)
            self.width, self.height = get_image_dimensions(self.image.path)
            self.slug = str(self.id) + '-' + self.slug
            force_insert, force_update = False, True
            image_changed = False
        else:
            old = Photo.objects.get(pk = self.pk)
            image_changed = old.image != self.image
        # rename image by slug
        imageType = detect_img_type(self.image.path)
        if imageType is not None:
            self.image = file_rename(self.image.name, self.slug, PHOTOS_TYPE_EXTENSION[ imageType ])
        # delete formatedphotos if new image was uploaded
        if image_changed:
            super(Photo, self).save(force_insert=force_insert, force_update=force_update, **kwargs)
            self.width, self.height = get_image_dimensions(self.image.path)
            force_insert, force_update = False, True
            for f_photo in self.formatedphoto_set.all():
                f_photo.delete()
        super(Photo, self).save(force_insert=force_insert, force_update=force_update, **kwargs)
Example #3
0
 def test_not_closing_of_files(self):
     """
     Open files passed into get_image_dimensions() should stay opened.
     """
     empty_io = StringIO()
     try:
         get_image_dimensions(empty_io)
     finally:
         self.assertTrue(not empty_io.closed)
    def test_width(self, image):
        '''
        Make sure that if width shrinks, then height shrinks
        proportionally
        '''
        transformed_size = 10

        transform = simpleimages.transforms.Scale(width=transformed_size)
        new_image = transform(image.django_file)
        new_height, new_width = get_image_dimensions(new_image)
        assert get_image_dimensions(new_image) == (transformed_size,) * 2
    def test_over_large(self, image):
        '''
        if specified dimension is larger than image, it shouldn't enlarge
        the image
        '''
        transformed_size = 200

        transform = simpleimages.transforms.Scale(width=transformed_size)
        new_image = transform(image.django_file)
        new_height, new_width = get_image_dimensions(new_image)
        assert get_image_dimensions(new_image) == image.dimensions
Example #6
0
 def test_multiple_calls(self):
     """
     Multiple calls of get_image_dimensions() should return the same size.
     """
     from django.core.files.images import ImageFile
     img_path = os.path.join(os.path.dirname(__file__), "test.png")
     image = ImageFile(open(img_path))
     image_pil = Image.open(img_path)
     size_1, size_2 = get_image_dimensions(image), get_image_dimensions(image)
     self.assertEqual(image_pil.size, size_1)
     self.assertEqual(size_1, size_2)
Example #7
0
 def test_multiple_calls(self):
     """
     Multiple calls of get_image_dimensions() should return the same size.
     """
     img_path = os.path.join(os.path.dirname(upath(__file__)), "test.png")
     with open(img_path, 'rb') as fh:
         image = images.ImageFile(fh)
         image_pil = Image.open(fh)
         size_1 = images.get_image_dimensions(image)
         size_2 = images.get_image_dimensions(image)
     self.assertEqual(image_pil.size, size_1)
     self.assertEqual(size_1, size_2)
    def test_width_and_height(self, image):
        '''
        Make sure that if both are set, will shrink to max of either
        '''

        transform = simpleimages.transforms.Scale(width=10, height=10)

        image.dimensions = (100, 10)
        new_image = transform(image.django_file)
        assert get_image_dimensions(new_image)[0] == 10

        image.dimensions = (10, 100)
        new_image = transform(image.django_file)
        assert get_image_dimensions(new_image)[1] == 10
def save(self, *args, **kwargs):
    if self.thumbnail:
        from django.core.files.images import get_image_dimensions
        import django
        if django.VERSION[1] < 2:
            width, height = get_image_dimensions(self.thumbnail.file)
        else:
            width, height = get_image_dimensions(self.thumbnail.file, close=True)
    else:
        width, height = None, None

    self.thumbnail_width = width
    self.thumbnail_height = height

    super(Category, self).save(*args, **kwargs)
Example #10
0
    def clean_cover(self):
        cover = self.cleaned_data['cover']
        if cover:
            if not cover.name:
                if cover.content_type not in settings.IMAGE_CONTENT_TYPE:
                    raise forms.ValidationError(
                        _(u"Journal cover image extension is not allowed! Please select another file."))

            if cover.size > settings.JOURNAL_COVER_MAX_SIZE:
                raise forms.ValidationError(
                    _(u"Journal cover image file size is too large! Please select another file."))

            w, h = get_image_dimensions(cover)

            if w != settings.IMAGE_DIMENSIONS['width_cover']:
                raise forms.ValidationError(
                    _(u"The image is {image_size}px pixel wide. It's supposed to be {expected_size}px".format(
                        image_size=w,
                        expected_size=settings.IMAGE_DIMENSIONS['width_cover'])))

            if h != settings.IMAGE_DIMENSIONS['height_cover']:
                raise forms.ValidationError(
                    _("The image is {image_size}px pixel high. It's supposed to be {expected_size}px".format(
                        image_size=h,
                        expected_size=settings.IMAGE_DIMENSIONS['height_cover'])))

        return cover
Example #11
0
def database_get_image_dimensions(file, close=False, dimensions=None):
    """
    Returns the (width, height) of an image, given ThumbnailFile.  Set
    'close' to True to close the file at the end if it is initially in an open
    state.

    Will attempt to get the dimensions from the file itself if they aren't
    in the db.
    """
    storage_hash = utils.get_storage_hash(file.storage)
    dimensions = None
    dimensions_cache = None
    try:
        thumbnail = models.Thumbnail.objects.select_related('dimensions').get(
            storage_hash=storage_hash, name=file.name)
    except models.Thumbnail.DoesNotExist:
        thumbnail = None
    else:
        try:
            dimensions_cache = thumbnail.dimensions
        except models.ThumbnailDimensions.DoesNotExist:
            dimensions_cache = None
        if dimensions_cache:
            return dimensions_cache.width, dimensions_cache.height
    dimensions = get_image_dimensions(file, close=close)
    if settings.THUMBNAIL_CACHE_DIMENSIONS and thumbnail:
        dimensions_cache = models.ThumbnailDimensions(thumbnail=thumbnail)
        dimensions_cache.width, dimensions_cache.height = dimensions
        dimensions_cache.save()
    return dimensions
Example #12
0
	def save(self, *args, **kwargs):
		mug, x, y, size = [self.cleaned_data[key] for key in ('mug', 'x', 'y', 'size')]
		mug = mug or self.instance.mug
		if get_image_dimensions(mug) != (100,100):
			if all([x, y, size]):
				make_thumb(mug, (x, y), size)
		return super(PostForm, self).save(*args, **kwargs)
Example #13
0
    def clean_avatar(self):
        avatar = self.cleaned_data["profile_picture"]

        try:
            w, h = get_image_dimensions(avatar)

            # validate dimensions
            max_width = max_height = 100
            if w > max_width or h > max_height:
                raise forms.ValidationError(
                    u"Please use an image that is " "%s x %s pixels or smaller." % (max_width, max_height)
                )

            # validate content type
            main, sub = avatar.content_type.split("/")
            if not (main == "image" and sub in ["jpeg", "pjpeg", "gif", "png"]):
                raise forms.ValidationError(u"Please use a JPEG, " "GIF or PNG image.")

            # validate file size
            if len(avatar) > (20 * 1024):
                raise forms.ValidationError(u"Avatar file size may not exceed 20k.")

        except AttributeError:
            """
            Handles case when we are updating the user profile
            and do not supply a new avatar
            """
            pass

        return avatar
Example #14
0
    def clean_avatar(self):
        avatar = self.cleaned_data['avatar']

        try:
            w, h = get_image_dimensions(avatar)

            #validate dimensions
            max_width = max_height = 100
            if w > max_width or h > max_height:
                raise forms.ValidationError(
                    u'Please use an image that is '
                     '%s x %s pixels or smaller.' % (max_width, max_height))

            #validate content type
            main, sub = avatar.content_type.split('/')
            if not (main == 'image' and sub in ['jpeg', 'pjpeg', 'gif', 'png']):
                raise forms.ValidationError(u'Please use a JPEG, '
                    'GIF or PNG image.')

            #validate file size
            if len(avatar) > (20 * 1024):
                raise forms.ValidationError(
                    u'Avatar file size may not exceed 20k.')

        except AttributeError:
            """
            Handles case when we are updating the user profile
            and do not supply a new avatar
            """
            pass

        return avatar
Example #15
0
    def clean_picture(self):
        picture = self.cleaned_data['picture']

        try:
            w, h = get_image_dimensions(picture)

            #validate dimensions
            max_width = max_height = 4000
            if w > max_width or h > max_height:
                raise forms.ValidationError(
                    u'Please use an image that is '
                    '%s x %s pixels or smaller.' % (max_width, max_height))

            #validate content type
            main, sub = picture.content_type.split('/')
            if not (main == 'image' and sub in ['jpeg', 'pjpeg', 'gif', 'png']):
                raise forms.ValidationError(u'Please use a JPEG, '
                    'GIF or PNG image.')

            #validate file size
            image = self.cleaned_data.get('image',False)
            if image:
                if image._size > 6*1024*1024:
                    raise ValidationError("Image file too large ( > 6mb )")
                return image

        except AttributeError:
            pass

        except TypeError:
            return picture

        return picture
Example #16
0
 def __set__(self, instance, value):
     super(ImageFileDescriptor, self).__set__(instance, value)
     
     # The rest of this method deals with width/height fields, so we can
     # bail early if neither is used.
     if not self.field.width_field and not self.field.height_field:
         return
     
     # We need to call the descriptor's __get__ to coerce this assigned 
     # value into an instance of the right type (an ImageFieldFile, in this
     # case).
     value = self.__get__(instance)
     
     if not value:
         return
     
     # Get the image dimensions, making sure to leave the file in the same
     # state (opened or closed) that we got it in. However, we *don't* rewind
     # the file pointer if the file is already open. This is in keeping with
     # most Python standard library file operations that leave it up to the
     # user code to reset file pointers after operations that move it.
     from django.core.files.images import get_image_dimensions
     close = value.closed
     value.open()
     try:
         width, height = get_image_dimensions(value)
     finally:
         if close:
             value.close()
     
     # Update the width and height fields
     if self.field.width_field:
         setattr(value.instance, self.field.width_field, width)
     if self.field.height_field:
         setattr(value.instance, self.field.height_field, height)
Example #17
0
File: forms.py Project: theju/smp
    def clean(self):
        data = self.cleaned_data

        if data.get("scheduled_datetime"):
            sched_dt = data["scheduled_datetime"]
            sched_tz = timezone.pytz.timezone(data.get("scheduled_tz"))
            sched_dt = sched_tz.localize(sched_dt.replace(tzinfo=None))
            data["scheduled_datetime"] = timezone.localtime(sched_dt)

        if data.get("attached_media") and data.get("media_url"):
            raise forms.ValidationError(_("Only one of media URL or "
                                          "attached media may be provided"))

        if data.get("media_url"):
            response = requests.get(data["media_url"])
            if not response.ok:
                raise forms.ValidationError(_("An error occurred while "
                                              "downloading the media from the URL"))
            ext = mimetypes.guess_extension(response.headers['content-type'])
            ff = tempfile.NamedTemporaryFile(suffix=ext)
            ff.write(response.content)
            img_file = ImageFile(ff, name=ff.name)
            height, width = get_image_dimensions(img_file)
            if height is None or width is None:
                ff.close()
                raise forms.ValidationError(_("Invalid image"))
            data["attached_media"] = img_file
        return data
Example #18
0
	def clean_image(self):
		image = self.cleaned_data['image']
		width, height = get_image_dimensions(image)
		if width != SIDE_AD_IMG_WIDTH or height != SIDE_AD_IMG_HEIGHT:
			raise ValidationError(_(u'Image must have {0}x{1} px size.'.format(SIDE_AD_IMG_WIDTH,
											 SIDE_AD_IMG_HEIGHT)))
		return image
Example #19
0
 def clean_button(self):
     button = self.cleaned_data.get('button')
     if button:
         width, height = get_image_dimensions(button)
         if width != 11 or height != 11:
             raise ValidationError("width or height is not 11, (11x11)")
     return button
Example #20
0
    def clean_profile_image(self):
        profile_image = self.cleaned_data['profile_image']

        try:
            w, h = get_image_dimensions(profile_image)

            #validate dimensions
            max_height = 960
            max_width = 1280
            if w > max_width or h > max_height:
                raise forms.ValidationError(u'Please use an image that is {w} x {h} pixels or smaller.'.format(w=max_width, h=max_height))

            #validate content type
            main, sub = profile_image.content_type.split('/')
            if not (main == 'image' and sub in ['jpg', 'jpeg', 'pjpeg', 'png']):
                raise forms.ValidationError(u'Please use a JPEG or PNG image.')

            #validate file size
            if len(profile_image) > (2000 * 1024):
                raise forms.ValidationError('Profile image file size may not exceed 2MB.')

        except AttributeError:
            pass

        return profile_image
Example #21
0
    def test_create_issuer_image_500x300_resizes_to_400x400(self):
        view = IssuerList.as_view()

        with open(os.path.join(os.path.dirname(__file__), 'testfiles',
                               '500x300.png'), 'r') as badge_image:
                issuer_fields_with_image = {
                    'name': 'Awesome Issuer',
                    'description': 'An issuer of awe-inspiring credentials',
                    'url': 'http://example.com',
                    'email': '*****@*****.**',
                    'image': badge_image,
                }

                request = factory.post('/v1/issuer/issuers',
                                       issuer_fields_with_image,
                                       format='multipart')

                force_authenticate(request,
                                   user=get_user_model().objects.get(pk=1))
                response = view(request)
                self.assertEqual(response.status_code, 201)

                badge_object = response.data.get('json')
                derived_slug = badge_object['id'].split('/')[-1]
                new_issuer = Issuer.objects.get(slug=derived_slug)

                image_width, image_height = \
                    get_image_dimensions(new_issuer.image.file)
                self.assertEqual(image_width, 400)
                self.assertEqual(image_height, 400)
Example #22
0
    def clean(self, *args, **kwargs):
        from django.core.files.images import get_image_dimensions
        data = super(ExtendedImageField, self).clean(*args, **kwargs)
        image = data.file

        # Controls the file size
        if self.max_upload_size and hasattr(image, 'size'):
            if image.size > self.max_upload_size:
                raise ValidationError(
                    _('Files of size greater than {} are not allowed. Your file is {}').format(
                        filesizeformat(self.max_upload_size),
                        filesizeformat(image.size)
                    )
                )

        # Controls the image size
        image_width, image_height = get_image_dimensions(data)
        if (self.min_width and self.max_width and not self.min_width <= image_width <= self.max_width):
            raise ValidationError(
                _('Images of width lesser than {}px or greater than {}px or are not allowed. The width of your image is {}px').format(
                    self.min_width, self.max_width, image_width))
        if self.min_height and self.max_height and not self.min_height <= image_height <= self.max_height:
            raise ValidationError(
                _('Images of height lesser than {}px or greater than {}px or are not allowed. The height of your image is {}px').format(
                    self.min_height, self.max_height, image_height))

        return data
Example #23
0
 def clean_thumbnail(self):
     thumbnail = self.cleaned_data.get("thumbnail")
     if thumbnail:
         w, h = get_image_dimensions(thumbnail)
         if w < Course.THUMBNAIL_WIDTH or h < Course.THUMBNAIL_HEIGHT:
             raise forms.ValidationError(self.error_messages['invalid_image'])
     return thumbnail
Example #24
0
def get_image_data_scaled(image_data, width):
    # NOTE: We refuse to scale images if we do not
    # have the Python Imaging Library.
    if not mysite.base.depends.Image:
        logger.info(
            "NOTE: We cannot resize this image, so we are going to pass it through. See ADVANCED_INSTALLATION.mkd for information on PIL.")
        return image_data

    # scale it
    image_fd = StringIO.StringIO(image_data)
    im = mysite.base.depends.Image.open(image_fd)
    image_fd.seek(0)

    w, h = get_image_dimensions(image_fd)

    new_w = int(width)
    new_h = int((h * 1.0 / w) * width)

    smaller = im.resize((new_w, new_h),
                        mysite.base.depends.Image.ANTIALIAS)

    # "Save" it to memory
    new_image_fd = StringIO.StringIO()
    smaller.save(new_image_fd, format='PNG')
    new_image_fd.seek(0)

    # pull data out
    image_data = new_image_fd.getvalue()
    return image_data
Example #25
0
    def clean_avatar(self):
        avatar = self.cleaned_data['avatar']

        try:
            w, h = get_image_dimensions(avatar)

            #validate dimensions
            max_width = max_height = 2800
            if w > max_width or h > max_height:
                raise forms.ValidationError(
                    u'Please use an image that is '
                     '%(width)s x %(height)s pixels or smaller.', params={'width': max_width, 'height': max_height}, code='invalid')

            #validate content type
            main, sub = avatar.content_type.split('/')
            if not (main == 'image' and sub in ['jpeg', 'pjpeg', 'gif', 'png']):
                raise forms.ValidationError(u'Please use a JPEG, '
                    'GIF or PNG image.', code='invalid')

            #validate file size
            if len(avatar) > (200 * 1024):
                raise forms.ValidationError(
                    u'Avatar file size may not exceed 200k.', code='invalid')

        except AttributeError:
            pass
        except TypeError:
            pass

        return avatar
Example #26
0
 def file_type(self):
     t = self.filetypes_dict[self.type]
     if self.type == 'image':
         from django.core.files.images import get_image_dimensions
         d = get_image_dimensions(self.file.file)
         if d: t += "<br/>%d&times;%d" % ( d[0], d[1] )
     return t
Example #27
0
    def clean_photo(self):
        # Safe copy of data...
        self.cleaned_data['photo'].seek(0)
        data = self.cleaned_data['photo'].read()
        self.cleaned_data['photo'].seek(0)
        data_fd = StringIO.StringIO(data)

        w, h = get_image_dimensions(data_fd)
        if w > 200:
            # Scale it down.
            too_big = PIL.Image.open(StringIO.StringIO(data))
            format = too_big.format
            new_w = 200
            new_h = (h * 1.0 / w) * 200

            smaller = too_big.resize((new_w, new_h),
                                     PIL.Image.ANTIALIAS)

            # "Save" it to memory
            new_image_fd = StringIO.StringIO()
            smaller.save(new_image_fd, format=format)
            new_image_fd.seek(0)

            old = self.cleaned_data['photo']

            new_image_uploaded_file = InMemoryUploadedFile(
                new_image_fd, '', old.name,
                old.content_type, new_image_fd.len, old.charset)

            # Modify the self.cleaned_data[]
            self.cleaned_data['photo'] = new_image_uploaded_file
        return self.cleaned_data['photo']
Example #28
0
 def clean_answer(self):
     answer = self.cleaned_data['answer']
     if answer and not get_image_dimensions(answer.file):
         raise ValidationError(_(
             "We couldn't read your file. Make sure it's a .jpeg, .png, or "
             ".gif file, not a .psd or other unsupported type."))
     return answer
Example #29
0
 def post(self, request, username):
     """Handles upload of profile picture by user."""
     if not is_user_current_user(request, username):
         self.error = 'You are not permitted to do this.'
         self.status = 405
         return render(request, 'error.html',
                       {
                           'error': self.error
                       }, status=self.status)
     else:
         user = User.objects.get(username=username)
         p = user.profile
         form = ProfilePictureUploadForm(request.POST, request.FILES)
         if form.is_valid():
             try:
                 image = request.FILES['image']
                 w, h = get_image_dimensions(image)
                 if w < 200 or h < 200 or w > 1000 or h > 1000:
                     error = """Image dimension should be between 200x200
                     and 1000x1000"""
                     raise
                 if p.picture:
                     os.remove(p.picture.path)
                 p.picture = image
                 p.save()
                 print(p.picture.path)
                 returnpath = '/user/' + \
                     user.username + '/crop_profilepicture'
                 return HttpResponseRedirect(returnpath)
             except:
                 return render(request, 'uploadprofilepicture.html',
                               {'user': user, 'error': error})
         else:
             return render(request, 'uploadprofilepicture.html',
                           {'user': user})
    def test_badgeclass_put_image_multipart(self):
        test_user = self.setup_user(authenticate=True)
        test_issuer = self.setup_issuer(owner=test_user)

        badgeclass_props = {
            'name': 'Badge of Awesome',
            'description': 'An awesome badge only awarded to awesome people or non-existent test entities',
            'criteria': 'http://wikipedia.org/Awesome',
        }

        with open(self.get_testfiles_path('300x300.png'), 'r') as badge_image:
            post_response = self.client.post('/v1/issuer/issuers/{issuer}/badges'.format(issuer=test_issuer.entity_id),
                dict(badgeclass_props, image=badge_image),
            )
            self.assertEqual(post_response.status_code, 201)
            slug = post_response.data.get('slug')

        with open(self.get_testfiles_path('450x450.png'), 'r') as new_badge_image:
            put_response = self.client.put('/v1/issuer/issuers/{issuer}/badges/{badge}'.format(issuer=test_issuer.entity_id, badge=slug),
                dict(badgeclass_props, image=new_badge_image),
                format='multipart'
            )
            self.assertEqual(put_response.status_code, 200)

            new_badgeclass = BadgeClass.objects.get(entity_id=slug)
            image_width, image_height = get_image_dimensions(new_badgeclass.image.file)

            # File should be changed to new 450x450 image
            self.assertEqual(image_width, 450)
            self.assertEqual(image_height, 450)
Example #31
0
    def check_min_image_size(self, limit):
        """
        验证上传的图片尺寸是否小于最小限制
        """

        for image in self.files:
            w, h = get_image_dimensions(image)
            if w < limit[0] or h < limit[1]:
                self.error = u'上传的图片尺寸太小(最小{0}x{1})'.format(*limit)
                return False
        return True
Example #32
0
def validate_image(fieldfile_obj):
    if fieldfile_obj:
        w, h = get_image_dimensions(fieldfile_obj)
    if w < 100:
        raise ValidationError(
            "The image is %i pixel narrow. It's supposed to be wider than 100px"
            % w)
    if h < 100:
        raise ValidationError(
            "The image is %i pixel low. It's supposed to be higher than 100px"
            % h)
Example #33
0
 def test_bug_19457(self):
     """
     Regression test for #19457
     get_image_dimensions fails on some pngs, while Image.size is working good on them
     """
     img_path = os.path.join(os.path.dirname(upath(__file__)), "magic.png")
     try:
         size = get_image_dimensions(img_path)
     except zlib.error:
         self.fail("Exception raised from get_image_dimensions().")
     self.assertEqual(size, Image.open(img_path).size)
Example #34
0
def validate_image(imageField):
    filesize = imageField.file.size
    w, h = get_image_dimensions(imageField)
    if w < 1280:
        raise ValidationError(
            f"The image is {w} pixel wide. It should be greater than or equal to 1280px"
        )
    if h < 640:
        raise ValidationError(
            f"The image is {h} pixel high. It should be greater than or equal to 640px"
        )
Example #35
0
 def clean_logo_file(self):
     picture = self.cleaned_data.get("logo_file")
     if picture:
         try:
             w, h = get_image_dimensions(picture)
             if w > 252 or h > 137:
                 raise forms.ValidationError(
                     _('Your customer header is too big'))
         except TypeError:
             raise forms.ValidationError(_('Unsupported format'))
     return picture
Example #36
0
 def clean_student_image(self):
     picture = self.cleaned_data['student_image']
     if not picture:
         raise ValidationError("No image!")
     else:
         w, h = get_image_dimensions(picture)
         if w > 450:
             raise ValidationError("Upload a max of 450px wide photo")
         if h > 450:
             raise ValidationError("Upload a photo of max height 450px")
     return picture
Example #37
0
    def save(self, name, content, save=True):
        # Repopulate the image dimension cache.
        self._dimensions_cache = get_image_dimensions(content)

        # Update width/height fields, if needed
        if self.field.width_field:
            setattr(self.instance, self.field.width_field, self.width)
        if self.field.height_field:
            setattr(self.instance, self.field.height_field, self.height)

        super(ImageFieldFile, self).save(name, content, save)
Example #38
0
 def clean_new_image(self):
     new_image = self.cleaned_data.get('new_image')
     if not new_image:
         raise forms.ValidationError("No image!")
     else:
         w, h = get_image_dimensions(new_image)
         if w < 110:
             raise forms.ValidationError("The image is %i pixel wide. It's supposed to be more than 110px" % w)
         if h < 110:
             raise forms.ValidationError("The image is %i pixel high. It's supposed to be more than 110px" % h)
         return new_image
Example #39
0
    def clean_profile_photo(self):
        photo = self.cleaned_data.get('profile_photo')
        w, h = get_image_dimensions(photo)
        min_width, min_height = 300, 300

        if w != h:
            raise forms.ValidationError('Image should be square')
        if w < min_width or h < min_height:
            raise forms.ValidationError(('Image should be at least {}x{}' \
                ' pixels').format(min_width, min_height))
        return photo
Example #40
0
 def check_resolution(self):
     """
     Проверяет разрешение изображения.
     :return True: если разрешение меньше 800x800
     :return False: если разрешение больше 800x800
     """
     image = self.cleaned_data['image']
     width, height = get_image_dimensions(image)
     if width > 1600 or height > 1600:
         return False
     return True
Example #41
0
 def clean_businesslogo(self):
     businesslogo = self.cleaned_data.get("businesslogo")
     if not businesslogo:
         raise forms.ValidationError("No image!")
     else:
         w, h = get_image_dimensions(businesslogo)
         if w != 400:
             raise forms.ValidationError("The image is %i pixel wide. It's supposed to be 400px" % w)
         if h != 300:
             raise forms.ValidationError("The image is %i pixel high. It's supposed to be 300px" % h)
     return businesslogo
Example #42
0
    def clean_image(self):
        image = self.cleaned_data['image']
        if image:
            from django.core.files.images import get_image_dimensions
            w, h = get_image_dimensions(image)

            if w > 958 or h > 460:
                raise forms.ValidationError(
                    u'That image is un suitable. The image needs to be width : 958px height :460px '
                )
        return image
Example #43
0
    def validate(self):
        cat_name = self.category.lower()
        print(cat_name)
        if Category.objects.filter(category=cat_name).exclude(
                id=self.id).exists():
            raise ValidationError("Category name should be unique")

        width, height = get_image_dimensions(self.cat_img.file)
        ratio = width / height
        if ratio >= 1.6 or ratio <= 1.4:
            raise ValidationError("Image aspect ratio must be near 3:2")
    def getImageDimensions(self):
        '''
        Returns the dimensions of the uploaded image file.

        Borrows Django's django.core.files.images.get_image_dimensions
        method to get the dimensions via Pillow (python imaging module).
        '''
        image_dimensions = get_image_dimensions(self.file)
        width = image_dimensions[0]
        height = image_dimensions[1]
        return width, height
Example #45
0
    def save(self, *args, **kwargs):
        if self.image:
            width, height = get_image_dimensions(self.image.open().file,
                                                 close=False)
            self.image_width = width
            self.image_height = height
        else:
            self.image_width = 0
            self.image_height = 0

        super(BlogPost, self).save(*args, **kwargs)
Example #46
0
 def clean(self):
     super(AdImageInlineForm, self).clean()
     device = self.cleaned_data.get('device', None)
     image = self.cleaned_data.get('image', None)
     ad = self.cleaned_data.get('ad', None)
     if image and device and ad:
         allowed_size = settings.ADS_ZONES.get(ad.zone, {}). \
             get('ad_size', {}). \
             get(device, settings.ADS_DEFAULT_AD_SIZE)
         allowed_w, allowed_h = [int(d) for d in allowed_size.split('x')]
         w, h = get_image_dimensions(image)
 def image_is_panoramic(self):
     """Return True if the image has a 3:2 ratio or bigger."""
     try:
         img_width, img_height = get_image_dimensions(self.image.file)
         # Images go in a 427x286 box -> 3:2 ratio
         if (img_width / img_height) >= 1.5:
             panoramic = True
         else:
             panoramic = False
     except Exception:
         panoramic = True
     return panoramic
Example #48
0
def get_file_info(file):
    ret = dict()
    ret["extension"] = file.name.split(".")[-1]
    ret["name"] = file.name
    ret["size"] = file.size
    ret["content_type"] = file.content_type
    if file.content_type.startswith("image/"):
        w, h = get_image_dimensions(file)
        ret["width"] = w
        ret["height"] = h
    # print("get_file_info: ", ret)
    return ret
Example #49
0
def validate_rectangle_gondola(image):
    """
    Raise a validation error if the gondola image is not a valid
    rectangle (580 x 290).
    :param image: image field
    :return: image
    """
    allowed_size = (580, 280)
    img_size = get_image_dimensions(image)
    if img_size not in allowed_size:
        raise ValidationError('Gondola image should be a rectangle %s instead'
                              'of %s' % (allowed_size, img_size))
Example #50
0
 def validate_picture(self, cleaned_data):
     picture = cleaned_data['appliance_icon']
     logger.debug('Icon uploaded: %s', picture)
     if picture:
         w, h = get_image_dimensions(picture)
         if (w > 150) or (h > 150):
             self.add_error('appliance_icon',
                            'Icon must be 150px by 150px or smaller.')
             logger.debug('Icon uploaded is larger than 150px by 150px.')
         logger.debug('Icon uploaded is valid.')
     elif not picture:
         logger.debug('Icon not uploaded.')
Example #51
0
 def is_valid(self):
     """"
         Redefine es is_valid() y aumenta la validacion del tamanio
         de la imagen
     """
     result = super(self.__class__, self).is_valid()
     if result:
         (width, height) = get_image_dimensions(self.cleaned_data['foto'])
         if not (width >= 1600 or height >= 1600):
             return (False, 'La imagen debe tener algún lado de\
                     1600 píxeles como mínimo')
     return (result, '')
Example #52
0
def get_or_create_image(image_path):
    image = default_storage.get_image_by_path(image_path)
    if not image:
        image_file = default_storage.open(image_path)
        width, height = get_image_dimensions(image_file)
        image = Image.objects.create(
            title=os.path.basename(image_path),
            width=width,
            height=height,
            file=image_path,
        )
    return image
Example #53
0
 def is_valid(self):
     """
         Redefine es is_valid() y aumenta la validacion del tamanio
         de la imagen
     """
     result = super(self.__class__, self).is_valid()
     if result:
         (width, height) = get_image_dimensions(self.cleaned_data['foto'])
         #if not (width >= 1600 or height >= 1600):
         #if not (width >= 960 or height >= 960):
         #    return (False, _(u'Your photo must measure at least 960 pixels in length or width.'))
     return (result, '')
Example #54
0
    def test_invalid_image(self):
        """
        get_image_dimensions() should return (None, None) for the dimensions of
        invalid images (#24441).

        brokenimg.png is not a valid image and it has been generated by:
        $ echo "123" > brokenimg.png
        """
        img_path = os.path.join(os.path.dirname(__file__), "brokenimg.png")
        with open(img_path, 'rb') as fh:
            size = images.get_image_dimensions(fh)
            self.assertEqual(size, (None, None))
Example #55
0
    def test_can_edit_with_discovery_edit_permission(self):
        uploaded_photo = get_uploaded_file('transparent.png')
        item = PrimaryHeroImage.objects.create(custom_image=uploaded_photo)
        self.detail_url = reverse(
            'admin:discovery_primaryheroimageupload_change', args=(item.pk,)
        )
        user = user_factory(email='*****@*****.**')
        self.grant_permission(user, 'Discovery:Edit')
        self.client.login(email=user.email)
        response = self.client.get(self.detail_url, follow=True)
        assert response.status_code == 200
        content = response.content.decode('utf-8')
        assert 'transparent.jpg' in content

        updated_photo = get_uploaded_file('preview_4x3.jpg')
        response = self.client.post(
            self.detail_url, dict(custom_image=updated_photo), follow=True
        )
        assert response.status_code == 200
        item.reload()
        assert PrimaryHeroImage.objects.count() == 1
        assert item.custom_image == 'hero-featured-image/preview_4x3.jpg'
        assert os.path.exists(
            os.path.join(settings.MEDIA_ROOT, 'hero-featured-image', 'preview_4x3.jpg')
        )
        assert os.path.exists(
            os.path.join(
                settings.MEDIA_ROOT, 'hero-featured-image', 'thumbs', 'preview_4x3.jpg'
            )
        )
        width, height = get_image_dimensions(
            os.path.join(settings.MEDIA_ROOT, 'hero-featured-image', 'preview_4x3.jpg')
        )
        t_width, t_height = get_image_dimensions(
            os.path.join(
                settings.MEDIA_ROOT, 'hero-featured-image', 'thumbs', 'preview_4x3.jpg'
            )
        )
        assert width <= 960 and height <= 640
        assert t_width <= 150 and t_height <= 120
Example #56
0
def new(request):
    if request.method == "POST":
        form = NewImageForm(request.POST, request.FILES)
        if form.is_valid():

            if form.cleaned_data[
                    'imageFile'] and not form.cleaned_data['imageName']:
                image = form.cleaned_data['imageFile']
                name = image.name
                width, height = get_image_dimensions(image)

            elif form.cleaned_data[
                    'imageName'] and not form.cleaned_data['imageFile']:
                img = get_remote_image(form.cleaned_data['imageName'])
                if img is None:
                    error = "Неверная ссылка"
                    return render(request, "new.html", {
                        'form': form,
                        'error': error
                    })
                image = img['im']
                name = img['name']
                width, height = get_image_dimensions(img['im'])

            else:
                error = "Можно использовать только один способ загрузки изображения"
                return render(request, "new.html", {
                    'form': form,
                    'error': error
                })

            result = Img.objects.create(image=image,
                                        name=name,
                                        width=width,
                                        height=height)
            return redirect("img_view", img_id=result.pk)

    else:
        form = NewImageForm()
    return render(request, "new.html", {'form': form})
Example #57
0
 def save(self, *args, **kwargs):
     if (not self.exif_time_taken) or (not self.exif_lat) or (
             not self.exif_lon):
         tags = exifread.process_file(self.image, details=False)
         if 'EXIF DateTimeOriginal' in tags:
             date_time_obj = datetime.datetime.strptime(
                 str(tags['EXIF DateTimeOriginal']), '%Y:%m:%d %H:%M:%S')
             self.exif_time_taken = date_time_obj
         lat, lon = get_exif_location(tags)
         if lat:
             self.exif_lat = round(lat, 5)
         if lon:
             self.exif_lon = round(lon, 5)
     super(Photo, self).save(*args, **kwargs)
     exif_fullhd = piexif.load(self.image.path)
     if '0th' in exif_fullhd:
         width, height = get_image_dimensions(self.image_fullhd.file)
         exif_fullhd['0th'][256] = width
         exif_fullhd['0th'][257] = height
     if '1st' in exif_fullhd:
         del exif_fullhd['1st']
     if 'thumbnail' in exif_fullhd:
         del exif_fullhd['thumbnail']
     # Fix S10 Mini photos
     if ('Exif' in exif_fullhd) and (41729 in exif_fullhd['Exif']):
         del exif_fullhd['Exif'][41729]
     exif_thumb = piexif.load(self.image.path)
     if '0th' in exif_thumb:
         width, height = get_image_dimensions(self.image_thumb.file)
         exif_thumb['0th'][256] = width
         exif_thumb['0th'][257] = height
     if '1st' in exif_thumb:
         del exif_thumb['1st']
     if 'thumbnail' in exif_thumb:
         del exif_thumb['thumbnail']
     # Fix S10 Mini photos
     if ('Exif' in exif_thumb) and (41729 in exif_thumb['Exif']):
         del exif_thumb['Exif'][41729]
     piexif.insert(piexif.dump(exif_fullhd), self.image_fullhd.path)
     piexif.insert(piexif.dump(exif_thumb), self.image_thumb.path)
def validate_video_image(image_file):
    """
    Validates video image file.

    Arguments:
        image_file: The selected image file.

   Returns:
        error (String or None): If there is error returns error message otherwise None.
    """
    error = None

    if not all(hasattr(image_file, attr) for attr in ['name', 'content_type', 'size']):
        error = _('The image must have name, content type, and size information.')
    elif image_file.content_type not in settings.VIDEO_IMAGE_SUPPORTED_FILE_FORMATS.values():
        error = _('This image file type is not supported. Supported file types are {supported_file_formats}.').format(
            supported_file_formats=settings.VIDEO_IMAGE_SUPPORTED_FILE_FORMATS.keys()
        )
    elif image_file.size > settings.VIDEO_IMAGE_SETTINGS['VIDEO_IMAGE_MAX_BYTES']:
        error = _('This image file must be smaller than {image_max_size}.').format(
            image_max_size=settings.VIDEO_IMAGE_MAX_FILE_SIZE_MB
        )
    elif image_file.size < settings.VIDEO_IMAGE_SETTINGS['VIDEO_IMAGE_MIN_BYTES']:
        error = _('This image file must be larger than {image_min_size}.').format(
            image_min_size=settings.VIDEO_IMAGE_MIN_FILE_SIZE_KB
        )
    else:
        try:
            image_file_width, image_file_height = get_image_dimensions(image_file)
        except TypeError:
            return _('There is a problem with this image file. Try to upload a different file.')
        if image_file_width is None or image_file_height is None:
            return _('There is a problem with this image file. Try to upload a different file.')
        image_file_aspect_ratio = abs(image_file_width / float(image_file_height) - settings.VIDEO_IMAGE_ASPECT_RATIO)
        if image_file_width < settings.VIDEO_IMAGE_MIN_WIDTH or image_file_height < settings.VIDEO_IMAGE_MIN_HEIGHT:
            error = _('Recommended image resolution is {image_file_max_width}x{image_file_max_height}. '
                      'The minimum resolution is {image_file_min_width}x{image_file_min_height}.').format(
                image_file_max_width=settings.VIDEO_IMAGE_MAX_WIDTH,
                image_file_max_height=settings.VIDEO_IMAGE_MAX_HEIGHT,
                image_file_min_width=settings.VIDEO_IMAGE_MIN_WIDTH,
                image_file_min_height=settings.VIDEO_IMAGE_MIN_HEIGHT
            )
        elif image_file_aspect_ratio > settings.VIDEO_IMAGE_ASPECT_RATIO_ERROR_MARGIN:
            error = _('This image file must have an aspect ratio of {video_image_aspect_ratio_text}.').format(
                video_image_aspect_ratio_text=settings.VIDEO_IMAGE_ASPECT_RATIO_TEXT
            )
        else:
            try:
                image_file.name.encode('ascii')
            except UnicodeEncodeError:
                error = _('The image file name can only contain letters, numbers, hyphens (-), and underscores (_).')
    return error
Example #59
0
    def test_valid_image(self):
        """
        get_image_dimensions() should catch struct.error while feeding the PIL
        Image parser (#24544).

        Emulates the Parser feed error. Since the error is raised on every feed
        attempt, the resulting image size should be invalid: (None, None).
        """
        img_path = os.path.join(os.path.dirname(__file__), "test.png")
        with mock.patch('PIL.ImageFile.Parser.feed', side_effect=struct.error):
            with open(img_path, 'rb') as fh:
                size = images.get_image_dimensions(fh)
                self.assertEqual(size, (None, None))
Example #60
0
    def clean_image(self):
        image = self.cleaned_data.get('image')

        # only 1000000 bytes max size is allowed
        if image.size > 1000000:
            raise ValidationError(
                'Размер изображения не должен превышать 1 мегабайта!')

        # only 1×1 format is allowed
        width, height = get_image_dimensions(image)
        if width != height:
            raise ValidationError('Формат изображения должен быть 1×1!')
        return image