mil-kit 0.3.0__py3-none-any.whl

mil_kit/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from psd-toolkit!")

mil_kit/job.py

@@ -0,0 +1,308 @@
+"""
+Batch Processing Module for PSD Files
+Manages parallel processing of PSD files with enhanced error handling and logging.
+"""
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Optional, Tuple, List
+from datetime import datetime
+import logging
+from tqdm import tqdm
+from mil_kit.psd.processor import PSDProcessor
+import os
+import shutil
+
+
+class BatchJob:
+    """
+    Manages the processing of a directory of files with parallel execution.
+    
+    Features:
+    - Parallel processing using ThreadPoolExecutor
+    - Progress tracking with tqdm
+    - Detailed logging and error handling
+    - Flexible output options
+    - Processing statistics and reporting
+    """
+
+    SUPPORTED_FORMATS = ["png", "jpg", "jpeg", "tiff", "bmp", "webp"]
+
+    def __init__(
+        self,
+        input_dir: str,
+        output_dir: Optional[str] = None,
+        recursive: bool = False,
+        output_format: str = "png",
+        max_workers: Optional[int] = None,
+        log_file: Optional[str] = None,
+        overwrite: bool = True,
+        verbose: bool = True,
+    ):
+        """
+        Initialize the BatchJob processor.
+        
+        Args:
+            input_dir: Directory containing PSD files
+            output_dir: Output directory (defaults to input_dir)
+            recursive: Search subdirectories recursively
+            output_format: Output image format (png, jpg, etc.)
+            max_workers: Max parallel workers (None = CPU count)
+            log_file: Path to log file (None = no file logging)
+            overwrite: Overwrite existing output files
+            verbose: Print detailed progress messages
+        """
+        self.input_dir = Path(input_dir)
+        self.recursive = recursive
+        self.output_format = output_format.lower()
+        self.max_workers = max_workers
+        self.overwrite = overwrite
+        self.verbose = verbose
+
+        # Validate input directory
+        if not self.input_dir.exists():
+            raise FileNotFoundError(f"Input directory not found: {self.input_dir}")
+        
+        if not self.input_dir.is_dir():
+            raise NotADirectoryError(f"Input path is not a directory: {self.input_dir}")
+
+        # Validate output format
+        if self.output_format not in self.SUPPORTED_FORMATS:
+            raise ValueError(
+                f"Unsupported format: {self.output_format}. "
+                f"Supported formats: {', '.join(self.SUPPORTED_FORMATS)}"
+            )
+
+        # Set up output directory
+        self.output_dir = Path(output_dir) if output_dir else self.input_dir
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Initialize statistics
+        self.stats = {
+            "success": 0,
+            "failed": 0,
+            "skipped": 0,
+            "total_layers_hidden": 0,
+            "start_time": None,
+            "end_time": None,
+        }
+        
+        self.failed_files = []  # Track failed files for reporting
+        
+        # Set up logging
+        self._setup_logging(log_file)
+
+    def _setup_logging(self, log_file: Optional[str]):
+        """Configure logging for the batch job."""
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(logging.DEBUG if self.verbose else logging.INFO)
+        
+        # Clear existing handlers
+        self.logger.handlers.clear()
+        
+        # Console handler
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.INFO)
+        console_format = logging.Formatter('%(message)s')
+        console_handler.setFormatter(console_format)
+        self.logger.addHandler(console_handler)
+        
+        # File handler (if specified)
+        if log_file:
+            log_path = Path(log_file)
+            log_path.parent.mkdir(parents=True, exist_ok=True)
+            file_handler = logging.FileHandler(log_file, mode='a')
+            file_handler.setLevel(logging.DEBUG)
+            file_format = logging.Formatter(
+                '%(asctime)s - %(levelname)s - %(message)s',
+                datefmt='%Y-%m-%d %H:%M:%S'
+            )
+            file_handler.setFormatter(file_format)
+            self.logger.addHandler(file_handler)
+
+    def run(self):
+        """
+        Execute the batch processing with parallel execution.
+        
+        Returns:
+            Dictionary containing processing statistics
+        """
+        self.stats["start_time"] = datetime.now()
+        
+        files = list(self._get_files())
+        total_files = len(files)
+
+        if total_files == 0:
+            message = f"No PSD files found in {self.input_dir}"
+            if self.recursive:
+                message += " (including subdirectories)"
+            self.logger.warning(message)
+            return self.stats
+
+        self.logger.info(
+            f"Found {total_files} PSD file(s) in {self.input_dir}"
+        )
+        self.logger.info(f"Output directory: {self.output_dir}")
+        self.logger.info(f"Output format: {self.output_format.upper()}")
+        self.logger.info(f"Max workers: {self.max_workers or 'Auto (CPU count)'}\n")
+
+        if total_files == 1:
+            # Single file - no need for parallelism
+            self._process_single_file_wrapper(files[0])
+        else:
+            # Multiple files - use parallel processing
+            self._process_multiple_files(files, total_files)
+
+        self.stats["end_time"] = datetime.now()
+        self._print_summary(total_files)
+        self._copy_failed_file()
+
+    def _process_multiple_files(self, files: List[Path], total_files: int):
+        """Process multiple files in parallel."""
+        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+            # Submit all tasks
+            futures = {
+                executor.submit(self._process_single_file, psd_path): psd_path
+                for psd_path in files
+            }
+
+            with tqdm(
+                total=total_files,
+                desc="Processing PSD files",
+                unit="file",
+                disable=not self.verbose,
+            ) as pbar:
+                for future in as_completed(futures):
+                    psd_path = futures[future]
+                    
+                    try:
+                        success, message, count = future.result()
+                        self._update_stats(success, count, psd_path if not success else None)
+                        
+                        if self.verbose:
+                            tqdm.write(message)
+                        
+                    except Exception as e:
+                        self._update_stats(False, 0, psd_path)
+                        error_msg = f"✗ {psd_path.name}: Unexpected error - {e}"
+                        if self.verbose:
+                            tqdm.write(error_msg)
+                        self.logger.error(error_msg)
+                    
+                    pbar.update(1)
+
+    def _process_single_file_wrapper(self, psd_path: Path):
+        """Wrapper for processing a single file (non-parallel)."""
+        try:
+            success, message, count = self._process_single_file(psd_path)
+            self._update_stats(success, count, psd_path if not success else None)
+            self.logger.info(message)
+        except Exception as e:
+            self._update_stats(False, 0, psd_path)
+            error_msg = f"✗ {psd_path.name}: Unexpected error - {e}"
+            self.logger.error(error_msg)
+
+    def _process_single_file(self, psd_path: Path) -> Tuple[bool, str, int]:
+        """
+        Process a single PSD file.
+        
+        Returns:
+            Tuple of (success: bool, message: str, layers_hidden: int)
+        """
+        try:
+            dest_path = self._generate_output_path(psd_path)
+            
+            # Check if output exists and overwrite is disabled
+            if dest_path.exists() and not self.overwrite:
+                return (
+                    False,
+                    f"⊘ {psd_path.name}: Skipped (output exists, overwrite=False)",
+                    0,
+                )
+
+            # Load and process PSD
+            processor = PSDProcessor(psd_path)
+            processor.load()
+
+            # Hide text layers
+            count = processor.hide_non_image_layers()
+
+            # Export to specified format
+            processor.export(dest_path, format=self.output_format)
+
+            return (
+                True,
+                f"✓ {psd_path.name}: Hidden {count} text layer(s) → {dest_path.name}",
+                count,
+            )
+
+        except FileNotFoundError as e:
+            return (False, f"✗ {psd_path.name}: File not found - {e}", 0)
+        
+        except PermissionError as e:
+            return (False, f"✗ {psd_path.name}: Permission denied - {e}", 0)
+        
+        except Exception as e:
+            return (False, f"✗ {psd_path.name}: Processing failed - {e}", 0)
+
+    def _update_stats(self, success: bool, layers_hidden: int, failed_path: Optional[Path] = None):
+        """Update processing statistics."""
+        if success:
+            self.stats["success"] += 1
+            self.stats["total_layers_hidden"] += layers_hidden
+        else:
+            self.stats["failed"] += 1
+            if failed_path:
+                self.failed_files.append(failed_path)
+
+    def _get_files(self) -> List[Path]:
+        """Generator that yields PSD files."""
+        pattern = "**/*.psd" if self.recursive else "*.psd"
+        for path in self.input_dir.glob(pattern):
+            if path.is_file():
+                yield path
+
+    def _generate_output_path(self, psd_path: Path) -> Path:
+        """Generate the output file path, preserving directory structure if recursive."""
+        if self.recursive and self.output_dir != self.input_dir:
+            # Preserve subdirectory structure
+            relative_path = psd_path.relative_to(self.input_dir)
+            output_subdir = self.output_dir / relative_path.parent
+            output_subdir.mkdir(parents=True, exist_ok=True)
+            return output_subdir / f"{psd_path.stem}.{self.output_format}"
+        else:
+            return self.output_dir / f"{psd_path.stem}.{self.output_format}"
+    
+    def _copy_failed_file(self):
+        """Copy failed file to output directory for review (if needed)."""
+        failed_dir = os.path.join(self.output_dir, "failed_files")
+        os.makedirs(failed_dir, exist_ok=True)
+        self.logger.info(f"Copying failed files to {failed_dir} for review.")
+        for file in self.failed_files:
+            shutil.copy(file, failed_dir)
+        
+
+    def _print_summary(self, total_files: int):
+        """Print detailed processing summary."""
+        duration = self.stats["end_time"] - self.stats["start_time"]
+        
+        print("\n" + "=" * 60)
+        print("PROCESSING COMPLETE")
+        print("=" * 60)
+        print(f"Total files:          {total_files}")
+        print(f"✓ Successful:         {self.stats['success']}")
+        print(f"✗ Failed:             {self.stats['failed']}")
+        print(f"⊘ Skipped:            {self.stats['skipped']}")
+        print(f"Text layers hidden:   {self.stats['total_layers_hidden']}")
+        print(f"Processing time:      {duration}")
+        print(f"Output directory:     {self.output_dir}")
+        print("=" * 60)
+        
+        # Log failed files if any
+        if self.failed_files:
+            print("\nFailed files:")
+            for failed_file in self.failed_files:
+                print(f"  - {failed_file}")
+        
+        # Log to file
+        self.logger.info(f"Batch job completed: {self.stats['success']}/{total_files} successful")

mil_kit/main.py

@@ -0,0 +1,45 @@
+import argparse
+import sys
+from mil_kit.job import BatchJob
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Batch hide text layers in PSDs and export PNGs."
+    )
+    parser.add_argument(
+        "-d",
+        "--dir",
+        required=True,
+        help="Input directory containing PSD files",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Output directory (default: input directory)",
+    )
+    parser.add_argument(
+        "-f",
+        "--output-format",
+        default="png",
+        help="Output format (default: png)",
+    )
+    parser.add_argument(
+        "-r",
+        "--recursive",
+        action="store_true",
+        help="Process subdirectories recursively",
+    )
+
+    args = parser.parse_args()
+
+    try:
+        job = BatchJob(args.dir, args.output, args.recursive, output_format=args.output_format)
+        job.run()
+    except Exception as e:
+        print(f"Critical Error: {e}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mil_kit/psd/processor.py

@@ -0,0 +1,77 @@
+from psd_tools import PSDImage
+from pathlib import Path
+
+
+class PSDProcessor:
+    """
+    Handles the loading, modification, and exporting of a single PSD file.
+    """
+
+    def __init__(self, file_path):
+        self.file_path = Path(file_path)
+        self.psd = None
+        self.hidden_count = 0
+
+    def load(self):
+        """Loads the PSD file."""
+        try:
+            self.psd = PSDImage.open(self.file_path)
+        except Exception as e:
+            raise IOError(f"Failed to open PSD: {e}")
+
+    def hide_text_layers(self):
+        """Iterates through all layers and hides those of kind 'type'."""
+        if not self.psd:
+            raise RuntimeError("PSD not loaded. Call load() first.")
+
+        self.hidden_count = 0
+        # descendants() iterates recursively through groups
+        for layer in self.psd.descendants():
+            if layer.kind == "type" and layer.visible:
+                layer.visible = False
+                self.hidden_count += 1
+
+        return self.hidden_count
+    
+    def hide_non_image_layers(self):
+        """
+        Hides all non-raster layers including text, vectors, shapes, and adjustments.
+        Only keeps pixel/image layers visible.
+        """
+        if not self.psd:
+            raise RuntimeError("PSD not loaded. Call load() first.")
+
+        self.hidden_count = 0
+        self.hidden_by_type = {
+            "type": 0,      # Text layers
+            "shape": 0,     # Vector/shape layers
+            "adjustment": 0, # Adjustment layers
+            "other": 0      # Other non-pixel layers
+        }
+        
+        # descendants() iterates recursively through groups
+        for layer in self.psd.descendants():
+            # Only keep pixel/image layers visible
+            if layer.visible and layer.kind != "pixel":
+                layer.visible = False
+                self.hidden_count += 1
+                
+                # Track what type was hidden
+                if layer.kind in self.hidden_by_type:
+                    self.hidden_by_type[layer.kind] += 1
+                else:
+                    self.hidden_by_type["other"] += 1
+
+        return self.hidden_count
+
+
+    def export(self, output_path, format="png"):
+        """Composites the PSD and saves as PNG."""
+        if not self.psd:
+            raise RuntimeError("PSD not loaded.")
+
+        # Ensure the target directory exists
+        Path(output_path).parent.mkdir(parents=True, exist_ok=True)
+
+        # Composite merges layers; save exports using PIL/Pillow
+        self.psd.composite().save(output_path, format=format.upper())

mil_kit-0.3.0.dist-info/METADATA

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: mil-kit
+Version: 0.3.0
+Summary: A toolkit for processing the ASM's Mammal Image Library (MIL).
+Project-URL: Homepage, https://github.com/hhandika/mil-kit
+Project-URL: Repository, https://github.com/hhandika/mil-kit
+Project-URL: Issues, https://github.com/hhandika/mil-kit/issues
+Author-email: Heru Handika <herubiolog@gmail.com>
+License: MIT
+License-File: LICENSE
+Keywords: automation,batch-processing,image-processing,photoshop,psd
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Graphics :: Graphics Conversion
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Requires-Dist: pillow>=12.0.0
+Requires-Dist: psd-tools>=1.12.0
+Requires-Dist: tqdm>=4.67.1
+Description-Content-Type: text/markdown
+
+# mil-kit
+
+![Tests](https://github.com/hhandika/psd-toolkit/actions/workflows/test.yml/badge.svg)
+![GitHub Tag](https://img.shields.io/github/v/tag/hhandika/psd-toolkit?label=GitHub)
+![PyPI - Version](https://img.shields.io/pypi/v/psd-toolkit?color=blue)
+
+A Python toolkit for batch processing the Mammal Image Library (MIL) images. Reshape, convert, and optimize images for the mammal diversity database and other applications.
+
+## Features
+
+- 🚀 Batch process multiple PSD files in a directory
+- ⚡ Parallel processing for faster execution
+- 📊 Progress bar with detailed status
+- 📝 Automatically hide all text layers
+- 🖼️ Export processed files as PNG (default) or other formats
+- 📁 Support for recursive directory processing
+- ⚡ Preserve folder structure in output
+
+## Installation
+
+Install using pip:
+
+```bash
+pip install mil-kit
+```
+
+Or using uv:
+
+```bash
+uv add mil-kit
+```
+
+## Usage
+
+### Command Line
+
+Process PSD files in a directory:
+
+```bash
+mil-kit -d /path/to/psd/files
+```
+
+Process recursively, specify output directory, and use JPEG format:
+
+```bash
+mil-kit -d /path/to/psd/files -o /path/to/output -r -f jpeg
+```
+
+### Options
+
+- `-d, --dir`: Input directory containing PSD files (required)
+- `-o, --output`: Output directory for processed files (default: input directory)
+- `-f, --output-format`: Output image format (default: png)
+- `-r, --recursive`: Process subdirectories recursively
+
+### Python API
+
+You can also use mil-kit as a Python library:
+
+```python
+from mil_kit.psd.processor import PSDProcessor
+from mil_kit.job import BatchJob
+
+# Process a single file
+processor = PSDProcessor("image.psd")
+processor.load()
+processor.hide_non_image_layers()
+processor.export("output.jpg", format="jpeg")
+
+# Batch process
+job = BatchJob(
+    input_dir="./psd_files",
+    output_dir="./output",
+    recursive=True,
+    output_format="png",
+    max_workers=4
+)
+job.run()
+```
+
+## Requirements
+
+- Python >= 3.10
+- psd-tools >= 1.12.0
+- pillow >= 12.0.0
+- tqdm >= 4.67.1
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Issues
+
+Report bugs and request features on [GitHub Issues](https://github.com/hhandika/psd-toolkit/issues).

mil_kit-0.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+mil_kit/__init__.py,sha256=dsQfNrRHFHjthFmgDbgWHD2Ho2VUjv2glCibmLg9XDQ,57
+mil_kit/job.py,sha256=TpPWMGVk00m4TDNixvGZHVXz_SlYidDfzyJAbyssHkc,11643
+mil_kit/main.py,sha256=Yw8TpRWWnxVkjxfJ8EXUUPgoi6kVv_mF126jFiBVWD0,1020
+mil_kit/psd/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mil_kit/psd/processor.py,sha256=mKYTZv32fKfuP_uBwjL4jwdWcMGK4rhu2uuDgvx9SrI,2577
+mil_kit-0.3.0.dist-info/METADATA,sha256=XL5sJfhDfL4MyPUgoG61W9WmWym_1JAo3B6SZoPbNk8,3418
+mil_kit-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mil_kit-0.3.0.dist-info/entry_points.txt,sha256=pdJaTXH8FgBxIi_p4-yEKeWONK6kD4fqUJRE65dYukw,46
+mil_kit-0.3.0.dist-info/licenses/LICENSE,sha256=KFqQz-OHVHOQWPwC7dROatkfKRXVDlH0wZnTJd44LsU,1069
+mil_kit-0.3.0.dist-info/RECORD,,

mil_kit-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mil_kit-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mil-kit = mil_kit.main:main

mil_kit-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Heru Handika
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.