mergeron 2025.739290.2__tar.gz → 2025.739290.4__tar.gz

{mergeron-2025.739290.2 → mergeron-2025.739290.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mergeron
-Version: 2025.739290.2
+Version: 2025.739290.4
 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
@@ -23,7 +23,7 @@ Requires-Dist: aenum (>=3.1.15,<4.0.0)
 Requires-Dist: attrs (>=23.2)
 Requires-Dist: bs4 (>=0.0.1)
 Requires-Dist: certifi (>=2023.11.17)
-Requires-Dist: google-re2 (>=1.1)
+Requires-Dist: h5py (>=3.13.0,<4.0.0)
 Requires-Dist: jinja2 (>=3.1)
 Requires-Dist: joblib (>=1.3)
 Requires-Dist: matplotlib (>=3.8)
@@ -33,7 +33,6 @@ 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)
 Requires-Dist: types-beautifulsoup4 (>=4.11.2)
 Requires-Dist: urllib3 (>=2.2.2,<3.0.0)
 Requires-Dist: xlrd (>=2.0.1,<3.0.0)

{mergeron-2025.739290.2 → mergeron-2025.739290.4}/pyproject.toml

@@ -13,7 +13,7 @@ keywords = [
     "upward pricing pressure",
     "GUPPI",
 ]
-version = "2025.739290.2"
+version = "2025.739290.4"
 
 # Classifiers list: https://pypi.org/classifiers/
 classifiers = [
@@ -41,7 +41,6 @@ build-backend = "poetry.core.masonry.api"
 aenum = "^3.1.15"
 attrs = ">=23.2"
 bs4 = ">=0.0.1"
-google-re2 = ">=1.1"
 jinja2 = ">=3.1"
 joblib = ">=1.3"
 matplotlib = ">=3.8"
@@ -51,13 +50,13 @@ msgpack-numpy = ">=0.4"
 python = "^3.12"
 scipy = ">=1.12"
 sympy = ">=1.12"
-tables = ">=3.10.1"
 xlsxwriter = ">=3.1"
 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"
+h5py = "^3.13.0"
 
 
 [tool.poetry.group.dev.dependencies]
@@ -131,7 +130,7 @@ select = [
     "S",    # flake8-bandit
     "SIM",  # flake8-simplify
     "TID",  # flake8-tidy-imports
-    "TC",  # flake8-type-checking
+    "TC",   # flake8-type-checking
     "UP",   # pyupgrade
     "RUF",  # ruff-specific
 ]
@@ -148,6 +147,8 @@ ignore = [
     'B904',
     'B905',
     "PLR2004", # avoid magic values
+    # RUF
+    "RUF052",
     # flake8-type-checking
     "TC001", # move application import into a type-checking block
     "TC002", # move third-party import into a type-checking block

mergeron-2025.739290.4/src/mergeron/__init__.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import enum
+from collections.abc import Mapping
+from multiprocessing import cpu_count
+from pathlib import Path
+from typing import Any, Literal
+
+import numpy as np
+from numpy.typing import NDArray
+from ruamel import yaml
+
+_PKG_NAME: str = Path(__file__).parent.stem
+
+VERSION = "2025.739290.4"
+
+__version__ = VERSION
+
+DATA_DIR: Path = Path.home() / _PKG_NAME
+"""
+Defines a subdirectory named for this package in the user's home path.
+
+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()
+
+PKG_ENUMS_MAP: dict[str, object] = {}
+PKG_ATTRS_MAP: dict[str, object] = {}
+
+np.set_printoptions(precision=24, floatmode="fixed")
+
+type HMGPubYear = Literal[1982, 1984, 1992, 2010, 2023]
+
+type ArrayBoolean = NDArray[np.bool_]
+type ArrayFloat = NDArray[np.floating]
+type ArrayINT = NDArray[np.unsignedinteger]
+
+type ArrayDouble = NDArray[np.float64]
+type ArrayBIGINT = NDArray[np.uint64]
+
+
+this_yaml = yaml.YAML(typ="rt")
+this_yaml.indent(mapping=2, sequence=4, offset=2)
+
+# 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, deep=True))
+    ),
+)
+
+
+@this_yaml.register_class
+class EnumYAMLized(enum.Enum):
+    @classmethod
+    def to_yaml(
+        cls, _r: yaml.representer.RoundTripRepresenter, _d: object[enum.EnumType]
+    ) -> yaml.ScalarNode:
+        return _r.represent_scalar(
+            f"!{super().__getattribute__(cls, '__name__')}", f"{_d.name}"
+        )
+
+    @classmethod
+    def from_yaml(
+        cls, _c: yaml.constructor.RoundTripConstructor, _n: yaml.ScalarNode
+    ) -> object[enum.EnumType]:
+        return super().__getattribute__(cls, _n.value)
+
+
+def yaml_rt_mapper(
+    _c: yaml.constructor.RoundTripConstructor, _n: yaml.MappingNode
+) -> Mapping[str, Any]:
+    data_: Mapping[str, Any] = yaml.constructor.CommentedMap()
+    _c.construct_mapping(_n, maptyp=data_, deep=True)
+    return data_
+
+
+def yamelize_attrs(
+    _typ: object,
+    excluded_attributes: set | None = None,
+    /,
+    *,
+    attr_map: Mapping[str, object] = PKG_ATTRS_MAP,
+) -> None:
+    attr_map |= {_typ.__name__: _typ}
+
+    _ = this_yaml.representer.add_representer(
+        _typ,
+        lambda _r, _d: _r.represent_mapping(
+            f"!{_d.__class__.__name__}",
+            # construct mapping, rather than calling attrs.asdict(),
+            # to use yaml representers defined in this package for
+            # "upstream" objects
+            {
+                _a.name: getattr(_d, _a.name)
+                for _a in _d.__attrs_attrs__
+                if excluded_attributes is None or _a.name not in excluded_attributes
+            },
+        ),
+    )
+    _ = this_yaml.constructor.add_constructor(
+        f"!{_typ.__name__}",
+        lambda _c, _n: attr_map[_n.tag.lstrip("!")](**yaml_rt_mapper(_c, _n)),
+    )
+
+
+@this_yaml.register_class
+@enum.unique
+class RECForm(str, EnumYAMLized):
+    """For derivation of recapture ratio from market shares."""
+
+    INOUT = "inside-out"
+    OUTIN = "outside-in"
+    FIXED = "proportional"
+
+
+@this_yaml.register_class
+@enum.unique
+class UPPAggrSelector(str, EnumYAMLized):
+    """
+    Aggregator for GUPPI and diversion ratio estimates.
+
+    """
+
+    AVG = "average"
+    CPA = "cross-product-share weighted average"
+    CPD = "cross-product-share weighted distance"
+    CPG = "cross-product-share weighted geometric mean"
+    DIS = "symmetrically-weighted distance"
+    GMN = "geometric mean"
+    MAX = "max"
+    MIN = "min"
+    OSA = "own-share weighted average"
+    OSD = "own-share weighted distance"
+    OSG = "own-share weighted geometric mean"

mergeron-2025.739290.4/src/mergeron/core/__init__.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from decimal import Decimal
+from types import MappingProxyType
+from typing import Any
+
+import mpmath  # type: ignore
+import numpy as np
+from attrs import cmp_using, field, frozen
+
+from .. import VERSION, ArrayBIGINT, this_yaml, yaml_rt_mapper  # noqa: TID252
+
+__version__ = VERSION
+
+type MPFloat = mpmath.ctx_mp_python.mpf
+type MPMatrix = mpmath.matrix  # type: ignore
+
+
+@frozen
+class INVTableData:
+    industry_group: str
+    additional_evidence: str
+    data_array: ArrayBIGINT = field(eq=cmp_using(eq=np.array_equal))
+
+
+type INVData = MappingProxyType[
+    str, MappingProxyType[str, MappingProxyType[str, INVTableData]]
+]
+type INVData_in_ = Mapping[str, Mapping[str, Mapping[str, INVTableData]]]
+
+
+(_, _) = (
+    this_yaml.representer.add_representer(
+        Decimal, lambda _r, _d: _r.represent_scalar("!Decimal", f"{_d}")
+    ),
+    this_yaml.constructor.add_constructor(
+        "!Decimal", lambda _c, _n, /: Decimal(_c.construct_scalar(_n))
+    ),
+)
+
+
+(_, _) = (
+    this_yaml.representer.add_representer(
+        mpmath.mpf, lambda _r, _d: _r.represent_scalar("!MPFloat", f"{_d}")
+    ),
+    this_yaml.constructor.add_constructor(
+        "!MPFloat", lambda _c, _n, /: mpmath.mpf(_c.construct_scalar(_n))
+    ),
+)
+
+(_, _) = (
+    this_yaml.representer.add_representer(
+        mpmath.matrix, lambda _r, _d: _r.represent_sequence("!MPMatrix", _d.tolist())
+    ),
+    this_yaml.constructor.add_constructor(
+        "!MPMatrix",
+        lambda _c, _n, /: mpmath.matrix(_c.construct_sequence(_n, deep=True)),
+    ),
+)
+
+
+def _dict_from_mapping(_p: Mapping[Any, Any], /) -> dict[Any, Any]:
+    retval = {}
+    for _k, _v in _p.items():  # for subit in it:
+        retval |= {_k: _dict_from_mapping(_v)} if isinstance(_v, Mapping) else {_k: _v}
+    return retval
+
+
+def _mappingproxy_from_mapping(_p: Mapping[Any, Any], /) -> MappingProxyType[Any, Any]:
+    retval = {}
+    for _k, _v in _p.items():  # for subit in it:
+        retval |= (
+            {_k: _mappingproxy_from_mapping(_v)}
+            if isinstance(_v, Mapping)
+            else {_k: _v}
+        )
+    return MappingProxyType(retval)
+
+
+_, _ = (
+    this_yaml.representer.add_representer(
+        MappingProxyType,
+        lambda _r, _d: _r.represent_mapping("!mappingproxy", dict(_d.items())),
+    ),
+    this_yaml.constructor.add_constructor(
+        "!mappingproxy", lambda _c, _n: MappingProxyType(yaml_rt_mapper(_c, _n))
+    ),
+)
+
+
+for _typ in (INVTableData,):
+    _, _ = (
+        this_yaml.representer.add_representer(
+            _typ,
+            lambda _r, _d: _r.represent_mapping(
+                f"!{_d.__class__.__name__}",
+                {
+                    _a.name: getattr(_d, _a.name)
+                    for _a in _d.__attrs_attrs__
+                    if _a.name not in {"coordinates", "area"}
+                },
+            ),
+        ),
+        this_yaml.constructor.add_constructor(
+            f"!{_typ.__name__}",
+            lambda _c, _n: globals()[_n.tag.lstrip("!")](**yaml_rt_mapper(_c, _n)),
+        ),
+    )

{mergeron-2025.739290.2 → mergeron-2025.739290.4}/src/mergeron/core/empirical_margin_distribution.py

@@ -2,7 +2,7 @@
 Functions to parse margin data compiled by
 Prof. Aswath Damodaran, Stern School of Business, NYU.
 
-Provides :func:`mgn_data_resampler` for generating margin data
+Provides :func:`margin_data_resampler` for generating margin data
 from an estimated Gaussian KDE from the source (margin) data.
 
 Data are downloaded or reused from a local copy, on demand.
@@ -37,123 +37,139 @@ price-cost margins fall in the interval :math:`[0, 1]`.
 """
 
 import shutil
+import zipfile
 from collections.abc import Mapping
 from importlib import resources
 from pathlib import Path
 from types import MappingProxyType
 
-import msgpack  # type:ignore
 import numpy as np
 import urllib3
 from numpy.random import PCG64DXSM, Generator, SeedSequence
 from scipy import stats  # type: ignore
 from xlrd import open_workbook  # type: ignore
 
-from .. import _PKG_NAME, DATA_DIR, VERSION, ArrayDouble  # noqa: TID252
+from .. import _PKG_NAME, DATA_DIR, VERSION, ArrayDouble, this_yaml  # noqa: TID252
+from . import _mappingproxy_from_mapping
 
 __version__ = VERSION
 
-MGNDATA_ARCHIVE_PATH = DATA_DIR / "damodaran_margin_data_dict.msgpack"
+MGNDATA_ARCHIVE_PATH = DATA_DIR / "damodaran_margin_data_serialized.zip"
+
 
 u3pm = urllib3.PoolManager()
 
 
-def mgn_data_getter(  # noqa: PLR0912
+def margin_data_getter(  # noqa: PLR0912
     _table_name: str = "margin",
     *,
     data_archive_path: Path | None = None,
     data_download_flag: bool = False,
-) -> MappingProxyType[str, Mapping[str, float | int]]:
+) -> MappingProxyType[str, MappingProxyType[str, float | int]]:
     if _table_name != "margin":  # Not validated for other tables
         raise ValueError(
             "This code is designed for parsing Prof. Damodaran's margin tables."
         )
 
-    _data_archive_path = data_archive_path or MGNDATA_ARCHIVE_PATH
-
-    _mgn_urlstr = f"https://pages.stern.nyu.edu/~adamodar/pc/datasets/{_table_name}.xls"
-    _mgn_path = _data_archive_path.parent / f"damodaran_{_table_name}_data.xls"
-    if _data_archive_path.is_file() and not data_download_flag:
-        return MappingProxyType(msgpack.unpackb(_data_archive_path.read_bytes()))
-    elif _mgn_path.is_file():
-        _mgn_path.unlink()
-        if _data_archive_path.is_file():
-            _data_archive_path.unlink()
-
+    data_archive_path_ = data_archive_path or MGNDATA_ARCHIVE_PATH
+    workbook_path_ = data_archive_path_.parent / f"damodaran_{_table_name}_data.xls"
+    if data_archive_path_.is_file() and not data_download_flag:
+        # with data_archive_path_.open("r") as _yfh:
+        #     margin_data_dict: dict[str, dict[str, float | int]] = this_yaml.load(_yfh)
+        with (
+            zipfile.ZipFile(data_archive_path_) as _yzip,
+            _yzip.open(f"{data_archive_path_.stem}.yaml") as _yfh,
+        ):
+            margin_data_dict: dict[str, dict[str, float | int]] = this_yaml.load(_yfh)
+        return _mappingproxy_from_mapping(margin_data_dict)
+    elif workbook_path_.is_file():
+        workbook_path_.unlink()
+        if data_archive_path_.is_file():
+            data_archive_path_.unlink()
+
+    margin_urlstr = (
+        f"https://pages.stern.nyu.edu/~adamodar/pc/datasets/{_table_name}.xls"
+    )
     try:
-        _chunk_size = 1024 * 1024
+        chunk_size_ = 1024 * 1024
         with (
-            u3pm.request("GET", _mgn_urlstr, preload_content=False) as _urlopen_handle,
-            _mgn_path.open("wb") as _mgn_file,
+            u3pm.request(
+                "GET", margin_urlstr, preload_content=False
+            ) as _urlopen_handle,
+            workbook_path_.open("wb") as margin_file,
         ):
             while True:
-                _data = _urlopen_handle.read(_chunk_size)
-                if not _data:
+                data_ = _urlopen_handle.read(chunk_size_)
+                if not data_:
                     break
-                _mgn_file.write(_data)
+                margin_file.write(data_)
 
-        print(f"Downloaded {_mgn_urlstr} to {_mgn_path}.")
+        print(f"Downloaded {margin_urlstr} to {workbook_path_}.")
 
-    except urllib3.exceptions.MaxRetryError as _err:
-        if isinstance(_err.__cause__, urllib3.exceptions.SSLError):
+    except urllib3.exceptions.MaxRetryError as error_:
+        if isinstance(error_.__cause__, urllib3.exceptions.SSLError):
             # Works fine with other sites secured with certificates
             # from the Internet2 CA, such as,
             # https://snap.stanford.edu/data/web-Stanford.txt.gz
             print(
-                f"WARNING: Could not establish secure connection to, {_mgn_urlstr}."
+                f"WARNING: Could not establish secure connection to, {margin_urlstr}."
                 "Using bundled copy."
             )
-            if not _mgn_path.is_file():
+            if not workbook_path_.is_file():
                 with resources.as_file(
                     resources.files(f"{_PKG_NAME}.data").joinpath(
                         "empirical_margin_distribution.xls"
                     )
-                ) as _mgn_data_archive_path:
-                    shutil.copy2(_mgn_data_archive_path, _mgn_path)
+                ) as margin_data_archive_path:
+                    shutil.copy2(margin_data_archive_path, workbook_path_)
         else:
-            raise _err
-
-    _xl_book = open_workbook(_mgn_path, ragged_rows=True, on_demand=True)
-    _xl_sheet = _xl_book.sheet_by_name("Industry Averages")
-
-    _mgn_dict: dict[str, dict[str, float]] = {}
-    _mgn_row_keys: list[str] = []
-    _read_row_flag = False
-    for _ridx in range(_xl_sheet.nrows):
-        _xl_row = _xl_sheet.row_values(_ridx)
-        if _xl_row[0] == "Industry Name":
-            _read_row_flag = True
-            _mgn_row_keys = _xl_row
+            raise error_
+
+    xl_book_ = open_workbook(workbook_path_, ragged_rows=True, on_demand=True)
+    xl_sheet_ = xl_book_.sheet_by_name("Industry Averages")
+
+    margin_dict: dict[str, dict[str, float | int]] = {}
+    row_keys_: list[str] = []
+    read_row_flag = False
+    for _ridx in range(xl_sheet_.nrows):
+        xl_row = xl_sheet_.row_values(_ridx)
+        if xl_row[0] == "Industry Name":
+            read_row_flag = True
+            row_keys_ = xl_row
             continue
 
-        if not _xl_row[0] or not _read_row_flag:
+        if not xl_row[0] or not read_row_flag:
             continue
 
-        _xl_row[1] = int(_xl_row[1])
-        _mgn_dict[_xl_row[0]] = dict(zip(_mgn_row_keys[1:], _xl_row[1:], strict=True))
+        xl_row[1] = int(xl_row[1])
+        margin_dict[xl_row[0]] = dict(zip(row_keys_[1:], xl_row[1:], strict=True))
 
-    _ = _data_archive_path.write_bytes(msgpack.packb(_mgn_dict))
+    with (
+        zipfile.ZipFile(data_archive_path_, "w") as _yzip,
+        _yzip.open(f"{data_archive_path_.stem}.yaml", "w") as _yfh,
+    ):
+        this_yaml.dump(margin_dict, _yfh)
 
-    return MappingProxyType(_mgn_dict)
+    return _mappingproxy_from_mapping(margin_dict)
 
 
-def mgn_data_builder(
-    _mgn_tbl_dict: Mapping[str, Mapping[str, float | int]] | None = None, /
+def margin_data_builder(
+    _src_data_dict: Mapping[str, Mapping[str, float | int]] | None = None, /
 ) -> tuple[ArrayDouble, ArrayDouble, ArrayDouble]:
-    if _mgn_tbl_dict is None:
-        _mgn_tbl_dict = mgn_data_getter()
+    if _src_data_dict is None:
+        _src_data_dict = margin_data_getter()
 
-    _mgn_data_wts, _mgn_data_obs = (
+    margin_data_wts, margin_data_obs = (
         _f.flatten()
         for _f in np.hsplit(
             np.array([
                 tuple(
-                    _mgn_tbl_dict[_g][_h] for _h in ["Number of firms", "Gross Margin"]
+                    _src_data_dict[_g][_h] for _h in ["Number of firms", "Gross Margin"]
                 )
-                for _g in _mgn_tbl_dict
+                for _g in _src_data_dict
                 if not _g.startswith("Total Market")
                 and _g
-                not in (
+                not in {
                     "Bank (Money Center)",
                     "Banks (Regional)",
                     "Brokerage & Investment Banking",
@@ -165,29 +181,35 @@ def mgn_data_builder(
                     "R.E.I.T.",
                     "Retail (REITs)",
                     "Reinsurance",
-                )
+                }
             ]),
             2,
         )
     )
 
-    _mgn_wtd_avg = np.average(_mgn_data_obs, weights=_mgn_data_wts)
+    margin_wtd_avg = np.average(margin_data_obs, weights=margin_data_wts)
     # https://www.itl.nist.gov/div898/software/dataplot/refman2/ch2/weighvar.pdf
-    _mgn_wtd_stderr = np.sqrt(
-        np.average((_mgn_data_obs - _mgn_wtd_avg) ** 2, weights=_mgn_data_wts)
-        * (len(_mgn_data_wts) / (len(_mgn_data_wts) - 1))
+    margin_wtd_stderr = np.sqrt(
+        np.average((margin_data_obs - margin_wtd_avg) ** 2, weights=margin_data_wts)
+        * (len(margin_data_wts) / (len(margin_data_wts) - 1))
     )
 
     return (
-        _mgn_data_obs,
-        _mgn_data_wts,
+        margin_data_obs,
+        margin_data_wts,
         np.round(
-            (_mgn_wtd_avg, _mgn_wtd_stderr, _mgn_data_obs.min(), _mgn_data_obs.max()), 8
+            (
+                margin_wtd_avg,
+                margin_wtd_stderr,
+                margin_data_obs.min(),
+                margin_data_obs.max(),
+            ),
+            8,
         ),
     )
 
 
-def mgn_data_resampler(
+def margin_data_resampler(
     _sample_size: int | tuple[int, ...] = (10**6, 2),
     /,
     *,
@@ -216,26 +238,26 @@ def mgn_data_resampler(
 
     """
 
-    _seed_sequence = seed_sequence or SeedSequence(pool_size=8)
+    seed_sequence_ = seed_sequence or SeedSequence(pool_size=8)
 
-    _x, _w, _ = mgn_data_builder(mgn_data_getter())
+    x_, w_, _ = margin_data_builder(margin_data_getter())
 
-    _mgn_kde = stats.gaussian_kde(_x, weights=_w, bw_method="silverman")
-    _mgn_kde.set_bandwidth(bw_method=_mgn_kde.factor / 3.0)
+    margin_kde = stats.gaussian_kde(x_, weights=w_, bw_method="silverman")
+    margin_kde.set_bandwidth(bw_method=margin_kde.factor / 3.0)
 
     if isinstance(_sample_size, int):
         return np.array(
-            _mgn_kde.resample(_sample_size, seed=Generator(PCG64DXSM(_seed_sequence)))[
-                0
-            ]
+            margin_kde.resample(
+                _sample_size, seed=Generator(PCG64DXSM(seed_sequence_))
+            )[0]
         )
     elif isinstance(_sample_size, tuple) and len(_sample_size) == 2:
-        _ssz, _num_cols = _sample_size
-        _ret_array = np.empty(_sample_size, np.float64)
-        for _idx, _seed_seq in enumerate(_seed_sequence.spawn(_num_cols)):
-            _ret_array[:, _idx] = _mgn_kde.resample(
-                _ssz, seed=Generator(PCG64DXSM(_seed_seq))
+        ssz, num_cols = _sample_size
+        ret_array = np.empty(_sample_size, np.float64)
+        for idx, seed_seq in enumerate(seed_sequence_.spawn(num_cols)):
+            ret_array[:, idx] = margin_kde.resample(
+                ssz, seed=Generator(PCG64DXSM(seed_seq))
             )[0]
-        return _ret_array
+        return ret_array
     else:
         raise ValueError(f"Invalid sample size: {_sample_size!r}")