sshreader 6.1.0__tar.gz → 6.2.0__tar.gz

{sshreader-6.1.0 → sshreader-6.2.0}/PKG-INFO

@@ -1,16 +1,14 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: sshreader
-Version: 6.1.0
+Version: 6.2.0
 Summary: Multi-threading/processing wrapper for Paramiko
+Author-Email: Jesse Almanrode <jesse@almanrode.com>
 License: LGPL-3.0-or-later
-Author: Jesse Almanrode
-Author-email: jesse@almanrode.com
-Requires-Python: >3.8,<3.14
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -18,30 +16,24 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Dist: click (>=8,<9)
-Requires-Dist: colorama (>=0.4,<0.5)
-Requires-Dist: paramiko (>=3,<4)
-Requires-Dist: progressbar2 (>=4,<5)
-Requires-Dist: python-hostlist (>=1,<2)
-Project-URL: Homepage, http://sshreader.readthedocs.io/
-Project-URL: Repository, https://bitbucket.org/isaiah1112/sshreader/
+Project-URL: homepage, http://sshreader.readthedocs.io/
+Project-URL: repository, https://bitbucket.org/isaiah1112/sshreader/
+Requires-Python: <4.0,>3.9
+Requires-Dist: click<9,>=8
+Requires-Dist: colorama<1.0,>=0.4
+Requires-Dist: paramiko<4,>=3
+Requires-Dist: progressbar2<5,>=4
+Requires-Dist: python-hostlist<2,>=1
 Description-Content-Type: text/markdown
 
-# [sshreader][]
+![logo](./logo.png)
 
-## Overview
+A Python Module for multiprocessing/threading ssh connections in order to make ssh operations
+across multiple servers parallel.  It utilizes the [Paramiko](http://www.paramiko.org/) module 
+for its ssh client.
 
-[SSHreader][] is a Python Module for multiprocessing/threading ssh connections in order to make ssh operations
-across multiple servers parallel.  It utilizes the [Paramiko](http://www.paramiko.org/) module for its ssh client.
-
-In order to maintain the widest range of compatibility, [SSHreader][] is currently tested using the following versions of
-Python:
-
-* Python3.9
-* Python3.10
-* Python3.11
-* Python3.12
-* Python3.13
+In order to maintain the widest range of compatibility, [SSHreader][] is currently tested 
+using [all supported versions of Python!](https://devguide.python.org/versions/)
 
 ## License
 
@@ -55,13 +47,16 @@ The most straightforward way to get the [SSHreader][] module working for you is:
 ```commandline
 pip install sshreader
 ```
+or, if you'd like to use a local install from the repo:
+```commandline
+make install
+```
 
 This ensures that all the requirements are met.
 
 ## Documentation
 
-The documentation for [SSHreader][] can be found [here](https://sshreader.readthedocs.io)
-
+The documentation for [SSHreader][] can be found at [ReadTheDocs.](https://sshreader.readthedocs.io)
 
 ## Contributing
 
@@ -69,37 +64,16 @@ Comments and enhancements are very welcome.
 
 Report any issues or feature requests on the [BitBucket bug
 tracker](https://bitbucket.org/isaiah1112/sshreader/issues?status=new&status=open). Please include a minimal
-(not-) working example which reproduces the bug and, if appropriate, the
- traceback information.  Please do not request features already being worked
+not-working example which reproduces the bug and, if appropriate, the
+traceback information.  Please do not request features already being worked
 towards.
 
 Code contributions are encouraged: please feel free to [fork the
 project](https://bitbucket.org/isaiah1112/sshreader) and submit pull requests to the develop branch.
 
-### Development Installation
-
-If you are wanting to work on development of [SSHreader][], first ensure [Poetry](https://python-poetry.org) is installed
-and then:
-
-```commandline
-poetry install --with dev
-```
-
-To ensure all development requirements are met. This will allow you to run the unit/integration tests!
-
-### Building Docs
-
-If you have installed [Poetry](https://python-poetry.org)] you can build its Sphinx Documentation for [SSHreader][] simply by:
-
-```commandline
-make docs
-```
-
-Then simply open `docs/build/html/index.html` in your browser.
-
 ## Extras
 
-Included with sshreader is a script called `pydsh`.  This works very similar to[pdsh](https://computing.llnl.gov/linux/pdsh.html) 
+Included with sshreader is a script called `pydsh`.  This works very similar to [pdsh](https://computing.llnl.gov/linux/pdsh.html) 
 but uses sshreader at its core to perform ssh commands in parallel and return the results.  
 The output of `pydsh` can also be piped through the `dshbak` tool that comes with pdsh.
 
@@ -110,4 +84,3 @@ to process.
 [GNU Lesser General Public License v3.0]: http://choosealicense.com/licenses/lgpl-3.0/ "LGPL v3"
 
 [sshreader]: https://bitbucket.org/isaiah1112/sshreader "SSHreader Package"
-

{sshreader-6.1.0 → sshreader-6.2.0}/README.md

@@ -1,18 +1,11 @@
-# [sshreader][]
+![logo](./logo.png)
 
-## Overview
+A Python Module for multiprocessing/threading ssh connections in order to make ssh operations
+across multiple servers parallel.  It utilizes the [Paramiko](http://www.paramiko.org/) module 
+for its ssh client.
 
-[SSHreader][] is a Python Module for multiprocessing/threading ssh connections in order to make ssh operations
-across multiple servers parallel.  It utilizes the [Paramiko](http://www.paramiko.org/) module for its ssh client.
-
-In order to maintain the widest range of compatibility, [SSHreader][] is currently tested using the following versions of
-Python:
-
-* Python3.9
-* Python3.10
-* Python3.11
-* Python3.12
-* Python3.13
+In order to maintain the widest range of compatibility, [SSHreader][] is currently tested 
+using [all supported versions of Python!](https://devguide.python.org/versions/)
 
 ## License
 
@@ -26,13 +19,16 @@ The most straightforward way to get the [SSHreader][] module working for you is:
 ```commandline
 pip install sshreader
 ```
+or, if you'd like to use a local install from the repo:
+```commandline
+make install
+```
 
 This ensures that all the requirements are met.
 
 ## Documentation
 
-The documentation for [SSHreader][] can be found [here](https://sshreader.readthedocs.io)
-
+The documentation for [SSHreader][] can be found at [ReadTheDocs.](https://sshreader.readthedocs.io)
 
 ## Contributing
 
@@ -40,37 +36,16 @@ Comments and enhancements are very welcome.
 
 Report any issues or feature requests on the [BitBucket bug
 tracker](https://bitbucket.org/isaiah1112/sshreader/issues?status=new&status=open). Please include a minimal
-(not-) working example which reproduces the bug and, if appropriate, the
- traceback information.  Please do not request features already being worked
+not-working example which reproduces the bug and, if appropriate, the
+traceback information.  Please do not request features already being worked
 towards.
 
 Code contributions are encouraged: please feel free to [fork the
 project](https://bitbucket.org/isaiah1112/sshreader) and submit pull requests to the develop branch.
 
-### Development Installation
-
-If you are wanting to work on development of [SSHreader][], first ensure [Poetry](https://python-poetry.org) is installed
-and then:
-
-```commandline
-poetry install --with dev
-```
-
-To ensure all development requirements are met. This will allow you to run the unit/integration tests!
-
-### Building Docs
-
-If you have installed [Poetry](https://python-poetry.org)] you can build its Sphinx Documentation for [SSHreader][] simply by:
-
-```commandline
-make docs
-```
-
-Then simply open `docs/build/html/index.html` in your browser.
-
 ## Extras
 
-Included with sshreader is a script called `pydsh`.  This works very similar to[pdsh](https://computing.llnl.gov/linux/pdsh.html) 
+Included with sshreader is a script called `pydsh`.  This works very similar to [pdsh](https://computing.llnl.gov/linux/pdsh.html) 
 but uses sshreader at its core to perform ssh commands in parallel and return the results.  
 The output of `pydsh` can also be piped through the `dshbak` tool that comes with pdsh.
 

sshreader-6.2.0/pyproject.toml

@@ -0,0 +1,83 @@
+[project]
+authors = [
+    { name = "Jesse Almanrode", email = "jesse@almanrode.com" },
+]
+requires-python = "<4.0,>3.9"
+dependencies = [
+    "click<9,>=8",
+    "colorama<1.0,>=0.4",
+    "paramiko<4,>=3",
+    "progressbar2<5,>=4",
+    "python-hostlist<2,>=1",
+]
+name = "sshreader"
+version = "6.2.0"
+description = "Multi-threading/processing wrapper for Paramiko"
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)",
+    "Development Status :: 5 - Production/Stable",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.license]
+text = "LGPL-3.0-or-later"
+
+[project.urls]
+homepage = "http://sshreader.readthedocs.io/"
+repository = "https://bitbucket.org/isaiah1112/sshreader/"
+
+[project.scripts]
+pydsh = "sshreader.scripts.pydsh:cli"
+
+[tool.pdm.build]
+includes = [
+    "sshreader",
+    "sshreader/scripts",
+]
+
+[tool.ruff.lint]
+select = [
+    "E",
+    "F",
+    "B",
+    "UP",
+    "B",
+    "SIM",
+    "I",
+]
+ignore = [
+    "E501",
+    "F401",
+]
+
+[[tool.uv.index]]
+name = "test-pypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[build-system]
+requires = [
+    "pdm-backend",
+]
+build-backend = "pdm.backend"
+
+[dependency-groups]
+test = [
+    "coverage<8,>=7",
+    "discover<1.0,>=0.4",
+    "ruff<1.0.0,>=0.9.9",
+]
+docs = [
+    "sphinx<8,>=7",
+]

{sshreader-6.1.0 → sshreader-6.2.0}/sshreader/__init__.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 """A Python Package for parallelizing ssh connections via threading and multiprocessing.
 """
 # Copyright (C) 2015-2025 Jesse Almanrode
@@ -17,11 +16,12 @@
 #     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 # For backwards compatibility
-from .ssh import SSH, envvars
-from .customtypes import Command, EnvVars, Timeout, TimeoutTuple
-from .utils import ServerJob, Hook, sshread, echo, cpu_limit, shell_command
 import logging
 
+from .customtypes import Command, EnvVars, Timeout, TimeoutTuple
+from .ssh import SSH, envvars
+from .utils import Hook, ServerJob, cpu_limit, echo, shell_command, sshread
+
 __author__ = 'Jesse Almanrode (jesse@almanrode.com)'
 __all__ = ['ssh', 'customtypes', 'utils']
 

{sshreader-6.1.0 → sshreader-6.2.0}/sshreader/customtypes.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 """ Typing module for sshreader
 """
 # Copyright (C) 2015-2025 Jesse Almanrode
@@ -15,7 +14,7 @@
 #
 #     You should have received a copy of the GNU Lesser General Public License
 #     along with this program.  If not, see <http://www.gnu.org/licenses/>.
-from typing import NamedTuple, Optional, Union, Tuple
+from typing import NamedTuple, Optional, Union
 
 
 class Command(NamedTuple):
@@ -34,4 +33,4 @@ class EnvVars(NamedTuple):
 
 
 Timeout = Union[int, float]
-TimeoutTuple = Tuple[Timeout, Timeout]
+TimeoutTuple = tuple[Timeout, Timeout]

{sshreader-6.1.0 → sshreader-6.2.0}/sshreader/scripts/__init__.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 """ Scripts portion of sshreader package
 """
 # Copyright (C) 2015-2025 Jesse Almanrode

{sshreader-6.1.0 → sshreader-6.2.0}/sshreader/scripts/pydsh.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 """ A Pythonic implementation of pdsh powered by sshreader
 """
 # Copyright (C) 2015-2025 Jesse Almanrode
@@ -16,17 +15,20 @@
 #     You should have received a copy of the GNU Lesser General Public License
 #     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import logging
+import os
+import sys
 from collections import defaultdict
 from hashlib import md5
-from hostlist import expand_hostlist, collect_hostlist
+
 import click
-import logging
-import os
+from hostlist import collect_hostlist, expand_hostlist
+
 import sshreader
-import sys
+
 # GLOBALS
 __author__ = 'Jesse Almanrode'
-__version__ = '3.1.0'
+__version__ = '3.2.0'
 __examples__ = """\b
 Examples:
     pydsh -w host1,host2,host3 "uname -r"
@@ -63,10 +65,7 @@ def output(thisjob):
     :param thisjob: <ServerJob> object
     :return: None
     """
-    if thisjob.status == 255:
-        result = thisjob.results[0]
-    else:
-        result = thisjob.results[0].stdout
+    result = thisjob.results[0] if thisjob.status == 255 else thisjob.results[0].stdout
     if len(result) != 0:
         for line in result.split('\n'):
             sshreader.echo(str(thisjob.name) + ': ' + str(line))
@@ -103,13 +102,10 @@ def coalesce(jobresults):
     job_hashes = defaultdict(list)
     output_hashes = dict()
     for job in jobresults:
-        if job.status == 255:
-            result = job.results[0]
-        else:
-            result = job.results[0].stdout
+        result = job.results[0] if job.status == 255 else job.results[0].stdout
         md5sum = md5(result.encode()).hexdigest()
         job_hashes[md5sum].append(job.name)
-        if md5sum not in output_hashes.keys():
+        if md5sum not in output_hashes:
             output_hashes[md5sum] = result
 
     for md5sum, stdout in output_hashes.items():
@@ -130,7 +126,7 @@ def validate_hostlist(ctx, param, value):
     try:
         return expand_hostlist(value)
     except Exception:
-        raise click.BadOptionUsage(param, 'Invalid hostlist expression')
+        raise click.BadOptionUsage(param, 'Invalid hostlist expression') from None
 
 
 @click.command(epilog=__examples__)
@@ -255,7 +251,7 @@ def cli(**kwargs):
             job.pre_hook = prehook
         jobs.append(job)
 
-    log.info('Sending %s ServerJobs to sshreader module' % (len(jobs),))
+    log.info(f'Sending {len(jobs)} ServerJobs to sshreader module')
     if kwargs['dshbak'] is False and kwargs['coalesce'] is False:
         if kwargs['redline']:
             sshreader.sshread(jobs, pcount=0, tcount=0, print_lock=True)

{sshreader-6.1.0 → sshreader-6.2.0}/sshreader/ssh.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 """A wrapper for Paramiko that attempts to make ssh sessions easier to work with.
 """
 # Copyright (C) 2015-2025 Jesse Almanrode
@@ -17,12 +16,14 @@
 #     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 import logging
 import os
-import paramiko
 import socket
 from getpass import getuser
 from typing import Any, Optional
 
+import paramiko
+
 from .customtypes import Command, EnvVars, Timeout
+
 log = logging.getLogger('sshreader')
 
 
@@ -56,7 +57,7 @@ def envvars() -> EnvVars:
     return EnvVars(**env)
 
 
-class SSH(object):
+class SSH:
     """SSH Session class which can be used to send commands to a remote server.  It also supports basic SFTP commands
     and can be used to push/pull files from a remote system.
 
@@ -80,16 +81,14 @@ class SSH(object):
     """
     def __init__(self, fqdn: str, username: str, password: Optional[str] = None, keyfile: Optional[str] = None,
                  keypass: Optional[str] = None, port: int = 22, connect: bool = True, rsa_sha2: bool = True) -> None:
-        if not keyfile:
-            if len(paramiko.Agent().get_keys()) == 0:
-                if not all((username, password)):
-                    paramiko.SSHException('username and password or keyfile not provided')
+        if not keyfile and len(paramiko.Agent().get_keys()) == 0 and not all((username, password)):
+            paramiko.SSHException('username and password or keyfile not provided')
         self.host = fqdn
         self.username = username
         self.password = password
         if keyfile:
             if not isinstance(keyfile, str):
-                raise TypeError('expected %s for keyfile, got %s' % (str(str), str(type(keyfile))))
+                raise TypeError(f'expected {str(str)} for keyfile, got {str(type(keyfile))}')
             self.keyfile = os.path.abspath(os.path.expanduser(keyfile))
         else:
             self.keyfile = keyfile
@@ -122,7 +121,7 @@ class SSH(object):
         :return: Result of :meth:`paramiko.SFTPClient.put()`
         """
         if not self.__alive():
-            raise paramiko.SSHException("connection to %s not established" % (self.host,))
+            raise paramiko.SSHException(f"connection to {self.host} not established")
         sftp = paramiko.SFTPClient.from_transport(self._connection.get_transport())
         try:
             result = sftp.put(os.path.expanduser(srcfile), os.path.expanduser(dstfile))
@@ -140,7 +139,7 @@ class SSH(object):
         :return: None
         """
         if not self.__alive():
-            raise paramiko.SSHException("connection to %s not established" % (self.host,))
+            raise paramiko.SSHException(f"connection to {self.host} not established")
         sftp = paramiko.SFTPClient.from_transport(self._connection.get_transport())
         try:
             sftp.get(os.path.expanduser(srcfile), os.path.expanduser(dstfile))
@@ -164,7 +163,7 @@ class SSH(object):
         :raises: :class:`paramiko.SSHException`
         """
         if self.__alive() is False:
-            raise paramiko.SSHException("connection to %s not established" % (self.host, ))
+            raise paramiko.SSHException(f"connection to {self.host} not established")
         if combine:
             try:
                 stdin, stdout, stderr = self._connection.exec_command(command, timeout=timeout, get_pty=True)
@@ -226,12 +225,10 @@ class SSH(object):
         :raises: :class:`paramiko.SSHException`
         """
         if self.__alive():
-            raise paramiko.SSHException("connection to %s already established" % (self.host, ))
+            raise paramiko.SSHException(f"connection to {self.host} already established")
         paramiko.util.logging.getLogger().setLevel(logging.CRITICAL)  # Keeping paramiko from logging errors to stdout
-        if not self.keyfile:
-            if len(paramiko.Agent().get_keys()) == 0:
-                if not all((self.username, self.password)):
-                    paramiko.SSHException('username and password or keyfile not provided')
+        if not self.keyfile and len(paramiko.Agent().get_keys()) == 0 and not all((self.username, self.password)):
+            paramiko.SSHException('username and password or keyfile not provided')
         if self.keyfile:
             if self.rsa_sha2:
                 self._connection.connect(self.host, port=self.port, username=self.username, password=self.keypass,

{sshreader-6.1.0 → sshreader-6.2.0}/sshreader/utils.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 """ All the classes and functions that make sshreader tick
 """
 # Copyright (C) 2015-2025 Jesse Almanrode
@@ -18,17 +17,17 @@
 import logging
 import multiprocessing
 import os
-import paramiko
 import subprocess
 import sys
 import threading
 import time
-from progressbar import ProgressBar
 from typing import Any, Callable, Optional, Union
 
+import paramiko
+from progressbar import ProgressBar
 
-from .ssh import SSH
 from .customtypes import Command, Timeout, TimeoutTuple
+from .ssh import SSH
 
 # Globals
 mpctx = multiprocessing.get_context('spawn')  # Forcing the forking type to spawn in older versions of Python3
@@ -68,7 +67,7 @@ def shell_command(command: str, combine: bool = False, decode_bytes: bool = True
     return result
 
 
-class Hook(object):
+class Hook:
     """ Custom class for creating "Hooks" that can execute code before of after a ServerJob object executes and
     can evn act on the data of a ServerJob when it is passed as the first argument to the Hook object.
 
@@ -117,7 +116,7 @@ class Hook(object):
         return str(self.__dict__)
 
 
-class ServerJob(object):
+class ServerJob:
     """ Custom class for holding all the info needed to run ssh commands or shell commands in sub-processes or threads
 
     :param fqdn: Fully qualified domain name or IP address
@@ -194,9 +193,8 @@ class ServerJob(object):
             self.post_hook = post_hook
         if run_local:
             self._conn = 'localhost'
-        elif not keyfile and len(paramiko.Agent().get_keys()) == 0:
-            if not all([username, password]):
-                raise paramiko.SSHException('username and password or ssh key not provided')
+        elif not keyfile and len(paramiko.Agent().get_keys()) == 0 and not all([username, password]):
+            raise paramiko.SSHException('username and password or ssh key not provided')
 
     def run(self) -> int:
         """Run a ServerJob. SSH to server, run cmds, return result
@@ -204,54 +202,54 @@ class ServerJob(object):
         :return: Sum of return codes for each command executed
         :rtype: int
         """
-        log.info('%s: starting ServerJob' % (self.name,))
+        log.info(f'{self.name}: starting ServerJob')
         if self.run_local:
             if self.pre_hook:
-                log.debug('%s: running prehook' % (self.name,))
+                log.debug(f'{self.name}: running prehook')
                 self.pre_hook.run(self)
             for cmd in self.cmds:
                 result = shell_command(cmd, combine=self.combine_output)
-                log.debug('%s: %s' % (self.name, str(result)))
+                log.debug(f'{self.name}: {str(result)}')
                 self.results.append(result)
                 self.status += result.return_code
             if self.post_hook:
-                log.debug('%s; running posthook' % (self.name,))
+                log.debug(f'{self.name}; running posthook')
                 self.post_hook.run(self)
         else:
             if self.pre_hook and self.pre_hook.ssh_established is False:
-                log.debug('%s: running prehook' % (self.name,))
+                log.debug(f'{self.name}: running prehook')
                 self.pre_hook.run(self)
             try:
                 self._conn = SSH(self.name, username=self.username, password=self.password, keyfile=self.key,
                                  port=self.ssh_port, connect=False, rsa_sha2=self.rsa_sha2)
                 self._conn.connect(timeout=self.ssh_timeout)
-                log.debug('%s: ssh connection established' % (self.name,))
+                log.debug(f'{self.name}: ssh connection established')
             except Exception as errorMsg:
                 log.debug(str(errorMsg))
                 self.status = 255
                 self.results.append(str(errorMsg))
             else:
                 if self.pre_hook and self.pre_hook.ssh_established:
-                    log.debug('%s: running prehook' % (self.name,))
+                    log.debug(f'{self.name}: running prehook')
                     self.pre_hook.run(self)
                 for cmd in self.cmds:
                     try:
                         result = self._conn.ssh_command(cmd, timeout=self.cmd_timeout, combine=self.combine_output)
                     except Exception as errorMsg:
                         result = Command(cmd, '', str(errorMsg), 54)
-                    log.debug('%s: %s' % (self.name, str(result)))
+                    log.debug(f'{self.name}: {str(result)}')
                     self.results.append(result)
                     self.status += result.return_code
                 if self.post_hook and self.post_hook.ssh_established:
-                    log.debug('%s; running posthook' % (self.name,))
+                    log.debug(f'{self.name}; running posthook')
                     self.post_hook.run(self)
                 self._conn.close()
             finally:
                 self._conn = None  # So the ssh connection can be pickled!
             if self.post_hook and self.post_hook.ssh_established is False:
-                log.debug('%s; running posthook' % (self.name,))
+                log.debug(f'{self.name}; running posthook')
                 self.post_hook.run(self)
-        log.info('%s: exiting ServerJob' % (self.name,))
+        log.info(f'{self.name}: exiting ServerJob')
         return self.status
 
     def __str__(self) -> str:
@@ -361,7 +359,7 @@ def sshread(serverjobs: list, pcount: Optional[int] = None, tcount: Optional[int
         else:
             tcount = int(min(tcount, totaljobs))
 
-        log.info(u'spawning %d threads' % (tcount, ))
+        log.info(f'spawning {tcount} threads')
         # Start a thread pool
         for thread in range(tcount):
             thread = threading.Thread(target=_sub_thread_, args=(task_queue, result_queue, item_counter, progress_bar),
@@ -389,7 +387,7 @@ def sshread(serverjobs: list, pcount: Optional[int] = None, tcount: Optional[int
                 # If we don't have enough jobs to spawn more than 1 thread per process, then we won't spawn threads
                 tcount = 0
 
-        log.info(u'spawning %d processes' % (pcount, ))
+        log.info(f'spawning {pcount} processes')
         for pid in range(pcount):
             pid = mpctx.Process(target=_sub_process_,
                                 args=(task_queue, result_queue, item_counter, tcount, progress_bar),
@@ -398,7 +396,7 @@ def sshread(serverjobs: list, pcount: Optional[int] = None, tcount: Optional[int
             pids.append(pid)
 
     # Non-blocking way to wait for threads/processes
-    log.debug('main waiting for %d ServerJobs to finish' % (totaljobs,))
+    log.debug(f'main waiting for {totaljobs} ServerJobs to finish')
     while result_queue.full() is False:
         if progress_bar:
             bar.update(item_counter.value)
@@ -407,12 +405,12 @@ def sshread(serverjobs: list, pcount: Optional[int] = None, tcount: Optional[int
         bar.finish()
 
     if len(threads) > 0:
-        log.info('joining %d threads' % (len(threads),))
+        log.info(f'joining {len(threads)} threads')
         for t in threads:
             if t.is_alive():
                 t.join(timeout=1)
     elif len(pids) > 0:
-        log.info('joining %d processes' % (len(pids),))
+        log.info(f'joining {len(pids)} processes')
         for p in pids:
             if p.is_alive():
                 p.join(timeout=1)
@@ -433,7 +431,7 @@ def _sub_process_(task_queue, result_queue, item_counter, thread_count, progress
     DO NOT USE THIS METHOD!
     """
     pid = os.getpid()
-    log.debug(u'starting process: %d' % (pid,))
+    log.debug(f'starting process: {pid}')
     if thread_count == 0:
         while task_queue.empty() is False:
             job = task_queue.get()
@@ -444,16 +442,16 @@ def _sub_process_(task_queue, result_queue, item_counter, thread_count, progress
                     item_counter.value += 1
     else:
         threads = list()
-        log.debug(u'process: %d spawning: %d threads' % (pid, thread_count))
+        log.debug(f'process: {pid} spawning: {thread_count} threads')
         for thread in range(thread_count):
             thread = threading.Thread(target=_sub_thread_, args=(task_queue, result_queue, item_counter, progress_bar),
                                       daemon=True)
             thread.start()
             threads.append(thread)
-        log.debug(u'process: %d waiting for: %d threads' % (pid, len(threads)))
+        log.debug(f'process: {pid} waiting for: {len(threads)} threads')
         for thread in threads:
             thread.join()
-    log.debug(u'exiting process: %d' % (pid,))
+    log.debug(f'exiting process: {pid}')
     return None
 
 

sshreader-6.2.0/tests/keys/id_rsa

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpAIBAAKCAQEAvJzuoZadl3gmPy+4f7mMtS/jpbHH7uxIih6aLRGNugF0Q/Xq
+8bS85mMBlHnz6lu6bDNiLa/Tq4gg8/T9LZ5WTfHWV2Eb4IKiop9k93/GkgSUN7tW
+Ig2GzvSgkqEU5SfR0C4V4N+DhJw5mi40AAEJtc1MN7wHvQ9YctV0L4800OZsn0xl
+LlfIruiP2QhaQ1LY1j0nuevHONxVN65zyOMF9pwp0WdJTiCyMx8NKcWxyi1GNOR+
+1GdANUP7DXRCOUN/JRJIQ2T04xdg+xIJLsEfNRdp8GKR7Gc7b/uwf2iBXgPhQ1pS
+s3yJOV+1WGG6xJ8RCm5Fw58cP/JTolbeRRFvhQIDAQABAoIBAEP+pyBltcZHMDKT
+N4YEFC+1ZfHz10nQsI3qXlZk/5zQrWNaoiokp/y+MHGgTUhtbRVYqMojmsE5v/dy
+mFr7u805o7W4cl5Leen6YGHBFIrLT8uPo4t/KNwu4Dw8CdZato7ALm705OrHjxSA
+F4rw1NlPe2yUQo3rnE05mjsS+01bRWJ8/K+EazDXAiVyOhcWnX/Q7yafhtwqelen
+sQiVChVk419SM/WZcqC9eeYVxM6JZRUrwV1ntKF4/8brwKazwUibsOhlrpqMB7yC
+HGR27XTwCpKHyBfFtc9XZOn15Nig5weHzcu9pNOlpNiG7Pn4jifSdU8q+9hEdZj+
+lRnr7zkCgYEA7U3Wd0i8ta3Z6os9DAMBuVJrPcyr4RQCkt48fH/CVrEh+IhC/gql
+OEMMmaIoarUI6yJikV7hOBJTn33EhyTMjg3I4jL8mxKLO50557uOuiOmfllX0BHD
+91HzBPKPju3nxVGHhPeUIlBpGjdalLY5sRGF3jIdCO2yggyJ2P7XGIcCgYEAy3kM
+tCNbM7a5L6WZ5pWbQNyqoqfO6WtrMCIpeAfEW9rYY2MLE6Lc7bPTUQ5NsSMpNtUK
+FLbku90CrYWi3OG//rfWPnhbchr7CJpwKjh0O3YQrzrfCj17RBAFdcUIHbsjPh17
+SBf489gvUFGYXyZTbg3sDgGLUWq7+To3k3lnVpMCgYEAhdjif9N6BSty/3Tb0Pud
+LE9Nh8T6qXBk5zwMd9iD3+v3EjyhNLMCb9J5t+oby9wilKWHXSFb/QlxO0Nv5x4d
+dn5V8Sf7DOiPuec7svY6Uckr7pYsDoMGumfxn7fEu0R69vO+cYRHfHdIYO4Z3ElQ
+DwyoKiSv9cpEZk/2LHvJDN8CgYB1JlPnH3gyNSE4SqtqdHa4CJUCI4XhJOTJCNJB
+do9ap4zw5CSLgLic721afNbEh08Cb/Rm6sqVU3FoQMn9TMkDOgtTWm6kKt6gHHM6
+C9j4J0kB6u5h8fYXwPWz0eaTX5yx9b12S78dfjn3j5MgLWvZsJBZnA//p2lk3F0F
+Pt/9mwKBgQCCRFX8Cgwkz6S+7kIWExZ+Dt3RtpKD+caZIoJaRZ4yHGAB+dHjk/G+
+PDuGGnHRjFU/R20YLm19b+nlwJiE/LcqA+esOyDaOyLCC1H87b0vJVzrqD2XPogL
+zNRVIA1Uz/d5q4eCLP5jMCIPEDXQq34uXYVtzn7A0RG7EU9KCxVhyA==
+-----END RSA PRIVATE KEY-----

sshreader-6.2.0/tests/keys/id_rsa.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC8nO6hlp2XeCY/L7h/uYy1L+Olscfu7EiKHpotEY26AXRD9erxtLzmYwGUefPqW7psM2Itr9OriCDz9P0tnlZN8dZXYRvggqKin2T3f8aSBJQ3u1YiDYbO9KCSoRTlJ9HQLhXg34OEnDmaLjQAAQm1zUw3vAe9D1hy1XQvjzTQ5myfTGUuV8iu6I/ZCFpDUtjWPSe568c43FU3rnPI4wX2nCnRZ0lOILIzHw0pxbHKLUY05H7UZ0A1Q/sNdEI5Q38lEkhDZPTjF2D7EgkuwR81F2nwYpHsZztv+7B/aIFeA+FDWlKzfIk5X7VYYbrEnxEKbkXDnxw/8lOiVt5FEW+F

sshreader-6.2.0/tests/test_pydsh.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+# coding=utf-8
+""" Integration and Unit tests for pydsh script
+"""
+import os
+import sys
+import unittest
+import warnings
+from click.testing import CliRunner
+
+__author__ = 'Jesse Almanrode (jesse@almanrode.com)'
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(project_root)
+import sshreader.scripts.pydsh as pydsh
+
+global ssh_data
+# Defaults for testing with Docker!
+ssh_data = {"host_fqdn": "127.0.0.1", "host_port": os.getenv('SSH_PORT', 22),
+            "ssh_user": "sshreader", "ssh_password": "sunshine",
+            "ssh_key_path": project_root + "/tests/keys/id_rsa"}
+
+
+class TestPydsh(unittest.TestCase):
+    """ Test cases for the pydsh cli
+    """
+
+    def setUp(self) -> None:
+        self.cli = CliRunner()
+
+    def test_help(self):
+        self.assertEqual(self.cli.invoke(pydsh.cli, ['--help']).exit_code, 0)
+        pass
+
+    def test_password_auth(self):
+        global ssh_data
+        cli_result = self.cli.invoke(pydsh.cli, ['-w', ssh_data['host_fqdn'], '--port', ssh_data['host_port'],
+                                                 '-u', ssh_data['ssh_user'], '-P', ssh_data['ssh_password'],
+                                                 'uname'])
+        self.assertIn('Linux', cli_result.stdout)
+        self.assertEqual(cli_result.exit_code, 0)
+        pass
+
+    def test_keyfile_auth(self):
+        global ssh_data
+        cli_result = self.cli.invoke(pydsh.cli, ['-w', ssh_data['host_fqdn'], '--port', ssh_data['host_port'],
+                                                 '-u', ssh_data['ssh_user'], '-k', ssh_data['ssh_key_path'],
+                                                 'uname'])
+        self.assertIn('Linux', cli_result.stdout)
+        self.assertEqual(cli_result.exit_code, 0)
+        pass
+
+    def test_hostlist_port(self):
+        global ssh_data
+        host_port = ssh_data['host_fqdn'] + ':' + str(ssh_data['host_port'])
+        cli_result = self.cli.invoke(pydsh.cli, ['-w', host_port,
+                                                 '-u', ssh_data['ssh_user'], '-k', ssh_data['ssh_key_path'],
+                                                 'uname'])
+        self.assertIn('Linux', cli_result.stdout)
+        self.assertEqual(cli_result.exit_code, 0)
+        pass
+
+    def test_dshbak_output(self):
+        global ssh_data
+        cli_result = self.cli.invoke(pydsh.cli, ['-w', ssh_data['host_fqdn'], '--port', ssh_data['host_port'],
+                                                 '-u', ssh_data['ssh_user'], '-k', ssh_data['ssh_key_path'],
+                                                 '-D', 'uname'])
+        self.assertIn('Linux', cli_result.stdout)
+        self.assertEqual(cli_result.exit_code, 0)
+        pass
+
+    def test_coalesce_output(self):
+        global ssh_data
+        cli_result = self.cli.invoke(pydsh.cli, ['-w', ssh_data['host_fqdn'], '--port', ssh_data['host_port'],
+                                                 '-u', ssh_data['ssh_user'], '-k', ssh_data['ssh_key_path'],
+                                                 '-C', 'uname'])
+        self.assertIn('Linux', cli_result.stdout)
+        self.assertEqual(cli_result.exit_code, 0)
+        pass
+
+
+if __name__ == '__main__':
+    with warnings.catch_warnings(record=True):
+        unittest.main()

sshreader-6.2.0/tests/test_sshreader.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python
+# coding=utf-8
+""" Integration and Unit tests for sshreader Python Package
+"""
+import os
+import sys
+import unittest
+import warnings
+
+__author__ = 'Jesse Almanrode (jesse@almanrode.com)'
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.append(project_root)
+import sshreader
+
+global ssh_data
+# Defaults for testing with Docker!
+ssh_data = {"host_fqdn": "127.0.0.1", "host_port": os.getenv('SSH_PORT', 22),
+            "ssh_user": "sshreader", "ssh_password": "sunshine",
+            "ssh_key_path": project_root + "/tests/keys/id_rsa"}
+
+
+class TestMisc(unittest.TestCase):
+    """ Test Cases for miscellaneous functions of SSH module
+    """
+
+    def test_env_variables(self):
+        """ Test envvars method"""
+        ssh_env = sshreader.envvars()
+        self.assertIsNotNone(ssh_env.username)
+        pass
+
+    def test_shell_command(self):
+        """ Test shell_command method
+        """
+        result = sshreader.shell_command('echo "foo"')
+        self.assertEqual(result.return_code, 0)
+        self.assertIn('foo', result.stdout)
+        self.assertEqual(len(result.stderr), 0)
+        pass
+
+    def test_shell_command_combined(self):
+        """ Test combining stdout and stderr of shell_command method
+        """
+        result = sshreader.shell_command('echo "foo"; echo "bar" 1>&2', combine=True)
+        self.assertEqual(result.return_code, 0)
+        self.assertIn('foo', result.stdout)
+        self.assertIn('bar', result.stdout)
+        self.assertEqual(result.stderr, None)
+        pass
+
+    def test_shell_command_stderr(self):
+        """ Test stderr of shell_command method
+        """
+        result = sshreader.shell_command('echo "bar" 1>&2')
+        self.assertEqual(result.return_code, 0)
+        self.assertEqual(len(result.stdout), 0)
+        self.assertIn('bar', result.stderr)
+        pass
+
+    def test_decode_bytes(self):
+        """ Test to ensure that result is a unicode string type
+        """
+        result = sshreader.shell_command('uname -a')
+        self.assertEqual(result.return_code, 0)
+        self.assertIsInstance(result.stdout, str)
+        pass
+
+    def test_bytes(self):
+        """ Test to ensure that result is a bytes string type
+        """
+        result = sshreader.shell_command('uname -a', decode_bytes=False)
+        self.assertEqual(result.return_code, 0)
+        self.assertIsInstance(result.stdout, bytes)
+        result = sshreader.shell_command('uname -a', combine=True, decode_bytes=False)
+        self.assertEqual(result.return_code, 0)
+        self.assertIsInstance(result.stdout, bytes)
+        pass
+
+
+class TestSSH(unittest.TestCase):
+    """ Test cases for the SSH class
+    """
+
+    def test_password(self):
+        """ Test an SSH connection using a password
+        """
+        global ssh_data
+        with sshreader.SSH(ssh_data['host_fqdn'], port=ssh_data['host_port'], username=ssh_data['ssh_user'],
+                           password=ssh_data['ssh_password']) as conn:
+            self.assertTrue(conn.alive())
+            self.assertEqual(conn.ssh_command('uname').stdout, 'Linux')
+        pass
+
+    def test_keyfile(self):
+        """ Test an SSH connection using an ssh key
+        """
+        global ssh_data
+        with sshreader.SSH(ssh_data['host_fqdn'], port=ssh_data['host_port'], username=ssh_data['ssh_user'],
+                           keyfile=ssh_data['ssh_key_path']) as conn:
+            self.assertTrue(conn.alive())
+            self.assertEqual(conn.ssh_command('uname').stdout, 'Linux')
+        pass
+
+    def test_reconnect(self):
+        """ Test re-opening an SSH connection
+        """
+        global ssh_data
+        conn = sshreader.SSH(ssh_data['host_fqdn'], port=ssh_data['host_port'], username=ssh_data['ssh_user'],
+                             password=ssh_data['ssh_password'], connect=False)
+        self.assertFalse(conn.alive())
+        conn.reconnect()
+        self.assertTrue(conn.alive())
+        conn.close()
+        pass
+
+    def test_command(self):
+        """ Test commands over ssh
+        """
+        with sshreader.SSH(ssh_data['host_fqdn'], port=ssh_data['host_port'], username=ssh_data['ssh_user'],
+                           password=ssh_data['ssh_password']) as conn:
+            cmd = conn.ssh_command('uname')
+            self.assertEqual(cmd.stdout, 'Linux')
+            self.assertEqual(cmd.stderr, '')
+            cmd = conn.ssh_command('uname 1>&2')
+            self.assertEqual(cmd.stderr, 'Linux')
+            self.assertEqual(cmd.stdout, '')
+            cmd = conn.ssh_command('echo foo; echo bar 1>&2;', combine=True)
+            self.assertIn('foo', cmd.stdout)
+            self.assertIn('bar', cmd.stdout)
+            self.assertIsNone(cmd.stderr)
+            cmd = conn.ssh_command('sleep 5', timeout=2)
+            self.assertEqual(cmd.return_code, 124)
+            self.assertIn('command timed out', cmd.stderr)
+        pass
+
+
+def my_hook(*args):
+    """ Function for testing hook
+    :param args: Args should be ('pre|post', sshreader.ServerJob)
+    :return:
+    """
+    args = list(args)
+    if len(args) == 1:
+        if args[0] in ('pre', 'post') and isinstance(args.pop(), sshreader.ServerJob):
+            return True
+        else:
+            return False
+    else:
+        if args[0] in ('pre', 'post'):
+            return True
+        else:
+            return False
+
+
+class TestSshreader(unittest.TestCase):
+    """ Test cases for the sshreader module
+    """
+
+    @staticmethod
+    def configure_serverjob_list(size):
+        """ Configure a list of serverjob objects to sshread (including pre and post hooks) and local commands
+        :return: List
+        """
+        global ssh_data
+        pre = sshreader.Hook(my_hook, args=['pre'])
+        post = sshreader.Hook(my_hook, args=['post'])
+        jobs = list()
+        for x in range(size):
+            x = sshreader.ServerJob(ssh_data['host_fqdn'], ['sleep 1', 'echo done'], pre_hook=pre, post_hook=post,
+                                    username=ssh_data['ssh_user'], password=ssh_data['ssh_password'],
+                                    ssh_port=ssh_data['host_port'])
+            jobs.append(x)
+        for x in range(size):
+            jobs.append(sshreader.ServerJob('local-' + str(x), ['sleep 1', 'echo done'], run_local=True))
+        return jobs
+
+    def test_Hook_creation(self):
+        """ Test valid hook creation
+        """
+        myhook = sshreader.Hook(my_hook, args=['pre'])
+        self.assertIsInstance(myhook, sshreader.Hook)
+        pass
+
+    def test_ServerJob(self):
+        """ Test valid ServerJob creation
+        """
+        global ssh_data
+        job = sshreader.ServerJob(ssh_data['host_fqdn'], 'echo foo', ssh_port=ssh_data['host_port'],
+                                  username=ssh_data['ssh_user'], password=ssh_data['ssh_password'])
+        self.assertIsInstance(job, sshreader.ServerJob)
+        pass
+
+    def test_ServerJob_with_hooks(self):
+        """ Test ServerJob with hooks
+        """
+        global ssh_data
+        pre = sshreader.Hook(my_hook, args=['pre'])
+        post = sshreader.Hook(my_hook, args=['post'])
+        job = sshreader.ServerJob(ssh_data['host_fqdn'], 'echo foo', pre_hook=pre, post_hook=post,
+                                  username=ssh_data['ssh_user'], password=ssh_data['ssh_password'],
+                                  ssh_port=ssh_data['host_port'])
+        self.assertIsInstance(job, sshreader.ServerJob)
+        pass
+
+    def test_sshread_threads(self):
+        """ Test sshread method using threads
+        """
+        jobs = self.configure_serverjob_list(1)
+        result = sshreader.sshread(jobs, tcount=0)
+        for x in result:
+            self.assertEqual(x.status, 0, msg=x.results)
+        pass
+
+    def test_sshread_processes(self):
+        """ Test sshread method using processes
+        """
+        jobs = self.configure_serverjob_list(1)
+        result = sshreader.sshread(jobs, pcount=0)
+        for x in result:
+            self.assertEqual(x.status, 0, msg=x.results)
+        pass
+
+    def test_sshread(self):
+        """ Test sshread method using threads and processes
+        """
+        jobs = self.configure_serverjob_list(1)
+        result = sshreader.sshread(jobs, pcount=0, tcount=0)
+        for x in result:
+            self.assertEqual(x.status, 0, msg=x.results)
+        pass
+
+    def test_cpu_limit(self):
+        """ Ensure the cpu_limit methods
+        """
+        self.assertIsInstance(sshreader.utils.cpu_limit(), int)
+        self.assertIsInstance(sshreader.utils.cpu_limit(2), int)
+        pass
+
+
+if __name__ == '__main__':
+    with warnings.catch_warnings(record=True):
+        unittest.main()

sshreader-6.1.0/pyproject.toml

@@ -1,53 +0,0 @@
-[tool.poetry]
-name = "sshreader"
-version = "6.1.0"
-description = "Multi-threading/processing wrapper for Paramiko"
-authors = ["Jesse Almanrode <jesse@almanrode.com>"]
-license = "LGPL-3.0-or-later"
-readme = "README.md"
-homepage = "http://sshreader.readthedocs.io/"
-repository = "https://bitbucket.org/isaiah1112/sshreader/"
-classifiers = [
-    "Programming Language :: Python",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)",
-    "Development Status :: 5 - Production/Stable",
-    "Programming Language :: Python",
-    "Programming Language :: Python :: 3.9",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Topic :: Software Development :: Libraries",
-    "Topic :: Software Development :: Libraries :: Python Modules"
-    ]
-packages = [{include = "sshreader"}, {include = "sshreader/scripts"}]
-
-[tool.poetry.scripts]
-pydsh = 'sshreader.scripts.pydsh:cli'
-
-[tool.poetry.dependencies]
-python = ">3.8,<3.14"
-click = "^8"
-colorama = "^0.4"
-paramiko = "^3"
-progressbar2 = "^4"
-python-hostlist = "^1"
-
-[tool.poetry.group.dev]
-optional = true
-
-[tool.poetry.group.dev.dependencies]
-coverage = "^7"
-discover = "^0.4"
-flake8 = "^5"
-
-[tool.poetry.group.docs]
-optional = true
-
-[tool.poetry.group.docs.dependencies]
-sphinx = "^7"
-
-[build-system]
-requires = ["poetry-core"]
-build-backend = "poetry.core.masonry.api"