issue #21, finish renaming parameter to parameter_definition, version…

… bump

spinedb_api/database_mapping_check_mixin.py

@@ -425,7 +425,7 @@ def check_parameter_definitions_for_insert(self, *items, strict=False):
         checked_items = list()
         obj_parameter_definition_names = {}
         rel_parameter_definition_names = {}
-        for x in self.parameter_list():
+        for x in self.parameter_definition_list():
             if x.object_class_id:
                 obj_parameter_definition_names[x.object_class_id, x.name] = x.id
             elif x.relationship_class_id:
@@ -473,10 +473,10 @@ def check_parameter_definitions_for_update(self, *items, strict=False):
         """
         intgr_error_log = []
         checked_items = list()
-        parameter_list = self.parameter_list()  # Query db only once
+        parameter_definition_list = self.parameter_definition_list()  # Query db only once
         obj_parameter_definition_names = {}
         rel_parameter_definition_names = {}
-        for x in parameter_list:
+        for x in parameter_definition_list:
             if x.object_class_id:
                 obj_parameter_definition_names[x.object_class_id, x.name] = x.id
             elif x.relationship_class_id:
@@ -489,7 +489,7 @@ def check_parameter_definitions_for_update(self, *items, strict=False):
                 "parameter_value_list_id": x.parameter_value_list_id,
                 "default_value": x.default_value,
             }
-            for x in parameter_list
+            for x in parameter_definition_list
         }
         object_class_dict = {x.id: x.name for x in self.object_class_list()}
         relationship_class_dict = {x.id: x.name for x in self.wide_relationship_class_list()}
@@ -578,7 +578,7 @@ def check_parameter_values_for_insert(self, *items, strict=False):
                 "relationship_class_id": x.relationship_class_id,
                 "parameter_value_list_id": x.parameter_value_list_id,
             }
-            for x in self.parameter_list()
+            for x in self.parameter_definition_list()
         }
         object_dict = {x.id: {"class_id": x.class_id, "name": x.name} for x in self.object_list()}
         relationship_dict = {x.id: {"class_id": x.class_id, "name": x.name} for x in self.wide_relationship_list()}
@@ -649,7 +649,7 @@ def check_parameter_values_for_update(self, *items, strict=False):
                 "relationship_class_id": x.relationship_class_id,
                 "parameter_value_list_id": x.parameter_value_list_id,
             }
-            for x in self.parameter_list()
+            for x in self.parameter_definition_list()
         }
         object_dict = {x.id: {"class_id": x.class_id, "name": x.name} for x in self.object_list()}
         relationship_dict = {x.id: {"class_id": x.class_id, "name": x.name} for x in self.wide_relationship_list()}
@@ -811,7 +811,7 @@ def check_parameter_definition_tags_for_insert(self, *items, strict=False):
         parameter_definition_tags = {
             (x.parameter_definition_id, x.parameter_tag_id): x.id for x in self.parameter_definition_tag_list()
         }
-        parameter_name_dict = {x.id: x.name for x in self.parameter_list()}
+        parameter_name_dict = {x.id: x.name for x in self.parameter_definition_list()}
         parameter_tag_dict = {x.id: x.tag for x in self.parameter_tag_list()}
         for item in items:
             try:

spinedb_api/database_mapping_query_mixin.py

@@ -26,7 +26,6 @@
 # TODO: Maybe handle errors in queries
 # TODO: Improve docstrings
 
-import warnings
 from sqlalchemy import false, distinct, func, or_
 
 
@@ -38,68 +37,6 @@ def __init__(self, *args, **kwargs):
         """Initialize class."""
         super().__init__(*args, **kwargs)
 
-    def single_parameter_definition(self, id=None, name=None):
-        """Return parameter corresponding to id."""
-        qry = self.query(self.parameter_definition_sq)
-        if id:
-            return qry.filter(self.parameter_definition_sq.c.id == id)
-        if name:
-            return qry.filter(self.parameter_definition_sq.c.name == name)
-        return self._empty_list()
-
-    def single_object_parameter_definition(self, id):
-        """Return object class and the parameter corresponding to id."""
-        return self.object_parameter_definition_list().filter(self.parameter_definition_sq.c.id == id)
-
-    def single_relationship_parameter_definition(self, id):
-        """Return relationship class and the parameter corresponding to id."""
-        return self.relationship_parameter_definition_list().filter(self.parameter_definition_sq.c.id == id)
-
-    def single_parameter(self, id=None, name=None):
-        warnings.warn("single_parameter is deprecated, use single_parameter_definition instead", DeprecationWarning)
-        return self.single_parameter_definition(id=id, name=name)
-
-    def single_object_parameter(self, id):
-        warnings.warn(
-            "single_object_parameter is deprecated, use single_object_parameter_definition instead", DeprecationWarning
-        )
-        return self.single_object_parameter_definition(id)
-
-    def single_relationship_parameter(self, id):
-        warnings.warn(
-            "single_relationship_parameter is deprecated, use single_relationship_parameter_definition instead",
-            DeprecationWarning,
-        )
-        return self.single_relationship_parameter_definition(id)
-
-    def single_parameter_value(self, id=None):
-        """Return parameter value corresponding to id."""
-        if id:
-            return self.parameter_value_list().filter(self.parameter_value_sq.c.id == id)
-        return self._empty_list()
-
-    def single_object_parameter_value(self, id=None, parameter_id=None, parameter_definition_id=None, object_id=None):
-        """Return object and the parameter value, either corresponding to id,
-        or to parameter_id and object_id.
-        """
-        if parameter_definition_id is None and parameter_id is not None:
-            parameter_definition_id = parameter_id
-            warnings.warn(
-                "the parameter_id argument is deprecated, use parameter_definition_id instead", DeprecationWarning
-            )
-        qry = self.object_parameter_value_list()
-        if id:
-            return qry.filter(self.parameter_value_sq.c.id == id)
-        if parameter_definition_id and object_id:
-            return qry.filter(self.parameter_value_sq.c.parameter_definition_id == parameter_definition_id).filter(
-                self.parameter_value_sq.c.object_id == object_id
-            )
-        return self._empty_list()
-
-    def single_relationship_parameter_value(self, id):
-        """Return relationship and the parameter value corresponding to id."""
-        return self.relationship_parameter_value_list().filter(self.parameter_value_sq.c.id == id)
-
     def object_class_list(self, id_list=None, ordered=True):
         """Return object classes ordered by display order."""
         qry = self.query(self.object_class_sq)
@@ -141,7 +78,6 @@ def wide_relationship_class_list(self, id_list=None, object_class_id=None):
                     self.wide_relationship_class_sq.c.object_class_id_list == object_class_id,
                 )
             )
-
         return qry
 
     def relationship_list(self, id=None, ordered=True):
@@ -182,57 +118,24 @@ def parameter_definition_list(self, id_list=None, object_class_id=None, relation
             qry = qry.filter(self.parameter_definition_sq.c.relationship_class_id == relationship_class_id)
         return qry
 
-    def object_parameter_definition_list(self, object_class_id=None, parameter_id=None, parameter_definition_id=None):
+    def object_parameter_definition_list(self, object_class_id=None, parameter_definition_id=None):
         """Return object classes and their parameters."""
-        if parameter_definition_id is None and parameter_id is not None:
-            parameter_definition_id = parameter_id
-            warnings.warn(
-                "the parameter_id argument is deprecated, use parameter_definition_id instead", DeprecationWarning
-            )
         qry = self.query(self.object_parameter_definition_sq)
         if object_class_id:
             qry = qry.filter(self.object_parameter_definition_sq.c.object_class_id == object_class_id)
-        if parameter_id:
+        if parameter_definition_id:
             qry = qry.filter(self.object_parameter_definition_sq.c.id == parameter_id)
         return qry
 
-    def relationship_parameter_definition_list(
-        self, relationship_class_id=None, parameter_id=None, parameter_definition_id=None
-    ):
+    def relationship_parameter_definition_list(self, relationship_class_id=None, parameter_definition_id=None):
         """Return relationship classes and their parameters."""
-        if parameter_definition_id is None and parameter_id is not None:
-            parameter_definition_id = parameter_id
-            warnings.warn(
-                "the parameter_id argument is deprecated, use parameter_definition_id instead", DeprecationWarning
-            )
         qry = self.query(self.relationship_parameter_definition_sq)
         if relationship_class_id:
             qry = qry.filter(self.relationship_parameter_definition_sq.c.relationship_class_id == relationship_class_id)
-        if parameter_id:
+        if parameter_definition_id:
             qry = qry.filter(self.relationship_parameter_definition_sq.c.id == parameter_id)
         return qry
 
-    def parameter_list(self, id_list=None, object_class_id=None, relationship_class_id=None):
-        warnings.warn("parameter_list is deprecated, use parameter_definition_list instead", DeprecationWarning)
-        return self.parameter_definition_list(
-            id_list=id_list, object_class_id=object_class_id, relationship_class_id=relationship_class_id
-        )
-
-    def object_parameter_list(self, object_class_id=None, parameter_id=None):
-        warnings.warn(
-            "object_parameter_list is deprecated, use object_parameter_definition_list instead", DeprecationWarning
-        )
-        return self.object_parameter_definition_list(object_class_id=object_class_id, parameter_id=parameter_id)
-
-    def relationship_parameter_list(self, relationship_class_id=None, parameter_id=None):
-        warnings.warn(
-            "relationship_parameter_list is deprecated, use relationship_parameter_definition_list instead",
-            DeprecationWarning,
-        )
-        return self.relationship_parameter_definition_list(
-            relationship_class_id=relationship_class_id, parameter_id=parameter_id
-        )
-
     def wide_object_parameter_definition_list(self, object_class_id_list=None, parameter_definition_id_list=None):
         """Return object classes and their parameter definitions in wide format."""
         qry = self.query(
@@ -300,78 +203,6 @@ def relationship_parameter_value_list(self, parameter_name=None):
             qry = qry.filter(self.relationship_parameter_value_sq.c.parameter_name == parameter_name)
         return qry
 
-    # TODO: Is this one needed?
-    def all_object_parameter_value_list(self, parameter_id=None):
-        """Return all object parameter values, even those that don't have a value."""
-        qry = (
-            self.query(
-                self.parameter_definition_sq.c.id.label("parameter_id"),
-                self.object_sq.c.name.label("object_name"),
-                self.parameter_value_sq.c.id.label("parameter_value_id"),
-                self.parameter_definition_sq.c.name.label("parameter_name"),
-                self.parameter_value_sq.c.value,
-            )
-            .filter(self.parameter_value_sq.c.object_id == self.object_sq.c.id)
-            .outerjoin(self.parameter_value_sq)
-            .filter(self.parameter_definition_sq.c.id == self.parameter_value_sq.c.parameter_definition_id)
-        )
-        if parameter_id:
-            qry = qry.filter(self.parameter_definition_sq.c.id == parameter_id)
-        return qry
-
-    # TODO: Aren't all these unvalued_ methods obsolete?
-    def unvalued_object_parameter_list(self, object_id):
-        """Return parameters that do not have a value for given object."""
-        object_ = self.single_object(id=object_id).one_or_none()
-        if not object_:
-            return self._empty_list()
-        valued_parameter_ids = self.query(self.parameter_value_sq.c.parameter_definition_id).filter(
-            self.parameter_value_sq.c.object_id == object_id
-        )
-        return self.parameter_definition_list(object_class_id=object_.class_id).filter(
-            ~self.parameter_definition_sq.c.id.in_(valued_parameter_ids)
-        )
-
-    def unvalued_object_list(self, parameter_id):
-        """Return objects for which given parameter does not have a value."""
-        parameter = self.single_parameter(parameter_id).one_or_none()
-        if not parameter:
-            return self._empty_list()
-        valued_object_ids = self.query(self.parameter_value_sq.c.object_id).filter(
-            self.parameter_value_sq.c.parameter_definition_id == parameter_id
-        )
-        return (
-            self.object_list()
-            .filter(self.object_sq.c.class_id == parameter.object_class_id)
-            .filter(~self.object_sq.c.id.in_(valued_object_ids))
-        )
-
-    def unvalued_relationship_parameter_list(self, relationship_id):
-        """Return parameters that do not have a value for given relationship."""
-        relationship = self.single_wide_relationship(id=relationship_id).one_or_none()
-        if not relationship:
-            return self._empty_list()
-        valued_parameter_ids = self.query(self.parameter_value_sq.c.parameter_definition_id).filter(
-            self.parameter_value_sq.relationship_id == relationship_id
-        )
-        return self.parameter_definition_list(relationship_class_id=relationship.class_id).filter(
-            ~self.parameter_definition_sq.c.id.in_(valued_parameter_ids)
-        )
-
-    def unvalued_relationship_list(self, parameter_id):
-        """Return relationships for which given parameter does not have a value."""
-        parameter = self.single_parameter(parameter_id).one_or_none()
-        if not parameter:
-            return self._empty_list()
-        valued_relationship_ids = self.query(self.parameter_value_sq.c.relationship_id).filter(
-            self.parameter_value_sq.c.parameter_definition_id == parameter_id
-        )
-        return (
-            self.wide_relationship_list()
-            .filter(self.relationship_sq.c.class_id == parameter.relationship_class_id)
-            .filter(~self.relationship_sq.c.id.in_(valued_relationship_ids))
-        )
-
     def parameter_tag_list(self, id_list=None, tag_list=None):
         """Return list of parameter tags."""
         qry = self.query(self.parameter_tag_sq)
@@ -419,11 +250,11 @@ def wide_parameter_value_list_list(self, id_list=None):
 
     def object_parameter_fields(self):
         """Return object parameter fields."""
-        return [x["name"] for x in self.object_parameter_list().column_descriptions]
+        return [x["name"] for x in self.object_parameter_definition_list().column_descriptions]
 
     def relationship_parameter_fields(self):
         """Return relationship parameter fields."""
-        return [x["name"] for x in self.relationship_parameter_list().column_descriptions]
+        return [x["name"] for x in self.relationship_parameter_definition_list().column_descriptions]
 
     def object_parameter_value_fields(self):
         """Return object parameter value fields."""

spinedb_api/diff_database_mapping_add_mixin.py

@@ -333,13 +333,13 @@ def add_parameter_definitions(self, *kwargs_list, strict=False, return_dups=Fals
             intgr_error_log (list): list of integrity error messages
         """
         checked_kwargs_list, intgr_error_log = self.check_parameter_definitions_for_insert(*kwargs_list, strict=strict)
-        id_list = self._add_parameters(*checked_kwargs_list)
+        id_list = self._add_parameter_definitions(*checked_kwargs_list)
         if return_dups:
             id_list.update(set(x.id for x in intgr_error_log if x.id))
-        new_item_list = self.parameter_list(id_list=id_list)
+        new_item_list = self.parameter_definition_list(id_list=id_list)
         return new_item_list, intgr_error_log
 
-    def _add_parameters(self, *kwargs_list):
+    def _add_parameter_definitions(self, *kwargs_list):
         """Add parameters to database without checking integrity.
 
         Args:
@@ -371,10 +371,6 @@ def _add_parameters(self, *kwargs_list):
             msg = "DBAPIError while inserting parameters: {}".format(e.orig.args)
             raise SpineDBAPIError(msg)
 
-    def add_parameters(self, *kwargs_list, strict=False, return_dups=False):
-        warnings.warn("add_parameters is deprecated, use add_parameter_definitions instead", DeprecationWarning)
-        return self.add_parameter_definitions(*kwargs_list, strict=strict, return_dups=return_dups)
-
     def add_parameter_values(self, *kwargs_list, strict=False, return_dups=False):
         """Add parameter values to database.
 
@@ -388,10 +384,6 @@ def add_parameter_values(self, *kwargs_list, strict=False, return_dups=False):
             parameter_values (list): added instances
             intgr_error_log (list): list of integrity error messages
         """
-        # FIXME: this should be removed once the 'parameter_definition_id' comes in the kwargs
-        for kwargs in kwargs_list:
-            if "parameter_id" in kwargs:
-                kwargs["parameter_definition_id"] = kwargs["parameter_id"]
         checked_kwargs_list, intgr_error_log = self.check_parameter_values_for_insert(*kwargs_list, strict=strict)
         id_list = self._add_parameter_values(*checked_kwargs_list)
         if return_dups:
@@ -592,8 +584,8 @@ def add_wide_relationship_class(self, **kwargs):
     def add_wide_relationship(self, **kwargs):
         return self.add_wide_relationships(kwargs, strict=True)[0].one_or_none()
 
-    def add_parameter(self, **kwargs):
-        return self.add_parameters(kwargs, strict=True)[0].one_or_none()
+    def add_parameter_definition(self, **kwargs):
+        return self.add_parameter_definitions(kwargs, strict=True)[0].one_or_none()
 
     def add_parameter_value(self, **kwargs):
         return self.add_parameter_values(kwargs, strict=True)[0].one_or_none()
@@ -604,5 +596,5 @@ def get_or_add_object_class(self, **kwargs):
     def get_or_add_object(self, **kwargs):
         return self.add_objects(kwargs, return_dups=True)[0].one_or_none()
 
-    def get_or_add_parameter(self, **kwargs):
-        return self.add_parameters(kwargs, return_dups=True)[0].one_or_none()
+    def get_or_add_parameter_definition(self, **kwargs):
+        return self.add_parameter_definitions(kwargs, return_dups=True)[0].one_or_none()

spinedb_api/diff_database_mapping_remove_mixin.py

@@ -43,7 +43,7 @@ def remove_items(
         object_ids=set(),
         relationship_class_ids=set(),
         relationship_ids=set(),
-        parameter_ids=set(),
+        parameter_definition_ids=set(),
         parameter_value_ids=set(),
         parameter_tag_ids=set(),
         parameter_definition_tag_ids=set(),
@@ -55,7 +55,7 @@ def remove_items(
             object_ids=object_ids,
             relationship_class_ids=relationship_class_ids,
             relationship_ids=relationship_ids,
-            parameter_definition_ids=parameter_ids,
+            parameter_definition_ids=parameter_definition_ids,
             parameter_value_ids=parameter_value_ids,
             parameter_tag_ids=parameter_tag_ids,
             parameter_definition_tag_ids=parameter_definition_tag_ids,

spinedb_api/diff_database_mapping_update_mixin.py

@@ -254,7 +254,7 @@ def _update_parameter_values(self, *checked_kwargs_list):
                 self.ParameterValue,
                 self.DiffParameterValue,
                 checked_kwargs_list,
-                unhandled_fields=("object_id", "relationship_id", "parameter_id"),
+                unhandled_fields=("object_id", "relationship_id", "parameter_definition_id"),
             )
             self.session.bulk_update_mappings(self.DiffParameterValue, items_for_update)
             self.session.bulk_insert_mappings(self.DiffParameterValue, items_for_insert)