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.)
"""
importos
importposixpath
importre
importfunctools

__all__= ["filter", "fnmatch", "fnmatchcase", "translate"]

deffnmatch(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).
 """
name=os.path.normcase(name)
pat=os.path.normcase(pat)
returnfnmatchcase(name, pat)

@functools.lru_cache(maxsize=32768, typed=True)
def_compile_pattern(pat):
ifisinstance(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)
returnre.compile(res).match

deffilter(names, pat):
"""Construct a list from those elements of the iterable NAMES that match PAT."""
result= []
pat=os.path.normcase(pat)
match=_compile_pattern(pat)
ifos.pathisposixpath:
# normcase on posix is NOP. Optimize it away from the loop.
fornameinnames:
ifmatch(name):
result.append(name)
else:
fornameinnames:
ifmatch(os.path.normcase(name)):
result.append(name)
returnresult

deffnmatchcase(name, pat):
"""Test whether FILENAME matches PATTERN, including case.

 This is a version of fnmatch() which doesn't case-normalize
 its arguments.
 """
match=_compile_pattern(pat)
returnmatch(name) isnotNone


deftranslate(pat):
"""Translate a shell PATTERN to a regular expression.

 There is no way to quote meta-characters.
 """

STAR=object()
parts=_translate(pat, STAR, '.')
return_join_translated_parts(parts, STAR)


def_translate(pat, STAR, QUESTION_MARK):
res= []
add=res.append
i, n=0, len(pat)
whilei<n:
c=pat[i]
i=i+1
ifc=='*':
# compress consecutive `*` into one
if (notres) orres[-1] isnotSTAR:
add(STAR)
elifc=='?':
add(QUESTION_MARK)
elifc=='[':
j=i
ifj<nandpat[j] =='!':
j=j+1
ifj<nandpat[j] ==']':
j=j+1
whilej<nandpat[j] !=']':
j=j+1
ifj>=n:
add('\\[')
else:
stuff=pat[i:j]
if'-'notinstuff:
stuff=stuff.replace('\\', r'\\')
else:
chunks= []
k=i+2ifpat[i] =='!'elsei+1
whileTrue:
k=pat.find('-', k, j)
ifk<0:
break
chunks.append(pat[i:k])
i=k+1
k=k+3
chunk=pat[i:j]
ifchunk:
chunks.append(chunk)
else:
chunks[-1] +='-'
# Remove empty ranges -- invalid in RE.
forkinrange(len(chunks)-1, 0, -1):
ifchunks[k-1][-1] >chunks[k][0]:
chunks[k-1] =chunks[k-1][:-1] +chunks[k][1:]
delchunks[k]
# Escape backslashes and hyphens for set difference (--).
# Hyphens that create ranges shouldn't be escaped.
stuff='-'.join(s.replace('\\', r'\\').replace('-', r'\-')
forsinchunks)
# Escape set operations (&&, ~~ and ||).
stuff=re.sub(r'([&~|])', r'\\\1', stuff)
i=j+1
ifnotstuff:
# Empty range: never match.
add('(?!)')
elifstuff=='!':
# Negated empty range: match any character.
add('.')
else:
ifstuff[0] =='!':
stuff='^'+stuff[1:]
elifstuff[0] in ('^', '['):
stuff='\\'+stuff
add(f'[{stuff}]')
else:
add(re.escape(c))
asserti==n
returnres


def_join_translated_parts(inp, STAR):
# Deal with STARs.
res= []
add=res.append
i, n=0, len(inp)
# Fixed pieces at the start?
whilei<nandinp[i] isnotSTAR:
add(inp[i])
i+=1
# Now deal with STAR fixed STAR fixed ...
# For an interior `STAR fixed` pairing, we want to do a minimal
# .*? match followed by `fixed`, with no possibility of backtracking.
# Atomic groups ("(?>...)") allow us to spell that directly.
# Note: people rely on the undocumented ability to join multiple
# translate() results together via "|" to build large regexps matching
# "one of many" shell patterns.
whilei<n:
assertinp[i] isSTAR
i+=1
ifi==n:
add(".*")
break
assertinp[i] isnotSTAR
fixed= []
whilei<nandinp[i] isnotSTAR:
fixed.append(inp[i])
i+=1
fixed="".join(fixed)
ifi==n:
add(".*")
add(fixed)
else:
add(f"(?>.*?{fixed})")
asserti==n
res="".join(res)
returnfr'(?s:{res})\Z'