wasp_general.command package

Submodules

wasp_general.command.command module

class wasp_general.command.command.WCommand(*command_tokens)

Bases: wasp_general.command.command.WCommandProto

Basic WCommandProto implementation

command()

Return command tokens

Returns:tuple of str

exec(*command_tokens, **command_env)

WCommandProto.exec() implementation

(throws RuntimeError if tokens are invalid, and calls WCommand._exec() method)

match(*command_tokens, **command_env)

WCommandProto.match() implementation

class wasp_general.command.command.WCommandAlias(selector)

Bases: wasp_general.command.command.WCommandProto

Prototype for command, that doesn’t do anything useful itself, but it helps to run a modified command and to return its result. For getting any useful result a WCommandSelector object is used.

exec(*command_tokens, **command_env)

WCommandProto.exec() implementation

match(*command_tokens, **command_env)

WCommandProto.match() implementation

mutate_command_tokens(*command_tokens)

Modify the input command so it can be called from the command selector

Parameters:command_tokens – Returns:

selector()

Return original command selector

Returns:WCommandSelector

class wasp_general.command.command.WCommandPrioritizedSelector(default_priority=30)

Bases: wasp_general.command.command.WCommandSelector

This class has priority for every stored commands. Command with lower priority value will be selected first.

add(command_obj)

WCommandSelector.add() redefinition (sets default priority for the given command)

add_prioritized(command_obj, priority)

Add command with the specified priority

Parameters:

• command_obj – command to add
• priority – command priority

Returns:

None

class wasp_general.command.command.WCommandProto

Bases: object

Prototype for a single command. Command tokens are string, where each token is a part of the command name or is the command parameter. Tokens are generated from a string, each token is separated by space (if space is a part of the token, then it must be quoted). Any command may require some additional parameters that are generated from environment with which this command will be checked and/or called. This extra parameters calls command environment

exec(*command_tokens, **command_env)

Execute valid command (that represent as tokens)

Parameters:

• command_tokens – command to execute
• command_env – command environment

Returns:

WCommandResultProto

static join_tokens(*command_tokens)

Join tokens into a single string

Parameters:command_tokens – tokens to join Returns:str

match(*command_tokens, **command_env)

Checks whether this command can be called with the given tokens. Return True - if tokens match this command, False - otherwise

Parameters:

• command_tokens – command to check
• command_env – command environment

Returns:

bool

static split_command(command_str)

Split command string into command tokens

Parameters:command_str – command to split Returns:tuple of str

class wasp_general.command.command.WCommandSelector

Bases: object

This class store command and selects suitable command for the given tokens.

add(command_obj)

Add command to selector

Parameters:command_obj – command to add Returns:None

select(*command_tokens, **command_env)

Select suitable command, that matches the given tokens. Each new command to check is fetched with this object iterator (WCommandSelector.__iter__())

Parameters:

• command_tokens – command
• command_env – command environment

Returns:

WCommandProto

class wasp_general.command.command.WCommandSet(command_selector=None, tracked_vars=None)

Bases: object

Class wraps routine of execution command from a command group. This class is able to keep command environment variables from previous commands results to use them in a future commands calls. Only those variables whose names were specified in a constructor will be kept.

exception NoCommandFound

Bases: Exception

Exception that is raised when no suitable command was found during WCommandSet.exec() method

commands()

Return used command selector

Returns:WCommandSelector

exec(command_str, **command_env)

Execute the given command (command will be split into tokens, every space that is a part of a token must be quoted)

Parameters:

• command_str – command to execute
• command_env – command environment

Returns:

WCommandResultProto

has_var(var_name)

Return True - if a environment variable with a specified name is kept by this command set. Otherwise - False is returned

Parameters:var_name – variable name to check Returns:bool

tracked_vars()

Return variables names that are kept (tracked) by this command set

Returns:tuple of str

var_value(var_name)

Return value of environment variable that is kept by this command set.

Note:No checks are made if there is a such variable. It implies that there is a such variable.

For any doubt - use WCommandSet.has_var() method

Parameters:var_name – target variable name Returns:anything

class wasp_general.command.command.WReduceCommand(selector, *reduce_tokens)

Bases: wasp_general.command.command.WCommandAlias

Command that creates subsection from a command selector. The command will be matched to command tokens only if the first token matches to one of reduce tokens (section name/aliases) and the command selector has command for remaining tokens. Command execution works the same way. The command will be executed from the command selector without the first token and only if the first token matches to one of reduce tokens.

mutate_command_tokens(*command_tokens)

WCommandAlias.mutate_command_tokens() implementation

reduce_tokens()

Return section names (aliases)

Returns:tuple of str

wasp_general.command.context module

class wasp_general.command.context.WCommandContext(base_command, context_adapter)

Bases: wasp_general.command.command.WCommandProto

Command that can be adapted by a context

adapter()

Return command adapter

Returns:WCommandAdapter

exec(*command_tokens, command_context=None, **command_env)

Execute command

Parameters:

• command_tokens – command tokens to execute
• command_context – command context
• command_env – command environment

Returns:

WCommandResultProto

match(*command_tokens, command_context=None, **command_env)

Match command

Parameters:

• command_tokens – command tokens to check
• command_context – command context
• command_env – command environment

Returns:

bool

original_command()

Return source command

Returns:WCommandProto

class wasp_general.command.context.WCommandContextAdapter(context_specifications)

Bases: object

Adapter is used for command tokens modification

adapt(*command_tokens, command_context=None, **command_env)

Adapt the given command tokens with this adapter

Parameters:

• command_tokens – command tokens to adapt
• command_context – context
• command_env – command environment

Returns:

list of str

match(command_context=None, **command_env)

Check if context request is compatible with adapters specification. True - if compatible, False - otherwise

Parameters:

• command_context – context to check
• command_env – command environment

Returns:

bool

specification()

Return adapter specification

Returns:WContextProto or None

class wasp_general.command.context.WContext(context_name, context_value=None, linked_context=None)

Bases: wasp_general.command.context.WContextProto

WContextProto implementation

context_name()

WContextProto.context_name() implementation

context_value()

WContextProto.context_value() implementation

classmethod export_context(context)

Export the specified context to be capable context transferring

Parameters:context – context to export Returns:tuple

classmethod import_context(context)

Import context to corresponding WContextProto object (WContext.export_context() reverse operation)

Parameters:context – context to import Returns:WContext

linked_context()

WContextProto.linked_context() implementation

classmethod specification(*context_specs)

Return linked context as adapter specification (is used by WCommandContextAdapter)

Parameters:context_specs – context names Returns:WContext

class wasp_general.command.context.WContextComposer

Bases: wasp_general.composer.WComposerProto

compose(obj_spec)

decompose(obj)

class wasp_general.command.context.WContextProto

Bases: object

Represent context configuration

context_name()

Return this context name

Returns:str

context_value()

Return this context value (can be None)

Returns:str or None

linked_context()

Return link to ‘parent’/’higher’ context

Returns:WContextProto or None

wasp_general.command.enhanced module

class wasp_general.command.enhanced.WCommandArgumentDescriptor(argument_name, required=False, flag_mode=False, multiple_values=False, help_info=None, meta_var=None, default_value=None, casting_helper=None)

Bases: object

class ArgumentCastingHelper(casting_fn=None, validate_fn=None, error_message=None)

Bases: wasp_general.command.enhanced.ArgumentCastingHelperProto

cast(argument_name, argument_value)

casting_function()

error_message()

validate_function()

class ArgumentCastingHelperProto

Bases: object

cast(argument_name, argument_value)

class DataSizeArgumentHelper

Bases: wasp_general.command.enhanced.ArgumentCastingHelper

static cast_string(value)

class EnumArgumentHelper(enum_cls)

Bases: wasp_general.command.enhanced.ArgumentCastingHelper

cast_string(value)

class FlagArgumentCastingHelper

Bases: wasp_general.command.enhanced.ArgumentCastingHelperProto

cast(argument_name, argument_value)

class FloatArgumentCastingHelper(validate_fn=None, error_message=None)

Bases: wasp_general.command.enhanced.ArgumentCastingHelper

class IntegerArgumentCastingHelper(base=10, validate_fn=None, error_message=None)

Bases: wasp_general.command.enhanced.ArgumentCastingHelper

class RegExpArgumentHelper(regexp)

Bases: wasp_general.command.enhanced.ArgumentCastingHelper

cast_string(value)

re()

validate_function()

class StringArgumentCastingHelper(validate_fn=None, error_message=None)

Bases: wasp_general.command.enhanced.ArgumentCastingHelper

argument_name()

cast(argument_name, argument_value)

casting_helper()

default_value()

flag_mode()

help_info()

meta_var()

multiple_values()

required()

class wasp_general.command.enhanced.WCommandArgumentParser(*argument_descriptors, relationships=None)

Bases: object

arguments_help()

descriptors()

parse(*command_tokens)

classmethod reduce_tokens(command_tokens, argument_descriptors, previous_result=None)

relationships()

exception wasp_general.command.enhanced.WCommandArgumentParsingError

Bases: Exception

class wasp_general.command.enhanced.WCommandArgumentRelationship(relationship, *argument_names)

Bases: object

class Relationship

Bases: enum.Enum

An enumeration.

conflict = 1

one_of = 3

requirement = 2

arguments()

relationship()

class wasp_general.command.enhanced.WEnhancedCommand(command, *argument_descriptors, relationships=None)

Bases: wasp_general.command.command.WCommandProto

argument_descriptors()

arguments_help()

command_help()

command_token()

exec(*command_tokens, **command_env)

match(*command_tokens, **command_env)

parser()

relationships()

wasp_general.command.proto module

class wasp_general.command.proto.WCommandResultProto

Bases: object

environment()

wasp_general.command.result module

class wasp_general.command.result.WCommandEnv(**command_env)

Bases: wasp_general.command.proto.WCommandResultProto

environment()

class wasp_general.command.result.WExceptionResult(message, exc, traceback, **command_env)

Bases: wasp_general.command.result.WCommandEnv

exception()

message()

traceback()

class wasp_general.command.result.WPlainCommandResult(result, **command_env)

Bases: wasp_general.command.result.WCommandEnv

classmethod error(message, **command_env)

wasp_general.command.template_command module

class wasp_general.command.template_command.WCommandResultTemplate(template, **command_env)

Bases: wasp_general.command.result.WPlainCommandResult, wasp_general.template.WTemplateRenderer

class wasp_general.command.template_command.WTemplateResultCommand(template, *command_tokens, template_context=None)

Bases: wasp_general.command.command.WCommand

Simple command that returns “template-result”, that can be “rendered” to str object later. In most time, this and derived classes return static template, which result is the same. The only requirement for execution of this command is to full command match. If WTemplateResultCommand was constructed with tokens like “foo”, “bar” then only “foo bar” command will be matched. (Note. For example, if WCommand object was constructed with tokens: “foo”, “bar”, then any of the following commands will be matched: “foo bar”, “foo bar 1”, “foo bar 2 3”.)

match(*command_tokens, **command_env)

same as WCommand.meth() method, but checks for extra arguments also (no extra arguments is allowed)

result_template(*command_tokens, **command_env)

Generate template result. command_tokens and command_env arguments are used for template detailing

Parameters:

• command_tokens – same as command_tokens in WCommandProto.match() and WCommandProto.exec() methods (so as WCommand._exec())
• command_env – same as command_env in WCommandProto.match() and WCommandProto.exec() methods (so as WCommand._exec())

Returns:

WCommandResultTemplate

template()

Return template object (that will be used in result)

Returns:WTemplate

template_context()

Return context with which template will be rendered

Returns:dict

Module contents