Hide keyboard shortcuts

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/>. 

21 

22__all__ = [] # importing this module adds methods to BaseColumnView 

23 

24import numpy as np 

25 

26from lsst.utils import continueClass 

27from ._table import KeyFlag, _BaseColumnViewBase 

28 

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. 

32 

33 

34@continueClass # noqa: F811 

35class _BaseColumnViewBase: 

36 

37 def getBits(self, keys=None): 

38 """Get the bits associated with the specified keys. 

39 

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. 

46 

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) 

61 

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) 

70 

71 get = __getitem__ 

72 

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 

78 

79 set = __setitem__ 

80 

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. 

84 

85 Parameters 

86 ---------- 

87 key : `lsst.afw.table.KeyFlag` 

88 Flag column to search for. 

89 

90 Returns 

91 ------- 

92 value : `list` of `bool` 

93 Array of booleans corresponding to the flag. 

94 

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)) 

103 

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). 

107 

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. 

111 

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. 

115 

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. 

121 

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. 

163 

164 Returns 

165 ------- 

166 d : `dict` 

167 Dictionary of extracted name-column array sets. 

168 

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") 

186 

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 

193 

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