mergeron 2024.739127.1__py3-none-any.whl → 2024.739145.0__py3-none-any.whl

mergeron/demo/visualize_empirical_margin_distribution.py

@@ -2,7 +2,6 @@
 Plot the empirical distribution derived using the Gaussian KDE with
 margin data downloaded from Prof. Damodaran's website at NYU.
 
-
 """
 
 import warnings
@@ -13,7 +12,7 @@ from matplotlib.ticker import StrMethodFormatter
 from numpy.random import PCG64DXSM, Generator, SeedSequence
 from scipy import stats  # type: ignore
 
-import mergeron.core.damodaran_margin_data as dmgn
+import mergeron.core.empirical_margin_distribution as dmgn
 from mergeron import DATA_DIR
 from mergeron.core.guidelines_boundary_functions import boundary_plot
 
@@ -46,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)
+mgn_kde.set_bandwidth(bw_method=mgn_kde.factor / 3.0)  # pyright: ignore
 
 mgn_ax.plot(
     (_xv := np.linspace(0, BIN_COUNT, 10**5) / BIN_COUNT),

mergeron/gen/__init__.py

@@ -25,13 +25,13 @@ from .. import (  # noqa: TID252
     RECForm,
     UPPAggrSelector,
 )
-from ..core.pseudorandom_numbers import DIST_PARMS_DEFAULT  # noqa: TID252
+from ..core.pseudorandom_numbers import DEFAULT_DIST_PARMS  # noqa: TID252
 
 __version__ = VERSION
 
 
-EMPTY_ARRAY_DEFAULT = np.zeros(2)
-FCOUNT_WTS_DEFAULT = np.divide(
+DEFAULT_EMPTY_ARRAY = np.zeros(2)
+DEFAULT_FCOUNT_WTS = np.divide(
     (_nr := np.arange(1, 7)[::-1]), _nr.sum(), dtype=np.float64
 )
 
@@ -105,22 +105,42 @@ class ShareSpec:
 
     Notes
     -----
-    If :attr:`mergeron.gen.ShareSpec.dist_type`:code:` == `:attr:`mergeron.gen.SHRDistribution.UNI`,
+    If :attr:`mergeron.gen.ShareSpec.dist_type` == :attr:`mergeron.gen.SHRDistribution.UNI`,
     then it is infeasible that
-    :attr:`mergeron.gen.ShareSpec.recapture_form`:code:` == `:attr:`mergeron.RECForm.OUTIN`.
-    In other words, if firm-counts are unspecified, the recapture rate cannot be
-    estimated using outside good choice probabilities.
+    :attr:`mergeron.gen.ShareSpec.recapture_form` == :attr:`mergeron.RECForm.OUTIN`.
+    In other words, if the distribution of markets over firm-counts is unspecified,
+    recapture ratios cannot be estimated using outside-good choice probabilities.
 
-    For a sample with explicit firm counts, market shares must
-    be specified as having a supported Dirichlet distribution
-    (see :class:`mergeron.gen.SHRDistribution`).
+    For a sample with explicit firm counts, market shares must be specified as
+    having a supported Dirichlet distribution (see :class:`mergeron.gen.SHRDistribution`).
 
     """
 
-    dist_type: SHRDistribution
+    dist_type: SHRDistribution = field(default=SHRDistribution.DIR_FLAT)
     """See :class:`SHRDistribution`"""
 
-    dist_parms: ArrayDouble | None = field(
+    @dist_type.validator  # pyright: ignore
+    def __dtv(
+        _i: ShareSpec, _a: Attribute[SHRDistribution], _v: SHRDistribution
+    ) -> None:
+        if _v == SHRDistribution.UNI:
+            if _i.firm_counts_weights is not None:
+                raise ValueError(
+                    "The specified value is incompatible with "
+                    " :code:`distypte`=:attr`:`SHRDistribution.UNI`. "
+                    "Set value to None or Consider revising the "
+                    r"distribution type to :attr:`SHRDistribution.DIR_FLAT`, which gives "
+                    "uniformly distributed draws on the :math:`n+1` simplex "
+                    "for firm-count, :math:`n`. "
+                    ""
+                )
+            elif _i.recapture_form == RECForm.OUTIN:
+                raise ValueError(
+                    "Market share specification requires estimation of recapture ratio from "
+                    "generated data. Either delete recapture ratio specification or set it to None."
+                )
+
+    dist_parms: ArrayFloat | ArrayINT | None = field(
         default=None, eq=cmp_using(eq=np.array_equal)
     )
     """Parameters for tailoring market-share distribution
@@ -131,49 +151,47 @@ class ShareSpec:
     type of Dirichlet-distribution specified.
 
     """
+
+    @dist_parms.validator  # pyright: ignore
+    def __dpv(
+        _i: ShareSpec,
+        _a: Attribute[ArrayFloat | ArrayINT | None],
+        _v: ArrayFloat | ArrayINT | None,
+    ) -> None:
+        if (
+            _i.firm_counts_weights is not None
+            and _v is not None
+            and len(_v) < 1 + len(_i.firm_counts_weights)
+        ):
+            raise ValueError(
+                "If specified, the number of distribution parameters must be at least "
+                "the maximum firm-count premerger, which is 1 plus the length of the "
+                "vector specifying firm-count weights."
+            )
+
     firm_counts_weights: ArrayFloat | ArrayINT | None = field(
-        default=None, eq=cmp_using(eq=np.array_equal)
+        default=DEFAULT_FCOUNT_WTS, eq=cmp_using(eq=np.array_equal)
     )
     """Relative or absolute frequencies of firm counts
 
     Given frequencies are exogenous to generated market data sample;
-    for Dirichlet-type distributions, defaults to FCOUNT_WTS_DEFAULT, which specifies
+    for Dirichlet-type distributions, defaults to DEFAULT_FCOUNT_WTS, which specifies
     firm-counts of 2 to 6 with weights in descending order from 5 to 1.
 
     """
 
-    @firm_counts_weights.validator
-    def _check_fcw(_i: ShareSpec, _a: Attribute[ArrayDouble], _v: ArrayDouble) -> None:
-        if _v is not None and _i.dist_type == SHRDistribution.UNI:
-            raise ValueError(
-                "Generated data for markets with specified firm-counts or "
-                "varying firm counts are not feasible for market shares "
-                "with Uniform distribution. Consider revising the "
-                r"distribution type to {SHRDistribution.DIR_FLAT}, which gives "
-                "uniformly distributed draws on the :math:`n+1` simplex "
-                "for firm-count, :math:`n`."
-            )
-
     recapture_form: RECForm = field(default=RECForm.INOUT)
     """See :class:`mergeron.RECForm`"""
 
-    @recapture_form.validator
-    def _check_rf(_i: ShareSpec, _a: Attribute[RECForm], _v: RECForm) -> None:
-        if _v == RECForm.OUTIN and _i.dist_type == SHRDistribution.UNI:
-            raise ValueError(
-                "Market share specification requires estimation of recapture rate from "
-                "generated data. Either delete recapture rate specification or set it to None."
-            )
-
-    recapture_rate: float | None = field(default=DEFAULT_REC_RATE)
+    recapture_ratio: float | None = field(default=DEFAULT_REC_RATE)
     """A value between 0 and 1.
 
     :code:`None` if market share specification requires direct generation of
     outside good choice probabilities (:attr:`mergeron.RECForm.OUTIN`).
 
-    The recapture rate is usually calibrated to the numbers-equivalent of the
+    The recapture ratio is usually calibrated to the numbers-equivalent of the
     HHI threshold for the presumtion of harm from unilateral competitive effects
-    in published merger guidelines. Accordingly, the recapture rate rounded to
+    in published merger guidelines. Accordingly, the recapture ratio rounded to
     the nearest 5% is:
 
     * 0.85, **7-to-6 merger from symmetry**; US Guidelines, 1992, 2023
@@ -188,14 +206,14 @@ class ShareSpec:
 
     """
 
-    @recapture_rate.validator
-    def _check_rr(_i: ShareSpec, _a: Attribute[float], _v: float) -> None:
+    @recapture_ratio.validator  # pyright: ignore
+    def __rrv(_i: ShareSpec, _a: Attribute[float], _v: float) -> None:
         if _v and not (0 < _v <= 1):
-            raise ValueError("Recapture rate must lie in the interval, [0, 1).")
+            raise ValueError("Recapture ratio must lie in the interval, [0, 1).")
         elif _v is None and _i.recapture_form != RECForm.OUTIN:
             raise ValueError(
                 f"Recapture specification, {_i.recapture_form!r} requires that "
-                "the market sample specification inclues a recapture rate in the "
+                "the market sample specification inclues a recapture ratio in the "
                 "interval [0, 1)."
             )
 
@@ -248,16 +266,16 @@ class PCMSpec:
 
     """
 
-    @dist_parms.validator
-    def _check_dp(
+    @dist_parms.validator  # pyright: ignore
+    def __dpv(
         _i: PCMSpec, _a: Attribute[ArrayDouble | None], _v: ArrayDouble | None
     ) -> None:
         if _i.dist_type.name.startswith("BETA"):
             if _v is None:
                 pass
-            elif np.array_equal(_v, DIST_PARMS_DEFAULT):
+            elif np.array_equal(_v, DEFAULT_DIST_PARMS):
                 raise ValueError(
-                    f"The distribution parameters, {DIST_PARMS_DEFAULT!r} "
+                    f"The distribution parameters, {DEFAULT_DIST_PARMS!r} "
                     "are not valid with margin distribution, {_dist_type_pcm!r}"
                 )
             elif (

mergeron/gen/data_generation.py

@@ -85,8 +85,8 @@ class MarketSample:
     )
     """Margin specification, see :class:`PCMSpec`"""
 
-    @pcm_spec.validator
-    def _check_pcm(self, _a: Attribute[PCMSpec], _v: PCMSpec, /) -> None:
+    @pcm_spec.validator  # pyright: ignore
+    def __psv(self, _a: Attribute[PCMSpec], _v: PCMSpec, /) -> None:
         if (
             self.share_spec.recapture_form == RECForm.FIXED
             and _v.firm2_pcm_constraint == FM2Constraint.MNL
@@ -113,7 +113,7 @@ class MarketSample:
 
     enf_counts: UPPTestsCounts = field(default=None)
 
-    def _gen_market_sample(
+    def __gen_market_sample(
         self,
         /,
         *,
@@ -134,7 +134,7 @@ class MarketSample:
         """
 
         _recapture_form = self.share_spec.recapture_form
-        _recapture_rate = self.share_spec.recapture_rate
+        _recapture_ratio = self.share_spec.recapture_ratio
         _dist_type_mktshr = self.share_spec.dist_type
         _dist_firm2_pcm = self.pcm_spec.firm2_pcm_constraint
         _hsr_filing_test_type = self.hsr_filing_test_type
@@ -208,7 +208,7 @@ class MarketSample:
         # Calculate diversion ratios
         _divr_array = gen_divr_array(
             _recapture_form,
-            _recapture_rate,
+            _recapture_ratio,
             _mktshr_array[:, :2],
             _aggregate_purchase_prob,
         )
@@ -256,7 +256,7 @@ class MarketSample:
 
         """
 
-        self.data = self._gen_market_sample(
+        self.data = self.__gen_market_sample(
             sample_size=sample_size, seed_seq_list=seed_seq_list, nthreads=nthreads
         )
 
@@ -273,14 +273,14 @@ class MarketSample:
             save_data_to_file=save_data_to_file,
         )
 
-    def _sim_enf_cnts(
+    def __sim_enf_cnts(
         self,
         _upp_test_parms: gbl.HMGThresholds,
         _sim_test_regime: UPPTestRegime,
         /,
         *,
         sample_size: int = 10**6,
-        seed_seq_list: list[SeedSequence] | None = None,
+        seed_seq_list: Sequence[SeedSequence] | None = None,
         nthreads: int = 16,
         save_data_to_file: SaveData = False,
         saved_array_name_suffix: str = "",
@@ -320,7 +320,7 @@ class MarketSample:
 
         """
 
-        _market_data_sample = self._gen_market_sample(
+        _market_data_sample = self.__gen_market_sample(
             sample_size=sample_size, seed_seq_list=seed_seq_list, nthreads=nthreads
         )
 
@@ -349,14 +349,14 @@ class MarketSample:
 
         return _upp_test_arrays
 
-    def _sim_enf_cnts_ll(
+    def __sim_enf_cnts_ll(
         self,
         _enf_parm_vec: gbl.HMGThresholds,
         _sim_test_regime: UPPTestRegime,
         /,
         *,
         sample_size: int = 10**6,
-        seed_seq_list: list[SeedSequence] | None = None,
+        seed_seq_list: Sequence[SeedSequence] | None = None,
         nthreads: int = 16,
         save_data_to_file: SaveData = False,
         saved_array_name_suffix: str = "",
@@ -410,11 +410,11 @@ class MarketSample:
 
         if (
             self.share_spec.recapture_form != RECForm.OUTIN
-            and self.share_spec.recapture_rate != _enf_parm_vec.rec
+            and self.share_spec.recapture_ratio != _enf_parm_vec.rec
         ):
             raise ValueError(
                 "{} {} {}".format(
-                    f"Recapture rate from market sample spec, {self.share_spec.recapture_rate}",
+                    f"Recapture ratio from market sample spec, {self.share_spec.recapture_ratio}",
                     f"must match the value, {_enf_parm_vec.rec}",
                     "the guidelines thresholds vector.",
                 )
@@ -433,12 +433,12 @@ class MarketSample:
         })
 
         _res_list = Parallel(n_jobs=_thread_count, prefer="threads")(
-            delayed(self._sim_enf_cnts)(
+            delayed(self.__sim_enf_cnts)(
                 _enf_parm_vec,
                 _sim_test_regime,
                 **_sim_enf_cnts_kwargs,
-                saved_array_name_suffix=f"{saved_array_name_suffix}_{_iter_id:0{2 + int(np.ceil(np.log10(_iter_count)))}d}",
-                seed_seq_list=_rng_seed_seq_list_ch,
+                saved_array_name_suffix=f"{saved_array_name_suffix}_{_iter_id:0{2 + int(np.ceil(np.log10(_iter_count)))}d}",  # pyright: ignore
+                seed_seq_list=_rng_seed_seq_list_ch,  # pyright: ignore
             )
             for _iter_id, _rng_seed_seq_list_ch in enumerate(_rng_seed_seq_list)
         )
@@ -508,7 +508,7 @@ class MarketSample:
         """
 
         if self.data is None:
-            self.enf_counts = self._sim_enf_cnts_ll(
+            self.enf_counts = self.__sim_enf_cnts_ll(
                 _enf_parm_vec,
                 _upp_test_regime,
                 sample_size=sample_size,

mergeron/gen/data_generation_functions.py

@@ -11,22 +11,16 @@ import numpy as np
 from attrs import evolve
 from numpy.random import SeedSequence
 
-from .. import (  # noqa: TID252
-    DEFAULT_REC_RATE,
-    VERSION,
-    ArrayBIGINT,
-    ArrayDouble,
-    RECForm,
-)
-from ..core.damodaran_margin_data import mgn_data_resampler  # noqa: TID252
+from .. import DEFAULT_REC_RATE, VERSION, ArrayDouble, RECForm  # noqa: TID252
+from ..core.empirical_margin_distribution import mgn_data_resampler  # noqa: TID252
 from ..core.pseudorandom_numbers import (  # noqa: TID252
-    DIST_PARMS_DEFAULT,
+    DEFAULT_DIST_PARMS,
     MultithreadedRNG,
     prng,
 )
 from . import (
-    EMPTY_ARRAY_DEFAULT,
-    FCOUNT_WTS_DEFAULT,
+    DEFAULT_EMPTY_ARRAY,
+    DEFAULT_FCOUNT_WTS,
     FM2Constraint,
     MarginDataSample,
     PCMDistribution,
@@ -106,7 +100,7 @@ def gen_share_data(
 
     # If recapture_form == "inside-out", recalculate _aggregate_purchase_prob
     _frmshr_array = _mkt_share_sample.mktshr_array[:, :2]
-    _r_bar = _share_spec.recapture_rate or DEFAULT_REC_RATE
+    _r_bar = _share_spec.recapture_ratio or DEFAULT_REC_RATE
     if _recapture_form == RECForm.INOUT:
         _mkt_share_sample = ShareDataSample(
             _mkt_share_sample.mktshr_array,
@@ -120,7 +114,7 @@ def gen_share_data(
 
 def gen_market_shares_uniform(
     _s_size: int = 10**6,
-    _dist_parms_mktshr: ArrayDouble | None = DIST_PARMS_DEFAULT,
+    _dist_parms_mktshr: ArrayDouble | None = DEFAULT_DIST_PARMS,
     _mktshr_rng_seed_seq: SeedSequence | None = None,
     _nthreads: int = 16,
     /,
@@ -145,9 +139,8 @@ def gen_market_shares_uniform(
     """
 
     _frmshr_array = np.empty((_s_size, 2), dtype=np.float64)
-    _dist_parms_mktshr: ArrayDouble = (
-        DIST_PARMS_DEFAULT if _dist_parms_mktshr is None else _dist_parms_mktshr
-    )
+
+    _dist_parms_mktshr = _dist_parms_mktshr or DEFAULT_DIST_PARMS
     _mrng = MultithreadedRNG(
         _frmshr_array,
         dist_type="Uniform",
@@ -164,6 +157,7 @@ def gen_market_shares_uniform(
     ))
 
     # Keep only share combinations representing feasible mergers
+    # This is a no-op for 64-bit floats, but is necessary for 32-bit floats
     _frmshr_array = _frmshr_array[_frmshr_array.min(axis=1) > 0]
 
     # Let a third column have values of "np.nan", so HHI calculations return "np.nan"
@@ -171,11 +165,18 @@ def gen_market_shares_uniform(
         _frmshr_array, ((0, 0), (0, 1)), "constant", constant_values=np.nan
     )
 
-    _fcounts: ArrayBIGINT = np.ones((_s_size, 1), np.int64) * np.nan  # type: ignore
+    _fcounts = np.empty((_s_size, 1), np.int64)
     _nth_firm_share, _aggregate_purchase_prob = (
-        np.nan * np.ones((_s_size, 1), np.float64) for _ in range(2)
+        np.empty(_fcounts.shape, np.float64)
+        for _ in ("nth_firm_share", "aggregate_purchase_prob")
     )
 
+    # This array is meant to be ignored, so a sentinel value is fine
+    _fcounts.fill(-9999)
+
+    _nth_firm_share.fill(np.nan)
+    _aggregate_purchase_prob.fill(np.nan)
+
     return ShareDataSample(
         _mktshr_array, _fcounts, _nth_firm_share, _aggregate_purchase_prob
     )
@@ -228,9 +229,10 @@ def gen_market_shares_dirichlet_multimarket(
 
     """
 
-    _firm_count_wts: ArrayDouble = (
-        FCOUNT_WTS_DEFAULT if _firm_count_wts is None else _firm_count_wts
-    )
+    # _firm_count_wts: ArrayDouble = (
+    #     DEFAULT_FCOUNT_WTS if _firm_count_wts is None else _firm_count_wts
+    # )
+    _firm_count_wts = DEFAULT_FCOUNT_WTS if _firm_count_wts is None else _firm_count_wts
 
     _min_choice_wt = 0.03 if _dist_type_dir == SHRDistribution.DIR_FLAT_CONSTR else 0.00
     _fcount_keys, _choice_wts = zip(
@@ -394,7 +396,8 @@ def gen_market_shares_dirichlet(
         )
 
     # If recapture_form == 'inside_out', further calculations downstream
-    _aggregate_purchase_prob = np.nan * np.empty((_s_size, 1))
+    _aggregate_purchase_prob = np.empty((_s_size, 1), dtype=np.float64)
+    _aggregate_purchase_prob.fill(np.nan)
     if _recapture_form == RECForm.OUTIN:
         _aggregate_purchase_prob = 1 - _mktshr_array[:, [-1]]
         _mktshr_array = _mktshr_array[:, :-1] / _aggregate_purchase_prob
@@ -409,9 +412,9 @@ def gen_market_shares_dirichlet(
 
 def gen_divr_array(
     _recapture_form: RECForm,
-    _recapture_rate: float | None,
+    _recapture_ratio: float | None,
     _frmshr_array: ArrayDouble,
-    _aggregate_purchase_prob: ArrayDouble = EMPTY_ARRAY_DEFAULT,
+    _aggregate_purchase_prob: ArrayDouble = DEFAULT_EMPTY_ARRAY,
     /,
 ) -> ArrayDouble:
     """
@@ -425,8 +428,8 @@ def gen_divr_array(
     _recapture_form
         Enum specifying Fixed (proportional), Inside-out, or Outside-in
 
-    _recapture_rate
-        If recapture is proportional or inside-out, the recapture rate
+    _recapture_ratio
+        If recapture is proportional or inside-out, the recapture ratio
         for the firm with the smaller share.
 
     _frmshr_array
@@ -450,7 +453,7 @@ def gen_divr_array(
 
     _divr_array: ArrayDouble
     if _recapture_form == RECForm.FIXED:
-        _divr_array = _recapture_rate * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore
+        _divr_array = _recapture_ratio * _frmshr_array[:, ::-1] / (1 - _frmshr_array)  # type: ignore
 
     else:
         _purchprob_array = _aggregate_purchase_prob * _frmshr_array
@@ -525,6 +528,10 @@ def gen_margin_price_data(
         Simulated margin- and price-data arrays for mergers in the sample.
     """
 
+    _margin_data = MarginDataSample(
+        np.empty_like(_frmshr_array), np.ones(len(_frmshr_array)) == 0
+    )
+
     _price_array, _price_ratio_array = (
         np.ones_like(_frmshr_array, np.float64),
         np.empty_like(_frmshr_array, np.float64),
@@ -673,7 +680,6 @@ def _gen_margin_data(
         for _f in ("dist_type", "firm2_pcm_constraint", "dist_parms")
     )
 
-    _dist_type: Literal["Beta", "Uniform"]
     _pcm_array = (
         np.empty((len(_frmshr_array), 1), dtype=np.float64)
         if _pcm_spec.firm2_pcm_constraint == FM2Constraint.SYM
@@ -683,23 +689,27 @@ def _gen_margin_data(
     _beta_min, _beta_max = [None] * 2  # placeholder
     if _dist_type_pcm == PCMDistribution.EMPR:
         _pcm_array = mgn_data_resampler(
-            _pcm_array.shape,  # type: ignore
-            seed_sequence=_pcm_rng_seed_seq,
+            _pcm_array.shape, seed_sequence=_pcm_rng_seed_seq
         )
     else:
-        _dist_type = "Uniform" if _dist_type_pcm == PCMDistribution.UNI else "Beta"
-        if _dist_type_pcm == PCMDistribution.BETA:
-            if _dist_parms_pcm is None:
-                _dist_parms_pcm = np.ones(2, np.float64)
-
-        elif _dist_type_pcm == PCMDistribution.BETA_BND:  # Bounded beta
-            if _dist_parms_pcm is None:
-                _dist_parms_pcm = np.array([0, 1, 0, 1], np.float64)
-                _dist_parms = beta_located_bound(_dist_parms_pcm)
+        _dist_type: Literal["Beta", "Uniform"]
+        if _dist_type_pcm in (PCMDistribution.BETA, PCMDistribution.BETA_BND):
+            _dist_type = "Beta"
+            _dist_parms_pcm = (
+                (
+                    np.array([0, 1, 0, 1], np.float64)
+                    if _dist_parms_pcm == PCMDistribution.BETA_BND
+                    else np.ones(2, np.float64)
+                )
+                if _dist_parms_pcm is None
+                else _dist_parms_pcm
+            )
+            _dist_parms = beta_located_bound(_dist_parms_pcm)
+
         else:
-            #  _dist_type_pcm == PCMDistribution.UNI
+            _dist_type = "Uniform"
             _dist_parms = (
-                DIST_PARMS_DEFAULT if _dist_parms_pcm is None else _dist_parms_pcm
+                DEFAULT_DIST_PARMS if _dist_parms_pcm is None else _dist_parms_pcm
             )
 
         _pcm_rng = MultithreadedRNG(
@@ -838,29 +848,29 @@ def parse_seed_seq_list(
         Seed sequence data
 
     """
+    _seed_count = 2 if _mktshr_dist_type == SHRDistribution.UNI else 3
+    _seed_count += 1 if _price_spec == PriceSpec.ZERO else 0
+
     _fcount_rng_seed_seq: SeedSequence | None = None
     _pr_rng_seed_seq: SeedSequence | None = None
 
-    if _price_spec == PriceSpec.ZERO:
-        _sseq_list, _pr_rng_seed_seq = (
-            (_sseq_list[:-1], _sseq_list[-1])
-            if _sseq_list
-            else (None, SeedSequence(pool_size=8))
-        )
-
-    _seed_count = 2 if _mktshr_dist_type == SHRDistribution.UNI else 3
+    _sseq_list = (
+        _sseq_list
+        if _sseq_list
+        else tuple(SeedSequence(pool_size=8) for _ in range(_seed_count))
+    )
 
-    if _sseq_list:
-        if len(_sseq_list) < _seed_count:
-            raise ValueError(
-                f"seed sequence list must contain {_seed_count} seed sequences"
-            )
-    else:
-        _sseq_list = tuple(SeedSequence(pool_size=8) for _ in range(_seed_count))
+    if (_l := len(_sseq_list)) < _seed_count:
+        raise ValueError(
+            f"Seed sequence list must contain {_seed_count} seed sequences; "
+            f"only {_l} given."
+        )
 
-    (_mktshr_rng_seed_seq, _pcm_rng_seed_seq, _fcount_rng_seed_seq) = (
-        _sseq_list if _seed_count == 3 else (*_sseq_list, None)  # type: ignore
+    _mktshr_rng_seed_seq, _pcm_rng_seed_seq = _sseq_list[:2]
+    _fcount_rng_seed_seq = (
+        None if _mktshr_dist_type == SHRDistribution.UNI else _sseq_list[2]
     )
+    _pr_rng_seed_seq = _sseq_list[-1] if _price_spec == PriceSpec.ZERO else None
 
     return SeedSequenceData(
         _mktshr_rng_seed_seq, _pcm_rng_seed_seq, _fcount_rng_seed_seq, _pr_rng_seed_seq

mergeron/gen/upp_tests.py

@@ -26,7 +26,7 @@ from .. import (  # noqa
 )
 from ..core import guidelines_boundaries as gbl  # noqa: TID252
 from . import (
-    EMPTY_ARRAY_DEFAULT,
+    DEFAULT_EMPTY_ARRAY,
     DataclassInstance,
     INVResolution,
     MarketDataSample,
@@ -38,9 +38,6 @@ from . import enforcement_stats as esl
 
 __version__ = VERSION
 
-ptb.parameters.MAX_NUMEXPR_THREADS = 8
-ptb.parameters.MAX_BLOSC_THREADS = 4
-
 type SaveData = Literal[False] | tuple[Literal[True], ptb.File, ptb.Group]
 
 
@@ -48,7 +45,7 @@ class INVRESCntsArgs(TypedDict, total=False):
     "Keyword arguments of function, :code:`sim_enf_cnts`"
 
     sample_size: int
-    seed_seq_list: list[SeedSequence] | None
+    seed_seq_list: Sequence[SeedSequence] | None
     nthreads: int
     save_data_to_file: SaveData
     saved_array_name_suffix: str
@@ -282,7 +279,7 @@ def _compute_test_array_seq(
             UPPAggrSelector.OSA,
             UPPAggrSelector.OSD,
         )
-        else EMPTY_ARRAY_DEFAULT
+        else DEFAULT_EMPTY_ARRAY
     )
 
     match _aggregator:
@@ -335,10 +332,10 @@ def initialize_hd5(
     if _h5_path.is_file():
         _h5_path.unlink()
     _h5_file = ptb.open_file(_h5_path, mode="w", title=_h5_title)
-    _save_data_to_file: tuple[Literal[True], ptb.File, str] = (True, _h5_file, "/")
+    _save_data_to_file: SaveData = (True, _h5_file, _h5_file.root)
     _next_subgroup_name_root = "enf_{}_{}_{}_{}".format(
         _hmg_pub_year,
-        *(getattr(_test_regime, _f.name).name for _f in _test_regime.__attrs_attrs__),
+        *(getattr(_test_regime, _f.name).name for _f in _test_regime.__attrs_attrs__),  # pyright: ignore
     )
     return _save_data_to_file, _next_subgroup_name_root
 
@@ -386,7 +383,7 @@ def save_array_to_hdf5(
         _h5_array_name,
         atom=ptb.Atom.from_dtype(_array_obj.dtype),
         shape=_array_obj.shape,
-        filters=ptb.Filters(complevel=3, complib="blosc:lz4hc", fletcher32=True),
+        filters=ptb.Filters(complevel=3, complib="blosc:lz4hc", fletcher32=True),  # pyright: ignore
     )
     _h5_array[:] = _array_obj