def encode(self):
lines = []
if self.space.doc is not None:
lines.append("\"\"\"" + self.space.doc + "\"\"\"")
lines.append("from modelx.serialize.jsonvalues import *")
# Output formula
if self.space.formula:
if self.space.formula.source[:6] == "lambda":
lines.append("_formula = " + self.space.formula.source)
else:
lines.append(self.space.formula.source)
else:
lines.append("_formula = None")
# Output bases
bases = []
for base in self.space._direct_bases:
bases.append(
abs_to_rel(base._evalrepr, self.parent._evalrepr))
lines.append("_bases = " + json.JSONEncoder(
ensure_ascii=False,
indent=4
).encode(bases))
# Output allow_none
lines.append("_allow_none = " + str(self.space.allow_none))
# Output _spaces. Exclude spaces created from methods
spaces = []
for name, space in self.space.spaces.items():
if name[0] == "_":
pass
elif MethodCallEncoder.from_method(space):
pass
else:
spaces.append(name)
lines.append("_spaces = " + json.JSONEncoder(
ensure_ascii=False,
indent=4
).encode(spaces))
lines.extend(e.encode() for e in self.space_method_encoders)
lines.extend(e.encode() for e in self.cells_method_encoders)
# Cells definitions
if self.cells_encoders:
separator = SECTION_DIVIDER + "\n" + SECTIONS["CELLSDEFS"].symbol
lines.append(separator)
for encoder in self.cells_encoders:
lines.append(encoder.encode())
lines.append(self.refview_encoder.encode())
return "\n\n".join(lines)
def _encode_refs(self, obj, namespace):
default_types = [str, Number, bool]
if any(isinstance(obj, type_) for type_ in default_types):
return obj
cls = type(obj)
builtins_name = type(int).__module__
if cls.__module__ is not None and cls.__module__ != builtins_name:
module = cls.__module__
else:
module = ""
result = {
"__module": module,
"__type": cls.__qualname__
}
if obj is None:
result.update({
"__encoding": "None",
"__value": "None"
})
elif isinstance(obj, types.ModuleType):
result.update({
"__encoding": "Module",
"__value": obj.__name__,
})
elif isinstance(obj, Interface):
result.update({
"__encoding": "Interface",
"__value": abs_to_rel(obj._evalrepr, namespace),
})
elif isinstance(obj, Sequence):
result.update({
"__encoding": "Sequence",
"__value": [
self._encode_refs(item, namespace) for item in obj],
})
elif isinstance(obj, Mapping):
result.update({
"__encoding": "Mapping",
"__value": [
(self._encode_refs(key, namespace),
self._encode_refs(value, namespace))
for key, value in obj.items()
],
})
else:
raise TypeError("Type %s not supported by JSON" % str(cls))
return result
def encode(self):
relname = abs_to_rel(self.target._evalrepr, self.parent._evalrepr)
return "(\"Interface\", \"%s\")" % relname
def encode(self, data):
data = [abs_to_rel(base.fullname, self.owner.fullname)
for base in data]
return super().encode(data)
