things_cli.cli

Complexity

Total Complexity

33

Size/Duplication

Total Lines	368
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	ThingsCLI.opml_convert()	0	12	3
A	ThingsCLI.csv_dumps()	0	17	3
A	ThingsCLI.defaults()	0	8	1
A	ThingsCLI.opml_dumps()	0	11	1
A	ThingsCLI.print_tasks()	0	10	4
A	ThingsCLI.__init__()	0	2	1
A	ThingsCLI.print_unimplemented()	0	4	1
A	ThingsCLI.csv_converter()	0	10	3
A	ThingsCLI.txt_dumps()	0	23	3
B	ThingsCLI.get_parser()	0	143	1
C	ThingsCLI.main()	0	65	9
A	ThingsCLI.csv_header()	0	5	2

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

"""A simple Python 3 CLI to read your Things app data."""

from __future__ import print_function

import argparse
import csv
from io import StringIO
import json
import sys
import webbrowser
from xml.dom import minidom
import xml.etree.ElementTree as ETree
from xml.etree.ElementTree import Element, SubElement

import argcomplete  # type: ignore

Unable to import 'argcomplete'

import things as api

Unable to import 'things'

from things_cli import __version__


class ThingsCLI:  # pylint: disable=R0902
    """A simple Python 3 CLI to read your Things app data."""

    print_json = False
    print_csv = False
    print_opml = False
    # anonymize = False
    database = None
    recursive = False
    filter_project = None
    filter_area = None
    filter_tag = None

    def __init__(self, database=None):
        self.database = database

    def print_tasks(self, tasks):
        """Print a task."""
        if self.print_json:
            print(json.dumps(tasks))
        elif self.print_opml:
            print(self.opml_dumps(tasks))
        elif self.print_csv:
            print(self.csv_dumps(tasks))
        else:
            print(self.txt_dumps(tasks), end="")

    def csv_dumps(self, tasks):
        """Convert tasks into CSV."""

        fieldnames = []
        self.csv_header(tasks, fieldnames)
        if "items" in fieldnames:
            fieldnames.remove("items")
        if "checklist" in fieldnames:
            fieldnames.remove("checklist")

        output = StringIO()
        writer = csv.DictWriter(output, fieldnames=fieldnames, delimiter=";")
        writer.writeheader()

        self.csv_converter(tasks, writer)

        return output.getvalue()

    def csv_header(self, tasks, fieldnames):
        """Convert tasks into CSV header."""
        for task in tasks:
            fieldnames.extend(field for field in task if field not in fieldnames)
            self.csv_header(task.get("items", []), fieldnames)

    def csv_converter(self, tasks, writer):
        """Convert tasks into CSV."""
        if tasks is True:
            return
        for task in tasks:
            self.csv_converter(task.get("items", []), writer)
            task.pop("items", [])
            self.csv_converter(task.get("checklist", []), writer)
            task.pop("checklist", [])
            writer.writerow(task)

    def opml_dumps(self, tasks):
        """Convert tasks into OPML."""

        top = Element("opml")
        head = SubElement(top, "head")
        SubElement(head, "title").text = "Things 3 Database"
        body = SubElement(top, "body")

        self.opml_convert(tasks, body)

        return minidom.parseString(ETree.tostring(top)).toprettyxml(indent="   ")

    def opml_convert(self, tasks, top):
        """Print pretty OPML of selected tasks."""

        if tasks is True:
            return
        for task in tasks:
            area = SubElement(top, "outline")
            area.set("text", task["title"])
            self.opml_convert(task.get("items", []), area)
            task.pop("items", [])
            self.opml_convert(task.get("checklist", []), area)
            task.pop("checklist", [])

    def txt_dumps(self, tasks, indentation="", result=""):
        """Print pretty text version of selected tasks."""

        if tasks is True:
            return result
        for task in tasks:
            title = task["title"]
            context = (
                task.get("project_title", None)
                or task.get("area_title", None)
                or task.get("heading_title", None)
                or task.get("start", None)
            )
            start = task.get("start_date", None)
            details = " | ".join(filter(None, [start, context]))
            result = result + f"{indentation}- {title} ({details})\n"
            result = self.txt_dumps(task.get("items", []), indentation + "  ", result)
            task.pop("items", [])
            result = self.txt_dumps(
                task.get("checklist", []), indentation + "  ", result
            )

        return result

    @classmethod
    def print_unimplemented(cls, command):
        """Show warning that method is not yet implemented."""
        print("command '%s' not implemented yet" % command, file=sys.stderr)

    @classmethod
    def get_parser(cls):
        """Create command line argument parser"""
        parser = argparse.ArgumentParser(description="Simple read-only Thing 3 CLI.")

        subparsers = parser.add_subparsers(
            help="", metavar="command", required=True, dest="command"
        )

        ################################
        # Core database methods
        ################################
        subparsers.add_parser("inbox", help="Shows inbox tasks")
        subparsers.add_parser("today", help="Shows todays tasks")
        subparsers.add_parser("upcoming", help="Shows upcoming tasks")
        subparsers.add_parser("anytime", help="Shows anytime tasks")
        subparsers.add_parser("completed", help="Shows completed tasks")
        subparsers.add_parser("canceled", help="Shows canceled tasks")
        subparsers.add_parser("trash", help="Shows trashed tasks")
        subparsers.add_parser("todos", help="Shows all todos")
        subparsers.add_parser("all", help="Shows all tasks")
        subparsers.add_parser("areas", help="Shows all areas")
        subparsers.add_parser("projects", help="Shows all projects")
        subparsers.add_parser("logbook", help="Shows tasks completed today")
        subparsers.add_parser("tags", help="Shows all tags ordered by their usage")
        subparsers.add_parser("deadlines", help="Shows tasks with due dates")

        ################################
        # Additional functions
        ################################
        subparsers.add_parser("feedback", help="Give feedback")
        subparsers.add_parser(
            "search", help="Searches for a specific task"
        ).add_argument("string", help="String to search for")

        ################################
        # To be implemented in things.py
        ################################
        # subparsers.add_parser("repeating", help="Shows all repeating tasks")
        # subparsers.add_parser("subtasks", help="Shows all subtasks")
        # subparsers.add_parser("headings", help="Shows headings")

        ################################
        # To be converted from https://github.com/alexanderwillner/things.sh
        ################################
        # subparsers.add_parser("backlog", help="Shows backlog tasks")
        # subparsers.add_parser("empty", help="Shows projects that are empty")
        # subparsers.add_parser("hours", help="Shows hours planned today")
        # subparsers.add_parser("ical", help="Shows tasks ordered by due date as iCal")
        # subparsers.add_parser("lint", help="Shows tasks that float around")
        # subparsers.add_parser(
        #     "mostClosed", help="Shows days when most tasks were closed"
        # )
        # subparsers.add_parser(
        #     "mostCancelled", help="Shows days when most tasks were cancelled"
        # )
        # subparsers.add_parser(
        #     "mostTrashed", help="Shows days when most tasks were trashed"
        # )
        # subparsers.add_parser(
        #     "mostCreated", help="Shows days when most tasks were created"
        # )
        # subparsers.add_parser("mostTasks", help="Shows projects that have most tasks")
        # subparsers.add_parser(
        #     "mostCharacters", help="Shows tasks that have most characters"
        # )
        # subparsers.add_parser("nextish", help="Shows all nextish tasks")
        # subparsers.add_parser("old", help="Shows all old tasks")
        # subparsers.add_parser("schedule", help="Schedules an event using a template")
        # subparsers.add_parser("stat", help="Provides a number of statistics")
        # subparsers.add_parser("statcsv", help="Exports some statistics as CSV")
        # subparsers.add_parser("tag", help="Shows all tasks with the waiting for tag")
        # subparsers.add_parser(
        #     "waiting", help="Shows all tasks with the waiting for tag"
        # )

        ################################
        # To be converted from https://github.com/alexanderwillner/things.sh
        ################################
        # parser.add_argument("-a", "--anonymize",
        #                     action="store_true", default=False,
        #                     help="anonymize output", dest="anonymize")

        parser.add_argument(
            "-p", "--filter-project", dest="filter_project", help="Filter by project"
        )
        parser.add_argument(
            "-a", "--filter-area", dest="filter_area", help="Filter by area"
        )
        parser.add_argument(
            "-t", "--filtertag", dest="filter_tag", help="Filter by tag"
        )

        parser.add_argument(
            "-o",
            "--opml",
            action="store_true",
            default=False,
            help="output as OPML",
            dest="opml",
        )

        parser.add_argument(
            "-j",
            "--json",
            action="store_true",
            default=False,
            help="output as JSON",
            dest="json",
        )

        parser.add_argument(
            "-c",
            "--csv",
            action="store_true",
            default=False,
            help="output as CSV",
            dest="csv",
        )

        parser.add_argument(
            "-r",
            "--recursive",
            help="in-depth output",
            dest="recursive",
            default=False,
            action="store_true",
        )

        parser.add_argument(
            "-d", "--database", help="set path to database", dest="database"
        )

        parser.add_argument(
            "--version",
            "-v",
            action="version",
            version="%(prog)s (version {version})".format(version=__version__),
        )

        argcomplete.autocomplete(parser)

        return parser

    def defaults(self):
        """Some default options for the new API."""
        return dict(
            project=self.filter_project,
            area=self.filter_area,
            tag=self.filter_tag,
            include_items=self.recursive,
            filepath=self.database,
        )

    def main(self, args=None):
        """ Main entry point of the app """

        if args is None:
            self.main(ThingsCLI.get_parser().parse_args())
        else:
            command = args.command
            self.print_json = args.json
            self.print_csv = args.csv
            self.print_opml = args.opml
            self.database = args.database or self.database
            self.filter_project = args.filter_project or None
            self.filter_area = args.filter_area or None
            self.filter_tag = args.filter_tag or None
            self.recursive = args.recursive
            # self.anonymize = args.anonymize
            # self.things3.anonymize = self.anonymize ## not implemented
            defaults = self.defaults()

            remove_filter = ["all", "areas", "tags"]
            if command in remove_filter:
                defaults.pop("area")
                defaults.pop("project")
                defaults.pop("tag")

            if command == "all":
                inbox = api.inbox(**defaults)
                today = api.today(**defaults)
                upcoming = api.upcoming(**defaults)
                anytime = api.anytime(**defaults)
                someday = api.someday(**defaults)
                logbook = api.logbook(**defaults)

                no_area = api.projects(**defaults)
                areas = api.areas(**defaults)
                structure = [
                    {"title": "Inbox", "items": inbox},
                    {"title": "Today", "items": today},
                    {"title": "Upcoming", "items": upcoming},
                    {"title": "Anytime", "items": anytime},
                    {"title": "Someday", "items": someday},
                    {"title": "Logbook", "items": logbook},
                    {"title": "No Area", "items": no_area},
                    {"title": "Areas", "items": areas},
                ]
                self.print_tasks(structure)
            elif command == "upcoming":
                result = getattr(api, command)(**defaults)
                result.sort(key=lambda task: task["start_date"], reverse=False)
                self.print_tasks(result)
            elif command == "search":
                self.print_tasks(
                    api.search(
                        args.string,
                        filepath=self.database,
                        include_items=self.recursive,
                    )
                )
            elif command == "feedback":  # pragma: no cover
                webbrowser.open("https://github.com/thingsapi/things-cli/issues")
            elif command in dir(api):
                self.print_tasks(getattr(api, command)(**defaults))
            else:  # pragma: no cover
                ThingsCLI.print_unimplemented(command)
                sys.exit(3)


def main():
    """Main entry point for CLI installation"""
    ThingsCLI().main()


if __name__ == "__main__":
    main()