Lib/fnmatch.py

   1 """Filename matching with shell patterns.
   2
   3 fnmatch(FILENAME, PATTERN) matches according to the local convention.
   4 fnmatchcase(FILENAME, PATTERN) always takes case in account.
   5
   6 The functions operate by translating the pattern into a regular
   7 expression.  They cache the compiled regular expressions for speed.
   8
   9 The function translate(PATTERN) returns a regular expression
  10 corresponding to PATTERN.  (It does not compile it.)
  11 """
  12
  13 import re
  14
  15 __all__ = ["filter", "fnmatch","fnmatchcase","translate"]
  16
  17 _cache = {}
  18
  19 def fnmatch(name, pat):
  20     """Test whether FILENAME matches PATTERN.
  21
  22     Patterns are Unix shell style:
  23
  24     *       matches everything
  25     ?       matches any single character
  26     [seq]   matches any character in seq
  27     [!seq]  matches any char not in seq
  28
  29     An initial period in FILENAME is not special.
  30     Both FILENAME and PATTERN are first case-normalized
  31     if the operating system requires it.
  32     If you don't want this, use fnmatchcase(FILENAME, PATTERN).
  33     """
  34
  35     import os
  36     name = os.path.normcase(name)
  37     pat = os.path.normcase(pat)
  38     return fnmatchcase(name, pat)
  39
  40 def filter(names, pat):
  41     """Return the subset of the list NAMES that match PAT"""
  42     import os,posixpath
  43     result=[]
  44     pat=os.path.normcase(pat)
  45     if not pat in _cache:
  46         res = translate(pat)
  47         _cache[pat] = re.compile(res)
  48     match=_cache[pat].match
  49     if os.path is posixpath:
  50         # normcase on posix is NOP. Optimize it away from the loop.
  51         for name in names:
  52             if match(name):
  53                 result.append(name)
  54     else:
  55         for name in names:
  56             if match(os.path.normcase(name)):
  57                 result.append(name)
  58     return result
  59
  60 def fnmatchcase(name, pat):
  61     """Test whether FILENAME matches PATTERN, including case.
  62
  63     This is a version of fnmatch() which doesn't case-normalize
  64     its arguments.
  65     """
  66
  67     if not pat in _cache:
  68         res = translate(pat)
  69         _cache[pat] = re.compile(res)
  70     return _cache[pat].match(name) is not None
  71
  72 def translate(pat):
  73     """Translate a shell PATTERN to a regular expression.
  74
  75     There is no way to quote meta-characters.
  76     """
  77
  78     i, n = 0, len(pat)
  79     res = ''
  80     while i < n:
  81         c = pat[i]
  82         i = i+1
  83         if c == '*':
  84             res = res + '.*'
  85         elif c == '?':
  86             res = res + '.'
  87         elif c == '[':
  88             j = i
  89             if j < n and pat[j] == '!':
  90                 j = j+1
  91             if j < n and pat[j] == ']':
  92                 j = j+1
  93             while j < n and pat[j] != ']':
  94                 j = j+1
  95             if j >= n:
  96                 res = res + '\\['
  97             else:
  98                 stuff = pat[i:j].replace('\\','\\\\')
  99                 i = j+1
 100                 if stuff[0] == '!':
 101                     stuff = '^' + stuff[1:]
 102                 elif stuff[0] == '^':
 103                     stuff = '\\' + stuff
 104                 res = '%s[%s]' % (res, stuff)
 105         else:
 106             res = res + re.escape(c)
 107     return res + "$"