Open-AutoTools 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

Open_AutoTools-0.0.2.dist-info/METADATA

@@ -0,0 +1,4 @@
+Metadata-Version: 2.2
+Name: Open-AutoTools
+Version: 0.0.2
+License-File: LICENSE

Open_AutoTools-0.0.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+autotools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/cli.py,sha256=VWQgHF0WuAD9XGtqaF48EHF5pczrg7VCq-w_wylV9Tc,7167
+autotools/autocaps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autocaps/core.py,sha256=NnOacVp0kMoq__KHWi5UMcApSuq6Iyo5bFxN40dRw7U,253
+autotools/autoip/__init__.py,sha256=T_5hz9G4reFPXDucdzRoMFPYlAKwTPt9TejOpkRPgn0,23
+autotools/autoip/core.py,sha256=_Gy8QyDIUaQmfBF6CIP3Ju3_KYbZhs2mst9Vm0sPQUI,6940
+autotools/autolower/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/autolower/core.py,sha256=vjM2ognA3tDCbv10a9vta9WPuAiqTPjOXZ1JHL_b-nk,260
+autotools/autotranslate/__init__.py,sha256=6BxuZqhyQhfsZ5x7DkB1BAEpC08GT_5l5bl0AY_eLpU,64
+autotools/autotranslate/core.py,sha256=-QdWBIF-eNbuN5qhf45BlOzaOkckwhaF4IMG3OOeRcw,1383
+autotools/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+autotools/downloader/core.py,sha256=xmQSEEi3UYPkbbwsL-H4vGKcpqLCkwhIYlZxDWrIEpI,8266
+autotools/password/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+autotools/password/core.py,sha256=GQrd-QGWpgxuq6Nf28URcTZRku8Gji1NfpbecXAsIF0,3146
+Open_AutoTools-0.0.2.dist-info/LICENSE,sha256=SpbSRxNWos2l0-geleCa6d0L9G_bOsZRkY4rB9OduJ0,1069
+Open_AutoTools-0.0.2.dist-info/METADATA,sha256=3voGwJ-WYx4RNm5sgB1o0SAyF8azU8UmwS91J-IXk9c,80
+Open_AutoTools-0.0.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+Open_AutoTools-0.0.2.dist-info/entry_points.txt,sha256=NVN0wuAVjff3e4_MyceS5o22V_l7_0R_wT2adgvWAlY,282
+Open_AutoTools-0.0.2.dist-info/top_level.txt,sha256=x5ZRvdQw7DQnVmR0YDqVSAuuS94KTHDmk6uIeW7YOPw,10
+Open_AutoTools-0.0.2.dist-info/RECORD,,

{Open_AutoTools-0.0.1.dist-info → Open_AutoTools-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.2)
+Generator: setuptools (75.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{Open_AutoTools-0.0.1.dist-info → Open_AutoTools-0.0.2.dist-info}/entry_points.txt

@@ -1,6 +1,8 @@
 [console_scripts]
 autocaps = autotools.cli:autocaps
-autocorrect = autotools.cli:autocorrect
 autodownload = autotools.cli:autodownload
+autoip = autotools.cli:autoip
+autolower = autotools.cli:autolower
+autopassword = autotools.cli:autopassword
 autotools = autotools.cli:autotools
 autotranslate = autotools.cli:autotranslate

autotools/autoip/__init__.py

@@ -0,0 +1 @@
+from .core import run 

autotools/autoip/core.py

@@ -0,0 +1,218 @@
+import socket
+import requests
+import netifaces
+import time
+import speedtest
+import psutil
+
+def get_local_ips():
+    """GET LOCAL IPS"""
+    ips = {'ipv4': [], 'ipv6': []} # INITIALIZE WITH EMPTY LISTS
+    
+    # GET LOCAL IPS
+    for interface in netifaces.interfaces():
+        addrs = netifaces.ifaddresses(interface)
+        
+        # GET IPV4
+        if netifaces.AF_INET in addrs:
+            for addr in addrs[netifaces.AF_INET]:
+                if 'addr' in addr and not addr['addr'].startswith('127.'):
+                    ips['ipv4'].append(addr['addr'])
+        
+        # GET IPV6
+        if netifaces.AF_INET6 in addrs:
+            for addr in addrs[netifaces.AF_INET6]:
+                if 'addr' in addr and not addr['addr'].startswith('fe80:'):
+                    # REMOVE SCOPE ID IF PRESENT
+                    clean_addr = addr['addr'].split('%')[0]
+                    ips['ipv6'].append(clean_addr)
+    
+    return ips
+
+def get_public_ips():
+    """GET PUBLIC IPS"""
+    ips = {'ipv4': None, 'ipv6': None} # INITIALIZE WITH NONE
+    
+    # TEST MULTIPLE IPV4 SERVICES
+    ipv4_services = [
+        'https://api.ipify.org',
+        'https://ipv4.icanhazip.com',
+        'https://v4.ident.me'
+    ]
+    
+    # GET PUBLIC IPV4
+    for service in ipv4_services:
+        try:
+            ips['ipv4'] = requests.get(service, timeout=2).text.strip()
+            if ips['ipv4']: break
+        except:
+            continue
+    
+    # TEST MULTIPLE IPV6 SERVICES
+    ipv6_services = [
+        'https://api6.ipify.org',
+        'https://ipv6.icanhazip.com',
+        'https://v6.ident.me'
+    ]
+    
+    # GET PUBLIC IPV6
+    for service in ipv6_services:
+        try:
+            ips['ipv6'] = requests.get(service, timeout=2).text.strip()
+            if ips['ipv6']: break
+        except:
+            continue
+
+    return ips
+
+# TEST CONNECTIVITY TO POPULAR SERVICES
+def test_connectivity():
+    """TEST CONNECTIVITY TO POPULAR SERVICES"""
+    
+    # TEST HOSTS
+    test_hosts = {
+        'Google DNS': ('8.8.8.8', 53),
+        'CloudFlare DNS': ('1.1.1.1', 53),
+        'Google': ('google.com', 443),
+        'Cloudflare': ('cloudflare.com', 443),
+        'GitHub': ('github.com', 443),
+    }
+    
+    results = [] # INITIALIZE WITH EMPTY LIST
+    
+    # TEST EACH HOST
+    for name, (host, port) in test_hosts.items():
+        try:
+            start = time.time()
+            s = socket.create_connection((host, port), timeout=2)
+            latency = round((time.time() - start) * 1000, 2)
+            s.close()
+            results.append((name, True, latency))
+        except:
+            results.append((name, False, None))
+    
+    return results
+
+# RUN INTERNET SPEED TEST
+def run_speedtest():
+    """RUN INTERNET SPEED TEST"""
+    print("\nRunning speed test (this may take a minute)...")
+    
+    # RUN SPEED TEST
+    try:
+        # GET BEST SERVER
+        st = speedtest.Speedtest()
+        st.get_best_server()
+        
+        # TEST DOWNLOAD
+        print("Testing download speed...")
+        download_speed = st.download() / 1_000_000  # Convert to Mbps
+        
+        # TEST UPLOAD
+        print("Testing upload speed...")
+        upload_speed = st.upload() / 1_000_000  # Convert to Mbps
+        
+        # GET PING
+        ping = st.results.ping
+        
+        print("\nSpeed Test Results:")
+        print(f"Download: {download_speed:.2f} Mbps")
+        print(f"Upload: {upload_speed:.2f} Mbps")
+        print(f"Ping: {ping:.0f} ms")
+        
+        return True
+    except Exception as e:
+        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()
+    
+    # DISPLAY IPS IF NOT HIDDEN
+    if not no_ip:
+        print("\nLocal IPs:")
+        if local['ipv4']:
+            for ip in local['ipv4']:
+                print(f"IPv4: {ip}")
+        else:
+            print("IPv4: Not available")
+            
+        if local['ipv6']:
+            for ip in local['ipv6']:
+                print(f"IPv6: {ip}")
+        else:
+            print("IPv6: Not available")
+        
+        print("\nPublic IPs:")
+        print(f"IPv4: {public['ipv4'] or 'Not available'}")
+        print(f"IPv6: {public['ipv6'] or 'Not available'}")
+
+    # RUN CONNECTIVITY TESTS IF REQUESTED
+    if test:
+        print("\nConnectivity Tests:")
+        results = test_connectivity()
+        for name, success, latency in results:
+            status = f"✓ {latency}ms" if success else "✗ Failed"
+            print(f"{name:<15} {status}")
+    
+    # RUN SPEED TEST IF REQUESTED
+    if speed:
+        run_speedtest()
+    
+    # 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")
+
+    # DISPLAY DNS SERVERS IF REQUESTED
+    if dns:
+        print("\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]}")
+        except:
+            print("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):")
+        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}")
+            sock.close()
+
+    # MONITOR NETWORK TRAFFIC IF REQUESTED
+    if monitor:
+        print("\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)
+                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
+                
+                print(f"\rUp: {upload_speed:.2f} KB/s | Down: {download_speed:.2f} KB/s", end='')
+                
+                prev_bytes_sent = bytes_sent
+                prev_bytes_recv = bytes_recv
+        except KeyboardInterrupt:
+            print("\nMonitoring stopped") 

autotools/autolower/core.py

@@ -0,0 +1,7 @@
+import pyperclip
+
+# AUTOLOWERCASE CORE FUNCTION DEFINITION
+def autolower_transform(text):
+    transformed_text = text.lower()  # TRANSFORM TEXT TO LOWERCASE
+    pyperclip.copy(transformed_text)  # COPY TRANSFORMED TEXT TO CLIPBOARD
+    return transformed_text

autotools/autotranslate/__init__.py

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

autotools/autotranslate/core.py

@@ -1,39 +1,40 @@
-import requests
-import os
+from deep_translator import GoogleTranslator
+from langdetect import detect
 import pyperclip
 
-# PARAMETERS API
-BASE_URL = "https://google-translate113.p.rapidapi.com/api/v1/translator/{}"
-HEADERS = {
-    "X-RapidAPI-Key": os.getenv('RAPIDAPI_API_KEY'),
-    "X-RapidAPI-Host": "google-translate113.p.rapidapi.com"
-}
-
-
-# FUNCTION TO GET SUPPORTED LANGUAGES
-def autotranslate_supported_languages():
-    endpoint = "support-languages"
-    full_url = BASE_URL.format(endpoint)
-    response = requests.get(full_url, headers=HEADERS)
-    languages = response.json()
-
-    language_codes = [lang['code'] for lang in languages]
-    return language_codes
-
-
-# FUNCTION TO TRANSLATE TEXT AND COPY TO CLIPBOARD
-def autotranslate_text(text, language_target):
-    endpoint = "text"
-    full_url = BASE_URL.format(endpoint)
-    payload = {"from": "auto", "to": language_target, "text": text}
-    specific_headers = {
-        **HEADERS, "content-type": "application/x-www-form-urlencoded"
-    }
-
-    response = requests.post(full_url, data=payload, headers=specific_headers)
-    translated_text = response.json()['trans']
-
-    # COPY TRANSLATED TEXT TO CLIPBOARD
-    pyperclip.copy(translated_text)
-
-    return translated_text
+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) -> 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
+        
+    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)
+    
+    # RETURN RESULT WITH DETECTED LANGUAGE IF REQUESTED
+    if detect_lang:
+        return f"[Detected: {source_lang}] {result}"
+    return result 

autotools/cli.py

@@ -1,17 +1,24 @@
-from dotenv import load_dotenv
-load_dotenv() # LOAD ENVIRONMENT VARIABLES BEFORE IMPORTING OTHER MODULES BECAUSE CERTAIN MODULES DEPEND ON ENVIRONMENT VARIABLES
-
 import os
 import click
-from autotools.autotranslate.core import autotranslate_text, autotranslate_supported_languages
-from autotools.autocorrect.core import autocorrect_text
+import base64
 from autotools.autocaps.core import autocaps_transform
+from autotools.autolower.core import autolower_transform
 from autotools.downloader.core import download_youtube_video, download_file
+from autotools.password.core import (
+    generate_password,
+    generate_encryption_key,
+    analyze_password_strength
+)
+from translate import Translator
+from autotools.autotranslate.core import translate_text, get_supported_languages
+import yt_dlp
+from autotools import downloader, autolower, autocaps, autoip
+import argparse
 
 # CLI FUNCTION DEFINITION
 @click.group()
 def cli():
-    """Autotools is a set of tools for text capitalization, correction and translation."""
+    """Autotools is a set of tools for text capitalization and file downloading."""
     pass
 
 # AUTOTOOLS COMMAND LINE INTERFACE FUNCTION DEFINITION FOR SHOW HELP MESSAGE
@@ -26,30 +33,13 @@ def autocaps(text):
     result = autocaps_transform(text)
     click.echo(result)
 
-# AUTOCORRECT COMMAND LINE INTERFACE FUNCTION DEFINITION
+# AUTOLOWER CASE COMMAND LINE INTERFACE FUNCTION DEFINITION
 @cli.command()
 @click.argument('text')
-def autocorrect(text):
-    result = autocorrect_text(text)
+def autolower(text):
+    result = autolower_transform(text)
     click.echo(result)
 
-# AUTOTRANSLATE COMMAND LINE INTERFACE FUNCTION DEFINITION
-VALID_LANGUAGES = autotranslate_supported_languages() # VALID LANGUAGES FOR TRANSLATION
-@cli.command()
-@click.argument('text')
-#@click.option('--from', 'language_origin', required=True, help="Language of the source text")
-@click.option('--to', 'language_target', required=True, help="Target language for translation")
-def autotranslate(text, language_target):
-    if language_target not in VALID_LANGUAGES:
-        click.secho(f"Language code '{
-                    language_target}' is not supported.", fg='red')
-        return
-
-    # CALL TO AUTOTRANSLATE FUNCTION
-    result = autotranslate_text(
-        text, language_target=language_target)
-    click.secho(result)
-
 # AUTODOWNLOAD COMMAND LINE INTERFACE FUNCTION DEFINITION
 @cli.command()
 @click.argument('url')
@@ -61,6 +51,133 @@ def autodownload(url, format, quality):
     else:
         download_file(url)
 
+# AUTOPASSWORD COMMAND LINE INTERFACE FUNCTION DEFINITION
+@cli.command()
+@click.option('--length', '-l', default=12, help='Password length (default: 12)')
+@click.option('--no-uppercase', is_flag=True, help='Exclude uppercase letters')
+@click.option('--no-numbers', is_flag=True, help='Exclude numbers')
+@click.option('--no-special', is_flag=True, help='Exclude special characters')
+@click.option('--min-special', default=1, help='Minimum number of special characters')
+@click.option('--min-numbers', default=1, help='Minimum number of numbers')
+@click.option('--analyze', is_flag=True, help='Analyze password strength')
+@click.option('--gen-key', is_flag=True, help='Generate encryption key')
+@click.option('--password-key', help='Generate key from password')
+def autopassword(length, no_uppercase, no_numbers, no_special, 
+                 min_special, min_numbers, analyze, gen_key, password_key):
+    """Generate secure passwords and encryption keys."""
+    
+    ## HELPER FUNCTION TO SHOW PASSWORD/KEY ANALYSIS
+    def show_analysis(text, prefix=""):
+        """Helper function to show password/key analysis"""
+        if analyze:
+            analysis = analyze_password_strength(text)
+            click.echo(f"\n{prefix}Strength Analysis:")
+            click.echo(f"Strength: {analysis['strength']}")
+            click.echo(f"Score: {analysis['score']}/5")
+            if analysis['suggestions']:
+                click.echo("\nSuggestions for improvement:")
+                for suggestion in analysis['suggestions']:
+                    click.echo(f"- {suggestion}")
+    
+    # GENERATE KEY
+    if gen_key:
+        key = generate_encryption_key()
+        key_str = key.decode()
+        click.echo(f"Encryption Key: {key_str}")
+        if analyze:
+            show_analysis(key_str, "Key ")
+        return
+    
+    # GENERATE KEY FROM PASSWORD
+    if password_key:
+        key, salt = generate_encryption_key(password_key)
+        key_str = key.decode()
+        click.echo(f"Derived Key: {key_str}")
+        click.echo(f"Salt: {base64.b64encode(salt).decode()}")
+        if analyze:
+            click.echo("\nAnalyzing source password:")
+            show_analysis(password_key, "Password ")
+            click.echo("\nAnalyzing generated key:")
+            show_analysis(key_str, "Key ")
+        return
+    
+    # GENERATE PASSWORD
+    password = generate_password(
+        length=length,
+        use_uppercase=not no_uppercase,
+        use_numbers=not no_numbers,
+        use_special=not no_special,
+        min_special=min_special,
+        min_numbers=min_numbers,
+    )
+    
+    # SHOW PASSWORD
+    click.echo(f"Generated Password: {password}")
+    show_analysis(password, "Password ")
+
+# TRANSLATE COMMAND LINE INTERFACE FUNCTION DEFINITION
+@cli.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')
+def autotranslate(text: str, to: str, from_lang: str, list_languages: bool, 
+                  copy: bool, detect: bool):
+    """TRANSLATE TEXT TO SPECIFIED LANGUAGE (AUTO-DETECTS SOURCE LANGUAGE)"""
+    
+    # LIST ALL SUPPORTED LANGUAGES
+    if list_languages:
+        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
+        
+    result = translate_text(text, to_lang=to, from_lang=from_lang, 
+                          copy=copy, detect_lang=detect)
+    click.echo(result)
+
+# AUTOIP COMMAND LINE INTERFACE FUNCTION DEFINITION
+@cli.command()
+@click.option('--test', '-t', is_flag=True, help='Run connectivity tests')
+@click.option('--speed', '-s', is_flag=True, help='Run internet speed test')
+@click.option('--monitor', '-m', is_flag=True, help='Monitor network traffic')
+@click.option('--ports', '-p', is_flag=True, help='Check common ports status')
+@click.option('--dns', '-d', is_flag=True, help='Show DNS servers')
+@click.option('--location', '-l', is_flag=True, help='Show IP location info')
+@click.option('--no-ip', '-n', is_flag=True, help='Hide IP addresses display')
+def autoip(test, speed, monitor, ports, dns, location, no_ip):
+    """DISPLAY LOCAL AND PUBLIC IP ADDRESSES"""
+    from autotools import autoip
+    autoip.run(test, speed, monitor, ports, dns, location, no_ip)
+
 # MAIN FUNCTION TO RUN CLI
 if __name__ == '__main__':
     cli()
+
+def download_video(url):
+    try:
+        # CONFIGURE YT-DLP WITH COOKIES AND HEADERS
+        yt_opts = {
+            'cookiefile': '~/cookies.txt',
+            'headers': {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+            }
+        }
+        with yt_dlp.YoutubeDL(yt_opts) as ydl:
+            ydl.download([url])
+        return True
+    except Exception as e:
+        print(f"ERROR: {str(e)}")
+        return False
+
+# REMOVE OR COMMENT OUT THE NEW ARGPARSE-BASED MAIN FUNCTION
+# def main():
+#     parser = argparse.ArgumentParser()
+#     ...

autotools/downloader/core.py

@@ -6,6 +6,7 @@ from tqdm import tqdm
 import yt_dlp
 import platform
 import subprocess
+import json
 
 
 # FUNCTION TO GET DEFAULT DOWNLOAD DIRECTORY
@@ -76,53 +77,91 @@ def download_file(url):
     except requests.exceptions.RequestException as e:
         print(f"Error during file download: {e}")
 
+# FUNCTION TO GET CONSENT FILE PATH
+def get_consent_file_path():
+    """GET PATH TO STORE CONSENT STATUS"""
+    return Path.home() / '.autotools' / 'consent.json'
+
+# FUNCTION TO LOAD CONSENT STATUS
+def load_consent_status():
+    """LOAD SAVED CONSENT STATUS"""
+    consent_file = get_consent_file_path()
+    
+    # CHECK IF CONSENT FILE EXISTS
+    if consent_file.exists():
+        try:
+            with open(consent_file) as f:
+                return json.load(f).get('youtube_consent', False)
+        except:
+            return False
+    return False
+
+# FUNCTION TO SAVE CONSENT STATUS
+def save_consent_status(status):
+    """SAVE CONSENT STATUS"""
+    consent_file = get_consent_file_path()
+    consent_file.parent.mkdir(exist_ok=True)
+    
+    # SAVE CONSENT STATUS TO FILE
+    with open(consent_file, 'w') as f:
+        json.dump({'youtube_consent': status}, f)
+
+# FUNCTION TO GET USER CONSENT WITH INTERACTIVE PROMPT
+def get_user_consent():
+    """GET USER CONSENT WITH INTERACTIVE PROMPT"""
+    print("\n⚠️  Important Notice:")
+    print("This tool will:")
+    print("1. Access your Chrome browser cookies")
+    print("2. Use them to authenticate with YouTube")
+    print("3. Download video content to your local machine")
+    
+    # GET USER CONSENT WITH INTERACTIVE PROMPT
+    while True:
+        response = input("\nDo you consent to these actions? (yes/no): ").lower()
+        if response in ['yes', 'y']:
+            save_consent_status(True)
+            return True
+        elif response in ['no', 'n']:
+            save_consent_status(False)
+            return False
+        print("Please answer 'yes' or 'no'")
 
-# FUNCTION TO DOWNLOAD YOUTUBE VIDEOS WITH YT-DLP AND SPECIFIED FORMAT AND QUALITY
-def download_youtube_video(url, file_format='mp4', quality='best'):
-    # First, validate the YouTube URL
-    if not validate_youtube_url(url):
-        print(f"Aborting download: Invalid URL {url}")
-        return
-
-    download_dir = get_default_download_dir()
 
-    video_formats = {
-        '1440p': 'bestvideo[height<=1440]+bestaudio/best[height<=1440]',
-        '1080p': 'bestvideo[height<=1080]+bestaudio/best[height<=1080]',
-        '720p': 'bestvideo[height<=720]+bestaudio/best[height<=720]',
-        '480p': 'bestvideo[height<=480]+bestaudio/best[height<=480]',
-        '360p': 'bestvideo[height<=360]+bestaudio/best[height<=360]',
-        '240p': 'bestvideo[height<=240]+bestaudio/best[height<=240]',
-        'best': 'bestvideo+bestaudio/best'
-    }
-
-    selected_format = video_formats.get(quality, video_formats['best'])
+# FUNCTION TO DOWNLOAD YOUTUBE VIDEOS WITH YT-DLP AND SPECIFIED FORMAT AND QUALITY
+def download_youtube_video(url, format='mp4', quality='best'):
+    """DOWNLOAD VIDEO WITH CONSENT CHECK"""
+    # CHECK IF CONSENT IS REQUIRED
+    if not load_consent_status():
+        if not get_user_consent():
+            print("\n❌ Download cancelled by user")
+            return False
+    
+    print(f"\n🎥 Downloading video from: {url}")
+    print(f"📋 Format: {format}, Quality: {quality}\n")
 
     ydl_opts = {
-        'format': selected_format if file_format == 'mp4' else 'bestaudio',
-        'outtmpl': str(download_dir / '%(title)s.%(ext)s'),
-        'progress_hooks': [tqdm_progress_hook],
-        'quiet': True,  # SUPPRESS MOST OF YT-DLP OUTPUT EXCEPT PROGRESS
-        'no_warnings': True,  # HIDE WARNINGS
-        'merge_output_format': 'mp4'  # AUTOMATICALLY REMUX TO MP4 IF NEEDED
+        'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best' if format == 'mp4' else 'bestaudio[ext=mp3]/best',
+        'quiet': False,
+        'no_warnings': False,
+        'cookiesfrombrowser': ('chrome',),
+        'extractor_args': {'youtube': {'player_client': ['android']}},
+        'http_headers': {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': 'en-us,en;q=0.5',
+            'Sec-Fetch-Mode': 'navigate'
+        },
+        'progress_hooks': [lambda d: print(f"⏳ {d['_percent_str']} of {d.get('_total_bytes_str', 'Unknown size')}") if d['status'] == 'downloading' else None]
     }
 
-    if file_format == 'mp3':
-        ydl_opts['postprocessors'] = [{
-            'key': 'FFmpegExtractAudio',
-            'preferredcodec': 'mp3',
-            'preferredquality': '192'
-        }]
-
     try:
         with yt_dlp.YoutubeDL(ydl_opts) as ydl:
             ydl.download([url])
-        # AUTOMATICALLY OPEN DOWNLOAD FOLDER AFTER YOUTUBE DOWNLOAD IS COMPLETE
-        open_download_folder(download_dir)
-    except yt_dlp.utils.DownloadError as e:
-        print(f"Error during YouTube download: {e}")
+        print("\n✅ Download completed successfully!")
+        return True
     except Exception as e:
-        print(f"Unexpected error: {e}")
+        print(f"\n❌ ERROR: {str(e)}")
+        return False
 
 
 # FUNCTION TO LIST AVAILABLE FORMATS FOR A YOUTUBE VIDEO

autotools/password/__init__.py

@@ -0,0 +1 @@
+

autotools/password/core.py

@@ -0,0 +1,102 @@
+import string
+import random
+import secrets
+import base64
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+def generate_password(length=12, use_uppercase=True, use_numbers=True, use_special=True, 
+                     min_special=1, min_numbers=1):
+    """Generate a secure random password with specified requirements."""
+
+    # DEFINE CHARACTER SETS
+    lowercase = string.ascii_lowercase
+    uppercase = string.ascii_uppercase if use_uppercase else ''
+    numbers = string.digits if use_numbers else ''
+    special = "!@#$%^&*()_+-=[]{}|;:,.<>?" if use_special else ''
+    
+    #  COMBINE ALL ALLOWED CHARACTERS
+    all_chars = lowercase + uppercase + numbers + special
+    
+    # ENSURE MINIMUM REQUIREMENTS
+    password = []
+    if use_uppercase:
+        password.append(secrets.choice(uppercase))
+    if use_numbers:
+        password.extend(secrets.choice(numbers) for _ in range(min_numbers))
+    if use_special:
+        password.extend(secrets.choice(special) for _ in range(min_special))
+    
+    # FILL REST OF PASSWORD
+    remaining_length = length - len(password)
+    password.extend(secrets.choice(all_chars) for _ in range(remaining_length))
+    
+    random.shuffle(password) # SHUFFLE PASSWORD
+    
+    return ''.join(password) ## RETURN PASSWORD
+
+def generate_encryption_key(password=None, salt=None):
+    """Generate a strong encryption key using Fernet."""
+    if not password:
+        # GENERATE A RANDOM KEY
+        return Fernet.generate_key()
+    
+    if not salt:
+        salt = secrets.token_bytes(16)
+    
+    # DERIVE A KEY FROM PASSWORD AND SALT
+    kdf = PBKDF2HMAC(
+        algorithm=hashes.SHA256(),
+        length=32,
+        salt=salt,
+        iterations=100000,
+    )
+    
+    # ENCODE KEY IN BASE64
+    key = base64.urlsafe_b64encode(kdf.derive(password.encode()))
+    return key, salt
+
+def analyze_password_strength(password):
+    """Analyze password strength and return a score and suggestions."""
+    score = 0
+    suggestions = []
+    
+    # CHECK LENGTH
+    if len(password) >= 12:
+        score += 2
+    elif len(password) >= 8:
+        score += 1
+    else:
+        suggestions.append("Password should be at least 8 characters long")
+    
+    # CHECK FOR CHARACTER TYPES
+    if any(c.isupper() for c in password):
+        score += 1
+    else:
+        suggestions.append("Add uppercase letters")
+    
+    # CHECK FOR CHARACTER TYPES
+    if any(c.islower() for c in password):
+        score += 1
+    else:
+        suggestions.append("Add lowercase letters")
+    
+    # CHECK FOR CHARACTER TYPES
+    if any(c.isdigit() for c in password):
+        score += 1
+    else:
+        suggestions.append("Add numbers")
+    
+    # CHECK FOR CHARACTER TYPES
+    if any(c in "!@#$%^&*()_+-=[]{}|;:,.<>?" for c in password):
+        score += 1
+    else:
+        suggestions.append("Add special characters")
+    
+    # RETURN SCORE AND SUGGESTIONS
+    return {
+        'score': score,
+        'strength': ['Very Weak', 'Weak', 'Medium', 'Strong', 'Very Strong'][min(score, 4)],
+        'suggestions': suggestions
+    }

Open_AutoTools-0.0.1.dist-info/METADATA

@@ -1,31 +0,0 @@
-Metadata-Version: 2.1
-Name: Open-AutoTools
-Version: 0.0.1
-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.7
-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: nltk==3.8.1
-Requires-Dist: platformdirs==4.2.0
-Requires-Dist: pycryptodomex==3.20.0
-Requires-Dist: pyperclip==1.9.0
-Requires-Dist: python-dotenv==1.0.1
-Requires-Dist: python-Levenshtein==0.25.0
-Requires-Dist: rapidfuzz==3.6.1
-Requires-Dist: regex==2023.12.25
-Requires-Dist: requests==2.32.3
-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.8.6
-Requires-Dist: zipp==3.17.0
-

Open_AutoTools-0.0.1.dist-info/RECORD

@@ -1,16 +0,0 @@
-autotools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autotools/cli.py,sha256=a510Nq8u3xUA_AGkkEDZSvnZ7DN28wKbpoyShlhU10k,2485
-autotools/autocaps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autotools/autocaps/core.py,sha256=NnOacVp0kMoq__KHWi5UMcApSuq6Iyo5bFxN40dRw7U,253
-autotools/autocorrect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autotools/autocorrect/core.py,sha256=S0Sp1wAfuv2k9J9pvvuSJ4vpD_rNn08kcG-jMiXMxlw,1168
-autotools/autotranslate/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autotools/autotranslate/core.py,sha256=qh_0marZKojHCMSuqJbeRZT5CyDwOxknWIygB-rkSXU,1159
-autotools/downloader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-autotools/downloader/core.py,sha256=Meyq0ABpHGziaFYXNYVfoewfZAONc-3stvPOzEzaBm0,6988
-Open_AutoTools-0.0.1.dist-info/LICENSE,sha256=SpbSRxNWos2l0-geleCa6d0L9G_bOsZRkY4rB9OduJ0,1069
-Open_AutoTools-0.0.1.dist-info/METADATA,sha256=PSTWsQQkC-lJVfHg1cZMpHICrUG6eJulQAJHm_OF_K4,925
-Open_AutoTools-0.0.1.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-Open_AutoTools-0.0.1.dist-info/entry_points.txt,sha256=xpRGvz30QlP0wB7R64UdNzgwOVH7yQMkgtQX7GwwqOk,214
-Open_AutoTools-0.0.1.dist-info/top_level.txt,sha256=x5ZRvdQw7DQnVmR0YDqVSAuuS94KTHDmk6uIeW7YOPw,10
-Open_AutoTools-0.0.1.dist-info/RECORD,,

autotools/autocorrect/core.py

@@ -1,34 +0,0 @@
-import requests
-import os
-import pyperclip
-
-# AUTOCORRECT FUNCTION DEFINITION
-def autocorrect_text(text, language="en"):
-    # API CALL TO REWRITER API
-    url = "https://rewriter-paraphraser-text-changer-multi-language.p.rapidapi.com/rewrite"
-
-    # PAYLOAD AND HEADERS FOR API CALL
-    payload = {
-        "language": language,
-        "strength": 3, # STRENGTH OF REWRITING (STRENGTH 3 IS RECOMMENDED FOR BETTER RESULTS)
-        "text": text
-    }
-    headers = {
-        "content-type": "application/json",
-        "X-RapidAPI-Key": os.getenv('RAPIDAPI_API_KEY'), # API KEY FROM ENVIRONMENT VARIABLE
-        "X-RapidAPI-Host": "rewriter-paraphraser-text-changer-multi-language.p.rapidapi.com"
-    }
-
-    # RESPONSE FROM API CALL
-    response = requests.post(url, json=payload, headers=headers)
-
-    # RETURN REWRITTEN TEXT IF SUCCESSFUL ELSE RETURN ERROR MESSAGE
-    if response.status_code == 200:
-        corrected_text = response.json()['rewrite']
-
-        # COPY CORRECTED TEXT TO CLIPBOARD
-        pyperclip.copy(corrected_text)
-
-        return corrected_text
-    else:
-        return "ERROR: CORRECTION FAILED - " + response.text + str(response.status_code)