Merge branch 'dev' into react-resizer

Author: Manik-Khajuria-5

.agents/context/backend.md

@@ -8,7 +8,7 @@
 - `py/visdom/server/app.py` — Application class, routes, state management.
 - `py/visdom/server/handlers/web_handlers.py` — HTTP handlers. Copy app attributes in `initialize()`, use `@check_auth`.
 - `py/visdom/server/handlers/socket_handlers.py` — WebSocket handlers (read-only + write-enabled).
-- `py/visdom/utils/server_utils.py` — `check_auth`, `broadcast`, `LazyEnvData`, `serialize_env`.
+- `py/visdom/utils/server_utils.py` — `check_auth`, `broadcast`, `LazyEnvData`. Environment persistence lives in `py/visdom/data_model/json_store.py` (`JSONStore`).
 - `py/visdom/server/build.py` — `download_scripts()`: fetches CDN dependencies.
 
 ## Coding Rules

.gitignore

@@ -2,6 +2,9 @@ cypress/screenshots
 cypress/screenshots_init
 cypress/downloads
 cypress/fixtures
+playwright/screenshots
+playwright/screenshots_init
+playwright/screenshots_diff
 node_modules
 build
 th/CMakeLists.txt

README.md

@@ -227,6 +227,32 @@ VISDOM_USE_ENV_CREDENTIALS=1 visdom -enable_login
 You can also use `VISDOM_COOKIE` variable to provide cookies value if the cookie file wasn't generated, or the
 flag `-force_new_cookie` was set.
 
+#### HTTPS Support
+
+To run the visdom server over HTTPS,user need to provide an SSL certificate and key file:
+
+```bash
+# Generate a self-signed certificate (for development only)
+openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes
+
+# Start the server with HTTPS
+python -m visdom.server -ssl_certfile cert.pem -ssl_keyfile key.pem
+```
+
+Access the server at `https://localhost:8097`.
+
+Connect via the Python client:
+```python
+# For Production - real CA-signed certificate (default)
+vis = visdom.Visdom(server="https://myserver.com")
+
+# For Development - self signed certificate
+vis = visdom.Visdom(server="https://localhost", ssl_verify=False)
+```
+
+> **Note**: `ssl_verify=False` disables certificate verification and should only be used in development with self-signed certificates. Do not use in production.
+
+
 #### Python example
 ```python
 import visdom
@@ -268,6 +294,7 @@ Other options are either currently unused (endpoint, ipv6) or used for internal
 Visdom offers the following basic visualization functions:
 - [`vis.image`](#visimage)    : image
 - [`vis.image_heatmap`](#visimageheatmap) : image with heatmap overlay
+- [`vis.update_image_slider`](#visupdate_image_slider) : set visible frame of an image_history pane
 - [`vis.images`](#visimages)   : list of images
 - [`vis.text`](#vistext)     : arbitrary HTML
 - [`vis.properties`](#visproperties)     : properties grid
@@ -332,6 +359,98 @@ vis._send({'data': [trace], 'layout': layout, 'win': 'mywin'})
 - [`vis.replay_log`](#visreplay_log): replay the actions from the provided log file
 
 
+## Loggers
+
+Framework-specific logging bridges that wrap the Visdom API so training loops stay focused on training. Each logger lives in its own submodule and handles window creation, step tracking, and throttling internally.
+
+### PyTorch
+
+`visdom.pytorch.VisdomLogger` is a context manager for raw PyTorch training loops. Call `tracker.log(name, value)` for any scalar — no `viz.line()` arguments needed.
+
+**Epoch-level logging** (recommended default — one call per epoch):
+
+```python
+import visdom
+from visdom.pytorch import VisdomLogger
+
+viz = visdom.Visdom()
+
+with VisdomLogger(viz, env="my_run") as tracker:
+    for epoch in range(num_epochs):
+        train_loss = run_train_epoch(model, loader)
+        val_loss   = run_val_epoch(model, val_loader)
+
+        tracker.log("Train Loss", train_loss)
+        tracker.log("Val Loss",   val_loss)
+        tracker.log("LR",         optimizer.param_groups[0]["lr"])
+```
+
+**Per-batch logging with `log_every`** — use when logging inside the batch loop on large datasets:
+
+```python
+with VisdomLogger(viz, env="my_run", log_every=50) as tracker:
+    for epoch in range(num_epochs):
+        for inputs, targets in train_loader:
+            loss = criterion(model(inputs), targets)
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+            # sent to Visdom every 50 batches, not every batch
+            tracker.log("Train Loss", loss.item(), xlabel="step")
+            tracker.log("LR",         optimizer.param_groups[0]["lr"], xlabel="step")
+```
+
+**Parameters:**
+- `viz`: a connected `visdom.Visdom()` instance
+- `env`: environment name (default: auto-generated from timestamp)
+- `log_every`: send every N calls per metric — use with per-batch logging on large datasets (default: `1`)
+
+Each unique name passed to `tracker.log()` gets its own window. The first call creates it; subsequent calls append. See `example/train_example.py` for a full working example.
+
+### scikit-learn
+
+`visdom.loggers.VisdomSklearnLogger` patches all sklearn `fit()` calls so every estimator trained after `autolog()` logs to Visdom automatically — no per-estimator code needed.
+
+**Plain estimators** (classifiers, regressors, clusterers) produce a text pane with the estimator name, dataset shape, training score, fit time, and all hyperparameters.
+
+**GridSearchCV / RandomizedSearchCV** produce a bar chart of `mean_test_score` per parameter combination and a text pane with `best_score_`, `best_params_`, and fit time.
+
+```python
+import visdom
+from visdom.loggers import VisdomSklearnLogger
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.linear_model import Ridge
+from sklearn.model_selection import GridSearchCV
+
+viz = visdom.Visdom()
+VisdomSklearnLogger.autolog()
+
+clf = RandomForestClassifier(n_estimators=100)
+clf.fit(X_train, y_train)        # -> text pane
+
+reg = Ridge(alpha=1.0)
+reg.fit(X_train, y_train)        # -> text pane
+
+gs = GridSearchCV(clf, param_grid, cv=3)
+gs.fit(X_train, y_train)         # -> bar chart + text pane
+```
+
+If you have a custom Visdom connection (non-default port, remote server, auth), pass it explicitly:
+
+```python
+import visdom
+
+viz = visdom.Visdom(port=8098, server="http://myserver")
+VisdomSklearnLogger.autolog(viz, env="sklearn_run")
+```
+
+**Parameters:**
+- `viz`: a connected `visdom.Visdom()` instance (optional — created internally if not passed)
+- `env`: environment name (default: `viz.env` if set, otherwise auto-generated from timestamp)
+
+See `example/train_sklearn_example.py` for a full working example covering plain estimators and grid search.
+
 ## Details
 <img src="https://user-images.githubusercontent.com/19650074/198747904-7a8a580f-851a-45fb-8f45-94e54a910ee2.png"/>
 
@@ -356,6 +475,18 @@ The following `opts` are supported:
 - `caption`: Caption for the image
 - `store_history`: Keep all images stored to the same window and attach a slider to the bottom that will let you select the image to view. You must always provide this opt when sending new images to an image with history.
 
+#### vis.update_image_slider
+
+Programmatically set the visible frame of an `image_history` pane from Python:
+
+```python
+win = vis.image(img, opts=dict(store_history=True))
+vis.image(img2, win=win, opts=dict(store_history=True))
+vis.update_image_slider(win, index=1)  # show second frame
+```
+
+The `index` is 0-based and is clamped to the valid range by the server. NumPy integer scalars (e.g. `np.int64`) are accepted and coerced automatically. Passing a non-integer or a non-`image_history` window raises an error.
+
 > **Note** You can use alt on an image pane to view the x/y coordinates of the cursor. You can also ctrl-scroll to zoom, alt scroll to pan vertically, and alt-shift scroll to pan horizontally. Double click inside the pane to restore the image to default.
 
 
@@ -499,6 +630,7 @@ The function accepts the following arguments:
 - `labels`: a list of corresponding labels for the tensors provided for `features`
 - `data_getter=fn`: (optional) a function that takes as a parameter an index into the features array and returns a summary representation of the tensor. If this is set, `data_type` must also be set.
 - `data_type=str`: (optional) currently the only acceptable value here is `"html"`
+- `opts.register_embedding_events`: (optional) set to `False` to skip registering the default Python client event handler for hover previews and lasso drilldown. This leaves embeddings interaction events for external server or frontend code to handle.
 
 We currently assume that there are no more than 10 unique labels, in the future we hope to provide a colormap in opts for other cases.
 
@@ -909,6 +1041,7 @@ The following `opts` are generic in the sense that they are the same for all vis
 - `opts.marginright` : right margin (in pixels)
 - `opts.margintop`   : top margin (in pixels)
 - `opts.marginbottom`: bottom margin (in pixels)
+- `opts.caption`     : caption displayed below the plot (`string`; optional)
 
 `opts` are passed as dictionary in python scripts.You can pass `opts` like:
 

REFACTORING.md

@@ -79,7 +79,7 @@ This is the primary TODO from PR #675: *"move the logic that actually parses env
 | File | Purpose |
 |------|---------|
 | `environment.py` | `Environment` class wrapping `{"jsons": {}, "reload": {}}` dict. Methods: `get_window()`, `set_window()`, `remove_window()`, `list_windows()`, `get_reload()` |
-| `state_manager.py` | `StateManager` class wrapping the top-level `state` dict. Methods: `get_env()`, `create_env()`, `delete_env()`, `list_envs()`, `fork_env()`, `serialize()`, `serialize_all()`. Absorbs functions from `server_utils.py` (`serialize_env`, `serialize_all`, `load_env`, `gather_envs`, `compare_envs`) |
+| `state_manager.py` | `StateManager` class wrapping the top-level `state` dict. Methods: `get_env()`, `create_env()`, `delete_env()`, `list_envs()`, `fork_env()`, `serialize()`, `serialize_all()`. Absorbs functions from `server_utils.py` (`load_env`, `gather_envs`, `compare_envs`). Environment file serialization now lives in `data_model/json_store.py` (`JSONStore`) via the `DataStore` abstraction |
 | `window.py` | Typed window structures (dataclasses/TypedDicts) replacing raw dicts built in `server_utils.py:window()` (lines 202-258) |
 
 ### 3b. Refactor handlers to use data model
@@ -109,12 +109,12 @@ py/visdom/server/
 **Effort: Medium-Large | Risk: Medium | PRs: 2 | Dependencies: Phase 3**
 
 ### 4a. Wrap blocking file I/O with `run_in_executor`
-Currently only **ONE** place uses async I/O (`socket_handlers.py:123` for `serialize_all`). All others block the Tornado event loop:
+Currently only **ONE** place uses async I/O (`socket_handlers.py:123` for `storage.save_all`). All others block the Tornado event loop:
 
 | File | Lines | Blocking Operation |
 |------|-------|-------------------|
 | `server_utils.py` | 72 | Cookie file write |
-| `server_utils.py` | 121-155 | `serialize_env()` — JSON file write |
+| `data_model/json_store.py` | `save_envs()` | `JSONStore` — JSON file write |
 | `server_utils.py` | 273-303 | `compare_envs()` — env file read |
 | `app.py` | 141 | Layout save (file write) |
 | `app.py` | 155 | Layout load (file read) |

cypress/integration/UploadDashboard.js

@@ -25,37 +25,4 @@ describe('Visdom - Upload Dashboard JSON Feature', () => {
       expect(str.toLowerCase()).to.contain('json');
     });
   });
-
-  it('should successfully upload valid dashboard JSON and set it as current environment', () => {
-    cy.intercept('POST', '/upload_env', (req) => {
-      req.continue((res) => {
-        res.delay = 1000;
-      });
-    }).as('uploadRequest');
-
-    cy.window().then((win) => {
-      cy.stub(win, 'alert').as('alertStub');
-    });
-
-    cy.fixture('test.json').then((fileContent) => {
-      cy.get('input[type="file"]').selectFile(
-        {
-          contents: fileContent,
-          fileName: 'test.json',
-          mimeType: 'application/json',
-        },
-        { force: true }
-      );
-
-      cy.get('button .glyphicon-upload').parent('button').click();
-      cy.wait('@uploadRequest');
-      cy.get('@alertStub', { timeout: 15000 }).should('have.been.called');
-
-      cy.window().then((win) => {
-        const envIDs = JSON.parse(win.localStorage.getItem('envIDs'));
-        expect(envIDs).to.be.an('array');
-        expect(envIDs[0]).to.match(/^uploaded_/);
-      });
-    });
-  });
 });

cypress/integration/export.js

@@ -65,27 +65,4 @@ describe('Test Export Env as HTML', () => {
       expect(html).to.include(env);
     });
   });
-
-  it('Shows alert when all panes are closed before export', () => {
-    const env = 'export_empty_' + Cypress._.random(0, 1e6);
-    cy.run('text_basic', { env });
-    cy.get('.layout .window').should('have.length', 1);
-
-    cy.get('.layout .react-grid-item')
-      .first()
-      .find('button[title="close"]')
-      .click();
-    cy.get('.layout .react-grid-item').should('have.length', 0);
-
-    cy.window().then((win) => {
-      cy.stub(win, 'alert').as('alertStub');
-    });
-
-    cy.get(exportButton).should('not.be.disabled').click();
-
-    cy.get('@alertStub').should(
-      'have.been.calledWith',
-      'No panes available to export.'
-    );
-  });
 });

cypress/integration/parallel_coordinates.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2017-present, The Visdom Authors
+ * All rights reserved.
+ *
+ * This source code is licensed under the license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+before(() => {
+  cy.visit('/');
+});
+
+describe('Parallel Coordinates Pane', () => {
+  it('parallel_coordinates_basic', () => {
+    cy.run('plot_special_parallel_coordinates');
+
+    cy.get('.layout .window').should('have.length', 1);
+
+    cy.get('.content').contains('Experiment Comparison');
+  });
+
+  it('parallel_coordinates_close', () => {
+    cy.run('plot_special_parallel_coordinates');
+    cy.get('.layout .react-grid-item')
+      .first()
+      .find('button[title="close"]')
+      .click();
+    cy.get('.layout .window').should('have.length', 0);
+  });
+});

example/components/image.py

@@ -133,6 +133,46 @@ def image_grid(viz, env, args):
         env=env,
     )
 
+# image slider sync demo — one slider drives two panes
+def image_slider_sync(viz, env, args):
+    n_frames = 4
+    colors = np.linspace(0.2, 0.8, n_frames)
+
+    win_a = None
+    win_b = None
+    for i, c in enumerate(colors):
+        frame = np.full((3, 128, 256), c)
+        win_a = viz.image(
+            frame,
+            win=win_a,
+            opts=dict(
+                title="Model A",
+                caption="Frame {}".format(i),
+                store_history=True,
+            ),
+            env=env,
+        )
+        win_b = viz.image(
+            1.0 - frame,
+            win=win_b,
+            opts=dict(
+                title="Model B (synced)",
+                caption="Frame {}".format(i),
+                store_history=True,
+            ),
+            env=env,
+        )
+
+    viz.update_image_slider(win_a, 0, env=env)
+    viz.update_image_slider(win_b, 0, env=env)
+
+    def on_slider_moved(event):
+        if event["event_type"] != "SliderMoved":
+            return
+        viz.update_image_slider(win_b, event["index"], env=env)
+
+    viz.register_event_handler(on_slider_moved, win_a)
+
 
 # SVG plotting
 def image_svg(viz, env, args):