Open-AutoTools 0.0.4rc1__py3-none-any.whl → 0.0.5__py3-none-any.whl

autotools/autocaps/commands.py

@@ -3,10 +3,31 @@ from .core import autocaps_transform
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
 
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Text'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'basic', 'args': ['test', 'with', 'multiple', 'words']},
+    {'name': 'special', 'args': ['special', 'chars:', '!@#$%^&*()']},
+    {'name': 'mixed', 'args': ['123', 'mixed', 'WITH', 'lowercase', '456']},
+    {'name': 'unicode', 'args': ['áccênts', 'ànd', 'émojis', '🚀', '⭐']},
+]
+
 # CLI COMMAND TO TRANSFORM TEXT TO UPPERCASE
 @click.command()
 @click.argument('text', nargs=-1)
 def autocaps(text):
+    """
+        TRANSFORMS TEXT TO UPPERCASE.
+
+        \b
+        EXAMPLES:
+            autocaps hello world
+            autocaps "this is a test"
+            echo "text" | autocaps
+    """
+
     with LoadingAnimation(): result = autocaps_transform(" ".join(text))
     click.echo(result)
     update_msg = check_for_updates()

autotools/autocolor/commands.py

@@ -0,0 +1,60 @@
+import click
+from .core import autocolor_convert
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Color'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'hex-default', 'args': ['#FF5733']},
+    {'name': 'hex-rgb', 'args': ['#FF5733', '--format', 'rgb']},
+    {'name': 'rgb-hsl', 'args': ['rgb(255,87,51)', '--format', 'hsl']},
+    {'name': 'hsl-rgba', 'args': ['hsl(9,100%,60%)', '--format', 'rgba']},
+]
+
+# CLI COMMAND TO CONVERT COLOR CODES BETWEEN FORMATS
+@click.command()
+@click.argument('color', nargs=-1)
+@click.option('--format', '-f', 'output_format', 
+              type=click.Choice(['hex', 'rgb', 'rgba', 'hsl', 'hsla'], case_sensitive=False),
+              default='hex', help='OUTPUT FORMAT (hex, rgb, rgba, hsl, hsla)')
+def autocolor(color, output_format):
+    """
+        CONVERTS COLOR CODES BETWEEN DIFFERENT FORMATS.
+
+        \b
+        SUPPORTS INPUT FORMATS:
+            - HEX: #RRGGBB, #RRGGBBAA, #RGB
+            - RGB: rgb(r, g, b)
+            - RGBA: rgba(r, g, b, a)
+            - HSL: hsl(h, s%, l%)
+            - HSLA: hsla(h, s%, l%, a)
+
+        \b
+        EXAMPLES:
+            autocolor "#FF5733"
+            autocolor "rgb(255, 87, 51)" --format hsl
+            autocolor "hsl(9, 100%, 60%)" --format hex
+            autocolor "#F73" --format rgba
+    """
+
+    if not color:
+        click.echo(click.style("ERROR: COLOR ARGUMENT IS REQUIRED", fg='red'), err=True)
+        click.echo(click.get_current_context().get_help())
+        return
+
+    color_input = " ".join(color)
+    
+    try:
+        with LoadingAnimation(): result = autocolor_convert(color_input, output_format)
+        click.echo(result)
+        update_msg = check_for_updates()
+        if update_msg: click.echo(update_msg)
+    except ValueError as e:
+        click.echo(click.style(f"ERROR: {str(e)}", fg='red'), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(click.style(f"UNEXPECTED ERROR: {str(e)}", fg='red'), err=True)
+        raise click.Abort()

autotools/autocolor/core.py

@@ -0,0 +1,99 @@
+import re
+import colorsys
+import pyperclip
+
+# CONVERTS HEX COLOR TO RGB TUPLE
+def _hex_to_rgb(hex_color):
+    hex_color = hex_color.lstrip('#')
+    if len(hex_color) == 3:
+        hex_color = ''.join([c * 2 for c in hex_color])
+    if len(hex_color) == 6:
+        return tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+    elif len(hex_color) == 8:
+        rgb = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
+        alpha = int(hex_color[6:8], 16) / 255.0
+        return (*rgb, alpha)
+    raise ValueError(f"INVALID HEX COLOR: {hex_color}")
+
+# CONVERTS RGB TUPLE TO HEX
+def _rgb_to_hex(r, g, b, alpha=None):
+    hex_color = f"#{r:02x}{g:02x}{b:02x}"
+    if alpha is not None: hex_color += f"{int(alpha * 255):02x}"
+    return hex_color.upper()
+
+# PARSES RGB/RGBA STRING
+def _parse_rgb(rgb_str):
+    match = re.match(r'rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)', rgb_str.lower())
+    if not match:
+        raise ValueError(f"INVALID RGB/RGBA FORMAT: {rgb_str}")
+    r, g, b = int(match.group(1)), int(match.group(2)), int(match.group(3))
+    alpha = float(match.group(4)) if match.group(4) else None
+    if alpha is not None and alpha > 1:
+        alpha = alpha / 255.0
+    return (r, g, b, alpha) if alpha is not None else (r, g, b)
+
+# PARSES HSL/HSLA STRING
+def _parse_hsl(hsl_str):
+    match = re.match(r'hsla?\((\d+),\s*(\d+)%,\s*(\d+)%(?:,\s*([\d.]+))?\)', hsl_str.lower())
+    if not match:
+        raise ValueError(f"INVALID HSL/HSLA FORMAT: {hsl_str}")
+    h = int(match.group(1)) / 360.0
+    s = int(match.group(2)) / 100.0
+    l = int(match.group(3)) / 100.0
+    alpha = float(match.group(4)) if match.group(4) else None
+    return (h, s, l, alpha) if alpha is not None else (h, s, l)
+
+# PARSES INPUT COLOR AND RETURNS RGB VALUES WITH ALPHA
+def _parse_color_input(color_input):
+    if color_input.startswith('#'):
+        rgb_result = _hex_to_rgb(color_input)
+        return rgb_result if len(rgb_result) == 4 else (*rgb_result, None)
+    elif color_input.startswith('rgb'):
+        rgb_result = _parse_rgb(color_input)
+        return rgb_result if len(rgb_result) == 4 else (*rgb_result, None)
+    elif color_input.startswith('hsl'):
+        hsl_result = _parse_hsl(color_input)
+        if len(hsl_result) == 4:
+            h, s, l, alpha = hsl_result
+        else:
+            h, s, l = hsl_result
+            alpha = None
+        r, g, b = [int(c * 255) for c in colorsys.hls_to_rgb(h, l, s)]
+        return (r, g, b, alpha)
+    raise ValueError(f"UNSUPPORTED COLOR FORMAT: {color_input}")
+
+# CONVERTS RGB TO HSL VALUES
+def _rgb_to_hsl_values(r, g, b):
+    h, l, s = colorsys.rgb_to_hls(r / 255.0, g / 255.0, b / 255.0)
+    return (int(h * 360), int(s * 100), int(l * 100))
+
+# FORMATS OUTPUT COLOR BASED ON FORMAT TYPE
+def _format_output(r, g, b, alpha, output_format):
+    if output_format == 'hex':
+        return _rgb_to_hex(r, g, b, alpha)
+    elif output_format == 'rgb':
+        return f"rgb({r}, {g}, {b})"
+    elif output_format == 'rgba':
+        alpha = alpha if alpha is not None else 1.0
+        return f"rgba({r}, {g}, {b}, {alpha:.2f})"
+    elif output_format == 'hsl':
+        h, s, l = _rgb_to_hsl_values(r, g, b)
+        return f"hsl({h}, {s}%, {l}%)"
+    elif output_format == 'hsla':
+        alpha = alpha if alpha is not None else 1.0
+        h, s, l = _rgb_to_hsl_values(r, g, b)
+        return f"hsla({h}, {s}%, {l}%, {alpha:.2f})"
+    raise ValueError(f"UNSUPPORTED OUTPUT FORMAT: {output_format}")
+
+# CONVERTS COLOR CODE TO DIFFERENT FORMATS
+def autocolor_convert(color_input, output_format='hex'):
+    color_input = color_input.strip()
+    output_format = output_format.lower()
+    
+    r, g, b, alpha = _parse_color_input(color_input)
+    result = _format_output(r, g, b, alpha, output_format)
+
+    try: pyperclip.copy(result)
+    except pyperclip.PyperclipException: pass
+    
+    return result

autotools/autoconvert/commands.py

@@ -0,0 +1,79 @@
+import os
+import click
+from pathlib import Path
+from .core import convert_file, detect_file_type
+from ..utils.loading import LoadingAnimation
+from ..utils.updates import check_for_updates
+
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Files'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'md-json', 'args': ['README.md', '/tmp/autoconvert-smoke.json']},
+]
+
+# CLI COMMAND TO CONVERT FILES BETWEEN DIFFERENT FORMATS
+@click.command()
+@click.argument('input_file', type=click.Path())
+@click.argument('output_file', type=click.Path())
+@click.option('--input-type', '-i', help='FORCE INPUT FILE TYPE (text/image/audio/video)')
+@click.option('--output-type', '-o', help='FORCE OUTPUT FILE TYPE (text/image/audio/video)')
+@click.option('--format', '-f', help='OUTPUT FORMAT (OVERRIDES OUTPUT FILE EXTENSION)')
+def autoconvert(input_file, output_file, input_type, output_type, format):
+    """
+        CONVERTS FILES BETWEEN DIFFERENT FORMATS.
+
+        \b
+        SUPPORTS:
+            - TEXT: txt, md, markdown, json, xml, html, htm, csv
+            - IMAGES: jpg, jpeg, png, gif, webp, bmp, tiff, tif, ico, svg
+            - AUDIO: mp3, wav, ogg, flac, aac, m4a, wma, opus
+            - VIDEO: mp4, avi, mov, mkv, wmv, flv, webm, m4v
+
+        \b
+        EXAMPLES:
+            autoconvert input.txt output.json
+            autoconvert image.jpg image.png
+            autoconvert audio.mp3 audio.wav
+            autoconvert video.mp4 video.avi
+    """
+
+    # TRY TO CONVERT FILE
+    # - CHECK IF INPUT FILE EXISTS, OTHERWISE FAIL
+    # - HANDLE --FORMAT: UPDATE OUTPUT NAME/EXT, DETECT OUTPUT TYPE IF UNSET
+    # - MAKE OUTPUT DIRECTORY IF IT DOESN'T EXIST, RUN CONVERT WITH LOADING SPINNER
+    # - SHOW RESULT, PRINT UPDATE NOTICE
+    try:
+        if not os.path.exists(input_file):
+            raise FileNotFoundError(f"INPUT FILE NOT FOUND: {input_file}")
+
+        if format:
+            output_path = Path(output_file)
+            if not output_file.endswith(f'.{format}'): output_file = str(output_path.with_suffix(f'.{format}'))
+            if output_type is None: output_type = detect_file_type(output_file)
+
+        output_path = Path(output_file)
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        with LoadingAnimation(): success, message = convert_file(input_file, output_file, input_type, output_type)
+        
+        if success:
+            click.echo(click.style(f"✓ {message}", fg='green'))
+            click.echo(click.style(f"OUTPUT: {output_file}", fg='blue'))
+        else:
+            click.echo(click.style(f"✗ {message}", fg='red'), err=True)
+            raise click.Abort()
+        
+        update_msg = check_for_updates()
+        if update_msg: click.echo(update_msg)
+
+    except FileNotFoundError as e:
+        click.echo(click.style(f"✗ FILE NOT FOUND: {str(e)}", fg='red'), err=True)
+        raise click.Abort()
+    except ImportError as e:
+        click.echo(click.style(f"✗ {str(e)}", fg='red'), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(click.style(f"✗ ERROR: {str(e)}", fg='red'), err=True)
+        raise click.Abort()

autotools/autoconvert/conversion/convert_audio.py

@@ -0,0 +1,24 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+# CONVERTS AUDIO BETWEEN FORMATS
+def convert_audio(input_path: str, output_path: str, output_format: Optional[str] = None) -> bool:
+    try:
+        from pydub import AudioSegment
+
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"INPUT FILE NOT FOUND: {input_path}")
+        if output_format is None: output_format = Path(output_path).suffix[1:].lower()
+
+        audio = AudioSegment.from_file(input_path)
+        audio.export(output_path, format=output_format)
+
+        return True
+
+    except ImportError:
+        raise ImportError("PYDUB is required for audio conversion. Install with: pip install pydub. Also install FFMPEG.")
+    except (OSError, ValueError, IOError) as e:
+        raise RuntimeError(f"AUDIO CONVERSION FAILED: {str(e)}")
+    except Exception as e:
+        raise RuntimeError(f"AUDIO CONVERSION FAILED: {str(e)}")

autotools/autoconvert/conversion/convert_image.py

@@ -0,0 +1,29 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+# CONVERTS IMAGE BETWEEN FORMATS
+def convert_image(input_path: str, output_path: str, output_format: Optional[str] = None) -> bool:
+    try:
+        from PIL import Image
+
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"INPUT FILE NOT FOUND: {input_path}")
+        if output_format is None: output_format = Path(output_path).suffix[1:].upper()
+
+        with Image.open(input_path) as img:
+            if output_format in ['JPG', 'JPEG'] and img.mode in ('RGBA', 'LA', 'P'):
+                rgb_img = Image.new('RGB', img.size, (255, 255, 255))
+                if img.mode == 'P': img = img.convert('RGBA')
+                rgb_img.paste(img, mask=img.split()[-1] if img.mode in ('RGBA', 'LA') else None)
+                img = rgb_img
+            
+            img.save(output_path, format=output_format)
+        return True
+
+    except ImportError:
+        raise ImportError("PILLOW (PIL) is required for image conversion. Install with: pip install Pillow")
+    except (OSError, ValueError, IOError) as e:
+        raise RuntimeError(f"IMAGE CONVERSION FAILED: {str(e)}")
+    except Exception as e:
+        raise RuntimeError(f"IMAGE CONVERSION FAILED: {str(e)}")

autotools/autoconvert/conversion/convert_text.py

@@ -0,0 +1,101 @@
+import os
+import json
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Tuple
+
+# CONVERTS TEXT TO JSON FORMAT
+def text_to_json(text: str, indent: int = 2) -> str:
+    data = {"text": text}
+    return json.dumps(data, indent=indent, ensure_ascii=False)
+
+# CONVERTS TEXT TO XML FORMAT
+def text_to_xml(text: str, root_tag: str = "text") -> str:
+    root = ET.Element(root_tag)
+    root.text = text
+    return ET.tostring(root, encoding='unicode')
+
+# CONVERTS TEXT TO HTML FORMAT
+def text_to_html(text: str, title: str = "Document") -> str:
+    escaped_text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    return f"""<!DOCTYPE html>
+<html>
+<head>
+    <title>{title}</title>
+</head>
+<body>
+    <pre>{escaped_text}</pre>
+</body>
+</html>"""
+
+# CONVERTS TEXT TO MARKDOWN FORMAT
+def text_to_markdown(text: str) -> str:
+    return text
+
+# CONVERTS JSON TO TEXT
+def json_to_text(json_str: str) -> str:
+    try:
+        data = json.loads(json_str)
+        if isinstance(data, dict) and "text" in data: return str(data["text"])
+        return json.dumps(data, indent=2, ensure_ascii=False)
+    except json.JSONDecodeError:
+        return json_str
+
+# CONVERTS XML TO TEXT
+def xml_to_text(xml_str: str) -> str:
+    try:
+        root = ET.fromstring(xml_str)
+        text_parts = []
+
+        for elem in root.iter():
+            if elem.text and elem.text.strip(): text_parts.append(elem.text.strip())
+            if elem.tail and elem.tail.strip(): text_parts.append(elem.tail.strip())
+
+        result = " ".join(text_parts)
+        return result
+    except ET.ParseError:
+        return xml_str
+
+# CONVERTS TEXT FILE FROM ONE FORMAT TO ANOTHER
+def convert_text_file(input_path: str, output_path: str) -> Tuple[bool, str]:
+    if not os.path.exists(input_path):
+        raise FileNotFoundError(f"INPUT FILE NOT FOUND: {input_path}")
+    with open(input_path, 'r', encoding='utf-8') as f: content = f.read()
+    
+    input_ext = Path(input_path).suffix[1:].lower()
+    output_ext = Path(output_path).suffix[1:].lower()
+    
+    # CONVERT BASED ON INPUT FORMAT
+    if input_ext == 'json':
+        content = json_to_text(content)
+    elif input_ext == 'xml':
+        content = xml_to_text(content)
+    elif input_ext in ['html', 'htm']:
+        from html.parser import HTMLParser
+        class TextExtractor(HTMLParser):
+            def __init__(self):
+                super().__init__()
+                self.text = []
+            def handle_data(self, data):
+                self.text.append(data)
+        parser = TextExtractor()
+        parser.feed(content)
+        content = ' '.join(parser.text)
+    
+    # CONVERT TO OUTPUT FORMAT
+    if output_ext == 'json': content = text_to_json(content)
+    elif output_ext == 'xml': content = text_to_xml(content)
+    elif output_ext in ['html', 'htm']: content = text_to_html(content)
+    
+    # CREATE OUTPUT DIRECTORY IF IT DOESN'T EXIST
+    output_dir = os.path.dirname(output_path)
+    if output_dir and not os.path.exists(output_dir):
+        try: os.makedirs(output_dir, exist_ok=True)
+        except OSError as e: return False, f"CONVERSION FAILED: Cannot create output directory: {str(e)}"
+    
+    try:
+        with open(output_path, 'w', encoding='utf-8') as f: f.write(content)
+    except OSError as e:
+        return False, f"CONVERSION FAILED: Cannot write output file: {str(e)}"
+    
+    return True, f"TEXT CONVERTED FROM {input_ext.upper()} TO {output_ext.upper()}"

autotools/autoconvert/conversion/convert_video.py

@@ -0,0 +1,25 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+# CONVERTS VIDEO BETWEEN FORMATS
+def convert_video(input_path: str, output_path: str, output_format: Optional[str] = None) -> bool:
+    try:
+        from moviepy.editor import VideoFileClip
+        
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(f"INPUT FILE NOT FOUND: {input_path}")
+        if output_format is None: output_format = Path(output_path).suffix[1:].lower()
+
+        with VideoFileClip(input_path) as video: video.write_videofile(output_path, codec='libx264', audio_codec='aac')
+
+        return True
+
+    except ImportError:
+        raise ImportError("MOVIEPY IS REQUIRED FOR VIDEO CONVERSION. INSTALL WITH: pip install moviepy. ALSO INSTALL FFMPEG.")
+
+    except (OSError, ValueError, IOError) as e:
+        raise RuntimeError(f"VIDEO CONVERSION FAILED: {str(e)}")
+
+    except Exception as e:
+        raise RuntimeError(f"VIDEO CONVERSION FAILED: {str(e)}")

autotools/autoconvert/core.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+from typing import Optional, Tuple
+
+from .conversion.convert_text import convert_text_file
+from .conversion.convert_image import convert_image
+from .conversion.convert_audio import convert_audio
+from .conversion.convert_video import convert_video
+
+# DETECTS FILE TYPE AND CONVERTS ACCORDINGLY
+def detect_file_type(file_path: str) -> str:
+    ext = Path(file_path).suffix[1:].lower()
+
+    # TEXT FORMATS
+    text_formats = ['txt', 'md', 'markdown', 'json', 'xml', 'html', 'htm', 'csv']
+    if ext in text_formats: return 'text'
+
+    # IMAGE FORMATS
+    image_formats = ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp', 'tiff', 'tif', 'ico', 'svg']
+    if ext in image_formats: return 'image'
+
+    # AUDIO FORMATS
+    audio_formats = ['mp3', 'wav', 'ogg', 'flac', 'aac', 'm4a', 'wma', 'opus']
+    if ext in audio_formats: return 'audio'
+
+    # VIDEO FORMATS
+    video_formats = ['mp4', 'avi', 'mov', 'mkv', 'wmv', 'flv', 'webm', 'm4v']
+    if ext in video_formats: return 'video'
+    
+    return 'unknown'
+
+# CONVERTS FILE FROM ONE FORMAT TO ANOTHER
+def convert_file(input_path: str, output_path: str, input_type: Optional[str] = None, output_type: Optional[str] = None) -> Tuple[bool, str]:
+    try:
+        if input_type is None: input_type = detect_file_type(input_path)
+        if output_type is None: output_type = detect_file_type(output_path)
+        if input_type == 'text' and output_type == 'text': return convert_text_file(input_path, output_path)
+        
+        # HANDLE CONVERSIONS WITHIN THE SAME MEDIA TYPE
+        elif input_type == 'image' and output_type == 'image':
+            convert_image(input_path, output_path)
+            return True, "IMAGE CONVERTED SUCCESSFULLY"
+        elif input_type == 'audio' and output_type == 'audio':
+            convert_audio(input_path, output_path)
+            return True, "AUDIO CONVERTED SUCCESSFULLY"
+        elif input_type == 'video' and output_type == 'video':
+            convert_video(input_path, output_path)
+            return True, "VIDEO CONVERTED SUCCESSFULLY"
+        else:
+            return False, f"UNSUPPORTED CONVERSION: {input_type} TO {output_type}"
+    
+    except FileNotFoundError:
+        raise
+    except Exception as e:
+        return False, f"CONVERSION FAILED: {str(e)}"

autotools/autoip/commands.py

@@ -2,6 +2,18 @@ import click
 from .core import run
 from ..utils.loading import LoadingAnimation
 from ..utils.updates import check_for_updates
+from ..utils.text import safe_text, is_ci_environment, mask_sensitive_info
+
+# TOOL CATEGORY (USED BY 'autotools smoke')
+TOOL_CATEGORY = 'Network'
+
+# SMOKE TEST CASES (USED BY 'autotools smoke')
+SMOKE_TESTS = [
+    {'name': 'basic', 'args': ['--no-ip']},
+    {'name': 'connectivity', 'args': ['--test']},
+    {'name': 'dns', 'args': ['--dns']},
+    {'name': 'ports', 'args': ['--ports']},
+]
 
 # CLI COMMAND TO DISPLAY NETWORK INFORMATION AND RUN DIAGNOSTICS
 @click.command()
@@ -14,11 +26,37 @@ 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):
+    """
+        DISPLAYS NETWORK INFORMATION AND RUNS DIAGNOSTICS.
+
+        \b
+        FEATURES:
+            - Show IP addresses (public and private)
+            - RUN CONNECTIVITY TESTS
+            - Measure internet speed
+            - Monitor network traffic
+            - Check port status
+            - Display DNS servers
+            - Show IP location information
+
+        \b
+        EXAMPLES:
+            autoip
+            autoip --test
+            autoip --speed
+            autoip --monitor --interval 5
+            autoip --ports --dns --location
+            autoip --no-ip
+    """
+
     with LoadingAnimation():
         output = run(
             test=test, speed=speed, monitor=monitor, interval=interval,
             ports=ports, dns=dns, location=location, no_ip=no_ip
         )
-    click.echo(output)
+
+    if is_ci_environment(): output = mask_sensitive_info(output, mask_ips=True)
+    
+    click.echo(safe_text(output))
     update_msg = check_for_updates()
     if update_msg: click.echo(update_msg)