combined patches from http://bugs.python.org/issue3187

Lib/fnmatch.py

 """Filename matching with shell patterns.
 
 fnmatch(FILENAME, PATTERN) matches according to the local convention.
 fnmatchcase(FILENAME, PATTERN) always takes case in account.
 
 The functions operate by translating the pattern into a regular
 expression.  They cache the compiled regular expressions for speed.
 
 The function translate(PATTERN) returns a regular expression
 corresponding to PATTERN.  (It does not compile it.)
 """
 
 import re
-import sys
 
 __all__ = ["filter", "fnmatch","fnmatchcase","translate"]
 
 _cache = {}
 
 def fnmatch(name, pat):
     """Test whether FILENAME matches PATTERN.
 
     Patterns are Unix shell style:
 
     *       matches everything
     ?       matches any single character
     [seq]   matches any character in seq
     [!seq]  matches any char not in seq
 
     An initial period in FILENAME is not special.
     Both FILENAME and PATTERN are first case-normalized
     if the operating system requires it.
     If you don't want this, use fnmatchcase(FILENAME, PATTERN).
     """
 
     import os
     name = os.path.normcase(name)
     pat = os.path.normcase(pat)
     return fnmatchcase(name, pat)
 
+def _compile_pattern(pat):
+    regex = _cache.get(pat)
+    if regex is None:
+        if isinstance(pat, bytes):
+            pat_str = str(pat, 'ISO-8859-1')
+            res_str = translate(pat_str)
+            res = bytes(res_str, 'ISO-8859-1')
+        else:
+            res = translate(pat)
+        _cache[pat] = regex = re.compile(res)
+    return regex.match
+
 def filter(names, pat):

[GvR, 2008/08/22 19:04:51]

I wonder if we shouldn't also support isinstance(pat, bytes).  Or perhaps key on
that and insist that the type of the names match the type of pat...

     """Return the subset of the list NAMES that match PAT"""
     import os,posixpath
-    result=[]
-    pat=os.path.normcase(pat)
-    if not pat in _cache:
-        res = translate(pat)
-        _cache[pat] = re.compile(res)
+    result = []
+    pat = os.path.normcase(pat)
+    match = _compile_pattern(pat)
+    if os.path is posixpath:
+        # normcase on posix is NOP. Optimize it away from the loop.
+        for name in names:
+            if match(name):
+                result.append(name)
     else:
-        res = None
-    match=_cache[pat].match
-    match_bytes = None
-    for name in names:
-        if isinstance(name, bytes):
-            if not match_bytes:
-                # create match regex for bytes string
-                charset = sys.getfilesystemencoding()
-                pat = pat.encode(charset)
-                if not pat in _cache:
-                    if res is None:
-                        res = translate(pat)
-                    res = res.encode(charset)
-                    _cache[pat] = re.compile(res)
-                match_bytes = _cache[pat].match
-            if match_bytes(os.path.normcase(name)):
-                result.append(name)
-        elif match(os.path.normcase(name)):
+        for name in names:
+            if match(os.path.normcase(name)):
                 result.append(name)
     return result
 
 def fnmatchcase(name, pat):
     """Test whether FILENAME matches PATTERN, including case.
 
     This is a version of fnmatch() which doesn't case-normalize
     its arguments.
     """
 
-    if not pat in _cache:
-        res = translate(pat)
-        _cache[pat] = re.compile(res)
-    return _cache[pat].match(name) is not None
+    match = _compile_pattern(pat)
+    return match(name) is not None
 
 def translate(pat):
     """Translate a shell PATTERN to a regular expression.
 
     There is no way to quote meta-characters.
     """
 
     i, n = 0, len(pat)
     res = ''
     while i < n:
@@ skipping 17 matching lines @@
                 stuff = pat[i:j].replace('\\','\\\\')
                 i = j+1
                 if stuff[0] == '!':
                     stuff = '^' + stuff[1:]
                 elif stuff[0] == '^':
                     stuff = '\\' + stuff
                 res = '%s[%s]' % (res, stuff)
         else:
             res = res + re.escape(c)
     return res + "$"