File: __main__.py

package info (click to toggle)
dijitso 2019.2.0~git20190418.c92dcb0-2
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 412 kB
  • sloc: python: 1,672; makefile: 194; sh: 53; ansic: 1
file content (118 lines) | stat: -rw-r--r-- 3,787 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
# -*- coding: utf-8 -*-
# Copyright (C) 2015-2016 Martin Sandve Aln├Žs
#
# This file is part of DIJITSO.
#
# DIJITSO is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# DIJITSO is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with DIJITSO. If not, see <http://www.gnu.org/licenses/>.

"""This is the commandline interface to dijitso. For usage help, run 'dijitso --help'."""

import sys
import argparse

from dijitso.params import validate_params
import dijitso.cmdline as cmd_namespace


def build_commands(cmd_namespace):
    """Collects functions called cmd_<basename> from given namespace.

    Returns dict {basename: function}.
    """
    commands = {}
    cmd_args = {}
    for name in list(cmd_namespace.keys()):
        if name.startswith("cmd_"):
            cmd_name = name.replace("cmd_", "")
            cmd = cmd_namespace[name]
            commands[cmd_name] = cmd
            args_name = "args_" + cmd_name
            if args_name in cmd_namespace:
                cmd_args[cmd_name] = cmd_namespace.get(args_name)
    return commands, cmd_args


def add_top_arguments(parser):
    "Add arguments to top level parser."
    parser.add_argument("--verbose", "-v", default=False,
                        help="set logging level")
    parser.add_argument("--cache-dir", "-r", default=None,
                        help="use non-default cache root path")
    parser.add_argument("--dry-run", "-n", default=False,
                        help="only show what would be done, don't modify filesystem")


def extract_params_from_args(args):
    p = {}
    p["cache"] = {}
    if args.cache_dir is not None:
        p["cache"]["cache_dir"] = args.cache_dir
    return p


def add_common_arguments(parser):
    "Add arguments to each subparser."
    pass


def add_cmd_arguments(cmd, parser, args):
    "Add arguments specific to a command."
    if hasattr(cmd, "add_arguments"):
        cmd.add_arguments(parser)


def build_parsers(commands, args):
    """Builds a top parser with subparsers for each command."""
    top_parser = argparse.ArgumentParser()
    add_top_arguments(top_parser)

    subparsers = top_parser.add_subparsers(help="command description", dest="cmd_name")
    cmd_parsers = {}
    for cmd_name, cmd in commands.items():
        parser = subparsers.add_parser(cmd_name, help=cmd.__doc__)
        add_common_arguments(parser)
        if cmd_name in args:
            args[cmd_name](parser)
        cmd_parsers[cmd_name] = parser

    return top_parser, subparsers, cmd_parsers


def main(args=None):
    """This is the commandline tool for the python module dijitso."""

    if args is None:
        args = sys.argv[1:]

    # Build subparsers for each command
    commands, cmd_args = build_commands(vars(cmd_namespace))
    top_parser, subparsers, cmd_parsers = build_parsers(commands, cmd_args)

    # Populate args namespace
    args_ns = argparse.Namespace()
    top_parser.parse_args(args, namespace=args_ns)

    # Extract generic params
    params = extract_params_from_args(args_ns)
    params = validate_params(params)

    # Run the chosen command (argparse doesn't allow
    # getting to this point with an invalid cmd_name)
    assert args_ns.cmd_name in commands
    cmd = commands[args_ns.cmd_name]
    return cmd(args_ns, params)


if __name__ == "__main__":
    sys.exit(main())