mergeron 2025.739265.0__tar.gz → 2025.739290.0__tar.gz

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mergeron
-Version: 2025.739265.0
+Version: 2025.739290.0
 Summary: Analyze merger enforcement policy using Python
 License: MIT
 Keywords: merger policy analysis,merger guidelines,merger screening,policy presumptions,concentration standards,upward pricing pressure,GUPPI
@@ -30,6 +30,7 @@ Requires-Dist: matplotlib (>=3.8)
 Requires-Dist: mpmath (>=1.3)
 Requires-Dist: msgpack (>=1.0)
 Requires-Dist: msgpack-numpy (>=0.4)
+Requires-Dist: ruamel-yaml (>=0.18.10,<0.19.0)
 Requires-Dist: scipy (>=1.12)
 Requires-Dist: sympy (>=1.12)
 Requires-Dist: tables (>=3.10.1)

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/pyproject.toml

@@ -13,7 +13,7 @@ keywords = [
     "upward pricing pressure",
     "GUPPI",
 ]
-version = "2025.739265.0"
+version = "2025.739290.0"
 
 # Classifiers list: https://pypi.org/classifiers/
 classifiers = [
@@ -57,10 +57,12 @@ certifi = ">=2023.11.17"
 types-beautifulsoup4 = ">=4.11.2"
 xlrd = "^2.0.1"                   # Needed to read margin data
 urllib3 = "^2.2.2"
+ruamel-yaml = "^0.18.10"
 
 
 [tool.poetry.group.dev.dependencies]
 icecream = ">=2.1.0"
+jinja2 = ">=3.1.5"
 mypy = ">=1.8"
 openpyxl = ">=3.1.2"
 pendulum = ">=3.0.0"
@@ -74,8 +76,7 @@ sphinx-autoapi = ">=3.0"
 sphinx-immaterial = ">=0.11"
 pipdeptree = ">=2.15.1"
 types-openpyxl = ">=3.0.0"
-pyright = "^1.1.380"
-
+virtualenv = ">=20.28.0"
 [tool.ruff]
 
 # Exclude a variety of commonly ignored directories.

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/__init__.py

@@ -1,18 +1,25 @@
 from __future__ import annotations
 
 import enum
+from multiprocessing import cpu_count
 from pathlib import Path
 from typing import Literal
 
 import numpy as np
 from numpy.typing import NDArray
+from ruamel import yaml
 
 _PKG_NAME: str = Path(__file__).parent.stem
 
-VERSION = "2025.739265.0"
+VERSION = "2025.739290.0"
 
 __version__ = VERSION
 
+this_yaml = yaml.YAML(typ="safe", pure=True)
+this_yaml.constructor.deep_construct = True
+this_yaml.indent(mapping=2, sequence=4, offset=2)
+
+
 DATA_DIR: Path = Path.home() / _PKG_NAME
 """
 Defines a subdirectory named for this package in the user's home path.
@@ -22,6 +29,13 @@ If the subdirectory doesn't exist, it is created on package invocation.
 if not DATA_DIR.is_dir():
     DATA_DIR.mkdir(parents=False)
 
+DEFAULT_REC_RATIO = 0.85
+
+EMPTY_ARRAYDOUBLE = np.array([], float)
+EMPTY_ARRAYINT = np.array([], int)
+
+NTHREADS = 2 * cpu_count()
+
 np.set_printoptions(precision=24, floatmode="fixed")
 
 type HMGPubYear = Literal[1982, 1984, 1992, 2010, 2023]
@@ -33,7 +47,24 @@ type ArrayINT = NDArray[np.intp]
 type ArrayDouble = NDArray[np.float64]
 type ArrayBIGINT = NDArray[np.int64]
 
-DEFAULT_REC_RATIO = 0.85
+## Add yaml representer, constructor for NoneType
+(_, _) = (
+    this_yaml.representer.add_representer(
+        type(None), lambda _r, _d: _r.represent_scalar("!None", "none")
+    ),
+    this_yaml.constructor.add_constructor("!None", lambda _c, _n, /: None),
+)
+
+## Add yaml representer, constructor for ndarray
+(_, _) = (
+    this_yaml.representer.add_representer(
+        np.ndarray,
+        lambda _r, _d: _r.represent_sequence("!ndarray", (_d.tolist(), _d.dtype.str)),
+    ),
+    this_yaml.constructor.add_constructor(
+        "!ndarray", lambda _c, _n, /: np.array(*_c.construct_sequence(_n))
+    ),
+)
 
 
 @enum.unique
@@ -63,3 +94,21 @@ class UPPAggrSelector(enum.StrEnum):
     OSA = "own-share weighted average"
     OSD = "own-share weighted distance"
     OSG = "own-share weighted geometric mean"
+
+
+for _typ in (RECForm, UPPAggrSelector):
+    #  NOTE: If additional enums are defined in this module,
+    #  add themn to the list above
+
+    _, _ = (
+        this_yaml.representer.add_representer(
+            _typ,
+            lambda _r, _d: _r.represent_scalar(f"!{_d.__class__.__name__}", _d.name),
+        ),
+        this_yaml.constructor.add_constructor(
+            f"!{_typ.__name__}",
+            lambda _c, _n, /: getattr(
+                globals().get(_n.tag.lstrip("!")), _c.construct_scalar(_n)
+            ),
+        ),
+    )

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/__init__.py

@@ -4,5 +4,5 @@ from .. import VERSION  # noqa: TID252
 
 __version__ = VERSION
 
-type MPFloat = mp.mpf  # pyright: ignore
-type MPMatrix = mp.matrix  # pyright: ignore
+type MPFloat = mp.mpf  # type: ignore
+type MPMatrix = mp.matrix  # type: ignore

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/empirical_margin_distribution.py

@@ -132,7 +132,7 @@ def mgn_data_getter(  # noqa: PLR0912
         _xl_row[1] = int(_xl_row[1])
         _mgn_dict[_xl_row[0]] = dict(zip(_mgn_row_keys[1:], _xl_row[1:], strict=True))
 
-    _ = _data_archive_path.write_bytes(msgpack.packb(_mgn_dict))  # pyright: ignore
+    _ = _data_archive_path.write_bytes(msgpack.packb(_mgn_dict))
 
     return MappingProxyType(_mgn_dict)
 
@@ -221,7 +221,7 @@ def mgn_data_resampler(
     _x, _w, _ = mgn_data_builder(mgn_data_getter())
 
     _mgn_kde = stats.gaussian_kde(_x, weights=_w, bw_method="silverman")
-    _mgn_kde.set_bandwidth(bw_method=_mgn_kde.factor / 3.0)  # pyright: ignore
+    _mgn_kde.set_bandwidth(bw_method=_mgn_kde.factor / 3.0)
 
     if isinstance(_sample_size, int):
         return np.array(

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/ftc_merger_investigations_data.py

@@ -198,7 +198,7 @@ def construct_data(
                 )
             }
 
-    _ = INVDATA_ARCHIVE_PATH.write_bytes(msgpack.packb(_invdata))  # pyright: ignore
+    _ = INVDATA_ARCHIVE_PATH.write_bytes(msgpack.packb(_invdata))
 
     return MappingProxyType(_invdata)
 

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/guidelines_boundaries.py

@@ -62,7 +62,7 @@ class GuidelinesThresholds:
     Year of publication of the Guidelines
     """
 
-    safeharbor: HMGThresholds = field(kw_only=True, default=None)
+    safeharbor: HMGThresholds = field(kw_only=True, default=None, init=False)
     """
     Negative presumption quantified on various measures
 
@@ -70,7 +70,7 @@ class GuidelinesThresholds:
     diversion ratio limit, CMCR, and IPR
     """
 
-    presumption: HMGThresholds = field(kw_only=True, default=None)
+    presumption: HMGThresholds = field(kw_only=True, default=None, init=False)
     """
     Presumption of harm defined in HMG
 
@@ -78,7 +78,7 @@ class GuidelinesThresholds:
     diversion ratio limit, CMCR, and IPR
     """
 
-    imputed_presumption: HMGThresholds = field(kw_only=True, default=None)
+    imputed_presumption: HMGThresholds = field(kw_only=True, default=None, init=False)
     """
     Presumption of harm imputed from guidelines
 
@@ -153,25 +153,28 @@ class ConcentrationBoundary:
     """Concentration parameters, boundary coordinates, and area under concentration boundary."""
 
     measure_name: Literal[
-        "ΔHHI", "Combined share", "Pre-merger HHI", "Post-merger HHI"
+        "ΔHHI",
+        "Combined share",
+        "Pre-merger HHI Contribution",
+        "Post-merger HHI Contribution",
     ] = field(kw_only=False, default="ΔHHI")
 
-    @measure_name.validator  # pyright: ignore
-    def __mnv(
+    @measure_name.validator
+    def _mnv(
         _instance: ConcentrationBoundary, _attribute: Attribute[str], _value: str, /
     ) -> None:
         if _value not in (
             "ΔHHI",
             "Combined share",
-            "Pre-merger HHI",
-            "Post-merger HHI",
+            "Pre-merger HHI Contribution",
+            "Post-merger HHI Contribution",
         ):
             raise ValueError(f"Invalid name for a concentration measure, {_value!r}.")
 
     threshold: float = field(kw_only=False, default=0.01)
 
-    @threshold.validator  # pyright: ignore
-    def __tv(
+    @threshold.validator
+    def _tv(
         _instance: ConcentrationBoundary, _attribute: Attribute[float], _value: float, /
     ) -> None:
         if not 0 <= _value <= 1:
@@ -193,9 +196,9 @@ class ConcentrationBoundary:
                 _conc_fn = gbfn.hhi_delta_boundary
             case "Combined share":
                 _conc_fn = gbfn.combined_share_boundary
-            case "Pre-merger HHI":
+            case "Pre-merger HHI Contribution":
                 _conc_fn = gbfn.hhi_pre_contrib_boundary
-            case "Post-merger HHI":
+            case "Post-merger HHI Contribution":
                 _conc_fn = gbfn.hhi_post_contrib_boundary
 
         _boundary = _conc_fn(self.threshold, dps=self.precision)
@@ -221,13 +224,13 @@ class DiversionRatioBoundary:
     diversion_ratio: float = field(kw_only=False, default=0.065)
 
     @diversion_ratio.validator
-    def __dvv(
+    def _dvv(
         _instance: DiversionRatioBoundary,
         _attribute: Attribute[float],
         _value: float,
         /,
     ) -> None:
-        if not (isinstance(_value, float) and 0 <= _value <= 1):
+        if not (isinstance(_value, decimal.Decimal | float) and 0 <= _value <= 1):
             raise ValueError(
                 "Margin-adjusted benchmark share ratio must lie between 0 and 1."
             )
@@ -260,7 +263,7 @@ class DiversionRatioBoundary:
     """
 
     @recapture_form.validator
-    def __rsv(
+    def _rsv(
         _instance: DiversionRatioBoundary,
         _attribute: Attribute[RECForm],
         _value: RECForm,

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/guidelines_boundary_functions.py

@@ -909,7 +909,7 @@ def lerp[LerpT: (float, MPFloat, ArrayDouble, ArrayBIGINT)](
     elif _r == 1:
         return _x2
     else:
-        return _r * _x2 + (1 - _r) * _x1  # pyright: ignore
+        return _r * _x2 + (1 - _r) * _x1
 
 
 def round_cust(

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/guidelines_boundary_functions_extra.py

@@ -91,7 +91,7 @@ def hhi_delta_boundary_qdtr(_dh_val: float = 0.01, /) -> GuidelinesBoundaryCalla
 
     _hhi_bdry_area = 2 * (
         _s_nought
-        + mp.quad(lambdify(_s_1, _hhi_bdry, "mpmath"), (_s_nought, 1 - _s_nought))  # pyright: ignore
+        + mp.quad(lambdify(_s_1, _hhi_bdry, "mpmath"), (_s_nought, 1 - _s_nought))
     )
 
     return GuidelinesBoundaryCallable(
@@ -159,7 +159,7 @@ def shrratio_boundary_qdtr_wtd_avg(
                 2
                 * (
                     _s_naught
-                    + mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (_s_naught, _s_mid))  # pyright: ignore
+                    + mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (_s_naught, _s_mid))
                 )
                 - (_s_mid**2 + _s_naught**2)
             )
@@ -189,7 +189,7 @@ def shrratio_boundary_qdtr_wtd_avg(
                         ),
                         (0, _s_mid),
                     )
-                ).real  # pyright: ignore
+                ).real
                 - _s_mid**2
             )
 
@@ -209,7 +209,7 @@ def shrratio_boundary_qdtr_wtd_avg(
 
             _bdry_func = solve(_bdry_eqn, _s_2)[0]
             _bdry_area = float(
-                2 * (mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (0, _s_mid)))  # pyright: ignore
+                2 * (mp.quad(lambdify(_s_1, _bdry_func, "mpmath"), (0, _s_mid)))
                 - _s_mid**2
             )
 

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/core/pseudorandom_numbers.py

@@ -6,20 +6,38 @@ https://github.com/numpy/numpy/issues/16313.
 
 """
 
+from __future__ import annotations
+
 import concurrent.futures
 from collections.abc import Sequence
-from multiprocessing import cpu_count
 from typing import Literal
 
 import numpy as np
+from attrs import Attribute, Converter, define, field
 from numpy.random import PCG64DXSM, Generator, SeedSequence
 
-from .. import VERSION, ArrayDouble  # noqa: TID252
+from .. import NTHREADS, VERSION, ArrayDouble, ArrayFloat, this_yaml  # noqa: TID252
 
 __version__ = VERSION
 
-NTHREADS = 2 * cpu_count()
-DEFAULT_DIST_PARMS = np.array([0.0, 1.0], np.float64)
+DEFAULT_DIST_PARMS: ArrayFloat = np.array([0.0, 1.0], float)
+DEFAULT_BETA_DIST_PARMS: ArrayFloat = np.array([1.0, 1.0], float)
+
+
+# Add yaml representer, constructor for SeedSequence
+this_yaml.representer.add_representer(
+    SeedSequence,
+    lambda _r, _d: _r.represent_mapping(
+        "!SeedSequence",
+        {
+            _a: getattr(_d, _a)
+            for _a in ("entropy", "spawn_key", "pool_size", "n_children_spawned")
+        },
+    ),
+)
+this_yaml.constructor.add_constructor(
+    "!SeedSequence", lambda _c, _n, /: SeedSequence(**_c.construct_mapping(_n))
+)
 
 
 def prng(_s: SeedSequence | None = None, /) -> np.random.Generator:
@@ -106,6 +124,21 @@ def gen_seed_seq_list_default(
     return [SeedSequence(_s, pool_size=8) for _s in generated_entropy[:_sseq_list_len]]
 
 
+def _dist_parms_conv(_v: ArrayFloat, _i: MultithreadedRNG) -> ArrayFloat:
+    if not len(_v):
+        return {
+            "Beta": DEFAULT_BETA_DIST_PARMS,
+            "Dirichlet": np.ones(_i.values.shape[-1], float),
+        }.get(_i.dist_type, DEFAULT_DIST_PARMS)
+    elif isinstance(_v, Sequence | np.ndarray):
+        return np.asarray(_v, float)
+    else:
+        raise ValueError(
+            "Input, {_v!r} has invalid type. Must be None, Sequence of floats, or Numpy ndarray."
+        )
+
+
+@define
 class MultithreadedRNG:
     """Fill given array on demand with pseudo-random numbers as specified.
 
@@ -114,98 +147,105 @@ class MultithreadedRNG:
     If a seed sequence is provided, it is used in a thread-safe way
     to generate repeatable i.i.d. draws. All arguments are validated
     before commencing multithreaded random number generation.
+    """
 
-    Parameters
-    ----------
-    __out_array
-        The output array to which generated data are written.
-        Its dimensions define the size of the sample.
-    dist_type
-        Distribution for the generated random numbers
-    dist_parms
-        Parameters, if any, for tailoring random number generation
-    seed_sequence
-        SeedSequence object for generating repeatable draws.
-    nthreads
-        Number of threads to spawn for random number generation.
+    values: ArrayDouble = field(kw_only=False)
+    """Output array to which generated data are over-written
 
+    Array-length defines the number of i.i.d. (vector) draws.
     """
 
-    def __init__(
-        self,
-        __out_array: ArrayDouble,
+    @values.validator
+    def _vsv(
+        _instance: MultithreadedRNG,
+        _attribute: Attribute[ArrayDouble],
+        _value: ArrayDouble,
         /,
-        *,
-        dist_type: Literal[
-            "Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform"
-        ] = "Uniform",
-        dist_parms: ArrayDouble | None = DEFAULT_DIST_PARMS,
-        seed_sequence: SeedSequence | None = None,
-        nthreads: int = NTHREADS,
-    ):
-        self.thread_count = nthreads
-
-        __seed_sequence = seed_sequence or SeedSequence(pool_size=8)
-        self._random_generators = [
-            prng(_t) for _t in __seed_sequence.spawn(self.thread_count)
-        ]
-
-        self.sample_sz = len(__out_array)
-
-        if dist_type not in (_rdts := ("Beta", "Dirichlet", "Normal", "Uniform")):
-            raise ValueError("Specified distribution must be one of {_rdts}")
-
-        if not (dist_parms is None or isinstance(dist_parms, Sequence | np.ndarray)):
-            raise ValueError(
-                "When specified, distribution parameters must be a list, tuple or Numpy array"
-            )
-            if isinstance(dist_parms, Sequence):
-                dist_parms = np.array(dist_parms)
-            elif not dist_parms.any():
-                dist_parms = None
-
-        self.dist_type = dist_type
-
-        if dist_parms is None or np.array_equal(dist_parms, DEFAULT_DIST_PARMS):
-            match dist_type:
-                case "Uniform":
-                    self.dist_type = "Random"
-                case "Normal":
-                    self.dist_type = "Gaussian"
-                case "Beta" | "Dirichlet":
-                    raise ValueError(
-                        f"parameter specification, {f'"{dist_parms}"'} "
-                        f"is invalid for specified distribution, f{'"{dist_type}"'}."
-                    )
-                case _:
-                    raise ValueError(
-                        f"Invalid distributions specified, {f'"{dist_type}"'}."
-                    )
-
-        elif dist_type == "Dirichlet":
-            if len(dist_parms) != __out_array.shape[1]:
-                raise ValueError(
-                    f"Insufficient shape parameters for requested Dirichlet sample "
-                    f"of size, {__out_array.shape}"
-                )
+    ) -> None:
+        if not len(_value):
+            raise ValueError("Output array must at least be one dimension")
+
+    dist_type: Literal[
+        "Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform"
+    ] = field(default="Uniform")
+    """Distribution for the generated random numbers.
+
+    Default is "Uniform".
+     """
+
+    @dist_type.validator
+    def _dtv(
+        _instance: MultithreadedRNG, _attribute: Attribute[str], _value: str, /
+    ) -> None:
+        if _value not in (
+            _rdts := ("Beta", "Dirichlet", "Gaussian", "Normal", "Random", "Uniform")
+        ):
+            raise ValueError(f"Specified distribution must be one of {_rdts}")
+
+    dist_parms: ArrayFloat = field(
+        converter=Converter(_dist_parms_conv, takes_self=True)  # type: ignore
+    )
+    """Parameters, if any, for tailoring random number generation
+    """
 
-        elif (_lrdp := len(dist_parms)) != 2:
-            raise ValueError(f"Expected 2 parameters, got, {_lrdp}")
+    @dist_parms.default
+    def _dpd(_instance: MultithreadedRNG) -> ArrayFloat:
+        return {
+            "Beta": DEFAULT_BETA_DIST_PARMS,
+            "Dirichlet": np.ones(_instance.values.shape[-1], float),
+        }.get(_instance.dist_type, DEFAULT_DIST_PARMS)
+
+    @dist_parms.validator
+    def _dpv(
+        _instance: MultithreadedRNG,
+        _attribute: Attribute[ArrayFloat],
+        _value: ArrayFloat,
+        /,
+    ) -> None:
+        if (
+            _instance.dist_type != "Dirichlet"
+            and (_lrdp := len(_value)) != (_trdp := 2)
+        ) or (
+            _instance.dist_type == "Dirichlet"
+            and (_lrdp := len(_value)) != (_trdp := _instance.values.shape[1])
+        ):
+            raise ValueError(f"Expected {_trdp} parameters, got, {_lrdp}")
 
-        self.dist_parms = dist_parms
+        elif _instance.dist_type in ("Beta", "Dirichlet") and (_value <= 0.0).any():
+            raise ValueError("Shape and location parameters must be strictly positive")
 
-        self.values = __out_array
-        self.executor = concurrent.futures.ThreadPoolExecutor(self.thread_count)
+    seed_sequence: SeedSequence | None = field(default=None)
+    """Seed sequence for generating random numbers."""
 
-        self.step_size = (len(self.values) / self.thread_count).__ceil__()
+    nthreads: int = field(default=NTHREADS)
+    """Number of threads to spawn for random number generation."""
 
     def fill(self) -> None:
-        """Fill the provided output array with random numbers as specified."""
+        """Fill the provided output array with random number draws as specified."""
+
+        if not len(self.dist_parms) or np.array_equal(
+            self.dist_parms, DEFAULT_DIST_PARMS
+        ):
+            if self.dist_type == "Uniform":
+                _dist_type = "Random"
+            elif self.dist_type == "Normal":
+                _dist_type = "Gaussian"
+        else:
+            _dist_type = self.dist_type
+
+        _step_size = (len(self.values) / self.nthreads).__ceil__()
+        # int; function gives float unsuitable for slicing
+
+        _seed_sequence = self.seed_sequence or SeedSequence(pool_size=8)
+
+        _random_generators = tuple(
+            prng(_t) for _t in _seed_sequence.spawn(self.nthreads)
+        )
 
         def _fill(
             _rng: np.random.Generator,
             _dist_type: str,
-            _dist_parms: ArrayDouble,
+            _dist_parms: ArrayFloat,
             _out: ArrayDouble,
             _first: int,
             _last: int,
@@ -213,37 +253,35 @@ class MultithreadedRNG:
         ) -> None:
             _sz: tuple[int, ...] = _out[_first:_last].shape
             match _dist_type:
-                case "Random":
-                    _rng.random(out=_out[_first:_last])
-                case "Uniform":
-                    _uni_l, _uni_h = _dist_parms
-                    _out[_first:_last] = _rng.uniform(_uni_l, _uni_h, size=_sz)
-                case "Dirichlet":
-                    _out[_first:_last] = _rng.dirichlet(_dist_parms, size=_sz[:-1])
                 case "Beta":
                     _shape_a, _shape_b = _dist_parms
                     _out[_first:_last] = _rng.beta(_shape_a, _shape_b, size=_sz)
+                case "Dirichlet":
+                    _out[_first:_last] = _rng.dirichlet(_dist_parms, size=_sz[:-1])
+                case "Gaussian":
+                    _rng.standard_normal(out=_out[_first:_last])
                 case "Normal":
                     _mu, _sigma = _dist_parms
                     _out[_first:_last] = _rng.normal(_mu, _sigma, size=_sz)
+                case "Random":
+                    _rng.random(out=_out[_first:_last])
+                case "Uniform":
+                    _uni_l, _uni_h = _dist_parms
+                    _out[_first:_last] = _rng.uniform(_uni_l, _uni_h, size=_sz)
                 case _:
-                    _rng.standard_normal(out=_out[_first:_last])
-
-        futures = {}
-        for i in range(self.thread_count):
-            _range_first = i * self.step_size
-            _range_last = min(len(self.values), (i + 1) * self.step_size)
-            args = (
-                _fill,
-                self._random_generators[i],
-                self.dist_type,
-                self.dist_parms,
-                self.values,
-                _range_first,
-                _range_last,
-            )
-            futures[self.executor.submit(*args)] = i  # type: ignore
-        concurrent.futures.wait(futures)
-
-    def __del__(self) -> None:
-        self.executor.shutdown(False)
+                    "Unreachable. The validator would have rejected this as invalid."
+
+        with concurrent.futures.ThreadPoolExecutor(self.nthreads) as _executor:
+            for i in range(self.nthreads):
+                _range_first = i * _step_size
+                _range_last = min(len(self.values), (i + 1) * _step_size)
+
+                _executor.submit(
+                    _fill,
+                    _random_generators[i],
+                    _dist_type,
+                    self.dist_parms,
+                    self.values,
+                    _range_first,
+                    _range_last,
+                )

{mergeron-2025.739265.0 → mergeron-2025.739290.0}/src/mergeron/demo/visualize_empirical_margin_distribution.py

@@ -45,7 +45,7 @@ with warnings.catch_warnings():
     ])
 
 mgn_kde = stats.gaussian_kde(mgn_data_obs, weights=mgn_data_wts, bw_method="silverman")
-mgn_kde.set_bandwidth(bw_method=mgn_kde.factor / 3.0)  # pyright: ignore
+mgn_kde.set_bandwidth(bw_method=mgn_kde.factor / 3.0)
 
 mgn_ax.plot(
     (_xv := np.linspace(0, BIN_COUNT, 10**5) / BIN_COUNT),