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

48 statements  

« prev     ^ index     » next       coverage.py v6.4.4, created at 2022-09-02 02:18 -0700

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 

35class _BaseColumnViewBase: # noqa: F811 

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 

129 ``items`` : `list` 

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. 

143 ``copy`` : `bool` 

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 

154 re.search. 

155 ``sub`` : `str` 

156 A replacement string (see re.MatchObject.expand) used 

157 to set the dictionary keys of any fields matched by 

158 regex. 

159 ``ordered`` : `bool` 

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. 

164 

165 Returns 

166 ------- 

167 d : `dict` 

168 Dictionary of extracted name-column array sets. 

169 

170 Raises 

171 ------ 

172 ValueError 

173 Raised if a list of ``items`` is supplied with additional 

174 keywords. 

175 """ 

176 copy = kwds.pop("copy", False) 

177 where = kwds.pop("where", None) 

178 d = kwds.pop("items", None) 

179 # If ``items`` is given as a kwd, an extraction has already been performed and there shouldn't be 

180 # any additional keywords. Otherwise call schema.extract to load the 

181 # dictionary. 

182 if d is None: 

183 d = self.schema.extract(*patterns, **kwds).copy() 

184 elif kwds: 

185 raise ValueError( 

186 "kwd 'items' was specified, which is not compatible with additional keywords") 

187 

188 def processArray(a): 

189 if where is not None: 

190 a = a[where] 

191 if copy: 

192 a = np.ascontiguousarray(a) 

193 return a 

194 

195 # must use list because we might be adding/deleting elements 

196 for name, schemaItem in list(d.items()): 

197 key = schemaItem.key 

198 if key.getTypeString() == "String": 

199 del d[name] 

200 else: 

201 d[name] = processArray(self.get(schemaItem.key)) 

202 return d