simind-python-connector 2.0.1__py3-none-any.whl → 2.0.2__py3-none-any.whl

simind_python_connector/__init__.py

@@ -14,7 +14,7 @@ for _dist_name in ("simind-python-connector", __name__):
     except _meta.PackageNotFoundError:
         continue
 else:  # editable / source checkout
-    __version__ = "2.0.1"
+    __version__ = "2.0.2"
 
 
 def __getattr__(name: str) -> Any:

simind_python_connector/connectors/python_connector.py

@@ -853,8 +853,8 @@ class SimindPythonConnector(BaseConnector):
         ):
             warnings.warn(
                 "SIMIND v9.0 on Linux can abort in SCATTWIN or silently return "
-                "corrupted projections. Use SIMIND v8, the macOS v9 build or "
-                "the PENETRATE scoring routine.",
+                "corrupted projections. Use SIMIND v8; v9 support is "
+                "experimental and unvalidated in this release (planned for 2.1.0).",
                 RuntimeWarning,
                 stacklevel=2,
             )

simind_python_connector/recon/corrections.py

@@ -23,9 +23,13 @@ class ScatterCorrection:
     output, which holds phantom scatter only.
 
     With measured, this is Dewaraja et al. 2017's pixel-wise model: the
-    scatter fraction scatter / total of SIMIND's run, times the measured data.
-    It does not depend on the projector's scalar scale. With smoothing,
-    smoothing_fwhm_bins=3.0 and smooth_across_views=True match the paper.
+    measured data times the scatter-to-total ratio of SIMIND's run. It does not
+    depend on the projector's scalar scale. With smoothing, SIMIND's scatter
+    and total are smoothed with the same Gaussian before the ratio, and the
+    scaled result is smoothed again. smoothing_fwhm_bins=3.0 and
+    smooth_across_views=True match the paper. The final smoothing is retained
+    because the measured noise enters the estimate. The ratio is zero only
+    where the smoothed total is not positive; signed scatter is not clipped.
     smooth_across_views wraps around the view axis, so it assumes the views
     cover 360 degrees.
     """
@@ -79,6 +83,26 @@ class ScatterCorrection:
                 f"scatter shape {scatter_array.shape}"
             )
         total_array = total.as_array()
+        if total_array.shape != scatter_array.shape:
+            raise ValueError(
+                f"total shape {total_array.shape} does not match "
+                f"scatter shape {scatter_array.shape}"
+            )
+        # Smooth the MC scatter and its total before forming the fraction. In
+        # the fixed-primary, noisy-scatter control used to check this order,
+        # pre-smoothing reduced the ratio noise in the summed estimate. The
+        # direction and size of a noisy ratio's error depend on the covariance
+        # between numerator and denominator, so this is an observation about
+        # that control, not a general theorem about Monte Carlo ratios, and it
+        # does not account for the unresolved pixel-wise drift. The final
+        # smoothing in estimate() is retained.
+        if self.smoothing_fwhm_bins is not None:
+            scatter_array = _smooth_array(
+                scatter_array, self.smoothing_fwhm_bins, self.smooth_across_views
+            )
+            total_array = _smooth_array(
+                total_array, self.smoothing_fwhm_bins, self.smooth_across_views
+            )
         fraction = np.divide(
             scatter_array,
             total_array,
@@ -90,27 +114,45 @@ class ScatterCorrection:
         return out
 
 
-def _smooth_views(data: Any, fwhm_bins: float, across_views: bool = False) -> Any:
-    """Gaussian-smooth each view along its axial and bin axes, keeping the total.
+def _smooth_array(
+    array: Any, fwhm_bins: float, across_views: bool = False
+) -> np.ndarray:
+    """Gaussian-smooth a projection array, keeping its total.
 
-    With across_views, also smooth along the view axis, wrapping round.
+    The total is restored by rescaling only when the input sum stands clear
+    of the rounding floor of that sum, so a zero-sum signed field keeps its
+    smoothed values instead of being multiplied by an arbitrary factor.
     """
     from scipy.ndimage import gaussian_filter
 
-    array = np.asarray(data.as_array(), dtype=np.float64)
-    sigma = [0.0] * array.ndim
-    mode = ["reflect"] * array.ndim
+    values = np.asarray(array, dtype=np.float64)
+    sigma = [0.0] * values.ndim
+    mode = ["reflect"] * values.ndim
     # Projection arrays end in (axial, view, bin); SIRF may add a TOF axis first.
     sigma[-3] = sigma[-1] = fwhm_bins / (2.0 * np.sqrt(2.0 * np.log(2.0)))
     if across_views:
         sigma[-2] = sigma[-1]
         mode[-2] = "wrap"
-    smoothed = gaussian_filter(array, sigma, mode=mode)
-    total = smoothed.sum()
-    if total != 0.0:
-        smoothed *= array.sum() / total
+    smoothed = gaussian_filter(values, sigma, mode=mode)
+    # Keep the original total, but only when it stands clear of the rounding
+    # floor of the sum. A cancelling signed field sums to about zero, and so
+    # does its smoothed version: their ratio is then an arbitrary factor (and
+    # zero erases the field), so such a field is left exactly as smoothed.
+    original_sum = values.sum()
+    if abs(original_sum) > 1e-9 * np.abs(values).sum():
+        total = smoothed.sum()
+        if total != 0.0:
+            smoothed *= original_sum / total
+    return smoothed.astype(np.float32)
+
+
+def _smooth_views(data: Any, fwhm_bins: float, across_views: bool = False) -> Any:
+    """Gaussian-smooth each view along its axial and bin axes, keeping the total.
+
+    With across_views, also smooth along the view axis, wrapping round.
+    """
     out = data.clone()
-    out.fill(smoothed.astype(np.float32))
+    out.fill(_smooth_array(data.as_array(), fwhm_bins, across_views))
     return out
 
 

simind_python_connector/recon/osem.py

@@ -28,7 +28,8 @@ def run_osem_with_corrections(
     Each pass builds a fresh model, objective and reconstructor, continuing
     from the preceding pass's image. initial_image is cloned and not modified.
     updater.update_now is called between passes at completed subiterations;
-    updater.schedule is not used.
+    updater.schedule is not used. Intermediate subiteration images are not
+    written to disk; only the returned image is produced.
     """
     # Each pass rebuilds a reconstructor that restarts at subset 0, so a
     # remainder would use some subsets more often and others never.
@@ -51,6 +52,9 @@ def run_osem_with_corrections(
         reconstructor.set_objective_function(objective)
         reconstructor.set_num_subsets(num_subsets)
         reconstructor.set_num_subiterations(subiterations_per_update)
+        # STIR otherwise writes one Interfile image per subiteration into the
+        # process working directory. Callers only need the returned image.
+        reconstructor.disable_output()
         reconstructor.set_input(acquisition_data)
         reconstructor.set_up(image)
         reconstructor.reconstruct(image)

simind_python_connector/utils/projection_metrics.py

@@ -0,0 +1,153 @@
+"""Small projection-metric helpers used by the worked examples.
+
+They are deliberately plain NumPy: the examples need a shared count scale, a
+repeatability measure, a triple-energy-window estimate and a quadrature check,
+not a reconstruction framework.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from simind_python_connector.core.types import MAX_SOURCE
+
+
+def projection_view0(projection: np.ndarray) -> np.ndarray:
+    """Return the first view of a 3-D or 4-D projection array."""
+    if projection.ndim == 4:
+        return projection[0, :, 0, :]
+    if projection.ndim == 3:
+        return projection[0, :, :]
+    raise ValueError(
+        f"Expected projection with 3 or 4 dimensions, got shape {projection.shape}"
+    )
+
+
+def require_output_keys(outputs: dict[str, object], *keys: str) -> dict[str, object]:
+    """Return only the named outputs, or say which ones the run did not write."""
+    missing = [key for key in keys if key not in outputs]
+    if missing:
+        raise KeyError(
+            f"SIMIND did not write {', '.join(missing)}; it wrote "
+            f"{', '.join(sorted(outputs))}"
+        )
+    return {key: outputs[key] for key in keys}
+
+
+def source_weights(source: np.ndarray, quantization_scale: float) -> np.ndarray:
+    """Return the integer photon-history weights the connector writes."""
+    source = np.asarray(source, dtype=float)
+    if source.size == 0:
+        raise ValueError("source must not be empty")
+    if not 0.0 < quantization_scale <= 1.0:
+        raise ValueError("quantization_scale must be in (0, 1]")
+    maximum = float(source.max())
+    if maximum == 0.0:
+        return np.zeros(source.shape, dtype=np.int64)
+    return np.clip(
+        np.round(source / maximum * (MAX_SOURCE * quantization_scale)),
+        0,
+        MAX_SOURCE,
+    ).astype(np.int64)
+
+
+def source_weight_sum(source: np.ndarray, quantization_scale: float) -> int:
+    """Number of photon histories per projection before the ``NN`` multiplier."""
+    return int(source_weights(source, quantization_scale).sum())
+
+
+def zero_history_fraction(source: np.ndarray, quantization_scale: float) -> float:
+    """Fraction of the source weight that integer rounding sends to zero."""
+    source = np.asarray(source, dtype=float)
+    total = float(source.sum())
+    if total == 0.0:
+        return 0.0
+    weights = source_weights(source, quantization_scale)
+    return float(source[weights == 0].sum() / total)
+
+
+def symmetric_limits(*images: np.ndarray) -> tuple[float, float]:
+    """A zero-centred colour scale that fits every image."""
+    if not images:
+        raise ValueError("symmetric_limits needs at least one image")
+    limit = max(float(np.max(np.abs(image))) for image in images)
+    if limit == 0.0:
+        return 0.0, 0.0
+    return -limit, limit
+
+
+def normalised_rms_difference(a: np.ndarray, b: np.ndarray) -> float:
+    """RMS difference between two images, relative to their mean magnitude."""
+    a = np.asarray(a, dtype=float)
+    b = np.asarray(b, dtype=float)
+    if a.shape != b.shape:
+        raise ValueError(f"shape mismatch: {a.shape} and {b.shape}")
+    scale = float(np.mean(np.abs(a) + np.abs(b)) / 2.0)
+    if scale == 0.0:
+        return 0.0
+    return float(np.sqrt(np.mean((a - b) ** 2)) / scale)
+
+
+def tew_scatter_estimate(
+    lower: np.ndarray,
+    upper: np.ndarray,
+    *,
+    lower_width_kev: float,
+    photopeak_width_kev: float,
+    upper_width_kev: float,
+) -> np.ndarray:
+    """Triple-energy-window scatter estimate for one photopeak.
+
+    Each side window is scaled to the photopeak width and half of the total is
+    assigned to the peak, which assumes the scatter spectrum is linear across
+    the three windows. That is an approximation, not a measurement.
+    """
+    widths = (lower_width_kev, photopeak_width_kev, upper_width_kev)
+    if any(width <= 0 for width in widths):
+        raise ValueError(f"window widths must be positive, got {widths}")
+    return np.asarray(lower) * (
+        photopeak_width_kev / (2.0 * lower_width_kev)
+    ) + np.asarray(upper) * (photopeak_width_kev / (2.0 * upper_width_kev))
+
+
+def tew_correction(
+    photopeak: np.ndarray,
+    lower: np.ndarray,
+    upper: np.ndarray,
+    *,
+    lower_width_kev: float,
+    photopeak_width_kev: float,
+    upper_width_kev: float,
+) -> tuple[np.ndarray, np.ndarray, float, float]:
+    """Return (scatter estimate, corrected, clipped count fraction, clipped pixels).
+
+    The corrected image is the photopeak minus the estimate, clipped at zero.
+    The count fraction is the part of the photopeak that clipping removed;
+    the pixel fraction is the part of the image that the estimate exceeded.
+    """
+    photopeak = np.asarray(photopeak)
+    estimate = tew_scatter_estimate(
+        lower,
+        upper,
+        lower_width_kev=lower_width_kev,
+        photopeak_width_kev=photopeak_width_kev,
+        upper_width_kev=upper_width_kev,
+    )
+    unclipped = photopeak - estimate
+    corrected = np.clip(unclipped, a_min=0.0, a_max=None)
+    peak_total = float(np.clip(photopeak, 0.0, None).sum())
+    clipped_counts = float((corrected - unclipped).sum())
+    clipped_count_fraction = clipped_counts / peak_total if peak_total else 0.0
+    clipped_pixel_fraction = float(np.mean(unclipped < 0.0))
+    return estimate, corrected, clipped_count_fraction, clipped_pixel_fraction
+
+
+def count_preservation_error(
+    outputs: dict[str, object], total_key: str, *component_keys: str
+) -> float:
+    """Relative difference between a total and the sum of its components."""
+    total = float(outputs[total_key].projection.sum())
+    components = sum(float(outputs[key].projection.sum()) for key in component_keys)
+    if total == 0.0:
+        return 0.0 if components == 0.0 else float("inf")
+    return (components - total) / total

{simind_python_connector-2.0.1.dist-info → simind_python_connector-2.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simind-python-connector
-Version: 2.0.1
+Version: 2.0.2
 Summary: Python SIMIND Monte Carlo connector with STIR/SIRF/PyTomography adaptors
 Author-email: Sam Porter <sam.porter.18@ucl.ac.uk>, Rebecca Gillen <rebecca.gillen.18@ucl.ac.uk>, "Efstathios (Stahis) Varzakis" <efstathios.varzakis.22@ucl.ac.uk>
 Maintainer-email: Sam Porter <sam.porter.18@ucl.ac.uk>
@@ -33,8 +33,8 @@ Requires-Dist: scipy; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Requires-Dist: sphinx; extra == "dev"
 Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: Pillow; extra == "dev"
 Requires-Dist: sphinx-autodoc-typehints; extra == "dev"
-Requires-Dist: sphinx-gallery<0.23,>=0.22; extra == "dev"
 Requires-Dist: pooch>=1.8; extra == "dev"
 Requires-Dist: myst-parser; extra == "dev"
 Requires-Dist: pre-commit; extra == "dev"
@@ -58,15 +58,12 @@ SIMIND project and Lund University.
 
 ## Start here
 
-See the [workflow tutorial](docs/tutorial.rst) for an ordered path through a
-core simulation, known-activity NEMA phantom, reconstruction, scatter
-correction, and measured-data calibration. The [gallery](docs/auto_examples/index.rst)
-has every tutorial with its figures and printed output. Rendered documentation,
-including the gallery, is built from the tagged repository; source distributions
-contain the example sources rather than the generated gallery. The
-[documentation](https://simind-python-connector.readthedocs.io/) explains
-installation, geometry, normalisation, backend options, and the
-[observed SIMIND output-component mapping](docs/simind_validation.md).
+The [workflow tutorial](docs/tutorial.rst) walks through a core simulation,
+known-activity NEMA phantom, reconstruction, scatter correction, and
+measured-data calibration; the [example pages](docs/example_pages/index.rst)
+collect the tutorials and figures. The
+[documentation](https://simind-python-connector.readthedocs.io/) covers
+installation, geometry, normalisation and backends.
 
 Install the package and example plotting dependencies:
 
@@ -79,15 +76,15 @@ Select a SIMIND executable and its matching data directory. The binary and
 `simind` on `PATH`; set `SMC_DIR` when required by your installation.
 
 ```bash
-export SIMIND_BIN=/path/to/simind-v9/simind
-export PATH=/path/to/simind-v9:$PATH
-export SMC_DIR=/path/to/simind-v9/smc_dir/
-export SIMIND_VERSION=9
+export SIMIND_BIN=/path/to/simind-v8/simind
+export PATH=/path/to/simind-v8:$PATH
+export SMC_DIR=/path/to/simind-v8/smc_dir/
+export SIMIND_VERSION=8
 ```
 
-Select version `8` or `9` explicitly. The connector uses this choice to place
-voxel source and density maps in the same physical coordinates; the default
-is version 8. A constructor's `simind_version` overrides `SIMIND_VERSION`.
+SIMIND v8 is the supported engine. A constructor's `simind_version` overrides
+`SIMIND_VERSION`; v9 selection is experimental. See
+[installation](docs/installation.rst).
 
 Use the installed connector directly:
 
@@ -96,7 +93,7 @@ import numpy as np
 from simind_python_connector import SimindPythonConnector, configs
 
 connector = SimindPythonConnector(
-    configs.get("Example.yaml"), "output/basic", "case01", simind_version=9
+    configs.get("Example.yaml"), "output/basic", "case01", simind_version=8
 )
 source = np.zeros((32, 32, 32), dtype=np.float32)
 source[12:20, 12:20, 12:20] = 1
@@ -107,42 +104,26 @@ outputs = connector.run()
 print(outputs["tot_w1"].projection.shape)
 ```
 
-Run a complete core simulation example from a source checkout:
-
-```bash
-python examples/getting_started/plot_01_basic_simulation.py
-```
-
 The core connector does not require STIR, SIRF, or PyTomography. Install only
-the optional backend used by your workflow; see
-[installation](docs/installation.rst). The NEMA examples need the optional
-phantomgen package; the install command is in the tutorial.
+the optional backend your workflow uses; the NEMA examples also need
+phantomgen. See [installation](docs/installation.rst) and the tutorial.
 
 ## Example map
 
-- `examples/getting_started/plot_01`–`plot_06`: core NumPy simulations, windows, configurations, scoring,
-  and density conversion.
-- `examples/backends/plot_07a` / `07b` / `07c`: STIR / SIRF / PyTomography adaptors.
-- `examples/backends/plot_08a` / `08b` / `08c`: DICOM setup for STIR / SIRF / PyTomography.
-- `examples/phantoms/plot_09` / `plot_10`: the SIMIND analytic phantom library,
-  and a known-activity NEMA/IEC simulation reconstructed with SIRF OSEM.
-- `examples/mc_scatter/plot_11`–`plot_13`: Monte Carlo scatter in SIRF OSEM,
-  scatter normalisation, and residual correction.
-- `examples/cil/plot_14` / `plot_15`: CIL scatter correction, and an
-  RDP-regularised SVRG reconstruction.
-- `examples/real_data/plot_16a` / `16b` / `16c`: CT-to-SPECT conversion with
-  STIR / SIRF / PyTomography for the measured Y-90 phantom.
-- `examples/real_data/plot_17`: the Y-90 effective attenuation energy with SIRF.
-
-The real-data pages are rendered case studies on restricted Y-90 input, not
-reproducible tutorials. See [datasets](docs/datasets.rst) for the availability
-statement.
-
-Lower `quantization_scale`, fewer projections, or a mostly-zero source map can
-make smoke runs faster. These settings reduce history statistics; they do not
-set projection counts. For quantitative output, use known activity and
-acquisition time or normalise against a measured or analytic reference. Keep
-`NN >= 1`.
+- `examples/getting_started/` and `examples/phantoms/`: core simulations,
+  windows, configurations, scoring, density conversion and phantoms.
+- `examples/backends/`: STIR, SIRF and PyTomography adaptors, plus the DICOM
+  projection recipe in `docs/example_pages/dicom_recipe.rst`.
+- `examples/mc_scatter/` and `examples/cil/`: Monte Carlo scatter and
+  residual correction, including CIL.
+- `examples/real_data/` and `docs/example_pages/y90_*.rst`: restricted Y-90
+  CT conversion and effective attenuation energy, from data that are not
+  redistributed; see [datasets](docs/datasets.rst).
+
+Lower `quantization_scale`, fewer projections, or a mostly-zero source map make
+smoke runs faster without changing projection counts. For quantitative output,
+use known activity and acquisition time or normalise against a measured or
+analytic reference. Keep `NN >= 1`.
 
 ## License
 

{simind_python_connector-2.0.1.dist-info → simind_python_connector-2.0.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-simind_python_connector/__init__.py,sha256=Byn5tXEI9VX7TGkMKvxJ0wbkDxeXtj8hgijKtJLLNsk,1730
+simind_python_connector/__init__.py,sha256=ISwXiFuVtdtlhjmW38_xOGAXKqmByMDxAEGdTYKmzFs,1730
 simind_python_connector/datasets.py,sha256=sOocwL2sHvjn03qaYEZXk--r9Nr92G8bWBVWMUIgSxc,2228
 simind_python_connector/normalisation.py,sha256=9cLibos1BYCTUSuanHVUTmzjaqP9N0lL-Of8Y7GEpB0,3527
 simind_python_connector/phantoms.py,sha256=IU12ET2bPzMtLo3LNXVl98HQHkIXgyNFtGnQ8JlXr0E,13513
@@ -15,7 +15,7 @@ simind_python_connector/configs/input.smc,sha256=oAY2JpwS6IBWZxM-rHdtqWNF4shrZTQ
 simind_python_connector/connectors/__init__.py,sha256=_pw86l4iOGONER1JJvKHFafj6bXBzHwSzo_D1GHSLkM,959
 simind_python_connector/connectors/_native_adaptor.py,sha256=TgQCInvYWcSKXaXyIZrAdUlauVi8BZl0ChT5JbzlVWc,19685
 simind_python_connector/connectors/base.py,sha256=XGGF7W7b5mr3yb2efTDOqvXXc6b8Y35KVhAMGHScLBI,1249
-simind_python_connector/connectors/python_connector.py,sha256=0bBPk-fPiV8wWEQ08c8XqRmAo4vSqd7qU_0NuzcWBgQ,58790
+simind_python_connector/connectors/python_connector.py,sha256=Bi63nkmOphI_yEexmtK_bjKV6n04ZuImbinyhKoNhv8,58817
 simind_python_connector/connectors/pytomography_adaptor.py,sha256=L-v5wk3904svETRbg53oWpC28tyRLruGWODlZR50ytE,13521
 simind_python_connector/connectors/sirf_adaptor.py,sha256=xgAcbLtKTsDBzZPZdmnv_xYEZ4WRtQiH5ua7FBnSR8E,1274
 simind_python_connector/connectors/stir_adaptor.py,sha256=umvI8z8i0ims82-o2rvmFH4SfKGVFxaHn9cHOra5eOw,1439
@@ -32,16 +32,17 @@ simind_python_connector/data/bone.atn,sha256=ROadKIOQPqJ7HGAxl43UnN_YjZ8keyTIV8H
 simind_python_connector/data/h2o.atn,sha256=UplHE9XSSxcsx_cji-5ZtRXcYQYgeyVMzAp_FMOS3cg,1860
 simind_python_connector/recon/__init__.py,sha256=T5TnLOsAbrWv6GNcwrARKJLswAl3KzwVAkkVU-JvF3U,1010
 simind_python_connector/recon/cil.py,sha256=TuemfbLBTUYj1v-odl1RXOCnGCIozyp2lxFnfOsoJ5w,7000
-simind_python_connector/recon/corrections.py,sha256=8qHvFqGSdG4npafC0OLTogUHpY51svW07c6eaJBYscQ,5518
+simind_python_connector/recon/corrections.py,sha256=B_QgDPFqWbwqsY77OQwiKN5HHHGflhpf7YczuFT3HAM,7813
 simind_python_connector/recon/diagnostics.py,sha256=BbTavxVEP2U7yA5zCuDonnqA92RarO_4L1gUt4gykN4,1588
-simind_python_connector/recon/osem.py,sha256=GRBcUUdBacGiUyDiEyeEbK0k7A955YeGOG5xUpGXxiM,2385
+simind_python_connector/recon/osem.py,sha256=LGCXWW2OtczOAws2U53sd_OIeWzLVa03MQZg5OvQcDo,2676
 simind_python_connector/recon/projector.py,sha256=emCDxcciKL4a96e5Lgd9g3U4g5cvWb3hWygpGEWcHa8,4960
 simind_python_connector/recon/updates.py,sha256=IeseWjD052Jt5G312gyMPnkkG2PQaZMGonA2ymzJ6_M,2914
 simind_python_connector/utils/__init__.py,sha256=lcqGs6Fg36If1zyeUph0vMC_bQCwbFJFRw76RGcAio8,2112
 simind_python_connector/utils/interfile.py,sha256=toasBMC63qRh6HkSgmUQWrCvcYUyZK2tUf4WAqtdIkI,24665
+simind_python_connector/utils/projection_metrics.py,sha256=xzVXJ_KweIGUwsjfeke2S_27W1L3VCt5qVtqB_9ZXZ8,5786
 simind_python_connector/utils/simind_utils.py,sha256=cIfpF5LQdFLZAWsqso0mYLGBPkIUB3H9YQdgt9UDb-o,3815
-simind_python_connector-2.0.1.dist-info/licenses/LICENSE,sha256=cCWAxo3f4AsMBTc9HmCzz4RiWcEW1m5hsTXSlMzKikE,10874
-simind_python_connector-2.0.1.dist-info/METADATA,sha256=grEm5DnnaUmeNMbLAKIzGSHbkxnt9pq1ZFALLIO0Qe4,6535
-simind_python_connector-2.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-simind_python_connector-2.0.1.dist-info/top_level.txt,sha256=9JxsbTd91-eq8ppiYYspHX1tpNz1Mk81LC9pJ53SkWA,24
-simind_python_connector-2.0.1.dist-info/RECORD,,
+simind_python_connector-2.0.2.dist-info/licenses/LICENSE,sha256=cCWAxo3f4AsMBTc9HmCzz4RiWcEW1m5hsTXSlMzKikE,10874
+simind_python_connector-2.0.2.dist-info/METADATA,sha256=BHvC9nSM-10jtGkQ6W23kNbK9ZQ4tcRjmzBtjzYQcWc,5449
+simind_python_connector-2.0.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+simind_python_connector-2.0.2.dist-info/top_level.txt,sha256=9JxsbTd91-eq8ppiYYspHX1tpNz1Mk81LC9pJ53SkWA,24
+simind_python_connector-2.0.2.dist-info/RECORD,,