from cliff import command
from cliff.lister import Lister


class Command(command.Command):
    """Command with a parser shortcut."""
    def get_parser(self, prog_name):
        parser = super().get_parser(prog_name)
        self.extend_parser(parser)
        return parser

    def extend_parser(self, parser):
        ...

class Add(Command):
    """Add new task."""

    def extend_parser(self, parser):
        parser.add_argument("title", help="Task title")

    def take_action(self, parsed_args):
        task = self.app.todoapp.add_task(parsed_args.title)
        print(task, "created with number", task.number, end=".\n")


class Show(Lister, Command):
    """Show current tasks."""

    def extend_parser(self, parser):
        parser.add_argument(
            "--show-done", action="store_true", help="Include done tasks"
        )

    def take_action(self, parsed_args):
        tasks = self.app.todoapp.list_tasks(show_done=parsed_args.show_done)
        # команда не выводит сообщение 'there is no todos' в целях
        # поддержки пустого вывода при форматировании
        return (
            ("Number", "Title", "Status"),
            [[task.number, task.title, "" if task.done else "?"] for task in tasks],
        )


class Done(Command):
    """Mark task as done."""

    def extend_parser(self, parser):
        parser.add_argument("number", type=int, help="Task number")

    def take_action(self, parsed_args):
        task = self.app.todoapp.task_done(number=parsed_args.number)
        print(task, "marked as done.")


# унаследована от Done для переиспользования парсера
class Remove(Done):
    """Remove task from the list."""

    def take_action(self, parsed_args):
        task = self.app.todoapp.remove_task(number=parsed_args.number)
        print(task, "removed from the list.")

from cliff import app
from cliff.commandmanager import CommandManager

from todolib import TodoApp, __version__


class App(app.App):
    def __init__(self):
        # кроме ручного add_command, CommandManager может
        # доставать команды из setuptools entrypoint
        manager = CommandManager("todo_cliff")
        manager.add_command("add", Add)
        manager.add_command("show", Show)
        manager.add_command("done", Done)
        manager.add_command("remove", Remove)
        super().__init__(
            description="Todo notes on cliff",
            version=__version__,
            command_manager=manager,
            deferred_help=True,
        )
        self.todoapp = None

    def initialize_app(self, argv):
        self.todoapp = TodoApp.fromenv()

    def clean_up(self, cmd, result, err):
        self.todoapp.save()


def main(args=sys.argv[1:]) -> int:
    app = App()
    return app.run(argv=args)

import plac
import todolib

class TodoInterface:
    commands = "add", "show", "done", "remove"

    def __init__(self):
        self.app = todolib.TodoApp.fromenv()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.app.save()

    def add(self, task):
        """ Add new task. """
        task = self.app.add_task(title=task)
        print(task, "created with number", task.number, end=".\n")

    def show(self, show_done: plac.Annotation("Include done tasks", kind="flag")):
        """ Show current tasks. """
        self.app.print_tasks(show_done=show_done)

    def done(self, number: "Task number"):
        """ Mark task as done. """
        task = self.app.task_done(number=int(number))
        print(task, "marked as done.")

    def remove(self, number: "Task number"):
        """ Remove task from the list. """
        task = self.app.remove_task(number=int(number))
        print(task, "removed from the list.")
    
if __name__ == "__main__":
    plac.Interpreter.call(TodoInterface)

from plumbum import cli, colors

class App(cli.Application):
    """Todo notes on plumbum."""

    VERSION = todolib.__version__
    verbosity = cli.CountOf("-v", help="Increase verbosity")

    def main(self, *args):
        if args:
            print(colors.red | f"Unknown command: {args[0]!r}.")
            return 1
        if not self.nested_command:  # will be ``None`` if no sub-command follows
            print(colors.red | "No command given.")
            return 1


class Command(cli.Application):
    """Command with todoapp object"""
    def __init__(self, executable):
        super().__init__(executable)
        self.todoapp = todolib.TodoApp.fromenv()
        atexit.register(self.todoapp.save)

    def log_task(self, task, msg):
        print("Task", colors.green | task.title, msg, end=".\n")

@App.subcommand("add")
class Add(Command):
    """Add new task"""
    def main(self, task):
        task = self.todoapp.add_task(title=task)
        self.log_task(task, "added to the list")


@App.subcommand("show")
class Show(Command):
    """Show current tasks"""
    show_done = cli.Flag("--show-done", help="Include done tasks")
    def main(self):
        self.todoapp.print_tasks(self.show_done)


@App.subcommand("done")
class Done(Command):
    """Mark task as done"""
    def main(self, number: int):
        task = self.todoapp.task_done(number)
        self.log_task(task, "marked as done")


@App.subcommand("remove")
class Remove(Command):
    """Remove task from the list"""
    def main(self, number: int):
        task = self.todoapp.remove_task(number)
        self.log_task(task, "removed from the list.")

if __name__ == '__main__':
    App.run()

import cmd2
import todolib


class App(cmd2.Cmd):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.todoapp = todolib.TodoApp.fromenv()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.todoapp.save()

    def do_add(self, title):
        """Add new task."""
        task = self.todoapp.add_task(str(title))
        self.poutput(f"{task} created with number {task.number}.")

    def do_show(self, show_done):
        """Show current tasks."""
        self.todoapp.print_tasks(bool(show_done))

    def do_done(self, number):
        """Mark task as done."""
        task = self.todoapp.task_done(int(number))
        self.poutput(f"{task} marked as done.")

    def do_remove(self, number):
        """Remove task from the list."""
        task = self.todoapp.remove_task(int(number))
        self.poutput(f"{task} removed from the list.")


def main(**kwargs):
    with App(**kwargs) as app:
        app.cmdloop()


if __name__ == '__main__':
    main()    

import cmd2
from todo_argparse import get_parser


parser = get_parser(progname="todo_cmd2_cli")


class App(cmd2.Cmd):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self.todoapp = todolib.TodoApp.fromenv()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.todoapp.save()

    def do_add(self, args):
        """Add new task."""
        task = self.todoapp.add_task(args.title)
        self.poutput(f"{task} created with number {task.number}.")

    def do_show(self, args):
        """Show current tasks."""
        self.todoapp.print_tasks(args.show_done)

    def do_done(self, args):
        """Mark task as done."""
        task = self.todoapp.task_done(args.number)
        self.poutput(f"{task} marked as done.")

    def do_remove(self, args):
        """Remove task from the list."""
        task = self.todoapp.remove_task(args.number)
        self.poutput(f"{task} removed from the list.")

    parser.add.set_defaults(func=do_add)
    parser.show.set_defaults(func=do_show)
    parser.done.set_defaults(func=do_done)
    parser.remove.set_defaults(func=do_remove)

    @cmd2.with_argparser(parser)
    def do_base(self, args):
        func = getattr(args, "func", None)
        if func:
            func(self, args)
        else:
            print("No command provided.")
            print("Call with --help to get available commands.")


def main(argv=None):
    with App() as app:
        app.do_base(argv or sys.argv[1:])


if __name__ == '__main__':
    main()

import urwid
from urwid import Button
import todolib


class App(urwid.WidgetPlaceholder):
    max_box_levels = 4
    def __init__(self):
        super().__init__(urwid.SolidFill())
        self.todoapp = None
        self.box_level = 0

    def __enter__(self):
        self.todoapp = todolib.TodoApp.fromenv()
        self.new_menu(
            "Todo notes on urwid",
            # у кнопки есть текст и хэндлер нажатия, который
            # должен принимать объект нажатой кнопки
            Button("New task", on_press=add),
            Button("List tasks", on_press=list_tasks),
        )
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.todoapp.save()

    def new_menu(self, title, *items):
        self.new_box(menu(title, *items))

    def new_box(self, widget):
        self.box_level += 1
        # overlay позволяет держать один виджет поверх другого,
        # в данном случае новый LineBox поверх существующего виджета
        self.original_widget = urwid.Overlay(
            # LineBox рисует unicode-линию вокруг переданного виджета
            self.original_widget,
            align="center",
            width=30,
            valign="middle",
            height=10,
        )

    def popup(self, text):
        self.new_menu(text, Button("To menu", on_press=lambda _: self.pop(levels=2)))

    def keypress(self, size, key):
        if key != "esc":
            super().keypress(size, key=key)
        elif self.box_level > 0:
            self.pop()

    def pop(self, levels=1):
        for _ in range(levels):
            self.original_widget = self.original_widget[0]
        self.box_level -= levels
        if self.box_level == 0:
            raise urwid.ExitMainLoop()

app = App()


def menu(title, *items) -> urwid.ListBox:
    body = [urwid.Text(title), urwid.Divider()]
    body.extend(items)
    return urwid.ListBox(urwid.SimpleFocusListWalker(body))


def add(button):
    edit = urwid.Edit("Title: ")

    def handle(button):
        text = edit.edit_text
        app.todoapp.add_task(text)
        app.popup("Task added")

    app.new_menu("New task", edit, Button("Add", on_press=handle))


def list_tasks(button):
    tasks = app.todoapp.list_tasks(show_done=True)
    buttons = []
    for task in tasks:
        status = "done" if task.done else "not done"
        text = f"{task.title} [{status}]"
        # кнопка также может передавать дополнительные данные в коллбэки
        button = Button(text, on_press=task_actions, user_data=task.number)
        buttons.append(button)
    app.new_menu("Task list", *buttons)


def task_actions(button, number):
    def done(button, number):
        app.todoapp.task_done(number)
        app.popup("Task marked as done.")

    def remove(button, number):
        app.todoapp.remove_task(number)
        app.popup("Task removed from the list.")

    btn_done = Button("Mark as done", on_press=done, user_data=number)
    btn_remove = Button("Remove from the list", on_press=remove, user_data=number)
    app.new_menu("Actions", btn_done, btn_remove)