27 from ._table
import KeyFlag, _BaseColumnViewBase
38 """Get the bits associated with the specified keys.
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
50 Integer array of the requested bitmask.
53 return self.getAllBits()
56 if isinstance(k, str):
57 arg.append(self.schema.find(k).key)
60 return self._getBits(arg)
63 """Get a column view; key may be a key object or the name of a field.
65 if isinstance(key, str):
66 keyobj = self.schema.find(key).key
69 return self._basicget(keyobj)
74 """Set a full column to an array or scalar; key may be a key object or
77 self.
get(key)[:] = value
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.
87 key : `lsst.afw.table.KeyFlag`
88 Flag column to search for.
92 value : `list` of `bool`
93 Array of booleans corresponding to the flag.
98 Raised if the key is not a KeyFlag.
100 if isinstance(key, KeyFlag):
102 raise TypeError(
"key={} not an lsst.afw.table.KeyFlag".format(key))
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
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
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
124 patterns : Array of `str`
125 List of glob patterns to use to select field names.
127 Dictionary of additional keyword arguments. May contain:
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.
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
155 A replacement string (see re.MatchObject.expand) used
156 to set the dictionary keys of any fields matched by
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.
167 Dictionary of extracted name-column array sets.
172 Raised if a list of ``items`` is supplied with additional
175 copy = kwds.pop(
"copy",
False)
176 where = kwds.pop(
"where",
None)
177 d = kwds.pop(
"items",
None)
182 d = self.schema.
extract(*patterns, **kwds).copy()
185 "kwd 'items' was specified, which is not compatible with additional keywords")
188 if where
is not None:
191 a = np.ascontiguousarray(a)
195 for name, schemaItem
in list(d.items()):
197 if key.getTypeString() ==
"String":
200 d[name] = processArray(self.
get(schemaItem.key))