Ensure support for non-finite floats

vidartf · vidartf · commit 72d27dc5affb · 2022-05-26T14:19:19.000+01:00
jupyter_client has deprecated support for non-finite floats, and aggressively prints to stderr if you try to serialize them.

Notes: We do not need a deserializer, as CFloats will handle the conversion in its validator. We were already relying on this fact, so no change. Similarly, the JS convertFloat[...] functions continue to serialize/deserialize there. This also extends Vector/Matrix/Euler to support IEEE floats.
diff --git a/js/scripts/prop-types.js b/js/scripts/prop-types.js
@@ -303,7 +303,7 @@ class Float extends BaseType {
         if (this.maxValue !== undefined) {
             limits += `, max=${this.maxValue}`;
         }
-        return `CFloat(${this.getPythonDefaultValue()}, ${nullableStr}${limits})${this.getTagString()}`;
+        return `IEEEFloat(${this.getPythonDefaultValue()}, ${nullableStr}${limits})${this.getTagString()}`;
     }
     getPropertyConverterFn() {
         return 'convertFloat';
diff --git a/js/src/_base/Three.js b/js/src/_base/Three.js
@@ -501,9 +501,9 @@ class ThreeModel extends widgets.WidgetModel {
     }
 
     convertFloatThreeToModel(v) {
-        if (isFinite(v)) { // Most common first
+        if (Number.isFinite(v)) { // Most common first
             return v;
-        } else if (isNaN(v)) {
+        } else if (Number.isNaN(v)) {
             return 'nan';
         } else if (v === Infinity) {
             return 'inf';
@@ -554,12 +554,12 @@ class ThreeModel extends widgets.WidgetModel {
         default:
             throw new Error('model vector has invalid length: ' + v.length);
         }
-        result.fromArray(v);
+        result.fromArray(v.map(this.convertFloatModelToThree));
         return result;
     }
 
     convertVectorThreeToModel(v) {
-        return v.toArray();
+        return v.toArray().map(this.convertFloatThreeToModel);
     }
 
     assignVector(obj, key, value) {
@@ -568,11 +568,13 @@ class ThreeModel extends widgets.WidgetModel {
 
     // Euler
     convertEulerModelToThree(v) {
-        return new THREE.Euler().fromArray(v);
+        // The float conversions will ignore the "XYZ" order strings
+        return new THREE.Euler().fromArray(v.map(this.convertFloatModelToThree));
     }
 
     convertEulerThreeToModel(v) {
-        return v.toArray();
+        // The float conversions will ignore the "XYZ" order strings
+        return v.toArray().map(this.convertFloatThreeToModel);
     }
 
     assignEuler(obj, key, value) {
@@ -676,12 +678,12 @@ class ThreeModel extends widgets.WidgetModel {
         default:
             throw new Error('model matrix has invalid length: ' + m.length);
         }
-        result.fromArray(m);
+        result.fromArray(m.map(this.convertFloatModelToThree));
         return result;
     }
 
     convertMatrixThreeToModel(m) {
-        return m.toArray();
+        return m.toArray().map(this.convertFloatThreeToModel);
     }
 
     assignMatrix(obj, key, value) {
diff --git a/pythreejs/_base/renderable.py b/pythreejs/_base/renderable.py
@@ -1,5 +1,5 @@
 from ipywidgets import DOMWidget, Widget, widget_serialization
-from traitlets import Unicode, CInt, CFloat, Enum, Bool, Int, Instance, List
+from traitlets import Unicode, CInt, Enum, Bool, Int, Instance, List
 
 from .._package import npm_pkg_name
 from .._version import EXTENSION_SPEC_VERSION
@@ -8,6 +8,7 @@
 from ..enums import ToneMappings
 from ..math.Plane_autogen import Plane
 from ..renderers.webgl.WebGLShadowMap_autogen import WebGLShadowMap
+from ..traits import IEEEFloat
 
 
 class RenderableWidget(DOMWidget):
@@ -28,7 +29,7 @@ class RenderableWidget(DOMWidget):
     autoClearDepth = Bool(True).tag(sync=True)
     autoClearStencil = Bool(True).tag(sync=True)
     clippingPlanes = List(Instance(Plane)).tag(sync=True, **widget_serialization)
-    gammaFactor = CFloat(2.0).tag(sync=True)
+    gammaFactor = IEEEFloat(2.0).tag(sync=True)
     gammaInput = Bool(False).tag(sync=True)
     gammaOutput = Bool(False).tag(sync=True)
     localClippingEnabled = Bool(False).tag(sync=True)
@@ -38,11 +39,11 @@ class RenderableWidget(DOMWidget):
     shadowMap = Instance(WebGLShadowMap, args=(), allow_none=True).tag(sync=True, **widget_serialization)
     sortObject = Bool(True).tag(sync=True)
     toneMapping = Enum(ToneMappings, 'LinearToneMapping').tag(sync=True)
-    toneMappingExposure = CFloat(1.0).tag(sync=True)
-    toneMappingWhitePoint = CFloat(1.0).tag(sync=True)
+    toneMappingExposure = IEEEFloat(1.0).tag(sync=True)
+    toneMappingWhitePoint = IEEEFloat(1.0).tag(sync=True)
 
     clearColor = Unicode('#000000').tag(sync=True)
-    clearOpacity = CFloat(1.0).tag(sync=True)
+    clearOpacity = IEEEFloat(1.0).tag(sync=True)
 
     def send_msg(self, message_type, payload=None):
         if payload is None:
diff --git a/pythreejs/_base/uniforms.py b/pythreejs/_base/uniforms.py
@@ -1,51 +1,70 @@
 
+import numbers
+import math
+
 from ipywidgets import Widget, widget_serialization
 
+
+def _serialize_item(value):
+    if value is None:
+        return { 'value': None }
+
+    elif isinstance(value, Widget):
+        return {
+            'type': 't',
+            'value': widget_serialization['to_json'](value, None)
+        }
+
+    elif isinstance(value, str):
+        return {
+            'type': 'c',
+            'value': value
+        }
+
+    elif isinstance(value, numbers.Real):
+        # cast non-finite floats to repr
+        if math.isnan(value) or math.isinf(value):
+            value = repr(value)
+        return {
+            'value': value
+        }
+
+    elif isinstance(value, (list, tuple)):
+        ret = {
+            'value': list(value)
+        }
+        for i, e in enumerate(value):
+            if isinstance(e, numbers.Real) and (math.isnan(e) or math.isinf(e)):
+                ret["value"][i] = repr(e)
+
+        ll = len(value)
+        if 2 <= ll <= 4:
+            ret['type'] = 'v%d' % ll
+        elif ll == 9:
+            ret['type'] = 'm3'
+        elif ll == 16:
+            ret['type'] = 'm4'
+        return ret
+
+    else:
+        return {
+            'value': value
+        }
+
 def serialize_uniforms(uniforms, obj):
+    """Serialize a uniform dict"""
 
     serialized = {}
 
     for name, uniform in uniforms.items():
-        value = uniform['value']
-
-        if value is None:
-            serialized[name] = { 'value': None }
-
-        elif isinstance(value, Widget):
-            serialized[name] = {
-                'type': 't',
-                'value': widget_serialization['to_json'](value, None)
-            }
-
-        elif isinstance(value, str):
-            serialized[name] = {
-                'type': 'c',
-                'value': value
-            }
-
-        elif isinstance(value, (list, tuple)):
-            serialized[name] = {
-                'value': value
-            }
-
-            ll = len(value)
-            if 2 <= ll <= 4:
-                serialized[name]['type'] = 'v%d' % ll
-            elif ll == 9:
-                serialized[name]['type'] = 'm3'
-            elif ll == 16:
-                serialized[name]['type'] = 'm4'
-
-        else:
-            serialized[name] = {
-                'value': value
-            }
+        serialized[name] = _serialize_item(uniform['value'])
 
     return serialized
 
 
 
 def deserialize_uniforms(serialized, obj):
+    """Deserialize a uniform dict"""
 
     uniforms = {}
 
diff --git a/pythreejs/animation/AnimationAction.py b/pythreejs/animation/AnimationAction.py
@@ -1,5 +1,7 @@
 from ipywidgets import register, DOMWidget, Widget
-from traitlets import Unicode, Union, CInt, CFloat
+from traitlets import Unicode, Union, CInt
+
+from ..traits import IEEEFloat, ieee_float_serializers
 
 from .._package import npm_pkg_name
 from .._version import EXTENSION_SPEC_VERSION
@@ -21,7 +23,11 @@ class AnimationAction(AnimationActionBase, DOMWidget):
     _previewable = False
 
     # Normally an int, but can also be inf:
-    repititions = Union([CInt(), CFloat()], default_value=float('inf'), allow_none=False).tag(sync=True)
+    repititions = Union(
+        [CInt(), IEEEFloat()],
+        default_value=float('inf'),
+        allow_none=False
+    ).tag(sync=True, **ieee_float_serializers)
 
     def play(self):
         content = {
diff --git a/pythreejs/traits.py b/pythreejs/traits.py

Original file line number	Diff line number	Diff line change
`@@ -303,7 +303,7 @@ class Float extends BaseType {`
`303`	`303`	`if (this.maxValue !== undefined) {`
`304`	`304`	limits += `, max=${this.maxValue}`;
`305`	`305`	`}`
`306`		- return `CFloat(${this.getPythonDefaultValue()}, ${nullableStr}${limits})${this.getTagString()}`;
	`306`	+ return `IEEEFloat(${this.getPythonDefaultValue()}, ${nullableStr}${limits})${this.getTagString()}`;
`307`	`307`	`}`
`308`	`308`	`getPropertyConverterFn() {`
`309`	`309`	`return 'convertFloat';`
Original file line number	Diff line number	Diff line change
`@@ -501,9 +501,9 @@ class ThreeModel extends widgets.WidgetModel {`
`501`	`501`	`}`
`502`	`502`
`503`	`503`	`convertFloatThreeToModel(v) {`
`504`		`- if (isFinite(v)) { // Most common first`
	`504`	`+ if (Number.isFinite(v)) { // Most common first`
`505`	`505`	`return v;`
`506`		`- } else if (isNaN(v)) {`
	`506`	`+ } else if (Number.isNaN(v)) {`
`507`	`507`	`return 'nan';`
`508`	`508`	`} else if (v === Infinity) {`
`509`	`509`	`return 'inf';`
`@@ -554,12 +554,12 @@ class ThreeModel extends widgets.WidgetModel {`
`554`	`554`	`default:`
`555`	`555`	`throw new Error('model vector has invalid length: ' + v.length);`
`556`	`556`	`}`
`557`		`- result.fromArray(v);`
	`557`	`+ result.fromArray(v.map(this.convertFloatModelToThree));`
`558`	`558`	`return result;`
`559`	`559`	`}`
`560`	`560`
`561`	`561`	`convertVectorThreeToModel(v) {`
`562`		`- return v.toArray();`
	`562`	`+ return v.toArray().map(this.convertFloatThreeToModel);`
`563`	`563`	`}`
`564`	`564`
`565`	`565`	`assignVector(obj, key, value) {`
`@@ -568,11 +568,13 @@ class ThreeModel extends widgets.WidgetModel {`
`568`	`568`
`569`	`569`	`// Euler`
`570`	`570`	`convertEulerModelToThree(v) {`
`571`		`- return new THREE.Euler().fromArray(v);`
	`571`	`+ // The float conversions will ignore the "XYZ" order strings`
	`572`	`+ return new THREE.Euler().fromArray(v.map(this.convertFloatModelToThree));`
`572`	`573`	`}`
`573`	`574`
`574`	`575`	`convertEulerThreeToModel(v) {`
`575`		`- return v.toArray();`
	`576`	`+ // The float conversions will ignore the "XYZ" order strings`
	`577`	`+ return v.toArray().map(this.convertFloatThreeToModel);`
`576`	`578`	`}`
`577`	`579`
`578`	`580`	`assignEuler(obj, key, value) {`
`@@ -676,12 +678,12 @@ class ThreeModel extends widgets.WidgetModel {`
`676`	`678`	`default:`
`677`	`679`	`throw new Error('model matrix has invalid length: ' + m.length);`
`678`	`680`	`}`
`679`		`- result.fromArray(m);`
	`681`	`+ result.fromArray(m.map(this.convertFloatModelToThree));`
`680`	`682`	`return result;`
`681`	`683`	`}`
`682`	`684`
`683`	`685`	`convertMatrixThreeToModel(m) {`
`684`		`- return m.toArray();`
	`686`	`+ return m.toArray().map(this.convertFloatThreeToModel);`
`685`	`687`	`}`
`686`	`688`
`687`	`689`	`assignMatrix(obj, key, value) {`