Skip to content

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.

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.tsx
index 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]">
<Banner
kind="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] ">
<Banner
kind={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.ts
index 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.py
index 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"]] = None
class Reconnected(Op, tag="reconnected"):
diff --git a/marimo/_runtime/packages/conda_package_manager.py b/marimo/_runtime/packages/conda_package_manager.py
index 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 json
diff --git a/marimo/_runtime/packages/package_manager.py b/marimo/_runtime/packages/package_manager.py
index b0409e0ae2..a3338e509c 100644
--- a/marimo/_runtime/packages/package_manager.py
+++ b/marimo/_runtime/packages/package_manager.py
@@ -3,7 +3,8 @@ from __future__ import annotations
import abc
import subprocess
-from typing import TYPE_CHECKING, Optional
+import sys
+from typing import TYPE_CHECKING, Callable, Optional
import 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 == 0
def 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.abstractmethod
def list_packages(self) -> list[PackageDescription]:
diff --git a/marimo/_runtime/packages/pypi_package_manager.py b/marimo/_runtime/packages/pypi_package_manager.py
index 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):
pass
try:
+ 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 False
async 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 True
LOGGER.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_frontmatter
from marimo._utils import yaml
from 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 = True
if 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 success
def _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.py
index 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_manager
from 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:
continue
package_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.py
index 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 time
self.startup_logs: Optional[StartupLogs] = None
+ # Package installation logs - accumulated per package
+ self.package_logs: dict[
+ str, str
+ ] = {} # package name -> accumulated logs
+
# Auto-saving
self.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.yaml
index 3a2cb9f87a..bb8ded0058 100644
--- a/packages/openapi/api.yaml
+++ b/packages/openapi/api.yaml
@@ -1606,6 +1606,21 @@ components:
type: object
InstallingPackageAlert:
properties:
+ log_status:
+ anyOf:
+ - enum:
+ - append
+ - done
+ - start
+ - type: 'null'
+ default: null
+ logs:
+ anyOf:
+ - additionalProperties:
+ type: string
+ type: object
+ - type: 'null'
+ default: null
op:
enum:
- installing-package-alert
diff --git a/packages/openapi/src/api.ts b/packages/openapi/src/api.ts
index 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.py
index 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 = None
for _ 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 = e
time.sleep(0.6)
- print("Failed to fetch contents")
+ print(f"Failed to fetch contents: {err}")
return None
diff --git a/tests/_messaging/test_ops.py b/tests/_messaging/test_ops.py
index 0a95f3507e..2efe2b276d 100644
--- a/tests/_messaging/test_ops.py
+++ b/tests/_messaging/test_ops.py
@@ -4,7 +4,12 @@ from __future__ import annotations
from unittest.mock import MagicMock
from 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 Html
from marimo._plugins.ui._impl.input import slider
from 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 == status
assert 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.py
index 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 LogCallback
from marimo._runtime.packages.package_managers import create_package_manager
from 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_callback
runs_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_callback
runs_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_callback
runs_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_callback
runs_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_callback
runs_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 False
diff --git a/tests/_runtime/test_manage_script_metadata.py b/tests/_runtime/test_manage_script_metadata.py
index 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 annotations
import pathlib
import sys
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Any, cast
from unittest.mock import AsyncMock, Mock, call, patch
import 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_broadcast
diff --git a/tests/_server/session/test_session_view.py b/tests/_server/session/test_session_view.py
index 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 None
assert 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"] == ""