From 86137e4068293b0574081f2eb4a1b4b46a424867 Mon Sep 17 00:00:00 2001 From: MrEx3cut0r Date: Thu, 28 May 2026 12:53:36 -0500 Subject: [PATCH 1/3] normalize_query is implemented into client --- mpds_client/retrieve_MPDS.py | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/mpds_client/retrieve_MPDS.py b/mpds_client/retrieve_MPDS.py index 5cdf34c..afec167 100755 --- a/mpds_client/retrieve_MPDS.py +++ b/mpds_client/retrieve_MPDS.py @@ -133,8 +133,26 @@ def __init__( self.dtype = dtype or MPDSDataTypes.PEER_REVIEWED self.verbose = verbose if verbose is not None else self.verbose self.debug = debug or self.debug + + def normalize_query(self, query): + """Ensure 'elements' and 'classes' are joined strings, not lists. - def _request(self, query, phases=None, page=0, pagesize=None): + The MPDS API expects: + - elements: dash-separated string e.g. "Sr-Ti-O" + - classes: comma-separated string e.g. "perovskite, conductor" + + Passing raw lists causes unsupported-symbol errors. + """ + out = dict(query) + if 'elements' in out and isinstance(out['elements'], (list, tuple)): + out['elements'] = '-'.join(out['elements']) + if 'classes' in out and isinstance(out['classes'], (list, tuple)): + out['classes'] = ','.join(out['classes']) + return out + + + def _request(self, raw_query, phases=None, page=0, pagesize=None): + query = self.normalize_query(raw_query) phases = ",".join([str(int(x)) for x in phases]) if phases else "" uri = ( From 5b195cbef2b07782c5ede28f24bedd580a83357c Mon Sep 17 00:00:00 2001 From: MrEx3cut0r Date: Thu, 28 May 2026 13:02:28 -0500 Subject: [PATCH 2/3] tests added, normalize_query renamed to _normalize_query --- mpds_client/retrieve_MPDS.py | 4 ++-- mpds_client/test_retrieve_MPDS.py | 29 +++++++++++++++++++++++++++++ 2 files changed, 31 insertions(+), 2 deletions(-) diff --git a/mpds_client/retrieve_MPDS.py b/mpds_client/retrieve_MPDS.py index afec167..9a34c1c 100755 --- a/mpds_client/retrieve_MPDS.py +++ b/mpds_client/retrieve_MPDS.py @@ -134,7 +134,7 @@ def __init__( self.verbose = verbose if verbose is not None else self.verbose self.debug = debug or self.debug - def normalize_query(self, query): + def _normalize_query(self, query): """Ensure 'elements' and 'classes' are joined strings, not lists. The MPDS API expects: @@ -152,7 +152,7 @@ def normalize_query(self, query): def _request(self, raw_query, phases=None, page=0, pagesize=None): - query = self.normalize_query(raw_query) + query = self._normalize_query(raw_query) phases = ",".join([str(int(x)) for x in phases]) if phases else "" uri = ( diff --git a/mpds_client/test_retrieve_MPDS.py b/mpds_client/test_retrieve_MPDS.py index 9319a83..131600e 100755 --- a/mpds_client/test_retrieve_MPDS.py +++ b/mpds_client/test_retrieve_MPDS.py @@ -13,6 +13,35 @@ class MPDSDataRetrievalTest(unittest.TestCase): + def test_normalize_query_elements_list(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + result = client._normalize_query({"elements": ["Sr", "Ti", "O"], "props": "band gap"}) + self.assertEqual(result["elements"], "Sr-Ti-O") + self.assertEqual(result["props"], "band gap") + + def test_normalize_query_elements_tuple(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + result = client._normalize_query({"elements": ("Ti", "O"), "props": "atomic structure"}) + self.assertEqual(result["elements"], "Ti-O") + + def test_normalize_query_classes_list(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + result = client._normalize_query({"elements": "Ti-O", "classes": ["perovskite", "conductor"]}) + self.assertEqual(result["classes"], "perovskite,conductor") + + def test_normalize_query_no_list(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + query = {"elements": "K-Ag", "classes": "iodide", "props": "heat capacity"} + result = client._normalize_query(query) + self.assertEqual(result, query) + + def test_normalize_query_does_not_mutate_original(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + original = {"elements": ["Sr", "Ti", "O"]} + result = client._normalize_query(original) + self.assertIsInstance(original["elements"], list) + self.assertEqual(result["elements"], "Sr-Ti-O") + @classmethod def setUpClass(cls): # warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*") From 1d9091da2ad0366e4c8a2fe78b53470c1f132d0f Mon Sep 17 00:00:00 2001 From: MrEx3cut0r Date: Fri, 29 May 2026 12:11:19 -0500 Subject: [PATCH 3/3] normalize_query fixed, empty classes and elements handling added --- mpds_client/retrieve_MPDS.py | 22 +++++++++++++++------- mpds_client/test_retrieve_MPDS.py | 12 ++++++++++++ 2 files changed, 27 insertions(+), 7 deletions(-) diff --git a/mpds_client/retrieve_MPDS.py b/mpds_client/retrieve_MPDS.py index 9a34c1c..f0683a2 100755 --- a/mpds_client/retrieve_MPDS.py +++ b/mpds_client/retrieve_MPDS.py @@ -133,23 +133,31 @@ def __init__( self.dtype = dtype or MPDSDataTypes.PEER_REVIEWED self.verbose = verbose if verbose is not None else self.verbose self.debug = debug or self.debug - + def _normalize_query(self, query): """Ensure 'elements' and 'classes' are joined strings, not lists. The MPDS API expects: - elements: dash-separated string e.g. "Sr-Ti-O" - - classes: comma-separated string e.g. "perovskite, conductor" + - classes: comma-separated string e.g. "perovskite,conductor" Passing raw lists causes unsupported-symbol errors. """ out = dict(query) - if 'elements' in out and isinstance(out['elements'], (list, tuple)): - out['elements'] = '-'.join(out['elements']) - if 'classes' in out and isinstance(out['classes'], (list, tuple)): - out['classes'] = ','.join(out['classes']) - return out + if el := out.get('elements'): + if isinstance(el, (list, tuple)): + out['elements'] = '-'.join(el) + elif el is not None: + raise ValueError("'elements' must not be empty") + + if cl := out.get('classes'): + if isinstance(cl, (list, tuple)): + out['classes'] = ','.join(cl) + elif cl is not None: + raise ValueError("'classes' must not be empty") + + return out def _request(self, raw_query, phases=None, page=0, pagesize=None): query = self._normalize_query(raw_query) diff --git a/mpds_client/test_retrieve_MPDS.py b/mpds_client/test_retrieve_MPDS.py index 131600e..71bd510 100755 --- a/mpds_client/test_retrieve_MPDS.py +++ b/mpds_client/test_retrieve_MPDS.py @@ -42,6 +42,18 @@ def test_normalize_query_does_not_mutate_original(self): self.assertIsInstance(original["elements"], list) self.assertEqual(result["elements"], "Sr-Ti-O") + def test_normalize_query_elements_list_is_empty(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + original = {"elements": []} + with self.assertRaises(ValueError): + client._normalize_query(original) + + def test_normalize_query_classes_list_is_empty(self): + client = MPDSDataRetrieval.__new__(MPDSDataRetrieval) + original = {"classes": []} + with self.assertRaises(ValueError): + client._normalize_query(original) + @classmethod def setUpClass(cls): # warnings.filterwarnings("ignore", category=ResourceWarning, message="unclosed.*")