import warnings
warnings.warn("Warning...........Message")

See the python documentation: here

To suppress warnings, I used the python warnings module.

# this should be at the very top of the file
import warnings
warnings.filterwarnings("ignore")

# the rest of the code, including all other import statements, goes here

Now, it only prints out errors and whatever I want it to output.

There is always monkeypatching:

import warnings

def custom_formatwarning(msg, *args, **kwargs):
    # ignore everything except the message
    return str(msg) + '\n'

warnings.formatwarning = custom_formatwarning
warnings.warn("achtung")

from https://pymotw.com/2/warnings/#stack-level-in-warnings

Stack Level in Warnings

You’ll notice that by default the warning message includes the source line that generated it, when available. It’s not all that useful to see the line of code with the actual warning message, though. Instead, you can tell warn() how far up the stack it has to go to find the line the called the function containing the warning. That way users of a deprecated function see where the function is called, instead of the implementation of the function.

# warnings_warn_stacklevel.py
import warnings

def old_function():
    warnings.warn(
        'old_function() is deprecated, use new_function() instead', 
        stacklevel=2)

def caller_of_old_function():
    old_function()

caller_of_old_function() 

Notice that in this example warn() needs to go up the stack 2 levels, one for itself and one for old_function().

$ python warnings_warn_stacklevel.py

warnings_warn_stacklevel.py:18: UserWarning: old_function() is deprecated, use new_function() instead   old_function()

The globals aren't doing much for you, so get rid of them.

Your code will not do the right thing if an argument fails to print: the colour will not be reset. Add a finally to handle this case.

You're too aggressive with your style reset. Just reset the fore colour and nothing else.

Add type hints.

am I horribly misusing *arg?

No, it's fine.

is it okay to use PASS as a variable, as lower-case pass is a reserved word?

Not really. The convention to get around keywords is an underscore suffix, as in pass_.

from typing import Any

import colorama


def print_colour(fore_colour: str, *text: Any) -> None:
    print(fore_colour, end='')
    try:
        print(*text, end='')
    finally:
        print(colorama.Fore.RESET)


def okay(*text: Any) -> None:
    print_colour(colorama.Fore.GREEN, *text)


def warn(*text: Any) -> None:
    print_colour(colorama.Fore.YELLOW, *text)


def fail(*text: Any) -> None:
    print_colour(colorama.Fore.RED, *text)


def test() -> None:
    class BadClass:
        def __str__(self):
            raise ValueError()

    try:
        fail(BadClass())
    except ValueError:
        pass

    print('Should be in default colour')

    warn("Unfragmented text")
    warn("Fragmented", "text")

    fail("Unfragmented text")
    fail("Fragmented", "text")

    okay("Unfragmented text")
    okay("Fragmented", "text")


if __name__ == '__main__':
    test()

The reference manual is a great source. For the warnings module, it says:

The printing of warning messages is done by calling showwarning(), which may be overridden

And later:

warnings.showwarning(message, category, filename, lineno, file=None, line=None)

... You may replace this function with any callable by assigning to warnings.showwarning.

So just declare your own function special_showwarning with the same parameters, format the output the way you want and simply do: logging.showwarning = special_showwarning.

An equivalent way is possible for exception by overriding sys.excepthook:

sys.excepthook(type, value, traceback)

This function prints out a given traceback and exception to sys.stderr.

When an exception is raised and uncaught, the interpreter calls sys.excepthook with three arguments... The handling of such top-level exceptions can be customized by assigning another three-argument function to sys.excepthook.

Unfortunately, this may not work when executing python code in an IDE, for example IDLE uses a custom loop and does not call sys.excepthook. In that case, you could simply wrap your current main in a try block and catch anything. It is then easy to display what you want:

def main():
    # your code ...

if __name__ == '__main__':
    try:
        main()
    except:
        type, value, traceback = sys.exc_info()
        # add your error formatting here