Defer formatting to adjust format based on the ouput context

[Batalex]

The current sciform implementation eagerly formats values as soon as Formatter.__call__ is called.
This discussion is about making sciform implementation lazy so the actual format would happen when the value is printed.

Here is a quick look at what it could look like

# sciform.formatter.py

class Formatter:
    # ...
    # __init__


    def __call__(self, value: Number, uncertainty: Number = None, /):
-        rendered_options = self.user_options.render()
-        if uncertainty is None:
-            return format_num(Decimal(str(value)), rendered_options)
-        else:
-            return format_val_unc(Decimal(str(value)),
-                                  Decimal(str(uncertainty)),
-                                  rendered_options)
+    return FormattedValue(self, value, uncertainty)

+class FormattedValue(str):
+
+    def __init__(self, fmt: Formatter, value: Number, uncertainty: Optional[Number] = None, /) -> None:
+        self.fmt = fmt
+        self.value = value
+        self.uncertainty = uncertainty
+
+    def __str__(self) -> str:
        rendered_options = self.fmt.user_options.render()
        if self.uncertainty is None:
            return format_num(Decimal(str(self.value)), rendered_options)
        else:
            return format_val_unc(Decimal(str(self.value)),
                                  Decimal(str(self.uncertainty)),
                                  rendered_options)

The example above would be similar to the current implementation, but you could then add _repr_html_ or _repr_latex_ methods so that your displayed value uses \textsuperscript in a LaTeX document or <sup></sup> in a notebook.

[jagerber48]

@Batalex thanks for this suggestion. How do you see this interfacing with the existing latex and superscript options?

My feeling is that the superscript option would remain as it is unchanged so that users can convert e+02 notation to unicode strings like ×10² even for code that might be output to a terminal directly from python.

But I think that your suggested lazy formatting strategy would basically have us remove the latex option from the formatter entirely, and instead repr_html or repr_latex or would be responsible for the conversion.

How do you imagine users using the FormattedValue? e.g. Why not just keep the current latex option and add an additional html option?

Also, I'm not sure the easiest way to implement the latex or html conversion strategies. Right now the latex mode has some steps that occur during the formatting, but other steps can just be applied as string replacements at the end. It would be easier if sciform could proceed as if latex=False throughout the formatting, returning a string, and then a separate functions exists to make that string a latex or html string, but I'm not sure if it can be done that easily.

[Batalex]

The main benefit would be that a single piece of code could be used in various contexts without user input.
For instance :

num = SciNum(12345)

In the Python REPL, displaying num like this

num

would use the __str__ implementation of the rendering logic.

In a notebook, the jupyter kernel would look for the _repr_html_ method.
In a quarto document with a pdf output format, _repr_latex_ would be used.

Also, I'm not sure the easiest way to implement the latex or html conversion strategies. Right now the latex mode has some steps that occur during the formatting, but other steps can just be applied as string replacements at the end. It would be easier if sciform could proceed as if latex=False throughout the formatting, returning a string, and then a separate functions exists to make that string a latex or html string, but I'm not sure if it can be done that easily.

Yeah, I fully agree with you. Ideally, we would like to regroup as much rendering logic as we could and avoid code duplicates

[jagerber48]

@Batalex I changed my mind on discussions/issues and I've moved this discussion to an issue here: #114

[jagerber48]

As a matter of separation of responsibilities I think it would be better if the Formatter lost the latex option and there was a separate tool that could convert sciform output into good latex or html commands. I don't know if this is easily possible or not. Once a string is parsed into mantissa, base and exp it is pretty easy to detect and do the conversion I think. The main challenge I see is a sciform output like 123.456,654 32 m. Here upper_separator=".", lower_separator=" " and decimal_separator=",". Additionally, prefix form is used to give m as a stand in for e-03. I'm not sure what regex can be used to disentangle the space-separated digits after the decimal symbol from the alphabetic SI prefix.

Maybe I could restrict the prefixes/parts-per-forms to be alphabetic and use the presence of alphabetic characters and the end of the string as a signal that a prefix mode has been used.