flit/flit.py

#!/usr/bin/python3

from datetime import datetime, timedelta
import argparse
import os
import random
import shutil
import string
from urllib.parse import quote
import json

CONFIG = ".flit.json"


def parse_opts():
    class _HelpAction(argparse._HelpAction):
        def __call__(self, parser, namespace, values, option_string=None):
            parser.print_help()
            print("")
            # retrieve subparsers from parser
            subparsers_actions = [
                action
                for action in parser._actions
                if isinstance(action, argparse._SubParsersAction)
            ]
            for subparsers_action in subparsers_actions:
                # get all subparsers and print help
                for choice, subparser in subparsers_action.choices.items():
                    print("Command: {}".format(choice))
                    print(subparser.format_help())

            parser.exit()

    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument(
        "--help", "-h", action=_HelpAction, help="Show this help message and exit"
    )
    parser.add_argument(
        "--verbose",
        "-v",
        action="store_true",
        dest="verbose",
        default=False,
        help="Increase verbosity",
    )

    parser.add_argument(
        "--root",
        "-r",
        action="store",
        dest="root",
        type=str,
        default="",
        help="Root address for printing URLS",
    )
    subparsers = parser.add_subparsers(dest="command", help="Command defaults to add")
    add_parser = subparsers.add_parser("add", add_help=False)
    add_parser.add_argument(
        "-d",
        action="store",
        type=int,
        help="Days to keep files",
        default=30,
        dest="days",
    )
    add_parser.add_argument(
        "-m",
        action="store",
        type=str,
        help="Describe share",
        default="-",
        dest="description",
    )
    add_parser.add_argument(
        "files",
        action="store",
        type=str,
        help="Copy files/folders under the new share",
        default=[],
        nargs="*",
    )

    list_parser = subparsers.add_parser("list", add_help=False)
    list_parser.add_argument(
        "--verbose",
        "-v",
        action="store_true",
        dest="verbose",
        default=False,
        help="Print individual files too",
    )
    del_parser = subparsers.add_parser("del", add_help=False)
    return parser.parse_args()


def random_char():
    return random.choice(string.ascii_uppercase + string.digits)


def random_name():
    while True:
        existing_names = [c["name"] for c in get_folders()]
        index = 0
        for existing in existing_names:
            try:
                e_index = int(existing[0:3])
                index = max(e_index + 1, index)
            except:
                pass
        name = "{:03d}-{}-{}".format(
            index,
            "".join([random_char() for x in range(3)]),
            "".join([random_char() for x in range(3)]),
        )
        if not os.path.exists(name):
            break
    return name


def create_new(p, days, description):
    os.mkdir(p)
    now = datetime.now()
    del_delta = timedelta(days=days)
    del_time = now + del_delta
    config = {}
    config["description"] = description
    config["delete_time"] = del_time.isoformat()
    config["created"] = now.isoformat()
    write_config(p, config)


def copy_files(cwd, new_name, files):
    target = os.path.abspath(new_name)
    for f in opts.files:
        print(f"Copying: {f}")
        source = os.path.join(cwd, f)
        if source.endswith("/"):
            source = source[0:-1]
        base = os.path.basename(source)
        if not os.path.exists(source):
            print("Path does not exist")
            continue
        if os.path.isfile(source):
            shutil.copy2(source, target)
        else:
            shutil.copytree(
                source,
                os.path.join(target, base),
                symlinks=True,
            )



def get_stats(p):
    # TODO: named tuple
    config = read_config(p)

    del_time = datetime.fromisoformat(config["delete_time"])
    now = datetime.now()
    mtime = datetime.fromisoformat(config["created"])

    to_del_time = del_time - now
    is_due = now > del_time
    config["delete_time"] = del_time
    config["created"] = mtime
    config["name"] = p
    config["to_deletion"] = to_del_time
    config["due"] = is_due

    return config


def get_sub_files(p):
    file_list = sorted([x for x in os.listdir(p) if not x.startswith(".")])
    dir_list = [x + "/" for x in file_list if os.path.isdir(os.path.join(p, x))]
    file_list = [x for x in file_list if os.path.isfile(os.path.join(p, x))]
    return dir_list + file_list


def get_folders():
    dir_list = [p for p in os.listdir(".") if os.path.exists(os.path.join(p, CONFIG))]
    configs = [get_stats(p) for p in dir_list]
    configs.sort(key=lambda c: c["created"], reverse=True)
    return configs


def list_folders(root_folder, verbose=False, filter_name=None):
    folders = get_folders()
    print("Folder   Created    ToDelete    InDays")
    for c in folders:
        if filter_name is not None:
            if filter_name != c["name"]:
                continue
        due = "*" if c["due"] else " "
        print(
            "{}/{}/ {} {} {: 4d}d{} {}".format(
                root_folder,
                c["name"],
                c["created"].isoformat()[0:10],
                c["delete_time"].isoformat()[0:10],
                c["to_deletion"].days,
                due,
                c["description"],
            )
        )
        if verbose:
            sub_files = get_sub_files(c["name"])
            for sp in sub_files:
                print("  {}/{}/{}".format(root_folder, c["name"], quote(sp, "/")))


def del_due_folders():
    folders = get_folders()
    for c in folders:
        if c["due"]:
            print("Deleting {}".format(c["name"]))
            shutil.rmtree(c["name"])


def read_config(p):
    with open(os.path.join(p, CONFIG), "rt") as fp:
        return json.load(fp)


def write_config(p, config):
    with open(os.path.join(p, CONFIG), "wt") as fp:
        return json.dump(config, fp, indent=2, sort_keys=True)


if __name__ == "__main__":
    opts = parse_opts()
    cwd = os.getcwd()
    os.chdir(os.path.dirname(__file__))
    if opts.command == "add":
        new_name = random_name()
        create_new(new_name, opts.days, opts.description)
        print(os.path.abspath(new_name))
        print("")
        copy_files(cwd, new_name, opts.files)
        list_folders(opts.root, verbose=True, filter_name=new_name)

    if opts.command == "list" or opts.command is None:
        list_folders(opts.root, verbose=opts.verbose)

    if opts.command == "del":
        del_due_folders()