verifiers 0.3.2.dev105__tar.gz → 0.3.2.dev107__tar.gz

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev105
+Version: 0.3.2.dev107
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/pyproject.toml

@@ -227,6 +227,8 @@ markers = [
     # per axis, so it matches every case touching that value on any axis.
     "subprocess: v1 e2e cases touching the subprocess (host) runtime",
     "docker: v1 e2e cases touching the docker runtime",
+    "podman: v1 e2e cases touching the podman runtime",
+    "apptainer: v1 e2e cases touching the apptainer runtime",
     "prime: v1 e2e cases touching the prime runtime (real sandbox + tunnel; local-only, excluded in CI)",
     "modal: v1 e2e cases touching the modal runtime (local-only setup; excluded in CI)",
     "colocated: v1 e2e cases with a user/tool server colocated in the harness runtime",

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/tests/v1/conftest.py

@@ -24,7 +24,7 @@ Every combination carries its axes' pytest marks, so subsets select with `-m`:
     uv run pytest tests/v1 -n auto -m prime                       # only prime (real sandboxes; local)
     uv run pytest tests/v1 -n auto -m modal                       # only modal (needs local setup)
 
-Marks: runtimes `subprocess` / `docker` / `prime` / `modal`, placement `colocated`,
+Marks: runtimes `subprocess` / `docker` / `podman` / `apptainer` / `prime` / `modal`, placement `colocated`,
 harnesses `null` / `bash` / `rlm` / `kimi_code` / `pi` / `openclaw` / `codex` /
 `claude_code` / `hermes_agent`.
 A mark is applied per axis, so it selects every case touching that value on ANY axis; for one exact

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/tests/v1/test_e2e.py

@@ -5,6 +5,7 @@ combinations a test runs — every axis value at least once plus the cross-bound
 with distinct networking — instead of fanning the full cross product. prime/modal rows
 are local-only (their marks are excluded in CI)."""
 
+import shutil
 import subprocess
 import sys
 
@@ -115,6 +116,15 @@ CHAT_PLACEMENTS = [
 # remote row per provider.
 AGENTIC_PLACEMENTS = [
     pair("bash", "subprocess", "bash-harness-in-subprocess"),
+    *[
+        pair(
+            "bash",
+            engine,
+            f"bash-harness-in-{engine}",
+            mark.skipif(shutil.which(engine) is None, reason=f"needs {engine}"),
+        )
+        for engine in ("podman", "apptainer")
+    ],
     pair("rlm", "docker", "rlm-harness-in-docker"),
     pytest.param(
         {"id": "kimi-code", "transport": "responses"},
@@ -148,6 +158,15 @@ USER_RUNTIMES = [
 # retain MCP access after resuming. Cover every harness in the local container runtime,
 # plus remote placements for the sandbox/tunnel and native-process boundaries.
 ACP_RESUME_PLACEMENTS = [
+    *[
+        pair(
+            "rlm",
+            engine,
+            f"rlm-acp-in-{engine}",
+            mark.skipif(shutil.which(engine) is None, reason=f"needs {engine}"),
+        )
+        for engine in ("podman", "apptainer")
+    ],
     pair("codex", "docker", "codex-acp-in-docker"),
     pair("claude-code", "docker", "claude-code-acp-in-docker"),
     pair("hermes-agent", "docker", "hermes-agent-acp-in-docker"),
@@ -178,6 +197,15 @@ ACP_RESUME_PLACEMENTS = [
 # (harness and tool in separate docker boxes) and a prime-colocated row (a tool in its
 # OWN prime sandbox needs port exposure; colocated rides the harness's box).
 TOOL_PLACEMENTS = [
+    *[
+        pair(
+            "subprocess",
+            engine,
+            f"harness-in-subprocess-with-tool-in-{engine}",
+            mark.skipif(shutil.which(engine) is None, reason=f"needs {engine}"),
+        )
+        for engine in ("podman", "apptainer")
+    ],
     pair("subprocess", "colocated", "harness-in-subprocess-with-tool-colocated"),
     pair("docker", "colocated", "harness-in-docker-with-tool-colocated"),
     pair("subprocess", "docker", "harness-in-subprocess-with-tool-in-docker"),

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/verifiers/v1/__init__.py

@@ -73,7 +73,9 @@ from verifiers.v1.mcp import (
     ToolsetConfig,
 )
 from verifiers.v1.runtimes import (
+    ApptainerConfig,
     DockerConfig,
+    PodmanConfig,
     PrimeConfig,
     ProgramResult,
     Runtime,
@@ -301,6 +303,8 @@ __all__ = [  # noqa: RUF022 - grouped by public API area
     "ProgramResult",
     "SubprocessConfig",
     "DockerConfig",
+    "PodmanConfig",
+    "ApptainerConfig",
     "PrimeConfig",
     "Env",
     "SingleAgentEnv",

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/verifiers/v1/harnesses/browser_use/harness.py

@@ -1,6 +1,8 @@
 from pathlib import Path
 from typing import Literal
+from urllib.parse import urlsplit
 
+import httpx
 from pydantic import model_validator
 
 from verifiers.v1.clients import ModelContext
@@ -92,7 +94,18 @@ class BrowserUseHarness(Harness[BrowserUseHarnessConfig]):
             f"--state-dir={state}",
         ]
         if self.config.cdp_url:
-            args.append(f"--cdp-url={self.config.cdp_url}")
+            cdp_url = runtime.host_url(self.config.cdp_url)
+            if cdp_url != self.config.cdp_url and urlsplit(
+                self.config.cdp_url
+            ).scheme in ("http", "https"):
+                # CDP discovery returns a host-side WebSocket URL; translate that too.
+                async with httpx.AsyncClient() as client:
+                    response = await client.get(
+                        f"{self.config.cdp_url.rstrip('/')}/json/version"
+                    )
+                    response.raise_for_status()
+                cdp_url = runtime.host_url(response.json()["webSocketDebuggerUrl"])
+            args.append(f"--cdp-url={cdp_url}")
         return await launch_chat_program(
             PROGRAM_SOURCE,
             self.config,

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/verifiers/v1/mcp/launch.py

@@ -28,7 +28,7 @@ from verifiers.v1.mcp.server import (
 )
 from verifiers.v1.runtimes import (
     Runtime,
-    make_runtime,
+    provision_runtime,
 )
 from verifiers.v1.runtimes.base import _ENSURE_UV
 from verifiers.v1.state import State
@@ -269,7 +269,7 @@ async def serve_in_runtime(
         # Keep provider temp files in the runtime workdir so cleanup removes them.
         assert runtime.info.id is not None
         env["TMPDIR"] = runtime.info.id
-    if runtime.published_port is not None:
+    if exposed and runtime.published_port is not None:
         env["MCP_HOST"] = "0.0.0.0"
     fixed = runtime.published_port if exposed else None
     port_file = None
@@ -318,17 +318,18 @@ async def reachable_url(
     runtime; `consumer_is_local` = the consumer can use a host-local URL without a tunnel.
 
     - `colocated` -> localhost (same runtime, in-sandbox or host loopback);
-    - the server runs in a remote sandbox -> its own published URL (`expose`), reachable anywhere;
-    - else it's host-local -> localhost to a local consumer, a host tunnel to a remote one."""
+    - else the runtime publishes the port (`expose`): a remote sandbox's URL is reachable
+      anywhere, a host-local URL directly by a local consumer and through a host tunnel
+      by a remote one."""
     if colocated:
         yield f"http://127.0.0.1:{port}"
-    elif not service.is_local:  # in a remote sandbox → it publishes its own port
-        yield await service.expose(port)
-    elif consumer_is_local:  # local consumer → localhost, no public tunnel
-        yield f"http://127.0.0.1:{port}"
-    else:  # remote consumer → a host tunnel publishes the port outward
-        async with PrimeTunnel().expose(port) as url:
-            yield url
+        return
+    url = await service.expose(port)
+    if service.is_local and not consumer_is_local:
+        async with PrimeTunnel().expose(urlsplit(url).port or 80) as public:
+            yield public
+    else:
+        yield url
 
 
 @dataclass(frozen=True)
@@ -365,9 +366,7 @@ async def _serve(
         if colocated and harness_runtime is not None:
             runtime = harness_runtime
         else:
-            runtime = make_runtime(cfg.runtime)
-            await runtime.start()
-            stack.push_async_callback(runtime.stop)
+            runtime = await stack.enter_async_context(provision_runtime(cfg.runtime))
         # Only consumers outside the server runtime need its fixed published port. Colocated tools
         # use independent OS-assigned ports, avoiding clashes on the runtime's service port.
         exposed = runtime is not harness_runtime
@@ -376,7 +375,7 @@ async def _serve(
         # whenever any consumer is remote). Eval-level shared servers get no per-rollout channel
         # (`state_base` is None for them).
         state_url = (
-            f"{runtime.host_url(state_base.rstrip('/'))}/state" if state_base else None
+            runtime.host_url(f"{state_base.rstrip('/')}/state") if state_base else None
         )
         port = await serve_in_runtime(
             server,

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/verifiers/v1/rollout.py

@@ -256,7 +256,7 @@ class Rollout:
                     self._shared_tools,
                 )
             )
-            self._endpoint = f"{runtime.host_url(base_url)}/v1"
+            self._endpoint = runtime.host_url(f"{base_url.rstrip('/')}/v1")
             self._secret = model_secret
             self._urls = await self._stack.enter_async_context(
                 serve_tools(
@@ -314,7 +314,11 @@ class Rollout:
                     )
                 if not self._session.stopped:
                     session_kwargs = (
-                        {"tool_interception_url": f"{runtime.host_url(base_url)}/tool"}
+                        {
+                            "tool_interception_url": runtime.host_url(
+                                f"{base_url.rstrip('/')}/tool"
+                            )
+                        }
                         if self.harness.SUPPORTS_TOOL_INTERCEPTION
                         and (
                             self._session.request_interceptors

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/verifiers/v1/runtimes/__init__.py

@@ -5,6 +5,11 @@ from typing import Annotated
 from pydantic import Field
 
 from verifiers.v1.configs.runtime import NetworkPolicyConfig
+from verifiers.v1.runtimes.apptainer import (
+    ApptainerConfig,
+    ApptainerRuntime,
+    ApptainerRuntimeInfo,
+)
 from verifiers.v1.runtimes.base import (
     BaseRuntimeInfo,
     ProgramResult,
@@ -12,7 +17,14 @@ from verifiers.v1.runtimes.base import (
     RuntimeProcess,
     register,
 )
-from verifiers.v1.runtimes.docker import DockerConfig, DockerRuntime, DockerRuntimeInfo
+from verifiers.v1.runtimes.docker import (
+    DockerConfig,
+    DockerRuntime,
+    DockerRuntimeInfo,
+    PodmanConfig,
+    PodmanRuntime,
+    PodmanRuntimeInfo,
+)
 from verifiers.v1.runtimes.modal import ModalConfig, ModalRuntime, ModalRuntimeInfo
 from verifiers.v1.runtimes.prime import (
     PrimeConfig,
@@ -27,24 +39,35 @@ from verifiers.v1.runtimes.subprocess import (
 )
 
 RuntimeConfig = Annotated[
-    SubprocessConfig | DockerConfig | PrimeConfig | ModalConfig,
+    SubprocessConfig
+    | DockerConfig
+    | PodmanConfig
+    | ApptainerConfig
+    | PrimeConfig
+    | ModalConfig,
     Field(discriminator="type"),
 ]
 
 RuntimeInfo = Annotated[
-    SubprocessRuntimeInfo | DockerRuntimeInfo | PrimeRuntimeInfo | ModalRuntimeInfo,
+    SubprocessRuntimeInfo
+    | DockerRuntimeInfo
+    | PodmanRuntimeInfo
+    | ApptainerRuntimeInfo
+    | PrimeRuntimeInfo
+    | ModalRuntimeInfo,
     Field(discriminator="type"),
 ]
 
 
 def _runtime_cls(config: RuntimeConfig) -> type[Runtime]:
-    if isinstance(config, PrimeConfig):
-        return PrimeRuntime
-    if isinstance(config, ModalConfig):
-        return ModalRuntime
-    if isinstance(config, DockerConfig):
-        return DockerRuntime
-    return SubprocessRuntime
+    return {
+        "subprocess": SubprocessRuntime,
+        "docker": DockerRuntime,
+        "podman": PodmanRuntime,
+        "apptainer": ApptainerRuntime,
+        "prime": PrimeRuntime,
+        "modal": ModalRuntime,
+    }[config.type]
 
 
 def make_runtime(config: RuntimeConfig, name: str | None = None) -> Runtime:
@@ -79,6 +102,9 @@ def runtime_is_local(config: RuntimeConfig) -> bool:
 
 
 __all__ = [
+    "ApptainerConfig",
+    "ApptainerRuntime",
+    "ApptainerRuntimeInfo",
     "BaseRuntimeInfo",
     "DockerConfig",
     "DockerRuntime",
@@ -87,6 +113,9 @@ __all__ = [
     "ModalRuntime",
     "ModalRuntimeInfo",
     "NetworkPolicyConfig",
+    "PodmanConfig",
+    "PodmanRuntime",
+    "PodmanRuntimeInfo",
     "PrimeConfig",
     "PrimeRuntime",
     "PrimeRuntimeInfo",

verifiers-0.3.2.dev107/verifiers/v1/runtimes/apptainer.py

@@ -0,0 +1,214 @@
+"""Local Apptainer runtime: an unprivileged instance sharing the host network."""
+
+import asyncio
+import contextlib
+import hashlib
+import logging
+import shutil
+import subprocess
+import tempfile
+import uuid
+from pathlib import Path
+from typing import ClassVar, Literal, Self
+from weakref import WeakValueDictionary
+
+from pydantic import model_validator
+
+from verifiers.v1.errors import SandboxError
+from verifiers.v1.runtimes.base import BaseRuntimeInfo, parse_gpu
+from verifiers.v1.runtimes.container import ContainerConfig, ContainerRuntime, cli
+from verifiers.v1.utils.paths import CACHE_DIR
+
+logger = logging.getLogger(__name__)
+
+_ROOT = CACHE_DIR / "runtimes" / "apptainer"
+
+
+class ApptainerConfig(ContainerConfig):
+    type: Literal["apptainer"] = "apptainer"
+    """Apptainer has no egress policy: instances run unprivileged on the host network,
+    as on HPC clusters without Docker. `image` is a Docker reference (pulled to a SIF
+    once per reference), any `scheme://` URI Apptainer can pull, or a local SIF path."""
+
+    @model_validator(mode="after")
+    def validate_workdir(self) -> Self:
+        if self.workdir is not None and (
+            not self.workdir.startswith("/")
+            or Path(self.workdir) == Path("/")
+            or ".." in Path(self.workdir).parts
+            or any(char in self.workdir for char in ":,")
+        ):
+            raise ValueError(
+                "Apptainer workdir must be an absolute non-root path without '..', ':' or ','"
+            )
+        return self
+
+
+class ApptainerRuntimeInfo(ApptainerConfig, BaseRuntimeInfo):
+    pass
+
+
+class ApptainerRuntime(ContainerRuntime):
+    _pulls: ClassVar[
+        WeakValueDictionary[tuple[asyncio.AbstractEventLoop, str], asyncio.Lock]
+    ] = WeakValueDictionary()
+
+    def __init__(self, config: ApptainerConfig, name: str | None = None) -> None:
+        super().__init__(name)
+        self.config = config.model_copy(update={"workdir": config.workdir or "/app"})
+        self.info = ApptainerRuntimeInfo(**self.config.model_dump())
+        # Apptainer names are user-global; never stop an instance named by a caller.
+        self._instance = f"vf-{uuid.uuid4().hex}"
+        self._dir: Path | None = None  # host backing for the workspace, /tmp and $HOME
+        self._stopped = False
+
+    def _exec(self, env: dict[str, str], *, stdin: bool = False) -> list[str]:
+        # `--env` is a comma-separated map flag, so values pass through `env` inside.
+        return [
+            "apptainer",
+            "exec",
+            "--cleanenv",
+            "--no-eval",
+            "--cwd",
+            self.config.workdir,
+            f"instance://{self._instance}",
+            "env",
+            *(f"{key}={value}" for key, value in env.items()),
+        ]
+
+    async def start(self) -> None:
+        try:
+            version = await cli("apptainer", "version")
+        except FileNotFoundError as e:
+            raise RuntimeError(
+                "apptainer runtime selected but the `apptainer` CLI is not installed"
+            ) from e
+        if version.exit_code != 0:
+            detail = (version.stderr or version.stdout).strip()
+            raise RuntimeError(
+                f"apptainer runtime selected but Apptainer is not usable: {detail}"
+            )
+        self._dir = Path(tempfile.mkdtemp(prefix="vf-apptainer-"))
+        (self._dir / "workspace").mkdir()
+        (self._dir / "session").mkdir()
+        # Bind targets below a contained directory must also exist in its backing tree.
+        workdir = Path(self.config.workdir)
+        for parent, backing in (
+            (Path("/tmp"), "tmp"),
+            (Path("/var/tmp"), "var_tmp"),
+            (Path.home(), "home"),
+        ):
+            if workdir.is_relative_to(parent):
+                (self._dir / "session" / backing / workdir.relative_to(parent)).mkdir(
+                    parents=True, exist_ok=True
+                )
+        image = await self._image()
+        inspected = await cli("apptainer", "inspect", "--startscript", image)
+        # Apptainer's default startscript contains only a shebang and comments.
+        if inspected.exit_code or any(
+            line.strip() and not line.lstrip().startswith("#")
+            for line in inspected.stdout.splitlines()
+        ):
+            raise SandboxError("Apptainer requires an image without a startscript")
+        containment = [
+            "--cleanenv",
+            "--containall",
+            "--no-mount",
+            "cwd,hostfs,bind-paths",
+            "--no-eval",
+        ]
+        # Seed the writable bind from the image before it hides the original workdir.
+        destination = f"/{self._instance}"
+        copied = await cli(
+            "apptainer",
+            "exec",
+            *containment,
+            "--no-mount",
+            "home,tmp",
+            "--bind",
+            f"{self._dir / 'workspace'}:{destination}",
+            image,
+            "sh",
+            "-c",
+            'if [ -d "$1" ]; then cp -R -P "$1"/. "$2"/; fi',
+            "vf-workspace",
+            self.config.workdir,
+            destination,
+        )
+        if copied.exit_code != 0:
+            raise SandboxError(
+                f"apptainer workdir copy failed: {copied.stderr.strip()}"
+            )
+        limits: list[str] = []
+        if self.config.cpu is not None:
+            limits += ["--cpus", str(self.config.cpu)]
+        if self.config.memory is not None:
+            limits += ["--memory", f"{self.config.memory}g"]
+        if parse_gpu(self.config.gpu)[1]:
+            limits += ["--nv"]
+        started = await cli(
+            "apptainer",
+            "instance",
+            "start",
+            *containment,
+            # A contained /tmp and $HOME live in tmpfs unless a workdir backs them.
+            "--workdir",
+            str(self._dir / "session"),
+            "--writable-tmpfs",
+            "--bind",
+            f"{self._dir / 'workspace'}:{self.config.workdir}",
+            *limits,
+            image,
+            self._instance,
+        )
+        if started.exit_code != 0:
+            raise SandboxError(
+                f"apptainer instance start failed: {started.stderr.strip()}"
+            )
+        self.info.id = self._instance
+        logger.info(
+            "apptainer: started instance %s (image=%s)", self.name, self.config.image
+        )
+
+    async def _image(self) -> str:
+        """The SIF to run: a local file as is, else the reference pulled once into the
+        cache, like a container engine keeping a pulled image."""
+        local = Path(self.config.image).expanduser()
+        if local.is_file():
+            return str(local)
+        image = self.config.image
+        ref = image if "://" in image else f"docker://{image}"
+        sif = _ROOT / "images" / f"{hashlib.sha256(ref.encode()).hexdigest()}.sif"
+        async with self._pulls.setdefault(
+            (asyncio.get_running_loop(), ref), asyncio.Lock()
+        ):
+            if not sif.exists():
+                sif.parent.mkdir(parents=True, exist_ok=True)
+                # Pull to a unique path and publish it atomically, so concurrent
+                # workers never read a half-written SIF.
+                tmp = sif.with_name(f"{uuid.uuid4().hex}.sif")
+                try:
+                    pulled = await cli("apptainer", "pull", str(tmp), ref)
+                    if pulled.exit_code != 0:
+                        raise SandboxError(
+                            f"apptainer pull {ref} failed: {pulled.stderr.strip()}"
+                        )
+                    tmp.replace(sif)
+                finally:
+                    tmp.unlink(missing_ok=True)
+        return str(sif)
+
+    def cleanup(self) -> None:
+        if self._dir is None or self._stopped:
+            return
+        self._stopped = True
+        logger.debug("apptainer: stopping instance %s", self.name)
+        with contextlib.suppress(Exception):
+            subprocess.run(
+                ["apptainer", "instance", "stop", "--force", self._instance],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=30,
+                check=False,
+            )
+        shutil.rmtree(self._dir, ignore_errors=True)

{verifiers-0.3.2.dev105 → verifiers-0.3.2.dev107}/verifiers/v1/runtimes/base.py

@@ -45,9 +45,9 @@ _ENSURE_UV = (
     f"|| {{ {_INSTALL_CURL}; {_DOWNLOAD_UV}; }}"
 )
 
-# The single port a self-publishing runtime (modal/prime) forwards to a public URL for a server
-# hosted in its sandbox. A server placed in such a runtime binds this (on 0.0.0.0) and is reached
-# at the runtime's public URL.
+# The single port a sandbox runtime forwards out for a server hosted in it: a public URL on
+# modal/prime, a host loopback port on the local container engines. A server placed in such
+# a runtime binds this (on 0.0.0.0) and is reached at the URL `expose` returns.
 SERVICE_PORT = 8000
 
 
@@ -136,8 +136,8 @@ class Runtime(ABC):
 
     is_local: ClassVar[bool] = True
     """Whether this runtime exchanges host-local URLs without a public tunnel. True for
-    subprocess and Docker (directly or through Docker's policy proxy); remote runtimes
-    override to False and use a host `Tunnel` inward plus `expose` outward."""
+    subprocess and the local container runtimes; remote runtimes override to False and
+    use a host `Tunnel` inward plus `expose` outward."""
 
     scripts_dir: ClassVar[str] = "/tmp/vf-scripts"
     """Digest-keyed PEP 723 scripts inside the runtime. Sandboxes own their `/tmp`;
@@ -397,13 +397,14 @@ class Runtime(ABC):
         """A fixed port this runtime exposes to the outside at startup, declared up front to the
         provider (Modal forwards only ports named at `Sandbox.create`). When set, a server placed
         here binds it instead of a host-chosen free port, and `expose` returns its public URL.
-        `None` for local runtimes (subprocess/docker), which pick a free port."""
+        `None` for runtimes whose services already sit on host loopback (subprocess,
+        apptainer), which pick a free port."""
         return None
 
-    async def expose(self, port: int) -> str | None:
-        """Publish a port running *inside this runtime* to a URL reachable from the host/outside,
-        or None when local. A remote runtime overrides this with the provider's native port
-        exposure (modal `tunnels()`, prime `client.expose`), torn down with the sandbox in
-        `stop()`. The reverse of a host `Tunnel` (interception.tunnel, which reaches a host
-        port from inside a runtime)."""
-        return None
+    async def expose(self, port: int) -> str:
+        """Publish a port running *inside this runtime* to a URL reachable from the host/outside.
+        A runtime on the host network is reached at host loopback as is; a sandbox overrides
+        this with its port exposure (modal `tunnels()`, prime `client.expose`, a container
+        engine's published port), torn down with the sandbox in `stop()`. The reverse of a
+        host `Tunnel` (interception.tunnel, which reaches a host port from inside a runtime)."""
+        return f"http://127.0.0.1:{port}"