def load(self, fname=[], to_state=BIBOLAMAZIFILE_LOADED): """ Load the given file into the current object. If `fname` is `None`, then reset the object to an empty state. If `fname` is not given or an empty ``list``, then use any previously loaded fname and its state. This function may be called several times with different states to incrementally load the file, for example:: bibolamazifile.reset() # load up to 'parsed' state bibolamazifile.load(fname="somefile.bibolamazi.bib", to_state=BIBOLAMAZIFILE_PARSED) # continue loading up to fully 'loaded' state bibolamazifile.load(fname="somefile.bibolamazi.bib", to_state=BIBOLAMAZIFILE_LOADED) If `to_state` is given, will only attempt to load the file up to that state. This can be useful, e.g., in a config editor which needs to parse the sections of the file but does not need to worry about syntax errors. The state should be one of :py:const:`BIBOLAMAZIFILE_INIT`, :py:const:`BIBOLAMAZIFILE_READ`, :py:const:`BIBOLAMAZIFILE_PARSED` or :py:const:`BIBOLAMAZIFILE_LOADED`. """ if (isinstance(fname, list) and not fname): # fname=[], so keep old file name and properties. pass else: #if (fname or not isinstance(fname, list)): # required to replace current file, if one open self._fname = fname self._dir = os.path.dirname(os.path.realpath(fname)) if fname is not None else None self._load_state = BIBOLAMAZIFILE_INIT self._header = None self._config = None self._config_data = None self._startconfigdatalineno = None self._rest = None self._cmds = None self._sources = None self._source_lists = [] self._filters = [] self._cache_accessors = {} # dict { class-type: class-instance } self._bibliographydata = None self._user_cache = BibUserCache(cache_version=butils.get_version()) if (to_state >= BIBOLAMAZIFILE_READ and self._load_state < BIBOLAMAZIFILE_READ): try: with codecs.open(self._fname, 'r', encoding=BIBOLAMAZI_FILE_ENCODING) as f: logger.longdebug("File "+repr(self._fname)+" opened.") self._read_config_stream(f, self._fname) except IOError as e: raise BibolamaziError(u"Can't open file `%s': %s" %(self._fname, unicode(e))) if (to_state >= BIBOLAMAZIFILE_PARSED and self._load_state < BIBOLAMAZIFILE_PARSED): self._parse_config() if (to_state >= BIBOLAMAZIFILE_LOADED and self._load_state < BIBOLAMAZIFILE_LOADED): self._load_contents() return True
def saveToFile(self): """ Save the current bibolamazi file object to disk. This will write to the file :py:meth:`fname()` in order: - the raw header data (:py:meth:`rawHeader()`) unchanged - the config section text (:py:meth:`rawConfig()`) unchanged - the bibliography data contained in :py:meth:`bibliographyData`, saved in BibTeX format. A warning message is included after the config section that the remainder of the file was automatically generated. As the file `fname` is expected to already exist, it is always silently overwritten (so be careful). """ with codecs.open(self._fname, 'w', BIBOLAMAZI_FILE_ENCODING) as f: f.write(self._header) f.write(self._config) f.write(_repl(AFTER_CONFIG_TEXT, { r'__BIBOLAMAZI_VERSION__': butils.get_version(), r'__DATETIME_NOW__': datetime.now().isoformat() })) if (self._bibliographydata): # # Pybtex 0.18: bibtex writer uses entry.original_type instead of # entry.type. (Why?? no idea) # # So if any filters changed entry.type, reflect that in # entry.original_type. for key, entry in self._bibliographydata.entries.iteritems(): entry.original_type = entry.type # # Write to bibtex output # w = outputbibtex.Writer() w.write_stream(self._bibliographydata, f) logger.info("Updated output file `"+self._fname+"'.") # if we have cache to save, save it if (self._user_cache and self._user_cache.hasCache()): cachefname = self.cacheFileName() try: with open(cachefname, 'wb') as f: logger.debug("Writing cache to file %s" %(cachefname)) self._user_cache.saveCache(f) except IOError as e: logger.debug("Couldn't save cache to file `%s'." %(cachefname)) pass
def saveToFile(self, fname=None, cachefname=None): """ Save the current bibolamazi file object to disk. This method will write the bibliography data to the file specified to by `fname` (or :py:meth:`fname()` if `fname=None`). Specifically, we will write in order: - the raw header data (:py:meth:`rawHeader()`) unchanged - the config section text (:py:meth:`rawConfig()`) unchanged - the bibliography data contained in :py:meth:`bibliographyData`, saved in BibTeX format. A warning message is included after the config section that the remainder of the file was automatically generated. The cache is also saved, unless `cachefname=False`. If `cachefname=None` (the default) or `cachefname=True`, the cache is saved to the *old* file name with extension '.bibolamazicache', that is, the one given by `self.fname()` and not in `fname`. (The rationale is that we want to be able to use the cache next time we open the file `self.fname()`.) You may also specify `cachefname=<file name>` to save the cache to a specific file name. NOTE: this file is silently overwritten. As the file `fname` is expected to already exist, it is always silently overwritten (so be careful). Same with the cache file. """ if fname is None: fname = self._fname if cachefname is None or (isinstance(cachefname, bool) and cachefname): cachefname = self.cacheFileName() elif isinstance(cachefname, bool) and not cachefname: cachefname = '' else: pass # cachefname has a specific file name with codecs.open(fname, 'w', BIBOLAMAZI_FILE_ENCODING) as f: f.write(self._header) f.write(self._config) f.write(_repl(AFTER_CONFIG_TEXT, { r'__BIBOLAMAZI_VERSION__': butils.get_version(), r'__DATETIME_NOW__': datetime.now().isoformat() })) if (self._bibliographydata): # # Pybtex 0.18: bibtex writer uses entry.original_type instead of # entry.type. (Why?? no idea) # # So if any filters changed entry.type, reflect that in # entry.original_type. for key, entry in self._bibliographydata.entries.iteritems(): entry.original_type = entry.type # # Write to bibtex output # w = outputbibtex.Writer() w.write_stream(self._bibliographydata, f) logger.info("Updated output file `"+self._fname+"'.") # if we have cache to save, save it if (cachefname and self._user_cache and self._user_cache.hasCache()): try: with open(cachefname, 'wb') as f: logger.debug("Writing cache to file %s" %(cachefname)) self._user_cache.saveCache(f) except IOError as e: logger.debug("Couldn't save cache to file `%s'." %(cachefname)) pass