Why

FAST! EASY! natural import usage! --help is decent!

Quickstart

1. Install:

   # pip install xacto

2. Prepare:

   # ln -s $(which xacto) do

3. Create python file at tools/work.py:

from pprint import pprint


__all__ = ["easy", "hard", "manual"]


def easy(method, speed=16, *tasks):
    """The simple version"""
    pprint(locals())


def hard(method, speed=32, *tasks, **params):
    """The difficult version"""
    pprint(locals())


class manual(object):
    """The laborious version"""

    def __call__(self, method, speed, *tasks):
        pprint(locals())

    def method(self, process):
        """Howto perform operation"""

    def speed(self, ops=64):
        """Operations per second"""

    def tasks(self, pri, sec, ter):
        """Various tasks"""

1. View --help:

   # ./do work --help
   usage: do work OBJECT ...
   
   additional modules:
     OBJECT  := { .do.work }
       easy  The simple version
       hard  The difficult version
       manual
             The laborious version

2. View object-level --help:

   # ./do work manual --help
   usage: do work manual --method PROCESS --speed [OPS] [tasks [tasks ...]]
   
   The laborious version
   
   positional arguments:
     tasks             Various tasks
   
   optional arguments:
     --method PROCESS  Howto perform operation
     --speed [OPS]     Operations per second
   
   The laborious version

3. Run tool (function):

   # ./do work hard --method=cheat --code=iddqd taskN
   {'method': 'cheat',
    'params': {'code': 'iddqd'},
    'speed': 32,
    'tasks': ('taskN',)}

4. Run tool (class):

   # ./do work manual --method=cheap --speed=256 taskN
   {'method': 'cheap',
    'self': <do.work.manual object at ...>,
    'speed': '256',
    'tasks': ('taskN',)}

Limitations

• true/false quirkyness (default=True means –default flips to False)

TODO

• RELEASE!

• testing: set-like functions, import semantics.. everything

• handle bools better

• detect output

• standard output structure

• prettify to tty

• lazy load tools

• lazy import globals (cpython)

• bytecode cache

• argument forwarding/chaining

• integrate with zippy.shell

• tab-completion

• auto-reduce common components for aliases

• make xacto object accessible to tools