imgzip 0.1.0__tar.gz

imgzip-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: imgzip
+Version: 0.1.0
+Summary: A lightweight Python library for compressing images with ease
+Home-page: https://github.com/RKSAHOO4414/imgzip
+Author: RKSAHOO4414
+Author-email: your_email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=9.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# imgzip
+
+A lightweight Python library for compressing images with ease.
+
+## Features
+
+- ✅ Simple and intuitive API
+- ✅ Support for JPG, PNG, BMP, GIF formats
+- ✅ Batch compression for multiple images
+- ✅ Customizable compression quality
+- ✅ Optional image resizing
+- ✅ Automatic format conversion
+- ✅ Detailed compression statistics
+
+## Installation
+
+Install `imgzip` from PyPI:
+
+```bash
+pip install imgzip

imgzip-0.1.0/README.md

@@ -0,0 +1,20 @@
+# imgzip
+
+A lightweight Python library for compressing images with ease.
+
+## Features
+
+- ✅ Simple and intuitive API
+- ✅ Support for JPG, PNG, BMP, GIF formats
+- ✅ Batch compression for multiple images
+- ✅ Customizable compression quality
+- ✅ Optional image resizing
+- ✅ Automatic format conversion
+- ✅ Detailed compression statistics
+
+## Installation
+
+Install `imgzip` from PyPI:
+
+```bash
+pip install imgzip

imgzip-0.1.0/imgzip/__init__.py

@@ -0,0 +1,8 @@
+"""
+imgzip - A lightweight Python library for compressing images with ease
+"""
+
+from .compressor import ImageCompressor
+
+__version__ = "0.1.0"
+__all__ = ["ImageCompressor"]

imgzip-0.1.0/imgzip/compressor.py

@@ -0,0 +1,137 @@
+"""
+Core image compression module
+"""
+
+import os
+from PIL import Image
+from pathlib import Path
+
+
+class ImageCompressor:
+    """
+    A simple and efficient image compressor for common image formats.
+    
+    Supported formats: JPG, PNG, BMP, GIF
+    """
+    
+    def __init__(self, quality=85, max_width=None, max_height=None):
+        """
+        Initialize the ImageCompressor.
+        
+        Args:
+            quality (int): JPEG quality level (1-100). Default is 85.
+                          Higher = better quality, larger file size.
+            max_width (int): Maximum width in pixels. Maintains aspect ratio if set.
+            max_height (int): Maximum height in pixels. Maintains aspect ratio if set.
+        """
+        if not 1 <= quality <= 100:
+            raise ValueError("Quality must be between 1 and 100")
+        
+        self.quality = quality
+        self.max_width = max_width
+        self.max_height = max_height
+    
+    def compress(self, input_path, output_path=None, format=None):
+        """
+        Compress a single image file.
+        
+        Args:
+            input_path (str): Path to the input image file.
+            output_path (str): Path to save the compressed image. 
+                              If None, saves as 'compressed_<original_name>'.
+            format (str): Image format for output (JPG, PNG). If None, uses input format.
+        
+        Returns:
+            dict: Dictionary with compression details (original size, compressed size, ratio).
+        
+        Raises:
+            FileNotFoundError: If input file doesn't exist.
+            ValueError: If file format is not supported.
+        """
+        # Validate input file
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"Input file not found: {input_path}")
+        
+        # Open image
+        try:
+            img = Image.open(input_path)
+        except Exception as e:
+            raise ValueError(f"Cannot open image file: {e}")
+        
+        # Get original file size
+        original_size = os.path.getsize(input_path)
+        
+        # Determine output path
+        if output_path is None:
+            input_name = Path(input_path).stem
+            input_ext = Path(input_path).suffix
+            output_path = f"compressed_{input_name}{input_ext}"
+        
+        # Determine output format
+        if format is None:
+            format = img.format or "JPEG"
+        format = format.upper()
+        
+        # Resize if max dimensions are set
+        if self.max_width or self.max_height:
+            img.thumbnail((self.max_width or img.width, self.max_height or img.height), Image.Resampling.LANCZOS)
+        
+        # Convert RGBA to RGB if saving as JPEG
+        if format == "JPEG" and img.mode in ("RGBA", "LA", "P"):
+            rgb_img = Image.new("RGB", img.size, (255, 255, 255))
+            rgb_img.paste(img, mask=img.split()[-1] if img.mode == "RGBA" else None)
+            img = rgb_img
+        
+        # Save compressed image
+        img.save(output_path, format=format, quality=self.quality, optimize=True)
+        
+        # Get compressed file size
+        compressed_size = os.path.getsize(output_path)
+        compression_ratio = (1 - (compressed_size / original_size)) * 100
+        
+        return {
+            "input_path": input_path,
+            "output_path": output_path,
+            "original_size_kb": round(original_size / 1024, 2),
+            "compressed_size_kb": round(compressed_size / 1024, 2),
+            "compression_ratio_percent": round(compression_ratio, 2),
+        }
+    
+    def compress_batch(self, input_folder, output_folder=None):
+        """
+        Compress all images in a folder.
+        
+        Args:
+            input_folder (str): Path to folder containing images.
+            output_folder (str): Path to save compressed images. 
+                                If None, creates 'compressed' folder in input folder.
+        
+        Returns:
+            list: List of dictionaries with compression details for each image.
+        """
+        if not os.path.isdir(input_folder):
+            raise FileNotFoundError(f"Input folder not found: {input_folder}")
+        
+        if output_folder is None:
+            output_folder = os.path.join(input_folder, "compressed")
+        
+        os.makedirs(output_folder, exist_ok=True)
+        
+        results = []
+        supported_formats = {".jpg", ".jpeg", ".png", ".bmp", ".gif"}
+        
+        for filename in os.listdir(input_folder):
+            if Path(filename).suffix.lower() in supported_formats:
+                input_path = os.path.join(input_folder, filename)
+                output_path = os.path.join(output_folder, f"compressed_{filename}")
+                
+                try:
+                    result = self.compress(input_path, output_path)
+                    results.append(result)
+                except Exception as e:
+                    results.append({
+                        "input_path": input_path,
+                        "error": str(e)
+                    })
+        
+        return results

imgzip-0.1.0/imgzip.egg-info/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: imgzip
+Version: 0.1.0
+Summary: A lightweight Python library for compressing images with ease
+Home-page: https://github.com/RKSAHOO4414/imgzip
+Author: RKSAHOO4414
+Author-email: your_email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pillow>=9.0.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# imgzip
+
+A lightweight Python library for compressing images with ease.
+
+## Features
+
+- ✅ Simple and intuitive API
+- ✅ Support for JPG, PNG, BMP, GIF formats
+- ✅ Batch compression for multiple images
+- ✅ Customizable compression quality
+- ✅ Optional image resizing
+- ✅ Automatic format conversion
+- ✅ Detailed compression statistics
+
+## Installation
+
+Install `imgzip` from PyPI:
+
+```bash
+pip install imgzip

imgzip-0.1.0/imgzip.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+setup.py
+imgzip/__init__.py
+imgzip/compressor.py
+imgzip.egg-info/PKG-INFO
+imgzip.egg-info/SOURCES.txt
+imgzip.egg-info/dependency_links.txt
+imgzip.egg-info/requires.txt
+imgzip.egg-info/top_level.txt
+tests/__init__.py
+tests/test_compressor.py

imgzip-0.1.0/imgzip.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

imgzip-0.1.0/imgzip.egg-info/requires.txt

@@ -0,0 +1 @@
+Pillow>=9.0.0

imgzip-0.1.0/imgzip.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+imgzip
+tests

imgzip-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

imgzip-0.1.0/setup.py

@@ -0,0 +1,28 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="imgzip",
+    version="0.1.0",
+    author="RKSAHOO4414",
+    author_email="your_email@example.com",
+    description="A lightweight Python library for compressing images with ease",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/RKSAHOO4414/imgzip",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+    install_requires=[
+        "Pillow>=9.0.0",
+    ],
+)

imgzip-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+# Tests package

imgzip-0.1.0/tests/test_compressor.py

@@ -0,0 +1,100 @@
+"""
+Unit tests for imgzip compressor
+"""
+
+import unittest
+import os
+import tempfile
+from pathlib import Path
+from PIL import Image
+from imgzip.compressor import ImageCompressor
+
+
+class TestImageCompressor(unittest.TestCase):
+    """Test cases for ImageCompressor class"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.temp_dir = tempfile.mkdtemp()
+        self.compressor = ImageCompressor(quality=85)
+        
+        # Create a test image
+        self.test_image_path = os.path.join(self.temp_dir, "test_image.png")
+        test_image = Image.new("RGB", (1000, 1000), color="red")
+        test_image.save(self.test_image_path)
+    
+    def tearDown(self):
+        """Clean up test files"""
+        for file in os.listdir(self.temp_dir):
+            file_path = os.path.join(self.temp_dir, file)
+            if os.path.isfile(file_path):
+                os.remove(file_path)
+        os.rmdir(self.temp_dir)
+    
+    def test_quality_validation(self):
+        """Test that quality parameter is validated"""
+        with self.assertRaises(ValueError):
+            ImageCompressor(quality=0)
+        
+        with self.assertRaises(ValueError):
+            ImageCompressor(quality=101)
+    
+    def test_compress_file_exists(self):
+        """Test compression of an existing file"""
+        output_path = os.path.join(self.temp_dir, "compressed_test.png")
+        result = self.compressor.compress(self.test_image_path, output_path)
+        
+        self.assertTrue(os.path.exists(output_path))
+        self.assertIn("compression_ratio_percent", result)
+        self.assertGreater(result["compression_ratio_percent"], 0)
+    
+    def test_compress_nonexistent_file(self):
+        """Test that compression fails for nonexistent file"""
+        with self.assertRaises(FileNotFoundError):
+            self.compressor.compress("/nonexistent/path/image.png")
+    
+    def test_auto_output_path(self):
+        """Test automatic output path generation"""
+        original_dir = os.getcwd()
+        try:
+            os.chdir(self.temp_dir)
+            result = self.compressor.compress(self.test_image_path)
+            
+            self.assertTrue(os.path.exists(result["output_path"]))
+            self.assertIn("compressed_", result["output_path"])
+        finally:
+            os.chdir(original_dir)
+    
+    def test_resize_functionality(self):
+        """Test image resizing during compression"""
+        compressor_with_resize = ImageCompressor(quality=85, max_width=500, max_height=500)
+        output_path = os.path.join(self.temp_dir, "resized.png")
+        
+        compressor_with_resize.compress(self.test_image_path, output_path)
+        
+        # Verify resized image
+        compressed_img = Image.open(output_path)
+        self.assertLessEqual(compressed_img.width, 500)
+        self.assertLessEqual(compressed_img.height, 500)
+    
+    def test_compression_ratio(self):
+        """Test that compression actually reduces file size"""
+        # Create a more complex image that compresses better
+        import random
+        test_image = Image.new("RGB", (1000, 1000))
+        pixels = test_image.load()
+        for i in range(1000):
+            for j in range(1000):
+                pixels[i, j] = (random.randint(0, 255), random.randint(0, 255), random.randint(0, 255))
+        
+        complex_image_path = os.path.join(self.temp_dir, "complex_image.png")
+        test_image.save(complex_image_path)
+        
+        output_path = os.path.join(self.temp_dir, "compressed_test.jpg")
+        result = self.compressor.compress(complex_image_path, output_path, format="JPEG")
+        
+        self.assertLess(result["compressed_size_kb"], result["original_size_kb"])
+
+
+if __name__ == "__main__":
+    unittest.main()