sdfr 1.4.6__py3-none-win32.whl → 1.4.8__py3-none-win32.whl

sdfr/SDF.py

@@ -17,6 +17,7 @@
 
 import ctypes as ct
 import numpy as np
+import struct
 from enum import IntEnum
 from .loadlib import sdf_lib
 
@@ -117,6 +118,17 @@ _ct_datatypes = [
     ct.c_bool,
     0,
 ]
+_st_datatypes = [
+    0,
+    "i",
+    "q",
+    "f",
+    "d",
+    "d",
+    "c",
+    "?",
+    0,
+]
 
 # Constants
 SDF_READ = 1
@@ -187,7 +199,7 @@ SdfBlock._fields_ = [
     ("ngrids", ct.c_int),
     ("offset", ct.c_int),
     ("ngb", ct.c_int * 6),
-    ("const_value", ct.c_char * 16),
+    ("const_value", ct.c_byte * 16),
     ("id", ct.c_char_p),
     ("units", ct.c_char_p),
     ("mesh_id", ct.c_char_p),
@@ -339,19 +351,64 @@ class RunInfo(ct.Structure):
 class BlockList:
     """Contains all the blocks"""
 
-    def __init__(self, filename, convert=False, derived=True):
+    def __init__(
+        self,
+        filename=None,
+        convert=False,
+        derived=True,
+        mode=SDF_READ,
+        code_name="sdfr",
+        restart=False,
+    ):
         self._handle = None
         clib = sdf_lib
         self._clib = clib
         clib.sdf_open.restype = ct.POINTER(SdfFile)
         clib.sdf_open.argtypes = [ct.c_char_p, ct.c_int, ct.c_int, ct.c_int]
+        clib.sdf_new.restype = ct.POINTER(SdfFile)
+        clib.sdf_new.argtypes = [ct.c_int, ct.c_int]
         clib.sdf_stack_init.argtypes = [ct.c_void_p]
         clib.sdf_read_blocklist.argtypes = [ct.c_void_p]
         clib.sdf_read_blocklist_all.argtypes = [ct.c_void_p]
         clib.sdf_helper_read_data.argtypes = [ct.c_void_p, ct.POINTER(SdfBlock)]
         clib.sdf_free_block_data.argtypes = [ct.c_void_p, ct.POINTER(SdfBlock)]
+        clib.sdf_stack_destroy.argtypes = [ct.c_void_p]
+        clib.sdf_close.argtypes = [ct.c_void_p]
+        clib.sdf_write.argtypes = [ct.c_void_p, ct.c_char_p]
+        clib.sdf_get_next_block.argtypes = [ct.c_void_p]
+        clib.sdf_set_namevalue.argtypes = [
+            ct.POINTER(SdfBlock),
+            ct.POINTER(ct.c_char_p),
+            ct.POINTER(ct.c_void_p),
+        ]
+        clib.sdf_set_code_name.argtypes = [ct.c_void_p, ct.c_char_p]
+        clib.sdf_set_block_name.argtypes = [
+            ct.c_void_p,
+            ct.c_char_p,
+            ct.c_char_p,
+        ]
+        clib.sdf_set_defaults.argtypes = [
+            ct.c_void_p,
+            ct.POINTER(SdfBlock),
+        ]
+        clib.sdf_create_id.argtypes = [
+            ct.c_void_p,
+            ct.c_char_p,
+        ]
+        clib.sdf_create_id.restype = ct.POINTER(ct.c_char_p)
+        clib.sdf_create_id_array.argtypes = [
+            ct.c_void_p,
+            ct.c_int,
+            ct.POINTER(ct.c_char_p),
+        ]
+        clib.sdf_create_id_array.restype = ct.POINTER(ct.c_char_p)
 
-        h = clib.sdf_open(filename.encode("utf-8"), 0, 1, 0)
+        comm = 0
+        use_mmap = 0
+        if filename is None:
+            h = clib.sdf_new(comm, use_mmap)
+        else:
+            h = clib.sdf_open(filename.encode("utf-8"), comm, mode, use_mmap)
         if h is None or not bool(h):
             raise Exception(f"Failed to open file: '{filename}'")
 
@@ -361,12 +418,16 @@ class BlockList:
         h._clib = clib
         self._handle = h
         clib.sdf_stack_init(h)
-        if derived:
-            clib.sdf_read_blocklist_all(h)
+        if mode == SDF_READ:
+            if derived:
+                clib.sdf_read_blocklist_all(h)
+            else:
+                clib.sdf_read_blocklist(h)
         else:
-            clib.sdf_read_blocklist(h)
+            clib.sdf_set_code_name(h, code_name.encode("utf-8"))
 
         block = h.contents.blocklist
+        h.contents.restart_flag = restart
         self.Header = get_header(h.contents)
         mesh_id_map = {}
         mesh_vars = []
@@ -486,12 +547,271 @@ class BlockList:
 
     def __del__(self):
         if self._handle:
-            self._clib.sdf_stack_destroy.argtypes = [ct.c_void_p]
-            self._clib.sdf_close.argtypes = [ct.c_void_p]
             self._clib.sdf_stack_destroy(self._handle)
             self._clib.sdf_close(self._handle)
             self._handle = None
 
+    def write(self, filename):
+        if not self._handle:
+            return
+        self._clib.sdf_write(self._handle, filename.encode())
+
+    def _set_block_name(self, id, name):
+        self._clib.sdf_set_block_name(
+            self._handle, id.encode("utf-8"), name.encode("utf-8")
+        )
+
+    def _create_id(self, values):
+        tmp = self._clib.sdf_create_id(self._handle, values.encode("utf-8"))
+        return ct.cast(tmp, ct.c_char_p)
+
+    def _string_array_ctype(self, values):
+        strings = [s.encode("utf-8") for s in values]
+        strings = [ct.create_string_buffer(s) for s in strings]
+        strings = [ct.cast(s, ct.c_char_p) for s in strings]
+        strings = (ct.c_char_p * len(values))(*strings)
+        return strings
+
+    def _create_id_array(self, values):
+        values = self._string_array_ctype(values)
+        res = self._clib.sdf_create_id_array(self._handle, len(values), values)
+        return res
+
+    def _add_preamble(self, id, name, datatype):
+        self._clib.sdf_get_next_block(self._handle)
+        h = self._handle.contents
+        h.nblocks += 1
+        h.nblocks_file += 1
+        block = h.current_block.contents
+        block._handle = self._handle
+        block._blocklist = h.blocklist
+        block._data = None
+        block.datatype = datatype
+        block.in_file = 1
+        block.AddBlock = None
+        self._set_block_name(id, name)
+        return h, block
+
+    def _add_post(self, block):
+        if block.AddBlock:
+            newblock = block.AddBlock(block)
+        else:
+            return
+
+        id = block.id.decode()
+        name = block.name.decode()
+        if not block.dont_display:
+            self.__dict__[name] = newblock
+        if block._data is not None:
+            newblock._data = block._data
+        self._block_ids.update({id: newblock})
+        self._block_names.update({name: newblock})
+
+    def _add_constant(self, name, value=0, datatype=None, id=None):
+        if datatype == SdfDataType.SDF_DATATYPE_CHARACTER:
+            print(f'Block "{id}", unsupported datatype: {type(value)}')
+            return
+
+        h, block = self._add_preamble(id, name, datatype)
+        block.blocktype = SdfBlockType.SDF_BLOCKTYPE_CONSTANT
+        block.AddBlock = BlockConstant
+
+        const_value = struct.pack(_st_datatypes[block.datatype], value)
+        ct.memmove(block.const_value, const_value, 16)
+
+        self._add_post(block)
+
+    def _add_namevalue(self, name, value={}, datatype=None, id=None):
+        h, block = self._add_preamble(id, name, datatype)
+        block.blocktype = SdfBlockType.SDF_BLOCKTYPE_NAMEVALUE
+        block.AddBlock = BlockNameValue
+
+        nvalue = len(value)
+        block.ndims = nvalue
+        ctype = _ct_datatypes[block.datatype]
+        if block.datatype == SdfDataType.SDF_DATATYPE_CHARACTER:
+            vals = self._string_array_ctype(value.values())
+        else:
+            vals = (ctype * nvalue)(*value.values())
+        names = self._string_array_ctype(value.keys())
+        vals = ct.cast(vals, ct.POINTER(ct.c_void_p))
+        self._clib.sdf_set_namevalue(block, names, vals)
+
+        self._add_post(block)
+
+    def _add_array(self, name, value=(), datatype=None, id=None):
+        if datatype == SdfDataType.SDF_DATATYPE_CHARACTER:
+            print(f'Block "{id}", unsupported datatype: {type(value[0])}')
+            return
+
+        h, block = self._add_preamble(id, name, datatype)
+        block.blocktype = SdfBlockType.SDF_BLOCKTYPE_ARRAY
+        block.AddBlock = BlockArray
+
+        block._data = np.array(value)
+        block.ndims = block._data.ndim
+        for i in range(block.ndims):
+            block.dims[i] = block._data.shape[i]
+        block.data = block._data.ctypes.data_as(ct.c_void_p)
+
+        self._add_post(block)
+
+    def _add_plainvar(
+        self,
+        name,
+        value=(),
+        datatype=None,
+        id=None,
+        mult=None,
+        units=None,
+        mesh_id=None,
+        stagger=None,
+    ):
+        if datatype == SdfDataType.SDF_DATATYPE_CHARACTER:
+            print(f'Block "{id}", unsupported datatype: {type(value[0])}')
+            return
+        try:
+            mult = float(mult)
+        except Exception:
+            if mult is not None:
+                print(f"ERROR: unable to use mult parameter, {mult}")
+                return
+        try:
+            stagger = SdfStagger(stagger)
+        except Exception:
+            if stagger is not None:
+                print(f"ERROR: unable to use stagger parameter, {stagger}")
+                return
+        if units is not None and not isinstance(units, str):
+            print(f"ERROR: unable to use units parameter, {units}")
+            return
+        if mesh_id is not None and not isinstance(mesh_id, str):
+            print(f"ERROR: unable to use mesh_id parameter, {mesh_id}")
+            return
+
+        h, block = self._add_preamble(id, name, datatype)
+        block.blocktype = SdfBlockType.SDF_BLOCKTYPE_PLAIN_VARIABLE
+        block.AddBlock = BlockPlainVariable
+
+        block._data = np.array(value, order="F")
+        block.ndims = block._data.ndim
+        for i in range(block.ndims):
+            block.dims[i] = block._data.shape[i]
+        block.data = block._data.ctypes.data_as(ct.c_void_p)
+        if mult is not None:
+            block.mult = mult
+        if isinstance(units, str):
+            block.units = self._create_id(units)
+        if isinstance(mesh_id, str):
+            block.mesh_id = self._create_id(mesh_id)
+        if stagger:
+            block.stagger = stagger
+
+        self._clib.sdf_set_defaults(self._handle, block)
+        self._add_post(block)
+
+    def _add_mesh(
+        self,
+        name,
+        value=None,
+        datatype=None,
+        id=None,
+        units=None,
+        labels=None,
+        geometry=None,
+        **kwargs,
+    ):
+        if datatype == SdfDataType.SDF_DATATYPE_CHARACTER:
+            print(f'Block "{id}", unsupported datatype: {type(value[0])}')
+            return
+
+        h, block = self._add_preamble(id, name, datatype)
+
+        keys = ["x", "y", "z"]
+        keys = [k for k in keys if k in kwargs and kwargs[k] is not None]
+        val = np.concatenate([kwargs[k] for k in keys]).flatten()[0]
+
+        block._data = [np.array(kwargs[k], dtype=val.dtype) for k in keys]
+        block._data = [np.array(row, order="F") for row in block._data]
+        block._data = tuple(block._data)
+        block.ndims = len(block._data)
+        block.ngrids = block.ndims
+        grids = [row.ctypes.data_as(ct.c_void_p) for row in block._data]
+        block.grids = (ct.c_void_p * block.ngrids)(*grids)
+        if block._data[0].ndim == 1:
+            block.blocktype = SdfBlockType.SDF_BLOCKTYPE_PLAIN_MESH
+            block.AddBlock = BlockPlainMesh
+            for i in range(block.ndims):
+                block.dims[i] = block._data[i].shape[0]
+        else:
+            block.blocktype = SdfBlockType.SDF_BLOCKTYPE_LAGRANGIAN_MESH
+            block.AddBlock = BlockLagrangianMesh
+            for i in range(block.ndims):
+                block.dims[i] = block._data[0].shape[i]
+        if isinstance(units, (list, tuple)):
+            block.dim_units = self._create_id_array(units)
+        if isinstance(labels, (list, tuple)):
+            block.dim_labels = self._create_id_array(labels)
+        if isinstance(geometry, str):
+            if geometry == "rz":
+                geometry = SdfGeometry.SDF_GEOMETRY_CYLINDRICAL
+        if isinstance(geometry, int):
+            block.geometry = geometry
+
+        self._clib.sdf_set_defaults(self._handle, block)
+        self._add_post(block)
+
+    def add_block(self, name, value=None, id=None, **kwargs):
+        if isinstance(value, dict):
+            val = next(iter(value.values()), None)
+            add_func = self._add_namevalue
+        elif isinstance(value, (tuple, list, np.ndarray)):
+            arr = np.array(value)
+            if arr.ndim == 1:
+                val = value[0]
+                add_func = self._add_array
+            else:
+                val = arr.flatten()[0]
+                add_func = self._add_plainvar
+        elif value is not None:
+            val = value
+            add_func = self._add_constant
+        else:
+            keys = ["x", "y", "z"]
+            keys = [k for k in keys if k in kwargs and kwargs[k] is not None]
+            val = np.concatenate([kwargs[k] for k in keys]).flatten()[0]
+            add_func = self._add_mesh
+            if id is None:
+                id = "grid"
+
+        if id is None:
+            id = name
+        if id in self._block_ids:
+            print(f'Unable to create block. ID duplicated: "{id}"')
+            return
+
+        datatype = None
+        if isinstance(val, bool):
+            datatype = SdfDataType.SDF_DATATYPE_LOGICAL
+        elif isinstance(val, np.int32):
+            datatype = SdfDataType.SDF_DATATYPE_INTEGER4
+        elif isinstance(val, (int, np.int64)):
+            datatype = SdfDataType.SDF_DATATYPE_INTEGER8
+        elif isinstance(val, np.float32):
+            datatype = SdfDataType.SDF_DATATYPE_REAL4
+        elif isinstance(val, float):
+            datatype = SdfDataType.SDF_DATATYPE_REAL8
+        elif isinstance(val, str):
+            datatype = SdfDataType.SDF_DATATYPE_CHARACTER
+        else:
+            add_func = None
+
+        if add_func:
+            add_func(name, value=value, id=id, datatype=datatype, **kwargs)
+        else:
+            print(f'Block "{id}", unsupported datatype: {type(value)}')
+            return
+
     @property
     def name_dict(self):
         """Dictionary of blocks using name field as key"""
@@ -889,10 +1209,12 @@ class BlockStitchedTensor(BlockStitched):
 
 def get_header(h):
     d = {}
-    d["filename"] = h.filename.decode()
+    if h.filename:
+        d["filename"] = h.filename.decode()
     d["file_version"] = h.file_version
     d["file_revision"] = h.file_revision
-    d["code_name"] = h.code_name.decode()
+    if h.code_name:
+        d["code_name"] = h.code_name.decode()
     d["step"] = h.step
     d["time"] = h.time
     d["jobid1"] = h.jobid1
@@ -958,7 +1280,7 @@ def read(file=None, convert=False, mmap=0, dict=False, derived=True):
 
     import warnings
 
-    if file == None:
+    if file is None:
         raise TypeError("Missing file parameter")
 
     if mmap != 0:
@@ -973,3 +1295,23 @@ def read(file=None, convert=False, mmap=0, dict=False, derived=True):
         return blocklist._block_names
 
     return blocklist
+
+
+def new(dict=False, code_name="sdfr", restart=False):
+    """Creates a new SDF blocklist and returns a dictionary of NumPy arrays.
+
+    Parameters
+    ----------
+    dict : bool, optional
+        Return file contents as a dictionary rather than member names.
+    """
+
+    blocklist = BlockList(mode=SDF_WRITE, code_name=code_name, restart=restart)
+
+    if isinstance(dict, str):
+        if dict == "id" or dict == "ids":
+            return blocklist._block_ids
+    elif isinstance(dict, bool) and dict:
+        return blocklist._block_names
+
+    return blocklist

sdfr/__init__.py

@@ -15,9 +15,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-_module_name = "sdfr"
-
-from .SDF import *
+from .SDF import new, read
 from . import sdf_helper
 from ._commit_info import (
     __commit_date__,
@@ -28,7 +26,9 @@ from .loadlib import (
     __library_commit_id__,
 )
 
-from importlib.metadata import version, PackageNotFoundError
+from importlib.metadata import version
+
+_module_name = "sdfr"
 
 try:
     __version__ = version(_module_name)
@@ -37,6 +37,9 @@ except Exception:
 
 __all__ = [
     "SDF",
+    "new",
+    "read",
+    "sdf_helper",
     "__library_commit_date__",
     "__library_commit_id__",
     "__version__",

sdfr/_commit_info.py

@@ -1,2 +1,2 @@
-__commit_date__ = "Fri Aug 8 17:11:48 2025 +0100"
-__commit_id__ = "254251dfdad1469679c14dd9bbbadf472cd9225b"
+__commit_date__ = "Wed Oct 1 21:41:44 2025 +0100"
+__commit_id__ = "8c9e6c5adfd223e16c62725d02cc85478ba80dbd"

sdfr/loadlib.py

@@ -17,7 +17,6 @@
 
 import sys
 import ctypes as ct
-from contextlib import suppress
 from itertools import product
 from pathlib import Path
 from site import getsitepackages
@@ -30,11 +29,6 @@ def _loadlib():
     packages. This enables the library to be found even on an editable install.
     Raises a ``RuntimeError`` if it is missing.
     """
-    # Try finding library using import.
-    # Expect this to fail, but it will trigger a rebuild if the project is
-    # installed in editable mode.
-    with suppress(ImportError):
-        import sdfr
 
     # Find library in site-packages or local to this module
     local_dir = Path(__file__).resolve().parent

sdfr/sdf_helper.py

@@ -11,11 +11,11 @@ try:
         TextArea,
         AnchoredOffsetbox,
     )
-except:
+except Exception:
     pass
 try:
     from mpl_toolkits.axes_grid1 import make_axes_locatable
-except:
+except Exception:
     try:
         # Workaround for broken macOS installation
         import sys
@@ -25,11 +25,11 @@ except:
             os.path.join(matplotlib.__path__[0], "..", "mpl_toolkits")
         )
         from axes_grid1 import make_axes_locatable
-    except:
+    except Exception:
         pass
 try:
     import builtins
-except:
+except Exception:
     import __builtin__ as builtins
 
 try:
@@ -353,7 +353,7 @@ def get_job_id(file_list=None, base=None, block=None):
             data = sdf.read(base, mmap=0)
             if len(data.__dict__) > 1:
                 return data.Header["jobid1"]
-        except:
+        except Exception:
             pass
 
     # Find the job id
@@ -364,7 +364,7 @@ def get_job_id(file_list=None, base=None, block=None):
                 if len(data.__dict__) < 2:
                     continue
                 return data.Header["jobid1"]
-            except:
+            except Exception:
                 pass
 
     return None
@@ -435,7 +435,7 @@ def get_files(wkd=None, base=None, block=None, varname=None, fast=True):
                     file_list.append(f)
             elif len(file_list) > 0:
                 break
-        except:
+        except Exception:
             pass
 
     return list(reversed(file_list))
@@ -708,7 +708,7 @@ def sdfr(filename):
 def plot_auto(*args, **kwargs):
     try:
         dims = args[0].dims
-    except:
+    except Exception:
         print(
             "error: Variable cannot be auto determined. "
             + "Use plot1d or plot2d"
@@ -773,7 +773,7 @@ def plot1d(
     hold=True,
     subplot=None,
     figure=None,
-    **kwargs
+    **kwargs,
 ):
     global data
     global x, y, mult_x, mult_y
@@ -791,7 +791,7 @@ def plot1d(
             if not hold:
                 try:
                     figure.clf()
-                except:
+                except Exception:
                     pass
         elif not hold:
             figure.clf()
@@ -913,7 +913,7 @@ def plot_path(
     axis_only=False,
     clip_reflect=False,
     power=(-3, 3),
-    **kwargs
+    **kwargs,
 ):
     """Plot an SDF path variable (eg. a laser ray)
 
@@ -1022,7 +1022,7 @@ def plot_path(
             if not hold:
                 try:
                     figure.clf()
-                except:
+                except Exception:
                     pass
         elif not hold:
             figure.clf()
@@ -1204,7 +1204,7 @@ def plot_path(
         try:
             cbar.formatter.set_powerlimits(power)
             cbar.update_ticks()
-        except:
+        except Exception:
             pass
         subplot.colorbar = cax
         plt.sca(ax)
@@ -1278,21 +1278,21 @@ def plot_rays(var, skip=1, rays=None, **kwargs):
     else:
         ray_start, ray_stop = None, None
 
-        l = "ray_start"
-        if l in kwargs:
-            ray_start = kwargs[l]
+        k = "ray_start"
+        if k in kwargs:
+            ray_start = kwargs[k]
 
-        l = "ray_stop"
-        if l in kwargs:
-            ray_stop = kwargs[l]
+        k = "ray_stop"
+        if k in kwargs:
+            ray_stop = kwargs[k]
 
         ray_slice = slice(ray_start, ray_stop, skip)
 
     if isinstance(var, sdf.BlockStitchedPath):
         v = var.data[0]
-        l = "_label"
-        if l not in kwargs:
-            kwargs[l] = var.name
+        lab = "_label"
+        if lab not in kwargs:
+            kwargs[lab] = var.name
 
         if isinstance(v, sdf.BlockStitchedPath):
             for v in var.data:
@@ -1310,8 +1310,8 @@ def plot_rays(var, skip=1, rays=None, **kwargs):
             if k not in kwargs or (
                 kwargs[k] and not isinstance(kwargs[k], str)
             ):
-                kwargs[k] = kwargs[l] + " $(" + escape_latex(v.units) + ")$"
-                del kwargs[l]
+                kwargs[k] = kwargs[lab] + " $(" + escape_latex(v.units) + ")$"
+                del kwargs[lab]
 
             k0 = "vmin"
             k1 = "vmax"
@@ -1424,7 +1424,7 @@ def plot2d_array(
     cbar_wd=5,
     cbar_top=False,
     power=(-3, 3),
-    **kwargs
+    **kwargs,
 ):
     import matplotlib as mpl
 
@@ -1468,7 +1468,7 @@ def plot2d_array(
             if not hold:
                 try:
                     figure.clf()
-                except:
+                except Exception:
                     pass
         elif not hold:
             figure.clf()
@@ -1573,7 +1573,7 @@ def plot2d_array(
                 cmap=cmap,
                 vmin=vrange[0],
                 vmax=vrange[1],
-                **kwargs
+                **kwargs,
             )
     else:
         X = np.multiply(mult_x, X)
@@ -1622,7 +1622,7 @@ def plot2d_array(
         try:
             cbar.formatter.set_powerlimits(power)
             cbar.update_ticks()
-        except:
+        except Exception:
             pass
         subplot.colorbar = cax
         plt.sca(ax)
@@ -1663,7 +1663,7 @@ def plot2d(
     add_cbar=True,
     cbar_label=True,
     cbar_top=False,
-    **kwargs
+    **kwargs,
 ):
     global data, fig, im, cbar
     global x, y, mult_x, mult_y
@@ -1807,7 +1807,7 @@ def plot2d(
         add_cbar=add_cbar,
         cbar_label=cbar_label,
         cbar_top=cbar_top,
-        **kwargs
+        **kwargs,
     )
 
 
@@ -1828,13 +1828,13 @@ def plot_levels(
     out=False,
     title=True,
     levels=True,
-    **kwargs
+    **kwargs,
 ):
     global data
 
     try:
         plt.clf()
-    except:
+    except Exception:
         pass
 
     if iso is None:
@@ -1882,19 +1882,19 @@ def plot_levels(
 
     if levels:
         fmt = {}
-        for l, i in zip(cs.levels, range(1, len(cs.levels) + 1)):
-            fmt[l] = str(i)
+        for level, i in zip(cs.levels, range(1, len(cs.levels) + 1)):
+            fmt[level] = str(i)
 
         sidx = ""
         slvl = ""
-        for l, i in reversed(
+        for level, i in reversed(
             list(zip(cs.levels, range(1, len(cs.levels) + 1)))
         ):
             # sidx += rtn + "%i" % i
-            # slvl += rtn + "%-6.4g" % l
+            # slvl += rtn + "%-6.4g" % level
             # rtn = "\n"
             sidx += "%i\n" % i
-            slvl += "%-6.4g\n" % l
+            slvl += "%-6.4g\n" % level
 
         t1 = TextArea("Level", textprops=dict(color="k", fontsize="small"))
         t2 = TextArea(sidx, textprops=dict(color="k", fontsize="small"))
@@ -1974,7 +1974,7 @@ def plot_contour(var, r0=None, r1=None, nl=10, iso=None, title=True, **kwargs):
         out=False,
         title=title,
         levels=False,
-        **kwargs
+        **kwargs,
     )
 
 
@@ -1990,17 +1990,17 @@ def getdata(fname, wkd=None, verbose=True, squeeze=False):
     if isinstance(fname, int):
         try:
             filename = wkdir + "/%0.4i.sdf" % fname
-        except:
+        except Exception:
             filename = wkdir + "/" + fname
     else:
         filename = fname
 
     try:
         st = os.stat(filename)
-    except OSError as e:
+    except OSError:
         try:
             filename = "./%0.4i.sdf" % fname
-        except:
+        except Exception:
             filename = "./" + fname
         try:
             st = os.stat(filename)
@@ -2034,7 +2034,7 @@ def getdata(fname, wkd=None, verbose=True, squeeze=False):
                 for element in value.dims:
                     dims.append([0, element - 1])
                 subarray(value, dims)
-            except:
+            except Exception:
                 pass
 
     sdfdict = data._block_ids
@@ -2164,7 +2164,7 @@ def _get_grid(data, verbose=False):
                 var = vargrid.data[n]
                 dims = str(tuple(int(i) for i in vargrid.dims))
                 if verbose:
-                    print(key + dims + " = " + k)
+                    print(key + dims + " = " + var)
                 globals()[key] = var
                 builtins.__dict__[key] = var
 
@@ -2234,11 +2234,11 @@ def axis_offset(boxed=False):
     f = 1e-3
 
     # for o in ax.findobj():
-    for l in ax.get_lines():
-        bb = l.get_clip_box()
+    for line in ax.get_lines():
+        bb = line.get_clip_box()
         bb._bbox = Bbox([[-f, -f], [1 + 2 * f, 1 + 2 * f]])
-        l.set_clip_box(bb)
-        # l.set_clip_on(False)
+        line.set_clip_box(bb)
+        # line.set_clip_on(False)
 
     if boxed:
         r = matplotlib.patches.Rectangle(
@@ -2309,7 +2309,7 @@ def list_variables(data):
                     np.array2string(np.array(val.dims), separator=", "),
                 )
             )
-        except:
+        except Exception:
             pass
 
 

{sdfr-1.4.6.dist-info → sdfr-1.4.8.dist-info}/METADATA

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

sdfr-1.4.8.dist-info/RECORD

@@ -0,0 +1,12 @@
+sdfr/__init__.py,sha256=ticK-M9p82dtnw9oebJJUD0eqqtQgQUoihhpG6hw50o,1239
+sdfr/_commit_info.py,sha256=ZyjDe5QNRlORYnTts9A4EhRoLbaNR-CANqxgtdfzFpE,111
+sdfr/loadlib.py,sha256=AFOSSEuTAu0kMLlVvtE4t_0gDwDF3VQ5HN-nwdNiMDs,2119
+sdfr/SDF.py,sha256=0ltv9XrbR5-WWGmumXO8urGMwS3S_xwSRlnEunkfgxc,43412
+sdfr/sdf_helper.py,sha256=Qg4Jhp69xvoochKt6lNKB6KxqnEnD4vG9GRO5LG0Stk,63666
+sdfr/sdfc_shared.dll,sha256=XIUu6no4_IcBWD5hJazhwKRdcgHdEi4H0W9YexWBc6c,103424
+sdfr/sdfc_shared.lib,sha256=mgG3DptrNu7r9YPWU3iGfdCKQ9OqN7zGicB5ac5VKvI,4320
+sdfr-1.4.8.dist-info/METADATA,sha256=_nfighJb9MBGYlEAkvsBq3MA2rAg7uSnXC6EckWZQyo,370
+sdfr-1.4.8.dist-info/WHEEL,sha256=vYHNRTV5iZ4cbCQq1z3P-rh0QJf8VlrEy6GTzTd7mOA,99
+sdfr-1.4.8.dist-info/licenses/LICENSE,sha256=gpLeavs1KxgJFrpL_uVDh0MoDvPfJoZ89A5dSCl4P5U,1652
+sdfr-1.4.8.dist-info/licenses/LICENSE_README.txt,sha256=KlBSoHArwoXbiygx3IJTjtgM7hLNO9o8ZMlZV77nrXs,235
+sdfr-1.4.8.dist-info/RECORD,,

{sdfr-1.4.6.dist-info → sdfr-1.4.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: scikit-build-core 0.11.5
+Generator: scikit-build-core 0.11.6
 Root-Is-Purelib: false
 Tag: py3-none-win32
 

sdfr-1.4.6.dist-info/RECORD

@@ -1,12 +0,0 @@
-sdfr/__init__.py,sha256=OxcJAJ0ADoE54vgqMQqxhoFWyU2ldb3fb-_LFyeZZfQ,1209
-sdfr/_commit_info.py,sha256=0rgHeEWqDT9BY-sUd4y9DzBpu47pTrR9Witiqaw_g-A,111
-sdfr/loadlib.py,sha256=xxp5MX-u7ZHIc12mcvN-y8L5UEjY-aEgINj2r-1swWk,2358
-sdfr/SDF.py,sha256=Vka3UM8TCbREKAf0-eppz5crPQ04bvGo2DjpMal4Kx0,31386
-sdfr/sdf_helper.py,sha256=EnwHKG0cHHkplE9wKAIdBb-XAhqvVbsG0aDea_6S3zU,63439
-sdfr/sdfc_shared.dll,sha256=XXDoCznExIObVMz2uqLFDZdmklLQABzkpI2S8nDDhfI,102400
-sdfr/sdfc_shared.lib,sha256=1rqYANk9NAZa4iiNyIeLa8ww-b5AQFfBXQvPfKLTvVE,3652
-sdfr-1.4.6.dist-info/METADATA,sha256=R-u3p3Va7lHdIEud6a2DFNhIFB71_K8erUQRV3Lndw8,370
-sdfr-1.4.6.dist-info/WHEEL,sha256=VieJsWSfQ9njvRAwkFtQWPMJWKO44XIFlEVDRnU0rMU,99
-sdfr-1.4.6.dist-info/licenses/LICENSE,sha256=gpLeavs1KxgJFrpL_uVDh0MoDvPfJoZ89A5dSCl4P5U,1652
-sdfr-1.4.6.dist-info/licenses/LICENSE_README.txt,sha256=KlBSoHArwoXbiygx3IJTjtgM7hLNO9o8ZMlZV77nrXs,235
-sdfr-1.4.6.dist-info/RECORD,,