lsst.afw.table._base.Catalog Class Reference

Inheritance diagram for lsst.afw.table._base.Catalog:

Public Member Functions
def	getColumnView (self)
def	__getitem__ (self, key)
def	__setitem__ (self, key, value)
def	__delitem__ (self, key)
def	append (self, record)
def	insert (self, key, value)
def	clear (self)
def	addNew (self)
def	cast (self, type_, deep=False)
def	copy (self, deep=False)
def	extend (self, iterable, deep=False, mapper=None)
def	__reduce__ (self)
def	asAstropy (self, cls=None, copy=False, unviewable="copy")
def	__dir__ (self)
def	__getattr__ (self, name)
def	__str__ (self)
def	__repr__ (self)

Properties
	columns = property(__getColumns, doc="a column view of the catalog")

Detailed Description

Definition at line 73 of file _base.py.

Member Function Documentation

__delitem__()

def lsst.afw.table._base.Catalog.__delitem__	(		self,
			key
	)

Definition at line 136 of file _base.py.

    def __delitem__(self, key):
        self._columns = None
        if isinstance(key, slice):
            self._delslice_(key)
        else:
            self._delitem_(key)
 

__dir__()

def lsst.afw.table._base.Catalog.__dir__

(

self

)

This custom dir is necessary due to the custom getattr below.
Without it, not all of the methods available are returned with dir.
See DM-7199.

Definition at line 317 of file _base.py.

    def __dir__(self):
        """
        This custom dir is necessary due to the custom getattr below.
        Without it, not all of the methods available are returned with dir.
        See DM-7199.
        """
        def recursive_get_class_dir(cls):
            """
            Return a set containing the names of all methods
            for a given class *and* all of its subclasses.
            """
            result = set()
            if cls.__bases__:
                for subcls in cls.__bases__:
                    result |= recursive_get_class_dir(subcls)
            result |= set(cls.__dict__.keys())
            return result
        return sorted(set(dir(self.columns)) | set(dir(self.table))
                      | recursive_get_class_dir(type(self)) | set(self.__dict__.keys()))
 

__getattr__()

def lsst.afw.table._base.Catalog.__getattr__	(		self,
			name
	)

Definition at line 337 of file _base.py.

    def __getattr__(self, name):
        # Catalog forwards unknown method calls to its table and column view
        # for convenience.  (Feature requested by RHL; complaints about magic
        # should be directed to him.)
        if name == "_columns":
            self._columns = None
            return None
        try:
            return getattr(self.table, name)
        except AttributeError:
            return getattr(self.columns, name)
 

__getitem__()

def lsst.afw.table._base.Catalog.__getitem__	(		self,
			key
	)

Return the record at index key if key is an integer,
return a column if `key` is a string field name or Key,
or return a subset of the catalog if key is a slice
or boolean NumPy array.

Definition at line 85 of file _base.py.

    def __getitem__(self, key):
        """Return the record at index key if key is an integer,
        return a column if `key` is a string field name or Key,
        or return a subset of the catalog if key is a slice
        or boolean NumPy array.
        """
        if type(key) is slice:
            (start, stop, step) = (key.start, key.stop, key.step)
            if step is None:
                step = 1
            if start is None:
                start = 0
            if stop is None:
                stop = len(self)
            return self.subset(start, stop, step)
        elif isinstance(key, np.ndarray):
            if key.dtype == bool:
                return self.subset(key)
            raise RuntimeError(f"Unsupported array type for indexing non-contiguous Catalog: {key.dtype}")
        elif isinstance(key, Key) or isinstance(key, str):
            if not self.isContiguous():
                if isinstance(key, str):
                    key = self.schema[key].asKey()
                array = self._getitem_(key)
                # This array doesn't share memory with the Catalog, so don't let it be modified by
                # the user who thinks that the Catalog itself is being modified.
                # Just be aware that this array can only be passed down to C++ as an ndarray::Array<T const>
                # instead of an ordinary ndarray::Array<T>. If pybind isn't letting it down into C++,
                # you may have left off the 'const' in the definition.
                array.flags.writeable = False
                return array
            return self.columns[key]
        else:
            return self._getitem_(key)
 

__reduce__()

def lsst.afw.table._base.Catalog.__reduce__

(

self

)

Definition at line 222 of file _base.py.

    def __reduce__(self):
        import lsst.afw.fits
        return lsst.afw.fits.reduceToFits(self)
 

__repr__()

def lsst.afw.table._base.Catalog.__repr__

(

self

)

Definition at line 356 of file _base.py.

    def __repr__(self):
        return "%s\n%s" % (type(self), self)
 
 
Catalog.register("Base", BaseCatalog)

__setitem__()

def lsst.afw.table._base.Catalog.__setitem__	(		self,
			key,
			value
	)

If ``key`` is an integer, set ``catalog[key]`` to
``value``. Otherwise select column ``key`` and set it to
``value``.

Definition at line 120 of file _base.py.

    def __setitem__(self, key, value):
        """If ``key`` is an integer, set ``catalog[key]`` to
        ``value``. Otherwise select column ``key`` and set it to
        ``value``.
        """
        self._columns = None
        if isinstance(key, str):
            key = self.schema[key].asKey()
        if isinstance(key, Key):
            if isinstance(key, Key["Flag"]):
                self._set_flag(key, value)
            else:
                self.columns[key] = value
        else:
            return self.set(key, value)
 

__str__()

def lsst.afw.table._base.Catalog.__str__

(

self

)

Definition at line 349 of file _base.py.

    def __str__(self):
        if self.isContiguous():
            return str(self.asAstropy())
        else:
            fields = ' '.join(x.field.getName() for x in self.schema)
            return f"Non-contiguous afw.Catalog of {len(self)} rows.\ncolumns: {fields}"
 

addNew()

def lsst.afw.table._base.Catalog.addNew

(

self

)

Definition at line 155 of file _base.py.

    def addNew(self):
        self._columns = None
        return self._addNew()
 

append()

def lsst.afw.table._base.Catalog.append	(		self,
			record
	)

Definition at line 143 of file _base.py.

    def append(self, record):
        self._columns = None
        self._append(record)
 

asAstropy()

def lsst.afw.table._base.Catalog.asAstropy	(		self,
			cls = None,
			copy = False,
			unviewable = "copy"
	)

Return an astropy.table.Table (or subclass thereof) view into this catalog.

Parameters
----------
cls :
    Table subclass to use; `None` implies `astropy.table.Table`
    itself.  Use `astropy.table.QTable` to get Quantity columns.
copy : bool, optional
    If `True`, copy data from the LSST catalog to the astropy
    table.  Not copying is usually faster, but can keep memory
    from being freed if columns are later removed from the
    Astropy view.
unviewable : `str`, optional
    One of the following options (which is ignored if
    copy=`True` ), indicating how to handle field types (`str`
    and `Flag`) for which views cannot be constructed:

    - 'copy' (default): copy only the unviewable fields.
    - 'raise': raise ValueError if unviewable fields are present.
    - 'skip': do not include unviewable fields in the Astropy Table.

Returns
-------
cls : `astropy.table.Table`
    Astropy view into the catalog.

Raises
------
ValueError
    Raised if the `unviewable` option is not a known value, or
    if the option is 'raise' and an uncopyable field is found.

Definition at line 226 of file _base.py.

    def asAstropy(self, cls=None, copy=False, unviewable="copy"):
        """Return an astropy.table.Table (or subclass thereof) view into this catalog.
 
        Parameters
        ----------
        cls :
            Table subclass to use; `None` implies `astropy.table.Table`
            itself.  Use `astropy.table.QTable` to get Quantity columns.
        copy : bool, optional
            If `True`, copy data from the LSST catalog to the astropy
            table.  Not copying is usually faster, but can keep memory
            from being freed if columns are later removed from the
            Astropy view.
        unviewable : `str`, optional
            One of the following options (which is ignored if
            copy=`True` ), indicating how to handle field types (`str`
            and `Flag`) for which views cannot be constructed:
 
            - 'copy' (default): copy only the unviewable fields.
            - 'raise': raise ValueError if unviewable fields are present.
            - 'skip': do not include unviewable fields in the Astropy Table.
 
        Returns
        -------
        cls : `astropy.table.Table`
            Astropy view into the catalog.
 
        Raises
        ------
        ValueError
            Raised if the `unviewable` option is not a known value, or
            if the option is 'raise' and an uncopyable field is found.
 
        """
        import astropy.table
        if cls is None:
            cls = astropy.table.Table
        if unviewable not in ("copy", "raise", "skip"):
            raise ValueError(
                f"'unviewable'={unviewable!r} must be one of 'copy', 'raise', or 'skip'")
        ps = self.getMetadata()
        meta = ps.toOrderedDict() if ps is not None else None
        columns = []
        items = self.schema.extract("*", ordered=True)
        for name, item in items.items():
            key = item.key
            unit = item.field.getUnits() or None  # use None instead of "" when empty
            if key.getTypeString() == "String":
                if not copy:
                    if unviewable == "raise":
                        raise ValueError("Cannot extract string "
                                         "unless copy=True or unviewable='copy' or 'skip'.")
                    elif unviewable == "skip":
                        continue
                data = np.zeros(
                    len(self), dtype=np.dtype((str, key.getSize())))
                for i, record in enumerate(self):
                    data[i] = record.get(key)
            elif key.getTypeString() == "Flag":
                if not copy:
                    if unviewable == "raise":
                        raise ValueError("Cannot extract packed bit columns "
                                         "unless copy=True or unviewable='copy' or 'skip'.")
                    elif unviewable == "skip":
                        continue
                data = self.columns.get_bool_array(key)
            elif key.getTypeString() == "Angle":
                data = self.columns.get(key)
                unit = "radian"
                if copy:
                    data = data.copy()
            elif "Array" in key.getTypeString() and key.isVariableLength():
                # Can't get columns for variable-length array fields.
                if unviewable == "raise":
                    raise ValueError("Cannot extract variable-length array fields unless unviewable='skip'.")
                elif unviewable == "skip" or unviewable == "copy":
                    continue
            else:
                data = self.columns.get(key)
                if copy:
                    data = data.copy()
            columns.append(
                astropy.table.Column(
                    data,
                    name=name,
                    unit=unit,
                    description=item.field.getDoc()
                )
            )
        return cls(columns, meta=meta, copy=False)
 

cast()

def lsst.afw.table._base.Catalog.cast	(		self,
			type_,
			deep = False
	)

Return a copy of the catalog with the given type.

Parameters
----------
type_ :
    Type of catalog to return.
deep : `bool`, optional
    If `True`, clone the table and deep copy all records.

Returns
-------
copy :
    Copy of catalog with the requested type.

Definition at line 159 of file _base.py.

    def cast(self, type_, deep=False):
        """Return a copy of the catalog with the given type.
 
        Parameters
        ----------
        type_ :
            Type of catalog to return.
        deep : `bool`, optional
            If `True`, clone the table and deep copy all records.
 
        Returns
        -------
        copy :
            Copy of catalog with the requested type.
        """
        if deep:
            table = self.table.clone()
            table.preallocate(len(self))
        else:
            table = self.table
        copy = type_(table)
        copy.extend(self, deep=deep)
        return copy
 

clear()

def lsst.afw.table._base.Catalog.clear

(

self

)

Definition at line 151 of file _base.py.

    def clear(self):
        self._columns = None
        self._clear()
 

copy()

def lsst.afw.table._base.Catalog.copy	(		self,
			deep = False
	)

Copy a catalog (default is not a deep copy).

Definition at line 183 of file _base.py.

    def copy(self, deep=False):
        """
        Copy a catalog (default is not a deep copy).
        """
        return self.cast(type(self), deep)
 

extend()

def lsst.afw.table._base.Catalog.extend	(		self,
			iterable,
			deep = False,
			mapper = None
	)

Append all records in the given iterable to the catalog.

Parameters
----------
iterable :
    Any Python iterable containing records.
deep : `bool`, optional
    If `True`, the records will be deep-copied; ignored if
    mapper is not `None` (that always implies `True`).
mapper : `lsst.afw.table.schemaMapper.SchemaMapper`, optional
    Used to translate records.

Definition at line 189 of file _base.py.

    def extend(self, iterable, deep=False, mapper=None):
        """Append all records in the given iterable to the catalog.
 
        Parameters
        ----------
        iterable :
            Any Python iterable containing records.
        deep : `bool`, optional
            If `True`, the records will be deep-copied; ignored if
            mapper is not `None` (that always implies `True`).
        mapper : `lsst.afw.table.schemaMapper.SchemaMapper`, optional
            Used to translate records.
        """
        self._columns = None
        # We can't use isinstance here, because the SchemaMapper symbol isn't available
        # when this code is part of a subclass of Catalog in another package.
        if type(deep).__name__ == "SchemaMapper":
            mapper = deep
            deep = None
        if isinstance(iterable, type(self)):
            if mapper is not None:
                self._extend(iterable, mapper)
            else:
                self._extend(iterable, deep)
        else:
            for record in iterable:
                if mapper is not None:
                    self._append(self.table.copyRecord(record, mapper))
                elif deep:
                    self._append(self.table.copyRecord(record))
                else:
                    self._append(record)
 

getColumnView()

def lsst.afw.table._base.Catalog.getColumnView

(

self

)

Definition at line 75 of file _base.py.

    def getColumnView(self):
        self._columns = self._getColumnView()
        return self._columns
 

insert()

def lsst.afw.table._base.Catalog.insert	(		self,
			key,
			value
	)

Definition at line 147 of file _base.py.

    def insert(self, key, value):
        self._columns = None
        self._insert(key, value)
 

Property Documentation

columns

lsst.afw.table._base.Catalog.columns = property(__getColumns, doc="a column view of the catalog")

static

Definition at line 83 of file _base.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-4.0.1/Linux64/afw/gba47b54d5d+94dc90c3ea/python/lsst/afw/table/_base.py