sdfr 1.2.0__py3-none-win_amd64.whl → 1.3.0__py3-none-win_amd64.whl

sdfr/SDF.py

@@ -20,11 +20,11 @@ import numpy as np
 from enum import IntEnum
 from .loadlib import sdf_lib
 
-#try:
+# try:
 #    import xarray as xr
 #
 #    got_xarray = True
-#except ImportError:
+# except ImportError:
 #    print("WARNING: xarray not installed. Generating plain numpy arrays.")
 #    got_xarray = False
 
@@ -63,12 +63,14 @@ class SdfBlockType(IntEnum):
     SDF_BLOCKTYPE_DATABLOCK = 28
     SDF_BLOCKTYPE_NAMEVALUE = 29
 
+
 class SdfGeometry(IntEnum):
     SDF_GEOMETRY_NULL = 0
     SDF_GEOMETRY_CARTESIAN = 1
     SDF_GEOMETRY_CYLINDRICAL = 2
     SDF_GEOMETRY_SPHERICAL = 3
 
+
 class SdfStagger(IntEnum):
     SDF_STAGGER_CELL_CENTRE = 0
     SDF_STAGGER_FACE_X = 1
@@ -79,6 +81,7 @@ class SdfStagger(IntEnum):
     SDF_STAGGER_EDGE_Z = 6
     SDF_STAGGER_VERTEX = 7
 
+
 class SdfDataType(IntEnum):
     SDF_DATATYPE_NULL = 0
     SDF_DATATYPE_INTEGER4 = 1
@@ -90,22 +93,45 @@ class SdfDataType(IntEnum):
     SDF_DATATYPE_LOGICAL = 7
     SDF_DATATYPE_OTHER = 8
 
-_np_datatypes = [0, np.int32, np.int64, np.float32, np.float64, \
-                 np.longdouble, np.byte, np.int32, bool, 0]
-_ct_datatypes = [0, ct.c_int32, ct.c_int64, ct.c_float, ct.c_double, \
-                 ct.c_longdouble, ct.c_char, ct.c_bool, 0]
+
+_np_datatypes = [
+    0,
+    np.int32,
+    np.int64,
+    np.float32,
+    np.float64,
+    np.longdouble,
+    np.byte,
+    np.int32,
+    bool,
+    0,
+]
+_ct_datatypes = [
+    0,
+    ct.c_int32,
+    ct.c_int64,
+    ct.c_float,
+    ct.c_double,
+    ct.c_longdouble,
+    ct.c_char,
+    ct.c_bool,
+    0,
+]
 
 # Constants
 SDF_READ = 1
 SDF_WRITE = 2
 SDF_MAXDIMS = 4
 
+
 class SdfBlock(ct.Structure):
     pass  # Forward declaration for self-referencing structure
 
+
 class SdfFile(ct.Structure):
     pass  # Forward declaration for function pointer compatibility
 
+
 SdfBlock._fields_ = [
     ("extents", ct.POINTER(ct.c_double)),
     ("dim_mults", ct.POINTER(ct.c_double)),
@@ -198,7 +224,12 @@ SdfBlock._fields_ = [
     ("prev", ct.POINTER(SdfBlock)),
     ("subblock", ct.POINTER(SdfBlock)),
     ("subblock2", ct.POINTER(SdfBlock)),
-    ("populate_data", ct.CFUNCTYPE(ct.POINTER(SdfBlock), ct.POINTER(SdfFile), ct.POINTER(SdfBlock))),
+    (
+        "populate_data",
+        ct.CFUNCTYPE(
+            ct.POINTER(SdfBlock), ct.POINTER(SdfFile), ct.POINTER(SdfBlock)
+        ),
+    ),
     ("cpu_split", ct.c_int * SDF_MAXDIMS),
     ("starts", ct.c_int * SDF_MAXDIMS),
     ("proc_min", ct.c_int * 3),
@@ -285,9 +316,10 @@ SdfFile._fields_ = [
     ("fd", ct.c_int),
     ("purge_duplicated_ids", ct.c_int),
     ("internal_ghost_cells", ct.c_int),
-    ("ignore_nblocks", ct.c_int)
+    ("ignore_nblocks", ct.c_int),
 ]
 
+
 class RunInfo(ct.Structure):
     _fields_ = [
         ("defines", ct.c_int64),
@@ -306,6 +338,7 @@ class RunInfo(ct.Structure):
 
 class BlockList:
     """Contains all the blocks"""
+
     def __init__(self, filename, convert=False, derived=True):
         clib = sdf_lib
         self._clib = clib
@@ -332,7 +365,6 @@ class BlockList:
         else:
             clib.sdf_read_blocklist(h)
 
-
         block = h.contents.blocklist
         self.Header = get_header(h.contents)
         meshes = []
@@ -345,45 +377,64 @@ class BlockList:
             block._blocklist = self
             blocktype = block.blocktype
             newblock = None
+            newblock_mid = None
             name = get_member_name(block.name)
             if blocktype == SdfBlockType.SDF_BLOCKTYPE_ARRAY:
                 newblock = BlockArray(block)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONSTANT:
                 newblock = BlockConstant(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED:
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED
+            ):
                 if block.stagger == 10 or block.stagger == 12:
                     newblock = BlockStitchedPath(block)
                 else:
                     newblock = BlockStitched(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_MATERIAL \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_MATERIAL:
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_MATERIAL
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_MATERIAL
+            ):
                 newblock = BlockStitchedMaterial(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_MATVAR \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_MATVAR:
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_MATVAR
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_MATVAR
+            ):
                 newblock = BlockStitchedMatvar(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_SPECIES \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_SPECIES:
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_SPECIES
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_SPECIES
+            ):
                 newblock = BlockStitchedSpecies(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_TENSOR \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_TENSOR:
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_CONTIGUOUS_TENSOR
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_STITCHED_TENSOR
+            ):
                 newblock = BlockStitchedTensor(block)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_DATABLOCK:
                 newblock = BlockData(block)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_LAGRANGIAN_MESH:
-                newblock = BlockLagrangianMesh(block)
-                meshes.append(newblock)
+                if block.datatype_out != 0:
+                    newblock = BlockLagrangianMesh(block)
+                    newblock_mid = block
+                    meshes.append(newblock)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_NAMEVALUE:
                 newblock = BlockNameValue(block)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_DERIVED \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_VARIABLE:
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_DERIVED
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_VARIABLE
+            ):
                 newblock = BlockPlainVariable(block)
                 mesh_vars.append(newblock)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_MESH:
-                newblock = BlockPlainMesh(block)
-                meshes.append(newblock)
-            elif blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_DERIVED \
-              or blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_VARIABLE:
+                if block.datatype_out != 0:
+                    newblock = BlockPlainMesh(block)
+                    newblock_mid = block
+                    meshes.append(newblock)
+            elif (
+                blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_DERIVED
+                or blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_VARIABLE
+            ):
                 newblock = BlockPointVariable(block)
                 mesh_vars.append(newblock)
             elif blocktype == SdfBlockType.SDF_BLOCKTYPE_POINT_MESH:
@@ -397,10 +448,26 @@ class BlockList:
                 pass
             if newblock is not None:
                 self.__dict__[name] = newblock
-                self._block_ids.update({block.id.decode() : newblock})
-                self._block_names.update({block.name.decode() : newblock})
+                self._block_ids.update({block.id.decode(): newblock})
+                self._block_names.update({block.name.decode(): newblock})
             block = block.next
 
+            if newblock_mid is not None:
+                block_mid = newblock_mid
+                block_mid._handle = h
+                block_mid._blocklist = self
+                blocktype = block_mid.blocktype
+                name = get_member_name(block_mid.name) + "_mid"
+                if blocktype == SdfBlockType.SDF_BLOCKTYPE_LAGRANGIAN_MESH:
+                    newblock = BlockLagrangianMesh(block_mid, mid=True)
+                elif blocktype == SdfBlockType.SDF_BLOCKTYPE_PLAIN_MESH:
+                    newblock = BlockPlainMesh(block_mid, mid=True)
+                self.__dict__[name] = newblock
+                nm = block_mid.id.decode() + "_mid"
+                self._block_ids.update({nm: newblock})
+                nm = block_mid.name.decode() + "_mid"
+                self._block_names.update({nm: newblock})
+
         for var in mesh_vars:
             gid = var.grid_id
             for mesh in meshes:
@@ -430,13 +497,14 @@ class Block:
     Contains the data and metadata for a single
     block from an SDF file.
     """
+
     def __init__(self, block):
         self._handle = block._handle
         self._id = block.id.decode()
         self._name = block.name.decode()
         self._datatype = _np_datatypes[block.datatype_out]
         self._data_length = block.data_length
-        self._dims = tuple(block.dims[:block.ndims])
+        self._dims = tuple(block.dims[: block.ndims])
         self._contents = block
         self._owndata = True
         self._blocklist = block._blocklist
@@ -452,8 +520,8 @@ class Block:
         buffer_from_memory.restype = ct.py_object
         dtype = self._datatype
         if dtype == np.byte:
-            dtype = np.dtype('|S1')
-        totype = _ct_datatypes[self._contents.datatype]
+            dtype = np.dtype("|S1")
+        totype = _ct_datatypes[self._contents.datatype_out]
         cast = ct.cast(data, ct.POINTER(totype))
         buf = buffer_from_memory(cast, blen)
         self._owndata = False
@@ -495,12 +563,12 @@ class Block:
         return self._name
 
 
-
 class BlockConstant(Block):
     """Constant block"""
+
     def __init__(self, block):
         super().__init__(block)
-        offset = getattr(SdfBlock, 'const_value').offset
+        offset = getattr(SdfBlock, "const_value").offset
         self._datatype = _np_datatypes[block.datatype]
         totype = _ct_datatypes[block.datatype]
         self._data = totype.from_buffer(block, offset).value
@@ -508,6 +576,7 @@ class BlockConstant(Block):
 
 class BlockPlainVariable(Block):
     """Plain variable block"""
+
     @property
     def data(self):
         """Block data contents"""
@@ -518,7 +587,7 @@ class BlockPlainVariable(Block):
             for d in self.dims:
                 blen *= d
             array = self._numpy_from_buffer(self._contents.data, blen)
-            self._data = array.reshape(self.dims, order='F')
+            self._data = array.reshape(self.dims, order="F")
         return self._data
 
     @property
@@ -549,16 +618,27 @@ class BlockPlainVariable(Block):
 
 class BlockPlainMesh(Block):
     """Plain mesh block"""
-    def __init__(self, block):
+
+    def __init__(self, block, mid=False):
         super().__init__(block)
+        self._mid = mid
         self._data = None
-        self._units = tuple([block.dim_units[i].decode() for i in range(block.ndims)])
-        self._labels = tuple([block.dim_labels[i].decode() for i in range(block.ndims)])
+        self._units = tuple(
+            [block.dim_units[i].decode() for i in range(block.ndims)]
+        )
+        self._labels = tuple(
+            [block.dim_labels[i].decode() for i in range(block.ndims)]
+        )
         self._mult = None
+        self._bdims = self._dims
+        if mid:
+            self._id += "_mid"
+            self._name += "_mid"
+            self._dims = tuple([i - 1 for i in self._dims])
         if bool(block.dim_mults):
-            self._mult = tuple(block.dim_mults[:block.ndims])
+            self._mult = tuple(block.dim_mults[: block.ndims])
         if bool(block.extents):
-            self._extents = tuple(block.extents[:2*block.ndims])
+            self._extents = tuple(block.extents[: 2 * block.ndims])
 
     @property
     def data(self):
@@ -567,9 +647,11 @@ class BlockPlainMesh(Block):
             clib = self._handle._clib
             clib.sdf_helper_read_data(self._handle, self._contents)
             grids = []
-            for i, d in enumerate(self.dims):
+            for i, d in enumerate(self._bdims):
                 blen = np.dtype(self._datatype).itemsize * d
                 array = self._numpy_from_buffer(self._contents.grids[i], blen)
+                if self._mid:
+                    array = 0.5 * (array[1:] + array[:-1])
                 grids.append(array)
             self._data = tuple(grids)
         return self._data
@@ -602,6 +684,7 @@ class BlockPlainMesh(Block):
 
 class BlockLagrangianMesh(BlockPlainMesh):
     """Lagrangian mesh block"""
+
     @property
     def data(self):
         """Block data contents"""
@@ -609,12 +692,20 @@ class BlockLagrangianMesh(BlockPlainMesh):
             clib = self._handle._clib
             clib.sdf_helper_read_data(self._handle, self._contents)
             blen = np.dtype(self._datatype).itemsize
-            for d in self.dims:
+            for d in self._bdims:
                 blen *= d
             grids = []
-            for i, d in enumerate(self.dims):
+            for i, d in enumerate(self._bdims):
                 array = self._numpy_from_buffer(self._contents.grids[i], blen)
-                array = array.reshape(self.dims, order='F')
+                array = array.reshape(self._bdims, order="F")
+                if self._mid:
+                    nn = len(self._bdims)
+                    for j in range(nn):
+                        s1 = nn * [slice(None)]
+                        s2 = nn * [slice(None)]
+                        s1[j] = slice(1, None)
+                        s2[j] = slice(None, -1)
+                        array = 0.5 * (array[tuple(s1)] + array[tuple(s2)])
                 grids.append(array)
             self._data = tuple(grids)
         return self._data
@@ -622,6 +713,7 @@ class BlockLagrangianMesh(BlockPlainMesh):
 
 class BlockPointMesh(BlockPlainMesh):
     """Point mesh block"""
+
     @property
     def species_id(self):
         """Species ID"""
@@ -630,6 +722,7 @@ class BlockPointMesh(BlockPlainMesh):
 
 class BlockPointVariable(BlockPlainVariable):
     """Point variable block"""
+
     @property
     def species_id(self):
         """Species ID"""
@@ -638,6 +731,7 @@ class BlockPointVariable(BlockPlainVariable):
 
 class BlockNameValue(Block):
     """Name/value block"""
+
     def __init__(self, block):
         super().__init__(block)
         self._dims = (block.ndims,)
@@ -658,6 +752,7 @@ class BlockNameValue(Block):
 
 class BlockArray(Block):
     """Array block"""
+
     @property
     def data(self):
         """Block data contents"""
@@ -668,12 +763,13 @@ class BlockArray(Block):
             for d in self.dims:
                 blen *= d
             array = self._numpy_from_buffer(self._contents.data, blen)
-            self._data = array.reshape(self.dims, order='F')
+            self._data = array.reshape(self.dims, order="F")
         return self._data
 
 
 class BlockData(Block):
     """Data block"""
+
     def __init__(self, block):
         super().__init__(block)
         self._checksum = block.checksum.decode()
@@ -709,6 +805,7 @@ class BlockData(Block):
 
 class BlockStitched(Block):
     """Stitched block"""
+
     @property
     def data(self):
         """Block data contents"""
@@ -724,73 +821,91 @@ class BlockStitched(Block):
 
 class BlockStitchedPath(BlockStitched):
     """Stitched path block"""
+
     pass
 
 
 class BlockStitchedMaterial(BlockStitched):
     """Stitched material block"""
+
     pass
 
 
 class BlockStitchedMatvar(BlockStitched):
     """Stitched material variable block"""
+
     pass
 
 
 class BlockStitchedSpecies(BlockStitched):
     """Stitched species block"""
+
     pass
 
 
 class BlockStitchedTensor(BlockStitched):
     """Stitched tensor block"""
+
     pass
 
 
 def get_header(h):
     d = {}
-    d['filename'] = h.filename.decode()
-    d['file_version'] = h.file_version
-    d['file_revision'] = h.file_revision
-    d['code_name'] = h.code_name.decode()
-    d['step'] = h.step
-    d['time'] = h.time
-    d['jobid1'] = h.jobid1
-    d['jobid2'] = h.jobid2
-    d['code_io_version'] = h.code_io_version
-    d['restart_flag'] = h.restart_flag
-    d['other_domains'] = h.other_domains
-    d['station_file'] = h.station_file
+    d["filename"] = h.filename.decode()
+    d["file_version"] = h.file_version
+    d["file_revision"] = h.file_revision
+    d["code_name"] = h.code_name.decode()
+    d["step"] = h.step
+    d["time"] = h.time
+    d["jobid1"] = h.jobid1
+    d["jobid2"] = h.jobid2
+    d["code_io_version"] = h.code_io_version
+    d["restart_flag"] = h.restart_flag
+    d["other_domains"] = h.other_domains
+    d["station_file"] = h.station_file
     return d
 
 
 def get_run_info(block):
     from datetime import datetime
+
     h = ct.cast(block.data, ct.POINTER(RunInfo)).contents
     d = {}
-    d['version'] = f"{h.version}.{h.revision}.{h.minor_rev}"
-    d['commit_id'] = h.commit_id.decode()
-    d['sha1sum'] = h.sha1sum.decode()
-    d['compile_machine'] = h.compile_machine.decode()
-    d['compile_flags'] = h.compile_flags.decode()
-    d['compile_date'] = datetime.utcfromtimestamp(h.compile_date).strftime('%c')
-    d['run_date'] = datetime.utcfromtimestamp(h.run_date).strftime('%c')
-    d['io_data'] = datetime.utcfromtimestamp(h.io_date).strftime('%c')
+    d["version"] = f"{h.version}.{h.revision}.{h.minor_rev}"
+    d["commit_id"] = h.commit_id.decode()
+    d["sha1sum"] = h.sha1sum.decode()
+    d["compile_machine"] = h.compile_machine.decode()
+    d["compile_flags"] = h.compile_flags.decode()
+    d["compile_date"] = datetime.utcfromtimestamp(h.compile_date).strftime("%c")
+    d["run_date"] = datetime.utcfromtimestamp(h.run_date).strftime("%c")
+    d["io_data"] = datetime.utcfromtimestamp(h.io_date).strftime("%c")
     return d
 
 
 def get_member_name(name):
     sname = name.decode()
-    return ''.join([i if ((i >= "a" and i <= "z") or (i >= "A" and i <= "Z") \
-                    or (i >= "0" and i <= "9")) else "_" \
-                    for i in sname])
-
-def read(filename, convert=False, mmap=0, dict=False, derived=True):
+    return "".join(
+        [
+            (
+                i
+                if (
+                    (i >= "a" and i <= "z")
+                    or (i >= "A" and i <= "Z")
+                    or (i >= "0" and i <= "9")
+                )
+                else "_"
+            )
+            for i in sname
+        ]
+    )
+
+
+def read(file=None, convert=False, mmap=0, dict=False, derived=True):
     """Reads the SDF data and returns a dictionary of NumPy arrays.
 
     Parameters
     ----------
-    filename : string
+    file : string
         The name of the SDF file to open.
     convert : bool, optional
         Convert double precision data to single when reading file.
@@ -802,10 +917,13 @@ def read(filename, convert=False, mmap=0, dict=False, derived=True):
 
     import warnings
 
+    if file == None:
+        raise TypeError("Missing file parameter")
+
     if mmap != 0:
         warnings.warn("mmap flag ignored")
 
-    blocklist = BlockList(filename, convert, derived)
+    blocklist = BlockList(file, convert, derived)
 
     if isinstance(dict, str):
         if dict == "id" or dict == "ids":

sdfr/_commit_info.py

@@ -1,2 +1,2 @@
-__commit_date__ = "Thu Mar 6 21:34:01 2025 +0000"
-__commit_id__ = "658f397aca1fa9cfcef3a31d2ea4ba9291c4aa96"
+__commit_date__ = "Wed May 7 13:32:07 2025 +0100"
+__commit_id__ = "c22be2665c4bcbc9925fa702205ace2f99585439"

{sdfr-1.2.0.dist-info → sdfr-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sdfr
-Version: 1.2.0
+Version: 1.3.0
 Summary: Python module for processing SDF files
 Author-Email: Keith Bennett <k.bennett@warwick.ac.uk>
 Requires-Dist: numpy

sdfr-1.3.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+sdfr/__init__.py,sha256=vSTzC03qtlxqcn-7dewmUa59NvhaZ-QqBi1svDCDzIo,1153
+sdfr/_commit_info.py,sha256=TmprDWbFKQKXQpJ-hWS2ELdZ46OBHS0lMKb2QHUqiyo,111
+sdfr/loadlib.py,sha256=EMcnZhh68fS72Bjv8QtfDzPbowx1FfaqX4TPhDl-o94,2328
+sdfr/SDF.py,sha256=D4M4qiaK-rYgYKNOi19cWt07M0Dqb6kYgId0uFZtYo4,29770
+sdfr/sdf_helper.py,sha256=jS4fxmq1y7PeryrPFuB_Lgu5n88-cNggaWMvQy4XqSA,63682
+sdfr/sdfc_shared.dll,sha256=JYkR3mF1Ikr4xFZf7NdUN6WNx7CeTdJZVB8k5cCeXRg,13312
+sdfr-1.3.0.dist-info/METADATA,sha256=qhi1HXCNjSgmcm0qLSwEETcCJnsec_45pXXf_41noyo,370
+sdfr-1.3.0.dist-info/WHEEL,sha256=n3HxvvUxRudexxUBRcXuzD3-t2g3c6dOWZQFWqwqrFk,103
+sdfr-1.3.0.dist-info/licenses/LICENSE,sha256=gpLeavs1KxgJFrpL_uVDh0MoDvPfJoZ89A5dSCl4P5U,1652
+sdfr-1.3.0.dist-info/licenses/LICENSE_README.txt,sha256=KlBSoHArwoXbiygx3IJTjtgM7hLNO9o8ZMlZV77nrXs,235
+sdfr-1.3.0.dist-info/RECORD,,

{sdfr-1.2.0.dist-info → sdfr-1.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.0
+Generator: scikit-build-core 0.11.2
 Root-Is-Purelib: false
 Tag: py3-none-win_amd64
 

sdfr-1.2.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-sdfr/__init__.py,sha256=vSTzC03qtlxqcn-7dewmUa59NvhaZ-QqBi1svDCDzIo,1153
-sdfr/_commit_info.py,sha256=lMdNiHt3-u650F4MkvWgSPFaSiRD5pBPkn1VFMpjYQQ,111
-sdfr/loadlib.py,sha256=EMcnZhh68fS72Bjv8QtfDzPbowx1FfaqX4TPhDl-o94,2328
-sdfr/SDF.py,sha256=ISfOQsaK61ahp-2aCui9RmDw8K3vF7pnIiLwoMjX5uM,27317
-sdfr/sdf_helper.py,sha256=jS4fxmq1y7PeryrPFuB_Lgu5n88-cNggaWMvQy4XqSA,63682
-sdfr/sdfc_shared.dll,sha256=7iv4hcKikWqeV5JOSmXaMlGrm_TXKbFOopsLfEdDYOQ,13312
-sdfr-1.2.0.dist-info/METADATA,sha256=VviDTlVggoJ9MqQy-s5IMRRYMJPpKTuUjp_tpYuRlDo,370
-sdfr-1.2.0.dist-info/WHEEL,sha256=QVvQyceONrQFRxko1Jifw1vmo8podRpkc8zfhwmIIMM,103
-sdfr-1.2.0.dist-info/licenses/LICENSE,sha256=gpLeavs1KxgJFrpL_uVDh0MoDvPfJoZ89A5dSCl4P5U,1652
-sdfr-1.2.0.dist-info/licenses/LICENSE_README.txt,sha256=KlBSoHArwoXbiygx3IJTjtgM7hLNO9o8ZMlZV77nrXs,235
-sdfr-1.2.0.dist-info/RECORD,,