Python script that polls for changes in filesystems

There are no docstrings. What do your functions do, what arguments do they take, and what do they return?

It's not clear to me what I could use your program for. The output is produced like this:

print msg
print '---'

where msg is a complicated Python data structure (a list of tuples of lists of strings). There's no easy way for me to use this output in a shell script: it would take too much parsing.

So what are the use cases for your program?

Your code does not run under Python 3.

You've defined a bunch of functions inside the function ianus. Presumably this is for reasons of "privacy" — the functions are only called in this context, so you have defined them there. However, in Python we generally don't define local functions like this unless we have a better reason than "privacy" (such as use of variables from the local scope). It would be simpler to define these functions at top level.

path_join is just a wrapper around os.path.join and so seems hardly worth defining. But if you really insisted on having such an alias, you could create it like this:

path_join = os.path.join

or like this:

from os.path import join as path_join

You call pathify all over the place but I doubt this is necessary. The paths mostly come from os.walk and so should be fine without this kind of manipulation.

A function that does the same thing as your flatten is already in the standard library: itertools.chain.from_iterable.

You always test not ignore_files and not ignore_dirs. This suggests that these Booleans are the wrong way round and you should have named them watch_files and watch_dirs instead.

You set rfiles to None if ignore_files is set. This means you have to keep testing if not ignore_files. But if you had set rfiles to the empty list in that case, then you could skip the test in several places (because iterating over the empty list would yield no files).

You don't need to use backslashes to continue lines inside brackets. So the backslash here is unnecessary:

dirs_updated = [d[0] for d in new_dir_times if not        \
               ((d in dir_times) or (d[0] in files_added))]

The parentheses here are unnecessary:

if(ignore_dirs and ignore_files):

(Python is not C.)

After collecting files and directories into separate lists dirs_after and files_after, you treat them almost identically. The only difference is that changes to directories go into msg[0] and changes to files go into msg[1]. Is this distinction really necessary? If not, why not just keep one list containing all watched paths, and simplify the code accordingly.

This code seems over-complicated, with double list comprehensions:

if recursive:
    walk = list(os.walk(path)) if recursive else None

    rdirs  = flatten(
            [[pathify(root, dir) for dir in dirs] for (root, dirs) in \
            [(root, dirs) for (root, dirs, files) in walk]])          \
            if not ignore_dirs else None

    rfiles = flatten(
            [[pathify(root, f) for f in files] for (root, files) in   \
            [(root, files) for (root, dirs, files) in walk]])         \
            if not ignore_files else None
else:
    l = [pathify(path, u) for u in os.listdir(path)]

    rdirs  = [d for d in l if os.path.isdir(d)]  \
            if not ignore_dirs else None

    rfiles = [f for f in l if os.path.isfile(f)] \
            if not ignore_files else None

I would write it like this:

watched_paths = []
if recursive:
    for root, dirs, files in os.walk(path):
        if watch_dirs:
            watched_paths.extend(os.path.join(root, d) for d in dirs)
        if watch_files:
            watched_paths.extend(os.path.join(root, f) for f in files)
else:
    for entry in os.listdir(path):
        entry = os.path.join(path, entry)
        if (watch_dirs and os.path.isdir(entry)
            or watch_files and os.path.isfile(entry)):
            watched_paths.append(entry)

You've spelled the arguments -intr and -rec with a single hyphen. Generally you should reserve single hyphens for options with just one letter. So I would change these to -i and -r respectively (with long versions --interval and --recursive).

In your argument parsing code, you should use the default keyword to ArgumentParser.add_argument to simplify the argument processing. For example, instead of:

parser.add_argument('-rec',
                    help='Checks all subdirectories for changes.')
parser.add_argument('--ignd',
                    help='Ignores directories. Leaves msg[0] as None.',
                    action='store_true')
parser.add_argument('--ignf',
                    help='Ignores files. Leaves msg[1] as None.',
                    action='store_true')

# ...

recursive, ignore_dirs, ignore_files = False, False, False 

# ...

if args.rec:
    recursive = True
if args.ignd:
    ignore_dirs = True  
if args.ignf:
    ignore_files = True

` you could write:

parser.add_argument('-rec', default=False,
                    help='Checks all subdirectories for changes.',
                    action='store_true')
parser.add_argument('--ignd', default=False,
                    help='Ignores directories. Leaves msg[0] as None.',
                    action='store_true')
parser.add_argument('--ignf', default=False,
                    help='Ignores files. Leaves msg[1] as None.',
                    action='store_true')

though as explained above I would recommend reversing the sense of the option variables and write something like this instead:

parser.add_argument('-r', '--recursive', default=False,
                    help='Checks all subdirectories for changes.',
                    action='store_true')
parser.add_argument('--ignore-dirs', dest='watch_dirs', default=True,
                    help='Ignore directories?',
                    action='store_false')
parser.add_argument('--ignore-files', dest='watch_files', default=True,
                    help='Ignore files?',
                    action='store_false')