artifact-app 1.0.1

Artifact is a design doc tool made for developers. It allows anyone to easily write and link their design docs both to each other and to source code, making it easy to track how complete their project is. Documents are revision controllable, can be rendered as a static web page and have a full suite of command line tools for searching, formatting and displaying them.
Documentation 
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

"""Interact with the artifact server.

TODO: this is still a work in progress. We need:
    - an Artifact data type with from_dict and to_dict methods
      and an `__init__` that we can use for making artifacts
    - all methods should ONLY accept and return the Artifact
      data type
    - better command line interface for interacting with the API

"""

from __future__ import print_function

import argparse
import code
import pprint

from py_helpers.json_rpc import JsonRpc


class CrudApi(JsonRpc):
    """Class for interacting with the artifact CRUD server API."""

    def create_artifacts(self, params):
        """create a list of artifacts."""
        payload = {
            'method': 'CreateArtifacts',
            'params': params,
        }
        return self.put(self.address, json=payload)

    def read_artifacts(self, params=None):
        """read the artifacts in a list."""
        payload = {
            'method': 'ReadArtifacts',
            'params': params,
        }
        r = self.put(self.address, json=payload)
        r.raise_for_status()
        return r.json()

    def update_artifacts(self, params):
        """update the list of artifacts.

        Artifacts must already exist.

        """
        payload = {
            'method': 'UpdateArtifacts',
            'params': params,
        }
        return self.put(self.address, json=payload)

    def delete_artifacts(self, params):
        """delete the list of artifact ids."""
        payload = {
            'method': 'DeleteArtifacts',
            'params': params,
        }
        return self.put(self.address, json=payload)


def parse_args(args=None):
    """parse cmdline arguments."""
    parser = argparse.ArgumentParser()
    parser.add_argument(
        'address', nargs='?',
        default="http://127.0.0.1:5373", help='address of artifact server')

    parser.add_argument(
        '-i', '--interactive',
        help='open python shell to interact with the server',
        action='store_true')

    return parser.parse_args(args=args)


def readline_setup(exports):
    """setup readline completion, if available.

    :param exports: the namespace to be used for completion
    :return: True on success

    """
    try:
        import readline
    except ImportError:
        # no completion for you.
        readline = None
        return False
    else:
        import rlcompleter
        readline.set_completer(
            rlcompleter.Completer(namespace=exports).complete)
        return True


# pylint: disable=unused-variable
def start_interactive(api):
    """start an interactive shell for the API.

    :param CrudApi api: the CrudApi session object.

    """
    # make pretty-printing easier
    pp = pprint.pprint

    create = api.create_artifacts
    read = api.read_artifacts
    update = api.update_artifacts
    delete = api.delete_artifacts

    local = locals()
    exports = globals().copy()
    exports.update(local)

    # completion for global and local namespace
    readline_setup(exports)
    # dir() will only show locals()
    code.interact(banner=__doc__, local=local)


def main():
    """execute as a script."""
    args = parse_args()
    api = CrudApi(args.address)
    if args.interactive:
        start_interactive(api)
    else:
        raise NotImplementedError('sorry, the rest is not implemented, yet')


if __name__ == '__main__':
    main()