From 3a8f95b4fe78a3891609248caf1f2c6bae8835fa Mon Sep 17 00:00:00 2001 From: Manuel Marin Date: Wed, 5 Jun 2019 16:45:55 -0400 Subject: [PATCH] issue #21, finish renaming parameter to parameter_definition, version bump --- spinedb_api/database_mapping_check_mixin.py | 14 +- spinedb_api/database_mapping_query_mixin.py | 181 +----------------- .../diff_database_mapping_add_mixin.py | 22 +-- .../diff_database_mapping_remove_mixin.py | 4 +- .../diff_database_mapping_update_mixin.py | 2 +- spinedb_api/import_functions.py | 4 +- spinedb_api/version.py | 2 +- test/test_import_functions.py | 22 ++- 8 files changed, 39 insertions(+), 212 deletions(-) diff --git a/spinedb_api/database_mapping_check_mixin.py b/spinedb_api/database_mapping_check_mixin.py index 55306338..0e834944 100644 --- a/spinedb_api/database_mapping_check_mixin.py +++ b/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: diff --git a/spinedb_api/database_mapping_query_mixin.py b/spinedb_api/database_mapping_query_mixin.py index 7ffa8c35..2ec24b36 100644 --- a/spinedb_api/database_mapping_query_mixin.py +++ b/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.""" diff --git a/spinedb_api/diff_database_mapping_add_mixin.py b/spinedb_api/diff_database_mapping_add_mixin.py index a5f037d9..6c26b123 100644 --- a/spinedb_api/diff_database_mapping_add_mixin.py +++ b/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() diff --git a/spinedb_api/diff_database_mapping_remove_mixin.py b/spinedb_api/diff_database_mapping_remove_mixin.py index 2bbd1ae5..116daf95 100644 --- a/spinedb_api/diff_database_mapping_remove_mixin.py +++ b/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, diff --git a/spinedb_api/diff_database_mapping_update_mixin.py b/spinedb_api/diff_database_mapping_update_mixin.py index 7ac15878..690a6eeb 100644 --- a/spinedb_api/diff_database_mapping_update_mixin.py +++ b/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) diff --git a/spinedb_api/import_functions.py b/spinedb_api/import_functions.py index 7303b710..7c179c6d 100644 --- a/spinedb_api/import_functions.py +++ b/spinedb_api/import_functions.py @@ -282,7 +282,7 @@ def import_object_parameters(db_map, parameter_data): except SpineIntegrityError as e: # Object class doesn't exists error_log.append(ImportErrorLogItem(msg=e.msg, db_type="parameter")) - added = db_map._add_parameters(*new_parameters) + added = db_map._add_parameter_definitions(*new_parameters) return len(added), error_log @@ -331,7 +331,7 @@ def import_relationship_parameters(db_map, parameter_data): except SpineIntegrityError as e: # Relationship class doesn't exists error_log.append(ImportErrorLogItem(msg=e.msg, db_type="parameter")) - added = db_map._add_parameters(*new_parameters) + added = db_map._add_parameter_definitions(*new_parameters) return len(added), error_log diff --git a/spinedb_api/version.py b/spinedb_api/version.py index 15331024..573b11cd 100644 --- a/spinedb_api/version.py +++ b/spinedb_api/version.py @@ -1 +1 @@ -__version__ = "0.0.26" +__version__ = "0.0.27" diff --git a/test/test_import_functions.py b/test/test_import_functions.py index d5e368ef..a9713152 100644 --- a/test/test_import_functions.py +++ b/test/test_import_functions.py @@ -102,7 +102,7 @@ def create_mock_db_map(): db_map.add_object_classes.return_value = [query, []] db_map.add_objects.return_value = [query, []] db_map.add_wide_relationship_classes.return_value = [query, []] - db_map.add_parameters.return_value = [query, []] + db_map.add_parameter_definitions.return_value = [query, []] db_map.add_wide_relationships.return_value = [query, []] db_map.add_parameter_values.return_value = [query, []] db_map.update_parameter_values.return_value = [query, []] @@ -247,26 +247,28 @@ def tearDown(self): def test_import_valid_object_class_parameter(self): num_imported, errors = import_object_parameters(self.mock_db_map, [["existing_oc1", "new_parameter"]]) - self.mock_db_map._add_parameters.assert_called_once_with({"name": "new_parameter", "object_class_id": 1}) + self.mock_db_map._add_parameter_definitions.assert_called_once_with( + {"name": "new_parameter", "object_class_id": 1} + ) self.assertEqual(len(errors), 0) def test_import_parameter_with_invalid_object_class_name(self): num_imported, errors = import_object_parameters(self.mock_db_map, [["new_parameter", "invalid_object_class"]]) - self.mock_db_map._add_parameters.assert_called_once() + self.mock_db_map._add_parameter_definitions.assert_called_once() self.assertEqual(len(errors), 1) def test_import_object_class_parameter_name_twice(self): num_imported, errors = import_object_parameters( self.mock_db_map, [["existing_oc1", "new_parameter"], ["existing_oc2", "new_parameter"]] ) - self.mock_db_map._add_parameters.assert_called_once_with( + self.mock_db_map._add_parameter_definitions.assert_called_once_with( {"name": "new_parameter", "object_class_id": 1}, {"name": "new_parameter", "object_class_id": 2} ) self.assertEqual(len(errors), 0) def test_import_existing_object_class_parameter(self): num_imported, errors = import_object_parameters(self.mock_db_map, [["existing_oc1", "existing_p1"]]) - self.mock_db_map._add_parameters.assert_called_once_with() + self.mock_db_map._add_parameter_definitions.assert_called_once_with() self.assertEqual(len(errors), 0) @@ -279,28 +281,30 @@ def tearDown(self): def test_import_valid_relationship_class_parameter(self): num_imported, errors = import_relationship_parameters(self.mock_db_map, [["existing_rc1", "new_parameter"]]) - self.mock_db_map._add_parameters.assert_called_once_with({"name": "new_parameter", "relationship_class_id": 1}) + self.mock_db_map._add_parameter_definitions.assert_called_once_with( + {"name": "new_parameter", "relationship_class_id": 1} + ) self.assertEqual(len(errors), 0) def test_import_parameter_with_invalid_relationship_class_name(self): num_imported, errors = import_relationship_parameters( self.mock_db_map, [["new_parameter", "invalid_relationship_class"]] ) - self.mock_db_map._add_parameters.assert_called_once() + self.mock_db_map._add_parameter_definitions.assert_called_once() self.assertEqual(len(errors), 1) def test_import_relationship_class_parameter_name_twice(self): num_imported, errors = import_relationship_parameters( self.mock_db_map, [["existing_rc1", "new_parameter"], ["existing_rc2", "new_parameter"]] ) - self.mock_db_map._add_parameters.assert_called_once_with( + self.mock_db_map._add_parameter_definitions.assert_called_once_with( {"name": "new_parameter", "relationship_class_id": 1}, {"name": "new_parameter", "relationship_class_id": 2} ) self.assertEqual(len(errors), 0) def test_import_existing_relationship_class_parameter(self): num_imported, errors = import_relationship_parameters(self.mock_db_map, [["existing_rc1", "existing_p2"]]) - self.mock_db_map._add_parameters.assert_called_once_with() + self.mock_db_map._add_parameter_definitions.assert_called_once_with() self.assertEqual(len(errors), 0)