pgwidgets-python 0.1.3__py3-none-any.whl → 0.2.1__py3-none-any.whl

pgwidgets/__init__.py

@@ -16,4 +16,17 @@ Usage (asynchronous):
     top = await W.TopLevel(title="Hello", resizable=True)
     ...
     await app.run()
+
+Version:
+    import pgwidgets
+    print(pgwidgets.__version__)
 """
+
+from importlib.metadata import version as _pkg_version, PackageNotFoundError
+
+try:
+    __version__ = _pkg_version("pgwidgets")
+except PackageNotFoundError:
+    # Package not installed (e.g. running from a source checkout
+    # without `pip install -e .`).  Fall back to a sentinel.
+    __version__ = "0.0.0+unknown"

pgwidgets/_json.py

@@ -0,0 +1,63 @@
+"""JSON encoding helper for the remote protocol.
+
+The wire format between Python and the browser is JSON.  The stdlib
+encoder has two issues for scientific data:
+
+1. It rejects numpy scalars other than ``np.float64`` (which inherits
+   from float), numpy arrays, and similar buffer-protocol objects —
+   silently dropping a TreeView payload that happens to contain
+   ``np.int64`` cell values.
+
+2. It writes the literal tokens ``NaN`` / ``Infinity`` / ``-Infinity``
+   for non-finite floats, which browsers' ``JSON.parse`` reject — a
+   single masked / missing cell in a float column makes the whole
+   payload silently fail to parse on the JS side.
+
+``JsonEncoder`` handles both: ``.item()`` / ``.tolist()`` fall-backs
+for numpy/pandas types, and a pre-walk that replaces non-finite floats
+with ``None`` (encoded as JSON ``null``).  Use it via
+``json.dumps(obj, cls=JsonEncoder)``.
+"""
+
+import json
+import math
+
+
+def _scrub_nan(obj):
+    """Recursively replace non-finite floats with None so the result
+    is RFC-8259-valid JSON when re-encoded.  Cheap walk: O(n) and
+    only visits dicts/lists/tuples/floats."""
+    if isinstance(obj, float):
+        return obj if math.isfinite(obj) else None
+    if isinstance(obj, dict):
+        return {k: _scrub_nan(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_scrub_nan(v) for v in obj]
+    return obj
+
+
+def _coerce_scalar(v):
+    """If *v* is a float, replace non-finite values with None."""
+    if isinstance(v, float) and not math.isfinite(v):
+        return None
+    return v
+
+
+class JsonEncoder(json.JSONEncoder):
+    def default(self, obj):
+        item = getattr(obj, "item", None)
+        if callable(item):
+            try:
+                return _coerce_scalar(item())
+            except (TypeError, ValueError):
+                pass
+        tolist = getattr(obj, "tolist", None)
+        if callable(tolist):
+            try:
+                return _scrub_nan(tolist())
+            except (TypeError, ValueError):
+                pass
+        return super().default(obj)
+
+    def iterencode(self, o, _one_shot=False):
+        return super().iterencode(_scrub_nan(o), _one_shot=_one_shot)

pgwidgets/async_/Widgets.py

@@ -0,0 +1,22 @@
+"""
+Module-level widget classes for the asynchronous API.
+
+All widget classes are built once at import time from the shared
+definitions.  They can be imported and subclassed normally::
+
+    from pgwidgets.async_.Widgets import FileDialog, Button
+
+    class MyFileDialog(FileDialog):
+        async def pick_file(self):
+            await self.open()
+
+Instances are created through the ``get_widgets()`` factory on a
+Session, which binds them to a session and handles constructor
+argument parsing, state tracking, and callback registration.
+"""
+
+from pgwidgets.async_.widget import build_all_widget_classes, Widget
+
+_classes = build_all_widget_classes()
+globals().update(_classes)
+__all__ = list(_classes.keys()) + ["Widget"]