def __call__(self, filename, *args, **kwargs): from ..stokes_spectral_cube import StokesSpectralCube if isinstance(filename, PosixPath): filename = str(filename) kwargs['target_cls'] = StokesSpectralCube try: return registry.read(StokesSpectralCube, filename, *args, **kwargs) except IsADirectoryError: # See note above StringWrapper return registry.read(StokesSpectralCube, StringWrapper(filename), *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read data for multiple bit vector channels into a `StateVectorDict` Parameters ---------- source : `str`, `~glue.lal.Cache` a single file path `str`, or a `~glue.lal.Cache` containing a contiguous list of files. channels : `~gwpy.detector.channel.ChannelList`, `list` a list of channels to read from the source. start : `~gwpy.time.LIGOTimeGPS`, `float`, `str` optional GPS start time of required data, anything parseable by :meth:`~gwpy.time.to_gps` is fine end : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional GPS end time of required data, anything parseable by :meth:`~gwpy.time.to_gps` is fine bits : `list` of `lists`, `dict`, optional the ordered list of interesting bit lists for each channel, or a `dict` of (`channel`, `list`) pairs format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. nproc : `int`, optional, default: ``1`` number of parallel processes to use, serial process by default. .. note:: Parallel frame reading, via the ``nproc`` keyword argument, is only available when giving a :class:`~glue.lal.Cache` of frames, or using the ``format='cache'`` keyword argument. gap : `str`, optional how to handle gaps in the cache, one of - 'ignore': do nothing, let the undelying reader method handle it - 'warn': do nothing except print a warning to the screen - 'raise': raise an exception upon finding a gap (default) - 'pad': insert a value to fill the gaps pad : `float`, optional value with which to fill gaps in the source data, only used if gap is not given, or `gap='pad'` is given Returns ------- statevectordict : `StateVectorDict` a `StateVectorDict` of (`channel`, `StateVector`) pairs. The keys are guaranteed to be the ordered list `channels` as given. Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read data into a `Spectrogram` Arguments and keywords depend on the output format, see the online documentation for full details for each format, the parameters below are common to most formats. Parameters ---------- source : `str`, :class:`~glue.lal.Cache` source of data, any of the following: - `str` path of single data file - `str` path of LAL-format cache file - :class:`~glue.lal.Cache` describing one or more data files, format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats Returns ------- specgram : `Spectrogram` Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read data into a `Spectrogram` Arguments and keywords depend on the output format, see the online documentation for full details for each format, the parameters below are common to most formats. Parameters ---------- source : `str`, `~glue.lal.Cache` source of data, any of the following: - `str` path of single data file - `str` path of LAL-format cache file - `~glue.lal.Cache` describing one or more data files, format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats Returns ------- specgram : `Spectrogram` Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, flags=None, format=None, **kwargs): """Read segments from file into a `DataQualityDict` Parameters ---------- source : `str` path of file to read format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. flags : `list`, optional, default: read all flags found list of flags to read, by default all flags are read separately. coalesce : `bool`, optional, default: `True` coalesce all `SegmentLists` before returning. Returns ------- flagdict : `DataQualityDict` a new `DataQualityDict` of `DataQualityFlag` entries with ``active`` and ``known`` segments seeded from the XML tables in the given file. Notes -----""" return io_registry.read(cls, source, flags=flags, format=format, **kwargs)
def read(cls, source, *args, **kwargs): """Read segments from file into a `DataQualityFlag`. Parameters ---------- filename : `str` path of file to read flag : `str`, optional, default: read all segments name of flag to read from file. format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. coltype : `type`, optional, default: `float` datatype to force for segment times, only valid for ``format='segwizard'``. strict : `bool`, optional, default: `True` require segment start and stop times match printed duration, only valid for ``format='segwizard'``. Returns ------- dqflag : `DataQualityFlag` formatted `DataQualityFlag` containing the active and known segments read from file. Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read data into a `SpectralVariance` Arguments and keywords depend on the output format, see the online documentation for full details for each format, the parameters below are common to most formats. Parameters ---------- source : `str`, `list` Source of data, any of the following: - `str` path of single data file, - `str` path of LAL-format cache file, - `list` of paths. *args Other arguments are (in general) specific to the given ``format``. format : `str`, optional Source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. **kwargs Other keywords are (in general) specific to the given ``format``. Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read data into a `FrequencySeries` Arguments and keywords depend on the output format, see the online documentation for full details for each format, the parameters below are common to most formats. Parameters ---------- source : `str`, `list` Source of data, any of the following: - `str` path of single data file, - `str` path of LAL-format cache file, - `list` of paths. *args Other arguments are (in general) specific to the given ``format``. format : `str`, optional Source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. **kwargs Other keywords are (in general) specific to the given ``format``. Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, *args, **kwargs): """Read and parse gridded N-dimensional data and return as an `~.NDDataBase`-derived object. This function provides the `~.NDDataBase` interface to the astropy unified I/O layer. This allows easily reading a file in the supported data formats. """ return io_registry.read(cls, *args, **kwargs)
def read(cls, *args, **kwargs): """ Read and parse gridded N-dimensional data and return as an NDData-derived object. This function provides the NDDataBase interface to the astropy unified I/O layer. This allows easily reading a file in the supported data formats. """ return io_registry.read(cls, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read a `ChannelList` from a file Parameters ---------- source : `str`, `file` either an open file object, or a file name path to read Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read a `ChannelList` from a file Parameters ---------- source : `str`, `file` either an open file object, or a file name path to read Notes -----""" return io_registry.read(cls, source, *args, **kwargs)
def __call__(self, *args, **kwargs): cls = self._cls out = registry.read(cls, *args, **kwargs) # For some readers (e.g., ascii.ecsv), the returned `out` class is not # guaranteed to be the same as the desired output `cls`. If so, # try coercing to desired class without copying (io.registry.read # would normally do a copy). The normal case here is swapping # Table <=> QTable. if cls is not out.__class__: try: out = cls(out, copy=False) except Exception: raise TypeError('could not convert reader output to {0} ' 'class.'.format(cls.__name__)) return out
def __call__(self, *args, **kwargs): from astropy.cosmology.core import Cosmology # so subclasses can override, also pass the class as a kwarg. # allows for `FlatLambdaCDM.read` and # `Cosmology.read(..., cosmology=FlatLambdaCDM)` if self._cls is not Cosmology: kwargs.setdefault("cosmology", self._cls) # set, if not present # check that it is the correct cosmology, can be wrong if user # passes in e.g. `w0wzCDM.read(..., cosmology=FlatLambdaCDM)` valid = (self._cls, self._cls.__qualname__) if kwargs["cosmology"] not in valid: raise ValueError( "keyword argument `cosmology` must be either the class " f"{valid[0]} or its qualified name '{valid[1]}'") cosmo = io_registry.read(self._cls, *args, **kwargs) return cosmo
def read(cls, source, *args, **kwargs): """Read data into a `StarField` This utility is essentially a wrapper around `~astropy.table.Table.read` which populates a `StarField` from the data collected in a `Table` Parameters ---------- source : `str` path of a single data file from which to read *args : `tuple`, optional other positional arguments passed directly to the underlying reader method for the given format format : `str`, optional file format for input data; if not given, the data reader will attempt to automatically identify the format based on ``source`` **kwargs : `dict`, optional other keyword arguments passed directly to the underlying reader method for the given format Returns ------- field : `StarField` Raises ------ astropy.io.registry.IORegistryError if the `format` cannot be automatically identified Notes -----""" # read as a table, then convert to a `StarField` data = registry.read(Table, source, *args, **kwargs) return cls( theta=data['theta'], phi=data['phi'], mag=data['mag'], angrad=data['angrad'], brightness=data['brightness'], )
def read(cls, source, format=None, **kwargs): """Read segments from file into a `SegmentList` Parameters ---------- filename : `str` path of file to read format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. Returns ------- segmentlist : `SegmentList` `SegmentList` active and known segments read from file. Notes -----""" return io_registry.read(cls, source, format=format, **kwargs)
def __call__(self, *args, **kwargs): return registry.read(self._cls, *args, **kwargs)
def __call__(self, *args, **kwargs): return registry.read(self._cls, *args, **kwargs)
def read(cls, source, *args, **kwargs): """Read data into a `StateVector` Parameters ---------- source : `str`, `~glue.lal.Cache` source of data, any of the following: - `str` path of single data file - `str` path of LAL-format cache file - `~glue.lal.Cache` describing one or more data files, channel : `str`, `~gwpy.detector.Channel` the name of the channel to read, or a `Channel` object. start : `~gwpy.time.LIGOTimeGPS`, `float`, `str` GPS start time of required data, any input parseable by `~gwpy.time.to_gps` is fine end : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional GPS end time of required data, defaults to end of data found; any input parseable by `~gwpy.time.to_gps` is fine bits : `list`, optional list of bits names for this `StateVector`, give `None` at any point in the list to mask that bit format : `str`, optional source format identifier. If not given, the format will be detected if possible. See below for list of acceptable formats. nproc : `int`, optional, default: `1` number of parallel processes to use, serial process by default. .. note:: Parallel frame reading, via the ``nproc`` keyword argument, is only available when giving a `~glue.lal.Cache` of frames, or using the ``format='cache'`` keyword argument. gap : `str`, optional how to handle gaps in the cache, one of - 'ignore': do nothing, let the undelying reader method handle it - 'warn': do nothing except print a warning to the screen - 'raise': raise an exception upon finding a gap (default) - 'pad': insert a value to fill the gaps pad : `float`, optional value with which to fill gaps in the source data, only used if gap is not given, or `gap='pad'` is given Example ------- To read the S6 state vector, with names for all the bits:: >>> sv = StateVector.read( 'H-H1_LDAS_C02_L2-968654592-128.gwf', 'H1:IFO-SV_STATE_VECTOR', bits=['Science mode', 'Conlog OK', 'Locked', 'No injections', 'No Excitations'], dtype='uint32') then you can convert these to segments >>> segments = sv.to_dqflags() or to read just the interferometer operations bits:: >>> sv = StateVector.read( 'H-H1_LDAS_C02_L2-968654592-128.gwf', 'H1:IFO-SV_STATE_VECTOR', bits=['Science mode', None, 'Locked'], dtype='uint32') Running `to_dqflags` on this example would only give 2 flags, rather than all five. Alternatively the `bits` attribute can be reset after reading, but before any further operations. Notes -----""" return io_registry.read(cls, source, *args, **kwargs)