shell-session-manager 1.0.0__py3-none-any.whl

shell_session_manager/__init__.py

@@ -0,0 +1,29 @@
+"""Public API for async shell/subprocess session management.
+
+The package exports the session primitives from `shell_session_manager.session`.
+Callers are responsible for constructing the command string; this package only
+owns process lifetime, incremental stdin writes, stdout/stderr draining, and
+session registry management.
+"""
+
+from shell_session_manager.session import (
+    NextResult,
+    ShellSession,
+    ShellSessionInfo,
+    ShellSessionManager,
+    ShellSessionOptions,
+    StreamName,
+    command_slug_parts,
+    random_6digits,
+)
+
+__all__ = [
+    "NextResult",
+    "ShellSession",
+    "ShellSessionInfo",
+    "ShellSessionManager",
+    "ShellSessionOptions",
+    "StreamName",
+    "command_slug_parts",
+    "random_6digits",
+]

shell_session_manager/session.py

@@ -0,0 +1,683 @@
+"""Async helpers for streaming subprocess-backed shell sessions.
+
+This module uses `anyio.open_process` and background tasks to drain
+stdout/stderr into a memory stream. The tasks are regular `asyncio` tasks
+instead of `anyio.TaskGroup` because `ShellSession` is designed to be held
+across multiple tool calls, which may run in different tasks; `anyio.TaskGroup`
+scopes must be entered/exited by the same task.
+
+Command construction is deliberately outside this package. Callers should pass
+the exact command to execute, including any shell, SSH, PTY, or environment
+bootstrap wrappers they require.
+
+Higher-level callers that need to manage multiple concurrent sessions should
+use `ShellSessionManager`, which owns a mapping of session ids to `ShellSession`
+instances and provides guardrails for cleanup.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import secrets
+import subprocess
+from contextlib import suppress
+from dataclasses import dataclass, field
+from typing import Literal, Self
+
+import anyio
+from anyio.abc import (
+    ByteReceiveStream,
+    ByteSendStream,
+    Process,
+)
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+
+type NextResult = tuple[bytes, bytes, int | None]
+type StreamName = Literal["stdout", "stderr"]
+
+
+def random_6digits() -> str:
+    """Generate a short session id suitable for surfacing to end users.
+
+    Notes:
+        This id is intended to be opaque, easy to read/relay, and "unique enough"
+        for in-memory session registries. Callers that persist sessions should
+        use a stronger id.
+    """
+
+    return f"{secrets.randbelow(1_000_000):06d}"
+
+
+@dataclass(frozen=True, slots=True)
+class ShellSessionOptions:
+    """Timing/timeout knobs for `ShellSession` (all in seconds)."""
+
+    timeout_seconds: float = 15.0
+    idle_output_wait_seconds: float = 0.1
+    post_exit_flush_seconds: float = 0.5
+    post_exit_drain_wait_seconds: float = 0.01
+    terminate_wait_seconds: float = 2.0
+    kill_wait_seconds: float = 2.0
+    process_close_wait_seconds: float = 0.5
+
+
+@dataclass(frozen=True)
+class _StreamDone:
+    stream: StreamName
+
+
+type OutputEvent = tuple[StreamName, bytes] | _StreamDone
+
+
+@dataclass(frozen=True, slots=True)
+class ShellSessionInfo:
+    """Public metadata for an active `ShellSession` registered in a manager.
+
+    Notes:
+        `desc` is an optional short, human-readable description supplied by the
+        higher-level caller. It is intentionally not the full raw command, which
+        may be long or sensitive.
+    """
+
+    session_id: str
+    desc: str | None = None
+
+
+@dataclass(slots=True)
+class ShellSessionManager:
+    """Manage multiple `ShellSession` instances by `session_id`.
+
+    This is intended for "tool loop" style runtimes where:
+    - sessions must be resumable across calls by a short opaque id
+    - callers need a single place to prune/interrupt/close sessions
+
+    Concurrency:
+        This manager serializes all operations with a single lock. It prioritizes
+        correctness and simple invariants over parallelism.
+    """
+
+    max_sessions: int = 32
+
+    _sessions: dict[str, ShellSession] = field(default_factory=dict, init=False)
+    _lock: anyio.Lock = field(default_factory=anyio.Lock, init=False, repr=False)
+    _closed: bool = field(default=False, init=False, repr=False)
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, exc_type: object, exc: object, tb: object) -> None:
+        await self.close()
+
+    def _require_open(self) -> None:
+        if self._closed:
+            raise RuntimeError("ShellSessionManager is closed")
+
+    async def new_shell(
+        self,
+        command: str,
+        *,
+        options: ShellSessionOptions | None = None,
+        desc: str | None = None,
+    ) -> str:
+        """Create, start, and register a new `ShellSession`.
+
+        Returns:
+            The new session's `session_id`.
+        """
+
+        async with self._lock:
+            self._require_open()
+            await self._prune_exited_sessions_locked()
+            if len(self._sessions) >= self.max_sessions:
+                raise RuntimeError(
+                    f"Too many active sessions ({len(self._sessions)}/{self.max_sessions})"
+                )
+
+            session = ShellSession(
+                command, options=options or ShellSessionOptions(), desc=desc
+            )
+            # Avoid id collisions within this process.
+            for _ in range(20):
+                if session.session_id not in self._sessions:
+                    break
+                session.session_id = random_6digits()
+            else:
+                raise RuntimeError("Failed to allocate a unique session id")
+
+            try:
+                await session.ensure_started()
+            except BaseException:
+                await session.interrupt()
+                raise
+
+            self._sessions[session.session_id] = session
+            return session.session_id
+
+    async def next(
+        self,
+        session_id: str,
+        stdin: bytes | None = None,
+        timeout_seconds: float | None = None,
+    ) -> NextResult:
+        """Run the next step for a registered session.
+
+        Args:
+            session_id: Registered shell session id.
+            stdin: Optional stdin bytes to write before waiting.
+            timeout_seconds:
+                Optional per-call timeout override (seconds) for this `next()`
+                call only. If omitted, the session default is used.
+        """
+
+        async with self._lock:
+            self._require_open()
+            session = self._sessions.get(session_id)
+            if session is None:
+                raise KeyError(f"Unknown session id: {session_id}")
+
+            result = await session.next(stdin=stdin, timeout_seconds=timeout_seconds)
+            if session.is_closed():
+                self._sessions.pop(session_id, None)
+            return result
+
+    async def interrupt(self, session_id: str) -> None:
+        """Interrupt and unregister a session (idempotent if already closed)."""
+
+        async with self._lock:
+            self._require_open()
+            session = self._sessions.pop(session_id, None)
+            if session is None:
+                raise KeyError(f"Unknown session id: {session_id}")
+            await session.interrupt()
+
+    async def clear(self) -> None:
+        """Interrupt all managed sessions and clear the registry."""
+
+        async with self._lock:
+            self._require_open()
+            sessions = list(self._sessions.values())
+            self._sessions.clear()
+
+        for session in sessions:
+            await session.interrupt()
+
+    async def close(self) -> None:
+        """Close the manager and interrupt all managed sessions."""
+
+        async with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            sessions = list(self._sessions.values())
+            self._sessions.clear()
+
+        for session in sessions:
+            await session.interrupt()
+
+    async def list_sessions(self) -> list[ShellSessionInfo]:
+        """Prune exited sessions and list remaining active sessions."""
+
+        async with self._lock:
+            self._require_open()
+            await self._prune_exited_sessions_locked()
+            return [
+                ShellSessionInfo(
+                    session_id=s.session_id,
+                    desc=s.desc,
+                )
+                for s in self._sessions.values()
+                if not s.is_closed()
+            ]
+
+    async def _prune_exited_sessions_locked(self) -> None:
+        """Best-effort prune of sessions whose subprocess has already exited.
+
+        This is mostly a guard for callers that start a session but never call
+        `next()`; `ShellSession.next()` normally detects exit and auto-closes.
+        We use a tiny bounded wait when polling process status because a strict
+        zero-timeout cancel scope can prevent the backend from refreshing
+        `process.returncode` in time.
+        """
+
+        to_remove: list[str] = []
+        for session_id, session in self._sessions.items():
+            if session.is_closed():
+                to_remove.append(session_id)
+                continue
+
+            process = session._process
+            if process is None:
+                continue
+
+            if process.returncode is None:
+                # Keep this short to avoid blocking list/prune for active sessions.
+                with anyio.move_on_after(0.01):
+                    await process.wait()
+
+            if process.returncode is not None:
+                await session.interrupt()
+                to_remove.append(session_id)
+
+        for session_id in to_remove:
+            self._sessions.pop(session_id, None)
+
+
+@dataclass(slots=True)
+class ShellSession:
+    """A minimal async session for incremental stdin and drained stdout/stderr.
+
+    API:
+    - `__init__(command: str, ...)`
+    - `await next(stdin: bytes | None) -> (stdout, stderr, returncode|None)`
+    - `await interrupt()`
+
+    `returncode=None` means the subprocess is still running.
+
+    When `next()` observes that the subprocess has exited, it drains any remaining
+    stdout/stderr (best-effort) and then automatically calls `interrupt()` to
+    release OS resources and mark the session as closed.
+    """
+
+    command: str
+
+    options: ShellSessionOptions = field(default_factory=ShellSessionOptions)
+
+    _process: Process | None = field(init=False, default=None, repr=False)
+    _stdin: ByteSendStream | None = field(init=False, default=None, repr=False)
+    _stdout: ByteReceiveStream | None = field(init=False, default=None, repr=False)
+    _stderr: ByteReceiveStream | None = field(init=False, default=None, repr=False)
+    _stdout_task: asyncio.Task[None] | None = field(
+        init=False, default=None, repr=False
+    )
+    _stderr_task: asyncio.Task[None] | None = field(
+        init=False, default=None, repr=False
+    )
+
+    _out_send: MemoryObjectSendStream[OutputEvent] = field(init=False, repr=False)
+    _out_recv: MemoryObjectReceiveStream[OutputEvent] = field(init=False, repr=False)
+
+    _closed: bool = field(init=False, default=False, repr=False)
+    _stdout_done: bool = field(init=False, default=False, repr=False)
+    _stderr_done: bool = field(init=False, default=False, repr=False)
+
+    session_id: str = field(init=False, default_factory=random_6digits)
+    desc: str | None = None
+
+    def __post_init__(self) -> None:
+        self._out_send, self._out_recv = anyio.create_memory_object_stream[OutputEvent](
+            1000
+        )
+
+    async def __aenter__(self) -> Self:
+        try:
+            await self.ensure_started()
+            return self
+        except BaseException:
+            # Best-effort cleanup on enter failures (e.g., spawn errors).
+            await self.interrupt()
+            raise
+
+    async def __aexit__(self, exc_type: object, exc: object, tb: object) -> None:
+        await self.interrupt()
+
+    async def ensure_started(self) -> None:
+        if self._process is not None:
+            return
+        try:
+            thread_name = (
+                f"{'-'.join(command_slug_parts(self.command))}-{self.session_id}"
+            )
+            process = await anyio.open_process(
+                self.command,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                start_new_session=False,
+            )
+
+            # Publish early so interrupt() can clean up even if we fail mid-start.
+            self._process = process
+
+            if (
+                process.stdin is None
+                or process.stdout is None
+                or process.stderr is None
+            ):
+                raise RuntimeError("Process started without stdin/stdout/stderr pipes")
+
+            # Publish state only after all required resources exist.
+            self._stdin = process.stdin
+            self._stdout = process.stdout
+            self._stderr = process.stderr
+
+            # Use asyncio Tasks instead of anyio.TaskGroup: this session is held across
+            # multiple tool calls which may run in different tasks. anyio.TaskGroup
+            # requires __aenter__/__aexit__ in the same task, which is easy to violate.
+            self._stdout_task = asyncio.create_task(
+                self._pump("stdout"),
+                name=f"ShellSession({thread_name}):stdout",
+            )
+            self._stderr_task = asyncio.create_task(
+                self._pump("stderr"),
+                name=f"ShellSession({thread_name}):stderr",
+            )
+        except BaseException:
+            await self.interrupt()
+            raise
+
+    async def _pump(
+        self,
+        stream_name: StreamName,
+    ) -> None:
+        stream: ByteReceiveStream | None
+        if stream_name == "stdout":
+            stream = self._stdout
+        else:
+            stream = self._stderr
+        if stream is None:
+            raise RuntimeError(f"Process {stream_name} is not available")
+
+        # Bind to a local var so interrupt() clearing instance fields doesn't affect the reader.
+        bound_stream = stream
+        try:
+            while True:
+                try:
+                    chunk = await bound_stream.receive(65536)
+                except anyio.EndOfStream:
+                    break
+                if chunk:
+                    try:
+                        await self._out_send.send((stream_name, chunk))
+                    except BaseException:
+                        break
+        finally:
+            # Best-effort signal that this stream is done.
+            with suppress(BaseException):
+                await self._out_send.send(_StreamDone(stream=stream_name))
+
+    async def next(
+        self, stdin: bytes | None = None, timeout_seconds: float | None = None
+    ) -> NextResult:
+        """Send stdin and wait for output or exit.
+
+        Args:
+            stdin: Optional stdin bytes to send first.
+            timeout_seconds:
+                Optional per-call timeout override in seconds. If omitted, uses
+                `self.options.timeout_seconds`.
+
+        Returns:
+            (stdout, stderr, returncode). `returncode=None` means the process did
+            not exit before the timeout.
+
+        Notes:
+            If the process exits (`returncode is not None`), this method performs
+            best-effort post-exit output draining and then automatically closes
+            the session by calling `interrupt()`. Callers should treat a non-None
+            return code as terminal: no further `next()` calls are supported.
+        """
+
+        if self._closed:
+            raise RuntimeError("Session is closed")
+        await self.ensure_started()
+        process = self._process
+        if process is None:
+            raise RuntimeError("Session not started")
+
+        if stdin is not None:
+            if self._stdin is None:
+                raise RuntimeError("Process stdin is not available")
+            await self._stdin.send(stdin)
+
+        stdout = bytearray()
+        stderr = bytearray()
+        returncode: int | None = None
+
+        effective_timeout = (
+            timeout_seconds
+            if timeout_seconds is not None
+            else self.options.timeout_seconds
+        )
+        if effective_timeout <= 0:
+            raise ValueError(f"timeout_seconds must be > 0; got {effective_timeout}")
+
+        deadline = anyio.current_time() + effective_timeout
+        while True:
+            if process.returncode is not None:
+                returncode = process.returncode
+                break
+
+            remaining = deadline - anyio.current_time()
+            if remaining <= 0:
+                returncode = None
+                break
+
+            # Drain what we already have; if there was nothing buffered, wait briefly
+            # for one event so callers don't need to spin.
+            await self._drain_output(stdout, stderr, timeout=0)
+            if not stdout and not stderr:
+                await self._drain_output(
+                    stdout,
+                    stderr,
+                    timeout=min(self.options.idle_output_wait_seconds, remaining),
+                )
+
+            with anyio.move_on_after(0):
+                await process.wait()
+
+        # Final drain after exit/timeout. If the process exited, give pumps a brief
+        # chance to flush remaining output and send stream-done markers.
+        if returncode is not None:
+            flush_deadline = anyio.current_time() + self.options.post_exit_flush_seconds
+            while anyio.current_time() < flush_deadline and not (
+                self._stdout_done and self._stderr_done
+            ):
+                await self._drain_output(
+                    stdout,
+                    stderr,
+                    timeout=self.options.post_exit_drain_wait_seconds,
+                )
+        await self._drain_output(stdout, stderr, timeout=0)
+
+        result = (bytes(stdout), bytes(stderr), returncode)
+
+        # If we have a final return code, this session is terminal. Close eagerly
+        # so higher-level callers (e.g. tool loops) don't need to remember to call
+        # interrupt() to release resources.
+        if returncode is not None:
+            await self.interrupt()
+
+        return result
+
+    async def _drain_output(
+        self, stdout: bytearray, stderr: bytearray, *, timeout: float
+    ) -> None:
+        """Drain buffered output, then optionally wait up to `timeout` for one event.
+
+        The `timeout` applies only to the single blocking `receive()`; all other
+        draining is non-blocking.
+        """
+
+        # Drain whatever is already buffered (non-blocking).
+        while True:
+            try:
+                event = self._out_recv.receive_nowait()
+            except (anyio.WouldBlock, anyio.EndOfStream):
+                break
+            self._apply_event(event, stdout, stderr)
+
+        if timeout <= 0:
+            return
+
+        # Wait up to `timeout` for a single output event, then drain any burst.
+        cancel_exc = anyio.get_cancelled_exc_class()
+        event = None
+        with anyio.move_on_after(timeout):
+            try:
+                event = await self._out_recv.receive()
+            except anyio.EndOfStream:
+                return
+            except cancel_exc:
+                event = None
+        if event is not None:
+            self._apply_event(event, stdout, stderr)
+
+        while True:
+            try:
+                event = self._out_recv.receive_nowait()
+            except (anyio.WouldBlock, anyio.EndOfStream):
+                break
+            self._apply_event(event, stdout, stderr)
+
+    def _apply_event(
+        self, event: OutputEvent, stdout: bytearray, stderr: bytearray
+    ) -> None:
+        if isinstance(event, _StreamDone):
+            if event.stream == "stdout":
+                self._stdout_done = True
+            else:
+                self._stderr_done = True
+            return
+
+        stream_name, chunk = event
+        if stream_name == "stdout":
+            stdout += chunk
+        else:
+            stderr += chunk
+
+    async def interrupt(self) -> None:
+        """Best-effort cleanup hook (never raises).
+
+        This is intentionally tolerant of partial initialization and cleanup
+        failures; callers should not need to wrap it in try/except.
+        """
+
+        if self._closed:
+            return
+        self._closed = True
+
+        try:
+            with anyio.CancelScope(shield=True):
+                process = self._process
+                stdout_task = self._stdout_task
+                stderr_task = self._stderr_task
+
+                # Terminate/kill first to encourage pumps to finish naturally.
+                if process is not None and process.returncode is None:
+                    with suppress(BaseException):
+                        process.terminate()
+                    with anyio.move_on_after(self.options.terminate_wait_seconds):
+                        with suppress(BaseException):
+                            await process.wait()
+                    if process.returncode is None:
+                        with suppress(BaseException):
+                            process.kill()
+                        with anyio.move_on_after(self.options.kill_wait_seconds):
+                            with suppress(BaseException):
+                                await process.wait()
+
+                # Cancel reader tasks before closing the output stream to avoid
+                # concurrent sends into a closed channel.
+                for task in (stdout_task, stderr_task):
+                    if task is None:
+                        continue
+                    with suppress(BaseException):
+                        task.cancel()
+                for task in (stdout_task, stderr_task):
+                    if task is None:
+                        continue
+                    with suppress(BaseException):
+                        await task
+
+                with suppress(BaseException):
+                    await self._out_send.aclose()
+
+                if process is not None:
+                    with anyio.move_on_after(self.options.process_close_wait_seconds):
+                        with suppress(BaseException):
+                            await process.aclose()
+        except BaseException:
+            # Cleanup must never leak exceptions (including cancellation) out to callers.
+            pass
+        finally:
+            self._process = None
+            self._stdin = None
+            self._stdout = None
+            self._stderr = None
+            self._stdout_task = None
+            self._stderr_task = None
+
+    def is_closed(self) -> bool:
+        """Check if the session has been closed."""
+        return self._closed
+
+    def __del__(self) -> None:
+        # Best-effort sync cleanup path for abnormal object destruction.
+        try:
+            process = getattr(self, "_process", None)
+            if process is not None and getattr(process, "returncode", None) is None:
+                process.terminate()
+        except Exception:
+            pass
+
+
+def command_slug_parts(
+    command: str,
+    *,
+    head_components: int = 3,
+    tail_components: int = 2,
+    component_limit: int = 24,
+    label_limit: int = 80,
+) -> list[str]:
+    """Generate a short, human-readable slug preview for a shell command.
+
+    Returns:
+        A list of slug components suitable for joining with `-` into a task name.
+
+    Notes:
+        This intentionally uses only a preview of the command (first few + last few
+        whitespace-delimited components) so we don't embed full command lines (which
+        can be long and/or sensitive) into asyncio task names that may surface in
+        logs and debuggers.
+    """
+
+    normalized = " ".join(command.strip().split())
+    if not normalized:
+        return ["cmd"]
+
+    components = normalized.split(" ")
+
+    def clean(component: str) -> str:
+        component = component.strip()
+        if (
+            len(component) >= 2
+            and component[0] == component[-1]
+            and component[0] in {"'", '"'}
+        ):
+            component = component[1:-1].strip()
+        component = component.rsplit("/", 1)[-1]
+        if len(component) > component_limit:
+            component = component[: max(0, component_limit - 1)] + "…"
+        return component or "…"
+
+    head = [clean(c) for c in components[:head_components]]
+    tail_start = max(head_components, len(components) - tail_components)
+    tail = [clean(c) for c in components[tail_start:]]
+
+    preview: list[str] = [*head]
+    if tail_start > head_components and tail:
+        preview.append("…")
+    preview.extend(tail)
+
+    # Ensure the final joined label stays reasonably short.
+    label = "-".join(preview).strip("-")
+    if len(label) > label_limit and preview:
+        prefix = "-".join(preview[:-1]).strip("-")
+        remaining = label_limit - (len(prefix) + (1 if prefix else 0))
+        if remaining <= 0:
+            return ["cmd"]
+        last = preview[-1]
+        if len(last) > remaining:
+            preview[-1] = last[: max(0, remaining - 1)] + "…"
+
+    return [p for p in preview if p] or ["cmd"]

shell_session_manager-1.0.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: shell-session-manager
+Version: 1.0.0
+Summary: Async subprocess session manager with incremental stdin/stdout/stderr support
+Author-Email: =?utf-8?b?WWFubGkg55uQ57KS?= <yanli@mail.one>
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: ==3.14.*
+Requires-Dist: anyio>=4.12.1
+Description-Content-Type: text/markdown
+
+# shell-session-manager
+
+`shell-session-manager` provides async subprocess sessions that can be resumed
+across multiple calls. It drains stdout/stderr in background asyncio tasks,
+supports incremental stdin writes, exposes short session ids, and manages
+best-effort cleanup for long-lived command sessions.
+
+Command construction is intentionally out of scope: callers should pass the
+exact command string they want to execute, including any shell, SSH, PTY, or
+environment bootstrap wrappers.
+
+## Usage
+
+```python
+import anyio
+
+from shell_session_manager import ShellSession, ShellSessionOptions
+
+
+async def main() -> None:
+    async with ShellSession(
+        "python -u -c 'import sys; print(\"ready\"); line = sys.stdin.readline(); print(line.upper(), end=\"\")'",
+        options=ShellSessionOptions(timeout_seconds=1),
+    ) as session:
+        stdout, stderr, code = await session.next()
+        print(stdout.decode(), stderr.decode(), code)  # ready\n, "", None
+
+        stdout, stderr, code = await session.next(b"hello\n")
+        print(stdout.decode(), stderr.decode(), code)  # HELLO\n, "", 0
+
+
+anyio.run(main)
+```
+
+For multiple long-lived sessions, use `ShellSessionManager`:
+
+```python
+import anyio
+
+from shell_session_manager import ShellSessionManager
+
+
+async def main() -> None:
+    async with ShellSessionManager() as manager:
+        session_id = await manager.new_shell("python -c 'print(42)'")
+        stdout, stderr, returncode = await manager.next(session_id)
+        print(stdout.decode(), stderr.decode(), returncode)
+
+
+anyio.run(main)
+```

shell_session_manager-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+shell_session_manager-1.0.0.dist-info/METADATA,sha256=yIoUCLDcHHXzK70kyyZQJp30JHBpWNo-FG6KpNCyl9k,1925
+shell_session_manager-1.0.0.dist-info/WHEEL,sha256=Z36eTX6lG3PITRleSd5hAZHCcz52yg3c0JQVxKBbLW0,90
+shell_session_manager-1.0.0.dist-info/entry_points.txt,sha256=6OYgBcLyFCUgeqLgnvMyOJxPCWzgy7se4rLPKtNonMs,34
+shell_session_manager-1.0.0.dist-info/licenses/LICENSE,sha256=argP9wYgQ1LWBagmxujAcNYuqlLgFJTGoF3ehfkczt8,10259
+shell_session_manager/__init__.py,sha256=wJ-5WLRmGkLI-VcnbwGwDdOjQuXU6hEn0XP8gFU5BGc,742
+shell_session_manager/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shell_session_manager/session.py,sha256=iDgw4SjLs-cj91AizdD2QWmMQg6GXcH-amBobITfpBw,24223
+shell_session_manager-1.0.0.dist-info/RECORD,,

shell_session_manager-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: pdm-backend (2.4.8)
+Root-Is-Purelib: true
+Tag: py3-none-any

shell_session_manager-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+
+[gui_scripts]
+

shell_session_manager-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction,
+and distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by
+the copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all
+other entities that control, are controlled by, or are under common
+control with that entity. For the purposes of this definition,
+"control" means (i) the power, direct or indirect, to cause the
+direction or management of such entity, whether by contract or
+otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity
+exercising permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation
+source, and configuration files.
+
+"Object" form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but
+not limited to compiled object code, generated documentation,
+and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or
+Object form, made available under the License, as indicated by a
+copyright notice that is included in or attached to the work
+(an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including
+the original version of the Work and any modifications or additions
+to that Work or Derivative Works thereof, that is intentionally
+submitted to Licensor for inclusion in the Work by the copyright owner
+or by an individual or Legal Entity authorized to submit on behalf of
+the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems,
+and issue tracking systems that are managed by, or on behalf of, the
+Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise
+designated in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity
+on behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the
+Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+this License, each Contributor hereby grants to You a perpetual,
+worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+(except as stated in this section) patent license to make, have made,
+use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable
+by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s)
+with the Work to which such Contribution(s) was submitted. If You
+institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work
+or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate
+as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+Work or Derivative Works thereof in any medium, with or without
+modifications, and in Source or Object form, provided that You
+meet the following conditions:
+
+(a) You must give any other recipients of the Work or
+Derivative Works a copy of this License; and
+
+(b) You must cause any modified files to carry prominent notices
+stating that You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works
+that You distribute, all copyright, patent, trademark, and
+attribution notices from the Source form of the Work,
+excluding those notices that do not pertain to any part of
+the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its
+distribution, then any Derivative Works that You distribute must
+include a readable copy of the attribution notices contained
+within such NOTICE file, excluding those notices that do not
+pertain to any part of the Derivative Works, in at least one
+of the following places: within a NOTICE text file distributed
+as part of the Derivative Works; within the Source form or
+documentation, if provided along with the Derivative Works; or,
+within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and
+do not modify the License. You may add Your own attribution
+notices within Derivative Works that You distribute, alongside
+or as an addendum to the NOTICE text from the Work, provided
+that such additional attribution notices cannot be construed
+as modifying the License.
+
+You may add Your own copyright statement to Your modifications and
+may provide additional or different license terms and conditions
+for use, reproduction, or distribution of Your modifications, or
+for any such Derivative Works as a whole, provided Your use,
+reproduction, and distribution of the Work otherwise complies with
+the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+any Contribution intentionally submitted for inclusion in the Work
+by You to the Licensor shall be under the terms and conditions of
+this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify
+the terms of any separate license agreement you may have executed
+with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+names, trademarks, service marks, or product names of the Licensor,
+except as required for reasonable and customary use in describing the
+origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+agreed to in writing, Licensor provides the Work (and each
+Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied, including, without limitation, any warranties or conditions
+of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any
+risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+whether in tort (including negligence), contract, or otherwise,
+unless required by applicable law (such as deliberate and grossly
+negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special,
+incidental, or consequential damages of any character arising as a
+result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses), even if such Contributor
+has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+the Work or Derivative Works thereof, You may choose to offer,
+and charge a fee for, acceptance of support, warranty, indemnity,
+or other liability obligations and/or rights consistent with this
+License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf
+of any other Contributor, and only if You agree to indemnify,
+defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason
+of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets "[]"
+replaced with your own identifying information. (Don't include
+the brackets!)  The text should be enclosed in the appropriate
+comment syntax for the file format. We also recommend that a
+file or class name and description of purpose be included on the
+same "printed page" as the copyright notice for easier
+identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.