dcnum 0.16.2__py3-none-any.whl → 0.16.3__py3-none-any.whl

dcnum/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.16.2'
-__version_tuple__ = version_tuple = (0, 16, 2)
+__version__ = version = '0.16.3'
+__version_tuple__ = version_tuple = (0, 16, 3)

dcnum/feat/event_extractor_manager_thread.py

@@ -81,9 +81,9 @@ class EventExtractorManagerThread(threading.Thread):
                    for _ in range(self.num_workers)]
         [w.start() for w in workers]
 
+        num_slots = len(self.slot_states)
         chunks_processed = 0
         while True:
-            num_slots = len(self.slot_states)
             cur_slot = 0
             unavailable_slots = 0
             # Check all slots for segmented labels
@@ -93,8 +93,10 @@ class EventExtractorManagerThread(threading.Thread):
                 # - "s" the extractor processed the data and is waiting
                 #   for the segmenter
                 if self.slot_states[cur_slot] == "e":
+                    # The segmenter has something for us in this slot.
                     break
                 else:
+                    # Try another slot.
                     unavailable_slots += 1
                     cur_slot = (cur_slot + 1) % num_slots
                 if unavailable_slots >= num_slots:
@@ -152,7 +154,7 @@ class EventExtractorManagerThread(threading.Thread):
         if inv_masks:
             self.logger.info(f"Encountered {inv_masks} invalid masks.")
             inv_frac = inv_masks / len(self.data)
-            if inv_frac > 0.0:
+            if inv_frac > 0.005:  # warn above one half percent
                 self.logger.warning(f"Discarded {inv_frac:.1%} of the masks. "
                                     f"Please check segmenter applicability.")
 

dcnum/feat/feat_background/base.py

@@ -7,12 +7,11 @@ import uuid
 import warnings
 
 import h5py
-import hdf5plugin
 import numpy as np
 
 from ...meta import ppid
 from ...read import HDF5Data
-from ...write import create_with_basins
+from ...write import create_with_basins, set_default_filter_kwargs
 
 
 # All subprocesses should use 'spawn' to avoid issues with threads
@@ -112,10 +111,7 @@ class Background(abc.ABC):
             self.h5out = h5py.File(output_path, "a", libver="latest")
 
         # Initialize background data
-        if compress:
-            compression_kwargs = hdf5plugin.Zstd(clevel=5)
-        else:
-            compression_kwargs = {}
+        ds_kwargs = set_default_filter_kwargs(compression=compress)
         h5bg = self.h5out.require_dataset(
             "events/image_bg",
             shape=self.input_data.shape,
@@ -123,8 +119,7 @@ class Background(abc.ABC):
             chunks=(min(100, self.image_count),
                     self.image_shape[0],
                     self.image_shape[1]),
-            fletcher32=True,
-            **compression_kwargs,
+            **ds_kwargs,
         )
         h5bg.attrs.create('CLASS', np.string_('IMAGE'))
         h5bg.attrs.create('IMAGE_VERSION', np.string_('1.2'))

dcnum/feat/feat_background/bg_sparse_median.py

@@ -5,6 +5,8 @@ import time
 import numpy as np
 from scipy import ndimage
 
+from ...read import HDF5Data
+
 from .base import mp_spawn, Background
 
 logger = logging.getLogger(__name__)
@@ -90,15 +92,16 @@ class BackgroundSparseMed(Background):
         # time axis
         self.time = None
         if self.h5in is not None:
-            if "time" in self.h5in["events"]:
+            hd = HDF5Data(self.h5in)
+            if "time" in hd:
                 # use actual time from dataset
-                self.time = self.h5in["/events/time"][:]
+                self.time = hd["time"][:]
                 self.time -= self.time[0]
-            elif "imaging:frame rate" in self.h5in.attrs:
-                fr = self.h5in.attrs["imaging:frame rate"]
-                if "frame" in self.h5in["/events"]:
+            elif "imaging:frame rate" in hd.meta:
+                fr = hd.meta["imaging:frame rate"]
+                if "frame" in hd:
                     # compute time from frame rate and frame numbers
-                    self.time = self.h5in["/events/frame"] / fr
+                    self.time = hd["frame"] / fr
                     self.time -= self.time[0]
                 else:
                     # compute time using frame rate (approximate)

dcnum/feat/queue_event_extractor.py

@@ -315,7 +315,7 @@ class QueueEventExtractor:
         queue_handler = QueueHandler(self.log_queue)
         queue_handler.setLevel(self.log_level)
         self.logger.addHandler(queue_handler)
-        self.logger.info("Running")
+        self.logger.info("Ready")
 
         mp_array = np.ctypeslib.as_array(
             self.label_array).reshape(self.data.image.chunk_shape)

dcnum/logic/ctrl.py

@@ -13,7 +13,6 @@ import time
 import traceback
 import uuid
 
-import hdf5plugin
 import h5py
 
 from ..feat.feat_background.base import get_available_background_methods
@@ -26,7 +25,7 @@ from ..read import HDF5Data
 from .._version import version_tuple
 from ..write import (
     DequeWriterThread, HDF5Writer, QueueCollectorThread,
-    copy_metadata, create_with_basins,
+    copy_metadata, create_with_basins, set_default_filter_kwargs
 )
 
 from .job import DCNumPipelineJob
@@ -36,6 +35,19 @@ from .json_encoder import ExtendedJSONEncoder
 # queues and threads and would end up with race conditions otherwise.
 mp_spawn = mp.get_context("spawn")
 
+#: valid states for a job runnter. The states must be in logical ordern,
+#: not in alphabetical order.
+valid_states = [
+    "created",
+    "init",
+    "setup",
+    "background",
+    "segmentation",
+    "cleanup",
+    "done",
+    "error",
+]
+
 
 class DCNumJobRunner(threading.Thread):
     def __init__(self,
@@ -178,6 +190,16 @@ class DCNumJobRunner(threading.Thread):
         po = pathlib.Path(self.job["path_out"])
         return po.with_name(po.stem + f"_output_{self.tmp_suffix}.rtdc~")
 
+    @property
+    def state(self):
+        return self._state
+
+    @state.setter
+    def state(self, state):
+        if state not in valid_states:
+            raise ValueError(f"Invalid state '{state}' specified!")
+        self._state = state
+
     def close(self, delete_temporary_files=True):
         if self._data_raw is not None:
             self._data_raw.close()
@@ -209,17 +231,32 @@ class DCNumJobRunner(threading.Thread):
         self.close(delete_temporary_files=delete_temporary_files)
 
     def get_status(self):
-        bgpart = .1  # fraction of background
-        expart = 0.85  # fraction of segmentation and feature extraction
-        clpart = 0.05  # fraction of cleanup
+        # Compute the total progress. The following weights indicate
+        # how much fractional time each processing step takes.
+        bgw = 4  # fraction of background
+        exw = 27  # fraction of segmentation and feature extraction
+        clw = 1  # fraction of cleanup operations
+        tot = bgw + exw + clw
         progress = 0
-        if self._progress_bg is not None:
+        st = self.state
+
+        # background
+        if valid_states.index(st) > valid_states.index("background"):
+            # background already computed
+            progress += bgw / tot
+        elif self._progress_bg is not None:
             # This is the image count of the input dataset
-            progress += bgpart * (self._progress_bg.value / len(self.draw))
-        if self._progress_ex is not None:
-            progress += expart * self._progress_ex
-        if self._state == "done":
-            progress += clpart
+            progress += bgw / tot * (self._progress_bg.value / len(self.draw))
+
+        # segmentation
+        if valid_states.index(st) > valid_states.index("segmentation"):
+            # segmentation already done
+            progress += exw / tot
+        elif self._progress_ex is not None:
+            progress += exw / tot * self._progress_ex
+
+        if self.state == "done":
+            progress = 1
 
         return {
             "progress": progress,
@@ -231,7 +268,7 @@ class DCNumJobRunner(threading.Thread):
         try:
             self.run_pipeline()
         except BaseException:
-            self._state = "error"
+            self.state = "error"
             self.error_tb = traceback.format_exc()
             if not self.is_alive():
                 # Thread has not been started. This means we are not running
@@ -248,7 +285,7 @@ class DCNumJobRunner(threading.Thread):
                 f"Output file {self.job['path_out']} already exists!")
         # Make sure the output directory exists.
         self.job["path_out"].parent.mkdir(parents=True, exist_ok=True)
-        self._state = "setup"
+        self.state = "setup"
         # First get a list of all pipeline IDs. If the input file has
         # already been processed by dcnum, then we do not have to redo
         # everything.
@@ -290,7 +327,7 @@ class DCNumJobRunner(threading.Thread):
             or (datdict["feat_id"] != self.ppdict["feat_id"])
             or (datdict["gate_id"] != self.ppdict["gate_id"]))
 
-        self._state = "background"
+        self.state = "background"
 
         if redo_bg:
             # The 'image_bg' feature is written to `self.path_temp_in`.
@@ -299,7 +336,7 @@ class DCNumJobRunner(threading.Thread):
             # (note that `self.path_temp_in` is basin-based).
             self.task_background()
 
-        self._state = "segmentation"
+        self.state = "segmentation"
 
         # We have the input data covered, and we have to run the
         # long-lasting segmentation and feature extraction step.
@@ -323,7 +360,7 @@ class DCNumJobRunner(threading.Thread):
             # reflected in `self.path_temp_out`.
             self.path_temp_in.rename(self.path_temp_out)
 
-        self._state = "cleanup"
+        self.state = "cleanup"
 
         # The user would normally expect the output file to be something
         # that is self-contained (copying the file wildly across file
@@ -410,7 +447,7 @@ class DCNumJobRunner(threading.Thread):
 
         # Rename the output file
         self.path_temp_out.rename(self.job["path_out"])
-        self._state = "done"
+        self.state = "done"
 
     def task_background(self):
         """Perform background computation task
@@ -442,8 +479,7 @@ class DCNumJobRunner(threading.Thread):
         self.logger.info("Starting segmentation and feature extraction")
         # Start writer thread
         writer_dq = collections.deque()
-        ds_kwds = dict(hdf5plugin.Zstd(clevel=5))
-        ds_kwds["fletcher32"] = True
+        ds_kwds = set_default_filter_kwargs()
         thr_write = DequeWriterThread(
             path_out=self.path_temp_out,
             dq=writer_dq,
@@ -462,13 +498,24 @@ class DCNumJobRunner(threading.Thread):
         if self.job["debug"]:
             num_slots = 1
             num_extractors = 1
+            num_segmenters = 1
         elif seg_cls.hardware_processor == "cpu":  # CPU segmenter
+            # We could in principle set the number of slots to one and
+            # jave both number of extractors and number of segmenters set
+            # to the total number of CPUs. However, we would need more RAM
+            # (for caching the image data) and we also have more overhead.
+            # Having two slots shared between all workers is more efficient.
             num_slots = 2
+            # Split segmentation and feature extraction workers evenly.
             num_extractors = self.job["num_procs"] // 2
+            num_segmenters = self.job["num_procs"] - num_extractors
         else:  # GPU segmenter
             num_slots = 3
             num_extractors = self.job["num_procs"]
+            num_segmenters = 1
         num_extractors = max(1, num_extractors)
+        num_segmenters = max(1, num_segmenters)
+        self.job["segmenter_kwargs"]["num_workers"] = num_segmenters
 
         slot_chunks = mp_spawn.Array("i", num_slots)
         slot_states = mp_spawn.Array("u", num_slots)

dcnum/read/cache.py

@@ -11,7 +11,7 @@ class HDF5ImageCache:
     def __init__(self,
                  h5ds: h5py.Dataset,
                  chunk_size: int = 1000,
-                 cache_size: int = 5,
+                 cache_size: int = 2,
                  boolean: bool = False):
         """An HDF5 image cache
 

dcnum/read/hdf5_data.py

@@ -25,7 +25,7 @@ class HDF5Data:
                  basins: List[Dict[List[str] | str]] = None,
                  logs: Dict[List[str]] = None,
                  tables: Dict[np.ndarray] = None,
-                 image_cache_size: int = 5,
+                 image_cache_size: int = 2,
                  ):
         # Init is in __setstate__ so we can pickle this class
         # and use it for multiprocessing.

dcnum/segm/segmenter_gpu.py

@@ -15,6 +15,7 @@ class GPUSegmenter(Segmenter, abc.ABC):
 
     def __init__(self,
                  *,
+                 num_workers: int = None,
                  kwargs_mask: Dict = None,
                  debug: bool = False,
                  **kwargs
@@ -31,6 +32,9 @@ class GPUSegmenter(Segmenter, abc.ABC):
             Additional, optional keyword arguments for `segment_approach`
             defined in the subclass.
         """
+        if num_workers not in [None, 1]:
+            raise ValueError(f"Number of workers must not be larger than 1 "
+                             f"for GPU segmenter, got '{num_workers}'!")
         super(GPUSegmenter, self).__init__(kwargs_mask=kwargs_mask,
                                            debug=debug,
                                            **kwargs)

dcnum/segm/segmenter_manager_thread.py

@@ -77,9 +77,9 @@ class SegmenterManagerThread(threading.Thread):
         self.debug = debug
 
     def run(self):
+        num_slots = len(self.slot_states)
         # We iterate over all the chunks of the image data.
         for chunk in self.image_data.iter_chunks():
-            num_slots = len(self.slot_states)
             cur_slot = 0
             empty_slots = 0
             # Wait for a free slot to perform segmentation (compute labels)
@@ -89,8 +89,11 @@ class SegmenterManagerThread(threading.Thread):
                 # - "s" the extractor processed the data and is waiting
                 #   for the segmenter
                 if self.slot_states[cur_slot] != "e":
+                    # It's the segmenters turn. Note that we use '!= "e"',
+                    # because the initial value is "\x00".
                     break
                 else:
+                    # Try another slot.
                     empty_slots += 1
                     cur_slot = (cur_slot + 1) % num_slots
                 if empty_slots >= num_slots:

dcnum/write/__init__.py

@@ -1,4 +1,5 @@
 # flake8: noqa: F401
 from .deque_writer_thread import DequeWriterThread
 from .queue_collector_thread import EventStash, QueueCollectorThread
-from .writer import HDF5Writer, copy_metadata, create_with_basins
+from .writer import (
+    HDF5Writer, copy_metadata, create_with_basins, set_default_filter_kwargs)

dcnum/write/writer.py

@@ -21,11 +21,7 @@ class HDF5Writer:
         """Write deformability cytometry HDF5 data"""
         self.h5 = h5py.File(path, mode=mode, libver="latest")
         self.events = self.h5.require_group("events")
-        if ds_kwds is None:
-            ds_kwds = {}
-        for key, val in dict(hdf5plugin.Zstd(clevel=5)).items():
-            ds_kwds.setdefault(key, val)
-        ds_kwds.setdefault("fletcher32", True)
+        ds_kwds = set_default_filter_kwargs(ds_kwds)
         self.ds_kwds = ds_kwds
 
     def __enter__(self):
@@ -249,10 +245,7 @@ def copy_metadata(h5_src: h5py.File,
     are not defined already are added.
     """
     # compress data
-    ds_kwds = {}
-    for key, val in dict(hdf5plugin.Zstd(clevel=5)).items():
-        ds_kwds.setdefault(key, val)
-    ds_kwds.setdefault("fletcher32", True)
+    ds_kwds = set_default_filter_kwargs()
     # set attributes
     src_attrs = dict(h5_src.attrs)
     for kk in src_attrs:
@@ -283,3 +276,15 @@ def copy_metadata(h5_src: h5py.File,
                                       f"dcnum {version}"]
                         soft_strgs = [s for s in soft_strgs if s is not None]
                         ds.attrs["software"] = " | ".join(soft_strgs)
+
+
+def set_default_filter_kwargs(ds_kwds=None, compression=True):
+    if ds_kwds is None:
+        ds_kwds = {}
+    if compression:
+        # compression
+        for key, val in dict(hdf5plugin.Zstd(clevel=5)).items():
+            ds_kwds.setdefault(key, val)
+    # checksums
+    ds_kwds.setdefault("fletcher32", True)
+    return ds_kwds

{dcnum-0.16.2.dist-info → dcnum-0.16.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dcnum
-Version: 0.16.2
+Version: 0.16.3
 Summary: numerics toolbox for imaging deformability cytometry
 Author: Paul Müller
 Maintainer-email: Paul Müller <dev@craban.de>

{dcnum-0.16.2.dist-info → dcnum-0.16.3.dist-info}/RECORD

@@ -1,14 +1,14 @@
 dcnum/__init__.py,sha256=hcawIKS7utYiOyVhOAX9t7K3xYzP1b9862VV0b6qSrQ,74
-dcnum/_version.py,sha256=vU7l2sB6vCpV8L2MtzyjC8oRhIaHUEJLtxeZiu0lk_E,413
+dcnum/_version.py,sha256=KgYmvPTSKj3FMTlG8S1wtqb14ST1EcsHHNSwLJp3foQ,413
 dcnum/feat/__init__.py,sha256=JqlgzOgDJhoTk8WVYcIiKTWq9EAM16_jGivzOtN6JGo,325
-dcnum/feat/event_extractor_manager_thread.py,sha256=JG0jp9FAbDxpOYvnxAcqcZF0ePg0mLb0j_sOptLaluc,6697
+dcnum/feat/event_extractor_manager_thread.py,sha256=ypsGEwmM_ohHCnnl8g1vpruezFAkH0drIU1AOngH5Bg,6837
 dcnum/feat/gate.py,sha256=srobj5p2RDr_S2SUtbwGbTKatnc_aPSndt0cR2P9zoY,7060
-dcnum/feat/queue_event_extractor.py,sha256=kOnaDf3F3HGmYxi6q4KNdUCEKH_LAKDRIsICB_vd9dQ,14972
+dcnum/feat/queue_event_extractor.py,sha256=o7K4p5VNExnaO6lgnlHrVk_qPhbXzocUyFhUcoP7OAU,14970
 dcnum/feat/feat_background/__init__.py,sha256=OTmMuazHNaSrZb2XW4cnJ6PlgJLbKrPbaidpEixYa0A,341
-dcnum/feat/feat_background/base.py,sha256=f22WMZ3gP4H9x0px43Ga9sONVFw3omdm6s54oTb699U,8466
+dcnum/feat/feat_background/base.py,sha256=KA1H5giTyMBADex2-LmGbu7B1PEAKjiCUAvSF89WiZs,8375
 dcnum/feat/feat_background/bg_copy.py,sha256=aHabgizRuwIdOH8S850Cun9NsmpMzo4B3yHWv1aFNFI,645
 dcnum/feat/feat_background/bg_roll_median.py,sha256=FfC3v1cX8mreLO971C_kTpFRBtuJP4Sv-Hj1Wj8yb3Q,12826
-dcnum/feat/feat_background/bg_sparse_median.py,sha256=Zmt3c0MxKdKOoLWmMYDF-SKIEr9oNqXR70gd89srShk,17644
+dcnum/feat/feat_background/bg_sparse_median.py,sha256=CDO8X7-7agBxTrC79lskt0zWTaSex6ouxUVfxImhgs4,17630
 dcnum/feat/feat_brightness/__init__.py,sha256=o6AebVlmydwNgVF5kW6ITqJyFreoKrU3Ki_3EC8If-s,155
 dcnum/feat/feat_brightness/bright_all.py,sha256=Z5b-xkw7g7ejMpbGmdUqrxGRymqFhAQsZ938gaGXk9Y,3102
 dcnum/feat/feat_brightness/common.py,sha256=JX49EszYDmnvoOKXFVV1CalEIWRmOuY5EryNbqGbdac,156
@@ -19,27 +19,27 @@ dcnum/feat/feat_texture/__init__.py,sha256=6StM9S540UVtdFFR3bHa7nfCTomeVdoo7Uy9C
 dcnum/feat/feat_texture/common.py,sha256=COXHpXS-7DMouGu3WF83I76L02Sr7P9re4lxajh6g0E,439
 dcnum/feat/feat_texture/tex_all.py,sha256=eGjjNfPpfZw7FA_VNFCIMiU38KD0qcGbxLciYy-tCiA,4097
 dcnum/logic/__init__.py,sha256=5hgAQMp2YGsqpWoeTQ9qxGAWfxPOKQjJsYyNsS49t0g,131
-dcnum/logic/ctrl.py,sha256=YpddNikb901HKLStMfC2ff544qFoGElk9r5IGkFxSfY,24994
+dcnum/logic/ctrl.py,sha256=aqXCH_yyrfifeAxmpW6Cg-FQIwTBjpElHbva60ghYpY,26655
 dcnum/logic/job.py,sha256=M0Q-Rfcm-zkTXTQc79W6YSNUjUlgmRPG0Ikbdn1aOpY,4608
 dcnum/logic/json_encoder.py,sha256=dy44ArmdnxpUfxxONmKdIv-fde3aTXPjZDN0HPATaxs,467
 dcnum/meta/__init__.py,sha256=cQT_HN5yDKzMnZM8CUyNmeA68OhE3ENO_rvFmgDj95c,40
 dcnum/meta/ppid.py,sha256=_xUqJal4wBqgic2aRN3ZMMteTggHeYGs44nrYbTKlpQ,8107
 dcnum/read/__init__.py,sha256=iV2wrBMdwJgpXaphNiiAVybndDzTTv0CAGRNXyvxcLY,157
-dcnum/read/cache.py,sha256=mr2DBJZYgNIAiz64TQ4cgkPmRt8nJWBvgkOpaz-p6Yg,5467
+dcnum/read/cache.py,sha256=0tMurtHOA7VnPNpfeAGi-dxWXfYhL5wmWuXb6ka_eEo,5467
 dcnum/read/const.py,sha256=SVlvEJiRIHyTyUlWG24_ogcnT5nTxCi0CRslNuNP56I,282
-dcnum/read/hdf5_data.py,sha256=jUPoXgn52eJZrF4uOpR2-fBLaQX9Ezw3tcuAlI5LnF8,18817
+dcnum/read/hdf5_data.py,sha256=8g39CZoFIa2tUvizZt_vzMeoCUcTkkt3AkXK6MMN0iY,18817
 dcnum/segm/__init__.py,sha256=iiq_1A9DU5wMUcKnsZ53E7NyzCkbZCJeUDimzunE-OM,247
 dcnum/segm/segm_thresh.py,sha256=aLVTydPjbrgKDkZFY3Ew5CX-miwOw71meHfxcO5EjCc,1176
 dcnum/segm/segmenter.py,sha256=F3gCp-Z51F9GxdFYPF1CHjnbfgqnS0_g-34lJF2tMCM,10611
 dcnum/segm/segmenter_cpu.py,sha256=tCY105rVr9_0RIq2618qnF1ueHRj7UtuK_nUBoAg-nY,10743
-dcnum/segm/segmenter_gpu.py,sha256=aIBieTjcr4YaOHUhYiOOh_EpKUzQLBhanpBrtPSUL5k,1900
-dcnum/segm/segmenter_manager_thread.py,sha256=xtuk7gnk7xhoRoV_J97rrv7IR3JgeRvVewCDT-chqpk,5172
-dcnum/write/__init__.py,sha256=6vAQECatcd7DJMXFEuab1wdvEiaxisbY8_qmK5tzIwY,207
+dcnum/segm/segmenter_gpu.py,sha256=tL2X5BN0jKmhC7wgfG0hygd-6UpG1ZCVuKe5OP1qde0,2133
+dcnum/segm/segmenter_manager_thread.py,sha256=2znDaKedSueomcU1pbHtFmVcGoHzp--sf494VgJF_Tk,5342
+dcnum/write/__init__.py,sha256=Cpn3LqL18hh8OScUnGp_AnNfpWPpKW-oAJZH6ot7aRA,241
 dcnum/write/deque_writer_thread.py,sha256=R4x3p-HZUls3upCBX3vV1VqSdSmaiHdrAswMJj_tVpk,1643
 dcnum/write/queue_collector_thread.py,sha256=c0Z6uZfZ3B8xsTMCB5jglEukM5sesA9HgEawBk_YEUA,11910
-dcnum/write/writer.py,sha256=UILOzQIQ4a8iNNMLE_CgF20rDWGOfEwLFMvjpA4SkUo,10411
-dcnum-0.16.2.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
-dcnum-0.16.2.dist-info/METADATA,sha256=2wha2ck7V_xlZAgElRL0_jRx0qR-FrGgsCVwL4lfSHk,2172
-dcnum-0.16.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-dcnum-0.16.2.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
-dcnum-0.16.2.dist-info/RECORD,,
+dcnum/write/writer.py,sha256=Hr37OSDJGUpJJ4OufJHYYBanE26GiNwUPOMAt-5Yc2Y,10478
+dcnum-0.16.3.dist-info/LICENSE,sha256=YRChA1C8A2E-amJbudwMcbTCZy_HzmeY0hMIvduh1MM,1089
+dcnum-0.16.3.dist-info/METADATA,sha256=BChO0SWVq5w9ZEFvvP0KDsFd-T1WRbMZkhW2xCBeVWc,2172
+dcnum-0.16.3.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+dcnum-0.16.3.dist-info/top_level.txt,sha256=Hmh38rgG_MFTVDpUDGuO2HWTSq80P585Het4COQzFTg,6
+dcnum-0.16.3.dist-info/RECORD,,