def get(self, key, unit=None, default=None, with_unit=False): """ Retrieve fdf-keyword from the file """ # First split into specification and key key, tmp_unit = str_spec(key) if unit is None: unit = tmp_unit found, fdf = self._read(key) if not found: return default # The keyword is found... if fdf.startswith('%block'): found, fdf = self._read_block(key) if not found: return default else: return fdf # We need to process the returned value further. fdfl = fdf.split() # Check whether this is a logical flag if len(fdfl) == 1: # This *MUST* be a boolean # SCF.Converge.H # defaults to .true. return True elif fdfl[1] in _LOGICAL_TRUE: return True elif fdfl[1] in _LOGICAL_FALSE: return False # It is something different. # Try and figure out what it is if len(fdfl) == 3: # We expect it to be a unit if unit is None: # Get group of unit group = unit_group(fdfl[2]) # return in default sisl units unit = unit_default(group) if with_unit and tmp_unit is not None: # The user has specifically requested the unit: # key{unit} return '{0:.4f} {1}'.format( float(fdfl[1]) * unit_convert(fdfl[2], unit), unit) elif not with_unit: return float(fdfl[1]) * unit_convert(fdfl[2], unit) return ' '.join(fdfl[1:])
def get_sile(file, *args, **kwargs): """ Guess the ``Sile`` corresponding to the input file and return an open object of the corresponding ``Sile`` Parameters ---------- file : str the file to be quried for a correct `Sile` object. This file name may contain {<class-name>} which sets `cls` in case `cls` is not set. For instance: water.dat{XYZSile} will read the file water.dat as an `XYZSile`. cls : class In case there are several files with similar file-suffixes you may query the exact base-class that should be chosen. If there are several `Sile`s with similar file-endings this function returns a random one. """ cls = kwargs.pop('cls', None) sile = get_sile_class(file, *args, cls=cls, **kwargs) return sile(str_spec(file)[0], *args, **kwargs)
def get_sile(file, *args, **kwargs): """ Retrieve an object from the global lookup table via filename and the extension Internally this is roughly equivalent to ``get_sile_class(...)()``. Parameters ---------- file : str or pathlib.Path the file to be quried for a correct `Sile` object. This file name may contain {<class-name>} which sets `cls` in case `cls` is not set. For instance ``get_sile("water.dat{xyzSile}")`` will read the file ``water.dat`` using the `xyzSile` class. cls : class In case there are several files with similar file-suffixes you may query the exact base-class that should be chosen. If there are several files with similar file-endings this function returns a random one. """ cls = kwargs.pop('cls', None) sile = get_sile_class(file, *args, cls=cls, **kwargs) return sile(Path(str_spec(str(file))[0]), *args, **kwargs)
def get_sile_class(filename, *args, **kwargs): """ Retrieve a class from the global lookup table via filename and the extension Parameters ---------- filename : str the file to be quried for a correct file object. This file name may contain {<class-name>} which sets `cls` in case `cls` is not set. For instance: water.xyz will return an `xyzSile`. cls : class, optional In case there are several files with similar file-suffixes you may query the exact base-class that should be chosen. If there are several files with similar file-endings this function returns a random one. """ global __sile_rules, __siles # This ensures that the first argument need not be cls cls = kwargs.pop('cls', None) # Split filename into proper file name and # the Specification of the type tmp_file, fcls = str_spec(str(filename)) if cls is None and not fcls is None: # cls has not been set, and fcls is found # Figure out if fcls is a valid sile, if not # do nothing (it may be part of the file name) # Which is REALLY obscure... but....) fclsl = fcls.lower() for sr in __sile_rules: if sr.in_class(fclsl): cls = sr.cls else: cls = sr.get_base(fclsl) if cls is not None: filename = tmp_file break try: # Create list of endings on this file f = basename(filename) end_list = [] end = '' # Check for files without ending, or that they are directly zipped lext = splitext(f) while len(lext[1]) > 0: end = lext[1] + end if end[0] == '.': end_list.append(end[1:]) else: end_list.append(end) lext = splitext(lext[0]) # We also check the entire file name # (mainly for VASP) end_list.append(f) # Reverse to start by the longest extension # (allows grid.nc extensions, etc.) end_list = list(reversed(end_list)) # First we check for class AND file ending clss = None for end in end_list: for sr in __sile_rules: if sr.is_class(cls): # class-specification has precedence # This should only occur when the # class-specification is exact (i.e. xyzSile) return sr.cls elif sr.is_suffix(end): if cls is None: return sr.cls elif sr.is_subclass(cls): return sr.cls clss = sr.cls if clss is not None: return clss if clss is None: raise NotImplementedError( "Sile for file '{}' could not be found, " "possibly the file has not been implemented.".format(filename)) return clss except Exception as e: raise e
def get_sile_class(file, *args, **kwargs): """ Guess the ``Sile`` class corresponding to the input file and return the class Parameters ---------- file : str the file to be quried for a correct `Sile` object. This file name may contain {<class-name>} which sets `cls` in case `cls` is not set. For instance: water.xyz will return an ``XYZSile``. cls : class In case there are several files with similar file-suffixes you may query the exact base-class that should be chosen. If there are several ``Sile``s with similar file-endings this function returns a random one. """ global __sile_rules, __siles # This ensures that the first argument need not be cls cls = kwargs.pop('cls', None) # Split filename into proper file name and # the specification of the type tmp_file, fcls = str_spec(file) if cls is None and not fcls is None: # cls has not been set, and fcls is found # Figure out if fcls is a valid sile, if not # do nothing (it may be part of the file name) # Which is REALLY obscure... but....) for sile in __siles: if sile.__name__.lower().startswith(fcls.lower()): cls = sile # Make sure that {class-name} is # removed from the file name file = tmp_file break try: # Create list of endings on this file f = file end_list = [] end = '' # Check for files without ending, or that they are directly zipped lext = splitext(f) while len(lext[1]) > 0: end = lext[1] + end if end[0] == '.': end_list.append(end[1:]) else: end_list.append(end) lext = splitext(lext[0]) # We also check the entire file name # (mainly for VASP) end_list.append(f) # Reverse to start by the longest extension # (allows grid.nc extensions, etc.) end_list = list(reversed(end_list)) # First we check for class AND file ending for end in end_list: for suf, base, fobj in __sile_rules: if end != suf: continue if cls is None: return fobj elif cls == base: return fobj # Now we skip the limitation of the suffix, # now only the base-class is necessary. for end in end_list: # Check for object for suf, base, fobj in __sile_rules: if cls == base: return fobj del end_list raise NotImplementedError('sile not implemented: {}'.format(file)) except NotImplementedError as e: pass except Exception as e: import traceback as t t.print_exc() raise e raise NotImplementedError( "Sile for file '" + file + "' could not be found, possibly the file has not been implemented.")