File Management Automation Suite

import hashlib
from PIL import Image
import os
from collections import defaultdict

class DuplicateDetector:
    def __init__(self):
        self.hash_map = defaultdict(list)
        self.supported_formats = {'.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff'}
    
    def generate_image_hash(self, image_path):
        """Generate MD5 hash from image content, not filename"""
        try:
            with Image.open(image_path) as img:
                # Convert to consistent format for comparison
                img = img.convert("RGB")
                # Generate hash from pixel data
                img_hash = hashlib.md5(img.tobytes()).hexdigest()
                return img_hash
        except Exception as e:
            return None
    
    def find_duplicates(self, directory_path):
        """Scan directory and identify duplicate images"""
        duplicates = []
        
        for root, dirs, files in os.walk(directory_path):
            for file in files:
                if os.path.splitext(file.lower())[1] in self.supported_formats:
                    file_path = os.path.join(root, file)
                    file_hash = self.generate_image_hash(file_path)
                    
                    if file_hash:
                        self.hash_map[file_hash].append(file_path)
        
        # Find groups with more than one file (duplicates)
        for hash_value, file_paths in self.hash_map.items():
            if len(file_paths) > 1:
                duplicates.append({
                    'hash': hash_value,
                    'files': file_paths,
                    'size': os.path.getsize(file_paths[0])
                })
        
        return duplicates

from PIL import Image, ImageEnhance
import multiprocessing
from concurrent.futures import ThreadPoolExecutor
import logging

class BatchImageProcessor:
    def __init__(self, quality=90, resample_algorithm=Image.LANCZOS):
        self.quality = quality
        self.resample = resample_algorithm
        self.processed_count = 0
        
    def resize_image(self, input_path, output_path, target_size, maintain_aspect=True):
        """Resize single image with quality preservation"""
        try:
            with Image.open(input_path) as img:
                if maintain_aspect:
                    # Calculate proportional size
                    img.thumbnail(target_size, self.resample)
                    target_size = img.size
                else:
                    # Force exact dimensions
                    img = img.resize(target_size, self.resample)
                
                # Enhance sharpness slightly to counteract resize softening
                if img.size != Image.open(input_path).size:
                    enhancer = ImageEnhance.Sharpness(img)
                    img = enhancer.enhance(1.1)
                
                # Save with optimal settings
                save_kwargs = {'quality': self.quality, 'optimize': True}
                if img.format == 'JPEG':
                    save_kwargs['progressive'] = True
                
                img.save(output_path, **save_kwargs)
                return True
                
        except Exception as e:
            logging.error(f"Failed to process {input_path}: {e}")
            return False
    
    def batch_process(self, file_list, target_size, output_dir):
        """Process multiple images in parallel"""
        with ThreadPoolExecutor(max_workers=multiprocessing.cpu_count()) as executor:
            futures = []
            
            for input_file in file_list:
                filename = os.path.basename(input_file)
                output_path = os.path.join(output_dir, filename)
                
                future = executor.submit(
                    self.resize_image, 
                    input_file, 
                    output_path, 
                    target_size
                )
                futures.append(future)
            
            # Collect results
            results = []
            for future in futures:
                results.append(future.result())
            
            return results