pint-cf 0.1.0__tar.gz

pint_cf-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pedro Gámez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pint_cf-0.1.0/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: pint-cf
+Version: 0.1.0
+Summary: CF-compliant unit registry and formatter for Pint
+Author: Pedro Gámez
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pint>=0.25.2
+Requires-Dist: lark
+Dynamic: license-file
+
+# pint-cf
+
+This package extends Pint with a CF-compliant unit registry and formatter.
+
+## Features
+
+This package provides:
+
+- A CF-compliant Pint UnitRegistry, with explicit plurals.
+- A custom formatter `cf`, supporting both long and short (symbol) formats.
+
+Known limitations:
+
+- Pint does not support **time coordinates** (e.g.
+  `days since 2001-01-01`) or **climate calendars** (e.g., `360_days`).
+  Consider using [cftime](https://unidata.github.io/cftime/) for that.
+- Pint does not support **scaling factors** in Unit expressions (e.g.
+  `pint.Unit('0.1 m')`). You can work around this by adding your own
+  [unit definition](https://pint.readthedocs.io/en/stable/advanced/defining.html#programmatically).
+
+## Usage
+
+Create a CF-ready unit registry with `cf_unitregistry()`.
+This function also registers the `cf` formatter.
+
+```python
+from pint_cf import cf_unitregistry
+
+ureg = cf_unitregistry()
+print(type(ureg))  # <class 'pint.registry.UnitRegistry'>
+
+q = ureg('10 meters per second^2').to('km s-2')
+
+print(f"{q:cf}")   # 0.01 kilometer-second^-2
+print(f"{q:~cf}")  # 0.01 km/s2
+```
+
+<!-- If you prefer Pint's global application registry:
+
+```python
+import pint
+from pint_cf import cf_unitregistry
+
+ureg = cf_unitregistry()
+pint.set_application_registry(ureg)
+```
+
+After that, quantities created through `pint.get_application_registry()` will
+use the same CF configuration. -->

pint_cf-0.1.0/README.md

@@ -0,0 +1,49 @@
+# pint-cf
+
+This package extends Pint with a CF-compliant unit registry and formatter.
+
+## Features
+
+This package provides:
+
+- A CF-compliant Pint UnitRegistry, with explicit plurals.
+- A custom formatter `cf`, supporting both long and short (symbol) formats.
+
+Known limitations:
+
+- Pint does not support **time coordinates** (e.g.
+  `days since 2001-01-01`) or **climate calendars** (e.g., `360_days`).
+  Consider using [cftime](https://unidata.github.io/cftime/) for that.
+- Pint does not support **scaling factors** in Unit expressions (e.g.
+  `pint.Unit('0.1 m')`). You can work around this by adding your own
+  [unit definition](https://pint.readthedocs.io/en/stable/advanced/defining.html#programmatically).
+
+## Usage
+
+Create a CF-ready unit registry with `cf_unitregistry()`.
+This function also registers the `cf` formatter.
+
+```python
+from pint_cf import cf_unitregistry
+
+ureg = cf_unitregistry()
+print(type(ureg))  # <class 'pint.registry.UnitRegistry'>
+
+q = ureg('10 meters per second^2').to('km s-2')
+
+print(f"{q:cf}")   # 0.01 kilometer-second^-2
+print(f"{q:~cf}")  # 0.01 km/s2
+```
+
+<!-- If you prefer Pint's global application registry:
+
+```python
+import pint
+from pint_cf import cf_unitregistry
+
+ureg = cf_unitregistry()
+pint.set_application_registry(ureg)
+```
+
+After that, quantities created through `pint.get_application_registry()` will
+use the same CF configuration. -->

pint_cf-0.1.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pint-cf"
+authors = [{ name = "Pedro Gámez" }]
+description = "CF-compliant unit registry and formatter for Pint"
+dynamic = ["version"]
+readme = "README.md"
+requires-python = ">=3.12"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+dependencies = ["Pint>=0.25.2", "lark"]
+
+[dependency-groups]
+tests = ["pytest", "pytest-cov"]
+build = ["build", "twine"]
+tools = ["defusedxml"]
+dev = [
+    { include-group = "tests" },
+    { include-group = "tools" },
+    { include-group = "build" },
+    "cf-units",
+    "cfunits",
+    "prek",
+    "ruff",
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "pint_cf.__version__" }
+
+[tool.setuptools.packages.find]
+where = ["src/"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "S"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/*" = ["S101"]
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+# addopts = ""
+testpaths = ["tests"]
+pythonpath = ["src"]
+
+[tool.coverage.run]
+omit = ["tests/*", "*/__init__.py"]

pint_cf-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pint_cf-0.1.0/src/pint_cf/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.1.0"
+__all__ = [
+    "cf_unitregistry",
+]
+
+from .units import cf_unitregistry

pint_cf-0.1.0/src/pint_cf/parser.py

@@ -0,0 +1,337 @@
+"""
+UDUNITS-2 to Pint String Transformer
+
+Converts Lark parse trees from udunits2.lark into strings
+that can be parsed directly by pint.
+"""
+
+from pathlib import Path
+
+from lark import Lark, Token, Transformer, v_args
+
+# Unicode superscript to ASCII digit mapping
+_SUPERSCRIPT_MAP = {
+    "⁰": "0",
+    "¹": "1",
+    "²": "2",
+    "³": "3",
+    "⁴": "4",
+    "⁵": "5",
+    "⁶": "6",
+    "⁷": "7",
+    "⁸": "8",
+    "⁹": "9",
+    "⁺": "+",
+    "⁻": "-",
+}
+
+_ANGLE_SYMBOL_REPLACEMENTS = {
+    "'": "arc_minute",
+    '"': "arc_second",
+}
+
+
+def _decode_superscript(s: str) -> str:
+    """Convert unicode superscript characters to regular digits."""
+    return "".join(_SUPERSCRIPT_MAP.get(c, c) for c in s)
+
+
+def _normalize_identifier(name: str) -> str:
+    """Normalize UDUNITS symbols that need explicit pint unit names."""
+    for symbol, replacement in _ANGLE_SYMBOL_REPLACEMENTS.items():
+        name = name.replace(symbol, replacement)
+    return name
+
+
+def _split_id_with_exponent(token_str: str) -> tuple[str, str]:
+    """Split trailing signed integer exponent from an identifier token."""
+    idx = len(token_str)
+    while idx > 0 and token_str[idx - 1].isdigit():
+        idx -= 1
+
+    # The grammar guarantees that exponent digits exist at the end.
+    if idx == len(token_str):
+        raise ValueError(f"ID_WITH_EXP token without trailing digits: {token_str}")
+
+    if idx > 0 and token_str[idx - 1] == "-":
+        idx -= 1
+
+    base_name = token_str[:idx]
+    exponent = token_str[idx:]
+
+    if not base_name or not exponent:
+        raise ValueError(f"Invalid ID_WITH_EXP token: {token_str}")
+
+    return base_name, exponent
+
+
+@v_args(inline=True)
+class UdunitsToPintTransformer(Transformer):
+    """
+    Transform a Lark parse tree from udunits2.lark into a string
+    that pint can parse directly.
+
+    Example:
+        >>> transformer = UdunitsToPintTransformer()
+        >>> parser = get_parser()
+        >>> tree = parser.parse("kg.m/s2")
+        >>> result = transformer.transform(tree)
+        >>> print(result)  # "kg * m / s ** 2"
+    """
+
+    # -------------------------------------------------------------------------
+    # Numbers
+    # -------------------------------------------------------------------------
+
+    @staticmethod
+    def _binary_operands(args: tuple) -> tuple[str, str]:
+        """Return left/right operands for binary forms with optional operator token."""
+        if len(args) == 2:
+            return args[0], args[1]
+        if len(args) == 3:
+            return args[0], args[2]
+        raise ValueError(f"Unexpected binary args: {args}")
+
+    def int(self, value: Token) -> str:
+        """Integer literal."""
+        return str(value)
+
+    def real(self, value: Token) -> str:
+        """Real number literal."""
+        return str(value)
+
+    def scalar(self, value: str) -> str:
+        """Scalar value (passes through)."""
+        return value
+
+    # -------------------------------------------------------------------------
+    # Identifiers
+    # -------------------------------------------------------------------------
+
+    def identifier(self, name: Token) -> str:
+        """
+        Unit identifier (e.g., 'm', 'kilogram', '°').
+        """
+        return _normalize_identifier(str(name))
+
+    def power_from_id(self, name: Token) -> str:
+        """Power notation encoded in identifier token (e.g., 'm2', 's-1')."""
+        base_name, exponent = _split_id_with_exponent(str(name))
+        return f"{base_name} ** {exponent}"
+
+    # -------------------------------------------------------------------------
+    # Arithmetic operations
+    # -------------------------------------------------------------------------
+
+    def multiply(self, *args) -> str:
+        """
+        Multiplication (explicit or implicit via juxtaposition).
+        """
+        left, right = self._binary_operands(args)
+        return f"{left} * {right}"
+
+    def divide(self, *args) -> str:
+        """Division."""
+        left, right = self._binary_operands(args)
+        return f"{left} / {right}"
+
+    def power(self, base: str, *args) -> str:
+        """
+        Exponentiation. Handles multiple forms:
+        - basic_exp EXPONENT (e.g., m²)
+        - basic_exp RAISE INTEGER (e.g., m^2, m**2)
+        """
+        if len(args) == 1:
+            exp_token = args[0]
+        elif len(args) == 2:
+            # RAISE INTEGER - skip the RAISE operator
+            exp_token = args[1]
+        else:
+            raise ValueError(f"Unexpected power args: {args}")
+
+        exp_str = str(exp_token)
+
+        # Handle unicode superscripts
+        if any(c in _SUPERSCRIPT_MAP for c in exp_str):
+            exp_str = _decode_superscript(exp_str)
+
+        return f"{base} ** {exp_str}"
+
+    # -------------------------------------------------------------------------
+    # Grouping
+    # -------------------------------------------------------------------------
+
+    def group(self, inner: str) -> str:
+        """Parenthetical group."""
+        return f"({inner})"
+
+    # -------------------------------------------------------------------------
+    # Logarithms
+    # -------------------------------------------------------------------------
+
+    # Mapping from UDUNITS log types to pint logbase/logfactor
+    _LOG_PARAMS = {
+        "lg": ("10", "10"),  # log base 10, decibels
+        "log": ("10", "10"),  # log base 10, decibels (alias)
+        "ln": (
+            "2.71828182845904523536028747135266249775724709369995",
+            "0.5",
+        ),  # natural log, neper
+        "lb": ("2", "1"),  # log base 2, octaves
+    }
+
+    def logarithm(self, logref: Token, argument: str) -> str:
+        """
+        Logarithmic units (e.g., lg(re 1 mW), ln(re Pa)).
+
+        Converts to pint's logarithmic unit format:
+          scale; logbase: X; logfactor: Y
+        """
+        logref_str = str(logref).strip().lower()
+
+        # Determine log type
+        if logref_str.startswith("log"):
+            log_type = "log"
+        elif logref_str.startswith("lg"):
+            log_type = "lg"
+        elif logref_str.startswith("ln"):
+            log_type = "ln"
+        elif logref_str.startswith("lb"):
+            log_type = "lb"
+        else:
+            log_type = "lg"  # default to decibels
+
+        logbase, logfactor = self._LOG_PARAMS.get(log_type, ("10", "10"))
+
+        return f"{argument}; logbase: {logbase}; logfactor: {logfactor}"
+
+    # -------------------------------------------------------------------------
+    # Time shifts (offset units)
+    # -------------------------------------------------------------------------
+
+    def shift_op(self, op: Token) -> str:
+        """Extract shift operator type."""
+        return str(op).lower()
+
+    def shift_by_number(self, unit: str, shift_op: str, offset: str) -> str:
+        """
+        Shift by numeric offset (e.g., K @ 273.15).
+
+        Uses pint's offset notation: "unit; offset: value"
+        """
+        return f"{unit}; offset: {offset}"
+
+    def shift_by_time(self, unit: str, shift_op: str, timestamp: str) -> str:
+        """
+        Shift by timestamp (e.g., seconds since 1970-01-01).
+
+        Creates a special notation for time references.
+        """
+        # return f"{unit} since {timestamp}"
+        raise NotImplementedError(
+            "Time-based offsets are not directly supported by pint. "
+            "Consider using a dedicated time handling library like cftime "
+            "for this use case (see: https://unidata.github.io/cftime/)"
+        )
+
+    # -------------------------------------------------------------------------
+    # Timestamps
+    # -------------------------------------------------------------------------
+
+    def date_only(self, date: Token) -> str:
+        """Date without time (e.g., 1970-01-01)."""
+        return str(date)
+
+    def date_time(self, date: Token, clock: Token) -> str:
+        """Date with time (e.g., 1970-01-01 00:00:00)."""
+        return f"{date} {clock}"
+
+    def date_time_offset(self, date: Token, clock: Token, offset: Token) -> str:
+        """Date with time and timezone offset."""
+        return f"{date} {clock} {offset}"
+
+    def date_time_tz(self, date: Token, clock: Token, tz: Token) -> str:
+        """Date with time and timezone identifier."""
+        return f"{date} {clock} {tz}"
+
+    def datetime_iso(self, dt: Token) -> str:
+        """ISO 8601 datetime (e.g., 1970-01-01T00:00:00)."""
+        return str(dt)
+
+    def datetime_iso_tz(self, dt: Token, tz: Token) -> str:
+        """ISO 8601 datetime with timezone."""
+        return f"{dt} {tz}"
+
+    def packed_timestamp(self, ts: Token) -> str:
+        """Packed timestamp (e.g., 19700101T000000)."""
+        return str(ts)
+
+    def packed_timestamp_offset(self, ts: Token, offset: Token) -> str:
+        """Packed timestamp with offset."""
+        return f"{ts} {offset}"
+
+    def packed_timestamp_tz(self, ts: Token, tz: Token) -> str:
+        """Packed timestamp with timezone."""
+        return f"{ts} {tz}"
+
+
+# =============================================================================
+# Convenience functions
+# =============================================================================
+
+_parser = None
+
+
+def get_parser() -> Lark:
+    """Get the UDUNITS-2 parser (cached)."""
+    global _parser
+    if _parser is None:
+        grammar_path = Path(__file__).parent / "resources" / "udunits2.lark"
+        _parser = Lark(
+            grammar_path.read_text(),
+            parser="lalr",
+            lexer="contextual",
+            maybe_placeholders=False,
+        )
+    return _parser
+
+
+def cf_string_to_pint(unit_string: str) -> str:
+    """
+    Convert a UDUNITS-2 unit string to pint-compatible format.
+
+    Args:
+        unit_string: A unit specification in UDUNITS-2 format.
+
+    Returns:
+        A string that pint can parse directly.
+
+    Examples:
+        >>> udunits_to_pint("m")
+        'm'
+        >>> udunits_to_pint("m2")
+        'm ** 2'
+        >>> udunits_to_pint("kg.m/s2")
+        'kg * m / s ** 2'
+        >>> udunits_to_pint("K @ 273.15")
+        'K; offset: 273.15'
+        >>> udunits_to_pint("seconds since 1970-01-01")
+        'seconds since 1970-01-01'
+    """
+    if not unit_string or unit_string.isspace():
+        return "1"
+
+    parser = get_parser()
+    transformer = UdunitsToPintTransformer()
+
+    tree = parser.parse(unit_string)
+
+    if tree is None or (hasattr(tree, "children") and len(tree.children) == 0):
+        return "1"
+
+    result = transformer.transform(tree)
+
+    if not isinstance(result, str):
+        return "1"
+
+    return result

pint_cf-0.1.0/src/pint_cf/units.py

@@ -0,0 +1,86 @@
+from collections.abc import Iterable
+from importlib import resources
+from typing import Any, Unpack
+
+import pint
+from pint.delegates.formatter._compound_unit_helpers import (
+    BabelKwds,
+    SortFunc,
+    prepare_compount_unit,
+)
+from pint.delegates.formatter._spec_helpers import REGISTERED_FORMATTERS
+from pint.delegates.formatter.plain import DefaultFormatter
+from pint.facets.plain import PlainUnit
+
+from .parser import cf_string_to_pint
+
+_CF_FORMATTER_NAME = "cf"
+
+
+class CFFormatter(DefaultFormatter):
+    """Formatter for CF-compliant unit strings."""
+
+    def format_unit(
+        self,
+        unit: PlainUnit | Iterable[tuple[str, Any]],
+        uspec: str = "",
+        sort_func: SortFunc | None = None,
+        **babel_kwds: Unpack[BabelKwds],
+    ) -> str:
+        if "~" in uspec:
+            as_ratio = True
+            product_fmt = "."
+            division_fmt = "/"
+            power_fmt = "{}{}"
+        else:
+            as_ratio = False
+            product_fmt = "-"
+            division_fmt = " per "
+            power_fmt = "{}^{}"
+
+        numerator, denominator = prepare_compount_unit(
+            unit,
+            uspec,
+            sort_func=sort_func,
+            **babel_kwds,
+            registry=self._registry,
+        )
+
+        return (
+            pint.formatter(
+                numerator,
+                denominator,
+                as_ratio=as_ratio,
+                product_fmt=product_fmt,
+                division_fmt=division_fmt,
+                power_fmt=power_fmt,
+            )
+            .replace("Δ", "")
+            .replace("delta_", "")
+            .replace("dimensionless", "")
+        ) or "1"
+
+
+def _register_cf_formatter(ureg: pint.UnitRegistry) -> None:
+    """Register the CF formatter in both registry-local and Pint-global maps."""
+    formatter = CFFormatter(ureg)
+    ureg.formatter._formatters[_CF_FORMATTER_NAME] = formatter
+    REGISTERED_FORMATTERS[_CF_FORMATTER_NAME] = formatter
+
+
+def cf_unitregistry() -> pint.UnitRegistry:
+    """Create a CF-ready UnitRegistry with parser and formatter configured."""
+    with resources.path("pint_cf.resources.registry", "udunits2.txt") as filename:
+        ureg = pint.UnitRegistry(
+            filename=str(filename),
+            autoconvert_offset_to_baseunit=True,
+            preprocessors=[cf_string_to_pint],
+        )
+
+    # ureg.formatter.default_format = "cf"
+
+    # Deactivate Pint's native pluralization, since UDUNITS2 already
+    # defines plural forms for units
+    ureg._suffixes = {"": ""}
+    _register_cf_formatter(ureg)
+    return ureg

pint_cf-0.1.0/src/pint_cf.egg-info/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: pint-cf
+Version: 0.1.0
+Summary: CF-compliant unit registry and formatter for Pint
+Author: Pedro Gámez
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Pint>=0.25.2
+Requires-Dist: lark
+Dynamic: license-file
+
+# pint-cf
+
+This package extends Pint with a CF-compliant unit registry and formatter.
+
+## Features
+
+This package provides:
+
+- A CF-compliant Pint UnitRegistry, with explicit plurals.
+- A custom formatter `cf`, supporting both long and short (symbol) formats.
+
+Known limitations:
+
+- Pint does not support **time coordinates** (e.g.
+  `days since 2001-01-01`) or **climate calendars** (e.g., `360_days`).
+  Consider using [cftime](https://unidata.github.io/cftime/) for that.
+- Pint does not support **scaling factors** in Unit expressions (e.g.
+  `pint.Unit('0.1 m')`). You can work around this by adding your own
+  [unit definition](https://pint.readthedocs.io/en/stable/advanced/defining.html#programmatically).
+
+## Usage
+
+Create a CF-ready unit registry with `cf_unitregistry()`.
+This function also registers the `cf` formatter.
+
+```python
+from pint_cf import cf_unitregistry
+
+ureg = cf_unitregistry()
+print(type(ureg))  # <class 'pint.registry.UnitRegistry'>
+
+q = ureg('10 meters per second^2').to('km s-2')
+
+print(f"{q:cf}")   # 0.01 kilometer-second^-2
+print(f"{q:~cf}")  # 0.01 km/s2
+```
+
+<!-- If you prefer Pint's global application registry:
+
+```python
+import pint
+from pint_cf import cf_unitregistry
+
+ureg = cf_unitregistry()
+pint.set_application_registry(ureg)
+```
+
+After that, quantities created through `pint.get_application_registry()` will
+use the same CF configuration. -->

pint_cf-0.1.0/src/pint_cf.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/pint_cf/__init__.py
+src/pint_cf/parser.py
+src/pint_cf/units.py
+src/pint_cf.egg-info/PKG-INFO
+src/pint_cf.egg-info/SOURCES.txt
+src/pint_cf.egg-info/dependency_links.txt
+src/pint_cf.egg-info/requires.txt
+src/pint_cf.egg-info/top_level.txt
+tests/test_formatter.py
+tests/test_parser.py

pint_cf-0.1.0/src/pint_cf.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pint_cf-0.1.0/src/pint_cf.egg-info/requires.txt

@@ -0,0 +1,2 @@
+Pint>=0.25.2
+lark

pint_cf-0.1.0/src/pint_cf.egg-info/top_level.txt

@@ -0,0 +1 @@
+pint_cf

pint_cf-0.1.0/tests/test_formatter.py

@@ -0,0 +1,166 @@
+"""
+Tests for the CF formatter.
+
+The CF formatter supports two modes via format specifiers:
+  - "cf"  : long form  (product="-", power="^", no ratio)
+  - "~cf" : short form (product=".", power=implicit digits, ratio with "/")
+"""
+
+import pint
+import pytest
+
+from pint_cf import cf_unitregistry
+
+# Test cases: (input_unit, expected_cf, expected_short_cf)
+TEST_CASES_FORMAT = [
+    # =====================================================================
+    # Dimensionless
+    # =====================================================================
+    ("1", "1", "1"),
+    # =====================================================================
+    # Base units: long name ↔ symbol
+    # =====================================================================
+    ("meter", "meter", "m"),
+    ("kilogram", "kilogram", "kg"),
+    ("second", "second", "s"),
+    ("kelvin", "kelvin", "K"),
+    ("ampere", "ampere", "A"),
+    ("mole", "mole", "mol"),
+    ("candela", "candela", "cd"),
+    # Short-form input produces same output
+    ("m", "meter", "m"),
+    ("kg", "kilogram", "kg"),
+    ("s", "second", "s"),
+    ("K", "kelvin", "K"),
+    ("A", "ampere", "A"),
+    ("mol", "mole", "mol"),
+    ("cd", "candela", "cd"),
+    # =====================================================================
+    # Prefixed units
+    # =====================================================================
+    ("kilometer", "kilometer", "km"),
+    ("centimeter", "centimeter", "cm"),
+    ("millimeter", "millimeter", "mm"),
+    ("micrometer", "micrometer", "µm"),
+    ("milligram", "milligram", "mg"),
+    ("millisecond", "millisecond", "ms"),
+    ("microsecond", "microsecond", "µs"),
+    ("hectopascal", "hectopascal", "hPa"),
+    # Short-form input
+    ("km", "kilometer", "km"),
+    ("cm", "centimeter", "cm"),
+    ("mm", "millimeter", "mm"),
+    # =====================================================================
+    # Derived units
+    # =====================================================================
+    ("newton", "newton", "N"),
+    ("pascal", "pascal", "Pa"),
+    ("joule", "joule", "J"),
+    ("watt", "watt", "W"),
+    ("hertz", "hertz", "Hz"),
+    ("volt", "volt", "V"),
+    ("ohm", "ohm", "Ω"),
+    # Short-form input
+    ("N", "newton", "N"),
+    ("Pa", "pascal", "Pa"),
+    ("J", "joule", "J"),
+    ("W", "watt", "W"),
+    ("Hz", "hertz", "Hz"),
+    # =====================================================================
+    # Non-SI units
+    # =====================================================================
+    ("degree", "arc_degree", "°"),
+    ("radian", "radian", "rad"),
+    ("steradian", "steradian", "sr"),
+    ("liter", "liter", "L"),
+    ("day", "day", "d"),
+    ("hour", "hour", "h"),
+    ("minute", "minute", "min"),
+    # =====================================================================
+    # Temperature
+    # =====================================================================
+    ("degree_Celsius", "degree_Celsius", "°C"),
+    ("degC", "degree_Celsius", "°C"),
+    # =====================================================================
+    # Plural forms (normalized to singular by registry)
+    # =====================================================================
+    ("meters", "meter", "m"),
+    ("seconds", "second", "s"),
+    ("kilometers", "kilometer", "km"),
+    # =====================================================================
+    # Single-unit powers
+    # Long: "unit^exp" | Short: "unitEXP" (positive) or "1/unitEXP" (negative)
+    # =====================================================================
+    ("m^2", "meter^2", "m2"),
+    ("m^3", "meter^3", "m3"),
+    ("s^-1", "second^-1", "1/s"),
+    ("m^-2", "meter^-2", "1/m2"),
+    # =====================================================================
+    # Product of units (MULTIPLY)
+    # Long: "-" separator, no ratio | Short: "." separator with "/" ratio
+    # =====================================================================
+    ("Pa s", "pascal-second", "Pa.s"),
+    # =====================================================================
+    # Division / compound (DIVIDE)
+    # Long: negative exponents with "-" | Short: "/" ratio
+    # =====================================================================
+    ("m/s", "meter-second^-1", "m/s"),
+    ("m/s^2", "meter-second^-2", "m/s2"),
+    ("kg/m^3", "kilogram-meter^-3", "kg/m3"),
+    ("W/m^2", "watt-meter^-2", "W/m2"),
+    ("mol/m^3", "mole-meter^-3", "mol/m3"),
+    ("K/m", "kelvin-meter^-1", "K/m"),
+    ("g/kg", "gram-kilogram^-1", "g/kg"),
+    ("mm/day", "millimeter-day^-1", "mm/d"),
+    ("mg/kg", "milligram-kilogram^-1", "mg/kg"),
+    ("1/s", "second^-1", "1/s"),
+    # =====================================================================
+    # Complex compounds: numerator and denominator
+    # Long: all terms with "-" and "^" | Short: "." and "/" with implicit exp
+    # =====================================================================
+    ("kg m/s^2", "kilogram-meter-second^-2", "kg.m/s2"),
+    ("kg m^2/s^2", "kilogram-meter^2-second^-2", "kg.m2/s2"),
+    ("kg m^2 s^-2", "kilogram-meter^2-second^-2", "kg.m2/s2"),
+    ("kg m^-1 s^-2", "kilogram-meter^-1-second^-2", "kg/m/s2"),
+    ("kg/(m s^2)", "kilogram-meter^-1-second^-2", "kg/m/s2"),
+    ("kg m^2 s^-2 K^-1", "kilogram-meter^2-kelvin^-1-second^-2", "kg.m2/K/s2"),
+    ("mol m^-3", "mole-meter^-3", "mol/m3"),
+    ("W m^-2", "watt-meter^-2", "W/m2"),
+    # =====================================================================
+    # Division with parenthesized denominator
+    # (same physical unit, just different input syntax)
+    # =====================================================================
+    ("J/(kg K)", "joule-kelvin^-1-kilogram^-1", "J/K/kg"),
+    ("W/(m^2 K)", "watt-kelvin^-1-meter^-2", "W/K/m2"),
+]
+
+_TEST_CASES_FORMAT_LONG = [(i[0], i[1]) for i in TEST_CASES_FORMAT]
+_TEST_CASES_FORMAT_SHORT = [(i[0], i[2]) for i in TEST_CASES_FORMAT]
+
+
+@pytest.fixture(scope="module")
+def ureg() -> pint.UnitRegistry:
+    """Return the CF-compliant UnitRegistry."""
+    return cf_unitregistry()
+
+
+@pytest.mark.parametrize("input_str, expected", _TEST_CASES_FORMAT_LONG)
+def test_cf_format(ureg: pint.UnitRegistry, input_str: str, expected: str) -> None:
+    """Long-form CF format: product='-', power='^', no ratio."""
+    u = ureg.Unit(input_str)
+    result = format(u, "cf")
+    assert result == expected, (
+        f"format(Unit('{input_str}'), 'cf') = {result!r}, expected {expected!r}"
+    )
+
+
+@pytest.mark.parametrize("input_str, expected", _TEST_CASES_FORMAT_SHORT)
+def test_cf_short_format(
+    ureg: pint.UnitRegistry, input_str: str, expected: str
+) -> None:
+    """Short-form CF format (~): product='.', power=implicit, ratio with '/'."""
+    u = ureg.Unit(input_str)
+    result = format(u, "~cf")
+    assert result == expected, (
+        f"format(Unit('{input_str}'), '~cf') = {result!r}, expected {expected!r}"
+    )

pint_cf-0.1.0/tests/test_parser.py

@@ -0,0 +1,416 @@
+"""
+TODO:
+
+- https://docs.unidata.ucar.edu/udunits/current/udunits2lib.html#Grammar
+- fechas (tienen el signo -)
+- # ("days since 1970-01-01", "a; offset: 1"), -> not implemented error
+- El XML tambien se tiene que probar
+
+"""
+
+import pytest
+
+# from cfunits import Units
+from lark.exceptions import UnexpectedInput, VisitError
+from pint.delegates import ParserConfig
+from pint.delegates.txt_defparser.plain import UnitDefinition
+
+from pint_cf.parser import cf_string_to_pint
+
+TEST_CASES_TRANSFORM = [
+    # =========================================================================
+    # Unit-Spec: nothing
+    # =========================================================================
+    ("", ""),
+    ("1", ""),
+    # =========================================================================
+    # Basic-Spec → ID: simple identifiers
+    # =========================================================================
+    ("a", "a"),
+    ("m", "m"),
+    ("kg", "kg"),
+    ("kilogram", "kilogram"),
+    ("degrees_Celsius", "degrees_Celsius"),
+    ("degrees_north", "degrees_north"),
+    ("degrees_east", "degrees_east"),
+    ("hPa", "hPa"),
+    ("dBm", "dBm"),
+    # Special symbol IDs
+    ("°", "°"),
+    ("°F", "°F"),
+    # ("µ", "µ"),
+    ("'", "arc_minute"),
+    ('"', "arc_second"),
+    ("'/60", "arc_minute / 60"),
+    # =========================================================================
+    # Basic-Spec → Number: INT and REAL
+    # =========================================================================
+    ("2", "2"),
+    ("10", "10"),
+    ("100", "100"),
+    ("+1", "+1"),
+    ("-1", "-1"),
+    ("3.14", "3.14"),
+    ("1.0", "1.0"),
+    ("1.", "1."),
+    (".1", ".1"),
+    (".5", ".5"),
+    ("0.5", "0.5"),
+    ("0.01", "0.01"),
+    ("1e10", "1e10"),
+    ("1.0e3", "1.0e3"),
+    ("1.0e-3", "1.0e-3"),
+    ("1e-6", "1e-6"),
+    # =========================================================================
+    # Basic-Spec → "(" Shift-Spec ")" : parenthesized groups
+    # =========================================================================
+    ("(m)", "(m)"),
+    ("(kg)", "(kg)"),
+    ("(m/s)", "(m / s)"),
+    ("(m/s^2)", "(m / s ** 2)"),
+    ("(kg/m^3)", "(kg / m ** 3)"),
+    ("(m^2/s)", "(m ** 2 / s)"),
+    ("(m/(s K))", "(m / (s * K))"),
+    ("((m))", "((m))"),
+    # =========================================================================
+    # Power-Spec → Basic-Spec INT : trailing digits as exponent
+    # =========================================================================
+    ("a2", "a ** 2"),
+    ("m3", "m ** 3"),
+    ("s1", "s ** 1"),
+    # Negative trailing exponent
+    ("a-2", "a ** -2"),
+    ("s-1", "s ** -1"),
+    ("m-s-2", "m * s ** -2"),
+    # =========================================================================
+    # Power-Spec → Basic-Spec EXPONENT : unicode superscripts (¹²³)
+    # =========================================================================
+    ("a¹", "a ** 1"),
+    ("a²", "a ** 2"),
+    ("a³", "a ** 3"),
+    ("m²", "m ** 2"),
+    ("m³", "m ** 3"),
+    ("kg³", "kg ** 3"),
+    ("s¹", "s ** 1"),
+    # Multi-digit superscript
+    ("m¹²", "m ** 12"),
+    # =========================================================================
+    # Power-Spec → Basic-Spec RAISE INT : ^ or **
+    # =========================================================================
+    ("a^2", "a ** 2"),
+    ("a**2", "a ** 2"),
+    ("a^-2", "a ** -2"),
+    ("a**-2", "a ** -2"),
+    ("m^3", "m ** 3"),
+    ("m**3", "m ** 3"),
+    ("m^-1", "m ** -1"),
+    ("m**-1", "m ** -1"),
+    ("s^-2", "s ** -2"),
+    ("s**-2", "s ** -2"),
+    ("K^-1", "K ** -1"),
+    ("m^1", "m ** 1"),
+    ("m^0", "m ** 0"),
+    ("m**0", "m ** 0"),
+    ("m^10", "m ** 10"),
+    ("m^+2", "m ** +2"),
+    # Power of group
+    ("(m)^2", "(m) ** 2"),
+    ("(m/s)^2", "(m / s) ** 2"),
+    ("(m/s)^-1", "(m / s) ** -1"),
+    ("(m/s)^-2", "(m / s) ** -2"),
+    ("(kg m)^2", "(kg * m) ** 2"),
+    ("(kg m)^-1", "(kg * m) ** -1"),
+    # =========================================================================
+    # Product-Spec → MULTIPLY : all multiplication operators
+    # =========================================================================
+    # Dash (-)
+    ("a-b", "a * b"),
+    # Dot (.)
+    ("a.b", "a * b"),
+    # Asterisk (*)
+    ("a*b", "a * b"),
+    # Space / juxtaposition
+    ("a b", "a * b"),
+    ("a  b", "a * b"),
+    ("m 2", "m * 2"),
+    ("kg m 2", "kg * m * 2"),
+    # Centered middot (·)
+    ("a·b", "a * b"),
+    # Chained multiply (3+ terms)
+    ("kg m s", "kg * m * s"),
+    ("m.s.K", "m * s * K"),
+    ("m*s*K", "m * s * K"),
+    # Products with exponents
+    ("m^2.s^-1", "m ** 2 * s ** -1"),
+    ("kg.m.s^-2", "kg * m * s ** -2"),
+    ("meter-second^-1", "meter * second ** -1"),
+    ("meter-second**-2", "meter * second ** -2"),
+    # =========================================================================
+    # Product-Spec → DIVIDE : all division operators
+    # =========================================================================
+    ("a/b", "a / b"),
+    ("a / b", "a / b"),
+    ("a  /  b", "a / b"),
+    ("a per b", "a / b"),
+    ("a PER b", "a / b"),
+    ("kg  /  m", "kg / m"),
+    # Chained division
+    ("m/s/K", "m / s / K"),
+    ("kg/m/s", "kg / m / s"),
+    ("m / s / K", "m / s / K"),
+    # Per with exponents
+    ("kg per s^2", "kg / s ** 2"),
+    ("W per m^2", "W / m ** 2"),
+    ("m^2 per s", "m ** 2 / s"),
+    ("m^2 per s^2", "m ** 2 / s ** 2"),
+    ("m^2 PER s^2", "m ** 2 / s ** 2"),
+    # Division of groups
+    ("(m)/(s)", "(m) / (s)"),
+    # =========================================================================
+    # Product-Spec → mixed multiply + divide
+    # =========================================================================
+    ("kg*m/s", "kg * m / s"),
+    ("kg m/s", "kg * m / s"),
+    ("kg m / s", "kg * m / s"),
+    ("kg m / s^2", "kg * m / s ** 2"),
+    ("kg m -2", "kg * m * -2"),
+    ("kg.m/s2", "kg * m * s ** -2"),
+    ("1/s", "1 / s"),
+    ("1/m", "1 / m"),
+    ("1/s^2", "1 / s ** 2"),
+    ("1 m/s", "1 * m / s"),
+    ("g/kg", "g / kg"),
+    # =========================================================================
+    # Shift-Spec → Product-Spec SHIFT INT
+    # =========================================================================
+    ("a @ 1", "a; offset: 1"),
+    ("a after 1", "a; offset: 1"),
+    ("a from 1", "a; offset: 1"),
+    ("a ref 1", "a; offset: 1"),
+    ("K @ 0", "K; offset: 0"),
+    # =========================================================================
+    # Shift-Spec → Product-Spec SHIFT REAL
+    # =========================================================================
+    ("K @ 273.15", "K; offset: 273.15"),
+    ("K @ -273.15", "K; offset: -273.15"),
+    ("a @ 1.5", "a; offset: 1.5"),
+    ("K after 273.15", "K; offset: 273.15"),
+    ("K from 273.15", "K; offset: 273.15"),
+    ("K ref 273.15", "K; offset: 273.15"),
+    ("degC @ 1.5", "degC; offset: 1.5"),
+    ("°R @ 459.67", "°R; offset: 459.67"),
+    # Shift on product expression
+    ("m/s @ 0", "m / s; offset: 0"),
+    # =========================================================================
+    # Basic-Spec → LOGREF Product-Spec ")" : logarithmic units
+    # =========================================================================
+    # All log types with reference value
+    ("log(re 1 a)", "1 * a; logbase: 10; logfactor: 10"),
+    ("lg(re 1 a)", "1 * a; logbase: 10; logfactor: 10"),
+    ("ln(re 1 a)", "1 * a; logbase: 2.718281828459045; logfactor: 0.5"),
+    ("lb(re 1 a)", "1 * a; logbase: 2; logfactor: 1"),
+    # With colon in "re:"
+    ("lb ( re: 1 a)", "1 * a; logbase: 2; logfactor: 1"),
+    ("ln(re: 1 Pa)", "1 * Pa; logbase: 2.718281828459045; logfactor: 0.5"),
+    # With real unit names
+    ("lg(re 1 mW)", "1 * mW; logbase: 10; logfactor: 10"),
+    ("ln(re 1 Pa)", "1 * Pa; logbase: 2.718281828459045; logfactor: 0.5"),
+    ("lb(re 1 W)", "1 * W; logbase: 2; logfactor: 1"),
+    # Without reference number
+    ("lg(re mW)", "mW; logbase: 10; logfactor: 10"),
+    ("lb(re W)", "W; logbase: 2; logfactor: 1"),
+    # Colon without number
+    ("lb(re: W)", "W; logbase: 2; logfactor: 1"),
+    ("lg(re: mW)", "mW; logbase: 10; logfactor: 10"),
+    # =========================================================================
+    # Complex / Real-world CF-convention expressions
+    # =========================================================================
+    # SI derived units with exponents
+    ("kg m^2 s^-2", "kg * m ** 2 * s ** -2"),
+    ("kg m^2 s^-2 K^-1", "kg * m ** 2 * s ** -2 * K ** -1"),
+    ("kg m^-1 s^-2", "kg * m ** -1 * s ** -2"),
+    ("kg^1 m^2 s^-3", "kg ** 1 * m ** 2 * s ** -3"),
+    ("W m^-2", "W * m ** -2"),
+    ("mol kg^-1", "mol * kg ** -1"),
+    ("m^2 s^-1", "m ** 2 * s ** -1"),
+    # Division with parenthesized denominators
+    ("W/(m^2)", "W / (m ** 2)"),
+    ("J/(kg K)", "J / (kg * K)"),
+    ("kg/(m s)", "kg / (m * s)"),
+    ("kg / (m s^2)", "kg * m ** -1 * s ** -2"),
+    ("W/(m^2 K)", "W / (m ** 2 * K)"),
+    ("m^2/(s^2 K)", "m ** 2 / (s ** 2 * K)"),
+    ("kg m^2/(s^2 K mol)", "kg * m ** 2 / (s ** 2 * K * mol)"),
+    # Scalar * unit
+    ("0.001 m", "0.001 * m"),
+    ("1000 kg", "1000 * kg"),
+    ("m 1.5", "1.5 * m"),
+    ("1e3 Pa", "1e3 * Pa"),
+    ("Pa 1e3", "1e3 * Pa"),
+    ("1e-3 m", "1e-3 * m"),
+    ("1e-6 m", "1e-6 * m"),
+    ("2 m^2", "2 * m ** 2"),
+    ("0.5 kg^-1", "0.5 * kg ** -1"),
+    ("0.1 Pa", "0.1 * Pa"),
+    # Common CF convention units
+    ("Pa s", "Pa * s"),
+    ("N m", "N * m"),
+    ("mm/day", "mm / day"),
+    ("W/m^2", "W / m ** 2"),
+    ("K/m", "K / m"),
+    ("mol/m^3", "mol / m ** 3"),
+    ("m/s^2", "m / s ** 2"),
+    # =========================================================================
+    # Whitespace handling
+    # =========================================================================
+    ("  m  ", "m"),
+    ("  m    /    s^2    ", "m / s ** 2"),
+    ("  kg  /  s  ", "kg / s"),
+]
+
+
+TEST_CASES_TIME_SHIFTS = [
+    "seconds since 1970-01-01",
+    "seconds since 1970-01-01 12:34",
+    "seconds since 1970-01-01 12:34 +01:00",
+    "seconds since 1970-01-01 12:34 UTC",
+    "seconds since 1970-01-01T12:34",
+    "seconds since 1970-01-01T12:34 Z",
+    "seconds since 19700101T1234",
+    "seconds since 19700101T1234 +01:00",
+    "seconds since 19700101T1234 UTC",
+]
+
+
+TEST_CASES_INVALID = [
+    # =========================================================================
+    # Invalid operators / syntax
+    # =========================================================================
+    # Double slash, double plus
+    "a // b",
+    "a ++ b",
+    # Double raise
+    "a^^2",
+    "a ^ ^ 2",
+    # Double consecutive operators
+    "a * * b",
+    "a / / b",
+    # Mixed invalid operators
+    "a*/b",
+    "a/*b",
+    "m ^^ 2",
+    # =========================================================================
+    # Trailing operators (incomplete expressions)
+    # =========================================================================
+    "a/",
+    "a*",
+    "a^",
+    "a**",
+    "m per",
+    "m since",
+    "K @",
+    # =========================================================================
+    # Leading operators (missing left operand)
+    # =========================================================================
+    "/m",
+    "*m",
+    "^m",
+    "/ s",
+    "* s",
+    "^ 2",
+    "^2",
+    "**2",
+    "@ 1",
+    # =========================================================================
+    # Unmatched / empty parentheses
+    # =========================================================================
+    "()",
+    "( )",
+    "(  )",
+    "(m",
+    "((m)",
+    # =========================================================================
+    # Invalid characters (not part of <alpha>, <digit>, or operators)
+    # =========================================================================
+    "!m",
+    "#kg",
+    "$m",
+    "&m",
+    "~m",
+    "m~",
+    "?m",
+    # Invalid delimiters
+    "m[2]",
+    "m{2}",
+    "m<2>",
+    "a=b",
+    "a+b",
+    "m,s",
+    "m;s",
+    # =========================================================================
+    # Only operators (no operands)
+    # =========================================================================
+    "*",
+    "/",
+    "^",
+    "**",
+    "@",
+    # =========================================================================
+    # Nonsense strings
+    # =========================================================================
+    "!!!",
+    "---",
+    "...",
+    "@@@",
+    # =========================================================================
+    # Invalid number format
+    # =========================================================================
+    "1e+",
+    # =========================================================================
+    # Invalid shift expressions
+    # =========================================================================
+    # Double shift
+    "K @ 1 @ 2",
+    # Shift with parenthesized offset (not allowed)
+    "K @ (1)",
+    # =========================================================================
+    # Invalid LOGREF expressions
+    # =========================================================================
+    # Missing closing paren
+    "log(re 1 mW",
+    # Missing opening paren
+    "log mW)",
+    # Empty log
+    "log()",
+    "lg()",
+    "ln()",
+    "lb()",
+]
+
+
+@pytest.mark.parametrize("input_str, expected_str", TEST_CASES_TRANSFORM)
+def test_transform(input_str: str, expected_str: str) -> None:
+    # assert Units(input_str).isvalid, f"Input '{input_str}' is not a valid unit"
+
+    u = cf_string_to_pint(input_str)
+    cfg = ParserConfig()
+    result = UnitDefinition.from_string_and_config(f"_ = {u}", cfg)
+    expected = UnitDefinition.from_string_and_config(f"_ = {expected_str}", cfg)
+    assert result == expected, (
+        f"Expected '{expected}', got '{result}' for input '{input_str}'"
+    )
+
+
+@pytest.mark.parametrize("input_str", TEST_CASES_INVALID)
+def test_invalid_raises(input_str: str) -> None:
+    """Strings that violate the grammar must raise an exception when parsed."""
+    with pytest.raises(UnexpectedInput):
+        cf_string_to_pint(input_str)
+
+
+@pytest.mark.parametrize("input_str", TEST_CASES_TIME_SHIFTS)
+def test_time_shifts_raise_not_implemented(input_str: str) -> None:
+    with pytest.raises(
+        VisitError, match="Time-based offsets are not directly supported by pint"
+    ):
+        cf_string_to_pint(input_str)