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

Open_AutoTools-0.0.3rc1.dist-info/METADATA

@@ -0,0 +1,307 @@
+Metadata-Version: 2.2
+Name: Open-AutoTools
+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
+Author-email: maxremy.dev@gmail.com
+Project-URL: Bug Tracker, https://github.com/BabylooPro/Open-AutoTools/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Brotli==1.1.0
+Requires-Dist: certifi==2024.2.2
+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: 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
+Requires-Dist: textblob==0.18.0.post0
+Requires-Dist: tomli==2.0.1
+Requires-Dist: tqdm==4.66.2
+Requires-Dist: urllib3==2.2.1
+Requires-Dist: websockets==13.0.1
+Requires-Dist: yapf==0.40.2
+Requires-Dist: yt-dlp>=2024.3.10
+Requires-Dist: zipp==3.17.0
+Requires-Dist: translate==3.6.1
+Requires-Dist: langdetect==1.0.9
+Requires-Dist: deep-translator==1.11.4
+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
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Open-AutoTools
+
+Open-AutoTools is an innovative project developed in Python, specifically designed to offer a suite of automated tools directly accessible via the terminal. This project aims to simplify and automate daily tasks for developers and terminal users. It is designed to be used as a set of CLI commands, making its features directly accessible from the user's terminal.
+
+https://github.com/BabylooPro/Open-AutoTools/assets/35376790/d57f2b9d-55f8-4368-bb40-c0010eb9d49a
+
+## How to install to use directly
+
+To install Open-AutoTools, use the following command in your terminal: `pip install open-autotools`
+
+This command installs all the necessary tools to integrate Open-AutoTools into your workflow.
+
+You can also find the package on PyPI at: https://pypi.org/project/Open-AutoTools/
+
+## How to develop more features
+
+Open-AutoTools is developed using Python 3.11.
+
+```bash
+# Create a virtual environment
+python -m venv venv
+
+# Activate virtual environment
+source venv/bin/activate  # On macOS/Linux
+venv\Scripts\activate  # On Windows
+
+# Install project dependencies
+pip install -r requirements.txt
+
+# For development, install in editable mode
+pip install -e .
+```
+
+## Key Features
+
+### AutoCaps
+
+- **Description:** Converts any text entered by the user to uppercase.
+- **Usage:**
+  ```
+  ~ ❯ autocaps "Your text here."
+  ```
+- **Output:**
+  ```
+  YOUR TEXT HERE.
+  ```
+
+### AutoLower
+
+- **Description:** Converts any text entered by the user to lowercase.
+- **Usage:**
+  ```
+  ~ ❯ autolower "Your text here."
+  ```
+- **Output:**
+  ```
+  your text here.
+  ```
+
+### AutoPassword
+
+- **Description:** Generates secure random passwords and encryption keys with customizable options.
+- **Usage:**
+  ```
+  ~ ❯ autopassword --length 16
+  ~ ❯ autopassword --no-special --length 8
+  ~ ❯ autopassword --gen-key
+  ~ ❯ autopassword --password-key "your-password" --analyze
+  ```
+- **Options:**
+  - `--length, -l`: Set password length (default: 12)
+  - `--no-uppercase`: Exclude uppercase letters
+  - `--no-numbers`: Exclude numbers
+  - `--no-special`: Exclude special characters
+  - `--min-special`: Minimum number of special characters (default: 1)
+  - `--min-numbers`: Minimum number of numbers (default: 1)
+  - `--gen-key`: Generate a random encryption key
+  - `--password-key`: Generate an encryption key from a password
+  - `--analyze`: Show password strength analysis
+
+These examples demonstrate how the terminal will display the results after executing each command, providing a straightforward way for users to understand the immediate effects of these commands.
+
+### AutoTranslate
+
+- **Description:** Translates text between languages with automatic source language detection.
+- **Usage:**
+
+  ```
+  ~ ❯ autotranslate "Bonjour le monde" --to en
+  Hello world
+
+  ~ ❯ autotranslate "Hello world" --to fr --copy
+  Bonjour le monde
+  // Result also copied to clipboard
+
+  ~ ❯ autotranslate "こんにちは" --to en --detect
+  [Detected: ja] Hello
+
+  ~ ❯ autotranslate --list-languages
+  // Shows all supported languages
+  ```
+
+- **Options:**
+  - `--to`: Target language code (default: en)
+  - `--from`: Source language code (default: auto-detect)
+  - `--copy`: Copy translation to clipboard
+  - `--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.
+- **Usage:**
+
+  ```bash
+  # Download YouTube video in MP4 format
+  ~ ❯ autodownload https://youtube.com/watch?v=example
+
+  # Download with specific format and quality
+  ~ ❯ autodownload https://youtube.com/watch?v=example --format mp3
+  ~ ❯ autodownload https://youtube.com/watch?v=example --quality 1080p
+  ```
+
+- **Options:**
+
+  - `--format`: Choose output format (mp4 or mp3)
+  - `--quality`: Select video quality (best, 1440p, 1080p, 720p, 480p, 360p, 240p)
+
+- **Features:**
+
+  - Automatic bot detection bypass
+  - Browser cookie integration
+  - Progress tracking
+  - Multiple quality options
+  - MP3 audio extraction
+  - Downloads to user's Downloads folder
+  - Supports both YouTube and general file downloads
+
+- **Setup Requirements:**
+
+  - Chrome browser installed and configured:
+
+    ```bash
+    # First time setup:
+    1. Open Chrome and sign in to YouTube
+    2. Make sure you're logged into your Google account
+    3. Accept YouTube's terms of service in browser
+    ```
+
+  - **Troubleshooting:**
+
+    - If downloads fail with "Sign in to confirm you're not a bot":
+
+      1. Open YouTube in Chrome
+      2. Sign in if not already
+      3. Solve any CAPTCHA if prompted
+      4. Try download again
+
+    - If you get cookie errors:
+      1. Clear Chrome cookies
+      2. Sign in to YouTube again
+      3. Wait a few minutes before downloading
+
+  - **Technical Requirements:**
+    - Chrome browser (for cookie and session handling)
+    - Active YouTube/Google account
+    - Internet connection
+    - Sufficient storage space
+    - yt-dlp library (automatically installed)
+
+  > **Note:** The tool uses your Chrome browser's cookies to authenticate with YouTube. This is required to bypass YouTube's bot detection and download restrictions.
+
+### AutoIP
+
+- **Description:** Displays network information including IP addresses, connectivity tests, speed tests, and more.
+- **Usage:**
+
+  ```bash
+  # Display IP addresses
+  ~ ❯ autoip
+
+  # Run speed test
+  ~ ❯ autoip --speed
+
+  # Test connectivity
+  ~ ❯ autoip --test
+
+  # Show location info
+  ~ ❯ autoip --location
+
+  # Monitor network traffic
+  ~ ❯ autoip --monitor
+
+  # Check common ports
+  ~ ❯ autoip --ports
+
+  # Show DNS servers
+  ~ ❯ autoip --dns
+
+  # Hide IP display and only show tests
+  ~ ❯ autoip --no-ip --test --speed
+  ```
+
+- **Options:**
+
+  - `--test, -t`: Run connectivity tests to popular services
+  - `--speed, -s`: Run internet speed test
+  - `--monitor, -m`: Monitor real-time network traffic
+  - `--ports, -p`: Check status of common ports
+  - `--dns, -d`: Show DNS server configuration
+  - `--location, -l`: Show IP geolocation information
+  - `--no-ip, -n`: Hide IP addresses display
+
+- **Features:**
+  - Local and public IP detection (IPv4 & IPv6)
+  - Internet speed testing
+  - Network connectivity checks
+  - Real-time traffic monitoring
+  - Port scanning
+  - DNS server information
+  - IP geolocation
+
+## License
+
+This project is licensed under the MIT License. For more details, see the [LICENSE](LICENSE) file.

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.post1.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