Synnefo » ./kamaki

* Python 2.7 or better (`Official versions <http://www.python.org/getit>`_)

* Setuptools (`Official versions and workarounds <http://pypi.python.org/pypi/setuptools>`_)

* Without removing existing values, append the following to PATH::

.. note:: Path values are separated by semicolons

.. warning:: C:\\Python should be replaced with the actual python path in the system, e.g. C:\\Python27

According to the corresponding `python org page <http://pypi.python.org/pypi/setuptools>`_, the setuptools installer doesn't currently work on 64bit machines.

* Users with 64-bit machines should download the `ez_setup.py <http://peak.telecommunity.com/dist/ez_setup.py>`_ script and install it from a command shell. In the following example, the script was downloaded at C:\\Downloads::

`Download GIT <http://git-scm.com/download/win>`_ and run the graphic installer. During the installation, users will be able to modify some installation options. The present guide is tested with the default selections.

* Enter the location where kamaki will be installed, e.g. **C:\\**

    .. code-block:: console

        $ cd /c/

    .. code-block:: console

        $ git clone http://code.grnet.gr/git/kamaki

        Cloning into 'kamaki'...

        Receiving objects: ...

        Resolving Deltas: ...

    .. code-block:: console

        $ cd kamaki

        $ python setup.py install

        running install

        ...

        Finished processing dependencies for kamaki==0.6.2

#  command auxiliary methods

_best_match = []

#  Generic init auxiliary functions

        add_handler('kamaki', logging.DEBUG, prefix='(debug): ')

        add_handler('kamaki', logging.INFO, prefix='(i): ')

    add_handler('kamaki', logging.WARNING, prefix='(warning): ')

    kloger = logging.getLogger('kamaki')

def _load_all_commands(cmd_tree, arguments):

    _config = arguments['config']

    for spec in [spec for spec in _config.get_groups()\

            if _config.get(spec, 'cli')]:

        try:

            spec_module = _load_spec_module(spec, arguments, '_commands')

            spec_commands = getattr(spec_module, '_commands')

        except AttributeError:

            if _debug:

                global kloger

                kloger.warning('No valid description for %s' % spec)

            continue

        for spec_tree in spec_commands:

            if spec_tree.name == spec:

                cmd_tree.add_tree(spec_tree)

                break

#  Methods to be used by CLI implementations

def print_subcommands_help(cmd):

def update_parser_help(parser, cmd):

def print_error_message(cli_err):

def exec_cmd(instance, cmd_args, help_method):

def get_command_group(unparsed, arguments):

    groups = arguments['config'].get_groups()

    for term in unparsed:

        if term.startswith('-'):

            continue

        if term in groups:

            unparsed.remove(term)

            return term

        return None

    return None

#  CLI Choice:

def run_one_cmd(exe_string, parser):

    global _history

    _history = History(

        parser.arguments['config'].get('history', 'file'))

    _history.add(' '.join([exe_string] + argv[1:]))

    from kamaki.cli import one_command

    one_command.run(parser, _help)

            run_one_cmd(exe, parser)

        print_error_message(err)

kloger = getLogger('kamaki')

from kamaki.cli import exec_cmd, print_error_message, print_subcommands_help

from kamaki.cli.utils import print_dict, split_input

                    exec_cmd(instance,

                    print_error_message(err)

                print_subcommands_help(cmd)

                print_subcommands_help(cmd)

from kamaki.cli import exec_cmd, print_error_message

            exec_cmd(instance, prs.unparsed, prs.parser.print_help)

            print_error_message(err)

# Copyright 2012-2013 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or

# without modification, are permitted provided that the following

# conditions are met:

#

#   1. Redistributions of source code must retain the above

#      copyright notice, this list of conditions and the following

#      disclaimer.

#

#   2. Redistributions in binary form must reproduce the above

#      copyright notice, this list of conditions and the following

#      disclaimer in the documentation and/or other materials

#      provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS

# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR

# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF

# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED

# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN

# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

# POSSIBILITY OF SUCH DAMAGE.

#

# The views and conclusions contained in the software and

# documentation are those of the authors and should not be

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.command

from logging import getLogger

from kamaki.cli import get_command_group, set_command_params

from kamaki.cli import print_subcommands_help, exec_cmd, update_parser_help

from kamaki.cli import _groups_help, _load_spec_module

kloger = getLogger('kamaki')

def _get_cmd_tree_from_spec(spec, cmd_tree_list):

    for tree in cmd_tree_list:

        if tree.name == spec:

            return tree

    return None

def _get_best_match_from_cmd_tree(cmd_tree, unparsed):

    matched = [term for term in unparsed if not term.startswith('-')]

    while matched:

        try:

            return cmd_tree.get_command('_'.join(matched))

        except KeyError:

            matched = matched[:-1]

    return None

def run(parser, _help):

    group = get_command_group(list(parser.unparsed), parser.arguments)

    if not group:

        parser.parser.print_help()

        _groups_help(parser.arguments)

        exit(0)

    nonargs = [term for term in parser.unparsed if not term.startswith('-')]

    set_command_params(nonargs)

    global _best_match

    _best_match = []

    spec_module = _load_spec_module(group, parser.arguments, '_commands')

    cmd_tree = _get_cmd_tree_from_spec(group, spec_module._commands)

    if _best_match:

        cmd = cmd_tree.get_command('_'.join(_best_match))

    else:

        cmd = _get_best_match_from_cmd_tree(cmd_tree, parser.unparsed)

        _best_match = cmd.path.split('_')

    if cmd is None:

        kloger.info(

            'Unexpected error: failed to load command (-d for details)')

        exit(1)

    update_parser_help(parser, cmd)

    if _help or not cmd.is_command:

        parser.parser.print_help()

        print_subcommands_help(cmd)

        exit(0)

    cls = cmd.get_class()

    executable = cls(parser.arguments)

    parser.update_arguments(executable.arguments)

    #parsed, unparsed = parse_known_args(parser, executable.arguments)

    for term in _best_match:

        parser.unparsed.remove(term)

    exec_cmd(executable, parser.unparsed, parser.parser.print_help)