Inheritance diagram for lsst.datarel.datasetScanner.HfsScanner:

Public Member Functions
def	__init__

def	walk

Private Attributes
	_formatKeys

	_pathComponents

Detailed Description

A hierarchical scanner for paths matching a template, optionally
also restricting visited paths to those matching a list of dataId rules.

Definition at line 206 of file datasetScanner.py.

Constructor & Destructor Documentation

def lsst.datarel.datasetScanner.HfsScanner.__init__	(	self,
		template
	)

Build an FsScanner for given a path template. The path template
should be a Python string with named format substitution
specifications, as used in mapper policy files. For example:

deepCoadd-results/%(filter)s/%(tract)d/%(patch)s/calexp-%(filter)s-%(tract)d-%(patch)s.fits

Note that a key may appear multiple times. If it does,
the value for each occurrence should be identical (the formatting
specs must be identical). Octal, binary, hexadecimal, and floating
point formats are not supported.

Definition at line 210 of file datasetScanner.py.

 
     def __init__(self, template):
         """Build an FsScanner for given a path template. The path template
         should be a Python string with named format substitution
         specifications, as used in mapper policy files. For example:
 
         deepCoadd-results/%(filter)s/%(tract)d/%(patch)s/calexp-%(filter)s-%(tract)d-%(patch)s.fits
 
         Note that a key may appear multiple times. If it does,
         the value for each occurrence should be identical (the formatting
         specs must be identical). Octal, binary, hexadecimal, and floating
         point formats are not supported.
         """
         template = os.path.normpath(template)
         if (len(template) == 0 or
             template == os.curdir or
             template[0] == os.sep or
             template[-1] == os.sep):
             raise RuntimeError(
                 'Path template is empty, absolute, or identifies a directory')
         self._formatKeys = {}
         self._pathComponents = []
         fmt = re.compile(r'%\((\w+)\).*?([diucrs])')
 
         # split path into components
         for component in template.split(os.sep):
             # search for all occurences of a format spec
             simple = True
             last = 0
             regex = ''
             newKeys = []
             for m in fmt.finditer(component):
                 simple = False
                 spec = m.group(0)
                 k = m.group(1)
                 seenBefore = self._formatKeys.has_key(k)
                 # transform format spec into a regular expression
                 regex += re.escape(component[last:m.start(0)])
                 last = m.end(0)
                 regex += '('
                 if seenBefore:
                     regex += '?:'
                 if m.group(2) in 'crs':
                     munge = _mungeStr
                     typ = str
                     regex += r'.+)'
                 else:
                     munge = _mungeInt
                     typ = int
                     regex += r'[+-]?\d+)'
                 if seenBefore:
                     # check consistency of formatting spec across key occurences
                     if spec[-1] != self._formatKeys[k].spec[-1]:
                         raise RuntimeError(
                             'Path template contains inconsistent format type-codes '
                             'for the same key')
                 else:
                     newKeys.append(k)
                     self._formatKeys[k] = _FormatKey(spec, typ, munge)
             regex += re.escape(component[last:])
             if simple:
                 regex = component # literal match
             else:
                 regex = re.compile('^' + regex + '$')
             self._pathComponents.append(_PathComponent(newKeys, regex, simple))