legend-daq2lh5 1.4.1__py3-none-any.whl → 1.4.2__py3-none-any.whl

daq2lh5/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.4.1'
-__version_tuple__ = version_tuple = (1, 4, 1)
+__version__ = version = '1.4.2'
+__version_tuple__ = version_tuple = (1, 4, 2)

daq2lh5/llama/llama_event_decoder.py

@@ -17,10 +17,10 @@ llama_decoded_values_template = {
     # packet index in file
     "packet_id": {"dtype": "uint32"},
     # combined index of FADC and channel
-    "fch_id": {"dtype": "uint32"},
+    "fadc_channel_id": {"dtype": "uint32"},
     # time since epoch
-    "timestamp": {"dtype": "uint64", "units": "clock_ticks"},
-    "status_flag": {"dtype": "uint32"},
+    "time_since_run_start": {"dtype": "float64", "units": "s"},
+    "fadc_status_bits": {"dtype": "uint32"},
     # waveform data --> not always present
     # "waveform": {
     #    "dtype": "uint16",
@@ -69,8 +69,9 @@ class LLAMAEventDecoder(DataDecoder):
         )  # constant part of the t0 of averaged waveforms
 
     def set_channel_configs(self, channel_configs: LLAMA_Channel_Configs_t) -> None:
-        """Receive channel configurations from llama_streamer after header was parsed
-        Adapt self.decoded_values dict based on read configuration
+        """Receive channel configurations from llama_streamer after header was parsed.
+
+        Adapt self.decoded_values dict based on read configuration.
         """
         self.channel_configs = channel_configs
         for fch, config in self.channel_configs.items():
@@ -109,10 +110,11 @@ class LLAMAEventDecoder(DataDecoder):
                 self.__add_energy(self.decoded_values[fch])
 
     def get_key_lists(self) -> list[list[int | str]]:
-        """
-        Return a list of lists of keys available for this decoder.
-        Each inner list are the fch_id's which share the exact same settings (trace lengths, avg mode, ...),
-        so they can end up in the same buffer.
+        """Get list of keys.
+
+        Return a list of lists of keys available for this decoder.  Each inner
+        list are the fadc_channel_id's which share the exact same settings
+        (trace lengths, avg mode, ...), so they can end up in the same buffer.
         """
         if self.channel_configs is None:
             raise RuntimeError(
@@ -125,14 +127,14 @@ class LLAMAEventDecoder(DataDecoder):
             return check_dict_spec_equal(c1, c2, params_for_equality)
 
         kll: list[list[int]] = []  # key-list-list
-        for fch_id, config in self.channel_configs.items():
+        for fadc_channel_id, config in self.channel_configs.items():
             for kl in kll:
                 # use 1st entry of a list of list as "archetype"
                 if check_equal(config, self.channel_configs[kl[0]]):
-                    kl.append(fch_id)
+                    kl.append(fadc_channel_id)
                     break
             else:
-                kll.append([fch_id])
+                kll.append([fadc_channel_id])
         log.debug(f"key lists are: {repr(kll)}")
         return kll
 
@@ -154,66 +156,78 @@ class LLAMAEventDecoder(DataDecoder):
         packet: bytes,
         evt_rbkd: lgdo.Table | dict[int, lgdo.Table],
         packet_id: int,
-        fch_id: int,
+        fadc_channel_id: int,
         # header: lgdo.Table | dict[int, lgdo.Table]
     ) -> bool:
-        """
-        Decodes a single packet, which is a single SIS3316 event, as specified in the Struck manual.
-        A single packet corresponds to a single event and channel, and has a unique timestamp.
-        packets of different channel groups can vary in size!
+        """Decode packet.
+
+        Decodes a single packet, which is a single SIS3316 event, as specified
+        in the Struck manual.  A single packet corresponds to a single event
+        and channel, and has a unique timestamp.  packets of different channel
+        groups can vary in size!
         """
 
-        # Check if this fch_id should be recorded.
-        if fch_id not in evt_rbkd:
-            if fch_id not in self.skipped_channels:
-                self.skipped_channels[fch_id] = 0
-                log.info(f"Skipping channel: {fch_id}")
+        # Check if this fadc_channel_id should be recorded.
+        if fadc_channel_id not in evt_rbkd:
+            if fadc_channel_id not in self.skipped_channels:
+                self.skipped_channels[fadc_channel_id] = 0
+                log.info(f"Skipping channel: {fadc_channel_id}")
                 log.debug(f"evt_rbkd: {evt_rbkd.keys()}")
-            self.skipped_channels[fch_id] += 1
+            self.skipped_channels[fadc_channel_id] += 1
             return False
 
-        tbl = evt_rbkd[fch_id].lgdo
-        ii = evt_rbkd[fch_id].loc
+        tbl = evt_rbkd[fadc_channel_id].lgdo
+        ii = evt_rbkd[fadc_channel_id].loc
 
         # parse the raw event data into numpy arrays of 16 and 32 bit ints
         evt_data_32 = np.frombuffer(packet, dtype=np.uint32)
         evt_data_16 = np.frombuffer(packet, dtype=np.uint16)
 
         # e sti gran binaries non ce li metti
-        # fch_id = (evt_data_32[0] >> 4) & 0x00000fff  --> to be read earlier, since we need size for chopping out the event from the stream
-        timestamp = ((evt_data_32[0] & 0xFFFF0000) << 16) + evt_data_32[1]
+        # fadc_channel_id = (evt_data_32[0] >> 4) & 0x00000fff  --> to be read earlier,
+        # since we need size for chopping out the event from the stream
+        timestamp_in_clock_ticks = ((evt_data_32[0] & 0xFFFF0000) << 16) + evt_data_32[
+            1
+        ]
         format_bits = (evt_data_32[0]) & 0x0000000F
-        tbl["fch_id"].nda[ii] = fch_id
+
+        timestamp = timestamp_in_clock_ticks * self.dt_raw[fadc_channel_id] * 1e-9
+
+        tbl["fadc_channel_id"].nda[ii] = fadc_channel_id
         tbl["packet_id"].nda[ii] = packet_id
-        tbl["timestamp"].nda[ii] = timestamp
+        tbl["time_since_run_start"].nda[ii] = timestamp
+
         offset = 2
         if format_bits & 0x1:
-            tbl["peakHighValue"].nda[ii] = evt_data_16[4]
-            tbl["peakHighIndex"].nda[ii] = evt_data_16[5]
-            tbl["information"].nda[ii] = (evt_data_32[offset + 1] >> 24) & 0xFF
-            tbl["accSum1"].nda[ii] = evt_data_32[offset + 2]
-            tbl["accSum2"].nda[ii] = evt_data_32[offset + 3]
-            tbl["accSum3"].nda[ii] = evt_data_32[offset + 4]
-            tbl["accSum4"].nda[ii] = evt_data_32[offset + 5]
-            tbl["accSum5"].nda[ii] = evt_data_32[offset + 6]
-            tbl["accSum6"].nda[ii] = evt_data_32[offset + 7]
+            tbl["wf_max_sample_value"].nda[ii] = evt_data_16[4]
+            tbl["wf_max_sample_idx"].nda[ii] = evt_data_16[5]
+            tbl["info_bits"].nda[ii] = (evt_data_32[offset + 1] >> 24) & 0xFF
+            tbl["cumsum_1"].nda[ii] = evt_data_32[offset + 2]
+            tbl["cumsum_2"].nda[ii] = evt_data_32[offset + 3]
+            tbl["cumsum_3"].nda[ii] = evt_data_32[offset + 4]
+            tbl["cumsum_4"].nda[ii] = evt_data_32[offset + 5]
+            tbl["cumsum_5"].nda[ii] = evt_data_32[offset + 6]
+            tbl["cumsum_6"].nda[ii] = evt_data_32[offset + 7]
             offset += 7
+
         if format_bits & 0x2:
-            tbl["accSum7"].nda[ii] = evt_data_32[offset + 0]
-            tbl["accSum8"].nda[ii] = evt_data_32[offset + 1]
+            tbl["cumsum_7"].nda[ii] = evt_data_32[offset + 0]
+            tbl["cumsum_8"].nda[ii] = evt_data_32[offset + 1]
             offset += 2
+
         if format_bits & 0x4:
-            tbl["mawMax"].nda[ii] = evt_data_32[offset + 0]
-            tbl["mawBefore"].nda[ii] = evt_data_32[offset + 1]
-            tbl["mawAfter"].nda[ii] = evt_data_32[offset + 2]
+            tbl["maw_max"].nda[ii] = evt_data_32[offset + 0]
+            tbl["maw_before"].nda[ii] = evt_data_32[offset + 1]
+            tbl["maw_after"].nda[ii] = evt_data_32[offset + 2]
             offset += 3
+
         if format_bits & 0x8:
-            tbl["startEnergy"].nda[ii] = evt_data_32[offset + 0]
-            tbl["maxEnergy"].nda[ii] = evt_data_32[offset + 1]
+            tbl["start_energy"].nda[ii] = evt_data_32[offset + 0]
+            tbl["max_energy"].nda[ii] = evt_data_32[offset + 1]
             offset += 2
 
         raw_length_32 = (evt_data_32[offset + 0]) & 0x03FFFFFF
-        tbl["status_flag"].nda[ii] = (
+        tbl["fadc_status_bits"].nda[ii] = (
             (evt_data_32[offset + 0]) & 0x04000000
         ) >> 26  # bit 26
         maw_test_flag = ((evt_data_32[offset + 0]) & 0x08000000) >> 27  # bit 27
@@ -249,35 +263,36 @@ class LLAMAEventDecoder(DataDecoder):
         # error check: waveform size must match expectations
         if raw_length_16 + avg_length_16 != expected_wf_length:
             raise RuntimeError(
-                f"Waveform sizes {raw_length_16} (raw) and {avg_length_16} (avg) doesn't match expected size {expected_wf_length}."
+                f"Waveform sizes {raw_length_16} (raw) and {avg_length_16} (avg) "
+                f"doesn't match expected size {expected_wf_length}."
             )
 
         # store waveform if available:
         if raw_length_16 > 0:
-            tbl["waveform"]["values"].nda[ii] = evt_data_16[
+            tbl["waveform_windowed"]["values"].nda[ii] = evt_data_16[
                 offset * 2 : offset * 2 + raw_length_16
             ]
             offset += raw_length_32
-            tbl["waveform"]["t0"].nda[ii] = self.t0_raw[fch_id]
+            tbl["waveform_windowed"]["t0"].nda[ii] = self.t0_raw[fadc_channel_id]
 
         # store pre-averaged (avg) waveform if available:
         if avg_length_16 > 0:
-            tbl["avgwaveform"]["values"].nda[ii] = evt_data_16[
+            tbl["waveform_presummed"]["values"].nda[ii] = evt_data_16[
                 offset * 2 : offset * 2 + avg_length_16
             ]
             offset += avg_length_32
             # need to update avg waveform t0 based on the offset I get per event
-            tbl["avgwaveform"]["t0"].nda[ii] = (
-                self.t0_avg_const[fch_id]
-                + float(avg_count_status) * self.dt_raw[fch_id]
+            tbl["waveform_presummed"]["t0"].nda[ii] = (
+                self.t0_avg_const[fadc_channel_id]
+                + float(avg_count_status) * self.dt_raw[fadc_channel_id]
             )
 
         if offset != len(evt_data_32):
             raise RuntimeError("I messed up...")
 
-        evt_rbkd[fch_id].loc += 1
+        evt_rbkd[fadc_channel_id].loc += 1
 
-        return evt_rbkd[fch_id].is_full()
+        return evt_rbkd[fadc_channel_id].is_full()
 
     def __add_waveform(
         self,
@@ -286,13 +301,17 @@ class LLAMAEventDecoder(DataDecoder):
         max_samples: int,
         dt: float,
     ) -> None:
-        """
-        Averaged samples are available from the 125 MHz (16 bit) variatnt of the SIS3316 and can be stored independently of raw samples.
-        I use waveform for raw samples (dt from clock itself) and avgwaveform from averaged samples (dt from clock * avg number).
+        """Helper function to add waveform.
+
+        Averaged samples are available from the 125 MHz (16 bit) variatnt of
+        the SIS3316 and can be stored independently of raw samples.  I use
+        waveform for raw samples (dt from clock itself) and waveform_presummed
+        from averaged samples (dt from clock * avg number).
 
-        GERDA used to have the low-frequency (waveform) & the high-frequency (aux waveform); here: LF = avgwaveform & HF = waveform.
+        GERDA used to have the low-frequency (waveform) & the high-frequency
+        (aux waveform); here: LF = waveform_presummed & HF = waveform_windowed.
         """
-        name: str = "avgwaveform" if is_avg else "waveform"
+        name: str = "waveform_presummed" if is_avg else "waveform_windowed"
         decoded_values_fch[name] = {
             "dtype": "uint16",
             "datatype": "waveform",
@@ -304,25 +323,25 @@ class LLAMAEventDecoder(DataDecoder):
         }
 
     def __add_accum1till6(self, decoded_values_fch: dict[str, Any]) -> None:
-        decoded_values_fch["peakHighValue"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["peakHighIndex"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["information"] = {"dtype": "uint32"}
-        decoded_values_fch["accSum1"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["accSum2"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["accSum3"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["accSum4"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["accSum5"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["accSum6"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["wf_max_sample_value"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["wf_max_sample_idx"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["info_bits"] = {"dtype": "uint32"}
+        decoded_values_fch["cumsum_1"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_2"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_3"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_4"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_5"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_6"] = {"dtype": "uint32", "units": "adc"}
 
     def __add_accum7and8(self, decoded_values_fch: dict[str, Any]) -> None:
-        decoded_values_fch["accSum7"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["accSum8"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_7"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["cumsum_8"] = {"dtype": "uint32", "units": "adc"}
 
     def __add_maw(self, decoded_values_fch: dict[str, Any]) -> None:
-        decoded_values_fch["mawMax"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["mawBefore"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["mawAfter"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["maw_max"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["maw_before"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["maw_after"] = {"dtype": "uint32", "units": "adc"}
 
     def __add_energy(self, decoded_values_fch: dict[str, Any]) -> None:
-        decoded_values_fch["startEnergy"] = {"dtype": "uint32", "units": "adc"}
-        decoded_values_fch["maxEnergy"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["start_energy"] = {"dtype": "uint32", "units": "adc"}
+        decoded_values_fch["max_energy"] = {"dtype": "uint32", "units": "adc"}

daq2lh5/llama/llama_header_decoder.py

@@ -16,8 +16,10 @@ LLAMA_Channel_Configs_t = Dict[int, Dict[str, Any]]
 
 
 class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
-    """
-    Decode llamaDAQ header data. Includes the file header as well as all available ("open") channel configurations.
+    """Decode llamaDAQ header data.
+
+    Includes the file header as well as all available ("open") channel
+    configurations.
     """
 
     @staticmethod
@@ -62,7 +64,7 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
 
         n_bytes_read += self.__decode_channel_configs(f_in)
 
-        # print(self.channel_configs[0]["MAW3_offset"])
+        # print(self.channel_configs[0]["maw3_offset"])
 
         # assemble LGDO struct:
         self.config.add_field("version_major", lgdo.Scalar(self.version_major))
@@ -87,14 +89,15 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
         return self.channel_configs
 
     def __decode_channel_configs(self, f_in: io.BufferedReader) -> int:
-        """
-        Reads the metadata from the beginning of the file (the "channel configuration" part, directly after the file header).
-        Creates a dictionary of the metadata for each FADC/channel combination, which is returned
+        """Reads the metadata.
 
-        FADC-ID and channel-ID are combined into a single id for flattening:
-            (fadcid << 4) + chid
+        Reads the metadata from the beginning of the file (the "channel
+        configuration" part, directly after the file header).  Creates a
+        dictionary of the metadata for each FADC/channel combination, which is
+        returned. Returns number of bytes read.
 
-        returns number of bytes read
+        FADC-ID and channel-ID are combined into a single id for flattening:
+        ``(fadcid << 4) + chid``.
         """
         # f_in.seek(16)    #should be after file header anyhow, but re-set if not
         n_bytes_read = 0
@@ -118,15 +121,16 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
 
             if fch_id in self.channel_configs:
                 raise RuntimeError(
-                    f"duplicate channel configuration in file: FADCID: {fadc_index}, ChannelID: {channel_index}"
+                    f"duplicate channel configuration in file: FADCID: "
+                    f"{fadc_index}, ChannelID: {channel_index}"
                 )
             else:
                 self.channel_configs[fch_id] = {}
 
-            self.channel_configs[fch_id]["14BitFlag"] = evt_data_32[2] & 0x00000001
+            self.channel_configs[fch_id]["14_bit_flag"] = evt_data_32[2] & 0x00000001
             if evt_data_32[2] & 0x00000002 == 0:
                 log.warning("Channel in configuration marked as non-open!")
-            self.channel_configs[fch_id]["ADC_offset"] = evt_data_32[3]
+            self.channel_configs[fch_id]["adc_offset"] = evt_data_32[3]
             self.channel_configs[fch_id]["sample_freq"] = evt_data_dpf[
                 0
             ]  # 64 bit float
@@ -138,12 +142,12 @@ class LLAMAHeaderDecoder(DataDecoder):  # DataDecoder currently unused
             self.channel_configs[fch_id]["avg_mode"] = evt_data_32[12]
             self.channel_configs[fch_id]["sample_length"] = evt_data_32[13]
             self.channel_configs[fch_id]["avg_sample_length"] = evt_data_32[14]
-            self.channel_configs[fch_id]["MAW_buffer_length"] = evt_data_32[15]
+            self.channel_configs[fch_id]["maw_buffer_length"] = evt_data_32[15]
             self.channel_configs[fch_id]["event_length"] = evt_data_32[16]
             self.channel_configs[fch_id]["event_header_length"] = evt_data_32[17]
             self.channel_configs[fch_id]["accum6_offset"] = evt_data_32[18]
             self.channel_configs[fch_id]["accum2_offset"] = evt_data_32[19]
-            self.channel_configs[fch_id]["MAW3_offset"] = evt_data_32[20]
+            self.channel_configs[fch_id]["maw3_offset"] = evt_data_32[20]
             self.channel_configs[fch_id]["energy_offset"] = evt_data_32[21]
 
         return n_bytes_read

{legend_daq2lh5-1.4.1.dist-info → legend_daq2lh5-1.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: legend_daq2lh5
-Version: 1.4.1
+Version: 1.4.2
 Summary: Convert digitizer data to LH5
 Home-page: https://github.com/legend-exp/legend-daq2lh5
 Author: Jason Detwiler

{legend_daq2lh5-1.4.1.dist-info → legend_daq2lh5-1.4.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 daq2lh5/__init__.py,sha256=VPmwKuZSA0icpce05ojhnsKWhR4_QUgD0oVXUoN9wks,975
-daq2lh5/_version.py,sha256=2wP77AlenYjrtKg1nXf5noV1SfpanFafZAGSe7wvBys,511
+daq2lh5/_version.py,sha256=Ls_J-pNiuTKX1KU6pZ6tPQXAMcmLAzW_HHHgGVQNEd0,511
 daq2lh5/build_raw.py,sha256=SDpdOU8qpfzMtx8gtFu-RZYqxutQo1smJSkv-LrH9YE,10672
 daq2lh5/cli.py,sha256=7bPfH1XbyAS48wZn_0unj4Y5MD5kF7V34Q5srn4jKVM,2913
 daq2lh5/data_decoder.py,sha256=Cn40fodfKs7pKa2odzG1j806iw9IyQVfbbWObNGmof8,10677
@@ -22,8 +22,8 @@ daq2lh5/fc/fc_status_decoder.py,sha256=o_3vTAgYXelZxIsreCYioVYid2mY-wqloYKlxoCqX
 daq2lh5/fc/fc_streamer.py,sha256=S0imXdVsiyolPvxI1uiBngpC58DporSNZPqx1HeVi5o,5737
 daq2lh5/llama/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 daq2lh5/llama/llama_base.py,sha256=B-NCBjE_FQE1WxijWi4Z1XBy4rqLHm2XhkC40s7Sdms,290
-daq2lh5/llama/llama_event_decoder.py,sha256=NGzUA1DLChcfnEUNqMAPWq4uqXwUd-FH2e-xXcj2lzM,13894
-daq2lh5/llama/llama_header_decoder.py,sha256=NB7wVH2r99hveQ2KJ-9YMkJMZ6ccNfFsjYa5HbuThAU,6114
+daq2lh5/llama/llama_event_decoder.py,sha256=D7MRPmE-ucNCjeLJzY3RepmijjkvGHzu3vNV0zkcLho,14489
+daq2lh5/llama/llama_header_decoder.py,sha256=xi_BMw4HLQc-PQ5wIZWSHSsBZvrCpS9_G03X7Mr6tGA,6175
 daq2lh5/llama/llama_streamer.py,sha256=Bmcj5Bs28KSV4y08TeJcntzUAkqz6HqlSNm7Kffgloc,5203
 daq2lh5/orca/__init__.py,sha256=Xf6uOIOzk_QkKH_7VizGlCo3iuiAgLtUE3A07x_HXC0,175
 daq2lh5/orca/orca_base.py,sha256=-XIolXsHj-1EdewaGxyvJTZvRGZsDyZe-5PzVOd-LFY,1333
@@ -34,9 +34,9 @@ daq2lh5/orca/orca_header_decoder.py,sha256=ORIIyfx22ybyKc-uyWy5ER49-dl3BGpHdfV8O
 daq2lh5/orca/orca_packet.py,sha256=nOHuBXsTI1SzTjHZtff0txSQYvkwo4XGx3fpk7XfYj8,2489
 daq2lh5/orca/orca_run_decoder.py,sha256=3atKXC6mDi8_PK6ICUBBJ-LyaTM8OU31kKWIpmttRr4,2065
 daq2lh5/orca/orca_streamer.py,sha256=VbD9PF-rx_Rk-rEy7XECPmgxr6kZSUf0tC7Qbol3Qeg,15693
-legend_daq2lh5-1.4.1.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-legend_daq2lh5-1.4.1.dist-info/METADATA,sha256=DoB9PfyP5G2H5Iz2fo5uBcMyVOcN-ez2lf4GI_jTu0U,3956
-legend_daq2lh5-1.4.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-legend_daq2lh5-1.4.1.dist-info/entry_points.txt,sha256=R08R4NrHi0ab5MJN_qKqzePVzrLSsw5WpmbiwwduYjw,59
-legend_daq2lh5-1.4.1.dist-info/top_level.txt,sha256=MJQVLyLqMgMKBdVfNXFaCKCjHKakAs19VLbC9ctXZ7A,8
-legend_daq2lh5-1.4.1.dist-info/RECORD,,
+legend_daq2lh5-1.4.2.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+legend_daq2lh5-1.4.2.dist-info/METADATA,sha256=a7rqLL0JYeSoxoD9lopkQN55eyrSC0Ten8M__syVX9A,3956
+legend_daq2lh5-1.4.2.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+legend_daq2lh5-1.4.2.dist-info/entry_points.txt,sha256=R08R4NrHi0ab5MJN_qKqzePVzrLSsw5WpmbiwwduYjw,59
+legend_daq2lh5-1.4.2.dist-info/top_level.txt,sha256=MJQVLyLqMgMKBdVfNXFaCKCjHKakAs19VLbC9ctXZ7A,8
+legend_daq2lh5-1.4.2.dist-info/RECORD,,