Enable creating attributes from attribute templates

implemented with the __call__ magic method. By default:
- name is inherited
- attribute is linked to the attribute template that created it

Author: dyllamt

taurus/entity/template/condition_template.py

@@ -1,7 +1,28 @@
 from taurus.entity.template.attribute_template import AttributeTemplate
+from taurus.entity.attribute.condition import Condition
 
 
 class ConditionTemplate(AttributeTemplate):
     """A template for a condition attribute."""
 
     typ = "condition_template"
+
+    def __call__(
+        self, name=None, template=None, origin="unknown", value=None, notes=None, file_links=None
+    ):
+        """Produces a condition that is linked to this condition template."""
+
+        if not name:  # inherit name from the template by default
+            name = self.name
+
+        if not template:  # link the condition to this template by default
+            template = self
+
+        return Condition(
+            name=name,
+            template=template,
+            origin=origin,
+            value=value,
+            notes=notes,
+            file_links=file_links,
+        )

taurus/entity/template/parameter_template.py

@@ -1,7 +1,28 @@
 from taurus.entity.template.attribute_template import AttributeTemplate
+from taurus.entity.attribute.parameter import Parameter
 
 
 class ParameterTemplate(AttributeTemplate):
     """A template for the parameter attribute."""
 
     typ = "parameter_template"
+
+    def __call__(
+        self, name=None, template=None, origin="unknown", value=None, notes=None, file_links=None
+    ):
+        """Produces a parameter that is linked to this parameter template."""
+
+        if not name:  # inherit name from the template by default
+            name = self.name
+
+        if not template:  # link the parameter to this template by default
+            template = self
+
+        return Parameter(
+            name=name,
+            template=template,
+            origin=origin,
+            value=value,
+            notes=notes,
+            file_links=file_links,
+        )

taurus/entity/template/property_template.py

@@ -1,7 +1,28 @@
 from taurus.entity.template.attribute_template import AttributeTemplate
+from taurus.entity.attribute.property import Property
 
 
 class PropertyTemplate(AttributeTemplate):
     """A template for the property attribute."""
 
     typ = "property_template"
+
+    def __call__(
+        self, name=None, template=None, origin="unknown", value=None, notes=None, file_links=None
+    ):
+        """Produces a property that is linked to this template."""
+
+        if not name:  # inherit name from the template by default
+            name = self.name
+
+        if not template:  # link the property to this template by default
+            template = self
+
+        return Property(
+            name=name,
+            template=template,
+            origin=origin,
+            value=value,
+            notes=notes,
+            file_links=file_links,
+        )

taurus/entity/template/tests/test_condition_template.py

@@ -0,0 +1,21 @@
+"""Test of the condition template."""
+from taurus.entity.template.condition_template import ConditionTemplate
+from taurus.entity.bounds.categorical_bounds import CategoricalBounds
+from taurus.entity.value.nominal_categorical import NominalCategorical
+
+
+condition_template = ConditionTemplate(
+    name="test_template", bounds=CategoricalBounds(["True", "False"])
+)
+
+
+def test_creating_condition():
+    """Test creating a condition from a condition template."""
+
+    condition = condition_template()  # by default, inherit name and the template
+    assert condition.name == condition_template.name
+    assert condition.template is condition_template
+
+    condition = condition_template(name='other name', value=NominalCategorical('True'))
+    assert condition.name != condition_template.name
+    assert condition.name is not None

taurus/entity/template/tests/test_parameter_template.py

@@ -0,0 +1,21 @@
+"""Test of the parameter template."""
+from taurus.entity.template.parameter_template import ParameterTemplate
+from taurus.entity.bounds.categorical_bounds import CategoricalBounds
+from taurus.entity.value.nominal_categorical import NominalCategorical
+
+
+parameter_template = ParameterTemplate(
+    name="test_template", bounds=CategoricalBounds(["True", "False"])
+)
+
+
+def test_creating_parameter():
+    """Test creating a parameter from a parameter template."""
+
+    parameter = parameter_template()  # by default, inherit name and the template
+    assert parameter.name == parameter_template.name
+    assert parameter.template is parameter_template
+
+    parameter = parameter_template(name='other name', value=NominalCategorical('True'))
+    assert parameter.name != parameter_template.name
+    assert parameter.name is not None

taurus/entity/template/tests/test_property_template.py

@@ -0,0 +1,21 @@
+"""Test of the property template."""
+from taurus.entity.template.property_template import PropertyTemplate
+from taurus.entity.bounds.categorical_bounds import CategoricalBounds
+from taurus.entity.value.nominal_categorical import NominalCategorical
+
+
+property_template = PropertyTemplate(
+    name="test_template", bounds=CategoricalBounds(["True", "False"])
+)
+
+
+def test_creating_property():
+    """Test creating a property from a property template."""
+
+    property = property_template()  # by default, inherit name and the template
+    assert property.name == property_template.name
+    assert property.template is property_template
+
+    property = property_template(name='other name', value=NominalCategorical('True'))
+    assert property.name != property_template.name
+    assert property.name is not None