commodutil 3.10.0__tar.gz → 4.0.0__tar.gz

commodutil-4.0.0/.gitignore

@@ -0,0 +1,27 @@
+/htmlcov/
+
+# Local IDE / agent state (should not be committed)
+.idea/
+.system/
+
+### Distribution / packaging
+build/
+dist/
+*.egg-info/
+.worktrees/
+
+### Byte-compiled
+__pycache__/
+*.py[cod]
+*.so
+
+### Test / coverage
+.pytest_cache/
+.mypy_cache/
+.coverage
+coverage.xml
+
+### IDE
+.vscode/
+
+scripts/

{commodutil-3.10.0 → commodutil-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commodutil
-Version: 3.10.0
+Version: 4.0.0
 Summary: common commodity/oil analytics utils
 Author-email: aeorxc <author@example.com>
 Project-URL: Homepage, https://dev.azure.com/RWEST-MFI-TE/Oil/_git/commodutil

{commodutil-3.10.0 → commodutil-4.0.0}/commodutil/convfactors.py

@@ -11,6 +11,8 @@ from dataclasses import dataclass
 import pandas as pd
 from functools import lru_cache
 
+from commodutil.standards.units import to_pint_token as _to_pint_token
+
 logger = logging.getLogger(__name__)
 
 # Initialize pint with custom definitions
@@ -468,37 +470,13 @@ class CommodityConverter:
             return False
 
     def _normalize_unit(self, unit: str) -> str:
-        """Normalize common aliases and fix encoding issues.
+        """Normalize a unit string into a pint-parseable token.
 
-        - Map 'm��'/'m³'/'m**3'/'cubic_meter' -> 'm^3'
-        - Map energy aliases 'BTU' -> 'Btu', 'MMBTU' -> 'MMBtu'
-        - Trim whitespace
+        Thin shim around :func:`commodutil.standards.units.to_pint_token`.
+        Kept as a bound method because it has six internal call sites and
+        is exercised by the public test surface (``converter._normalize_unit``).
         """
-        if unit is None:
-            return unit
-        u = unit.strip()
-        # Fix cubic meter notations and encoding issues
-        replacements = {
-            "m��": "m^3",
-            "m³": "m^3",
-            "m**3": "m^3",
-            "cubic_meter": "m^3",
-            "CUBIC_METER": "m^3",
-        }
-        for bad, good in replacements.items():
-            u = u.replace(bad, good)
-
-        # Additional robust normalizations using ASCII-only fallbacks
-        if u.lower() == "m3":
-            u = "m^3"
-        # Handle rate-style variants like 'm3/day' or 'M3/day'
-        u = u.replace("m3/", "m^3/").replace("M3/", "m^3/")
-        # Energy unit common uppercase forms
-        if u == "BTU":
-            u = "Btu"
-        if u == "MMBTU":
-            u = "MMBtu"
-        return u
+        return _to_pint_token(unit)
 
     @property
     def available_commodities(self) -> list:

commodutil-4.0.0/commodutil/standards/__init__.py

@@ -0,0 +1,86 @@
+"""commodutil.standards: canonical vocabularies for commodity trading.
+
+Re-exports the public surface of each submodule so callers can write
+`from commodutil.standards import normalize_region` instead of reaching
+into the submodule directly.
+"""
+
+from commodutil.standards.analysis_types import (
+    ANALYSIS_TYPES,
+    infer_analysis_type,
+)
+from commodutil.standards.commodities import (
+    COMMODITY_CONVERSION_MAP,
+    COMMODITY_KEYWORDS,
+    infer_commodity_and_group,
+    infer_commodity_from_exchange_symbol,
+    normalize_commodity_for_conversion,
+)
+from commodutil.standards.commodity_groups import (
+    COMMODITY_GROUPS,
+    VALID_COMMODITY_GROUPS,
+    is_valid_commodity_group,
+)
+from commodutil.standards.currency import (
+    CURRENCY_MAP,
+    FRACTIONAL_CURRENCY_DIVISORS,
+    FRACTIONAL_TO_MAJOR,
+    VALID_CURRENCY_TOKENS,
+    fractional_to_major,
+    is_fractional_currency,
+    required_fx_pair,
+    split_currency_unit,
+    to_symbol,
+)
+from commodutil.standards.regions import (
+    CRUDE_GRADE_REGIONS,
+    REGION_PATTERNS,
+    VALID_CRUDE_GRADE_REGIONS,
+    VALID_REGIONS,
+    is_crude_grade_region,
+    is_valid_region,
+    normalize_region,
+)
+from commodutil.standards.units import (
+    UNIT_MAP,
+    default_unit_for_commodity,
+    to_pint_token,
+)
+
+__all__ = [
+    # analysis_types
+    "ANALYSIS_TYPES",
+    "infer_analysis_type",
+    # commodities
+    "COMMODITY_CONVERSION_MAP",
+    "COMMODITY_KEYWORDS",
+    "infer_commodity_and_group",
+    "infer_commodity_from_exchange_symbol",
+    "normalize_commodity_for_conversion",
+    # commodity_groups
+    "COMMODITY_GROUPS",
+    "VALID_COMMODITY_GROUPS",
+    "is_valid_commodity_group",
+    # currency
+    "CURRENCY_MAP",
+    "FRACTIONAL_CURRENCY_DIVISORS",
+    "FRACTIONAL_TO_MAJOR",
+    "VALID_CURRENCY_TOKENS",
+    "fractional_to_major",
+    "is_fractional_currency",
+    "required_fx_pair",
+    "split_currency_unit",
+    "to_symbol",
+    # regions
+    "CRUDE_GRADE_REGIONS",
+    "REGION_PATTERNS",
+    "VALID_CRUDE_GRADE_REGIONS",
+    "VALID_REGIONS",
+    "is_crude_grade_region",
+    "is_valid_region",
+    "normalize_region",
+    # units
+    "UNIT_MAP",
+    "default_unit_for_commodity",
+    "to_pint_token",
+]

commodutil-4.0.0/commodutil/standards/commodities.py

@@ -0,0 +1,208 @@
+"""commodutil.standards.commodities: canonical commodity vocabulary.
+
+Owns:
+- COMMODITY_KEYWORDS: ordered list of (display_name, group, [keywords])
+  used by free-text inference. Ordering matters — "Natural Gasoline"
+  must precede "Natural Gas" so the substring "natural gas" inside
+  "natural gasoline" doesn't win.
+- COMMODITY_CONVERSION_MAP: display_name -> commodutil.convfactors.COMMODITIES
+  key, for downstream conversion routing.
+- infer_commodity_and_group(text): free-text inference helper that walks
+  COMMODITY_KEYWORDS in order and returns the first hit.
+- normalize_commodity_for_conversion(commodity): map a free-form commodity
+  string to a commodutil.convfactors conversion key.
+- infer_commodity_from_exchange_symbol(symbol): last-resort short-substring
+  fallback for raw exchange symbols (e.g. "CL_Mar25" -> "crude").
+
+Previously lived in curvemetadata.common_maps / curvemetadata.taxonomy;
+relocated to eliminate divergence risk between curvemetadata and
+commodutil's commodity lists.
+"""
+
+from __future__ import annotations
+
+
+COMMODITY_KEYWORDS = [
+    ("Brent", "Crude Oil", ["brent"]),
+    ("WTI", "Crude Oil", ["wti"]),
+    ("Crude Oil", "Crude Oil", ["crude oil", "crude"]),
+    # NB: 'Natural Gasoline' MUST come before 'Natural Gas' — the substring
+    # "natural gas" is contained in "natural gasoline" and would otherwise win.
+    ("Natural Gasoline", "NGL", ["natural gasoline"]),
+    ("Natural Gas", "Natural Gas", ["natural gas", "nat gas", "natgas"]),
+    ("Jet", "Refined Products", ["jet fuel", "jet"]),
+    ("Diesel", "Refined Products", ["diesel", "ulsd", "gasoil", "heating oil"]),
+    ("Gasoline", "Refined Products", ["gasoline", "rbob", "cbob", "mogas", "eurobob"]),
+    ("Fuel Oil", "Refined Products", ["fuel oil", "hsfo", "lsfo", "marine fuel"]),
+    ("Naphtha", "Refined Products", ["naphtha"]),
+    ("Product Basket", "Refined Products", ["refined products", "product basket"]),
+    ("VGO", "Refined Products", ["vgo"]),
+    ("FAME", "Biofuel", ["fame"]),
+    ("HVO", "Biofuel", ["hvo"]),
+    ("Isobutane", "NGL", ["isobutane"]),
+    ("Butane", "NGL", ["butane"]),
+    ("Ethane", "NGL", ["ethane"]),
+    ("Propane", "NGL", ["propane"]),
+    ("NGL", "NGL", ["ngl"]),
+    ("FFA", "Freight", ["freight", "ffa"]),
+]
+
+COMMODITY_CONVERSION_MAP = {
+    "Crude Oil": "crude",
+    "Brent": "crude",
+    "WTI": "crude",
+    "Natural Gas": "natgas",
+    "Jet": "jet",
+    "Diesel": "diesel",
+    "Gasoline": "gasoline",
+    "Fuel Oil": "fuel_oil",
+    "Naphtha": "naphtha",
+    "Product Basket": "product_basket",
+    "VGO": "vgo",
+    "FAME": "fame",
+    "HVO": "hvo",
+    # NGL species — switched from the generic 'lpg' blend to first-class species
+    # in commodutil 2026-05 (each has its own density / HHV for $/gal<->$/MMBtu).
+    # Keep the generic 'NGL' bucket on 'lpg' as a safe blend default.
+    "Natural Gasoline": "natural_gasoline",
+    "Isobutane": "isobutane",
+    "Butane": "butane",
+    "Propane": "propane",
+    "NGL": "lpg",
+    "Ethane": "ethane",
+}
+
+
+def _normalize_text(value: str) -> str:
+    """Normalise text for keyword matching: lowercase, replace separators, collapse whitespace.
+
+    Args:
+        value: Input text string.
+
+    Returns:
+        Normalised lowercase text with single spaces and no `/` or `-` separators.
+    """
+    text = value.strip().lower()
+    text = text.replace("/", " ").replace("-", " ")
+    text = " ".join(text.split())
+    return text
+
+
+def infer_commodity_and_group(
+    text: Optional[str],
+) -> tuple[Optional[str], Optional[str]]:
+    """Infer commodity and group from free-form text using COMMODITY_KEYWORDS.
+
+    Args:
+        text: Product name or description text.
+
+    Returns:
+        Tuple of (commodity_name, group_name), or (None, None) if not found.
+
+    Examples:
+        >>> infer_commodity_and_group("ICE Brent Crude Futures")
+        ('Brent', 'Crude Oil')
+        >>> infer_commodity_and_group("Henry Hub Natural Gas")
+        ('Natural Gas', 'Natural Gas')
+        >>> infer_commodity_and_group("Natural Gasoline OPIS")
+        ('Natural Gasoline', 'NGL')
+        >>> infer_commodity_and_group("Unknown Widget") == (None, None)
+        True
+    """
+    if not text:
+        return None, None
+    haystack = _normalize_text(str(text))
+    for commodity_name, group_name, keywords in COMMODITY_KEYWORDS:
+        for keyword in keywords:
+            if keyword in haystack:
+                return commodity_name, group_name
+    return None, None
+
+
+def normalize_commodity_for_conversion(commodity: Optional[str]) -> Optional[str]:
+    """Normalise a free-form commodity string to a commodutil conversion key.
+
+    Args:
+        commodity: Commodity name (free-form text or canonical display name).
+
+    Returns:
+        Normalised key for use with commodutil.convfactors conversion
+        functions (e.g. ``"crude"``, ``"natgas"``), or ``None`` for empty
+        input. Falls back to a slugged form of the input if no
+        COMMODITY_KEYWORDS hit.
+
+    Examples:
+        >>> normalize_commodity_for_conversion("Brent")
+        'crude'
+        >>> normalize_commodity_for_conversion("ICE Brent Crude")
+        'crude'
+        >>> normalize_commodity_for_conversion(None) is None
+        True
+    """
+    if not commodity:
+        return None
+
+    text = _normalize_text(str(commodity))
+
+    commodity_name, _ = infer_commodity_and_group(text)
+    if commodity_name:
+        mapped = COMMODITY_CONVERSION_MAP.get(commodity_name)
+        if mapped:
+            return mapped
+        return _normalize_text(commodity_name).replace(" ", "_")
+
+    return text.replace(" ", "_")
+
+
+def infer_commodity_from_exchange_symbol(symbol: Optional[str]) -> Optional[str]:
+    """Infer commodity from a raw exchange symbol name (loose substring match).
+
+    Last-resort fallback when description-based ``infer_commodity_and_group``
+    fails (no Description, or Description didn't match COMMODITY_KEYWORDS).
+    Mirrors legacy substring-fallback logic that lived inline in
+    ``pyoilprice.conversion`` and then in ``curvemetadata.taxonomy``. Patterns
+    are SHORT substrings (cl, rb, ho, ng) matched anywhere in the input —
+    ``"close_value"`` will match ``cl`` and return ``"crude"``. This is
+    acceptable on raw exchange-symbol identifiers (which are short and
+    predictable) but **UNSAFE on free-text inputs** — use
+    ``infer_commodity_and_group()`` for descriptions or product names.
+
+    Returns:
+        Canonical commodity name ('crude' / 'gasoline' / 'gasoil' / 'natgas')
+        or None if no match.
+
+    Examples (raw exchange symbols only):
+        >>> infer_commodity_from_exchange_symbol("CL_Mar25")
+        'crude'
+        >>> infer_commodity_from_exchange_symbol("ICE_EuroFutures:BRN")
+        'crude'
+        >>> infer_commodity_from_exchange_symbol("RBOB_Apr25")
+        'gasoline'
+        >>> infer_commodity_from_exchange_symbol("HO_May25")
+        'gasoil'
+        >>> infer_commodity_from_exchange_symbol("NG_Jun25")
+        'natgas'
+        >>> infer_commodity_from_exchange_symbol("XYZ_Spot") is None
+        True
+    """
+    if not symbol:
+        return None
+    s = str(symbol).lower()
+    if any(x in s for x in ["cl", "wti", "brent", "brn"]):
+        return "crude"
+    if any(x in s for x in ["rb", "gasoline", "mogas"]):
+        return "gasoline"
+    if any(x in s for x in ["ho", "diesel", "gasoil"]):
+        return "gasoil"
+    if any(x in s for x in ["ng", "natural"]):
+        return "natgas"
+    return None
+
+
+__all__ = [
+    "COMMODITY_KEYWORDS",
+    "COMMODITY_CONVERSION_MAP",
+    "infer_commodity_and_group",
+    "normalize_commodity_for_conversion",
+    "infer_commodity_from_exchange_symbol",
+]

{commodutil-3.10.0 → commodutil-4.0.0}/commodutil/standards/currency.py

@@ -210,10 +210,36 @@ def to_symbol(code: Optional[str]) -> str:
     return _SYMBOLS.get(str(code), str(code))
 
 
+# ---- Vendor-spec free-text -> canonical-token map ------------------------
+#
+# Maps lowercase free-form currency phrases (as they appear in CME/ICE
+# contract spec descriptions) to canonical ISO 4217 codes. Used by
+# vendor-spec parsers (e.g. curvemetadata.ice_util.map_currency) to lift
+# strings like "US Dollars and Cents" -> "USD". Keys are matched
+# case-insensitively at call time — callers should lowercase input.
+#
+# Lifted from curvemetadata.common_maps so commodutil owns the single
+# source of truth for currency-token vocabulary.
+CURRENCY_MAP = {
+    "us dollars and cents": "USD",
+    "u.s. dollars and cents": "USD",
+    "us dollars": "USD",
+    "u.s. dollars": "USD",
+    "usd": "USD",
+    "euros": "EUR",
+    "euro": "EUR",
+    "pounds sterling": "GBP",
+    "british pounds": "GBP",
+    "canadian dollars": "CAD",
+    "cad": "CAD",
+}
+
+
 __all__ = [
     "VALID_CURRENCY_TOKENS",
     "FRACTIONAL_TO_MAJOR",
     "FRACTIONAL_CURRENCY_DIVISORS",
+    "CURRENCY_MAP",
     "is_fractional_currency",
     "fractional_to_major",
     "split_currency_unit",

{commodutil-3.10.0 → commodutil-4.0.0}/commodutil/standards/regions.py

@@ -29,6 +29,8 @@ REGION_PATTERNS = [
     ("ARA", ["ara"]),
     ("Med", ["mediterranean", "med"]),
     ("Sing", ["singapore", "sing"]),
+    ("MEG", ["meg", "middle east gulf", "arabian gulf", "persian gulf"]),
+    ("Japan", ["japan"]),
 ]
 
 # Canonical region codes as frozenset for fast membership checks
@@ -60,8 +62,15 @@ def normalize_region(text: Optional[str]) -> Optional[str]:
 
     lower = text.lower()
 
-    # RBOB convention: always NY Harbor
-    if "rbob" in lower:
+    # CARBOB short-circuit: California Reformulated Blendstock for Oxygenate
+    # Blending — Los Angeles / US West Coast, NOT NY Harbor. Must run BEFORE
+    # the RBOB check so "carbob" doesn't fall through to the NYH heuristic.
+    if re.search(r"\bcarbob\b", lower):
+        return "LA"
+
+    # RBOB convention: always NY Harbor. Use word boundary so "carbob" (which
+    # has 'a' before 'rbob' — no word boundary) does not match here.
+    if re.search(r"\brbob\b", lower):
         return "NYH"
 
     # Pattern-match against REGION_PATTERNS
@@ -90,9 +99,109 @@ def is_valid_region(code: str) -> bool:
     return code in VALID_REGIONS
 
 
+# ---- Crude grade regions ----
+#
+# Producer-region groupings for crude grades, used by crude-differentials
+# charts. Lifted from oilpricingcharts.symbols_config_crudediffs (keys kept
+# byte-identical to the source so chart configs can switch over without
+# re-mapping). Values are ordered tuples of display grade names — they are
+# NOT pricing symbols and do NOT carry vendor (Platts/Argus) IDs. Symbol
+# resolution stays in the chart-config layer.
+CRUDE_GRADE_REGIONS = {
+    "north_sea": (
+        "Forties",
+        "Oseberg",
+        "Ekofisk",
+        "Troll",
+        "Johan Sverdrup",
+        "FOB N Sea WTI Midland",
+    ),
+    "waf": (
+        "Bonny Light",
+        "Forcados",
+        "Qua Iboe",
+        "Cabinda",
+        "Doba",
+    ),
+    "nafrica": (
+        "Nile Blend",
+        "Dar Blend",
+        "Es Sider",
+    ),
+    "russian": (
+        "Urals Rott",
+        "Urals Med",
+        "ESPO",
+        "Siberian Light",
+        "Sokol",
+    ),
+    "us_midcon": (
+        "Bakken Clearbook",
+        "Light Sweet Guernsey",
+        "Denver Julesburg Light",
+    ),
+    "us_texas": (
+        "WTI Houston",
+        "WTI Midland",
+        "WTS",
+        "Southern Green Canyon",
+        "WCS Houston",
+    ),
+    "us_louisiana": (
+        "LLS",
+        "HLS",
+        "Thunder Horse",
+        "Poseidon",
+        "Mars",
+    ),
+    "canadian": (
+        "WCS",
+        "CDB",
+        "AWB",
+        "CLK",
+        "MSW",
+        "Syn",
+    ),
+    "latam_wti": (
+        "Vasconia",
+        "Castilla",
+        "Maya",
+        "Liza",
+        "Buzios",
+        "Mero",
+        "Tupi",
+        "Unity Gold",
+    ),
+    "asia_pacific": (
+        "Tapis",
+        "Duri",
+        "Vincent",
+    ),
+    "middle_east": (
+        "Dubai",
+        "Oman",
+        "Murban",
+        "Al Shaheen",
+        "Upper Zakum",
+        "Qatar Land",
+        "Qatar Marine",
+    ),
+}
+
+VALID_CRUDE_GRADE_REGIONS = frozenset(CRUDE_GRADE_REGIONS.keys())
+
+
+def is_crude_grade_region(key: str) -> bool:
+    """Return True if key is a canonical crude grade-region key."""
+    return key in VALID_CRUDE_GRADE_REGIONS
+
+
 __all__ = [
     "REGION_PATTERNS",
     "VALID_REGIONS",
     "normalize_region",
     "is_valid_region",
+    "CRUDE_GRADE_REGIONS",
+    "VALID_CRUDE_GRADE_REGIONS",
+    "is_crude_grade_region",
 ]

commodutil-4.0.0/commodutil/standards/units.py

@@ -0,0 +1,125 @@
+"""commodutil.standards.units: canonical unit vocabulary.
+
+Owns:
+- UNIT_MAP: alias -> canonical unit map for normalising free-form unit
+  strings from vendor contract specs ("barrel", "Barrels", "BBL" -> "bbl").
+- default_unit_for_commodity(): returns the canonical quoted unit for a
+  commodity (volume basis).
+- to_pint_token(): cleans a unit string into a form pint can parse
+  (encoding fixes, cubic-meter notation, BTU casing, whitespace).
+
+Pure string-shaped — no pint imports, no pandas. The pint registry in
+commodutil.convfactors handles unit algebra. Two sibling normalisation
+layers live here:
+
+1. Vocab normalisation (UNIT_MAP): free-form vendor text -> canonical
+   token. Used pre-pint by vendor-spec parsers (curvemetadata).
+2. Pint-token normalisation (to_pint_token): canonical token -> pint-
+   parseable string. Used by commodutil.convfactors before feeding the
+   pint registry.
+
+They solve different problems and do NOT share a vocabulary; see the
+merge plan in commodutil 3.11.0 notes for the trade-off discussion.
+"""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+# ---- Alias -> canonical normalisation ----
+
+# Maps lowercase aliases (singular / plural / abbreviated forms) to the
+# canonical unit token used by downstream code. Used by vendor-spec
+# parsers (e.g. curvemetadata.ice_util.parse_unit). Keys are matched
+# case-insensitively at call time -- callers should lowercase input.
+UNIT_MAP = {
+    "barrel": "bbl",
+    "barrels": "bbl",
+    "bbl": "bbl",
+    "bbls": "bbl",
+    "gallon": "gal",
+    "gallons": "gal",
+    "gal": "gal",
+    "metric ton": "mt",
+    "metric tons": "mt",
+    "metric tonne": "mt",
+    "metric tonnes": "mt",
+    "tonne": "mt",
+    "tonnes": "mt",
+}
+
+
+# ---- Default unit per commodity ----
+
+_DEFAULT_UNIT = {
+    "natgas": "mmbtu",
+    "natural_gas": "mmbtu",
+    "gasoline": "gal",
+    "diesel": "gal",
+    "jet": "gal",
+}
+
+
+def default_unit_for_commodity(commodity: Optional[str]) -> str:
+    """Return the canonical quoted unit for a commodity (volume basis).
+
+    Falls back to 'bbl' for any commodity not in the explicit map (covers
+    crude / fuel oil / naphtha / VGO / NGL species etc.).
+    """
+    if not commodity:
+        return "bbl"
+    return _DEFAULT_UNIT.get(str(commodity).lower(), "bbl")
+
+
+# ---- Pint-token normalisation ----
+
+
+def to_pint_token(unit: Optional[str]) -> Optional[str]:
+    """Normalize a unit string into a pint-parseable token.
+
+    Fixes ASCII / encoding / casing pitfalls so the resulting string can
+    be fed to ``pint.UnitRegistry`` without raising. Does NOT canonicalise
+    to the bbl/gal/mt vocabulary (that's UNIT_MAP's job).
+
+    Rules:
+    - ``None`` -> ``None`` (passthrough).
+    - Strip whitespace.
+    - Cubic-meter notations: ``m��`` / ``m³`` / ``m**3`` / ``cubic_meter``
+      / ``CUBIC_METER`` / ``m3`` (case-insensitive exact match) -> ``m^3``.
+    - Rate forms: ``m3/...`` / ``M3/...`` -> ``m^3/...``.
+    - Energy casing: ``BTU`` -> ``Btu``; ``MMBTU`` -> ``MMBtu``.
+
+    Other tokens pass through unchanged. Aliases like ``barrel``, ``tonne``,
+    ``gallon`` are not handled here -- they are registered as pint aliases
+    in commodutil.convfactors at module load and resolved by the pint
+    registry itself.
+    """
+    if unit is None:
+        return unit
+    u = unit.strip()
+    # Fix cubic meter notations and encoding issues
+    replacements = {
+        "m��": "m^3",  # UTF-8 mojibake of m^3 written as "m??"
+        "m³": "m^3",
+        "m**3": "m^3",
+        "cubic_meter": "m^3",
+        "CUBIC_METER": "m^3",
+    }
+    for bad, good in replacements.items():
+        u = u.replace(bad, good)
+
+    # Additional robust normalizations using ASCII-only fallbacks
+    if u.lower() == "m3":
+        u = "m^3"
+    # Handle rate-style variants like 'm3/day' or 'M3/day'
+    u = u.replace("m3/", "m^3/").replace("M3/", "m^3/")
+    # Energy unit common uppercase forms
+    if u == "BTU":
+        u = "Btu"
+    if u == "MMBTU":
+        u = "MMBtu"
+    return u
+
+
+__all__ = ["UNIT_MAP", "default_unit_for_commodity", "to_pint_token"]

{commodutil-3.10.0 → commodutil-4.0.0}/commodutil.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: commodutil
-Version: 3.10.0
+Version: 4.0.0
 Summary: common commodity/oil analytics utils
 Author-email: aeorxc <author@example.com>
 Project-URL: Homepage, https://dev.azure.com/RWEST-MFI-TE/Oil/_git/commodutil