def save(traces, filename_template, additional={}, max_open_files=10): fns = set() open_files = {} def close_files(): while open_files: open_files.popitem()[1].close() for tr in traces: fn = tr.fill_template(filename_template, **additional) if fn not in open_files: if len(open_files) >= max_open_files: close_files() if fn not in fns: ensuredirs(fn) open_files[fn] = open(fn, 'wa'[fn in fns]) fns.add(fn) tf = TracesFileIO(open_files[fn]) tf.save([tr]) tf.close() close_files() return list(fns)
def save(traces, filename_template, format='mseed', additional={}, stations=None): '''Save traces to file(s). :param traces: a trace or an iterable of traces to store :param filename_template: filename template with placeholders for trace metadata. Uses normal python '%(placeholder)s' string templates. The following placeholders are considered: ``network``, ``station``, ``location``, ``channel``, ``tmin`` (time of first sample), ``tmax`` (time of last sample), ``tmin_ms``, ``tmax_ms``, ``tmin_us``, ``tmax_us``. The versions with '_ms' include milliseconds, the versions with '_us' include microseconds. :param format: ``mseed``, ``sac``, ``text``, or ``yaff``. :param additional: dict with custom template placeholder fillins. :returns: list of generated filenames .. note:: Network, station, location, and channel codes may be silently truncated to file format specific maximum lengthes. ''' if isinstance(traces, trace.Trace): traces = [ traces ] if format == 'from_extension': format = os.path.splitext(filename_template)[1][1:] if format == 'mseed': return mseed.save(traces, filename_template, additional) elif format == 'sac': fns = [] for tr in traces: f = sac.SacFile(from_trace=tr) if stations: s = stations[tr.network, tr.station, tr.location] f.stla = s.lat f.stlo = s.lon f.stel = s.elevation f.stdp = s.depth f.cmpinc = s.get_channel(tr.channel).dip + 90. f.cmpaz = s.get_channel(tr.channel).azimuth fn = tr.fill_template(filename_template, **additional) util.ensuredirs(fn) f.write(fn) fns.append(fn) return fns elif format == 'text': fns = [] for tr in traces: fn = tr.fill_template(filename_template, **additional) x,y = tr.get_xdata(), tr.get_ydata() num.savetxt(fn, num.transpose((x,y))) fns.append(fn) elif format == 'yaff': return yaff.save(traces, filename_template, additional) else: raise UnsupportedFormat(format)
def __call__(self, path, mode="r", text=False, atomictemp=False, notindexed=False): '''Open ``path`` file, which is relative to vfs root. Newly created directories are marked as "not to be indexed by the content indexing service", if ``notindexed`` is specified for "write" mode access. ''' if self._audit: r = util.checkosfilename(path) if r: raise util.Abort("%s: %r" % (r, path)) self.audit(path) f = self.join(path) if not text and "b" not in mode: mode += "b" # for that other OS nlink = -1 if mode not in ('r', 'rb'): dirname, basename = util.split(f) # If basename is empty, then the path is malformed because it points # to a directory. Let the posixfile() call below raise IOError. if basename: if atomictemp: util.ensuredirs(dirname, self.createmode, notindexed) return util.atomictempfile(f, mode, self.createmode) try: if 'w' in mode: util.unlink(f) nlink = 0 else: # nlinks() may behave differently for files on Windows # shares if the file is open. fd = util.posixfile(f) nlink = util.nlinks(f) if nlink < 1: nlink = 2 # force mktempcopy (issue1922) fd.close() except (OSError, IOError) as e: if e.errno != errno.ENOENT: raise nlink = 0 util.ensuredirs(dirname, self.createmode, notindexed) if nlink > 0: if self._trustnlink is None: self._trustnlink = nlink > 1 or util.checknlink(f) if nlink > 1 or not self._trustnlink: util.rename(util.mktempcopy(f), f) fp = util.posixfile(f, mode) if nlink == 0: self._fixfilemode(f) return fp
def symlink(self, src, dst): self.audit(dst) linkname = self.join(dst) try: os.unlink(linkname) except OSError: pass util.ensuredirs(os.path.dirname(linkname), self.createmode) if self._cansymlink: try: os.symlink(src, linkname) except OSError, err: raise OSError(err.errno, _("could not symlink to %r: %s") % (src, err.strerror), linkname)
def symlink(self, src, dst): self.audit(dst) linkname = self.join(dst) try: os.unlink(linkname) except OSError: pass util.ensuredirs(os.path.dirname(linkname), self.createmode) if self._cansymlink: try: os.symlink(src, linkname) except OSError, err: raise OSError(err.errno, _('could not symlink to %r: %s') % (src, err.strerror), linkname)
def __call__(self, path, mode="r", text=False, atomictemp=False): if self._audit: r = util.checkosfilename(path) if r: raise util.Abort("%s: %r" % (r, path)) self.audit(path) f = self.join(path) if not text and "b" not in mode: mode += "b" # for that other OS nlink = -1 if mode not in ('r', 'rb'): dirname, basename = util.split(f) # If basename is empty, then the path is malformed because it points # to a directory. Let the posixfile() call below raise IOError. if basename: if atomictemp: util.ensuredirs(dirname, self.createmode) return util.atomictempfile(f, mode, self.createmode) try: if 'w' in mode: util.unlink(f) nlink = 0 else: # nlinks() may behave differently for files on Windows # shares if the file is open. fd = util.posixfile(f) nlink = util.nlinks(f) if nlink < 1: nlink = 2 # force mktempcopy (issue1922) fd.close() except (OSError, IOError), e: if e.errno != errno.ENOENT: raise nlink = 0 util.ensuredirs(dirname, self.createmode) if nlink > 0: if self._trustnlink is None: self._trustnlink = nlink > 1 or util.checknlink(f) if nlink > 1 or not self._trustnlink: util.rename(util.mktempcopy(f), f)
def __call__(self, path, mode="r", text=False, atomictemp=False): if self._audit: r = util.checkosfilename(path) if r: raise util.Abort("%s: %r" % (r, path)) self.audit(path) f = self.join(path) if not text and "b" not in mode: mode += "b" # for that other OS nlink = -1 if mode not in ("r", "rb"): dirname, basename = util.split(f) # If basename is empty, then the path is malformed because it points # to a directory. Let the posixfile() call below raise IOError. if basename: if atomictemp: util.ensuredirs(dirname, self.createmode) return util.atomictempfile(f, mode, self.createmode) try: if "w" in mode: util.unlink(f) nlink = 0 else: # nlinks() may behave differently for files on Windows # shares if the file is open. fd = util.posixfile(f) nlink = util.nlinks(f) if nlink < 1: nlink = 2 # force mktempcopy (issue1922) fd.close() except (OSError, IOError), e: if e.errno != errno.ENOENT: raise nlink = 0 util.ensuredirs(dirname, self.createmode) if nlink > 0: if self._trustnlink is None: self._trustnlink = nlink > 1 or util.checknlink(f) if nlink > 1 or not self._trustnlink: util.rename(util.mktempcopy(f), f)
def save(traces, filename_template, additional={}): fn_tr = {} for tr in traces: fn = tr.fill_template(filename_template, **additional) if fn not in fn_tr: fn_tr[fn] = [] fn_tr[fn].append(tr) for fn, traces_thisfile in fn_tr.items(): trtups = [] traces_thisfile.sort(lambda a, b: cmp(a.full_id, b.full_id)) for tr in traces_thisfile: trtups.append(as_tuple(tr)) ensuredirs(fn) try: mseed_ext.store_traces(trtups, fn) except MSeedError, e: raise MSeedError(str(e) + " (while storing traces to file '%s')" % fn)
def save(traces, filename_template, additional={}): fn_tr = {} for tr in traces: fn = tr.fill_template(filename_template, **additional) if fn not in fn_tr: fn_tr[fn] = [] fn_tr[fn].append(tr) for fn, traces_thisfile in fn_tr.items(): trtups = [] traces_thisfile.sort(lambda a,b: cmp(a.full_id, b.full_id)) for tr in traces_thisfile: trtups.append(as_tuple(tr)) ensuredirs(fn) try: mseed_ext.store_traces(trtups, fn) except MSeedError, e: raise MSeedError( str(e) + ' (while storing traces to file \'%s\')' % fn)