Open-AutoTools 0.0.3rc2__py3-none-any.whl → 0.0.3rc4__py3-none-any.whl

autotools/autodownload/core.py

@@ -7,6 +7,8 @@ import yt_dlp
 import platform
 import subprocess
 import json
+from rich.progress import Progress
+from ..utils.loading import LoadingAnimation
 
 
 # FUNCTION TO GET DEFAULT DOWNLOAD DIRECTORY
@@ -44,17 +46,23 @@ def open_download_folder(path):
 
 # FUNCTION TO VALIDATE YOUTUBE URL FORMAT
 def validate_youtube_url(url):
-    try:
-        # USE YT-DLP TO CHECK IF THE URL IS VALID
-        with yt_dlp.YoutubeDL({'quiet': True, 'no_warnings': True}) as ydl:
-            ydl.extract_info(url, download=False)
-        return True
-    except yt_dlp.utils.DownloadError as e:
-        print(f"Invalid YouTube URL: {e}")
-        return False
-    except Exception as e:
-        print(f"Unexpected error during URL validation: {e}")
-        return False
+    """BASIC URL VALIDATION WITH PROPER FORMAT CHECK"""
+    # CHECK IF URL CONTAINS YOUTUBE DOMAIN
+    is_youtube = any(domain in url for domain in ["youtube.com", "youtu.be", "music.youtube.com"])
+    
+    # CHECK IF URL HAS PROPER VIDEO ID FORMAT
+    has_video_id = False
+    if "youtube.com/watch" in url and "v=" in url:
+        has_video_id = True
+    elif "youtu.be/" in url and len(url.split("youtu.be/")[1]) > 0:
+        has_video_id = True
+    elif any(pattern in url for pattern in ["/watch/", "/shorts/", "/live/"]):
+        path_parts = url.split("/")
+        has_video_id = len(path_parts[-1]) > 0
+    elif "attribution_link" in url and "watch?v=" in url:
+        has_video_id = True
+        
+    return is_youtube and has_video_id
 
 
 # FUNCTION TO DOWNLOAD FILES WITH REQUESTS, INCLUDING ERROR HANDLING AND PROGRESS BAR
@@ -85,40 +93,50 @@ def download_file(url):
 # FUNCTION TO GET CONSENT FILE PATH
 def get_consent_file_path():
     """GET PATH TO STORE CONSENT STATUS"""
+    # INFO: delete consent file with "rm -f ~/.autotools/consent.json" if you want to force new consent in local development
     return Path.home() / '.autotools' / 'consent.json'
 
 # FUNCTION TO LOAD CONSENT STATUS
 def load_consent_status():
     """LOAD SAVED CONSENT STATUS"""
-    consent_file = get_consent_file_path()
-    
-    # CHECK IF CONSENT FILE EXISTS
-    if consent_file.exists():
-        try:
-            with open(consent_file) as f:
-                return json.load(f).get('youtube_consent', False)
-        except:
+    try:
+        consent_file = get_consent_file_path()
+        
+        # FORCE NEW CONSENT IF FILE DOESN'T EXIST OR IS EMPTY
+        if not consent_file.exists():
             return False
-    return False
+            
+        # READ CONSENT STATUS
+        with open(consent_file) as f:
+            data = json.load(f)
+            return data.get('youtube_consent', False)
+    except Exception:
+        # IF ANY ERROR OCCURS, FORCE NEW CONSENT
+        return False
 
 # FUNCTION TO SAVE CONSENT STATUS
 def save_consent_status(status):
     """SAVE CONSENT STATUS"""
-    consent_file = get_consent_file_path()
-    consent_file.parent.mkdir(exist_ok=True)
-    
-    # SAVE CONSENT STATUS TO FILE
-    with open(consent_file, 'w') as f:
-        json.dump({'youtube_consent': status}, f)
+    try:
+        consent_file = get_consent_file_path()
+        consent_file.parent.mkdir(exist_ok=True)
+        
+        # SAVE CONSENT STATUS TO FILE
+        with open(consent_file, 'w') as f:
+            json.dump({'youtube_consent': status}, f)
+        return True
+    except Exception:
+        # IF SAVING FAILS, RETURN FALSE TO FORCE NEW CONSENT NEXT TIME
+        return False
 
 # FUNCTION TO GET USER CONSENT WITH INTERACTIVE PROMPT
 def get_user_consent():
     """GET USER CONSENT WITH INTERACTIVE PROMPT"""
     print("\n⚠️  Important Notice:")
     print("This tool will:")
-    print("1. Access your Chrome browser cookies")
-    print("2. Use them to authenticate with YouTube")
-    print("3. Download video content to your local machine")
+    print("1. Download video content from YouTube")
+    print("2. Save files to your local machine")
+    print("3. Use mobile API for better compatibility")
     
     # GET USER CONSENT WITH INTERACTIVE PROMPT
     while True:
@@ -132,40 +150,163 @@ def get_user_consent():
         print("Please answer 'yes' or 'no'")
 
 
+# FUNCTION TO CHECK IF VIDEO EXISTS AND GET USER CONSENT FOR REPLACEMENT
+def check_existing_video(info, format='mp4'):
+    """CHECK IF VIDEO EXISTS AND ASK FOR REPLACEMENT"""
+    download_dir = get_default_download_dir()
+    title = info.get('title', '').replace('/', '_')  # SANITIZE TITLE
+    filename = f"{title}.{format}"
+    filepath = download_dir / filename
+
+    # CHECK IF FILE EXISTS AND ASK FOR REPLACEMENT
+    if filepath.exists():
+        print(f"\n⚠️  File already exists: {filename}")
+        while True:
+            response = input("Do you want to replace it? (yes/no): ").lower()
+            if response in ['yes', 'y']:
+                return True
+            elif response in ['no', 'n']:
+                # OPEN DOWNLOADS FOLDER TO SHOW EXISTING FILE
+                open_download_folder(download_dir)
+                return False
+            print("Please answer 'yes' or 'no'")
+    return True
+
+
 # FUNCTION TO DOWNLOAD YOUTUBE VIDEOS WITH YT-DLP AND SPECIFIED FORMAT AND QUALITY
 def download_youtube_video(url, format='mp4', quality='best'):
     """DOWNLOAD VIDEO WITH CONSENT CHECK"""
-    # CHECK IF CONSENT IS REQUIRED
-    if not load_consent_status():
-        if not get_user_consent():
-            print("\n❌ Download cancelled by user")
-            return False
+    # VALIDATE URL FIRST
+    if not validate_youtube_url(url):
+        print("\n❌ Invalid YouTube URL")
+        return False
+
+    # CHECK FOR SAVED CONSENT FIRST AND GET NEW CONSENT IF NEEDED
+    if not load_consent_status() and not get_user_consent():
+        print("\n❌ Download cancelled by user")
+        return False
+    
+    # FIRST CHECK VIDEO INFO AND EXISTENCE
+    try:
+        with yt_dlp.YoutubeDL({
+            'quiet': True,
+            'no_warnings': True,
+            'extractor_args': {'youtube': {
+                'player_client': ['web', 'android'],
+                'formats': ['missing_pot']  # ALLOW FORMATS WITHOUT PO TOKEN
+            }}
+        }) as ydl:
+            info = ydl.extract_info(url, download=False)
+            formats = info.get('formats', [])
+            if not formats:
+                print("\n❌ No formats available for this video")
+                return False
+            
+            # FIND BEST AVAILABLE QUALITY
+            best_height = 0
+            for f in formats:
+                height = f.get('height')
+                if height is not None and height > best_height:
+                    best_height = height
+            
+            # IF NO VALID HEIGHT FOUND, DEFAULT TO 1080P
+            if best_height == 0:
+                best_height = 1080
+            
+            # IF QUALITY IS 'BEST', USE THE BEST AVAILABLE
+            if quality == 'best':
+                height = best_height
+                # ASK FOR CONFIRMATION IF 4K OR HIGHER (ONLY FOR MP4)
+                if format == 'mp4' and height >= 2160:
+                    print(f"\n⚠️  This video is available in {height}p quality!")
+                    while True:
+                        response = input(f"Do you want to download in {height}p quality? (yes/no): ").lower()
+                        if response in ['no', 'n']:
+                            height = 1080
+                            print("\nDowngrading to 1080p quality.")
+                            break
+                        elif response in ['yes', 'y']:
+                            break
+                        print("Please answer 'yes' or 'no'")
+            else:
+                # EXTRACT HEIGHT FROM QUALITY STRING
+                try:
+                    height = int(quality.lower().replace('p', ''))
+                except ValueError:
+                    height = 1080  # DEFAULT TO 1080P IF INVALID FORMAT
+            
+            # CHECK IF FILE EXISTS AND GET REPLACEMENT CONSENT
+            force_download = check_existing_video(info, format)
+            if not force_download:
+                print("\n❌ Download cancelled - file already exists")
+                return False
+                
+            # OPEN DOWNLOADS FOLDER IF STARTING NEW DOWNLOAD OR REPLACING
+            download_dir = get_default_download_dir()
+            open_download_folder(download_dir)
+
+    except Exception as e:
+        print(f"\n❌ Error checking video: {str(e)}")
+        return False
+    
+    loading = LoadingAnimation()
+    
+    # START LOADING FOR DOWNLOAD PROCESS
+    with loading:
+        loading._spinner.start()
+        print("\n🔍 Starting download...")
     
     print(f"\n🎥 Downloading video from: {url}")
-    print(f"📋 Format: {format}, Quality: {quality}\n")
+    if format == 'mp3':
+        print(f"📋 Format: {format}\n")
+    else:
+        print(f"📋 Format: {format}, Quality: {height}p\n")
 
+    # YT-DLP PERMISSION OPTIONS FOR DOWNLOADING YOUTUBE VIDEOS
     ydl_opts = {
-        'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best' if format == 'mp4' else 'bestaudio[ext=mp3]/best',
-        'quiet': False,
-        'no_warnings': False,
-        'cookiesfrombrowser': ('chrome',),
-        'extractor_args': {'youtube': {'player_client': ['android']}},
+        'format': f'bestvideo[height={height}][ext=mp4]+bestaudio[ext=m4a]/bestvideo[height<={height}][ext=mp4]+bestaudio[ext=m4a]/best[height<={height}][ext=mp4]/best[ext=mp4]/best' if format == 'mp4' else 'bestaudio/best',
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }] if format == 'mp3' else [],
+        'quiet': True,
+        'no_warnings': True,
+        'progress': True,
+        'progress_hooks': [lambda d: update_progress(d)],
+        'extractor_args': {
+            'youtube': {
+                'player_client': ['web', 'android'],  # USE WEB CLIENT FIRST
+                'formats': ['missing_pot'],  # ALLOW FORMATS WITHOUT PO TOKEN
+                'player_skip': ['configs', 'webpage']  # SKIP UNNECESSARY CONFIGS
+            }
+        },
         'http_headers': {
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
             'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
             'Accept-Language': 'en-us,en;q=0.5',
             'Sec-Fetch-Mode': 'navigate'
         },
-        'progress_hooks': [lambda d: print(f"⏳ {d['_percent_str']} of {d.get('_total_bytes_str', 'Unknown size')}") if d['status'] == 'downloading' else None]
+        'outtmpl': str(download_dir / '%(title)s.%(ext)s'),  # SET OUTPUT TEMPLATE
+        'overwrites': True,  # FORCE OVERWRITE IF USER CONSENTED
+        'no_check_certificates': True,  # SKIP CERTIFICATE VALIDATION
+        'cookiesfrombrowser': ('chrome',),  # USE CHROME COOKIES IF AVAILABLE
     }
 
     try:
+        # THEN DOWNLOAD
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
             ydl.download([url])
         print("\n✅ Download completed successfully!")
         return True
     except Exception as e:
-        print(f"\n❌ ERROR: {str(e)}")
+        error_msg = str(e)
+        if "Requested format is not available" in error_msg:
+            print("\n❌ Format not available. Available formats are:")
+            for f in formats:
+                print(f"- {f.get('format_id', 'N/A')}: {f.get('ext', 'N/A')} ({f.get('format_note', 'N/A')})")
+        else:
+            print(f"\n❌ ERROR: {error_msg}")
         return False
 
 
@@ -187,23 +328,22 @@ pbar = None  # GLOBAL VARIABLE TO STORE PROGRESS BAR
 
 
 # FUNCTION TO UPDATE PROGRESS BAR
-def tqdm_progress_hook(d):
+def update_progress(d):
     global pbar
-
     if d['status'] == 'downloading':
         total = d.get('total_bytes', 0)
         downloaded = d.get('downloaded_bytes', 0)
 
         if pbar is None:
-            pbar = tqdm(total=total, unit='B', unit_scale=True, desc="YouTube Download", leave=True)
+            pbar = tqdm(total=total, unit='B', unit_scale=True, desc="⏳ Downloading", leave=True, ncols=80, bar_format='{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt} [{rate_fmt}]')
 
-        pbar.n = downloaded
-        pbar.refresh()
+        if total > 0:
+            pbar.n = downloaded
+            pbar.total = total
+            pbar.refresh()
 
     elif d['status'] == 'finished' and pbar:
-        pbar.n = pbar.total
         pbar.close()
-        print("Download completed")
         pbar = None
 
 

autotools/autoip/commands.py

@@ -0,0 +1,29 @@
+import click
+from .core import run
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+@click.command()
+@click.option('--test', '-t', is_flag=True, help='Run connectivity tests')
+@click.option('--speed', '-s', is_flag=True, help='Run internet speed test')
+@click.option('--monitor', '-m', is_flag=True, help='Monitor network traffic')
+@click.option('--interval', '-i', default=1, help='Monitoring interval in seconds')
+@click.option('--ports', '-p', is_flag=True, help='Check common ports status')
+@click.option('--dns', '-d', is_flag=True, help='Show DNS servers')
+@click.option('--location', '-l', is_flag=True, help='Show IP location info')
+@click.option('--no-ip', '-n', is_flag=True, help='Hide IP addresses')
+def autoip(test, speed, monitor, interval, ports, dns, location, no_ip):
+    """Display network information and diagnostics.
+    
+    Shows local and public IP addresses, runs network diagnostics,
+    performs speed tests, monitors traffic with custom intervals,
+    checks ports, displays DNS information and provides geolocation data."""
+    with LoadingAnimation():
+        output = run(test=test, speed=speed, monitor=monitor, interval=interval,
+                    ports=ports, dns=dns, location=location, no_ip=no_ip)
+    click.echo(output)
+    
+    # UPDATE CHECK AT THE END
+    update_msg = check_for_updates()
+    if update_msg:
+        click.echo(update_msg) 

autotools/autolower/commands.py

@@ -0,0 +1,17 @@
+import click
+from .core import autolower_transform
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+@click.command()
+@click.argument('text', nargs=-1)
+def autolower(text):
+    """Convert text to lowercase."""
+    with LoadingAnimation():
+        result = autolower_transform(" ".join(text))
+    click.echo(result)
+    
+    # UPDATE CHECK AT THE END
+    update_msg = check_for_updates()
+    if update_msg:
+        click.echo(update_msg) 

autotools/autopassword/commands.py

@@ -0,0 +1,76 @@
+import click
+import base64
+from .core import generate_password, generate_encryption_key, analyze_password_strength
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+@click.command()
+@click.option('--length', '-l', default=12, help='Password length (default: 12)')
+@click.option('--no-uppercase', '-u', is_flag=True, help='Exclude uppercase letters')
+@click.option('--no-numbers', '-n', is_flag=True, help='Exclude numbers')
+@click.option('--no-special', '-s', is_flag=True, help='Exclude special characters')
+@click.option('--min-special', '-m', default=1, help='Minimum number of special characters')
+@click.option('--min-numbers', '-d', default=1, help='Minimum number of numbers')
+@click.option('--analyze', '-a', is_flag=True, help='Analyze password strength')
+@click.option('--gen-key', '-g', is_flag=True, help='Generate encryption key')
+@click.option('--password-key', '-p', help='Generate key from password')
+def autopassword(length, no_uppercase, no_numbers, no_special, 
+                 min_special, min_numbers, analyze, gen_key, password_key):
+    """Generate secure passwords and encryption keys."""
+    
+    def show_analysis(text, prefix=""):
+        """Helper function to show password/key analysis"""
+        if analyze:
+            with LoadingAnimation():
+                analysis = analyze_password_strength(text)
+            click.echo(f"\n{prefix}Strength Analysis:")
+            click.echo(f"Strength: {analysis['strength']}")
+            click.echo(f"Score: {analysis['score']}/5")
+            if analysis['suggestions']:
+                click.echo("\nSuggestions for improvement:")
+                for suggestion in analysis['suggestions']:
+                    click.echo(f"- {suggestion}")
+    
+    # GENERATE KEY
+    if gen_key:
+        with LoadingAnimation():
+            key = generate_encryption_key()
+        key_str = key.decode()
+        click.echo(f"Encryption Key: {key_str}")
+        if analyze:
+            show_analysis(key_str, "Key ")
+        return
+    
+    # GENERATE KEY FROM PASSWORD
+    if password_key:
+        with LoadingAnimation():
+            key, salt = generate_encryption_key(password_key)
+        key_str = key.decode()
+        click.echo(f"Derived Key: {key_str}")
+        click.echo(f"Salt: {base64.b64encode(salt).decode()}")
+        if analyze:
+            click.echo("\nAnalyzing source password:")
+            show_analysis(password_key, "Password ")
+            click.echo("\nAnalyzing generated key:")
+            show_analysis(key_str, "Key ")
+        return
+    
+    # GENERATE PASSWORD
+    with LoadingAnimation():
+        password = generate_password(
+            length=length,
+            use_uppercase=not no_uppercase,
+            use_numbers=not no_numbers,
+            use_special=not no_special,
+            min_special=min_special,
+            min_numbers=min_numbers,
+        )
+    
+    # SHOW PASSWORD
+    click.echo(f"Generated Password: {password}")
+    show_analysis(password, "Password ")
+    
+    # UPDATE CHECK AT THE END
+    update_msg = check_for_updates()
+    if update_msg:
+        click.echo(update_msg) 

autotools/autopassword/core.py

@@ -21,6 +21,7 @@ def generate_password(length=12, use_uppercase=True, use_numbers=True, use_speci
     
     # ENSURE MINIMUM REQUIREMENTS
     password = []
+    password.append(secrets.choice(lowercase))
     if use_uppercase:
         password.append(secrets.choice(uppercase))
     if use_numbers:

autotools/autospell/commands.py

@@ -0,0 +1,123 @@
+import click
+import json as json_module
+from .core import SpellChecker
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+@click.command()
+@click.argument('texts', nargs=-1)
+@click.option('--lang', '-l', default='auto', help='Language code (auto for detection)')
+@click.option('--fix', '-f', is_flag=True, help='Auto-fix text and copy to clipboard')
+@click.option('--copy', '-c', is_flag=True, help='Copy result to clipboard')
+@click.option('--list-languages', is_flag=True, help='List supported languages')
+@click.option('--json', '-j', is_flag=True, help='Output results as JSON')
+@click.option('--ignore', '-i', multiple=True, 
+    type=click.Choice(['spelling', 'grammar', 'style', 'punctuation']),
+    help='Error types to ignore')
+@click.option('--interactive', '-n', is_flag=True, 
+    help='Interactive mode - confirm each correction')
+@click.option('--output', '-o', type=click.Path(), 
+    help='Save corrections to file')
+def autospell(texts: tuple, lang: str, fix: bool, copy: bool, list_languages: bool, 
+              json: bool, ignore: tuple, interactive: bool, output: str):
+    """Check and fix text for spelling, grammar, style, and punctuation errors.
+    
+    Provides comprehensive text analysis with support for multiple languages,
+    interactive corrections, and various output formats (text/JSON).
+    Can ignore specific error types: spelling, grammar, style, or punctuation."""
+    checker = SpellChecker()
+    
+    # LIST ALL SUPPORTED LANGUAGES
+    if list_languages:
+        with LoadingAnimation():
+            languages = checker.get_supported_languages()
+            if json:
+                result = {'languages': languages}
+                click.echo(json_module.dumps(result, indent=2))
+            else:
+                click.echo("\nSupported Languages:")
+                for lang in languages:
+                    click.echo(f"{lang['code']:<8} {lang['name']}")
+        return
+        
+    # --CHECK AND FIX SPELLING/GRAMMAR IN TEXT
+    for text in texts:
+        if not text:
+            click.echo("Error: Please provide text to check")
+            continue
+        
+        # --FIX OPTION: SPELLING/GRAMMAR IN TEXT
+        if fix:
+            # CORRECT TEXT WITH SPELL CHECKER
+            with LoadingAnimation():
+                corrected = checker.fix_text(text, lang, copy_to_clipboard=True, 
+                                           ignore=ignore, interactive=interactive)
+                result = {'corrected_text': corrected}
+            
+            # OUTPUT RESULTS AS JSON
+            if json:
+                click.echo(json_module.dumps(result, indent=2))
+            else:
+                # LANGUAGE INFORMATION
+                with LoadingAnimation():
+                    check_result = checker.check_text(text, lang)
+                lang_info = check_result['language']
+                click.echo(f"\nLanguage detected: {lang_info['name']} ({lang_info['code']})")
+                click.echo(f"Confidence: {lang_info['confidence']:.2%}")
+                click.echo("\nCorrected text (copied to clipboard):")
+                click.echo(corrected)
+                
+            # SAVE CORRECTIONS TO FILE
+            if output:
+                with open(output, 'w', encoding='utf-8') as f:
+                    if json:
+                        json_module.dump(result, f, indent=2)
+                    else:
+                        f.write(corrected)
+        else:
+            # CHECK SPELLING/GRAMMAR IN TEXT
+            with LoadingAnimation():
+                check_result = checker.check_text(text, lang)
+            
+            # OUTPUT RESULTS AS JSON
+            if json:
+                click.echo(json_module.dumps(check_result, indent=2))
+            else:
+                lang_info = check_result['language']
+                click.echo(f"\nLanguage detected: {lang_info['name']} ({lang_info['code']})")
+                click.echo(f"Confidence: {lang_info['confidence']:.2%}")
+                click.echo(f"Total errors found: {check_result['statistics']['total_errors']}")
+                
+                # CORRECTIONS SUGGESTED
+                if check_result['corrections']:
+                    click.echo("\nCorrections suggested:")
+                    for i, corr in enumerate(check_result['corrections'], 1):
+                        click.echo(f"\n{i}. [{corr['severity'].upper()}] {corr['message']}")
+                        click.echo(f"   Context: {corr['context']}")
+                        if corr['replacements']:
+                            click.echo(f"   Suggestions: {', '.join(corr['replacements'][:3])}")
+            
+            # SAVE CHECK RESULT TO FILE
+            if output:
+                with open(output, 'w', encoding='utf-8') as f:
+                    if json:
+                        json_module.dump(check_result, f, indent=2)
+                    else:
+                        # WRITE A HUMAN-READABLE REPORT
+                        f.write(f"Language: {lang_info['name']} ({lang_info['code']})\n")
+                        f.write(f"Confidence: {lang_info['confidence']:.2%}\n")
+                        f.write(f"Total errors: {check_result['statistics']['total_errors']}\n\n")
+                        
+                        # CORRECTIONS SUGGESTED
+                        if check_result['corrections']:
+                            f.write("Corrections suggested:\n")
+                            for i, corr in enumerate(check_result['corrections'], 1):
+                                f.write(f"\n{i}. [{corr['severity'].upper()}] {corr['message']}\n")
+                                f.write(f"   Context: {corr['context']}\n")
+                                if corr['replacements']:
+                                    f.write(f"   Suggestions: {', '.join(corr['replacements'][:3])}\n")
+    
+    # UPDATE CHECK AT THE END
+    update_msg = check_for_updates()
+    if update_msg:
+        click.echo(update_msg) 

autotools/autotranslate/commands.py

@@ -0,0 +1,42 @@
+import click
+from .core import translate_text, get_supported_languages
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+@click.command()
+@click.argument('text', required=False)
+@click.option('--to', default='en', help='Target language (default: en)')
+@click.option('--from', 'from_lang', help='Source language (default: auto-detect)')
+@click.option('--list-languages', is_flag=True, help='List all supported languages')
+@click.option('--copy', is_flag=True, help='Copy translation to clipboard')
+@click.option('--detect', is_flag=True, help='Show detected source language')
+@click.option('--output', '-o', type=click.Path(), help='Save translation to file')
+def autotranslate(text: str, to: str, from_lang: str, list_languages: bool, 
+                  copy: bool, detect: bool, output: str):
+    """Translate text to specified language.
+    
+    Supports automatic language detection, multiple target languages,
+    clipboard operations and file output. Use --list-languages to see
+    all supported language codes."""
+    # LIST ALL SUPPORTED LANGUAGES
+    if list_languages:
+        with LoadingAnimation():
+            click.echo("\nSupported Languages:")
+            for code, name in get_supported_languages().items():
+                click.echo(f"{code:<8} {name}")
+        return
+    
+    # CHECK IF TEXT IS PROVIDED
+    if not text:
+        click.echo("Error: Please provide text to translate")
+        return
+        
+    with LoadingAnimation():
+        result = translate_text(text, to_lang=to, from_lang=from_lang, 
+                              copy=copy, detect_lang=detect, output=output)
+    click.echo(result)
+    
+    # UPDATE CHECK AT THE END
+    update_msg = check_for_updates()
+    if update_msg:
+        click.echo(update_msg)