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

autotools/autocaps/commands.py

@@ -3,15 +3,11 @@ from .core import autocaps_transform
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
 
+# CLI COMMAND TO TRANSFORM TEXT TO UPPERCASE
 @click.command()
 @click.argument('text', nargs=-1)
 def autocaps(text):
-    """Convert text to UPPERCASE."""
-    with LoadingAnimation():
-        result = autocaps_transform(" ".join(text))
+    with LoadingAnimation(): result = autocaps_transform(" ".join(text))
     click.echo(result)
-    
-    # UPDATE CHECK AT THE END
     update_msg = check_for_updates()
-    if update_msg:
-        click.echo(update_msg) 
+    if update_msg: click.echo(update_msg) 

autotools/autocaps/core.py

@@ -1,7 +1,8 @@
 import pyperclip
 
-# AUTOCAPS CORE FUNCTION DEFINITION
+# TRANSFORMS TEXT TO UPPERCASE AND COPIES IT TO CLIPBOARD
 def autocaps_transform(text):
-    transformed_text = text.upper()  # TRANSFORM TEXT TO UPPERCASE
-    pyperclip.copy(transformed_text)  # COPY TRANSFORMED TEXT TO CLIPBOARD
-    return transformed_text
+    transformed_text = text.upper()
+    try: pyperclip.copy(transformed_text)
+    except pyperclip.PyperclipException: pass 
+    return transformed_text

autotools/autoip/commands.py

@@ -3,6 +3,7 @@ from .core import run
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
 
+# CLI COMMAND TO DISPLAY NETWORK INFORMATION AND RUN DIAGNOSTICS
 @click.command()
 @click.option('--test', '-t', is_flag=True, help='Run connectivity tests')
 @click.option('--speed', '-s', is_flag=True, help='Run internet speed test')
@@ -13,17 +14,11 @@ from ..utils.updates import check_for_updates
 @click.option('--location', '-l', is_flag=True, help='Show IP location info')
 @click.option('--no-ip', '-n', is_flag=True, help='Hide IP addresses')
 def autoip(test, speed, monitor, interval, ports, dns, location, no_ip):
-    """Display network information and diagnostics.
-    
-    Shows local and public IP addresses, runs network diagnostics,
-    performs speed tests, monitors traffic with custom intervals,
-    checks ports, displays DNS information and provides geolocation data."""
     with LoadingAnimation():
-        output = run(test=test, speed=speed, monitor=monitor, interval=interval,
-                    ports=ports, dns=dns, location=location, no_ip=no_ip)
+        output = run(
+            test=test, speed=speed, monitor=monitor, interval=interval,
+            ports=ports, dns=dns, location=location, no_ip=no_ip
+        )
     click.echo(output)
-    
-    # UPDATE CHECK AT THE END
     update_msg = check_for_updates()
-    if update_msg:
-        click.echo(update_msg) 
+    if update_msg: click.echo(update_msg) 

autotools/autoip/core.py

@@ -7,71 +7,61 @@ import time
 import speedtest
 import psutil
 
+# EXTRACTS IPV4 ADDRESSES FROM INTERFACE ADDRESSES
+def _extract_ipv4_addresses(addrs):
+    ipv4_list = []
+    if netifaces.AF_INET in addrs:
+        for addr in addrs[netifaces.AF_INET]:
+            if 'addr' in addr and not addr['addr'].startswith('127.'):
+                ipv4_list.append(addr['addr'])
+    return ipv4_list
+
+# EXTRACTS IPV6 ADDRESSES FROM INTERFACE ADDRESSES
+def _extract_ipv6_addresses(addrs):
+    ipv6_list = []
+    if netifaces.AF_INET6 in addrs:
+        for addr in addrs[netifaces.AF_INET6]:
+            if 'addr' in addr and not addr['addr'].startswith('fe80:'):
+                clean_addr = addr['addr'].split('%')[0]
+                ipv6_list.append(clean_addr)
+    return ipv6_list
+
+# RETRIEVES ALL LOCAL IP ADDRESSES (IPV4 AND IPV6) FROM NETWORK INTERFACES
 def get_local_ips():
-    """GET LOCAL IPS"""
-    ips = {'ipv4': [], 'ipv6': []} # INITIALIZE WITH EMPTY LISTS
-    
-    # GET LOCAL IPS
+    ips = {'ipv4': [], 'ipv6': []}
+
     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)
-    
+        ips['ipv4'].extend(_extract_ipv4_addresses(addrs))
+        ips['ipv6'].extend(_extract_ipv6_addresses(addrs))
+
     return ips
 
+# RETRIEVES PUBLIC IP ADDRESSES (IPV4 AND IPV6) FROM EXTERNAL SERVICES
 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
+    ips = {'ipv4': None, 'ipv6': None}
+    ipv4_services = ['https://api.ipify.org', 'https://ipv4.icanhazip.com', 'https://v4.ident.me']
+    ipv6_services = ['https://api6.ipify.org', 'https://ipv6.icanhazip.com', 'https://v6.ident.me']
+
     for service in ipv4_services:
         try:
             ips['ipv4'] = requests.get(service, timeout=2).text.strip()
             if ips['ipv4']: break
-        except:
+        except (requests.RequestException, requests.Timeout, requests.ConnectionError):
             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:
+        except (requests.RequestException, requests.Timeout, requests.ConnectionError):
             continue
 
     return ips
 
-# TEST CONNECTIVITY TO POPULAR SERVICES
+# TESTS NETWORK CONNECTIVITY TO COMMON HOSTS
 def test_connectivity():
-    """TEST CONNECTIVITY TO POPULAR SERVICES"""
-    
-    # TEST HOSTS
+    results = []
     test_hosts = {
         'Google DNS': ('8.8.8.8', 53),
         'CloudFlare DNS': ('1.1.1.1', 53),
@@ -79,10 +69,7 @@ def test_connectivity():
         '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()
@@ -90,31 +77,25 @@ def test_connectivity():
             latency = round((time.time() - start) * 1000, 2)
             s.close()
             results.append((name, True, latency))
-        except:
+        except OSError:
             results.append((name, False, None))
-    
+
     return results
 
-# RUN INTERNET SPEED TEST
+# RUNS INTERNET SPEED TEST AND DISPLAYS RESULTS INCLUDING PING
 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
+        download_speed = st.download() / 1_000_000 # CONVERT TO MBPS
+
         print("Testing upload speed...")
-        upload_speed = st.upload() / 1_000_000  # Convert to Mbps
-        
-        # GET PING
+        upload_speed = st.upload() / 1_000_000 # CONVERT TO MBPS
+
+        print("Testing ping...")
         ping = st.results.ping
         
         print("\nSpeed Test Results:")
@@ -127,185 +108,155 @@ def run_speedtest():
         print(f"\nSpeed test failed: {str(e)}")
         return False
 
-# GET PUBLIC IP ADDRESS USING IPIFY API
+# GETS PUBLIC IP ADDRESS USING EXTERNAL API SERVICES
 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:
+        except (requests.RequestException, KeyError, ValueError):
             return None
 
-# GET LOCAL IP ADDRESS
+# GETS LOCAL IP ADDRESS OF DEFAULT NETWORK INTERFACE
 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
+    except (KeyError, IndexError, OSError):
         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:
+        except OSError:
             return None
 
-# GET IP INFORMATION USING IPAPI.CO
+# RETRIEVES DETAILED INFORMATION ABOUT AN IP ADDRESS
 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']}")
-            
+
+        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 = []
-    
-    # GET IP ADDRESSES IF NOT HIDDEN
-    if not no_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:
-            output.append("IPv4: Not available")
-            
-        if local_ips['ipv6']:
-            for ip in local_ips['ipv6']:
-                output.append(f"IPv6: {ip}")
-        else:
-            output.append("IPv6: Not available")
+# DISPLAYS LOCAL AND PUBLIC IP ADDRESSES
+def _display_ip_addresses(output):
+    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:
+        output.append("IPv4: 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:
-        output.append("\nConnectivity Tests:")
-        results = test_connectivity()
-        for name, success, latency in results:
-            status = f"✓ {latency}ms" if success else "✗ Failed"
-            output.append(f"{name:<15} {status}")
+    if local_ips['ipv6']:
+        for ip in local_ips['ipv6']: output.append(f"IPv6: {ip}")
+    else:
+        output.append("IPv6: Not available")
     
-    # RUN SPEED TEST IF REQUESTED
+    output.append("\nPublic IPs:")
+    output.append(f"IPv4: {public_ips['ipv4'] or 'Not available'}")
+    output.append(f"IPv6: {public_ips['ipv6'] or 'Not available'}")
+
+# DISPLAYS CONNECTIVITY TEST RESULTS
+def _display_connectivity_tests(output):
+    output.append("\nConnectivity Tests:")
+    results = test_connectivity()
+    for name, success, latency in results:
+        status = f"✓ {latency}ms" if success else "✗ Failed"
+        output.append(f"{name:<15} {status}")
+
+# DISPLAYS LOCATION INFORMATION
+def _display_location_info(output):
+    try:
+        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)}")
+
+# DISPLAYS DNS SERVER INFORMATION
+def _display_dns_servers(output):
+    output.append("\nDNS Servers:")
+    try:
+        with open('/etc/resolv.conf', 'r') as f:
+            for line in f:
+                if 'nameserver' in line: output.append(f"DNS: {line.split()[1]}")
+    except OSError:
+        output.append("Could not read DNS configuration")
+
+# CHECKS AND DISPLAYS COMMON PORTS STATUS
+def _display_ports_status(output):
+    common_ports = [80, 443, 22, 21, 25, 3306]
+    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"
+        output.append(f"Port {port}: {status}")
+        sock.close()
+
+# MONITORS NETWORK TRAFFIC
+def _monitor_network_traffic(output, interval):
+    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(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 * interval)
+            download_speed = (bytes_recv - prev_bytes_recv) / (1024 * interval)
+            
+            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:
+        output.append("\nMonitoring stopped")
+
+# MAIN FUNCTION TO RUN NETWORK DIAGNOSTICS AND DISPLAY RESULTS
+def run(test=False, speed=False, monitor=False, interval=1, ports=False, dns=False, location=False, no_ip=False):
+    output = []
+
+    if not no_ip: _display_ip_addresses(output)
+    if test: _display_connectivity_tests(output)
+    if location: _display_location_info(output)
+    if dns: _display_dns_servers(output)
+    if ports: _display_ports_status(output)
+    if monitor: _monitor_network_traffic(output, interval)
+
     if speed:
         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 = 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:
-        output.append("\nDNS Servers:")
-        try:
-            with open('/etc/resolv.conf', 'r') as f:
-                for line in f:
-                    if 'nameserver' in line:
-                        output.append(f"DNS: {line.split()[1]}")
-        except:
-            output.append("Could not read DNS configuration")
-
-    # CHECK COMMON PORTS IF REQUESTED
-    if ports:
-        common_ports = [80, 443, 22, 21, 25, 3306]
-        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"
-            output.append(f"Port {port}: {status}")
-            sock.close()
-
-    # MONITOR NETWORK TRAFFIC IF REQUESTED
-    if monitor:
-        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(interval)
-                bytes_sent = psutil.net_io_counters().bytes_sent
-                bytes_recv = psutil.net_io_counters().bytes_recv
-                
-                # CALCULATE UPLOAD AND DOWNLOAD SPEEDS
-                upload_speed = (bytes_sent - prev_bytes_sent) / (1024 * interval)
-                download_speed = (bytes_recv - prev_bytes_recv) / (1024 * interval)
-                
-                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:
-            output.append("\nMonitoring stopped")
-    
+        if run_speedtest(): output.append("Speed test completed successfully")
+        else: output.append("Speed test failed")
+
     return "\n".join(output) 

autotools/autolower/commands.py

@@ -3,15 +3,11 @@ from .core import autolower_transform
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
 
+# CLI COMMAND TO TRANSFORM TEXT TO LOWERCASE
 @click.command()
 @click.argument('text', nargs=-1)
 def autolower(text):
-    """Convert text to lowercase."""
-    with LoadingAnimation():
-        result = autolower_transform(" ".join(text))
+    with LoadingAnimation(): result = autolower_transform(" ".join(text))
     click.echo(result)
-    
-    # UPDATE CHECK AT THE END
     update_msg = check_for_updates()
-    if update_msg:
-        click.echo(update_msg) 
+    if update_msg: click.echo(update_msg) 

autotools/autolower/core.py

@@ -1,7 +1,8 @@
 import pyperclip
 
-# AUTOLOWERCASE CORE FUNCTION DEFINITION
+# TRANSFORMS TEXT TO LOWERCASE AND COPIES IT TO CLIPBOARD
 def autolower_transform(text):
-    transformed_text = text.lower()  # TRANSFORM TEXT TO LOWERCASE
-    pyperclip.copy(transformed_text)  # COPY TRANSFORMED TEXT TO CLIPBOARD
+    transformed_text = text.lower()
+    try: pyperclip.copy(transformed_text)
+    except pyperclip.PyperclipException: pass
     return transformed_text

autotools/autopassword/commands.py

@@ -1,9 +1,10 @@
 import click
 import base64
-from .core import generate_password, generate_encryption_key, analyze_password_strength
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
+from .core import generate_password, generate_encryption_key, analyze_password_strength
 
+# CLI COMMAND TO GENERATE PASSWORDS OR ENCRYPTION KEYS
 @click.command()
 @click.option('--length', '-l', default=12, help='Password length (default: 12)')
 @click.option('--no-uppercase', '-u', is_flag=True, help='Exclude uppercase letters')
@@ -14,48 +15,44 @@ from ..utils.updates import check_for_updates
 @click.option('--analyze', '-a', is_flag=True, help='Analyze password strength')
 @click.option('--gen-key', '-g', is_flag=True, help='Generate encryption key')
 @click.option('--password-key', '-p', 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."""
-    
+def autopassword(length, no_uppercase, no_numbers, no_special, min_special, min_numbers, analyze, gen_key, password_key):    
+    # DISPLAYS PASSWORD STRENGTH ANALYSIS RESULTS
     def show_analysis(text, prefix=""):
-        """Helper function to show password/key analysis"""
-        if analyze:
-            with LoadingAnimation():
-                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 not analyze: return
+        with LoadingAnimation(): 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}")
+
+    # GENERATES ENCRYPTION KEY IF GEN_KEY FLAG IS SET
     if gen_key:
-        with LoadingAnimation():
-            key = generate_encryption_key()
+        with LoadingAnimation(): key = generate_encryption_key()
         key_str = key.decode()
         click.echo(f"Encryption Key: {key_str}")
-        if analyze:
-            show_analysis(key_str, "Key ")
+        if analyze: show_analysis(key_str, "Key ")
         return
     
-    # GENERATE KEY FROM PASSWORD
+    # GENERATES ENCRYPTION KEY FROM PASSWORD IF PASSWORD_KEY FLAG IS SET
     if password_key:
-        with LoadingAnimation():
-            key, salt = generate_encryption_key(password_key)
+        with LoadingAnimation(): 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
+
+    # GENERATES PASSWORD IF NO OTHER OPTIONS ARE SET
     with LoadingAnimation():
         password = generate_password(
             length=length,
@@ -65,12 +62,9 @@ def autopassword(length, no_uppercase, no_numbers, no_special,
             min_special=min_special,
             min_numbers=min_numbers,
         )
-    
-    # SHOW PASSWORD
+
     click.echo(f"Generated Password: {password}")
     show_analysis(password, "Password ")
-    
-    # UPDATE CHECK AT THE END
+
     update_msg = check_for_updates()
-    if update_msg:
-        click.echo(update_msg) 
+    if update_msg: click.echo(update_msg)