A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
feat: stream pkg installation logs (#6279)
Myles Scolnicke34a58666444
diff --git a/frontend/src/components/editor/package-alert.tsx b/frontend/src/components/editor/package-alert.tsxindex a708006fda..a5aeb671fe 100644--- a/frontend/src/components/editor/package-alert.tsx+++ b/frontend/src/components/editor/package-alert.tsx@@ -4,6 +4,8 @@ import { zodResolver } from "@hookform/resolvers/zod";import {BoxIcon,CheckIcon,+ ChevronDownIcon,+ ChevronRightIcon,DownloadCloudIcon,PackageCheckIcon,PackageXIcon,@@ -73,7 +75,7 @@ function buildPackageSpecifier(name: string, extras: string[]): string {}export const PackageAlert: React.FC = () => {- const { packageAlert } = useAlerts();+ const { packageAlert, packageLogs } = useAlerts();const { clearPackageAlert } = useAlertActions();const [userConfig] = useResolvedMarimoConfig();const [desiredPackageVersions, setDesiredPackageVersions] = useState<@@ -92,10 +94,10 @@ export const PackageAlert: React.FC = () => {if (isMissingPackageAlert(packageAlert)) {return (- <div className="flex flex-col gap-4 mb-5 fixed top-5 left-12 min-w-[400px] z-200 opacity-95">+ <div className="flex flex-col gap-4 mb-5 fixed top-5 left-12 min-w-[400px] z-200 opacity-95 max-w-[600px]"><Bannerkind="danger"- className="flex flex-col rounded py-3 px-5 animate-in slide-in-from-left"+ className="flex flex-col rounded py-3 px-5 animate-in slide-in-from-left overflow-auto max-h-[80vh] scrollbar-thin"><div className="flex justify-between"><span className="font-bold text-lg flex items-center mb-2">@@ -114,45 +116,46 @@ export const PackageAlert: React.FC = () => {<div className="flex flex-col gap-4 justify-between items-start text-muted-foreground text-base"><div><p>The following packages were not found:</p>- <ul className="list-disc ml-4 mt-1">+ <table className="list-disc ml-2 mt-1">{packageAlert.packages.map((pkg, index) => {const parsed = parsePackageSpecifier(pkg);const currentExtras = selectedExtras[pkg] || parsed.extras;return (- <li- className="flex items-center gap-2 font-mono text-sm"- key={index}- >- <BoxIcon size="1rem" />-- <ExtrasSelector- packageName={parsed.name}- selectedExtras={currentExtras}- onExtrasChange={(extras) =>- setSelectedExtras((prev) => ({- ...prev,- [pkg]: extras,- }))- }- />-- {doesSupportVersioning && (- <PackageVersionSelect- value={desiredPackageVersions[pkg] ?? "latest"}- onChange={(value) =>- setDesiredPackageVersions((prev) => ({+ <tr className="font-mono text-sm" key={index}>+ <td className="pr-2 py-1 align-middle">+ <BoxIcon size="1rem" />+ </td>+ <td className="pr-2 py-1 align-middle">+ <ExtrasSelector+ packageName={parsed.name}+ selectedExtras={currentExtras}+ onExtrasChange={(extras) =>+ setSelectedExtras((prev) => ({...prev,- [pkg]: value,+ [pkg]: extras,}))}- packageName={parsed.name}/>+ </td>+ {doesSupportVersioning && (+ <td className="pr-2 py-1 align-middle">+ <PackageVersionSelect+ value={desiredPackageVersions[pkg] ?? "latest"}+ onChange={(value) =>+ setDesiredPackageVersions((prev) => ({+ ...prev,+ [pkg]: value,+ }))+ }+ packageName={parsed.name}+ />+ </td>)}- </li>+ </tr>);})}- </ul>+ </table></div><div className="ml-auto flex flex-row items-baseline">{packageAlert.isolated ? (@@ -200,10 +203,10 @@ export const PackageAlert: React.FC = () => {}return (- <div className="flex flex-col gap-4 mb-5 fixed top-5 left-12 min-w-[400px] z-200 opacity-95">+ <div className="flex flex-col gap-4 mb-5 fixed top-5 left-12 min-w-[400px] z-200 opacity-95 max-w-[600px] "><Bannerkind={status === "failed" ? "danger" : "info"}- className="flex flex-col rounded pt-3 pb-4 px-5"+ className="flex flex-col rounded pt-3 pb-4 px-5 overflow-auto max-h-[80vh] scrollbar-thin"><div className="flex justify-between"><span className="font-bold text-lg flex items-center mb-2">@@ -225,30 +228,29 @@ export const PackageAlert: React.FC = () => {status === "installed" && "text-accent-foreground",)}>- <div>- <p>{description}</p>- <ul className="list-disc ml-4 mt-1">- {Object.entries(packageAlert.packages).map(- ([pkg, st], index) => (- <li- className={cn(- "flex items-center gap-1 font-mono text-sm",- st === "installing" && "font-semibold",- st === "failed" && "text-destructive",- st === "installed" && "text-accent-foreground",- st === "installed" &&- status === "failed" &&- "text-muted-foreground",- )}- key={index}- >- <ProgressIcon status={st} />- {pkg}- </li>- ),- )}- </ul>- </div>+ <p>{description}</p>+ <ul className="list-disc ml-2 mt-1">+ {Object.entries(packageAlert.packages).map(([pkg, st], index) => (+ <li+ className={cn(+ "flex items-center gap-1 font-mono text-sm",+ st === "installing" && "font-semibold",+ st === "failed" && "text-destructive",+ st === "installed" && "text-accent-foreground",+ st === "installed" &&+ status === "failed" &&+ "text-muted-foreground",+ )}+ key={index}+ >+ <ProgressIcon status={st} />+ {pkg}+ </li>+ ))}+ </ul>+ {Object.keys(packageLogs).length > 0 && (+ <StreamingLogsViewer packageLogs={packageLogs} />+ )}</div></Banner></div>@@ -288,7 +290,7 @@ function getInstallationStatusElements(packages: PackageInstallationStatus) {status: "failed",title: "Some packages failed to install",titleIcon: <PackageXIcon className="w-5 h-5 inline-block mr-2" />,- description: "See terminal for error logs.",+ description: "See error logs.",};}@@ -441,7 +443,7 @@ const ExtrasSelector: React.FC<ExtrasSelectorProps> = ({return (<div className="flex items-center max-w-72">- <span className="shrink-0">{packageName}</span>+ <span className="shrink-0 flex-1">{packageName}</span>{selectedExtras.length > 0 ? (<span className="flex items-center min-w-0 flex-1">@@ -594,3 +596,49 @@ const PackageVersionSelect: React.FC<PackageVersionSelectProps> = ({</NativeSelect>);};++interface StreamingLogsViewerProps {+ packageLogs: { [packageName: string]: string };+}++const StreamingLogsViewer: React.FC<StreamingLogsViewerProps> = ({+ packageLogs,+}) => {+ const [isExpanded, setIsExpanded] = useState(true);++ const packageCount = Object.keys(packageLogs).length;+ if (packageCount === 0) return null;++ return (+ <div className="mt-4 border-t border-border pt-4 w-full">+ <button+ onClick={() => setIsExpanded(!isExpanded)}+ className="flex items-center gap-2 text-sm font-medium text-muted-foreground hover:text-foreground transition-colors"+ >+ {isExpanded ? (+ <ChevronDownIcon className="w-4 h-4" />+ ) : (+ <ChevronRightIcon className="w-4 h-4" />+ )}+ Installation logs+ </button>++ {isExpanded && (+ <div className="mt-3 space-y-3 w-full">+ {Object.entries(packageLogs).map(([packageName, logs]) => (+ <div key={packageName} className="w-full">+ <h4 className="font-mono text-sm font-medium mb-2 text-foreground">+ {packageName}+ </h4>+ <div className="border border-border rounded w-full">+ <pre className="p-3 text-xs font-mono bg-background max-h-64 overflow-y-auto text-muted-foreground whitespace-pre-wrap scrollbar-thin">+ {logs || "No logs available"}+ </pre>+ </div>+ </div>+ ))}+ </div>+ )}+ </div>+ );+};diff --git a/frontend/src/core/alerts/state.ts b/frontend/src/core/alerts/state.tsindex fa600564ce..5e11814675 100644--- a/frontend/src/core/alerts/state.ts+++ b/frontend/src/core/alerts/state.ts@@ -16,6 +16,8 @@ export interface MissingPackageAlert {export interface InstallingPackageAlert {kind: "installing";packages: PackageInstallationStatus;+ logs?: { [key: string]: string } | null;+ log_status?: "append" | "start" | "done" | null;}export interface StartupLogsAlert {@@ -45,24 +47,54 @@ interface AlertState {| Identified<InstallingPackageAlert>| null;startupLogsAlert: StartupLogsAlert | null;+ packageLogs: { [packageName: string]: string };}const { valueAtom: alertAtom, useActions } = createReducerAndAtoms(- () => ({ packageAlert: null, startupLogsAlert: null }) as AlertState,+ () =>+ ({+ packageAlert: null,+ startupLogsAlert: null,+ packageLogs: {},+ }) as AlertState,{addPackageAlert: (state,alert: MissingPackageAlert | InstallingPackageAlert,) => {+ const newPackageLogs = { ...state.packageLogs };++ // Handle streaming logs for installing package alerts+ if (isInstallingPackageAlert(alert) && alert.logs && alert.log_status) {+ for (const [packageName, newContent] of Object.entries(alert.logs)) {+ if (alert.log_status === "start") {+ // Start new log for this package+ newPackageLogs[packageName] = newContent;+ } else if (alert.log_status === "append") {+ // Append to existing log+ const prevContent = newPackageLogs[packageName] || "";+ newPackageLogs[packageName] = prevContent + newContent;+ } else if (alert.log_status === "done") {+ // Append final content and mark as done+ const prevContent = newPackageLogs[packageName] || "";+ newPackageLogs[packageName] = prevContent + newContent;+ }+ }+ }++ const existingAlert = state.packageAlert;+ const alertId = existingAlert?.id || generateUUID();+return {...state,- packageAlert: { id: generateUUID(), ...alert },+ packageAlert: { id: alertId, ...alert },+ packageLogs: newPackageLogs,};},clearPackageAlert: (state, id: string) => {return state.packageAlert !== null && state.packageAlert.id === id- ? { ...state, packageAlert: null }+ ? { ...state, packageAlert: null, packageLogs: {} }: state;},diff --git a/marimo/_messaging/ops.py b/marimo/_messaging/ops.pyindex 5110006e80..d6014396b9 100644--- a/marimo/_messaging/ops.py+++ b/marimo/_messaging/ops.py@@ -444,6 +444,9 @@ PackageStatusType = dict[class InstallingPackageAlert(Op, tag="installing-package-alert"):name: ClassVar[str] = "installing-package-alert"packages: PackageStatusType+ # Optional fields for streaming logs per package+ logs: Optional[dict[str, str]] = None # package name -> log content+ log_status: Optional[Literal["append", "start", "done"]] = Noneclass Reconnected(Op, tag="reconnected"):diff --git a/marimo/_runtime/packages/conda_package_manager.py b/marimo/_runtime/packages/conda_package_manager.pyindex e4bf8c6c9c..f1641a1a48 100644--- a/marimo/_runtime/packages/conda_package_manager.py+++ b/marimo/_runtime/packages/conda_package_manager.py@@ -1,11 +1,14 @@# Copyright 2024 Marimo. All rights reserved.from __future__ import annotations+from typing import Optional+from marimo._runtime.packages.module_name_to_conda_name import (module_name_to_conda_name,)from marimo._runtime.packages.package_manager import (CanonicalizingPackageManager,+ LogCallback,PackageDescription,)from marimo._runtime.packages.utils import split_packages@@ -22,14 +25,28 @@ class CondaPackageManager(CanonicalizingPackageManager):class PixiPackageManager(CondaPackageManager):name = "pixi"- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:if upgrade:- return self.run(["pixi", "upgrade", *split_packages(package)])+ return self.run(+ ["pixi", "upgrade", *split_packages(package)],+ log_callback=log_callback,+ )else:- return self.run(["pixi", "add", *split_packages(package)])+ return self.run(+ ["pixi", "add", *split_packages(package)],+ log_callback=log_callback,+ )async def uninstall(self, package: str) -> bool:- return self.run(["pixi", "remove", *split_packages(package)])+ return self.run(+ ["pixi", "remove", *split_packages(package)], log_callback=None+ )def list_packages(self) -> list[PackageDescription]:import jsondiff --git a/marimo/_runtime/packages/package_manager.py b/marimo/_runtime/packages/package_manager.pyindex b0409e0ae2..a3338e509c 100644--- a/marimo/_runtime/packages/package_manager.py+++ b/marimo/_runtime/packages/package_manager.py@@ -3,7 +3,8 @@ from __future__ import annotationsimport abcimport subprocess-from typing import TYPE_CHECKING, Optional+import sys+from typing import TYPE_CHECKING, Callable, Optionalimport msgspec@@ -17,6 +18,9 @@ if TYPE_CHECKING:LOGGER = _loggers.marimo_logger()+# Type alias for log callback function+LogCallback = Callable[[str], None]+class PackageDescription(msgspec.Struct, rename="camel"):name: str@@ -53,20 +57,38 @@ class PackageManager(abc.ABC):return False@abc.abstractmethod- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:"""Installation logic."""...async def install(- self, package: str, version: Optional[str], upgrade: bool = False+ self,+ package: str,+ version: Optional[str],+ upgrade: bool = False,+ log_callback: Optional[LogCallback] = None,) -> bool:"""Attempt to install a package that makes this module available.+ Args:+ package: The package to install+ version: Optional version specification+ upgrade: Whether to upgrade the package if already installed+ log_callback: Optional callback to receive log output during installation+Returns True if installation succeeded, else False."""self._attempted_packages.add(package)return await self._install(- append_version(package, version), upgrade=upgrade+ append_version(package, version),+ upgrade=upgrade,+ log_callback=log_callback,)@abc.abstractmethod@@ -85,11 +107,37 @@ class PackageManager(abc.ABC):"""Should this package manager auto-install packages"""return False- def run(self, command: list[str]) -> bool:+ def run(+ self, command: list[str], log_callback: Optional[LogCallback]+ ) -> bool:if not self.is_manager_installed():return False- proc = subprocess.run(command) # noqa: ASYNC101- return proc.returncode == 0++ if log_callback is None:+ # Original behavior - just run the command without capturing output+ completed_process = subprocess.run(command) # noqa: ASYNC101+ return completed_process.returncode == 0++ # Stream output to both the callback and the terminal+ proc = subprocess.Popen(+ command,+ stdout=subprocess.PIPE,+ stderr=subprocess.STDOUT,+ universal_newlines=False, # Keep as bytes to preserve ANSI codes+ bufsize=0, # Unbuffered for real-time output+ )++ if proc.stdout:+ for line in iter(proc.stdout.readline, b""):+ # Send to terminal (original behavior)+ sys.stdout.buffer.write(line)+ sys.stdout.buffer.flush()+ # Send to callback for streaming+ log_callback(line.decode("utf-8", errors="replace"))+ proc.stdout.close()++ return_code = proc.wait()+ return return_code == 0def update_notebook_script_metadata(self,@@ -100,7 +148,7 @@ class PackageManager(abc.ABC):import_namespaces_to_add: Optional[list[str]] = None,import_namespaces_to_remove: Optional[list[str]] = None,upgrade: bool,- ) -> None:+ ) -> bool:del (filepath,packages_to_add,@@ -119,7 +167,7 @@ class PackageManager(abc.ABC):This follows PEP 723 https://peps.python.org/pep-0723/"""- return+ return True@abc.abstractmethoddef list_packages(self) -> list[PackageDescription]:diff --git a/marimo/_runtime/packages/pypi_package_manager.py b/marimo/_runtime/packages/pypi_package_manager.pyindex b4a42a2725..c70f59dcc5 100644--- a/marimo/_runtime/packages/pypi_package_manager.py+++ b/marimo/_runtime/packages/pypi_package_manager.py@@ -16,6 +16,7 @@ from marimo._runtime.packages.module_name_to_pypi_name import ()from marimo._runtime.packages.package_manager import (CanonicalizingPackageManager,+ LogCallback,PackageDescription,)from marimo._runtime.packages.utils import split_packages@@ -55,13 +56,19 @@ class PipPackageManager(PypiPackageManager):name = "pip"docs_url = "https://pip.pypa.io/"- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:LOGGER.info(f"Installing {package} with pip")cmd = ["pip", "--python", PY_EXE, "install"]if upgrade:cmd.append("--upgrade")cmd.extend(split_packages(package))- return self.run(cmd)+ return self.run(cmd, log_callback=log_callback)async def uninstall(self, package: str) -> bool:LOGGER.info(f"Uninstalling {package} with pip")@@ -73,7 +80,8 @@ class PipPackageManager(PypiPackageManager):"uninstall","-y",*split_packages(package),- ]+ ],+ log_callback=None,)def list_packages(self) -> list[PackageDescription]:@@ -91,7 +99,13 @@ class MicropipPackageManager(PypiPackageManager):def is_manager_installed(self) -> bool:return is_pyodide()- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:assert is_pyodide()import micropip # type: ignore@@ -104,9 +118,15 @@ class MicropipPackageManager(PypiPackageManager):passtry:+ if log_callback:+ log_callback(f"Installing {package} with micropip...\n")await micropip.install(split_packages(package))+ if log_callback:+ log_callback(f"Successfully installed {package}\n")return True- except ValueError:+ except ValueError as e:+ if log_callback:+ log_callback(f"Failed to install {package}: {e}\n")return Falseasync def uninstall(self, package: str) -> bool:@@ -145,7 +165,13 @@ class UvPackageManager(PypiPackageManager):def is_manager_installed(self) -> bool:return self._uv_bin != "uv" or super().is_manager_installed()- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:install_cmd: list[str]if self.is_in_uv_project:LOGGER.info(f"Installing in {package} with 'uv add'")@@ -165,7 +191,9 @@ class UvPackageManager(PypiPackageManager):return self.run(# trade installation time for faster start time- install_cmd + ["--compile", *split_packages(package), "-p", PY_EXE]+ install_cmd+ + ["--compile", *split_packages(package), "-p", PY_EXE],+ log_callback=log_callback,)def update_notebook_script_metadata(@@ -177,7 +205,7 @@ class UvPackageManager(PypiPackageManager):import_namespaces_to_add: Optional[list[str]] = None,import_namespaces_to_remove: Optional[list[str]] = None,upgrade: bool,- ) -> None:+ ) -> bool:"""Update the notebook's script metadata with the packages to add/remove.Args:@@ -201,7 +229,7 @@ class UvPackageManager(PypiPackageManager):]if not packages_to_add and not packages_to_remove:- return+ return TrueLOGGER.info(f"Updating script metadata for {filepath}")@@ -243,7 +271,7 @@ class UvPackageManager(PypiPackageManager):packages_to_add: list[str],packages_to_remove: list[str],upgrade: bool,- ) -> None:+ ) -> bool:from marimo._convert.markdown.markdown import extract_frontmatterfrom marimo._utils import yamlfrom marimo._utils.inline_script_metadata import (@@ -269,7 +297,7 @@ class UvPackageManager(PypiPackageManager):temp_file.write(header)temp_file.flush()# Have UV modify it- self._process_changes_for_script_metadata(+ result = self._process_changes_for_script_metadata(temp_file.name,packages_to_add,packages_to_remove,@@ -299,24 +327,29 @@ class UvPackageManager(PypiPackageManager):with open(filepath, "w", encoding="utf-8") as f:f.write("\n".join(document))+ return result+def _process_changes_for_script_metadata(self,filepath: str,packages_to_add: list[str],packages_to_remove: list[str],upgrade: bool,- ) -> None:+ ) -> bool:+ success = Trueif packages_to_add:cmd = [self._uv_bin, "--quiet", "add", "--script", filepath]if upgrade:cmd.append("--upgrade")cmd.extend(packages_to_add)- self.run(cmd)+ success &= self.run(cmd, log_callback=None)if packages_to_remove:- self.run(+ success &= self.run([self._uv_bin, "--quiet", "remove", "--script", filepath]- + packages_to_remove+ + packages_to_remove,+ log_callback=None,)+ return successdef _get_version_map(self) -> dict[str, str]:packages = self.list_packages()@@ -374,7 +407,8 @@ class UvPackageManager(PypiPackageManager):uninstall_cmd = [self._uv_bin, "pip", "uninstall"]return self.run(- uninstall_cmd + [*split_packages(package), "-p", PY_EXE]+ uninstall_cmd + [*split_packages(package), "-p", PY_EXE],+ log_callback=None,)def list_packages(self) -> list[PackageDescription]:@@ -440,15 +474,26 @@ class RyePackageManager(PypiPackageManager):name = "rye"docs_url = "https://rye.astral.sh/"- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:if upgrade:return self.run(- ["rye", "sync", "--update", *split_packages(package)]+ ["rye", "sync", "--update", *split_packages(package)],+ log_callback=log_callback,)- return self.run(["rye", "add", *split_packages(package)])+ return self.run(+ ["rye", "add", *split_packages(package)], log_callback=log_callback+ )async def uninstall(self, package: str) -> bool:- return self.run(["rye", "remove", *split_packages(package)])+ return self.run(+ ["rye", "remove", *split_packages(package)], log_callback=None+ )def list_packages(self) -> list[PackageDescription]:cmd = ["rye", "list", "--format=json"]@@ -459,7 +504,13 @@ class PoetryPackageManager(PypiPackageManager):name = "poetry"docs_url = "https://python-poetry.org/docs/"- async def _install(self, package: str, *, upgrade: bool) -> bool:+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:if upgrade:return self.run([@@ -467,16 +518,19 @@ class PoetryPackageManager(PypiPackageManager):"update","--no-interaction",*split_packages(package),- ]+ ],+ log_callback=log_callback,)return self.run(- ["poetry", "add", "--no-interaction", *split_packages(package)]+ ["poetry", "add", "--no-interaction", *split_packages(package)],+ log_callback=log_callback,)async def uninstall(self, package: str) -> bool:return self.run(- ["poetry", "remove", "--no-interaction", *split_packages(package)]+ ["poetry", "remove", "--no-interaction", *split_packages(package)],+ log_callback=None,)def _list_packages_from_cmd(diff --git a/marimo/_runtime/runtime.py b/marimo/_runtime/runtime.pyindex e89b3058d0..0d7f9c67b8 100644--- a/marimo/_runtime/runtime.py+++ b/marimo/_runtime/runtime.py@@ -110,7 +110,10 @@ from marimo._runtime.packages.import_error_extractors import (try_extract_packages_from_import_error_message,)from marimo._runtime.packages.module_registry import ModuleRegistry-from marimo._runtime.packages.package_manager import PackageManager+from marimo._runtime.packages.package_manager import (+ LogCallback,+ PackageManager,+)from marimo._runtime.packages.package_managers import create_package_managerfrom marimo._runtime.packages.utils import (PackageRequirement,@@ -2548,6 +2551,16 @@ class PackagesCallbacks:}InstallingPackageAlert(packages=package_statuses).broadcast()+ def create_log_callback(pkg: str) -> LogCallback:+ def log_callback(log_line: str) -> None:+ InstallingPackageAlert(+ packages=package_statuses,+ logs={pkg: log_line},+ log_status="append",+ ).broadcast()++ return log_callback+for pkg in missing_packages:if self.package_manager.attempted_to_install(package=pkg):# Already attempted an installation; it must have failed.@@ -2555,15 +2568,35 @@ class PackagesCallbacks:continuepackage_statuses[pkg] = "installing"InstallingPackageAlert(packages=package_statuses).broadcast()++ # Send initial "start" log+ InstallingPackageAlert(+ packages=package_statuses,+ logs={pkg: f"Installing {pkg}...\n"},+ log_status="start",+ ).broadcast()+version = request.versions.get(pkg)- if await self.package_manager.install(pkg, version=version):+ if await self.package_manager.install(+ pkg, version=version, log_callback=create_log_callback(pkg)+ ):package_statuses[pkg] = "installed"- InstallingPackageAlert(packages=package_statuses).broadcast()+ # Send final "done" log+ InstallingPackageAlert(+ packages=package_statuses,+ logs={pkg: f"Successfully installed {pkg}\n"},+ log_status="done",+ ).broadcast()else:package_statuses[pkg] = "failed"mod = self.package_manager.package_to_module(pkg)self._kernel.module_registry.excluded_modules.add(mod)- InstallingPackageAlert(packages=package_statuses).broadcast()+ # Send final "done" log with error+ InstallingPackageAlert(+ packages=package_statuses,+ logs={pkg: f"Failed to install {pkg}\n"},+ log_status="done",+ ).broadcast()installed_modules = [self.package_manager.package_to_module(pkg)diff --git a/marimo/_server/session/session_view.py b/marimo/_server/session/session_view.pyindex de50ce0449..87039e5fe7 100644--- a/marimo/_server/session/session_view.py+++ b/marimo/_server/session/session_view.py@@ -11,6 +11,7 @@ from marimo._messaging.ops import (CellOp,Datasets,DataSourceConnections,+ InstallingPackageAlert,Interrupted,MessageOperation,SendUIElementMessage,@@ -99,6 +100,11 @@ class SessionView:# Startup logs for startup command - only one at a timeself.startup_logs: Optional[StartupLogs] = None+ # Package installation logs - accumulated per package+ self.package_logs: dict[+ str, str+ ] = {} # package name -> accumulated logs+# Auto-savingself.auto_export_state = AutoExportState()@@ -263,6 +269,28 @@ class SessionView:status=operation.status,)+ elif isinstance(operation, InstallingPackageAlert):+ # Handle streaming logs if present+ if operation.logs and operation.log_status:+ for package_name, new_content in operation.logs.items():+ if operation.log_status == "start":+ # Start new log for this package+ self.package_logs[package_name] = new_content+ elif operation.log_status == "append":+ # Append to existing log+ prev_content = self.package_logs.get(package_name, "")+ self.package_logs[package_name] = (+ prev_content + new_content+ )+ elif operation.log_status == "done":+ # Append final content and mark as done+ prev_content = self.package_logs.get(package_name, "")+ self.package_logs[package_name] = (+ prev_content + new_content+ )+ # We could clean up completed logs here if desired,+ # but for now keep them for replay purposes+def get_cell_outputs(self, ids: list[CellId_t]) -> dict[CellId_t, CellOutput]:diff --git a/packages/openapi/api.yaml b/packages/openapi/api.yamlindex 3a2cb9f87a..bb8ded0058 100644--- a/packages/openapi/api.yaml+++ b/packages/openapi/api.yaml@@ -1606,6 +1606,21 @@ components:type: objectInstallingPackageAlert:properties:+ log_status:+ anyOf:+ - enum:+ - append+ - done+ - start+ - type: 'null'+ default: null+ logs:+ anyOf:+ - additionalProperties:+ type: string+ type: object+ - type: 'null'+ default: nullop:enum:- installing-package-alertdiff --git a/packages/openapi/src/api.ts b/packages/openapi/src/api.tsindex e51668f98e..c9a58e1a82 100644--- a/packages/openapi/src/api.ts+++ b/packages/openapi/src/api.ts@@ -3444,6 +3444,12 @@ export interface components {};/** InstallingPackageAlert */InstallingPackageAlert: {+ /** @default null */+ log_status?: ("append" | "done" | "start") | null;+ /** @default null */+ logs?: {+ [key: string]: string;+ } | null;/** @enum {unknown} */op: "installing-package-alert";packages: {diff --git a/tests/_cli/test_cli.py b/tests/_cli/test_cli.pyindex b474922bf6..251305b26d 100644--- a/tests/_cli/test_cli.py+++ b/tests/_cli/test_cli.py@@ -97,15 +97,17 @@ def _check_shutdown(def _try_fetch(port: int, host: str = "localhost", token: Optional[str] = None) -> Optional[bytes]:+ err: Exception | None = Nonefor _ in range(20):try:url = f"http://{host}:{port}"if token is not None:url = f"{url}?access_token={token}"return urllib.request.urlopen(url).read()- except Exception:+ except Exception as e:+ err = etime.sleep(0.6)- print("Failed to fetch contents")+ print(f"Failed to fetch contents: {err}")return Nonediff --git a/tests/_messaging/test_ops.py b/tests/_messaging/test_ops.pyindex 0a95f3507e..2efe2b276d 100644--- a/tests/_messaging/test_ops.py+++ b/tests/_messaging/test_ops.py@@ -4,7 +4,12 @@ from __future__ import annotationsfrom unittest.mock import MagicMockfrom marimo._ast.toplevel import HINT_UNPARSABLE, TopLevelStatus-from marimo._messaging.ops import CellOp, StartupLogs, VariableValue+from marimo._messaging.ops import (+ CellOp,+ InstallingPackageAlert,+ StartupLogs,+ VariableValue,+)from marimo._output.hypertext import Htmlfrom marimo._plugins.ui._impl.input import sliderfrom marimo._types.ids import CellId_t@@ -68,3 +73,29 @@ def test_startup_logs_all_statuses() -> None:startup_log = StartupLogs(content=f"Test {status}", status=status)assert startup_log.status == statusassert startup_log.content == f"Test {status}"+++def test_installing_package_alert_basic() -> None:+ """Test basic InstallingPackageAlert without streaming logs."""+ alert = InstallingPackageAlert(+ packages={"numpy": "queued", "pandas": "installing"}+ )+ assert alert.name == "installing-package-alert"+ assert alert.packages == {"numpy": "queued", "pandas": "installing"}+ assert alert.logs is None+ assert alert.log_status is None+++def test_installing_package_alert_with_logs() -> None:+ """Test InstallingPackageAlert with streaming logs."""+ packages = {"numpy": "installing"}+ logs = {"numpy": "Installing numpy...\n"}++ alert = InstallingPackageAlert(+ packages=packages, logs=logs, log_status="start"+ )++ assert alert.name == "installing-package-alert"+ assert alert.packages == packages+ assert alert.logs == logs+ assert alert.log_status == "start"diff --git a/tests/_runtime/packages/test_package_managers.py b/tests/_runtime/packages/test_package_managers.pyindex adedf15f27..5436b64808 100644--- a/tests/_runtime/packages/test_package_managers.py+++ b/tests/_runtime/packages/test_package_managers.py@@ -1,7 +1,12 @@from __future__ import annotations+import sys+from typing import Optional+from unittest.mock import AsyncMock, MagicMock, patch+import pytest+from marimo._runtime.packages.package_manager import LogCallbackfrom marimo._runtime.packages.package_managers import create_package_managerfrom marimo._runtime.packages.pypi_package_manager import (PY_EXE,@@ -29,7 +34,12 @@ def test_update_script_metadata() -> None:runs_calls: list[list[str]] = []class MockUvPackageManager(UvPackageManager):- def run(self, command: list[str]) -> bool:+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del log_callbackruns_calls.append(command)return True@@ -55,7 +65,12 @@ def test_update_script_metadata_with_version_map() -> None:runs_calls: list[list[str]] = []class MockUvPackageManager(UvPackageManager):- def run(self, command: list[str]) -> bool:+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del log_callbackruns_calls.append(command)return True@@ -83,7 +98,12 @@ def test_update_script_metadata_with_mapping() -> None:runs_calls: list[list[str]] = []class MockUvPackageManager(UvPackageManager):- def run(self, command: list[str]) -> bool:+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del log_callbackruns_calls.append(command)return True@@ -131,7 +151,12 @@ def test_update_script_metadata_marimo_packages() -> None:runs_calls: list[list[str]] = []class MockUvPackageManager(UvPackageManager):- def run(self, command: list[str]) -> bool:+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del log_callbackruns_calls.append(command)return True@@ -262,7 +287,12 @@ async def test_uv_pip_install() -> None:runs_calls: list[list[str]] = []class MockUvPackageManager(UvPackageManager):- def run(self, command: list[str]) -> bool:+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del log_callbackruns_calls.append(command)return True@@ -271,3 +301,233 @@ async def test_uv_pip_install() -> None:assert runs_calls == [["uv", "pip", "install", "--compile", "foo", "-p", PY_EXE],]+++def test_log_callback_type() -> None:+ """Test that LogCallback type works correctly."""+ captured_logs = []++ def test_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ # Test type annotation works+ callback: LogCallback = test_callback+ callback("test log\n")++ assert len(captured_logs) == 1+ assert captured_logs[0] == "test log\n"+++def test_package_manager_run_without_callback() -> None:+ """Test PackageManager.run without log callback (backward compatibility)."""+ pm = PipPackageManager()++ with (+ patch("subprocess.run") as mock_run,+ patch.object(pm, "is_manager_installed", return_value=True),+ ):+ mock_run.return_value.returncode = 0+ result = pm.run(["echo", "test"], log_callback=None)++ assert result is True+ mock_run.assert_called_once_with(["echo", "test"])+++def test_package_manager_run_with_callback() -> None:+ """Test PackageManager.run with log callback streams output."""+ pm = PipPackageManager()+ captured_logs = []++ def log_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ mock_stdout_lines = [+ b"Installing package...\n",+ b"Successfully installed!\n",+ ]++ with (+ patch("subprocess.Popen") as mock_popen,+ patch("sys.stdout.buffer.write") as mock_buffer_write,+ patch.object(pm, "is_manager_installed", return_value=True),+ ):+ # Mock the subprocess.Popen to return our test output+ mock_proc = MagicMock()+ mock_proc.stdout.readline.side_effect = mock_stdout_lines + [+ b""+ ] # End with empty bytes+ mock_proc.wait.return_value = 0+ mock_popen.return_value = mock_proc++ result = pm.run(["echo", "test"], log_callback=log_callback)++ assert result is True+ assert captured_logs == [+ "Installing package...\n",+ "Successfully installed!\n",+ ]++ # Verify buffer write was called for terminal output+ assert mock_buffer_write.call_count == len(mock_stdout_lines)+ mock_buffer_write.assert_any_call(b"Installing package...\n")+ mock_buffer_write.assert_any_call(b"Successfully installed!\n")+++def test_package_manager_run_with_callback_failure() -> None:+ """Test PackageManager.run with log callback handles failure."""+ pm = PipPackageManager()+ captured_logs = []++ def log_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ with (+ patch("subprocess.Popen") as mock_popen,+ patch.object(pm, "is_manager_installed", return_value=True),+ ):+ mock_proc = MagicMock()+ mock_proc.stdout.readline.side_effect = [+ b"Error occurred\n",+ b"",+ ] # End with empty bytes+ mock_proc.wait.return_value = 1 # Non-zero return code+ mock_popen.return_value = mock_proc++ result = pm.run(["failing_command"], log_callback=log_callback)++ assert result is False+ assert captured_logs == ["Error occurred\n"]+++async def test_pip_install_with_log_callback() -> None:+ """Test PipPackageManager._install with log callback."""+ captured_logs = []++ def log_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ class MockPipPackageManager(PipPackageManager):+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del command+ if log_callback:+ log_callback("Installing numpy...\n")+ log_callback("Successfully installed numpy\n")+ return True++ pm = MockPipPackageManager()+ result = await pm._install(+ "numpy", upgrade=False, log_callback=log_callback+ )++ assert result is True+ assert captured_logs == [+ "Installing numpy...\n",+ "Successfully installed numpy\n",+ ]+++async def test_uv_install_with_log_callback() -> None:+ """Test UvPackageManager._install with log callback."""+ captured_logs = []++ def log_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ class MockUvPackageManager(UvPackageManager):+ def run(+ self,+ command: list[str],+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del command+ if log_callback:+ log_callback("Resolving dependencies...\n")+ log_callback("Installing packages...\n")+ return True++ pm = MockUvPackageManager()+ result = await pm._install(+ "pandas", upgrade=False, log_callback=log_callback+ )++ assert result is True+ assert captured_logs == [+ "Resolving dependencies...\n",+ "Installing packages...\n",+ ]+++async def test_micropip_install_with_log_callback() -> None:+ """Test MicropipPackageManager._install with log callback."""+ captured_logs = []++ def log_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ pm = MicropipPackageManager()++ mock_micropip = MagicMock()+ mock_micropip.install = AsyncMock(return_value=None)++ with (+ patch("marimo._utils.platform.is_pyodide", return_value=True),+ patch(+ "marimo._runtime.packages.pypi_package_manager.is_pyodide",+ return_value=True,+ ),+ patch.dict(sys.modules, {"micropip": mock_micropip}),+ ):+ result = await pm._install(+ "requests", upgrade=False, log_callback=log_callback+ )++ assert result is True+ assert len(captured_logs) == 2+ assert "Installing requests with micropip" in captured_logs[0]+ assert "Successfully installed requests" in captured_logs[1]+++async def test_package_manager_install_method_with_callback() -> None:+ """Test PackageManager.install method passes log_callback to _install."""+ captured_logs = []++ def log_callback(log_line: str) -> None:+ captured_logs.append(log_line)++ class MockPackageManager(PipPackageManager):+ async def _install(+ self,+ package: str,+ *,+ upgrade: bool,+ log_callback: Optional[LogCallback] = None,+ ) -> bool:+ del upgrade+ if log_callback:+ log_callback(f"Installing {package}...\n")+ return True++ pm = MockPackageManager()+ result = await pm.install(+ "test-package", version="1.0.0", log_callback=log_callback+ )++ assert result is True+ assert captured_logs == ["Installing test-package==1.0.0...\n"]+++def test_package_manager_run_manager_not_installed() -> None:+ """Test PackageManager.run when manager is not installed."""+ pm = PipPackageManager()++ with patch.object(pm, "is_manager_installed", return_value=False):+ result = pm.run(["test", "command"], log_callback=None)+ assert result is False++ # Should also return False with log callback+ result = pm.run(["test", "command"], log_callback=lambda _: None)+ assert result is Falsediff --git a/tests/_runtime/test_manage_script_metadata.py b/tests/_runtime/test_manage_script_metadata.pyindex 4ac013173d..33bc9d12b4 100644--- a/tests/_runtime/test_manage_script_metadata.py+++ b/tests/_runtime/test_manage_script_metadata.py@@ -3,7 +3,7 @@ from __future__ import annotationsimport pathlibimport sys-from typing import TYPE_CHECKING, cast+from typing import TYPE_CHECKING, Any, castfrom unittest.mock import AsyncMock, Mock, call, patchimport pytest@@ -498,3 +498,281 @@ def test_missing_packages_hook_pip("pandas": "","scipy": "",}+++async def test_install_missing_packages_with_streaming_logs(+ mocked_kernel: MockedKernel,+) -> None:+ """Test that install_missing_packages uses streaming logs functionality."""+ k = mocked_kernel.k+ broadcast_messages: list[InstallingPackageAlert] = []++ def mock_broadcast(self):+ """Mock the broadcast method to capture alerts"""+ broadcast_messages.append(self)++ # Mock package manager+ mock_package_manager = Mock(spec=PipPackageManager)+ mock_package_manager.name = "pip"+ mock_package_manager.is_manager_installed.return_value = True+ mock_package_manager.attempted_to_install.return_value = False+ mock_package_manager.package_to_module.return_value = "test_module"++ # Mock successful installation with log callback+ async def mock_install(pkg: str, version=None, log_callback=None):+ del pkg, version+ if log_callback:+ log_callback("Starting installation...\n")+ log_callback("Downloading package...\n")+ log_callback("Installing package...\n")+ log_callback("Installation complete!\n")+ return True++ mock_package_manager.install = AsyncMock(side_effect=mock_install)++ # Set up packages callbacks+ k.packages_callbacks.package_manager = mock_package_manager++ # Monkey patch broadcast for testing+ original_broadcast = InstallingPackageAlert.broadcast+ InstallingPackageAlert.broadcast = mock_broadcast++ try:+ # Create install request+ request = InstallMissingPackagesRequest(+ manager="pip", versions={"numpy": ""}+ )++ await k.packages_callbacks.install_missing_packages(request)++ # Verify broadcast messages+ assert (+ len(broadcast_messages) >= 5+ ) # Initial + start + done + status updates++ # Check that streaming logs were sent+ streaming_alerts = [+ msg for msg in broadcast_messages if msg.logs is not None+ ]+ assert len(streaming_alerts) >= 2 # At least start and done++ # Verify start log+ start_alerts = [+ msg for msg in streaming_alerts if msg.log_status == "start"+ ]+ assert len(start_alerts) == 1+ assert "numpy" in start_alerts[0].logs+ assert "Installing numpy" in start_alerts[0].logs["numpy"]++ # Verify done log+ done_alerts = [+ msg for msg in streaming_alerts if msg.log_status == "done"+ ]+ assert len(done_alerts) == 1+ assert "numpy" in done_alerts[0].logs+ assert "Successfully installed numpy" in done_alerts[0].logs["numpy"]++ # Verify package manager was called with log callback+ mock_package_manager.install.assert_called_once()+ call_args = mock_package_manager.install.call_args+ assert call_args.kwargs.get("log_callback") is not None++ finally:+ # Restore original broadcast method+ InstallingPackageAlert.broadcast = original_broadcast+++async def test_install_missing_packages_streaming_logs_failure(+ mocked_kernel: MockedKernel,+) -> None:+ """Test streaming logs when package installation fails."""+ k = mocked_kernel.k+ broadcast_messages: list[InstallingPackageAlert] = []++ def mock_broadcast(self):+ broadcast_messages.append(self)++ # Mock package manager+ mock_package_manager = Mock(spec=PipPackageManager)+ mock_package_manager.name = "pip"+ mock_package_manager.is_manager_installed.return_value = True+ mock_package_manager.attempted_to_install.return_value = False+ mock_package_manager.package_to_module.return_value = "test_module"++ # Mock failed installation with log callback+ async def mock_install_fail(pkg: str, version=None, log_callback=None):+ del pkg, version+ if log_callback:+ log_callback("Starting installation...\n")+ log_callback("Error: Package not found\n")+ return False # Installation failed++ mock_package_manager.install = AsyncMock(side_effect=mock_install_fail)+ k.packages_callbacks.package_manager = mock_package_manager++ # Monkey patch broadcast+ original_broadcast = InstallingPackageAlert.broadcast+ InstallingPackageAlert.broadcast = mock_broadcast++ try:+ request = InstallMissingPackagesRequest(+ manager="pip", versions={"nonexistent-package": ""}+ )++ await k.packages_callbacks.install_missing_packages(request)++ # Verify failure logs were sent+ streaming_alerts = [+ msg for msg in broadcast_messages if msg.logs is not None+ ]+ assert len(streaming_alerts) >= 2++ # Verify done log with failure message+ done_alerts = [+ msg for msg in streaming_alerts if msg.log_status == "done"+ ]+ assert len(done_alerts) == 1+ assert "nonexistent-package" in done_alerts[0].logs+ assert (+ "Failed to install" in done_alerts[0].logs["nonexistent-package"]+ )++ finally:+ InstallingPackageAlert.broadcast = original_broadcast+++async def test_install_missing_packages_streaming_logs_multiple_packages(+ mocked_kernel: MockedKernel,+) -> None:+ """Test streaming logs for multiple packages."""+ k = mocked_kernel.k+ broadcast_messages: list[InstallingPackageAlert] = []++ def mock_broadcast(self):+ broadcast_messages.append(self)++ # Mock package manager+ mock_package_manager = Mock(spec=PipPackageManager)+ mock_package_manager.name = "pip"+ mock_package_manager.is_manager_installed.return_value = True+ mock_package_manager.attempted_to_install.return_value = False+ mock_package_manager.package_to_module.side_effect = (+ lambda pkg: pkg.replace("-", "_")+ )++ # Track which packages are being installed+ installation_calls = []++ async def mock_install(pkg: str, version=None, log_callback=None):+ del version+ installation_calls.append(pkg)+ if log_callback:+ log_callback(f"Installing {pkg}...\n")+ log_callback(f"Successfully installed {pkg}!\n")+ return True++ mock_package_manager.install = AsyncMock(side_effect=mock_install)+ k.packages_callbacks.package_manager = mock_package_manager++ # Monkey patch broadcast+ original_broadcast = InstallingPackageAlert.broadcast+ InstallingPackageAlert.broadcast = mock_broadcast++ try:+ request = InstallMissingPackagesRequest(+ manager="pip", versions={"numpy": "", "pandas": "", "scipy": ""}+ )++ await k.packages_callbacks.install_missing_packages(request)++ # Verify all packages were processed+ assert len(installation_calls) == 3+ assert set(installation_calls) == {"numpy", "pandas", "scipy"}++ # Verify streaming logs for each package+ streaming_alerts = [+ msg for msg in broadcast_messages if msg.logs is not None+ ]++ # Should have start and done logs for each package+ start_alerts = [+ msg for msg in streaming_alerts if msg.log_status == "start"+ ]+ done_alerts = [+ msg for msg in streaming_alerts if msg.log_status == "done"+ ]++ assert len(start_alerts) == 3+ assert len(done_alerts) == 3++ # Verify each package has its own logs+ packages_in_start_logs = set()+ for alert in start_alerts:+ packages_in_start_logs.update(alert.logs.keys())++ packages_in_done_logs = set()+ for alert in done_alerts:+ packages_in_done_logs.update(alert.logs.keys())++ assert packages_in_start_logs == {"numpy", "pandas", "scipy"}+ assert packages_in_done_logs == {"numpy", "pandas", "scipy"}++ finally:+ InstallingPackageAlert.broadcast = original_broadcast+++async def test_install_missing_packages_no_logs_backward_compatibility(+ mocked_kernel: MockedKernel,+) -> None:+ """Test that package installation still works without streaming logs (backward compatibility)."""+ k = mocked_kernel.k+ broadcast_messages: list[InstallingPackageAlert] = []++ def mock_broadcast(self):+ broadcast_messages.append(self)++ # Mock package manager that doesn't use log callbacks+ mock_package_manager = Mock(spec=PipPackageManager)+ mock_package_manager.name = "pip"+ mock_package_manager.is_manager_installed.return_value = True+ mock_package_manager.attempted_to_install.return_value = False+ mock_package_manager.package_to_module.return_value = "test_module"++ # Mock installation without using log callback parameter+ async def mock_install_old_style(pkg: str, version=None, **kwargs: Any):+ del version, kwargs, pkg+ # Ignore log_callback if provided (simulating old package managers)+ return True++ mock_package_manager.install = AsyncMock(+ side_effect=mock_install_old_style+ )+ k.packages_callbacks.package_manager = mock_package_manager++ # Monkey patch broadcast+ original_broadcast = InstallingPackageAlert.broadcast+ InstallingPackageAlert.broadcast = mock_broadcast++ try:+ request = InstallMissingPackagesRequest(+ manager="pip", versions={"requests": ""}+ )++ await k.packages_callbacks.install_missing_packages(request)++ # Should still work and send basic status updates+ status_alerts = [msg for msg in broadcast_messages if msg.logs is None]+ assert len(status_alerts) >= 2 # At least installing and installed++ # Verify normal package status progression+ package_statuses = []+ for alert in status_alerts:+ if "requests" in alert.packages:+ package_statuses.append(alert.packages["requests"])++ # Should have at least installing and installed statuses+ assert "installed" in package_statuses+ # Note: The exact sequence might vary, but we should have final success++ finally:+ InstallingPackageAlert.broadcast = original_broadcastdiff --git a/tests/_server/session/test_session_view.py b/tests/_server/session/test_session_view.pyindex c58d955c51..2ac45a0900 100644--- a/tests/_server/session/test_session_view.py+++ b/tests/_server/session/test_session_view.py@@ -13,6 +13,7 @@ from marimo._messaging.ops import (Datasets,DataSourceConnection,DataSourceConnections,+ InstallingPackageAlert,SendUIElementMessage,StartupLogs,UpdateCellCodes,@@ -1049,3 +1050,210 @@ def test_session_view_startup_logs_standalone_done() -> None:assert session_view.startup_logs is not Noneassert session_view.startup_logs.content == "Process complete"assert session_view.startup_logs.status == "done"+++def test_session_view_package_logs_initialization() -> None:+ """Test that SessionView initializes package_logs correctly."""+ session_view = SessionView()+ assert hasattr(session_view, "package_logs")+ assert isinstance(session_view.package_logs, dict)+ assert len(session_view.package_logs) == 0+++def test_session_view_package_logs_start() -> None:+ """Test SessionView handles package logs start status."""+ session_view = SessionView()++ alert = InstallingPackageAlert(+ packages={"numpy": "installing"},+ logs={"numpy": "Installing numpy...\n"},+ log_status="start",+ )++ session_view.add_operation(alert)++ assert "numpy" in session_view.package_logs+ assert session_view.package_logs["numpy"] == "Installing numpy...\n"+++def test_session_view_package_logs_append() -> None:+ """Test SessionView handles package logs append status."""+ session_view = SessionView()++ # Start with initial log+ start_alert = InstallingPackageAlert(+ packages={"pandas": "installing"},+ logs={"pandas": "Starting installation...\n"},+ log_status="start",+ )+ session_view.add_operation(start_alert)++ # Append more logs+ append_alert = InstallingPackageAlert(+ packages={"pandas": "installing"},+ logs={"pandas": "Downloading dependencies...\n"},+ log_status="append",+ )+ session_view.add_operation(append_alert)++ expected_content = (+ "Starting installation...\nDownloading dependencies...\n"+ )+ assert session_view.package_logs["pandas"] == expected_content+++def test_session_view_package_logs_done() -> None:+ """Test SessionView handles package logs done status."""+ session_view = SessionView()++ # Start installation+ start_alert = InstallingPackageAlert(+ packages={"scipy": "installing"},+ logs={"scipy": "Installing scipy...\n"},+ log_status="start",+ )+ session_view.add_operation(start_alert)++ # Add progress log+ append_alert = InstallingPackageAlert(+ packages={"scipy": "installing"},+ logs={"scipy": "Building wheels...\n"},+ log_status="append",+ )+ session_view.add_operation(append_alert)++ # Finish installation+ done_alert = InstallingPackageAlert(+ packages={"scipy": "installed"},+ logs={"scipy": "Successfully installed scipy!\n"},+ log_status="done",+ )+ session_view.add_operation(done_alert)++ expected_content = (+ "Installing scipy...\n"+ "Building wheels...\n"+ "Successfully installed scipy!\n"+ )+ assert session_view.package_logs["scipy"] == expected_content+++def test_session_view_package_logs_multiple_packages() -> None:+ """Test SessionView handles logs for multiple packages simultaneously."""+ session_view = SessionView()++ # Start installing multiple packages+ multi_alert = InstallingPackageAlert(+ packages={"numpy": "installing", "pandas": "installing"},+ logs={+ "numpy": "Starting numpy install...\n",+ "pandas": "Starting pandas install...\n",+ },+ log_status="start",+ )+ session_view.add_operation(multi_alert)++ # Add logs for numpy only+ numpy_alert = InstallingPackageAlert(+ packages={"numpy": "installing", "pandas": "installing"},+ logs={"numpy": "Numpy progress...\n"},+ log_status="append",+ )+ session_view.add_operation(numpy_alert)++ # Add logs for pandas only+ pandas_alert = InstallingPackageAlert(+ packages={"numpy": "installing", "pandas": "installing"},+ logs={"pandas": "Pandas progress...\n"},+ log_status="append",+ )+ session_view.add_operation(pandas_alert)++ assert len(session_view.package_logs) == 2+ assert "numpy" in session_view.package_logs+ assert "pandas" in session_view.package_logs++ assert session_view.package_logs["numpy"] == (+ "Starting numpy install...\nNumpy progress...\n"+ )+ assert session_view.package_logs["pandas"] == (+ "Starting pandas install...\nPandas progress...\n"+ )+++def test_session_view_package_logs_without_logs() -> None:+ """Test SessionView handles InstallingPackageAlert without logs (backward compatibility)."""+ session_view = SessionView()++ # Old-style alert without logs+ alert = InstallingPackageAlert(packages={"requests": "installing"})+ session_view.add_operation(alert)++ # Should not add any package logs+ assert len(session_view.package_logs) == 0+++def test_session_view_package_logs_partial_logs() -> None:+ """Test SessionView handles alerts with logs but no log_status."""+ session_view = SessionView()++ # Alert with logs but no log_status+ alert = InstallingPackageAlert(+ packages={"matplotlib": "installing"},+ logs={"matplotlib": "Some log content...\n"},+ # log_status is None+ )+ session_view.add_operation(alert)++ # Should not add any package logs since log_status is missing+ assert len(session_view.package_logs) == 0+++def test_session_view_package_logs_start_without_existing() -> None:+ """Test package logs start status on package that doesn't exist yet."""+ session_view = SessionView()++ alert = InstallingPackageAlert(+ packages={"new_package": "installing"},+ logs={"new_package": "Starting fresh install...\n"},+ log_status="start",+ )+ session_view.add_operation(alert)++ assert (+ session_view.package_logs["new_package"]+ == "Starting fresh install...\n"+ )+++def test_session_view_package_logs_append_without_existing() -> None:+ """Test package logs append status on package that doesn't exist yet."""+ session_view = SessionView()++ # Append to non-existing package should start with empty string+ alert = InstallingPackageAlert(+ packages={"orphan_package": "installing"},+ logs={"orphan_package": "Appending to nothing...\n"},+ log_status="append",+ )+ session_view.add_operation(alert)++ assert (+ session_view.package_logs["orphan_package"]+ == "Appending to nothing...\n"+ )+++def test_session_view_package_logs_empty_content() -> None:+ """Test SessionView handles empty log content."""+ session_view = SessionView()++ alert = InstallingPackageAlert(+ packages={"empty_logs": "installing"},+ logs={"empty_logs": ""},+ log_status="start",+ )+ session_view.add_operation(alert)++ assert "empty_logs" in session_view.package_logs+ assert session_view.package_logs["empty_logs"] == ""