You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@ariatosca.apache.org by em...@apache.org on 2017/02/27 18:51:02 UTC

[2/2] incubator-ariatosca git commit: Template and instance complete (as_raw as well)

Template and instance complete (as_raw as well)


Project: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/commit/33a4ee72
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/tree/33a4ee72
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/diff/33a4ee72

Branch: refs/heads/ARIA-105-integrate-modeling
Commit: 33a4ee7252ddfbfdfc6a6bcf7ab5c5c6117c71aa
Parents: f62cdd4
Author: Tal Liron <ta...@gmail.com>
Authored: Mon Feb 27 12:50:34 2017 -0600
Committer: Tal Liron <ta...@gmail.com>
Committed: Mon Feb 27 12:50:34 2017 -0600

----------------------------------------------------------------------
 aria/modeling/service_models.py          | 477 ++++++++++++++------------
 aria/modeling/service_template_models.py | 476 +++++++++++++------------
 aria/modeling/utils.py                   |  20 +-
 aria/parser/modeling/context.py          |   7 +
 4 files changed, 510 insertions(+), 470 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/33a4ee72/aria/modeling/service_models.py
----------------------------------------------------------------------
diff --git a/aria/modeling/service_models.py b/aria/modeling/service_models.py
index 0198b6f..a3d714f 100644
--- a/aria/modeling/service_models.py
+++ b/aria/modeling/service_models.py
@@ -22,7 +22,6 @@ from sqlalchemy import (
 from sqlalchemy import DateTime
 from sqlalchemy.ext.associationproxy import association_proxy
 from sqlalchemy.ext.declarative import declared_attr
-from sqlalchemy.ext.orderinglist import ordering_list
 
 from .base import ModelMixin
 from ..parser import validation
@@ -36,7 +35,7 @@ from . import (
 # pylint: disable=no-self-argument, no-member, abstract-method
 
 
-class InstanceModelMixin(ModelMixin):
+class _InstanceModelMixin(ModelMixin):
     """
     Mixin for :class:`ServiceInstance` models.
 
@@ -58,23 +57,21 @@ class InstanceModelMixin(ModelMixin):
         pass
 
 
-class ServiceBase(InstanceModelMixin):
+class ServiceBase(_InstanceModelMixin):
     """
     A service instance is an instance of a :class:`ServiceTemplate`.
 
     You will usually not create it programmatically, but instead instantiate it from the template.
 
-    Properties:
-
-    * :code:`description`: Human-readable description
-    * :code:`meta_data`: Dict of :class:`Metadata`
-    * :code:`nodes`: Dict of :class:`Node`
-    * :code:`groups`: Dict of :class:`Group`
-    * :code:`policies`: Dict of :class:`Policy`
-    * :code:`substitution`: :class:`Substitution`
-    * :code:`inputs`: Dict of :class:`Parameter`
-    * :code:`outputs`: Dict of :class:`Parameter`
-    * :code:`operations`: Dict of :class:`Operation`
+    :ivar description: Human-readable description
+    :ivar meta_data: Dict of :class:`Metadata`
+    :ivar nodes: Dict of :class:`Node`
+    :ivar groups: Dict of :class:`Group`
+    :ivar policies: Dict of :class:`Policy`
+    :ivar substitution: :class:`Substitution`
+    :ivar inputs: Dict of :class:`Parameter`
+    :ivar outputs: Dict of :class:`Parameter`
+    :ivar operations: Dict of :class:`Operation`
     """
 
     __tablename__ = 'service'
@@ -151,8 +148,6 @@ class ServiceBase(InstanceModelMixin):
 
     # endregion
 
-    # association proxies
-
     def satisfy_requirements(self, context):
         satisfied = True
         for node in self.nodes:
@@ -175,7 +170,7 @@ class ServiceBase(InstanceModelMixin):
         return collections.FrozenList(nodes)
 
     def get_node_ids(self, node_template_name):
-        return collections.FrozenList((node.id for node in self.find_nodes(node_template_name)))
+        return collections.FrozenList((node.name for node in self.find_nodes(node_template_name)))
 
     def find_groups(self, group_template_name):
         groups = []
@@ -185,7 +180,7 @@ class ServiceBase(InstanceModelMixin):
         return collections.FrozenList(groups)
 
     def get_group_ids(self, group_template_name):
-        return collections.FrozenList((group.id for group in self.find_groups(group_template_name)))
+        return collections.FrozenList((group.name for group in self.find_groups(group_template_name)))
 
     def is_node_a_target(self, context, target_node):
         for node in self.nodes:
@@ -196,7 +191,7 @@ class ServiceBase(InstanceModelMixin):
     def _is_node_a_target(self, context, source_node, target_node):
         if source_node.relationships:
             for relationship in source_node.relationships:
-                if relationship.target_node_id == target_node.id:
+                if relationship.target_node_id == target_node.name:
                     return True
                 else:
                     node = context.modeling.instance.nodes.get(relationship.target_node_id)
@@ -205,23 +200,96 @@ class ServiceBase(InstanceModelMixin):
                             return True
         return False
 
+    @property
+    def as_raw(self):
+        return collections.OrderedDict((
+            ('description', self.description),
+            ('metadata', formatting.as_raw_dict(self.meta_data)),
+            ('nodes', formatting.as_raw_list(self.nodes)),
+            ('groups', formatting.as_raw_list(self.groups)),
+            ('policies', formatting.as_raw_list(self.policies)),
+            ('substitution', formatting.as_raw(self.substitution)),
+            ('inputs', formatting.as_raw_dict(self.inputs)),
+            ('outputs', formatting.as_raw_dict(self.outputs)),
+            ('operations', formatting.as_raw_list(self.operations))))
+
+    def validate(self, context):
+        utils.validate_dict_values(context, self.meta_data)
+        utils.validate_list_values(context, self.nodes)
+        utils.validate_list_values(context, self.groups)
+        utils.validate_list_values(context, self.policies)
+        if self.substitution is not None:
+            self.substitution.validate(context)
+        utils.validate_dict_values(context, self.inputs)
+        utils.validate_dict_values(context, self.outputs)
+        utils.validate_dict_values(context, self.operations)
 
-class NodeBase(InstanceModelMixin):
+    def coerce_values(self, context, container, report_issues):
+        utils.coerce_dict_values(context, container, self.meta_data, report_issues)
+        utils.coerce_list_values(context, container, self.nodes, report_issues)
+        utils.coerce_list_values(context, container, self.groups, report_issues)
+        utils.coerce_list_values(context, container, self.policies, report_issues)
+        if self.substitution is not None:
+            self.substitution.coerce_values(context, container, report_issues)
+        utils.coerce_dict_values(context, container, self.inputs, report_issues)
+        utils.coerce_dict_values(context, container, self.outputs, report_issues)
+        utils.coerce_dict_values(context, container, self.operations, report_issues)
+
+    def dump(self, context):
+        if self.description is not None:
+            console.puts(context.style.meta(self.description))
+        utils.dump_parameters(context, self.meta_data, 'Metadata')
+        for node in self.nodes:
+            node.dump(context)
+        for group in self.groups:
+            group.dump(context)
+        for policy in self.policies:
+            policy.dump(context)
+        if self.substitution is not None:
+            self.substitution.dump(context)
+        utils.dump_parameters(context, self.inputs, 'Inputs')
+        utils.dump_parameters(context, self.outputs, 'Outputs')
+        utils.dump_dict_values(context, self.operations, 'Operations')
+
+    def dump_graph(self, context):
+        for node in self.nodes.itervalues():
+            if not self.is_node_a_target(context, node):
+                self._dump_graph_node(context, node)
+
+    def _dump_graph_node(self, context, node):
+        console.puts(context.style.node(node.name))
+        if node.relationships:
+            with context.style.indent:
+                for relationship in node.relationships:
+                    relationship_name = (context.style.node(relationship.template_name)
+                                         if relationship.template_name is not None
+                                         else context.style.type(relationship.type_name))
+                    capability_name = (context.style.node(relationship.target_capability_name)
+                                       if relationship.target_capability_name is not None
+                                       else None)
+                    if capability_name is not None:
+                        console.puts('-> {0} {1}'.format(relationship_name, capability_name))
+                    else:
+                        console.puts('-> {0}'.format(relationship_name))
+                    target_node = self.nodes.get(relationship.target_node_id)
+                    with console.indent(3):
+                        self._dump_graph_node(context, target_node)
+
+
+class NodeBase(_InstanceModelMixin):
     """
     An instance of a :class:`NodeTemplate`.
 
     Nodes may have zero or more :class:`Relationship` instances to other nodes.
 
-    Properties:
-
-    * :code:`id`: Unique ID (prefixed with the template name)
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`template_name`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`interfaces`: Dict of :class:`Interface`
-    * :code:`artifacts`: Dict of :class:`Artifact`
-    * :code:`capabilities`: Dict of :class:`CapabilityTemplate`
-    * :code:`relationships`: List of :class:`Relationship`
+    :ivar name: Unique ID (prefixed with the template name)
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar template_name: Must be represented in the :class:`ServiceTemplate`
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar interfaces: Dict of :class:`Interface`
+    :ivar artifacts: Dict of :class:`Artifact`
+    :ivar capabilities: Dict of :class:`CapabilityTemplate`
+    :ivar relationships: List of :class:`Relationship`
     """
 
     __tablename__ = 'node'
@@ -336,9 +404,8 @@ class NodeBase(InstanceModelMixin):
                                                      requirement_template,
                                                      requirement_template_index=i)
             else:
-                context.validation.report('requirement "%s" of node "%s" has no target node '
-                                          'template' % (requirement_template.name,
-                                                        self.id),
+                context.validation.report('requirement "{0}" of node "{1}" has no target node '
+                                          'template'.format(requirement_template.name, self.name),
                                           level=validation.Issue.BETWEEN_INSTANCES)
                 satisfied = False
         return satisfied
@@ -367,26 +434,26 @@ class NodeBase(InstanceModelMixin):
                 relationship = model.Relationship(
                     name=requirement_template.name,
                     source_requirement_index=requirement_template_index,
-                    target_node_id=target_node.id
+                    target_node_id=target_node.name
                 )
                 if target_capability is not None:
                     relationship.target_capability_name = target_capability.name
                 self.outbound_relationships.append(relationship)
             else:
-                context.validation.report('requirement "%s" of node "%s" targets node '
-                                          'template "%s" but its instantiated nodes do not '
-                                          'have enough capacity'
-                                          % (requirement_template.name,
-                                             self.id,
-                                             target_node_template.name),
+                context.validation.report('requirement "{0}" of node "{1}" targets node '
+                                          'template "{2}" but its instantiated nodes do not '
+                                          'have enough capacity'.format(
+                                              requirement_template.name,
+                                              self.name,
+                                              target_node_template.name),
                                           level=validation.Issue.BETWEEN_INSTANCES)
                 return False
         else:
-            context.validation.report('requirement "%s" of node "%s" targets node template '
-                                      '"%s" but it has no instantiated nodes'
-                                      % (requirement_template.name,
-                                         self.id,
-                                         target_node_template.name),
+            context.validation.report('requirement "{0}" of node "{1}" targets node template '
+                                      '"{2}" but it has no instantiated nodes'.format(
+                                          requirement_template.name,
+                                          self.name,
+                                          target_node_template.name),
                                       level=validation.Issue.BETWEEN_INSTANCES)
             return False
 
@@ -394,12 +461,12 @@ class NodeBase(InstanceModelMixin):
         satisfied = False
         for capability in self.capabilities.itervalues():
             if not capability.has_enough_relationships:
-                context.validation.report('capability "%s" of node "%s" requires at least %d '
-                                          'relationships but has %d'
-                                          % (capability.name,
-                                             self.id,
-                                             capability.min_occurrences,
-                                             capability.occurrences),
+                context.validation.report('capability "{0}" of node "{1}" requires at least {2:d} '
+                                          'relationships but has {3:d}'.format(
+                                              capability.name,
+                                              self.name,
+                                              capability.min_occurrences,
+                                              capability.occurrences),
                                           level=validation.Issue.BETWEEN_INSTANCES)
                 satisfied = False
         return satisfied
@@ -407,21 +474,22 @@ class NodeBase(InstanceModelMixin):
     @property
     def as_raw(self):
         return collections.OrderedDict((
-            ('id', self.id),
+            ('name', self.name),
             ('type_name', self.type_name),
             ('template_name', self.template_name),
             ('properties', formatting.as_raw_dict(self.properties)),
             ('interfaces', formatting.as_raw_list(self.interfaces)),
             ('artifacts', formatting.as_raw_list(self.artifacts)),
             ('capabilities', formatting.as_raw_list(self.capabilities)),
-            ('relationships', formatting.as_raw_list(self.relationships))))
+            ('relationships', formatting.as_raw_list(self.outbound_relationships))))
 
     def validate(self, context):
-        if len(self.id) > context.modeling.id_max_length:
-            context.validation.report('"%s" has an ID longer than the limit of %d characters: %d'
-                                      % (self.id,
-                                         context.modeling.id_max_length,
-                                         len(self.id)),
+        if len(self.name) > context.modeling.id_max_length:
+            context.validation.report('"{0}" has an ID longer than the limit of {1:d} characters: '
+                                      '{2:d}'.format(
+                                            self.name,
+                                            context.modeling.id_max_length,
+                                            len(self.name)),
                                       level=validation.Issue.BETWEEN_INSTANCES)
 
         # TODO: validate that node template is of type?
@@ -430,40 +498,38 @@ class NodeBase(InstanceModelMixin):
         utils.validate_dict_values(context, self.interfaces)
         utils.validate_dict_values(context, self.artifacts)
         utils.validate_dict_values(context, self.capabilities)
-        utils.validate_list_values(context, self.relationships)
+        utils.validate_list_values(context, self.outbound_relationships)
 
     def coerce_values(self, context, container, report_issues):
         utils.coerce_dict_values(context, self, self.properties, report_issues)
         utils.coerce_dict_values(context, self, self.interfaces, report_issues)
         utils.coerce_dict_values(context, self, self.artifacts, report_issues)
         utils.coerce_dict_values(context, self, self.capabilities, report_issues)
-        utils.coerce_list_values(context, self, self.relationships, report_issues)
+        utils.coerce_list_values(context, self, self.outbound_relationships, report_issues)
 
     def dump(self, context):
-        console.puts('Node: %s' % context.style.node(self.id))
+        console.puts('Node: {0}'.format(context.style.node(self.name)))
         with context.style.indent:
-            console.puts('Template: %s' % context.style.node(self.template_name))
-            console.puts('Type: %s' % context.style.type(self.type_name))
+            console.puts('Template: {0}'.format(context.style.node(self.template_name)))
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
             utils.dump_parameters(context, self.properties)
             utils.dump_interfaces(context, self.interfaces)
             utils.dump_dict_values(context, self.artifacts, 'Artifacts')
             utils.dump_dict_values(context, self.capabilities, 'Capabilities')
-            utils.dump_list_values(context, self.relationships, 'Relationships')
+            utils.dump_list_values(context, self.outbound_relationships, 'Relationships')
 
 
-class GroupBase(InstanceModelMixin):
+class GroupBase(_InstanceModelMixin):
     """
     An instance of a :class:`GroupTemplate`.
 
-    Properties:
-
-    * :code:`id`: Unique ID (prefixed with the template name)
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`template_name`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`interfaces`: Dict of :class:`Interface`
-    * :code:`member_node_ids`: Must be represented in the :class:`ServiceInstance`
-    * :code:`member_group_ids`: Must be represented in the :class:`ServiceInstance`
+    :ivar name: Unique ID (prefixed with the template name)
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar template_name: Must be represented in the :class:`ServiceTemplate`
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar interfaces: Dict of :class:`Interface`
+    :ivar member_node_ids: Must be represented in the :class:`ServiceInstance`
+    :ivar member_group_ids: Must be represented in the :class:`ServiceInstance`
     """
 
     __tablename__ = 'group'
@@ -496,40 +562,36 @@ class GroupBase(InstanceModelMixin):
     @property
     def as_raw(self):
         return collections.OrderedDict((
-            ('id', self.id),
+            ('name', self.name),
             ('type_name', self.type_name),
             ('template_name', self.template_name),
             ('properties', formatting.as_raw_dict(self.properties)),
             ('interfaces', formatting.as_raw_list(self.interfaces)),
-            ('policies', formatting.as_raw_list(self.policies)),
             ('member_node_ids', self.member_node_ids),
             ('member_group_ids', self.member_group_ids)))
 
     def validate(self, context):
         if context.modeling.group_types.get_descendant(self.type_name) is None:
-            context.validation.report('group "%s" has an unknown type: %s'
-                                      % (self.name,  # pylint: disable=no-member
-                                         # TODO fix self.name reference
-                                         formatting.safe_repr(self.type_name)),
+            context.validation.report('group "{0}" has an unknown type: {1}'.format(
+                                        self.name,  # pylint: disable=no-member
+                                        # TODO fix self.name reference
+                                        formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
         utils.validate_dict_values(context, self.interfaces)
-        utils.validate_dict_values(context, self.policies)
 
     def coerce_values(self, context, container, report_issues):
         utils.coerce_dict_values(context, container, self.properties, report_issues)
         utils.coerce_dict_values(context, container, self.interfaces, report_issues)
-        utils.coerce_dict_values(context, container, self.policies, report_issues)
 
     def dump(self, context):
-        console.puts('Group: %s' % context.style.node(self.id))
+        console.puts('Group: {0}'.format(context.style.node(self.name)))
         with context.style.indent:
-            console.puts('Type: %s' % context.style.type(self.type_name))
-            console.puts('Template: %s' % context.style.type(self.template_name))
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
+            console.puts('Template: {0}'.format(context.style.type(self.template_name)))
             utils.dump_parameters(context, self.properties)
             utils.dump_interfaces(context, self.interfaces)
-            utils.dump_dict_values(context, self.policies, 'Policies')
             if self.member_node_ids:
                 console.puts('Member nodes:')
                 with context.style.indent:
@@ -537,17 +599,15 @@ class GroupBase(InstanceModelMixin):
                         console.puts(context.style.node(node_id))
 
 
-class PolicyBase(InstanceModelMixin):
+class PolicyBase(_InstanceModelMixin):
     """
     An instance of a :class:`PolicyTemplate`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`target_node_ids`: Must be represented in the :class:`ServiceInstance`
-    * :code:`target_group_ids`: Must be represented in the :class:`ServiceInstance`
+    :ivar name: Name
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar target_node_ids: Must be represented in the :class:`ServiceInstance`
+    :ivar target_group_ids: Must be represented in the :class:`ServiceInstance`
     """
 
     __tablename__ = 'policy'
@@ -583,8 +643,8 @@ class PolicyBase(InstanceModelMixin):
 
     def validate(self, context):
         if context.modeling.policy_types.get_descendant(self.type_name) is None:
-            context.validation.report('policy "%s" has an unknown type: %s'
-                                      % (self.name, utils.safe_repr(self.type_name)),
+            context.validation.report('policy "{0}" has an unknown type: {1}'.format(
+                                        self.name, formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
@@ -593,9 +653,9 @@ class PolicyBase(InstanceModelMixin):
         utils.coerce_dict_values(context, container, self.properties, report_issues)
 
     def dump(self, context):
-        console.puts('Policy: %s' % context.style.node(self.name))
+        console.puts('Policy: {0}'.format(context.style.node(self.name)))
         with context.style.indent:
-            console.puts('Type: %s' % context.style.type(self.type_name))
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
             utils.dump_parameters(context, self.properties)
             if self.target_node_ids:
                 console.puts('Target nodes:')
@@ -609,14 +669,12 @@ class PolicyBase(InstanceModelMixin):
                         console.puts(context.style.node(group_id))
 
 
-class SubstitutionBase(InstanceModelMixin):
+class SubstitutionBase(_InstanceModelMixin):
     """
     An instance of a :class:`SubstitutionTemplate`.
 
-    Properties:
-
-    * :code:`node_type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`mappings`: Dict of :class:` SubstitutionMapping`
+    :ivar node_type_name: Must be represented in the :class:`ModelingContext`
+    :ivar mappings: Dict of :class:` SubstitutionMapping`
     """
 
     __tablename__ = 'substitution'
@@ -635,41 +693,35 @@ class SubstitutionBase(InstanceModelMixin):
     def as_raw(self):
         return collections.OrderedDict((
             ('node_type_name', self.node_type_name),
-            ('capabilities', formatting.as_raw_list(self.capabilities)),
-            ('requirements', formatting.as_raw_list(self.requirements))))
+            ('mappings', formatting.as_raw_dict(self.mappings))))
 
     def validate(self, context):
         if context.modeling.node_types.get_descendant(self.node_type_name) is None:
-            context.validation.report('substitution "%s" has an unknown type: %s'
-                                      % (self.name,  # pylint: disable=no-member
-                                         # TODO fix self.name reference
-                                         formatting.safe_repr(self.node_type_name)),
+            context.validation.report('substitution "{0}" has an unknown type: {1}'.format(
+                                        self.name,  # pylint: disable=no-member
+                                        # TODO fix self.name reference
+                                        formatting.safe_repr(self.node_type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
-        utils.validate_dict_values(context, self.capabilities)
-        utils.validate_dict_values(context, self.requirements)
+        utils.validate_dict_values(context, self.mappings)
 
     def coerce_values(self, context, container, report_issues):
-        utils.coerce_dict_values(context, container, self.capabilities, report_issues)
-        utils.coerce_dict_values(context, container, self.requirements, report_issues)
+        utils.coerce_dict_values(context, container, self.mappings, report_issues)
 
     def dump(self, context):
         console.puts('Substitution:')
         with context.style.indent:
-            console.puts('Node type: %s' % context.style.type(self.node_type_name))
-            utils.dump_dict_values(context, self.capabilities, 'Capability mappings')
-            utils.dump_dict_values(context, self.requirements, 'Requirement mappings')
+            console.puts('Node type: {0}'.format(context.style.type(self.node_type_name)))
+            utils.dump_dict_values(context, self.mappings, 'Mappings')
 
 
-class SubstitutionMappingBase(InstanceModelMixin):
+class SubstitutionMappingBase(_InstanceModelMixin):
     """
     An instance of a :class:`MappingTemplate`.
 
-    Properties:
-
-    * :code:`mapped_name`: Exposed capability or requirement name
-    * :code:`node_id`: Must be represented in the :class:`ServiceInstance`
-    * :code:`name`: Name of capability or requirement at the node
+    :ivar mapped_name: Exposed capability or requirement name
+    :ivar node_id: Must be represented in the :class:`ServiceInstance`
+    :ivar name: Name of capability or requirement at the node
     """
 
     __tablename__ = 'substitution_mapping'
@@ -695,28 +747,26 @@ class SubstitutionMappingBase(InstanceModelMixin):
             ('name', self.name)))
 
     def dump(self, context):
-        console.puts('%s -> %s.%s'
-                     % (context.style.node(self.mapped_name),
+        console.puts('{0} -> {1}.{2}'.format(
+                        context.style.node(self.mapped_name),
                         context.style.node(self.node_id),
                         context.style.node(self.name)))
 
 
-class RelationshipBase(InstanceModelMixin):
+class RelationshipBase(_InstanceModelMixin):
     """
     Connects :class:`Node` to another node.
 
     An instance of a :class:`RelationshipTemplate`.
 
-    Properties:
-
-    * :code:`name`: Name (usually the name of the requirement at the source node template)
-    * :code:`source_requirement_index`: Must be represented in the source node template
-    * :code:`target_node_id`: Must be represented in the :class:`ServiceInstance`
-    * :code:`target_capability_name`: Matches the capability at the target node
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`template_name`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`interfaces`: Dict of :class:`Interface`
+    :ivar name: Name (usually the name of the requirement at the source node template)
+    :ivar source_requirement_index: Must be represented in the source node template
+    :ivar target_node_id: Must be represented in the :class:`ServiceInstance`
+    :ivar target_capability_name: Matches the capability at the target node
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar template_name: Must be represented in the :class:`ServiceTemplate`
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar interfaces: Dict of :class:`Interface`
     """
 
     __tablename__ = 'relationship'
@@ -773,9 +823,9 @@ class RelationshipBase(InstanceModelMixin):
     def validate(self, context):
         if self.type_name:
             if context.modeling.relationship_types.get_descendant(self.type_name) is None:
-                context.validation.report('relationship "%s" has an unknown type: %s'
-                                          % (self.name,
-                                             formatting.safe_repr(self.type_name)),
+                context.validation.report('relationship "{0}" has an unknown type: {1}'.format(
+                                            self.name,
+                                            formatting.safe_repr(self.type_name)),
                                           level=validation.Issue.BETWEEN_TYPES)
         utils.validate_dict_values(context, self.properties)
         utils.validate_dict_values(context, self.interfaces)
@@ -787,38 +837,38 @@ class RelationshipBase(InstanceModelMixin):
     def dump(self, context):
         if self.name:
             if self.source_requirement_index is not None:
-                console.puts('%s (%d) ->' % (
-                    context.style.node(self.name),
-                    self.source_requirement_index))
+                console.puts('{0} ({1:d}) ->'.format(
+                                context.style.node(self.name),
+                                self.source_requirement_index))
             else:
-                console.puts('%s ->' % context.style.node(self.name))
+                console.puts('{0} ->'.format(context.style.node(self.name)))
         else:
             console.puts('->')
         with context.style.indent:
-            console.puts('Node: %s' % context.style.node(self.target_node_id))
+            console.puts('Node: {0}'.format(context.style.node(self.target_node_id)))
             if self.target_capability_name is not None:
-                console.puts('Capability: %s' % context.style.node(self.target_capability_name))
+                console.puts('Capability: {0}'.format(
+                    context.style.node(self.target_capability_name)))
             if self.type_name is not None:
-                console.puts('Relationship type: %s' % context.style.type(self.type_name))
+                console.puts('Relationship type: {0}'.format(context.style.type(self.type_name)))
             if self.template_name is not None:
-                console.puts('Relationship template: %s' % context.style.node(self.template_name))
+                console.puts('Relationship template: {0}'.format(
+                    context.style.node(self.template_name)))
             utils.dump_parameters(context, self.properties)
             utils.dump_interfaces(context, self.interfaces, 'Interfaces')
 
 
-class CapabilityBase(InstanceModelMixin):
+class CapabilityBase(_InstanceModelMixin):
     """
     A capability of a :class:`Node`.
 
     An instance of a :class:`CapabilityTemplate`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`min_occurrences`: Minimum number of requirement matches required
-    * :code:`max_occurrences`: Maximum number of requirement matches allowed
-    * :code:`properties`: Dict of :class:`Parameter`
+    :ivar name: Name
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar min_occurrences: Minimum number of requirement matches required
+    :ivar max_occurrences: Maximum number of requirement matches allowed
+    :ivar properties: Dict of :class:`Parameter`
     """
 
     __tablename__ = 'capability'
@@ -865,9 +915,9 @@ class CapabilityBase(InstanceModelMixin):
 
     def validate(self, context):
         if context.modeling.capability_types.get_descendant(self.type_name) is None:
-            context.validation.report('capability "%s" has an unknown type: %s'
-                                      % (self.name,
-                                         formatting.safe_repr(self.type_name)),
+            context.validation.report('capability "{0}" has an unknown type: {1}'.format(
+                                        self.name,
+                                        formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
@@ -878,28 +928,26 @@ class CapabilityBase(InstanceModelMixin):
     def dump(self, context):
         console.puts(context.style.node(self.name))
         with context.style.indent:
-            console.puts('Type: %s' % context.style.type(self.type_name))
-            console.puts('Occurrences: %s (%s%s)'
-                         % (self.occurrences,
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
+            console.puts('Occurrences: {0:d} ({1:d}{2})'.format(
+                            self.occurrences,
                             self.min_occurrences or 0,
-                            (' to %d' % self.max_occurrences)
-                            if self.max_occurrences is not None
-                            else ' or more'))
+                            ' to {0:d}'.format(self.max_occurrences)
+                                if self.max_occurrences is not None
+                                else ' or more'))
             utils.dump_parameters(context, self.properties)
 
 
-class InterfaceBase(InstanceModelMixin):
+class InterfaceBase(_InstanceModelMixin):
     """
     A typed set of :class:`Operation`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`edge`: Edge
-    * :code:`inputs`: Dict of :class:`Parameter`
-    * :code:`operations`: Dict of :class:`Operation`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar edge: Edge
+    :ivar inputs: Dict of :class:`Parameter`
+    :ivar operations: Dict of :class:`Operation`
     """
 
     __tablename__ = 'interface'
@@ -949,9 +997,9 @@ class InterfaceBase(InstanceModelMixin):
     def validate(self, context):
         if self.type_name:
             if context.modeling.interface_types.get_descendant(self.type_name) is None:
-                context.validation.report('interface "%s" has an unknown type: %s'
-                                          % (self.name,
-                                             formatting.safe_repr(self.type_name)),
+                context.validation.report('interface "{0}" has an unknown type: {1}'.format(
+                                            self.name,
+                                            formatting.safe_repr(self.type_name)),
                                           level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.inputs)
@@ -966,25 +1014,23 @@ class InterfaceBase(InstanceModelMixin):
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Interface type: %s' % context.style.type(self.type_name))
+            console.puts('Interface type: {0}'.format(context.style.type(self.type_name)))
             utils.dump_parameters(context, self.inputs, 'Inputs')
             utils.dump_dict_values(context, self.operations, 'Operations')
 
 
-class OperationBase(InstanceModelMixin):
+class OperationBase(_InstanceModelMixin):
     """
     An operation in a :class:`Interface`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`implementation`: Implementation string (interpreted by the orchestrator)
-    * :code:`dependencies`: List of strings (interpreted by the orchestrator)
-    * :code:`executor`: Executor string (interpreted by the orchestrator)
-    * :code:`max_retries`: Maximum number of retries allowed in case of failure
-    * :code:`retry_interval`: Interval between retries
-    * :code:`inputs`: Dict of :class:`Parameter`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar implementation: Implementation string (interpreted by the orchestrator)
+    :ivar dependencies: List of strings (interpreted by the orchestrator)
+    :ivar executor: Executor string (interpreted by the orchestrator)
+    :ivar max_retries: Maximum number of retries allowed in case of failure
+    :ivar retry_interval: Interval between retries
+    :ivar inputs: Dict of :class:`Parameter`
     """
 
     __tablename__ = 'operation'
@@ -997,8 +1043,8 @@ class OperationBase(InstanceModelMixin):
     implementation = Column(Text)
     dependencies = Column(modeling_type.StrictList(item_cls=basestring))
     executor = Column(Text)
-    max_retries = Column(Integer, default=None)
-    retry_interval = Column(Integer, default=None)
+    max_retries = Column(Integer)
+    retry_interval = Column(Integer)
 
     @declared_attr
     def inputs(cls):
@@ -1044,34 +1090,34 @@ class OperationBase(InstanceModelMixin):
             console.puts(context.style.meta(self.description))
         with context.style.indent:
             if self.implementation is not None:
-                console.puts('Implementation: %s' % context.style.literal(self.implementation))
+                console.puts('Implementation: {0}'.format(
+                    context.style.literal(self.implementation)))
             if self.dependencies:
                 console.puts(
-                    'Dependencies: %s'
-                    % ', '.join((str(context.style.literal(v)) for v in self.dependencies)))
+                    'Dependencies: {0}'.format(
+                        ', '.join((str(context.style.literal(v)) for v in self.dependencies))))
             if self.executor is not None:
-                console.puts('Executor: %s' % context.style.literal(self.executor))
+                console.puts('Executor: {0}'.format(context.style.literal(self.executor)))
             if self.max_retries is not None:
-                console.puts('Max retries: %s' % context.style.literal(self.max_retries))
+                console.puts('Max retries: {0}'.format(context.style.literal(self.max_retries)))
             if self.retry_interval is not None:
-                console.puts('Retry interval: %s' % context.style.literal(self.retry_interval))
+                console.puts('Retry interval: {0}'.format(
+                    context.style.literal(self.retry_interval)))
             utils.dump_parameters(context, self.inputs, 'Inputs')
 
 
-class ArtifactBase(InstanceModelMixin):
+class ArtifactBase(_InstanceModelMixin):
     """
     A file associated with a :class:`Node`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`source_path`: Source path (CSAR or repository)
-    * :code:`target_path`: Path at destination machine
-    * :code:`repository_url`: Repository URL
-    * :code:`repository_credential`: Dict of string
-    * :code:`properties`: Dict of :class:`Parameter`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar source_path: Source path (CSAR or repository)
+    :ivar target_path: Path at destination machine
+    :ivar repository_url: Repository URL
+    :ivar repository_credential: Dict of string
+    :ivar properties: Dict of :class:`Parameter`
     """
 
     __tablename__ = 'artifact'
@@ -1112,9 +1158,9 @@ class ArtifactBase(InstanceModelMixin):
 
     def validate(self, context):
         if context.modeling.artifact_types.get_descendant(self.type_name) is None:
-            context.validation.report('artifact "%s" has an unknown type: %s'
-                                      % (self.name,
-                                         formatting.safe_repr(self.type_name)),
+            context.validation.report('artifact "{0}" has an unknown type: {1}'.format(
+                                        self.name,
+                                        formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
         utils.validate_dict_values(context, self.properties)
 
@@ -1126,13 +1172,14 @@ class ArtifactBase(InstanceModelMixin):
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Artifact type: %s' % context.style.type(self.type_name))
-            console.puts('Source path: %s' % context.style.literal(self.source_path))
+            console.puts('Artifact type: {0}'.format(context.style.type(self.type_name)))
+            console.puts('Source path: {0}'.format(context.style.literal(self.source_path)))
             if self.target_path is not None:
-                console.puts('Target path: %s' % context.style.literal(self.target_path))
+                console.puts('Target path: {0}'.format(context.style.literal(self.target_path)))
             if self.repository_url is not None:
-                console.puts('Repository URL: %s' % context.style.literal(self.repository_url))
+                console.puts('Repository URL: {0}'.format(
+                    context.style.literal(self.repository_url)))
             if self.repository_credential:
-                console.puts('Repository credential: %s'
-                             % context.style.literal(self.repository_credential))
+                console.puts('Repository credential: {0}'.format(
+                    context.style.literal(self.repository_credential)))
             utils.dump_parameters(context, self.properties)

http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/33a4ee72/aria/modeling/service_template_models.py
----------------------------------------------------------------------
diff --git a/aria/modeling/service_template_models.py b/aria/modeling/service_template_models.py
index d7398ec..5f5e50d 100644
--- a/aria/modeling/service_template_models.py
+++ b/aria/modeling/service_template_models.py
@@ -30,7 +30,7 @@ from ..storage import exceptions
 from ..parser import validation
 from ..parser.modeling import utils as parser_utils
 from ..utils import collections, formatting, console
-from .service_models import InstanceModelMixin
+from .service_models import _InstanceModelMixin
 from . import (
     utils,
     type as modeling_type
@@ -40,7 +40,7 @@ from . import (
 
 
 
-class TemplateModelMixin(InstanceModelMixin):
+class _TemplateModelMixin(_InstanceModelMixin):
     """
     Mixin for :class:`ServiceTemplate` models.
 
@@ -51,25 +51,23 @@ class TemplateModelMixin(InstanceModelMixin):
         raise NotImplementedError
 
 
-class ServiceTemplateBase(TemplateModelMixin):
+class ServiceTemplateBase(_TemplateModelMixin):
     """
     A service template is a normalized blueprint from which :class:`ServiceInstance` instances can
     be created.
 
-    It is usually created by various DSL parsers, such as ARIA's TOSCA extension. However, it
-    can also be created programmatically.
-
-    Properties:
-
-    * :code:`description`: Human-readable description
-    * :code:`meta_data`: Dict of :class:`Metadata`
-    * :code:`node_templates`: List of :class:`NodeTemplate`
-    * :code:`group_templates`: List of :class:`GroupTemplate`
-    * :code:`policy_templates`: List of :class:`PolicyTemplate`
-    * :code:`substitution_template`: :class:`SubstituionTemplate`
-    * :code:`inputs`: Dict of :class:`Parameter`
-    * :code:`outputs`: Dict of :class:`Parameter`
-    * :code:`operation_templates`: Dict of :class:`OperationTemplate`
+    It is usually created by various DSL parsers, such as ARIA's TOSCA extension. However, it can
+    also be created programmatically.
+
+    :ivar description: Human-readable description
+    :ivar meta_data: Dict of :class:`Metadata`
+    :ivar node_templates: List of :class:`NodeTemplate`
+    :ivar group_templates: List of :class:`GroupTemplate`
+    :ivar policy_templates: List of :class:`PolicyTemplate`
+    :ivar substitution_template: :class:`SubstituionTemplate`
+    :ivar inputs: Dict of :class:`Parameter`
+    :ivar outputs: Dict of :class:`Parameter`
+    :ivar operation_templates: Dict of :class:`OperationTemplate`
     """
 
     __tablename__ = 'service_template'
@@ -175,7 +173,7 @@ class ServiceTemplateBase(TemplateModelMixin):
 
         for name, the_input in context.modeling.inputs.iteritems():
             if name not in service.inputs:
-                context.validation.report('input "%s" is not supported' % name)
+                context.validation.report('input "{0}" is not supported'.format(name))
             else:
                 service.inputs[name].value = the_input
 
@@ -206,7 +204,7 @@ class ServiceTemplateBase(TemplateModelMixin):
     def dump(self, context):
         if self.description is not None:
             console.puts(context.style.meta(self.description))
-        dump_parameters(context, self.meta_data, 'Metadata')
+        utils.dump_parameters(context, self.meta_data, 'Metadata')
 
         for node_template in self.node_templates:
             node_template.dump(context)
@@ -216,29 +214,27 @@ class ServiceTemplateBase(TemplateModelMixin):
             policy_template.dump(context)
         if self.substitution_template is not None:
             self.substitution_template.dump(context)
-        dump_parameters(context, self.inputs, 'Inputs')
-        dump_parameters(context, self.outputs, 'Outputs')
+        utils.dump_parameters(context, self.inputs, 'Inputs')
+        utils.dump_parameters(context, self.outputs, 'Outputs')
         utils.dump_dict_values(context, self.operation_templates, 'Operation templates')
 
 
-class NodeTemplateBase(TemplateModelMixin):
+class NodeTemplateBase(_TemplateModelMixin):
     """
     A template for creating zero or more :class:`Node` instances.
 
-    Properties:
-
-    * :code:`name`: Name (will be used as a prefix for node IDs)
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`default_instances`: Default number nodes that will appear in the deployment plan
-    * :code:`min_instances`: Minimum number nodes that will appear in the deployment plan
-    * :code:`max_instances`: Maximum number nodes that will appear in the deployment plan
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`interface_templates`: Dict of :class:`InterfaceTemplate`
-    * :code:`artifact_templates`: Dict of :class:`ArtifactTemplate`
-    * :code:`capability_templates`: Dict of :class:`CapabilityTemplate`
-    * :code:`requirement_templates`: List of :class:`RequirementTemplate`
-    * :code:`target_node_template_constraints`: List of :class:`FunctionType`
+    :ivar name: Name (will be used as a prefix for node IDs)
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar default_instances: Default number nodes that will appear in the deployment plan
+    :ivar min_instances: Minimum number nodes that will appear in the deployment plan
+    :ivar max_instances: Maximum number nodes that will appear in the deployment plan
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar interface_templates: Dict of :class:`InterfaceTemplate`
+    :ivar artifact_templates: Dict of :class:`ArtifactTemplate`
+    :ivar capability_templates: Dict of :class:`CapabilityTemplate`
+    :ivar requirement_templates: List of :class:`RequirementTemplate`
+    :ivar target_node_template_constraints: List of :class:`FunctionType`
     """
 
     __tablename__ = 'node_template'
@@ -325,7 +321,9 @@ class NodeTemplateBase(TemplateModelMixin):
 
     def instantiate(self, context, *args, **kwargs):
         from . import model
-        node = model.Node(template_name=self.name,
+        name = context.modeling.generate_node_id(self.name) 
+        node = model.Node(name=name,
+                          template_name=self.name,
                           type_name=self.type_name)
         utils.instantiate_dict(context, node, node.properties, self.properties)
         utils.instantiate_dict(context, node, node.interfaces, self.interface_templates)
@@ -335,9 +333,9 @@ class NodeTemplateBase(TemplateModelMixin):
 
     def validate(self, context):
         if context.modeling.node_types.get_descendant(self.type_name) is None:
-            context.validation.report('node template "%s" has an unknown type: %s'
-                                      % (self.name,
-                                         formatting.safe_repr(self.type_name)),
+            context.validation.report('node template "{0}" has an unknown type: {1}'.format(
+                                        self.name,
+                                        formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
@@ -354,40 +352,38 @@ class NodeTemplateBase(TemplateModelMixin):
         utils.coerce_list_values(context, self, self.requirement_templates, report_issues)
 
     def dump(self, context):
-        console.puts('Node template: %s' % context.style.node(self.name))
+        console.puts('Node template: {0}'.format(context.style.node(self.name)))
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Type: %s' % context.style.type(self.type_name))
-            console.puts('Instances: %d (%d%s)'
-                         % (self.default_instances,
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
+            console.puts('Instances: {0:d} ({1:d}{2})'.format(
+                            self.default_instances,
                             self.min_instances,
-                            (' to %d' % self.max_instances
-                             if self.max_instances is not None
-                             else ' or more')))
-            dump_parameters(context, self.properties)
+                            ' to {0:d}'.format(self.max_instances)
+                                if self.max_instances is not None
+                                else ' or more'))
+            utils.dump_parameters(context, self.properties)
             utils.dump_interfaces(context, self.interface_templates)
-            utils.dump_dict_values(context, self.artifact_templates, 'Artifact tempaltes')
+            utils.dump_dict_values(context, self.artifact_templates, 'Artifact templates')
             utils.dump_dict_values(context, self.capability_templates, 'Capability templates')
             utils.dump_list_values(context, self.requirement_templates, 'Requirement templates')
 
 
-class GroupTemplateBase(TemplateModelMixin):
+class GroupTemplateBase(_TemplateModelMixin):
     """
     A template for creating zero or more :class:`Group` instances.
 
     Groups are logical containers for zero or more nodes that allow applying zero or more
     :class:`GroupPolicy` instances to the nodes together.
 
-    Properties:
-
-    * :code:`name`: Name (will be used as a prefix for group IDs)
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`interface_templates`: Dict of :class:`InterfaceTemplate`
-    * :code:`member_node_template_names`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`member_group_template_names`: Must be represented in the :class:`ServiceTemplate`
+    :ivar name: Name (will be used as a prefix for group IDs)
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar interface_templates: Dict of :class:`InterfaceTemplate`
+    :ivar member_node_template_names: Must be represented in the :class:`ServiceTemplate`
+    :ivar member_group_template_names: Must be represented in the :class:`ServiceTemplate`
     """
 
     __tablename__ = 'group_template'
@@ -448,8 +444,8 @@ class GroupTemplateBase(TemplateModelMixin):
 
     def validate(self, context):
         if context.modeling.group_types.get_descendant(self.type_name) is None:
-            context.validation.report('group template "%s" has an unknown type: %s'
-                                      % (self.name, formatting.safe_repr(self.type_name)),
+            context.validation.report('group template "{0}" has an unknown type: {1}'.format(
+                                        self.name, formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
@@ -460,32 +456,30 @@ class GroupTemplateBase(TemplateModelMixin):
         utils.coerce_dict_values(context, self, self.interface_templates, report_issues)
 
     def dump(self, context):
-        console.puts('Group template: %s' % context.style.node(self.name))
+        console.puts('Group template: {0}'.format(context.style.node(self.name)))
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
             if self.type_name:
-                console.puts('Type: %s' % context.style.type(self.type_name))
-            dump_parameters(context, self.properties)
+                console.puts('Type: {0}'.format(context.style.type(self.type_name)))
+            utils.dump_parameters(context, self.properties)
             utils.dump_interfaces(context, self.interface_templates)
             if self.member_node_template_names:
-                console.puts('Member node templates: %s' % ', '.join(
-                    (str(context.style.node(v)) for v in self.member_node_template_names)))
+                console.puts('Member node templates: {0}'.format(', '.join(
+                    (str(context.style.node(v)) for v in self.member_node_template_names))))
 
 
-class PolicyTemplateBase(TemplateModelMixin):
+class PolicyTemplateBase(_TemplateModelMixin):
     """
     Policies can be applied to zero or more :class:`NodeTemplate` or :class:`GroupTemplate`
     instances.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`target_node_template_names`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`target_group_template_names`: Must be represented in the :class:`ServiceTemplate`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar target_node_template_names: Must be represented in the :class:`ServiceTemplate`
+    :ivar target_group_template_names: Must be represented in the :class:`ServiceTemplate`
     """
     __tablename__ = 'policy_template'
 
@@ -539,8 +533,8 @@ class PolicyTemplateBase(TemplateModelMixin):
 
     def validate(self, context):
         if context.modeling.policy_types.get_descendant(self.type_name) is None:
-            context.validation.report('policy template "%s" has an unknown type: %s'
-                                      % (self.name, formatting.safe_repr(self.type_name)),
+            context.validation.report('policy template "{0}" has an unknown type: {1}'.format(
+                                        self.name, formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
@@ -549,28 +543,26 @@ class PolicyTemplateBase(TemplateModelMixin):
         utils.coerce_dict_values(context, self, self.properties, report_issues)
 
     def dump(self, context):
-        console.puts('Policy template: %s' % context.style.node(self.name))
+        console.puts('Policy template: {0}'.format(context.style.node(self.name)))
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Type: %s' % context.style.type(self.type_name))
-            dump_parameters(context, self.properties)
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
+            utils.dump_parameters(context, self.properties)
             if self.target_node_template_names:
-                console.puts('Target node templates: %s' % ', '.join(
-                    (str(context.style.node(v)) for v in self.target_node_template_names)))
+                console.puts('Target node templates: {0}'.format(', '.join(
+                    (str(context.style.node(v)) for v in self.target_node_template_names))))
             if self.target_group_template_names:
-                console.puts('Target group templates: %s' % ', '.join(
-                    (str(context.style.node(v)) for v in self.target_group_template_names)))
+                console.puts('Target group templates: {0}'.format(', '.join(
+                    (str(context.style.node(v)) for v in self.target_group_template_names))))
 
 
-class SubstitutionTemplateBase(TemplateModelMixin):
+class SubstitutionTemplateBase(_TemplateModelMixin):
     """
     Used to substitute a single node for the entire deployment.
 
-    Properties:
-
-    * :code:`node_type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`mappings`: Dict of :class:` SubstitutionTemplateMapping`
+    :ivar node_type_name: Must be represented in the :class:`ModelingContext`
+    :ivar mappings: Dict of :class:` SubstitutionTemplateMapping`
     """
 
     __tablename__ = 'substitution_template'
@@ -585,19 +577,18 @@ class SubstitutionTemplateBase(TemplateModelMixin):
     def as_raw(self):
         return collections.OrderedDict((
             ('node_type_name', self.node_type_name),
-            ('mappings', formatting.as_raw_list(self.mappings))))
+            ('mappings', formatting.as_raw_dict(self.mappings))))
 
     def instantiate(self, context, container):
         from . import model
         substitution = model.Substitution(node_type_name=self.node_type_name)
-        utils.instantiate_dict(context, container, substitution.mappings,
-                               self.mappings)
+        utils.instantiate_dict(context, container, substitution.mappings, self.mappings)
         return substitution
 
     def validate(self, context):
         if context.modeling.node_types.get_descendant(self.node_type_name) is None:
-            context.validation.report('substitution template has an unknown type: %s'
-                                      % formatting.safe_repr(self.node_type_name),
+            context.validation.report('substitution template has an unknown type: {0}'.format(
+                                        formatting.safe_repr(self.node_type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.mappings)
@@ -608,20 +599,17 @@ class SubstitutionTemplateBase(TemplateModelMixin):
     def dump(self, context):
         console.puts('Substitution template:')
         with context.style.indent:
-            console.puts('Node type: %s' % context.style.type(self.node_type_name))
-            utils.dump_dict_values(context, self.mappings,
-                                   'Mappings')
+            console.puts('Node type: {0}'.format(context.style.type(self.node_type_name)))
+            utils.dump_dict_values(context, self.mappings, 'Mappings')
 
 
-class SubstitutionTemplateMappingBase(TemplateModelMixin):
+class SubstitutionTemplateMappingBase(_TemplateModelMixin):
     """
     Used by :class:`SubstitutionTemplate` to map a capability or a requirement to a node.
 
-    Properties:
-
-    * :code:`mapped_name`: Exposed capability or requirement name
-    * :code:`node_template_name`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`name`: Name of capability or requirement at the node template
+    :ivar mapped_name: Exposed capability or requirement name
+    :ivar node_template_name: Must be represented in the :class:`ServiceTemplate`
+    :ivar name: Name of capability or requirement at the node template
     """
 
     __tablename__ = 'substitution_template_mapping'
@@ -651,30 +639,30 @@ class SubstitutionTemplateMappingBase(TemplateModelMixin):
         nodes = context.modeling.instance.find_nodes(self.node_template_name)
         if len(nodes) == 0:
             context.validation.report(
-                'mapping "%s" refers to node template "%s" but there are no '
-                'node instances' % (self.mapped_name,
-                                    self.node_template_name),
+                'mapping "{0}" refers to node template "{1}" but there are no '
+                'node instances'.format(self.mapped_name, self.node_template_name),
                 level=validation.Issue.BETWEEN_INSTANCES)
             return None
         return model.SubstitutionMapping(mapped_name=self.mapped_name,
-                                         node_id=nodes[0].id,
+                                         node_id=nodes[0].name,
                                          name=self.name)
 
     def validate(self, context):
         if self.node_template_name not in (v.name for v in context.modeling.model.node_templates):
-            context.validation.report('mapping "%s" refers to an unknown node template: %s'
-                                      % (
+            context.validation.report('mapping "{0}" refers to an unknown node template: {1}' \
+                                      .format(
                                           self.mapped_name,
                                           formatting.safe_repr(self.node_template_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
     def dump(self, context):
-        console.puts('%s -> %s.%s' % (context.style.node(self.mapped_name),
-                                      context.style.node(self.node_template_name),
-                                      context.style.node(self.name)))
+        console.puts('{0} -> {1}.{2}'.format(
+            context.style.node(self.mapped_name),
+            context.style.node(self.node_template_name),
+            context.style.node(self.name)))
 
 
-class RequirementTemplateBase(TemplateModelMixin):
+class RequirementTemplateBase(_TemplateModelMixin):
     """
     A requirement for a :class:`NodeTemplate`. During instantiation will be matched with a
     capability of another
@@ -683,27 +671,29 @@ class RequirementTemplateBase(TemplateModelMixin):
     Requirements may optionally contain a :class:`RelationshipTemplate` that will be created between
     the nodes.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`target_node_type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`target_node_template_name`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`target_node_template_constraints`: List of :class:`FunctionType`
-    * :code:`target_capability_type_name`: Type of capability in target node
-    * :code:`target_capability_name`: Name of capability in target node
-    * :code:`relationship_template`: :class:`RelationshipTemplate`
+    :ivar name: Name
+    :ivar target_node_type_name: Must be represented in the :class:`ModelingContext`
+    :ivar target_node_template_name: Must be represented in the :class:`ServiceTemplate`
+    :ivar target_node_template_constraints: List of :class:`FunctionType`
+    :ivar target_capability_type_name: Type of capability in target node
+    :ivar target_capability_name: Name of capability in target node
+    :ivar relationship_template: :class:`RelationshipTemplate`
     """
 
     __tablename__ = 'requirement_template'
 
-    __private_fields__ = ['node_template_fk']
+    __private_fields__ = ['node_template_fk',
+                          'relationship_template_fk']
 
     target_node_type_name = Column(Text)
     target_node_template_name = Column(Text)
     target_node_template_constraints = Column(modeling_type.StrictList(FunctionType))
     target_capability_type_name = Column(Text)
     target_capability_name = Column(Text)
-    relationship_template = Column(Text) # TODO
+
+    @declared_attr
+    def relationship_template(cls):
+        return cls.one_to_one_relationship('relationship_template')
 
     # region foreign keys
 
@@ -711,6 +701,10 @@ class RequirementTemplateBase(TemplateModelMixin):
     def node_template_fk(cls):
         return cls.foreign_key('node_template', nullable=True)
 
+    @declared_attr
+    def relationship_template_fk(cls):
+        return cls.foreign_key('relationship_template', nullable=True)
+
     # endregion
 
     def instantiate(self, context, container):
@@ -723,11 +717,11 @@ class RequirementTemplateBase(TemplateModelMixin):
                 context.modeling.model.get_node_template(self.target_node_template_name)
 
             if not source_node_template.is_target_node_valid(target_node_template):
-                context.validation.report('requirement "%s" of node template "%s" is for node '
-                                          'template "%s" but it does not match constraints'
-                                          % (self.name,
-                                             self.target_node_template_name,
-                                             source_node_template.name),
+                context.validation.report('requirement "{0}" of node template "{1}" is for node '
+                                          'template "{2}" but it does not match constraints'.format(
+                                              self.name,
+                                              self.target_node_template_name,
+                                              source_node_template.name),
                                           level=validation.Issue.BETWEEN_TYPES)
                 return None, None
 
@@ -787,15 +781,17 @@ class RequirementTemplateBase(TemplateModelMixin):
         capability_types = context.modeling.capability_types
         if self.target_node_type_name \
                 and node_types.get_descendant(self.target_node_type_name) is None:
-            context.validation.report('requirement "%s" refers to an unknown node type: %s'
-                                      % (self.name,
-                                         formatting.safe_repr(self.target_node_type_name)),
+            context.validation.report('requirement "{0}" refers to an unknown node type: {1}' \
+                                        .format(
+                                            self.name,
+                                            formatting.safe_repr(self.target_node_type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
         if self.target_capability_type_name and \
                 capability_types.get_descendant(self.target_capability_type_name is None):
-            context.validation.report('requirement "%s" refers to an unknown capability type: %s'
-                                      % (self.name,
-                                         formatting.safe_repr(self.target_capability_type_name)),
+            context.validation.report('requirement "{0}" refers to an unknown capability type: '
+                                      '{1}'.format(
+                                          self.name,
+                                          formatting.safe_repr(self.target_capability_type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
         if self.relationship_template:
             self.relationship_template.validate(context)
@@ -811,17 +807,17 @@ class RequirementTemplateBase(TemplateModelMixin):
             console.puts('Requirement:')
         with context.style.indent:
             if self.target_node_type_name is not None:
-                console.puts('Target node type: %s'
-                             % context.style.type(self.target_node_type_name))
+                console.puts('Target node type: {0}'.format(
+                    context.style.type(self.target_node_type_name)))
             elif self.target_node_template_name is not None:
-                console.puts('Target node template: %s'
-                             % context.style.node(self.target_node_template_name))
+                console.puts('Target node template: {0}'.format(
+                    context.style.node(self.target_node_template_name)))
             if self.target_capability_type_name is not None:
-                console.puts('Target capability type: %s'
-                             % context.style.type(self.target_capability_type_name))
+                console.puts('Target capability type: {0}'.format(
+                    context.style.type(self.target_capability_type_name)))
             elif self.target_capability_name is not None:
-                console.puts('Target capability name: %s'
-                             % context.style.node(self.target_capability_name))
+                console.puts('Target capability name: {0}'.format(
+                    context.style.node(self.target_capability_name)))
             if self.target_node_template_constraints:
                 console.puts('Target node template constraints:')
                 with context.style.indent:
@@ -833,23 +829,22 @@ class RequirementTemplateBase(TemplateModelMixin):
                     self.relationship_template.dump(context)
 
 
-class RelationshipTemplateBase(TemplateModelMixin):
+class RelationshipTemplateBase(_TemplateModelMixin):
     """
-    Optional addition to a :class:`Requirement` in :class:`NodeTemplate` that can be applied when
-    the requirement is matched with a capability.
-
-    Properties:
-
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`template_name`: Must be represented in the :class:`ServiceTemplate`
-    * :code:`description`: Description
-    * :code:`properties`: Dict of :class:`Parameter`
-    * :code:`interface_templates`: Dict of :class:`InterfaceTemplate`
+    Optional addition to a :class:`RequirementTemplate` in :class:`NodeTemplate` that can be applied
+    when the requirement is matched with a capability.
+
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar template_name: Must be represented in the :class:`ServiceTemplate`
+    :ivar description: Description
+    :ivar properties: Dict of :class:`Parameter`
+    :ivar interface_templates: Dict of :class:`InterfaceTemplate`
     """
 
     __tablename__ = 'relationship_template'
 
     type_name = Column(Text)
+    template_name = Column(Text)
     description = Column(Text)
 
     @declared_attr
@@ -909,20 +904,18 @@ class RelationshipTemplateBase(TemplateModelMixin):
             utils.dump_interfaces(context, self.interface_templates, 'Interface templates')
 
 
-class CapabilityTemplateBase(TemplateModelMixin):
+class CapabilityTemplateBase(_TemplateModelMixin):
     """
     A capability of a :class:`NodeTemplate`. Nodes expose zero or more capabilities that can be
     matched with :class:`Requirement` instances of other nodes.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`min_occurrences`: Minimum number of requirement matches required
-    * :code:`max_occurrences`: Maximum number of requirement matches allowed
-    * :code:`valid_source_node_type_names`: Must be represented in the :class:`ModelingContext`
-    * :code:`properties`: Dict of :class:`Parameter`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar min_occurrences: Minimum number of requirement matches required
+    :ivar max_occurrences: Maximum number of requirement matches allowed
+    :ivar valid_source_node_type_names: Must be represented in the :class:`ModelingContext`
+    :ivar properties: Dict of :class:`Parameter`
     """
 
     __tablename__ = 'capability_template'
@@ -997,8 +990,8 @@ class CapabilityTemplateBase(TemplateModelMixin):
 
     def validate(self, context):
         if context.modeling.capability_types.get_descendant(self.type_name) is None:
-            context.validation.report('capability "%s" refers to an unknown type: %s'
-                                      % (self.name, formatting.safe_repr(self.type)),  # pylint: disable=no-member
+            context.validation.report('capability "{0}" refers to an unknown type: {1}'.format(
+                                        self.name, formatting.safe_repr(self.type)),  # pylint: disable=no-member
                                       #  TODO fix self.type reference
                                       level=validation.Issue.BETWEEN_TYPES)
 
@@ -1012,29 +1005,29 @@ class CapabilityTemplateBase(TemplateModelMixin):
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Type: %s' % context.style.type(self.type_name))
+            console.puts('Type: {0}'.format(context.style.type(self.type_name)))
             console.puts(
-                'Occurrences: %d%s'
-                % (self.min_occurrences or 0, (' to %d' % self.max_occurrences)
-                   if self.max_occurrences is not None else ' or more'))
+                'Occurrences: {0:d}{1}'.format(
+                    self.min_occurrences or 0,
+                    ' to {0:d}'.format(self.max_occurrences)
+                        if self.max_occurrences is not None
+                        else ' or more'))
             if self.valid_source_node_type_names:
-                console.puts('Valid source node types: %s'
-                             % ', '.join((str(context.style.type(v))
-                                          for v in self.valid_source_node_type_names)))
-            dump_parameters(context, self.properties)
+                console.puts('Valid source node types: {0}'.format(
+                                ', '.join((str(context.style.type(v))
+                                           for v in self.valid_source_node_type_names))))
+            utils.dump_parameters(context, self.properties)
 
 
-class InterfaceTemplateBase(TemplateModelMixin):
+class InterfaceTemplateBase(_TemplateModelMixin):
     """
     A typed set of :class:`OperationTemplate`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`inputs`: Dict of :class:`Parameter`
-    * :code:`operation_templates`: Dict of :class:`OperationTemplate`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar inputs: Dict of :class:`Parameter`
+    :ivar operation_templates: Dict of :class:`OperationTemplate`
     """
 
     __tablename__ = 'interface_template'
@@ -1076,7 +1069,7 @@ class InterfaceTemplateBase(TemplateModelMixin):
             ('name', self.name),
             ('description', self.description),
             ('type_name', self.type_name),
-            ('inputs', formatting.as_raw_dict(self.properties)),  # pylint: disable=no-member
+            ('inputs', formatting.as_raw_dict(self.inputs)),  # pylint: disable=no-member
             # TODO fix self.properties reference
             ('operation_templates', formatting.as_raw_list(self.operation_templates))))
 
@@ -1092,8 +1085,8 @@ class InterfaceTemplateBase(TemplateModelMixin):
     def validate(self, context):
         if self.type_name:
             if context.modeling.interface_types.get_descendant(self.type_name) is None:
-                context.validation.report('interface "%s" has an unknown type: %s'
-                                          % (self.name, formatting.safe_repr(self.type_name)),
+                context.validation.report('interface "{0}" has an unknown type: {1}'.format(
+                                            self.name, formatting.safe_repr(self.type_name)),
                                           level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.inputs)
@@ -1108,25 +1101,23 @@ class InterfaceTemplateBase(TemplateModelMixin):
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Interface type: %s' % context.style.type(self.type_name))
-            dump_parameters(context, self.inputs, 'Inputs')
+            console.puts('Interface type: {0}'.format(context.style.type(self.type_name)))
+            utils.dump_parameters(context, self.inputs, 'Inputs')
             utils.dump_dict_values(context, self.operation_templates, 'Operation templates')
 
 
-class OperationTemplateBase(TemplateModelMixin):
+class OperationTemplateBase(_TemplateModelMixin):
     """
     An operation in a :class:`InterfaceTemplate`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`implementation`: Implementation string (interpreted by the orchestrator)
-    * :code:`dependencies`: List of strings (interpreted by the orchestrator)
-    * :code:`executor`: Executor string (interpreted by the orchestrator)
-    * :code:`max_retries`: Maximum number of retries allowed in case of failure
-    * :code:`retry_interval`: Interval between retries
-    * :code:`inputs`: Dict of :class:`Parameter`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar implementation: Implementation string (interpreted by the orchestrator)
+    :ivar dependencies: List of strings (interpreted by the orchestrator)
+    :ivar executor: Executor string (interpreted by the orchestrator)
+    :ivar max_retries: Maximum number of retries allowed in case of failure
+    :ivar retry_interval: Interval between retries
+    :ivar inputs: Dict of :class:`Parameter`
     """
 
     __tablename__ = 'operation_template'
@@ -1179,7 +1170,8 @@ class OperationTemplateBase(TemplateModelMixin):
 
     def instantiate(self, context, container):
         from . import model
-        operation = model.Operation(description=deepcopy_with_locators(self.description),
+        operation = model.Operation(name=self.name,
+                                    description=deepcopy_with_locators(self.description),
                                     implementation=self.implementation,
                                     dependencies=self.dependencies,
                                     executor=self.executor,
@@ -1200,33 +1192,33 @@ class OperationTemplateBase(TemplateModelMixin):
             console.puts(context.style.meta(self.description))
         with context.style.indent:
             if self.implementation is not None:
-                console.puts('Implementation: %s' % context.style.literal(self.implementation))
+                console.puts('Implementation: {0}'.format(
+                    context.style.literal(self.implementation)))
             if self.dependencies:
-                console.puts('Dependencies: %s' % ', '.join(
-                    (str(context.style.literal(v)) for v in self.dependencies)))
+                console.puts('Dependencies: {0}'.format(
+                        ', '.join((str(context.style.literal(v)) for v in self.dependencies))))
             if self.executor is not None:
-                console.puts('Executor: %s' % context.style.literal(self.executor))
+                console.puts('Executor: {0}'.format(context.style.literal(self.executor)))
             if self.max_retries is not None:
-                console.puts('Max retries: %s' % context.style.literal(self.max_retries))
+                console.puts('Max retries: {0}'.format(context.style.literal(self.max_retries)))
             if self.retry_interval is not None:
-                console.puts('Retry interval: %s' % context.style.literal(self.retry_interval))
-            dump_parameters(context, self.inputs, 'Inputs')
+                console.puts('Retry interval: {0}'.format(
+                    context.style.literal(self.retry_interval)))
+            utils.dump_parameters(context, self.inputs, 'Inputs')
 
 
-class ArtifactTemplateBase(TemplateModelMixin):
+class ArtifactTemplateBase(_TemplateModelMixin):
     """
     A file associated with a :class:`NodeTemplate`.
 
-    Properties:
-
-    * :code:`name`: Name
-    * :code:`description`: Description
-    * :code:`type_name`: Must be represented in the :class:`ModelingContext`
-    * :code:`source_path`: Source path (CSAR or repository)
-    * :code:`target_path`: Path at destination machine
-    * :code:`repository_url`: Repository URL
-    * :code:`repository_credential`: Dict of string
-    * :code:`properties`: Dict of :class:`Parameter`
+    :ivar name: Name
+    :ivar description: Description
+    :ivar type_name: Must be represented in the :class:`ModelingContext`
+    :ivar source_path: Source path (CSAR or repository)
+    :ivar target_path: Path at destination machine
+    :ivar repository_url: Repository URL
+    :ivar repository_credential: Dict of string
+    :ivar properties: Dict of :class:`Parameter`
     """
 
     __tablename__ = 'artifact_template'
@@ -1263,7 +1255,7 @@ class ArtifactTemplateBase(TemplateModelMixin):
             ('target_path', self.target_path),
             ('repository_url', self.repository_url),
             ('repository_credential', formatting.as_agnostic(self.repository_credential)),
-            ('properties', formatting.as_raw_dict(self.properties.iteritems()))))
+            ('properties', formatting.as_raw_dict(self.properties))))
 
     def instantiate(self, context, container):
         from . import model
@@ -1279,8 +1271,8 @@ class ArtifactTemplateBase(TemplateModelMixin):
 
     def validate(self, context):
         if context.modeling.artifact_types.get_descendant(self.type_name) is None:
-            context.validation.report('artifact "%s" has an unknown type: %s'
-                                      % (self.name, formatting.safe_repr(self.type_name)),
+            context.validation.report('artifact "{0}" has an unknown type: {1}'.format(
+                                        self.name, formatting.safe_repr(self.type_name)),
                                       level=validation.Issue.BETWEEN_TYPES)
 
         utils.validate_dict_values(context, self.properties)
@@ -1293,24 +1285,30 @@ class ArtifactTemplateBase(TemplateModelMixin):
         if self.description:
             console.puts(context.style.meta(self.description))
         with context.style.indent:
-            console.puts('Artifact type: %s' % context.style.type(self.type_name))
-            console.puts('Source path: %s' % context.style.literal(self.source_path))
+            console.puts('Artifact type: {0}'.format(context.style.type(self.type_name)))
+            console.puts('Source path: {0}'.format(context.style.literal(self.source_path)))
             if self.target_path is not None:
-                console.puts('Target path: %s' % context.style.literal(self.target_path))
+                console.puts('Target path: {0}'.format(context.style.literal(self.target_path)))
             if self.repository_url is not None:
-                console.puts('Repository URL: %s' % context.style.literal(self.repository_url))
+                console.puts('Repository URL: {0}'.format(
+                    context.style.literal(self.repository_url)))
             if self.repository_credential:
-                console.puts('Repository credential: %s'
-                             % context.style.literal(self.repository_credential))
-            dump_parameters(context, self.properties)
+                console.puts('Repository credential: {0}'.format(
+                                context.style.literal(self.repository_credential)))
+            utils.dump_parameters(context, self.properties)
 
 
 
-class ParameterBase(TemplateModelMixin):
+class ParameterBase(_TemplateModelMixin):
     """
     Represents a typed value.
 
     This class is used by both service template and service instance elements.
+    
+    :ivar name: Name
+    :ivar type_name: Type name
+    :ivar value: Value
+    :ivar description: Description
     """
 
     __tablename__ = 'parameter'
@@ -1365,11 +1363,14 @@ class ParameterBase(TemplateModelMixin):
                                                        report_issues)
 
 
-class MetadataBase(TemplateModelMixin):
+class MetadataBase(_TemplateModelMixin):
     """
     Custom values associated with the service.
 
     This class is used by both service template and service instance elements.
+
+    :ivar name: Name
+    :ivar value: Value
     """
 
     __tablename__ = 'metadata'
@@ -1408,23 +1409,6 @@ class Function(object):
         return self
 
 
-def dump_parameters(context, parameters, name='Properties'):
-    if not parameters:
-        return
-    console.puts('%s:' % name)
-    with context.style.indent:
-        for parameter_name, parameter in parameters.items():
-            if hasattr(parameter, 'type_name') and (parameter.type_name is not None):
-                console.puts('%s = %s (%s)' % (context.style.property(parameter_name),
-                                               context.style.literal(parameter.value),
-                                               context.style.type(parameter.type_name)))
-            else:
-                console.puts('%s = %s' % (context.style.property(parameter_name),
-                                          context.style.literal(parameter.value)))
-            if hasattr(parameter, 'description') and parameter.description:
-                console.puts(context.style.meta(parameter.description))
-
-
 # TODO (left for tal): Move following two methods to some place parser specific
 def deepcopy_with_locators(value):
     """