nvda-addon-testkit 0.1.0__py3-none-any.whl

nvda_testkit/plugin.py

@@ -0,0 +1,137 @@
+"""The pytest plugin. Registered automatically via the pytest11 entry point."""
+
+from __future__ import annotations
+
+import warnings
+from pathlib import Path
+
+import pytest
+
+from .client import NvdaClient
+from .errors import ProvisionError
+from .provisioning import Provisioned, provision, provision_fake
+from .settings import load_settings
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("nvda-testkit", "NVDA add-on end-to-end testing")
+    group.addoption("--nvda-channel", default=None, help="stable, beta, alpha, or a pinned version")
+    group.addoption("--nvda-version", default=None, help="alias for --nvda-channel <version>")
+    group.addoption("--nvda-timeout-scale", type=float, default=None, help="multiply every timeout")
+    group.addoption("--nvda-allow-eval", action="store_true", default=None, help="enable nvda.eval")
+    group.addoption(
+        "--nvda-keep-portable",
+        action="store_true",
+        default=None,
+        help="do not delete the portable NVDA copy on teardown",
+    )
+    group.addoption("--nvda-out-dir", default=None, help="where logs and artifacts are written")
+    group.addoption(
+        "--nvda-fake",
+        default=None,
+        help="drive the FakeNvda double at this path instead of a real NVDA (development only)",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line("markers", "fresh_nvda: restart NVDA before this test")
+
+    # Only one NVDA can own a desktop session, so parallel workers would fight
+    # over it and produce results that mean nothing.
+    workers = getattr(config.option, "numprocesses", None)
+    if isinstance(workers, int) and workers > 1:
+        raise pytest.UsageError(
+            f"nvda-addon-testkit cannot run in parallel: -n {workers} was requested, but only "
+            "one NVDA can own a desktop session. Shard across CI jobs instead."
+        )
+
+
+@pytest.fixture(scope="session")
+def nvda_settings(pytestconfig: pytest.Config):
+    option = pytestconfig.option
+    return load_settings(
+        overrides={
+            "channel": option.nvda_version or option.nvda_channel,
+            "timeout_scale": option.nvda_timeout_scale,
+            "allow_eval": True if option.nvda_allow_eval else None,
+            "keep_portable": True if option.nvda_keep_portable else None,
+            "out_dir": option.nvda_out_dir,
+        }
+    )
+
+
+@pytest.fixture(scope="session")
+def _nvda_provisioned(nvda_settings, pytestconfig: pytest.Config):
+    fake = pytestconfig.option.nvda_fake
+    running: Provisioned = (
+        provision_fake(nvda_settings, Path(fake)) if fake else provision(nvda_settings)
+    )
+    try:
+        yield running
+    finally:
+        running.teardown()
+
+
+@pytest.fixture(scope="session")
+def nvda_session(_nvda_provisioned, nvda_settings) -> NvdaClient:
+    return NvdaClient(_nvda_provisioned.process, _nvda_provisioned.rpc, settings=nvda_settings)
+
+
+@pytest.fixture
+def nvda(request: pytest.FixtureRequest, nvda_session: NvdaClient) -> NvdaClient:
+    if request.node.get_closest_marker("fresh_nvda"):
+        nvda_session.restart()
+    nvda_session.reset()
+    return nvda_session
+
+
+@pytest.fixture(autouse=True)
+def nvda_reset(request: pytest.FixtureRequest):
+    """Reset after any test that touched NVDA, so the next one starts clean.
+
+    Autouse, but deliberately lazy: a test that never asks for `nvda` never
+    causes NVDA to start.
+    """
+    yield
+    if "nvda_session" not in request.fixturenames:
+        return
+    client = request.getfixturevalue("nvda_session")
+    try:
+        client.reset()
+    except Exception as error:
+        # Non-fatal here -- the next test's `nvda` fixture calls reset() again
+        # and will surface a persistent failure -- but never silent: if this
+        # is the last test in the session, a warning is the only channel left.
+        warnings.warn(
+            f"nvda-testkit: reset() failed during teardown: {error}",
+            stacklevel=2,
+        )
+
+
+@pytest.fixture(scope="session")
+def addon_bundle(nvda_settings) -> Path:
+    pattern = nvda_settings.addon_bundle
+    if not pattern:
+        raise ProvisionError(
+            "No add-on bundle configured. Set addon-bundle under [tool.nvda-testkit] "
+            'in pyproject.toml, e.g. addon-bundle = "dist/my-addon-*.nvda-addon".'
+        )
+    matches = sorted(Path().glob(pattern.replace("{version}", "*")))
+    if not matches:
+        raise ProvisionError(
+            f"No add-on bundle matched {pattern!r} from {Path().resolve()}. Build it first."
+        )
+    if len(matches) > 1:
+        raise ProvisionError(
+            f"{pattern!r} matched {len(matches)} bundles: {[str(m) for m in matches]}. "
+            "Clean the stale ones out, or pin the pattern."
+        )
+    return matches[0]
+
+
+@pytest.fixture(scope="session")
+def addon_under_test(nvda_session: NvdaClient, addon_bundle: Path) -> Path:
+    """The bundle, installed and enabled, with NVDA restarted to complete it."""
+    nvda_session.addons.install(addon_bundle)
+    nvda_session.restart()
+    return addon_bundle

nvda_testkit/portable.py

@@ -0,0 +1,161 @@
+"""Create a disposable portable NVDA and seed it for testing.
+
+Portable rather than a system install: no admin rights, several NVDA versions
+side by side, and cleanup is deleting a directory. The trade-off, accepted
+deliberately, is that the secure/lock screen is out of reach.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from .errors import ProvisionError, UnsupportedPlatformError
+
+#: Settings applied to every portable copy the kit creates. Each one removes
+#: something that would either block a headless run or add wall-clock time.
+DEFAULT_CONFIG: dict[str, Any] = {
+    "general": {
+        "showWelcomeDialogAtStartup": False,
+        "saveConfigurationOnExit": False,
+        "askToExit": False,
+        "playStartAndExitSounds": False,
+    },
+    "update": {
+        "autoCheck": False,
+        "startupNotification": False,
+        "allowUsageStats": False,
+        # NVDA only skips AskAllowUsageStatsDialog once this is set; setting
+        # allowUsageStats alone still shows the blocking first-run prompt.
+        "askedAllowUsageStats": True,
+    },
+    "braille": {
+        "display": "noBraille",
+    },
+    "speechViewer": {
+        "showSpeechViewerAtStartup": False,
+    },
+}
+
+
+@dataclass(frozen=True)
+class PortableNvda:
+    root: Path
+    exe: Path
+    user_config: Path
+    addons_dir: Path
+
+
+def _render_section(name: str, values: dict[str, Any], depth: int) -> list[str]:
+    brackets = "[" * depth
+    closing = "]" * depth
+    lines = [f"{brackets}{name}{closing}"]
+    nested: list[str] = []
+    for key, value in values.items():
+        if isinstance(value, dict):
+            nested.extend(_render_section(key, value, depth + 1))
+        else:
+            lines.append(f"{key} = {value}")
+    return lines + nested
+
+
+def _merge(base: dict[str, Any], overrides: dict[str, Any]) -> dict[str, Any]:
+    merged = {key: dict(value) if isinstance(value, dict) else value for key, value in base.items()}
+    for key, value in overrides.items():
+        if isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = _merge(merged[key], value)
+        else:
+            merged[key] = value
+    return merged
+
+
+def render_nvda_ini(overrides: dict[str, Any] | None = None) -> str:
+    """Render an nvda.ini in ConfigObj's format.
+
+    schemaVersion is deliberately omitted: NVDA fills in its own defaults for a
+    partial config, which is more durable than pinning a number that changes
+    every release.
+    """
+    config = _merge(DEFAULT_CONFIG, overrides or {})
+    lines: list[str] = []
+    for name, values in config.items():
+        if not isinstance(values, dict):
+            lines.append(f"{name} = {values}")
+            continue
+        lines.extend(_render_section(name, values, depth=1))
+    return "\n".join(lines) + "\n"
+
+
+def extract_addon(bundle: Path, dest_dir: Path) -> None:
+    """Unzip a .nvda-addon into dest_dir, refusing entries that escape it."""
+    bundle = Path(bundle)
+    dest_dir = Path(dest_dir)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    resolved_dest = dest_dir.resolve()
+
+    with zipfile.ZipFile(bundle) as archive:
+        names = archive.namelist()
+        for name in names:
+            target = (dest_dir / name).resolve()
+            if not target.is_relative_to(resolved_dest):
+                raise ProvisionError(
+                    f"Entry {name!r} in {bundle} escapes the destination directory."
+                )
+        if "manifest.ini" not in names:
+            raise ProvisionError(f"{bundle} has no manifest.ini; it is not an NVDA add-on bundle.")
+        archive.extractall(dest_dir)
+
+
+def seed_user_config(root: Path, overrides: dict[str, Any] | None = None) -> Path:
+    root = Path(root)
+    user_config = root / "userConfig"
+    (user_config / "addons").mkdir(parents=True, exist_ok=True)
+    (user_config / "nvda.ini").write_text(render_nvda_ini(overrides), encoding="utf-8")
+    return user_config
+
+
+def create_portable(launcher: Path, dest: Path, *, timeout: float = 300) -> PortableNvda:
+    """Run the launcher to produce a portable copy at `dest`."""
+    if sys.platform != "win32":
+        raise UnsupportedPlatformError(
+            "Creating a portable NVDA copy needs a real Windows host. "
+            "Host-side logic is testable on Linux; this step is not."
+        )
+    launcher = Path(launcher)
+    dest = Path(dest)
+    if not launcher.is_file():
+        raise ProvisionError(f"Launcher not found: {launcher}")
+
+    try:
+        completed = subprocess.run(
+            [str(launcher), "--create-portable-silent", f"--portable-path={dest}"],
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False,
+        )
+    except subprocess.TimeoutExpired as expired:
+        raise ProvisionError(
+            f"Creating a portable copy timed out after {timeout}s. Launcher: {launcher}\n"
+            f"stdout so far: {expired.stdout!r}\nstderr so far: {expired.stderr!r}"
+        ) from expired
+
+    exe = dest / "nvda.exe"
+    if completed.returncode != 0 or not exe.is_file():
+        raise ProvisionError(
+            f"Creating a portable copy failed (exit {completed.returncode}).\n"
+            f"stdout: {completed.stdout.strip()}\n"
+            f"stderr: {completed.stderr.strip()}"
+        )
+
+    user_config = seed_user_config(dest)
+    return PortableNvda(
+        root=dest,
+        exe=exe,
+        user_config=user_config,
+        addons_dir=user_config / "addons",
+    )

nvda_testkit/process.py

@@ -0,0 +1,287 @@
+"""Start, watch and stop the NVDA under test.
+
+The handshake protocol: we generate a token, hand it to NVDA in the
+environment, delete any stale handshake file, then poll for a new one while
+also watching for the process dying. Watching both matters -- an NVDA that
+crashes on startup must fail in seconds, not at the handshake deadline.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import json
+import logging
+import os
+import secrets
+import subprocess
+import sys
+import time
+from collections.abc import Iterable, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+
+from .errors import HandshakeTimeout, NvdaStartupError
+from .portable import PortableNvda
+
+HANDSHAKE_FILENAME = "testkit-handshake.json"
+
+_POLL_INTERVAL = 0.05
+
+
+def new_token() -> str:
+    return secrets.token_hex(16)
+
+
+@dataclass(frozen=True)
+class Handshake:
+    port: int
+    pid: int
+    nvda_version: str
+    api_version: str | None
+    api_compat_to: str | None
+
+    @classmethod
+    def from_payload(cls, payload: dict) -> Handshake:
+        return cls(
+            port=int(payload["port"]),
+            pid=int(payload["pid"]),
+            nvda_version=str(payload.get("nvdaVersion", "unknown")),
+            api_version=payload.get("apiVersion"),
+            api_compat_to=payload.get("apiCompatTo"),
+        )
+
+
+def nvda_argv(
+    portable: PortableNvda,
+    log_file: Path,
+    *,
+    # NVDA's --log-level takes one of the stdlib logging levels as an int
+    # (10/20/30/40/50), not a level name: a name fails argparse's type=int
+    # conversion and NVDA pops a blocking "Command-line Argument Error"
+    # dialog instead of exiting, hanging every real-NVDA test indefinitely.
+    log_level: int = logging.DEBUG,
+    minimal: bool = False,
+    extra: Iterable[str] = (),
+) -> list[str]:
+    argv = [
+        str(portable.exe),
+        f"--log-file={log_file}",
+        f"--log-level={log_level}",
+        f"--config-path={portable.user_config}",
+        # Leave the system screen-reader flag alone: the runner may be shared,
+        # and flipping it has effects that outlive the test session.
+        "--no-sr-flag",
+    ]
+    if minimal:
+        argv.append("--minimal")
+    argv.extend(extra)
+    return argv
+
+
+class NvdaProcess:
+    """Owns one NVDA (or FakeNvda) process and its handshake."""
+
+    def __init__(
+        self,
+        argv: Sequence[str],
+        out_dir: Path,
+        *,
+        token: str | None = None,
+        env: dict[str, str] | None = None,
+        log_file: Path | None = None,
+        quit_via: str = "exe",
+        timeout_scale: float = 1.0,
+    ) -> None:
+        self.argv = list(argv)
+        # NVDA runs os.chdir(appDir) at startup (source/nvda.pyw), so a relative
+        # NVDA_TESTKIT_OUTDIR would resolve against the portable copy, not us.
+        self.out_dir = Path(out_dir).resolve()
+        self.token = token or new_token()
+        self._log_file_base = Path(log_file).resolve() if log_file else None
+        self.log_file = self._log_file_base
+        self._start_count = 0
+        self.timeout_scale = timeout_scale
+        self._quit_via = quit_via
+        self._extra_env = dict(env or {})
+        self._proc: subprocess.Popen | None = None
+        self._handshake: Handshake | None = None
+
+    @property
+    def handshake_path(self) -> Path:
+        return self.out_dir / HANDSHAKE_FILENAME
+
+    @property
+    def handshake(self) -> Handshake | None:
+        return self._handshake
+
+    @property
+    def is_running(self) -> bool:
+        return self._proc is not None and self._proc.poll() is None
+
+    def _environment(self) -> dict[str, str]:
+        environment = dict(os.environ)
+        environment.update(self._extra_env)
+        environment["NVDA_TESTKIT_TOKEN"] = self.token
+        environment["NVDA_TESTKIT_OUTDIR"] = str(self.out_dir)
+        return environment
+
+    def log_tail(self, lines: int = 80) -> str:
+        if self.log_file is None or not self.log_file.is_file():
+            return "(no NVDA log available)"
+        content = self.log_file.read_text(encoding="utf-8", errors="replace").splitlines()
+        return "\n".join(content[-lines:])
+
+    def _hang_diagnostics(self) -> str:
+        """Best-effort Windows process/AV snapshot, captured *before* kill().
+
+        A real NVDA that never even opens its own log file points at something
+        blocking before Python starts -- Defender's on-access scan of a
+        freshly-extracted .exe is the leading suspect on GH runners. Never
+        raises: a diagnostic that itself fails must not replace the original
+        HandshakeTimeout.
+        """
+        if sys.platform != "win32":
+            return ""
+        pid = self._proc.pid if self._proc is not None else None
+        sections = []
+        try:
+            tasklist = subprocess.run(
+                ["tasklist", "/V", "/FO", "CSV"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+                check=False,
+            )
+            needles = [needle for needle in ("nvda", "werfault", f'"{pid}"') if needle]
+            matches = [
+                line
+                for line in tasklist.stdout.splitlines()
+                if any(needle in line.lower() for needle in needles)
+            ]
+            sections.append(
+                "tasklist (nvda/WerFault/our pid):\n" + ("\n".join(matches) or "(none found)")
+            )
+        except Exception as error:
+            sections.append(f"tasklist failed: {error}")
+        try:
+            defender = subprocess.run(
+                [
+                    "powershell",
+                    "-NoProfile",
+                    "-NonInteractive",
+                    "-Command",
+                    "(Get-MpComputerStatus).RealTimeProtectionEnabled",
+                ],
+                capture_output=True,
+                text=True,
+                timeout=15,
+                check=False,
+            )
+            status = defender.stdout.strip() or defender.stderr.strip() or "(unknown)"
+            sections.append(f"Defender real-time protection enabled: {status}")
+        except Exception as error:
+            sections.append(f"Defender status check failed: {error}")
+        return "\n\n".join(sections)
+
+    def _number_log_file(self) -> None:
+        """Point --log-file at a fresh numbered file: NVDA truncates it on every start."""
+        if self._log_file_base is None:
+            return
+        base = self._log_file_base
+        self.log_file = base.with_name(f"{base.stem}-{self._start_count}{base.suffix}")
+        flag = f"--log-file={self.log_file}"
+        self.argv = [flag if arg.startswith("--log-file=") else arg for arg in self.argv]
+
+    def start(self, timeout: float = 60) -> Handshake:
+        deadline_seconds = timeout * self.timeout_scale
+        self.out_dir.mkdir(parents=True, exist_ok=True)
+        self.handshake_path.unlink(missing_ok=True)
+        self._handshake = None
+        self._start_count += 1
+        self._number_log_file()
+
+        self._proc = subprocess.Popen(self.argv, env=self._environment())
+
+        deadline = time.monotonic() + deadline_seconds
+        while time.monotonic() < deadline:
+            exit_code = self._proc.poll()
+            if exit_code is not None:
+                raise NvdaStartupError(
+                    f"NVDA exited with code {exit_code} before handshaking.\n"
+                    f"Command: {' '.join(self.argv)}\n"
+                    f"Log tail:\n{self.log_tail()}"
+                )
+            if self.handshake_path.is_file():
+                try:
+                    payload = json.loads(self.handshake_path.read_text(encoding="utf-8"))
+                except json.JSONDecodeError:
+                    time.sleep(_POLL_INTERVAL)
+                    continue
+                self._handshake = Handshake.from_payload(payload)
+                return self._handshake
+            time.sleep(_POLL_INTERVAL)
+
+        diagnostics = self._hang_diagnostics()
+        self.kill()
+        raise HandshakeTimeout(
+            f"NVDA started but never announced itself within {deadline_seconds:.1f}s. "
+            f"Expected {self.handshake_path}. Is the spy add-on installed and enabled?\n"
+            f"Log tail:\n{self.log_tail()}" + (f"\n\n{diagnostics}" if diagnostics else "")
+        )
+
+    def _request_quit(self) -> None:
+        if self._quit_via == "rpc":
+            if self._handshake is None:
+                return
+            import xmlrpc.client
+
+            proxy = xmlrpc.client.ServerProxy(
+                f"http://127.0.0.1:{self._handshake.port}", allow_none=True
+            )
+            with contextlib.suppress(Exception):  # any failure here just falls through to kill
+                proxy.quit(self.token)
+            return
+        # Both branches must fall through to kill(). A --quit that itself
+        # hangs is exactly the case that guarantee exists for.
+        with contextlib.suppress(OSError, subprocess.TimeoutExpired):
+            subprocess.run(
+                [self.argv[0], "--quit"],
+                capture_output=True,
+                check=False,
+                timeout=30 * self.timeout_scale,
+            )
+
+    def quit(self, timeout: float = 30) -> None:
+        if self._proc is None:
+            return
+        if self._proc.poll() is not None:
+            self._proc = None
+            return
+
+        self._request_quit()
+
+        deadline = time.monotonic() + timeout * self.timeout_scale
+        while time.monotonic() < deadline:
+            if self._proc.poll() is not None:
+                self._proc = None
+                return
+            time.sleep(_POLL_INTERVAL)
+        # An NVDA that will not leave is still an NVDA holding the desktop
+        # session hostage for every later test. Kill it.
+        self.kill()
+
+    def kill(self) -> None:
+        if self._proc is None:
+            return
+        if self._proc.poll() is None:
+            self._proc.kill()
+            # kill() is called from except-handlers; a reap that times out here
+            # would replace the original failure (and its log tail) with itself.
+            with contextlib.suppress(subprocess.TimeoutExpired):
+                self._proc.wait(timeout=30)
+        self._proc = None
+        self._handshake = None
+
+    def restart(self, timeout: float = 60) -> Handshake:
+        self.quit(timeout=timeout)
+        return self.start(timeout=timeout)

nvda_testkit/provisioning.py

@@ -0,0 +1,106 @@
+"""Assemble a running NVDA from settings.
+
+Two paths: the real one, which needs Windows, and the FakeNvda one, which is
+how the kit's own tests and a Linux developer exercise everything above the
+transport.
+"""
+
+from __future__ import annotations
+
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+from .download import ensure_launcher
+from .errors import UnsupportedPlatformError
+from .portable import create_portable, extract_addon
+from .process import NvdaProcess, new_token, nvda_argv
+from .resolve import resolve_launcher
+from .rpcclient import RpcClient
+from .settings import TestkitSettings
+from .spybundle import require_spy_bundle
+
+SPY_ADDON_DIRNAME = "nvda-testkit-spy"
+
+
+class Provisioned:
+    """A running NVDA plus everything needed to tear it down."""
+
+    def __init__(self, process: NvdaProcess, rpc: RpcClient, workdir: Path, keep: bool) -> None:
+        self.process = process
+        self.rpc = rpc
+        self.workdir = workdir
+        self.keep = keep
+
+    def teardown(self) -> None:
+        # rpc.close() must never be able to strand a live NVDA process: if it
+        # raises, process.quit() (and then cleanup) must still run.
+        try:
+            self.rpc.close()
+        finally:
+            try:
+                self.process.quit(timeout=30)
+            finally:
+                if not self.keep:
+                    shutil.rmtree(self.workdir, ignore_errors=True)
+
+
+def provision_fake(settings: TestkitSettings, fake_script: Path) -> Provisioned:
+    workdir = Path(tempfile.mkdtemp(prefix="nvda-testkit-fake-"))
+    out_dir = workdir / "out"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    token = new_token()
+    process = NvdaProcess(
+        [sys.executable, str(fake_script)],
+        out_dir,
+        token=token,
+        quit_via="rpc",
+        timeout_scale=settings.timeout_scale,
+    )
+    try:
+        handshake = process.start(timeout=60)
+        rpc = RpcClient.from_handshake(handshake, token=token, timeout_scale=settings.timeout_scale)
+    except Exception:
+        # Any failure past this point -- not just the timeout process.start()
+        # already guards -- must not leave the subprocess running.
+        process.kill()
+        raise
+    return Provisioned(process, rpc, workdir, keep=settings.keep_portable)
+
+
+def provision(settings: TestkitSettings) -> Provisioned:
+    if sys.platform != "win32":
+        raise UnsupportedPlatformError(
+            "Driving a real NVDA needs Windows. On Linux, point the plugin at the "
+            "FakeNvda double with --nvda-fake to exercise everything above the transport."
+        )
+    info = resolve_launcher(settings.channel)
+    launcher = ensure_launcher(info)
+
+    workdir = Path(tempfile.mkdtemp(prefix="nvda-testkit-"))
+    # Resolved here too, not just in NvdaProcess, so log_file below is absolute:
+    # NVDA chdirs into its own directory before it opens either of them.
+    out_dir = settings.out_dir.resolve()
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    portable = create_portable(launcher, workdir / "nvda")
+    extract_addon(require_spy_bundle(), portable.addons_dir / SPY_ADDON_DIRNAME)
+
+    log_file = out_dir / "nvda.log"
+    token = new_token()
+    process = NvdaProcess(
+        nvda_argv(portable, log_file),
+        out_dir,
+        token=token,
+        log_file=log_file,
+        quit_via="exe",
+        timeout_scale=settings.timeout_scale,
+    )
+    try:
+        handshake = process.start(timeout=120)
+        rpc = RpcClient.from_handshake(handshake, token=token, timeout_scale=settings.timeout_scale)
+    except Exception:
+        process.kill()
+        raise
+    return Provisioned(process, rpc, workdir, keep=settings.keep_portable)