home *** CD-ROM | disk | FTP | other *** search
/ Chip 2011 November / CHIP_2011_11.iso / Programy / Narzedzia / Inkscape / Inkscape-0.48.2-1-win32.exe / python / Lib / fnmatch.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-03-27  |  3.2 KB  |  125 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''Filename matching with shell patterns.
  5.  
  6. fnmatch(FILENAME, PATTERN) matches according to the local convention.
  7. fnmatchcase(FILENAME, PATTERN) always takes case in account.
  8.  
  9. The functions operate by translating the pattern into a regular
  10. expression.  They cache the compiled regular expressions for speed.
  11.  
  12. The function translate(PATTERN) returns a regular expression
  13. corresponding to PATTERN.  (It does not compile it.)
  14. '''
  15. import re
  16. __all__ = [
  17.     'filter',
  18.     'fnmatch',
  19.     'fnmatchcase',
  20.     'translate']
  21. _cache = { }
  22.  
  23. def fnmatch(name, pat):
  24.     """Test whether FILENAME matches PATTERN.
  25.  
  26.     Patterns are Unix shell style:
  27.  
  28.     *       matches everything
  29.     ?       matches any single character
  30.     [seq]   matches any character in seq
  31.     [!seq]  matches any char not in seq
  32.  
  33.     An initial period in FILENAME is not special.
  34.     Both FILENAME and PATTERN are first case-normalized
  35.     if the operating system requires it.
  36.     If you don't want this, use fnmatchcase(FILENAME, PATTERN).
  37.     """
  38.     import os
  39.     name = os.path.normcase(name)
  40.     pat = os.path.normcase(pat)
  41.     return fnmatchcase(name, pat)
  42.  
  43.  
  44. def filter(names, pat):
  45.     '''Return the subset of the list NAMES that match PAT'''
  46.     import os
  47.     import posixpath
  48.     result = []
  49.     pat = os.path.normcase(pat)
  50.     if pat not in _cache:
  51.         res = translate(pat)
  52.         _cache[pat] = re.compile(res)
  53.     
  54.     match = _cache[pat].match
  55.     if os.path is posixpath:
  56.         for name in names:
  57.             if match(name):
  58.                 result.append(name)
  59.                 continue
  60.         
  61.     else:
  62.         for name in names:
  63.             if match(os.path.normcase(name)):
  64.                 result.append(name)
  65.                 continue
  66.         
  67.     return result
  68.  
  69.  
  70. def fnmatchcase(name, pat):
  71.     """Test whether FILENAME matches PATTERN, including case.
  72.  
  73.     This is a version of fnmatch() which doesn't case-normalize
  74.     its arguments.
  75.     """
  76.     if pat not in _cache:
  77.         res = translate(pat)
  78.         _cache[pat] = re.compile(res)
  79.     
  80.     return _cache[pat].match(name) is not None
  81.  
  82.  
  83. def translate(pat):
  84.     '''Translate a shell PATTERN to a regular expression.
  85.  
  86.     There is no way to quote meta-characters.
  87.     '''
  88.     i = 0
  89.     n = len(pat)
  90.     res = ''
  91.     while i < n:
  92.         c = pat[i]
  93.         i = i + 1
  94.         if c == '*':
  95.             res = res + '.*'
  96.             continue
  97.         if c == '?':
  98.             res = res + '.'
  99.             continue
  100.         if c == '[':
  101.             j = i
  102.             if j < n and pat[j] == '!':
  103.                 j = j + 1
  104.             
  105.             if j < n and pat[j] == ']':
  106.                 j = j + 1
  107.             
  108.             while j < n and pat[j] != ']':
  109.                 j = j + 1
  110.             if j >= n:
  111.                 res = res + '\\['
  112.             else:
  113.                 stuff = pat[i:j].replace('\\', '\\\\')
  114.                 i = j + 1
  115.                 if stuff[0] == '!':
  116.                     stuff = '^' + stuff[1:]
  117.                 elif stuff[0] == '^':
  118.                     stuff = '\\' + stuff
  119.                 
  120.                 res = '%s[%s]' % (res, stuff)
  121.         j >= n
  122.         res = res + re.escape(c)
  123.     return res + '\\Z(?ms)'
  124.  
  125.