def applyWithTypeConversion(callable_method, request, **kwargs): ''' Currently useful kwargs: `resource` => instance of the resource executing ''' types = getattr(callable_method, 'types', {}) returnConverter = getattr(callable_method, 'returnConverter', None) inputConverter = getattr(callable_method, 'inputConverter', None) fs = request.get_field_storage() parameters = storage_to_dict(fs) if inputConverter: if not isinstance(inputConverter, (list, tuple)): inputConverter = (inputConverter, ) for conv in inputConverter: rc = conv(kwargs.get('resource'), request, parameters) parameters = rc or parameters try: converted = {} for (key, value) in types.items(): request.target_name = key request.target = value if parameters.has_key(key): val = parameters[key] else: val = getattr(value, 'default', None) try: val = convertTypes(request, val) except (TypeError, ValueError): val = None if val is not None: converted[key] = val result = callable_method(**converted) except TypeError: raise if result is None: result = '' if not returnConverter: return False, result if not isinstance(returnConverter, (list, tuple)): returnConverter = (returnConverter, ) for conv in returnConverter: result = conv(result) return True, result
def elementType( eLetter ): """ Classify an atom as polar or unpolar:: atomType( eLetter ) -> list of types this element belongs to @param eLetter: atom name @type eLetter: str @return: return 'p' for polar, 'u' for unpolar and None if not in classified @rtype: p|u OR None """ types = {'p' : ['N','O','H','Cl'], ## polar 'u' : ['C','S'] } ## unpolar for key, values in types.items(): if eLetter in values: return key return None
def new_f(*args, **kwds): argument_types = ", ".join( "%s=%s" %(v,t) for v,t in types.items() ) for i,v in enumerate(args): if types.has_key(f.func_code.co_varnames[i]) and \ not isinstance(v, types[f.func_code.co_varnames[i]]): raise exception("Function argument '%s' with a " "value of %r does not match the allowed " "types %s. \n The arguments " "of this function have allowed types of %s" % \ (f.func_code.co_varnames[i],v, types[f.func_code.co_varnames[i]],argument_types)) del types[f.func_code.co_varnames[i]] for k,v in kwds.iteritems(): if types.has_key(k) and not isinstance(v, types[k]): raise exception("Function argument '%s' with a " "value of %r does not match one of the allowed " "types %s. \n The arguments " "of this function have allowed types of %s" % \ (k,v,types[k],argument_types)) return f(*args, **kwds)
def new_f(*args, **kwds): argument_types = ", ".join("%s=%s" % (v, t) for v, t in types.items()) for i, v in enumerate(args): if types.has_key(f.func_code.co_varnames[i]) and \ not isinstance(v, types[f.func_code.co_varnames[i]]): raise exception("Function argument '%s' with a " "value of %r does not match the allowed " "types %s. \n The arguments " "of this function have allowed types of %s" % \ (f.func_code.co_varnames[i],v, types[f.func_code.co_varnames[i]],argument_types)) del types[f.func_code.co_varnames[i]] for k, v in kwds.iteritems(): if types.has_key(k) and not isinstance(v, types[k]): raise exception("Function argument '%s' with a " "value of %r does not match one of the allowed " "types %s. \n The arguments " "of this function have allowed types of %s" % \ (k,v,types[k],argument_types)) return f(*args, **kwds)
def new_f(*args, **kwds): argument_types = ", ".join( "%s=%s" %(v,t) for v,t in types.items() ) for i,v in enumerate(args): # no need to check self argument if i == 0 : continue if types.has_key(f.func_code.co_varnames[i]) and \ not isinstance(v, types[f.func_code.co_varnames[i]]): raise exception("Method argument '%s' with a " "value of %r does not match the " "allowed types %s. \n The " "arguments of this method have " "allowed types of %s" % \ (f.func_code.co_varnames[i],v,types[f.func_code.co_varnames[i]],argument_types)) del types[f.func_code.co_varnames[i]] for k,v in kwds.iteritems(): if types.has_key(k) and not isinstance(v, types[k]): raise exception("Method argument '%s' with a " "value of %r does not match one " "of the allowed types %s. \n The " "arguments of this method have allowed types of %s" % \ (k,v,types[k],argument_types)) return f(*args, **kwds)
def new_f(*args, **kwds): argument_types = ", ".join("%s=%s" % (v, t) for v, t in types.items()) for i, v in enumerate(args): # no need to check self argument if i == 0: continue if types.has_key(f.func_code.co_varnames[i]) and \ not isinstance(v, types[f.func_code.co_varnames[i]]): raise exception("Method argument '%s' with a " "value of %r does not match the " "allowed types %s. \n The " "arguments of this method have " "allowed types of %s" % \ (f.func_code.co_varnames[i],v,types[f.func_code.co_varnames[i]],argument_types)) del types[f.func_code.co_varnames[i]] for k, v in kwds.iteritems(): if types.has_key(k) and not isinstance(v, types[k]): raise exception("Method argument '%s' with a " "value of %r does not match one " "of the allowed types %s. \n The " "arguments of this method have allowed types of %s" % \ (k,v,types[k],argument_types)) return f(*args, **kwds)
def set_properties(cls, types={}, descriptor=UnitProperty): """Set Unit Properties for cls.""" for key, typ in types.items(): cls.set_property(key, typ, False, descriptor)