Python print verbose

def print_if_verbose(self, option, action=None, use_default=False):
        """Print out `option` if verbosity and other conditions are met.

        Parameters
        ----------
        option : str
            Key/option name for the parameter being read out.
        action : str, optional
            Use to adapt printout message to specific actions (e.g. "Deleting")
        """
        name = self.name
        verbose = self.verbose
        new_key = option in self.unused
        if verbose >= 100 or (new_key and verbose >= (2. if use_default else 1.)):
            val = self.options.get(option, "<not set>")
            if action is None:
                action = "Option"
            defaultstring = "(default) " if use_default else ""
            print("{action} {option!r}={val!r} {defaultstring}for config {name!s}".format(
                action=action, name=name, option=option, val=val, defaultstring=defaultstring)) 

def print_verbose(self):
        """Print a verbose representation of a network."""
        print("Nodes: ")
        for a in self.nodes(failed="all"):
            print(a)

        print("\nVectors: ")
        for v in self.vectors(failed="all"):
            print(v)

        print("\nInfos: ")
        for i in self.infos(failed="all"):
            print(i)

        print("\nTransmissions: ")
        for t in self.transmissions(failed="all"):
            print(t)

        print("\nTransformations: ")
        for t in self.transformations(failed="all"):
            print(t) 

def printAllControlsVerbose(self):
        line = "############################\n"
        line += "Primary Channel Pots:"
        for i,chn in enumerate(self.channels):
            if i % 4 == 0:
                line +="\n"
            line += chn.name + ": " + str(chn.getPotValue()) + "\t"
        line += "\nPrimary Channel CVs:"
        for i,chn in enumerate(self.channels):
            if i % 4 == 0:
                line +="\n"
            line += chn.name + ": " + str(chn.getCVValue()) + "\t"
        line += "\nSecondary Channels:"
        for i,chn in enumerate(self.altchannels):
            if i % 4 == 0:
                line += "\n"
            line += chn.name + ": " + str(chn.getValue()) + "\t"
        line += "\n############################\n"
        print line 

def print_verbose(self):
        """Print a verbose representation of a network."""
        print "Nodes: "
        for a in (self.nodes(failed="all")):
            print a

        print "\nVectors: "
        for v in (self.vectors(failed="all")):
            print v

        print "\nInfos: "
        for i in (self.infos(failed="all")):
            print i

        print "\nTransmissions: "
        for t in (self.transmissions(failed="all")):
            print t

        print "\nTransformations: "
        for t in (self.transformations(failed="all")):
            print t 

def print_verbose(msg, *a):
    if verbose:
        s = msg if len(a) == 0 else msg.format(*a)
        t = time.time()
        dt = datetime.fromtimestamp(t)
        s = LOG_FORMAT.format(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, str(dt.microsecond)[0:3], s)
        print(s) 

def print_verbose(self):
        if self.verbose:
            print(self.tcs)
        if self.verbose > 1:
            print(self.alpha[:, :, 0])
            print(self.theta) 

def print_verbose(self):
        if self.verbose:
            print(self.tcs)
        if self.verbose > 1:
            print(self.alpha[:,:,0])
            if hasattr(self, "mis"):
                print(self.mis[:,:,0]) 

def print_verbose(self):
        if self.verbose:
            print(self.tcs)
        if self.verbose > 1:
            print(self.alpha[:, :, 0])
            print(self.theta)
            if hasattr(self, "mis"):
                print(self.mis) 

def print_verbose(self, d, root_result, axis):
        """Prints information related to the function solver convergence to the terminal.

        :param float d: Location of the plastic centroid axis
        :param root_result: Result object from the root finder
        :type root_result: :class:`scipy.optimize.RootResults`
        :param string axis: Axis being considered by the function sovler
        """

        str = "---{0} plastic centroid calculation converged at ".format(axis)
        str += "{0:.5e} in {1} iterations.".format(d, root_result.iterations)
        print(str) 

def print_verbose(error_message):
    """
        Prints message with green color to show success
    """
    print("\033[1;32mVERBOSE\033[0m {}".format(error_message)) 

def print_verbose(signature, key, msg):
    secret = CBitcoinSecret(key)
    address = P2PKHBitcoinAddress.from_pubkey(secret.pub)
    message = BitcoinMessage(msg)
    print('Address: %s' % address)
    print('Message: %s' % msg)
    print('Signature: %s' % signature)
    print('Verified: %s' % VerifyMessage(address, message, signature))
    print('\nTo verify using bitcoin core:')
    print('\n`bitcoin-cli verifymessage %s \'%s\' \'%s\'`\n' % (address, signature.decode('ascii'), msg)) 

def print_verbose(*args):
    global print_lock
    if argparser.args.verbose: 
        with print_lock:
            print(*args) 

def printVerboseCatalog(rtable, ftable, ctable, opt):
	"""
	Prints flat catalog to text file with additional columns

	rtable: Repeater table
	ftable: Families table
	ctable: Correlation table
	opt: Options object describing station/run parameters

	Columns correspond to cluster number, event time, frequency index, amplitude, time
	since last event in hours, correlation coefficient with respect to the best
	correlated event, and correlation coefficient with respect to the core event.
	"""

	with open('{}{}/catalog.txt'.format(opt.outputPath, opt.groupName), 'w') as f:
			
		startTimes = rtable.cols.startTime[:]
		startTimeMPL = rtable.cols.startTimeMPL[:]
		windowStarts = rtable.cols.windowStart[:]
		windowAmps = rtable.cols.windowAmp[:]
		ids = rtable.cols.id[:]
		id1 = ctable.cols.id1[:]
		id2 = ctable.cols.id2[:]
		ccc = ctable.cols.ccc[:]
		fi = np.nanmean(rtable.cols.FI[:], axis=1)
	
		f.write("cnum\tevTime                    \tfi\txcormax\txcorcore\tdt(hr)\tamps\n")
		for cnum in range(ftable.attrs.nClust):
			fam = np.fromstring(ftable[cnum]['members'], dtype=int, sep=' ')
		
			catalogind = np.argsort(startTimeMPL[fam])
			catalog = startTimeMPL[fam][catalogind]
			spacing = np.diff(catalog)*24
			idf = ids[fam]
			ix = np.where(np.in1d(id2,idf))
			C = np.eye(len(idf))
			r1 = [np.where(idf==xx)[0][0] for xx in id1[ix]]
			r2 = [np.where(idf==xx)[0][0] for xx in id2[ix]]
			C[r1,r2] = ccc[ix]
			C[r2,r1] = ccc[ix]
			xcorrmax = C[np.argmax(np.sum(C,0)),:]
			core = ftable[cnum]['core']
			xcorrcore = C[np.where(fam==core)[0][0],:]
		
			j = -1
			for i in catalogind:
				evTime = (UTCDateTime(startTimes[fam][i]) +
					windowStarts[fam][i]/opt.samprate)
				amp = windowAmps[fam[i],:]
				if j == -1:
					dt = np.nan
				else:
					dt = spacing[j]
				j += 1
			
				f.write("{0}\t{1}\t{2: 4.3f}\t{4:3.2f}\t{5:3.2f}\t{3:12.6f}\t[".format(
				    cnum,evTime.isoformat(),fi[fam][i],dt,xcorrmax[i],xcorrcore[i]))
				for a in amp:
					f.write(" {:10.2f} ".format(a))
				f.write("]\n")