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)