Add session and code attribution for plots

extensions/positron-python/python_files/posit/positron/matplotlib_backend.py

@@ -19,7 +19,8 @@
 import hashlib
 import io
 import logging
-from typing import TYPE_CHECKING, cast
+import sys
+from typing import TYPE_CHECKING, Any, cast
 
 import matplotlib
 from matplotlib.backend_bases import FigureManagerBase
@@ -38,6 +39,26 @@
 matplotlib.interactive(True)  # noqa: FBT003
 
 
+def _detect_plotting_library() -> str:
+    """
+    Detect the most likely high-level plotting library in use.
+
+    Checks sys.modules for known plotting libraries that build on matplotlib,
+    returning the most specific library name found.
+    """
+    # Check for high-level libraries that build on matplotlib
+    # Order matters - check more specific libraries first
+    # Note: We don't include pandas here because pandas.plotting is auto-loaded
+    # when pandas is imported, even if not used for plotting.
+    library_priority = ["seaborn", "plotnine"]
+
+    for module_name in library_priority:
+        if module_name in sys.modules:
+            return module_name
+
+    return "matplotlib"
+
+
 class FigureManagerPositron(FigureManagerBase):
     """
     Interface for the matplotlib backend to interact with the Positron frontend.
@@ -62,9 +83,23 @@ def __init__(self, canvas: FigureCanvasPositron, num: int | str):
 
         super().__init__(canvas, num)
 
+        kernel = cast("PositronIPyKernel", PositronIPyKernel.instance())
+
+        # Get the execution context from the current shell message
+        parent = kernel.get_parent("shell")
+        header: dict[str, Any] = cast("dict[str, Any]", parent.get("header", {}))
+        content: dict[str, Any] = cast("dict[str, Any]", parent.get("content", {}))
+        execution_id: str = header.get("msg_id", "")
+        code: str = content.get("code", "")
+
+        # Detect which plotting library was used
+        kind = _detect_plotting_library()
+
         # Create the plot instance via the plots service.
-        self._plots_service = cast("PositronIPyKernel", PositronIPyKernel.instance()).plots_service
-        self._plot = self._plots_service.create_plot(canvas.render, canvas.intrinsic_size)
+        self._plots_service = kernel.plots_service
+        self._plot = self._plots_service.create_plot(
+            canvas.render, canvas.intrinsic_size, kind, execution_id, code, num
+        )
 
     @property
     def closed(self) -> bool:

extensions/positron-python/python_files/posit/positron/plot_comm.py

@@ -68,6 +68,28 @@ class IntrinsicSize(BaseModel):
     )
 
 
+class PlotMetadata(BaseModel):
+    """
+    The plot's metadata
+    """
+
+    name: StrictStr = Field(
+        description="A human-readable name for the plot",
+    )
+
+    kind: StrictStr = Field(
+        description="The kind of plot e.g. 'Matplotlib', 'ggplot2', etc.",
+    )
+
+    execution_id: StrictStr = Field(
+        description="The ID of the code fragment that produced the plot",
+    )
+
+    code: StrictStr = Field(
+        description="The code fragment that produced the plot",
+    )
+
+
 class PlotResult(BaseModel):
     """
     A rendered plot
@@ -128,6 +150,9 @@ class PlotBackendRequest(str, enum.Enum):
     # Get the intrinsic size of a plot, if known.
     GetIntrinsicSize = "get_intrinsic_size"
 
+    # Get metadata for the plot
+    GetMetadata = "get_metadata"
+
     # Render a plot
     Render = "render"
 
@@ -148,6 +173,21 @@ class GetIntrinsicSizeRequest(BaseModel):
     )
 
 
+class GetMetadataRequest(BaseModel):
+    """
+    Get metadata for the plot
+    """
+
+    method: Literal[PlotBackendRequest.GetMetadata] = Field(
+        description="The JSON-RPC method name (get_metadata)",
+    )
+
+    jsonrpc: str = Field(
+        default="2.0",
+        description="The JSON-RPC version specifier",
+    )
+
+
 class RenderParams(BaseModel):
     """
     Requests a plot to be rendered. The plot data is returned in a
@@ -192,6 +232,7 @@ class PlotBackendMessageContent(BaseModel):
     comm_id: str
     data: Union[
         GetIntrinsicSizeRequest,
+        GetMetadataRequest,
         RenderRequest,
     ] = Field(..., discriminator="method")
 
@@ -221,6 +262,8 @@ class UpdateParams(BaseModel):
 
 IntrinsicSize.update_forward_refs()
 
+PlotMetadata.update_forward_refs()
+
 PlotResult.update_forward_refs()
 
 PlotSize.update_forward_refs()
@@ -229,6 +272,8 @@ class UpdateParams(BaseModel):
 
 GetIntrinsicSizeRequest.update_forward_refs()
 
+GetMetadataRequest.update_forward_refs()
+
 RenderParams.update_forward_refs()
 
 RenderRequest.update_forward_refs()

extensions/positron-python/python_files/posit/positron/plots.py

@@ -12,9 +12,11 @@
 
 from .plot_comm import (
     GetIntrinsicSizeRequest,
+    GetMetadataRequest,
     IntrinsicSize,
     PlotBackendMessageContent,
     PlotFrontendEvent,
+    PlotMetadata,
     PlotResult,
     PlotSize,
     PlotUnit,
@@ -50,17 +52,33 @@ class Plot:
         A callable that renders the plot. See `plot_comm.RenderRequest` for parameter details.
     intrinsic_size
         The intrinsic size of the plot in inches.
+    kind
+        The kind of plot, e.g., 'Matplotlib', 'Seaborn', 'plotnine'.
+    execution_id
+        The ID of the execute_request that produced the plot.
+    code
+        The code fragment that produced the plot.
+    figure_num
+        The matplotlib figure number, used for generating plot names.
     """
 
     def __init__(
         self,
         comm: PositronComm,
         render: Renderer,
         intrinsic_size: tuple[int, int],
+        kind: str,
+        execution_id: str,
+        code: str,
+        figure_num: int | str,
     ) -> None:
         self._comm = comm
         self._render = render
         self._intrinsic_size = intrinsic_size
+        self._kind = kind
+        self._execution_id = execution_id
+        self._code = code
+        self._figure_num = figure_num
 
         self._closed = False
 
@@ -115,6 +133,8 @@ def _handle_msg(
             )
         elif isinstance(request, GetIntrinsicSizeRequest):
             self._handle_get_intrinsic_size()
+        elif isinstance(request, GetMetadataRequest):
+            self._handle_get_metadata()
         else:
             logger.warning(f"Unhandled request: {request}")
 
@@ -137,10 +157,21 @@ def _handle_get_intrinsic_size(self) -> None:
                 width=self._intrinsic_size[0],
                 height=self._intrinsic_size[1],
                 unit=PlotUnit.Inches,
-                source="Matplotlib",
+                source=self._kind,
             ).dict()
         self._comm.send_result(data=result)
 
+    def _handle_get_metadata(self) -> None:
+        # Generate a short but meaningful name for the plot
+        name = f"{self._kind} {self._figure_num}"
+        result = PlotMetadata(
+            name=name,
+            kind=self._kind,
+            execution_id=self._execution_id,
+            code=self._code,
+        ).dict()
+        self._comm.send_result(data=result)
+
     def _handle_close(self, _msg: JsonRecord) -> None:
         self.close()
 
@@ -169,7 +200,15 @@ def __init__(self, target_name: str, session_mode: SessionMode):
 
         self._plots: list[Plot] = []
 
-    def create_plot(self, render: Renderer, intrinsic_size: tuple[int, int]) -> Plot:
+    def create_plot(
+        self,
+        render: Renderer,
+        intrinsic_size: tuple[int, int],
+        kind: str,
+        execution_id: str,
+        code: str,
+        figure_num: int | str,
+    ) -> Plot:
         """
         Create a plot.
 
@@ -179,6 +218,14 @@ def create_plot(self, render: Renderer, intrinsic_size: tuple[int, int]) -> Plot
             A callable that renders the plot. See `plot_comm.RenderRequest` for parameter details.
         intrinsic_size
             The intrinsic size of the plot in inches.
+        kind
+            The kind of plot, e.g., 'Matplotlib', 'Seaborn', 'plotnine'.
+        execution_id
+            The ID of the execute_request that produced the plot.
+        code
+            The code fragment that produced the plot.
+        figure_num
+            The matplotlib figure number, used for generating plot names.
 
         See Also
         --------
@@ -187,7 +234,7 @@ def create_plot(self, render: Renderer, intrinsic_size: tuple[int, int]) -> Plot
         comm_id = str(uuid.uuid4())
         logger.info(f"Creating plot with comm {comm_id}")
         plot_comm = PositronComm.create(self._target_name, comm_id)
-        plot = Plot(plot_comm, render, intrinsic_size)
+        plot = Plot(plot_comm, render, intrinsic_size, kind, execution_id, code, figure_num)
         self._plots.append(plot)
         return plot
 

extensions/positron-python/python_files/posit/positron/tests/test_plots.py

@@ -132,12 +132,33 @@ def test_mpl_get_intrinsic_size(shell: PositronShell, plots_service: PlotsServic
                 "width": intrinsic_size[0],
                 "height": intrinsic_size[1],
                 "unit": PlotUnit.Inches.value,
-                "source": "Matplotlib",
+                "source": "matplotlib",
             }
         )
     ]
 
 
+def test_mpl_get_metadata(shell: PositronShell, plots_service: PlotsService) -> None:
+    # Create a plot.
+    plot_comm = _create_mpl_plot(shell, plots_service)
+
+    # Send a get_metadata request to the plot comm.
+    msg = json_rpc_request("get_metadata", {}, comm_id="dummy_comm_id")
+    plot_comm.handle_msg(msg)
+
+    # Check that the response includes the expected metadata.
+    assert len(plot_comm.messages) == 1
+    response = plot_comm.messages[0]
+    result = response["data"]["result"]
+
+    # Verify the metadata structure
+    assert result["kind"] == "matplotlib"
+    assert result["name"] == "matplotlib 1"
+    # execution_id and code may be empty in test context since there's no real execute_request
+    assert "execution_id" in result
+    assert "code" in result
+
+
 def test_mpl_show(shell: PositronShell, plots_service: PlotsService) -> None:
     plot_comm = _create_mpl_plot(shell, plots_service)
 

positron/comms/plot-backend-openrpc.json

@@ -43,6 +43,44 @@
 				}
 			}
 		},
+		{
+			"name": "get_metadata",
+			"summary": "Get metadata for the plot",
+			"description": "Get metadata for the plot",
+			"params": [],
+			"result": {
+				"required": true,
+				"schema": {
+					"name": "plot_metadata",
+					"description": "The plot's metadata",
+					"type": "object",
+					"properties": {
+						"name": {
+							"type": "string",
+							"description": "A unique, human-readable name for the plot"
+						},
+						"kind": {
+							"type": "string",
+							"description": "The kind of plot e.g. 'Matplotlib', 'ggplot2', etc."
+						},
+						"execution_id": {
+							"type": "string",
+							"description": "The ID of the code fragment that produced the plot"
+						},
+						"code": {
+							"description": "The code fragment that produced the plot",
+							"type": "string"
+						}
+					},
+					"required": [
+						"name",
+						"kind",
+						"execution_id",
+						"code"
+					]
+				}
+			}
+		},
 		{
 			"name": "render",
 			"summary": "Render a plot",

src/vs/workbench/contrib/positronConsole/browser/components/activityInput.css

@@ -13,19 +13,33 @@
 	position: absolute;
 	top: 0;
 	left: -10px;
+	opacity: 0;
 }
 
 @keyframes positronActivityInput-fadeIn {
 	0% { opacity: 0; }
 	100% { opacity: 1; }
 }
 
+@keyframes positronActivityInput-revealFadeInOut {
+	0% { opacity: 0; }
+	15% { opacity: 1; }
+	85% { opacity: 1; }
+	100% { opacity: 0; }
+}
+
 .activity-input.executing .progress-bar {
 	background-color: var(--vscode-positronConsole-ansiGreen);
 	opacity: 0;
 	animation: positronActivityInput-fadeIn 0.25s ease-in 0.25s 1 forwards;
 }
 
+.activity-input.revealed .progress-bar {
+	background-color: var(--vscode-focusBorder);
+	opacity: 0;
+	animation: positronActivityInput-revealFadeInOut 2s ease-in-out 1 forwards;
+}
+
 .activity-input .prompt {
 	text-align: right;
 	display: inline-block;