sshscript 3.1.4__py3-none-any.whl → 3.1.5__py3-none-any.whl

sshscript/__init__.py

@@ -26,9 +26,9 @@ Example::
     from sshscript import Session
 
     with Session() as local:
-        stdout, stderr = local("hostname")
+        stdout, stderr, exitcode = local("hostname")
         with local.connect("user@host") as remote:
-            stdout, stderr = remote("uname -s")
+            stdout, stderr, exitcode = remote("uname -s")
             print(stdout.strip())
 
 Use run_file(path) for a script file, run_script(source) for source text,
@@ -49,8 +49,10 @@ else:
     from spyimporter import spy_imports
 
 run_file = sshscript.run_file
+check_file = sshscript.check_file
 run_script = sshscript.run_script
 Session = session.Session
+CommandResult = session.CommandResult
 
 set_logger = errorutils.set_logger
 get_logger = errorutils.get_logger
@@ -73,8 +75,10 @@ SSHScriptException = errorutils.SSHScriptException
 
 __all__ = [
     'run_file',
+    'check_file',
     'run_script',
     'Session',
+    'CommandResult',
     'get_logger',
     'set_logger',
     'spy_imports',

sshscript/_version.py

@@ -1,3 +1,3 @@
 """Single source of the SSHScript package version."""
 
-__version__ = "3.1.4"
+__version__ = "3.1.5"

sshscript/commandresult.py

@@ -0,0 +1,28 @@
+"""Immutable snapshots of completed commands."""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    """One completed command, with text output and elapsed monotonic seconds.
+
+    Three-value unpacking/indexing yields ``stdout, stderr, exitcode``.
+    Output is a text snapshot, not a live/consuming console buffer.
+    host snapshots Session.host (None for a local session).
+    """
+
+    stdout: str
+    stderr: str
+    exitcode: int
+    host: str | None
+    duration: float
+    command: str | tuple[str, ...]
+
+    def __iter__(self):
+        return iter((self.stdout, self.stderr, self.exitcode))
+
+    def __len__(self):
+        return 3
+
+    def __getitem__(self, index):
+        return (self.stdout, self.stderr, self.exitcode)[index]

sshscript/dollar.py

@@ -66,6 +66,7 @@ class Dollar(object):
         self.for_with = for_with
 
         self.command = command
+        self.argv = None
         self.session = session # Session instance in context
         self.channel = None
         self.use_shell = use_shell
@@ -461,7 +462,7 @@ class Dollar(object):
                 shell_executable = self.shell_executable or '/bin/sh'
                 cpargs = [shell_executable,'-c',self.command]
             else:
-                cpargs = shlex.split(self.command)
+                cpargs = list(self.argv) if self.argv is not None else shlex.split(self.command)
             summary = command_summary(cpargs)
             kw['text'] = False
             ## with_pty is always False
@@ -536,7 +537,7 @@ class Dollar(object):
                 summary = command_summary([shell_executable])
                 argc = None
             else:
-                argv = shlex.split(self.command)
+                argv = self.argv if self.argv is not None else shlex.split(self.command)
                 command = 'exec ' + ' '.join(shlex.quote(str(arg)) for arg in argv)
                 summary = command_summary(argv)
                 argc = summary['arg_count']

sshscript/dollarchanger.py

@@ -544,7 +544,7 @@ class DollarChanger(ast.NodeTransformer):
                 ## upgrade "try" block one level
                 if isinstance(originNode.value,ast.Try):
                     newnode = originNode.value  
-                    ## eg. stdout,stderr = $hostname
+                    ## eg. stdout,stderr,exitcode = $hostname
                     originNode.value = self._template(self.tmplLineAssignAtBottom.value, node)
                     ## append original assignment to last statement
                     newnode.finalbody.append(originNode)

sshscript/dollarparser.py

@@ -145,6 +145,10 @@ def parse(script_path, spyscript):
         token_script = tokenparser.convert(spyscript)
     except tokenize.TokenError as error:
         raise _token_syntax_error(error, script_path, spyscript) from None
+    except SyntaxError as error:
+        # tokenize also raises IndentationError/TabError with '<tokenize>' as
+        # filename; keep these diagnostics attached to the actual .spy file.
+        raise _source_syntax_error(error, script_path, spyscript) from None
 
     try:
         tree = ast.parse(token_script, filename=script_path)

sshscript/session.py

@@ -37,8 +37,11 @@ import asyncio
 import warnings
 import subprocess
 import socket
+import shlex
 from select import select
 if __package__:
+    from .commandresult import CommandResult
+    from .sshconfig import resolve_connection
     from .dollar import Dollar
     from .sessionwrapper import SessionWrapper,SudoConsole,SuConsole
     from .errorutils import get_logger, SSHScriptExit, SSHScriptBreak, SSHScriptException, dumpScript, listRightIndex
@@ -46,6 +49,8 @@ if __package__:
     from . import dollarparser
 
 else:
+    from commandresult import CommandResult
+    from sshconfig import resolve_connection
     ## called directly from the same folder
     ## see above "try" block for details
     from dollar import Dollar
@@ -277,7 +282,8 @@ class Session(object):
     successful block, or attached as a note to an exception from the block. A
     local session remains reusable.
 
-    session(command) aliases exec_command() and returns (stdout, stderr).
+    session(command) aliases exec_command() and returns a CommandResult that
+    supports three-value stdout/stderr/exitcode unpacking.
     Read session.exitcode for the last command status. Use shell() when commands
     must share a working directory or environment, enter() for interactive
     programs, and sudo()/su() for a console under another user.
@@ -285,9 +291,9 @@ class Session(object):
     Example::
 
         with Session() as local:
-            stdout, stderr = local("hostname")
+            stdout, stderr, exitcode = local("hostname")
             with local.connect("user@host") as remote:
-                stdout, stderr = remote("uname -s")
+                stdout, stderr, exitcode = remote("uname -s")
 
     In .spy files, $command executes in the active session or console, and
     $.connect(), $.shell(), $.enter(), $.upload(), and $.download() provide the
@@ -349,6 +355,7 @@ class Session(object):
         ## this value was stored, so user can access its stdout, stderr and exitcode
         ## by self.stdout and self.stderr, self.exitcode
         self._lastDollar = None
+        self.last_result = None
         self._attached_stack = None
     ## added in v2.0.3
     ## always return the session which is not connected to execute commands by subprocess at localhost
@@ -566,7 +573,7 @@ class Session(object):
         raise SSHScriptExit(message,code)
 
     @export2Dollar
-    def connect(self,host,username=None,password=None,port=22,policy=None,**kw):
+    def connect(self,host,username=None,password=None,port=None,policy=None,*,ssh_config=None,**kw):
         """Return a connected child session, optionally through this session's SSH link.
 
         Use with session.connect("user@host") as remote to scope the connection.
@@ -575,6 +582,10 @@ class Session(object):
 
         host may include the username; connect("user@host", password) is supported.
         pkey_path loads an RSA key from this session's host (local for a new Session).
+        Local connections read ~/.ssh/config by default; ssh_config=False opts
+        out, and a path selects a config file. Explicit parameters win. Nested
+        connections skip local config unless a path is explicitly supplied.
+        resolve_connection() previews effective settings without connecting.
         Other connection keywords are forwarded to SSHClient.connect().
 
         Unknown and changed host keys are rejected by default. policy may explicitly
@@ -588,13 +599,26 @@ class Session(object):
             raise RuntimeError('cannot connect from a closed session')        
         
         ## host might be in format of "username@hostname"
-        if '@' in host:
+        if isinstance(host, str) and '@' in host:
             if username and password is None:
                 password = username
-            username,host = host.split('@')
+                username = None
+            embedded_username,host = host.rsplit('@', 1)
+            if username is None:
+                username = embedded_username
 
-        has_proxy = 'proxyCommand' in kw
         is_nested = self._client is not None
+        effective = resolve_connection(
+            host, username, port,
+            ssh_config=False if is_nested and ssh_config is None else ssh_config,
+            **kw,
+        )
+        host = effective.pop('hostname')
+        username = effective.pop('username')
+        port = effective.pop('port')
+        kw = effective
+
+        has_proxy = 'proxyCommand' in kw
         logger.debug(
             'Opening SSH connection (host=%s, port=%s, username=%s, nested=%s, proxy=%s)',
             host,
@@ -720,6 +744,8 @@ class Session(object):
                 )
             raise
 
+    resolve_connection = staticmethod(resolve_connection)
+
     ## alias of connect, would be removed later
     @export2Dollar
     def open(self,*args,**kw):
@@ -1013,14 +1039,19 @@ class Session(object):
         if self._lastDollar: self._lastDollar.clear()
 
 
-    def exec_command(self,cmd:str,*,shell=None,shell_executable=None,
+    def exec_command(self,cmd,*,shell=None,shell_executable=None,check=False,
                      _legacy_twodollars=False,**kw):
-        """Execute one command and return (stdout, stderr); also available as session(cmd).
+        """Execute one command and return a CommandResult; also session(cmd).
 
         Wait for completion on this session's host. stdout, stderr, and exitcode
         remain available on the session as the latest command result. Check exitcode
-        for command failure; execution/transport errors propagate. Local execution
-        also accepts check=True to raise for a nonzero command status.
+        for command failure; execution/transport errors propagate. check=True
+        raises CalledProcessError on either backend, after saving last_result.
+        Unpacking yields stdout and stderr text snapshots plus the exit code.
+
+        cmd is a command string or a nonempty list/tuple of string arguments.
+        Argument sequences bypass shell detection and require shell=None/False.
+        Remote sequences are quoted for a POSIX login shell; they are not batches.
 
         shell=None automatically detects shell syntax. shell=False forces direct
         execution; shell=True uses a POSIX shell; shell="bash" selects a named shell.
@@ -1032,11 +1063,31 @@ class Session(object):
 
         Example::
 
-            stdout, stderr = session("cat", input="hello")
+            stdout, stderr, exitcode = session("cat", input="hello")
             status = session.exitcode
         """
-        if not isinstance(cmd,str):
-            raise TypeError(f'command must be str, not {type(cmd).__name__}')
+        if self.closed:
+            raise RuntimeError('cannot execute on a closed session')
+        if self._client is not None and not self.connected:
+            raise BrokenPipeError('SSH transport is not active')
+        if not isinstance(check, bool):
+            raise TypeError('check must be bool')
+        argv = None
+        if isinstance(cmd, (list, tuple)):
+            if not cmd:
+                raise ValueError('argument sequence must not be empty')
+            if not all(isinstance(arg, str) for arg in cmd):
+                raise TypeError('every command argument must be str')
+            if not cmd[0] or any('\x00' in arg for arg in cmd):
+                raise ValueError('executable must be nonempty and arguments cannot contain NUL')
+            if ((shell is not None and shell is not False)
+                    or shell_executable is not None or _legacy_twodollars):
+                raise ValueError('argument sequences require shell=None or shell=False')
+            argv = tuple(cmd)
+            cmd = shlex.join(argv)
+            shell = False
+        elif not isinstance(cmd,str):
+            raise TypeError(f'command must be str, list, or tuple, not {type(cmd).__name__}')
         cmd = cmd.strip()
         if not cmd:
             raise ValueError('command must not be empty')
@@ -1057,7 +1108,7 @@ class Session(object):
             )
             shell = True
 
-        self._lastDollar = Dollar(
+        execution = Dollar(
             self,
             cmd,
             for_with=False,
@@ -1065,8 +1116,26 @@ class Session(object):
             shell_executable=shell_executable,
             **kw,
         )
-        self._lastDollar()
-        return self._lastDollar.stdout,self._lastDollar.stderr
+        # Keep actual argv for local exec; the SSH protocol only carries strings.
+        execution.argv = argv
+        self._lastDollar = execution
+        self.last_result = None
+        host = self.host
+        started = time.monotonic()
+        execution()
+        result = CommandResult(
+            str(execution.stdout), str(execution.stderr), execution.exitcode,
+            host, time.monotonic() - started, argv if argv is not None else cmd,
+        )
+        self.last_result = result
+        if check and result.exitcode != 0:
+            error = subprocess.CalledProcessError(
+                result.exitcode, result.command,
+                output=result.stdout, stderr=result.stderr,
+            )
+            error.result = result
+            raise error
+        return result
 
     ## Compatibility aliases for code generated by older parsers.
     def onedollar(self,cmd,**kw):

sshscript/sshconfig.py

@@ -0,0 +1,127 @@
+"""Resolve a documented subset of OpenSSH config without opening connections.
+
+Match/Include/canonicalization are rejected, rather than partially interpreted.
+Proxy commands are only started by Session.connect(), never by this resolver.
+"""
+import getpass
+import os
+import re
+import shlex
+from urllib.parse import urlsplit
+import warnings
+
+import paramiko
+
+
+class _RawConfig(paramiko.SSHConfig):
+    def _expand_variables(self, config, target_hostname):
+        # Expansion must happen after explicit API overrides are applied.
+        return config
+
+
+def _expand(value, tokens):
+    def substitute(match):
+        token = match.group(0)
+        if token not in tokens:
+            raise ValueError(f'unsupported SSH config token: {token}')
+        return str(tokens[token])
+    return re.sub(r'%[%A-Za-z]', substitute, value)
+
+
+def resolve_connection(host, username=None, port=None, *, ssh_config=None, **options):
+    """Return effective Paramiko kwargs and proxyCommand without connecting.
+
+    None reads ~/.ssh/config if it exists; False disables config; a path is
+    required to exist. Explicit arguments override config. Only local callers
+    should opt into reading local config for an already nested SSH connection.
+    """
+    if not isinstance(host, str):
+        raise TypeError('host must be str')
+    if '@' in host:
+        user, host = host.rsplit('@', 1)
+        if username is None:
+            username = user
+    if not host or host.startswith('-') or any(c.isspace() or c == '\x00' for c in host):
+        raise ValueError('host must be a nonempty hostname or address')
+    alias = host
+    config = {}
+    path = None
+    if ssh_config is not False:
+        if ssh_config is not None and not isinstance(ssh_config, (str, os.PathLike)):
+            raise TypeError('ssh_config must be a path, None, or False')
+        path = os.path.expanduser(os.fspath(ssh_config) if ssh_config is not None else '~/.ssh/config')
+        try:
+            with open(path, encoding='utf-8') as stream:
+                source = stream.read()
+        except FileNotFoundError:
+            if ssh_config is not None:
+                raise
+        else:
+            # Paramiko can execute Match exec during lookup. Reject before parse.
+            for line in source.splitlines():
+                match = re.match(r'\s*([\w]+)(?:\s|=|$)', line)
+                if match and match[1].lower() in ('match', 'include', 'canonicalizehostname'):
+                    raise NotImplementedError(f'SSH config directive {match[1]} is not supported')
+            parser = _RawConfig.from_text(source)
+            config = parser.lookup(alias)
+    supported = {'hostname', 'user', 'port', 'identityfile', 'proxycommand', 'proxyjump'}
+    unsupported = sorted(set(config) - supported)
+    if unsupported:
+        warnings.warn('SSH config options not applied: ' + ', '.join(unsupported),
+                      UserWarning, stacklevel=2)
+    host = _expand(config.get('hostname', alias), {'%h': alias, '%n': alias, '%%': '%'})
+    username = username if username is not None else config.get('user')
+    if username is not None and (not isinstance(username, str) or not username
+                                 or any(c.isspace() or c == '\x00' for c in username)):
+        raise ValueError('username must be a nonempty string without whitespace')
+    port = port if port is not None else int(config.get('port', 22))
+    if not isinstance(port, int) or isinstance(port, bool) or not 1 <= port <= 65535:
+        raise ValueError('port must be an integer between 1 and 65535')
+    if not host or host.startswith('-') or any(c.isspace() or c in '\x00%' for c in host):
+        raise ValueError('resolved HostName must be a hostname or address')
+    tokens = {'%%': '%', '%h': host, '%n': alias, '%p': port,
+              '%r': username or getpass.getuser(), '%u': getpass.getuser(),
+              '%d': os.path.expanduser('~')}
+    if not any(key in options for key in ('key_filename', 'pkey', 'pkey_path')):
+        keys = config.get('identityfile', [])
+        if keys:
+            options['key_filename'] = [os.path.expanduser(_expand(key, tokens)) for key in keys if key.lower() != 'none']
+
+    explicit_proxy = 'proxyCommand' in options or 'proxyJump' in options
+    command = options.pop('proxyCommand', None)
+    jump = options.pop('proxyJump', None)
+    if not explicit_proxy:
+        command, jump = config.get('proxycommand'), config.get('proxyjump')
+    if command is not None and not isinstance(command, str):
+        raise TypeError('proxyCommand must be a string or None')
+    if jump is not None and not isinstance(jump, str):
+        raise TypeError('proxyJump must be a string or None')
+    if command and command.lower() == 'none':
+        command = None
+    if jump and jump.lower() == 'none':
+        jump = None
+    if command and jump:
+        raise ValueError('ProxyCommand and ProxyJump cannot both be active; override one explicitly')
+    if command:
+        # Explicit proxyCommand retains its historical verbatim semantics.
+        options['proxyCommand'] = command if explicit_proxy else _expand(command, tokens)
+    elif jump:
+        jumps = jump.split(',')
+        if any(not item or any(c.isspace() or c in '\x00%' for c in item) for item in jumps):
+            raise ValueError('invalid ProxyJump chain')
+        endpoint = urlsplit('ssh://' + jumps[-1])
+        if not endpoint.hostname or endpoint.hostname.startswith('-') or endpoint.password or endpoint.path or endpoint.query or endpoint.fragment:
+            raise ValueError('ProxyJump must use [user@]host[:port]')
+        # OpenSSH manages hop authentication; Paramiko still verifies the target.
+        args = ['ssh', '-F', path if path and os.path.isfile(path) else os.devnull,
+                '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes',
+                '-W', f'[{host}]:{port}']
+        if len(jumps) > 1:
+            args.extend(['-J', ','.join(jumps[:-1])])
+        if endpoint.port is not None:
+            args.extend(['-p', str(endpoint.port)])
+        if endpoint.username is not None:
+            args.extend(['-l', endpoint.username])
+        args.append(endpoint.hostname)
+        options['proxyCommand'] = shlex.join(args)
+    return dict(options, hostname=host, username=username, port=port)

sshscript/sshscript.py

@@ -15,8 +15,8 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
 """Public script runners and command-line entry point.
 
-For commands in ordinary Python, use Session: session(command) returns
-(stdout, stderr), and session.connect(host) creates a remote child session.
+For commands in ordinary Python, use Session: session(command) returns a
+CommandResult supporting stdout/stderr/exitcode unpacking; connect(host) creates a child.
 run_file(path) executes one file; run_script(source) returns its namespace.
 Importing this module does not install .spy import hooks or console logging.
 """
@@ -32,18 +32,20 @@ def warning_on_one_line(message, category, filename, lineno, file=None, line=Non
     return '%s:%s: %s: %s\n' % (filename, lineno, category.__name__, message)
 if __package__:
     from ._version import __version__
-    from .session import Session
+    from .session import Session, CommandResult
     from .errorutils import SSHScriptExit, SSHScriptBreak, get_logger, set_logger, SSHScriptException,command_summary
     ## 2025/3/3 v2.0.3 feature: import *.spy file directly
     from . import spyimporter
+    from . import dollarparser
 else:
     ## 2024/8/16, should add mydir into sys.path for python 3.12
     mydir = os.path.abspath(os.path.dirname(__file__))
     if not mydir in sys.path: sys.path.insert(0,mydir)
     from _version import __version__
-    from session import Session
+    from session import Session, CommandResult
     from errorutils import SSHScriptExit, SSHScriptBreak, get_logger, set_logger, SSHScriptException,command_summary
     import spyimporter
+    import dollarparser
     ## 2024/8/16, should remove mydir out of sys.path for python 3.11
     if mydir == sys.path[0]: del sys.path[0]
 
@@ -55,6 +57,21 @@ sshscript_module = sys.modules[__package__ or __name__]
 logger = get_logger()
 spy_imports = spyimporter.spy_imports
 
+def check_file(script_path):
+    """Compile one Python/.spy source file without executing it or its imports.
+
+    Return 0 on success. SyntaxError retains the original filename and line.
+    This checks Python/dollar syntax, not shell syntax or remote availability.
+    """
+    import tokenize
+    if not isinstance(script_path, (str, os.PathLike)):
+        raise TypeError('script_path must be str or os.PathLike')
+    path = os.path.abspath(os.fspath(script_path))
+    with tokenize.open(path) as stream:
+        source = stream.read()
+    dollarparser.compile_spy(path, source)
+    return 0
+
 def run_file(
     script_path,
     vars=None,
@@ -283,9 +300,11 @@ def main():
                         help='show the installed version')
 
     ## new on v2.0.2
-    parser.add_argument('--check-updates', '--check', dest='checkversion',
+    parser.add_argument('--check-updates', dest='checkversion',
                         action='store_true', default=False,
                         help='check PyPI for a newer compatible stable release (requires internet)')
+    parser.add_argument('--check', action='store_true',
+                        help='check file syntax without execution; without a file, legacy update check')
 
     ## new on v3.1.0
     parser.add_argument(
@@ -329,7 +348,7 @@ def main():
     ## handling starts
     if (args.version):
         print(get_current_version())
-    elif (args.checkversion):
+    elif args.checkversion or (args.check and not args.path):
         sys.exit(_check_updates())
 
     elif args.path:
@@ -346,10 +365,17 @@ def main():
             os.environ['VERBOSE_STDERR'] = '1'
 
         try:
-            exitcode = run_file(
-                args.path,
-                showScript=args.showScript,
-            )
+            if args.check:
+                if unknown:
+                    parser.error('--check accepts exactly one file and no script arguments')
+                if args.showScript:
+                    parser.error('--check and --script cannot be combined')
+                exitcode = check_file(args.path)
+            else:
+                exitcode = run_file(
+                    args.path,
+                    showScript=args.showScript,
+                )
         except SSHScriptExit as e:
             sys.exit(e.errno)
         except SSHScriptException as e:

sshscript-3.1.5.dist-info/METADATA

@@ -0,0 +1,375 @@
+Metadata-Version: 2.4
+Name: sshscript
+Version: 3.1.5
+Summary: Python automation for local processes, SSH, and SSHScript .spy files
+Author-email: "Yeh, Hsin-Yuan" <iapyeh@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/iapyeh/sshscript
+Project-URL: Documentation, https://iapyeh.github.io/sshscript/v3a/
+Project-URL: Changelog, https://github.com/iapyeh/sshscript/blob/release/CHANGELOG.md
+Project-URL: Releases, https://github.com/iapyeh/sshscript/releases
+Project-URL: Source, https://github.com/iapyeh/sshscript
+Project-URL: Issues, https://github.com/iapyeh/sshscript/issues
+Project-URL: Security, https://github.com/iapyeh/sshscript/security/policy
+Project-URL: Support, https://github.com/iapyeh/sshscript/discussions
+Keywords: automation,paramiko,remote-execution,sftp,ssh,subprocess,system-administration
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: paramiko<5,>=2.11
+Requires-Dist: packaging>=21
+Dynamic: license-file
+
+# SSHScript
+
+[![PyPI](https://img.shields.io/pypi/v/sshscript)](https://pypi.org/project/sshscript/)
+[![Python](https://img.shields.io/pypi/pyversions/sshscript)](https://pypi.org/project/sshscript/)
+[![CI](https://github.com/iapyeh/sshscript/actions/workflows/ci.yml/badge.svg?branch=release)](https://github.com/iapyeh/sshscript/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/iapyeh/sshscript/actions/workflows/codeql.yml/badge.svg?branch=release)](https://github.com/iapyeh/sshscript/actions/workflows/codeql.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/iapyeh/sshscript/blob/release/LICENSE.txt)
+
+SSHScript is a Python automation library for running commands locally and over
+SSH through one `Session` API. It also provides optional dollar syntax for
+compact `.spy` automation files.
+
+**Current release:** [3.1.5](https://github.com/iapyeh/sshscript/releases/tag/v3.1.5)
+(Production/Stable) · **Python:** 3.11 or newer · **Tested:** Python
+3.11–3.14 on Linux and macOS
+
+[Documentation](https://iapyeh.github.io/sshscript/v3a/) ·
+[PyPI](https://pypi.org/project/sshscript/) ·
+[Changelog](https://github.com/iapyeh/sshscript/blob/release/CHANGELOG.md) ·
+[Security](https://github.com/iapyeh/sshscript/security/policy) ·
+[Support](https://github.com/iapyeh/sshscript/blob/release/SUPPORT.md)
+
+## Why SSHScript?
+
+- Use the same interface for local subprocesses and remote SSH commands.
+- Traverse nested SSH connections without rebuilding connection logic.
+- Keep ordinary Python functions, packages, exceptions, data processing, and
+  threading around your automation.
+- Scope connections, privilege changes, persistent shells, and interactive
+  programs with context managers.
+- Read stdout, stderr, and exit status directly after each command.
+- Add concise dollar syntax only where command-shaped notation improves a
+  script.
+
+## Install
+
+SSHScript requires Python 3.11 or newer. Installing in a virtual environment is
+recommended:
+
+```sh
+python3 -m venv .venv
+. .venv/bin/activate
+python3 -m pip install --upgrade pip
+python3 -m pip install sshscript
+sshscript --version
+```
+
+For a production deployment that requires repeatable dependency resolution,
+pin SSHScript and all transitive dependencies in your application's lock file.
+To install this release explicitly:
+
+```sh
+python3 -m pip install "sshscript==3.1.5"
+```
+
+Use `python3 -m pip install --upgrade sshscript` to upgrade. The optional
+`sshscript --check-updates` command queries PyPI and prints an upgrade command;
+it never installs an update by itself.
+
+## 60-second local quickstart
+
+```python
+import shlex
+import sys
+
+from sshscript import Session
+
+command = shlex.join([
+    sys.executable,
+    "-c",
+    "print('sshscript is ready')",
+])
+
+with Session() as local:
+    stdout, stderr, exitcode = local.exec_command(
+        command,
+        shell=False,
+        check=True,
+    )
+    print(str(stdout).strip())
+    print(f"exit code: {local.exitcode}")
+```
+
+Expected output:
+
+```text
+sshscript is ready
+exit code: 0
+```
+
+`exec_command()` accepts one nonempty command string or a nonempty list/tuple
+of string arguments. An argument sequence means **one command**, not a batch.
+Sequences execute directly on the local host and are quoted for a POSIX login
+shell over SSH; shell operators inside them are literal arguments. They accept
+only `shell=None` or `shell=False`, without `shell_executable`. Use a string
+with `shell=True` when you intentionally need shell operators.
+
+```python
+with Session() as local:
+    result = local.exec_command(
+        [sys.executable, "-c", "import sys; print(sys.argv[1])", "a; b"],
+        check=True,
+        timeout=30,
+    )
+    print(result.stdout, result.exitcode, result.duration)
+    stdout, stderr, exitcode = result  # three-value unpacking
+```
+
+Each call returns an immutable `CommandResult` containing text `stdout` and
+`stderr`, `exitcode`, `host`, `duration`, and `command`. `host` snapshots
+`session.host` (`None` locally); it does not execute `hostname`. `duration` is
+elapsed monotonic seconds for command execution and output collection,
+including communication and worker cleanup but excluding connection setup.
+`command` is the normalized string or an immutable tuple of arguments.
+`session.last_result` references the most recently completed command; saved
+results remain valid after later commands or session closure. Validation
+failures leave it alone; starting a command clears it until completion.
+
+Both local and remote commands accept `check=True` to raise
+`subprocess.CalledProcessError` for a nonzero status **after** preserving the
+result. The exception has text `stdout`/`stderr`, the normalized `cmd`, and a
+`result` attribute. With the default `check=False`, a nonzero status is result
+data. Connection errors and timeouts propagate unchanged.
+
+Compatibility: the returned object is no longer a tuple of live output
+buffers. Unpack exactly three values: stdout, stderr, exitcode. Indexing and
+slicing use that same three-value order; old two-value unpacking must change.
+Use `session.stdout`/`session.stderr` for the existing buffer interface.
+Persistent shell and interactive console APIs retain their existing buffer
+and prompt semantics; this result/check contract applies to one-shot Session
+commands, including `$` commands outside persistent consoles.
+
+## First secure SSH connection
+
+SSHScript uses Paramiko and verifies system host keys by default. Before the
+first connection, place the server key in the account's standard
+`known_hosts` file and verify its fingerprint through an independent trusted
+channel. Prefer an SSH agent, managed private key, or secret manager over a
+password embedded in source code.
+
+```python
+from sshscript import Session
+
+with Session() as local:
+    with local.connect(
+        "ops@example.net",
+        timeout=30,
+        banner_timeout=30,
+        auth_timeout=30,
+    ) as remote:
+        result = remote.exec_command(
+            ["uname", "-s"],
+            check=True,
+            timeout=30,
+        )
+        print(result.stdout.strip())
+```
+
+Unknown and changed host keys are rejected unless the caller explicitly
+supplies a different Paramiko policy. Do not use automatic key acceptance in a
+production workflow unless a separate trusted bootstrap process has already
+verified the key. See the
+[SSHScript v3 documentation](https://iapyeh.github.io/sshscript/v3a/) for
+nested connections, timeouts, file transfer, `sudo`, `su`, and interactive
+programs.
+
+## Reusing SSH configuration
+
+Connections from a local session read `~/.ssh/config` if it exists. Supported
+settings are `Host` patterns, `HostName`, `User`, `Port`, `IdentityFile`,
+`ProxyCommand`, and `ProxyJump`. Explicit API arguments override config, then
+built-in defaults apply. `port=None` means unspecified; an explicit `port=22`
+overrides a configured port. Explicit `pkey`, `pkey_path`, or `key_filename`
+overrides configured identity files. Host-key verification remains enabled.
+
+```python
+# Inspect effective settings without connecting or starting a proxy process.
+settings = Session.resolve_connection("production", port=2222)
+
+with Session() as local:
+    with local.connect("production") as remote:
+        result = remote(["uname", "-s"], check=True)
+```
+
+Pass `ssh_config=False` to disable config lookup, or `ssh_config="/path/config"`
+to require a particular file. Nested connections do not read local config
+unless an explicit file is supplied; proxy options remain unsupported on
+nested sessions. `session.host` and `result.host` use the resolved HostName.
+`resolve_connection()` returns effective Paramiko keyword arguments plus
+`proxyCommand`, when applicable; it performs no network operations.
+
+Config tokens `%h`, `%n`, `%p`, `%r`, `%u`, `%d`, and `%%` are expanded after
+explicit overrides for identity paths and configured proxy commands. Other
+tokens fail clearly. Explicit `proxyCommand` strings retain their historical
+verbatim behavior. Explicit `proxyCommand=None` disables configured proxies.
+You can also supply `proxyJump="user@bastion:2222"` or a comma-separated chain.
+When both configured proxy types are active, select one explicitly or remove
+the conflict; SSHScript does not implement OpenSSH's first-proxy-wins rule.
+
+`ProxyJump` uses the local `ssh` executable to forward to the target, with
+batch authentication and strict host-key checks on jump hosts. It requires
+known host keys and noninteractive authentication for those hops. The target
+connection remains managed and verified by Paramiko. A custom config file is
+also passed to `ssh`; otherwise its user config is used when present.
+
+This is a subset of OpenSSH configuration. `Match`, `Include`, and hostname
+canonicalization are rejected before lookup; other unapplied options produce
+a warning. In particular, alternate known-hosts files and identity-agent
+settings are not imported. Treat config and proxy commands as trusted local
+inputs; connecting may execute configured proxy programs.
+
+## Optional dollar syntax
+
+Dollar syntax is not ordinary Python syntax. It is normally stored in `.spy`
+files; `run_script(source)` also accepts Dollar syntax from an in-memory string.
+Both forms use the same session and transport implementation as the module API:
+
+```python
+# health.spy
+$hostname
+if $.exitcode != 0:
+    raise RuntimeError("hostname failed")
+print($.stdout.strip())
+
+with $.connect("ops@example.net"):
+    $uname -s
+    if $.exitcode != 0:
+        raise RuntimeError("remote uname failed")
+```
+
+Run exactly one file with:
+
+```sh
+sshscript health.spy
+```
+
+Check one file without executing its Python, imports, or commands:
+
+```sh
+sshscript --check health.spy
+```
+
+The exit status is 0 for valid syntax, 1 for a syntax/read failure, and 2 for
+invalid CLI usage. Syntax diagnostics show the original file, line, source,
+and caret. `sshscript.check_file(path)` provides the same compile-only check
+and raises source-located `SyntaxError` or filesystem errors. It validates
+Python/dollar syntax, not shell commands, imported modules, or remote hosts.
+`--script` remains available to inspect generated Python without execution.
+For compatibility, **`--check` without a file still checks PyPI for updates**;
+use `--check-updates` explicitly for that purpose.
+
+In version 3, a single `$` supports direct commands and shell features such as
+pipelines and redirection. The old `$$` form is retained for compatibility but
+is deprecated. New applications should start with the regular Python module
+API and adopt dollar syntax only when its notation is useful.
+
+The CLI and `run_file()` execute one file. Directories, globs, and multiple
+paths are intentionally unsupported. Importing SSHScript does not globally
+enable imports of `.spy` modules; use the temporary `sshscript.spy_imports()`
+context manager when a regular Python program needs that behavior.
+
+## Security model
+
+SSHScript executes commands and Python code; it is not a sandbox. Treat every
+`.spy` file, Python module, command string, remote host, and command output as a
+trust boundary. In particular:
+
+- never run unreviewed automation with production credentials;
+- avoid shell interpolation of external data;
+- keep credentials, private keys, inventories, and captured production output
+  out of source control;
+- verify host keys independently and retain timeouts around network operations;
+- validate site-specific PAM, `sudoers`, shell, and network policy in a
+  disposable environment before rollout.
+
+See the [security policy](https://github.com/iapyeh/sshscript/security/policy)
+for the complete reporting and security model, and the
+[stable exception contract](https://github.com/iapyeh/sshscript/blob/release/EXCEPTIONS.md)
+for runtime behavior.
+
+## Release confidence and provenance
+
+The 3.1 release line uses the following public controls:
+
+- CI on Linux and macOS with Python 3.11, 3.12, 3.13, and 3.14;
+- normal and optimized-mode tests, syntax smoke tests, compile checks, and a
+  runtime-assertion gate;
+- disposable loopback OpenSSH integration tests for host keys, SFTP, PTY,
+  `sudo`/`su`, and timeout behavior;
+- CodeQL and Dependabot;
+- PyPI Trusted Publishing with short-lived OIDC credentials;
+- GitHub build-provenance attestations and a SHA-256 `verified.json` manifest
+  attached to the GitHub Release.
+
+Download distributions from [PyPI](https://pypi.org/project/sshscript/) or the
+[GitHub Release](https://github.com/iapyeh/sshscript/releases/tag/v3.1.5), not
+from unverified mirrors. These controls establish tested behavior, artifact
+integrity, and release provenance; they are not a substitute for reviewing the
+automation you run or for validating your production environment.
+
+## Compatibility and support
+
+| Component | Current policy |
+| --- | --- |
+| SSHScript | Latest 3.1.x receives bug and security fixes |
+| Python | 3.11–3.14 are continuously tested |
+| Platforms | Current Linux and macOS releases |
+| SSH | OpenSSH integration is tested on Ubuntu; other servers are best effort |
+| Paramiko | Runtime dependency is `>=2.11,<5`; CI resolves a compatible release |
+| Windows | Not currently tested or supported |
+
+See the [support policy](https://github.com/iapyeh/sshscript/blob/release/SUPPORT.md)
+for scope, support channels, and the information needed in a useful bug report.
+
+## Development and verification
+
+A release checkout uses the `src/sshscript/` package layout:
+
+```sh
+python3 -m pip install 'paramiko>=2.11,<5' 'packaging>=21' build twine
+python3 tools/run_checks.py
+python3 tools/check_release.py --output /tmp/sshscript-candidate-UNIQUE
+```
+
+The output directory must not already exist. `run_checks.py` locates the test
+suite under `src/sshscript/unittest/` automatically. See the
+[contributing guide](https://github.com/iapyeh/sshscript/blob/release/CONTRIBUTING.md)
+before proposing a change and the
+[release guide](https://github.com/iapyeh/sshscript/blob/release/RELEASING.md)
+for maintainer-only release steps.
+
+## Project policies
+
+- [Changelog](https://github.com/iapyeh/sshscript/blob/release/CHANGELOG.md)
+- [Support policy](https://github.com/iapyeh/sshscript/blob/release/SUPPORT.md)
+- [Security policy](https://github.com/iapyeh/sshscript/security/policy)
+- [Stable exception contract](https://github.com/iapyeh/sshscript/blob/release/EXCEPTIONS.md)
+- [Contributing guide](https://github.com/iapyeh/sshscript/blob/release/CONTRIBUTING.md)
+- [Code of Conduct](https://github.com/iapyeh/sshscript/blob/release/CODE_OF_CONDUCT.md)
+
+## License
+
+SSHScript is released under the
+[MIT License](https://github.com/iapyeh/sshscript/blob/release/LICENSE.txt).

sshscript-3.1.5.dist-info/RECORD

@@ -0,0 +1,25 @@
+sshscript/__init__.py,sha256=yynfg2qm6lJ74Gwcx0ab06e-6Uf9lyEIuR9vabQGERA,2779
+sshscript/_version.py,sha256=QGa2cIG9obcBYmqJvXxzRZUypKmn6yVFUqspO2RjWx4,77
+sshscript/channelgeneric.py,sha256=3kUfggHKx8uasZqYVas7YnwhoIrxcEwEgSn-2lItzxg,73834
+sshscript/channelssh.py,sha256=Obco0J0J1PwUpyVKoWluVn_hGpUw5WrC51SPmuN1tIM,11969
+sshscript/channelsubprocess.py,sha256=hgFgDYeba-GQjlOp8sV0d7xl1imLyDDIEVxPh-49-7w,12092
+sshscript/channelutils.py,sha256=cIH-OcU4EiUMGBNw9r0LI7Z2BSN6zhwdOo7cnxFa4ws,19609
+sshscript/commandresult.py,sha256=0U9t9HglcEpCyehPw-MlkUg-rImSYyFZyHSzJJ8nUlQ,772
+sshscript/dollar.py,sha256=Ei1EiMZTvf6IUe9_e2vsb2do7rta-CoBOaJxqfUq3jU,24711
+sshscript/dollarchanger.py,sha256=mwG9xCJEI6yvH7s_SRebqnfMG5koeqIL7lfnLemhSkQ,30368
+sshscript/dollarparser.py,sha256=7cl4QgffzfueeGOPN-NeoLP_3bKm04I9cVtCyag7JcE,9638
+sshscript/errorutils.py,sha256=MgwYoPipEVCa9L33FmVoYXl77CD-Mrq958q_ft3cuvw,16386
+sshscript/patching.py,sha256=OXBRkAJpy2mC0aswqrhEhlgR5-Zs4K4f93rVcaLVwDg,6488
+sshscript/session.py,sha256=EzKr12APSH27unYmQlqQC7sj95SuEc5jkwdG0vNxATE,61610
+sshscript/sessionwrapper.py,sha256=r8_Q3JkmNSqVXjSeVgClk58bPpPghOVyWS9tnBhdObw,12731
+sshscript/spyimporter.py,sha256=ASAs2nPBU1mtpI7FquXYJctLFQR_PeGMnhjcw1G6LPg,5574
+sshscript/sshconfig.py,sha256=aPfVOd-bx4k7gBuDeSb55Y812G4QNGeL3sbZPLPdiic,6295
+sshscript/sshscript.py,sha256=O4YevYCfKSeBnvyU2hMi6Gao9YcPyULxdR0ge-5p7J4,16489
+sshscript/stdio.py,sha256=Ql_7wX7oJ5vY74uOlCaotwoyqXrNteYdSl-aM4ersVM,16040
+sshscript/tokenparser.py,sha256=9cYokDMXLSnwimZMkkuxH7S8PimhrKZJXLeOfqE5rNc,20053
+sshscript-3.1.5.dist-info/licenses/LICENSE.txt,sha256=FPqC-mLQDBkQ26LK_CAUGEUQQ7eyFTbftywlk2GMlls,1075
+sshscript-3.1.5.dist-info/METADATA,sha256=UM-JZ_tGI6bgf4yh4OUPTP8Nmo60H8hcq1b0kNnDTP8,16065
+sshscript-3.1.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+sshscript-3.1.5.dist-info/entry_points.txt,sha256=6fcLx-kJz2y_kehCAYQi7NqEuiflzEXiOlCl_E9j9uQ,55
+sshscript-3.1.5.dist-info/top_level.txt,sha256=Y-dzSWzuCbcKE8qSC2fvXTZulaSZVI7qk1lQhq1meMI,10
+sshscript-3.1.5.dist-info/RECORD,,

sshscript-3.1.4.dist-info/METADATA

@@ -1,178 +0,0 @@
-Metadata-Version: 2.4
-Name: sshscript
-Version: 3.1.4
-Summary: Python automation for local processes, SSH, and SSHScript .spy files
-Author-email: "Yeh, Hsin-Yuan" <iapyeh@gmail.com>
-License-Expression: MIT
-Project-URL: Documentation, https://iapyeh.github.io/sshscript/v3a/
-Project-URL: Source, https://github.com/iapyeh/sshscript
-Project-URL: Issues, https://github.com/iapyeh/sshscript/issues
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Topic :: System :: Systems Administration
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: paramiko<5,>=2.11
-Requires-Dist: packaging>=21
-Dynamic: license-file
-
-# SSHScript
-
-[![CI](https://github.com/iapyeh/sshscript/actions/workflows/ci.yml/badge.svg?branch=release)](https://github.com/iapyeh/sshscript/actions/workflows/ci.yml)
-[![CodeQL](https://github.com/iapyeh/sshscript/actions/workflows/codeql.yml/badge.svg?branch=release)](https://github.com/iapyeh/sshscript/actions/workflows/codeql.yml)
-
-SSHScript is a Python automation library and `.spy` script runner for executing
-commands locally or over SSH. It provides a regular Python `Session` API and a
-compact dollar syntax for automation scripts.
-
-## Installation
-
-SSHScript requires Python 3.11 or newer.
-
-Use `sshscript --version` to display the installed version, or
-`sshscript --check-updates` to query PyPI for a newer stable release compatible
-with the current Python version. The check only prints an upgrade command;
-it does not install anything. `--check` remains an alias. A failed query exits
-with status 1; a successful check exits with status 0, whether an update exists
-or not. This checks release Python requirements, not dependency resolution or
-platform availability.
-
-```sh
-python3 -m pip install sshscript
-```
-
-For a release checkout containing `src/sshscript/`, `python3 -m pip install .`
-installs that checkout. The flat development checkout is not an installable
-package; use the following checks instead:
-
-```sh
-python3 -m pip install 'paramiko>=2.11,<5' 'packaging>=21' build twine
-python3 tools/run_checks.py
-python3 tools/check_release.py --output /tmp/sshscript-candidate-UNIQUE
-```
-
-See [RELEASING.md](RELEASING.md) for synchronization and publishing. SSHScript
-3.1 is the supported production line; a GitHub source update does not by itself
-publish a new version to PyPI. See the
-[v3.1 documentation](https://iapyeh.github.io/sshscript/v3a/).
-
-## Python API
-
-```python
-from sshscript import Session
-
-session = Session()
-try:
-    stdout, stderr = session.exec_command("uname -a", shell=False)
-    print(str(stdout))
-    print(session.exitcode)
-finally:
-    session.close(strict=True)
-```
-
-Pass command arguments as a safely quoted string, for example with
-`shlex.join()`, and use `shell=False` when shell expansion is not required.
-
-## Running `.spy` files
-
-```sh
-sshscript automation.spy
-```
-
-The CLI and `run_file()` execute exactly one file. Directories, globs, and
-multiple paths are intentionally unsupported. Compose larger automation with
-SSHScript include syntax or ordinary Python imports.
-
-Importing SSHScript does not globally enable Python imports of `.spy` files.
-Use the explicit, temporary importer when a regular Python program needs one:
-
-```python
-import sshscript
-
-with sshscript.spy_imports():
-    import automation  # loads automation.spy
-```
-
-`run_file()` enables this importer only for the duration of the script, so
-imports between `.spy` files continue to work without additional setup.
-Threads created with `threading.Thread(...)` inside a `.spy` file inherit the
-session that is active when the thread is constructed, without patching the
-process-wide `threading.Thread` class.
-
-## SSH host-key security
-
-SSH connections verify system host keys by default and reject unknown or
-changed keys. Load the server key into `known_hosts` before connecting.
-
-Accepting a new key without verification must be an explicit decision:
-
-```python
-import paramiko
-
-remote = session.connect(
-    "user@new-host.example",
-    policy=paramiko.AutoAddPolicy(),
-)
-```
-
-Do this only in a trusted bootstrap environment. Interactive SSH sessions do
-not forward the complete local process environment; only terminal/locale
-defaults and values explicitly supplied through `env={...}` are sent.
-
-## Tests
-
-The canonical credential-free release gate is:
-
-```sh
-python3 tools/run_checks.py
-```
-
-It includes normal and optimized unit tests, compile checks, the package assert
-scan, and the `.spy` language smoke suite. Public CI additionally provisions a
-disposable loopback OpenSSH server to validate real SSH, SFTP, host-key, PTY,
-sudo/su and timeout behavior against the built wheel.
-
-The `.spy` language smoke suite can also be run directly:
-
-```sh
-python3 sshscript.py unittest/dollar_syntax.spy
-```
-
-Site-specific and credentialed SSH tests live under `unittest-v3/` and are not
-part of the default release gate. See [CONTRIBUTING.md](CONTRIBUTING.md) before
-running them.
-
-## Project status
-
-Version 3.1 is production/stable software. Public behavior is covered by the
-credential-free release gates and isolated OpenSSH integration CI. Operators
-should still validate site-specific PAM, sudoers, network and host-key policy in
-a disposable environment before production rollout.
-
-SSHScript is released under the MIT License.
-See [SUPPORT.md](SUPPORT.md), [SECURITY.md](SECURITY.md),
-[CONTRIBUTING.md](CONTRIBUTING.md), and [CHANGELOG.md](CHANGELOG.md) for project
-policies and release history.
-
-## Production exception contract
-
-SSHScript validates runtime inputs in both normal and optimized Python modes.
-See [the stable exception matrix](EXCEPTIONS.md). `AssertionError` was never a
-supported SSHScript API contract. User-written `.spy` assertions remain ordinary
-Python assertions: `python -O` removes them. Production scripts must use explicit
-status checks or `check=True` for command-success handling.
-
-```python
-with Session() as session:
-    session.exec_command("false", check=True)
-```
-
-A nonzero exit status otherwise remains result data, available as
-`session.exitcode`.

sshscript-3.1.4.dist-info/RECORD

@@ -1,23 +0,0 @@
-sshscript/__init__.py,sha256=cjjUOPbICmiAozH4_3aBpMJkcaUlIFFbVsgDxwgDEc0,2648
-sshscript/_version.py,sha256=v4LnAFtvMF2xPQifR-JKsZ93ImGm14rR1pVB-L1wVFE,77
-sshscript/channelgeneric.py,sha256=3kUfggHKx8uasZqYVas7YnwhoIrxcEwEgSn-2lItzxg,73834
-sshscript/channelssh.py,sha256=Obco0J0J1PwUpyVKoWluVn_hGpUw5WrC51SPmuN1tIM,11969
-sshscript/channelsubprocess.py,sha256=hgFgDYeba-GQjlOp8sV0d7xl1imLyDDIEVxPh-49-7w,12092
-sshscript/channelutils.py,sha256=cIH-OcU4EiUMGBNw9r0LI7Z2BSN6zhwdOo7cnxFa4ws,19609
-sshscript/dollar.py,sha256=lWmF1UNhXMdnNFKanppb-8QrOzgjxwghJh6AbYyGpGY,24600
-sshscript/dollarchanger.py,sha256=IlE9afIRDdUq1jFbwL_w_lwW3eqBVpOU4FEC6YYqMNw,30359
-sshscript/dollarparser.py,sha256=bwRYbI7m-k1N39fXrFY4D4GtgBkOAEC4tMuefIBYgGo,9374
-sshscript/errorutils.py,sha256=MgwYoPipEVCa9L33FmVoYXl77CD-Mrq958q_ft3cuvw,16386
-sshscript/patching.py,sha256=OXBRkAJpy2mC0aswqrhEhlgR5-Zs4K4f93rVcaLVwDg,6488
-sshscript/session.py,sha256=TnfjcJ0VhP3TqeIw614lOeJhNTKZzhOGFdf9dGyKQrY,58318
-sshscript/sessionwrapper.py,sha256=r8_Q3JkmNSqVXjSeVgClk58bPpPghOVyWS9tnBhdObw,12731
-sshscript/spyimporter.py,sha256=ASAs2nPBU1mtpI7FquXYJctLFQR_PeGMnhjcw1G6LPg,5574
-sshscript/sshscript.py,sha256=CiJmCq-oCXHKTj8GJRfrxpW3lNKncmjLeoC9hmNE4jo,15268
-sshscript/stdio.py,sha256=Ql_7wX7oJ5vY74uOlCaotwoyqXrNteYdSl-aM4ersVM,16040
-sshscript/tokenparser.py,sha256=9cYokDMXLSnwimZMkkuxH7S8PimhrKZJXLeOfqE5rNc,20053
-sshscript-3.1.4.dist-info/licenses/LICENSE.txt,sha256=FPqC-mLQDBkQ26LK_CAUGEUQQ7eyFTbftywlk2GMlls,1075
-sshscript-3.1.4.dist-info/METADATA,sha256=w7OCgiyd40FJsvvX8Aaz8-D9n2BR8guPghY6tFquABE,6431
-sshscript-3.1.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-sshscript-3.1.4.dist-info/entry_points.txt,sha256=6fcLx-kJz2y_kehCAYQi7NqEuiflzEXiOlCl_E9j9uQ,55
-sshscript-3.1.4.dist-info/top_level.txt,sha256=Y-dzSWzuCbcKE8qSC2fvXTZulaSZVI7qk1lQhq1meMI,10
-sshscript-3.1.4.dist-info/RECORD,,