skilleter-modules 0.0.3__tar.gz → 0.0.6__tar.gz

{skilleter_modules-0.0.3/src/skilleter_modules.egg-info → skilleter_modules-0.0.6}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: skilleter_modules
-Version: 0.0.3
+Version: 0.0.6
 Summary: Modules used by my various Python projects (and hopefully useful to other people)
 Author-email: John Skilleter <john@skilleter.org.uk>
 Project-URL: Home, https://skilleter.org.uk
+Project-URL: Repository, https://gitlab.com/skilleter/skilleter-modules
+Project-URL: Issues, https://gitlab.com/skilleter/skilleter-extras/-/modules
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/pyproject.toml

@@ -7,7 +7,7 @@ name = "skilleter_modules"
 
 # Version must be incremented to install updated skilleter-extras
 
-version = "0.0.3"
+version = "0.0.6"
 
 authors = [
     {name="John Skilleter", email="john@skilleter.org.uk"},
@@ -32,5 +32,10 @@ dependencies = [
 
 [project.urls]
 Home = "https://skilleter.org.uk"
+Repository = "https://gitlab.com/skilleter/skilleter-modules"
+Issues = "https://gitlab.com/skilleter/skilleter-extras/-/modules"
 
 [project.scripts]
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/colour.py

@@ -272,57 +272,3 @@ def warning(txt, newline=True, stream=sys.stderr, prefix=False):
         write('[RED:WARNING]: ', newline=False, stream=stream, )
 
     write(txt, newline, stream)
-
-################################################################################
-
-if __name__ == '__main__':
-    for combo in (0, 1, 2):
-        print()
-        if combo == 0:
-            print('Background colours')
-        elif combo == 1:
-            print('Foreground colours')
-        else:
-            print('Combinations')
-
-        print()
-        for y in range(0, 16):
-            for x in range(0, 16):
-                colour = x + y * 16
-
-                if combo == 0:
-                    write(format('[B%d]%4d' % (colour, colour)), newline=False)
-                elif combo == 1:
-                    write(format('[%d]%4d' % (colour, colour)), newline=False)
-                else:
-                    write(format('[B%d]%4d[%d]/%4d ' % (colour, colour, 255 - colour, 255 - colour)), newline=False)
-
-            write('[NORMAL]')
-
-    print()
-
-    write('Foreground: [RED]red [GREEN]green [BLACK]black [NORMAL]normal')
-    write('Background: [BRED]red [BGREEN]green [BBLACK]black [NORMAL]normal')
-
-    write('Foreground: [BBLUE:blue] [RED:red] normal')
-
-    write('Bright foreground: [RED_B]red [GREEN_B]green [BLACK_B]black [NORMAL]normal')
-    write('Bright background: [BRED_B]red [BGREEN_B]green [BBLACK_B]black [NORMAL]normal')
-
-    write('Foreground: [BBLUE:blue_B] [RED:red_B] normal')
-
-    print()
-
-    write('[NORMAL:Normal text]')
-    write('[FAINT:Faint text]')
-    write('[ITALIC:Italic text]')
-    write('[UNDERSCORE:Underscored text]')
-    write('[BLINK:Blinking text]')
-    write('[REVERSE:Reverse text]')
-    write('[STRIKE:Strikethrough text]')
-
-    print()
-
-    error('Error message (nothing should be output after this)', status=0)
-
-    write('This message should not appear')

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/dc_curses.py

@@ -79,19 +79,21 @@ class CursesDircolors:
         """ Given a set of attributes return the equivalent curses colour pair,
             creating a new one if a matching one doesn't already exsit """
 
-        # TODO: Take account of attributes as well as colours
-
         colours = [attr['fore'], attr['back']]
 
         # Get an existing colour pair that uses the same colours or create
-        # a new one if one doesn't exist
+        # a new one if one doesn't exist. If a pair slot is already allocated
+        # but the curses subsystem cannot allocate (e.g., no colours), skip init.
 
         if colours in self.colour_pairs:
             pair_index = self.colour_pairs.index(colours) + self.reserved
         else:
             pair_index = len(self.colour_pairs) + self.reserved
             self.colour_pairs.append(colours)
-            curses.init_pair(pair_index, attr['fore'], attr['back'])
+            try:
+                curses.init_pair(pair_index, attr['fore'], attr['back'])
+            except curses.error:
+                pass
 
         return pair_index
 

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/dircolors.py

@@ -131,8 +131,10 @@ class Dircolors:
         Returns a boolean indicating whether any data was loaded.
         The current database will always be cleared. """
         self.clear()
+        need_close = False
         if isinstance(database, str):
             file = open(database, 'r')
+            need_close = True
         elif isinstance(database, TextIOBase):
             file = database
         else:
@@ -157,6 +159,8 @@ class Dircolors:
                     continue  # ignore TERM directives
                 elif key in _CODE_MAP:
                     self._codes[_CODE_MAP[key]] = val
+                elif key.startswith('*.'):
+                    self._extensions[key[1:]] = val
                 elif key.startswith('.'):
                     self._extensions[key] = val
                 elif strict:
@@ -167,7 +171,8 @@ class Dircolors:
                 self._loaded = True
             return self._loaded
         finally:
-            file.close()
+            if need_close:
+                file.close()
 
     def load_defaults(self):
         """ Load the default database. """

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/docker.py

@@ -35,8 +35,9 @@ def instances(all=False):
     try:
         process = subprocess.run(cmd, capture_output=True, check=True, text=True)
 
-        for result in process.stdout:
-            instances_list.append(result)
+        for result in process.stdout.splitlines():
+            if result:
+                instances_list.append(result)
 
     except subprocess.CalledProcessError as exc:
         raise DockerError(exc)
@@ -48,12 +49,17 @@ def instances(all=False):
 def stop(instance, force=False):
     """ Stop the specified Docker instance """
 
-    # TODO: force option not implemented
+    cmd = ['docker', 'stop']
+
+    if force:
+        cmd.append('--force')
+
+    cmd.append(instance)
 
     try:
-        subprocess.run(['docker', 'stop', instance], check=True, capture_output=False)
+        subprocess.run(cmd, check=True, capture_output=False)
 
-    except suprocess.CalledProcessError as exc:
+    except subprocess.CalledProcessError as exc:
         raise DockerError(exc)
 
 ################################################################################
@@ -80,10 +86,11 @@ def images():
     """ Return a list of all current Docker images """
 
     try:
-        process = subprocess.run(['docker', 'images', '-q'], capture_output=True, check=True)
+        process = subprocess.run(['docker', 'images', '-q'], capture_output=True, check=True, text=True)
 
-        for result in process:
-            yield result
+        for result in process.stdout.splitlines():
+            if result:
+                yield result
 
     except subprocess.CalledProcessError as exc:
         raise DockerError(exc)

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/files.py

@@ -19,7 +19,9 @@ def is_binary_file(filename):
     """ Return True if there is a strong likelihood that the specified file
         is binary. """
 
-    return file_type(filename, mime=True).endswith('binary')
+    filetype = file_type(filename, mime=True)
+
+    return filetype.endswith('binary') if filetype else False
 
 ################################################################################
 
@@ -49,7 +51,7 @@ def format_size(size, always_suffix=False):
     """ Convert a memory/disk size into appropriately-scaled units in bytes,
         MiB, GiB, TiB as a string """
 
-   # Keep all the maths positive
+    # Keep all the maths positive
 
     if size < 0:
         size = -size

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/git.py

@@ -933,7 +933,7 @@ def config_rm(section, key, source=LOCAL, path=None):
 
 ################################################################################
 
-def ref(fields=('objectname'), sort=None, remotes=False, path=None):
+def ref(fields=('objectname',), sort=None, remotes=False, path=None):
     """ Wrapper for git for-each-ref """
 
     cmd = ['for-each-ref']
@@ -958,7 +958,7 @@ def ref(fields=('objectname'), sort=None, remotes=False, path=None):
 def branches(all=False, path=None, remote=False):
     """ Return a list of all the branches in the current repo """
 
-    cmd = ['branch', '--format=%(refname:short)','--list']
+    cmd = ['branch', '--format=%(refname:short)', '--list']
 
     if all:
         cmd.append('--all')

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/path.py

@@ -32,7 +32,10 @@ def is_subdirectory(root_path, sub_path):
     logging.debug('root path: %s', abs_root_path)
     logging.debug('sub path : %s', abs_sub_path)
 
-    return abs_sub_path.startswith('%s/' % abs_root_path)
+    common = os.path.commonpath([abs_root_path, abs_sub_path])
+
+    # Require a strict subdirectory: common path matches root and paths differ
+    return common == abs_root_path and abs_sub_path != abs_root_path
 
 ################################################################################
 

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/popup.py

@@ -63,6 +63,11 @@ class PopUp():
 
         self.start_time = time.monotonic()
 
+        return self
+
+    def __exit__(self, _exc_type, _exc_value, _exc_traceback):
+        """ Remove the popup """
+
         if self.waitkey:
             while True:
                 keypress = self.screen.getch()
@@ -72,9 +77,6 @@ class PopUp():
                 curses.panel.update_panels()
                 self.screen.refresh()
 
-    def __exit__(self, _exc_type, _exc_value, _exc_traceback):
-        """ Remove the popup """
-
         if self.panel:
             if self.sleep:
                 elapsed = time.monotonic() - self.start_time

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/run.py

@@ -231,18 +231,19 @@ def _process(command,
 
     # Wait until the command terminates (and set the returncode)
 
+    cmd.wait()
+
     if stdout_thread:
         stdout_thread.join()
 
     if stderr_thread:
         stderr_thread.join()
 
-    cmd.wait()
-
     # If the command failed, raise an exception
 
     if cmd.returncode:
-        raise RunError('\n'.join(stderr_data) if stderr_data else 'Error %d running "%s"' % (cmd.returncode, ' '.join(command)))
+        raise RunError('\n'.join(stderr_data) if stderr_data else 'Error %d running "%s"' % (cmd.returncode, ' '.join(command)),
+                       status=cmd.returncode)
 
     # Return status, stdout, stderr (the latter 2 may be empty if we did not capture data).
 

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules/tidy.py

@@ -57,7 +57,7 @@ RE_TIME = [
     {'regex': re.compile(r'[0-9]{4}-[0-9]{2}-[0-9]{2}'), 'replace': '{DATE}'},
     {'regex': re.compile(r'[0-9]{2}-[0-9]{2}-[0-9]{4}'), 'replace': '{DATE}'},
 
-    {'regex': re.compile(r'[0-9]([.][0-9]*)*\s*(second[s]?)'), 'replace': '{ELAPSED}'},
+    {'regex': re.compile(r'[0-9]+([.][0-9]*)*\s*(second[s]?)'), 'replace': '{ELAPSED}'},
 
     {'find': '{DATE} {TIME}', 'replace': '{DATE+TIME}'},
     {'regex': re.compile(r'[0-9]+m *[0-9]+s'), 'replace': '{ELAPSED}'},
@@ -83,7 +83,7 @@ RE_AWS = \
         {'regex': re.compile(r'vol-0[0-9a-f]{16}'), 'replace': '{AMI-VOL}'},
         {'regex': re.compile(r'sir-[0-9a-z]{8}'), 'replace': '{SPOT-INSTANCE}'},
         {'regex': re.compile(r'i-0[0-9a-f]{16}'), 'replace': '{EC2-ID}'},
-        {'regex': re.compile(r'request id: [0-0a-f]{8}-[0-0a-f]{4}-[0-0a-f]{4}-[0-0a-f]{4}-[0-0a-f]{12}'),
+        {'regex': re.compile(r'request id: [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'),
          'replace': 'request id: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'},
     ]
 

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6/src/skilleter_modules.egg-info}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: skilleter_modules
-Version: 0.0.3
+Version: 0.0.6
 Summary: Modules used by my various Python projects (and hopefully useful to other people)
 Author-email: John Skilleter <john@skilleter.org.uk>
 Project-URL: Home, https://skilleter.org.uk
+Project-URL: Repository, https://gitlab.com/skilleter/skilleter-modules
+Project-URL: Issues, https://gitlab.com/skilleter/skilleter-extras/-/modules
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
 Classifier: Operating System :: OS Independent

{skilleter_modules-0.0.3 → skilleter_modules-0.0.6}/src/skilleter_modules.egg-info/SOURCES.txt

@@ -14,11 +14,21 @@ src/skilleter_modules/gitlab.py
 src/skilleter_modules/path.py
 src/skilleter_modules/popup.py
 src/skilleter_modules/run.py
-src/skilleter_modules/tfm_pane.py
 src/skilleter_modules/tidy.py
 src/skilleter_modules/venv_template.py
 src/skilleter_modules.egg-info/PKG-INFO
 src/skilleter_modules.egg-info/SOURCES.txt
 src/skilleter_modules.egg-info/dependency_links.txt
 src/skilleter_modules.egg-info/requires.txt
-src/skilleter_modules.egg-info/top_level.txt
+src/skilleter_modules.egg-info/top_level.txt
+tests/test_colour.py
+tests/test_dircolors.py
+tests/test_docker.py
+tests/test_files.py
+tests/test_git.py
+tests/test_gitlab.py
+tests/test_path.py
+tests/test_popup.py
+tests/test_run.py
+tests/test_tfm_pane.py
+tests/test_tidy.py

skilleter_modules-0.0.6/tests/test_colour.py

@@ -0,0 +1,65 @@
+"""Minimal test code for colour"""
+
+import io
+
+import skilleter_modules.colour as colour
+
+def test_colour():
+    """Very basic test"""
+
+    for combo in (0, 1, 2):
+        print()
+        if combo == 0:
+            print('Background colours')
+        elif combo == 1:
+            print('Foreground colours')
+        else:
+            print('Combinations')
+
+        print()
+        for y in range(0, 16):
+            for x in range(0, 16):
+                colour_index = x + y * 16
+
+                if combo == 0:
+                    colour.write(format('[B%d]%4d' % (colour_index, colour_index)), newline=False)
+                elif combo == 1:
+                    colour.write(format('[%d]%4d' % (colour_index, colour_index)), newline=False)
+                else:
+                    colour.write(format('[B%d]%4d[%d]/%4d ' % (colour_index, colour_index, 255 - colour_index, 255 - colour_index)), newline=False)
+
+            colour.write('[NORMAL]')
+
+    print()
+
+    colour.write('Foreground: [RED]red [GREEN]green [BLACK]black [NORMAL]normal')
+    colour.write('Background: [BRED]red [BGREEN]green [BBLACK]black [NORMAL]normal')
+
+    colour.write('Foreground: [BBLUE:blue] [RED:red] normal')
+
+    colour.write('Bright foreground: [RED_B]red [GREEN_B]green [BLACK_B]black [NORMAL]normal')
+    colour.write('Bright background: [BRED_B]red [BGREEN_B]green [BBLACK_B]black [NORMAL]normal')
+
+    colour.write('Foreground: [BBLUE:blue_B] [RED:red_B] normal')
+
+    print()
+
+    colour.write('[NORMAL:Normal text]')
+    colour.write('[FAINT:Faint text]')
+    colour.write('[ITALIC:Italic text]')
+    colour.write('[UNDERSCORE:Underscored text]')
+    colour.write('[BLINK:Blinking text]')
+    colour.write('[REVERSE:Reverse text]')
+    colour.write('[STRIKE:Strikethrough text]')
+
+
+def test_write_empty_string_no_indent():
+    buf = io.StringIO()
+    colour.write('', indent=4, stream=buf)
+    assert buf.getvalue() == '\n'
+
+
+def test_write_with_indent_and_strip():
+    buf = io.StringIO()
+    colour.write('  text', indent=2, strip=True, stream=buf)
+    assert buf.getvalue() == '  text\n'

skilleter_modules-0.0.6/tests/test_dircolors.py

@@ -0,0 +1,27 @@
+import io
+import stat
+
+import skilleter_modules.dircolors as dircolors
+
+
+def test_load_from_dircolors_does_not_close_stream():
+    data = io.StringIO('DIR 01;34\n')
+    dc = dircolors.Dircolors(load=False)
+    assert dc.load_from_dircolors(data, strict=True) is True
+    assert data.closed is False
+    assert dc.loaded is True
+
+
+def test_format_mode_directory_and_extension(tmp_path):
+    dc = dircolors.Dircolors(load=False)
+    # Load minimal rules: directories blue (01;34), *.txt red (31)
+    rules = 'DIR 01;34\n*.txt 31\n'
+    assert dc.load_from_dircolors(io.StringIO(rules), strict=True)
+
+    # Directory formatting: should wrap with escape codes
+    formatted_dir = dc.format_mode('name', (stat.S_IFDIR | stat.S_IRUSR))
+    assert '\x1b[' in formatted_dir and formatted_dir.endswith('\x1b[0m')
+
+    # Extension formatting: .txt uses red foreground
+    formatted_file = dc.format_mode('file.txt', 0)
+    assert '\x1b[' in formatted_file and formatted_file.endswith('\x1b[0m')

skilleter_modules-0.0.6/tests/test_docker.py

@@ -0,0 +1,30 @@
+import types
+
+import pytest
+
+import skilleter_modules.docker as docker
+
+
+class DummyResult(types.SimpleNamespace):
+    pass
+
+
+def test_instances_parses_lines(monkeypatch):
+    def fake_run(cmd, capture_output, check, text):
+        assert cmd[:2] == ['docker', 'ps']
+        return DummyResult(stdout='id1\nid2\n')
+
+    monkeypatch.setattr('subprocess.run', fake_run)
+    assert docker.instances() == ['id1', 'id2']
+
+
+def test_stop_force_passes_flag(monkeypatch):
+    seen = {}
+
+    def fake_run(cmd, check, capture_output):
+        seen['cmd'] = cmd
+        return DummyResult()
+
+    monkeypatch.setattr('subprocess.run', fake_run)
+    docker.stop('abc', force=True)
+    assert seen['cmd'] == ['docker', 'stop', '--force', 'abc']

skilleter_modules-0.0.6/tests/test_files.py

@@ -0,0 +1,22 @@
+import os
+
+import skilleter_modules.files as files
+
+
+def test_format_size_suffix_and_sign():
+    assert files.format_size(-1024, always_suffix=True).startswith('-')
+    assert files.format_size(1024, always_suffix=True).endswith(' KiB')
+
+
+def test_backup_no_file_no_raise(tmp_path):
+    missing = tmp_path / 'missing.txt'
+    # Should no-op when file is absent
+    files.backup(str(missing))
+    assert not list(tmp_path.iterdir())
+
+
+def test_backup_creates_copy(tmp_path):
+    src = tmp_path / 'file.txt'
+    src.write_text('data', encoding='utf-8')
+    files.backup(str(src))
+    assert (tmp_path / 'file.bak').read_text(encoding='utf-8') == 'data'

skilleter_modules-0.0.6/tests/test_git.py

@@ -0,0 +1,6 @@
+import pytest
+
+git = pytest.importorskip('skilleter_modules.git', reason='pygit2 not installed')
+
+def test_git():
+    pass

skilleter_modules-0.0.6/tests/test_gitlab.py

@@ -0,0 +1,4 @@
+import skilleter_modules.gitlab as gitlab
+
+def test_gitlab():
+    pass

skilleter_modules-0.0.6/tests/test_path.py

@@ -0,0 +1,23 @@
+import skilleter_modules.path as path
+
+
+def test_is_subdirectory_strict_descendant():
+    assert path.is_subdirectory('/root', '/root/child') is True
+
+
+def test_is_subdirectory_same_path_is_false():
+    assert path.is_subdirectory('/root', '/root') is False
+
+
+def test_is_subdirectory_unrelated_is_false():
+    assert path.is_subdirectory('/root/one', '/root/two') is False
+
+
+def test_trimpath_home_to_tilde(monkeypatch):
+    monkeypatch.setenv('HOME', '/home/user')
+    assert path.trimpath('/home/user/projects', 80).startswith('~/')
+
+
+def test_trimpath_truncates_middle():
+    trimmed = path.trimpath('/a/b/c/d/e/f/g/h/i', 10)
+    assert '...' in trimmed

skilleter_modules-0.0.6/tests/test_popup.py

@@ -0,0 +1,70 @@
+from types import SimpleNamespace
+
+import skilleter_modules.popup as popup
+
+
+class FakePanel:
+    def __init__(self):
+        self.update_calls = 0
+        self.new_calls = []
+
+    def new_panel(self, window):
+        self.new_calls.append(window)
+        return SimpleNamespace(top=lambda: None)
+
+    def update_panels(self):
+        self.update_calls += 1
+
+
+class FakeWindow:
+    def __init__(self):
+        self.add_calls = []
+        self.bkgd_calls = []
+
+    def bkgd(self, ch, colour):
+        self.bkgd_calls.append((ch, colour))
+
+    def addstr(self, y_pos, x_pos, line, colour):
+        self.add_calls.append((y_pos, x_pos, line, colour))
+
+
+class FakeScreen:
+    def __init__(self, keys):
+        self.keys = list(keys)
+        self.getch_calls = 0
+        self.refresh_calls = 0
+
+    def getmaxyx(self):
+        return (24, 80)
+
+    def refresh(self):
+        self.refresh_calls += 1
+
+    def getch(self):
+        self.getch_calls += 1
+        return self.keys.pop(0)
+
+
+def test_waitkey_occurs_on_exit(monkeypatch):
+    fake_panel = FakePanel()
+
+    fake_curses = SimpleNamespace(
+        KEY_RESIZE=999,
+        panel=fake_panel,
+    )
+
+    fake_curses.color_pair = lambda colour: f'colour-{colour}'
+    fake_curses.newwin = lambda h, w, y, x: FakeWindow()
+
+    monkeypatch.setattr(popup, 'curses', fake_curses)
+
+    keys = [fake_curses.KEY_RESIZE, ord('a')]
+    screen = FakeScreen(keys)
+
+    with popup.PopUp(screen, 'hello', 3, waitkey=True):
+        enter_updates = fake_panel.update_calls
+        assert screen.getch_calls == 0
+
+    assert fake_panel.update_calls == enter_updates + 1
+    assert screen.getch_calls == 2
+    assert screen.refresh_calls >= 1

skilleter_modules-0.0.6/tests/test_run.py

@@ -0,0 +1,32 @@
+import subprocess
+
+import skilleter_modules.run as run
+
+
+def test_process_echoes_and_captures_stdout(monkeypatch):
+    real_popen = subprocess.Popen
+
+    def fake_popen(command, bufsize=0, stdout=None, stderr=None, text=False, errors=None, encoding=None, **kwargs):
+        assert stdout == subprocess.PIPE
+        assert stderr == subprocess.PIPE
+        proc = real_popen(['printf', 'hello\n'], stdout=stdout, stderr=stderr, text=True)
+        return proc
+
+    monkeypatch.setattr(subprocess, 'Popen', fake_popen)
+    result = run._process(['printf', 'hello'])
+    assert result['stdout'] == ['hello']
+
+
+def test_process_raises_on_nonzero(monkeypatch):
+    real_popen = subprocess.Popen
+
+    def fake_popen(command, bufsize=0, stdout=None, stderr=None, text=False, errors=None, encoding=None, **kwargs):
+        return real_popen(['python', '-c', 'import sys; sys.exit(3)'], stdout=stdout, stderr=stderr, text=True)
+
+    monkeypatch.setattr(subprocess, 'Popen', fake_popen)
+    try:
+        run._process(['python', '-c', 'exit 3'])
+    except run.RunError as exc:
+        assert exc.status == 3
+    else:
+        assert False, 'expected RunError'

skilleter_modules-0.0.6/tests/test_tfm_pane.py

@@ -0,0 +1,6 @@
+import pytest
+
+tfm_pane = pytest.importorskip('skilleter_modules.tfm_pane', reason='inotify not installed')
+
+def test_tfm_pane():
+    pass

skilleter_modules-0.0.6/tests/test_tidy.py

@@ -0,0 +1,10 @@
+import skilleter_modules.tidy as tidy
+
+
+def test_remove_times_does_not_match_stray_dot():
+    text = 'Version 1. release'
+    assert tidy.remove_times(text) == text
+
+
+def test_remove_times_replaces_seconds():
+    assert tidy.remove_times('took 12.5 seconds') == 'took {ELAPSED}'

skilleter_modules-0.0.3/src/skilleter_modules/tfm_pane.py

@@ -1,593 +0,0 @@
-################################################################################
-""" Pane class for tfm """
-################################################################################
-
-import sys
-import os
-import curses
-import fnmatch
-import stat
-import glob
-import time
-import threading
-
-from enum import IntEnum
-
-if sys.platform == 'linux':
-    import inotify.adapters
-
-from . import dc_curses
-from . import path
-from . import popup
-
-################################################################################
-
-class SortOrder(IntEnum):
-    """ Sort order for filename list """
-
-    FILENAME = 0
-    EXTENSION = 1
-    MODIFIED_DATE = 2
-    SIZE = 3
-    NUM_SORTS = 4
-
-SORT_TYPE = ('filename', 'extension', 'modified date', 'size')
-
-################################################################################
-
-def inotify_wait(self):
-    """Thread to wait for inotify events and post an event to the queue if there
-       any create/delete/modify events in the current directory.
-       Sends no more than 1 update per second to avoid drowning the recipient."""
-
-    while True:
-        trigger = False
-        for event in self.ino.event_gen(yield_nones=False, timeout_s=1):
-            (_, events, path, _) = event
-
-            if path == self.current_dir and ('IN_CREATE' in events or 'IN_DELETE' in events or 'IN_MODIFY' in events):
-                trigger = True
-
-        if trigger:
-            self.event_queue.put(('inotify', self.index))
-
-################################################################################
-
-class Pane():
-    """ Class for a file manager pane """
-
-    def __init__(self, index, num_panes, colours, event_queue):
-        # Create window for the pane (dummy size and position initially)
-
-        self.screen = curses.newwin(1, 1, 0, 0)
-
-        self.index = index
-
-        self.current_dir = ''
-
-        self.ino = inotify.adapters.Inotify() if sys.platform == 'linux' else None
-
-        self.set_current_dir(os.getcwd())
-
-        self.event_queue = event_queue
-
-        if sys.platform == 'linux':
-            inotify_thread = threading.Thread(target=inotify_wait, args=(self,), daemon=True)
-            inotify_thread.start()
-
-        # Default sort order
-
-        self.sort_order = SortOrder.FILENAME
-        self.reverse_sort = False
-
-        # Set the attributes of the current review (some are initialised
-        # when the screen is drawn)
-
-        # Index of the current file in the filtered_file_indices
-
-        self.current = 0
-
-        self.offset = 0
-        self.num_panes = num_panes
-        self.colours = colours
-
-        self.searchstring = None
-
-        self.height = self.width = -1
-        self.file_list_y = 1
-        self.file_list_h = -1
-
-        # File list is a list of the files in the current directory
-
-        self.file_list = []
-
-        # Filtered file list is a list of the indices in file_list of the visible files
-        # in the current directory
-
-        self.filtered_file_indices = []
-
-        # Set of the names of currently-tagged files
-
-        self.tagged_set = set()
-
-        self.in_filter = self.out_filter = None
-        self.hide_hidden_filter = True
-
-        self.file_display_fields = ['size', 'mtime']
-
-        # Set up dircolor highlighting
-
-        self.dircolours = dc_curses.CursesDircolors(reserved=self.colours['reserved_colours'])
-
-        # Generate the list of files to be shown (takes filtering into account)
-
-        self.update_files()
-
-    ################################################################################
-
-    def sort_file_list(self):
-        """ Sort the file list according to the current sort order """
-
-        if self.sort_order == SortOrder.FILENAME:
-            self.file_list.sort(reverse=self.reverse_sort, key=lambda entry: (not entry['isdir'], os.path.basename(entry['name'])))
-        elif self.sort_order == SortOrder.EXTENSION:
-            self.file_list.sort(reverse=self.reverse_sort, key=lambda entry: (not entry['isdir'], entry['name'].split('.')[-1]))
-        elif self.sort_order == SortOrder.MODIFIED_DATE:
-            self.file_list.sort(reverse=self.reverse_sort, key=lambda entry: (not entry['isdir'], entry['mtime']))
-        elif self.sort_order == SortOrder.SIZE:
-            self.file_list.sort(reverse=self.reverse_sort, key=lambda entry: (not entry['isdir'], entry['size']))
-
-    ################################################################################
-
-    def update_files(self):
-        """ Get the list of files
-        """
-
-        def file_stats(filename):
-            """ Get the stats for a file """
-
-            filestat = os.stat(filename, follow_symlinks=False)
-
-            info = {'name': filename,
-                    'mode': filestat.st_mode,
-                    'uid': filestat.st_uid,
-                    'gid': filestat.st_gid,
-                    'size': filestat.st_size,
-                    'atime': filestat.st_atime,
-                    'mtime': filestat.st_mtime,
-                    'ctime': filestat.st_ctime,
-                    'isdir': stat.S_ISDIR(filestat.st_mode)}
-
-            return info
-
-        # Rebuild the file list
-
-        self.file_list = []
-        for filename in glob.glob(os.path.join(self.current_dir, '*')) + glob.glob(os.path.join(self.current_dir, '.*')):
-            self.file_list.append(file_stats(filename))
-
-        # Update the tagged file list to contain only current files
-
-        self.tagged_set = {entry['name'] for entry in self.file_list if entry['name'] in self.tagged_set}
-
-        # Optionally add '..' as an entry
-
-        if self.current_dir != '/':
-            self.file_list.append(file_stats('..'))
-
-        self.sort_file_list()
-        self.update_file_list()
-
-    ################################################################################
-
-    def update_file_list(self):
-        """ Generate the file list from the list of current files with filtering
-            applied if enabled """
-
-        self.sort_file_list()
-
-        if self.active_filters():
-            self.filtered_file_indices = [i for i, entry in enumerate(self.file_list) if not self.filtered(entry)]
-        else:
-            self.filtered_file_indices = range(len(self.file_list))
-
-    ################################################################################
-
-    def active_filters(self):
-        """ Return true if any filters are active """
-
-        return self.out_filter or \
-               self.in_filter or \
-               self.hide_hidden_filter
-
-    ################################################################################
-
-    def filtered(self, entry):
-        """ Return True if an entry is hidden by one or more filters """
-
-        result = False
-
-        if self.out_filter and fnmatch.fnmatch(entry['name'], self.out_filter):
-            result = True
-
-        elif self.in_filter and not fnmatch.fnmatch(entry['name'], self.in_filter):
-            result = True
-
-        elif self.hide_hidden_filter:
-            base_name = os.path.basename(entry['name'])
-            if base_name[0] == '.' and base_name != '..':
-                result = True
-
-        return result
-
-    ################################################################################
-
-    def constrain_display_parameters(self):
-        """ Ensure that the current display parameters are within range - easier
-            to do it in one place for all of them than check individually whenever we
-            change any of them """
-
-        self.current = max(min(self.current, len(self.filtered_file_indices) - 1), 0)
-        self.offset = min(len(self.filtered_file_indices) - 1, max(0, self.offset))
-
-        # Keep the current entry on-screen
-
-        if self.current >= self.offset + self.height - 2:
-            self.offset = self.current
-        elif self.current < self.offset:
-            self.offset = self.current
-
-    ################################################################################
-
-    def file_info_display(self, filename):
-        """ Extract the additional file info fields displayed to the right
-            of the filename """
-
-        data = []
-        for field in self.file_display_fields:
-            if field == 'name':
-                data.append(filename['name'])
-            elif field in ('atime', 'mtime', 'ctime'):
-                data.append(time.strftime('%x %X', time.gmtime(filename[field])))
-            elif field == 'uid':
-                pass
-            elif field == 'gid':
-                pass
-            elif field == 'mode':
-                pass
-            elif field == 'size':
-                data.append(str(filename[field]))
-
-        return ' '.join(data)
-
-    ################################################################################
-
-    def show_file_list(self, current_pane):
-        """ Draw the current page of the file list """
-
-        for ypos in range(0, self.file_list_h):
-
-            normal_colour = curses.color_pair(self.colours['normal'])
-
-            if 0 <= self.offset + ypos < len(self.filtered_file_indices):
-                # Work out what colour to render the file details in
-
-                current_file = self.file_list[self.filtered_file_indices[self.offset + ypos]]
-
-                current = self.offset + ypos == self.current
-
-                # The text to render
-
-                filename = os.path.basename(current_file['name'])
-
-                data = self.file_info_display(current_file)
-
-                name = f'/{filename}' if current_file['isdir'] else filename
-                name = f'* {name}' if current_file['name'] in self.tagged_set else f'  {name}'
-
-                if len(name) > self.width - len(data):
-                    entry = name[:self.width - 3] + '...'
-                else:
-                    entry = name + ' ' * (self.width - len(name) - len(data)) + data
-
-                file_colour = self.dircolours.get_colour_pair(current_file['name'], current_file['mode'])
-            else:
-                filename = entry = None
-                current = False
-                file_colour = normal_colour
-
-            # Reverse the colours if this the cursor line
-
-            if current and current_pane:
-                file_colour |= curses.A_REVERSE
-                normal_colour |= curses.A_REVERSE
-
-            # Write the prefix, filename, and, if necessary, padding
-
-            self.screen.move(self.file_list_y + ypos, 0)
-            if entry:
-                self.screen.addstr(entry, file_colour)
-            else:
-                self.screen.clrtoeol()
-
-            # if len(filename) < self.width:
-            #    self.screen.addstr(self.file_list_y + ypos, len(filename), ' ' * (self.width - len(filename)), normal_colour)
-
-        current_dir = path.trimpath(self.current_dir, self.width)
-
-        self.screen.move(0, 0)
-        self.screen.attron(curses.color_pair(self.colours['status']))
-        self.screen.addstr(current_dir + ' '*(self.width-len(current_dir)))
-
-        self.screen.refresh()
-
-        if not self.filtered_file_indices:
-            with popup.PopUp(self.screen, 'All files are hidden - Press \'c\' to clear filters.', self.colours['status']):
-                pass
-
-    ################################################################################
-
-    def filter_description(self):
-        """ Return a textual description of the active filters """
-
-        filters = []
-
-        if self.out_filter:
-            filters.append('filter-out wildcard')
-
-        if self.in_filter:
-            filters.append('filter-in wildcard')
-
-        return ', '.join(filters)
-
-    ################################################################################
-
-    def clear_filters(self):
-        """ Clear all filters """
-
-        if self.out_filter or self.in_filter:
-            self.out_filter = self.in_filter = None
-            self.update_file_list()
-
-    ################################################################################
-
-    def reload_changes(self):
-        """ Update the list of files in case something external has
-            changed it. """
-
-        self.update_files()
-
-    ################################################################################
-
-    def get_current_dir(self):
-        """ Get the current directory for the pane """
-
-        return self.current_dir
-
-    ################################################################################
-
-    def set_current_dir(self, directory):
-        """ Set the current directory for the pane """
-
-        if self.current_dir and self.ino:
-            self.ino.remove_watch(self.current_dir)
-
-        self.current_dir = os.path.normpath(directory)
-
-        if self.ino:
-            self.ino.add_watch(directory)
-
-    ################################################################################
-
-    def get_current_file(self):
-        """ Get the current file for the pane """
-
-        return self.file_list[self.filtered_file_indices[self.current]]
-
-    ################################################################################
-
-    def get_tagged_files(self):
-        """ Get the list of tagged files, or the current file if none are tagged """
-
-        if self.tagged_set:
-            return [self.file_list[entry] for entry in self.filtered_file_indices if self.file_list[entry]['name'] in self.tagged_set]
-
-        return [self.get_current_file()]
-
-    ################################################################################
-
-    def search_entry(self, searchstring):
-        """ Search for the next match with the specified search string """
-
-        for i in list(range(self.current + 1, len(self.filtered_file_indices))) + list(range(0, self.current)):
-            if fnmatch.fnmatch(os.path.basename(self.file_list[self.filtered_file_indices[i]]['name']), searchstring):
-                self.current = i
-                break
-
-    ################################################################################
-
-    def search_match(self, searchstring):
-        """ Search for the first match """
-
-        self.searchstring = searchstring
-        self.search_next_match()
-
-    ################################################################################
-
-    def search_next_match(self):
-        """ Search for the next match with the current search string """
-
-        self.search_entry(self.searchstring)
-
-    ################################################################################
-
-    def move_end(self):
-        """ Move to the end of the file list """
-
-        self.current = len(self.filtered_file_indices) - 1
-
-    ################################################################################
-
-    def move_top(self):
-        """ Move to the top of the file list """
-
-        self.current = self.offset = 0
-
-    ################################################################################
-
-    def move_to_file(self, filename):
-        """ Move to the specified file (if it exists) in the current directory
-            or to the top if not """
-
-        self.current = self.offset = 0
-        if filename:
-            self.search_entry(filename)
-
-    ################################################################################
-
-    def move(self, delta):
-        """ Move up or down the file list """
-
-        self.current += delta
-
-    ################################################################################
-
-    def filter_out(self, filter_out):
-        """ Set an exclusion filter """
-
-        self.out_filter = filter_out
-        self.in_filter = None
-        self.update_file_list()
-
-    ################################################################################
-
-    def filter_in(self, filter_in):
-        """ Set an inclusion filter """
-
-        self.in_filter = filter_in
-        self.out_filter = None
-        self.update_file_list()
-
-    ################################################################################
-
-    def move_page_down(self):
-        """ Page down """
-
-        pos = self.current - self.offset
-        self.offset += self.file_list_h - 1
-        self.current = self.offset + pos
-
-    ################################################################################
-
-    def move_page_up(self):
-        """ Page up """
-
-        pos = self.current - self.offset
-        self.offset -= self.file_list_h - 1
-        self.current = self.offset + pos
-
-    ################################################################################
-
-    def set_sort_order(self, value):
-        """ Set the sort order """
-
-        self.sort_order = (self.sort_order + value) % SortOrder.NUM_SORTS
-
-        self.update_sort()
-
-    ################################################################################
-
-    def get_sort_order(self):
-        """ Get the current sort order """
-
-        return self.sort_order
-
-    ################################################################################
-
-    def sort_type_msg(self):
-        """ Return a textual explanation of the current sort type """
-
-        if self.reverse_sort:
-            msg = f'Reverse-sorting by {SORT_TYPE[self.sort_order]}'
-        else:
-            msg = f'Sorting by {SORT_TYPE[self.sort_order]}'
-
-        return msg
-
-    ################################################################################
-
-    def reverse_sort_order(self):
-        """ Reverse the sort order """
-
-        self.reverse_sort = not self.reverse_sort
-        self.update_sort()
-
-    ################################################################################
-
-    def update_sort(self):
-        """ Update the sort """
-
-        msg = self.sort_type_msg()
-
-        with popup.PopUp(self.screen, msg, self.colours['status']):
-            self.update_file_list()
-
-    ################################################################################
-
-    def set_pane_coords(self, y, x, height, width):
-        """ Set the pane height given the pane display area """
-
-        pane_width = width//self.num_panes
-
-        self.height = height
-        self.file_list_h = height-1
-        self.width = pane_width-1  # TODO: Why '-1'?
-        self.screen.resize(height, pane_width)
-        self.screen.mvwin(y, x + pane_width*self.index)
-
-    ################################################################################
-
-    def tag_current(self):
-        """ Tag the current entry (unless it is '..') """
-
-        current = self.file_list[self.filtered_file_indices[self.current]]['name']
-
-        if current != '..':
-            if current in self.tagged_set:
-                self.tagged_set.remove(current)
-            else:
-                self.tagged_set.add(current)
-
-    ################################################################################
-
-    def untag(self, wildcard=None):
-        """ Tag all, or selected tagged items """
-
-        if wildcard:
-            remove_tags = set()
-            for entry in self.tagged_set:
-                if fnmatch.fnmatch(self.filtered_file_indices[entry], wildcard):
-                    remove_tags.add(entry)
-
-                self.tagged_set -= remove_tags
-        else:
-            self.tagged_set = set()
-
-    ################################################################################
-
-    def get_hidden_visibility(self):
-        """ Return the current state of hidden file visibility """
-
-        return not self.hide_hidden_filter
-
-    ################################################################################
-
-    def set_hidden_visibility(self, state=False):
-        """ Set the visibility of hidden files """
-
-        self.hide_hidden_filter = not state
-
-        change_txt = 'Hiding' if self.hide_hidden_filter else 'Showing'
-
-        with popup.PopUp(self.screen, f'{change_txt} hidden files', self.colours['status']):
-            self.update_file_list()