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

sciform/formatting.py

@@ -1,11 +1,15 @@
 """Main formatting functions."""
+from __future__ import annotations
 
 from dataclasses import replace
 from decimal import Decimal
-from typing import cast
+from typing import TYPE_CHECKING, cast
 from warnings import warn
 
+from typing_extensions import Self
+
 from sciform.format_utils import (
+    Number,
     construct_val_unc_exp_str,
     construct_val_unc_str,
     format_num_by_top_bottom_dig,
@@ -13,9 +17,8 @@ from sciform.format_utils import (
     get_mantissa_exp_base,
     get_round_digit,
     get_val_unc_exp,
-    get_val_unc_mantissa_exp_strs,
+    get_val_unc_mantissa_strs,
     get_val_unc_top_digit,
-    latex_translate,
     round_val_unc,
 )
 from sciform.grouping import add_separators
@@ -26,10 +29,35 @@ from sciform.modes import (
     RoundModeEnum,
     SignModeEnum,
 )
-from sciform.rendered_options import RenderedOptions
+from sciform.options.conversion import finalize_populated_options, populate_options
+from sciform.output_conversion import convert_sciform_format
+
+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 format_from_options(
+    value: Number,
+    uncertainty: Number | None = None,
+    /,
+    input_options: InputOptions | None = None,
+) -> FormattedNumber:
+    """Finalize options and select value of value/uncertainty formatter."""
+    populated_options = populate_options(input_options)
+    finalized_options = finalize_populated_options(populated_options)
+    value = Decimal(str(value))
+
+    if uncertainty is not None:
+        uncertainty = Decimal(str(uncertainty))
+        formatted_str = format_val_unc(value, uncertainty, finalized_options)
+    else:
+        formatted_str = format_num(value, finalized_options)
+    return FormattedNumber(formatted_str, populated_options)
 
 
-def format_non_finite(num: Decimal, options: RenderedOptions) -> str:
+def format_non_finite(num: Decimal, options: FinalizedOptions) -> str:
     """Format non-finite numbers."""
     if num.is_nan():
         num_str = "nan"
@@ -53,8 +81,6 @@ def format_non_finite(num: Decimal, options: RenderedOptions) -> str:
             exp_mode=exp_mode,
             exp_format=options.exp_format,
             capitalize=options.capitalize,
-            latex=options.latex,
-            latex_trim_whitespace=True,
             superscript=options.superscript,
             extra_si_prefixes=options.extra_si_prefixes,
             extra_iec_prefixes=options.extra_iec_prefixes,
@@ -73,13 +99,10 @@ def format_non_finite(num: Decimal, options: RenderedOptions) -> str:
     else:
         result = result.lower()
 
-    if options.latex:
-        result = latex_translate(result)
-
     return result
 
 
-def format_num(num: Decimal, options: RenderedOptions) -> str:
+def format_num(num: Decimal, options: FinalizedOptions) -> str:
     """Format a single number according to input options."""
     if not num.is_finite():
         return format_non_finite(num, options)
@@ -115,13 +138,13 @@ def format_num(num: Decimal, options: RenderedOptions) -> str:
         """
         exp_val = 0
 
-    fill_char = options.fill_char.value
+    left_pad_char = options.left_pad_char.value
     mantissa_str = format_num_by_top_bottom_dig(
         mantissa_rounded.normalize(),
         options.left_pad_dec_place,
         round_digit,
         options.sign_mode,
-        fill_char,
+        left_pad_char,
     )
 
     upper_separator = options.upper_separator.value
@@ -140,8 +163,6 @@ def format_num(num: Decimal, options: RenderedOptions) -> str:
         exp_mode=exp_mode,
         exp_format=options.exp_format,
         capitalize=options.capitalize,
-        latex=options.latex,
-        latex_trim_whitespace=False,
         superscript=options.superscript,
         extra_si_prefixes=options.extra_si_prefixes,
         extra_iec_prefixes=options.extra_iec_prefixes,
@@ -150,13 +171,10 @@ def format_num(num: Decimal, options: RenderedOptions) -> str:
 
     result = f"{mantissa_str}{exp_str}"
 
-    if options.latex:
-        result = latex_translate(result)
-
     return result
 
 
-def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
+def format_val_unc(val: Decimal, unc: Decimal, options: FinalizedOptions) -> str:
     """Format value/uncertainty pair according to input options."""
     exp_mode = options.exp_mode
 
@@ -205,7 +223,7 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
         use_pdg_sig_figs=options.pdg_sig_figs,
     )
 
-    exp_val, exp_driver_type = get_val_unc_exp(
+    exp_val = get_val_unc_exp(
         val_rounded,
         unc_rounded,
         options.exp_mode,
@@ -240,7 +258,7 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
        * With the calculated shared exponent
        * Without percent mode (percent mode for val/unc pairs is
          handled below in the scope of this function)
-       * Without superscript, prefix, parts-per, or latex translations.
+       * Without superscript, prefix, or parts-per translations.
          The remaining steps rely on parsing an exponent string like
          'e+03' or similar. Such translations are handled within the
          scope of this function.
@@ -253,7 +271,6 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
         exp_mode=exp_mode,
         exp_val=exp_val,
         superscript=False,
-        latex=False,
         exp_format=ExpFormatEnum.STANDARD,
     )
 
@@ -265,10 +282,9 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
     val_mantissa_exp_str = format_num(val_rounded, val_format_options)
     unc_mantissa_exp_str = format_num(unc_rounded, unc_format_options)
 
-    (val_mantissa_str, unc_mantissa_str, exp_str) = get_val_unc_mantissa_exp_strs(
+    val_mantissa_str, unc_mantissa_str = get_val_unc_mantissa_strs(
         val_mantissa_exp_str,
         unc_mantissa_exp_str,
-        exp_driver_type,
     )
 
     val_unc_str = construct_val_unc_str(
@@ -278,12 +294,11 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
         unc_mantissa,
         decimal_separator=options.decimal_separator,
         paren_uncertainty=options.paren_uncertainty,
-        latex=options.latex,
         pm_whitespace=options.pm_whitespace,
         paren_uncertainty_separators=options.paren_uncertainty_separators,
     )
 
-    if exp_str is not None:
+    if val.is_finite() or unc.is_finite() or options.nan_inf_exp:
         val_unc_exp_str = construct_val_unc_exp_str(
             val_unc_str=val_unc_str,
             exp_val=exp_val,
@@ -293,7 +308,6 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
             extra_iec_prefixes=options.extra_iec_prefixes,
             extra_parts_per_forms=options.extra_parts_per_forms,
             capitalize=options.capitalize,
-            latex=options.latex,
             superscript=options.superscript,
             paren_uncertainty=options.paren_uncertainty,
         )
@@ -303,7 +317,62 @@ def format_val_unc(val: Decimal, unc: Decimal, options: RenderedOptions) -> str:
     if options.exp_mode is ExpModeEnum.PERCENT:
         val_unc_exp_str = f"({val_unc_exp_str})%"
 
-    if options.latex:
-        val_unc_exp_str = latex_translate(val_unc_exp_str)
-
     return val_unc_exp_str
+
+
+class FormattedNumber(str):
+    """
+    Representation of a formatted value of value/uncertainty pair.
+
+    The :class:`FormattedNumber` class is returned by ``sciform``
+    formatting methods. In most cases it behaves like a regular python
+    string, but it provides functionality for post-converting the string
+    to various other formats such as latex or html. This allows the
+    formatted number to be displayed in a range of contexts other than
+    e.g. text terminals.
+
+    The :class:`FormattedNumber` class should never be instantiated
+    directly.
+    """
+
+    __slots__ = {
+        "populated_options": "Record of the :class:`PopulatedOptions` used to "
+        "generate the :class:`FormattedNumber`.",
+    }
+
+    def __new__(
+        cls: type[Self],
+        formatted_str: str,
+        populated_options: PopulatedOptions,
+    ) -> Self:
+        """Get a new string."""
+        obj = super().__new__(cls, formatted_str)
+        obj.populated_options = populated_options
+        return obj
+
+    def as_str(self: FormattedNumber) -> str:
+        """Return the string representation of the formatted number."""
+        return self.__str__()
+
+    def as_ascii(self: FormattedNumber) -> str:
+        """Return the ascii representation of the formatted number."""
+        return convert_sciform_format(self, "ascii")
+
+    def as_html(self: FormattedNumber) -> str:
+        """Return the html representation of the formatted number."""
+        return convert_sciform_format(self, "html")
+
+    def as_latex(self: FormattedNumber, *, strip_math_mode: bool = False) -> str:
+        """Return the latex representation of the formatted number."""
+        latex_repr = convert_sciform_format(self, "latex")
+        if strip_math_mode:
+            latex_repr = latex_repr.strip("$")
+        return latex_repr
+
+    def _repr_html_(self: FormattedNumber) -> str:
+        """Hook for HTML display."""  # noqa: D401
+        return self.as_html()
+
+    def _repr_latex_(self: FormattedNumber) -> str:
+        """Hook for LaTeX display."""  # noqa: D401
+        return self.as_latex()

sciform/fsml.py

@@ -4,11 +4,11 @@ from __future__ import annotations
 
 import re
 
-from sciform.user_options import UserOptions
+from sciform.options.input_options import InputOptions
 
 pattern = re.compile(
     r"""^
-                         (?:(?P<fill_char>[ 0])=)?
+                         (?:(?P<left_pad_char>[ 0])=)?
                          (?P<sign_mode>[-+ ])?
                          (?P<alternate_mode>\#)?
                          (?P<left_pad_dec_place>\d+)?
@@ -51,14 +51,14 @@ def parse_exp_mode(
     return exp_mode, capitalize
 
 
-def format_options_from_fmt_spec(fmt_spec: str) -> UserOptions:
-    """Resolve UserOptions form format specification string."""
+def format_options_from_fmt_spec(fmt_spec: str) -> InputOptions:
+    """Resolve InputOptions from format specification string."""
     match = pattern.match(fmt_spec)
     if match is None:
         msg = f"Invalid format specifier: '{fmt_spec}'"
         raise ValueError(msg)
 
-    fill_char = match.group("fill_char")
+    left_pad_char = match.group("left_pad_char")
     sign_mode = match.group("sign_mode")
 
     alternate_mode = match.group("alternate_mode")
@@ -101,8 +101,8 @@ def format_options_from_fmt_spec(fmt_spec: str) -> UserOptions:
     else:
         paren_uncertainty = None
 
-    return UserOptions(
-        fill_char=fill_char,
+    return InputOptions(
+        left_pad_char=left_pad_char,
         sign_mode=sign_mode,
         left_pad_dec_place=left_pad_dec_place,
         round_mode=round_mode,

sciform/global_configuration.py

@@ -4,21 +4,28 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from sciform import global_options, modes
-from sciform.user_options import UserOptions
+from sciform.options import global_options
+from sciform.options.conversion import populate_options
+from sciform.options.input_options import InputOptions
 
 if TYPE_CHECKING:  # pragma: no cover
     from types import TracebackType
 
-    from sciform.rendered_options import RenderedOptions
+    from sciform import modes
+    from sciform.options.populated_options import PopulatedOptions
 
 
-def print_global_defaults() -> None:
-    """Print current global default formatting options as a dictionary."""
-    print(str(global_options.GLOBAL_DEFAULT_OPTIONS))  # noqa: T201
+def get_default_global_options() -> PopulatedOptions:
+    """Return the package default global options."""
+    return global_options.PKG_DEFAULT_OPTIONS
 
 
-def set_global_defaults(  # noqa: PLR0913
+def get_global_options() -> PopulatedOptions:
+    """Return the current global options."""
+    return global_options.GLOBAL_DEFAULT_OPTIONS
+
+
+def set_global_options(  # noqa: PLR0913
     *,
     exp_mode: modes.ExpMode | None = None,
     exp_val: int | type(modes.AutoExpVal) | None = None,
@@ -28,7 +35,7 @@ def set_global_defaults(  # noqa: PLR0913
     decimal_separator: modes.DecimalSeparators | None = None,
     lower_separator: modes.LowerSeparators | None = None,
     sign_mode: modes.SignMode | None = None,
-    fill_char: modes.FillChar | None = None,
+    left_pad_char: modes.LeftPadChar | None = None,
     left_pad_dec_place: int | None = None,
     exp_format: modes.ExpFormat | None = None,
     extra_si_prefixes: dict[int, str] | None = None,
@@ -36,7 +43,6 @@ def set_global_defaults(  # noqa: PLR0913
     extra_parts_per_forms: dict[int, str] | None = None,
     capitalize: bool | None = None,
     superscript: bool | None = None,
-    latex: bool | None = None,
     nan_inf_exp: bool | None = None,
     paren_uncertainty: bool | None = None,
     pdg_sig_figs: bool | None = None,
@@ -48,11 +54,11 @@ def set_global_defaults(  # noqa: PLR0913
     add_ppth_form: bool = False,
 ) -> None:
     """
-    Configure global default format options.
+    Configure the global options.
 
     Accepts the same keyword arguments as :class:`Formatter`.
     """
-    user_options = UserOptions(
+    input_options = InputOptions(
         exp_mode=exp_mode,
         exp_val=exp_val,
         round_mode=round_mode,
@@ -61,7 +67,7 @@ def set_global_defaults(  # noqa: PLR0913
         decimal_separator=decimal_separator,
         lower_separator=lower_separator,
         sign_mode=sign_mode,
-        fill_char=fill_char,
+        left_pad_char=left_pad_char,
         left_pad_dec_place=left_pad_dec_place,
         exp_format=exp_format,
         extra_si_prefixes=extra_si_prefixes,
@@ -69,7 +75,6 @@ def set_global_defaults(  # noqa: PLR0913
         extra_parts_per_forms=extra_parts_per_forms,
         capitalize=capitalize,
         superscript=superscript,
-        latex=latex,
         nan_inf_exp=nan_inf_exp,
         paren_uncertainty=paren_uncertainty,
         pdg_sig_figs=pdg_sig_figs,
@@ -80,30 +85,30 @@ def set_global_defaults(  # noqa: PLR0913
         add_small_si_prefixes=add_small_si_prefixes,
         add_ppth_form=add_ppth_form,
     )
-    set_global_defaults_rendered(user_options.render())
+    set_global_options_populated(populate_options(input_options))
 
 
-def set_global_defaults_rendered(rendered_options: RenderedOptions) -> None:
-    """Directly set global defaults to input RenderedOptions."""
-    global_options.GLOBAL_DEFAULT_OPTIONS = rendered_options
+def set_global_options_populated(populated_options: PopulatedOptions) -> None:
+    """Directly set global options to input :class:`PopulatedOptions`."""
+    global_options.GLOBAL_DEFAULT_OPTIONS = populated_options
 
 
-def reset_global_defaults() -> None:
-    """Reset global default options to :mod:`sciform` package defaults."""
+def reset_global_options() -> None:
+    """Reset global options to :mod:`sciform` package defaults."""
     global_options.GLOBAL_DEFAULT_OPTIONS = global_options.PKG_DEFAULT_OPTIONS
 
 
-class GlobalDefaultsContext:
+class GlobalOptionsContext:
     """
-    Temporarily update global default options.
+    Temporarily update global options.
 
-    New settings are applied when the context is entered and original
-    global settings are re-applied when the context is exited. Accepts
-    the same keyword arguments as :class:`Formatter`.
+    New global options are applied when the context is entered and the
+    original global settings are re-applied when the context is exited.
+    Accepts the same keyword arguments as :class:`Formatter`.
     """
 
     def __init__(  # noqa: PLR0913
-        self: GlobalDefaultsContext,
+        self: GlobalOptionsContext,
         *,
         exp_mode: modes.ExpMode | None = None,
         exp_val: int | type(modes.AutoExpVal) | None = None,
@@ -113,7 +118,7 @@ class GlobalDefaultsContext:
         decimal_separator: modes.DecimalSeparators | None = None,
         lower_separator: modes.LowerSeparators | None = None,
         sign_mode: modes.SignMode | None = None,
-        fill_char: modes.FillChar | None = None,
+        left_pad_char: modes.LeftPadChar | None = None,
         left_pad_dec_place: int | None = None,
         exp_format: modes.ExpFormat | None = None,
         extra_si_prefixes: dict[int, str] | None = None,
@@ -121,7 +126,6 @@ class GlobalDefaultsContext:
         extra_parts_per_forms: dict[int, str] | None = None,
         capitalize: bool | None = None,
         superscript: bool | None = None,
-        latex: bool | None = None,
         nan_inf_exp: bool | None = None,
         paren_uncertainty: bool | None = None,
         pdg_sig_figs: bool | None = None,
@@ -132,7 +136,7 @@ class GlobalDefaultsContext:
         add_small_si_prefixes: bool = False,
         add_ppth_form: bool = False,
     ) -> None:
-        user_options = UserOptions(
+        input_options = InputOptions(
             exp_mode=exp_mode,
             exp_val=exp_val,
             round_mode=round_mode,
@@ -141,7 +145,7 @@ class GlobalDefaultsContext:
             decimal_separator=decimal_separator,
             lower_separator=lower_separator,
             sign_mode=sign_mode,
-            fill_char=fill_char,
+            left_pad_char=left_pad_char,
             left_pad_dec_place=left_pad_dec_place,
             exp_format=exp_format,
             extra_si_prefixes=extra_si_prefixes,
@@ -149,7 +153,6 @@ class GlobalDefaultsContext:
             extra_parts_per_forms=extra_parts_per_forms,
             capitalize=capitalize,
             superscript=superscript,
-            latex=latex,
             nan_inf_exp=nan_inf_exp,
             paren_uncertainty=paren_uncertainty,
             pdg_sig_figs=pdg_sig_figs,
@@ -160,19 +163,19 @@ class GlobalDefaultsContext:
             add_small_si_prefixes=add_small_si_prefixes,
             add_ppth_form=add_ppth_form,
         )
-        self.rendered_options = user_options.render()
+        self.populated_options = populate_options(input_options)
         self.initial_global_defaults = None
 
-    def __enter__(self: GlobalDefaultsContext) -> None:
+    def __enter__(self: GlobalOptionsContext) -> None:
         """Enter the context."""
-        self.initial_global_defaults = global_options.GLOBAL_DEFAULT_OPTIONS
-        set_global_defaults_rendered(self.rendered_options)
+        self.initial_global_defaults = get_global_options()
+        set_global_options_populated(self.populated_options)
 
     def __exit__(
-        self: GlobalDefaultsContext,
+        self: GlobalOptionsContext,
         exc_type: type[BaseException] | None,
         exc_val: BaseException | None,
         exc_tb: TracebackType | None,
     ) -> None:
         """Exit the context."""
-        set_global_defaults_rendered(self.initial_global_defaults)
+        set_global_options_populated(self.initial_global_defaults)

sciform/modes.py

@@ -50,11 +50,11 @@ class AutoDigits(metaclass=SentinelMeta):
     """
 
 
-FillChar = Literal[" ", "0"]
+LeftPadChar = Literal[" ", "0"]
 
 
-class FillCharEnum(str, Enum):
-    """Fill mode Enum."""
+class LeftPadCharEnum(str, Enum):
+    """Left pad character mode Enum."""
 
     SPACE = " "
     ZERO = "0"
@@ -145,13 +145,6 @@ class ExpFormatEnum(str, Enum):
     PARTS_PER = "parts_per"
 
 
-class ExpDriver(Enum):
-    """Exponent drive Enum. Used for value/uncertainty formatting."""
-
-    VAL = "val"
-    UNC = "unc"
-
-
 T = TypeVar("T", bound=Enum)
 
 

sciform/options/__init__.py

@@ -0,0 +1 @@
+"""Code pertaining to sciform options handling."""

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