sciform 0.33.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

sciform/options/conversion.py

@@ -0,0 +1,120 @@
+"""Code for converting between various types of sciform options."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import TYPE_CHECKING
+
+from sciform import modes
+from sciform.options import global_options
+from sciform.options.finalized_options import FinalizedOptions
+from sciform.options.populated_options import PopulatedOptions
+from sciform.options.validation import validate_options
+
+if TYPE_CHECKING:  # pragma: no cover
+    from sciform.options.input_options import InputOptions
+
+
+def populate_extra_si_prefixes(
+    extra_si_prefixes: dict[int, str] | None,
+    *,
+    add_c_prefix: bool,
+    add_small_si_prefixes: bool,
+) -> dict[int, str]:
+    """Populate extra_si_prefixes dict."""
+    if add_c_prefix:
+        if extra_si_prefixes is None:
+            extra_si_prefixes = {}
+        if -2 not in extra_si_prefixes:
+            extra_si_prefixes[-2] = "c"
+    if add_small_si_prefixes:
+        if extra_si_prefixes is None:
+            extra_si_prefixes = {}
+        if -2 not in extra_si_prefixes:
+            extra_si_prefixes[-2] = "c"
+        if -1 not in extra_si_prefixes:
+            extra_si_prefixes[-1] = "d"
+        if +1 not in extra_si_prefixes:
+            extra_si_prefixes[+1] = "da"
+        if +2 not in extra_si_prefixes:
+            extra_si_prefixes[+2] = "h"
+    return extra_si_prefixes
+
+
+def populate_extra_parts_per_forms(
+    extra_parts_per_forms: dict[int, str] | None,
+    *,
+    add_ppth_form: bool,
+) -> dict[int, str]:
+    """Populate extra_si_prefixes dict."""
+    if add_ppth_form:
+        if extra_parts_per_forms is None:
+            extra_parts_per_forms = {}
+        if -3 not in extra_parts_per_forms:
+            extra_parts_per_forms[-3] = "ppth"
+    return extra_parts_per_forms
+
+
+def populate_options(input_options: InputOptions) -> PopulatedOptions:
+    """Populate InputOptions into PopulatedOptions."""
+    global_options_dict = asdict(global_options.GLOBAL_DEFAULT_OPTIONS)
+    input_options_dict = asdict(input_options)
+    kwargs = {}
+    for key in list(input_options_dict.keys()):
+        if key in ["add_c_prefix", "add_small_si_prefixes", "add_ppth_form"]:
+            continue
+
+        value = input_options_dict[key]
+        if key == "left_pad_char" and value == 0:
+            value = "0"
+
+        if key == "extra_si_prefixes":
+            value = populate_extra_si_prefixes(
+                value,
+                add_c_prefix=input_options.add_c_prefix,
+                add_small_si_prefixes=input_options.add_small_si_prefixes,
+            )
+        if key == "extra_parts_per_forms" and input_options.add_ppth_form:
+            value = populate_extra_parts_per_forms(
+                value,
+                add_ppth_form=input_options.add_ppth_form,
+            )
+
+        if value is None:
+            populated_value = global_options_dict[key]
+        else:
+            populated_value = value
+
+        kwargs[key] = populated_value
+    populated_options = PopulatedOptions(**kwargs)
+    validate_options(populated_options)
+    return populated_options
+
+
+key_to_enum_dict = {
+    "exp_mode": modes.ExpModeEnum,
+    "round_mode": modes.RoundModeEnum,
+    "upper_separator": modes.SeparatorEnum,
+    "decimal_separator": modes.SeparatorEnum,
+    "lower_separator": modes.SeparatorEnum,
+    "sign_mode": modes.SignModeEnum,
+    "left_pad_char": modes.LeftPadCharEnum,
+    "exp_format": modes.ExpFormatEnum,
+}
+
+
+def finalize_populated_options(populated_options: PopulatedOptions) -> FinalizedOptions:
+    """Convert PopulatedOptions into FinalizedOptions with enum values."""
+    kwargs = populated_options.as_dict()
+    for key, value in kwargs.items():
+        if key in key_to_enum_dict:
+            enum = key_to_enum_dict[key]
+            kwargs[key] = modes.mode_str_to_enum(value, enum)
+    return FinalizedOptions(**kwargs)
+
+
+def finalize_input_options(input_options: InputOptions) -> FinalizedOptions:
+    """Convert InputOptions into FinalizedOptions."""
+    populated_options = populate_options(input_options)
+    finalized_options = finalize_populated_options(populated_options)
+    return finalized_options

sciform/{rendered_options.py → options/finalized_options.py}

@@ -1,23 +1,23 @@
 """
 Rendered format options used in sciform backend formatting algorithm.
 
-:class:`UserOptions` are converted into :class:`RenderedOptions`
+:class:`InputOptions` are converted into :class:`FinalizedOptions`
 internally at format time.
 """
 
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from enum import Enum
-from pprint import pformat
+from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
+from sciform.options.validation import validate_options
+
 if TYPE_CHECKING:  # pragma: no cover
     from sciform import modes
 
 
 @dataclass(frozen=True)
-class RenderedOptions:
+class FinalizedOptions:
     """Rendered options: All options populated and using Enum instead of Literal."""
 
     exp_mode: modes.ExpModeEnum
@@ -43,9 +43,5 @@ class RenderedOptions:
     paren_uncertainty_separators: bool
     pm_whitespace: bool
 
-    def __str__(self: RenderedOptions) -> str:
-        options_dict = asdict(self)
-        for key, value in options_dict.items():
-            if isinstance(value, Enum):
-                options_dict[key] = value.value
-        return pformat(options_dict, sort_dicts=False)
+    def __post_init__(self: FinalizedOptions) -> None:
+        validate_options(self)

sciform/{global_options.py → options/global_options.py}

@@ -1,20 +1,20 @@
 """Global Options."""
 
 from sciform import modes
-from sciform.rendered_options import RenderedOptions
+from sciform.options.populated_options import PopulatedOptions
 
-PKG_DEFAULT_OPTIONS = RenderedOptions(
-    exp_mode=modes.ExpModeEnum.FIXEDPOINT,
+PKG_DEFAULT_OPTIONS = PopulatedOptions(
+    exp_mode="fixed_point",
     exp_val=modes.AutoExpVal,
-    round_mode=modes.RoundModeEnum.SIG_FIG,
+    round_mode="sig_fig",
     ndigits=modes.AutoDigits,
-    upper_separator=modes.SeparatorEnum.NONE,
-    decimal_separator=modes.SeparatorEnum.POINT,
-    lower_separator=modes.SeparatorEnum.NONE,
-    sign_mode=modes.SignModeEnum.NEGATIVE,
-    left_pad_char=modes.LeftPadCharEnum.SPACE,
+    upper_separator="",
+    decimal_separator=".",
+    lower_separator="",
+    sign_mode="-",
+    left_pad_char=" ",
     left_pad_dec_place=0,
-    exp_format=modes.ExpFormatEnum.STANDARD,
+    exp_format="standard",
     extra_si_prefixes={},
     extra_iec_prefixes={},
     extra_parts_per_forms={},

sciform/options/input_options.py

@@ -0,0 +1,104 @@
+"""InputOptions Dataclass which stores user input."""
+
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pprint import pformat
+from typing import TYPE_CHECKING, Any, Literal
+
+from sciform.options.validation import validate_options
+
+if TYPE_CHECKING:  # pragma: no cover
+    from sciform import modes
+
+
+@dataclass(frozen=True)
+class InputOptions:
+    """
+    Dataclass storing user input.
+
+    Stores the user input to :class:`Formatter`, so any keyword
+    arguments that can be passed into :class:`Formatter` are stored in
+    :class:`InputOptions`. Any unpopulated options retain the ``None``
+    value. At format time the :class:`InputOptions` are populated and
+    replaced by a :class:`PopulatedOptions` instance which necessarily
+    has all attributes populated with meaningful values.
+
+    :class:`InputOptions` instances should only be accessed via the
+    :class:`Formatter.input_options()` property. They should not be
+    instantiated directly.
+
+    >>> from sciform import Formatter
+    >>> formatter = Formatter(
+    ...     exp_mode="engineering",
+    ...     round_mode="sig_fig",
+    ...     ndigits=2,
+    ...     superscript=True,
+    ... )
+    >>> print(formatter.input_options.round_mode)
+    sig_fig
+    >>> print(formatter.input_options.exp_format)
+    None
+    >>> print(formatter.input_options)
+    InputOptions(
+     'exp_mode': 'engineering',
+     'round_mode': 'sig_fig',
+     'ndigits': 2,
+     'superscript': True,
+    )
+    >>> print(formatter.input_options.as_dict())
+    {'exp_mode': 'engineering', 'round_mode': 'sig_fig', 'ndigits': 2, 'superscript': True}
+    """  # noqa: E501
+
+    exp_mode: modes.ExpMode | None = None
+    exp_val: int | type(modes.AutoExpVal) | None = None
+    round_mode: modes.RoundMode | None = None
+    ndigits: int | type(modes.AutoDigits) | None = None
+    upper_separator: modes.UpperSeparators | None = None
+    decimal_separator: modes.DecimalSeparators | None = None
+    lower_separator: modes.LowerSeparators | None = None
+    sign_mode: modes.SignMode | None = None
+    left_pad_char: modes.LeftPadChar | Literal[0] | None = None
+    left_pad_dec_place: int | None = None
+    exp_format: modes.ExpFormat | None = None
+    extra_si_prefixes: dict[int, str] | None = None
+    extra_iec_prefixes: dict[int, str] | None = None
+    extra_parts_per_forms: dict[int, str] | None = None
+    capitalize: bool | None = None
+    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_separators: bool | None = None
+    pm_whitespace: bool | None = None
+
+    add_c_prefix: bool = None
+    add_small_si_prefixes: bool = None
+    add_ppth_form: bool = None
+
+    def __post_init__(self: InputOptions) -> None:
+        validate_options(self)
+
+    def as_dict(self: InputOptions) -> dict[str, Any]:
+        """
+        Return a dict representation of the InputOptions.
+
+        This dict can be passed into :class:`Formatter` as ``**kwargs``,
+        possibly after modification. This allows for the possibility of
+        constructing new :class:`Formatter` instances based on old ones.
+        Only explicitly populated attributes are included in the
+        returned dictionary.
+        """
+        options_dict = asdict(self)
+        for key in list(options_dict.keys()):
+            if options_dict[key] is None:
+                del options_dict[key]
+        return options_dict
+
+    def __str__(self: InputOptions) -> str:
+        options_str = pformat(self.as_dict(), width=-1, sort_dicts=False)
+        options_str = options_str.lstrip("{").rstrip("}")
+        options_str = f"InputOptions(\n {options_str},\n)"
+        return options_str

sciform/options/populated_options.py

@@ -0,0 +1,136 @@
+"""InputOptions Dataclass which stores user input."""
+
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from pprint import pformat
+from typing import TYPE_CHECKING, Any
+
+from sciform.options.validation import validate_options
+
+if TYPE_CHECKING:  # pragma: no cover
+    from sciform import modes
+
+
+@dataclass(frozen=True)
+class PopulatedOptions:
+    """
+    Dataclass storing fully populated formatting options.
+
+    User input options during :class:`Formatter` initialization are
+    stored in :class:`InputOptions` instances. But
+    :class:`InputOptions` instances don't necessarily have all options
+    populated as required for the formatting algorithm. At formatting
+    time the unpopulated options are populated from the global options.
+    The new resulting options object with all options populated is a
+    :class:`PopulatedOptions` instances. Note that the global options
+    are stored as a :class:`PopulatedOptions` instance.
+
+    :class:`PopulatedOptions` instances should only be accessed via the
+    :class:`Formatter.populated_options()` property. They should not be
+    instantiated directly.
+
+    >>> from sciform import Formatter
+    >>> formatter = Formatter(
+    ...     exp_mode="engineering",
+    ...     round_mode="sig_fig",
+    ...     ndigits=2,
+    ...     superscript=True,
+    ... )
+    >>> print(formatter.populated_options.round_mode)
+    sig_fig
+    >>> print(formatter.populated_options.exp_format)
+    standard
+    >>> print(formatter.populated_options)
+    PopulatedOptions(
+     'exp_mode': 'engineering',
+     'exp_val': AutoExpVal,
+     'round_mode': 'sig_fig',
+     'ndigits': 2,
+     'upper_separator': '',
+     'decimal_separator': '.',
+     'lower_separator': '',
+     'sign_mode': '-',
+     'left_pad_char': ' ',
+     'left_pad_dec_place': 0,
+     'exp_format': 'standard',
+     'extra_si_prefixes': {},
+     'extra_iec_prefixes': {},
+     'extra_parts_per_forms': {},
+     'capitalize': False,
+     'superscript': True,
+     'nan_inf_exp': False,
+     'paren_uncertainty': False,
+     'pdg_sig_figs': False,
+     'left_pad_matching': False,
+     'paren_uncertainty_separators': True,
+     'pm_whitespace': True,
+    )
+    >>> print(formatter.populated_options.as_dict())
+    {'exp_mode': 'engineering', 'exp_val': AutoExpVal, 'round_mode': 'sig_fig', 'ndigits': 2, 'upper_separator': '', 'decimal_separator': '.', 'lower_separator': '', 'sign_mode': '-', 'left_pad_char': ' ', 'left_pad_dec_place': 0, 'exp_format': 'standard', 'extra_si_prefixes': {}, 'extra_iec_prefixes': {}, 'extra_parts_per_forms': {}, 'capitalize': False, 'superscript': True, 'nan_inf_exp': False, 'paren_uncertainty': False, 'pdg_sig_figs': False, 'left_pad_matching': False, 'paren_uncertainty_separators': True, 'pm_whitespace': True}
+
+    Note that :class:`PopulatedOptions` lacks the ``add_c_prefix``,
+    ``add_small_si_prefixes`` and ``add_ppth_form`` options present
+    in :class:`InputOptions`. These options are helper functions which
+    modify the corresponding exponent replacement dictionaries.
+
+    >>> formatter = Formatter(
+    ...     exp_mode="engineering",
+    ...     exp_format="prefix",
+    ...     add_c_prefix=True,
+    ... )
+    >>> print(formatter.input_options)
+    InputOptions(
+     'exp_mode': 'engineering',
+     'exp_format': 'prefix',
+     'add_c_prefix': True,
+    )
+    >>> print(formatter.input_options.extra_si_prefixes)
+    None
+    >>> print(formatter.populated_options.extra_si_prefixes)
+    {-2: 'c'}
+
+    """  # noqa: E501
+
+    exp_mode: modes.ExpMode
+    exp_val: int | type(modes.AutoExpVal)
+    round_mode: modes.RoundMode
+    ndigits: int | type(modes.AutoDigits)
+    upper_separator: modes.UpperSeparators
+    decimal_separator: modes.DecimalSeparators
+    lower_separator: modes.LowerSeparators
+    sign_mode: modes.SignMode
+    left_pad_char: modes.LeftPadChar
+    left_pad_dec_place: int
+    exp_format: modes.ExpFormat
+    extra_si_prefixes: dict[int, str]
+    extra_iec_prefixes: dict[int, str]
+    extra_parts_per_forms: dict[int, str]
+    capitalize: bool
+    superscript: bool
+    nan_inf_exp: bool
+    paren_uncertainty: bool
+    pdg_sig_figs: bool
+    left_pad_matching: bool
+    paren_uncertainty_separators: bool
+    pm_whitespace: bool
+
+    def __post_init__(self: PopulatedOptions) -> None:
+        validate_options(self)
+
+    def as_dict(self: PopulatedOptions) -> dict[str, Any]:
+        """
+        Return a dict representation of the PopulatedOptions.
+
+        This dict can be passed into :class:`Formatter` as ``**kwargs``,
+        possibly after modification. This allows for the possibility of
+        constructing new :class:`Formatter` instances based on old ones.
+        """
+        return asdict(self)
+
+    def __str__(self: PopulatedOptions) -> str:
+        options_str = pformat(self.as_dict(), width=-1, sort_dicts=False)
+        options_str = options_str.lstrip("{").rstrip("}")
+        options_str = f"PopulatedOptions(\n {options_str},\n)"
+        return options_str

sciform/options/validation.py

@@ -0,0 +1,101 @@
+"""Options validation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, get_args
+
+from sciform import modes
+
+if TYPE_CHECKING:  # pragma: no cover
+    from sciform.options.finalized_options import FinalizedOptions
+    from sciform.options.input_options import InputOptions
+    from sciform.options.populated_options import PopulatedOptions
+
+
+def validate_options(
+    options: InputOptions | PopulatedOptions | FinalizedOptions,
+) -> None:
+    """Validate user inputs."""
+    validate_sig_fig_round_mode(options)
+    validate_exp_val(options)
+    validate_separator_options(options)
+
+
+def validate_sig_fig_round_mode(
+    options: InputOptions | PopulatedOptions | FinalizedOptions,
+) -> None:
+    r"""Validate ndigits if round_mode == "sig_fig"."""
+    if (
+        options.round_mode == "sig_fig"
+        and isinstance(options.ndigits, int)
+        and options.ndigits < 1
+    ):
+        msg = f"ndigits must be >= 1 for sig fig rounding, not {options.ndigits}."
+        raise ValueError(msg)
+
+
+def validate_exp_val(
+    options: InputOptions | PopulatedOptions | FinalizedOptions,
+) -> None:
+    """Validate exp_val."""
+    if options.exp_val is not modes.AutoExpVal and options.exp_val is not None:
+        if options.exp_mode in ["fixed_point", "percent"] and options.exp_val != 0:
+            msg = (
+                f"Exponent must must be 0, not exp_val={options.exp_val}, for "
+                f"fixed point and percent exponent modes."
+            )
+            raise ValueError(msg)
+        if (
+            options.exp_mode in ["engineering", "engineering_shifted"]
+            and options.exp_val % 3 != 0
+        ):
+            msg = (
+                f"Exponent must be a multiple of 3, not exp_val={options.exp_val}, "
+                f"for engineering exponent modes."
+            )
+            raise ValueError(msg)
+        if options.exp_mode == "binary_iec" and options.exp_val % 10 != 0:
+            msg = (
+                f"Exponent must be a multiple of 10, not "
+                f"exp_val={options.exp_val}, for binary IEC exponent mode."
+            )
+            raise ValueError(msg)
+
+
+def validate_separator_options(
+    options: InputOptions | PopulatedOptions | FinalizedOptions,
+) -> None:
+    """Validate separator user input."""
+    if options.upper_separator is not None:
+        if options.upper_separator not in get_args(modes.UpperSeparators):
+            msg = (
+                f"upper_separator must be in "
+                f"{get_args(modes.UpperSeparators)}, not "
+                f"{options.upper_separator}."
+            )
+            raise ValueError(msg)
+        if options.upper_separator == options.decimal_separator:
+            msg = (
+                f"upper_separator and decimal_separator "
+                f"({options.upper_separator}) cannot be equal."
+            )
+            raise ValueError(msg)
+
+    if options.decimal_separator is not None and (
+        options.decimal_separator not in get_args(modes.DecimalSeparators)
+    ):
+        msg = (
+            f"decimal_separator must be in "
+            f"{get_args(modes.DecimalSeparators)}, not "
+            f"{options.decimal_separator}."
+        )
+        raise ValueError(msg)
+
+    if options.lower_separator is not None and (
+        options.lower_separator not in get_args(modes.LowerSeparators)
+    ):
+        msg = (
+            f"lower_separator must be in {get_args(modes.LowerSeparators)}, "
+            f"not {options.lower_separator}."
+        )
+        raise ValueError(msg)

sciform/output_conversion.py

@@ -84,9 +84,9 @@ def convert_sciform_format(
 
     >>> from sciform.output_conversion import convert_sciform_format
     >>> print(convert_sciform_format("(7.8900 ± 0.0001)×10²", "latex"))
-    (7.8900\:\pm\:0.0001)\times10^{2}
+    $(7.8900\:\pm\:0.0001)\times10^{2}$
     >>> print(convert_sciform_format("16.18033E+03", "latex"))
-    16.18033\times10^{3}
+    $16.18033\times10^{3}$
 
     HTML
     ====

sciform/scinum.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from decimal import Decimal
 from typing import TYPE_CHECKING
 
-from sciform.formatting import format_num, format_val_unc
+from sciform.formatting import FormattedNumber, format_from_options
 from sciform.fsml import format_options_from_fmt_spec
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -23,13 +23,13 @@ class SciNum:
     be populated with global default settings at format time.
 
     >>> from sciform import SciNum
-    >>> snum = SciNum(12345.54321)
-    >>> print(f"{snum:!3f}")
+    >>> num = SciNum(12345.54321)
+    >>> print(f"{num:!3f}")
     12300
-    >>> print(f"{snum:+2.3R}")
+    >>> print(f"{num:+2.3R}")
     + 12.346E+03
-    >>> snum = SciNum(123456.654321, 0.0234)
-    >>> print(f"{snum:#!2r()}")
+    >>> num = SciNum(123456.654321, 0.0234)
+    >>> print(f"{num:#!2r()}")
     (0.123456654(23))e+06
     """
 
@@ -45,12 +45,13 @@ class SciNum:
         else:
             self.uncertainty = Decimal(str(uncertainty))
 
-    def __format__(self: SciNum, fmt: str) -> str:
-        user_options = format_options_from_fmt_spec(fmt)
-        rendered_options = user_options.render()
-        if self.uncertainty is not None:
-            return format_val_unc(self.value, self.uncertainty, rendered_options)
-        return format_num(self.value, rendered_options)
+    def __format__(self: SciNum, fmt: str) -> FormattedNumber:
+        input_options = format_options_from_fmt_spec(fmt)
+        return format_from_options(
+            self.value,
+            self.uncertainty,
+            input_options=input_options,
+        )
 
     def __repr__(self: SciNum) -> str:
         if self.uncertainty is not None:

{sciform-0.33.0.dist-info → sciform-0.34.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sciform
-Version: 0.33.0
+Version: 0.34.0
 Summary: A package for formatting numbers into scientific formatted strings.
 Author-email: Justin Gerber <justin.gerber48@gmail.com>
 Project-URL: homepage, https://github.com/jagerber48/sciform
@@ -132,18 +132,22 @@ You can view the on-going review
 Usage
 =====
 
+Here we provide a few key usage examples.
+For many more details see
+`Usage <https://sciform.readthedocs.io/en/stable/usage.html>`_.
+
 ``sciform`` provides a wide variety of formatting options which can be
 controlled when constructing ``Formatter`` objects which are then used
 to format numbers into strings according to the selected options.
 
 >>> from sciform import Formatter
->>> sform = Formatter(
+>>> formatter = Formatter(
 ...     round_mode="dec_place", ndigits=6, upper_separator=" ", lower_separator=" "
 ... )
->>> print(sform(51413.14159265359))
+>>> print(formatter(51413.14159265359))
 51 413.141 593
->>> sform = Formatter(round_mode="sig_fig", ndigits=4, exp_mode="engineering")
->>> print(sform(123456.78))
+>>> formatter = Formatter(round_mode="sig_fig", ndigits=4, exp_mode="engineering")
+>>> print(formatter(123456.78))
 123.5e+03
 
 Users can also format numbers by constructing ``SciNum`` objects and
@@ -162,11 +166,11 @@ to format pairs of numbers as value/uncertainty pairs.
 This can be done by passing two numbers into a ``Formatter`` call or by
 using the ``SciNum`` object.
 
->>> sform = Formatter(ndigits=2, upper_separator=" ", lower_separator=" ")
->>> print(sform(123456.654321, 0.00345))
+>>> formatter = Formatter(ndigits=2, upper_separator=" ", lower_separator=" ")
+>>> print(formatter(123456.654321, 0.00345))
 123 456.654 3 ± 0.003 4
->>> sform = Formatter(ndigits=4, exp_mode="engineering")
->>> print(sform(123456.654321, 0.00345))
+>>> formatter = Formatter(ndigits=4, exp_mode="engineering")
+>>> print(formatter(123456.654321, 0.00345))
 (123.456654321 ± 0.000003450)e+03
 
 >>> num = SciNum(123456.654321, 0.00345)

sciform-0.34.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+sciform/__init__.py,sha256=S6-oZ4wA-h2iFlpUhrRLDSycdn5b8kRd5s5xGI64-a8,844
+sciform/format_utils.py,sha256=JNFlSxxM9K3M1KI5oLyTsPPzAsvgKDQAGgxPN3wqG_I,16545
+sciform/formatter.py,sha256=paVP2I6IO9y7lvkFB7_tMGFikfp7MS9PSlSG5zPWrzQ,15057
+sciform/formatting.py,sha256=Z2jLIeuqMm6JWd_FurJ_-rU0Yr96jT-tb8CYEzjPgZA,12228
+sciform/fsml.py,sha256=r22RiBPrkDaiPgE2VQrtGms9aBmWqolymsmmnp-z57s,3378
+sciform/global_configuration.py,sha256=L3nORbdGOO6ZZk8Xv81lr8S95Od35CgxlpOsdJDxs44,6964
+sciform/grouping.py,sha256=1hZjjVKRUy477LGGFniZwwEHHBDaSb6E0K3SAeCACVY,1641
+sciform/modes.py,sha256=8slohyIPHeAdgq3aszoNq9RJl6ibageFqDMxeC9NhrQ,3893
+sciform/output_conversion.py,sha256=IwylcmSXdfIZlVaa7fplL0E0F6JdtJyoHC_T9ZwGYo8,5489
+sciform/prefix.py,sha256=1rJeKMs8m97V3ZvMzHikqXLDDINp9aEK0AI3YaCcRMw,596
+sciform/scinum.py,sha256=oqbXiENMwELQmhVF7sR6fcnBECqDV8GNyOLNIrNIB9I,1857
+sciform/options/__init__.py,sha256=tw_CZHaNrdixZoQyG6ZD5UMKkQxXok0qBQCxt28Gh20,51
+sciform/options/conversion.py,sha256=ReqASoGNQIfa-r5-HEGZxokENti_NRkAjRP-zrxY0EU,4124
+sciform/options/finalized_options.py,sha256=PNcoAiB_WccbqxRJ5o_WPLnqb_n3J_MDpFTKqJxdSBM,1388
+sciform/options/global_options.py,sha256=8493K2Yu47D8-Dr6rgVWVKAVo-aAVaPzFNEpG7X0IAk,782
+sciform/options/input_options.py,sha256=gGUhuZr_t89IVhHwpEbtzLV9hvjMXVdMCgwe9OghO4k,3788
+sciform/options/populated_options.py,sha256=rVExq0YXzpk9kk-KUVm2oGXQEH56jBDGtZZ2vTqLqqo,4999
+sciform/options/validation.py,sha256=O1UTe5yHA0eN7sTtDsMNBh-1t3C-lbPayGoW9kn7FSU,3527
+sciform-0.34.0.dist-info/LICENSE,sha256=-oyCEZu-6HLrRSfRg44uuNDE0c59GVEdqYIgidqSP70,1056
+sciform-0.34.0.dist-info/METADATA,sha256=wZhvWEVrSkst3jLEYmpX5imgbzg0IatMk861S37M0f4,8002
+sciform-0.34.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+sciform-0.34.0.dist-info/top_level.txt,sha256=mC01YOQ-1u5pDk9BJia-pQKLUMvkreMsldDpFcp7NV8,8
+sciform-0.34.0.dist-info/RECORD,,