def emit_types():
def get_code(t):
if isinstance(t, core.Class):
code = _emit_snippet_class(t)
else:
code = _emit_snippet_enum(t)
code += gu.emit_line_return(2)
return code
return gu.emit(get_classes(p), get_code, sort=False) + \
gu.emit(p.enums, get_code)
def get_imports():
def get_code(c):
return "from {0} import {1}".format(
pgu.get_package_module_name(c.package, 'decoder'),
_get_decoder_function_name(c)) + gu.emit_line_return()
return gu.emit(o.entities, get_code)
def _emit_snippet_decodings(c):
"""Emits a set of class decodings."""
code = []
for p in sorted(c.all_properties, key= lambda p: p.name):
for dc in c.get_property_decodings(p):
if dc.decoding is not None:
code.append(_emit_snippet_decoding(p, dc.decoding, dc.type))
return gu.emit(code)
def emit_imports():
def get_code(ap):
return "import {} as {}{}".format(
pgu.get_package_module_name(ap, 'typeset'),
ap.op_name,
gu.emit_line_return())
return code
return gu.emit(p.associated_for_import, get_code)
def emit_package_imports(o):
"""Emit set of package imports.
"""
def emit_import(p):
return "import {} as {}{}".format(
get_package_module_name(p, 'typeset'),
p.op_name,
gu.emit_line_return())
return gu.emit(o.packages, emit_import)
def _emit_snippet_class_computed_properties(c):
"""Emits set of class computed properties."""
def get_code(cp):
# Open template.
code = _TEMPLATES[_TEMPLATE_CLASS_COMPUTED_PROPERTY]
# Generate code.
code = code.replace('{computed-property-name}', cp.name)
code = code.replace('{computed-property-computation}', cp.computation)
return code
return gu.emit(c.computed_properties, get_code)
def _emit_snippet_class_properties(c):
"""Emits set of class properties."""
def get_code(p):
return "{0}{1}{2}# {3} ({4}){5}".format(
gu.emit_indent(2),
pgu.get_property_ctor(p),
''.ljust(50 - len(pgu.get_property_ctor(p))),
pgu.get_type_doc_name(p.type),
p.cardinality,
gu.emit_line_return()
)
return gu.emit(c.properties, get_code)
def emit_descriptions():
def get_code(m):
code = gu.emit_line_return()
code += gu.emit_indent(2)
code += '"{}"'.format(m.doc_string)
return code
code = gu.emit(e.members, get_code, joiner=",", sort=False)
code += gu.emit_line_return()
code += gu.emit_indent(2)
return code
def emit_members():
def get_code(m):
code = gu.emit_line_return()
code += gu.emit_indent(2)
code += '"{}"'.format(m.name)
return code
code = gu.emit(e.members, get_code, joiner=",", sort=False)
code += gu.emit_line_return()
code += gu.emit_indent(2)
return code
def _emit_snippet_class_property_constants(c):
"""Emits set of class property constants."""
def get_code(cnt):
prp = c.get_property(cnt[0])
if prp is not None:
return '{0}self.{1} = {2}("{3}"){4}'.format(
gu.emit_indent(2),
cnt[0],
pgu.get_type_functional_name(prp.type),
cnt[1],
gu.emit_line_return()
)
return gu.emit(c.constants, get_code)
