tinycomp-amadeus 0.1.0__tar.gz

tinycomp_amadeus-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 TinyComp
+
+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. 

tinycomp_amadeus-0.1.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: tinycomp-amadeus
+Version: 0.1.0
+Summary: A Python package for compressing images using TinyPNG API
+Home-page: https://github.com/Amadeus9029/tinycomp
+Author: Amadeus9029
+Author-email: 965720890@qq.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tinify
+Requires-Dist: requests
+Requires-Dist: tqdm
+Requires-Dist: beautifulsoup4
+Requires-Dist: selenium
+Requires-Dist: fake-useragent
+
+# TinyComp
+
+TinyComp is a Python package that helps you compress images using the TinyPNG API. It provides both a command-line interface and a Python API for easy integration into your projects.
+
+## Features
+
+- Automatic API key management and rotation
+- Automatic API key acquisition when needed
+- Batch image compression
+- Support for multiple image formats (PNG, JPG, JPEG, SVG, GIF)
+- Progress bar for tracking compression status
+- Multi-threaded compression for better performance
+- Automatic handling of API usage limits
+- Automatic API key update through web automation
+
+## Installation
+
+```bash
+pip install tinycomp
+```
+
+## Usage
+
+### Command Line Interface
+
+#### Compressing Images
+
+```bash
+# Basic compression
+tinycomp compress --source ./images --target ./compressed
+
+# With custom API key
+tinycomp compress --source ./images --target ./compressed --api-key YOUR_API_KEY
+
+# Set number of threads
+tinycomp compress --source ./images --target ./compressed --threads 4
+
+# Enable automatic API key updates when needed
+tinycomp compress --source ./images --target ./compressed --auto-update-key
+```
+
+#### Managing API Keys
+
+```bash
+# Update API key (checks current key first)
+tinycomp update-key
+
+# Force update API key even if current one is valid
+tinycomp update-key --force
+```
+
+### Python API
+
+```python
+from tinycomp import TinyCompressor
+
+# Initialize compressor
+compressor = TinyCompressor(api_key="YOUR_API_KEY")  # API key is optional
+
+# Enable automatic API key updates
+compressor = TinyCompressor(auto_update_key=True)
+
+# Compress a single image
+compressor.compress_image("input.png", "output.png")
+
+# Compress multiple images
+compressor.compress_directory("./images", "./compressed")
+
+# Update API key programmatically
+from tinycomp.api_manager import APIKeyManager
+api_manager = APIKeyManager()
+new_key = api_manager.get_new_api_key()
+```
+
+## Configuration
+
+You can configure TinyComp using environment variables:
+
+- `TINYCOMP_API_KEY`: Your TinyPNG API key
+- `TINYCOMP_MAX_THREADS`: Maximum number of compression threads (default: 4)
+
+## Requirements
+
+- Python 3.6 or higher
+- Chrome/Chromium browser (for automatic API key updates)
+- ChromeDriver matching your Chrome version
+
+## API Key Management
+
+TinyComp includes an automatic API key management system that:
+
+1. Automatically rotates between multiple API keys
+2. Monitors remaining API usage
+3. Can automatically obtain new API keys when needed
+4. Saves API keys for future use
+
+The package offers two modes for handling API key depletion:
+
+1. Default mode: Stops compression and notifies when the API key runs out
+2. Auto-update mode: Automatically obtains new API keys when needed (use `--auto-update-key` flag)
+
+The automatic key update feature requires:
+- Chrome/Chromium browser installed
+- ChromeDriver in your system PATH or in the working directory
+- Internet connection for accessing TinyPNG website
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. 

tinycomp_amadeus-0.1.0/README.md

@@ -0,0 +1,113 @@
+# TinyComp
+
+TinyComp is a Python package that helps you compress images using the TinyPNG API. It provides both a command-line interface and a Python API for easy integration into your projects.
+
+## Features
+
+- Automatic API key management and rotation
+- Automatic API key acquisition when needed
+- Batch image compression
+- Support for multiple image formats (PNG, JPG, JPEG, SVG, GIF)
+- Progress bar for tracking compression status
+- Multi-threaded compression for better performance
+- Automatic handling of API usage limits
+- Automatic API key update through web automation
+
+## Installation
+
+```bash
+pip install tinycomp
+```
+
+## Usage
+
+### Command Line Interface
+
+#### Compressing Images
+
+```bash
+# Basic compression
+tinycomp compress --source ./images --target ./compressed
+
+# With custom API key
+tinycomp compress --source ./images --target ./compressed --api-key YOUR_API_KEY
+
+# Set number of threads
+tinycomp compress --source ./images --target ./compressed --threads 4
+
+# Enable automatic API key updates when needed
+tinycomp compress --source ./images --target ./compressed --auto-update-key
+```
+
+#### Managing API Keys
+
+```bash
+# Update API key (checks current key first)
+tinycomp update-key
+
+# Force update API key even if current one is valid
+tinycomp update-key --force
+```
+
+### Python API
+
+```python
+from tinycomp import TinyCompressor
+
+# Initialize compressor
+compressor = TinyCompressor(api_key="YOUR_API_KEY")  # API key is optional
+
+# Enable automatic API key updates
+compressor = TinyCompressor(auto_update_key=True)
+
+# Compress a single image
+compressor.compress_image("input.png", "output.png")
+
+# Compress multiple images
+compressor.compress_directory("./images", "./compressed")
+
+# Update API key programmatically
+from tinycomp.api_manager import APIKeyManager
+api_manager = APIKeyManager()
+new_key = api_manager.get_new_api_key()
+```
+
+## Configuration
+
+You can configure TinyComp using environment variables:
+
+- `TINYCOMP_API_KEY`: Your TinyPNG API key
+- `TINYCOMP_MAX_THREADS`: Maximum number of compression threads (default: 4)
+
+## Requirements
+
+- Python 3.6 or higher
+- Chrome/Chromium browser (for automatic API key updates)
+- ChromeDriver matching your Chrome version
+
+## API Key Management
+
+TinyComp includes an automatic API key management system that:
+
+1. Automatically rotates between multiple API keys
+2. Monitors remaining API usage
+3. Can automatically obtain new API keys when needed
+4. Saves API keys for future use
+
+The package offers two modes for handling API key depletion:
+
+1. Default mode: Stops compression and notifies when the API key runs out
+2. Auto-update mode: Automatically obtains new API keys when needed (use `--auto-update-key` flag)
+
+The automatic key update feature requires:
+- Chrome/Chromium browser installed
+- ChromeDriver in your system PATH or in the working directory
+- Internet connection for accessing TinyPNG website
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. 

tinycomp_amadeus-0.1.0/setup.cfg

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

tinycomp_amadeus-0.1.0/setup.py

@@ -0,0 +1,41 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="tinycomp-amadeus",
+    version="0.1.0",
+    author="Amadeus9029",
+    author_email="965720890@qq.com",
+    description="A Python package for compressing images using TinyPNG API",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/Amadeus9029/tinycomp",
+    packages=find_packages(),
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.6",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+    ],
+    python_requires=">=3.6",
+    install_requires=[
+        "tinify",
+        "requests",
+        "tqdm",
+        "beautifulsoup4",
+        "selenium",
+        "fake-useragent"
+    ],
+    entry_points={
+        'console_scripts': [
+            'tinycomp=tinycomp.cli:main',
+        ],
+    },
+) 

tinycomp_amadeus-0.1.0/tinycomp/__init__.py

@@ -0,0 +1,11 @@
+"""
+TinyComp - A Python package for compressing images using TinyPNG API
+"""
+
+from .compressor import TinyCompressor
+
+__version__ = "0.1.0"
+__author__ = "Amadeus9029"
+__email__ = "965720890@qq.com"
+
+__all__ = ['TinyCompressor'] 

tinycomp_amadeus-0.1.0/tinycomp/api_manager.py

@@ -0,0 +1,318 @@
+"""
+API key management for TinyPNG
+"""
+
+import os
+import json
+import time
+import random
+import string
+from typing import List, Dict, Optional, Tuple
+import tinify
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+from selenium.webdriver.chrome.service import Service
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support.ui import WebDriverWait
+from selenium.webdriver.support import expected_conditions as EC
+from fake_useragent import UserAgent
+
+class APIKeyManager:
+    """Manages TinyPNG API keys, including loading, saving, and validation."""
+    
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Initialize the API key manager.
+        
+        Args:
+            api_key (str, optional): Initial API key to use. If not provided,
+                                   will try to get from environment or saved keys.
+        """
+        self.api_keys_file = "tinypng_api_keys.json"
+        self.current_key = api_key or os.getenv("TINYCOMP_API_KEY")
+        
+        if not self.current_key:
+            self.current_key = self._get_valid_api_key()
+    
+    def _load_api_keys(self) -> List[str]:
+        """Load saved API keys from file."""
+        if os.path.exists(self.api_keys_file):
+            try:
+                with open(self.api_keys_file, 'r') as f:
+                    data = json.load(f)
+                    return data.get("api_keys", [])
+            except Exception as e:
+                print(f"Error loading API keys file: {str(e)}")
+        return []
+    
+    def _save_api_keys(self, api_keys: List[str]) -> None:
+        """Save API keys to file."""
+        try:
+            data = {"api_keys": api_keys}
+            with open(self.api_keys_file, 'w') as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"Error saving API keys to file: {str(e)}")
+    
+    def _get_compression_count(self, api_key: Optional[str] = None) -> Dict[str, any]:
+        """
+        Get the compression count for an API key.
+        
+        Args:
+            api_key (str, optional): API key to check. If None, uses current key.
+            
+        Returns:
+            dict: Contains compression count information and status.
+        """
+        result = {
+            'compression_count': 0,
+            'remaining': 500,
+            'success': False,
+            'error': None
+        }
+        
+        # If provided new API key, temporarily set it
+        old_key = None
+        if api_key:
+            old_key = tinify.key
+            tinify.key = api_key
+        
+        try:
+            # Create a tiny PNG image for validation
+            tiny_png = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\nIDATx\x9cc\x00\x01\x00\x00\x05\x00\x01\r\n-\xb4\x00\x00\x00\x00IEND\xaeB`\x82'
+            
+            # Send request to activate compression_count
+            source = tinify.from_buffer(tiny_png)
+            
+            # Get compression count
+            compression_count = getattr(tinify, 'compression_count', 0)
+            if compression_count is None:
+                compression_count = 0
+                
+            # Calculate remaining
+            remaining = 500 - compression_count
+            
+            result.update({
+                'compression_count': compression_count,
+                'remaining': remaining,
+                'success': True
+            })
+            
+        except tinify.Error as e:
+            result['error'] = str(e)
+        except Exception as e:
+            result['error'] = f"Unknown error: {str(e)}"
+        
+        # Restore original API key
+        if old_key:
+            tinify.key = old_key
+            
+        return result
+    
+    def _get_valid_api_key(self) -> Optional[str]:
+        """Get a valid API key from saved keys or environment."""
+        # Load saved API keys
+        api_keys = self._load_api_keys()
+        
+        # Check each saved key
+        for key in api_keys:
+            tinify.key = key
+            try:
+                result = self._get_compression_count(key)
+                if result['success'] and result['remaining'] > 0:
+                    return key
+            except:
+                continue
+        
+        return None
+
+    def _generate_random_name(self) -> str:
+        """Generate random name for registration."""
+        first_names = ['Zhang', 'Li', 'Wang', 'Liu', 'Chen', 'Yang', 'Huang', 'Zhao', 'Wu', 'Zhou']
+        last_names = ['Wei', 'Min', 'Jie', 'Fang', 'Ying', 'Hai', 'Jun', 'Xin', 'Feng', 'Yu']
+        return f"{random.choice(first_names)} {random.choice(last_names)}"
+
+    def _configure_chrome_options(self) -> Options:
+        """Configure Chrome options with random fingerprint."""
+        chrome_options = Options()
+        chrome_options.add_argument('--headless')
+        chrome_options.add_argument('--no-sandbox')
+        chrome_options.add_argument('--disable-dev-shm-usage')
+        
+        try:
+            ua = UserAgent().chrome
+        except:
+            ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+        
+        chrome_options.add_argument(f'--user-agent={ua}')
+        chrome_options.add_argument('--disable-blink-features=AutomationControlled')
+        chrome_options.add_experimental_option('excludeSwitches', ['enable-automation'])
+        chrome_options.add_experimental_option('useAutomationExtension', False)
+        
+        return chrome_options
+
+    def _get_temp_email(self) -> Tuple[Optional[str], Optional[webdriver.Chrome]]:
+        """Get temporary email address from temporary email service."""
+        print("Getting temporary email...")
+        
+        chrome_options = self._configure_chrome_options()
+        driver_path = os.path.join(os.getcwd(), "chromedriver.exe")
+        driver = webdriver.Chrome(service=Service(driver_path), options=chrome_options)
+        
+        try:
+            driver.get("https://www.nimail.cn/index.html")
+            
+            random_email_btn = WebDriverWait(driver, 10).until(
+                EC.element_to_be_clickable((By.XPATH, "//button[contains(text(), '随机邮箱')]"))
+            )
+            random_email_btn.click()
+            
+            time.sleep(2)
+            
+            email_username_element = WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.XPATH, '//*[@id="mailuser"]'))
+            )
+            email_username = email_username_element.get_attribute("value")
+            email = f"{email_username}@nimail.cn"
+            
+            apply_email_btn = WebDriverWait(driver, 10).until(
+                EC.element_to_be_clickable((By.XPATH, "//button[contains(text(), '申请邮箱')]"))
+            )
+            apply_email_btn.click()
+            
+            time.sleep(3)
+            print(f"Temporary email activated: {email}")
+            
+            return email, driver
+        except Exception as e:
+            print(f"Failed to get temporary email: {str(e)}")
+            if driver:
+                driver.quit()
+            return None, None
+
+    def _request_new_api_key(self, email: str, driver: webdriver.Chrome) -> Optional[str]:
+        """Request new TinyPNG API key using temporary email."""
+        print(f"Requesting new TinyPNG API key using email: {email}")
+        
+        try:
+            original_window = driver.current_window_handle
+            driver.execute_script("window.open('https://tinify.com/developers', '_blank');")
+            time.sleep(2)
+            driver.switch_to.window(driver.window_handles[-1])
+            
+            WebDriverWait(driver, 20).until(
+                EC.presence_of_element_located((By.NAME, "name"))
+            )
+            
+            name_input = driver.find_element(By.NAME, "name")
+            name_input.send_keys(self._generate_random_name())
+            
+            email_input = driver.find_element(By.NAME, "email")
+            email_input.send_keys(email)
+            
+            submit_button = driver.find_element(By.CSS_SELECTOR, "button[type='submit']")
+            submit_button.click()
+            
+            driver.switch_to.window(original_window)
+            
+            max_attempts = 15
+            for attempt in range(max_attempts):
+                print(f"Waiting for confirmation email... ({attempt+1}/{max_attempts})")
+                time.sleep(10)
+                
+                try:
+                    tinypng_email = WebDriverWait(driver, 5).until(
+                        EC.presence_of_element_located((By.XPATH, '//*[@id="inbox"]/tr[2]'))
+                    )
+                    tinypng_email.click()
+                    time.sleep(3)
+                    
+                    new_window = driver.window_handles[-1]
+                    driver.switch_to.window(new_window)
+                    
+                    dashboard_link = WebDriverWait(driver, 5).until(
+                        EC.element_to_be_clickable((By.XPATH, "//a[contains(text(), 'Visit your dashboard') or contains(@href, 'dashboard')]"))
+                    )
+                    dashboard_url = dashboard_link.get_attribute("href")
+                    driver.execute_script(f"window.open('{dashboard_url}', '_blank');")
+                    time.sleep(3)
+                    
+                    driver.switch_to.window(driver.window_handles[-1])
+                    time.sleep(5)
+                    
+                    api_key_element = WebDriverWait(driver, 10).until(
+                        EC.presence_of_element_located((By.XPATH, "/html/body/div[1]/div/main/section/div/div/section/div[2]/div[1]/div/div[3]/strong/p"))
+                    )
+                    key_text = api_key_element.text.strip()
+                    
+                    if key_text and len(key_text) > 20:
+                        print(f"Successfully obtained new API key")
+                        return key_text
+                    
+                except Exception as e:
+                    print(f"Attempt {attempt+1} failed: {str(e)}")
+                    continue
+            
+            print("Timeout waiting for API key")
+            return None
+            
+        except Exception as e:
+            print(f"Failed to request new API key: {str(e)}")
+            return None
+        finally:
+            if driver:
+                driver.quit()
+
+    def get_new_api_key(self) -> Optional[str]:
+        """Get new API key and save it."""
+        email, driver = self._get_temp_email()
+        if not email or not driver:
+            return None
+        
+        try:
+            new_key = self._request_new_api_key(email, driver)
+            if new_key:
+                # Add new key to saved keys
+                api_keys = self._load_api_keys()
+                if new_key not in api_keys:
+                    api_keys.append(new_key)
+                    self._save_api_keys(api_keys)
+                return new_key
+            return None
+        finally:
+            if driver:
+                driver.quit()
+    
+    def check_and_update_api_key(self) -> bool:
+        """
+        Check current API key and update if necessary.
+        
+        Returns:
+            bool: True if a valid API key is available, False otherwise.
+        """
+        if not self.current_key:
+            self.current_key = self._get_valid_api_key()
+            if not self.current_key:
+                return False
+        
+        tinify.key = self.current_key
+        
+        # Get API key usage
+        result = self._get_compression_count()
+        
+        if result['success']:
+            if result['remaining'] <= 50:  # If less than 50 compressions remaining
+                # Try to get a new key
+                new_key = self._get_valid_api_key()
+                if new_key:
+                    self.current_key = new_key
+                    tinify.key = new_key
+            return True
+        else:
+            # Current key is invalid, try to get a new one
+            new_key = self._get_valid_api_key()
+            if new_key:
+                self.current_key = new_key
+                tinify.key = new_key
+                return True
+            return False 

tinycomp_amadeus-0.1.0/tinycomp/cli.py

@@ -0,0 +1,149 @@
+"""
+Command-line interface for TinyComp
+"""
+
+import os
+import argparse
+from typing import Optional
+from .compressor import TinyCompressor
+from .api_manager import APIKeyManager
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(
+        description="Compress images using TinyPNG API",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter
+    )
+    
+    subparsers = parser.add_subparsers(dest='command', help='Commands')
+    
+    # Compress command
+    compress_parser = subparsers.add_parser('compress', help='Compress images')
+    compress_parser.add_argument(
+        "--source",
+        "-s",
+        required=True,
+        help="Source directory or file path"
+    )
+    
+    compress_parser.add_argument(
+        "--target",
+        "-t",
+        required=True,
+        help="Target directory or file path"
+    )
+    
+    compress_parser.add_argument(
+        "--api-key",
+        "-k",
+        help="TinyPNG API key (optional)"
+    )
+    
+    compress_parser.add_argument(
+        "--threads",
+        "-n",
+        type=int,
+        default=4,
+        help="Number of compression threads"
+    )
+    
+    compress_parser.add_argument(
+        "--skip-existing",
+        "-x",
+        action="store_true",
+        default=True,
+        help="Skip existing files in target directory"
+    )
+    
+    compress_parser.add_argument(
+        "--auto-update-key",
+        "-a",
+        action="store_true",
+        help="Automatically get new API keys when current one runs out"
+    )
+    
+    # Update API key command
+    update_parser = subparsers.add_parser('update-key', help='Update TinyPNG API key')
+    update_parser.add_argument(
+        "--force",
+        "-f",
+        action="store_true",
+        help="Force update even if current key is still valid"
+    )
+    
+    return parser.parse_args()
+
+def compress_images(args):
+    """Handle image compression command."""
+    # Initialize compressor
+    compressor = TinyCompressor(
+        api_key=args.api_key,
+        max_workers=args.threads,
+        auto_update_key=args.auto_update_key
+    )
+    
+    # Check if source is a directory or file
+    if os.path.isdir(args.source):
+        # Compress directory
+        print(f"Compressing directory: {args.source}")
+        stats = compressor.compress_directory(
+            args.source,
+            args.target,
+            skip_existing=args.skip_existing
+        )
+        
+        # Print results
+        print("\nCompression completed!")
+        print(f"Total files: {stats['total']}")
+        print(f"Successfully compressed: {stats['success']}")
+        print(f"Failed: {stats['failed']}")
+        print(f"Success rate: {stats['percent']:.1f}%")
+        if stats.get('keys_used'):
+            print(f"API keys used: {stats['keys_used']}")
+        
+    else:
+        # Compress single file
+        print(f"Compressing file: {args.source}")
+        result = compressor.compress_image(args.source, args.target)
+        
+        if result['status'] == 'success':
+            print("File compressed successfully!")
+        else:
+            print(f"Compression failed: {result['message']}")
+
+def update_api_key(args):
+    """Handle API key update command."""
+    api_manager = APIKeyManager()
+    
+    if not args.force:
+        # Check if current key is still valid
+        if api_manager.current_key:
+            result = api_manager._get_compression_count()
+            if result['success'] and result['remaining'] > 50:
+                print(f"Current API key is still valid (remaining: {result['remaining']} compressions)")
+                print("Use --force to update anyway")
+                return
+    
+    print("Requesting new API key...")
+    new_key = api_manager.get_new_api_key()
+    
+    if new_key:
+        print("Successfully obtained and saved new API key")
+        print(f"Remaining compressions: {api_manager._get_compression_count(new_key)['remaining']}")
+    else:
+        print("Failed to obtain new API key")
+
+def main():
+    """Main entry point for the CLI."""
+    args = parse_args()
+    
+    if args.command == 'compress':
+        compress_images(args)
+    elif args.command == 'update-key':
+        update_api_key(args)
+    else:
+        print("Please specify a command: compress or update-key")
+        print("Use -h or --help for more information")
+
+if __name__ == "__main__":
+    main() 

tinycomp_amadeus-0.1.0/tinycomp/compressor.py

@@ -0,0 +1,195 @@
+"""
+TinyCompressor class for handling image compression using TinyPNG API
+"""
+
+import os
+import json
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Dict, Optional, Union
+from tqdm import tqdm
+import tinify
+from .api_manager import APIKeyManager
+
+class TinyCompressor:
+    """
+    A class for compressing images using the TinyPNG API.
+    """
+    
+    SUPPORTED_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.svg', '.gif']
+    
+    def __init__(self, api_key: Optional[str] = None, max_workers: int = 4, auto_update_key: bool = False):
+        """
+        Initialize the TinyCompressor.
+        
+        Args:
+            api_key (str, optional): TinyPNG API key. If not provided, will try to get from environment
+                                   or manage automatically.
+            max_workers (int): Maximum number of concurrent compression threads.
+            auto_update_key (bool): Whether to automatically get new API keys when current one runs out.
+        """
+        self.max_workers = max_workers
+        self.auto_update_key = auto_update_key
+        self.api_manager = APIKeyManager(api_key)
+        self.keys_used = set()  # Track used API keys
+        
+    def compress_image(self, source_path: str, target_path: str) -> Dict[str, str]:
+        """
+        Compress a single image.
+        
+        Args:
+            source_path (str): Path to the source image.
+            target_path (str): Path where the compressed image will be saved.
+            
+        Returns:
+            dict: Compression result containing status and message.
+        """
+        # Ensure the API key is valid
+        if not self.api_manager.check_and_update_api_key():
+            if self.auto_update_key:
+                print("Current API key is invalid or depleted, requesting new key...")
+                new_key = self.api_manager.get_new_api_key()
+                if not new_key:
+                    return {
+                        'status': 'failed',
+                        'message': 'Failed to obtain new API key'
+                    }
+                self.api_manager.current_key = new_key
+                tinify.key = new_key
+            else:
+                return {
+                    'status': 'failed',
+                    'message': 'No valid API key available. Use --auto-update-key to automatically get new keys.'
+                }
+        
+        # Add current key to used keys set
+        if self.api_manager.current_key:
+            self.keys_used.add(self.api_manager.current_key)
+        
+        # Create target directory if it doesn't exist
+        os.makedirs(os.path.dirname(target_path), exist_ok=True)
+        
+        try:
+            # Compress the image
+            source = tinify.from_file(source_path)
+            source.to_file(target_path)
+            
+            return {
+                'status': 'success',
+                'message': 'Image compressed successfully'
+            }
+        except tinify.AccountError as e:
+            if self.auto_update_key:
+                print("API key limit reached, requesting new key...")
+                new_key = self.api_manager.get_new_api_key()
+                if new_key:
+                    self.api_manager.current_key = new_key
+                    tinify.key = new_key
+                    # Retry compression with new key
+                    return self.compress_image(source_path, target_path)
+            return {
+                'status': 'failed',
+                'message': f'API key error: {str(e)}. Use --auto-update-key to automatically get new keys.'
+            }
+        except tinify.Error as e:
+            return {
+                'status': 'failed',
+                'message': f'Compression failed: {str(e)}'
+            }
+        except Exception as e:
+            return {
+                'status': 'failed',
+                'message': f'Processing error: {str(e)}'
+            }
+    
+    def compress_directory(self, source_dir: str, target_dir: str, 
+                         skip_existing: bool = True) -> Dict[str, Union[int, float]]:
+        """
+        Compress all supported images in a directory.
+        
+        Args:
+            source_dir (str): Source directory containing images to compress.
+            target_dir (str): Target directory for compressed images.
+            skip_existing (bool): Whether to skip files that already exist in target directory.
+            
+        Returns:
+            dict: Compression statistics.
+        """
+        # Get list of files to process
+        image_files = self._get_image_files(source_dir)
+        
+        if skip_existing:
+            image_files = [f for f in image_files if self._should_compress(f, source_dir, target_dir)]
+        
+        total_files = len(image_files)
+        if total_files == 0:
+            return {
+                'total': 0,
+                'processed': 0,
+                'success': 0,
+                'failed': 0,
+                'percent': 100.0,
+                'keys_used': 0
+            }
+        
+        stats = {
+            'total': total_files,
+            'processed': 0,
+            'success': 0,
+            'failed': 0
+        }
+        
+        # Process files with progress bar
+        with tqdm(total=total_files, unit="file", desc="Compressing images") as progress_bar:
+            with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
+                future_to_file = {
+                    executor.submit(
+                        self._process_single_file, 
+                        file_path, 
+                        source_dir, 
+                        target_dir
+                    ): file_path for file_path in image_files
+                }
+                
+                for future in as_completed(future_to_file):
+                    result = future.result()
+                    stats['processed'] += 1
+                    
+                    if result['status'] == 'success':
+                        stats['success'] += 1
+                    else:
+                        stats['failed'] += 1
+                        print(f"\nFailed to compress {future_to_file[future]}: {result['message']}")
+                        
+                    progress_bar.update(1)
+        
+        stats['percent'] = (stats['success'] / stats['total']) * 100
+        stats['keys_used'] = len(self.keys_used)
+        return stats
+    
+    def _get_image_files(self, directory: str) -> List[str]:
+        """Get all supported image files in the directory."""
+        image_files = []
+        
+        for root, _, files in os.walk(directory):
+            for name in files:
+                file_path = os.path.join(root, name)
+                _, file_ext = os.path.splitext(name)
+                
+                if file_ext.lower() in self.SUPPORTED_EXTENSIONS:
+                    image_files.append(file_path)
+        
+        return image_files
+    
+    def _should_compress(self, file_path: str, source_dir: str, target_dir: str) -> bool:
+        """Check if the file should be compressed (skip if target exists)."""
+        relative_path = os.path.relpath(file_path, source_dir)
+        target_path = os.path.join(target_dir, relative_path)
+        return not os.path.exists(target_path)
+    
+    def _process_single_file(self, file_path: str, source_dir: str, target_dir: str) -> Dict[str, str]:
+        """Process a single file for compression."""
+        relative_path = os.path.relpath(file_path, source_dir)
+        target_path = os.path.join(target_dir, relative_path)
+        
+        return self.compress_image(file_path, target_path) 

tinycomp_amadeus-0.1.0/tinycomp/tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test package for TinyComp
+""" 

tinycomp_amadeus-0.1.0/tinycomp/tests/test_compressor.py

@@ -0,0 +1,101 @@
+"""
+Tests for the TinyCompressor class
+"""
+
+import os
+import unittest
+from unittest.mock import patch, MagicMock
+from tinycomp import TinyCompressor
+
+class TestTinyCompressor(unittest.TestCase):
+    """Test cases for TinyCompressor class."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        self.compressor = TinyCompressor(api_key="YYKcY8Z99BDJnjvZhgRWJQqqvNFKhlcL")
+        self.test_image = "test.png"
+        self.test_output = "output.png"
+    
+    @patch('tinycomp.compressor.tinify.from_file')
+    def test_compress_image_success(self, mock_from_file):
+        """Test successful image compression."""
+        # Mock the tinify.from_file() call
+        mock_source = MagicMock()
+        mock_from_file.return_value = mock_source
+        
+        # Mock successful compression
+        result = self.compressor.compress_image(self.test_image, self.test_output)
+        
+        # 验证返回值
+        self.assertEqual(result['status'], 'success')
+        self.assertEqual(result['message'], 'Image compressed successfully')
+        
+        # 验证调用
+        mock_from_file.assert_called_once_with(self.test_image)
+        mock_source.to_file.assert_called_once_with(self.test_output)
+    
+    def test_get_image_files(self):
+        """Test getting supported image files from directory."""
+        # Create temporary test directory with some files
+        test_dir = "test_dir"
+        os.makedirs(test_dir, exist_ok=True)
+        
+        # Create test files
+        test_files = [
+            "test1.png",
+            "test2.jpg",
+            "test3.txt",  # Unsupported extension
+            "test4.jpeg"
+        ]
+        
+        for file in test_files:
+            with open(os.path.join(test_dir, file), 'w') as f:
+                f.write("test")
+        
+        # Get image files
+        image_files = self.compressor._get_image_files(test_dir)
+        
+        # Verify results
+        self.assertEqual(len(image_files), 3)  # Should find 3 supported images
+        
+        # Clean up
+        for file in test_files:
+            os.remove(os.path.join(test_dir, file))
+        os.rmdir(test_dir)
+    
+    def test_should_compress(self):
+        """Test should_compress method."""
+        # Create test directories
+        source_dir = "test_source"
+        target_dir = "test_target"
+        os.makedirs(source_dir, exist_ok=True)
+        os.makedirs(target_dir, exist_ok=True)
+        
+        # Create test file
+        test_file = os.path.join(source_dir, "test.png")
+        with open(test_file, 'w') as f:
+            f.write("test")
+        
+        # Test when target doesn't exist
+        self.assertTrue(
+            self.compressor._should_compress(test_file, source_dir, target_dir)
+        )
+        
+        # Create target file
+        target_file = os.path.join(target_dir, "test.png")
+        with open(target_file, 'w') as f:
+            f.write("test")
+        
+        # Test when target exists
+        self.assertFalse(
+            self.compressor._should_compress(test_file, source_dir, target_dir)
+        )
+        
+        # Clean up
+        os.remove(test_file)
+        os.remove(target_file)
+        os.rmdir(source_dir)
+        os.rmdir(target_dir)
+
+if __name__ == '__main__':
+    unittest.main() 

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

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: tinycomp-amadeus
+Version: 0.1.0
+Summary: A Python package for compressing images using TinyPNG API
+Home-page: https://github.com/Amadeus9029/tinycomp
+Author: Amadeus9029
+Author-email: 965720890@qq.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tinify
+Requires-Dist: requests
+Requires-Dist: tqdm
+Requires-Dist: beautifulsoup4
+Requires-Dist: selenium
+Requires-Dist: fake-useragent
+
+# TinyComp
+
+TinyComp is a Python package that helps you compress images using the TinyPNG API. It provides both a command-line interface and a Python API for easy integration into your projects.
+
+## Features
+
+- Automatic API key management and rotation
+- Automatic API key acquisition when needed
+- Batch image compression
+- Support for multiple image formats (PNG, JPG, JPEG, SVG, GIF)
+- Progress bar for tracking compression status
+- Multi-threaded compression for better performance
+- Automatic handling of API usage limits
+- Automatic API key update through web automation
+
+## Installation
+
+```bash
+pip install tinycomp
+```
+
+## Usage
+
+### Command Line Interface
+
+#### Compressing Images
+
+```bash
+# Basic compression
+tinycomp compress --source ./images --target ./compressed
+
+# With custom API key
+tinycomp compress --source ./images --target ./compressed --api-key YOUR_API_KEY
+
+# Set number of threads
+tinycomp compress --source ./images --target ./compressed --threads 4
+
+# Enable automatic API key updates when needed
+tinycomp compress --source ./images --target ./compressed --auto-update-key
+```
+
+#### Managing API Keys
+
+```bash
+# Update API key (checks current key first)
+tinycomp update-key
+
+# Force update API key even if current one is valid
+tinycomp update-key --force
+```
+
+### Python API
+
+```python
+from tinycomp import TinyCompressor
+
+# Initialize compressor
+compressor = TinyCompressor(api_key="YOUR_API_KEY")  # API key is optional
+
+# Enable automatic API key updates
+compressor = TinyCompressor(auto_update_key=True)
+
+# Compress a single image
+compressor.compress_image("input.png", "output.png")
+
+# Compress multiple images
+compressor.compress_directory("./images", "./compressed")
+
+# Update API key programmatically
+from tinycomp.api_manager import APIKeyManager
+api_manager = APIKeyManager()
+new_key = api_manager.get_new_api_key()
+```
+
+## Configuration
+
+You can configure TinyComp using environment variables:
+
+- `TINYCOMP_API_KEY`: Your TinyPNG API key
+- `TINYCOMP_MAX_THREADS`: Maximum number of compression threads (default: 4)
+
+## Requirements
+
+- Python 3.6 or higher
+- Chrome/Chromium browser (for automatic API key updates)
+- ChromeDriver matching your Chrome version
+
+## API Key Management
+
+TinyComp includes an automatic API key management system that:
+
+1. Automatically rotates between multiple API keys
+2. Monitors remaining API usage
+3. Can automatically obtain new API keys when needed
+4. Saves API keys for future use
+
+The package offers two modes for handling API key depletion:
+
+1. Default mode: Stops compression and notifies when the API key runs out
+2. Auto-update mode: Automatically obtains new API keys when needed (use `--auto-update-key` flag)
+
+The automatic key update feature requires:
+- Chrome/Chromium browser installed
+- ChromeDriver in your system PATH or in the working directory
+- Internet connection for accessing TinyPNG website
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request. 

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

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+tinycomp/__init__.py
+tinycomp/api_manager.py
+tinycomp/cli.py
+tinycomp/compressor.py
+tinycomp/tests/__init__.py
+tinycomp/tests/test_compressor.py
+tinycomp_amadeus.egg-info/PKG-INFO
+tinycomp_amadeus.egg-info/SOURCES.txt
+tinycomp_amadeus.egg-info/dependency_links.txt
+tinycomp_amadeus.egg-info/entry_points.txt
+tinycomp_amadeus.egg-info/requires.txt
+tinycomp_amadeus.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

tinycomp_amadeus-0.1.0/tinycomp_amadeus.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tinycomp = tinycomp.cli:main

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

@@ -0,0 +1,6 @@
+tinify
+requests
+tqdm
+beautifulsoup4
+selenium
+fake-useragent

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

@@ -0,0 +1 @@
+tinycomp