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

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

 

__all__ = ("DatasetOriginInfo", "DatasetOriginInfoDef", "PreFlightUnitsRow") 

 

 

from abc import ABCMeta, abstractmethod 

 

 

class DatasetOriginInfo(metaclass=ABCMeta): 

"""Interface for classes providing collection information for pre-flight. 

 

Pre-flight supports per-DatasetType collections, multiple collections 

can be searched for input Datasets and there is one output collection 

per Dataset. Typically one collection will be used for all inputs and 

possibly separate single collection will be used for all outputs. Some 

configurations may need more complex setup, and this interface 

encapsulates all possible behaviors. 

""" 

 

@abstractmethod 

def getInputCollections(self, datasetTypeName): 

"""Return ordered list of input collections for given dataset type. 

 

Returns 

------- 

collections : `list` of `str` 

Names of input collections. 

""" 

pass 

 

@abstractmethod 

def getOutputCollection(self, datasetTypeName): 

"""Return output collection name for given dataset type. 

 

Returns 

------- 

collection : `str` 

Name of output collection. 

""" 

pass 

 

 

class DatasetOriginInfoDef(DatasetOriginInfo): 

"""Default implementation of the DatasetOriginInfo. 

 

Parameters 

---------- 

defaultInputs : `list` of `str` 

Default list of input collections, used for dataset types for which 

there are no overrides. 

defaultOutput : `str` 

Default output collection, used for dataset types for which there is 

no override. 

inputOverrides : `dict` {`str`: `list` of `str`}, optional 

Per-DatasetType overrides for input collections. The key is the name 

of the DatasetType, the value is a list of input collection names. 

outputOverrides : `dict` {`str`: `str`}, optional 

Per-DatasetType overrides for output collections. The key is the name 

of the DatasetType, the value is output collection name. 

""" 

def __init__(self, defaultInputs, defaultOutput, inputOverrides=None, 

outputOverrides=None): 

self.defaultInputs = defaultInputs 

self.defaultOutput = defaultOutput 

self.inputOverrides = inputOverrides or {} 

self.outputOverrides = outputOverrides or {} 

 

def getInputCollections(self, datasetTypeName): 

"""Return ordered list of input collections for given dataset type. 

 

Returns 

------- 

collections : `list` of `str` 

Names of input collections. 

""" 

return self.inputOverrides.get(datasetTypeName, self.defaultInputs) 

 

def getOutputCollection(self, datasetTypeName): 

"""Return output collection name for given dataset type. 

 

Returns 

------- 

collection : `str` 

Name of output collection. 

""" 

return self.outputOverrides.get(datasetTypeName, self.defaultOutput) 

 

 

class PreFlightUnitsRow: 

"""Simple data class holding combination of DataUnit values for one row 

returned by pre-flight solver. 

 

Logically instance of this class represents a single "path" connecting a 

set of DatasetRefs which exist or may exist for a given set of 

DatasetTypes based on the DataUnit relational algebra. 

 

Pre-flight solver returns a sequence of `PreFlightUnitsRow` instances, 

each instance will have unique ``dataId``, but `DatasetRef` in 

``datasetRefs`` are not necessarily unique. For example when pre-flight 

solver generates data for Quantum which has two DatasetRefs on input and 

one on output it will create two `PreFlightUnitsRow` instances with the 

same `DatasetRef` for output dataset type. It is caller's responsibility 

to combine multiple `PreFlightUnitsRow` into a suitable structure 

(e.g. QuantumGraph). 

 

Attributes 

---------- 

dataId : `dict` 

Maps DataUnit link name to its corresponding value. 

datasetRefs : `dict` 

Maps `DatasetType` to its corresponding `DatasetRef`. 

""" 

__slots__ = ("_dataId", "_datasetRefs") 

 

def __init__(self, dataId, datasetRefs): 

self._dataId = dataId 

self._datasetRefs = datasetRefs 

 

@property 

def dataId(self): 

return self._dataId 

 

@property 

def datasetRefs(self): 

return self._datasetRefs 

 

def __str__(self): 

return "(dataId={}, datasetRefs=[{}])".format( 

self.dataId, ', '.join(str(ref) for ref in self.datasetRefs.values()))