Repository: incubator-ariatosca Updated Branches: refs/heads/ARIA-132-Models-cascading-deletion-raises-constraint-errors f86477e1f -> bc8d5535f
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/bc8d5535 Tree: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/tree/bc8d5535 Diff: http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/diff/bc8d5535 Branch: refs/heads/ARIA-132-Models-cascading-deletion-raises-constraint-errors Commit: bc8d5535fc3a48cff269cbe65003620910514900 Parents: f86477e Author: max-orlov <[email protected]> Authored: Mon Mar 27 14:36:37 2017 +0300 Committer: max-orlov <[email protected]> Committed: Mon Mar 27 14:36:37 2017 +0300 ---------------------------------------------------------------------- aria/modeling/service_changes.py | 92 +++- aria/modeling/service_instance.py | 808 ++++++++++++++++++++------------- aria/modeling/service_template.py | 772 ++++++++++++++++++++----------- 3 files changed, 1078 insertions(+), 594 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-ariatosca/blob/bc8d5535/aria/modeling/service_changes.py ---------------------------------------------------------------------- diff --git a/aria/modeling/service_changes.py b/aria/modeling/service_changes.py index d81ed98..0eb8972 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,27 @@ 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 + pass + @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/bc8d5535/aria/modeling/service_instance.py ---------------------------------------------------------------------- diff --git a/aria/modeling/service_instance.py b/aria/modeling/service_instance.py index d9a8d88..df446d9 100644 --- a/aria/modeling/service_instance.py +++ b/aria/modeling/service_instance.py @@ -90,6 +90,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') + + # endregion + + # region one_to_many relationships @declared_attr def updates(cls): return relationship.one_to_many(cls, 'service_update') @@ -107,17 +139,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') @@ -130,8 +151,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): @@ -142,13 +179,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) @@ -159,29 +196,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(): @@ -363,27 +377,52 @@ class NodeBase(InstanceModelMixin): # pylint: disable=too-many-public-methods 'node_template_fk', 'service_name'] + # 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): @@ -407,12 +446,32 @@ class NodeBase(InstanceModelMixin): # pylint: disable=too-many-public-methods return relationship.one_to_many( cls, 'relationship', child_fk='target_node_fk', child_property='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(Text, nullable=False) @@ -434,41 +493,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 @@ -629,9 +653,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): @@ -645,7 +704,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): @@ -655,29 +716,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(( @@ -732,9 +774,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): @@ -748,7 +821,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): @@ -762,25 +837,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(( @@ -834,33 +894,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') @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 @@ -912,22 +992,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 @@ -952,6 +1016,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') + + @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') + + # 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(( @@ -1024,51 +1124,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 @@ -1117,6 +1172,63 @@ class RelationshipBase(InstanceModelMixin): # endregion + # region one_to_one relationships + + @declared_attr + def target_capability(cls): + return relationship.one_to_one(cls, 'capability') + + # 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(( @@ -1192,26 +1304,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 @@ -1231,6 +1323,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: @@ -1306,36 +1438,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 @@ -1365,6 +1467,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(( @@ -1433,59 +1585,79 @@ class OperationBase(InstanceModelMixin): 'plugin_fk', 'operation_template_fk'] + # region foreign_keys + @declared_attr - def service(cls): - return relationship.many_to_one(cls, 'service') + def service_fk(cls): + """For Service one-to-many to Operation""" + return relationship.foreign_key('service', nullable=True) @declared_attr - def interface(cls): - return relationship.many_to_one(cls, 'interface') + def interface_fk(cls): + """For Interface one-to-many to Operation""" + return relationship.foreign_key('interface', nullable=True) @declared_attr - def operation_template(cls): - return relationship.many_to_one(cls, 'operation_template') + def plugin_specification_fk(cls): + """For Operation one-to-one to PluginSpecification""" + return relationship.foreign_key('plugin_specification', nullable=True) - description = Column(Text) + @declared_attr + def operation_template_fk(cls): + """For Operation many-to-one to OperationTemplate""" + return relationship.foreign_key('operation_template', 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') - implementation = Column(Text) - dependencies = Column(modeling_types.StrictList(item_cls=basestring)) + # endregion - @declared_attr - def inputs(cls): - return relationship.many_to_many(cls, 'parameter', prefix='inputs', dict_key='name') + # region one_to_many relationships - executor = Column(Text) - max_retries = Column(Integer) - retry_interval = Column(Integer) + # endregion - # region foreign_keys + # region many_to_one relationships @declared_attr - def service_fk(cls): - """For Service one-to-many to Operation""" - return relationship.foreign_key('service', nullable=True) + def service(cls): + return relationship.many_to_one(cls, 'service') @declared_attr - def interface_fk(cls): - """For Interface one-to-many to Operation""" - return relationship.foreign_key('interface', nullable=True) + def interface(cls): + return relationship.many_to_one(cls, 'interface') @declared_attr - def plugin_specification_fk(cls): - """For Operation one-to-one to PluginSpecification""" - return relationship.foreign_key('plugin_specification', nullable=True) + def operation_template(cls): + return relationship.many_to_one(cls, 'operation_template') + + # endregion + + # region many_to_many relationships @declared_attr - def operation_template_fk(cls): - """For Operation many-to-one to OperationTemplate""" - return relationship.foreign_key('operation_template', nullable=True) + 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(( @@ -1563,28 +1735,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 @@ -1604,6 +1754,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/bc8d5535/aria/modeling/service_template.py ---------------------------------------------------------------------- diff --git a/aria/modeling/service_template.py b/aria/modeling/service_template.py index f3af0d2..302248b 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') @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 + + # endregion + + # region one_to_one relationships + + # endregion + + # region one_to_many relationships @declared_attr - def group_templates(cls): - return relationship.many_to_many(cls, 'group_template') + def policies(cls): + return relationship.one_to_many(cls, 'policy') + + # endregion + + # region many_to_one relationships @declared_attr - def properties(cls): - return relationship.many_to_many(cls, 'parameter', prefix='properties', dict_key='name') + def service_template(cls): + return relationship.many_to_one(cls, 'service_template') - # region foreign keys + @declared_attr + def type(cls): + return relationship.many_to_one(cls, 'type', back_populates=False) + + # endregion + + # region many_to_many relationships @declared_attr - def type_fk(cls): - """For PolicyTemplate many-to-one to Type""" - return relationship.foreign_key('type') + def node_templates(cls): + return relationship.many_to_many(cls, 'node_template') @declared_attr - def service_template_fk(cls): - """For ServiceTemplate one-to-many to PolicyTemplate""" - return relationship.foreign_key('service_template') + 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') + + @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') + + # 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') - # 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') - 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):
