Ejemplo n.º 1
0
 def cmd_pose(self, question, sentence_space):
     for i in range(len(question)):
         if i != len(question) - 1:
             print(("\t%d" % (i)) + crayons.red('.') + ("%s" %
                                                        (question[i])))
         else:
             print(("\t%d" % (i)) + crayons.red('.') +
                   ("%s" % (question[i])) + crayons.magenta("?"))
     answer = None
     done = False
     while not done:
         answer = input(
             crayons.green('.') + crayons.magenta('.') + crayons.blue('.'))
         if answer == "":
             print("refusing question.")
             done = True
         elif answer.isdigit():
             answer_index = int(answer)
             if answer_index >= 0 and answer_index < len(question):
                 return qt.Qobj(sentence_space[answer_index])
                 done = True
             else:
                 print("not enough options!")
         else:
             print("use answer #!")
     return answer
Ejemplo n.º 2
0
 def v_pose(self, question, sentence_space, initial_state=None):
     print(crayons.red("\t               +Z             "))
     print(crayons.green("\t               w       +Y     "))
     print(crayons.blue("\t      q quit   |     e        "))
     print(crayons.yellow("\t               |   /          "))
     print(crayons.magenta("\t               | /            "))
     print(crayons.cyan("\t -X a  ________*________ d +X "))
     print(crayons.magenta("\t             / |              "))
     print(crayons.yellow("\t           /   |              "))
     print(crayons.blue("\t        -Y     |     x save   "))
     print(crayons.green("\t      z        s              "))
     print(crayons.red("\t              -Z              "))
     answer_spheres = []
     answer_colors = [
         vp.vector(*np.random.rand(3)) for i in range(len(question))
     ]
     for i in range(len(question)):
         answer_vector = qt.Qobj(sentence_space[i])
         answer_vector.dims = [[len(question)], [1]]
         answer_sphere = MajoranaSphere(len(question), answer_vector,\
                             color=answer_colors[i],\
                             star_color=answer_colors[i],
                             tag=question[i])
         answer_sphere.visualize()
         answer_spheres.append(answer_sphere)
     if initial_state == None:
         initial_state = qt.Qobj(
             sum([sentence_space[i] for i in range(len(question))]))
     decision_sphere = MajoranaSphere(len(question), initial_state)
     decision_sphere.visualize()
     save_v_decision = decision_sphere.decide()
     if save_v_decision:
         return decision_sphere.state
     else:
         return None
Ejemplo n.º 3
0
 def cmd_assign_ordering(self, a, b):
     print(crayons.red(self.combo_question_string(a)))
     print("\t.VS.")
     print(crayons.blue(self.combo_question_string(b)))
     print(crayons.red("\t                coexists               "))
     print(crayons.green("\t                   w       covers      "))
     print(crayons.blue("\t      q            |     e             "))
     print(crayons.yellow("\t       defer...    |   /               "))
     print(crayons.magenta("\t                   | /                 "))
     print(crayons.cyan("\t before a  _______SUM_______ d after   "))
     print(crayons.magenta("\t                /  x                   "))
     print(crayons.yellow("\t        is    /    |     p             "))
     print(crayons.blue("\t   covered  z      |      to quit...   "))
     print(crayons.green("\t        by         s                   "))
     print(crayons.red("\t               excludes                "))
     ordering = input(
         crayons.green('.') + crayons.magenta('.') + crayons.blue('.'))
     while ordering not in ["a", "d", "s", "w", "z", "e", "q", "p"]:
         if ordering == 'x':
             if self.questions[a][1].dims != self.questions[b][1].dims:
                 print('wrong dimensions!'
                       )  # add permutations aka word to word mapping!
             else:
                 return x
         ordering = input(
             crayons.green('.') + crayons.magenta('.') + crayons.blue('.'))
     return ordering
Ejemplo n.º 4
0
def list(depth=None):
    tree = get_dependency_tree()
    # click.echo(json.dumps(tree, indent=4))

    piper_file = project.piper_file
    base_keys = [_key for _key in piper_file["dependencies"]]
    dev_keys = [_key for _key in piper_file["dev_dependencies"]]

    click.echo("# " + crayons.green("base = green") + " | " +
               crayons.magenta("dev = magenta") + " | " +
               crayons.cyan("sub dependencies = cyan"))

    for node in tree:
        name = node["package"]["package_name"]
        if node["package"]["package_name"].lower() in IGNORED_PACKAGES:
            continue
        elif node["package"]["package_name"].lower() in base_keys:
            name = crayons.green(node["package"]["package_name"])
        elif node["package"]["package_name"].lower() in dev_keys:
            name = crayons.magenta(node["package"]["package_name"])
        else:
            name = crayons.cyan(node["package"]["package_name"])

        click.echo("├─ {0}=={1}".format(name,
                                        node["package"]["installed_version"]))
        for dep in node["dependencies"]:
            version_string = dep["required_version"] or ""
            click.echo("│  └─ {0}{1}".format(dep["package_name"],
                                             version_string))

    click.echo(
        crayons.green(
            emoji.emojize("\n:sparkles:  Package list complete",
                          use_aliases=True)))
Ejemplo n.º 5
0
 def __str__(self):
     rep = crayons.red(
         "**************************************************************\n")
     rep += crayons.magenta("%s:\n" % self.name)
     rep += crayons.green("  vocabulary:\n")
     for i in range(len(self.vocabulary)):
         v = self.vocabulary[i]
         rep += crayons.blue("    %d.%s\n      " % (i, v))
         for e in self.symbol_basis[v].full().T[0].tolist():
             rep += '[{0.real:.2f}+{0.imag:.2f}i] '.format(e)
         rep += "\n"
     rep += crayons.yellow("  concordance_matrix:\n")
     rep += str(self.concordance_matrix) + "\n"
     rep += crayons.cyan("  questions:\n")
     for i in range(len(self.questions)):
         possible_answers, answer = self.questions[i]
         rep += crayons.red("    %d.'%s'\n      " %
                            (i, ", ".join(possible_answers)))
         #for e in answer.full().T[0].tolist():
         #    rep += '[{0.real:.2f}+{0.imag:.2f}i] '.format(e)
         probs = self.question_to_probabilities(i)
         #print(probs)
         for p in probs:
             rep += "\t%s: %.6f%%\n" % (p[0], p[1])
     rep += crayons.magenta("  orderings:\n")
     for e in self.unordered:
         rep += "\t.%s\n" % (self.combo_question_string(e))
     rep += crayons.yellow("  state:\n")
     rep += str(self.state) + "\n"
     rep += crayons.blue(
         "**************************************************************")
     return rep
Ejemplo n.º 6
0
def mainMenu():
    clearScreen()
    print(
        crayons.red("|*|*|*|*|*|*| Birch Micro IDE " + version +
                    " |*|*|*|*|*|*|"))
    print(crayons.yellow("1.Editor"))
    print(crayons.yellow("2.Parser"))
    print(crayons.yellow("3.Open File"))
    print(crayons.yellow("4.New File"))
    print(crayons.yellow("5.Check for errors in code"))
    print(crayons.green("6.Scan project for files"))
    menuopt = input(crayons.yellow("\noption [1-3]: ", bold=True))

    if menuopt == "1":
        clearScreen()
        ffn = input("\n\nfilename: ")
        editorMain(ffn)
    if menuopt == "2":
        clearScreen()
        print("birch-prompt " + version + " " + platform)
        return
    if menuopt == "3":
        clearScreen()
        ResizeList(sys.argv, 2, fill_with=0)
        sys.argv[1] = input("\n\nfilename: ")
        frmain()
    if menuopt == "4":
        clearScreen()
        nfn = input("\n\nnew filename: ")
        with open(nfn, "w") as nfile:
            nfile.write("^== Made with " + crayons.yellow("Birch", bold=True) +
                        crayons.magenta("Micro", bold=True) +
                        crayons.cyan("IDE", bold=True) + "\n")
        editorMain(nfn)
    if menuopt == "5":
        clearScreen()
        ResizeList(sys.argv, 2, fill_with=0)
        sys.argv[1] = input("\n\nfilename: ")
        frmain()
    if menuopt == "6":
        clearScreen()
        inFdir = input("Project Directory: ")
        filesall = dict()
        e = 1
        print("\n\n")
        for root, dirs, files in os.walk(os.getcwd() + "/" + inFdir):
            for file in files:
                if file.endswith(".bir") or file.endswith(".brc"):
                    print(
                        crayons.magenta(
                            str(e) + ". " + os.path.join(root, file)))
                    filesall[str(e)] = os.path.join(root, file)
                    e += 1
        fname = input("\nfile number: ")
        clearScreen()
        ResizeList(sys.argv, 2, fill_with=0)
        sys.argv[1] = str(filesall[fname]).replace(os.getcwd() + "/", "")
        frmain()
        sys.exit()
Ejemplo n.º 7
0
async def log_command(ctx):
    if ctx.invoked_subcommand:
        return
    ts = crayons.white(utils.get_timestamp(), bold=True)
    msg = crayons.green(ctx.message.content.replace(ctx.prefix, "", 1),
                        bold=True)
    chan = crayons.magenta(f"#{ctx.channel}", bold=True)
    guild = crayons.magenta(f"({ctx.guild})")
    user = crayons.yellow(f"{ctx.author}", bold=True)
    print(f"{ts} {msg!s} in {chan} {guild} by {user}")
Ejemplo n.º 8
0
async def clean(ctx: fortnitepy.ext.commands.Context) -> None:
    await ctx.send('Cleared CMD')
    clear()
    print(
        crayons.magenta(
            f'███████╗██╗      █████╗ ██████╗       ██████╗  █████╗ ████████╗')
    )
    print(
        crayons.magenta(
            f'██╔════╝██║     ██╔══██╗██╔══██╗      ██╔══██╗██╔══██╗╚══██╔══╝')
    )
    print(
        crayons.magenta(
            f'█████╗  ██║     ██║  ██║██████╔╝█████╗██████╦╝██║  ██║   ██║   ')
    )
    print(
        crayons.magenta(
            f'██╔══╝  ██║     ██║  ██║██╔═══╝ ╚════╝██╔══██╗██║  ██║   ██║   ')
    )
    print(
        crayons.magenta(
            f'██║     ███████╗╚█████╔╝██║           ██████╦╝╚█████╔╝   ██║   ')
    )
    print(
        crayons.magenta(
            f'╚═╝     ╚══════╝ ╚════╝ ╚═╝           ╚═════╝  ╚════╝    ╚═╝   ')
    )
    print(
        crayons.red(
            f'---------------------------------------------------------------------'
        ))
    print(
        crayons.magenta(
            f'[FLOP BOT] [{time()}] massive shout out to oli for inspiring me')
    )
    print(
        crayons.magenta(
            f'[FLOP BOT] [{time()}] Discord server: https://discord.gg/7WrH6r3 '
        ))
    print(
        crayons.magenta(f'[FLOP BOT] [{time()}] For support, questions, etc'))
    print(
        crayons.cyan(
            f'[FLOP BOT] [{time()}] This bot is in progress, if  any issue occurs'
        ))
    print(
        crayons.cyan(
            f'[FLOP BOT] [{time()}] Please report to the discord ASAP'))
    print(
        crayons.red(
            f'---------------------------------------------------------------------'
        ))
    print(
        crayons.green(
            f'[FLOP BOT] [{time()}] Client ready as {client.user.display_name}'
        ))
    print(
        crayons.red(
            f'---------------------------------------------------------------------'
        ))
Ejemplo n.º 9
0
def log_pokemon(match, message):
    p = match.pokemon
    ts = crayons.white(utils.get_timestamp(), bold=True)
    cat = crayons.cyan(p.category, bold=True)
    name = crayons.green(str(p))
    score = crayons.red(f"[{match.score}]", bold=True)
    chan = crayons.magenta(f"#{message.channel}", bold=True)
    guild = crayons.magenta(f"({message.guild})")
    print(
        f"{ts} {cat} {name} {score} (#{str(p.id).zfill(3)} {p.generation}) in {chan} {guild}"
    )
Ejemplo n.º 10
0
 def display_vprompt(self):
     self.decider_sphere.display_visuals()
     for answer_sphere in self.answer_spheres:
         answer_sphere.display_visuals()
     print(crayons.red("\t               +Z             "))
     print(crayons.green("\t               w       +Y     "))
     print(crayons.blue("\t      q quit   |     e        "))
     print(crayons.yellow("\t               |   /          "))
     print(crayons.magenta("\t               | /            "))
     print(crayons.cyan("\t -X a  ________*________ d +X "))
     print(crayons.magenta("\t             / |              "))
     print(crayons.yellow("\t           /   |              "))
     print(crayons.blue("\t        -Y     |     x save   "))
     print(crayons.green("\t      z        s              "))
     print(crayons.red("\t              -Z              "))
Ejemplo n.º 11
0
def format_path(path):
    """
    Format the cycle with colors
    :param path:
    :return: str
    """
    if len(path) == 1:
        # print the node path if it recursively import itself
        return str(path[0].full_path)
    elif len(path) > 1:
        result = [crayons.yellow(path[0].name)]

        previous = path[0]
        for item in path[1:]:
            result.append(' -> ')
            result.append(crayons.yellow(item.name))
            result.append(': Line ')
            result.append(
                crayons.cyan(str(
                    item.is_imported_from[previous.full_path][0])))
            previous = item
        result.append(' =>> ')

        result.append(crayons.magenta(path[0].name))
        return ''.join(str(x) for x in result)
    else:
        return ''
Ejemplo n.º 12
0
def _str_value(v, prec=3, colour="white"):
    """Prints a single value as an optimal decimal valued string.
    If the crayons module is detected, then it will show the value in
    colour (unless the global force_no_colour is True)."""
    s = better_float_str(str(v), tolerance=prec, pre_strip=False).rstrip(".")
    if len(s):
        if s[0] != "-":
            s = "  " + s
        else:
            s = " " + s
    if has_crayons and not force_no_colour:
        if colour.lower() == "red":
            return str(crayons.red(s))
        elif colour.lower() == "green":
            return str(crayons.green(s))
        elif colour.lower() == "blue":
            return str(crayons.blue(s))
        elif colour.lower() == "yellow":
            return str(crayons.yellow(s))
        elif colour.lower() == "magenta":
            return str(crayons.magenta(s))
        elif colour.lower() == "white":
            return str(crayons.white(s))
        else:
            return str(crayons.cyan(s))
    else:
        return s
Ejemplo n.º 13
0
    def render_graph(self):
        print(crayons.magenta('render graph', bold=True))
        g = gv.AGraph(directed=True, rankdir='LR')

        def safe_label(s0):
            s1 = s0.replace('\n', '\\l')
            s2 = s1.replace('\\"', '\'')
            #breakpoint()
            return s2

        def f1(n, d, f):
            if n:
                h0 = hashlib.md5(n.encode()).hexdigest()

            for k, v in d.items():

                h = hashlib.md5(k.encode()).hexdigest()

                g.add_node(h, label=safe_label(k))
                #print(f'h={h!r}')
                #print(f'k={k!r}')

                if n:
                    g.add_edge(h0, h)

                f(k, v, f1)

        f1(None, self.graph, f1)

        g.write('layout.dot')
        return

        with open('layout.dot', 'w') as f:
            f.write(g.string())
Ejemplo n.º 14
0
def _filter_answer(args):
    answer_url = _get_link(args['query'][0])
    all_answers = _get_answer(args, answer_url)

    if isinstance(all_answers, str):
        return all_answers

    if not args['property']:
        return all_answers

    filter_answer = []
    if args['property'] == 'n':
        for answer in all_answers:
            if answer[0] == 'noun':
                filter_answer.append(answer)
    if args['property'] == 'v':
        for answer in all_answers:
            if answer[0] == 'verb':
                filter_answer.append(answer)
    if args['property'] == 'adj':
        for answer in all_answers:
            if answer[0] == 'adj':
                filter_answer.append(answer)
    if args['property'] == 'adv':
        for answer in all_answers:
            if answer[0] == 'adv':
                filter_answer.append(answer)

    if not filter_answer:
        return crayons.magenta(
            '\nIt seems, "{}" has no such property.\n'.format(
                args['query'][0])).color_str

    return filter_answer
Ejemplo n.º 15
0
def main():
    """Runtime code. Always indent a function"""
    # print 'red string' in red
    print(crayons.red('red string'))

    # Red White and Blue text
    print('{} white {}'.format(crayons.red('red'), crayons.blue('blue')))

    crayons.disable()  # disables the crayons package
    print('{} white {}'.format(crayons.red('red'), crayons.blue('blue')))

    crayons.DISABLE_COLOR = False  # enable the crayons package

    # This line will print in color because color is enabled
    print('{} white {}'.format(crayons.red('red'), crayons.blue('blue')))

    # print 'red string' in red
    print(crayons.red('red string', bold=True))

    # print 'yellow string' in yellow
    print(crayons.yellow('yellow string', bold=True))

    # print 'magenta string' in magenta
    print(crayons.magenta('magenta string', bold=True))

    # print 'white string' in white
    print(crayons.white('white string', bold=True))
Ejemplo n.º 16
0
 def display_txtprompt(self):
     for i in range(self.n_choices):
         if i != self.n_choices - 1:
             print(("\t%d" + crayons.red('.') + "%s") % (i, question[i]))
         else:
             print(
                 ("\t%d" + crayons.red('.') + "%s" + crayons.magenta("?")) %
                 (i, question[i]))
     done = False
     answer = None
     while not done:
         answer = self.sphere_command.display_inner_prompt()
         if answer == "":
             print("refusing question.")
             done = True
         elif answer.isdigit():
             answer_index = int(answer)
             if answer_index >= 0 and answer_index < self.n_choices:
                 return qt.Qobj(self.question_space[answer_index])
                 done = True
             else:
                 self.sphere_command.display_error(
                     message="not enough options for you!")
         else:
             self.sphere_command.display_error(message="use answer #!")
     return answer
Ejemplo n.º 17
0
def main():
    """run time code. Always indent under function"""

    # print 'red string' in red
    print(crayons.red('red string', bold=True))

    # print 'yellow string' in yellow
    print(crayons.yellow('yellow string', bold=True))

    # print 'magenta string' in magenta
    print(crayons.magenta('magenta string', bold=True))

    # print 'white string' in white
    print(crayons.white('white string', bold=True))

    # print 'black string' in black
    print(crayons.black('black string', bold=True))

    # print 'green string' in green
    print(crayons.green('green string', bold=True))

    # print 'cyan string' in cyan
    print(crayons.cyan('cyan string', bold=True))

    # print 'blue string' in blue
    print(crayons.blue('blue string', bold=True))

    # print 'Lina Do name' in Red
    print(crayons.red('Lina Do', bold=True))
Ejemplo n.º 18
0
def test_get_referred():
    print("\n")
    print(cy.magenta("Referred Users", bold=True))
    print_line()
    ref_list = userlib.get_user_info(original_user_email)
    print(ref_list)
    pass
Ejemplo n.º 19
0
def bandwidth():  #Define the function name
    import crayons
    from subprocess import call
    from time import sleep
    openfile = open("test.csv", "r")  #Open the file, "r" to read
    readfile = openfile.read()  #Read the file
    filesplit = readfile.splitlines()  #Separate each row
    outfile = open("output.txt",
                   "a")  #Define a file to output the results to, "a" to append
    for x in filesplit:  #Loop through each row
        x = x.split(',')
        speed = x[0]
        carrier = x[1]
        message = "The movie is about to begin..."  #Define the inital user message
        if int(x[0]) >= 25:
            message = f"{message} since your bandwidth is {speed}, and your carrier is {carrier}, we recommend setting video to 4k."
            #Display the specific message in GREEN
            print(crayons.green(message, bold=True))
            print(message, file=outfile)
        elif int(x[0]) >= 5:
            message = f"{message} since your bandwidth is {speed}, and your carrier is {carrier}, we recommend setting video to 1080p."
            #Display the specific message in YELLOW
            print(crayons.yellow(message, bold=True))
            print(message, file=outfile)
        elif int(x[0]) >= 2:
            message = f"{message} since your bandwidth is {speed}, and your carrier is {carrier}, we recommend setting video to 720p."
            #Display the specific message in RED
            print(crayons.red(message, bold=True))
            print(message, file=outfile)
        else:
            message = f"{message} Since your bandwidth is {speed}, and your carrier is {carrier}, we recommend finding another provider."
            #Display the specific message in MAGENTA
            print(crayons.magenta(message, bold=True))
            print(message, file=outfile)

    print(
        "\nAll of the above results have been saved to a file named output.txt"
    )
    #Display a message that shows we are now opening the file
    print("\n\n\nWe are now opening the file, please wait...")
    #Wait for 5 seconds
    sleep(3)
    #Now display the file that was generated from running the script
    call(["cat", "output.txt"])
    #Show the file exists in this directory
    print(
        crayons.green(
            "\nWe are now showing the file exists in this directory."))
    call(["ls", "output.txt"])
    sleep(3)
    #Now lets delete the file that was created
    print(crayons.green("\nWe are now deleting the file"))
    call(["rm", "output.txt"])
    #Show that the file no longer exists
    call(["ls", "output.txt"])
    sleep(3)
    print(crayons.green("\nYou can now see the file no longer exists!"))
    #Clean things up by closing the input and outfile files
    openfile.close()
    outfile.close()
Ejemplo n.º 20
0
def common_instance_clones(
        instances: List['InstanceClone'],
        action: KubeClusterAction = KubeClusterAction.create,
        role='master',
        vmid_placeholder=9999):
    symbol = get_action_symbol(action)
    for instance in instances:
        if instance.vmid == vmid_placeholder:
            vmid = crayons.magenta('[Known after apply]')
        else:
            vmid = crayons.yellow(instance.vmid)
        print(create_update_or_delete(msg=symbol, action=action))
        print(
            create_update_or_delete(f'*** {instance.vm_attributes.name} ***',
                                    action=action))
        print(crayons.blue('Role: ') + crayons.yellow(role))
        print(
            create_update_or_delete('Proxmox Node: ', action=action) +
            crayons.yellow(instance.vm_attributes.node))
        print(
            create_update_or_delete(f'Username: '******'{instance.username}'))
        print(create_update_or_delete('VMID: ', action=action) + vmid)
        vm_output_helper(instance.vm_attributes, action=action)
        vm_output_hotplug_helper(instance, action=action)
        print('')
Ejemplo n.º 21
0
    def __init__(self):
        parser = argparse.ArgumentParser(
            description=
            'A CLI tool to help prune your overgrown requirements file')
        parser.add_argument('--nocolor',
                            action='store_true',
                            help='turns off colored output')
        parser.add_argument('--with_exit_code',
                            action='store_true',
                            help='forces exit code to 1 if requirements '
                            'needed pruning')
        parser.add_argument('requirements_file',
                            help='requirements file you want to prune')
        parser.add_argument('output_file',
                            help='file to store the required requirements')
        parser.add_argument(
            'test_command',
            nargs='*',
            help='command to run to test the project still works')
        self.args = parser.parse_args()

        self._loadArgs()
        self.PROMPT = crayons.magenta('PRUNER: ', bold=True)
        self._getRequirements()
        self._loadVirtualEnv()
        self._installRequirements()
Ejemplo n.º 22
0
    def __load_current_info(self):
        """Load current add-on version information and current config."""
        config_files = ("config.json", "config.yaml", "config.yml")
        for config_file in config_files:
            if os.path.exists(
                    os.path.join(self.repository.working_dir,
                                 self.repository_target, config_file)):
                self.existing_config_filename = config_file
                break

        if self.existing_config_filename is None:
            click.echo("Current version: %s" % crayons.yellow("Not available"))
            return False

        with open(
                os.path.join(
                    self.repository.working_dir,
                    self.repository_target,
                    self.existing_config_filename,
                ),
                "r",
                encoding="utf8",
        ) as f:
            current_config = (json.load(f) if
                              self.existing_config_filename.endswith(".json")
                              else yaml.safe_load(f))

        self.current_version = current_config["version"]
        self.name = current_config["name"]
        self.description = current_config["description"]
        self.slug = current_config["slug"]
        self.url = current_config["url"]
        if "arch" in current_config:
            self.archs = current_config["arch"]

        current_parsed_version = False
        try:
            current_parsed_version = semver.parse(self.current_version)
        except ValueError:
            pass

        if current_parsed_version:
            try:
                ref = self.addon_repository.get_git_ref("tags/" +
                                                        self.current_version)
            except UnknownObjectException:
                ref = self.addon_repository.get_git_ref("tags/v" +
                                                        self.current_version)
            self.current_commit = self.addon_repository.get_commit(
                ref.object.sha)
        else:
            try:
                self.current_commit = self.addon_repository.get_commit(
                    f"v{self.current_version}")
            except GithubException:
                self.current_commit = self.addon_repository.get_commit(
                    self.current_version)

        click.echo("Current version: %s (%s)" % (crayons.magenta(
            self.current_version), self.current_commit.sha[:7]))
Ejemplo n.º 23
0
 def soul___(self, soul_name):
     """soul *name*"""
     if self.does_soul_exist(soul_name):
         soul = self.spheres.souls[soul_name]
         rep = crayons.red(
             "**************************************************************\n"
         )
         rep += crayons.magenta("%s:\n" % soul.name)
         rep += crayons.green("  vocabulary:\n")
         for i in range(len(soul.vocabulary)):
             v = soul.vocabulary[i]
             rep += crayons.blue("    %d.%s\n      " % (i, v))
             for e in soul.symbol_basis[v].full().T[0].tolist():
                 rep += '[{0.real:.2f}+{0.imag:.2f}i] '.format(e)
             rep += "\n"
         rep += crayons.yellow("  concordance_matrix:\n")
         rep += str(soul.concordance_matrix) + "\n"
         rep += crayons.cyan("  questions:\n")
         for i in range(len(soul.questions)):
             question, answer = soul.questions[i]
             rep += crayons.red("    %d.'%s'\n      " %
                                (i, ", ".join(question)))
             for e in answer.full().T[0].tolist():
                 rep += '[{0.real:.2f}+{0.imag:.2f}i] '.format(e)
         rep += crayons.blue(
             "**************************************************************"
         )
         print(rep)
Ejemplo n.º 24
0
    def load_repository(self, addon: str):
        """Load repository configuration from remote repository and add-ons."""
        click.echo("Locating repository add-on list...", nl=False)
        try:
            config = self.github_repository.get_contents(".addons.yml")
        except UnknownObjectException:
            print(
                "Seems like the repository does not contain an "
                ".addons.yml file, falling back to legacy file."
            )
            try:
                config = self.github_repository.get_contents(".hassio-addons.yml")
            except UnknownObjectException:
                print(
                    "Seems like the repository does not contain an "
                    ".hassio-addons.yml file either."
                )
                sys.exit(1)

        config = yaml.safe_load(config.decoded_content)
        click.echo(crayons.green("Loaded!"))

        if not config["channel"] in CHANNELS:
            click.echo(
                crayons.red(
                    'Channel "%s" is not a valid channel identifier' % config["channel"]
                )
            )
            sys.exit(1)

        self.channel = config["channel"]
        click.echo("Repository channel: %s" % crayons.magenta(self.channel))

        if addon:
            click.echo(crayons.yellow('Only updating addon "%s" this run!' % addon))

        click.echo("Start loading repository add-ons:")
        for target, addon_config in config["addons"].items():
            click.echo(crayons.cyan("-" * 50, bold=True))
            click.echo(crayons.cyan(f"Loading add-on {target}"))
            self.addons.append(
                Addon(
                    self.git_repo,
                    target,
                    addon_config["image"],
                    self.github.get_repo(addon_config["repository"]),
                    addon_config["target"],
                    self.channel,
                    (
                        not addon
                        or addon_config["repository"] == addon
                        or target == addon
                    ),
                )
            )
        click.echo(crayons.cyan("-" * 50, bold=True))
        click.echo("Done loading all repository add-ons")
Ejemplo n.º 25
0
def main(start_date: datetime.datetime, end_date: datetime.datetime) -> None:
    tick = time.time()
    date_range = pd.date_range(start_date, end_date)
    for date in date_range:
        process_quality_control(RID, date, OUTPATH)
    tock = time.time()
    print(crayons.magenta(f"Process finished in {tock - tick:0.4}s."))

    return None
Ejemplo n.º 26
0
    def setup(self,
              noinput=False,
              init_data={},
              python=None,
              virtualenv_location="inside",
              installable=False):

        if not self.has_virtualenv:
            click.secho("Creating virtualenv...", fg="yellow")
            # self.virtualenv_location = virtualenv_location
            with click_spinner.spinner():
                self.create_virtualenv(python=python,
                                       virtualenv_location=virtualenv_location)
            click.secho("Virtualenv created ✓", fg="green")
            click.secho("Your virtualenv path: " +
                        crayons.magenta("{}".format(self.virtualenv_dir)))
        else:
            click.secho("Virtualenv already exists ✓", fg="green")

        if not self.has_requirements_structure:
            click.secho("Creating requirement files...", fg="yellow")
            self.create_requirements_structure()
            click.secho("Requirement files created ✓", fg="green")
        else:
            click.secho("Requirement files already exists ✓", fg="green")

        if not self.has_piper_file:
            click.secho("Creating piper file...", fg="yellow")
            self.create_piper_file(noinput=noinput, init_data=init_data)
            click.secho("Piper file created ✓", fg="green")
        else:
            click.secho("Piper file already exists ✓", fg="green")

        if not self.has_piper_lock:
            click.secho("Creating piper lock...", fg="yellow")
            self.create_piper_lock()
            click.secho("Piper lock created ✓", fg="green")
        else:
            click.secho("Piper lock already exists ✓", fg="green")

        if not self.has_setup_py:
            if (not installable) and (not noinput):
                wants_setup_py = click.confirm(
                    "Do you want to make the project installable (adding setup.py)?"
                )
                installable = wants_setup_py

            if installable:
                self.setup_py_dir.write_text(setup_py_template.text())
                click.secho("setup.py created ✓", fg="green")
            else:
                click.secho("setup.py creation skipped", fg="yellow")

        logger.debug([
            self.virtualenv_dir, self.piper_file_dir, self.piper_lock_dir,
            self.requirements_dir
        ])
def show(msgt):
    msg=msgt.printing()
    msg=list(msg)
    for i in range(len(msg)):
        if msg[i]=='a':
            msg[i]=crayons.magenta('a',bold=True)
        elif msg[i]=='b':
            msg[i]=crayons.yellow('b',bold=True)
    for i in msg:
        print(i,end='')
Ejemplo n.º 28
0
 def display(self):
     self.sphere_command.vycle()
     print(crayons.magenta("q to quit..."))
     for word_sphere in self.word_spheres:
         word_sphere.visualize()
     key = self.sphere_command.get_vkey()
     while key != "q":
         key = self.sphere_command.get_vkey()
     for word_sphere in self.word_spheres:
         del word_sphere
Ejemplo n.º 29
0
 def display_startup_message(self):
     os.system("clear")
     print("welcome to %s" % \
             crayons.red("s")+\
             crayons.white("p")+\
             crayons.yellow("h")+\
             crayons.green("e")+\
             crayons.cyan("r")+\
             crayons.blue("e")+\
             crayons.magenta("s"))
Ejemplo n.º 30
0
 def format(self, record):
     s = super().format(record)
     if record.levelno == logging.DEBUG:
         return str(magenta(s))
     if record.levelno == logging.INFO:
         return str(green(s))
     if record.levelno == logging.WARN:
         return str(yellow(s))
     if record.levelno == logging.ERROR:
         return str(red(s))
     return s
Ejemplo n.º 31
0
 def update_status(config, status, computer, manager):
     """Update each application's status."""
     log.info("Recording application status...")
     for application in config.applications:
         latest = status.get_latest(application)
         if manager.is_running(application):
             if computer != latest:
                 if status.is_running(application, computer):
                     # case 1: application just launched remotely
                     manager.stop(application)
                     status.stop(application, computer)
                     print(crayons.green(
                         f"{application} is now running on {latest}"))
                     print(crayons.red(
                         f"{application} is now stopped on {computer}"))
                 else:
                     # case 2: application just launched locally
                     status.start(application, computer)
                     print(crayons.green(
                         f"{application} is now running on {computer}"))
             else:
                 # case 3: application already running locally
                 print(crayons.cyan(
                     f"{application} is running on {computer}"))
         else:
             if status.is_running(application, computer):
                 # case 4: application just closed locally
                 status.stop(application, computer)
                 print(crayons.red(
                     f"{application} is now stopped on {computer}"))
             elif latest:
                 # case 5: application already closed locally
                 print(crayons.magenta(
                     f"{application} is running on {latest}"))
             else:
                 # case 6: application is not running
                 print(crayons.white(
                     f"{application} is not running"))