mergeron 2025.739290.2__py3-none-any.whl → 2025.739290.4__py3-none-any.whl

mergeron/gen/upp_tests.py

@@ -5,14 +5,10 @@ from generated market data.
 """
 
 from collections.abc import Sequence
-from contextlib import suppress
-from pathlib import Path
-from typing import Any, Literal, TypedDict
+from typing import TypedDict
 
 import numpy as np
-import tables as ptb  # type: ignore
 from numpy.random import SeedSequence
-from numpy.typing import NDArray
 
 from .. import (  # noqa
     VERSION,
@@ -26,7 +22,6 @@ from .. import (  # noqa
 )
 from ..core import guidelines_boundaries as gbl  # noqa: TID252
 from . import (
-    DataclassInstance,
     INVResolution,
     MarketSampleData,
     UPPTestRegime,
@@ -37,8 +32,6 @@ from . import enforcement_stats as esl
 
 __version__ = VERSION
 
-type SaveData = Literal[False] | tuple[Literal[True], ptb.File, ptb.Group]
-
 
 class INVRESCntsArgs(TypedDict, total=False):
     "Keyword arguments of function, :code:`sim_enf_cnts`"
@@ -46,8 +39,6 @@ class INVRESCntsArgs(TypedDict, total=False):
     sample_size: int
     seed_seq_list: Sequence[SeedSequence] | None
     nthreads: int
-    save_data_to_file: SaveData
-    saved_array_name_suffix: str
 
 
 def compute_upp_test_counts(
@@ -80,116 +71,115 @@ def compute_upp_test_counts(
 
     """
 
-    _enf_cnts_sim_array = -1 * np.ones((6, 2), np.int64)
-    _upp_test_arrays = compute_upp_test_arrays(
+    upp_test_arrays = compute_upp_test_arrays(
         _market_data_sample, _upp_test_parms, _upp_test_regime
     )
 
-    _fcounts, _hhi_delta, _hhi_post = (
+    fcounts, hhi_delta, hhi_post = (
         getattr(_market_data_sample, _g) for _g in ("fcounts", "hhi_delta", "hhi_post")
     )
 
-    _stats_rowlen = 6
+    stats_rowlen = 6
     # Clearance/enforcement counts --- by firm count
-    _firmcounts_list = np.unique(_fcounts)
-    if _firmcounts_list is not None and np.all(_firmcounts_list >= 0):
-        _max_firmcount = max(_firmcounts_list)
-
-        _enf_cnts_sim_byfirmcount_array: ArrayBIGINT = -1 * np.ones(_stats_rowlen, int)
-        for _firmcount in np.arange(2, _max_firmcount + 1):
-            _firmcount_test = _fcounts == _firmcount
-
-            _enf_cnts_sim_byfirmcount_array = np.vstack((
-                _enf_cnts_sim_byfirmcount_array,
+    enf_cnts_sim_byfirmcount_array: ArrayBIGINT = np.zeros(stats_rowlen, int)
+    firmcounts_list = np.unique(fcounts)
+    if firmcounts_list.any():
+        for _fc in firmcounts_list:
+            fc_test = fcounts == _fc
+
+            enf_cnts_sim_byfirmcount_array = np.vstack((
+                enf_cnts_sim_byfirmcount_array,
                 np.array([
-                    _firmcount,
-                    np.einsum("ij->", 1 * _firmcount_test),
+                    _fc,
+                    np.einsum("ij->", 1 * fc_test),
                     *[
                         np.einsum(
-                            "ij->",
-                            1 * (_firmcount_test & getattr(_upp_test_arrays, _f)),
+                            "ij->", 1 * (fc_test & getattr(upp_test_arrays, _a.name))
                         )
-                        for _f in _upp_test_arrays.__dataclass_fields__
+                        for _a in upp_test_arrays.__attrs_attrs__
                     ],
                 ]),
             ))
-        _enf_cnts_sim_byfirmcount_array = _enf_cnts_sim_byfirmcount_array[1:]
+
+        enf_cnts_sim_byfirmcount_array = enf_cnts_sim_byfirmcount_array[1:]
     else:
-        _enf_cnts_sim_byfirmcount_array = np.array(
-            np.nan * np.empty((1, _stats_rowlen)), np.int64
-        )
-        _enf_cnts_sim_byfirmcount_array[0] = 2
+        enf_cnts_sim_byfirmcount_array = np.array([], int)
 
     # Clearance/enforcement counts --- by delta
-    _hhi_delta_ranged = esl.hhi_delta_ranger(_hhi_delta)
-    _enf_cnts_sim_bydelta_array: ArrayBIGINT = -1 * np.ones(_stats_rowlen, int)
-    for _hhi_delta_lim in esl.HHI_DELTA_KNOTS[:-1]:
-        _hhi_delta_test = _hhi_delta_ranged == _hhi_delta_lim
+    enf_cnts_sim_bydelta_array: ArrayBIGINT = np.zeros(stats_rowlen, int)
+    hhi_deltaranged = esl.hhi_delta_ranger(hhi_delta)
+    for hhi_deltalim in esl.HHI_DELTA_KNOTS[:-1]:
+        hhi_deltatest = hhi_deltaranged == hhi_deltalim
 
-        _enf_cnts_sim_bydelta_array = np.vstack((
-            _enf_cnts_sim_bydelta_array,
+        enf_cnts_sim_bydelta_array = np.vstack((
+            enf_cnts_sim_bydelta_array,
             np.array([
-                _hhi_delta_lim,
-                np.einsum("ij->", 1 * _hhi_delta_test),
+                hhi_deltalim,
+                np.einsum("ij->", 1 * hhi_deltatest),
                 *[
                     np.einsum(
-                        "ij->", 1 * (_hhi_delta_test & getattr(_upp_test_arrays, _f))
+                        "ij->", 1 * (hhi_deltatest & getattr(upp_test_arrays, _a.name))
                     )
-                    for _f in _upp_test_arrays.__dataclass_fields__
+                    for _a in upp_test_arrays.__attrs_attrs__
                 ],
             ]),
         ))
 
-    _enf_cnts_sim_bydelta_array = _enf_cnts_sim_bydelta_array[1:]
+    enf_cnts_sim_bydelta_array = enf_cnts_sim_bydelta_array[1:]
 
     # Clearance/enforcement counts --- by zone
-    try:
-        _hhi_zone_post_ranged = esl.hhi_zone_post_ranger(_hhi_post)
-    except ValueError as _err:
-        print(_hhi_post)
-        raise _err
-
-    _stats_byconczone_sim = -1 * np.ones(_stats_rowlen + 1, np.int64)
-    for _hhi_zone_post_knot in esl.HHI_POST_ZONE_KNOTS[:-1]:
-        _level_test = _hhi_zone_post_ranged == _hhi_zone_post_knot
-
-        for _hhi_zone_delta_knot in [0, 100, 200]:
-            _delta_test = (
-                _hhi_delta_ranged > 100
-                if _hhi_zone_delta_knot == 200
-                else _hhi_delta_ranged == _hhi_zone_delta_knot
-            )
-
-            _conc_test = _level_test & _delta_test
-
-            _stats_byconczone_sim = np.vstack((
-                _stats_byconczone_sim,
-                np.array([
-                    _hhi_zone_post_knot,
-                    _hhi_zone_delta_knot,
-                    np.einsum("ij->", 1 * _conc_test),
-                    *[
-                        np.einsum(
-                            "ij->", 1 * (_conc_test & getattr(_upp_test_arrays, _f))
-                        )
-                        for _f in _upp_test_arrays.__dataclass_fields__
-                    ],
-                ]),
-            ))
-
-    _enf_cnts_sim_byconczone_array = esl.enf_cnts_byconczone(_stats_byconczone_sim[1:])
-    del _stats_byconczone_sim
-    del _hhi_delta, _hhi_post, _fcounts
+    if np.isnan(hhi_post).all():
+        stats_byconczone_sim = np.array([], int)
+    else:
+        try:
+            hhi_zone_post_ranged = esl.hhi_zone_post_ranger(hhi_post)
+        except ValueError as _err:
+            print(hhi_post)
+            raise _err
+
+        stats_byconczone_sim = np.zeros(stats_rowlen + 1, int)
+        for hhi_zone_post_knot in esl.HHI_POST_ZONE_KNOTS[:-1]:
+            level_test = hhi_zone_post_ranged == hhi_zone_post_knot
+
+            for hhi_zone_delta_knot in [0, 100, 200]:
+                delta_test = (
+                    hhi_deltaranged > 100
+                    if hhi_zone_delta_knot == 200
+                    else hhi_deltaranged == hhi_zone_delta_knot
+                )
+
+                conc_test = level_test & delta_test
+
+                stats_byconczone_sim = np.vstack((
+                    stats_byconczone_sim,
+                    np.array([
+                        hhi_zone_post_knot,
+                        hhi_zone_delta_knot,
+                        np.einsum("ij->", 1 * conc_test),
+                        *[
+                            np.einsum(
+                                "ij->",
+                                1 * (conc_test & getattr(upp_test_arrays, _a.name)),
+                            )
+                            for _a in upp_test_arrays.__attrs_attrs__
+                        ],
+                    ]),
+                ))
+
+    enf_cnts_sim_byconczone_array = esl.enf_cnts_byconczone(stats_byconczone_sim[1:])
+
+    del stats_byconczone_sim
+    del hhi_delta, hhi_post, fcounts
 
     return UPPTestsCounts(
-        _enf_cnts_sim_byfirmcount_array,
-        _enf_cnts_sim_bydelta_array,
-        _enf_cnts_sim_byconczone_array,
+        enf_cnts_sim_byfirmcount_array,
+        enf_cnts_sim_bydelta_array,
+        enf_cnts_sim_byconczone_array,
     )
 
 
 def compute_upp_test_arrays(
-    _market_data: MarketSampleData,
+    _market_data_sample: MarketSampleData,
     _upp_test_parms: gbl.HMGThresholds,
     _sim_test_regime: UPPTestRegime,
     /,
@@ -209,59 +199,61 @@ def compute_upp_test_arrays(
         configuration to use for generating UPP tests
 
     """
-    _g_bar, _divr_bar, _cmcr_bar, _ipr_bar = (
+    g_bar_, divr_bar_, cmcr_bar_, ipr_bar_ = (
         getattr(_upp_test_parms, _f) for _f in ("guppi", "divr", "cmcr", "ipr")
     )
 
-    _guppi_array, _ipr_array, _cmcr_array = (
-        np.empty_like(_market_data.price_array) for _ in range(3)
+    guppi_array, ipr_array, cmcr_array = (
+        np.empty_like(_market_data_sample.price_array) for _ in range(3)
     )
 
     np.einsum(
         "ij,ij,ij->ij",
-        _market_data.divr_array,
-        _market_data.pcm_array[:, ::-1],
-        _market_data.price_array[:, ::-1] / _market_data.price_array,
-        out=_guppi_array,
+        _market_data_sample.divr_array,
+        _market_data_sample.pcm_array[:, ::-1],
+        _market_data_sample.price_array[:, ::-1] / _market_data_sample.price_array,
+        out=guppi_array,
     )
 
     np.divide(
-        np.einsum("ij,ij->ij", _market_data.pcm_array, _market_data.divr_array),
-        1 - _market_data.divr_array,
-        out=_ipr_array,
+        np.einsum(
+            "ij,ij->ij", _market_data_sample.pcm_array, _market_data_sample.divr_array
+        ),
+        1 - _market_data_sample.divr_array,
+        out=ipr_array,
     )
 
-    np.divide(_ipr_array, 1 - _market_data.pcm_array, out=_cmcr_array)
+    np.divide(ipr_array, 1 - _market_data_sample.pcm_array, out=cmcr_array)
 
-    (_divr_test_vector,) = _compute_test_array_seq(
-        (_market_data.divr_array,),
-        _market_data.frmshr_array,
+    (divr_test_vector,) = _compute_test_array_seq(
+        (_market_data_sample.divr_array,),
+        _market_data_sample.frmshr_array,
         _sim_test_regime.divr_aggregator,
     )
 
-    (_guppi_test_vector, _cmcr_test_vector, _ipr_test_vector) = _compute_test_array_seq(
-        (_guppi_array, _cmcr_array, _ipr_array),
-        _market_data.frmshr_array,
+    (guppi_test_vector, cmcr_test_vector, ipr_test_vector) = _compute_test_array_seq(
+        (guppi_array, cmcr_array, ipr_array),
+        _market_data_sample.frmshr_array,
         _sim_test_regime.guppi_aggregator,
     )
-    del _cmcr_array, _ipr_array, _guppi_array
+    del cmcr_array, ipr_array, guppi_array
 
     if _sim_test_regime.resolution == INVResolution.ENFT:
-        _upp_test_arrays = UPPTestsRaw(
-            _guppi_test_vector >= _g_bar,
-            (_guppi_test_vector >= _g_bar) | (_divr_test_vector >= _divr_bar),
-            _cmcr_test_vector >= _cmcr_bar,
-            _ipr_test_vector >= _ipr_bar,
+        upp_test_arrays = UPPTestsRaw(
+            guppi_test_vector >= g_bar_,
+            (guppi_test_vector >= g_bar_) | (divr_test_vector >= divr_bar_),
+            cmcr_test_vector >= cmcr_bar_,
+            ipr_test_vector >= ipr_bar_,
         )
     else:
-        _upp_test_arrays = UPPTestsRaw(
-            _guppi_test_vector < _g_bar,
-            (_guppi_test_vector < _g_bar) & (_divr_test_vector < _divr_bar),
-            _cmcr_test_vector < _cmcr_bar,
-            _ipr_test_vector < _ipr_bar,
+        upp_test_arrays = UPPTestsRaw(
+            guppi_test_vector < g_bar_,
+            (guppi_test_vector < g_bar_) & (divr_test_vector < divr_bar_),
+            cmcr_test_vector < cmcr_bar_,
+            ipr_test_vector < ipr_bar_,
         )
 
-    return _upp_test_arrays
+    return upp_test_arrays
 
 
 def _compute_test_array_seq(
@@ -272,119 +264,52 @@ def _compute_test_array_seq(
     _wt_array = (
         _wt_array / np.einsum("ij->i", _wt_array)[:, None]
         if _aggregator
-        in (
+        in {
             UPPAggrSelector.CPA,
             UPPAggrSelector.CPD,
             UPPAggrSelector.OSA,
             UPPAggrSelector.OSD,
-        )
+        }
         else np.array([0.5, 0.5], float)
     )
 
     match _aggregator:
         case UPPAggrSelector.AVG:
-            _test_array_seq = (
+            test_array_seq = (
                 1 / 2 * np.einsum("ij->i", _g)[:, None] for _g in _test_measure_seq
             )
         case UPPAggrSelector.CPA:
-            _test_array_seq = (
+            test_array_seq = (
                 np.einsum("ij,ij->i", _wt_array[:, ::-1], _g)[:, None]
                 for _g in _test_measure_seq
             )
         case UPPAggrSelector.CPD:
-            _test_array_seq = (
+            test_array_seq = (
                 np.sqrt(np.einsum("ij,ij,ij->i", _wt_array[:, ::-1], _g, _g))[:, None]
                 for _g in _test_measure_seq
             )
         case UPPAggrSelector.DIS:
-            _test_array_seq = (
+            test_array_seq = (
                 np.sqrt(1 / 2 * np.einsum("ij,ij->i", _g, _g))[:, None]
                 for _g in _test_measure_seq
             )
         case UPPAggrSelector.MAX:
-            _test_array_seq = (
-                _g.max(axis=1, keepdims=True) for _g in _test_measure_seq
-            )
+            test_array_seq = (_g.max(axis=1, keepdims=True) for _g in _test_measure_seq)
         case UPPAggrSelector.MIN:
-            _test_array_seq = (
-                _g.min(axis=1, keepdims=True) for _g in _test_measure_seq
-            )
+            test_array_seq = (_g.min(axis=1, keepdims=True) for _g in _test_measure_seq)
         case UPPAggrSelector.OSA:
-            _test_array_seq = (
+            test_array_seq = (
                 np.einsum("ij,ij->i", _wt_array, _g)[:, None]
                 for _g in _test_measure_seq
             )
         case UPPAggrSelector.OSD:
-            _test_array_seq = (
+            test_array_seq = (
                 np.sqrt(np.einsum("ij,ij,ij->i", _wt_array, _g, _g))[:, None]
                 for _g in _test_measure_seq
             )
         case _:
             raise ValueError("GUPPI/diversion ratio aggregation method is invalid.")
-    return tuple(_test_array_seq)
-
-
-def initialize_hd5(
-    _h5_path: Path, _hmg_pub_year: HMGPubYear, _test_regime: UPPTestRegime, /
-) -> tuple[SaveData, str]:
-    _h5_title = f"HMG version: {_hmg_pub_year}; Test regime: {_test_regime}"
-    if _h5_path.is_file():
-        _h5_path.unlink()
-    _h5_file = ptb.open_file(_h5_path, mode="w", title=_h5_title)
-    _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__),
-    )
-    return _save_data_to_file, _next_subgroup_name_root
-
-
-def save_data_to_hdf5(
-    _dclass: DataclassInstance,
-    /,
-    *,
-    saved_array_name_suffix: str | None = "",
-    excluded_attrs: Sequence[str] | None = (),
-    save_data_to_file: SaveData = False,
-) -> None:
-    if save_data_to_file:
-        _, _h5_file, _h5_group = save_data_to_file
-        # Save market data arrays
-        excluded_attrs = excluded_attrs or ()
-        for _array_name in _dclass.__dataclass_fields__:
-            if _array_name in excluded_attrs:
-                continue
-            save_array_to_hdf5(
-                getattr(_dclass, _array_name),
-                _array_name,
-                _h5_group,
-                _h5_file,
-                saved_array_name_suffix=saved_array_name_suffix,
-            )
-
-
-def save_array_to_hdf5(
-    _array_obj: NDArray[Any],
-    _array_name: str,
-    _h5_group: ptb.Group,
-    _h5_file: ptb.File,
-    /,
-    *,
-    saved_array_name_suffix: str | None = None,
-) -> None:
-    _h5_array_name = f"{_array_name}_{saved_array_name_suffix or ''}".rstrip("_")
-
-    with suppress(ptb.NoSuchNodeError):
-        _h5_file.remove_node(_h5_group, name=_array_name)
-
-    _h5_array = ptb.CArray(
-        _h5_group,
-        _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),
-    )
-    _h5_array[:] = _array_obj
+    return tuple(test_array_seq)
 
 
 if __name__ == "__main__":

{mergeron-2025.739290.2.dist-info → mergeron-2025.739290.4.dist-info}/METADATA

@@ -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.4.dist-info/RECORD

@@ -0,0 +1,24 @@
+mergeron/__init__.py,sha256=AEuHY5uWPKWw8LDwGoe1vKTgwi0CAYKUsvLqzyYfY94,4269
+mergeron/core/__init__.py,sha256=pn8s3Tg1IM-ZSIRjKt4suJyPkHtt4fT7GSySzXBClWE,3082
+mergeron/core/empirical_margin_distribution.py,sha256=DFblaHUA6iXbU3L022fOSw39h9FVqJq8BOnxo4SCBTw,9474
+mergeron/core/ftc_merger_investigations_data.py,sha256=y-CmeXKC8IY5f9iTJ0RIdFAsZFpvN2KM8h2uNiLx2Mk,28485
+mergeron/core/guidelines_boundaries.py,sha256=4VikatoJAqJnUkw6Y01ow2ym-BmTZZ7r_i01PoU5ULE,15730
+mergeron/core/guidelines_boundary_functions.py,sha256=hKYvmAY4ev1N_eOP533VrsMwX0PKvVHceS2O40oONy0,28877
+mergeron/core/guidelines_boundary_functions_extra.py,sha256=tzYODCEh5vcR_pVwIHEsncf1v3aViehe5ZEmZkjmfwQ,16154
+mergeron/core/pseudorandom_numbers.py,sha256=6CX395445p-LP6MEBQyIajgqr44mt6oi0QPQyIVTgQw,10021
+mergeron/data/__init__.py,sha256=KtjBlZOl7jwBCAUhrTJB9PdrN39YLYytNiSUSM_gRmA,62
+mergeron/data/damodaran_margin_data.xls,sha256=Qggl1p5nkOMJI8YUXhkwXQRz-OhRSqBTzz57N0JQyYA,79360
+mergeron/data/damodaran_margin_data_serialized.zip,sha256=_oCVHI2YpG762WN5-KM5vnAS4OoAGkhP7Vd8KSWuiG8,20384
+mergeron/data/ftc_invdata.msgpack,sha256=WBFHgi7Ld4R-h2zL2Zc3TOIlKqVrbVFMH1LoI4-T-M0,264664
+mergeron/data/ftc_invdata.zip,sha256=1J74iTM1RVHTcvqv2v7H3yqeYN3vEvp4ZUszDk1oHQc,15686
+mergeron/demo/__init__.py,sha256=KtjBlZOl7jwBCAUhrTJB9PdrN39YLYytNiSUSM_gRmA,62
+mergeron/demo/visualize_empirical_margin_distribution.py,sha256=U40SYsSSghJrDgLHu91A2uRd1dqv5yDkkFM8NFYMGHM,2388
+mergeron/gen/__init__.py,sha256=J5E3Oq8PSVSL7MkEKGfdRpk15BW2hBNm3go2_BGxF6Q,21789
+mergeron/gen/data_generation.py,sha256=dPuUUGKfxYpATbCFvqVJUTbwEY7orYuznWpxrb9GQe8,17644
+mergeron/gen/data_generation_functions.py,sha256=UDh3B4FPwh4SxTdJs7-faLouf7cWUUjHarRkfJc9gjI,26408
+mergeron/gen/enforcement_stats.py,sha256=469UT7YTAo-My1lvtfMQRgbB2py8Z30hKP0HYKvyrm0,10781
+mergeron/gen/upp_tests.py,sha256=KVjGHHahdpyo5wEy0QSbSV0eSSiHHY4EOuNC_FMnsdY,9979
+mergeron/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+mergeron-2025.739290.4.dist-info/METADATA,sha256=qiFizgv4_0bMnmP-29HwF6m4oU6Ceq82LqZoPiBGd_E,14512
+mergeron-2025.739290.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+mergeron-2025.739290.4.dist-info/RECORD,,

{mergeron-2025.739290.2.dist-info → mergeron-2025.739290.4.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.0.1
+Generator: poetry-core 2.1.1
 Root-Is-Purelib: true
 Tag: py3-none-any

mergeron-2025.739290.2.dist-info/RECORD

@@ -1,23 +0,0 @@
-mergeron/__init__.py,sha256=UPdsvB_F8JjzmyClewmgX9s_vQy8CChgDoGxq9EVGsM,3515
-mergeron/core/__init__.py,sha256=qYRA1D4Gx-WSkICqiueWLWPedkWmb_CIn7fgvN7unk4,182
-mergeron/core/empirical_margin_distribution.py,sha256=byO11ROGVQcmbZVWdVJkJ906WnHhx7jcoL5BbxPmX7I,8688
-mergeron/core/ftc_merger_investigations_data.py,sha256=13yEg7L3wpR2XU4v7WAfSH-lIDk0eRv31i0LY39Fk4w,29452
-mergeron/core/guidelines_boundaries.py,sha256=1d-ToNnX-lQpcj4ucfxwwa9Vu2dcQTx8DPJKEZ7SmEM,17723
-mergeron/core/guidelines_boundary_functions.py,sha256=4vMz5DQ72fgj7leUlVJvXBrxdZAeDJP7FoGBEVXDdeQ,34866
-mergeron/core/guidelines_boundary_functions_extra.py,sha256=qL1zT-Xgj2qD2EyBRR87APoVc47MkGM02xYQhNgwEvg,11216
-mergeron/core/pseudorandom_numbers.py,sha256=8_MBHIvWjVZUN4Et7Tt3J1NzWxuzq9vtzFkycW5rBaQ,9918
-mergeron/data/__init__.py,sha256=KtjBlZOl7jwBCAUhrTJB9PdrN39YLYytNiSUSM_gRmA,62
-mergeron/data/damodaran_margin_data.xls,sha256=Qggl1p5nkOMJI8YUXhkwXQRz-OhRSqBTzz57N0JQyYA,79360
-mergeron/data/damodaran_margin_data_dict.msgpack,sha256=sr6s4L69kposEpzGI7jpPb4ULz0UpY-bEYfeNi6UlRA,57621
-mergeron/data/ftc_invdata.msgpack,sha256=WBFHgi7Ld4R-h2zL2Zc3TOIlKqVrbVFMH1LoI4-T-M0,264664
-mergeron/demo/__init__.py,sha256=KtjBlZOl7jwBCAUhrTJB9PdrN39YLYytNiSUSM_gRmA,62
-mergeron/demo/visualize_empirical_margin_distribution.py,sha256=kDwPfhsBjsQdYPyhe4KZG2guB_xHhPaCrvn8fezIz4M,2354
-mergeron/gen/__init__.py,sha256=lzUBHgkkVTF5rRTFEBPOaqiKCHx7aFVe27hkWJcs0x4,22351
-mergeron/gen/data_generation.py,sha256=IBWo-Al2ApHnjVQyIUV35x0OnoMgliJfqy5YrbBCVgo,16101
-mergeron/gen/data_generation_functions.py,sha256=RqPTjCAyYJkOvbLdbgnBJUFJ7ecE1UvPB1rvBhfimy0,26988
-mergeron/gen/enforcement_stats.py,sha256=z_Kjw1OwLue5B-tKFlmEoyGDusi9D6c77foRCmiNGqQ,11532
-mergeron/gen/upp_tests.py,sha256=VTh0rDd0cJ70MwkvRDYx27LWMaA1BPThXfd3D1HKX-E,12489
-mergeron/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-mergeron-2025.739290.2.dist-info/METADATA,sha256=qEqlP5po3UdqHSYtsEK2R8dD3y7rBsl1pM7Wqg9-0e0,14541
-mergeron-2025.739290.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-mergeron-2025.739290.2.dist-info/RECORD,,