ATLAS Offline Software
DiskUtils.py
Go to the documentation of this file.
1 # Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
2 
3 from __future__ import print_function
4 import glob
5 import os
6 import re
7 import subprocess
8 import functools
9 
10 # DEPRECATED CODE #############################################################
11 
12 import sys
13 from functools import wraps
14 def deprecated(message):
15  def deco(fn):
16  @wraps(fn)
17  def wrapper(*args, **kwargs):
18  print('WARNING: [InDetBeamSpotExample.DiskUtils]',
19  '{}() is deprecated and will be removed'.format( fn.__name__),
20  file=sys.stderr)
21  print('WARNING: ', message,
22  file=sys.stderr)
23  return fn(*args, **kwargs)
24  return wrapper
25  return deco
26 
27 import fnmatch
28 from collections import namedtuple
29 StorageManager = namedtuple('StorageManager', ['name', 'prefix', 'cp', 'ls', 'longls'])
30 CastorMgr = StorageManager(name='castor', prefix='root://castoratlas/', cp='xrdcp', ls='nsls %s', longls='nsls -l %s')
31 RFIOMgr = StorageManager(name='rfio', prefix='rfio:', cp='rfcp', ls='rfdir %s', longls='rfdir %s')
32 EOSMgr = StorageManager(name='eos', prefix='root://eosatlas.cern.ch/', cp='xrdcp', ls='/bin/sh -l -c "LD_LIBRARY_PATH=/usr/lib64/ eos ls %s"', longls='/bin/sh -l -c "LD_LIBRARY_PATH=/usr/lib64/ eos ls -l %s"')
33 UnixMgr = StorageManager(name='unix', prefix='', cp='cp', ls='ls %s', longls='ls -l %s')
34 
35 def _rationalise(path):
36  """
37  Rationalise a path, removing prefix and esuring single leading slash
38  """
39  for p in ('root://castoratlas/', 'root://eosatlas.cern.ch/', 'rfio:', 'castor:'):
40  if path.startswith(p):
41  path = path[len(p):]
42  if path.startswith('//'):
43  path = path[1:]
44  if not path.startswith('/'):
45  path = '/'+path
46  break
47 
48  return path
49 
50 @deprecated("EOS is mounted on /eos with fuse, so you probably don't need this abstraction")
51 def storageManager(name):
52  """
53  Return SotrageManager to deal with listing, copying and reading files from various storage systems
54  """
55  name = _rationalise(name)
56  if name.startswith('/castor/'):
57  return CastorMgr
58  elif name.startswith('/eos/'):
59  return EOSMgr
60  else:
61  return UnixMgr
62 
63 @deprecated("DiskUtils.FileSet replaces this functionality")
64 def filelist(files, prefix=None):
65  """
66  lists CASTOR/EOS name server directory/file entries.
67  If path is a directory, filelist lists the entries in the directory;
68  they are sorted alphabetically.
69 
70  `files` specifies the CASTOR/EOS pathname.
71  `prefix` specifies the prefix one wants to prepend to the path found.
72  (e.g. prefix='root://castoratlas/' or 'root://eosatlas.cern.ch//')
73  if prefix=True it will determin the prefix based on the pathname
74 
75  ex:
76  filelist('/castor/cern.ch/atlas/*')
77  filelist('/castor/cern.ch/atl*/foo?[bar]/*.pool.root.?')
78  filelist('/eos/atlas/*', prefix='root://eosatlas.cern.ch/')
79  filelist('/castor/cern.ch/atlas/*', prefix=True)
80  """
81 
82  path, fname = os.path.split(files)
83  path = _rationalise(path)
84 
85  if ( path.count('*') > 0 or path.count('?') > 0 or
86  path.count('[') > 0 or path.count(']') > 0 ) :
87  paths = ls(path)
88  return sum([ls(os.path.join(p,fname))
89  for p in paths], [])
90 
91  mgr = storageManager(path)
92 
93  try:
94  flist = subprocess.check_output(mgr.ls % path, shell=True).split()
95  except subprocess.CalledProcessError as err:
96  print(err.output)
97  return []
98 
99  if not (os.path.basename(files) in ['', '*']): # no need to filter
100  pattern = fnmatch.translate(os.path.basename(files))
101  flist = filter(lambda x: re.search(pattern, x), flist)
102 
103  if prefix:
104  if isinstance(prefix, str):
105  return [os.path.join(prefix+path, p) for p in flist]
106  else:
107  return [os.path.join(mgr.prefix+path, p) for p in flist]
108  else:
109  return [os.path.join(path, p) for p in flist]
110 
111 @deprecated("EOS is mounted on /eos with fuse, so you probably don't need this abstraction")
112 def ls(path, longls=False):
113  """
114  Simple list of files
115 
116  `longls` specifies long listing format
117  """
118 
119  path = _rationalise(path)
120  mgr = storageManager(path)
121 
122  if longls:
123  return subprocess.check_output(mgr.longls % path, shell=True)
124  else:
125  return subprocess.check_output(mgr.ls % path, shell=True)
126 
127 @deprecated("EOS is mounted on /eos with fuse, so you probably don't need this abstraction")
128 def cp(src, dest='.'):
129  src = _rationalise(src)
130  dest = _rationalise(dest)
131  srcmgr = storageManager(src)
132  destmgr = storageManager(dest)
133 
134  cp = 'cp'
135  if srcmgr.cp == 'xrdcp' or destmgr.cp == 'xrdcp': cp = 'xrdcp'
136 
137  return os.system('%s %s%s %s%s' %(cp, srcmgr.prefix, src, destmgr.prefix, dest))
138 
139 
140 
141 class AccessError(RuntimeError): pass
142 
143 def get_lumi_blocks(root_file):
144 
145  try:
146  from PyUtils.RootUtils import import_root
147  root = import_root()
148  f = root.TFile.Open(root_file, 'READ')
149 
150  meta = f.Get( 'MetaData' )
151  if not meta:
152  raise Exception('No metadata')
153 
154  meta.GetEntry( 0 )
155 
156  esiName= 'Stream'
157  esiTypeName = 'EventStreamInfo'
158  for l in meta.GetListOfLeaves():
159  if l.GetTypeName().startswith(esiTypeName):
160  esiTypeName = l.GetTypeName()
161  esiName = l.GetName()
162  break
163 
164  if esiTypeName != 'EventStreamInfo_p3':
165  raise Exception("old schema is not supported:", esiTypeName)
166 
167  import cppyy
168 
169  esic = cppyy.gbl.EventStreamInfoPTCnv_p3()
170  esi = getattr (meta, esiName)
171  if esiName.startswith(esiTypeName):
172  esiName = esiName[len(esiTypeName)+1:]
173 
174  return( list(esic.lumiBlockNumbers(esi)) )
175 
176  except Exception as e:
177  print( "Failed to read MetaData will fall back to looping ", repr(e))
178  finally:
179  f.Close()
180 
181  try:
182  from PyUtils.RootUtils import import_root
183  root = import_root()
184  f = root.TFile.Open(root_file, 'READ')
185  lumiblocks = set()
186  metadata= f.Get('CollectionMetadata') if f else None
187  if metadata:
188  metadata.GetEntry(0)
189  import ctypes
190  key_name = str(ctypes.c_char_p(metadata.Key).value)
191  assert key_name == 'POOLCollectionID'
192  del metadata
193  coll_tree = f.Get('POOLCollectionTree') if f else None
194  if coll_tree:
195  evtmax = coll_tree.GetEntries()
196  if evtmax in (-1, None):
197  evtmax = 0
198  evtmax = int(evtmax)
199  for row in range(evtmax):
200  if coll_tree.GetEntry(row) < 0:
201  break
202  lbn = coll_tree.LumiBlockN
203  lumiblocks.add(lbn)
204  del coll_tree
205  return list( lumiblocks )
206  finally:
207  f.Close()
208 
209 def make_lumi_block_map_file(file_set, path):
210  with open(path, 'w') as mapfile:
211  for f, lbs in file_set.with_lumi_blocks():
212  print('Reading:', f)
213  mapfile.write('{} {}\n'.format(
214  os.path.basename(f),
215  ','.join(str(x) for x in lbs)))
216 
217 
218 class Backend:
219  def exists(self, path): raise NotImplementedError
220  def is_file(self, path): raise NotImplementedError
221  def is_directory(self, path): raise NotImplementedError
222  def children(self, path): raise NotImplementedError
223  def glob(self, pattern): raise NotImplementedError
224  def wrap(self, path): return path
225 
226 class Local(Backend):
227  def exists(self, path): return os.path.exists(path)
228  def is_directory(self, path): return os.path.isdir(path)
229  def is_file(self, path): return os.path.isfile(path)
230 
231  def children(self, path):
232  def generator(p):
233  for dir_name, dirs, files in os.walk(p):
234  for f in files:
235  yield os.path.join(dir_name, f)
236  return generator(path)
237 
238  def glob(self, pattern):
239  return glob.glob(pattern)
240 
241 class EOS(Backend):
242  """ Accesses EOS using the command line interface.
243  NB: when EOS is fuse-mounted on /eos this class is not really necessary.
244  """
245 
246  def __init__(self, prefix='root://eosatlas.cern.ch/'):
247  self.prefix = prefix
248 
249  def wrap(self, path):
250  if path.startswith('/'):
251  path = self.prefix + path
252  return path
253 
254  def unwrap(self, path):
255  if path.startswith(self.prefix):
256  path = path[len(self.prefix):]
257  return path
258 
259  def exists(self, path):
260  return self._call('eos', '-b', 'ls', '-s', self.unwrap(path)) == 0
261 
262  def is_file(self, path):
263  return self._call('eos', '-b', 'sat', '-f', self.unwrap(path)) == 0
264 
265  def is_directory(self, path):
266  return self._call('eos', '-b', 'sat', '-d', self.unwrap(path)) == 0
267 
268  def children(self, path):
269  with open(os.devnull, 'w') as null:
270  output = subprocess.check_output(['eos', '-b', 'find', '-f',
271  self.unwrap(path)], stderr=null)
272  return [l.strip() for l in output.split('\n')]
273 
274  def _call(self, *args):
275  with open(os.devnull, 'w') as null:
276  retcode = subprocess.call(args, stderr=null)
277  return retcode
278 
279 class FilterError(RuntimeError): pass
280 
281 class FileSet:
282  """ Represents a list of input files.
283  This class abstracts over the different ways files can be specified, and
284  the different storage backends/protocols on which they reside. It is an
285  iterator, and provides some methods for filtering the file set. E.g.:
286 
287  fs = FileSet.from_input('/eos/atlas/path/to/dataset/')
288  for f in fs.matching(r'.*AOD.*').only_existing():
289  print(f)
290  """
291 
292  def __init__(self, iterator, backend):
293  self.backend = backend
294  self._iter = iterator
295  self._existing = False
296  self._white_pattern = None
297  self._black_pattern = None
298  self._strict = True
299  self._explicit = None
300  self._dedup = False
301  self._single_dataset = False
302  self.broken = []
303  self.lb_map = {}
304 
305  @classmethod
306  def from_single_file(cls, path, backend=None):
307  return cls(iter([path]), backend or Local())
308 
309  @classmethod
310  def from_directory(cls, path, backend=None):
311  be = backend or Local()
312  return cls(be.children(path), be)
313 
314  @classmethod
315  def from_file_containing_list(cls, path, backend=None):
316  with open(path) as lf:
317  listtoiter = [l.strip() for l in lf.readlines()]
318  iterator = iter(listtoiter)
319  return cls(iterator, backend or Local())
320 
321  @classmethod
322  def from_glob(cls, pattern, backend=None):
323  be = backend or Local()
324  return cls(be.glob(pattern), be)
325 
326  @classmethod
327  def from_ds_info(cls, run, project, stream, base, backend=None):
328  path = os.path.join(base, project, stream,
329  '{:0{digits}d}'.format(int(run), digits=8))
330  return cls.from_directory(path, backend=backend)
331 
332  @classmethod
333  def from_input(cls, input_string, backend=None):
334  ''' Guess what kind of input file specification was provided. '''
335  be = backend or Local()
336  if be.is_directory(input_string):
337  return cls.from_directory(input_string, be)
338  elif Local().is_file(input_string) and not (
339  input_string.endswith('.root') or
340  input_string[-7:-2] == '.root'):
341  return cls.from_file_containing_list(input_string, be)
342  elif be.is_file(input_string):
343  return cls.from_single_file(input_string, be)
344  elif '*' in input_string or '?' in input_string or '[' in input_string:
345  return cls.from_glob(input_string, be)
346  else:
347  raise AccessError('Unable to resolve input: ' + repr(input_string))
348 
349  def __iter__(self):
350  it = self._iter
351  if self._white_pattern:
352  it = filter(lambda x: self._white_pattern.search(x), it)
353  if self._black_pattern:
354  it = filter(lambda x: not self._black_pattern.search(x), it)
355  if self._existing: # see: only_existing
356  if self._strict:
357  def generator(i, b):
358  for f in i:
359  if b.exists(f):
360  yield f
361  else:
362  raise AccessError('File not found: ' + f)
363  it = generator(it, self.backend)
364  else:
365  it = filter(lambda x: self.backend.exists(x), it)
366  if self._explicit is not None: # see: use_files_from
367  def generator(i, strict):
368  for f in i:
369  name = os.path.basename(f)
370  if self._explicit.pop(name, False):
371  yield f
372  if strict and self._explicit:
373  for f in self._explicit: print('Missing:', f)
374  raise FilterError('Not all explicit files were found.')
375  it = generator(it, self._strict)
376  if self._dedup: # see: only_latest
377  def fn(m, f):
378  name, ext = os.path.splitext(f)
379  if name in m:
380  m[name] = str(max(int(m[name]), int(ext[1:])))
381  else:
382  m[name] = ext[1:]
383  return m
384  def generator(em):
385  for name, ext in em.items():
386  yield '.'.join([name, ext])
387  it = generator(functools.reduce(fn, self, {}))
388  if self._single_dataset: # see: only_single_dataset
389  def generator(i):
390  dataset = None
391  for f in i:
392  ds = '.'.join(f.split('.')[0:3])
393  if dataset is None:
394  dataset = ds
395  if ds == dataset:
396  yield f
397  else:
398  raise FilterError(
399  "Files found from more than one dataset: '{}' != '{}'"
400  .format(ds, dataset))
401  it = generator(it)
402  it = map(lambda x: self.backend.wrap(x), it)
403  return it
404 
405  def strict_mode(self, setting=True):
406  """ When strict, errors are raised in the following cases (which
407  otherwise cause the corresponding files to be silently skipped):
408 
409  * When LB info is requested but cannot be found for a file (because
410  it was not in the map file, or we couldn't open the ROOT file).
411  * When `only_existing` is set and a file is missing.
412  * When a file list is provided and not all of the files it mentions
413  were encountered by the end of iteration.
414  """
415  self._strict = setting
416  return self
417 
418  def matching(self, pattern):
419  ''' Only accept filenames matching the provided regular expression. '''
420  self._white_pattern = re.compile(pattern) if pattern else None
421  return self
422 
423  def excluding(self, pattern):
424  ''' Skip filenames matching the provided regular expression. '''
425  self._black_pattern = re.compile(pattern) if pattern else None
426  return self
427 
428  def use_files_from(self, path):
429  ''' Use specific filenames from within the provided dataset. '''
430  if path:
431  with open(path) as lf:
432  self._explicit = [l.strip() for l in lf.readlines()]
433  else:
434  self._explicit = None
435  return self
436 
437  def only_existing(self, setting=True):
438  ''' Only use existing files. '''
439  self._existing = setting
440  return self
441 
442  def only_latest(self, setting=True):
443  ''' Keep only the latest retry from sets like `*.1`, `*.2`. '''
444  self._dedup = setting
445  return self
446 
447  def only_single_dataset(self, setting=True):
448  ''' Require all files to be from the same dataset. '''
449  self._single_dataset = setting
450  return self
451 
452  def with_lumi_blocks(self, map_file=None):
453  """ Lookup the luminosity blocks contained in each file.
454  If a map file is provided it will be queried for the LB mapping,
455  otherwise each file will be opened and accessed using AthenaROOTAccess
456  which can be a little slow.
457  """
458  if map_file:
459  return self._with_lumi_blocks_from_map(map_file)
460  else:
461  return self._with_lumi_blocks_from_ara()
462 
463  def _with_lumi_blocks_from_map(self, map_file):
464  with open(map_file) as mf:
465  for line in mf:
466  print(line)
467  fname = line.split(' ')[0]
468  print(line.split(' ')[0])
469  print(line.split(' ')[1])
470  lbs = set(int(l) for l in line.split(' ')[1].split(','))
471  self.lb_map[fname] = lbs
472  def generator(s):
473  for f in s:
474  try:
475  yield f, s.lb_map[os.path.basename(f)]
476  except KeyError:
477  if s._strict:
478  raise
479  else:
480  s.broken.append(f)
481  return generator(self)
482 
484  def generator(s):
485  for f in s:
486  try:
487  lbs = get_lumi_blocks(f)
488  except AccessError:
489  if s._strict:
490  raise
491  else:
492  s.broken.append(f)
493  continue
494  yield f, set(lbs)
495  return generator(self)
python.DiskUtils.AccessError
Definition: DiskUtils.py:141
python.DiskUtils.EOS.exists
def exists(self, path)
Definition: DiskUtils.py:259
python.DiskUtils.FileSet._white_pattern
_white_pattern
Definition: DiskUtils.py:296
python.DiskUtils.EOS.is_directory
def is_directory(self, path)
Definition: DiskUtils.py:265
vtune_athena.format
format
Definition: vtune_athena.py:14
python.DiskUtils.FileSet.broken
broken
Definition: DiskUtils.py:302
python.DiskUtils.deprecated
def deprecated(message)
Definition: DiskUtils.py:14
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
python.DiskUtils.FileSet.with_lumi_blocks
def with_lumi_blocks(self, map_file=None)
Definition: DiskUtils.py:452
max
constexpr double max()
Definition: ap_fixedTest.cxx:33
python.DiskUtils.FileSet._black_pattern
_black_pattern
Definition: DiskUtils.py:297
python.DiskUtils.FileSet.use_files_from
def use_files_from(self, path)
Definition: DiskUtils.py:428
python.DiskUtils.FileSet._explicit
_explicit
Definition: DiskUtils.py:299
python.DiskUtils.FileSet._single_dataset
_single_dataset
Definition: DiskUtils.py:301
CaloClusterListBadChannel.cls
cls
Definition: CaloClusterListBadChannel.py:8
python.DiskUtils.Local
Definition: DiskUtils.py:226
python.DiskUtils.FileSet.__init__
def __init__(self, iterator, backend)
Definition: DiskUtils.py:292
python.DiskUtils.FileSet._strict
_strict
Definition: DiskUtils.py:298
search
void search(TDirectory *td, const std::string &s, std::string cwd, node *n)
recursive directory search for TH1 and TH2 and TProfiles
Definition: hcg.cxx:738
python.DiskUtils.EOS.__init__
def __init__(self, prefix='root://eosatlas.cern.ch/')
Definition: DiskUtils.py:246
python.DiskUtils.FilterError
Definition: DiskUtils.py:279
python.RootUtils.import_root
def import_root(batch=True)
functions --------------------------------------------------------------—
Definition: RootUtils.py:22
python.DiskUtils.EOS.prefix
prefix
Definition: DiskUtils.py:247
covarianceTool.filter
filter
Definition: covarianceTool.py:514
python.DiskUtils.Backend.is_directory
def is_directory(self, path)
Definition: DiskUtils.py:221
python.getCurrentFolderTag.fn
fn
Definition: getCurrentFolderTag.py:65
convertTimingResiduals.sum
sum
Definition: convertTimingResiduals.py:55
python.DiskUtils.FileSet.from_input
def from_input(cls, input_string, backend=None)
Definition: DiskUtils.py:333
python.DiskUtils.EOS.wrap
def wrap(self, path)
Definition: DiskUtils.py:249
python.DiskUtils.FileSet
Definition: DiskUtils.py:281
python.DiskUtils.Local.exists
def exists(self, path)
Definition: DiskUtils.py:227
python.DiskUtils.FileSet.excluding
def excluding(self, pattern)
Definition: DiskUtils.py:423
python.DiskUtils.FileSet._with_lumi_blocks_from_ara
def _with_lumi_blocks_from_ara(self)
Definition: DiskUtils.py:483
plotBeamSpotVxVal.range
range
Definition: plotBeamSpotVxVal.py:195
python.DiskUtils.FileSet.matching
def matching(self, pattern)
Definition: DiskUtils.py:418
PyAthena::repr
std::string repr(PyObject *o)
returns the string representation of a python object equivalent of calling repr(o) in python
Definition: PyAthenaUtils.cxx:106
python.DiskUtils.Local.glob
def glob(self, pattern)
Definition: DiskUtils.py:238
python.DiskUtils.cp
def cp(src, dest='.')
Definition: DiskUtils.py:128
histSizes.list
def list(name, path='/')
Definition: histSizes.py:38
python.DiskUtils.FileSet.only_latest
def only_latest(self, setting=True)
Definition: DiskUtils.py:442
python.DiskUtils.FileSet.from_file_containing_list
def from_file_containing_list(cls, path, backend=None)
Definition: DiskUtils.py:315
python.DiskUtils.FileSet._with_lumi_blocks_from_map
def _with_lumi_blocks_from_map(self, map_file)
Definition: DiskUtils.py:463
python.DiskUtils.FileSet.from_directory
def from_directory(cls, path, backend=None)
Definition: DiskUtils.py:310
python.DiskUtils.Local.is_file
def is_file(self, path)
Definition: DiskUtils.py:229
python.DiskUtils.get_lumi_blocks
def get_lumi_blocks(root_file)
Definition: DiskUtils.py:143
python.DiskUtils.FileSet.backend
backend
Definition: DiskUtils.py:293
python.DiskUtils.FileSet.from_single_file
def from_single_file(cls, path, backend=None)
Definition: DiskUtils.py:306
CxxUtils::set
constexpr std::enable_if_t< is_bitmask_v< E >, E & > set(E &lhs, E rhs)
Convenience function to set bits in a class enum bitmask.
Definition: bitmask.h:232
python.DiskUtils.StorageManager
StorageManager
Definition: DiskUtils.py:29
python.DiskUtils.filelist
def filelist(files, prefix=None)
Definition: DiskUtils.py:64
print
void print(char *figname, TCanvas *c1)
Definition: TRTCalib_StrawStatusPlots.cxx:25
TCS::join
std::string join(const std::vector< std::string > &v, const char c=',')
Definition: Trigger/TrigT1/L1Topo/L1TopoCommon/Root/StringUtils.cxx:10
python.DiskUtils.storageManager
def storageManager(name)
Definition: DiskUtils.py:51
python.DiskUtils.EOS.is_file
def is_file(self, path)
Definition: DiskUtils.py:262
python.DiskUtils.Backend.exists
def exists(self, path)
Definition: DiskUtils.py:219
python.DiskUtils.FileSet.strict_mode
def strict_mode(self, setting=True)
Definition: DiskUtils.py:405
python.DiskUtils.FileSet.lb_map
lb_map
Definition: DiskUtils.py:303
python.DiskUtils.Local.children
def children(self, path)
Definition: DiskUtils.py:231
Trk::open
@ open
Definition: BinningType.h:40
mc.generator
generator
Configure Herwig7 These are the commands corresponding to what would go into the regular Herwig infil...
Definition: mc.MGH7_FxFx_H71-DEFAULT_test.py:18
python.DiskUtils.EOS._call
def _call(self, *args)
Definition: DiskUtils.py:274
python.DiskUtils.Local.is_directory
def is_directory(self, path)
Definition: DiskUtils.py:228
python.DiskUtils._rationalise
def _rationalise(path)
Definition: DiskUtils.py:35
str
Definition: BTagTrackIpAccessor.cxx:11
python.DiskUtils.ls
def ls(path, longls=False)
Definition: DiskUtils.py:112
python.DiskUtils.FileSet.from_ds_info
def from_ds_info(cls, run, project, stream, base, backend=None)
Definition: DiskUtils.py:327
python.DiskUtils.EOS
Definition: DiskUtils.py:241
python.DiskUtils.EOS.unwrap
def unwrap(self, path)
Definition: DiskUtils.py:254
python.dummyaccess.exists
def exists(filename)
Definition: dummyaccess.py:9
python.DiskUtils.EOS.children
def children(self, path)
Definition: DiskUtils.py:268
python.DiskUtils.FileSet._dedup
_dedup
Definition: DiskUtils.py:300
python.DiskUtils.FileSet.from_glob
def from_glob(cls, pattern, backend=None)
Definition: DiskUtils.py:322
python.DiskUtils.FileSet._existing
_existing
Definition: DiskUtils.py:295
Trk::split
@ split
Definition: LayerMaterialProperties.h:38
python.DiskUtils.Backend
Definition: DiskUtils.py:218
python.DiskUtils.FileSet.__iter__
def __iter__(self)
Definition: DiskUtils.py:349
python.DiskUtils.FileSet.only_single_dataset
def only_single_dataset(self, setting=True)
Definition: DiskUtils.py:447
python.DiskUtils.FileSet.only_existing
def only_existing(self, setting=True)
Definition: DiskUtils.py:437
python.DiskUtils.make_lumi_block_map_file
def make_lumi_block_map_file(file_set, path)
Definition: DiskUtils.py:209
python.DiskUtils.FileSet._iter
_iter
Definition: DiskUtils.py:294
python.DiskUtils.Backend.glob
def glob(self, pattern)
Definition: DiskUtils.py:223