sciform 0.36.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

sciform/__init__.py

@@ -11,7 +11,6 @@ from sciform.api.global_configuration import (
 )
 from sciform.api.scinum import SciNum
 from sciform.options.input_options import InputOptions
-from sciform.options.option_types import AutoDigits, AutoExpVal
 from sciform.options.populated_options import PopulatedOptions
 
 __all__ = [
@@ -22,8 +21,6 @@ __all__ = [
     "get_global_options",
     "reset_global_options",
     "set_global_options",
-    "AutoDigits",
-    "AutoExpVal",
     "SciNum",
     "InputOptions",
     "PopulatedOptions",

sciform/api/formatter.py

@@ -107,7 +107,7 @@ class Formatter:
     >>> print(formatter.populated_options)
     PopulatedOptions(
      'exp_mode': 'engineering',
-     'exp_val': AutoExpVal,
+     'exp_val': 'auto',
      'round_mode': 'sig_fig',
      'ndigits': 2,
      'upper_separator': '',
@@ -124,7 +124,6 @@ class Formatter:
      'superscript': True,
      'nan_inf_exp': False,
      'paren_uncertainty': False,
-     'pdg_sig_figs': False,
      'left_pad_matching': False,
      'paren_uncertainty_trim': True,
      'pm_whitespace': True,
@@ -143,9 +142,9 @@ class Formatter:
         self: Formatter,
         *,
         exp_mode: option_types.ExpMode | None = None,
-        exp_val: int | type(option_types.AutoExpVal) | None = None,
+        exp_val: int | option_types.ExpVal | None = None,
         round_mode: option_types.RoundMode | None = None,
-        ndigits: int | type(option_types.AutoDigits) | None = None,
+        ndigits: int | None = None,
         upper_separator: option_types.UpperSeparators | None = None,
         decimal_separator: option_types.DecimalSeparators | None = None,
         lower_separator: option_types.LowerSeparators | None = None,
@@ -160,7 +159,6 @@ class Formatter:
         superscript: bool | None = None,
         nan_inf_exp: bool | None = None,
         paren_uncertainty: bool | None = None,
-        pdg_sig_figs: bool | None = None,
         left_pad_matching: bool | None = None,
         paren_uncertainty_trim: bool | None = None,
         pm_whitespace: bool | None = None,
@@ -174,10 +172,10 @@ class Formatter:
         The following checks are performed when creating a new
         :class:`Formatter` object:
 
-        * ``ndigits`` >= 1 for significant figure rounding mode
+        * If ``round_mode`` is ``"sig_fig"`` then ``ndigits`` >= 1.
         * ``exp_val`` must be consistent with the exponent mode. If
           ``exp_val`` is specified (i.e. not ``None``) and ``exp_val``
-          is not ``AutoExpVal`` then
+          is not ``"auto"`` then
 
           * ``exp_val`` must be 0 for fixed point and percent modes
           * ``exp_val`` must be a multiple of 3 for engineering and
@@ -189,7 +187,7 @@ class Formatter:
         * ``decimal_separator`` may be any of ``['.', ',']``
         * ``lower_separator`` may be any of ``['', ' ', '_']``
 
-        :param exp_mode: Specify the formatting mode.
+        :param exp_mode: Specify the exponent formatting mode.
         :type exp_mode: ``Literal['fixed_point', 'percent',
           'scientific', 'engineering', 'engineering_shifted', 'binary',
           'binary_iec'] | None``
@@ -197,16 +195,14 @@ class Formatter:
           chosen. If an integer is specified, the value must be 0 for
           fixed point and percent modes, an integer multiple of 3 for
           engineering and engineering shifted modes, and an integer
-          multiple of 10 for binary IEC mode.
-        :type exp_val: ``int | type[AutoExpVal] | None``
+          multiple of 10 for binary IEC mode. Can be set to ``"auto"``.
+        :type exp_val: ``int | Literal['auto'] | None``
         :param round_mode: Indicate how to round numbers during
           formatting.
-        :type round_mode: ``Literal['sig_fig', 'dec_place'] | None``
-        :param ndigits: Indicate how the many significant digits or the
-          decimal place to use for rounding. Must be >= 1 for
-          significant figure rounding. Can be any integer for decimal
-          place rounding.
-        :type ndigits: ``int | type[AutoDigits] | None``
+        :type round_mode: ``Literal['sig_fig', 'dec_place', 'all', 'pdg'] | None``
+        :param ndigits: Specifies how many digits to use for significant figure
+          or digits-past-the-decimal rounding.
+        :type ndigits: ``int | None``
         :param upper_separator: Separator character to be used to group
           digits above the decimal symbol.
         :type upper_separator: ``Literal['', ',', '.', ' ', '_'] | None``
@@ -261,11 +257,6 @@ class Formatter:
           uncertainty mode (e.g. ``12.34(82)`` instead of
           ``12.34 ± 0.82``) should be used.
         :type paren_uncertainty: ``bool | None``
-        :param pdg_sig_figs: Flag indicating whether the
-          particle-data-group conventions should be used to
-          automatically determine the number of significant figures to
-          use for uncertainty. Ignored for single value formatting.
-        :type pdg_sig_figs: ``bool | None``
         :param left_pad_matching: Flag indicating if the value or
           uncertainty should be left padded to ensure they are both left
           padded to the same digits place.
@@ -312,7 +303,6 @@ class Formatter:
             superscript=superscript,
             nan_inf_exp=nan_inf_exp,
             paren_uncertainty=paren_uncertainty,
-            pdg_sig_figs=pdg_sig_figs,
             left_pad_matching=left_pad_matching,
             paren_uncertainty_trim=paren_uncertainty_trim,
             pm_whitespace=pm_whitespace,

sciform/api/global_configuration.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from sciform.options import global_options, option_types
 from sciform.options.conversion import populate_options
@@ -27,9 +27,9 @@ def get_global_options() -> PopulatedOptions:
 def set_global_options(  # noqa: PLR0913
     *,
     exp_mode: option_types.ExpMode | None = None,
-    exp_val: int | type(option_types.AutoExpVal) | None = None,
+    exp_val: int | Literal["auto"] | None = None,
     round_mode: option_types.RoundMode | None = None,
-    ndigits: int | type(option_types.AutoDigits) | None = None,
+    ndigits: int | Literal["all", "pdg"] | None = None,
     upper_separator: option_types.UpperSeparators | None = None,
     decimal_separator: option_types.DecimalSeparators | None = None,
     lower_separator: option_types.LowerSeparators | None = None,
@@ -44,7 +44,6 @@ def set_global_options(  # noqa: PLR0913
     superscript: bool | None = None,
     nan_inf_exp: bool | None = None,
     paren_uncertainty: bool | None = None,
-    pdg_sig_figs: bool | None = None,
     left_pad_matching: bool | None = None,
     paren_uncertainty_trim: bool | None = None,
     pm_whitespace: bool | None = None,
@@ -76,7 +75,6 @@ def set_global_options(  # noqa: PLR0913
         superscript=superscript,
         nan_inf_exp=nan_inf_exp,
         paren_uncertainty=paren_uncertainty,
-        pdg_sig_figs=pdg_sig_figs,
         left_pad_matching=left_pad_matching,
         paren_uncertainty_trim=paren_uncertainty_trim,
         pm_whitespace=pm_whitespace,
@@ -110,9 +108,9 @@ class GlobalOptionsContext:
         self: GlobalOptionsContext,
         *,
         exp_mode: option_types.ExpMode | None = None,
-        exp_val: int | type(option_types.AutoExpVal) | None = None,
+        exp_val: int | option_types.ExpVal | None = None,
         round_mode: option_types.RoundMode | None = None,
-        ndigits: int | type(option_types.AutoDigits) | None = None,
+        ndigits: int | option_types.NDigits | None = None,
         upper_separator: option_types.UpperSeparators | None = None,
         decimal_separator: option_types.DecimalSeparators | None = None,
         lower_separator: option_types.LowerSeparators | None = None,
@@ -127,7 +125,6 @@ class GlobalOptionsContext:
         superscript: bool | None = None,
         nan_inf_exp: bool | None = None,
         paren_uncertainty: bool | None = None,
-        pdg_sig_figs: bool | None = None,
         left_pad_matching: bool | None = None,
         paren_uncertainty_trim: bool | None = None,
         pm_whitespace: bool | None = None,
@@ -154,7 +151,6 @@ class GlobalOptionsContext:
             superscript=superscript,
             nan_inf_exp=nan_inf_exp,
             paren_uncertainty=paren_uncertainty,
-            pdg_sig_figs=pdg_sig_figs,
             left_pad_matching=left_pad_matching,
             paren_uncertainty_trim=paren_uncertainty_trim,
             pm_whitespace=pm_whitespace,

sciform/format_utils/exponents.py

@@ -15,13 +15,12 @@ from sciform.format_utils.numbers import (
 from sciform.options.option_types import (
     ExpFormatEnum,
     ExpModeEnum,
+    ExpValEnum,
 )
 
 if TYPE_CHECKING:  # pragma: no cover
     from decimal import Decimal
 
-    from sciform.options.option_types import AutoExpVal
-
 
 def get_translation_dict(
     exp_format: ExpFormatEnum,
@@ -120,7 +119,7 @@ def get_val_unc_exp(
     val: Decimal,
     unc: Decimal,
     exp_mode: ExpModeEnum,
-    input_exp: int | AutoExpVal,
+    input_exp: int | ExpValEnum,
 ) -> int:
     """Get exponent for value/uncertainty formatting."""
     if val.is_finite() and unc.is_finite():

sciform/format_utils/make_strings.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 import decimal
-from typing import TYPE_CHECKING
+from decimal import Decimal
 
 from sciform.format_utils.numbers import (
     get_top_dec_place,
@@ -14,9 +14,6 @@ from sciform.options.option_types import (
     SignModeEnum,
 )
 
-if TYPE_CHECKING:  # pragma: no cover
-    from decimal import Decimal
-
 
 def get_sign_str(num: Decimal, sign_mode: SignModeEnum) -> str:
     """Get the format sign string."""
@@ -95,11 +92,26 @@ def construct_num_str(
     return f"{sign_str}{pad_str}{abs_num_str}"
 
 
+def parse_mantissa_str_to_dec(
+    mantissa_str: str,
+    decimal_separator: DecimalSeparatorEnums,
+) -> Decimal:
+    """Convert a string, possibly with non-standard separators, to a decimal."""
+    clean_mantissa_str = mantissa_str
+    for separator in SeparatorEnum:
+        if separator != decimal_separator:
+            clean_mantissa_str = clean_mantissa_str.replace(
+                separator,
+                "",
+            )
+    clean_mantissa_str = clean_mantissa_str.replace(decimal_separator, ".")
+    mantissa_dec = Decimal(clean_mantissa_str)
+    return mantissa_dec
+
+
 def construct_val_unc_str(  # noqa: PLR0913
     val_mantissa_str: str,
     unc_mantissa_str: str,
-    val_mantissa: Decimal,
-    unc_mantissa: Decimal,
     decimal_separator: DecimalSeparatorEnums,
     *,
     paren_uncertainty: bool,
@@ -113,22 +125,20 @@ def construct_val_unc_str(  # noqa: PLR0913
             pm_symb = f" {pm_symb} "
         val_unc_str = f"{val_mantissa_str}{pm_symb}{unc_mantissa_str}"
     else:
-        if (
-            paren_uncertainty_trim
-            and unc_mantissa.is_finite()
-            and val_mantissa.is_finite()
-            and 0 < unc_mantissa < abs(val_mantissa)
-        ):
-            """
-            Don't strip the unc_mantissa_str if val_mantissa is non-finite.
-            Don't strip the unc_mantissa_str if unc_mantissa == 0 (because then the
-              empty string would remain).
-            Don't left strip the unc_mantissa_str if unc_mantissa >= val_mantissa
-            """
-            for separator in SeparatorEnum:
-                if separator != decimal_separator:
-                    unc_mantissa_str = unc_mantissa_str.replace(separator, "")
-            unc_mantissa_str = unc_mantissa_str.lstrip("0" + decimal_separator)
+        if paren_uncertainty_trim:
+            val_dec = parse_mantissa_str_to_dec(val_mantissa_str, decimal_separator)
+            unc_dec = parse_mantissa_str_to_dec(unc_mantissa_str, decimal_separator)
+            if unc_dec.is_finite() and val_dec.is_finite():
+                if unc_dec == 0:
+                    unc_mantissa_str = "0"
+                elif unc_dec < abs(val_dec):
+                    for separator in SeparatorEnum:
+                        if separator != decimal_separator:
+                            unc_mantissa_str = unc_mantissa_str.replace(
+                                separator,
+                                "",
+                            )
+                    unc_mantissa_str = unc_mantissa_str.lstrip("0" + decimal_separator)
         val_unc_str = f"{val_mantissa_str}({unc_mantissa_str})"
     return val_unc_str
 

sciform/format_utils/numbers.py

@@ -13,15 +13,14 @@ from sciform.formatting.parser import (
     non_finite_val_pattern,
 )
 from sciform.options.option_types import (
-    AutoDigits,
-    AutoExpVal,
     ExpModeEnum,
+    ExpValEnum,
 )
 
 
 def get_top_dec_place(num: Decimal) -> int:
     """Get the decimal place of a decimal's most significant digit."""
-    if not num.is_finite() or num == 0:
+    if not num.is_finite():
         return 0
     _, digits, exp = num.normalize().as_tuple()
     return len(digits) + exp - 1
@@ -48,7 +47,7 @@ def get_val_unc_top_dec_place(
     input_top_dec_place: int,
     *,
     left_pad_matching: bool,
-) -> int | AutoDigits:
+) -> int:
     """Get top decimal place for value/uncertainty formatting."""
     if left_pad_matching:
         val_top_dec_place = get_top_dec_place(val_mantissa)
@@ -65,10 +64,10 @@ def get_val_unc_top_dec_place(
 
 
 def get_fixed_exp(
-    input_exp: int | type(AutoExpVal),
+    input_exp: int | ExpValEnum,
 ) -> Literal[0]:
     """Get the exponent for fixed or percent format modes."""
-    if input_exp is not AutoExpVal and input_exp != 0:
+    if input_exp is not ExpValEnum.AUTO and input_exp != 0:
         msg = "Cannot set non-zero exponent in fixed point or percent exponent mode."
         raise ValueError(msg)
     return 0
@@ -76,20 +75,20 @@ def get_fixed_exp(
 
 def get_scientific_exp(
     num: Decimal,
-    input_exp: int | type(AutoExpVal),
+    input_exp: int | ExpValEnum,
 ) -> int:
     """Get the exponent for scientific formatting mode."""
-    return get_top_dec_place(num) if input_exp is AutoExpVal else input_exp
+    return get_top_dec_place(num) if input_exp is ExpValEnum.AUTO else input_exp
 
 
 def get_engineering_exp(
     num: Decimal,
-    input_exp: int | type(AutoExpVal),
+    input_exp: int | ExpValEnum,
     *,
     shifted: bool = False,
 ) -> int:
     """Get the exponent for engineering formatting modes."""
-    if input_exp is AutoExpVal:
+    if input_exp is ExpValEnum.AUTO:
         exp_val = get_top_dec_place(num)
         exp_val = exp_val // 3 * 3 if not shifted else (exp_val + 1) // 3 * 3
     else:
@@ -105,12 +104,12 @@ def get_engineering_exp(
 
 def get_binary_exp(
     num: Decimal,
-    input_exp: int | type(AutoExpVal),
+    input_exp: int | ExpValEnum,
     *,
     iec: bool = False,
 ) -> int:
     """Get the exponent for binary formatting modes."""
-    if input_exp is AutoExpVal:
+    if input_exp is ExpValEnum.AUTO:
         exp_val = get_top_dec_place_binary(num)
         if iec:
             exp_val = (exp_val // 10) * 10
@@ -128,7 +127,7 @@ def get_binary_exp(
 def get_mantissa_exp_base(
     num: Decimal,
     exp_mode: ExpModeEnum,
-    input_exp: int | type(AutoExpVal),
+    input_exp: int | ExpValEnum,
 ) -> tuple[Decimal, int, int]:
     """Get mantissa, exponent, and base for formatting a decimal number."""
     if exp_mode is ExpModeEnum.BINARY or exp_mode is ExpModeEnum.BINARY_IEC:
@@ -138,7 +137,7 @@ def get_mantissa_exp_base(
 
     if num == 0 or not num.is_finite():
         mantissa = Decimal(num)
-        exp = 0 if input_exp is AutoExpVal else input_exp
+        exp = 0 if input_exp is ExpValEnum.AUTO else input_exp
     else:
         if exp_mode is ExpModeEnum.FIXEDPOINT or exp_mode is ExpModeEnum.PERCENT:
             exp = get_fixed_exp(input_exp)

sciform/format_utils/rounding.py

@@ -8,10 +8,7 @@ from sciform.format_utils.numbers import (
     get_bottom_dec_place,
     get_top_dec_place,
 )
-from sciform.options.option_types import (
-    AutoDigits,
-    RoundModeEnum,
-)
+from sciform.options.option_types import RoundModeEnum
 
 
 def get_pdg_round_digit(num: Decimal) -> int:
@@ -28,11 +25,13 @@ def get_pdg_round_digit(num: Decimal) -> int:
     if not num.is_finite():
         msg = f"num must be finite, not {num}."
         raise ValueError(msg)
+    if num == 0:
+        return 0
 
     top_dec_place = get_top_dec_place(num)
 
     # Bring num to be between 100 and 1000.
-    num_top_three_digs = num * Decimal(10) ** (Decimal(2) - Decimal(top_dec_place))
+    num_top_three_digs = abs(num) * Decimal(10) ** (Decimal(2) - Decimal(top_dec_place))
     num_top_three_digs = num_top_three_digs.quantize(1, rounding="ROUND_FLOOR")
     new_top_dec_place = get_top_dec_place(num_top_three_digs)
     num_top_three_digs = num_top_three_digs * 10 ** (2 - new_top_dec_place)
@@ -59,21 +58,21 @@ def get_pdg_round_digit(num: Decimal) -> int:
 def get_round_dec_place(
     num: Decimal,
     round_mode: RoundModeEnum,
-    ndigits: int | type(AutoDigits),
-    *,
-    pdg_sig_figs: bool = False,
+    ndigits: int,
 ) -> int:
     """Get the decimal place to which to round."""
     # TODO: Handle nan and inf
-    if round_mode is RoundModeEnum.SIG_FIG:
-        if pdg_sig_figs:
-            round_digit = get_pdg_round_digit(num)
-        elif ndigits is AutoDigits:
-            round_digit = get_bottom_dec_place(num)
+    if round_mode is RoundModeEnum.ALL:
+        round_digit = get_bottom_dec_place(num)
+    elif round_mode is RoundModeEnum.PDG:
+        round_digit = get_pdg_round_digit(num)
+    elif round_mode is RoundModeEnum.SIG_FIG:
+        if num == 0:
+            round_digit = 0
         else:
             round_digit = get_top_dec_place(num) - (ndigits - 1)
     elif round_mode is RoundModeEnum.DEC_PLACE:
-        round_digit = get_bottom_dec_place(num) if ndigits is AutoDigits else -ndigits
+        round_digit = -ndigits
     else:
         msg = f"Unhandled round mode: {round_mode}."
         raise ValueError(msg)
@@ -83,17 +82,15 @@ def get_round_dec_place(
 def round_val_unc(
     val: Decimal,
     unc: Decimal,
-    ndigits: int | type[AutoDigits],
-    *,
-    use_pdg_sig_figs: bool = False,
+    round_mode: RoundModeEnum,
+    ndigits: int,
 ) -> tuple[Decimal, Decimal, int]:
     """Simultaneously round the value and uncertainty."""
     if unc.is_finite() and unc != 0:
         round_digit = get_round_dec_place(
             unc,
-            RoundModeEnum.SIG_FIG,
+            round_mode,
             ndigits,
-            pdg_sig_figs=use_pdg_sig_figs,
         )
         unc_rounded = round(unc, -round_digit)
         if val.is_finite():
@@ -103,9 +100,8 @@ def round_val_unc(
     elif val.is_finite():
         round_digit = get_round_dec_place(
             val,
-            RoundModeEnum.SIG_FIG,
+            round_mode,
             ndigits,
-            pdg_sig_figs=False,
         )
         unc_rounded = unc
         val_rounded = round(val, -round_digit)

sciform/formatting/fsml.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import re
 
 from sciform.options.input_options import InputOptions
+from sciform.options.option_types import RoundModeEnum
 
 pattern = re.compile(
     r"""^
@@ -12,7 +13,11 @@ pattern = re.compile(
                          (?P<sign_mode>[-+ ])?
                          (?P<alternate_mode>\#)?
                          (?P<left_pad_dec_place>\d+)?
-                         (?:(?P<round_mode>[.!])(?P<ndigits>[+-]?\d+))?
+                         (?:
+                           (?P<round_mode>[.!])(?P<ndigits>([+-]?\d+))
+                           |
+                           (?P<round_mode_special>[AP])
+                         )?
                          (?P<exp_mode>[fF%eErRbB])?
                          (?:x(?P<exp_val>[+-]?\d+))?
                          (?P<prefix_mode>p)?
@@ -51,6 +56,15 @@ def parse_exp_mode(
     return exp_mode, capitalize
 
 
+ROUND_MODE_MAPPING = {
+    "!": "sig_fig",
+    ".": "dec_place",
+    "A": RoundModeEnum.ALL,
+    "P": RoundModeEnum.PDG,
+    None: None,
+}
+
+
 def format_options_from_fmt_spec(fmt_spec: str) -> InputOptions:
     """Resolve InputOptions from format specification string."""
     match = pattern.match(fmt_spec)
@@ -68,16 +82,17 @@ def format_options_from_fmt_spec(fmt_spec: str) -> InputOptions:
     if left_pad_dec_place is not None:
         left_pad_dec_place = int(left_pad_dec_place)
 
-    round_mode_mapping = {"!": "sig_fig", ".": "dec_place", None: None}
-
     round_mode_flag = match.group("round_mode")
-    round_mode = round_mode_mapping[round_mode_flag]
-
     ndigits = match.group("ndigits")
-    if ndigits is not None:
-        ndigits = int(ndigits)
+    if not round_mode_flag:
+        special_round_mode_flag = match.group("round_mode_special")
+        if not special_round_mode_flag:
+            round_mode = None
+        else:
+            round_mode = ROUND_MODE_MAPPING[special_round_mode_flag]
     else:
-        ndigits = None
+        round_mode = ROUND_MODE_MAPPING[round_mode_flag]
+        ndigits = int(ndigits)
 
     exp_mode = match.group("exp_mode")
     exp_mode, capitalize = parse_exp_mode(