Current File : //usr/lib/python2.7/site-packages/requestbuilder/__init__.py
# Copyright (c) 2012-2015, Eucalyptus Systems, Inc.
#
# Permission to use, copy, modify, and/or distribute this software for
# any purpose with or without fee is hereby granted, provided that the
# above copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
import argparse
import operator
import os.path
import subprocess
import warnings
__version__ = '0.7.1'
if '__file__' in globals():
# Check if this is a git repo; maybe we can get more precise version info
try:
repo_path = os.path.join(os.path.dirname(__file__), '..')
env = {'GIT_DIR': os.path.join(repo_path, '.git')}
git = subprocess.Popen(['git', 'describe'], stdout=subprocess.PIPE,
stderr=subprocess.PIPE, env=env)
git.wait()
git.stderr.read()
if git.returncode == 0:
__version__ = git.stdout.read().strip().lstrip('v')
if type(__version__).__name__ == 'bytes':
__version__ = __version__.decode()
except:
# Not really a bad thing; we'll just use what we had
pass
########## SINGLETONS ##########
# Indicates a parameter that should be sent to the server without a value.
# Contrast this with empty strings, with are omitted from requests entirely.
EMPTY = type('EMPTY', (), {'__repr__': lambda self: "''",
'__str__': lambda self: ''})()
# Getters used for arg routing
PARAMS = operator.attrgetter('params')
SESSION = operator.attrgetter('service.session_args')
########## ARG CLASSES ##########
class Arg(object):
'''
A command line argument. Positional and keyword arguments to __init__
are the same as those to argparse.ArgumentParser.add_argument.
The value specified by the 'dest' argument (or the one inferred if
none is specified) is used as the name of the parameter to server
queries unless send=False is also supplied.
'''
def __init__(self, *pargs, **kwargs):
if 'route_to' in kwargs:
if isinstance(kwargs['route_to'], (list, set, tuple)):
self.routes = tuple(kwargs.pop('route_to'))
else:
self.routes = (kwargs.pop('route_to'),)
else:
self.routes = None
self.pargs = pargs
self.kwargs = kwargs
def __eq__(self, other):
if isinstance(other, Arg):
return sorted(self.pargs) == sorted(other.pargs)
return False
def __repr__(self):
return '{0}({1})'.format(
self.__class__.__name__,
', '.join(repr(arg) for arg in self.pargs))
class MutuallyExclusiveArgList(list):
'''
Pass Args as positional arguments to __init__ to create a set of
command line arguments that are mutually exclusive. If you also
call the required() method then the user must specify exactly one
of them. The recommended way to do that is via chaining it from
__init__.
Examples:
MutuallyExclusiveArgList(Arg('--spam'), Arg('--eggs'))
MutuallyExclusiveArgList(Arg('--spam'),
Arg('--eggs')).required()
'''
def __init__(self, *args):
if len(args) > 0 and isinstance(args[0], bool):
# Deprecated in 0.6
warnings.warn('positional booleans in MutuallyExclusiveArgLists '
'are deprecated; use .required() instead',
DeprecationWarning)
self.is_required = args[0]
list.__init__(self, args[1:])
else:
self.is_required = False
list.__init__(self, args)
def required(self):
self.is_required = True
return self
def __repr__(self):
return '{0}({1}){2}'.format(
self.__class__.__name__,
', '.join(repr(item) for item in self),
'.required()' if self.required else '')
class Filter(object):
'''
An AWS query API filter. For APIs that support filtering by
name/value pairs, adding a Filter to a request's list of filters will
allow a user to send an output filter to the server with '--filter
name=value' at the command line.
The value specified by the 'dest' argument (or the 'name' argument,
if none is given) is used as the name of a filter in queries.
'''
def __init__(self, name, type=str, choices=None, help=None):
self.name = name
self.type = type
self.choices = choices
self.help = help
def matches_argval(self, argval):
return argval.startswith(self.name + '=')
def convert(self, argval):
'''
Given an argument to --filter of the form "<name>=<value>", convert
the value to the appropriate type by calling self.type on it, then
return a (name, converted_value) tuple. If the value's type conversion
doesn't work then an ArgumentTypeError will result. If the conversion
succeeds but does not appear in self.choices when it exists, an
ArgumentTypeError will result as well.
'''
if '=' not in argval:
msg = "filter '{0}' must have format 'NAME=VALUE'".format(argval)
raise argparse.ArgumentTypeError(msg)
(name, value_str) = argval.split('=', 1)
try:
value = self.type(value_str)
except ValueError:
msg = "{0} filter value '{1}' must have type {2}".format(
name, value_str, self.type.__name__)
raise argparse.ArgumentTypeError(msg)
if self.choices and value not in self.choices:
msg = "{0} filter value '{1}' must match one of {2}".format(
name, value,
', '.join([str(choice) for choice in self.choices]))
raise argparse.ArgumentTypeError(msg)
if value == '':
value = EMPTY
return (name, value)
def __repr__(self):
return '{0}({1})'.format(self.__class__.__name__, repr(self.name))
class GenericTagFilter(Filter):
'''
A filter that accepts "tag:<key>=<value>" values
'''
def matches_argval(self, argval):
return argval.startswith('tag:') and '=' in argval
Mini Shell