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)
def	__new__ (cls, name, bases, attrs)
def	__call__ (cls, args, kwds)
def	__subclasscheck__ (cls, subclass)
def	__instancecheck__ (cls, instance)
def	__subclasses__ (cls)
def	register (cls, key, subclass)
def	alias (cls, key, subclass)
def	__iter__ (cls)
def	__len__ (cls)
def	__contains__ (cls, key)
def	keys (cls)
def	values (cls)
def	items (cls)
def	get (cls, key, default=None)

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

Detailed Description

Definition at line 88 of file _base.py.

Member Function Documentation

__call__()

def lsst.utils.wrappers.TemplateMeta.__call__ (   cls,   args,   kwds  )

inherited

Definition at line 293 of file wrappers.py.

    def __call__(cls, *args, **kwds):
        # __call__ is invoked when someone tries to construct an instance of
        # the abstract base class.
        # If the ABC defines a "TEMPLATE_PARAMS" attribute, we use those strings
        # as the kwargs we should intercept to find the right type.
        # Generate a type mapping key from input keywords. If the type returned
        # from the keyword lookup is a numpy dtype object, fetch the underlying
        # type of the dtype
        key = []
        for p, d in zip(cls.TEMPLATE_PARAMS, cls.TEMPLATE_DEFAULTS):
            tempKey = kwds.pop(p, d)
            if isinstance(tempKey, np.dtype):
                tempKey = tempKey.type
            key.append(tempKey)
        key = tuple(key)

        # indices are only tuples if there are multiple elements
        clz = cls._registry.get(key[0] if len(key) == 1 else key, None)
        if clz is None:
            d = {k: v for k, v in zip(cls.TEMPLATE_PARAMS, key)}
            raise TypeError("No registered subclass for {}.".format(d))
        return clz(*args, **kwds)

__contains__()

def lsst.utils.wrappers.TemplateMeta.__contains__ (   cls,   key  )

inherited

Definition at line 458 of file wrappers.py.

    def __contains__(cls, key):
        return key in cls._registry

__delitem__()

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

Definition at line 147 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 327 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 347 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 100 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("Unsupported array type for indexing non-contiguous Catalog: %s" %
                               (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)

__instancecheck__()

def lsst.utils.wrappers.TemplateMeta.__instancecheck__ (   cls,   instance  )

inherited

Definition at line 326 of file wrappers.py.

    def __instancecheck__(cls, instance):
        # Special method hook for the isinstance built-in: we return true for
        # an instance of any registered type or true subclass thereof.
        if type(instance) in cls._registry:
            return True
        for v in cls._registry.values():
            if isinstance(instance, v):
                return True
        return False

__iter__()

def lsst.utils.wrappers.TemplateMeta.__iter__ (   cls )

inherited

Definition at line 452 of file wrappers.py.

    def __iter__(cls):
        return iter(cls._registry)

__len__()

def lsst.utils.wrappers.TemplateMeta.__len__ (   cls )

inherited

Definition at line 455 of file wrappers.py.

    def __len__(cls):
        return len(cls._registry)

__new__()

def lsst.utils.wrappers.TemplateMeta.__new__ (   cls,   name,   bases,   attrs  )

inherited

Definition at line 261 of file wrappers.py.

    def __new__(cls, name, bases, attrs):
        # __new__ is invoked when the abstract base class is defined (via a
        # class statement).  We save a dict of class attributes (including
        # methods) that were defined in the class body so we can copy them
        # to registered subclasses later.
        # We also initialize an empty dict to store the registered subclasses.
        attrs["_inherited"] = {k: v for k, v in attrs.items()
                               if isAttributeSafeToTransfer(k, v)}
        # The special "TEMPLATE_PARAMS" class attribute, if defined, contains
        # names of the template parameters, which we use to set those
        # attributes on registered subclasses and intercept arguments to the
        # constructor.  This line removes it from the dict of things that
        # should be inherited while setting a default of 'dtype' if it's not
        # defined.
        attrs["TEMPLATE_PARAMS"] = \
            attrs["_inherited"].pop("TEMPLATE_PARAMS", ("dtype",))
        attrs["TEMPLATE_DEFAULTS"] = \
            attrs["_inherited"].pop("TEMPLATE_DEFAULTS",
                                    (None,)*len(attrs["TEMPLATE_PARAMS"]))
        attrs["_registry"] = dict()
        self = type.__new__(cls, name, bases, attrs)

        if len(self.TEMPLATE_PARAMS) == 0:
            raise ValueError(
                "TEMPLATE_PARAMS must be a tuple with at least one element."
            )
        if len(self.TEMPLATE_DEFAULTS) != len(self.TEMPLATE_PARAMS):
            raise ValueError(
                "TEMPLATE_PARAMS and TEMPLATE_DEFAULTS must have same length."
            )
        return self

__reduce__()

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

(

self

)

Definition at line 233 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 367 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 136 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, Key) or isinstance(key, str):
            self.columns[key] = value
        else:
            return self.set(key, value)

__str__()

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

(

self

)

Definition at line 359 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)
            string = "Non-contiguous afw.Catalog of %d rows.\ncolumns: %s" % (len(self), fields)
            return string

__subclasscheck__()

def lsst.utils.wrappers.TemplateMeta.__subclasscheck__ (   cls,   subclass  )

inherited

Definition at line 316 of file wrappers.py.

    def __subclasscheck__(cls, subclass):
        # Special method hook for the issubclass built-in: we return true for
        # any registered type or true subclass thereof.
        if subclass in cls._registry:
            return True
        for v in cls._registry.values():
            if issubclass(subclass, v):
                return True
        return False

__subclasses__()

def lsst.utils.wrappers.TemplateMeta.__subclasses__ (   cls )

inherited

Return a tuple of all classes that inherit from this class.

Definition at line 336 of file wrappers.py.

    def __subclasses__(cls):
        """Return a tuple of all classes that inherit from this class.
        """
        # This special method isn't defined as part of the Python data model,
        # but it exists on builtins (including ABCMeta), and it provides useful
        # functionality.
        return tuple(set(cls._registry.values()))

addNew()

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

(

self

)

Definition at line 166 of file _base.py.

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

alias()

def lsst.utils.wrappers.TemplateMeta.alias (   cls,   key,   subclass  )

inherited

Add an alias that allows an existing subclass to be accessed with a
different key.

Definition at line 429 of file wrappers.py.

    def alias(cls, key, subclass):
        """Add an alias that allows an existing subclass to be accessed with a
        different key.
        """
        if key is None:
            raise ValueError("None may not be used as a key.")
        if key in cls._registry:
            raise KeyError("Cannot multiply-register key {}".format(key))
        primaryKey = tuple(getattr(subclass, p, None)
                           for p in cls.TEMPLATE_PARAMS)
        if len(primaryKey) == 1:
            # indices are only tuples if there are multiple elements
            primaryKey = primaryKey[0]
        if cls._registry.get(primaryKey, None) != subclass:
            raise ValueError("Subclass is not registered with this base class.")
        cls._registry[key] = subclass

append()

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

Definition at line 154 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 237 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(
                "'unviewable'=%r must be one of 'copy', 'raise', or 'skip'" % (unviewable,))
        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 170 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 162 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 194 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 200 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)

get()

def lsst.utils.wrappers.TemplateMeta.get (   cls,   key,   default = None  )

inherited

Return the subclass associated with the given key (including
aliases), or ``default`` if the key is not recognized.

Definition at line 477 of file wrappers.py.

    def get(cls, key, default=None):
        """Return the subclass associated with the given key (including
        aliases), or ``default`` if the key is not recognized.
        """
        return cls._registry.get(key, default)

getColumnView()

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

(

self

)

Definition at line 90 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 158 of file _base.py.

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

items()

def lsst.utils.wrappers.TemplateMeta.items (   cls )

inherited

Return an iterable of (key, subclass) pairs.

Definition at line 472 of file wrappers.py.

    def items(cls):
        """Return an iterable of (key, subclass) pairs.
        """
        return cls._registry.items()

keys()

def lsst.utils.wrappers.TemplateMeta.keys (   cls )

inherited

Return an iterable containing all keys (including aliases).

Definition at line 461 of file wrappers.py.

    def keys(cls):
        """Return an iterable containing all keys (including aliases).
        """
        return cls._registry.keys()

register()

def lsst.utils.wrappers.TemplateMeta.register (   cls,   key,   subclass  )

inherited

Register a subclass of this ABC with the given key (a string,
number, type, or other hashable).

Register may only be called once for a given key or a given subclass.

Definition at line 344 of file wrappers.py.

    def register(cls, key, subclass):
        """Register a subclass of this ABC with the given key (a string,
        number, type, or other hashable).

        Register may only be called once for a given key or a given subclass.
        """
        if key is None:
            raise ValueError("None may not be used as a key.")
        if subclass in cls._registry.values():
            raise ValueError(
                "This subclass has already registered with another key; "
                "use alias() instead."
            )
        if cls._registry.setdefault(key, subclass) != subclass:
            if len(cls.TEMPLATE_PARAMS) == 1:
                d = {cls.TEMPLATE_PARAMS[0]: key}
            else:
                d = {k: v for k, v in zip(cls.TEMPLATE_PARAMS, key)}
            raise KeyError(
                "Another subclass is already registered with {}".format(d)
            )
        # If the key used to register a class matches the default key,
        # make the static methods available through the ABC
        if cls.TEMPLATE_DEFAULTS:
            defaults = (cls.TEMPLATE_DEFAULTS[0] if
                        len(cls.TEMPLATE_DEFAULTS) == 1 else
                        cls.TEMPLATE_DEFAULTS)
            if key == defaults:
                conflictStr = ("Base class has attribute {}"
                               " which is a {} method of {}."
                               " Cannot link method to base class.")
                # In the following if statements, the explicit lookup in
                # __dict__ must be done, as a call to getattr returns the
                # bound method, which no longer reports as a static or class
                # method. The static methods must be transfered to the ABC
                # in this unbound state, so that python will still see them
                # as static methods and not attempt to pass self. The class
                # methods must be transfered to the ABC as a bound method
                # so that the correct cls be called with the class method
                for name in subclass.__dict__:
                    if name in ("__new__", "__init_subclass__"):
                        continue
                    obj = subclass.__dict__[name]
                    # copy over the static methods
                    isBuiltin = isinstance(obj, types.BuiltinFunctionType)
                    isStatic = isinstance(obj, staticmethod)
                    if isBuiltin or isStatic:
                        if hasattr(cls, name):
                            raise AttributeError(
                                conflictStr.format(name, "static", subclass))
                        setattr(cls, name, obj)
                    # copy over the class methods
                    elif isinstance(obj, classmethod):
                        if hasattr(cls, name):
                            raise AttributeError(
                                conflictStr.format(name, "class", subclass))
                        setattr(cls, name, getattr(subclass, name))

        def setattrSafe(name, value):
            try:
                currentValue = getattr(subclass, name)
                if currentValue != value:
                    msg = ("subclass already has a '{}' attribute with "
                           "value {} != {}.")
                    raise ValueError(
                        msg.format(name, currentValue, value)
                    )
            except AttributeError:
                setattr(subclass, name, value)

        if len(cls.TEMPLATE_PARAMS) == 1:
            setattrSafe(cls.TEMPLATE_PARAMS[0], key)
        elif len(cls.TEMPLATE_PARAMS) == len(key):
            for p, k in zip(cls.TEMPLATE_PARAMS, key):
                setattrSafe(p, k)
        else:
            raise ValueError(
                "key must have {} elements (one for each of {})".format(
                    len(cls.TEMPLATE_PARAMS), cls.TEMPLATE_PARAMS
                )
            )

        for name, attr in cls._inherited.items():
            setattr(subclass, name, attr)

values()

def lsst.utils.wrappers.TemplateMeta.values (   cls )

inherited

Return an iterable of registered subclasses, with duplicates
corresponding to any aliases.

Definition at line 466 of file wrappers.py.

    def values(cls):
        """Return an iterable of registered subclasses, with duplicates
        corresponding to any aliases.
        """
        return cls._registry.values()

Property Documentation

columns

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

static

Definition at line 98 of file _base.py.

---

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

• /j/snowflake/release/lsstsw/stack/Linux64/afw/19.0.0-4-ga671dab3b+1/python/lsst/afw/table/_base.py

---

Generated on Wed Jan 8 2020 09:12:20 for LSSTApplications by   1.8.13