skilleter-thingy 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

skilleter_thingy/ffind.py

@@ -26,11 +26,10 @@ import pwd
 import datetime
 import re
 import shlex
-import copy
 import logging
+import subprocess
 
 from thingy import git
-from thingy import run
 from thingy import dircolors
 from thingy import colour
 
@@ -39,7 +38,7 @@ from thingy import colour
 def error(msg, status=1):
     """ Report an error message and exit """
 
-    sys.stderr.write('%s\n' % msg)
+    sys.stderr.write(f'{msg}\n')
     sys.exit(status)
 
 ################################################################################
@@ -48,7 +47,7 @@ def report_exception(exc):
     """ Handle an exception triggered inside os.walk - currently just reports
         the exception - typically a permission error. """
 
-    sys.stderr.write('%s\n' % exc)
+    sys.stderr.write(f'{exc}\n')
 
 ################################################################################
 
@@ -68,17 +67,18 @@ def report_file(args, filepath, filestat, dircolour):
     if args.exec:
         # Copy the exec string and insert the file
 
-        cmd = copy.copy(args.exec)
-        cmd[cmd.index('^')] = filepath
+        cmd = []
+        for i in args.exec:
+            cmd.append(i.replace('^', filepath))
 
         logging.debug('Running "%s"', ' '.join(cmd))
 
         # Attempt to run the command
 
         try:
-            run.run(cmd, stdout=sys.stdout, stderr=sys.stderr)
-        except run.RunError as exc:
-            error(exc.msg)
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as exc:
+            error('%s failed with status=%d' % (' '.join(cmd), exc.returncode))
         except FileNotFoundError:
             error('File not found attempting to run "%s"' % ' '.join(cmd))
         except PermissionError:
@@ -86,7 +86,7 @@ def report_file(args, filepath, filestat, dircolour):
 
     if args.verbose or not args.exec:
         if args.zero:
-            sys.stdout.write('%s\0' % filepath)
+            sys.stdout.write(f'{filepath}\0')
         else:
             # Colourise output if required
 
@@ -96,7 +96,7 @@ def report_file(args, filepath, filestat, dircolour):
             # Quote the file if necessary
 
             if not args.unquoted and ' ' in filepath:
-                filepath = '"%s"' % filepath
+                filepath = f'"{filepath}"'
 
             # Output full details or just the filename
 
@@ -186,7 +186,7 @@ def grep_match(regex, filename):
 
     recomp = re.compile(regex)
 
-    with open(filename, 'r', errors='ignore') as infile:
+    with open(filename, 'r', errors='ignore', encoding='utf8') as infile:
         for text in infile:
             if recomp.search(text):
                 break
@@ -299,7 +299,7 @@ def validate_arguments(args):
     if args.type:
         for t in args.type:
             if t not in ['b', 'c', 'd', 'p', 'f', 'l', 's']:
-                error('Invalid type "%s"' % t)
+                error(f'Invalid type "{t}"')
 
     # Precompile regexes if using them
 
@@ -392,14 +392,15 @@ def validate_arguments(args):
     # marker if it isn't there.
 
     if args.exec:
-        if args.exec.count('^') > 1:
+        replacements = args.exec.count('^')
+
+        if replacements > 1:
             error('Too many "^" characters in the exec string')
+        elif not replacements:
+            args.exec = f'{args.exec} ^'
 
         args.exec = shlex.split(args.exec)
 
-        if '^' not in args.exec:
-            args.exec.append('^')
-
     # If the path option has been used, try to switch to the specified directory
 
     if args.path:
@@ -501,9 +502,11 @@ def main():
                     diff_cmd.append(file)
 
             try:
-                run.run(diff_cmd)
-            except Exception as exc:
-                error(exc)
+                subprocess.run(diff_cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+            except subprocess.CalledProcessError as exc:
+                error(f'Diff failed with status={exc.returncode}')
+            except FileNotFoundError:
+                error('Unable to run %s' % ' '.join(diff_cmd))
 
     # Report the number of objects found
 

skilleter_thingy/git_cleanup.py

@@ -105,7 +105,7 @@ def main():
     # Get the list of all local branches
 
     try:
-        all_branches = [branch for branch in git.branches()]
+        all_branches = git.branches()
     except git.GitError as exc:
         colour.error(exc.msg, status=exc.status)
 

skilleter_thingy/git_review.py

@@ -47,7 +47,6 @@ import sys
 import argparse
 import curses
 import curses.panel
-import curses.textpad
 import pickle
 import fnmatch
 import subprocess
@@ -200,7 +199,7 @@ class PopUp():
                 else:
                     break
 
-    def __exit__(self, exc_type, exc_value, exc_traceback):
+    def __exit__(self, _exc_type, _exc_value, _exc_traceback):
         """ Remove the popup """
 
         if self.panel:

skilleter_thingy/git_update.py

@@ -18,6 +18,9 @@
 
    TODO: Avoid lots of pulls - should be able to fetch then updated each local branch.
    TODO: Add option to specify name of master branch or additional names to add to the list
+   TODO: Config entry for regularly-ignored branches
+   TODO: Config entry for branches that shouldn't be rebased (main, master, release/*)
+   TODO: Command line option when using -a to skip working trees that are modified
 """
 ################################################################################
 

skilleter_thingy/gitcmp_helper.py

@@ -43,9 +43,9 @@ import argparse
 import filecmp
 import re
 import logging
+import subprocess
 
 from thingy import colour
-from thingy import run
 from thingy import files
 from thingy import git
 from thingy import dircolors
@@ -81,7 +81,7 @@ def report_permissions(perm):
         permtext.append(mask_char if permissions & mask else '-')
         mask >>= 1
 
-    return '%s' % ''.join(permtext)
+    return ''.join(permtext)
 
 ################################################################################
 
@@ -146,7 +146,7 @@ def main():
     # Check and handle for the simple case of an unmerged file
 
     if args.old_file is None:
-        colour.write('[CYAN:%s] is not merged' % args.file_path)
+        colour.write(f'[CYAN:{args.file_path}] is not merged')
         sys.exit(0)
 
     # Make sure that we have all the expected parameters
@@ -158,11 +158,11 @@ def main():
     # Make sure we can access the temporary files supplied
 
     if not os.access(args.old_file, os.R_OK):
-        sys.stderr.write('Unable to read temporary old file: %s\n' % args.old_file)
+        sys.stderr.write(f'Unable to read temporary old file: {args.old_file}\n')
         sys.exit(2)
 
     if not os.access(args.new_file, os.R_OK):
-        sys.stderr.write('Unable to read temporary new file: %s\n' % args.new_file)
+        sys.stderr.write(f'Unable to read temporary new file: {args.new_file}\n')
         sys.exit(2)
 
     dc = dircolors.Dircolors()
@@ -195,12 +195,12 @@ def main():
     # If processing more than one file, append he index and total number of files
 
     if path_total > 0:
-        heading.append('(%d/%d)' % (path_count, path_total))
+        heading.append(f'({path_count}/{path_total})')
 
     # Check for newly created/deleted files (other version will be '/dev/null')
 
-    created_file = (args.old_file == '/dev/null')
-    deleted_file = (args.new_file == '/dev/null')
+    created_file = args.old_file == '/dev/null'
+    deleted_file = args.new_file == '/dev/null'
 
     if created_file:
         heading.append('(new file)')
@@ -232,11 +232,11 @@ def main():
     formatted_new_size = files.format_size(new_size, always_suffix=True)
 
     if created_file:
-        colour.write('    New size:             [CYAN:%s]' % formatted_new_size)
+        colour.write(f'    New size:             [CYAN:{formatted_new_size}]')
     elif deleted_file:
-        colour.write('    Original size:        [CYAN:%s]' % formatted_old_size)
+        colour.write(f'    Original size:        [CYAN:{formatted_old_size}]')
     elif new_size == old_size:
-        colour.write('    Size:                 [CYAN]%s[NORMAL] (no change)' % formatted_new_size)
+        colour.write(f'    Size:                 [CYAN]{formatted_new_size}[NORMAL] (no change)')
     else:
         formatted_delta_size = files.format_size(abs(new_size - old_size), always_suffix=True)
 
@@ -297,9 +297,12 @@ def main():
 
             if not deleted_file or not skip_deleted:
                 try:
-                    run.run([difftool, args.old_file, args.new_file])
-                except run.RunError as exc:
-                    print('Diff failed: %s' % exc.msg)
+                    subprocess.run([difftool, args.old_file, args.new_file], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)
+                except subprocess.CalledProcessError as exc:
+                    print(f'WARNING: Diff failed - status = {exc.returncode}')
+                except FileNotFoundError:
+                    print(f'ERROR: Unable to locate diff tool {difftool}')
+                    sys.exit(1)
 
     # Separate reports with a blank line
 

skilleter_thingy/rpylint.py

@@ -10,8 +10,11 @@ import os
 import sys
 import argparse
 import glob
+import subprocess
 
-import thingy.process as process
+################################################################################
+
+PYLINT = 'pylint'
 
 ################################################################################
 
@@ -32,26 +35,30 @@ def main():
 
     sourcefiles = []
 
-    # Use rgrep to find source files that have a Python 3 #!
+    # Use rgrep to find source files that have a Python 3 hashbang
 
     for entry in args.paths:
         if os.path.isdir(entry):
-            try:
-                sourcefiles += process.run(['rgrep', '-E', '--exclude-dir=.git', '-l', '#![[:space:]]*/usr/bin/(env[[:space:]])?python3'] + args.paths)
-            except process.RunError as exc:
-                if exc.status == 1:
-                    sys.stderr.write('No Python3 source files found\n')
-                    sys.exit(2)
-                else:
-                    sys.stderr.write('%d: %s\n' % (exc.status, exc.msg))
-                    sys.exit(1)
+            result = subprocess.run(['rgrep', '-E', '--exclude-dir=.git', '-l', '#![[:space:]]*/usr/bin/(env[[:space:]])?python3'] + args.paths,
+                                    capture_output=True, check=False, text=True)
+
+            if result.returncode == 1:
+                sys.stderr.write('No Python3 source files found\n')
+                sys.exit(2)
+
+            if result.returncode:
+                sys.stderr.write(f'ERROR #{result.returncode}: {result.stderr}')
+                sys.exit(1)
+
+            sourcefiles += result.stdout.split('\n')
+
         elif os.path.isfile(entry):
             sourcefiles.append(entry)
         else:
             files = glob.glob(entry)
 
             if not files:
-                sys.stderr.write('No files found matching "%s"' % entry)
+                sys.stderr.write(f'No files found matching "{entry}"')
                 sys.exit(2)
 
             sourcefiles += files
@@ -59,18 +66,19 @@ def main():
     # Run pylint on all the files
 
     try:
-        process.run(['pylint3', '--output-format', 'parseable'] + sourcefiles, foreground=True)
-    except process.RunError as exc:
-        status = exc.status
-    else:
-        status = 0
+        result = subprocess.run([PYLINT, '--output-format', 'parseable'] + sourcefiles, capture_output=False, check=False, text=True)
+
+    except FileNotFoundError:
+        sys.stderr.write(f'Unable to locate {PYLINT}\n')
+        sys.exit(1)
 
-    if status >= 64:
-        sys.stderr.write('Unexpected error: %d\n' % status)
+    if result.returncode >= 64:
+        sys.stderr.write(f'Unexpected error: {result.returncode}\n')
+        sys.exit(3)
 
     # Function return code is the status return from pylint
 
-    return status
+    return result.returncode
 
 ################################################################################
 

skilleter_thingy/tfm.py

@@ -82,8 +82,6 @@ import os
 import sys
 import argparse
 import curses
-import curses.panel
-import curses.textpad
 import subprocess
 import shutil
 from collections import defaultdict

skilleter_thingy/thingy/docker.py

@@ -12,7 +12,7 @@
 """
 ################################################################################
 
-import thingy.process as process
+import thingy.run as run
 
 ################################################################################
 
@@ -33,9 +33,9 @@ def instances(all=False):
 
     instances_list = []
     try:
-        for result in process.run(cmd):
+        for result in run.run(cmd):
             instances_list.append(result)
-    except process.RunError as exc:
+    except run.RunError as exc:
         raise DockerError(exc)
 
     return instances_list
@@ -48,8 +48,8 @@ def stop(instance, force=False):
     # TODO: force option not implemented
 
     try:
-        process.run(['docker', 'stop', instance], foreground=True)
-    except process.RunError as exc:
+        run.run(['docker', 'stop', instance], output=True)
+    except run.RunError as exc:
         raise DockerError(exc)
 
 ################################################################################
@@ -65,8 +65,8 @@ def rm(instance, force=False):
     cmd.append(instance)
 
     try:
-        process.run(cmd, foreground=True)
-    except process.RunError as exc:
+        run.run(cmd, output=True)
+    except run.RunError as exc:
         raise DockerError(exc)
 
 ################################################################################
@@ -75,9 +75,9 @@ def images():
     """ Return a list of all current Docker images """
 
     try:
-        for result in process.run(['docker', 'images', '-q']):
+        for result in run.run(['docker', 'images', '-q']):
             yield result
-    except process.RunError as exc:
+    except run.RunError as exc:
         raise DockerError(exc)
 
 ################################################################################
@@ -92,6 +92,6 @@ def rmi(image, force=False):
     cmd.append(image)
 
     try:
-        process.run(cmd, foreground=True)
-    except process.RunError as exc:
+        run.run(cmd, foreground=True)
+    except run.RunError as exc:
         raise DockerError(exc)

skilleter_thingy/thingy/files.py

@@ -11,8 +11,7 @@
 
 import os
 import shutil
-
-import thingy.process as process
+import subprocess
 
 ################################################################################
 
@@ -31,7 +30,7 @@ def file_type(filename, mime=False):
     # is not a file, so we have to do that.
 
     if not os.path.isfile(filename) or not os.access(filename, os.R_OK):
-        raise IOError('Unable to access %s' % filename)
+        raise FileNotFoundError('Unable to access %s' % filename)
 
     cmd = ['file', '--brief']
 
@@ -40,8 +39,9 @@ def file_type(filename, mime=False):
 
     cmd.append(filename)
 
-    result = process.run(cmd)
-    return result[0] if result else ""
+    result = subprocess.run(cmd, capture_output=True, check=False, text=True)
+
+    return result.stdout.split('\n')[0] if result.returncode==0 else None
 
 ################################################################################
 
@@ -148,7 +148,7 @@ if __name__ == "__main__":
     for mimeflag in (False, True):
         print('/bin/sh is:             %s' % file_type('/bin/sh', mimeflag))
         print('/bin/dash is:           %s' % file_type('/bin/dash', mimeflag))
-        print('git-ca is:              %s' % file_type('git-ca', mimeflag))
+        print('multigit.py is:         %s' % file_type('multigit.py', mimeflag))
         print('')
 
     for sizevalue in (0, 1, 999, 1024, 1025, 1.3 * 1024, 2**32 - 1, 2**64 + 2**49):

skilleter_thingy/thingy/git.py

@@ -948,18 +948,21 @@ def ref(fields=('objectname'), sort=None, remotes=False, path=None):
 
 ################################################################################
 
-def branches(all=False, path=None):
+def branches(all=False, path=None, remote=False):
     """ Return a list of all the branches in the current repo """
 
-    cmd = ['branch']
+    cmd = ['branch', '--format=%(refname:short)','--list']
 
     if all:
         cmd.append('--all')
 
+    if remote:
+        cmd.append('--remote')
+
     results = []
     for output in git(cmd, path=path):
         if ' -> ' not in output and '(HEAD detached at ' not in output:
-            results.append(output[2:])
+            results.append(output)
 
     return results
 
@@ -1250,7 +1253,10 @@ def matching_branch(branchname, case=False, path=None):
         otherwise, it just checks for a branches containing the branchname
         as a substring. """
 
-    all_branches = branches(all=True, path=path)
+    local_branches = branches(path=path)
+    remote_branches = branches(path=path, remote=True)
+
+    all_branches = local_branches + remote_branches
 
     # Always return exact matches
 
@@ -1284,8 +1290,8 @@ def matching_branch(branchname, case=False, path=None):
                 # If the match is a remote branch, ignore it if we already have the equivalent
                 # local branch, otherwise add the name of the local branch that would be created.
 
-                if branch.startswith('remotes/'):
-                    localbranch = '/'.join(branch.split('/')[2:])
+                if branch in remote_branches:
+                    localbranch = '/'.join(branch.split('/')[1:])
                     if localbranch not in matching:
                         matching_remote.append(localbranch)
                 else:

skilleter_thingy/thingy/popup.py

@@ -14,6 +14,7 @@ the popup again.
 
 import time
 import curses
+import curses.panel
 
 ################################################################################
 
@@ -71,7 +72,7 @@ class PopUp():
                 curses.panel.update_panels()
                 self.screen.refresh()
 
-    def __exit__(self, exc_type, exc_value, exc_traceback):
+    def __exit__(self, _exc_type, _exc_value, _exc_traceback):
         """ Remove the popup """
 
         if self.panel:

skilleter_thingy/thingy/run.py

@@ -37,108 +37,125 @@ class RunError(Exception):
 
 ################################################################################
 
-def capture_output(cmd, input_stream, output_streams, ansi_clean):
-    """ Capture data from a stream (input_stream), optionally
-        outputting it (if output_streams is not None and optionally
-        saving it into a variable (data, if not None), terminating
-        when the specified command (cmd, which is presumed to be the process
-        outputting to the input stream) exits.
-        TODO: Use of convert_ansi should be controlled via a parameter (off/light/dark)
-        TODO: Another issue is that readline() only returns at EOF or EOL, so if you get a prompt "Continue?" with no newline you do not see it until after you respond to it.
+# TODO: This is the _process() and run() replacement once additional parameters have been implemented
+# as those functions are probably over-specified, so need to work out what functionality is ACTUALLY being used!
+
+def command(cmd, show_stdout=False, show_stderr=False):
     """
+    Run an external command and optionally stream its stdout/stderr to the console
+    while capturing them.
 
-    while True:
-        output = input_stream.readline()
+    Args:
+        cmd: Command to run (string or argv list). If a string, it will be split with shlex.split().
+        show_stdout: If True, echo stdout lines to the console as they arrive.
+        show_stderr: If True, echo stderr lines to the console as they arrive.
 
-        if output:
-            if output_streams:
-                for stream in output_streams:
-                    if isinstance(stream, list):
-                        stream.append(output.rstrip())
-                    else:
-                        if stream in (sys.stdout, sys.stderr):
-                            stream.write(tidy.convert_ansi(output))
-                        elif ansi_clean:
-                            stream.write(tidy.remove_ansi(output))
-                        else:
-                            stream.write(output)
+    Returns:
+        (returncode, stdout_lines, stderr_lines)
+    """
 
-        elif cmd.poll() is not None:
-            return
+    def _pump(stream, sink, echo):
+        """Thread to capture and optionally echo output from subprocess.Popen"""
+
+        # Read line-by-line until EOF
+
+        for line in iter(stream.readline, ""):
+            # Strip trailing newline when storing; keep original when echoing
+            sink.append(line.rstrip("\n"))
+
+            if echo:
+                print(tidy.convert_ansi(line), end="", flush=True)
+
+        stream.close()
+
+    # Normalize command to be a string
+
+    if isinstance(cmd, str):
+        cmd = shlex.split(cmd)
+
+    # Storage for stdout/stderr
+
+    stdout_lines = []
+    stderr_lines = []
+
+    # Start process with separate pipes; line-buffering for timely reads
+
+    proc = subprocess.Popen(
+        cmd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True,                 # decode to str
+        bufsize=1,                 # line-buffered
+        universal_newlines=True,   # compatibility alias
+        errors="replace"           # avoid crashes on decoding issues
+    )
+
+    # Threads to read both streams concurrently (prevents deadlocks)
+
+    t_out = threading.Thread(target=_pump, args=(proc.stdout, stdout_lines, show_stdout))
+    t_err = threading.Thread(target=_pump, args=(proc.stderr, stderr_lines, show_stderr))
+
+    t_out.start()
+    t_err.start()
+
+    # Wait for process to complete and threads to drain
+
+    returncode = proc.wait()
+    t_out.join()
+    t_err.join()
+
+    # Return the status, stdout and stderr
+
+    return returncode, stdout_lines, stderr_lines
 
 ################################################################################
 
-def capture_continuous(cmd, input_stream, output_streams, ansi_clean):
+def capture_output(cmd, input_stream, output_streams):
     """ Capture data from a stream (input_stream), optionally
         outputting it (if output_streams is not None and optionally
         saving it into a variable (data, if not None), terminating
         when the specified command (cmd, which is presumed to be the process
         outputting to the input stream) exits.
         TODO: Use of convert_ansi should be controlled via a parameter (off/light/dark)
-        TODO: ansi_clean not implemented
+        TODO: Another issue is that readline() only returns at EOF or EOL, so if you get a prompt "Continue?" with no newline you do not see it until after you respond to it.
     """
 
-    output_buffer = []
-
     while True:
-        output = input_stream.read(1)
+        output = input_stream.readline()
 
         if output:
             if output_streams:
                 for stream in output_streams:
                     if isinstance(stream, list):
-                        if output == '\n':
-                            stream.append(''.join(output_buffer))
-                            output_buffer = []
-                        else:
-                            output_buffer.append(output)
+                        stream.append(output.rstrip())
                     else:
-                        stream.write(output)
-                        stream.flush()
+                        if stream in (sys.stdout, sys.stderr):
+                            stream.write(tidy.convert_ansi(output))
+                        else:
+                            stream.write(output)
 
         elif cmd.poll() is not None:
-            if output_buffer:
-                stream.append(''.join(output_buffer))
-
             return
 
 ################################################################################
 
-def process(command,
-            stdout=None, stderr=None,
-            return_stdout=False, return_stderr=False,
-            shell=False,
-            output=None,
-            ansi_clean=False,
-            exception=True,
-            continuous=False):
+def _process(command,
+             stdout=None, stderr=None,
+             output=None):
     """ Run an external command.
 
         stdout and stderr indicate whether stdout/err are output and/or sent to a file and/or stored in a variable.
         They can be boolean (True: output to sys.stdout/err, False: Do nothing), a file handle or a variable, or an
         array of any number of these (except booleans).
 
-        return_stdout and return_stderr indicate whether stdout/err should be returned from the function (setting
-        these to False saves memory if the output is not required).
-
-        If shell is True the command will be run in a shell and wildcard arguments expanded
-
-        If exception is True an exception will be raised if the command returns a non-zero status
-
         If output is True then stdout and stderr are both output as if stdout=True and stderr=True (in addition to
         any other values passed in those parameters)
 
-        If ansi_clean is True then ANSI control sequences are removed from any streams in stdout and stderr but
-        not from the console output.
-
-        If continuous is True then output is processed character-by-character (normally for use when output=True)
-        TODO: Currently this causes the ansi_clean option to be ignored
-
         The return value is a tuple consisting of the status code, captured stdout (if any) and captured
         stderr (if any).
 
-        Will raise OSError if the command could not be run and RunError if exception is True and the
-        command returned a non-zero status code. """
+        Will raise OSError if the command could not be run and RunError if the command returned a non-zero status code.
+    """
 
     # If stdout/stderr are booleans then output to stdout/stderr if True, else discard output
 
@@ -165,26 +182,16 @@ def process(command,
         if sys.stderr not in stderr:
             stderr.append(sys.stderr)
 
-    # Capture stdout/stderr to arrays unless asked not to
+    # Capture stdout/stderr to arrays
 
     stdout_data = []
     stderr_data = []
 
-    if return_stdout:
-        stdout.append(stdout_data)
-
-    if return_stderr:
-        stderr.append(stderr_data)
+    stdout.append(stdout_data)
+    stderr.append(stderr_data)
 
-    # If running via the shell then the command should be a string, otherwise
-    # it should be an array
-
-    if shell:
-        if not isinstance(command, str):
-            command = ' '.join(command)
-    else:
-        if isinstance(command, str):
-            command = shlex.split(command, comments=True)
+    if isinstance(command, str):
+        command = shlex.split(command, comments=True)
 
     # Use a pipe for stdout/stderr if are are capturing it
     # and send it to /dev/null if we don't care about it at all.
@@ -206,19 +213,18 @@ def process(command,
                            stderr=stderr_stream,
                            text=True,
                            errors='ignore',
-                           encoding='ascii',
-                           shell=shell)
+                           encoding='ascii')
 
     # Create threads to capture stderr and/or stdout if necessary
 
     if stdout_stream == subprocess.PIPE:
-        stdout_thread = threading.Thread(target=capture_continuous if continuous else capture_output, args=(cmd, cmd.stdout, stdout, ansi_clean), daemon=True)
+        stdout_thread = threading.Thread(target=capture_output, args=(cmd, cmd.stdout, stdout), daemon=True)
         stdout_thread.start()
     else:
         stdout_thread = None
 
     if stderr_stream == subprocess.PIPE:
-        stderr_thread = threading.Thread(target=capture_continuous if continuous else capture_output, args=(cmd, cmd.stderr, stderr, ansi_clean), daemon=True)
+        stderr_thread = threading.Thread(target=capture_output, args=(cmd, cmd.stderr, stderr), daemon=True)
         stderr_thread.start()
     else:
         stderr_thread = None
@@ -233,13 +239,10 @@ def process(command,
 
     cmd.wait()
 
-    # If the command failed, raise an exception (if required)
+    # If the command failed, raise an exception
 
-    if exception and cmd.returncode:
-        if return_stderr:
-            raise RunError('\n'.join(stderr_data))
-        else:
-            raise RunError('Error %d running "%s"' % (cmd.returncode, (command if isinstance(command, str) else ' '.join(command))))
+    if cmd.returncode:
+        raise RunError('\n'.join(stderr_data) if stderr_data else 'Error %d running "%s"' % (cmd.returncode, ' '.join(command)))
 
     # Return status, stdout, stderr (the latter 2 may be empty if we did not capture data).
 
@@ -248,107 +251,34 @@ def process(command,
 ################################################################################
 
 def run(command,
-        stdout=None, stderr=None,
-        shell=False,
-        output=None,
-        ansi_clean=False,
-        exception=True,
-        continuous=False):
-    """ Simple interface to the process() function
+        stdout=None,
+        stderr=None,
+        output=None):
+    """ Simple interface to the _process() function
         Has the same parameters, with the same defaults.
         The return value is either the data output to stdout, if any
         or the data output to stderr otherwise.
         The status code is not returned, but the function will raise an exception
-        by default if it is non-zero """
+        if it is non-zero """
 
-    result = process(command=command,
-                     stdout=stdout, stderr=stderr,
-                     return_stdout=True, return_stderr=True,
-                     shell=shell,
-                     output=output,
-                     ansi_clean=ansi_clean,
-                     exception=exception,
-                     continuous=continuous)
+    result = _process(command=command,
+                      stdout=stdout,
+                      stderr=stderr,
+                      output=output)
 
     return result['stdout'] if result['stdout'] else result['stderr']
 
 ################################################################################
 
-def status(command, shell=False, output=False):
-    """ Alternative simple interface to the process() function
-        Just takes a command and the shell flag.
-        Runs the command without capturing the output
-        Optionally outputting both stdout and stderr
-        and returns the status code.
-        Will only raise an exception if the command could not be run. """
-
-    return process(command,
-                   stdout=output,
-                   stderr=output,
-                   shell=shell,
-                   exception=False)['status']
-
-################################################################################
-# Legacy compatibility layer for process.py API
-
-def run_process(command, foreground=False, shell=False):
-    """
-    Legacy compatibility function for process.py API.
-
-    Args:
-        command: Command to run (string or list)
-        foreground: If True, run in foreground with output to console
-        shell: Whether to use shell for execution
-
-    Returns:
-        List of output lines (empty if foreground=True)
-
-    Raises:
-        RunError: If command fails
-    """
-    if foreground:
-        # For foreground mode, output directly to console
-        try:
-            status_result = status(command, shell=shell, output=True)
-            if status_result != 0:
-                raise RunError(f"Command failed with return code {status_result}")
-            return []  # process.py returns empty list for foreground mode
-        except Exception as e:
-            if isinstance(e, RunError):
-                raise
-            raise RunError(f"Command failed: {str(e)}")
-    else:
-        # For background mode, capture and return output
-        try:
-            result = run(command, shell=shell, exception=True)
-            if isinstance(result, list):
-                return [line.rstrip() for line in result if line.strip()]
-            elif isinstance(result, str):
-                return [line.rstrip() for line in result.splitlines() if line.strip()]
-            return []
-        except Exception as e:
-            if isinstance(e, RunError):
-                raise
-            raise RunError(f"Command failed: {str(e)}")
-
-################################################################################
-
 if __name__ == '__main__':
     def test_run(cmd,
-                 stdout=None, stderr=None,
-                 return_stdout=True, return_stderr=True,
-                 shell=False,
-                 exception=True):
+                 stdout=None, stderr=None):
         """ Test wrapper for the process() function. """
 
         print('-' * 80)
         print('Running: %s' % (cmd if isinstance(cmd, str) else ' '.join(cmd)))
 
-        result = process(cmd,
-                         stdout=stdout, stderr=stderr,
-                         return_stdout=return_stdout, return_stderr=return_stderr,
-                         shell=shell,
-                         exception=exception)
+        result = _process(cmd, stdout=stdout, stderr=stderr)
 
         print('Status: %d' % result['status'])
 
@@ -358,19 +288,19 @@ if __name__ == '__main__':
         test_run('echo nothing')
 
         test_run(['ls', '-l', 'run_jed'])
-        test_run(['ls -l run_*'], stdout=True, shell=True)
-        test_run('false', exception=False)
-        test_run('true', stdout=sys.stdout, exception=False)
-        test_run(['git', 'status'], stdout=sys.stdout, stderr=sys.stderr, exception=False)
+        test_run(['ls -l run_*'], stdout=True)
+        test_run('false')
+        test_run('true', stdout=sys.stdout)
+        test_run(['git', 'status'], stdout=sys.stdout, stderr=sys.stderr)
 
-        test_run(['make'], stderr=sys.stderr, exception=False)
-        test_run(['make'], stdout=sys.stdout, stderr=[sys.stderr], exception=False)
-        test_run(['make'], stdout=True, exception=False)
-        test_run(['make'], stdout=sys.stdout, exception=False)
-        test_run(['make'], exception=False)
+        test_run(['make'], stderr=sys.stderr)
+        test_run(['make'], stdout=sys.stdout, stderr=[sys.stderr])
+        test_run(['make'], stdout=True)
+        test_run(['make'], stdout=sys.stdout)
+        test_run(['make'])
 
         output = []
-        test_run('ls -l x*; sleep 1; echo "Bye!"', stderr=[sys.stderr, output], stdout=sys.stdout, shell=True, return_stdout=False)
+        test_run('ls -l x*; sleep 1; echo "Bye!"', stderr=[sys.stderr, output], stdout=sys.stdout)
         print('Output=%s' % output)
 
     test()

skilleter_thingy/x.py

@@ -0,0 +1,3 @@
+import subprocess
+
+subprocess.check_call(['ls'])

{skilleter_thingy-0.2.13.dist-info → skilleter_thingy-0.2.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skilleter_thingy
-Version: 0.2.13
+Version: 0.2.15
 Summary: A collection of useful utilities, mainly aimed at making Git more friendly
 Author-email: John Skilleter <john@skilleter.org.uk>
 Project-URL: Home, https://skilleter.org.uk

{skilleter_thingy-0.2.13.dist-info → skilleter_thingy-0.2.15.dist-info}/RECORD

@@ -2,22 +2,22 @@ skilleter_thingy/__init__.py,sha256=rVPTxm8L5w52U0YdTd7r_D44SBP7pS3JCJtsf0iIsow,
 skilleter_thingy/addpath.py,sha256=4Yhhgjjz1XDI98j0dAiQpNA2ejLefeWUTeSg3nIXQq0,3842
 skilleter_thingy/console_colours.py,sha256=BOS9mo3jChx_FE8L1j488MDoVNgib11KjTRhrz_YRYE,1781
 skilleter_thingy/docker_purge.py,sha256=PRQ7EBXymjYIHuJL4pk4r6KNn09IF28OGZ0ln57xtNg,3314
-skilleter_thingy/ffind.py,sha256=rEgotUaMj9JxDCwz-7H5vdqxH_bXllaHqttwsOUGKj8,19235
+skilleter_thingy/ffind.py,sha256=kIMx3VDvNpvTbp0gDzsiOiSlV_R8xZowHxADjts9qI0,19571
 skilleter_thingy/ggit.py,sha256=BL-DhNcz4Nd3sA-3Kl6gZ-zFtbNqOpyufvas-0aD8nk,2465
 skilleter_thingy/ggrep.py,sha256=fnTzOI1Qbf7IY_TnStdx5uqeUhqSDkapxmhYgrONJHw,5887
 skilleter_thingy/git_br.py,sha256=QdFU5HPLoV4YKX0bVLX_j_6Kv00TDenU6o3_ufbQAq8,6004
 skilleter_thingy/git_ca.py,sha256=nkbxPS0BZQ8WXsiqf7dbcUyKXus6Bz4MSJ5olCWNUQQ,5168
-skilleter_thingy/git_cleanup.py,sha256=22wrUNzd4BH3gi2ZL_rdw1vrPUNkJFb0pFFu_tuzhKs,10542
+skilleter_thingy/git_cleanup.py,sha256=3T8vkDJHsEVMTMkC2ARo8KHJ4zgPo6mmABVeuHcXheY,10519
 skilleter_thingy/git_co.py,sha256=Mc-6jEUpVWAJJ-2PTpQ4tjDw03_zJMJDX9SGIxCqzJQ,8404
 skilleter_thingy/git_common.py,sha256=FKXB6aT-y_a3N6wFnnwM6qJi4ClLFvDAivkSQ4iEYP4,2111
 skilleter_thingy/git_hold.py,sha256=coyHdl1bWivrWdmgs7smVPvHRNoXgsgmUjR6n-08lV4,4920
 skilleter_thingy/git_mr.py,sha256=MsrAkIKW27fVTljV__zAjMveIpufvDQ_j0jeKJu2rZM,3426
 skilleter_thingy/git_parent.py,sha256=VqP4v3zsWp6utJvxFxSB_GwCv82xNIiiBlAlkinO1Wk,2938
 skilleter_thingy/git_retag.py,sha256=JT-yD-uU4dL0mxDq9IRynugUKqIxjMCdU1dYDjiBSTU,1828
-skilleter_thingy/git_review.py,sha256=Z_e0wyQJ2AzOSy5cPI3jmAWystpJbHH4ygENjFagepo,52576
-skilleter_thingy/git_update.py,sha256=Z3p3E33ZJ2DVa107UzaFR9V8LXADRuHjJL8TX3IhEa4,14348
+skilleter_thingy/git_review.py,sha256=AsCVq2viAsNE527uHvbPOYASI3iVx0JgCfuA0J0Ocmg,52557
+skilleter_thingy/git_update.py,sha256=Ic5X_GZO2yez_nwrCqSTq3p07k3TyRAMSvQYpjP-yvE,14571
 skilleter_thingy/git_wt.py,sha256=tkGN_Bfz80icHNDVG8xuXVeUUR-xyZ3u8jopLRt1Ff4,2355
-skilleter_thingy/gitcmp_helper.py,sha256=MlRimPj-S-ov44ETUvocRvfygs3cArP6WdSJCIJWNCs,11347
+skilleter_thingy/gitcmp_helper.py,sha256=SwYYHXYJQnPizCrLpHwOt-h0_O61zRwV1Ckr2XehyKc,11576
 skilleter_thingy/gitprompt.py,sha256=19vBe2JSs6H_7us5MYmdmGnwEIKiP9K2JlUBWPxXuCg,8939
 skilleter_thingy/gl.py,sha256=9zbGpKxw6lX9RghLkdy-Q5sZlqtbB3uGFO04qTu1dH8,5954
 skilleter_thingy/linecount.py,sha256=ehTN6VD76i4U5k6dXuYoiqSRHI67_BP-bziklNAJSKY,4309
@@ -26,12 +26,13 @@ skilleter_thingy/py_audit.py,sha256=4CAdqBAIIVcpTCn_7dGm56bdfGpUtUJofqTGZomClkY,
 skilleter_thingy/readable.py,sha256=LcMMOiuzf9j5TsxcMbO0sbj6m1QCuABl91Hrv-YyIww,15422
 skilleter_thingy/remdir.py,sha256=Ueg3a6_m7y50zWykhKk6pcuz4FKPjoLJVPo9gh_dsic,4653
 skilleter_thingy/rmdupe.py,sha256=RWtOHq__zY4yOf6_Y-H-8RRJy31Sr3c8DEyTd6Y4oV4,17213
-skilleter_thingy/rpylint.py,sha256=uAQRvscsW5x85P4COXE6HWk4XykBkRmGowAdViDkwi4,2601
+skilleter_thingy/rpylint.py,sha256=spdVVpNyElkV1fQknv-RESmqe7U0QZYneX96vSAEMSo,2875
 skilleter_thingy/strreplace.py,sha256=zMhqC38KF0BddTsRM5Pa99HU3KXvxXg942qxRK-LALA,2539
-skilleter_thingy/tfm.py,sha256=xMsqcuNJ32PwKF5vO3SO6etlbJKbCLUJhSdC2w0clwE,33829
+skilleter_thingy/tfm.py,sha256=bw_S4bCAisZAEkzrbqnXqJsjC62oA08FM_xrbkuDQuQ,33787
 skilleter_thingy/tfparse.py,sha256=rRoinnbq6sLfkT38yzzXi2jQuJgBIJoC--G05TVTDIc,2991
 skilleter_thingy/trimpath.py,sha256=ijLowl-rxV53m0G75tGNuHWobObz5NreBy8yXP9l4eY,2373
 skilleter_thingy/venv_create.py,sha256=EV_oZh3JlDc5hX5h9T1hnt65AEABw6PufaKvPYabR00,1159
+skilleter_thingy/x.py,sha256=hFiinFX2p0x0OkPf7QnBdW6vAhSIfocwq4siZl2_MvQ,49
 skilleter_thingy/xchmod.py,sha256=T89xiH_po0nvH5T1AGgQOD5yhjKd9-LcHcmez3IORww,4604
 skilleter_thingy/yamlcheck.py,sha256=FXylZ5NtHirDlPVhVEUZUZkTugVR-g51BbjaN06akAc,2868
 skilleter_thingy/thingy/__init__.py,sha256=rVPTxm8L5w52U0YdTd7r_D44SBP7pS3JCJtsf0iIsow,110
@@ -40,20 +41,19 @@ skilleter_thingy/thingy/dc_curses.py,sha256=fuuQPR11zV_akAhygL_cAhVLC5YAgKgowzlI
 skilleter_thingy/thingy/dc_defaults.py,sha256=ahcteQvoWZrO5iTU68zkIY1Zex6iX5uR5ubwI4CCYBk,6170
 skilleter_thingy/thingy/dc_util.py,sha256=Df73imXhHx3HzcPHiRcHAoea0e3HURdLcrolUsMhOFs,1783
 skilleter_thingy/thingy/dircolors.py,sha256=aBcq9ci855GSOIjrZWm8kG0ksCodvUmc4FlIOEOyBcA,12292
-skilleter_thingy/thingy/docker.py,sha256=zFgLLGAmqGsBdy9SWhl6BVkPyng9vZygPe7dJylkTEc,2533
-skilleter_thingy/thingy/files.py,sha256=jNnLpkhfmZ3W2uqdQvt-zI27FSwBLBERwAbsVeQ2TTs,4708
-skilleter_thingy/thingy/git.py,sha256=NTZv9um6-Yigqdt-O9WTNxA19LyNTXw9IunrdflEpoM,43036
+skilleter_thingy/thingy/docker.py,sha256=iT8PqX2hJfcR1e4hotQfSBBYNe0Qdcmeo-XJ6y7lw7Y,2477
+skilleter_thingy/thingy/files.py,sha256=nFIOEi2rl2SuYa6Zd7Nf1BWCKyKlF8D6hsbPlfnVefQ,4791
+skilleter_thingy/thingy/git.py,sha256=aa4vFwXiZ9JkH-zJuKZWACw4Ympcomi6EsPdlLIJiSs,43227
 skilleter_thingy/thingy/gitlab.py,sha256=uXAF918xnPk6qQyiwPQDbMZfqtJzhiRqDS7yEtJEIAg,6079
 skilleter_thingy/thingy/path.py,sha256=8uM2Q9zFRWv_SaVOX49PeecQXttl7J6lsmBuRXWsXKY,4732
-skilleter_thingy/thingy/popup.py,sha256=hNfA9yh4jCv2su8XK33udcTWwgf98noBdYRRkFX1mxc,2517
-skilleter_thingy/thingy/process.py,sha256=R8JXKaxJJ6rgnSdJYJIsJ7Ox2e-5nPV1EJ0sjGZGxec,1092
-skilleter_thingy/thingy/run.py,sha256=mqafCzW9op_xKCt8OY3jJ6YltmoOJGh44vzl667mwws,14196
+skilleter_thingy/thingy/popup.py,sha256=TY9rpj4q8uZxerSt641LGUTy0TZgUjgfEX-CkRMuyek,2540
+skilleter_thingy/thingy/run.py,sha256=Q6uug_LucKbn36RB-r08QYaCzmeoU452ipzQ2YiVUPs,10593
 skilleter_thingy/thingy/tfm_pane.py,sha256=XTTpSm71CyQyGmlVLuCthioOwech0jhUiFUXb-chS_Q,19792
 skilleter_thingy/thingy/tidy.py,sha256=AQ2RawsZJg6WHrgayi_ZptFL9occ7suSdCHbU3P-cys,5971
 skilleter_thingy/thingy/venv_template.py,sha256=ZfUvi8qFNGrk7J030Zy57xjwMtfIArJyqa-MqafyjVk,1016
-skilleter_thingy-0.2.13.dist-info/licenses/LICENSE,sha256=ljOS4DjXvqEo5VzGfdaRwgRZPbNScGBmfwyC8PChvmQ,32422
-skilleter_thingy-0.2.13.dist-info/METADATA,sha256=p-NDmQvDF8A6oO5s1Lx1VIKmApg1e2f1VfyJsKqfTg8,28914
-skilleter_thingy-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-skilleter_thingy-0.2.13.dist-info/entry_points.txt,sha256=MTNWf8jOx8Fy3tSwVLCZPlEyzlDF36odw-IN-cSefP8,1784
-skilleter_thingy-0.2.13.dist-info/top_level.txt,sha256=8-JhgToBBiWURunmvfpSxEvNkDHQQ7r25-aBXtZv61g,17
-skilleter_thingy-0.2.13.dist-info/RECORD,,
+skilleter_thingy-0.2.15.dist-info/licenses/LICENSE,sha256=ljOS4DjXvqEo5VzGfdaRwgRZPbNScGBmfwyC8PChvmQ,32422
+skilleter_thingy-0.2.15.dist-info/METADATA,sha256=NV9puo96TLDp25-yZ2LNqq95Q3eAAIcNX0rhciQJh58,28914
+skilleter_thingy-0.2.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+skilleter_thingy-0.2.15.dist-info/entry_points.txt,sha256=MTNWf8jOx8Fy3tSwVLCZPlEyzlDF36odw-IN-cSefP8,1784
+skilleter_thingy-0.2.15.dist-info/top_level.txt,sha256=8-JhgToBBiWURunmvfpSxEvNkDHQQ7r25-aBXtZv61g,17
+skilleter_thingy-0.2.15.dist-info/RECORD,,

skilleter_thingy/thingy/process.py

@@ -1,32 +0,0 @@
-#! /usr/bin/env python3
-
-################################################################################
-""" Legacy compatibility module for process.py API.
-    This module provides backward compatibility for existing code that used
-    the original process.py module. The actual implementation has been moved
-    to thingy.run with enhanced capabilities.
-"""
-################################################################################
-
-from thingy.run import run_process, RunError
-
-# Provide the same API as the original process.py
-def run(command, foreground=False, shell=False):
-    """
-    Run a command with the original process.py API.
-
-    Args:
-        command: Command to run (string or list)
-        foreground: If True, run in foreground with output to console
-        shell: Whether to use shell for execution
-
-    Returns:
-        List of output lines (empty if foreground=True)
-
-    Raises:
-        RunError: If command fails
-    """
-    return run_process(command, foreground=foreground, shell=shell)
-
-# Re-export RunError for compatibility
-__all__ = ['run', 'RunError']