gradients for mindy

gradient.py

#!/bin/python
"""purpose: create gradients"""

from shutil import which
from argparse import ArgumentParser
from os import popen

default_colors = {
    "clear": (0, 0, 0),
    "black": (0, 0, 0),
    "white": (255, 255, 255),
    "lightgray": (191, 191, 191),
    "gray": (127, 127, 127),
    "darkgray": (63, 63, 63),
    "blue": (0, 0, 255),
    "navy": (0, 0, 128),
    "royal": (65, 105, 225),
    "slate": (112, 128, 144),
    "sky": (135, 206, 235),
    "cyan": (0, 255, 255),
    "teal": (0, 128, 128),
    "green": (0, 255, 0),
    "acid": (127, 255, 0),
    "lime": (50, 205, 50),
    "forest": (34, 139, 34),
    "olive": (107, 142, 35),
    "yellow": (255, 255, 0),
    "gold": (255, 215, 0),
    "goldenrod": (218, 165, 32),
    "orange": (255, 165, 0),
    "brown": (139, 69, 19),
    "tan": (210, 180, 140),
    "brick": (178, 34, 34),
    "red": (255, 0, 0),
    "scarlet": (255, 52, 28),
    "coral": (255, 127, 80),
    "salmon": (250, 128, 114),
    "pink": (255, 105, 180),
    "magenta": (255, 0, 255),
    "purple": (160, 32, 240),
    "violet": (238, 130, 238),
    "maroon": (176, 48, 96),
    "accent": (255, 211, 127),
}


def rgb_to_hex(rgb):
    """converts rgb to hex"""
    return "#%02x%02x%02x" % tuple(rgb)


def default_color(key: str):
    """gets color from default colors"""
    if key in default_colors:
        return default_colors[key]
    raise IOError(
        f"colors invalid: please supply color in {default_colors.keys()}")


def hex_to_rgb(code: str):
    """hex code > rgb"""
    if len(code) > 5:
        code = code.lstrip("#")
        return list(int(code[i: i + 2], 16) for i in (0, 2, 4))
    else:
        raise IOError(f"invalid hex code {code}: please supply 6 digits")


def helper(argument):
    """helper"""
    return f"[{argument}]"


def has_paint():
    """checks if the pastel program is installed"""
    return which("pastel") is not None


def render_primer(text):
    """prepares the text for rendering"""
    text_array = []
    color_array = []
    temp = ""
    incolor = False
    for letter in text:
        if letter == '[' or incolor:
            if not incolor and temp:  # just got in, temp should have text
                text_array.append(temp)
                temp = ""
            temp += letter
            incolor = True
            if letter == ']':
                incolor = False
                color_array.append(temp)
                temp = ""
                continue
        else:
            temp += letter
    text_array.append(temp)
    return [color_array, text_array]


def render(text_i):
    """renders the text"""
    text = render_primer(text_i)
    if text:
        string = "\u001b[1m"
        for i in range(len(text[1])):
            string += escape(text[0][i], text[1][i])
        print(string + "\033[0m\n")


def escape(color, text):
    r, g, b = strip(color)
    return f"\u001b[38;2;{r};{g};{b}m{text}"


def strip(color):
    out = color.lstrip('[').rstrip(']')
    try:
        default = default_color(out)
        return default
    except IOError:
        pass
    return hex_to_rgb(out)


def solve(colors, text: str, defc: list, args) -> str:
    """creates the gradient"""
    out = ""
    textlen = len(text)
    lencolors = len(colors)
    intermediates = textlen
    # append selected colors to the gradients list
    gradients = [helper(rgb_to_hex(color)) for color in colors]
    if args.lowercharcount:
        # let intermediaries = Math.floor(((150 - (pickedColors.length * 9)) - inputStr.length) / 9) > inputStr.length - 2 ? inputStr.length - 2 : Math.floor((132 - inputStr.length) / 9);
        intermediates = textlen - \
            2 if ((150 - (lencolors * 9)) - textlen) // 9 > textlen - \
            2 else (132 - textlen) // 9
    intras = intermediates // (lencolors - 1)
    for j in range(1, lencolors):
        start_color = colors[j - 1]
        end_color = colors[j]
        for i in range(1, intras):
            factor = [abs(start_color[index] - end_color[index]) //
                      (intras + 1) * i for index in range(3)]
            current = [start_color[i] - factor[i] if start_color[i]
                       > end_color[i] else start_color[i] + factor[i] for i in range(3)]
            gradients.insert(i + ((intras) * (j - 1)),
                             helper(rgb_to_hex(current)))
    out = list(text)
    for i in range(len(gradients)):
        insertionpoint = (textlen // intermediates) * i + i
        out.insert(insertionpoint, gradients[i])
    out = "".join(out)
    if args.lowercharcount and len(out) >= 150:
        raise IOError("text too long: please supply shorter text")
    imported = False
    if args.copy:
        try:
            import pyperclip
            imported = True
        except ImportError:
            print(
                "pyperclip is not installed, please install(`pip install pyperclip`) to use copy")
    touche = ""
    endche = ""
    if imported:
        pyperclip.copy(out)
        touche = "copied:"
        endche = " to clipboard"
    if args.print:
        print(f"{touche} {out}{endche}")
    if args.render:
        render(out)
    return out


def pick_color(prompt, paint):
    """gets out the colorpicker"""
    print(prompt)
    if not paint:
        raise IOError("please install pastel to use colorpicker")
    return hex_to_rgb(popen("pastel pick | pastel format").read())


def main():
    """setup args"""
    parser = ArgumentParser(
        description="Convert text to rainbow text. example usage: 'gradient -lct h̸̗͉͊̀̈́e̶͇͈̚l̸̬̓̓̉ͅl̷̮͎̐̚o̶̝̱̎̈́̽ ẃ̵͈̰̩o̵̢̤̬͆̅͝ř̴̝͖̏̕l̵̼̪͆d̷̪͛!'"
    )
    parser.add_argument("-np", "--no-print", action="store_false", dest="print",
                        help="to print or not to print. that is the question")
    parser.add_argument("-nr", "--no-render", action="store_false", dest="render",
                        help="disables text rendering")
    parser.add_argument("-nc", "--no-copy", action="store_false", dest="copy",
                        help="Copy to clipboard")
    parser.add_argument("-nl", "--no-lowercharcount", dest="lowercharcount",
                        action="store_false", help="Disables char count lowering")
    parser.add_argument("-t", "--text", type=str,
                        nargs="*", help="Text to convert")
    parser.add_argument(
        "-s", "--server", action="store_true", help="disables inputs")
    group = parser.add_mutually_exclusive_group()
    group.add_argument(
        "-d",
        "--default_color",
        nargs='*',
        help="use default colors, eg: 'gradient -lcd slate red -t footer message'",
        metavar=("defaultcolor", "defaultcolor2"),
    )
    group.add_argument("-x", "--hex", nargs='*',
                       help="use hex codes, eg: gradient -clx '#708090' '#e91d17' -t textures",
                       metavar=("hex", "hex2"))
    args = parser.parse_args()
    pastel = has_paint()
    text = " ".join(args.text) if args.text else ""
    if len(text) > 0 and len(text) < 6:
        raise IOError(
            f"invalid text length {text}: please supply at least 5 characters")
    while len(text) < 6:
        if args.text:
            text = args.text
        elif not args.server:
            text = input("text: ")
        else:
            text = "smhsmhsmh"
        if len(text) < 6:
            print("text too short, please supply at least 5 characters")
            continue
        break
    colors = []
    if args.hex:
        if len(args.hex) < 2:
            raise IOError("more values")
        colors = [hex_to_rgb(args.hex[i]) for i in range(len(args.hex))]
    elif args.default_color:
        if len(args.default_color) < 2:
            raise IOError("need more values doofus")
        colors = [default_color(args.default_color[i])
                  for i in range(len(args.default_color))]

    else:
        if args.server:
            raise IOError("bruh fill yer args")
        colors.append(pick_color("start color:", pastel))
        colors.append(pick_color("end color:", pastel))
    solve(colors, text, args.default_color, args)


if __name__ == "__main__":
    main()

fuck escape codes

escape codes are awesome