Public Member Functions
def	getBits (self, keys=None)

def	__getitem__ (self, key)

def	__setitem__ (self, key, value)

def	get_bool_array (self, key)

def	extract (self, patterns, *kwds)

Static Public Attributes
def	get = __getitem__

def	set = __setitem__

Detailed Description

Definition at line 35 of file _baseColumnView.py.

Member Function Documentation

◆ getitem()

def lsst.afw.table._baseColumnView._BaseColumnViewBase.__getitem__	(	self,
		key
	)

Get a column view; key may be a key object or the name of a field.

Definition at line 62 of file _baseColumnView.py.

     def __getitem__(self, key):
         """Get a column view; key may be a key object or the name of a field.
         """
         if isinstance(key, str):
             keyobj = self.schema.find(key).key
         else:
             keyobj = key
         return self._basicget(keyobj)
  

◆ setitem()

def lsst.afw.table._baseColumnView._BaseColumnViewBase.__setitem__	(	self,
		key,
		value
	)

Set a full column to an array or scalar; key may be a key object or
the name of a field.

Definition at line 73 of file _baseColumnView.py.

     def __setitem__(self, key, value):
         """Set a full column to an array or scalar; key may be a key object or
         the name of a field.
         """
         self.get(key)[:] = value
  

◆ extract()

def lsst.afw.table._baseColumnView._BaseColumnViewBase.extract	(		self,
		*	patterns,
		**	kwds
	)

Extract a dictionary of {<name>: <column-array>} in which the field
names match the given shell-style glob pattern(s).

Any number of glob patterns may be passed (including none); the result
will be the union of all the result of each glob considered
separately.

Note that extract("*", copy=True) provides an easy way to transform a
row-major ColumnView into a possibly more efficient set of contiguous
NumPy arrays.

This routines unpacks `Flag` columns into full boolean arrays and
covariances into dense (i.e. non-triangular packed) arrays with
dimension (N,M,M), where N is the number of records and M is the
dimension of the covariance matrix.  String fields are silently
ignored.

Parameters
----------
patterns : Array of `str`
    List of glob patterns to use to select field names.
kwds : `dict`
    Dictionary of additional keyword arguments.  May contain:

    ``items`` : `list`
        The result of a call to self.schema.extract(); this
        will be used instead of doing any new matching, and
        allows the pattern matching to be reused to extract
        values from multiple records.  This keyword is
        incompatible with any position arguments and the
        regex, sub, and ordered keyword arguments.
    ``where`` : array index expression
        Any expression that can be passed as indices to a
        NumPy array, including slices, boolean arrays, and
        index arrays, that will be used to index each column
        array.  This is applied before arrays are copied when
        copy is True, so if the indexing results in an
        implicit copy no unnecessary second copy is performed.
    ``copy`` : `bool`
        If True, the returned arrays will be contiguous copies
        rather than strided views into the catalog.  This
        ensures that the lifetime of the catalog is not tied
        to the lifetime of a particular catalog, and it also
        may improve the performance if the array is used
        repeatedly. Default is False.
    ``regex`` : `str` or `re` pattern
        A regular expression to be used in addition to any
        glob patterns passed as positional arguments.  Note
        that this will be compared with re.match, not
        re.search.
    ``sub`` : `str`
        A replacement string (see re.MatchObject.expand) used
        to set the dictionary keys of any fields matched by
        regex.
    ``ordered`` : `bool`
        If True, a collections.OrderedDict will be returned
        instead of a standard dict, with the order
        corresponding to the definition order of the
        Schema. Default is False.

Returns
-------
d : `dict`
    Dictionary of extracted name-column array sets.

Raises
------
ValueError
    Raised if a list of ``items`` is supplied with additional
    keywords.

Definition at line 104 of file _baseColumnView.py.

     def extract(self, *patterns, **kwds):
         """Extract a dictionary of {<name>: <column-array>} in which the field
         names match the given shell-style glob pattern(s).
  
         Any number of glob patterns may be passed (including none); the result
         will be the union of all the result of each glob considered
         separately.
  
         Note that extract("*", copy=True) provides an easy way to transform a
         row-major ColumnView into a possibly more efficient set of contiguous
         NumPy arrays.
  
         This routines unpacks `Flag` columns into full boolean arrays and
         covariances into dense (i.e. non-triangular packed) arrays with
         dimension (N,M,M), where N is the number of records and M is the
         dimension of the covariance matrix.  String fields are silently
         ignored.
  
         Parameters
         ----------
         patterns : Array of `str`
             List of glob patterns to use to select field names.
         kwds : `dict`
             Dictionary of additional keyword arguments.  May contain:
  
             ``items`` : `list`
                 The result of a call to self.schema.extract(); this
                 will be used instead of doing any new matching, and
                 allows the pattern matching to be reused to extract
                 values from multiple records.  This keyword is
                 incompatible with any position arguments and the
                 regex, sub, and ordered keyword arguments.
             ``where`` : array index expression
                 Any expression that can be passed as indices to a
                 NumPy array, including slices, boolean arrays, and
                 index arrays, that will be used to index each column
                 array.  This is applied before arrays are copied when
                 copy is True, so if the indexing results in an
                 implicit copy no unnecessary second copy is performed.
             ``copy`` : `bool`
                 If True, the returned arrays will be contiguous copies
                 rather than strided views into the catalog.  This
                 ensures that the lifetime of the catalog is not tied
                 to the lifetime of a particular catalog, and it also
                 may improve the performance if the array is used
                 repeatedly. Default is False.
             ``regex`` : `str` or `re` pattern
                 A regular expression to be used in addition to any
                 glob patterns passed as positional arguments.  Note
                 that this will be compared with re.match, not
                 re.search.
             ``sub`` : `str`
                 A replacement string (see re.MatchObject.expand) used
                 to set the dictionary keys of any fields matched by
                 regex.
             ``ordered`` : `bool`
                 If True, a collections.OrderedDict will be returned
                 instead of a standard dict, with the order
                 corresponding to the definition order of the
                 Schema. Default is False.
  
         Returns
         -------
         d : `dict`
             Dictionary of extracted name-column array sets.
  
         Raises
         ------
         ValueError
             Raised if a list of ``items`` is supplied with additional
             keywords.
         """
         copy = kwds.pop("copy", False)
         where = kwds.pop("where", None)
         d = kwds.pop("items", None)
         # If ``items`` is given as a kwd, an extraction has already been performed and there shouldn't be
         # any additional keywords. Otherwise call schema.extract to load the
         # dictionary.
         if d is None:
             d = self.schema.extract(*patterns, **kwds).copy()
         elif kwds:
             raise ValueError(
                 "kwd 'items' was specified, which is not compatible with additional keywords")
  
         def processArray(a):
             if where is not None:
                 a = a[where]
             if copy:
                 a = np.ascontiguousarray(a)
             return a
  
         # must use list because we might be adding/deleting elements
         for name, schemaItem in list(d.items()):
             key = schemaItem.key
             if key.getTypeString() == "String":
                 del d[name]
             else:
                 d[name] = processArray(self.get(schemaItem.key))
         return d

◆ get_bool_array()

def lsst.afw.table._baseColumnView._BaseColumnViewBase.get_bool_array	(	self,
		key
	)

Get the value of a flag column as a boolean array; key must be a
key object or the name of a field.

Parameters
----------
key : `lsst.afw.table.KeyFlag`
    Flag column to search for.

Returns
-------
value : `list` of `bool`
    Array of booleans corresponding to the flag.

Raises
------
TypeError
    Raised if the key is not a KeyFlag.

Definition at line 81 of file _baseColumnView.py.

     def get_bool_array(self, key):
         """Get the value of a flag column as a boolean array; key must be a
         key object or the name of a field.
  
         Parameters
         ----------
         key : `lsst.afw.table.KeyFlag`
             Flag column to search for.
  
         Returns
         -------
         value : `list` of `bool`
             Array of booleans corresponding to the flag.
  
         Raises
         ------
         TypeError
             Raised if the key is not a KeyFlag.
         """
         if isinstance(key, KeyFlag):
             return self[key]
         raise TypeError("key={} not an lsst.afw.table.KeyFlag".format(key))
  

◆ getBits()

def lsst.afw.table._baseColumnView._BaseColumnViewBase.getBits	(	self,
		keys = `None`
	)

Get the bits associated with the specified keys.

Parameters
----------
key : `str`
    Key to retrieve. Unlike the C++ version, each key may be a
    field name or a key, and if keys is `None` then all bits
    are returned.

Returns
-------
bits : `int`
     Integer array of the requested bitmask.

Definition at line 37 of file _baseColumnView.py.

     def getBits(self, keys=None):
         """Get the bits associated with the specified keys.
  
         Parameters
         ----------
         key : `str`
             Key to retrieve. Unlike the C++ version, each key may be a
             field name or a key, and if keys is `None` then all bits
             are returned.
  
         Returns
         -------
         bits : `int`
              Integer array of the requested bitmask.
         """
         if keys is None:
             return self.getAllBits()
         arg = []
         for k in keys:
             if isinstance(k, str):
                 arg.append(self.schema.find(k).key)
             else:
                 arg.append(k)
         return self._getBits(arg)
  

Member Data Documentation

◆ get

def lsst.afw.table._baseColumnView._BaseColumnViewBase.get = __getitem__

static

Definition at line 71 of file _baseColumnView.py.

◆ set

def lsst.afw.table._baseColumnView._BaseColumnViewBase.set = __setitem__

static

Definition at line 79 of file _baseColumnView.py.

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

/j/snowflake/release/lsstsw/stack/lsst-scipipe-0.7.0/Linux64/afw/22.0.1-42-gca6935d93+ba5e5ca3eb/python/lsst/afw/table/_baseColumnView.py

Public Member Functions

Static Public Attributes