def process(self):
self.ensure_enums_have_no_space(enums=["current_op"])
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
func = self.implementation_func_dict[self.implementation][0].get(
self.current_op)[1]
num_inputs = len(inputs)
# get either input data, or socket default
input_one = inputs[0].sv_get(deepcopy=True)
level = levels_of_list_or_np(input_one) - 1
if num_inputs == 1:
recurse_func = self.implementation_func_dict[
self.implementation][1]
params = [input_one, func, level]
# result = recurse_func(input_one, func, level, self.output_numpy)
else:
input_two = inputs[1].sv_get(deepcopy=True)
level = max(level, levels_of_list_or_np(input_two) - 1)
min_l2_level = 3 if inputs[1].bl_idname == "SvVerticesSocket" else 2
params = [input_one, input_two, func, level, min_l2_level]
recurse_func = self.implementation_func_dict[
self.implementation][2]
if self.implementation == 'NumPy':
params.append(self.output_numpy)
result = recurse_func(*params)
outputs[0].sv_set(result)
def process(self):
inputs, outputs = self.inputs, self.outputs
if not outputs[0].is_linked:
return
func = self.implementation_func_dict[self.implementation][0].get(
self.current_op)[1]
num_inputs = len(inputs)
# get either input data, or socket default
input_one = inputs[0].sv_get(deepcopy=True)
# level = levelsOflist(input_one) - 1
level = levels_of_list_or_np(input_one) - 1
if num_inputs == 1:
recurse_func = self.implementation_func_dict[
self.implementation][1]
params = [input_one, func, level]
# result = recurse_func(input_one, func, level, self.output_numpy)
else:
input_two = inputs[1].sv_get(deepcopy=True)
level = max(level, levels_of_list_or_np(input_two) - 1)
params = [input_one, input_two, func, level]
recurse_func = self.implementation_func_dict[
self.implementation][2]
if self.implementation == 'NumPy':
params.append(self.output_numpy)
result = recurse_func(*params)
outputs[0].sv_set(result)
def process(self):
if not self.outputs['data'].links:
return
slots = []
for socket in self.inputs:
if socket.is_linked and socket.links:
slots.append(socket.sv_get(deepcopy=False))
if len(slots) == 0:
return
if self.match_and_join:
match_func = list_match_func[self.list_match]
if self.mix_check:
result = match_and_join_mix(slots, self.JoinLevel,
self.wrap_check, match_func)
else:
result = match_and_join(slots, self.JoinLevel, self.wrap_check,
match_func)
else:
if self.numpy_mode:
if self.outputs[0].bl_idname == 'SvVerticesSocket':
min_axis = 2
else:
min_axis = 1
depth = levels_of_list_or_np(slots[0])
true_depth = depth - min_axis
result = numpy_join(slots, self.JoinLevel, self.mix_check,
true_depth)
else:
result = python_join(slots, self.JoinLevel, self.mix_check,
self.wrap_check)
self.outputs[0].sv_set(result)
def process_matched(params, main_func, matching_mode, input_nesting, outputs_num):
'''params will spread using the matching fmode,
the main_func is the function to apply
the input_nesting should be like an Integer List like [1, 2, 1, 3...] one level per parameter
outputs_num: number of outputs (Integer)
'''
input_levels = [levels_of_list_or_np(p) for p in params]
over_levels = [lv > dl for lv, dl in zip(input_levels, input_nesting)]
one_output = outputs_num == 1
matching_f = list_match_func[matching_mode]
if one_output:
result = []
else:
result = [[] for l in range(outputs_num)]
if any(over_levels):
p_temp = []
for p, lv, dl in zip(params, input_levels, input_nesting):
if lv <= dl:
p_temp.append([p])
else:
p_temp.append(p)
params = matching_f(p_temp)
for g in zip(*params):
local_result = process_matched(g, main_func, matching_mode, input_nesting, outputs_num)
append_result(result, local_result, one_output)
else:
result = main_func(matching_f(params))
return result
def recurse_f_level_control(params,
constant,
main_func,
matching_f,
desired_levels,
concatenate="APPEND"):
'''params will spread using the matching function (matching_f), the const is a constant
parameter that you dont want to spread , the main_func is the function to apply
and the desired_levels should be like [1, 2, 1, 3...] one level per parameter'''
input_levels = [levels_of_list_or_np(p) for p in params]
over_levels = [lv > dl for lv, dl in zip(input_levels, desired_levels)]
if any(over_levels):
p_temp = []
result = []
result_add = result.extend if concatenate == 'EXTEND' else result.append
for p, lv, dl in zip(params, input_levels, desired_levels):
if lv <= dl:
p_temp.append([p])
else:
p_temp.append(p)
params = matching_f(p_temp)
for g in zip(*params):
result_add(
recurse_f_level_control(matching_f(g),
constant,
main_func,
matching_f,
desired_levels,
concatenate=concatenate))
else:
result = main_func(params, constant, matching_f)
return result
def recurse_fxy_numpy(l1, l2, func, level, min_l2_level, out_numpy):
if level == 1:
nl1 = np.array(l1)
nl2 = np.array(l2)
nl1, nl2 = numpy_match_long_repeat([nl1, nl2])
res = func(nl1, nl2) if out_numpy else func(nl1, nl2).tolist()
return res
else:
res = []
res_append = res.append
if levels_of_list_or_np([l1]) < 4:
l1 = [l1]
if levels_of_list_or_np([l2]) < min_l2_level+1:
l2 = [l2]
# will only be used if lists are of unequal length
fl = l2[-1] if len(l1) > len(l2) else l1[-1]
for u, v in zip_longest(l1, l2, fillvalue=fl):
res_append(recurse_fxy_numpy(u, v, func, level-1, min_l2_level, out_numpy))
return res
def what_is_next(self):
if self._stack[-1] is DataWalker.EXIT_VALUE:
return DataWalker.END
if isinstance(self._stack[-1], (list, tuple, np.ndarray)):
nesting = levels_of_list_or_np(self._stack[-1])
else:
nesting = 0
if nesting == self._output_nesting:
return DataWalker.VALUE
else: # todo add the case when next element has too less nested levels
return DataWalker.SUB_TREE
def process(self):
if not (self.inputs['Vectors'].is_linked
and any(s.is_linked for s in self.outputs)):
return
vectors = self.inputs['Vectors'].sv_get(deepcopy=False)
if self.correct_output == 'FLAT':
data = dataCorrect_np(vectors)
xyz = unpack(data, self.output_numpy)
else:
input_level = levels_of_list_or_np(vectors)
xyz = unpack_multilevel(vectors, input_level, self.output_numpy)
for i, name in enumerate(['X', 'Y', 'Z']):
if self.outputs[name].is_linked:
self.outputs[name].sv_set(xyz[i])
def format_to_text(data):
deptl = levels_of_list_or_np(data)
out = ''
if deptl > 1:
for i, sub_data in enumerate(data):
if i > 0:
out += '\n'
sub_data_len = len(sub_data) - 1
for i, d in enumerate(sub_data):
out += str(d)
if i < sub_data_len:
out += '\n'
else:
for d in data:
out += str(d) + '\n'
return out
def process(self):
if self.outputs[0].is_linked:
current_func = func_from_mode(self.current_op)
params = [
si.sv_get(default=[[]], deepcopy=False) for si in self.inputs
]
matching_f = list_match_func[self.list_match]
desired_levels = [2 if self.current_op == 'join_all' else 1
] * len(params)
inputs_signature = self.sockets_signature.split(' ')[0]
ops = [current_func, inputs_signature]
if self.current_op == 'to_string':
depth = levels_of_list_or_np(params[0])
desired_levels = [max(depth - self.level + 1, 1)]
result = recurse_f_level_control(params, ops, string_tools,
matching_f, desired_levels)
self.outputs[0].sv_set(result)
def process(self):
if self.inputs['Data'].is_linked:
data = self.inputs['Data'].sv_get(deepcopy=False)
# blocking too height values of levels, reduce
levels = levels_of_list_or_np(data)-1
if levels >= self.level:
levels = self.level-1
elif levels < 1:
levels = 1
# assign out
if self.outputs['First'].is_linked:
out = self.count(data, levels, 0)
self.outputs['First'].sv_set(out)
if self.outputs['Middl'].is_linked:
out = self.count(data, levels, 1)
self.outputs['Middl'].sv_set(out)
if self.outputs['Last'].is_linked:
out = self.count(data, levels, 2)
self.outputs['Last'].sv_set(out)
