Open-AutoTools 0.0.2.post1__py3-none-any.whl → 0.0.3rc1__py3-none-any.whl

autotools/autoip/tests/test_autoip_core.py

@@ -0,0 +1,72 @@
+import pytest
+from unittest.mock import patch, Mock
+from autotools.autoip.core import get_public_ip, get_local_ip, get_ip_info
+
+# MOCK DATA
+MOCK_IP_INFO = {
+    'ip': '8.8.8.8',
+    'city': 'Mountain View',
+    'region': 'California',
+    'country': 'US',
+    'loc': '37.4056,-122.0775',
+    'org': 'Google LLC',
+    'timezone': 'America/Los_Angeles'
+}
+
+# UNIT TESTS
+
+# TEST FOR PUBLIC IP RETRIEVAL
+@patch('requests.get')
+def test_get_public_ip(mock_get):
+    """TEST PUBLIC IP RETRIEVAL"""
+    mock_get.return_value.text = "1.2.3.4"
+    ip = get_public_ip()
+    assert ip == "1.2.3.4"
+    mock_get.assert_called_once()
+
+# TEST FOR LOCAL IP RETRIEVAL
+@patch('socket.socket')
+@patch('netifaces.gateways')
+@patch('netifaces.ifaddresses')
+def test_get_local_ip(mock_ifaddresses, mock_gateways, mock_socket):
+    """TEST LOCAL IP RETRIEVAL"""
+    # MOCK NETIFACES
+    mock_gateways.return_value = {'default': {2: ('192.168.1.1', 'eth0')}}
+    mock_ifaddresses.return_value = {2: [{'addr': '192.168.1.100'}]}
+    
+    ip = get_local_ip()
+    assert ip == "192.168.1.100"
+
+# TEST FOR IP INFO RETRIEVAL
+@patch('requests.get')
+def test_get_ip_info(mock_get):
+    """TEST IP INFO RETRIEVAL"""
+    mock_get.return_value.json.return_value = MOCK_IP_INFO
+    info = get_ip_info()
+    assert isinstance(info, dict)
+    assert info == MOCK_IP_INFO
+
+# TEST FOR IP INFO WITH SPECIFIC IP
+@patch('requests.get')
+def test_get_ip_info_with_ip(mock_get):
+    """TEST IP INFO WITH SPECIFIC IP"""
+    mock_get.return_value.json.return_value = MOCK_IP_INFO
+    test_ip = "8.8.8.8"  # GOOGLE DNS
+    info = get_ip_info(test_ip)
+    assert isinstance(info, dict)
+    assert info['ip'] == test_ip
+    assert 'Google' in info['org']
+
+# TEST FOR IP INFO WITH INVALID IP
+def test_get_ip_info_invalid():
+    """TEST IP INFO WITH INVALID IP"""
+    with pytest.raises(ValueError):
+        get_ip_info("invalid.ip.address")
+
+# TEST FOR IP INFO WITH PRIVATE IP
+def test_get_ip_info_private():
+    """TEST IP INFO WITH PRIVATE IP"""
+    private_ips = ["192.168.1.1", "10.0.0.1", "172.16.0.1"]
+    for ip in private_ips:
+        with pytest.raises(ValueError):
+            get_ip_info(ip) 

autotools/autoip/tests/test_autoip_integration.py

@@ -0,0 +1,92 @@
+import pytest
+from unittest.mock import patch, Mock
+from click.testing import CliRunner
+from autotools.cli import autoip
+
+# MOCK DATA
+MOCK_IP_INFO = {
+    'ip': '8.8.8.8',
+    'city': 'Mountain View',
+    'region': 'California',
+    'country': 'US',
+    'loc': '37.4056,-122.0775',
+    'org': 'Google LLC',
+    'timezone': 'America/Los_Angeles'
+}
+
+# INTEGRATION TESTS
+
+# TEST FOR BASIC CLI FUNCTIONALITY
+@patch('autotools.autoip.core.get_local_ips')
+@patch('autotools.autoip.core.get_public_ips')
+def test_autoip_cli_basic(mock_public_ips, mock_local_ips):
+    """TEST BASIC CLI FUNCTIONALITY"""
+    mock_local_ips.return_value = {
+        'ipv4': ['192.168.1.100'],
+        'ipv6': ['fe80::1']
+    }
+    mock_public_ips.return_value = {
+        'ipv4': '1.2.3.4',
+        'ipv6': None
+    }
+    
+    runner = CliRunner()
+    result = runner.invoke(autoip)
+    assert result.exit_code == 0
+    assert "192.168.1.100" in result.output
+    assert "1.2.3.4" in result.output
+    assert "fe80::1" in result.output
+
+# TEST FOR CONNECTIVITY TEST
+@patch('autotools.autoip.core.test_connectivity')
+def test_autoip_cli_test(mock_test):
+    """TEST CONNECTIVITY TEST"""
+    mock_test.return_value = [
+        ('Google DNS', True, 20),
+        ('CloudFlare', False, None)
+    ]
+    
+    runner = CliRunner()
+    result = runner.invoke(autoip, ['--test'])
+    assert result.exit_code == 0
+    assert "Google DNS" in result.output
+    assert "CloudFlare" in result.output
+    assert "✓ 20ms" in result.output
+    assert "✗ Failed" in result.output
+
+# TEST FOR SPEED TEST
+@patch('autotools.autoip.core.run_speedtest')
+def test_autoip_cli_speed(mock_speed):
+    """TEST SPEED TEST"""
+    mock_speed.return_value = True
+    
+    runner = CliRunner()
+    result = runner.invoke(autoip, ['--speed'])
+    assert result.exit_code == 0
+    assert "Running speed test" in result.output
+    assert "completed successfully" in result.output
+
+# TEST FOR LOCATION INFO DISPLAY
+@patch('autotools.autoip.core.get_ip_info')
+def test_autoip_cli_location(mock_get_info):
+    """TEST LOCATION INFO DISPLAY"""
+    mock_get_info.return_value = MOCK_IP_INFO
+    
+    runner = CliRunner()
+    result = runner.invoke(autoip, ['--location'])
+    assert result.exit_code == 0
+    assert "Mountain View" in result.output
+    assert "California" in result.output
+    assert "Google LLC" in result.output
+
+# TEST FOR HELP DISPLAY
+def test_autoip_cli_help():
+    """TEST HELP DISPLAY"""
+    runner = CliRunner()
+    result = runner.invoke(autoip, ['--help'])
+    assert result.exit_code == 0
+    assert "Usage:" in result.output
+    assert "Options:" in result.output
+    assert "--test" in result.output
+    assert "--speed" in result.output
+    assert "--location" in result.output 

autotools/autolower/tests/__init__.py

@@ -0,0 +1 @@
+# INIT FILE FOR TESTS 

autotools/autolower/tests/test_autolower_core.py

@@ -0,0 +1,45 @@
+import pytest
+from autotools.autolower.core import autolower_transform
+
+# UNIT TESTS
+
+# TEST FOR BASIC STRING TRANSFORMATION
+def test_autolower_transform_basic():
+    """TEST BASIC STRING TRANSFORMATION"""
+    assert autolower_transform("HELLO") == "hello"
+    assert autolower_transform("Hello World") == "hello world"
+    assert autolower_transform("123") == "123"
+
+# TEST FOR EMPTY STRING
+def test_autolower_transform_empty():
+    """TEST EMPTY STRING"""
+    assert autolower_transform("") == ""
+
+# TEST FOR SPECIAL CHARACTERS
+def test_autolower_transform_special_chars():
+    """TEST STRING WITH SPECIAL CHARACTERS"""
+    assert autolower_transform("HELLO@WORLD.COM") == "hello@world.com"
+    assert autolower_transform("HELLO-WORLD!") == "hello-world!"
+
+# TEST FOR MIXED CASE STRING
+def test_autolower_transform_mixed_case():
+    """TEST MIXED CASE STRING"""
+    assert autolower_transform("HeLLo WoRLD") == "hello world"
+
+# TEST FOR WHITESPACE
+def test_autolower_transform_whitespace():
+    """TEST STRING WITH WHITESPACE"""
+    assert autolower_transform("  HELLO  WORLD  ") == "  hello  world  "
+    assert autolower_transform("\tHELLO\nWORLD") == "\thello\nworld"
+
+# TEST FOR NUMBERS
+def test_autolower_transform_numbers():
+    """TEST STRING WITH NUMBERS"""
+    assert autolower_transform("HELLO123WORLD") == "hello123world"
+    assert autolower_transform("123HELLO456WORLD789") == "123hello456world789"
+
+# TEST FOR UNICODE CHARACTERS
+def test_autolower_transform_unicode():
+    """TEST UNICODE CHARACTERS"""
+    assert autolower_transform("HÉLLO WÖRLD") == "héllo wörld"
+    assert autolower_transform("こんにちは") == "こんにちは"  # JAPANESE SHOULD REMAIN UNCHANGED 

autotools/autolower/tests/test_autolower_integration.py

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

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

autotools/autospell/core.py

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

@@ -10,7 +10,7 @@ def get_supported_languages() -> dict:
     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) -> str:
+                  copy: bool = False, detect_lang: bool = False, output: str = None) -> str:
     """TRANSLATE TEXT TO SPECIFIED LANGUAGE
     
     ARGS:
@@ -19,6 +19,7 @@ def translate_text(text: str, to_lang: str = 'en', from_lang: str = None,
         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
@@ -34,6 +35,17 @@ def translate_text(text: str, to_lang: str = 'en', from_lang: str = None,
     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}"