I'd be curious what the generated c code looks like for the whole function this versus the original if statements.

@snowman2 how about sorting matches using preferred_authorities.index(auth_name) if auth_name in preferred_authorities else 10 as a sort key, and then take the first one?

how about sorting matches

What improvement do you see from sorting?

I'd like to avoid using try/except for logic when there are other approaches, leaving it more for handing unexpected errors or inherently non-deterministic behavior. Also, the whole intent of the function is to sort preferentially, so I think it's best to do that explicitly.

Would something like this work?

if not matches:
    return None
for auth_name in preferred_authorities:
    if auth_name in matches:
        return auth_name, matches[auth_name][0]
else:
    auth_name, codes = max(matches.items(), key=lambda x: x[1][0])
    return auth_name, codes[0]

@groutr something like that.

Looking at the code of to_authority() and _matches(), however, I'm no longer sure that the latter returns a data structure that allows the former to return the best match.

GDAL has a method that finds authority matches and returns them in descending confidence order. I think my intention for "preferred authorities" was that we could break ties in one direction in case there were multiple authority/code matches with the same confidence. I had the understanding at the time, and I think I saw it in practice, that the ESRI authority duplicated items in the EPSG database, and that it would be best to return ("EPSG", 00000) in such cases.

However, _matches() loses information about confidence when it collects matches by authority name. If we changed it (it's a "private" method, so we can if we want), we could have it return a list, every item of which could be a list of authority/code matches with the same confidence level. Something like:

[
  [("ESRI", 10000), ("EPSG", 20000), ...],
  [("FOO", 30000)],
  ...
]

Then, to_authority() could iterate over these items, return the one that is most preferred, or move on to the next item in the list.

Does that seem okay to you all?

Preserving the confidence info makes a lot of sense to me. What if _matches() just returned a flat list? I'm not seeing the utility of having the results grouped by confidence level.

# First element is the confidence level (0-100).
[(100, "ESRI", 10000),
(95, "EPSG", 20000),
(80, "ESRI", 10500),
(75, "FOO", 30000),
  ...
]

We know the output OSRFindMatches is already sorted in descending order, which is useful to preserve. If we wanted to groupby confidence level it becomes easy with:

from itertools import groupby
groupby(matches, key=itemgetter(0))

list_authority would be a good reference for the design. It returns a list of namedtuple that contains the match confidence information. The docstrings show an example of that.