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

skilleter_thingy/diskspacecheck.py

@@ -1,67 +0,0 @@
-#! /usr/bin/env python3
-
-################################################################################
-""" Check how much free space is available on all filesystems, ignoring
-    read-only filesystems, /dev and tmpfs.
-
-    Issue a warning if any are above 90% used.
-"""
-################################################################################
-
-import sys
-import argparse
-import psutil
-
-################################################################################
-
-WARNING_LEVEL = 15
-
-################################################################################
-
-def main():
-    """ Do everything """
-
-    parser = argparse.ArgumentParser(description='Check for filesystems that are running low on space')
-    parser.add_argument('--level', action='store', type=int, default=WARNING_LEVEL,
-                        help='Warning if less than this amount of space is available on any writeable, mounted filesystem (default=%d)' % WARNING_LEVEL)
-    args = parser.parse_args()
-
-    if args.level < 0 or args.level > 100:
-        print('Invalid value: %d' % args.level)
-        sys.exit(3)
-
-    disks = psutil.disk_partitions()
-    devices = []
-    warning = []
-
-    for disk in disks:
-        if 'ro' not in disk.opts.split(',') and disk.device not in devices:
-            devices.append(disk.device)
-            usage = psutil.disk_usage(disk.mountpoint)
-
-            disk_space = 100 - usage.percent
-
-            if disk_space < args.level:
-                warning.append('%s has only %2.1f%% space available' % (disk.mountpoint, disk_space))
-
-    if warning:
-        print('Filesystems with less than %d%% available space:' % args.level)
-        print('\n'.join(warning))
-
-################################################################################
-
-def diskspacecheck():
-    """Entry point"""
-
-    try:
-        main()
-
-    except KeyboardInterrupt:
-        sys.exit(1)
-    except BrokenPipeError:
-        sys.exit(2)
-
-################################################################################
-
-if __name__ == '__main__':
-    diskspacecheck()

skilleter_thingy/localphotosync.py

@@ -1,201 +0,0 @@
-#!/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

@@ -1,133 +0,0 @@
-#! /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

@@ -1,135 +0,0 @@
-#!/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()