Coverage for tests/data/make_metricvalue_butlers.py: 14%

66 statements  

« prev     ^ index     » next       coverage.py v6.5.0, created at 2023-04-07 00:56 +0000

1#!/usr/bin/env python 

2"""Create two butler repos for tests of the metricvalue extract/print code. 

3""" 

4 

5import astropy.units as u 

6 

7import lsst.daf.butler 

8from lsst.daf.butler.tests import addDatasetType, addDataIdValue 

9from lsst.verify import Measurement 

10 

11collection = "testrun" 

12 

13 

14def setup_butler(repo): 

15 """Create a butler at the given location, and register appropriate things 

16 in it to allow adding metricvalues. 

17 """ 

18 lsst.daf.butler.Butler.makeRepo(repo) 

19 butler = lsst.daf.butler.Butler(repo, writeable=True) 

20 

21 addDataIdValue(butler, "instrument", "TestCam") 

22 for x in range(189): 

23 addDataIdValue(butler, "detector", x) 

24 addDataIdValue(butler, "visit", 12345) 

25 addDataIdValue(butler, "visit", 54321) 

26 butler.registry.registerCollection(collection, lsst.daf.butler.CollectionType.RUN) 

27 

28 return butler 

29 

30 

31def add_metricvalues(butler, plus): 

32 """Add Measurements as MetricValue datasets to a pre-configured butler, 

33 adding ``plus`` to the values that are stored (to allow different repos to 

34 have different Measurement values). 

35 """ 

36 storageClass = "MetricValue" 

37 

38 # a metric that only depends on instrument 

39 dimensions = {"instrument"} 

40 addDatasetType(butler, "metricvalue_verify_instrumentTest", dimensions, storageClass) 

41 value = Measurement("verify.instrumentTest", (2 + plus)*u.dimensionless_unscaled) 

42 butler.put(value, "metricvalue_verify_instrumentTest", {"instrument": "TestCam"}, run=collection) 

43 

44 # The rest are detector+visit metrics 

45 dimensions = {"instrument", "visit", "detector"} 

46 dataIds = [{"instrument": "TestCam", "visit": 12345, "detector": 12}, 

47 {"instrument": "TestCam", "visit": 54321, "detector": 25}, 

48 {"instrument": "TestCam", "visit": 54321, "detector": 12}] 

49 addDatasetType(butler, "metricvalue_verify_testing", dimensions, storageClass) 

50 value = Measurement("verify.testing", (12 + plus)*u.dimensionless_unscaled) 

51 butler.put(value, "metricvalue_verify_testing", dataIds[0], run=collection) 

52 value = Measurement("verify.testing", (42 + plus)*u.dimensionless_unscaled) 

53 butler.put(value, "metricvalue_verify_testing", dataIds[1], run=collection) 

54 value = Measurement("verify.testing", (5 + plus)*u.dimensionless_unscaled) 

55 butler.put(value, "metricvalue_verify_testing", dataIds[2], run=collection) 

56 

57 addDatasetType(butler, "metricvalue_verify_other", dimensions, storageClass) 

58 value = Measurement("verify.other", (7 + plus)*u.ct) 

59 butler.put(value, "metricvalue_verify_other", dataIds[0], run=collection) 

60 value = Measurement("verify.other", (8 + plus)*u.ct) 

61 butler.put(value, "metricvalue_verify_other", dataIds[1], run=collection) 

62 

63 addDatasetType(butler, "metricvalue_verify_another", dimensions, storageClass) 

64 value = Measurement("verify.another", (3 + plus)*u.mas) 

65 butler.put(value, "metricvalue_verify_another", dataIds[0], run=collection) 

66 

67 addDatasetType(butler, "metricvalue_verify_testingTime", dimensions, storageClass) 

68 value = Measurement("verify.testingTime", (18 + plus)*u.second) 

69 butler.put(value, "metricvalue_verify_testingTime", dataIds[0], run=collection) 

70 value = Measurement("verify.testingTime", (19 + plus)*u.second) 

71 butler.put(value, "metricvalue_verify_testingTime", dataIds[1], run=collection) 

72 

73 addDatasetType(butler, "metricvalue_verify_anotherTime", dimensions, storageClass) 

74 value = Measurement("verify.anotherTime", (100 + plus)*u.ms) 

75 butler.put(value, "metricvalue_verify_anotherTime", dataIds[0], run=collection) 

76 value = Measurement("verify.anotherTime", (200 + plus)*u.ms) 

77 butler.put(value, "metricvalue_verify_anotherTime", dataIds[1], run=collection) 

78 

79 addDatasetType(butler, "metricvalue_verify_testingMemory", dimensions, storageClass) 

80 value = Measurement("verify.testingMemory", (100 + plus)*u.Mbyte) 

81 butler.put(value, "metricvalue_verify_testingMemory", dataIds[0], run=collection) 

82 value = Measurement("verify.testingMemory", (200 + plus)*u.Mbyte) 

83 butler.put(value, "metricvalue_verify_testingMemory", dataIds[1], run=collection) 

84 

85 addDatasetType(butler, "metricvalue_verify_anotherTaskMemory", dimensions, storageClass) 

86 value = Measurement("verify.anotherTaskMemory", (5 + plus)*u.Gbyte) 

87 butler.put(value, "metricvalue_verify_anotherTaskMemory", dataIds[0], run=collection) 

88 value = Measurement("verify.anotherTaskMemory", (6 + plus)*u.Gbyte) 

89 butler.put(value, "metricvalue_verify_anotherTaskMemory", dataIds[1], run=collection) 

90 

91 

92if __name__ == "__main__": 92 ↛ 93line 92 didn't jump to line 93, because the condition on line 92 was never true

93 repo = "metricvalue_repo1" 

94 butler = setup_butler(repo) 

95 add_metricvalues(butler, 0) 

96 

97 repo = "metricvalue_repo2" 

98 butler = setup_butler(repo) 

99 add_metricvalues(butler, 1)