def generate_copied_value(value: 'values.Value'):
assert(isinstance(value, values.Value))
if isinstance(value, values.NumberValue):
copied = values.NumberValue(value.internal_value)
copied.dtype = value.dtype
return copied
if isinstance(value, values.TensorValue):
copied = values.TensorValue()
copied.value = value.value
copied.shape = value.shape
copied.dtype = value.dtype
return copied
if isinstance(value, values.ListValue):
copied = values.ListValue()
copied.dtype = value.dtype
copied.vtype = value.vtype
if value.internal_value is not None:
copied.internal_value = value.internal_value.copy()
return copied
if isinstance(value, values.NoneValue):
copied = values.NoneValue()
return copied
if isinstance(value, values.BoolValue):
copied = values.BoolValue(value.internal_value)
return copied
if isinstance(value, values.StrValue):
copied = values.StrValue(value.internal_value)
return copied
if isinstance(value, values.RangeValue):
copied = values.RangeValue()
return copied
if isinstance(value, values.TupleValue):
if value.internal_value is not None:
copied = values.TupleValue(value.internal_value.copy())
else:
copied = values.TupleValue(value.internal_value)
copied.dtype = value.dtype
copied.vtype = value.vtype
return copied
if config.show_warnings:
print('Unknown type {} is copied'.format(value))
return values.Value()
def vcall(self,
module: 'Field',
graph: 'Graph',
inst: 'values.ValueRef',
args: 'functions.FunctionArgInput',
line=-1):
args = functions.FunctionArgInput()
args.inputs.append(inst)
args.keywords['self'] = inst
node = nodes.NodeCall(self, args, line)
value = values.TupleValue()
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
graph.add_node(node)
return values.ValueRef(value)
def make_attribute(value):
if isinstance(value, list):
for i in range(len(value)):
value[i] = make_attribute(value[i])
if isinstance(value, functions.FunctionArgValueInput):
converted = {}
ret = functions.FunctionArgValueInput()
for v in value.inputs:
converted_v = make_attribute(v)
ret.inputs.append(converted_v)
converted[v] = converted_v
keywords_ = {}
for k, v in value.keywords.items():
if v in converted.keys():
keywords_[k] = converted[v]
else:
keywords_[k] = make_attribute(v)
ret.keywords = keywords_
return ret
if isinstance(value,
values.TupleValue) and value.internal_value is not None:
vs = []
for v in value.internal_value:
if isinstance(v, values.Object):
v = v.get_value()
vs.append(v)
ret = values.TupleValue(vs)
ret.name = value.name
ret.generator = value.generator
return ret
if isinstance(value, values.Object):
return value.get_value()
return value
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.Object',
args: 'functions.FunctionArgInput',
option: 'vevaluator.VEvalContext' = None,
line=-1):
chainer_link = chainer_links[type(self.owner.inst)]
if len(self.args.args_list) == 0:
if chainer_link.args is None:
self.args.add_arg('self', None)
self.args.add_arg('x', None)
else:
for arg in chainer_link.args:
self.args.add_arg(arg[0], arg[1])
vargs = self.args.merge_inputs(inst, args)
node = nodes.NodeCall(self, vargs, line)
graph.add_node(node)
if chainer_link.get_ret is not None:
ret = chainer_link.get_ret()
node.set_outputs(ret)
return values.Object(
values.TupleValue([values.Object(v) for v in ret]))
else:
value = values.TensorValue()
estimate_shape = chainer_links[type(
self.owner.inst)].estimate_shape
if estimate_shape is not None:
value.shape = estimate_shape(self.owner.inst, vargs)
node.set_outputs([value])
return values.Object(value)
def veval_ast_tuple(astc: 'AstContext',
local_field: 'values.Field',
graph: 'Graph',
option: 'VEvalOption' = None):
assert (isinstance(astc.nast, gast.gast.Tuple))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
if option is not None and option.eval_as_written_target:
vs = []
for v in astc.nast.elts:
a_ = veval_ast(astc.c(v), local_field, graph, option=option)
vs.append(a_)
return vs
else:
vs_ref = []
vs = []
for v in astc.nast.elts:
a_ = veval_ast(astc.c(v), local_field, graph, option=option)
v_ = try_get_ref(a_, 'tuple', lineprop)
if v_ is None:
utils.print_warning('Unknown tuple element {}'.format(v),
lineprop)
return None
vs_ref.append(v_)
vs.append(v_.get_value())
v_.in_container = True
tuple_value = values.TupleValue(vs_ref)
node = nodes.NodeGenerate('Tuple', vs, line=lineprop)
node.set_outputs([tuple_value])
graph.add_node(node)
return values.ValueRef(tuple_value)
def generate_value_with_same_type(value: 'values.Value', is_dummy_value = False, suffix_type = SuffixType.Unknown):
assert(isinstance(value, values.Value))
ret = None
if isinstance(value, values.TensorValue):
ret = values.TensorValue()
ret.shape = value.shape
ret.dtype = value.dtype
elif isinstance(value, values.NumberValue):
dtype = None
if value.internal_value is None:
dtype = value.dtype
elif isinstance(value.internal_value, int):
dtype = np.array(value.internal_value).dtype
elif isinstance(value.internal_value, float):
dtype = np.array(value.internal_value).dtype
ret = values.NumberValue(None)
ret.dtype = dtype
elif isinstance(value, values.StrValue):
ret = values.StrValue(None)
elif isinstance(value, values.BoolValue):
ret = values.BoolValue(None)
elif isinstance(value, values.ListValue):
ret = values.ListValue(None)
ret.dtype = value.dtype
ret.vtype = value.vtype
elif isinstance(value, values.NoneValue):
ret = values.NoneValue()
elif isinstance(value, values.TupleValue):
ret = values.TupleValue()
ret.dtype = value.dtype
ret.vtype = value.vtype
elif isinstance(value, values.RangeValue):
ret = values.RangeValue()
elif isinstance(value, values.UnknownValue):
ret = values.UnknownValue()
elif ret is None and isinstance(value, values.Value):
ret = values.Value()
else:
assert(False)
assert(ret is not None)
ret.is_dummy_value = is_dummy_value
if suffix_type == SuffixType.Unknown:
ret.name = value.name + '_st'
elif suffix_type == SuffixType.Unused:
ret.name = value.name + '_unused'
elif suffix_type == SuffixType.Dummy:
ret.name = value.name + '_dummy'
elif suffix_type == SuffixType.Input:
ret.name = value.name + '_in'
else:
assert(False)
return ret
def ret_tuple(funcArgs = None):
ret = values.TupleValue()
ret.vtype = values.TensorValue
return ret
def ret_tuple():
ret = values.TupleValue()
ret.vtype = values.TensorValue
return ret