Coverage for python/lsst/afw/table/_baseColumnView.py : 20%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# This file is part of afw.
2#
3# Developed for the LSST Data Management System.
4# This product includes software developed by the LSST Project
5# (https://www.lsst.org).
6# See the COPYRIGHT file at the top-level directory of this distribution
7# for details of code ownership.
8#
9# This program is free software: you can redistribute it and/or modify
10# it under the terms of the GNU General Public License as published by
11# the Free Software Foundation, either version 3 of the License, or
12# (at your option) any later version.
13#
14# This program is distributed in the hope that it will be useful,
15# but WITHOUT ANY WARRANTY; without even the implied warranty of
16# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17# GNU General Public License for more details.
18#
19# You should have received a copy of the GNU General Public License
20# along with this program. If not, see <https://www.gnu.org/licenses/>.
22__all__ = [] # importing this module adds methods to BaseColumnView
24import numpy as np
26from lsst.utils import continueClass
27from ._table import KeyFlag, _BaseColumnViewBase
29# We can't call this "BaseColumnView" because that's the typedef for
30# "ColumnViewT<BaseRecord>". This is just a mostly-invisible implementation
31# base class, so we use the same naming convention we use for those.
34@continueClass # noqa: F811
35class _BaseColumnViewBase:
37 def getBits(self, keys=None):
38 """Get the bits associated with the specified keys.
40 Parameters
41 ----------
42 key : `str`
43 Key to retrieve. Unlike the C++ version, each key may be a
44 field name or a key, and if keys is `None` then all bits
45 are returned.
47 Returns
48 -------
49 bits : `int`
50 Integer array of the requested bitmask.
51 """
52 if keys is None:
53 return self.getAllBits()
54 arg = []
55 for k in keys:
56 if isinstance(k, str):
57 arg.append(self.schema.find(k).key)
58 else:
59 arg.append(k)
60 return self._getBits(arg)
62 def __getitem__(self, key):
63 """Get a column view; key may be a key object or the name of a field.
64 """
65 if isinstance(key, str):
66 keyobj = self.schema.find(key).key
67 else:
68 keyobj = key
69 return self._basicget(keyobj)
71 get = __getitem__
73 def __setitem__(self, key, value):
74 """Set a full column to an array or scalar; key may be a key object or
75 the name of a field.
76 """
77 self.get(key)[:] = value
79 set = __setitem__
81 def get_bool_array(self, key):
82 """Get the value of a flag column as a boolean array; key must be a
83 key object or the name of a field.
85 Parameters
86 ----------
87 key : `lsst.afw.table.KeyFlag`
88 Flag column to search for.
90 Returns
91 -------
92 value : `list` of `bool`
93 Array of booleans corresponding to the flag.
95 Raises
96 ------
97 TypeError
98 Raised if the key is not a KeyFlag.
99 """
100 if isinstance(key, KeyFlag):
101 return self[key]
102 raise TypeError("key={} not an lsst.afw.table.KeyFlag".format(key))
104 def extract(self, *patterns, **kwds):
105 """Extract a dictionary of {<name>: <column-array>} in which the field
106 names match the given shell-style glob pattern(s).
108 Any number of glob patterns may be passed (including none); the result
109 will be the union of all the result of each glob considered
110 separately.
112 Note that extract("*", copy=True) provides an easy way to transform a
113 row-major ColumnView into a possibly more efficient set of contiguous
114 NumPy arrays.
116 This routines unpacks `Flag` columns into full boolean arrays and
117 covariances into dense (i.e. non-triangular packed) arrays with
118 dimension (N,M,M), where N is the number of records and M is the
119 dimension of the covariance matrix. String fields are silently
120 ignored.
122 Parameters
123 ----------
124 patterns : Array of `str`
125 List of glob patterns to use to select field names.
126 kwds : `dict`
127 Dictionary of additional keyword arguments. May contain:
128 - ``items`` : `list`
129 The result of a call to self.schema.extract(); this
130 will be used instead of doing any new matching, and
131 allows the pattern matching to be reused to extract
132 values from multiple records. This keyword is
133 incompatible with any position arguments and the
134 regex, sub, and ordered keyword arguments.
135 - ``where`` : array index expression
136 Any expression that can be passed as indices to a
137 NumPy array, including slices, boolean arrays, and
138 index arrays, that will be used to index each column
139 array. This is applied before arrays are copied when
140 copy is True, so if the indexing results in an
141 implicit copy no unnecessary second copy is performed.
142 - ``copy`` : `bool`
143 If True, the returned arrays will be contiguous copies
144 rather than strided views into the catalog. This
145 ensures that the lifetime of the catalog is not tied
146 to the lifetime of a particular catalog, and it also
147 may improve the performance if the array is used
148 repeatedly. Default is False.
149 - ``regex`` : `str` or `re` pattern
150 A regular expression to be used in addition to any
151 glob patterns passed as positional arguments. Note
152 that this will be compared with re.match, not
153 re.search.
154 - ``sub`` : `str`
155 A replacement string (see re.MatchObject.expand) used
156 to set the dictionary keys of any fields matched by
157 regex.
158 - ``ordered`` : `bool`
159 If True, a collections.OrderedDict will be returned
160 instead of a standard dict, with the order
161 corresponding to the definition order of the
162 Schema. Default is False.
164 Returns
165 -------
166 d : `dict`
167 Dictionary of extracted name-column array sets.
169 Raises
170 ------
171 ValueError
172 Raised if a list of ``items`` is supplied with additional
173 keywords.
174 """
175 copy = kwds.pop("copy", False)
176 where = kwds.pop("where", None)
177 d = kwds.pop("items", None)
178 # If ``items`` is given as a kwd, an extraction has already been performed and there shouldn't be
179 # any additional keywords. Otherwise call schema.extract to load the
180 # dictionary.
181 if d is None:
182 d = self.schema.extract(*patterns, **kwds).copy()
183 elif kwds:
184 raise ValueError(
185 "kwd 'items' was specified, which is not compatible with additional keywords")
187 def processArray(a):
188 if where is not None:
189 a = a[where]
190 if copy:
191 a = np.ascontiguousarray(a)
192 return a
194 # must use list because we might be adding/deleting elements
195 for name, schemaItem in list(d.items()):
196 key = schemaItem.key
197 if key.getTypeString() == "String":
198 del d[name]
199 else:
200 d[name] = processArray(self.get(schemaItem.key))
201 return d