def input_conversion(self, cpp_type, argument_var, arg_num):
temp_var = "v%d" % arg_num
temp_it = "it_%d" % arg_num
item = "item%d" % arg_num
code = Code().add(
"""
|cdef libcpp_vector[_String] * $temp_var = new libcpp_vector[_String]()
|cdef bytes $item
|for $item in $argument_var:
| $temp_var.push_back(_String(<char *>$item))
""", locals())
if cpp_type.is_ref:
cleanup_code = Code().add(
"""
|replace = []
|cdef libcpp_vector[_String].iterator $temp_it = $temp_var.begin()
|while $temp_it != $temp_var.end():
| replace.append(<char*>deref($temp_it).c_str())
| inc($temp_it)
|$argument_var[:] = replace
|del $temp_var
""", locals())
else:
cleanup_code = "del %s" % temp_var
return code, "deref(%s)" % temp_var, cleanup_code
def input_conversion(self, cpp_type, argument_var, arg_num):
temp_var = "v%d" % arg_num
item = "item%d" % arg_num
code = Code().add(
"""
|cdef libcpp_set[_String] * $temp_var = new libcpp_set[_String]()
|cdef bytes $item
|for $item in $argument_var:
| $temp_var.insert(_String(<char *>$item))
""", locals())
if cpp_type.is_ref:
cleanup_code = Code().add(
"""
|cdef replace = set()
|cdef libcpp_set[_String].iterator it = $temp_var.begin()
|while it != $temp_var.end():
| replace.add(<char*>deref(it).c_str())
| inc(it)
|$argument_var.clear()
|$argument_var.update(replace)
|del $temp_var
""", locals())
else:
cleanup_code = "del %s" % temp_var
return code, "deref(%s)" % temp_var, cleanup_code
def input_conversion(self, cpp_type, argument_var, arg_num):
dp = "_dp_%s" % arg_num
vec ="_dp_vec_%s" % arg_num
ii = "_dp_ii_%s" % arg_num
N = "_dp_N_%s" % arg_num
code = Code().add("""
|cdef libcpp_vector[_DPosition2] $vec
|cdef _DPosition2 $dp
|cdef int $ii
|cdef int $N = $argument_var.shape[0]
|for $ii in range($N):
| $dp[0] = $argument_var[$ii,0]
| $dp[1] = $argument_var[$ii,1]
| $vec.push_back($dp)
""", locals())
cleanup = ""
if cpp_type.is_ref:
it = "_dp_it_%s" % arg_num
n = "_dp_n_%s" % arg_num
cleanup = Code().add("""
|$n = $vec.size()
|$argument_var.resize(($n,2))
|$n = $vec.size()
|cdef libcpp_vector[_DPosition2].iterator $it = $vec.begin()
|$ii = 0
|while $it != $vec.end():
| $argument_var[$ii, 0] = deref($it)[0]
| $argument_var[$ii, 1] = deref($it)[1]
| inc($it)
| $ii += 1
""", locals())
call_as = vec
return code, call_as, cleanup
def input_conversion(self, cpp_type, argument_var, arg_num):
map_name = "_map_%d" % arg_num
v_vec = "_v_vec_%d" % arg_num
v_ptr = "_v_ptr_%d" % arg_num
v_i = "_v_i_%d" % arg_num
k_string = "_k_str_%d" % arg_num
code = Code().add(
"""
|cdef Map[_String, libcpp_vector[_CVTerm]] $map_name
|cdef libcpp_vector[_CVTerm] $v_vec
|cdef _String $k_string
|cdef CVTerm $v_i
|for k, v in $argument_var.items():
| $v_vec.clear()
| for $v_i in v:
| $v_vec.push_back(deref($v_i.inst.get()))
| $map_name[_String(<char *>k)] = $v_vec
""", locals())
if cpp_type.is_ref:
replace = "_replace_%d" % arg_num
outer_it = "outer_it_%d" % arg_num
inner_it = "inner_it_%d" % arg_num
item = "item_%d" % arg_num
inner_key = "inner_key_%d" % arg_num
inner_values = "inner_values_%d" % arg_num
cleanup_code = Code().add(
"""
|cdef $replace = dict()
|cdef Map[_String, libcpp_vector[_CVTerm]].iterator $outer_it
+ = $map_name.begin()
|cdef libcpp_vector[_CVTerm].iterator $inner_it
|cdef CVTerm $item
|cdef str $inner_key
|cdef list $inner_values
|while $outer_it != $map_name.end():
| $inner_key = deref($outer_it).first.c_str()
| $inner_values = []
| $inner_it = deref($outer_it).second.begin()
| while $inner_it != deref($outer_it).second.end():
| $item = CVTerm.__new__(CVTerm)
| $item.inst = shared_ptr[_CVTerm](new _CVTerm(deref($inner_it)))
| $inner_values.append($item)
| inc($inner_it)
| $replace[$inner_key] = $inner_values
| inc($outer_it)
|$argument_var.clear()
|$argument_var.update($replace)
""", locals())
else:
cleanup_code = ""
return code, map_name, cleanup_code
def input_conversion(self, cpp_type, argument_var, arg_num):
dp = "_dp_%s" % arg_num
code = Code().add("""
|cdef _DPosition2 $dp
|$dp[0] = <float>$argument_var[0]
|$dp[1] = <float>$argument_var[1]
""", locals())
cleanup = ""
if cpp_type.is_ref:
cleanup = Code().add("""
|$cpp_type[0] = $dp[0]
|$cpp_type[1] = $dp[1]
""", locals())
call_as = dp
return code, call_as, cleanup
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
return Code().add(
"""
|cdef MatchIterator $output_py_var = MatchIterator.__new__(MatchIterator)
|$output_py_var.it = _r.begin()
|$output_py_var.end = _r.end()
""", locals())
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
# this one is slow as it uses construction of python type ParamValue for
# delegating conversion to this type, which reduces code below:
return Code().add("""
|cdef ParamValue _value = ParamValue.__new__(ParamValue)
|_value.inst = shared_ptr[_ParamValue](new _ParamValue($input_cpp_var))
|cdef int _type = $input_cpp_var.valueType()
|cdef object $output_py_var
|if _type == ValueType.STRING_VALUE:
| $output_py_var = _value.toString()
|elif _type == ValueType.INT_VALUE:
| $output_py_var = _value.toInt()
|elif _type == ValueType.DOUBLE_VALUE:
| $output_py_var = _value.toDouble()
|elif _type == ValueType.INT_LIST:
| $output_py_var = _value.toIntVector()
|elif _type == ValueType.DOUBLE_LIST:
| $output_py_var = _value.toDoubleVector()
|elif _type == ValueType.STRING_LIST:
| $output_py_var = _value.toStringVector()
|elif _type == ValueType.EMPTY_VALUE:
| $output_py_var = None
|else:
| raise Exception("ParamValue instance has invalid value type %d" % _type)
""", locals())
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
# this one is slow as it uses construction of python type DataValue for
# delegating conversion to this type, which reduces code below:
return Code().add(
"""
|$output_py_var = [$input_cpp_var[0], $input_cpp_var[1]]
""", locals())
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
rnd = str(id(self))+str(time.time()).split(".")[0]
outer_it = "outer_it_%s" % rnd
inner_it = "inner_it_%s" % rnd
item = "item_%s" % rnd
inner_key = "inner_key_%s" % rnd
inner_values = "inner_values_%s" % rnd
code = Code().add("""
|$output_py_var = dict()
|cdef Map[_String, libcpp_vector[_CVTerm]].iterator $outer_it
+ = $input_cpp_var.begin()
|cdef libcpp_vector[_CVTerm].iterator $inner_it
|cdef CVTerm $item
|cdef str $inner_key
|cdef list $inner_values
|while $outer_it != $input_cpp_var.end():
| $inner_key = deref($outer_it).first.c_str()
| $inner_values = []
| $inner_it = deref($outer_it).second.begin()
| while $inner_it != deref($outer_it).second.end():
| $item = CVTerm.__new__(CVTerm)
| $item.inst = shared_ptr[_CVTerm](new _CVTerm(deref($inner_it)))
| $inner_values.append($item)
| inc($inner_it)
| $output_py_var[$inner_key] = $inner_values
| inc($outer_it)
""", locals())
return code
def type_check_expression(self, cpp_type, arg_var):
return Code().add("""
|isinstance($arg_var, dict)
+ and all(isinstance(k, str) for k in $arg_var.keys())
+ and all(isinstance(v, list) for v in $arg_var.values())
+ and all(isinstance(vi, CVTerm) for v in $arg_var.values() for vi in
v)
""", locals()).render()
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
t = self.inner_cpp_type
code = Code().add("""
|$output_py_var = []
|cdef int i, n
|n = $input_cpp_var.size()
|for i in range(n):
| $output_py_var.append(<$t>$input_cpp_var.at(i))
""", locals())
return code
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
if cpp_type.is_ptr:
raise AssertionError()
tt_key, tt_value = cpp_type.template_args
cy_tt_key = self.converters.cython_type(tt_key)
cy_tt_value = self.converters.cython_type(tt_value)
it = mangle("it_" + input_cpp_var)
if not cy_tt_key.is_enum and tt_key.base_type in self.converters.names_to_wrap:
raise Exception("can not handle wrapped classes as keys in map")
else:
key_conv = "<%s>(deref(%s).first)" % (cy_tt_key, it)
if not cy_tt_value.is_enum and tt_value.base_type in self.converters.names_to_wrap:
cy_tt = tt_value.base_type
item = mangle("item_" + output_py_var)
code = Code().add(
"""
|$output_py_var = dict()
|cdef _Map[$cy_tt_key, $cy_tt_value].iterator $it = $input_cpp_var.begin()
|cdef $cy_tt $item
|while $it != $input_cpp_var.end():
| $item = $cy_tt.__new__($cy_tt)
| $item.inst = shared_ptr[$cy_tt_value](new $cy_tt_value((deref($it)).second))
| $output_py_var[$key_conv] = $item
| inc($it)
""", locals())
return code
else:
value_conv = "<%s>(deref(%s).second)" % (cy_tt_value, it)
code = Code().add(
"""
|$output_py_var = dict()
|cdef _Map[$cy_tt_key, $cy_tt_value].iterator $it = $input_cpp_var.begin()
|while $it != $input_cpp_var.end():
| $output_py_var[$key_conv] = $value_conv
| inc($it)
""", locals())
return code
def input_conversion(self, cpp_type, argument_var, arg_num):
# here we inject special behavoir for testing if this converter
# was called !
ih_name = "ih_" + argument_var
code = Code().add("""
|cdef _Holder[int] $ih_name
|$ih_name.set(<int>$argument_var)
""", locals())
call_as = "(%s)" % ih_name
cleanup = ""
return code, call_as, cleanup
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
assert not cpp_type.is_ptr
it = mangle("it_" + input_cpp_var)
item = mangle("item_" + output_py_var)
code = Code().add("""
|$output_py_var = set()
|cdef libcpp_set[_String].iterator $it = $input_cpp_var.begin()
|while $it != $input_cpp_var.end():
| $output_py_var.add(<char*>deref($it).c_str())
| inc($it)
""", locals())
return code
def input_conversion(self, cpp_type, argument_var, arg_num):
temp_var = "v%d" % arg_num
t = self.inner_cpp_type
ltype = self.openms_type
code = Code().add("""
|cdef libcpp_vector[$t] _$temp_var = $argument_var
|cdef _$ltype $temp_var = _$ltype(_$temp_var)
""", locals())
cleanup = ""
if cpp_type.is_ref:
cleanup_code = Code().add("""
|replace = []
|cdef int i, n
|n = $temp_var.size()
|for i in range(n):
| replace.append(<$t>$temp_var.at(i))
|$argument_var[:] = replace
""", locals())
# here we inject special behavoir for testing if this converter
# was called !
call_as = "(%s)" % temp_var
return code, call_as, cleanup
def input_conversion(self, cpp_type, argument_var, arg_num):
temp_var = "v%d" % arg_num
t = self.inner_cpp_type
ltype = self.openms_type
code = Code().add(
"""
|cdef libcpp_vector[$t] _$temp_var = $argument_var
|cdef _$ltype $temp_var = _$ltype(_$temp_var)
""", locals())
cleanup = ""
# here we inject special behavoir for testing if this converter
# was called !
call_as = "(%s)" % temp_var
return code, call_as, cleanup
def type_check_expression(self, cpp_type, arg_var):
tt_key, tt_value = cpp_type.template_args
inner_conv_1 = self.converters.get(tt_key)
inner_conv_2 = self.converters.get(tt_value)
assert inner_conv_1 is not None, "arg type %s not supported" % tt_key
assert inner_conv_2 is not None, "arg type %s not supported" % tt_value
inner_check_1 = inner_conv_1.type_check_expression(tt_key, "k")
inner_check_2 = inner_conv_2.type_check_expression(tt_value, "v")
return Code().add("""
|isinstance($arg_var, dict)
+ and all($inner_check_1 for k in $arg_var.keys())
+ and all($inner_check_2 for v in $arg_var.values())
""", locals()).render()
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
if cpp_type.is_ptr:
raise AssertionError()
it = mangle("it_" + input_cpp_var)
item = mangle("item_" + output_py_var)
code = Code().add("""
|$output_py_var = []
|cdef libcpp_vector[_String].iterator $it = $input_cpp_var.begin()
|while $it != $input_cpp_var.end():
| $output_py_var.append(<char*>deref($it).c_str())
| inc($it)
""", locals())
return code
def collect_manual_code(addons):
# collect code which is manually generated and will be added to the
# wrapper code by autowrap:
manual_code = dict()
cimports = []
for name in addons:
clz_name, __ = os.path.splitext(os.path.basename(name))
line_iter = open(name, "r")
for line in line_iter:
if line and line.strip() not in "\n\r\t ":
cimports.append(line)
else:
break
remainder = "".join(line_iter)
manual_code.setdefault(clz_name, Code()).add(remainder)
return cimports, manual_code
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
# this one is slow as it uses construction of python type DataValue for
# delegating conversion to this type, which reduces code below:
it = "_out_it_dpos_vec"
n = "_out_n_dpos_vec"
ii = "_out_ii_dpos_vec"
return Code().add("""
|cdef int $n = $input_cpp_var.size()
|cdef $output_py_var = np.zeros([$n,2], dtype=np.float32)
|cdef libcpp_vector[_DPosition2].iterator $it = $input_cpp_var.begin()
|cdef int $ii = 0
|while $it != $input_cpp_var.end():
| $output_py_var[$ii, 0] = deref($it)[0]
| $output_py_var[$ii, 1] = deref($it)[1]
| inc($it)
| $ii += 1
""", locals())
def output_conversion(self, cpp_type, input_cpp_var, output_py_var):
# this one is slow as it uses construction of python type DataValue for
# delegating conversion to this type, which reduces code below:
return Code().add("""
|cdef DataValue _vvv = DataValue.__new__(DataValue)
|_vvv.inst = shared_ptr[_DataValue](new _DataValue($input_cpp_var))
|cdef int _value_type_x = $input_cpp_var.valueType()
|if _value_type_x == DataType.STRING_VALUE:
| $output_py_var = _vvv.toString()
|elif _value_type_x == DataType.INT_VALUE:
| $output_py_var = _vvv.toInt()
|elif _value_type_x == DataType.DOUBLE_VALUE:
| $output_py_var = _vvv.toDouble()
|elif _value_type_x == DataType.INT_LIST:
| $output_py_var = _vvv.toIntList()
|elif _value_type_x == DataType.DOUBLE_LIST:
| $output_py_var = _vvv.toDoubleList()
|elif _value_type_x == DataType.STRING_LIST:
| $output_py_var = _vvv.toStringList()
""", locals())
def type_check_expression(self, cpp_type, arg_var):
return Code().add("""
|isinstance($arg_var, set) and all(isinstance(i, bytes) for i in
+ $arg_var)
""", locals()).render()
def input_conversion(self, cpp_type, argument_var, arg_num):
tt_key, tt_value = cpp_type.template_args
temp_var = "v%d" % arg_num
cy_tt_key = self.converters.cython_type(tt_key)
cy_tt_value = self.converters.cython_type(tt_value)
if cy_tt_key.is_enum:
key_conv = "<%s> key" % cy_tt_key
elif tt_key.base_type in self.converters.names_to_wrap:
raise Exception("can not handle wrapped classes as keys in map")
else:
key_conv = "<%s> key" % cy_tt_key
if cy_tt_value.is_enum:
value_conv = "<%s> value" % cy_tt_value
elif tt_value.base_type in self.converters.names_to_wrap:
value_conv = "deref((<%s>value).inst.get())" % tt_value.base_type
else:
value_conv = "<%s> value" % cy_tt_value
code = Code().add("""
|cdef _Map[$cy_tt_key, $cy_tt_value] * $temp_var = new
+ _Map[$cy_tt_key, $cy_tt_value]()
|for key, value in $argument_var.items():
| deref($temp_var)[$key_conv] = $value_conv
""", locals())
if cpp_type.is_ref:
replace = mangle("replace_" + argument_var)
it = mangle("it_" + argument_var)
if cy_tt_key.is_enum:
key_conv = "<%s> deref(%s).first" % (cy_tt_key, it)
elif tt_key.base_type in self.converters.names_to_wrap:
raise Exception("can not handle wrapped classes as keys in map")
else:
key_conv = "<%s> deref(%s).first" % (cy_tt_key, it)
if not cy_tt_value.is_enum and tt_value.base_type in self.converters.names_to_wrap:
cy_tt = tt_value.base_type
item = mangle("item_" + argument_var)
cleanup_code = Code().add("""
|cdef $replace = dict()
|cdef _Map[$cy_tt_key, $cy_tt_value].iterator $it = $temp_var.begin()
|cdef $cy_tt $item
|while $it != $temp_var.end():
| $item = $cy_tt.__new__($cy_tt)
| $item.inst = shared_ptr[$cy_tt_value](new $cy_tt_value((deref($it)).second))
| $replace[$key_conv] = $item
| inc($it)
|$argument_var.clear()
|$argument_var.update($replace)
|del $temp_var
""", locals())
else:
value_conv = "<%s> deref(%s).second" % (cy_tt_value, it)
cleanup_code = Code().add("""
|cdef $replace = dict()
|cdef _Map[$cy_tt_key, $cy_tt_value].iterator $it = $temp_var.begin()
|while $it != $temp_var.end():
| $replace[$key_conv] = $value_conv
| inc($it)
|$argument_var.clear()
|$argument_var.update($replace)
|del $temp_var
""", locals())
else:
cleanup_code = "del %s" % temp_var
return code, "deref(%s)" % temp_var, cleanup_code
