def color(string, color=None):
    """
    Change text color for the Linux terminal.
    """

    attr = []
    # bold
    attr.append("1")

    if color:
        if color.lower() == "red":
            attr.append("31")
        elif color.lower() == "green":
            attr.append("32")
        elif color.lower() == "blue":
            attr.append("34")
        return "\x1b[%sm%s\x1b[0m" % (";".join(attr), string)

    else:
        if string.startswith("[!]"):
            attr.append("31")
            return "\x1b[%sm%s\x1b[0m" % (";".join(attr), string)
        elif string.startswith("[+]"):
            attr.append("32")
            return "\x1b[%sm%s\x1b[0m" % (";".join(attr), string)
        elif string.startswith("[*]"):
            attr.append("34")
            return "\x1b[%sm%s\x1b[0m" % (";".join(attr), string)
        else:
            return string

def color(string, color=None):
    """
    Change text color for the Linux terminal.
    """

    attr = []
    # bold
    attr.append('1')

    if color:
        if color.lower() == "red":
            attr.append('31')
        elif color.lower() == "yellow":
            attr.append('33')
        elif color.lower() == "green":
            attr.append('32')
        elif color.lower() == "blue":
            attr.append('34')
        return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), string)

    else:
        if string.startswith("[!]"):
            attr.append('31')
            return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), string)
        elif string.startswith("[+]"):
            attr.append('32')
            return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), string)
        elif string.startswith("[*]"):
            attr.append('34')
            return '\x1b[%sm%s\x1b[0m' % (';'.join(attr), string)
        else:
            return string

def color(string, color='', graphic=''):
    """
    Change text color for the Linux terminal.

    Args:
        string (str): String to colorify
        color (str): Color to colorify the string in the following list:
            black, red, green, yellow, blue, purple, cyan, gr[ae]y
        graphic (str): Graphic to append to the beginning of the line
    """


    if not color:
        if string.startswith("[!] "):
            color = 'red'
        elif string.startswith("[+] "):
            color = 'green'
        elif string.startswith("[*] "):
            color = 'blue'
        else:
            color = 'normal'

    if color not in colors:
        print(colors['red'] + 'Color not found: {}'.format(color) + colors['normal'])
        return

    if color:
        return colors[color] + graphic + string + colors['normal']
    else:
        return string + colors['normal']

def expand_tilde(string):
    """
    Return an expanded version of the string by replacing a leading tilde
    with %HOME% (if defined) or %USERPROFILE%.
    """
    if 'HOME' in os.environ.keys():
        home_var = 'HOME'
    else:
        home_var = 'USERPROFILE'
    if string.startswith('~') or string.startswith('"~'):
        string = string.replace('~', '%' + home_var + '%', 1)
    return string

 def cleanExtension(string):
     """
     @param string: The extension to clean
     @type string: str
     
     @return: The cleaned extension in <i>.ext</i> format.
     @rtype: str
     """
     if string.startswith('*'): 
         string = string[1:]
     if not string.startswith('.'): 
         string = '.' + string
     return string

    def is_multiline_start(self, string):
        start_quote = False
        end_quote = False

        if string.startswith('"') and not string.startswith('"""'):
            start_quote = True
        if string.endswith('"') and not string.endswith('"""'):
            end_quote = True

        # line that only contains a quote
        if len(string.strip()) == 1 and (start_quote or end_quote):
            return True

        return start_quote and (start_quote and not end_quote)

def string_remove_quotes(string):
    if type(string) not in (str, unicode):
        return string

    for char in ('"', "'"):
        if string.startswith(char) and string.endswith(char):
            return string[1:-1]

    def _check_conflict(self, option):
        conflict_opts = []
        for opt in option._short_opts:
            if self._short_opt.has_key(opt):
                conflict_opts.append((opt, self._short_opt[opt]))
        for opt in option._long_opts:
            if self._long_opt.has_key(opt):
                conflict_opts.append((opt, self._long_opt[opt]))

        if conflict_opts:
            handler = self.conflict_handler
            if handler == "error":
                opts = []
                for co in conflict_opts:
                    opts.append(co[0])
                raise errors.OptionConflictError(
                    "conflicting option string(s): %s"
                    % string.join(opts, ", "),
                    option)
            elif handler == "resolve":
                for (opt, c_option) in conflict_opts:
                    if string.startswith(opt, "--"):
                        c_option._long_opts.remove(opt)
                        del self._long_opt[opt]
                    else:
                        c_option._short_opts.remove(opt)
                        del self._short_opt[opt]
                    if not (c_option._short_opts or c_option._long_opts):
                        c_option.container.option_list.remove(c_option)

        def unQuote(string):
            """
            @param string:
            @type string:

            @return: The stripped string.
            @rtype: string
            """

            if string.startswith('"') and string.endswith('"'):
                string = string[1:-1]
                
            elif string.startswith("'") and string.endswith("'"):
                string = string[1:-1]

            return string

    def decode(cls, string, base):
        """
        Decode a Base X encoded string into a decimal number

        @param string: The encoded number, in str format
        @param base:   The base from which to convert the number

        @return : Number in decimal encoding
        @rvalue : int
        """
        if base < 2 or base > 62:
            raise ValueError('Illegal base')            

        num = 0

        # If ``string`` is padded with zeros, remove them
        while 1:
            if string != '0' and string.startswith('0'):
                string = string[1:]
            else:
                break
        
        for power, char in enumerate(string[::-1]):
            try:
                index = cls.ALPHABET.index(char)
            except ValueError:
                # ``char`` is not contained in the alphabet
                raise ValueError('Number contains illegal digits')

            if index >= base:
                raise ValueError('Number contains illegal digits')

            num += index * (base ** power)

        return num

def ltrim(string, prefix):
    ''' Trim all prefixes from string. '''

    length = len(prefix)
    while string.startswith(prefix):
        string = string[length:]
    return string

 def fromPDBrecord(cls,string):
     if string.startswith('ATOM'):
         name = string[12:16].strip()
         x = float(string[30:38].strip())
         y = float(string[38:46].strip())
         z = float(string[46:54].strip())
         return cls(name,[x,y,z])
     else:
         sys.exit(1)

def color(string, color='', graphic=''):
    """
    Change text color for the Linux terminal.

    Args:
        string (str): String to colorify
        color (str): Color to colorify the string in the following list:
            black, red, green, yellow, blue, purple, cyan, gr[ae]y
        graphic (str): Graphic to append to the beginning of the line
    """

    colors = {
    'normal'         : "\x1b[0m",
    'black'          : "\x1b[30m",
    'red'            : "\x1b[31m",
    'green'          : "\x1b[32m",
    'yellow'         : "\x1b[33m",
    'blue'           : "\x1b[34m",
    'purple'         : "\x1b[35m",
    'cyan'           : "\x1b[36m",
    'grey'           : "\x1b[90m",
    'gray'           : "\x1b[90m",
    'bold'           : "\x1b[1m"
    }

    if not color:
        if string.startswith("[!] "): 
            color = 'red'
        elif string.startswith("[+] "): 
            color = 'green'
        elif string.startswith("[*] "): 
            color = 'blue'
        else:
            color = 'normal'

    if color not in colors:
        print colors['red'] + 'Color not found: {}'.format(color) + colors['normal']
        return

    if color:
        return colors[color] + graphic + string + colors['normal']
    else:
        return string + colors['normal']

def remove_prefix(string, prefix):
    """
    This funtion removes the given prefix from a string, if the string does
    indeed begin with the prefix; otherwise, it returns the string
    unmodified.
    """
    if string.startswith(prefix):
        return string[len(prefix):]
    else:
        return string

def lchop(string, prefix):
    """Removes a prefix from string

    :param string: String, possibly prefixed with prefix
    :param prefix: Prefix to remove from string
    :returns: string without the prefix
    """
    if string.startswith(prefix):
        return string[len(prefix):]
    return string

 def set_usage(self, usage):
     if usage is None:
         self.usage = _("%prog [options]")
     elif usage is SUPPRESS_USAGE:
         self.usage = None
     # For backwards compatibility with Optik 1.3 and earlier.
     elif string.startswith(usage, "usage:" + " "):
         self.usage = usage[7:]
     else:
         self.usage = usage

def dequote(string):
    """Takes string which may or may not be quoted and unquotes it.

    It only considers double quotes. This function does NOT consider
    parenthised lists to be quoted.
    """
    if string and string.startswith('"') and string.endswith('"'):
        string = string[1:-1]  # Strip off the surrounding quotes.
        string = string.replace('\\"', '"')
        string = string.replace('\\\\', '\\')
    return string

def find_in_bor(root, string):
    #print string
    if string == 'le':
        for i in range(len(root.arr)):
            print root.arr[i].string

    for i in range(len(root.arr)):
        if root.arr[i].string == string:
            return True if root.arr[i].is_leaf else False;
        elif string.startswith(root.arr[i].string):
            return find_in_bor(root.arr[i], string[len(root.arr[i].string):])
    return False

def string_safe_shell(string):
    if string.startswith("'") and string.endswith("'"):
        return string
    else:
        return string_escape_char(
            string,
            str(
                '&();|\n'+  # Control operators
                '<>'+       # Redirection operators
                '!*?[]'+    # Shell patterns
                '$'         # Variables
            )
        )

def safe_prepend(prepend_string, string):
    """Prepend to string non-destructively
    Ex: safe_prepend('EUCTR', 'EUCTR12345678') => 'EUCTR12345678'

    Args:
        prepend_string: string to prepend
        string: string to prepend to
    """
    if string is None:
        return None
    if not string.startswith(prepend_string):
        string = '%s%s' % (prepend_string, string)

    return string