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

mergeron/core/guidelines_boundaries.py

@@ -7,12 +7,11 @@ with a canvas on which to draw boundaries for Guidelines standards.
 from __future__ import annotations
 
 import decimal
-from dataclasses import dataclass
 from typing import Literal
 
 import numpy as np
 from attrs import Attribute, field, frozen, validators
-from mpmath import mp, mpf  # type: ignore
+from mpmath import mp  # type: ignore
 from ruamel import yaml
 
 from .. import (  # noqa: TID252
@@ -23,6 +22,8 @@ from .. import (  # noqa: TID252
     RECForm,
     UPPAggrSelector,
     this_yaml,
+    yamelize_attrs,
+    yaml_rt_mapper,
 )
 from . import guidelines_boundary_functions as gbfn
 
@@ -33,7 +34,7 @@ mp.dps = 32
 mp.trap_complex = True
 
 
-@dataclass(frozen=True)
+@frozen
 class HMGThresholds:
     delta: float
     fc: float
@@ -43,21 +44,6 @@ class HMGThresholds:
     cmcr: float
     ipr: float
 
-    @classmethod
-    def to_yaml(
-        cls, _r: yaml.representer.SafeRepresenter, _d: HMGThresholds
-    ) -> yaml.MappingNode:
-        _ret: yaml.MappingNode = _r.represent_mapping(
-            f"!{cls.__name__}", {_a: getattr(_d, _a) for _a in _d.__dataclass_fields__}
-        )
-        return _ret
-
-    @classmethod
-    def from_yaml(
-        cls, _c: yaml.constructor.SafeConstructor, _n: yaml.MappingNode
-    ) -> HMGThresholds:
-        return cls(**_c.construct_mapping(_n))
-
 
 @this_yaml.register_class
 @frozen
@@ -112,7 +98,7 @@ class GuidelinesThresholds:
         # that staff only investigates mergers that meet the presumption;
         # thus, here, the tentative delta safeharbor under
         # the 2023 Guidelines is 100 points
-        _hhi_p, _dh_s, _dh_p = {
+        hhi_p, dh_s, dh_p = {
             1982: (_s1982 := (0.18, 0.005, 0.01)),
             1984: _s1982,
             1992: _s1982,
@@ -124,18 +110,18 @@ class GuidelinesThresholds:
             self,
             "safeharbor",
             HMGThresholds(
-                _dh_s,
-                _fc := int(np.ceil(1 / _hhi_p)),
-                _r := float(_r_s := gbfn.round_cust(_fc / (_fc + 1), frac=0.05)),
-                _g := float(guppi_from_delta(_dh_s, m_star=1.0, r_bar=_r)),
-                _dr := float(1 - _r_s),
+                dh_s,
+                _fc := int(np.ceil(1 / hhi_p)),
+                _r := gbfn.round_cust(_fc / (_fc + 1), frac=0.05),
+                _g := guppi_from_delta(dh_s, m_star=1.0, r_bar=_r),
+                _dr := 1 - _r,
                 _cmcr := 0.03,  # Not strictly a Guidelines standard
                 _ipr := _g,  # Not strictly a Guidelines standard
             ),
         )
 
         object.__setattr__(
-            self, "presumption", HMGThresholds(_dh_p, _fc, _r, _g, _dr, _cmcr, _ipr)
+            self, "presumption", HMGThresholds(dh_p, _fc, _r, _g, _dr, _cmcr, _ipr)
         )
 
         # imputed_presumption is relevant for presumptions implicating
@@ -148,13 +134,9 @@ class GuidelinesThresholds:
                 HMGThresholds(
                     2 * (0.5 / _fc) ** 2,
                     _fc,
-                    float(
-                        _r_i := gbfn.round_cust(
-                            (_fc - 1 / 2) / (_fc + 1 / 2), frac=0.05
-                        )
-                    ),
+                    _r_i := gbfn.round_cust((_fc - 1 / 2) / (_fc + 1 / 2), frac=0.05),
                     _g,
-                    float((1 - _r_i) / 2),
+                    (1 - _r_i) / 2,
                     _cmcr,
                     _ipr := _g,
                 )
@@ -167,22 +149,20 @@ class GuidelinesThresholds:
 
     @classmethod
     def to_yaml(
-        cls, _r: yaml.representer.SafeRepresenter, _d: GuidelinesThresholds
+        cls, _r: yaml.representer.RoundTripRepresenter, _d: GuidelinesThresholds
     ) -> yaml.MappingNode:
-        _ret: yaml.MappingNode = _r.represent_mapping(
-            f"!{cls.__name__}",
-            {_a.name: getattr(_d, _a.name) for _a in _d.__attrs_attrs__},
+        ret: yaml.MappingNode = _r.represent_mapping(
+            f"!{cls.__name__}", {"pub_year": _d.pub_year}
         )
-        return _ret
+        return ret
 
     @classmethod
     def from_yaml(
-        cls, _c: yaml.constructor.SafeConstructor, _n: yaml.MappingNode
+        cls, _c: yaml.constructor.RoundTripConstructor, _n: yaml.MappingNode
     ) -> GuidelinesThresholds:
-        return cls(**_c.construct_mapping(_n))
+        return cls(**yaml_rt_mapper(_c, _n))
 
 
-@this_yaml.register_class
 @frozen
 class ConcentrationBoundary:
     """Concentration parameters, boundary coordinates, and area under concentration boundary."""
@@ -198,12 +178,12 @@ class ConcentrationBoundary:
     def _mnv(
         _instance: ConcentrationBoundary, _attribute: Attribute[str], _value: str, /
     ) -> None:
-        if _value not in (
+        if _value not in {
             "ΔHHI",
             "Combined share",
             "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)
@@ -228,40 +208,19 @@ class ConcentrationBoundary:
     def __attrs_post_init__(self, /) -> None:
         match self.measure_name:
             case "ΔHHI":
-                _conc_fn = gbfn.hhi_delta_boundary
+                conc_fn = gbfn.hhi_delta_boundary
             case "Combined share":
-                _conc_fn = gbfn.combined_share_boundary
+                conc_fn = gbfn.combined_share_boundary
             case "Pre-merger HHI Contribution":
-                _conc_fn = gbfn.hhi_pre_contrib_boundary
+                conc_fn = gbfn.hhi_pre_contrib_boundary
             case "Post-merger HHI Contribution":
-                _conc_fn = gbfn.hhi_post_contrib_boundary
+                conc_fn = gbfn.hhi_post_contrib_boundary
 
-        _boundary = _conc_fn(self.threshold, dps=self.precision)
-        object.__setattr__(self, "area", _boundary.area)
-        object.__setattr__(self, "coordinates", _boundary.coordinates)
+        boundary_ = conc_fn(self.threshold, dps=self.precision)
+        object.__setattr__(self, "area", boundary_.area)
+        object.__setattr__(self, "coordinates", boundary_.coordinates)
 
-    @classmethod
-    def to_yaml(
-        cls, _r: yaml.representer.SafeRepresenter, _d: ConcentrationBoundary
-    ) -> yaml.MappingNode:
-        _ret: yaml.MappingNode = _r.represent_mapping(
-            f"!{cls.__name__}",
-            {
-                _a.name: getattr(_d, _a.name)
-                for _a in _d.__attrs_attrs__
-                if _a.name not in ("area", "coordinates")
-            },
-        )
-        return _ret
 
-    @classmethod
-    def from_yaml(
-        cls, _c: yaml.constructor.SafeConstructor, _n: yaml.MappingNode
-    ) -> ConcentrationBoundary:
-        return cls(**_c.construct_mapping(_n))
-
-
-@this_yaml.register_class
 @frozen
 class DiversionRatioBoundary:
     """
@@ -373,70 +332,50 @@ class DiversionRatioBoundary:
     """Market-share pairs as Cartesian coordinates of points on the diversion ratio boundary."""
 
     def __attrs_post_init__(self, /) -> None:
-        _share_ratio = critical_share_ratio(
+        share_ratio = critical_share_ratio(
             self.diversion_ratio, r_bar=self.recapture_ratio
         )
-        _upp_agg_kwargs: gbfn.ShareRatioBoundaryKeywords = {
+        upp_agg_kwargs: gbfn.ShareRatioBoundaryKeywords = {
             "recapture_form": getattr(self.recapture_form, "value", "inside-out"),
             "dps": self.precision,
         }
 
         match self.agg_method:
             case UPPAggrSelector.DIS:
-                _upp_agg_fn = gbfn.shrratio_boundary_wtd_avg
-                _upp_agg_kwargs |= {"agg_method": "distance", "weighting": None}
+                upp_agg_fn = gbfn.shrratio_boundary_wtd_avg
+                upp_agg_kwargs |= {"agg_method": "distance", "weighting": None}
             case UPPAggrSelector.AVG:
-                _upp_agg_fn = gbfn.shrratio_boundary_xact_avg  # type: ignore
+                upp_agg_fn = gbfn.shrratio_boundary_xact_avg  # type: ignore
             case UPPAggrSelector.MAX:
-                _upp_agg_fn = gbfn.shrratio_boundary_max  # type: ignore
-                _upp_agg_kwargs = {"dps": 10}  # replace here
+                upp_agg_fn = gbfn.shrratio_boundary_max  # type: ignore
+                upp_agg_kwargs = {"dps": 10}  # replace here
             case UPPAggrSelector.MIN:
-                _upp_agg_fn = gbfn.shrratio_boundary_min  # type: ignore
-                _upp_agg_kwargs |= {"dps": 10}  # update here
+                upp_agg_fn = gbfn.shrratio_boundary_min  # type: ignore
+                upp_agg_kwargs |= {"dps": 10}  # update here
             case _:
-                _upp_agg_fn = gbfn.shrratio_boundary_wtd_avg
+                upp_agg_fn = gbfn.shrratio_boundary_wtd_avg
 
-                _aggregator: Literal["arithmetic mean", "geometric mean", "distance"]
-                if self.agg_method.value.endswith("average"):
-                    _aggregator = "arithmetic mean"
-                elif self.agg_method.value.endswith("geometric mean"):
-                    _aggregator = "geometric mean"
+                aggregator_: Literal["arithmetic mean", "geometric mean", "distance"]
+                if self.agg_method.value.endswith("geometric mean"):
+                    aggregator_ = "geometric mean"
+                elif self.agg_method.value.endswith("average"):
+                    aggregator_ = "arithmetic mean"
                 else:
-                    _aggregator = "distance"
+                    aggregator_ = "distance"
 
-                _wgt_type: Literal["cross-product-share", "own-share", None]
+                wgt_type: Literal["cross-product-share", "own-share", None]
                 if self.agg_method.value.startswith("cross-product-share"):
-                    _wgt_type = "cross-product-share"
+                    wgt_type = "cross-product-share"
                 elif self.agg_method.value.startswith("own-share"):
-                    _wgt_type = "own-share"
+                    wgt_type = "own-share"
                 else:
-                    _wgt_type = None
+                    wgt_type = None
 
-                _upp_agg_kwargs |= {"agg_method": _aggregator, "weighting": _wgt_type}
+                upp_agg_kwargs |= {"agg_method": aggregator_, "weighting": wgt_type}
 
-        _boundary = _upp_agg_fn(_share_ratio, self.recapture_ratio, **_upp_agg_kwargs)
-        object.__setattr__(self, "area", _boundary.area)
-        object.__setattr__(self, "coordinates", _boundary.coordinates)
-
-    @classmethod
-    def to_yaml(
-        cls, _r: yaml.representer.SafeRepresenter, _d: DiversionRatioBoundary
-    ) -> yaml.MappingNode:
-        _ret: yaml.MappingNode = _r.represent_mapping(
-            f"!{cls.__name__}",
-            {
-                _a.name: getattr(_d, _a.name)
-                for _a in _d.__attrs_attrs__
-                if _a.name not in ("area", "coordinates")
-            },
-        )
-        return _ret
-
-    @classmethod
-    def from_yaml(
-        cls, _c: yaml.constructor.SafeConstructor, _n: yaml.MappingNode
-    ) -> DiversionRatioBoundary:
-        return cls(**_c.construct_mapping(_n))
+        boundary_ = upp_agg_fn(share_ratio, self.recapture_ratio, **upp_agg_kwargs)
+        object.__setattr__(self, "area", boundary_.area)
+        object.__setattr__(self, "coordinates", boundary_.coordinates)
 
 
 def guppi_from_delta(
@@ -445,7 +384,7 @@ def guppi_from_delta(
     *,
     m_star: float = 1.00,
     r_bar: float = DEFAULT_REC_RATIO,
-) -> decimal.Decimal:
+) -> float:
     """
     Translate ∆HHI bound to GUPPI bound.
 
@@ -471,13 +410,13 @@ def guppi_from_delta(
 
 
 def critical_share_ratio(
-    _guppi_bound: float | decimal.Decimal = 0.075,
+    _guppi_bound: float = 0.075,
     /,
     *,
     m_star: float = 1.00,
     r_bar: float = 1.00,
     frac: float = 1e-16,
-) -> decimal.Decimal:
+) -> float:
     """
     Corollary to GUPPI bound.
 
@@ -496,18 +435,16 @@ def critical_share_ratio(
         for given margin and recapture ratio.
 
     """
-    return gbfn.round_cust(
-        mpf(f"{_guppi_bound}") / mp.fmul(f"{m_star}", f"{r_bar}"), frac=frac
-    )
+    return gbfn.round_cust(_guppi_bound / (m_star * r_bar), frac=frac)
 
 
 def share_from_guppi(
-    _guppi_bound: float | decimal.Decimal = 0.065,
+    _guppi_bound: float = 0.065,
     /,
     *,
     m_star: float = 1.00,
     r_bar: float = DEFAULT_REC_RATIO,
-) -> decimal.Decimal:
+) -> float:
     """
     Symmetric-firm share for given GUPPI, margin, and recapture ratio.
 
@@ -538,3 +475,7 @@ if __name__ == "__main__":
     print(
         "This module defines classes with methods for generating boundaries for concentration and diversion-ratio screens."
     )
+
+
+for _typ in (HMGThresholds, ConcentrationBoundary, DiversionRatioBoundary):
+    yamelize_attrs(_typ, {"coordinates", "area"})