uml2python.mtl

[comment encoding = UTF-8 /]
[module uml2python('http://www.eclipse.org/uml2/4.0.0/UML')]


[comment]
 Main entry point. This main template MUST be named 'generate' and it must
 own the main annotation.
[/comment]
[template public generate(m : Package)]
[comment @main/]
[file (m.qualifiedName.replaceAll('::', '/') + '/__init__.py', false, 'UTF-8')]
[if (not m.ownedComment->isEmpty())]
"""
[m.ownedComment.genComment(' ')/]
"""

[/if]
# [protected ('-> additional imports for ' + m.name + ' package')]

# [/protected]
[let nonPrimitiveClasses : Set(Classifier) = m.packagedElement->union(m.importedMember)->filter(Classifier)->reject(oclIsKindOf(Association) or oclIsKindOf(PrimitiveType))]
[let nonPrimitiveInstances : Set(InstanceSpecification) = m.packagedElement->union(m.importedMember)->filter(InstanceSpecification)]
[for (e : NamedElement | nonPrimitiveClasses->union(nonPrimitiveInstances)->sortedBy(qualifiedName)) before('__all__ = [') separator(', ') after(']')]
"[e.name/]"[/for]

[for (e : Classifier | nonPrimitiveClasses->sortedBy(qualifiedName))]
from [e.qualifiedName.replaceAll('::', '.')/] import [e.name/]
[/for]
[for (instance : InstanceSpecification | nonPrimitiveInstances->sortedBy(qualifiedName))]
import [instance.classifier.qualifiedName.replaceAll('::', '.')/]
[/for]

[for (instance : InstanceSpecification | nonPrimitiveInstances->sortedBy(qualifiedName))]
[instance.name/] = [instance.classifier.qualifiedName.replaceAll('::', '.')/]()
[/for]
[/let]
[/let]

[/file]
[m.genPackageContent()/]
[/template]

[**
 * This template generates a package content (one class per file)
 */]
[template public genPackageContent(m : Package)]
[for (e : Classifier | m.ownedElement->filter(Classifier)->reject(oclIsKindOf(Association)))]
[file(e.qualifiedName.replaceAll('::', '/') + '.py', false, 'UTF-8')]
# [protected ('-> additional imports for ' + e.name)]

# [/protected]
[if (not m.packagedElement->select(isAbstract)->isEmpty())]
from abc import ABCMeta, abstractmethod, abstractclassmethod, abstractstaticmethod
[/if]
[for (u : Dependency | m.packagedElement->filter(Dependency)->select(match | match.oclAsType(Dependency).client->includes(e))->sortedBy(qualifiedName))]
from [u.supplier.qualifiedName.replaceAll('::', '.')/] import [u.supplier.name/]
[/for]
[comment Dummy and very simple import management (misses the extern module imports) /]
[if (not m.allOwnedElements()->filter(TypedElement)->select(type <> null and type.name <> null and type.name = 'Date')->isEmpty())]
from datetime import datetime

[/if]
[comment Generate code for classes/interfaces /]
[e.genClassif()/]
[/file]
[/for]
[/template]

[comment]
 These templates are used to generate 'Classifier' code, i.e., Class, Interface and Enumeration.
[/comment]
[template public genClassif(e : Classifier)/]
[template public genClassif(d : DataType)]
[let inherited : Set(Classifier) = d.parents()]
[for (inheritedNonPrimitiveClass : Classifier | inherited->reject(oclIsKindOf(PrimitiveType))->sortedBy(qualifiedName))]
from [inheritedNonPrimitiveClass.qualifiedName.replaceAll('::', '.')/] import [inheritedNonPrimitiveClass.name/]
[/for]
[let nonPrimitiveAttributes : OrderedSet(Property) = d.attribute->reject(oclIsKindOf(PrimitiveType))->reject(type.qualifiedName = d.qualifiedName)]
[for (attribute : Property | nonPrimitiveAttributes->sortedBy(qualifiedName))]from [attribute.type.qualifiedName.replaceAll('::', '.')/] import [attribute.type.name/]
[/for][/let]
class [d.name/]([if (not inherited->isEmpty())][for (cl : Classifier | inherited) separator(', ')][cl.name/][/for][else]object[/if]):
[/let]
	[if (not d.ownedComment->isEmpty())]
	"""
	[d.ownedComment.genComment(' ')/]
	"""
	[/if]
	def __init__(self):
		super().__init__()
		[d.ownedAttribute.gen()/]
		# [protected ('-> additional implementation details for ' + d.name + ' datatype constructor')]

		# [/protected]
	# [protected ('-> properties/constructors for ' + d.name + ' class')]

	# [/protected]
[/template]
[template public genClassif(c : Class)]
[let inherited : Bag(Classifier) = c.superClass->union(c.interfaceRealization.contract)]
[for (inheritedNonPrimitiveClass : Classifier | inherited->reject(oclIsKindOf(PrimitiveType))->sortedBy(qualifiedName))]
from [inheritedNonPrimitiveClass.qualifiedName.replaceAll('::', '.')/] import [inheritedNonPrimitiveClass.name/]
[/for]
[let nonPrimitiveAttributes : OrderedSet(Property) = c.attribute->reject(oclIsKindOf(PrimitiveType))->reject(type.qualifiedName = c.qualifiedName)]
[for (attribute : Property | nonPrimitiveAttributes->sortedBy(qualifiedName))]from [attribute.type.qualifiedName.replaceAll('::', '.')/] import [attribute.type.name/]
[/for][/let]


class [c.name/]([if (not inherited->isEmpty())][for (cl : Classifier | inherited->sortedBy(qualifiedName)) separator(', ')][cl.name/][/for][else]object[/if][if (not c.ownedOperation->select(isAbstract)->isEmpty())], metaclass=ABCMeta[/if]):
	[if (not c.ownedComment->isEmpty())]
	"""
	[c.ownedComment.genComment(' ')/]
	"""
	[/if]
	[let navig : Bag(Property) = c.getAssociations().navigableOwnedEnd->select(type <> c)]
	[if (not c.ownedOperation->select(m | m.name = c.name)->isEmpty())]
	[c.ownedOperation->select(m | m.name = c.name)->first().gen()/]
	[else]
	def __init__(self):
		super().__init__()
[if (not c.ownedAttribute->union(navig)->isEmpty())]		[c.ownedAttribute->union(navig).gen()/][/if]
		# [protected ('-> additional implementation details for ' + c.name + ' class constructor')]

		# [/protected]
	[/if][/let]
	# [protected ('-> properties for ' + c.name + ' class')]

	# [/protected]
	[if (not c.nestedClassifier->isEmpty())]
	[c.nestedClassifier.genClassif()/]
	[/if]
	[if (not c.ownedOperation->isEmpty())]
		[for (ops : Operation | c.ownedOperation->reject(op | op.name = c.name))]
	[ops.gen()/]
		[/for]
	[/if]
	# [protected ('-> methods for ' + c.name + ' class')]

	# [/protected]
[/let]
[/template]

[template public genClassif(i : Interface)]
[let inherited : Bag(Classifier) = i.generalization.general]
[for (inheritedNonPrimitiveClass : Classifier | inherited->reject(oclIsKindOf(PrimitiveType))->sortedBy(qualifiedName))]
from [inheritedNonPrimitiveClass.qualifiedName.replaceAll('::', '.')/] import [inheritedNonPrimitiveClass.name/]
[/for]
class [i.name/]([if (not inherited->isEmpty())][for (cl : Classifier | inherited->sortedBy(qualifiedName)) separator(', ')][cl.name/][/for][else]object[/if]):
	[if (not i.ownedComment->isEmpty())]
	"""
	[i.ownedComment.genComment(' ')/]
	"""
	[/if]
	[let navig : Bag(Property) = i.getAssociations().navigableOwnedEnd->select(type <> i)]
	def __init__(self):
		super().__init__()
		[if (not i.ownedAttribute->union(navig)->isEmpty())][i.ownedAttribute->union(navig).gen()/][/if]
		# [protected ('-> additional implementation details for ' + i.name + ' interface constructor')]

		# [/protected]
	[/let]
	# [protected ('-> properties for ' + i.name + ' class(interface)')]

	# [/protected]
	[if (not i.nestedClassifier->isEmpty())]
	[i.nestedClassifier.genClassif()/]
	[/if]
	[if (not i.ownedOperation->isEmpty())]
		[for (ops : Operation | i.ownedOperation->reject(op | op.name = i.name))]
	[ops.gen()/]
		[/for]
	[/if]
	# [protected ('-> methods for ' + i.name + ' class(interface)')]

	# [/protected]
[/let]
[/template]

[comment]
 This template represents the choice we made about UML Enumeration
 compilation to python code.
[/comment]
[template public genClassif(e : Enumeration)]
class [e.name/]:
	[if (not e.ownedComment->isEmpty())]
	"""
	[e.ownedComment.genComment(' ')/]
	"""
	[/if]
	[if (not e.ownedLiteral->isEmpty())]
	[for (lit : EnumerationLiteral | e.ownedLiteral) separator(', ')][lit.name/][/for] = range([e.ownedLiteral->size()/])
	[/if]
[/template]

[template public gen(p : Property)]
[if (not p.ownedComment->isEmpty())]
[p.ownedComment.genComment('#')/]

[/if]
self.[if (p.visibility = VisibilityKind::_private)]__[/if][p.name/]: [p.type.name/][if ((not p.defaultValue.oclIsInvalid()) and (not p.defaultValue.oclIsUndefined()))] = [p.defaultValue.translate()/][/if]

[/template]

[template public gen(o : Operation)]

[o.header()/]
	[if (not o.ownedComment->isEmpty())]
	"""
	[o.ownedComment.genComment(' ')/]
	"""
	[/if]
	# [protected ('protected zone for ' + o.name + ' function body')]

	# [/protected]
	[o.bodyOperation()/]
[/template]



[template public translate(v : ValueSpecification)]
[if (v.oclIsTypeOf(InstanceValue) or v.oclIsTypeOf(LiteralNull) or v.oclIsTypeOf(EnumerationLiteral) or v.oclIsTypeOf(LiteralInteger) or v.oclIsTypeOf(LiteralReal) or v.oclIsTypeOf(LiteralBoolean))]
[v.translate()/]
[else]
[v.stringValue()/]
[/if]
[/template]

[template public translate(v : InstanceValue)]
[if (not v.instance.qualifiedName.oclIsUndefined())][v.instance.classifier.name/].[v.instance.name.replaceAll('::', '.')/]
[elseif (not v.type.qualifiedName.oclIsUndefined())][v.type.name.replaceAll('::', '.')/]()
[/if]
[/template]

[template public translate(ln : LiteralNull)]
None
[/template]

[template public translate(v : EnumerationLiteral)]
[v.name/]
[/template]

[template public translate(v : LiteralInteger)]
[v.value/]
[/template]

[template public translate(v : LiteralReal)]
[v.value/]
[/template]

[template public translate(v : LiteralBoolean)]
[if (not v.value.oclIsUndefined() and v.booleanValue())]True[else]False[/if]
[/template]
[comment]
 Generate an operation header. If the operation visibility is set to
 private, '__' prefixes the operation name.
[/comment]
[template public header(o : Operation)]
[if (o.isAbstract)]@abstractmethod
[/if][if (o.isStatic)]@staticmethod
[/if]
def [if (o.visibility = VisibilityKind::_private)]__[/if][if (o.class.name = o.name)]__init__[else][o.name/][/if]([if (not o.isStatic)]self[if (not o.ownedParameter->excluding(o.getReturnResult())->isEmpty())], [/if][/if][for (param : Parameter | o.ownedParameter->excluding(o.getReturnResult())) separator(', ')][param.name/][if ((not param.type.oclIsInvalid()) and param.type.oclIsKindOf(PrimitiveType))]: [param.type.name/][/if][if ((not param.defaultValue.oclIsUndefined()) and (not param.defaultValue.oclIsInvalid()))] = [param.defaultValue.translate()/][/if][/for])[if ((not o.getReturnResult().oclIsInvalid()) and (not o.getReturnResult().oclIsUndefined()))] -> [o.getReturnResult().type.name/][/if]:
[/template]

[template public bodyOperation(o : Operation)]
[if (o.isAbstract)]raise NotImplementedError
[elseif (not o.method->isEmpty())]
[let behaviors : Set(FunctionBehavior) = o.method]
[for (behavior : FunctionBehavior | behaviors->select(b | b->one(language->first() = 'Python')))][behavior._body->first()/][/for]
[/let]
[elseif (o.getReturnResult() <> null and o.getReturnResult().type <> null)]
return [o.getReturnResult().genValue()/]
[else]raise NotImplementedError
[/if]
[/template]

[template public genValue(m : MultiplicityElement) post (trim())]
[if (m.isMany())]['['/]]
[elseif (m.oclIsKindOf(TypedElement))][m.oclAsType(TypedElement).type.genSingleValue()/]
[else]None
[/if]
[/template]

[comment]
 Generate single values for methods and attributes initialization.
[/comment]
[template public genSingleValue(t : Type) ? (not t.oclIsUndefined()) post (trim())]
[if (t.name = 'str')]""
[elseif (t.name = 'unlimitedNatural')]0L
[elseif (t.name = 'double')]0.
[elseif (t.name = 'real')]0.
[elseif (t.name = 'float')]0.
[elseif (t.name = 'long')]0L
[elseif (t.name = 'int')]0
[elseif (t.name = 'short')]0
[elseif (t.name = 'byte')]0x0
[elseif (t.name = 'array')]['['/]]
[elseif (t.name = 'boolean')]False
[elseif (t.name = 'date')]datetime()
[elseif (t.name = 'char')]''
[elseif (t.name = 'List')]['[]'/]
[elseif (t.oclIsKindOf(Enumeration))][if (not t.oclAsType(Enumeration).ownedLiteral->isEmpty())][t.name/].[t.oclAsType(Enumeration).ownedLiteral->at(1).name/][else]None[/if]
[else]None[/if]
[/template]


[template public genComment(c : Comment, prefix : String)]
[prefix/][c.genBody(prefix).replaceAll('\n','\n' + prefix + ' ')/]
[/template]

[template public genBody(c : Comment, prefix : String)]
[c._body/][if (not c.ownedComment->isEmpty())]['\n'/][prefix/] [c.ownedComment.genBody(prefix)->sep('\n ' + prefix)/][/if]
[/template]

[query public isMany(s : MultiplicityElement) : Boolean =
	s.lower > 1 or s.upper = -1 or s.upper > 1 
/]

[query public isAssociation(p : Property) : Boolean =
	not p.association.oclIsUndefined()
/]