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

{Open_AutoTools-0.0.2.post2.dist-info → Open_AutoTools-0.0.3rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: Open-AutoTools
-Version: 0.0.2.post2
+Version: 0.0.3rc1
 Summary: A suite of automated tools accessible via CLI with a simple `autotools` command
 Home-page: https://github.com/BabylooPro/Open-AutoTools
 Author: BabylooPro
@@ -18,14 +18,16 @@ Requires-Dist: charset-normalizer==3.3.2
 Requires-Dist: click==8.1.3
 Requires-Dist: cryptography==42.0.2
 Requires-Dist: idna==3.6
-Requires-Dist: importlib-metadata==7.0.1
+Requires-Dist: importlib-metadata>=7.0.1
 Requires-Dist: joblib==1.3.2
 Requires-Dist: Levenshtein==0.25.0
 Requires-Dist: mutagen==1.47.0
+Requires-Dist: packaging>=23.0
 Requires-Dist: platformdirs==4.2.0
 Requires-Dist: pycryptodomex==3.20.0
 Requires-Dist: pyperclip==1.8.2
 Requires-Dist: python-Levenshtein==0.25.0
+Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rapidfuzz==3.6.1
 Requires-Dist: regex==2023.12.25
 Requires-Dist: requests>=2.32.2
@@ -44,6 +46,12 @@ Requires-Dist: netifaces>=0.11.0
 Requires-Dist: speedtest-cli>=2.1.3
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: setuptools>=40.8.0
+Requires-Dist: language-tool-python>=2.7.1
+Requires-Dist: spacy>=3.7.2
+Requires-Dist: beautifulsoup4>=4.12.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.4.0; extra == "test"
+Requires-Dist: pytest-cov>=4.1.0; extra == "test"
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -51,6 +59,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: project-url
+Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -164,6 +173,22 @@ These examples demonstrate how the terminal will display the results after execu
   - `--detect`: Show detected source language
   - `--list-languages`: Show all supported language codes and names
 
+### AutoSpell (unreleased)
+
+- **Description:** Checks and corrects spelling in text with multi-language support.
+- **Usage:**
+  ```
+  ~ ❯ autospell "Your text with misspellings"
+  ~ ❯ autospell --lang fr "Votre texte avec des fautes"
+  ~ ❯ autospell --file document.txt
+  ```
+- **Options:**
+  - `--lang`: Language code (default: en)
+  - `--file`: Input from file
+  - `--copy`: Copy corrected text to clipboard
+  - `--suggest`: Show alternative suggestions
+  - `--interactive`: Interactive correction mode
+
 ### AutoDownload
 
 - **Description:** Downloads videos from YouTube and files from other sources.

Open_AutoTools-0.0.3rc1.dist-info/RECORD

@@ -0,0 +1,31 @@
+autotools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/cli.py,sha256=YJ_0Dq7t97SPkmmRSvqFuBkOVsh2UcnNcS8wdNSoESg,24389
+autotools/autocaps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autocaps/core.py,sha256=NnOacVp0kMoq__KHWi5UMcApSuq6Iyo5bFxN40dRw7U,253
+autotools/autocaps/tests/__init__.py,sha256=CckydfM7SZdXtW3pLgAeRdrC60sovNx_v59nyFvslFo,23
+autotools/autocaps/tests/test_autocaps_core.py,sha256=fzpci_sK7L1fSf_IJ1paJ__bmnHwC9OUOD7ftd3w07c,1672
+autotools/autocaps/tests/test_autocaps_integration.py,sha256=Qe2hzVEvzf0-INp14oTTrHi0RiRDCE2fxo9abVNcd_E,1435
+autotools/autodownload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autodownload/core.py,sha256=xmQSEEi3UYPkbbwsL-H4vGKcpqLCkwhIYlZxDWrIEpI,8266
+autotools/autoip/__init__.py,sha256=T_5hz9G4reFPXDucdzRoMFPYlAKwTPt9TejOpkRPgn0,23
+autotools/autoip/core.py,sha256=Q3dzLstZQruwYkSbCSlKQNmKVGCyNpo1DGst5VFtHLU,10123
+autotools/autoip/tests/__init__.py,sha256=CckydfM7SZdXtW3pLgAeRdrC60sovNx_v59nyFvslFo,23
+autotools/autoip/tests/test_autoip_core.py,sha256=Q8865qqhopcGBzS4mIlDlEzxu-mTIbZxpgJyzIyuQXc,2153
+autotools/autoip/tests/test_autoip_integration.py,sha256=-vS2gnY8ZfT-tfY2FRbUtTzY0lcIBtVZHbPbWsKyueo,2746
+autotools/autolower/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autolower/core.py,sha256=vjM2ognA3tDCbv10a9vta9WPuAiqTPjOXZ1JHL_b-nk,260
+autotools/autolower/tests/__init__.py,sha256=CckydfM7SZdXtW3pLgAeRdrC60sovNx_v59nyFvslFo,23
+autotools/autolower/tests/test_autolower_core.py,sha256=ChkS3qZgXz75iLfC9EXVH_kMd-sjaxpRKFjaxKoBnxo,1694
+autotools/autolower/tests/test_autolower_integration.py,sha256=M2yN1Ym7kGulys62-IwKq-uWn7CFvI3sCnoo-e3CTaA,1446
+autotools/autopassword/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autotools/autopassword/core.py,sha256=GQrd-QGWpgxuq6Nf28URcTZRku8Gji1NfpbecXAsIF0,3146
+autotools/autospell/__init__.py,sha256=jkpkiE7pksBgllXKfkNpYYvqtlm8vN0h4kXnQOqcb_U,60
+autotools/autospell/core.py,sha256=WPvi9Xs6uF3dte_g2I9oHfTjCV1-NasrJElLP9bbC8U,8103
+autotools/autotranslate/__init__.py,sha256=6BxuZqhyQhfsZ5x7DkB1BAEpC08GT_5l5bl0AY_eLpU,64
+autotools/autotranslate/core.py,sha256=H2f90IWr_jNGiJD3XAv-20i5sRGM-VDYWrYt65EDEkI,1836
+Open_AutoTools-0.0.3rc1.dist-info/LICENSE,sha256=SpbSRxNWos2l0-geleCa6d0L9G_bOsZRkY4rB9OduJ0,1069
+Open_AutoTools-0.0.3rc1.dist-info/METADATA,sha256=Vvbj28d0I4k0RdUeBE6v2lxmkvr5UxV89nznLpU9bVs,9120
+Open_AutoTools-0.0.3rc1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+Open_AutoTools-0.0.3rc1.dist-info/entry_points.txt,sha256=QLIsUk6vHo0wAYDk1K74kIuYunJMwWe2xbwQhJXLoKo,312
+Open_AutoTools-0.0.3rc1.dist-info/top_level.txt,sha256=x5ZRvdQw7DQnVmR0YDqVSAuuS94KTHDmk6uIeW7YOPw,10
+Open_AutoTools-0.0.3rc1.dist-info/RECORD,,

{Open_AutoTools-0.0.2.post2.dist-info → Open_AutoTools-0.0.3rc1.dist-info}/entry_points.txt

@@ -4,5 +4,6 @@ autodownload = autotools.cli:autodownload
 autoip = autotools.cli:autoip
 autolower = autotools.cli:autolower
 autopassword = autotools.cli:autopassword
-autotools = autotools.cli:autotools
+autospell = autotools.cli:autospell
+autotools = autotools.cli:cli
 autotranslate = autotools.cli:autotranslate

autotools/autocaps/tests/__init__.py

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

autotools/autocaps/tests/test_autocaps_core.py

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

autotools/autocaps/tests/test_autocaps_integration.py

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

autotools/autoip/core.py

@@ -1,5 +1,7 @@
 import socket
 import requests
+import json
+import ipaddress
 import netifaces
 import time
 import speedtest
@@ -125,94 +127,185 @@ def run_speedtest():
         print(f"\nSpeed test failed: {str(e)}")
         return False
 
-def run(test=False, speed=False, monitor=False, ports=False, dns=False, location=False, no_ip=False):
-    """MAIN FUNCTION"""
-    # GET LOCAL AND PUBLIC IPS
-    local = get_local_ips()
-    public = get_public_ips()
+# GET PUBLIC IP ADDRESS USING IPIFY API
+def get_public_ip():
+    """GET PUBLIC IP ADDRESS USING IPIFY API"""
+    try:
+        response = requests.get('https://api.ipify.org')
+        return response.text
+    except requests.RequestException:
+        # FALLBACK TO ANOTHER SERVICE IF IPIFY FAILS
+        try:
+            response = requests.get('https://api.ipapi.com/api/check')
+            return response.json()['ip']
+        except:
+            return None
+
+# GET LOCAL IP ADDRESS
+def get_local_ip():
+    """GET LOCAL IP ADDRESS"""
+    try:
+        # GET DEFAULT INTERFACE
+        gateways = netifaces.gateways()
+        default_interface = gateways['default'][netifaces.AF_INET][1]
+        
+        # GET IP FROM DEFAULT INTERFACE
+        addrs = netifaces.ifaddresses(default_interface)
+        return addrs[netifaces.AF_INET][0]['addr']
+    except:
+        # FALLBACK METHOD
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(("8.8.8.8", 80))
+            ip = s.getsockname()[0]
+            s.close()
+            return ip
+        except:
+            return None
+
+# GET IP INFORMATION USING IPAPI.CO
+def get_ip_info(ip=None):
+    """GET IP INFORMATION USING IPAPI.CO
+    
+    Args:
+        ip (str, optional): IP address to get info for. If None, uses current IP.
+        
+    Returns:
+        dict: Dictionary containing IP information
+        
+    Raises:
+        ValueError: If IP is invalid or private
+    """
+    if ip:
+        # VALIDATE IP
+        try:
+            ip_obj = ipaddress.ip_address(ip)
+            if ip_obj.is_private:
+                raise ValueError("Cannot get info for private IP addresses")
+        except ValueError as e:
+            raise ValueError(f"Invalid IP address: {str(e)}")
+    
+    try:
+        # USE IPAPI.CO FOR IP INFO
+        url = f'https://ipapi.co/{ip}/json' if ip else 'https://ipapi.co/json'
+        response = requests.get(url)
+        data = response.json()
+        
+        if 'error' in data:
+            raise ValueError(f"Error getting IP info: {data['error']}")
+            
+        return data
+    except requests.RequestException as e:
+        raise ValueError(f"Error connecting to IP info service: {str(e)}")
+
+# MAIN FUNCTION TO RUN IP TOOLS
+def run(test=False, speed=False, monitor=False, interval=1, ports=False, dns=False, location=False, no_ip=False):
+    """MAIN FUNCTION TO RUN IP TOOLS
+    
+    Args:
+        test (bool): Run connectivity tests
+        speed (bool): Run speed test
+        monitor (bool): Monitor network traffic
+        interval (int): Monitoring interval in seconds
+        ports (bool): Check common ports status
+        dns (bool): Show DNS servers
+        location (bool): Show IP location info
+        no_ip (bool): Hide IP addresses
+    """
+    output = []
     
-    # DISPLAY IPS IF NOT HIDDEN
+    # GET IP ADDRESSES IF NOT HIDDEN
     if not no_ip:
-        print("\nLocal IPs:")
-        if local['ipv4']:
-            for ip in local['ipv4']:
-                print(f"IPv4: {ip}")
+        local_ips = get_local_ips()
+        public_ips = get_public_ips()
+        
+        output.append("\nLocal IPs:")
+        if local_ips['ipv4']:
+            for ip in local_ips['ipv4']:
+                output.append(f"IPv4: {ip}")
         else:
-            print("IPv4: Not available")
+            output.append("IPv4: Not available")
             
-        if local['ipv6']:
-            for ip in local['ipv6']:
-                print(f"IPv6: {ip}")
+        if local_ips['ipv6']:
+            for ip in local_ips['ipv6']:
+                output.append(f"IPv6: {ip}")
         else:
-            print("IPv6: Not available")
+            output.append("IPv6: Not available")
         
-        print("\nPublic IPs:")
-        print(f"IPv4: {public['ipv4'] or 'Not available'}")
-        print(f"IPv6: {public['ipv6'] or 'Not available'}")
+        output.append("\nPublic IPs:")
+        output.append(f"IPv4: {public_ips['ipv4'] or 'Not available'}")
+        output.append(f"IPv6: {public_ips['ipv6'] or 'Not available'}")
 
     # RUN CONNECTIVITY TESTS IF REQUESTED
     if test:
-        print("\nConnectivity Tests:")
+        output.append("\nConnectivity Tests:")
         results = test_connectivity()
         for name, success, latency in results:
             status = f"✓ {latency}ms" if success else "✗ Failed"
-            print(f"{name:<15} {status}")
+            output.append(f"{name:<15} {status}")
     
     # RUN SPEED TEST IF REQUESTED
     if speed:
-        run_speedtest()
+        output.append("\nRunning speed test...")
+        if run_speedtest():
+            output.append("Speed test completed successfully")
+        else:
+            output.append("Speed test failed")
     
     # DISPLAY LOCATION INFO IF REQUESTED
     if location:
         try:
-            loc = requests.get('https://ipapi.co/json/').json()
-            print("\nLocation Info:")
-            print(f"City: {loc.get('city', 'Unknown')}")
-            print(f"Region: {loc.get('region', 'Unknown')}")
-            print(f"Country: {loc.get('country_name', 'Unknown')}")
-            print(f"ISP: {loc.get('org', 'Unknown')}")
-        except:
-            print("\nLocation lookup failed")
+            loc = get_ip_info()
+            output.append("\nLocation Info:")
+            output.append(f"City: {loc.get('city', 'Unknown')}")
+            output.append(f"Region: {loc.get('region', 'Unknown')}")
+            output.append(f"Country: {loc.get('country', 'Unknown')}")
+            output.append(f"ISP: {loc.get('org', 'Unknown')}")
+        except Exception as e:
+            output.append(f"\nLocation lookup failed: {str(e)}")
 
     # DISPLAY DNS SERVERS IF REQUESTED
     if dns:
-        print("\nDNS Servers:")
+        output.append("\nDNS Servers:")
         try:
             with open('/etc/resolv.conf', 'r') as f:
                 for line in f:
                     if 'nameserver' in line:
-                        print(f"DNS: {line.split()[1]}")
+                        output.append(f"DNS: {line.split()[1]}")
         except:
-            print("Could not read DNS configuration")
+            output.append("Could not read DNS configuration")
 
     # CHECK COMMON PORTS IF REQUESTED
     if ports:
         common_ports = [80, 443, 22, 21, 25, 3306]
-        print("\nCommon Ports Status (localhost):")
+        output.append("\nCommon Ports Status (localhost):")
         for port in common_ports:
             sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             result = sock.connect_ex(('127.0.0.1', port))
             status = "Open" if result == 0 else "Closed"
-            print(f"Port {port}: {status}")
+            output.append(f"Port {port}: {status}")
             sock.close()
 
     # MONITOR NETWORK TRAFFIC IF REQUESTED
     if monitor:
-        print("\nNetwork Monitor (Press Ctrl+C to stop):")
+        output.append("\nNetwork Monitor (Press Ctrl+C to stop):")
         try:
             prev_bytes_sent = psutil.net_io_counters().bytes_sent
             prev_bytes_recv = psutil.net_io_counters().bytes_recv
             while True:
-                time.sleep(1)
+                time.sleep(interval)
                 bytes_sent = psutil.net_io_counters().bytes_sent
                 bytes_recv = psutil.net_io_counters().bytes_recv
                 
-                upload_speed = (bytes_sent - prev_bytes_sent) / 1024  # KB/s
-                download_speed = (bytes_recv - prev_bytes_recv) / 1024  # KB/s
+                # CALCULATE UPLOAD AND DOWNLOAD SPEEDS
+                upload_speed = (bytes_sent - prev_bytes_sent) / (1024 * interval)
+                download_speed = (bytes_recv - prev_bytes_recv) / (1024 * interval)
                 
-                print(f"\rUp: {upload_speed:.2f} KB/s | Down: {download_speed:.2f} KB/s", end='')
+                output.append(f"\rUp: {upload_speed:.2f} KB/s | Down: {download_speed:.2f} KB/s")
                 
                 prev_bytes_sent = bytes_sent
                 prev_bytes_recv = bytes_recv
         except KeyboardInterrupt:
-            print("\nMonitoring stopped") 
+            output.append("\nMonitoring stopped")
+    
+    return "\n".join(output) 

autotools/autoip/tests/__init__.py

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

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