def test_isXxxType_more(self):
import operator
assert not operator.isSequenceType(list)
assert not operator.isSequenceType(dict)
assert not operator.isSequenceType({})
assert not operator.isMappingType(list)
assert not operator.isMappingType(dict)
assert not operator.isMappingType([])
assert not operator.isMappingType(())
assert not operator.isNumberType(int)
assert not operator.isNumberType(float)
def test_isXxxType_more(self):
import operator
assert not operator.isSequenceType(list)
assert not operator.isSequenceType(dict)
assert not operator.isSequenceType({})
assert not operator.isMappingType(list)
assert not operator.isMappingType(dict)
assert not operator.isMappingType([])
assert not operator.isMappingType(())
assert not operator.isNumberType(int)
assert not operator.isNumberType(float)
def test_isMappingType(self):
import operator
assert not operator.isMappingType([])
assert operator.isMappingType(dict())
class M:
def __getitem__(self, key):
return 42
assert operator.isMappingType(M())
del M.__getitem__
assert not operator.isMappingType(M())
class M(object):
def __getitem__(self, key):
return 42
assert operator.isMappingType(M())
del M.__getitem__
assert not operator.isMappingType(M())
class M:
def __getitem__(self, key):
return 42
def __getslice__(self, key):
return 42
assert operator.isMappingType(M())
class M(object):
def __getitem__(self, key):
return 42
def __getslice__(self, key):
return 42
assert not operator.isMappingType(M())
def merge(*mappings, **opts):
'''
Merges all mappings given as arguments.
opts can have {'keyeq': predicate}
'''
mapping = {}
keytransform = opts.get('keytransform', lambda k: k)
use_list = opts.get('use_list', lambda k: k)
for elem in mappings:
if isMappingType(elem):
# {key: value, key: value, ...}
items = elem.iteritems()
elif isSequenceType(elem):
# [(key, value), (key, value), ...]
if not all(len(s) == 2 for s in elem):
raise TypeError(
'mapping sequences must be sequences of (key,'
'value) pairs: %s %s', type(elem), repr(elem))
items = elem
else:
raise TypeError('all arguments to merge must be mappings: %r',
elem)
for key, value in items:
merge_values(mapping, keytransform(key), value, keytransform,
use_list)
return mapping
def _build_parameter(self, param_def):
'''Builds a list of parameters, each of them represented by a dictionary
containing information: name, type, default_value, description, min and
max values. In case of simple parameters, type is the parameter type.
In case of ParamRepeat, type is a list containing definition of the
param repeat.
'''
ret = []
param_def = param_def or ()
for p in param_def:
t = p[1]
ret_p = {'min': 1, 'max': None}
# take care of old ParamRepeat
if isinstance(t, ParamRepeat):
t = t.obj()
if operator.isSequenceType(t) and not isinstance(t, (str, unicode)):
if operator.isMappingType(t[-1]):
ret_p.update(t[-1])
t = self._build_parameter(t[:-1])
else:
t = self._build_parameter(t)
ret_p['name'] = p[0]
ret_p['type'] = t
ret_p['default_value'] = p[2]
ret_p['description'] = p[3]
ret.append(ret_p)
return ret
def _build_parameter(self, param_def):
'''Builds a list of parameters, each of them represented by a dictionary
containing information: name, type, default_value, description, min and
max values. In case of simple parameters, type is the parameter type.
In case of ParamRepeat, type is a list containing definition of the
param repeat.
'''
ret = []
param_def = param_def or ()
for p in param_def:
t = p[1]
ret_p = {'min': 1, 'max': None}
# take care of old ParamRepeat
if isinstance(t, ParamRepeat):
t = t.obj()
if operator.isSequenceType(t) and not isinstance(t, (str, unicode)):
if operator.isMappingType(t[-1]):
ret_p.update(t[-1])
t = self._build_parameter(t[:-1])
else:
t = self._build_parameter(t)
ret_p['name'] = p[0]
ret_p['type'] = t
ret_p['default_value'] = p[2]
ret_p['description'] = p[3]
ret.append(ret_p)
return ret
def register(self,objects,groupname=None):
"""
Register a set of objects, possibly in a group
:param objects: map of the datum name to the associated objects to store
:type objects:
dictionary mapping strings to objects with type matching :attr:`datatype`
:param groupname: A common name that applies to all of the objects
:type groupname: string or None
"""
from operator import isMappingType,isSequenceType
if not isMappingType(objects):
raise ValueError('input must be a map of bands')
for k,v in objects.iteritems():
if self.datatype is not None and not isinstance(v,self.datatype):
raise ValueError('an object in the %s set is not a %s'%(self.dataname,self.datatype.__name__))
self[str(k)]=v
if groupname:
if type(groupname) is str:
self._groupdict[groupname] = objects.keys()
elif isSequenceType(groupname):
for s in groupname:
self._groupdict[s] = objects.keys()
else:
raise ValueError('unrecognized group name type')
def _fitdata_fired(self,new):
from operator import isSequenceType,isMappingType
if self.model is not None:
if isSequenceType(new) and len(new) == 2:
kw={'x':new[0],'y':new[1]}
elif isSequenceType(new) and len(new) == 3:
kw={'x':new[0],'y':new[1],'weights':new[2]}
elif isMappingType(new):
kw = dict(new)
#add any missing pieces
for i,k in enumerate(('x','y','weights')):
if k not in new:
if self.model.fiteddata:
new[k] = self.model.fiteddata[i]
else:
raise ValueError('no pre-fitted data available')
elif new is True:
if self.model.fiteddata:
fd = self.model.fiteddata
kw= {'x':fd[0],'y':fd[1],'weights':fd[2]}
else:
raise ValueError('No data to fit')
else:
raise ValueError('unusable fitdata event input')
if 'fixedpars' not in kw:
kw['fixedpars'] = [tn.replace('fixfit_','') for tn in self.traits() if tn.startswith('fixfit_') if getattr(self,tn)]
try:
self.model.fitData(**kw)
self.updatetraitparams = True
self.lastfitfailure = None
except Exception,e:
self.lastfitfailure = e
def _sift_tasks(mapping):
tasks, collections = [], []
for name, value in mapping.iteritems():
(collections if isMappingType(value) else tasks).append(name)
tasks = sorted(tasks)
collections = sorted(collections)
return tasks, collections
def test_module_dict(self):
me = sys.modules[__name__]
moduleDict = me.__dict__
self.assertEqual(operator.isMappingType(moduleDict), True)
self.assertEqual(moduleDict.__contains__("DictTest"), True)
self.assertEqual(moduleDict["DictTest"], DictTest)
self.assertEqual(moduleDict.keys().__contains__("DictTest"), True)
def _sift_tasks(mapping):
tasks, collections = [], []
for name, value in mapping.iteritems():
(collections if isMappingType(value) else tasks).append(name)
tasks = sorted(tasks)
collections = sorted(collections)
return tasks, collections
def format_string(f, val, grouping=False):
percents = list(_percent_re.finditer(f))
new_f = _percent_re.sub("%s", f)
if operator.isMappingType(val):
new_val = []
for perc in percents:
if perc.group()[-1] == "%":
new_val.append("%")
else:
new_val.append(format(perc.group(), val, grouping))
else:
if not isinstance(val, tuple):
val = (val,)
new_val = []
i = 0
for perc in percents:
if perc.group()[-1] == "%":
new_val.append("%")
else:
starcount = perc.group("modifiers").count("*")
new_val.append(_format(perc.group(), val[i], grouping, False, *val[i + 1 : i + 1 + starcount]))
i += 1 + starcount
val = tuple(new_val)
return new_f % val
def format_string(f, val, grouping = False):
percents = list(_percent_re.finditer(f))
new_f = _percent_re.sub('%s', f)
if operator.isMappingType(val):
new_val = []
for perc in percents:
if perc.group()[-1] == '%':
new_val.append('%')
else:
new_val.append(format(perc.group(), val, grouping))
else:
if not isinstance(val, tuple):
val = (val,)
new_val = []
i = 0
for perc in percents:
if perc.group()[-1] == '%':
new_val.append('%')
else:
starcount = perc.group('modifiers').count('*')
new_val.append(_format(perc.group(), val[i], grouping, False, *val[i + 1:i + 1 + starcount]))
i += 1 + starcount
val = tuple(new_val)
return new_f % val
def merge(*mappings, **opts):
'''
Merges all mappings given as arguments.
opts can have {'keyeq': predicate}
'''
mapping = {}
keytransform = opts.get('keytransform', lambda k: k)
use_list = opts.get('use_list', lambda k: k)
for elem in mappings:
if isMappingType(elem):
# {key: value, key: value, ...}
items = elem.iteritems()
elif isSequenceType(elem):
# [(key, value), (key, value), ...]
if not all(len(s) == 2 for s in elem):
raise TypeError(
'mapping sequences must be sequences of (key,'
'value) pairs: %s %s', type(elem), repr(elem)
)
items = elem
else:
raise TypeError('all arguments to merge must be mappings: %r',
elem)
for key, value in items:
merge_values(
mapping, keytransform(key), value, keytransform, use_list
)
return mapping
def test_module_dict():
me = sys.modules[__name__]
moduleDict = me.__dict__
AreEqual(operator.isMappingType(moduleDict), True)
AreEqual(moduleDict.__contains__("test_module_dict"), True)
AreEqual(moduleDict["test_module_dict"], test_module_dict)
AreEqual(moduleDict.keys().__contains__("test_module_dict"), True)
def filtered_list(l, key, value, op='eq'):
'''Filter list items based on their value in a specific key/attr.
'''
if not l:
return l
op_map = {
'ne': operator.ne,
'eq': operator.eq,
'le': operator.ge,
'lt': operator.gt,
'ge': operator.le,
'gt': operator.lt,
'!=': operator.ne,
'==': operator.eq,
'<=': operator.ge,
'<': operator.gt,
'>=': operator.le,
'>': operator.lt,
'in': operator.contains,
'not-in': lambda a, b: not operator.contains(a, b)
}
op = op_map.get(str(op).lower(), operator.eq)
items_are_dicts = operator.isMappingType(l[0])
if items_are_dicts:
def pred(x):
return op(value, x.get(key))
else:
def pred(x):
return op(value, getattr(x, key, None))
return filter(pred, l)
def test_module_dict():
me = sys.modules[__name__]
moduleDict = me.__dict__
AreEqual(operator.isMappingType(moduleDict), True)
AreEqual(moduleDict.__contains__("test_module_dict"), True)
AreEqual(moduleDict["test_module_dict"], test_module_dict)
AreEqual(moduleDict.keys().__contains__("test_module_dict"), True)
def _insertOrReplaceFields(self, cmd, table, fields, delayed=0):
# if dictionary given, add field names clause
if operator.isMappingType(fields):
values = fields.values()
fields = fields.keys()
else:
values = fields
fields = None
# determine number of recs to insert, if zero, just return
numRecsList = map(len, filter(isTupleOrList, values))
if len(numRecsList) == 0 or min(numRecsList) == 0:
numRecs = 1
else:
numRecs = min(numRecsList)
# adjust values that are not sequences to be sequences of
# num_recs length containing the non sequence value
# also clean values for the database
filledVals = [None] * len(values)
for i in range(len(values)):
if not isTupleOrList(values[i]):
filledVals[i] = ((values[i]),) * numRecs
else:
filledVals[i] = values[i]
return self._insertOrReplaceRecs(cmd, table, zip(*filledVals), fields, delayed)
def values(self):
"return a list of `EnumValue`s"
if operator.isMappingType(self._values):
return tuple(
[self._values[k] for k in sorted(self._values.keys())])
else:
return self._values
def filtered_list(l, key, value, op='eq'):
'''Filter list items based on their value in a specific key/attr.
'''
if not l:
return l
op_map = {
'ne': operator.ne,
'eq': operator.eq,
'le': operator.ge,
'lt': operator.gt,
'ge': operator.le,
'gt': operator.lt,
'!=': operator.ne,
'==': operator.eq,
'<=': operator.ge,
'<': operator.gt,
'>=': operator.le,
'>': operator.lt,
'in': operator.contains,
'not-in': lambda a, b: not operator.contains(a, b)
}
op = op_map.get(str(op).lower(), operator.eq)
items_are_dicts = operator.isMappingType(l[0])
if items_are_dicts:
def pred(x):
return op(value, x.get(key))
else:
def pred(x):
return op(value, getattr(x, key, None))
return filter(pred, l)
def __init__(self, name, keys, **kwargs):
""" Create an enumeration instance """
if not keys:
raise EnumEmptyError()
if operator.isMappingType(keys):
reverse = dict([(v, k) for k, v in keys.items()])
keygen = [(v, reverse[v]) for v in sorted(reverse.keys())]
values = {}
else:
keygen = enumerate(keys)
values = [None] * len(keys)
value_type = kwargs.get("value_type", EnumValue)
# keys = tuple(keys)
docs = {}
keyDict = {}
for val, key in keygen:
# print val, key
kwargs = {}
if isinstance(key, tuple) or isinstance(key, list) and len(key) == 2:
key, doc = key
docs[val] = doc
kwargs["doc"] = doc
value = value_type(self, val, key, **kwargs)
values[val] = value
keyDict[key] = val
try:
super(Enum, self).__setattr__(key, value)
except TypeError, e:
raise EnumBadKeyError(key)
def format_string(f, val, grouping = False):
"""Formats a string in the same way that the % formatting would use,
but takes the current locale into account.
Grouping is applied if the third parameter is true."""
percents = list(_percent_re.finditer(f))
new_f = _percent_re.sub('%s', f)
if operator.isMappingType(val):
new_val = []
for perc in percents:
if perc.group()[-1] == '%':
new_val.append('%')
else:
new_val.append(format(perc.group(), val, grouping))
else:
if not isinstance(val, tuple):
val = (val,)
new_val = []
i = 0
for perc in percents:
if perc.group()[-1] == '%':
new_val.append('%')
else:
starcount = perc.group('modifiers').count('*')
new_val.append(_format(perc.group(), val[i], grouping, False, *val[i + 1:i + 1 + starcount]))
i += 1 + starcount
val = tuple(new_val)
return new_f % val
def __setitem__(self, attr, args):
"""
dynModule['attrName'] = ( callbackFunc, ( 'arg1', ), {} )
"""
# args will either be a single callable, or will be a tuple of
# ( callable, (args,), {kwargs} )
if hasattr(args, '__call__'):
callback = args
elif isinstance(args, (tuple, list)):
if len(args) >= 1:
assert hasattr(args[0],
'__call__'), 'first argument must be callable'
callback = args[0]
else:
raise ValueError, "must supply at least one argument"
if len(args) >= 2:
assert hasattr(args[1],
'__iter__'), 'second argument must be iterable'
cb_args = args[1]
else:
cb_args = ()
cb_kwargs = {}
if len(args) == 3:
assert operator.isMappingType(
args[2]), 'third argument must be a mapping type'
cb_kwargs = args[2]
else:
cb_kwargs = {}
if len(args) > 3:
raise ValueError, "if args and kwargs are desired, they should be passed as a tuple and dictionary, respectively"
else:
raise ValueError, "the item must be set to a callable, or to a 3-tuple of (callable, (args,), {kwargs})"
self._lazyModule_addAttr(attr, callback, *cb_args, **cb_kwargs)
def format_string(self, f, val, grouping=False):
"""Formats a string in the same way that the % formatting would use,
but takes the current locale into account.
Grouping is applied if the third parameter is true."""
percents = list(self._percent_re.finditer(f))
new_f = self._percent_re.sub('%s', f)
if isinstance(val, tuple):
new_val = list(val)
i = 0
for perc in percents:
starcount = perc.group('modifiers').count('*')
new_val[i] = self.format(perc.group(), new_val[i], grouping, False, *new_val[i+1:i+1+starcount])
del new_val[i+1:i+1+starcount]
i += (1 + starcount)
val = tuple(new_val)
elif operator.isMappingType(val):
for perc in percents:
key = perc.group("key")
val[key] = self.format(perc.group(), val[key], grouping)
else:
# val is a single value
val = self.format(percents[0].group(), val, grouping)
return new_f % val
def execfile(filename, glob=None, loc=None):
"""execfile(filename[, globals[, locals]])
Read and execute a Python script from a file.
The globals and locals are dictionaries, defaulting to the current
globals and locals. If only globals is given, locals defaults to it."""
if glob is not None and not isinstance(glob, dict):
raise TypeError("execfile() arg 2 must be a dict, not %s",
type(glob).__name__)
if loc is not None and not operator.isMappingType(loc):
raise TypeError("execfile() arg 3 must be a mapping, not %s",
type(loc).__name__)
if glob is None:
# Warning this is at hidden_applevel
glob = globals()
if loc is None:
loc = locals()
elif loc is None:
loc = glob
f = file(filename, 'rU')
try:
source = f.read()
finally:
f.close()
#Don't exec the source directly, as this loses the filename info
co = compile(source.rstrip()+"\n", filename, 'exec',
PyCF_ACCEPT_NULL_BYTES)
exec co in glob, loc
def __setitem__(self, attr, args):
"""
dynModule['attrName'] = ( callbackFunc, ( 'arg1', ), {} )
"""
# args will either be a single callable, or will be a tuple of
# ( callable, (args,), {kwargs} )
if hasattr( args, '__call__'):
callback = args
elif isinstance( args, (tuple, list) ):
if len(args) >= 1:
assert hasattr( args[0], '__call__' ), 'first argument must be callable'
callback = args[0]
else:
raise ValueError, "must supply at least one argument"
if len(args) >= 2:
assert hasattr( args[1], '__iter__'), 'second argument must be iterable'
cb_args = args[1]
else:
cb_args = ()
cb_kwargs = {}
if len(args) == 3:
assert operator.isMappingType(args[2]), 'third argument must be a mapping type'
cb_kwargs = args[2]
else:
cb_kwargs = {}
if len(args) > 3:
raise ValueError, "if args and kwargs are desired, they should be passed as a tuple and dictionary, respectively"
else:
raise ValueError, "the item must be set to a callable, or to a 3-tuple of (callable, (args,), {kwargs})"
self._lazyModule_addAttr(attr, callback, *cb_args, **cb_kwargs)
def test_noniterable_object_with_mapping_interface(self):
module = self.import_extension('foo', [
("test", "METH_NOARGS",
'''
PyObject *obj;
obj = PyObject_New(PyObject, &Foo_Type);
return obj;
'''
),
("get_dictproxy", "METH_O",
'''
return PyDictProxy_New(args);
'''
),
("check", "METH_O",
'''
return PyInt_FromLong(
PySequence_Check(args) +
PyMapping_Check(args) * 2);
''')
], prologue = '''
static PyObject *
mp_subscript(PyObject *self, PyObject *key)
{
return PyInt_FromLong(42);
}
static Py_ssize_t
mp_length(PyObject *self)
{
return 2;
}
PyMappingMethods tp_as_mapping;
static PyTypeObject Foo_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"foo.foo",
};
''', more_init = '''
Foo_Type.tp_flags = Py_TPFLAGS_DEFAULT;
Foo_Type.tp_as_mapping = &tp_as_mapping;
tp_as_mapping.mp_length = mp_length;
tp_as_mapping.mp_subscript = mp_subscript;
if (PyType_Ready(&Foo_Type) < 0) INITERROR;
''')
obj = module.test()
assert obj["hi there"] == 42
assert len(obj) == 2
assert not hasattr(obj, "__iter__")
e = raises(TypeError, iter, obj)
assert str(e.value).endswith("object is not iterable")
#
import operator
assert not operator.isSequenceType(obj)
assert operator.isMappingType(obj)
#
assert module.check(obj) == 2
# make sure dictionaries return false for PySequence_Check
assert module.check({'a': 1}) == 2
obj = module.get_dictproxy({'a': 10})
assert module.check(obj) == 2
def isMapping( obj ):
"""
Returns True if an object is a mapping (dictionary) type, otherwise returns False.
same as `operator.isMappingType`
:rtype: bool"""
return operator.isMappingType(obj)
def isMapping( obj ):
"""
Returns True if an object is a mapping (dictionary) type, otherwise returns False.
same as `operator.isMappingType`
:rtype: bool"""
return operator.isMappingType(obj)
def strings_to_tasks(d):
ret = {}
for key, value in d.iteritems():
if isMappingType(value):
val = strings_to_tasks(value)
else:
val = name_to_task(value)
ret[key] = val
return ret
def test_sequence_type(self):
from mmap import mmap
f = open(self.tmpname + "x", "w+")
f.write("foobar")
f.flush()
m = mmap(f.fileno(), 6)
import operator
assert operator.isSequenceType(m)
assert not operator.isMappingType(m)
def test_sequence_type(self):
from mmap import mmap
f = open(self.tmpname + "x", "w+")
f.write("foobar")
f.flush()
m = mmap(f.fileno(), 6)
import operator
assert operator.isSequenceType(m)
assert not operator.isMappingType(m)
def keys(self):
"return a list of keys as strings"
if not hasattr(self, '_keyStrings'):
if operator.isMappingType(self._values):
keyStrings = tuple([self._values[k].key for k in sorted(self._values.keys())])
else:
keyStrings = tuple([v.key for v in self._values])
super(Enum, self).__setattr__('_keyStrings', keyStrings)
return self._keyStrings
def keys(self):
"return a list of keys as strings"
if not hasattr(self, '_keyStrings'):
if operator.isMappingType(self._values):
keyStrings = tuple([self._values[k].key for k in sorted(self._values.keys())])
else:
keyStrings = tuple([v.key for v in self._values])
super(Enum, self).__setattr__('_keyStrings', keyStrings)
return self._keyStrings
def strings_to_tasks(d):
ret = {}
for key, value in d.iteritems():
if isMappingType(value):
val = strings_to_tasks(value)
else:
val = name_to_task(value)
ret[key] = val
return ret
def _sift_tasks(mapping):
tasks, collections = [], []
for name, value in iteritems(mapping):
if _is_task(name, value):
tasks.append(name)
elif isMappingType(value):
collections.append(name)
tasks = sorted(tasks)
collections = sorted(collections)
return tasks, collections
def _sift_tasks(mapping):
tasks, collections = [], []
for name, value in six.iteritems(mapping):
if _is_task(name, value):
tasks.append(name)
elif isMappingType(value):
collections.append(name)
tasks = sorted(tasks)
collections = sorted(collections)
return tasks, collections
def httpRequest(self, url, data=None): if operator.isMappingType(data) : data = urllib.urlencode(data) request = urllib2.Request(url, data, self.headers) opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cookieJar)) result = opener.open(request) self.headers['Referer'] = result.geturl() return result
def tolower(mapping, maptype=dict):
"""Returns a copy of a mapping tree with all string keys lowercased."""
return maptype(
(
getattr(k, 'lower', lambda k: k)(),
tolower(v, maptype) if isMappingType(v) else v
)
for k, v in mapping.iteritems()
)
def dump(data):
print type(data), "=>",
if operator.isCallable(data):
print "CALLABLE",
if operator.isMappingType(data):
print "MAPPING",
if operator.isNumberType(data):
print "NUMBER",
if operator.isSequenceType(data):
print "SEQUENCE",
print
def test_operator(self):
import operator
self.assertIs(operator.truth(0), False)
self.assertIs(operator.truth(1), True)
self.assertIs(operator.isNumberType(None), False)
self.assertIs(operator.isNumberType(0), True)
self.assertIs(operator.not_(1), False)
self.assertIs(operator.not_(0), True)
self.assertIs(operator.isSequenceType(0), False)
self.assertIs(operator.isSequenceType([]), True)
self.assertIs(operator.contains([], 1), False)
self.assertIs(operator.contains([1], 1), True)
self.assertIs(operator.isMappingType(1), False)
self.assertIs(operator.isMappingType({}), True)
self.assertIs(operator.lt(0, 0), False)
self.assertIs(operator.lt(0, 1), True)
self.assertIs(operator.is_(True, True), True)
self.assertIs(operator.is_(True, False), False)
self.assertIs(operator.is_not(True, True), False)
self.assertIs(operator.is_not(True, False), True)
def dump(data):
print type(data), "=>",
if operator.isCallable(data):
print "CALLABLE",
if operator.isMappingType(data):
print "MAPPING",
if operator.isNumberType(data):
print "NUMBER",
if operator.isSequenceType(data):
print "SEQUENCE",
print
def merge_values(mapping, key, value, keytransform = None):
'''
Exactly like mapping.update({key: value}) except that if both values are
mappings, then they are merged recursively.
'''
assert isMappingType(mapping)
assert key is not sentinel and value is not sentinel
if keytransform is None:
keytransform = lambda k: k
curval = mapping.get(key, sentinel)
if curval is not sentinel and isMappingType(curval) and isMappingType(value):
# key exists in old and new, and both values are mappings--recursively
# merge those mappings
for subkey, subvalue in value.iteritems():
merge_values(curval, keytransform(subkey), subvalue)
else:
# new value doesn't exist in mapping or both values are not mappings--
# so overwrite the old value with the new one
mapping[keytransform(key)] = value
def test_operator(self):
import operator
self.assertIs(operator.truth(0), False)
self.assertIs(operator.truth(1), True)
self.assertIs(operator.isCallable(0), False)
self.assertIs(operator.isCallable(len), True)
self.assertIs(operator.isNumberType(None), False)
self.assertIs(operator.isNumberType(0), True)
self.assertIs(operator.not_(1), False)
self.assertIs(operator.not_(0), True)
self.assertIs(operator.isSequenceType(0), False)
self.assertIs(operator.isSequenceType([]), True)
self.assertIs(operator.contains([], 1), False)
self.assertIs(operator.contains([1], 1), True)
self.assertIs(operator.isMappingType(1), False)
self.assertIs(operator.isMappingType({}), True)
self.assertIs(operator.lt(0, 0), False)
self.assertIs(operator.lt(0, 1), True)
self.assertIs(operator.is_(True, True), True)
self.assertIs(operator.is_(True, False), False)
self.assertIs(operator.is_not(True, True), False)
self.assertIs(operator.is_not(True, False), True)
def merge_values(mapping, key, value, keytransform=None):
'''
Exactly like mapping.update({key: value}) except that if both values are
mappings, then they are merged recursively.
'''
assert isMappingType(mapping)
assert key is not sentinel and value is not sentinel
if keytransform is None:
keytransform = lambda k: k
curval = mapping.get(key, sentinel)
if curval is not sentinel and isMappingType(curval) and isMappingType(
value):
# key exists in old and new, and both values are mappings--recursively
# merge those mappings
for subkey, subvalue in value.iteritems():
merge_values(curval, keytransform(subkey), subvalue)
else:
# new value doesn't exist in mapping or both values are not mappings--
# so overwrite the old value with the new one
mapping[keytransform(key)] = value
def _ExpandFor(tag, template, specials, block_data):
"""Expands a for block iterating over the block_data."""
result = []
if operator.isMappingType(block_data):
for v in block_data:
result.append(ExpandTemplate(template, specials, block_data[v], v))
elif operator.isSequenceType(block_data):
for i in xrange(len(block_data)):
result.append(ExpandTemplate(template, specials, block_data[i], str(i)))
else:
_Log('Error: Invalid type: %s' % (tag,))
return ''
return ''.join(result)
def _ExpandFor(tag, template, specials, block_data):
"""Expands a for block iterating over the block_data."""
result = []
if operator.isMappingType(block_data):
for v in block_data:
result.append(ExpandTemplate(template, specials, block_data[v], v))
elif operator.isSequenceType(block_data):
for i in xrange(len(block_data)):
result.append(ExpandTemplate(template, specials, block_data[i], str(i)))
else:
_Log('Error: Invalid type: %s' % (tag,))
return ''
return ''.join(result)
def test_iterable_nonmapping_object(self):
module = self.import_extension('foo', [
("test", "METH_NOARGS",
'''
PyObject *obj;
obj = PyObject_New(PyObject, &Foo_Type);
return obj;
'''),
("check", "METH_O",
'''
return PyInt_FromLong(
PySequence_Check(args) +
PyMapping_Check(args) * 2);
''')
], prologue='''
static PyObject *
sq_item(PyObject *self, Py_ssize_t size)
{
return PyInt_FromLong(42);
}
static Py_ssize_t
sq_length(PyObject *self)
{
return 2;
}
PySequenceMethods tp_as_sequence;
static PyTypeObject Foo_Type = {
PyVarObject_HEAD_INIT(NULL, 0)
"foo.foo",
};
''', more_init='''
Foo_Type.tp_flags = Py_TPFLAGS_DEFAULT;
Foo_Type.tp_as_sequence = &tp_as_sequence;
tp_as_sequence.sq_length = sq_length;
tp_as_sequence.sq_item = sq_item;
if (PyType_Ready(&Foo_Type) < 0) INITERROR;
''')
obj = module.test()
assert obj[1] == 42
assert len(obj) == 2
assert not hasattr(obj, "__iter__")
it = iter(obj)
assert it.next() == 42
assert it.next() == 42
#
import operator
assert operator.isSequenceType(obj)
assert not operator.isMappingType(obj)
#
assert module.check(obj) == 1
def _GetValue(collection, index, default=''):
"""Gets a single indexed value out of a collection.
The index is either a key in a mapping or a numeric index into
a sequence.
"""
if operator.isMappingType(collection) and index in collection:
value = collection[index]
elif (operator.isSequenceType(collection) and index.isdigit() and
int(index) < len(collection)):
value = collection[int(index)]
else:
value = default
return value
def test_operator(self):
import operator
self.assertIs(operator.truth(0), False)
self.assertIs(operator.truth(1), True)
with test_support.check_py3k_warnings():
self.assertIs(operator.isCallable(0), False)
self.assertIs(operator.isCallable(len), True)
self.assertIs(operator.isNumberType(None), False)
self.assertIs(operator.isNumberType(0), True)
self.assertIs(operator.not_(1), False)
self.assertIs(operator.not_(0), True)
self.assertIs(operator.isSequenceType(0), False)
self.assertIs(operator.isSequenceType([]), True)
self.assertIs(operator.contains([], 1), False)
self.assertIs(operator.contains([1], 1), True)
self.assertIs(operator.isMappingType(1), False)
self.assertIs(operator.isMappingType({}), True)
self.assertIs(operator.lt(0, 0), False)
self.assertIs(operator.lt(0, 1), True)
self.assertIs(operator.is_(True, True), True)
self.assertIs(operator.is_(True, False), False)
self.assertIs(operator.is_not(True, True), False)
self.assertIs(operator.is_not(True, False), True)
def _GetValue(collection, index, default=''):
"""Gets a single indexed value out of a collection.
The index is either a key in a mapping or a numeric index into
a sequence.
"""
if operator.isMappingType(collection) and index in collection:
value = collection[index]
elif (operator.isSequenceType(collection) and index.isdigit()
and int(index) < len(collection)):
value = collection[int(index)]
else:
value = default
return value
def save(self, filename, minimize=False):
from operator import isSequenceType, isMappingType
spec_file = open(filename, 'w')
if minimize:
# don't write empty containers
towrite = dict([(k, v) for k, v in iteritems(self)
if not (isSequenceType(v) or isMappingType(v)) \
or len(v)])
else:
towrite = self
spec_file.write(
json.dumps(towrite, indent=2, sort_keys=True, cls=SPECJSONEncoder))
spec_file.write('\n')
spec_file.close()
def save(self, filename, minimize=False):
from operator import isSequenceType, isMappingType
spec_file = open(filename, 'w')
if minimize:
# don't write empty containers
towrite = dict([(k, v) for k, v in self.iteritems()
if not (isSequenceType(v) or isMappingType(v)) \
or len(v)])
else:
towrite = self
spec_file.write(json.dumps(towrite, indent=2, sort_keys=True,
cls=SPECJSONEncoder))
spec_file.write('\n')
spec_file.close()
def merge_values(mapping, key, value, keytransform=None, use_list=None):
'''
Exactly like mapping.update({key: value}) except that if both values are
mappings, then they are merged recursively.
'''
assert isMappingType(mapping)
assert key is not SENTINEL and value is not SENTINEL
if keytransform is None:
keytransform = lambda k: k
curval = mapping.get(key, SENTINEL)
if (curval is not SENTINEL and isMappingType(curval)
and isMappingType(value)):
# key exists in old and new, and both values are mappings--recursively
# merge those mappings
for subkey, subvalue in value.iteritems():
merge_values(curval, keytransform(subkey), subvalue)
else:
# new value doesn't exist in mapping or both values are not mappings--
# so overwrite the old value with the new one, unless 'use_list'
# is set in which case if it's a sequence append the value to the
# current sequence
try:
map_val = mapping[keytransform(key)]
except KeyError:
mapping[keytransform(key)] = value
else:
if (use_list and isSequenceType(map_val)
and not isinstance(value, str)):
if isSequenceType(value):
map_val.extend(value)
else:
map_val.append(value)
else:
mapping[keytransform(key)] = value
def __init__(self, keys, **kwargs):
""" Create an enumeration instance """
if not keys:
raise EnumEmptyError()
if operator.isMappingType(keys):
items = keys.items()
if isinstance(items[0][0], int):
byKey = dict((k, v) for v, k in items)
else:
byKey = keys
else:
byKey = dict((k, v) for v, k in enumerate(keys))
super(EnumDict, self).__init__(byKey)
def __call__ (self, req, **kw):
if not self._prepared: self._prepare()
if not self.base:
#self.base = req.get_host() nope, unless we stop using _data and use iterMembers
self._data ['base'] = self._host (req)
if req.is_ajax(): # and hasattr (self, '_ajax'):
try:
rslt = self._ajax (req, req.session, **kw)
if isMappingType (rslt):
# text/plain is seen by jQuery as 'string', app/json too, app/javascript nfg too
# , mimetype="application/javascript") looks like we'll have to do it in the js
return HttpResponse (json.JSONEncoder().encode(rslt))
else:
return HttpResponse (rslt)
except Exception, e:
return HttpResponse (e) # should return alert script, here!
