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:
130 The result of a call to self.schema.extract(); this
131 will be used instead of doing any new matching, and
132 allows the pattern matching to be reused to extract
133 values from multiple records. This keyword is
134 incompatible with any position arguments and the
135 regex, sub, and ordered keyword arguments.
136 ``where`` : array index expression
137 Any expression that can be passed as indices to a
138 NumPy array, including slices, boolean arrays, and
139 index arrays, that will be used to index each column
140 array. This is applied before arrays are copied when
141 copy is True, so if the indexing results in an
142 implicit copy no unnecessary second copy is performed.
144 If True, the returned arrays will be contiguous copies
145 rather than strided views into the catalog. This
146 ensures that the lifetime of the catalog is not tied
147 to the lifetime of a particular catalog, and it also
148 may improve the performance if the array is used
149 repeatedly. Default is False.
150 ``regex`` : `str` or `re` pattern
151 A regular expression to be used in addition to any
152 glob patterns passed as positional arguments. Note
153 that this will be compared with re.match, not
156 A replacement string (see re.MatchObject.expand) used
157 to set the dictionary keys of any fields matched by
160 If True, a collections.OrderedDict will be returned
161 instead of a standard dict, with the order
162 corresponding to the definition order of the
163 Schema. Default is False.
168 Dictionary of extracted name-column array sets.
173 Raised if a list of ``items`` is supplied with additional
176 copy = kwds.pop(
"copy",
False)
177 where = kwds.pop(
"where",
None)
178 d = kwds.pop(
"items",
None)
183 d = self.schema.
extract(*patterns, **kwds).copy()
186 "kwd 'items' was specified, which is not compatible with additional keywords")
189 if where
is not None:
192 a = np.ascontiguousarray(a)
196 for name, schemaItem
in list(d.items()):
198 if key.getTypeString() ==
"String":
201 d[name] = processArray(self.
get(schemaItem.key))