mergeron 2025.739290.9__tar.gz → 2025.739319.1__tar.gz

{mergeron-2025.739290.9 → mergeron-2025.739319.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: mergeron
-Version: 2025.739290.9
+Version: 2025.739319.1
 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

{mergeron-2025.739290.9 → mergeron-2025.739319.1}/pyproject.toml

@@ -13,7 +13,7 @@ keywords = [
     "upward pricing pressure",
     "GUPPI",
 ]
-version = "2025.739290.9"
+version = "2025.739319.1"
 
 # Classifiers list: https://pypi.org/classifiers/
 classifiers = [

{mergeron-2025.739290.9 → mergeron-2025.739319.1}/src/mergeron/__init__.py

@@ -12,7 +12,7 @@ from ruamel import yaml
 
 _PKG_NAME: str = Path(__file__).parent.stem
 
-VERSION = "2025.739290.9"
+VERSION = "2025.739319.1"
 
 __version__ = VERSION
 

{mergeron-2025.739290.9 → mergeron-2025.739319.1}/src/mergeron/core/empirical_margin_distribution.py

@@ -38,7 +38,6 @@ price-cost margins fall in the interval :math:`[0, 1]`.
 
 import shutil
 import zipfile
-from collections.abc import Mapping
 from pathlib import Path
 from types import MappingProxyType
 
@@ -60,6 +59,7 @@ WORK_DIR = globals().get("WORK_DIR", PKG_WORK_DIR)
 
 MGNDATA_ARCHIVE_PATH = WORK_DIR / "damodaran_margin_data_serialized.zip"
 
+type DamodaranMarginData = MappingProxyType[str, MappingProxyType[str, float | int]]
 
 u3pm = urllib3.PoolManager()
 
@@ -69,7 +69,7 @@ def margin_data_getter(  # noqa: PLR0912
     *,
     data_archive_path: Path | None = None,
     data_download_flag: bool = False,
-) -> MappingProxyType[str, MappingProxyType[str, float | int]]:
+) -> DamodaranMarginData:
     if _table_name != "margin":  # Not validated for other tables
         raise ValueError(
             "This code is designed for parsing Prof. Damodaran's margin tables."
@@ -78,13 +78,10 @@ def margin_data_getter(  # noqa: PLR0912
     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 (
-            zipfile.ZipFile(data_archive_path) as _yzip,
-            _yzip.open(f"{data_archive_path.stem}.yaml") as _yfh,
-        ):
-            margin_data_dict: MappingProxyType[
-                str, MappingProxyType[str, float | int]
-            ] = this_yaml.load(_yfh)
+        with zipfile.ZipFile(data_archive_path) as _yzip:
+            margin_data_dict = this_yaml.load(
+                _yzip.read(data_archive_path.with_suffix(".yaml").name)
+            )
         return margin_data_dict
     elif workbook_path.is_file():
         workbook_path.unlink()
@@ -154,8 +151,8 @@ def margin_data_getter(  # noqa: PLR0912
 
 
 def margin_data_builder(
-    _src_data_dict: Mapping[str, Mapping[str, float | int]] | None = None, /
-) -> tuple[ArrayDouble, ArrayDouble, ArrayDouble]:
+    _src_data_dict: DamodaranMarginData | None = None, /
+) -> tuple[ArrayDouble, ArrayDouble]:
     if _src_data_dict is None:
         _src_data_dict = margin_data_getter()
 
@@ -194,25 +191,22 @@ def margin_data_builder(
         * (len(margin_data_wts) / (len(margin_data_wts) - 1))
     )
 
-    return (
-        margin_data_obs,
-        margin_data_wts,
-        np.round(
-            (
-                margin_wtd_avg,
-                margin_wtd_stderr,
-                margin_data_obs.min(),
-                margin_data_obs.max(),
-            ),
-            8,
+    return np.stack([margin_data_obs, margin_data_wts], axis=1, dtype=float), np.round(
+        (
+            margin_wtd_avg,
+            margin_wtd_stderr,
+            margin_data_obs.min(),
+            margin_data_obs.max(),
         ),
+        8,
     )
 
 
 def margin_data_resampler(
-    _sample_size: int | tuple[int, ...] = (10**6, 2),
+    _dist_parms: tuple[ArrayDouble, ArrayDouble] | None = None,
     /,
     *,
+    sample_size: int | tuple[int, ...] = (10**6, 2),
     seed_sequence: SeedSequence | None = None,
 ) -> ArrayDouble:
     """
@@ -220,12 +214,17 @@ def margin_data_resampler(
 
     The empirical distribution is estimated using a Gaussian KDE; the bandwidth
     selected using Silverman's rule is narrowed to reflect that the margin data
-    are multimodal. Margins for firms in finance, investment, insurance, reinsurance, and
-    REITs are excluded from the sample used to estimate the empirical distribution.
+    are multimodal. Margins for firms in finance, investment, insurance,
+    reinsurance, and REITs are excluded from the sample used to estimate the
+    empirical distribution.
 
     Parameters
     ----------
-    _sample_size
+
+    _dist_parms
+        Array of margins and firm counts extracted from Prof. Damodaran's margin data
+
+    sample_size
         Number of draws; if tuple, (number of draws, number of columns)
 
     seed_sequence
@@ -238,24 +237,26 @@ def margin_data_resampler(
 
     """
 
+    _dist_parms = margin_data_builder()[0] if _dist_parms is None else _dist_parms
+
     _seed = seed_sequence or SeedSequence(pool_size=8)
 
-    _x, _w, _ = margin_data_builder(margin_data_getter())
+    _x, _w = _dist_parms[:, 0], _dist_parms[:, 1] 
 
     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):
+    if isinstance(sample_size, int):
         return np.array(
-            margin_kde.resample(_sample_size, seed=Generator(PCG64DXSM(_seed)))[0]
+            margin_kde.resample(sample_size, seed=Generator(PCG64DXSM(_seed)))[0]
         )
-    elif isinstance(_sample_size, tuple) and len(_sample_size) == 2:
-        _ssz, _ncol = _sample_size
-        ret_array = np.empty(_sample_size, float)
+    elif isinstance(sample_size, tuple) and len(sample_size) == 2:
+        _ssz, _ncol = sample_size
+        ret_array = np.empty(sample_size, float)
         for idx, _col_seed in enumerate(_seed.spawn(_ncol)):
             ret_array[:, idx] = margin_kde.resample(
                 _ssz, seed=Generator(PCG64DXSM(_col_seed))
             )[0]
         return ret_array
     else:
-        raise ValueError(f"Invalid sample size: {_sample_size!r}")
+        raise ValueError(f"Invalid sample size: {sample_size!r}")

{mergeron-2025.739290.9 → mergeron-2025.739319.1}/src/mergeron/gen/__init__.py

@@ -30,6 +30,7 @@ from .. import (  # noqa: TID252
     this_yaml,
     yamelize_attrs,
 )
+from ..core.empirical_margin_distribution import margin_data_builder  # noqa: TID252
 from ..core.pseudorandom_numbers import (  # noqa: TID252
     DEFAULT_BETA_DIST_PARMS,
     DEFAULT_DIST_PARMS,
@@ -307,11 +308,11 @@ class FM2Constraint(str, Enameled):
 
 
 def _pcm_dp_conv(
-    _v: Sequence[float] | ArrayFloat | None, _i: PCMSpec
-) -> ArrayFloat | None:
-    if _i.dist_type == PCMDistribution.EMPR:
-        return None
-    elif _v is None or len(_v) == 0 or np.array_equal(_v, DEFAULT_DIST_PARMS):
+    _v: ArrayFloat | Sequence[float] | None, _i: PCMSpec
+) -> ArrayFloat:
+    if _v is None or len(_v) == 0 or np.array_equal(_v, DEFAULT_DIST_PARMS):
+        if _i.dist_type == PCMDistribution.EMPR:
+            return margin_data_builder()[0]
         match _i.dist_type:
             case PCMDistribution.BETA:
                 return DEFAULT_BETA_DIST_PARMS
@@ -319,13 +320,20 @@ def _pcm_dp_conv(
                 return DEFAULT_BETA_BND_DIST_PARMS
             case _:
                 return DEFAULT_DIST_PARMS
+    elif (_i.dist_type == PCMDistribution.EMPR and not isinstance(_v, np.ndarray)):
+            raise ValueError(
+                "Invalid specification; use output of mergeron.core.empriical_margin_distribution.margin_data_builider()."
+            )
     elif isinstance(_v, Sequence | np.ndarray):
         return np.asarray(_v, float)
     else:
         raise ValueError(
-            f"Input, {_v!r} has invalid type. Must be None, Sequence of floats, or Numpy ndarray."
+            f"Input, {_v!r} has invalid type. Must be None, sequence of floats,"
+            "sequence of Numpy arrays, or Numpy ndarray."
         )
 
+    return _v
+
 
 @frozen
 class PCMSpec:
@@ -350,7 +358,7 @@ class PCMSpec:
     def __dtd(_i: PCMSpec) -> PCMDistribution:
         return PCMDistribution.UNI
 
-    dist_parms: ArrayFloat | None = field(
+    dist_parms: ArrayFloat = field(
         kw_only=True,
         eq=cmp_using(eq=np.array_equal),
         converter=Converter(_pcm_dp_conv, takes_self=True),  # type: ignore
@@ -365,12 +373,16 @@ class PCMSpec:
     """
 
     @dist_parms.default
-    def __dpwd(_i: PCMSpec) -> ArrayFloat | None:
+    def __dpwd(
+        _i: PCMSpec,
+    ) -> ArrayFloat:
         return _pcm_dp_conv(None, _i)
 
     @dist_parms.validator
     def __dpv(
-        _i: PCMSpec, _a: Attribute[ArrayFloat | None], _v: ArrayFloat | None
+        _i: PCMSpec,
+        _a: Attribute[ArrayFloat | Sequence[ArrayDouble] | None],
+        _v: ArrayFloat | Sequence[ArrayDouble] | None,
     ) -> None:
         if _i.dist_type.name.startswith("BETA"):
             if _v is None or not any(_v.shape):
@@ -391,10 +403,12 @@ class PCMSpec:
                     f'for PCM with distribution, "{_i.dist_type}" is incorrect.'
                 )
 
-        elif _v is not None and _i.dist_type == PCMDistribution.EMPR:
+        elif (
+            _i.dist_type == PCMDistribution.EMPR
+            and not isinstance(_v, np.ndarray)
+        ):
             raise ValueError(
-                f"Empirical distribution does not require additional parameters; "
-                f'"given value, {_v!r} is ignored."'
+                "Empirical distribution requires deserialzed margin data from Prof. Damodaran, NYU"
             )
 
     firm2_pcm_constraint: FM2Constraint = field(kw_only=True, default=FM2Constraint.IID)

{mergeron-2025.739290.9 → mergeron-2025.739319.1}/src/mergeron/gen/data_generation_functions.py

@@ -671,16 +671,16 @@ def _gen_margin_data(
     )
 
     pcm_array = (
-        np.empty((len(_frmshr_array), 1), float)
+        np.empty_like(_frmshr_array[:, :1])
         if _pcm_spec.firm2_pcm_constraint == FM2Constraint.SYM
-        else np.empty_like(_frmshr_array, float)
+        else np.empty_like(_frmshr_array)
     )
 
     dist_parms_: ArrayFloat
     beta_min, beta_max = [0.0] * 2  # placeholder
     if dist_type_pcm == PCMDistribution.EMPR:
         pcm_array = margin_data_resampler(
-            pcm_array.shape, seed_sequence=_pcm_rng_seed_seq
+            dist_parms_pcm, sample_size=pcm_array.shape, seed_sequence=_pcm_rng_seed_seq
         )
     else:
         dist_type_: Literal["Beta", "Uniform"]