skilleter-thingy 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

skilleter_thingy/git_parent.py

@@ -7,9 +7,11 @@ the same commit. Can optionally ignore feature branches and/or report
 the distance to the potential parent.
 """
 
+import os
 import argparse
 import sys
 
+# TODO: Update to git2
 import thingy.git as git
 import thingy.colour as colour
 
@@ -23,33 +25,34 @@ def main():
     parser = argparse.ArgumentParser(description='Attempt to determine the parent branch for the specified branch (defaulting to the current one)')
     parser.add_argument('--all', '-a', action='store_true', help='Include feature branches as possible parents')
     parser.add_argument('--verbose', '-v', action='store_true', help='Report verbose results (includes number of commits between branch and parent)')
+    parser.add_argument('--path', '-C', nargs=1, type=str, default=None,
+                        help='Run the command in the specified directory')
     parser.add_argument('branch', action='store', nargs='?', type=str, default=current_branch,
                         help=f'Branch, commit or commit (defaults to current branch; {current_branch})')
 
     args = parser.parse_args()
 
-    try:
-        if args.all:
-            any_parents, any_distance = git.parents(args.branch)
-        else:
-            any_parents = []
+    if args.path:
+        os.chdir(args.path[0])
 
-        parents, distance = git.parents(args.branch, ignore='feature/*')
+    if args.all:
+        any_parents, any_distance = git.parents(args.branch)
+    else:
+        any_parents = []
 
-        # If we have feature and non-feature branch candidates, decide which to report
-        # (one or both) based on distance.
+    parents, distance = git.parents(args.branch, ignore='feature/*')
 
-        if parents and any_parents:
-            if any_distance < distance:
-                parents = any_parents
-                distance = any_distance
-            elif any_distance == distance:
-                for more in any_parents:
-                    if more not in parents:
-                        parents.append(more)
+    # If we have feature and non-feature branch candidates, decide which to report
+    # (one or both) based on distance.
 
-    except git.GitError as exc:
-        colour.error(exc.msg, status=exc.status, prefix=True)
+    if parents and any_parents:
+        if any_distance < distance:
+            parents = any_parents
+            distance = any_distance
+        elif any_distance == distance:
+            for more in any_parents:
+                if more not in parents:
+                    parents.append(more)
 
     if parents:
         if args.verbose:
@@ -73,6 +76,8 @@ def git_parent():
         sys.exit(1)
     except BrokenPipeError:
         sys.exit(2)
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status, prefix=True)
 
 ################################################################################
 

skilleter_thingy/git_retag.py

@@ -9,6 +9,7 @@
 """
 ################################################################################
 
+import os
 import sys
 import argparse
 
@@ -23,10 +24,17 @@ def main():
 
     parser = argparse.ArgumentParser(description='Apply or update a tag, optionally updating it on the remote as well.')
     parser.add_argument('--push', '-p', action='store_true', help='Push the tag to the remote')
+    parser.add_argument('--path', '-C', nargs=1, type=str, default=None,
+                        help='Run the command in the specified directory')
     parser.add_argument('tag', nargs=1, help='The tag')
 
     args = parser.parse_args()
 
+    # Change directory, if specified
+
+    if args.path:
+        os.chdir(args.path[0])
+
     tag = args.tag[0]
 
     # Delete the tag if it currently exists, optionally pushing the deletion
@@ -49,6 +57,8 @@ def git_retag():
         sys.exit(1)
     except BrokenPipeError:
         sys.exit(2)
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status, prefix=True)
 
 ################################################################################
 

skilleter_thingy/git_review.py

@@ -54,6 +54,7 @@ import subprocess
 import time
 from enum import IntEnum
 
+# TODO: Update to git2
 import thingy.git as git
 import thingy.dc_curses as dc_curses
 import thingy.colour as colour

skilleter_thingy/git_update.py

@@ -27,6 +27,7 @@ import argparse
 import fnmatch
 import logging
 
+# TODO: Update to git2
 import thingy.git as git
 import thingy.colour as colour
 

skilleter_thingy/git_wt.py

@@ -62,6 +62,8 @@ def git_wt():
         sys.exit(1)
     except BrokenPipeError:
         sys.exit(2)
+    except git.GitError as exc:
+        colour.error(exc.msg, status=exc.status, prefix=True)
 
 ################################################################################
 

skilleter_thingy/gitprompt.py

@@ -49,6 +49,7 @@ import os
 import sys
 import argparse
 
+# TODO: Update to git2
 import thingy.git as git
 import thingy.colour as colour
 

skilleter_thingy/localphotosync.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+
+"""
+Sync a directory tree full of photos into a tree organised by year, month and date
+"""
+
+# TODO: Ignore patterns for source and destination file paths (.trashed* and .stversions)
+# TODO: Use inotify to detect changes and run continuously
+
+import os
+import glob
+import shutil
+import sys
+import logging
+import argparse
+import re
+import datetime
+
+from enum import Enum
+
+################################################################################
+
+# Default locations for local storage of photos and videos
+
+DEFAULT_PHOTO_DIR = os.path.expanduser('~/Pictures')
+DEFAULT_VIDEO_DIR = os.path.expanduser('~/Videos')
+
+# File extensions (case-insensitive)
+
+IMAGE_EXTENSIONS = ('.jpg', '.jpeg', '.png')
+VIDEO_EXTENSIONS = ('.mp4', '.mov')
+
+# Enum of filetypes
+
+class FileType(Enum):
+    """File types"""
+    IMAGE = 0
+    VIDEO = 1
+    UNKNOWN = 2
+    IGNORE = 3
+
+################################################################################
+
+def error(msg, status=1):
+    """Exit with an error message"""
+
+    print(msg)
+    sys.exit(status)
+
+################################################################################
+
+def parse_command_line():
+    """Parse and validate the command line options"""
+
+    parser = argparse.ArgumentParser(description='Sync photos from Google Photos')
+
+    parser.add_argument('--verbose', '-v', action='store_true', help='Output verbose status information')
+    parser.add_argument('--dryrun', '--dry-run', '-D', action='store_true', help='Just list files to be copied, without actually copying them')
+    parser.add_argument('--picturedir', '-P', action='store', default=DEFAULT_PHOTO_DIR,
+                        help=f'Location of local picture storage directory (defaults to {DEFAULT_PHOTO_DIR})')
+    parser.add_argument('--videodir', '-V', action='store', default=DEFAULT_VIDEO_DIR,
+                        help=f'Location of local video storage directory (defaults to {DEFAULT_VIDEO_DIR})')
+    parser.add_argument('--path', '-p', action='store', default=None, help='Path to sync from')
+
+    args = parser.parse_args()
+
+    if not args.path:
+        error('You must specify a source directory')
+
+    # Configure debugging
+
+    logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO)
+
+    # Report parameters if verbose
+
+    logging.debug('Source:    %s', args.path)
+    logging.debug('Pictures:  %s', args.picturedir)
+    logging.debug('Videos:    %s', args.videodir)
+    logging.debug('Dry run:   %d', args.dryrun)
+
+    return args
+
+################################################################################
+
+def get_filetype(filename):
+    """Return the type of a file"""
+
+    _, ext = os.path.splitext(filename)
+
+    ext = ext.lower()
+
+    if ext in IMAGE_EXTENSIONS:
+        return FileType.IMAGE
+
+    if ext in VIDEO_EXTENSIONS:
+        return FileType.VIDEO
+
+    return FileType.UNKNOWN
+
+################################################################################
+
+def media_sync(args):
+    """Sync photos and videos from args.path to date-structured directory
+       trees in args.picturedir and args.videodir.
+       Assumes that the source files are in Android naming format:
+           (IMG|VID)_YYYYMMDD_*.(jpg|mp4)
+       Looks for a destination directory called:
+           YYYY/YYYY-MM-DD*/
+       If multiple destination directories exist, it uses the first one when the
+       names are sorted alphbetically
+       If a file with the same name exists in the destination directory it is
+       not overwritten"""
+
+    files_copied = 0
+
+    filetype_re = re.compile(r'(PANO|IMG|VID)[-_](\d{4})(\d{2})(\d{2})[-_.].*')
+
+    for sourcefile in [source for source in glob.glob(os.path.join(args.path, '*')) if os.path.isfile(source)]:
+        filetype = get_filetype(sourcefile)
+
+        if filetype == FileType.IMAGE:
+            dest_dir = args.picturedir
+        elif filetype == FileType.VIDEO:
+            dest_dir = args.videodir
+        else:
+            logging.info('Ignoring %s - unable to determine file type', sourcefile)
+            continue
+
+        date_match = filetype_re.fullmatch(os.path.basename(sourcefile))
+        if date_match:
+            year = date_match.group(2)
+            month = date_match.group(3)
+            day = date_match.group(4)
+            
+            default_dest_dir = f'{dest_dir}/{year}/{year}-{month}-{day}'
+        else:
+            logging.debug('Ignoring %s - unable to extract date from filename - using last-modified date', sourcefile)
+            
+            timestamp = os.path.getmtime(sourcefile)
+            last_modified_date = datetime.datetime.fromtimestamp(timestamp)
+            
+            year = last_modified_date.year
+            month = last_modified_date.month
+            day = last_modified_date.day
+
+            default_dest_dir = f'{dest_dir}/{year:04}/{year:04}-{month:02}-{day:02}'
+
+        dest_dir_pattern = f'{default_dest_dir}*'
+
+        dest_dirs = [path for path in glob.glob(dest_dir_pattern) if os.path.isdir(path)]
+
+        sourcefile_name = os.path.basename(sourcefile)
+
+        # Search any matching destination directories to see if the file exists
+
+        if dest_dirs:
+            for dest_dir in dest_dirs:
+                if os.path.isfile(os.path.join(dest_dir, sourcefile_name)):
+                    break
+            else:
+                dest_dir = sorted(dest_dirs)[0]
+        else:
+            if not args.dryrun:
+                os.makedirs(default_dest_dir)
+
+            dest_dir = default_dest_dir
+
+        dest_file = os.path.join(dest_dir, sourcefile_name)
+
+        if os.path.exists(dest_file):
+            logging.debug('Destination file %s already exists', dest_file)
+        else:
+            logging.info('Copying %s to %s', sourcefile, dest_file)
+
+            if not args.dryrun:
+                shutil.copyfile(sourcefile, dest_file)
+
+            files_copied += 1
+
+    if files_copied:
+        print(f'{files_copied} files copied')
+
+################################################################################
+
+def localphotosync():
+    """Entry point"""
+    try:
+        args = parse_command_line()
+
+        media_sync(args)
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    localphotosync()

skilleter_thingy/moviemover.py

@@ -0,0 +1,133 @@
+#! /usr/bin/env python3
+
+""" Search for files matching a wildcard in a directory tree and move them to an
+    equivalent location in a different tree """
+
+import argparse
+import os
+import sys
+import glob
+import pathlib
+import shutil
+import filecmp
+
+################################################################################
+
+def error(msg, status=1):
+    """ Exit with an error message """
+
+    print(msg)
+
+    sys.exit(status)
+
+################################################################################
+
+def parse_command_line():
+    """ Handle command line arguments """
+
+    parser = argparse.ArgumentParser(description='File relocation - move files by wildcard from one directory tree to another')
+
+    parser.add_argument('--source', '-s', type=str, required=True, help='Source directory')
+    parser.add_argument('--destination', '-d', type=str, required=True, help='Destination directory')
+    parser.add_argument('--dry-run', '-D', action='store_true', help='Report what files would be moved, without actually moving them')
+    parser.add_argument('files', nargs='*', help='List of wildcard matches')
+
+    args = parser.parse_args()
+
+    if not args.files:
+        print('You must specify at least one wildcard/regex parameter')
+
+    if not os.path.isdir(args.source):
+        error(f'{args.source} is not a directory')
+
+    if not os.path.isdir(args.destination):
+        error(f'{args.destination} is not a directory')
+
+    args.source_path = pathlib.Path(os.path.realpath(args.source))
+    args.destination_path = pathlib.Path(os.path.realpath(args.destination))
+
+    if args.source_path == args.destination_path:
+        error('Source and destination paths cannot be the same')
+
+    if args.source_path in args.destination_path.parents:
+        error('The destination directory cannot be within the source path')
+
+    if args.destination_path in args.source_path.parents:
+        error('The source directory cannot be within the destination path')
+
+    return args
+
+################################################################################
+
+def main():
+    """ Entry point """
+
+    args = parse_command_line()
+
+    # Process each wildcard
+
+    for wild in args.files:
+        # Find matching files in the source tree
+
+        for source_file in args.source_path.glob(f'**/{wild}'):
+            # Ignore anything that isn't a file
+
+            if source_file.is_file():
+                # Determine where to put it
+
+                dest_file = args.destination_path / source_file.relative_to(args.source_path)
+
+                if dest_file.exists():
+
+                    if filecmp.cmp(source_file, dest_file, shallow=False):
+                        print(f'Destination file {dest_file} already exists and is identical, so deleting source')
+                        if not args.dry_run:
+                            os.unlink(source_file)
+                    else:
+                        print(f'Destination file {dest_file} already exists and is DIFFERENT')
+                else:
+                    # If the destination directory doesn't exist, then create it
+
+                    if not dest_file.parent.is_dir():
+                        print(f'Creating directory {dest_file.parent}')
+
+                        if not args.dry_run:
+                            dest_file.parent.mkdir(parents=True, exist_ok=True)
+
+                    # Move the file
+
+                    print(f'Moving {source_file.name} to {dest_file.parent}')
+
+                    if not args.dry_run:
+                        try:
+                            shutil.move(source_file, dest_file)
+                        except PermissionError:
+                            print(f'WARNING: Permissions error moving {source_file}')
+
+                    # Delete the source directory if it is not empty
+
+                    source_dir = os.path.dirname(source_file)
+
+                    if not glob.glob(source_dir, recursive=True):
+                        print('Deleting directory "{source_dir}"')
+                        if not args.dry_run:
+                            os.path.unlink(source_dir)
+
+################################################################################
+
+def moviemover():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    moviemover()

skilleter_thingy/photodupe.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""Hash photos to find closely-similar images and report them"""
+
+import sys
+import os
+import pickle
+import argparse
+
+import PIL
+
+from collections import defaultdict
+
+from PIL import Image
+import imagehash
+
+################################################################################
+
+def read_image_hashes(directories):
+    """Read all the specfied directories and hash every picture therein"""
+
+    hashes = defaultdict(list)
+
+    # Walk each directory tree
+
+    for directory in directories:
+        print(f'Scanning directory tree {directory}')
+
+        for root, _, files in os.walk(directory):
+            print(f'Scanning directory {root}')
+
+            for file in files:
+                filepath = os.path.join(root, file)
+
+                fileext = os.path.splitext(file)[1]
+
+                if fileext.lower() not in ('.jbf', '.ini', '.xml', '.ffs_db'):
+                    # Calculate the hash and store path, dimensions and file size under the hash entry in the hashes table
+
+                    try:
+                        with Image.open(filepath) as image:
+                            hash_value = imagehash.average_hash(image, hash_size=12)
+
+                            size = os.stat(filepath).st_size
+                            hashes[hash_value].append({'path': filepath, 'width': image.width, 'height': image.height, 'size': size})
+
+                    except PIL.UnidentifiedImageError:
+                        sys.stderr.write(f'ERROR: Unrecognized format {filepath} (size={size})\n')
+
+                    except OSError:
+                        sys.stderr.write(f'ERROR: Unable to read {filepath} (size={size})\n')
+
+    # Return the hash table
+
+    return hashes
+
+################################################################################
+
+def main():
+    """Read the hashes and report duplicates in a vaguely civilised way"""
+
+    parser = argparse.ArgumentParser(description='Search for similar images')
+    parser.add_argument('directories', nargs='*', action='store', help='Directories to search')
+
+    args = parser.parse_args()
+
+    if not args.directories:
+        print('You must be specify at least one directory')
+        sys.exit(1)
+
+    try:
+        print('Loading cached data')
+
+        with open('photodupe.pickle', 'rb') as pickles:
+            hashes = pickle.load(pickles)
+    except (FileNotFoundError, EOFError):
+        print('Scanning directories')
+
+        hashes = read_image_hashes(args.directories)
+
+    # Sort the list of hashes so that we can easily find close matches
+
+    print('Sorting hashes')
+
+    hash_values = sorted([str(hashval) for hashval in hashes])
+
+    for hash_value in hash_values:
+        if len(hashes[hash_value]) > 1:
+            print(hash_value)
+            max_len = 0
+            min_size = None
+
+            for entry in hashes[hash_value]:
+                max_len = max(max_len, len(entry['path']))
+
+                if min_size is None:
+                    min_size = entry['size']
+                else:
+                    min_size = min(min_size, entry['size'])
+
+                if min_size >= 1024 * 1024:
+                    size_suffix = 'MiB'
+                    size_div = 1024*1024
+
+                elif min_size > 1024:
+                    size_suffix = 'KiB'
+                    size_div = 1024
+                else:
+                    size_div = 1
+                    size_suffix = ''
+
+            for entry in hashes[hash_value]:
+                size = entry['size'] // size_div
+                print(f'    {entry["path"]:{max_len}} {size:>4} {size_suffix} ({entry["width"]}x{entry["height"]})')
+
+    with open('photodupe.pickle', 'wb') as pickles:
+        pickle.dump(hashes, pickles)
+
+################################################################################
+
+def photodupe():
+    """Entry point"""
+
+    try:
+        main()
+
+    except KeyboardInterrupt:
+        sys.exit(1)
+
+    except BrokenPipeError:
+        sys.exit(2)
+
+################################################################################
+
+if __name__ == '__main__':
+    photodupe()