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 37 of file baseColumnViewContinued.py.

Member Function Documentation

◆ getitem()

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

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

Definition at line 55 of file baseColumnViewContinued.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.baseColumnViewContinued._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 66 of file baseColumnViewContinued.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.baseColumnViewContinued._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.

Additional Keyword Arguments
----------------------------
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.

Definition at line 82 of file baseColumnViewContinued.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.
 
         Additional Keyword Arguments
         ----------------------------
         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.
         """
         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.baseColumnViewContinued._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.

Definition at line 74 of file baseColumnViewContinued.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.
         """
         if isinstance(key, KeyFlag):
             return self[key]
         raise TypeError("key={} not an lsst.afw.table.KeyFlag".format(key))
 

◆ getBits()

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

Get the bits associated with the specified keys

Unlike the C++ version, each key may be a field name or a key,
and if keys is None then all bits are returned.

Definition at line 39 of file baseColumnViewContinued.py.

     def getBits(self, keys=None):
         """Get the bits associated with the specified keys
 
         Unlike the C++ version, each key may be a field name or a key,
         and if keys is None then all bits are returned.
         """
         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.baseColumnViewContinued._BaseColumnViewBase.get = __getitem__

static

Definition at line 64 of file baseColumnViewContinued.py.

◆ set

def lsst.afw.table.baseColumnView.baseColumnViewContinued._BaseColumnViewBase.set = __setitem__

static

Definition at line 72 of file baseColumnViewContinued.py.

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

/j/snowflake/release/lsstsw/stack/Linux64/afw/18.1.0/python/lsst/afw/table/baseColumnView/baseColumnViewContinued.py

Public Member Functions

Static Public Attributes