Generator expression in combination with StopIteration: kind of a hack? The first piece of code should cover the standard expected data. But as you can easily see, the data not always conveys to this standard. The code works great but I wonder if this is thought be a miss-use of the try/except clause. Better to go with if/else?  

try:
    short_name = short_name.upper()
    m = (k for k,v in c.countries_dict.iteritems() if v[0] == short_name).next() 
    m = [m]
except StopIteration:
    if re_type == 'MAP_INFO' or re_type == 'SHAPE' or re_type == 'ARC_INFO':
        reg_dict = REGIONS
        short_name = short_name.lower()
    elif re_type == 'NAV_SHAPE':
        reg_dict = NAV_REGIONS
        short_name = short_name.upper()
    m = []
    for k,v in reg_dict.iteritems():
        if k == short_name:
            for tup in v:
                m.append(tup[1])
I would discourage this particular usage. Not exactly because it's a risk or a hack—in other circumstances it might even be the right choice for good performance—but because I find it quite obfuscatory. (This happens to echo the usual guidance to avoid using exceptions for flow control, although it's harder to apply that guidance around Python's iterators.)

Instead I would suggest trying to make it clear what you are doing. I believe in this case you are trying to find the "first" key that maps to a list of values containing short_name in index 0. (I say "first" because it's in dictionary order, which isn't a particularly meaningful; it's probably more useful to say an arbitrary key.) If such a key does not exist, you wish to fall through to your except case. A reader is going to find that motive hard to discern. Here is an alternative way to write the first couple lines using itertools:

from itertools import islice

short_name = short_name.upper()
# find a key of an item containing short_name, if available
m = list(islice((k for k,v in c.countries_dict.iteritems() if v[0] == short_name), 1))
if not m:
    # due to bad data, not all short_name values are mapped correctly; try another way
    # code from original except StopIteration


For bonus readability you might split that up into a named generator function that finds all matches, and then filter to the first match with islice or another helper. Clearly performance isn't your goal here, as you're scanning a dict by value. (If you have a lot of these to look up, you may want to create the reverse dict instead of scanning multiple times.)

I'm far from certain that this code is what you intended. Since in the fallback case you build up a list of potentially multiple values, it seems surprising that in the primary case you explicitly exclude alternate keys. If you wanted to include all keys, you can skip islice and use a simple list comprehension: (Note that by slicing the list comprehension with [:1], it would yield the same value for m as the previous approach, and is more readable, although it potentially does more work.)

short_name = short_name.upper()
m = [k for k,v in c.countries_dict.iteritems() if v[0] == short_name]
if not m:
    # due to bad data, not all short_name values are mapped correctly; try another way
    # code from original except StopIteration