isolate 0.12.14__py3-none-any.whl → 0.12.16__py3-none-any.whl

isolate/_isolate_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.12.14'
-__version_tuple__ = version_tuple = (0, 12, 14)
+__version__ = version = '0.12.16'
+__version_tuple__ = version_tuple = (0, 12, 16)

isolate/backends/_base.py

@@ -12,7 +12,6 @@ from typing import (
 )
 
 from isolate.backends.settings import DEFAULT_SETTINGS, IsolateSettings
-from isolate.exceptions import IsolateException
 from isolate.logs import Log, LogLevel, LogSource
 
 __all__ = [
@@ -28,7 +27,7 @@ CallResultType = TypeVar("CallResultType")
 BasicCallable = Callable[[], CallResultType]
 
 
-class EnvironmentCreationError(IsolateException):
+class EnvironmentCreationError(Exception):
     """Raised when the environment cannot be created."""
 
 

isolate/backends/common.py

@@ -171,23 +171,26 @@ def _unblocked_pipe() -> tuple[int, int]:
 def logged_io(
     stdout_hook: HookT,
     stderr_hook: HookT | None = None,
-) -> Iterator[tuple[int, int]]:
+    log_hook: HookT | None = None,
+) -> Iterator[tuple[int, int, int]]:
     """Open two new streams (for stdout and stderr, respectively) and start relaying all
     the output from them to the given hooks."""
 
     stdout_reader_fd, stdout_writer_fd = _unblocked_pipe()
     stderr_reader_fd, stderr_writer_fd = _unblocked_pipe()
+    log_reader_fd, log_writer_fd = _unblocked_pipe()
 
     termination_event = threading.Event()
     io_observer = _io_observer(
         hooks={
             stdout_reader_fd: stdout_hook,
             stderr_reader_fd: stderr_hook or stdout_hook,
+            log_reader_fd: log_hook or stdout_hook,
         },
         termination_event=termination_event,
     )
     try:
-        yield stdout_writer_fd, stderr_writer_fd
+        yield stdout_writer_fd, stderr_writer_fd, log_writer_fd
     finally:
         termination_event.set()
         try:

isolate/backends/conda.py

@@ -171,7 +171,7 @@ class CondaEnvironment(BaseEnvironment[Path]):
 
     def _run_conda(self, *args: Any) -> None:
         conda_executable = get_executable(self._exec_command, self._exec_home)
-        with logged_io(partial(self.log, level=LogLevel.INFO)) as (stdout, stderr):
+        with logged_io(partial(self.log, level=LogLevel.INFO)) as (stdout, stderr, _):
             subprocess.check_call(
                 [conda_executable, *args],
                 stdout=stdout,

isolate/backends/container.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, ClassVar
+
+from isolate.backends import BaseEnvironment
+from isolate.backends.common import sha256_digest_of
+from isolate.backends.settings import DEFAULT_SETTINGS, IsolateSettings
+from isolate.connections import PythonIPC
+
+
+@dataclass
+class ContainerizedPythonEnvironment(BaseEnvironment[Path]):
+    BACKEND_NAME: ClassVar[str] = "container"
+
+    image: dict[str, Any] = field(default_factory=dict)
+    python_version: str | None = None
+    tags: list[str] = field(default_factory=list)
+
+    @classmethod
+    def from_config(
+        cls,
+        config: dict[str, Any],
+        settings: IsolateSettings = DEFAULT_SETTINGS,
+    ) -> BaseEnvironment:
+        environment = cls(**config)
+        environment.apply_settings(settings)
+        return environment
+
+    @property
+    def key(self) -> str:
+        # dockerfile_str is always there, but the validation is handled by the
+        # controller.
+        dockerfile_str = self.image.get("dockerfile_str", "")
+        return sha256_digest_of(dockerfile_str, *sorted(self.tags))
+
+    def create(self, *, force: bool = False) -> Path:
+        return Path(sys.exec_prefix)
+
+    def destroy(self, connection_key: Path) -> None:
+        raise NotImplementedError("ContainerizedPythonEnvironment cannot be destroyed")
+
+    def exists(self) -> bool:
+        return True
+
+    def open_connection(self, connection_key: Path) -> PythonIPC:
+        return PythonIPC(self, connection_key)

isolate/backends/pyenv.py

@@ -80,7 +80,7 @@ class PyenvEnvironment(BaseEnvironment[Path]):
         return Path(prefix.strip())
 
     def _install_python(self, pyenv: Path, root_path: Path) -> None:
-        with logged_io(partial(self.log, level=LogLevel.INFO)) as (stdout, stderr):
+        with logged_io(partial(self.log, level=LogLevel.INFO)) as (stdout, stderr, _):
             try:
                 subprocess.check_call(
                     [pyenv, "install", "--skip-existing", self.python_version],
@@ -102,7 +102,7 @@ class PyenvEnvironment(BaseEnvironment[Path]):
                 return None
 
             pyenv_root = connection_key.parent.parent
-            with logged_io(self.log) as (stdout, stderr):
+            with logged_io(self.log) as (stdout, stderr, _):
                 subprocess.check_call(
                     [pyenv, "uninstall", "-f", connection_key.name],
                     env={**os.environ, "PYENV_ROOT": str(pyenv_root)},

isolate/backends/virtualenv.py

@@ -110,7 +110,7 @@ class VirtualPythonEnvironment(BaseEnvironment[Path]):
         for extra_index_url in self.extra_index_urls:
             pip_cmd.extend(["--extra-index-url", extra_index_url])
 
-        with logged_io(partial(self.log, level=LogLevel.INFO)) as (stdout, stderr):
+        with logged_io(partial(self.log, level=LogLevel.INFO)) as (stdout, stderr, _):
             try:
                 subprocess.check_call(
                     pip_cmd,

isolate/connections/_local/_base.py

@@ -17,7 +17,7 @@ from typing import (
 
 from isolate.backends.common import get_executable_path, logged_io
 from isolate.connections.common import AGENT_SIGNATURE
-from isolate.logs import LogLevel
+from isolate.logs import LogLevel, LogSource
 
 if TYPE_CHECKING:
     from isolate.backends import BaseEnvironment
@@ -113,14 +113,22 @@ class PythonExecutionBase(Generic[ConnectionType]):
 
         python_executable = get_executable_path(self.environment_path, "python")
         with logged_io(
-            partial(self.handle_agent_log, level=LogLevel.STDOUT),
-            partial(self.handle_agent_log, level=LogLevel.STDERR),
-        ) as (stdout, stderr):
+            partial(
+                self.handle_agent_log, source=LogSource.USER, level=LogLevel.STDOUT
+            ),
+            partial(
+                self.handle_agent_log, source=LogSource.USER, level=LogLevel.STDERR
+            ),
+            partial(
+                self.handle_agent_log, source=LogSource.BRIDGE, level=LogLevel.TRACE
+            ),
+        ) as (stdout, stderr, log_fd):
             yield subprocess.Popen(
-                self.get_python_cmd(python_executable, connection),
+                self.get_python_cmd(python_executable, connection, log_fd),
                 env=self.get_env_vars(),
                 stdout=stdout,
                 stderr=stderr,
+                pass_fds=(log_fd,),
                 text=True,
             )
 
@@ -158,11 +166,12 @@ class PythonExecutionBase(Generic[ConnectionType]):
         self,
         executable: Path,
         connection: ConnectionType,
+        log_fd: int,
     ) -> list[str | Path]:
         """Return the command to run the agent process with."""
         raise NotImplementedError
 
-    def handle_agent_log(self, line: str, level: LogLevel) -> None:
+    def handle_agent_log(self, line: str, level: LogLevel, source: LogSource) -> None:
         """Handle a log line emitted by the agent process. The level will be either
         STDOUT or STDERR."""
         raise NotImplementedError

isolate/connections/common.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import importlib
 import os
-from typing import TYPE_CHECKING, Any, cast
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterator, cast
 
 from tblib import Traceback, TracebackParseError
 
-from isolate.exceptions import IsolateException
-
 if TYPE_CHECKING:
     from typing import Protocol
 
@@ -20,18 +20,24 @@ if TYPE_CHECKING:
 AGENT_SIGNATURE = "IS_ISOLATE_AGENT"
 
 
-class BaseSerializationError(IsolateException):
+@dataclass
+class SerializationError(Exception):
     """An error that happened during the serialization process."""
 
-    pass
-
+    message: str
 
-class SerializationError(BaseSerializationError):
-    pass
 
+@contextmanager
+def _step(message: str) -> Iterator[None]:
+    """A context manager to capture every expression
+    underneath it and if any of them fails for any reason
+    then it will raise a SerializationError with the
+    given message."""
 
-class DeserializationError(BaseSerializationError):
-    pass
+    try:
+        yield
+    except BaseException as exception:
+        raise SerializationError("Error while " + message) from exception
 
 
 def as_serialization_method(backend: Any) -> SerializationBackend:
@@ -60,22 +66,13 @@ def load_serialized_object(
     flag is set to true, then the given object will be raised as an exception (instead
     of being returned)."""
 
-    try:
+    with _step(f"preparing the serialization backend ({serialization_method})"):
         serialization_backend = as_serialization_method(
             importlib.import_module(serialization_method)
         )
-    except BaseException as exc:
-        raise DeserializationError(
-            "Error while preparing the serialization backend "
-            f"({serialization_method})"
-        ) from exc
 
-    try:
+    with _step("deserializing the given object"):
         result = serialization_backend.loads(raw_object)
-    except BaseException as exc:
-        raise DeserializationError(
-            "Error while deserializing the given object"
-        ) from exc
 
     if was_it_raised:
         raise prepare_exc(result, stringized_traceback=stringized_traceback)
@@ -87,19 +84,13 @@ def serialize_object(serialization_method: str, object: Any) -> bytes:
     """Serialize the given object using the given serialization method. If
     anything fails, then a SerializationError will be raised."""
 
-    try:
+    with _step(f"preparing the serialization backend ({serialization_method})"):
         serialization_backend = as_serialization_method(
             importlib.import_module(serialization_method)
         )
-    except BaseException as exc:
-        raise SerializationError(
-            f"Error while preparing the serialization backend ({serialization_method})"
-        ) from exc
 
-    try:
+    with _step("serializing the given object"):
         return serialization_backend.dumps(object)
-    except BaseException as exc:
-        raise SerializationError("Error while serializing the given object") from exc
 
 
 def is_agent() -> bool:

isolate/connections/grpc/_base.py

@@ -16,11 +16,10 @@ from isolate.connections.common import serialize_object
 from isolate.connections.grpc import agent, definitions
 from isolate.connections.grpc.configuration import get_default_options
 from isolate.connections.grpc.interface import from_grpc
-from isolate.exceptions import IsolateException
 from isolate.logs import LogLevel, LogSource
 
 
-class AgentError(IsolateException):
+class AgentError(Exception):
     """An internal problem caused by (most probably) the agent."""
 
 
@@ -137,13 +136,17 @@ class LocalPythonGRPC(PythonExecutionBase[str], GRPCExecutionBase):
         self,
         executable: Path,
         connection: str,
+        log_fd: int,
     ) -> List[Union[str, Path]]:
         return [
             executable,
             agent_startup.__file__,
             agent.__file__,
             connection,
+            "--log-fd",
+            str(log_fd),
         ]
 
-    def handle_agent_log(self, line: str, level: LogLevel) -> None:
-        self.log(line, level=level, source=LogSource.USER)
+    def handle_agent_log(self, line: str, level: LogLevel, source: LogSource) -> None:
+        print(f"[{source}] [{level}] {line}")
+        self.log(line, level=level, source=source)

isolate/connections/grpc/agent.py

@@ -2,16 +2,16 @@
 
 from __future__ import annotations
 
+import os
+import sys
 import traceback
 from argparse import ArgumentParser
 from concurrent import futures
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from typing import (
     Any,
-    Generator,
     Iterable,
     Iterator,
-    cast,
 )
 
 import grpc
@@ -21,26 +21,27 @@ from isolate.backends.common import sha256_digest_of
 from isolate.connections.common import SerializationError, serialize_object
 from isolate.connections.grpc import definitions
 from isolate.connections.grpc.configuration import get_default_options
-from isolate.connections.grpc.interface import from_grpc, to_grpc
-from isolate.exceptions import IsolateException
-from isolate.logs import Log, LogLevel, LogSource
+from isolate.connections.grpc.interface import from_grpc
 
 
 @dataclass
-class AbortException(IsolateException):
+class AbortException(Exception):
     message: str
 
 
-@dataclass
 class AgentServicer(definitions.AgentServicer):
-    _run_cache: dict[str, Any] = field(default_factory=dict)
+    def __init__(self, log_fd: int | None = None):
+        super().__init__()
+
+        self._run_cache: dict[str, Any] = {}
+        self._log = sys.stdout if log_fd is None else os.fdopen(log_fd, "w")
 
     def Run(
         self,
         request: definitions.FunctionCall,
         context: ServicerContext,
     ) -> Iterator[definitions.PartialRunResult]:
-        yield from self.log(f"A connection has been established: {context.peer()}!")
+        self.log(f"A connection has been established: {context.peer()}!")
 
         extra_args = []
         if request.HasField("setup_func"):
@@ -54,16 +55,16 @@ class AgentServicer(definitions.AgentServicer):
                         result,
                         was_it_raised,
                         stringized_tb,
-                    ) = yield from self.execute_function(
+                    ) = self.execute_function(
                         request.setup_func,
                         "setup",
                     )
 
                     if was_it_raised:
-                        yield from self.log(
+                        self.log(
                             "The setup function has thrown an error. Aborting the run."
                         )
-                        yield from self.send_object(
+                        yield self.send_object(
                             request.setup_func.method,
                             result,
                             was_it_raised,
@@ -79,12 +80,12 @@ class AgentServicer(definitions.AgentServicer):
             extra_args.append(self._run_cache[cache_key])
 
         try:
-            result, was_it_raised, stringized_tb = yield from self.execute_function(
+            result, was_it_raised, stringized_tb = self.execute_function(
                 request.function,
                 "function",
                 extra_args=extra_args,
             )
-            yield from self.send_object(
+            yield self.send_object(
                 request.function.method,
                 result,
                 was_it_raised,
@@ -99,7 +100,7 @@ class AgentServicer(definitions.AgentServicer):
         function_kind: str,
         *,
         extra_args: Iterable[Any] = (),
-    ) -> Generator[definitions.PartialRunResult, None, Any]:
+    ) -> tuple[Any, bool, str | None]:
         if function.was_it_raised:
             raise AbortException(
                 f"The {function_kind} function must be callable, "
@@ -107,11 +108,14 @@ class AgentServicer(definitions.AgentServicer):
             )
 
         try:
-            # NOTE: technically any sort of exception could be raised here, since
+            # TODO: technically any sort of exception could be raised here, since
             # depickling is basically involves code execution from the *user*.
             function = from_grpc(function)
-        except BaseException as exc:
-            return exc, True, traceback.format_exc()
+        except SerializationError:
+            self.log(traceback.format_exc())
+            raise AbortException(
+                f"The {function_kind} function could not be deserialized."
+            )
 
         if not callable(function):
             raise AbortException(
@@ -119,7 +123,7 @@ class AgentServicer(definitions.AgentServicer):
                 f"not {type(function).__name__}."
             )
 
-        yield from self.log(f"Starting the execution of the {function_kind} function.")
+        self.log(f"Starting the execution of the {function_kind} function.")
 
         was_it_raised = False
         stringized_tb = None
@@ -131,7 +135,7 @@ class AgentServicer(definitions.AgentServicer):
             num_frames = len(traceback.extract_stack()[:-5])
             stringized_tb = "".join(traceback.format_exc(limit=-num_frames))
 
-        yield from self.log(f"Completed the execution of the {function_kind} function.")
+        self.log(f"Completed the execution of the {function_kind} function.")
         return result, was_it_raised, stringized_tb
 
     def send_object(
@@ -140,46 +144,38 @@ class AgentServicer(definitions.AgentServicer):
         result: object,
         was_it_raised: bool,
         stringized_tb: str | None,
-    ) -> Generator[definitions.PartialRunResult, None, Any]:
+    ) -> definitions.PartialRunResult:
         try:
             definition = serialize_object(serialization_method, result)
         except SerializationError:
             if stringized_tb:
-                yield from self.log(
-                    stringized_tb, source=LogSource.USER, level=LogLevel.STDERR
-                )
+                print(stringized_tb, file=sys.stderr)
             raise AbortException(
                 "Error while serializing the execution result "
                 f"(object of type {type(result)})."
             )
         except BaseException:
-            yield from self.log(traceback.format_exc(), level=LogLevel.ERROR)
+            self.log(traceback.format_exc())
             raise AbortException(
                 "An unexpected error occurred while serializing the result."
             )
 
-        yield from self.log("Sending the result.")
+        self.log("Sending the result.")
         serialized_obj = definitions.SerializedObject(
             method=serialization_method,
             definition=definition,
             was_it_raised=was_it_raised,
             stringized_traceback=stringized_tb,
         )
-        yield definitions.PartialRunResult(
+        return definitions.PartialRunResult(
             result=serialized_obj,
             is_complete=True,
             logs=[],
         )
 
-    def log(
-        self,
-        message: str,
-        level: LogLevel = LogLevel.TRACE,
-        source: LogSource = LogSource.BRIDGE,
-    ) -> Iterator[definitions.PartialRunResult]:
-        log = to_grpc(Log(message, level=level, source=source))
-        log = cast(definitions.Log, log)
-        yield definitions.PartialRunResult(result=None, is_complete=False, logs=[log])
+    def log(self, message: str) -> None:
+        self._log.write(message)
+        self._log.flush()
 
     def abort_with_msg(
         self,
@@ -209,10 +205,10 @@ def create_server(address: str) -> grpc.Server:
     return server
 
 
-def run_agent(address: str) -> int:
+def run_agent(address: str, log_fd: int | None = None) -> int:
     """Run the agent servicer on the given address."""
     server = create_server(address)
-    servicer = AgentServicer()
+    servicer = AgentServicer(log_fd=log_fd)
 
     # This function just calls some methods on the server
     # and register a generic handler for the bridge. It does
@@ -227,9 +223,10 @@ def run_agent(address: str) -> int:
 def main() -> int:
     parser = ArgumentParser()
     parser.add_argument("address", type=str)
+    parser.add_argument("--log-fd", type=int)
 
     options = parser.parse_args()
-    return run_agent(options.address)
+    return run_agent(options.address, log_fd=options.log_fd)
 
 
 if __name__ == "__main__":

isolate/connections/ipc/_base.py

@@ -202,6 +202,7 @@ class PythonIPC(PythonExecutionBase[AgentListener], IsolatedProcessConnection):
         self,
         executable: Path,
         connection: AgentListener,
+        log_fd: int,
     ) -> list[str | Path]:
         assert isinstance(connection.address, tuple)
         return [
@@ -214,21 +215,9 @@ class PythonIPC(PythonExecutionBase[AgentListener], IsolatedProcessConnection):
             # the connection with the bridge.
             "--serialization-backend",
             self.environment.settings.serialization_method,
+            "--log-fd",
+            str(log_fd),
         ]
 
-    def handle_agent_log(self, line: str, level: LogLevel) -> None:
-        # TODO: we probably should create a new fd and pass it as
-        # one of the the arguments to the child process. Then everything
-        # from that fd can be automatically logged as originating from the
-        # bridge.
-
-        # Agent can produce [trace] messages, so change the log
-        # level to it if this does not originate from the user.
-        if line.startswith("[trace]"):
-            line = line.replace("[trace]", "", 1)
-            level = LogLevel.TRACE
-            source = LogSource.BRIDGE
-        else:
-            source = LogSource.USER
-
+    def handle_agent_log(self, line: str, level: LogLevel, source: LogSource) -> None:
         self.log(line, level=level, source=source)

isolate/connections/ipc/agent.py

@@ -15,6 +15,8 @@
 # one being the actual result of the given callable, and the other one is a boolean flag
 # indicating whether the callable has raised an exception or not.
 
+from __future__ import annotations
+
 import base64
 import importlib
 import os
@@ -24,7 +26,7 @@ import traceback
 from argparse import ArgumentParser
 from contextlib import closing
 from multiprocessing.connection import Client
-from typing import TYPE_CHECKING, Any, Callable, ContextManager, Tuple
+from typing import TYPE_CHECKING, Any, Callable, ContextManager
 
 if TYPE_CHECKING:
     # Somhow mypy can't figure out that `ConnectionWrapper`
@@ -47,13 +49,13 @@ else:
     from multiprocessing.connection import ConnectionWrapper
 
 
-def decode_service_address(address: str) -> Tuple[str, int]:
+def decode_service_address(address: str) -> tuple[str, int]:
     host, port = base64.b64decode(address).decode("utf-8").rsplit(":", 1)
     return host, int(port)
 
 
 def child_connection(
-    serialization_method: str, address: Tuple[str, int]
+    serialization_method: str, address: tuple[str, int]
 ) -> ContextManager[ConnectionWrapper]:
     serialization_backend = importlib.import_module(serialization_method)
     return closing(
@@ -70,7 +72,11 @@ DEBUG_TIMEOUT = 60 * 15
 
 
 def run_client(
-    serialization_method: str, address: Tuple[str, int], *, with_pdb: bool = False
+    serialization_method: str,
+    address: tuple[str, int],
+    *,
+    with_pdb: bool = False,
+    log_fd: int | None = None,
 ) -> None:
     # Debug Mode
     # ==========
@@ -96,13 +102,22 @@ def run_client(
 
         pdb.set_trace()
 
-    print(f"[trace] Trying to create a connection to {address}")
+    if log_fd is None:
+        _log = sys.stdout
+    else:
+        _log = os.fdopen(log_fd, "w")
+
+    def log(_msg):
+        _log.write(_msg)
+        _log.flush()
+
+    log(f"Trying to create a connection to {address}")
     # TODO(feat): this should probably run in a loop instead of
     # receiving a single function and then exitting immediately.
     with child_connection(serialization_method, address) as connection:
-        print(f"[trace] Created child connection to {address}")
+        log(f"Created child connection to {address}")
         callable = connection.recv()
-        print(f"[trace] Received the callable at {address}")
+        log(f"Received the callable at {address}")
 
         result = None
         did_it_raise = False
@@ -149,12 +164,11 @@ def _get_shell_bootstrap() -> str:
 
 
 def main() -> int:
-    print(f"[trace] Starting the isolated process at PID {os.getpid()}")
-
     parser = ArgumentParser()
     parser.add_argument("listen_at")
     parser.add_argument("--with-pdb", action="store_true", default=False)
     parser.add_argument("--serialization-backend", default="pickle")
+    parser.add_argument("--log-fd", type=int)
 
     options = parser.parse_args()
     if IS_DEBUG_MODE:
@@ -178,7 +192,12 @@ def main() -> int:
 
     serialization_method = options.serialization_backend
     address = decode_service_address(options.listen_at)
-    run_client(serialization_method, address, with_pdb=options.with_pdb)
+    run_client(
+        serialization_method,
+        address,
+        with_pdb=options.with_pdb,
+        log_fd=options.log_fd,
+    )
     return 0
 
 

{isolate-0.12.14.dist-info → isolate-0.12.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: isolate
-Version: 0.12.14
+Version: 0.12.16
 Summary: Managed isolated environments for Python
 Author-email: Features & Labels <hello@fal.ai>
 Project-URL: Issues, https://github.com/fal-ai/isolate/issues

{isolate-0.12.14.dist-info → isolate-0.12.16.dist-info}/RECORD

@@ -1,29 +1,29 @@
 isolate/__init__.py,sha256=uXOKnONs7sXgARNgElwr4_A1sKoA6ACHVEvs3IDiX1M,127
-isolate/_isolate_version.py,sha256=oRsayPIGrFfFJRhHuJNbw-xM7LmQjNrAd4E8zKg1CVc,415
+isolate/_isolate_version.py,sha256=bxigpDKzhomSYVhs2qwGig9Gi0LMxVUVJgPbV18aLDk,415
 isolate/_version.py,sha256=05pXvy-yr5t3I1m9JMn42Ilzpg7fa8IB2J8a3G7t1cU,274
-isolate/exceptions.py,sha256=ki-f7khY-Yo1J8nPdy5IP-aZhQyLUP9pp3dE0moEVKw,44
 isolate/logs.py,sha256=R_AHUVYD18z_PhtK_mDWi9Gch79CxmwHY09hUDShtwg,2079
 isolate/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isolate/registry.py,sha256=hpzv4HI7iihG5I7i5r8Pb257ibhEKY18xQcG-w1-BgI,1590
 isolate/backends/__init__.py,sha256=LLrSM7UnDFW8tIT5oYlE1wVJrxKcaj_v7cFwvTjQTlc,119
-isolate/backends/_base.py,sha256=senNj-k2Dp2DkyxmZy7WxzsexmPfU6_DBo7bbZDqTLQ,4167
-isolate/backends/common.py,sha256=ZiU0Vkz78qaPH_3ThV28OcHi8QgXie4aBrkPXCJuNBM,8321
-isolate/backends/conda.py,sha256=OIQrpt_VffW2PjPOIzp-JvonW4e7rDQ1ASHOEjyzD8E,7646
+isolate/backends/_base.py,sha256=Kt5pkhDzXZblq4vxaM3DQTo-Bj-7pIRZFlqJR7OfejY,4112
+isolate/backends/common.py,sha256=Zx0HXnBX_jlOLpFNJzY4ue8NcW-kktqo_WZOJmPSjvI,8481
+isolate/backends/conda.py,sha256=S5q5bdY787AMTck2iMGtwu-LHMH4a1qCIjNHDKTkqok,7649
+isolate/backends/container.py,sha256=Ek06tMwrCzEGFUlIQ8lIWURiwchTiuiS4HHDk-9bN9k,1567
 isolate/backends/local.py,sha256=woxe4dmXuEHxWKsGNndoRA1_sP6yG-dg6tlFZni0mZc,1360
-isolate/backends/pyenv.py,sha256=G-OIwESUOU5TqqumwsKVUhRiFQzxB1xrPn-bGm4LQoI,5428
+isolate/backends/pyenv.py,sha256=ZwTYoVPIWhS3Y4hN51x95aIOHi15GF7kEDdKTNhlMTE,5434
 isolate/backends/remote.py,sha256=qUm54mpqk0kaEfbPZl962Td3_P3qcpyVcfGdKfmkJHs,4234
 isolate/backends/settings.py,sha256=AiPYpzeon_AHS3ewSIKc0TMF4XrNdM32EFvgSTH2odE,3291
-isolate/backends/virtualenv.py,sha256=DiBAiybOLWMxJobIRaH4AgDn9agY5VrVPaSQObQa1Lo,6989
+isolate/backends/virtualenv.py,sha256=CdzDO4stxNCMbBsNnR1agwyu2FDBDx9UwJWI7bv010k,6992
 isolate/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 isolate/common/timestamp.py,sha256=seh7FrMRH4i1SCQavA8d-7z8qi0pP8lYYhd29gTPMwE,367
 isolate/connections/__init__.py,sha256=oa0PNo7ZQ0StPIDvKnJ02_CNVMyfOhxJ3M1C0VMvj9c,627
-isolate/connections/common.py,sha256=NwdUAV3jpzZwnzDFylPvdUtIwi6axx1G4HITJ11xMdg,3602
+isolate/connections/common.py,sha256=PAfBGKZNUdtFlZQlw3_nQaUCKQXTnEkxzNNRV_i4R2A,3498
 isolate/connections/_local/__init__.py,sha256=6FtCKRSFBvTvjm5LNlNA-mieKEq3J7DZZRPcXVedERo,146
-isolate/connections/_local/_base.py,sha256=qCx2M8kbxuPTruj9kH5z005LU2FaC0BkLxsgY-sXRlg,6214
+isolate/connections/_local/_base.py,sha256=nbeIH25wAZn1WDTGXv2HvAfFggzjJAF8GgGS4_iqNoY,6544
 isolate/connections/_local/agent_startup.py,sha256=swCs6Q0yVkDw7w-RftizHSMyJDM7DQwuP3TB0qI1ucg,1552
 isolate/connections/grpc/__init__.py,sha256=tcesLxlC36P6wSg2lBcO2egsJWMbSKwc8zFXhWac3YU,85
-isolate/connections/grpc/_base.py,sha256=hfGy_kFjifpK3zHD0_OTqpTF6CTOZH6abNnET4XLwE8,5613
-isolate/connections/grpc/agent.py,sha256=xRBfbmsWlOU4U6pBl0g_fhMdRZgVzXoKmi4gKTM3dYQ,7747
+isolate/connections/grpc/_base.py,sha256=ZxmAVOqy1N-k0xqw4xwmpLEXhmCoxecbJC4jXGPbGfc,5685
+isolate/connections/grpc/agent.py,sha256=LfmLs6B_lLftU-BQ_lm-p3RR-69Ls9hwLz0FpQDts3c,7451
 isolate/connections/grpc/configuration.py,sha256=50YvGGHA9uyKg74xU_gc73j7bsFk973uIpMhmw2HhxY,788
 isolate/connections/grpc/interface.py,sha256=yt63kytgXRXrTnjePGJVdXz4LJJVSSrNkJCF1yz6FIE,2270
 isolate/connections/grpc/definitions/__init__.py,sha256=Z0453Bbjoq-Oxm2Wfi9fae-BFf8YsZwmuh88strmvxo,459
@@ -36,8 +36,8 @@ isolate/connections/grpc/definitions/common_pb2.py,sha256=kU4hYQ04B2LNcjCjXb9m1u
 isolate/connections/grpc/definitions/common_pb2.pyi,sha256=J624Xc1Fp91ZFF8zdjJk1KCHNfHc2gRY8i3Aj1ofzKo,6887
 isolate/connections/grpc/definitions/common_pb2_grpc.py,sha256=xYOs94SXiNYAlFodACnsXW5QovLsHY5tCk3p76RH5Zc,158
 isolate/connections/ipc/__init__.py,sha256=j2Mbsph2mRhAWmkMyrtPOz0VG-e75h1OOZLwzs6pXUo,131
-isolate/connections/ipc/_base.py,sha256=iXCcgRU0c1Q0FDfm9nXVvjGwi-_6nCgkQZPATFaSu7Q,8494
-isolate/connections/ipc/agent.py,sha256=Wcoi5nA5RPPCll60sih9nTnFtM1JXM2QEUfSbjZUgjs,6828
+isolate/connections/ipc/_base.py,sha256=Jk715XK2ei3yBpFcwUnFZ0owQMMf5jekZFNh2WlKRT4,8009
+isolate/connections/ipc/agent.py,sha256=hGlL4x78FhRvMZ4DkVh3dk-EmWQqxHW4LIipgyOkw08,7069
 isolate/server/__init__.py,sha256=7R3GuWmxuqe0q28rVqETJN9OCrP_-Svjv9h0NR1GFL0,79
 isolate/server/health_server.py,sha256=yN7F1Q28DdX8-Zk3gef7XcQEE25XwlHwzV5GBM75aQM,1249
 isolate/server/interface.py,sha256=nGbjdxrN0p9m1LNdeds8NIoJOwPYW2NM6ktmbhfG4_s,687
@@ -52,9 +52,9 @@ isolate/server/health/health.proto,sha256=wE2_QD0OQAblKkEBG7sALLXEOj1mOLKG-FbC4t
 isolate/server/health/health_pb2.py,sha256=mCnDq0-frAddHopN_g_LueHddbW-sN5kOfntJDlAvUY,1783
 isolate/server/health/health_pb2.pyi,sha256=boMRHMlX770EuccQCFTeRgf_KA_VMgW7l9GZIwxvMok,2546
 isolate/server/health/health_pb2_grpc.py,sha256=JRluct2W4af83OYxwmcCn0vRc78zf04Num0vBApuPEo,4005
-isolate-0.12.14.dist-info/LICENSE,sha256=427vuyirL5scgBLqA9UWcdnxKrtSGc0u_JfUupk6lAA,11359
-isolate-0.12.14.dist-info/METADATA,sha256=ETQt_2bLdwTFn_TFF31pJs_dYbc4xM1YKWzCDHhNlGQ,3154
-isolate-0.12.14.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-isolate-0.12.14.dist-info/entry_points.txt,sha256=XQ_nl-8MR94UnekxbBJRNGlY-lZ_Qh50N4mzwFDdwV8,290
-isolate-0.12.14.dist-info/top_level.txt,sha256=W9QJBHcq5WXRkbOXf25bvftzFsOZZN4n1DAatdroZrs,8
-isolate-0.12.14.dist-info/RECORD,,
+isolate-0.12.16.dist-info/LICENSE,sha256=427vuyirL5scgBLqA9UWcdnxKrtSGc0u_JfUupk6lAA,11359
+isolate-0.12.16.dist-info/METADATA,sha256=GYUwGs0Vlac8ds1WYrR52NRjidg9W_eEyKsGMDSAY7Q,3154
+isolate-0.12.16.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+isolate-0.12.16.dist-info/entry_points.txt,sha256=s3prh2EERaVCbL8R45tfY5WFPZ1TsYOsz305YR7s-Pc,360
+isolate-0.12.16.dist-info/top_level.txt,sha256=W9QJBHcq5WXRkbOXf25bvftzFsOZZN4n1DAatdroZrs,8
+isolate-0.12.16.dist-info/RECORD,,

{isolate-0.12.14.dist-info → isolate-0.12.16.dist-info}/entry_points.txt

@@ -1,5 +1,6 @@
 [isolate.backends]
 conda = isolate.backends.conda:CondaEnvironment
+container = isolate.backends.container:ContainerizedPythonEnvironment
 isolate-server = isolate.backends.remote:IsolateServer
 local = isolate.backends.local:LocalPythonEnvironment
 pyenv = isolate.backends.pyenv:PyenvEnvironment

isolate/exceptions.py

@@ -1,2 +0,0 @@
-class IsolateException(Exception):
-    pass