Open-AutoTools 0.0.3rc5__py3-none-any.whl → 0.0.4rc1__py3-none-any.whl

autotools/autolower/tests/test_autolower_integration.py

@@ -1,46 +0,0 @@
-import pytest
-from click.testing import CliRunner
-from autotools.cli import autolower
-
-# INTEGRATION TESTS
-
-# TEST FOR BASIC CLI FUNCTIONALITY
-def test_autolower_cli_basic():
-    """TEST BASIC CLI FUNCTIONALITY"""
-    runner = CliRunner()
-    result = runner.invoke(autolower, ["HELLO WORLD"])
-    assert result.exit_code == 0
-    assert "hello world" in result.output
-
-# TEST FOR EMPTY INPUT
-def test_autolower_cli_empty():
-    """TEST CLI WITH EMPTY INPUT"""
-    runner = CliRunner()
-    result = runner.invoke(autolower, [""])
-    assert result.exit_code == 0
-    assert "" in result.output
-
-# TEST FOR SPECIAL CHARACTERS
-def test_autolower_cli_special_chars():
-    """TEST CLI WITH SPECIAL CHARACTERS"""
-    runner = CliRunner()
-    result = runner.invoke(autolower, ["HELLO@WORLD.COM"])
-    assert result.exit_code == 0
-    assert "hello@world.com" in result.output
-
-# TEST FOR UNICODE CHARACTERS
-def test_autolower_cli_unicode():
-    """TEST CLI WITH UNICODE CHARACTERS"""
-    runner = CliRunner()
-    result = runner.invoke(autolower, ["HÉLLO WÖRLD"])
-    assert result.exit_code == 0
-    assert "héllo wörld" in result.output
-
-# TEST FOR MULTIPLE ARGUMENTS
-def test_autolower_cli_multiple_args():
-    """TEST CLI WITH MULTIPLE ARGUMENTS"""
-    runner = CliRunner()
-    result = runner.invoke(autolower, ["HELLO", "WORLD"])
-    assert result.exit_code == 0
-    # SHOULD ONLY PROCESS FIRST ARGUMENT
-    assert "hello" in result.output 

autotools/autospell/__init__.py

@@ -1,3 +0,0 @@
-from .core import SpellChecker
-
-__all__ = ['SpellChecker'] 

autotools/autospell/commands.py

@@ -1,123 +0,0 @@
-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/autospell/core.py

@@ -1,222 +0,0 @@
-import language_tool_python
-import spacy
-from typing import List, Dict, Optional
-import pyperclip
-import requests
-from langdetect import detect, detect_langs
-
-class SpellChecker:
-    def __init__(self):
-        # INITIALIZE LANGUAGE TOOL
-        self.tool = language_tool_python.LanguageTool('auto')
-        
-        # CACHE FOR SPACY MODELS
-        self.nlp_models = {}
-
-    # LOAD SPACY MODEL FOR GIVEN LANGUAGE
-    def _load_spacy_model(self, lang_code: str) -> Optional[spacy.language.Language]:
-        """LOAD SPACY MODEL FOR GIVEN LANGUAGE"""
-        try:
-            if lang_code not in self.nlp_models:
-                # GET ALL INSTALLED MODELS FOR THIS LANGUAGE
-                available_models = [
-                    model for model in spacy.util.get_installed_models()
-                    if model.startswith(lang_code)
-                ]
-                
-                if not available_models:
-                    # TRY TO CREATE A BLANK MODEL IF NO TRAINED MODELS
-                    self.nlp_models[lang_code] = spacy.blank(lang_code)
-                else:
-                    # USE MOST COMPREHENSIVE MODEL (USUALLY ENDS WITH 'lg' OR 'trf')
-                    preferred_model = None
-                    for suffix in ['trf', 'lg', 'md', 'sm']:
-                        for model in available_models:
-                            if model.endswith(suffix):
-                                preferred_model = model
-                                break
-                        if preferred_model:
-                            break
-                    
-                    # IF NO PREFERRED MODEL, USE FIRST AVAILABLE MODEL
-                    if not preferred_model:
-                        preferred_model = available_models[0]
-                    
-                    self.nlp_models[lang_code] = spacy.load(preferred_model) # LOAD PREFERRED MODEL
-                    
-            return self.nlp_models.get(lang_code) # RETURN LOADED MODEL
-        except:
-            return None
-
-    # CHECK TEXT FOR SPELLING AND GRAMMAR ERRORS
-    def check_text(self, text: str, lang: str = 'auto') -> Dict:
-        """CHECK TEXT FOR SPELLING AND GRAMMAR ERRORS
-        
-        ARGS:
-            text: Text to check
-            lang: Language code (auto for automatic detection)
-            
-        RETURNS:
-            Dict with corrections and statistics
-        """
-        # DETECT LANGUAGE CONFIDENCE
-        if lang == 'auto':
-            try:
-                lang_scores = detect_langs(text)
-                lang = lang_scores[0].lang
-                confidence = lang_scores[0].prob
-            except:
-                confidence = 0
-        else:
-            confidence = 1.0
-            
-        # SET LANGUAGE
-        if lang != 'auto':
-            self.tool.language = lang
-            
-        # GET MATCHES
-        matches = self.tool.check(text)
-        
-        # PREPARE CORRECTIONS WITH SEVERITY LEVELS
-        corrections = []
-        for match in matches:
-            severity = self._get_error_severity(match)
-            correction = {
-                'message': match.message,
-                'context': match.context,
-                'offset': match.offset,
-                'length': match.errorLength,
-                'category': match.category,
-                'rule_id': match.ruleId,
-                'replacements': match.replacements,
-                'severity': severity
-            }
-            corrections.append(correction)
-            
-        # GET DETAILED STATISTICS
-        stats = self._get_detailed_stats(corrections)
-        
-        return {
-            'corrections': corrections,
-            'statistics': stats,
-            'language': {
-                'code': lang,
-                'name': lang.upper(),
-                'confidence': confidence
-            }
-        }
-
-    # DETERMINE ERROR SEVERITY LEVEL
-    def _get_error_severity(self, match) -> str:
-        """DETERMINE ERROR SEVERITY LEVEL"""
-        if 'TYPO' in match.ruleId or 'SPELLING' in match.ruleId:
-            return 'high'
-        elif 'GRAMMAR' in match.ruleId:
-            return 'medium'
-        else:
-            return 'low'
-
-    # GET DETAILED ERROR STATISTICS
-    def _get_detailed_stats(self, corrections: List[Dict]) -> Dict:
-        """GET DETAILED ERROR STATISTICS"""
-        stats = {
-            'total_errors': len(corrections),
-            'categories': {},
-            'severity': {
-                'high': 0,
-                'medium': 0,
-                'low': 0
-            }
-        }
-        
-        # COUNT ERRORS BY CATEGORY AND SEVERITY
-        for corr in corrections:
-            # COUNT BY CATEGORY
-            cat = corr['category']
-            stats['categories'][cat] = stats['categories'].get(cat, 0) + 1
-            
-            # COUNT BY SEVERITY
-            stats['severity'][corr['severity']] += 1
-            
-        return stats
-
-    # FIX TEXT AUTOMATICALLY
-    def fix_text(self, text: str, lang: str = 'auto', copy_to_clipboard: bool = False,
-                 ignore: list = None, interactive: bool = False) -> str:
-        """FIX TEXT AUTOMATICALLY"""
-        if lang != 'auto':
-            self.tool.language = lang
-        
-        if interactive:
-            # GET ALL CORRECTIONS
-            matches = self.tool.check(text)
-            corrected = text
-            
-            # ASK FOR EACH CORRECTION
-            for match in matches:
-                if ignore and any(t in match.ruleId.lower() for t in ignore):
-                    continue
-                    
-                print(f"\nError: {match.message}")
-                print(f"Context: {match.context}")
-                if match.replacements:
-                    print("Suggestions:")
-                    for i, sugg in enumerate(match.replacements[:3], 1):
-                        print(f"{i}. {sugg}")
-                        
-                    # ASK FOR EACH CORRECTION
-                    choice = input("\nApply correction? (1-3/n): ").lower()
-                    if choice.isdigit() and 1 <= int(choice) <= len(match.replacements[:3]):
-                        replacement = match.replacements[int(choice)-1]
-                        corrected = corrected[:match.offset] + replacement + corrected[match.offset + match.errorLength:]
-        else:
-            # NORMAL AUTO-FIX
-            corrected = self.tool.correct(text)
-        
-        # COPY TO CLIPBOARD IF REQUESTED
-        if copy_to_clipboard:
-            pyperclip.copy(corrected)
-            
-        return corrected
-
-    # GET LIST OF SUPPORTED LANGUAGES
-    def get_supported_languages(self) -> List[Dict]:
-        """GET LIST OF SUPPORTED LANGUAGES"""
-        try:
-            # GET LANGUAGES FROM LANGUAGE TOOL PUBLIC API
-            response = requests.get('https://api.languagetool.org/v2/languages')
-            languages = response.json()
-            
-            # FORMAT LANGUAGES INTO REQUIRED STRUCTURE
-            formatted_langs = []
-            seen_codes = set()
-            
-            # FORMAT LANGUAGES INTO REQUIRED STRUCTURE
-            for lang in languages:
-                code = lang['longCode'].split('-')[0]
-                
-                # SKIP DUPLICATES
-                if code in seen_codes:
-                    continue
-                    
-                # TEST IF LANGUAGE IS ACTUALLY SUPPORTED BY LOCAL TOOL
-                try:
-                    self.tool.language = code
-                    formatted_langs.append({
-                        'code': code,
-                        'name': lang['name'],
-                        'variants': [v['name'] for v in lang.get('variants', [])]
-                    })
-                    seen_codes.add(code)
-                except:
-                    continue
-            
-            return formatted_langs
-            
-        except Exception as e:
-            # IF API FAILS, GET LANGUAGES FROM LOCAL TOOL
-            try:
-                current_lang = self.tool.language
-                return [{'code': current_lang, 'name': current_lang.upper(), 'variants': []}]
-            except:
-                return []

autotools/autotranslate/__init__.py

@@ -1,3 +0,0 @@
-from .core import translate_text
-
-__all__ = ['translate_text'] 

autotools/autotranslate/commands.py

@@ -1,42 +0,0 @@
-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) 

autotools/autotranslate/core.py

@@ -1,52 +0,0 @@
-from deep_translator import GoogleTranslator
-from langdetect import detect
-import pyperclip
-
-def get_supported_languages() -> dict:
-    """GET ALL SUPPORTED LANGUAGES FROM GOOGLE TRANSLATE"""
-    # GET LANGUAGES CODES
-    langs = GoogleTranslator().get_supported_languages(as_dict=True)
-    # SORT BY LANGUAGE NAME
-    return dict(sorted(langs.items(), key=lambda x: x[1].lower()))
-
-def translate_text(text: str, to_lang: str = 'en', from_lang: str = None, 
-                  copy: bool = False, detect_lang: bool = False, output: str = None) -> str:
-    """TRANSLATE TEXT TO SPECIFIED LANGUAGE
-    
-    ARGS:
-        text (str): TEXT TO TRANSLATE
-        to_lang (str): TARGET LANGUAGE CODE (DEFAULT: EN)
-        from_lang (str): SOURCE LANGUAGE CODE (DEFAULT: AUTO-DETECT)
-        copy (bool): COPY RESULT TO CLIPBOARD
-        detect_lang (bool): SHOW DETECTED SOURCE LANGUAGE
-        output (str): PATH TO SAVE TRANSLATION TO FILE
-        
-    RETURNS:
-        str: TRANSLATED TEXT
-    """
-    # AUTO-DETECT SOURCE LANGUAGE IF NOT SPECIFIED
-    source_lang = from_lang or detect(text)
-    
-    # TRANSLATE
-    translator = GoogleTranslator(source=source_lang, target=to_lang)
-    result = translator.translate(text)
-    
-    # COPY TO CLIPBOARD IF REQUESTED
-    if copy:
-        pyperclip.copy(result)
-    
-    # SAVE TO FILE IF OUTPUT PATH PROVIDED
-    if output:
-        try:
-            with open(output, 'w', encoding='utf-8') as f:
-                if detect_lang:
-                    f.write(f"[Detected: {source_lang}] {result}")
-                else:
-                    f.write(result)
-        except Exception as e:
-            print(f"\nError saving to file: {str(e)}")
-    
-    # RETURN RESULT WITH DETECTED LANGUAGE IF REQUESTED
-    if detect_lang:
-        return f"[Detected: {source_lang}] {result}"
-    return result 

autotools/test/__init__.py

@@ -1,3 +0,0 @@
-from .commands import test
-
-__all__ = ['test'] 

autotools/test/commands.py

@@ -1,118 +0,0 @@
-import click
-import subprocess
-import sys
-import os
-import re
-from ..utils.updates import check_for_updates
-
-@click.command()
-@click.option('--unit', '-u', is_flag=True, help='Run only unit tests')
-@click.option('--integration', '-i', is_flag=True, help='Run only integration tests')
-@click.option('--no-cov', is_flag=True, help='Disable coverage report')
-@click.option('--html', is_flag=True, help='Generate HTML coverage report')
-@click.option('--module', '-m', help='Test specific module (e.g., autocaps, autolower)')
-def test(unit, integration, no_cov, html, module):
-    """Run test suite with various options."""
-    # CHECK IF PYTEST IS INSTALLED
-    try:
-        import pytest
-        import pytest_cov
-    except ImportError:
-        click.echo(click.style("\n❌ pytest and/or pytest-cov not found. Installing...", fg='yellow', bold=True))
-        try:
-            subprocess.run(['pip', 'install', 'pytest', 'pytest-cov'], check=True)
-            click.echo(click.style("✅ Successfully installed pytest and pytest-cov", fg='green', bold=True))
-        except subprocess.CalledProcessError as e:
-            click.echo(click.style(f"\n❌ Failed to install dependencies: {str(e)}", fg='red', bold=True))
-            sys.exit(1)
-    
-    # BASE COMMAND WITH ENHANCED VERBOSITY
-    cmd = [
-        sys.executable,             # USE SYSTEM PYTHON EXECUTABLE
-        '-m', 'pytest',            # RUN PYTEST AS MODULE
-        '-vv',                     # VERY VERBOSE OUTPUT
-        '--capture=no',            # SHOW PRINT STATEMENTS
-        '--showlocals',            # SHOW LOCAL VARIABLES IN TRACEBACKS
-        '--log-cli-level=DEBUG',   # SHOW DEBUG LOGS
-        '-s',                      # DISABLE CAPTURE
-    ]
-    
-    # COVERAGE OPTIONS
-    if not no_cov:
-        if html:
-            cmd.extend(['--cov-report=html', '--cov=autotools'])
-        else:
-            cmd.extend(['--cov-report=term-missing', '--cov=autotools'])
-    
-    # TEST SELECTION
-    if module:
-        test_path = f'autotools/{module}/tests'
-        if unit and not integration:
-            test_path = f'{test_path}/unit'
-        elif integration and not unit:
-            test_path = f'{test_path}/integration'
-        cmd.append(test_path)
-    else:
-        cmd.append('autotools')
-    
-    # SHOW COMMAND BEING RUN
-    click.echo(click.style("\nRunning tests with command:", fg='blue', bold=True))
-    click.echo(" ".join(cmd))
-    click.echo()
-    
-    # RUN TESTS
-    try:
-        env = dict(os.environ)
-        env['PYTHONPATH'] = os.getcwd()
-        env['FORCE_COLOR'] = '1'  # FORCE COLORS IN OUTPUT
-        
-        process = subprocess.Popen(
-            cmd,
-            env=env,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            universal_newlines=True,
-            bufsize=1
-        )
-        
-        # READ AND PROCESS OUTPUT IN REAL-TIME
-        while True:
-            line = process.stdout.readline()
-            if not line and process.poll() is not None:
-                break
-            if line:
-                # CLEAN THE LINE
-                line = line.strip()
-                if line:  # ONLY PROCESS NON-EMPTY LINES
-                    if '::' in line and 'autotools/' in line:
-                        # REMOVE PARENT DIRECTORY PATHS
-                        line = line.split('autotools/')[-1].replace('/tests/', '/')
-                        # REMOVE MODULE PARENT DIRECTORY
-                        parts = line.split('/')
-                        if len(parts) > 1:
-                            line = parts[-1]
-                    # REMOVE MULTIPLE SPACES AND DOTS
-                    line = re.sub(r'\s+', ' ', line)
-                    line = re.sub(r'\.+', '.', line)
-                    # REMOVE EMPTY LINES WITH JUST DOTS OR SPACES
-                    if line.strip('. '):
-                        sys.stdout.write(line + '\n')
-                        sys.stdout.flush()
-        
-        process.wait()
-        if process.returncode == 0:
-            click.echo(click.style("\n✅ All tests passed!", fg='green', bold=True))
-        else:
-            click.echo(click.style("\n❌ Some tests failed!", fg='red', bold=True))
-            sys.exit(1)
-    except subprocess.CalledProcessError as e:
-        click.echo(click.style(f"\n❌ Tests failed with return code {e.returncode}", fg='red', bold=True))
-        sys.exit(1)
-    except Exception as e:
-        click.echo(click.style(f"\n❌ Error running tests: {str(e)}", fg='red', bold=True))
-        sys.exit(1)
-    
-    # UPDATE CHECK AT THE END
-    update_msg = check_for_updates()
-    if update_msg:
-        click.echo(update_msg)