Example #1
0
    def __init__(self, min_length: int=None, max_length: int=None, content_type: str=None, content_length: int=None,
                 extension: str=None, original_filename: str=None, header_buffer_size=1024,
                 reproducible: bool=False, **kwargs):

        self.min_length = min_length
        self.max_length = max_length
        self.header_buffer_size = header_buffer_size
        self.content_length = content_length

        self.original_filename = original_filename

        self._source_pos = 0

        for k, v in kwargs.items():
            setattr(self, k, v)

        if content_type:
            self.content_type = content_type
        elif original_filename:
            self.content_type = guess_type(original_filename)
        elif extension:
            self.content_type = guess_type('a' + extension)

        if extension:
            self.extension = extension
        elif self.original_filename:
            self.extension = splitext(self.original_filename)[1]
        elif self.content_type:
            self.extension = guess_extension(self.content_type)

        self.reproducible = reproducible
Example #2
0
    def process(self, descriptor: StreamDescriptor, context: dict):

        # Ensuring the wand package is installed.
        ensure_wand()
        # noinspection PyPackageRequirements
        from wand.image import Image as WandImage

        # Copy the original info
        # generating thumbnail and storing in buffer
        # noinspection PyTypeChecker
        img = WandImage(file=descriptor)

        if self.crop is None and (
                self.format is None or img.format == self.format) and (
                    (self.width is None or img.width == self.width) and
                    (self.height is None or img.height == self.height)):
            img.close()
            descriptor.prepare_to_read(backend='memory')
            return

        if 'length' in context:
            del context['length']

        # opening the original file
        output_buffer = io.BytesIO()
        with img:
            # Changing format if required.
            if self.format and img.format != self.format:
                img.format = self.format

            # Changing dimension if required.
            if self.width or self.height:
                width, height, _ = validate_width_height_ratio(
                    self.width, self.height, None)
                img.resize(
                    width(img.size) if callable(width) else width,
                    height(img.size) if callable(height) else height)

            # Cropping
            if self.crop:
                img.crop(
                    **{
                        key: int(
                            int(value[:-1]) / 100 *
                            (img.width if key in ('width', 'left',
                                                  'right') else img.height)
                        ) if key in ('left', 'top', 'right', 'bottom', 'width',
                                     'height') and '%' in value else value
                        for key, value in self.crop.items()
                    })

            img.save(file=output_buffer)

            context.update(content_type=img.mimetype,
                           width=img.width,
                           height=img.height,
                           extension=guess_extension(img.mimetype))

        output_buffer.seek(0)
        descriptor.replace(output_buffer, position=0, **context)