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

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

# This file is part of daf_butler. 

# 

# Developed for the LSST Data Management System. 

# This product includes software developed by the LSST Project 

# (http://www.lsst.org). 

# See the COPYRIGHT file at the top-level directory of this distribution 

# for details of code ownership. 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 3 of the License, or 

# (at your option) any later version. 

# 

# This program is distributed in the hope that it will be useful, 

# but WITHOUT ANY WARRANTY; without even the implied warranty of 

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

# GNU General Public License for more details. 

# 

# You should have received a copy of the GNU General Public License 

# along with this program. If not, see <http://www.gnu.org/licenses/>. 

 

""" 

Python classes that can be used to test datastores without requiring 

large external dependencies on python classes such as afw or serialization 

formats such as FITS or HDF5. 

""" 

 

import copy 

from lsst.daf.butler import CompositeAssembler 

 

 

class MetricsExample: 

"""Smorgasboard of information that might be the result of some 

processing. 

 

Parameters 

---------- 

summary : `dict` 

Simple dictionary mapping key performance metrics to a scalar 

result. 

output : `dict` 

Structured nested data. 

data : `list`, optional 

Arbitrary array data. 

""" 

 

def __init__(self, summary=None, output=None, data=None): 

self.summary = summary 

self.output = output 

self.data = data 

 

def __eq__(self, other): 

return self.summary == other.summary and self.output == other.output and self.data == other.data 

 

def exportAsDict(self): 

"""Convert object contents to a single python dict.""" 

exportDict = {"summary": self.summary, 

"output": self.output} 

59 ↛ 61line 59 didn't jump to line 61, because the condition on line 59 was never false if self.data is not None: 

exportDict["data"] = list(self.data) 

return exportDict 

 

def _asdict(self): 

"""Convert object contents to a single Python dict. 

 

This interface is used for JSON serialization. 

 

Returns 

------- 

exportDict : `dict` 

Object contents in the form of a dict with keys corresponding 

to object attributes. 

""" 

return self.exportAsDict() 

 

@classmethod 

def makeFromDict(cls, exportDict): 

"""Create a new object from a dict that is compatible with that 

created by `exportAsDict`. 

 

Parameters 

---------- 

exportDict : `dict` 

`dict` with keys "summary", "output", and (optionally) "data". 

 

Returns 

------- 

newobject : `MetricsExample` 

New `MetricsExample` object. 

""" 

data = None 

if "data" in exportDict: 

data = exportDict["data"] 

return cls(exportDict["summary"], exportDict["output"], data) 

 

 

class ListAssembler(CompositeAssembler): 

"""Parameter handler for list parameters""" 

 

def handleParameters(self, inMemoryDataset, parameters=None): 

"""Modify the in-memory dataset using the supplied parameters, 

returning a possibly new object. 

 

Parameters 

---------- 

inMemoryDataset : `object` 

Object to modify based on the parameters. 

parameters : `dict` 

Parameters to apply. Values are specific to the parameter. 

Supported parameters are defined in the associated 

`StorageClass`. If no relevant parameters are specified the 

inMemoryDataset will be return unchanged. 

 

Returns 

------- 

inMemoryDataset : `object` 

Updated form of supplied in-memory dataset, after parameters 

have been used. 

""" 

inMemoryDataset = copy.deepcopy(inMemoryDataset) 

use = self.storageClass.filterParameters(parameters, subset={"slice"}) 

122 ↛ 124line 122 didn't jump to line 124, because the condition on line 122 was never false if use: 

inMemoryDataset = inMemoryDataset[use["slice"]] 

return inMemoryDataset 

 

 

class MetricsAssembler(CompositeAssembler): 

"""Parameter handler for parameters using Metrics""" 

 

def handleParameters(self, inMemoryDataset, parameters=None): 

"""Modify the in-memory dataset using the supplied parameters, 

returning a possibly new object. 

 

Parameters 

---------- 

inMemoryDataset : `object` 

Object to modify based on the parameters. 

parameters : `dict` 

Parameters to apply. Values are specific to the parameter. 

Supported parameters are defined in the associated 

`StorageClass`. If no relevant parameters are specified the 

inMemoryDataset will be return unchanged. 

 

Returns 

------- 

inMemoryDataset : `object` 

Updated form of supplied in-memory dataset, after parameters 

have been used. 

""" 

inMemoryDataset = copy.deepcopy(inMemoryDataset) 

use = self.storageClass.filterParameters(parameters, subset={"slice"}) 

if use: 

inMemoryDataset.data = inMemoryDataset.data[use["slice"]] 

return inMemoryDataset