You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@ariatosca.apache.org by mx...@apache.org on 2017/03/28 08:54:04 UTC
[4/4] incubator-ariatosca git commit: reorded model representation
order of relationships(comments)
reorded model representation order of relationships(comments)
Project: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/commit/6fb69000
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/tree/6fb69000
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/diff/6fb69000
Branch: refs/heads/ARIA-132-Models-cascading-deletion-raises-constraint-errors
Commit: 6fb690006b034a3bf09e07ea63b01c6dd9286c98
Parents: 6e8391b
Author: max-orlov <ma...@gigaspaces.com>
Authored: Mon Mar 27 14:36:37 2017 +0300
Committer: max-orlov <ma...@gigaspaces.com>
Committed: Tue Mar 28 11:26:07 2017 +0300
----------------------------------------------------------------------
aria/modeling/relationship.py | 39 +-
aria/modeling/service_changes.py | 87 +++-
aria/modeling/service_instance.py | 814 ++++++++++++++++++++-------------
aria/modeling/service_template.py | 778 ++++++++++++++++++++-----------
4 files changed, 1100 insertions(+), 618 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/6fb69000/aria/modeling/relationship.py
----------------------------------------------------------------------
diff --git a/aria/modeling/relationship.py b/aria/modeling/relationship.py
index 63b13c8..1121dc0 100644
--- a/aria/modeling/relationship.py
+++ b/aria/modeling/relationship.py
@@ -78,12 +78,14 @@ def one_to_one_self(model_class, fk):
model_class=model_class.__name__,
column=fk
)
-
- return relationship(
- _get_class_for_table(model_class, model_class.__tablename__).__name__,
- primaryjoin=primaryjoin,
- remote_side=remote_side,
- post_update=True,
+ return _relationship(
+ model_class,
+ model_class.__tablename__,
+ relationship_kwargs={
+ 'primaryjoin': primaryjoin,
+ 'remote_side': remote_side,
+ 'post_update': True
+ }
)
@@ -108,9 +110,8 @@ def one_to_many_self(model_class, fk, dict_key=None):
model_class,
model_class.__tablename__,
relationship_kwargs={
- 'remote_side': '{model_class}.{remote_column}'.format(model_class=model_class.__name__,
- remote_column=fk
- )
+ 'remote_side': '{model_class}.{remote_column}'.format(
+ model_class=model_class.__name__, remote_column=fk)
},
back_populates=False,
dict_key=dict_key
@@ -144,6 +145,8 @@ def one_to_one(model_class,
false to disable
:type back_populates: basestring|bool
"""
+ if back_populates is None:
+ back_populates = model_class.__tablename__
return _relationship(model_class,
other_table,
@@ -156,7 +159,7 @@ def one_to_many(model_class,
child_table,
child_fk=None,
dict_key=None,
- child_property=None):
+ back_populates=None):
"""
Declare a one-to-many relationship property. The property value would be a list or dict of
instances of the child table's model.
@@ -177,14 +180,16 @@ def one_to_many(model_class,
:param dict_key: If set the value will be a dict with this key as the dict key; otherwise will
be a list
:type dict_key: basestring
- :param child_property: Override name of matching many-to-one property at child table; set to
+ :param back_populates: Override name of matching many-to-one property at child table; set to
false to disable
- :type child_property: basestring|bool
+ :type back_populates: basestring|bool
"""
+ if back_populates is None:
+ back_populates = model_class.__tablename__
return _relationship(
model_class,
child_table,
- relationship_kwargs={'back_populates': child_property or model_class.__tablename__},
+ back_populates=back_populates,
other_fk=child_fk,
dict_key=dict_key)
@@ -217,14 +222,12 @@ def many_to_one(model_class,
false to disable
:type back_populates: basestring|bool
"""
- relationship_kwargs = {}
- if back_populates is not False:
- relationship_kwargs['back_populates'] = back_populates or \
- formatting.pluralize(model_class.__tablename__)
+ if back_populates is None:
+ back_populates = formatting.pluralize(model_class.__tablename__)
return _relationship(model_class,
parent_table,
- relationship_kwargs=relationship_kwargs,
+ back_populates=back_populates,
fk=fk,
other_fk=parent_fk)
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/6fb69000/aria/modeling/service_changes.py
----------------------------------------------------------------------
diff --git a/aria/modeling/service_changes.py b/aria/modeling/service_changes.py
index d81ed98..6c13b0f 100644
--- a/aria/modeling/service_changes.py
+++ b/aria/modeling/service_changes.py
@@ -57,18 +57,6 @@ class ServiceUpdateBase(ModelMixin):
modified_entity_ids = Column(Dict)
state = Column(Text)
- @declared_attr
- def execution(cls):
- return relationship.one_to_one(cls, 'execution', back_populates=False)
-
- @declared_attr
- def service(cls):
- return relationship.many_to_one(cls, 'service', back_populates='updates')
-
- @declared_attr
- def steps(cls):
- return relationship.one_to_many(cls, 'service_update_step')
-
# region foreign keys
@declared_attr
@@ -95,6 +83,34 @@ class ServiceUpdateBase(ModelMixin):
# endregion
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def steps(cls):
+ return relationship.one_to_many(cls, 'service_update_step')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def execution(cls):
+ return relationship.one_to_one(cls, 'execution', back_populates=False)
+
+ @declared_attr
+ def service(cls):
+ return relationship.many_to_one(cls, 'service', back_populates='updates')
+
+ # endregion
+
+ # region many_to_many relationships
+
+ # endregion
+
def to_dict(self, suppress_error=False, **kwargs):
dep_update_dict = super(ServiceUpdateBase, self).to_dict(suppress_error) #pylint: disable=no-member
# Taking care of the fact the DeploymentSteps are _BaseModels
@@ -134,10 +150,6 @@ class ServiceUpdateStepBase(ModelMixin):
entity_id = Column(Text, nullable=False)
entity_type = Column(Enum(*ENTITY_TYPES, name='entity_type'), nullable=False)
- @declared_attr
- def service_update(cls):
- return relationship.many_to_one(cls, 'service_update', back_populates='steps')
-
# region foreign keys
@declared_attr
@@ -155,6 +167,26 @@ class ServiceUpdateStepBase(ModelMixin):
# endregion
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service_update(cls):
+ return relationship.many_to_one(cls, 'service_update', back_populates='steps')
+
+ # endregion
+
+ # region many_to_many relationships
+
+ # endregion
+
def __hash__(self):
return hash((getattr(self, self.id_column_name()), self.entity_id))
@@ -207,10 +239,6 @@ class ServiceModificationBase(ModelMixin):
nodes = Column(Dict)
status = Column(Enum(*STATES, name='service_modification_status'))
- @declared_attr
- def service(cls):
- return relationship.many_to_one(cls, 'service', back_populates='modifications')
-
# region foreign keys
@declared_attr
@@ -227,3 +255,22 @@ class ServiceModificationBase(ModelMixin):
return association_proxy('service', cls.name_column_name())
# endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+ @declared_attr
+ def service(cls):
+ return relationship.many_to_one(cls, 'service', back_populates='modifications')
+
+ # endregion
+
+ # region many_to_many relationships
+
+ # endregion
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/6fb69000/aria/modeling/service_instance.py
----------------------------------------------------------------------
diff --git a/aria/modeling/service_instance.py b/aria/modeling/service_instance.py
index 4adf8ac..327affc 100644
--- a/aria/modeling/service_instance.py
+++ b/aria/modeling/service_instance.py
@@ -91,6 +91,38 @@ class ServiceBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
'service_template_fk',
'service_template_name']
+ # region foreign keys
+
+ @declared_attr
+ def substitution_fk(cls):
+ """Service one-to-one to Substitution"""
+ return relationship.foreign_key('substitution', nullable=True)
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For Service many-to-one to ServiceTemplate"""
+ return relationship.foreign_key('service_template', nullable=True)
+
+ # endregion
+
+ # region association proxies
+
+ @declared_attr
+ def service_template_name(cls):
+ """Required for use by SQLAlchemy queries"""
+ return association_proxy('service_template', 'name')
+
+ # endregion
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def substitution(cls):
+ return relationship.one_to_one(cls, 'substitution', back_populates=False)
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
def updates(cls):
return relationship.one_to_many(cls, 'service_update')
@@ -108,17 +140,6 @@ class ServiceBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
return relationship.one_to_many(cls, 'operation')
@declared_attr
- def service_template(cls):
- return relationship.many_to_one(cls, 'service_template')
-
- description = Column(Text)
-
- @declared_attr
- def meta_data(cls):
- # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy!
- return relationship.many_to_many(cls, 'metadata', dict_key='name')
-
- @declared_attr
def nodes(cls):
return relationship.one_to_many(cls, 'node', dict_key='name')
@@ -131,8 +152,24 @@ class ServiceBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
return relationship.one_to_many(cls, 'policy', dict_key='name')
@declared_attr
- def substitution(cls):
- return relationship.one_to_one(cls, 'substitution')
+ def workflows(cls):
+ return relationship.one_to_many(cls, 'operation', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service_template(cls):
+ return relationship.many_to_one(cls, 'service_template')
+
+ # endregion
+
+ # region many_to_many relationships
+ @declared_attr
+ def meta_data(cls):
+ # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy!
+ return relationship.many_to_many(cls, 'metadata', dict_key='name')
@declared_attr
def inputs(cls):
@@ -143,13 +180,13 @@ class ServiceBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
return relationship.many_to_many(cls, 'parameter', prefix='outputs', dict_key='name')
@declared_attr
- def workflows(cls):
- return relationship.one_to_many(cls, 'operation', dict_key='name')
-
- @declared_attr
def plugin_specifications(cls):
return relationship.many_to_many(cls, 'plugin_specification', dict_key='name')
+ # endregion
+
+ description = Column(Text)
+
created_at = Column(DateTime, nullable=False, index=True)
updated_at = Column(DateTime)
@@ -160,29 +197,6 @@ class ServiceBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
# endregion
- # region foreign keys
-
- @declared_attr
- def substitution_fk(cls):
- """Service one-to-one to Substitution"""
- return relationship.foreign_key('substitution', nullable=True)
-
- @declared_attr
- def service_template_fk(cls):
- """For Service many-to-one to ServiceTemplate"""
- return relationship.foreign_key('service_template', nullable=True)
-
- # endregion
-
- # region association proxies
-
- @declared_attr
- def service_template_name(cls):
- """Required for use by SQLAlchemy queries"""
- return association_proxy('service_template', 'name')
-
- # endregion
-
def satisfy_requirements(self):
satisfied = True
for node in self.nodes.itervalues():
@@ -407,27 +421,52 @@ class NodeBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
except KeyError:
return None
+ # region foreign_keys
+
@declared_attr
- def tasks(cls):
- return relationship.one_to_many(cls, 'task')
+ def type_fk(cls):
+ """For Node many-to-one to Type"""
+ return relationship.foreign_key('type')
@declared_attr
- def service(cls):
- return relationship.many_to_one(cls, 'service')
+ def host_fk(cls):
+ """For Node one-to-one to Node"""
+ return relationship.foreign_key('node', nullable=True)
@declared_attr
- def node_template(cls):
- return relationship.many_to_one(cls, 'node_template')
+ def service_fk(cls):
+ """For Service one-to-many to Node"""
+ return relationship.foreign_key('service')
@declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def node_template_fk(cls):
+ """For Node many-to-one to NodeTemplate"""
+ return relationship.foreign_key('node_template')
- description = Column(Text)
+ # endregion
+
+ # region association proxies
@declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+ def service_name(cls):
+ """Required for use by SQLAlchemy queries"""
+ return association_proxy('service', 'name')
+
+ # endregion
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def host(cls):
+ return relationship.one_to_one_self(cls, 'host_fk')
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def tasks(cls):
+ return relationship.one_to_many(cls, 'task')
@declared_attr
def interfaces(cls):
@@ -444,19 +483,39 @@ class NodeBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
@declared_attr
def outbound_relationships(cls):
return relationship.one_to_many(
- cls, 'relationship', child_fk='source_node_fk', child_property='source_node')
+ cls, 'relationship', child_fk='source_node_fk', back_populates='source_node')
@declared_attr
def inbound_relationships(cls):
return relationship.one_to_many(
- cls, 'relationship', child_fk='target_node_fk', child_property='target_node')
+ cls, 'relationship', child_fk='target_node_fk', back_populates='target_node')
+
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def host(cls):
- return relationship.one_to_one_self(cls, 'host_fk')
+ def service(cls):
+ return relationship.many_to_one(cls, 'service')
- # region orchestration
+ @declared_attr
+ def node_template(cls):
+ return relationship.many_to_one(cls, 'node_template')
+ @declared_attr
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+
+ # endregion
+
+ description = Column(Text)
runtime_properties = Column(modeling_types.Dict)
scaling_groups = Column(modeling_types.List)
state = Column(Enum(*STATES, name='node_state'), nullable=False, default=INITIAL)
@@ -478,41 +537,6 @@ class NodeBase(InstanceModelMixin): # pylint: disable=too-many-public-methods
return host_ip_property.value
return None
- # endregion
-
- # region foreign_keys
-
- @declared_attr
- def type_fk(cls):
- """For Node many-to-one to Type"""
- return relationship.foreign_key('type')
-
- @declared_attr
- def host_fk(cls):
- """For Node one-to-one to Node"""
- return relationship.foreign_key('node', nullable=True)
-
- @declared_attr
- def service_fk(cls):
- """For Service one-to-many to Node"""
- return relationship.foreign_key('service')
-
- @declared_attr
- def node_template_fk(cls):
- """For Node many-to-one to NodeTemplate"""
- return relationship.foreign_key('node_template')
-
- # endregion
-
- # region association proxies
-
- @declared_attr
- def service_name(cls):
- """Required for use by SQLAlchemy queries"""
- return association_proxy('service', 'name')
-
- # endregion
-
def satisfy_requirements(self):
node_template = self.node_template
satisfied = True
@@ -673,9 +697,44 @@ class GroupBase(InstanceModelMixin):
__tablename__ = 'group'
- __private_fields__ = ['type_fk',
- 'service_fk',
- 'group_template_fk']
+ __private_fields__ = ['type_fk', 'service_fk', 'group_template_fk']
+
+ # region foreign_keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For Group many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def service_fk(cls):
+ """For Service one-to-many to Group"""
+ return relationship.foreign_key('service')
+
+ @declared_attr
+ def group_template_fk(cls):
+ """For Group many-to-one to GroupTemplate"""
+ return relationship.foreign_key('group_template', nullable=True)
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def interfaces(cls):
+ return relationship.one_to_many(cls, 'interface', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
def service(cls):
@@ -689,7 +748,9 @@ class GroupBase(InstanceModelMixin):
def type(cls):
return relationship.many_to_one(cls, 'type', back_populates=False)
- description = Column(Text)
+ # endregion
+
+ # region many_to_many relationships
@declared_attr
def nodes(cls):
@@ -699,29 +760,10 @@ class GroupBase(InstanceModelMixin):
def properties(cls):
return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
- @declared_attr
- def interfaces(cls):
- return relationship.one_to_many(cls, 'interface', dict_key='name')
-
- # region foreign_keys
-
- @declared_attr
- def type_fk(cls):
- """For Group many-to-one to Type"""
- return relationship.foreign_key('type')
-
- @declared_attr
- def service_fk(cls):
- """For Service one-to-many to Group"""
- return relationship.foreign_key('service')
-
- @declared_attr
- def group_template_fk(cls):
- """For Group many-to-one to GroupTemplate"""
- return relationship.foreign_key('group_template', nullable=True)
-
# endregion
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -776,9 +818,40 @@ class PolicyBase(InstanceModelMixin):
__tablename__ = 'policy'
- __private_fields__ = ['type_fk',
- 'service_fk',
- 'policy_template_fk']
+ __private_fields__ = ['type_fk', 'service_fk', 'policy_template_fk']
+
+ # region foreign_keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For Policy many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def service_fk(cls):
+ """For Service one-to-many to Policy"""
+ return relationship.foreign_key('service')
+
+ @declared_attr
+ def policy_template_fk(cls):
+ """For Policy many-to-one to PolicyTemplate"""
+ return relationship.foreign_key('policy_template', nullable=True)
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
def service(cls):
@@ -792,7 +865,9 @@ class PolicyBase(InstanceModelMixin):
def type(cls):
return relationship.many_to_one(cls, 'type', back_populates=False)
- description = Column(Text)
+ # endregion
+
+ # region many_to_many relationships
@declared_attr
def properties(cls):
@@ -806,25 +881,10 @@ class PolicyBase(InstanceModelMixin):
def groups(cls):
return relationship.many_to_many(cls, 'group')
- # region foreign_keys
-
- @declared_attr
- def type_fk(cls):
- """For Policy many-to-one to Type"""
- return relationship.foreign_key('type')
-
- @declared_attr
- def service_fk(cls):
- """For Service one-to-many to Policy"""
- return relationship.foreign_key('service')
-
- @declared_attr
- def policy_template_fk(cls):
- """For Policy many-to-one to PolicyTemplate"""
- return relationship.foreign_key('policy_template', nullable=True)
-
# endregion
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -878,33 +938,53 @@ class SubstitutionBase(InstanceModelMixin):
__private_fields__ = ['node_type_fk',
'substitution_template_fk']
- @declared_attr
- def service(cls):
- return relationship.one_to_one(cls, 'service')
+ # region foreign_keys
@declared_attr
- def substitution_template(cls):
- return relationship.many_to_one(cls, 'substitution_template')
+ def node_type_fk(cls):
+ """For Substitution many-to-one to Type"""
+ return relationship.foreign_key('type')
@declared_attr
- def node_type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def substitution_template_fk(cls):
+ """For Substitution many-to-one to SubstitutionTemplate"""
+ return relationship.foreign_key('substitution_template', nullable=True)
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
def mappings(cls):
return relationship.one_to_many(cls, 'substitution_mapping', dict_key='name')
- # region foreign_keys
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def node_type_fk(cls):
- """For Substitution many-to-one to Type"""
- return relationship.foreign_key('type')
+ def service(cls):
+ return relationship.one_to_one(cls, 'service', back_populates=False)
@declared_attr
- def substitution_template_fk(cls):
- """For Substitution many-to-one to SubstitutionTemplate"""
- return relationship.foreign_key('substitution_template', nullable=True)
+ def substitution_template(cls):
+ return relationship.many_to_one(cls, 'substitution_template')
+
+ @declared_attr
+ def node_type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
# endregion
@@ -956,22 +1036,6 @@ class SubstitutionMappingBase(InstanceModelMixin):
'capability_fk',
'requirement_template_fk']
- @declared_attr
- def substitution(cls):
- return relationship.many_to_one(cls, 'substitution', back_populates='mappings')
-
- @declared_attr
- def node(cls):
- return relationship.one_to_one(cls, 'node')
-
- @declared_attr
- def capability(cls):
- return relationship.one_to_one(cls, 'capability')
-
- @declared_attr
- def requirement_template(cls):
- return relationship.one_to_one(cls, 'requirement_template')
-
# region foreign keys
@declared_attr
@@ -996,6 +1060,42 @@ class SubstitutionMappingBase(InstanceModelMixin):
# endregion
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def substitution(cls):
+ return relationship.many_to_one(cls, 'substitution', back_populates='mappings')
+
+ @declared_attr
+ def node(cls):
+ return relationship.one_to_one(cls, 'node', back_populates=False)
+
+ @declared_attr
+ def capability(cls):
+ return relationship.one_to_one(cls, 'capability', back_populates=False)
+
+ @declared_attr
+ def requirement_template(cls):
+ return relationship.one_to_one(cls, 'requirement_template', back_populates=False)
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+
+ # endregion
+
+ # region many_to_many relationships
+
+ # endregion
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1068,51 +1168,6 @@ class RelationshipBase(InstanceModelMixin):
'source_node_name',
'target_node_name']
- @declared_attr
- def tasks(cls):
- return relationship.one_to_many(cls, 'task')
-
- @declared_attr
- def source_node(cls):
- return relationship.many_to_one(
- cls, 'node', fk='source_node_fk', back_populates='outbound_relationships')
-
- @declared_attr
- def target_node(cls):
- return relationship.many_to_one(
- cls, 'node', fk='target_node_fk', back_populates='inbound_relationships')
-
- @declared_attr
- def relationship_template(cls):
- return relationship.many_to_one(cls, 'relationship_template')
-
- @declared_attr
- def requirement_template(cls):
- return relationship.many_to_one(cls, 'requirement_template')
-
- @declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
-
- @declared_attr
- def target_capability(cls):
- return relationship.one_to_one(cls, 'capability')
-
- @declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
-
- @declared_attr
- def interfaces(cls):
- return relationship.one_to_many(cls, 'interface', dict_key='name')
-
- # region orchestration
-
- source_position = Column(Integer) # ???
- target_position = Column(Integer) # ???
-
- # endregion
-
# region foreign keys
@declared_attr
@@ -1161,6 +1216,63 @@ class RelationshipBase(InstanceModelMixin):
# endregion
+ # region one_to_one relationships
+
+ @declared_attr
+ def target_capability(cls):
+ return relationship.one_to_one(cls, 'capability', back_populates=False)
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def tasks(cls):
+ return relationship.one_to_many(cls, 'task')
+
+ @declared_attr
+ def interfaces(cls):
+ return relationship.one_to_many(cls, 'interface', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def source_node(cls):
+ return relationship.many_to_one(
+ cls, 'node', fk='source_node_fk', back_populates='outbound_relationships')
+
+ @declared_attr
+ def target_node(cls):
+ return relationship.many_to_one(
+ cls, 'node', fk='target_node_fk', back_populates='inbound_relationships')
+
+ @declared_attr
+ def relationship_template(cls):
+ return relationship.many_to_one(cls, 'relationship_template')
+
+ @declared_attr
+ def requirement_template(cls):
+ return relationship.many_to_one(cls, 'requirement_template')
+
+ @declared_attr
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+
+ # endregion
+
+ source_position = Column(Integer) # ???
+ target_position = Column(Integer) # ???
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1236,26 +1348,6 @@ class CapabilityBase(InstanceModelMixin):
'node_fk',
'capability_template_fk']
- @declared_attr
- def node(cls):
- return relationship.many_to_one(cls, 'node')
-
- @declared_attr
- def capability_template(cls):
- return relationship.many_to_one(cls, 'capability_template')
-
- @declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
-
- min_occurrences = Column(Integer, default=None)
- max_occurrences = Column(Integer, default=None)
- occurrences = Column(Integer, default=0)
-
- @declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
-
# region foreign_keys
@declared_attr
@@ -1275,6 +1367,46 @@ class CapabilityBase(InstanceModelMixin):
# endregion
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node(cls):
+ return relationship.many_to_one(cls, 'node')
+
+ @declared_attr
+ def capability_template(cls):
+ return relationship.many_to_one(cls, 'capability_template')
+
+ @declared_attr
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+
+ # endregion
+
+ min_occurrences = Column(Integer, default=None)
+ max_occurrences = Column(Integer, default=None)
+ occurrences = Column(Integer, default=0)
+
@property
def has_enough_relationships(self):
if self.min_occurrences is not None:
@@ -1350,36 +1482,6 @@ class InterfaceBase(InstanceModelMixin):
'relationship_fk',
'interface_template_fk']
- @declared_attr
- def node(cls):
- return relationship.many_to_one(cls, 'node')
-
- @declared_attr
- def relationship(cls):
- return relationship.many_to_one(cls, 'relationship')
-
- @declared_attr
- def group(cls):
- return relationship.many_to_one(cls, 'group')
-
- @declared_attr
- def interface_template(cls):
- return relationship.many_to_one(cls, 'interface_template')
-
- @declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
-
- description = Column(Text)
-
- @declared_attr
- def inputs(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
-
- @declared_attr
- def operations(cls):
- return relationship.one_to_many(cls, 'operation', dict_key='name')
-
# region foreign_keys
@declared_attr
@@ -1409,6 +1511,56 @@ class InterfaceBase(InstanceModelMixin):
# endregion
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ @declared_attr
+ def operations(cls):
+ return relationship.one_to_many(cls, 'operation', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def node(cls):
+ return relationship.many_to_one(cls, 'node')
+
+ @declared_attr
+ def relationship(cls):
+ return relationship.many_to_one(cls, 'relationship')
+
+ @declared_attr
+ def group(cls):
+ return relationship.many_to_one(cls, 'group')
+
+ @declared_attr
+ def interface_template(cls):
+ return relationship.many_to_one(cls, 'interface_template')
+
+ @declared_attr
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def inputs(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
+
+ # endregion
+
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1477,35 +1629,6 @@ class OperationBase(InstanceModelMixin):
'plugin_fk',
'operation_template_fk']
- @declared_attr
- def service(cls):
- return relationship.many_to_one(cls, 'service')
-
- @declared_attr
- def interface(cls):
- return relationship.many_to_one(cls, 'interface')
-
- @declared_attr
- def operation_template(cls):
- return relationship.many_to_one(cls, 'operation_template')
-
- description = Column(Text)
-
- @declared_attr
- def plugin_specification(cls):
- return relationship.one_to_one(cls, 'plugin_specification')
-
- implementation = Column(Text)
- dependencies = Column(modeling_types.StrictList(item_cls=basestring))
-
- @declared_attr
- def inputs(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
-
- executor = Column(Text)
- max_retries = Column(Integer)
- retry_interval = Column(Integer)
-
# region foreign_keys
@declared_attr
@@ -1530,6 +1653,55 @@ class OperationBase(InstanceModelMixin):
# endregion
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def plugin_specification(cls):
+ return relationship.one_to_one(cls, 'plugin_specification', back_populates=False)
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def service(cls):
+ return relationship.many_to_one(cls, 'service')
+
+ @declared_attr
+ def interface(cls):
+ return relationship.many_to_one(cls, 'interface')
+
+ @declared_attr
+ def operation_template(cls):
+ return relationship.many_to_one(cls, 'operation_template')
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def inputs(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
+
+ # endregion
+
+ description = Column(Text)
+ implementation = Column(Text)
+ dependencies = Column(modeling_types.StrictList(item_cls=basestring))
+ executor = Column(Text)
+ max_retries = Column(Integer)
+ retry_interval = Column(Integer)
+
+
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1607,28 +1779,6 @@ class ArtifactBase(InstanceModelMixin):
'node_fk',
'artifact_template_fk']
- @declared_attr
- def node(cls):
- return relationship.many_to_one(cls, 'node')
-
- @declared_attr
- def artifact_template(cls):
- return relationship.many_to_one(cls, 'artifact_template')
-
- @declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
-
- description = Column(Text)
- source_path = Column(Text)
- target_path = Column(Text)
- repository_url = Column(Text)
- repository_credential = Column(modeling_types.StrictDict(basestring, basestring))
-
- @declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
-
# region foreign_keys
@declared_attr
@@ -1648,6 +1798,44 @@ class ArtifactBase(InstanceModelMixin):
# endregion
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+ @declared_attr
+ def node(cls):
+ return relationship.many_to_one(cls, 'node')
+
+ @declared_attr
+ def artifact_template(cls):
+ return relationship.many_to_one(cls, 'artifact_template')
+
+ @declared_attr
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+ # endregion
+
+ # region many_to_many relationships
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+ # endregion
+
+ description = Column(Text)
+ source_path = Column(Text)
+ target_path = Column(Text)
+ repository_url = Column(Text)
+ repository_credential = Column(modeling_types.StrictDict(basestring, basestring))
+
@property
def as_raw(self):
return collections.OrderedDict((
http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/6fb69000/aria/modeling/service_template.py
----------------------------------------------------------------------
diff --git a/aria/modeling/service_template.py b/aria/modeling/service_template.py
index 228fb26..0cbbe24 100644
--- a/aria/modeling/service_template.py
+++ b/aria/modeling/service_template.py
@@ -108,51 +108,62 @@ class ServiceTemplateBase(TemplateModelMixin): # pylint: disable=too-many-public
description = Column(Text)
main_file_name = Column(Text)
+ created_at = Column(DateTime, nullable=False, index=True)
+ updated_at = Column(DateTime)
- @declared_attr
- def services(cls):
- return relationship.one_to_many(cls, 'service')
+ # region foreign keys
@declared_attr
- def meta_data(cls):
- # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy!
- return relationship.many_to_many(cls, 'metadata', dict_key='name')
+ def substitution_template_fk(cls):
+ """For ServiceTemplate one-to-one to SubstitutionTemplate"""
+ return relationship.foreign_key('substitution_template', nullable=True)
@declared_attr
- def operation_templates(cls):
- return relationship.one_to_many(cls, 'operation_template')
+ def node_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def node_templates(cls):
- return relationship.one_to_many(cls, 'node_template', dict_key='name')
+ def group_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def group_templates(cls):
- return relationship.one_to_many(cls, 'group_template', dict_key='name')
+ def policy_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def policy_templates(cls):
- return relationship.one_to_many(cls, 'policy_template', dict_key='name')
+ def relationship_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def substitution_template(cls):
- return relationship.one_to_one(cls, 'substitution_template')
+ def capability_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def inputs(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
+ def interface_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def outputs(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='outputs', dict_key='name')
+ def artifact_type_fk(cls):
+ """For ServiceTemplate one-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
- @declared_attr
- def workflow_templates(cls):
- return relationship.one_to_many(cls, 'operation_template', dict_key='name')
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
@declared_attr
- def plugin_specifications(cls):
- return relationship.one_to_many(cls, 'plugin_specification', dict_key='name')
+ def substitution_template(cls):
+ return relationship.one_to_one(cls, 'substitution_template', back_populates=False)
@declared_attr
def node_types(cls):
@@ -182,57 +193,63 @@ class ServiceTemplateBase(TemplateModelMixin): # pylint: disable=too-many-public
def artifact_types(cls):
return relationship.one_to_one(cls, 'type', fk='artifact_type_fk', back_populates=False)
- # region orchestration
+ # endregion
- created_at = Column(DateTime, nullable=False, index=True)
- updated_at = Column(DateTime)
+ # region one_to_many relationships
- # endregion
+ @declared_attr
+ def services(cls):
+ return relationship.one_to_many(cls, 'service')
- # region foreign keys
+ @declared_attr
+ def operation_templates(cls):
+ return relationship.one_to_many(cls, 'operation_template')
@declared_attr
- def substitution_template_fk(cls):
- """For ServiceTemplate one-to-one to SubstitutionTemplate"""
- return relationship.foreign_key('substitution_template', nullable=True)
+ def node_templates(cls):
+ return relationship.one_to_many(cls, 'node_template', dict_key='name')
@declared_attr
- def node_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def group_templates(cls):
+ return relationship.one_to_many(cls, 'group_template', dict_key='name')
@declared_attr
- def group_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def policy_templates(cls):
+ return relationship.one_to_many(cls, 'policy_template', dict_key='name')
@declared_attr
- def policy_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def workflow_templates(cls):
+ return relationship.one_to_many(cls, 'operation_template', dict_key='name')
@declared_attr
- def relationship_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def plugin_specifications(cls):
+ return relationship.one_to_many(cls, 'plugin_specification', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ # endregion
+
+ # region many_to_many relationships
@declared_attr
- def capability_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def meta_data(cls):
+ # Warning! We cannot use the attr name "metadata" because it's used by SQLAlchemy!
+ return relationship.many_to_many(cls, 'metadata', dict_key='name')
@declared_attr
- def interface_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def inputs(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
@declared_attr
- def artifact_type_fk(cls):
- """For ServiceTemplate one-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def outputs(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='outputs', dict_key='name')
# endregion
+
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -420,23 +437,55 @@ class NodeTemplateBase(TemplateModelMixin):
'service_template_fk',
'service_template_name']
+ # region foreign_keys
+
@declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def type_fk(cls):
+ """For NodeTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
- description = Column(Text)
- default_instances = Column(Integer, default=1)
- min_instances = Column(Integer, default=0)
- max_instances = Column(Integer, default=None)
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to NodeTemplate"""
+ return relationship.foreign_key('service_template')
+
+ # endregion
+
+ # region association proxies
+
+ @declared_attr
+ def service_template_name(cls):
+ """Required for use by SQLAlchemy queries"""
+ return association_proxy('service_template', 'name')
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
def nodes(cls):
return relationship.one_to_many(cls, 'node')
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
@declared_attr
def service_template(cls):
return relationship.many_to_one(cls, 'service_template')
+ # endregion
+
+ # region many_to_many relationships
+
@declared_attr
def properties(cls):
return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
@@ -457,30 +506,13 @@ class NodeTemplateBase(TemplateModelMixin):
def requirement_templates(cls):
return relationship.one_to_many(cls, 'requirement_template', child_fk='node_template_fk')
- target_node_template_constraints = Column(modeling_types.StrictList(FunctionType))
-
- # region foreign_keys
-
- @declared_attr
- def type_fk(cls):
- """For NodeTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
-
- @declared_attr
- def service_template_fk(cls):
- """For ServiceTemplate one-to-many to NodeTemplate"""
- return relationship.foreign_key('service_template')
-
# endregion
- # region association proxies
-
- @declared_attr
- def service_template_name(cls):
- """Required for use by SQLAlchemy queries"""
- return association_proxy('service_template', 'name')
-
- # endregion
+ description = Column(Text)
+ default_instances = Column(Integer, default=1)
+ min_instances = Column(Integer, default=0)
+ max_instances = Column(Integer, default=None)
+ target_node_template_constraints = Column(modeling_types.StrictList(FunctionType))
def is_target_node_valid(self, target_node_template):
if self.target_node_template_constraints:
@@ -585,11 +617,43 @@ class GroupTemplateBase(TemplateModelMixin):
__private_fields__ = ['type_fk',
'service_template_fk']
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For GroupTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to GroupTemplate"""
+ return relationship.foreign_key('service_template')
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
@declared_attr
def groups(cls):
return relationship.one_to_many(cls, 'group')
@declared_attr
+ def interface_templates(cls):
+ return relationship.one_to_many(cls, 'interface_template', dict_key='name')
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
def service_template(cls):
return relationship.many_to_one(cls, 'service_template')
@@ -597,7 +661,9 @@ class GroupTemplateBase(TemplateModelMixin):
def type(cls):
return relationship.many_to_one(cls, 'type', back_populates=False)
- description = Column(Text)
+ # endregion
+
+ # region many_to_many relationships
@declared_attr
def node_templates(cls):
@@ -607,24 +673,10 @@ class GroupTemplateBase(TemplateModelMixin):
def properties(cls):
return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
- @declared_attr
- def interface_templates(cls):
- return relationship.one_to_many(cls, 'interface_template', dict_key='name')
-
- # region foreign keys
-
- @declared_attr
- def type_fk(cls):
- """For GroupTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
-
- @declared_attr
- def service_template_fk(cls):
- """For ServiceTemplate one-to-many to GroupTemplate"""
- return relationship.foreign_key('service_template')
-
# endregion
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -697,46 +749,66 @@ class PolicyTemplateBase(TemplateModelMixin):
__private_fields__ = ['type_fk', 'service_template_fk']
- @declared_attr
- def policies(cls):
- return relationship.one_to_many(cls, 'policy')
+ # region foreign keys
@declared_attr
- def service_template(cls):
- return relationship.many_to_one(cls, 'service_template')
+ def type_fk(cls):
+ """For PolicyTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
@declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to PolicyTemplate"""
+ return relationship.foreign_key('service_template')
- description = Column(Text)
+ # endregion
- @declared_attr
- def node_templates(cls):
- return relationship.many_to_many(cls, 'node_template')
+ # region association proxies
- @declared_attr
- def group_templates(cls):
- return relationship.many_to_many(cls, 'group_template')
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+ def policies(cls):
+ return relationship.one_to_many(cls, 'policy')
- # region foreign keys
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def type_fk(cls):
- """For PolicyTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
+ def service_template(cls):
+ return relationship.many_to_one(cls, 'service_template')
@declared_attr
- def service_template_fk(cls):
- """For ServiceTemplate one-to-many to PolicyTemplate"""
- return relationship.foreign_key('service_template')
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def node_templates(cls):
+ return relationship.many_to_many(cls, 'node_template')
+
+ @declared_attr
+ def group_templates(cls):
+ return relationship.many_to_many(cls, 'group_template')
+
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
# endregion
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -801,24 +873,44 @@ class SubstitutionTemplateBase(TemplateModelMixin):
__private_fields__ = ['node_type_fk']
+ # region foreign keys
+
@declared_attr
- def substitutions(cls):
- return relationship.one_to_many(cls, 'substitution')
+ def node_type_fk(cls):
+ """For SubstitutionTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
- def node_type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def substitutions(cls):
+ return relationship.one_to_many(cls, 'substitution')
@declared_attr
def mappings(cls):
return relationship.one_to_many(cls, 'substitution_template_mapping', dict_key='name')
- # region foreign keys
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def node_type_fk(cls):
- """For SubstitutionTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
+ def node_type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
# endregion
@@ -875,22 +967,6 @@ class SubstitutionTemplateMappingBase(TemplateModelMixin):
'capability_template_fk',
'requirement_template_fk']
- @declared_attr
- def substitution_template(cls):
- return relationship.many_to_one(cls, 'substitution_template', back_populates='mappings')
-
- @declared_attr
- def node_template(cls):
- return relationship.one_to_one(cls, 'node_template')
-
- @declared_attr
- def capability_template(cls):
- return relationship.one_to_one(cls, 'capability_template')
-
- @declared_attr
- def requirement_template(cls):
- return relationship.one_to_one(cls, 'requirement_template')
-
# region foreign keys
@declared_attr
@@ -915,6 +991,48 @@ class SubstitutionTemplateMappingBase(TemplateModelMixin):
# endregion
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ @declared_attr
+ def node_template(cls):
+ return relationship.one_to_one(cls, 'node_template', back_populates=False)
+
+ @declared_attr
+ def capability_template(cls):
+ return relationship.one_to_one(cls, 'capability_template', back_populates=False)
+
+ @declared_attr
+ def requirement_template(cls):
+ return relationship.one_to_one(cls, 'requirement_template', back_populates=False)
+
+ # endregion
+
+ # region one_to_many relationships
+
+ # endregion
+
+ # region many_to_one relationships
+
+ @declared_attr
+ def substitution_template(cls):
+ return relationship.many_to_one(cls, 'substitution_template', back_populates='mappings')
+
+ # endregion
+
+ # region many_to_many relationships
+
+ # endregion
+
+
+
+
+
+
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1004,18 +1122,40 @@ class RequirementTemplateBase(TemplateModelMixin):
'node_template_fk',
'relationship_template_fk']
+ # region foreign keys
+
@declared_attr
- def relationships(cls):
- return relationship.one_to_many(cls, 'relationship')
+ def target_node_type_fk(cls):
+ """For RequirementTemplate many-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
@declared_attr
- def node_template(cls):
- return relationship.many_to_one(cls, 'node_template', fk='node_template_fk')
+ def target_node_template_fk(cls):
+ """For RequirementTemplate one-to-one to NodeTemplate"""
+ return relationship.foreign_key('node_template', nullable=True)
@declared_attr
- def target_node_type(cls):
- return relationship.many_to_one(
- cls, 'type', fk='target_node_type_fk', back_populates=False)
+ def target_capability_type_fk(cls):
+ """For RequirementTemplate one-to-one to NodeTemplate"""
+ return relationship.foreign_key('type', nullable=True)
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to RequirementTemplate"""
+ return relationship.foreign_key('node_template')
+
+ @declared_attr
+ def relationship_template_fk(cls):
+ """For RequirementTemplate one-to-one to RelationshipTemplate"""
+ return relationship.foreign_key('relationship_template', nullable=True)
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
@declared_attr
def target_node_template(cls):
@@ -1027,42 +1167,40 @@ class RequirementTemplateBase(TemplateModelMixin):
return relationship.one_to_one(cls, 'type', fk='target_capability_type_fk',
back_populates=False)
- target_capability_name = Column(Text)
- target_node_template_constraints = Column(modeling_types.StrictList(FunctionType))
-
@declared_attr
def relationship_template(cls):
- return relationship.one_to_one(cls, 'relationship_template')
+ return relationship.one_to_one(cls, 'relationship_template', back_populates=False)
- # region foreign keys
+ # endregion
- @declared_attr
- def target_node_type_fk(cls):
- """For RequirementTemplate many-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ # region one_to_many relationships
@declared_attr
- def target_node_template_fk(cls):
- """For RequirementTemplate one-to-one to NodeTemplate"""
- return relationship.foreign_key('node_template', nullable=True)
+ def relationships(cls):
+ return relationship.one_to_many(cls, 'relationship')
@declared_attr
- def target_capability_type_fk(cls):
- """For RequirementTemplate one-to-one to NodeTemplate"""
- return relationship.foreign_key('type', nullable=True)
+ def target_node_type(cls):
+ return relationship.many_to_one(
+ cls, 'type', fk='target_node_type_fk', back_populates=False)
- @declared_attr
- def node_template_fk(cls):
- """For NodeTemplate one-to-many to RequirementTemplate"""
- return relationship.foreign_key('node_template')
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def relationship_template_fk(cls):
- """For RequirementTemplate one-to-one to RelationshipTemplate"""
- return relationship.foreign_key('relationship_template', nullable=True)
+ def node_template(cls):
+ return relationship.many_to_one(cls, 'node_template', fk='node_template_fk')
# endregion
+ # region many_to_many relationships
+
+ # endregion
+
+ target_capability_name = Column(Text)
+ target_node_template_constraints = Column(modeling_types.StrictList(FunctionType))
+
def find_target(self, source_node_template):
context = ConsumptionContext.get_thread_local()
@@ -1193,33 +1331,53 @@ class RelationshipTemplateBase(TemplateModelMixin):
__private_fields__ = ['type_fk']
- @declared_attr
- def relationships(cls):
- return relationship.one_to_many(cls, 'relationship')
+ # region foreign keys
@declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def type_fk(cls):
+ """For RelationshipTemplate many-to-one to Type"""
+ return relationship.foreign_key('type', nullable=True)
- description = Column(Text)
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+ def relationships(cls):
+ return relationship.one_to_many(cls, 'relationship')
@declared_attr
def interface_templates(cls):
return relationship.one_to_many(cls, 'interface_template', dict_key='name')
- # region foreign keys
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def type_fk(cls):
- """For RelationshipTemplate many-to-one to Type"""
- return relationship.foreign_key('type', nullable=True)
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
# endregion
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1294,10 +1452,39 @@ class CapabilityTemplateBase(TemplateModelMixin):
__private_fields__ = ['type_fk',
'node_template_fk']
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For CapabilityTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to CapabilityTemplate"""
+ return relationship.foreign_key('node_template')
+
+ # endregion
+
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
@declared_attr
def capabilities(cls):
return relationship.one_to_many(cls, 'capability')
+ # endregion
+
+ # region many_to_one relationships
+
@declared_attr
def node_template(cls):
return relationship.many_to_one(cls, 'node_template')
@@ -1306,9 +1493,9 @@ class CapabilityTemplateBase(TemplateModelMixin):
def type(cls):
return relationship.many_to_one(cls, 'type', back_populates=False)
- description = Column(Text)
- min_occurrences = Column(Integer, default=None) # optional
- max_occurrences = Column(Integer, default=None) # optional
+ # endregion
+
+ # region many_to_many relationships
@declared_attr
def valid_source_node_types(cls):
@@ -1318,20 +1505,12 @@ class CapabilityTemplateBase(TemplateModelMixin):
def properties(cls):
return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
- # region foreign keys
-
- @declared_attr
- def type_fk(cls):
- """For CapabilityTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
-
- @declared_attr
- def node_template_fk(cls):
- """For NodeTemplate one-to-many to CapabilityTemplate"""
- return relationship.foreign_key('node_template')
-
# endregion
+ description = Column(Text)
+ min_occurrences = Column(Integer, default=None) # optional
+ max_occurrences = Column(Integer, default=None) # optional
+
def satisfies_requirement(self,
source_node_template,
requirement,
@@ -1435,60 +1614,82 @@ class InterfaceTemplateBase(TemplateModelMixin):
'group_template_fk',
'relationship_template_fk']
- @declared_attr
- def interfaces(cls):
- return relationship.one_to_many(cls, 'interface')
+
+ # region foreign keys
@declared_attr
- def relationship_template(cls):
- return relationship.many_to_one(cls, 'relationship_template')
+ def type_fk(cls):
+ """For InterfaceTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
@declared_attr
- def group_template(cls):
- return relationship.many_to_one(cls, 'group_template')
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to InterfaceTemplate"""
+ return relationship.foreign_key('node_template', nullable=True)
@declared_attr
- def node_template(cls):
- return relationship.many_to_one(cls, 'node_template')
+ def group_template_fk(cls):
+ """For GroupTemplate one-to-many to InterfaceTemplate"""
+ return relationship.foreign_key('group_template', nullable=True)
@declared_attr
- def type(cls):
- return relationship.many_to_one(cls, 'type', back_populates=False)
+ def relationship_template_fk(cls):
+ """For RelationshipTemplate one-to-many to InterfaceTemplate"""
+ return relationship.foreign_key('relationship_template', nullable=True)
- description = Column(Text)
+ # endregion
+
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
- def inputs(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
+ def interfaces(cls):
+ return relationship.one_to_many(cls, 'interface')
@declared_attr
def operation_templates(cls):
return relationship.one_to_many(cls, 'operation_template', dict_key='name')
- # region foreign keys
+ # endregion
+
+ # region many_to_one relationships
@declared_attr
- def type_fk(cls):
- """For InterfaceTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
+ def relationship_template(cls):
+ return relationship.many_to_one(cls, 'relationship_template')
@declared_attr
- def node_template_fk(cls):
- """For NodeTemplate one-to-many to InterfaceTemplate"""
- return relationship.foreign_key('node_template', nullable=True)
+ def group_template(cls):
+ return relationship.many_to_one(cls, 'group_template')
@declared_attr
- def group_template_fk(cls):
- """For GroupTemplate one-to-many to InterfaceTemplate"""
- return relationship.foreign_key('group_template', nullable=True)
+ def node_template(cls):
+ return relationship.many_to_one(cls, 'node_template')
@declared_attr
- def relationship_template_fk(cls):
- """For RelationshipTemplate one-to-many to InterfaceTemplate"""
- return relationship.foreign_key('relationship_template', nullable=True)
+ def type(cls):
+ return relationship.many_to_one(cls, 'type', back_populates=False)
+
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def inputs(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
# endregion
+ description = Column(Text)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1569,52 +1770,71 @@ class OperationTemplateBase(TemplateModelMixin):
description = Column(Text)
+ # region foreign keys
+
@declared_attr
- def operations(cls):
- return relationship.one_to_many(cls, 'operation')
+ def service_template_fk(cls):
+ """For ServiceTemplate one-to-many to OperationTemplate"""
+ return relationship.foreign_key('service_template', nullable=True)
@declared_attr
- def service_template(cls):
- return relationship.many_to_one(cls, 'service_template')
+ def interface_template_fk(cls):
+ """For InterfaceTemplate one-to-many to OperationTemplate"""
+ return relationship.foreign_key('interface_template', nullable=True)
@declared_attr
- def interface_template(cls):
- return relationship.many_to_one(cls, 'interface_template')
+ def plugin_specification_fk(cls):
+ """For OperationTemplate one-to-one to PluginSpecification"""
+ return relationship.foreign_key('plugin_specification', nullable=True)
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
@declared_attr
def plugin_specification(cls):
- return relationship.one_to_one(cls, 'plugin_specification')
+ return relationship.one_to_one(cls, 'plugin_specification', back_populates=False)
- implementation = Column(Text)
- dependencies = Column(modeling_types.StrictList(item_cls=basestring))
+ # endregion
+
+ # region one_to_many relationships
@declared_attr
- def inputs(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
+ def operations(cls):
+ return relationship.one_to_many(cls, 'operation')
- executor = Column(Text)
- max_retries = Column(Integer)
- retry_interval = Column(Integer)
+ # endregion
- # region foreign keys
+ # region many_to_one relationships
@declared_attr
- def service_template_fk(cls):
- """For ServiceTemplate one-to-many to OperationTemplate"""
- return relationship.foreign_key('service_template', nullable=True)
+ def service_template(cls):
+ return relationship.many_to_one(cls, 'service_template')
@declared_attr
- def interface_template_fk(cls):
- """For InterfaceTemplate one-to-many to OperationTemplate"""
- return relationship.foreign_key('interface_template', nullable=True)
+ def interface_template(cls):
+ return relationship.many_to_one(cls, 'interface_template')
+
+ # endregion
+
+ # region many_to_many relationships
@declared_attr
- def plugin_specification_fk(cls):
- """For OperationTemplate one-to-one to PluginSpecification"""
- return relationship.foreign_key('plugin_specification', nullable=True)
+ def inputs(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name')
# endregion
+ implementation = Column(Text)
+ dependencies = Column(modeling_types.StrictList(item_cls=basestring))
+ executor = Column(Text)
+ max_retries = Column(Integer)
+ retry_interval = Column(Integer)
+
@property
def as_raw(self):
return collections.OrderedDict((
@@ -1701,10 +1921,38 @@ class ArtifactTemplateBase(TemplateModelMixin):
__private_fields__ = ['type_fk',
'node_template_fk']
+ # region foreign keys
+
+ @declared_attr
+ def type_fk(cls):
+ """For ArtifactTemplate many-to-one to Type"""
+ return relationship.foreign_key('type')
+
+ @declared_attr
+ def node_template_fk(cls):
+ """For NodeTemplate one-to-many to ArtifactTemplate"""
+ return relationship.foreign_key('node_template')
+
+ # endregion
+
+ # region association proxies
+
+ # endregion
+
+ # region one_to_one relationships
+
+ # endregion
+
+ # region one_to_many relationships
+
@declared_attr
def artifacts(cls):
return relationship.one_to_many(cls, 'artifact')
+ # endregion
+
+ # region many_to_one relationships
+
@declared_attr
def node_template(cls):
return relationship.many_to_one(cls, 'node_template')
@@ -1713,29 +1961,25 @@ class ArtifactTemplateBase(TemplateModelMixin):
def type(cls):
return relationship.many_to_one(cls, 'type', back_populates=False)
+ # endregion
+
+ # region many_to_many relationships
+
+ @declared_attr
+ def properties(cls):
+ return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
+
+ # endregion
+
description = Column(Text)
source_path = Column(Text)
target_path = Column(Text)
repository_url = Column(Text)
repository_credential = Column(modeling_types.StrictDict(basestring, basestring))
- @declared_attr
- def properties(cls):
- return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name')
- # region foreign keys
-
- @declared_attr
- def type_fk(cls):
- """For ArtifactTemplate many-to-one to Type"""
- return relationship.foreign_key('type')
- @declared_attr
- def node_template_fk(cls):
- """For NodeTemplate one-to-many to ArtifactTemplate"""
- return relationship.foreign_key('node_template')
- # endregion
@property
def as_raw(self):