Keep the stored literal of a raw decimal zero (LMFDB#1010)

raw_json_dumps special-cased RealNumber, but psycodict does not hand back
a numeric that is exactly zero as one: numeric_converter returns an
LmfdbDecimalZero, an integer wrapper keeping the literal in .literal.
Such a value fell through to Json.prep, which sees a Sage integer and
emits 0, dropping the stored scale and, for -0.000, the sign, whether the
zero stood alone or sat inside a numeric[], a list or a dictionary. That
contradicted the format's promise that a numeric is the decimal Postgres
sent, copied verbatim.

The literal lookup moves into exact_decimal(), which handles the integer
wrapper alongside RealLiteral and RealNumber and validates the literal
against the JSON number syntax once, so nothing is rebuilt from a float
or an int. A numeric with no decimal point is still a Sage integer and is
unaffected; NaN and the infinities still fall back to psycodict's
extended encoding rather than emit an unparseable token.

test_api.py gains test_raw_json_dumps, calling the serializer directly so
the behaviour does not depend on finding a zero-valued row: 0.000, -0.000
and 1.250 come back verbatim, as do zeros nested in an array and in an
object, and each result is re-parsed as JSON. The exact strings are the
point, since Decimal("-0.000") == Decimal("0.000").

Verified: sage -python -m pytest lmfdb/api/test_api.py -> 8 passed;
pyflakes and ruff clean; /api/lfunc_lfunctions/?_format=raw&_fields=
mu_imag,analytic_normalization now gives [[0.0], 0] rather than [[0], 0].

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: roed314

lmfdb/api/api.py

@@ -6,7 +6,7 @@
 from sage.rings.real_mpfr import RealLiteral, RealNumber
 from lmfdb.utils.psycopg_compat import QueryCanceledError
 from lmfdb import db
-from psycodict.encoding import Json
+from psycodict.encoding import Json, LmfdbDecimalZero
 from lmfdb.utils import flash_error, comma
 from lmfdb.utils.datetime_utils import utc_now_naive
 from lmfdb.logger import logger
@@ -39,6 +39,28 @@ def pretty_document(rec, sep=", ", id=True):
 JSON_NUMBER_RE = re.compile(r"-?(0|[1-9][0-9]*)(\.[0-9]+)?([eE][-+]?[0-9]+)?\Z")
 
 
+def exact_decimal(value):
+    """
+    The decimal that Postgres sent for a numeric value, as JSON number text.
+
+    psycodict hands a numeric back as a Sage real remembering the decimal it
+    was built from, except for a decimal that is exactly zero, which it hands
+    back as an integer wrapper remembering it instead.  Either way the literal
+    is the value, and rebuilding it from a float or an int would drop the
+    stored scale, and with it the sign of a literal like -0.000.
+
+    None if there is no such literal, or if it is not JSON number syntax: NaN
+    and the infinities have no JSON representation.
+    """
+    if isinstance(value, (LmfdbDecimalZero, RealLiteral)):
+        literal = value.literal
+    elif isinstance(value, RealNumber):
+        literal = str(value)
+    else:
+        return None
+    return literal if JSON_NUMBER_RE.match(literal) else None
+
+
 def raw_json_dumps(value):
     """
     The JSON text for one database value in the raw output format.
@@ -51,14 +73,10 @@ def raw_json_dumps(value):
     rounded.  Values with no plain JSON rendering (rationals, number field
     elements, dates, ...) keep psycodict's extended encoding.
     """
-    if isinstance(value, RealNumber):
-        literal = value.literal if isinstance(value, RealLiteral) else str(value)
-        # NaN and the infinities have no JSON number syntax, so they fall
-        # through to the extended encoding rather than produce a line that no
-        # JSON reader will accept.
-        if JSON_NUMBER_RE.match(literal):
-            return literal
-    elif isinstance(value, (list, tuple)):
+    literal = exact_decimal(value)
+    if literal is not None:
+        return literal
+    if isinstance(value, (list, tuple)):
         return "[" + ", ".join(raw_json_dumps(entry) for entry in value) + "]"
     elif isinstance(value, dict) and all(isinstance(key, str) for key in value):
         return "{" + ", ".join("%s: %s" % (json.dumps(key), raw_json_dumps(val))

lmfdb/api/test_api.py

@@ -1,6 +1,9 @@
 import json
 from decimal import Decimal
 
+from psycodict.encoding import numeric_converter
+
+from lmfdb.api.api import raw_json_dumps
 from lmfdb.tests import LmfdbTest
 
 class ApiTest(LmfdbTest):
@@ -61,6 +64,27 @@ def test_api_examples_json(self):
         data = self.tc.get("/api/{}".format(query), follow_redirects=True).get_data(as_text=True)
         assert '"label": "12.2.167630295667.1",' in data
 
+    def test_raw_json_dumps(self):
+        r"""
+        Check the raw serializer (LMFDB#1010) on the decimals that are awkward
+        to look for in the database: one that is exactly zero, which psycodict
+        hands back as an exact integer wrapper rather than as a real number,
+        and which still carries the scale, and the sign, that Postgres sent.
+        The exact strings are what matters, since numeric equality catches
+        neither a lost scale nor a lost sign.
+        """
+        for text in ('0.000', '-0.000', '1.250', '-0.30800984111840306468901426146'):
+            out = raw_json_dumps(numeric_converter(text))
+            assert out == text
+            json.loads(out)  # and every one of them is valid JSON
+        # zeros nested in an array or an object keep their literal too
+        out = raw_json_dumps([numeric_converter('1.250'), numeric_converter('0.000')])
+        assert out == '[1.250, 0.000]'
+        assert json.loads(out, parse_float=Decimal) == [Decimal('1.250'), Decimal('0.000')]
+        out = raw_json_dumps({'a': numeric_converter('-0.000')})
+        assert out == '{"a": -0.000}'
+        assert json.loads(out, parse_float=Decimal) == {'a': Decimal('-0.000')}
+
     def test_api_raw(self):
         r"""
         Check the raw output format (LMFDB#1010): newline-delimited JSON with