dccQuantities 2.0.0.dev1__tar.gz → 2.0.0.dev2__tar.gz

{dccquantities-2.0.0.dev1/src/dccQuantities.egg-info → dccquantities-2.0.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dccQuantities
-Version: 2.0.0.dev1
+Version: 2.0.0.dev2
 Summary: Python classes for working with DDC calibration data
 Author: Vanessa Stehr, Thomas Bruns
 Author-email: Benedikt Seeger <benedikt.seeger@ptb.de>

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dccQuantities"
-version = "2.0.0.dev1"
+version = "2.0.0.dev2"
 description = "Python classes for working with DDC calibration data"
 readme = "README.md"
 requires-python = ">=3.9"

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/AbstractListType.py

@@ -10,7 +10,7 @@ class AbstractListType(AbstractQuantityTypeData):
     def __init__(self, children: list[Union[AbstractListType,AbstractValueType]]) -> None:
         super().__init__()
         self.children = children
-    
+
     def toJsonDict(self):
         result = defaultdict(list)
         for child in self.children:
@@ -19,6 +19,7 @@ class AbstractListType(AbstractQuantityTypeData):
                 result[key].append(value)
         return dict(result)
 
+
     def flatten(self):
         pass
 

dccquantities-2.0.0.dev2/src/AbstractQuantityTypeData.py

@@ -0,0 +1,4 @@
+class AbstractQuantityTypeData:
+    def __init__(self) -> None:
+        self._sorted=None
+        pass

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/AbstractValueType.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 from dsiUnits import dsiUnit
+from numpy.core.defchararray import endswith
 
 from AbstractQuantityTypeData import AbstractQuantityTypeData
 from typing import Union #for python 3.8/3.9 compatibility
@@ -59,7 +60,7 @@ class AbstractValueType(AbstractQuantityTypeData):
                         flattValues = vec_values(flattarray)[0]
                         flattUncs = vec_uncs(flattarray)[0]
             # okay now we can create the json
-            suffix = "" if length ==1 else "XMLList"
+            suffix = "" if length ==1 and not self._originType.endswith('XMLList') else "XMLList"
             resultjson = {"si:value"+suffix: flattValues,}
             if flattUncs and self._uncInfo != None:
                 kfactor=self._uncInfo['coverageFactor']
@@ -72,18 +73,33 @@ class AbstractValueType(AbstractQuantityTypeData):
                     distribution=distribution[0]
                 if not np.all(kfactor==1.0):
                     # we should create expanded uncs now
+
+                    if not "originalUnc" in self._uncInfo:
+                        # we had no original uncer so wie calculate expanded unc
+                        uncValues=(np.array(flattUncs) * kfactor).tolist()
+                        if suffix=='':
+                            try:
+                                uncValues=uncValues[0]
+                            except TypeError:
+                                # if we cant suscribe it it must be int or float
+                                pass
+                    else:
+                        uncValues=self._uncInfo["originalUnc"]
+                        if suffix=='':
+                            try:
+                                uncValues=uncValues[0]
+                            except TypeError:
+                                # if we cant suscribe it it must be int or float
+                                pass
+
                     resultjson["si:measurementUncertaintyUnivariate"+suffix] = {
                         "si:expandedMU"+suffix:{
+                            "si:valueExpandedMU" + suffix:uncValues,
                             "si:coverageFactor"+suffix:kfactor,
                             "si:coverageProbability"+suffix:covP,
                             "si:distribution"+suffix:distribution
                         }
                     }
-                    if not "originalUnc" in self._uncInfo:
-                        # we had no original uncer so wie calculate expanded unc
-                        resultjson["si:measurementUncertaintyUnivariate"+suffix]["si:valueExpandedMU" + suffix]= (np.array(flattUncs) * kfactor).tolist()
-                    else:
-                        resultjson["si:measurementUncertaintyUnivariate" + suffix]["si:valueExpandedMU" + suffix]=self._uncInfo["originalUnc"]
                 else:
                     resultjson["si:measurementUncertaintyUnivariate"+suffix] = {
                         "si:standardMU"+suffix:{

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/DccName.py

@@ -67,7 +67,7 @@ class DccName(dict):
         else:
             raise TypeError(f"Unsupported type {type(other)} for matching")
 
-    def toJsonDict(self):
+    def to_json_dict(self):
         return {'dcc:name':{'dcc:content': [{'@lang': key, '$': value} for key, value in dict(self).items()]}}
 
     def merge_names(self, insertion: str, other: Union['DccName', str, float, int, None]):

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/DccNoQuantity.py

@@ -11,7 +11,6 @@ from DccRichContentType import (
 )
 from DccName import DccName
 
-
 class DccNoQuantity(AbstractQuantityTypeData):
     def __init__(
         self,
@@ -48,8 +47,9 @@ class DccNoQuantity(AbstractQuantityTypeData):
         if len(paramStr) > 0:
             paramStr = " (" + paramStr + ")"
         return f"{str(self.data)}{paramStr}"
-    
+
     def toJsonDict(self) -> dict:
+        privateKeys=['_sorted']
         keyMapping = {
             'id': '@id',
             'refId': '@refId',
@@ -68,9 +68,15 @@ class DccNoQuantity(AbstractQuantityTypeData):
                 elif key == 'data':
                     for key, value in self.data.items():
                         if value is not None:
-                            result[dataKeyMapping[key]] = value
+                            if isinstance(value,list):
+                                if len(value) >0: #skip empty lists
+                                    result[dataKeyMapping[key]] = []
+                                    for item in value:
+                                        result[dataKeyMapping[key]].append(item.toJSONDict())
                     if set(self.data.keys()) - set(dataKeyMapping.keys()):
                         pass # TODO: This should not happen, maybe add a warning?
+                elif key in privateKeys:
+                    pass
                 else:
                     # Use the fallback handler for unexpected keys.
                     unexpected_key_serialization_handler(result, key, value, self.__class__.__name__)

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/DccQuantityTable.py

@@ -459,7 +459,7 @@ class DccLongTable(DccQuantityTable):
         FieldSpec(
             name=None,
             tag="dcc:name",
-            serializer=lambda s: s.name.toJsonDict()["dcc:name"] if s.name else None
+            serializer=lambda s: s.name.to_json_dict()["dcc:name"] if s.name else None
         ),
 
         # 2. description
@@ -606,7 +606,7 @@ class DccLongTable(DccQuantityTable):
         all_quants = idxs + vals
 
         return [
-            q.toJsonDict()["dcc:quantity"]
+            q.to_json_dict()
             for q in all_quants
         ]
 
@@ -637,7 +637,7 @@ class DccFlatTable(DccQuantityTable):
         FieldSpec(
             name=None,
             tag="dcc:name",
-            serializer=lambda s: s.name.toJsonDict()["dcc:name"] if s.name else None
+            serializer=lambda s: s.name.to_json_dict()["dcc:name"] if s.name else None
         ),
 
         # 2. description
@@ -745,12 +745,12 @@ class DccFlatTable(DccQuantityTable):
         """
         # helper to build one wrapper
         def make_wrapper(title: dict, ref_type: list[str], quants: list):
-            wrapper = DccName(title).toJsonDict()  # yields {'dcc:name': ...}
+            wrapper = DccName(title).to_json_dict()  # yields {'dcc:name': ...}
             wrapper["@refType"] = ref_type
             # each quant.toJsonDict() returns {'dcc:quantity': {...}}
             # we pull out that inner dict
             wrapper["dcc:quantity"] = [
-                q.toJsonDict()["dcc:quantity"] for q in quants
+                q.to_json_dict() for q in quants
             ]
             return wrapper
 

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/DccQuantityType.py

@@ -28,7 +28,7 @@ class DccQuantityType(ExplicitSerializerMixin):
         FieldSpec(
             name=None,
             tag="dcc:name",
-            serializer=lambda s: s.name.toJsonDict()["dcc:name"]
+            serializer=lambda s: s.name.to_json_dict()["dcc:name"]
         ),
 
         # 2. description (raw dict under 'dcc:description')
@@ -223,7 +223,4 @@ class DccQuantityType(ExplicitSerializerMixin):
         """
         Wrap the ordered fields under the <dcc:quantity> root.
         """
-        return {"dcc:quantity": self.to_dict()}
-
-    # keep backwards‐compatibility if code calls toJsonDict()
-    toJsonDict = to_json_dict
+        return self.to_dict()

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/DccRichContentType.py

@@ -36,7 +36,7 @@ class DccContent:
                     # Use the fallback handler for unexpected keys.
                     unexpected_key_serialization_handler(result, key, value, self.__class__.__name__)
 
-        return {'dcc:content': result}
+        return result
 
 
 def parseDccContent(jsonDict):

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/SiRealList.py

@@ -14,28 +14,47 @@ from parseUncertainties import parseUncertainties, uncertaintyKeys
 import numpy as np
 from helpers import FieldSpec,ExplicitSerializerMixin
 
-
 class SiRealList(ExplicitSerializerMixin,AbstractValueType):
-    # 1) FieldSpec list for single‑value serialization
+    # 1) Specs for the single‐value form
     __single_specs__ = [
-        # (attr_name, output_tag, serializer, merge)
+        # optional label first
         FieldSpec("label",    "si:label",
                   lambda s: s.label[0] if isinstance(s.label, list) else s.label),
-        # merge in whatever serilizeDataToJSON() returns (expects {'si:value':…, …})
-        FieldSpec(None,       None, "serilizeDataToJSON", merge=True),
+
+        # raw value
+        FieldSpec(None,       "si:value", "serialize_value", merge=False),
+
+        # unit
         FieldSpec("unit",     "si:unit",
                   lambda s: str(s.unit[0])),
+
+        # timestamp
         FieldSpec("dateTime", "si:dateTime",
                   lambda s: s.dateTime[0] if isinstance(s.dateTime, list) else s.dateTime),
+
+        # then any measurementUncertainty…
+        FieldSpec(None,       "si:measurementUncertaintyUnivariate",
+                  "serialize_unc", merge=True),
     ]
+    # For unkown reason the order of sireal and sireallist ist not consitent, WTF!
 
-    # 2) FieldSpec list for list serialization
+    # 2) Specs for the list‐value form
     __list_specs__ = [
-        FieldSpec("label",         "si:labelXMLList",   lambda s: s.label),
-        FieldSpec("dateTime",      "si:dateTimeXMLList",lambda s: s.dateTime),
-        FieldSpec(None, None, "serilizeDataToJSON", merge=True),        # merge in data dict (expects {'si:valueXMLList':…, …})
-        FieldSpec("unit",          "si:unitXMLList",    lambda s: [str(u) for u in s.unit]),
+        # optional label list
+        FieldSpec("label",         "si:labelXMLList",    lambda s: s.label),
+
+        # array of values
+        FieldSpec(None,            "si:valueXMLList",    "serialize_value", merge=False),
+
+        # list‐unit
+        FieldSpec("unit", "si:unitXMLList", lambda s: [str(u) for u in s.unit]),
 
+        # optional timestamp list
+        FieldSpec("dateTime", "si:dateTimeXMLList", lambda s: s.dateTime),
+
+        # then any list‐uncertainty
+        FieldSpec(None,            "si:measurementUncertaintyUnivariateXMLList",
+                  "serialize_unc", merge=True),
     ]
 
     def __init__(
@@ -173,6 +192,36 @@ class SiRealList(ExplicitSerializerMixin,AbstractValueType):
         # 3) Wrap under the correct root element
         return {root: ordered}
 
+    # ————— helper methods for those specs —————
+
+    def serialize_value(self):
+        """
+        Return just the flattened 'si:value' or 'si:valueXMLList' entry
+        from serilizeDataToJSON().
+        """
+        if not hasattr(self,'_data'):
+            self._data = self.serilizeDataToJSON()
+        for key, val in self._data.items():
+            if key.startswith("si:value"):
+                return val
+        return None
+
+    def serialize_unc(self):
+        """
+        Return only the uncertainty sub-dict (everything *except* the 'si:value…'
+        keys) from serilizeDataToJSON(), so it merges in the correct position.
+        """
+        # we dont need to copy since unc will allways call after the values ...
+        if not hasattr(self, '_data'):
+            self._data = self.serilizeDataToJSON()
+        for key in list(self._data.keys()):
+            if key.startswith("si:value"):
+                self._data.pop(key)
+        out=deepcopy(self._data)
+        del self._data
+        #we will delete '_data' since we don't need it anymore ... if we serialize again, we will create it again completely to prevent race conditions ...
+        return out
+
     def __neg__(self):
         new_data = [-item for item in self.data]
         return SiRealList(

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2/src/dccQuantities.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dccQuantities
-Version: 2.0.0.dev1
+Version: 2.0.0.dev2
 Summary: Python classes for working with DDC calibration data
 Author: Vanessa Stehr, Thomas Bruns
 Author-email: Benedikt Seeger <benedikt.seeger@ptb.de>

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/helpers.py

@@ -33,10 +33,15 @@ _REGEX_TYPE = type(re.compile(''))
 class DCCJSONEncoder(json.JSONEncoder):
     def default(self, obj):
         # If the object has a callable toJSON method, use it.
+        if hasattr(obj, 'to_json_dict') and callable(obj.to_json_dict):
+            return obj.to_json_dict()
+
         if hasattr(obj, 'toJSONDict') and callable(obj.toJSONDict):
             return obj.toJSONDict()
+
         elif hasattr(obj, 'toJSON') and callable(obj.toJSON):
             return obj.toJSON()
+
         elif isinstance(obj, dsiUnit):
             return str(obj)
         # 3a) explicit DateTime10
@@ -79,42 +84,48 @@ class ExplicitSerializerMixin:
         """
         out = OrderedDict()
         for spec in self.__serialize_fields__:
-            # Determine raw value
-            if spec.serializer is None:
-                val = getattr(self, spec.name)
-            elif isinstance(spec.serializer, tuple):
-                method, key = spec.serializer
-                temp = getattr(self, method)() if isinstance(method, str) else method(self)
-                val = temp[key]
-            elif isinstance(spec.serializer, str):
-                val = getattr(self, spec.serializer)()
-            else:
-                val = spec.serializer(self)
+            try:
+                # Determine raw value
+                if spec.serializer is None:
+                    val = getattr(self, spec.name, None)
+                elif isinstance(spec.serializer, tuple):
+                    method, key = spec.serializer
+                    temp = getattr(self, method)() if isinstance(method, str) else method(self)
+                    val = temp.get(key) if isinstance(temp, dict) else None
+                elif isinstance(spec.serializer, str):
+                    val = getattr(self, spec.serializer)()
+                else:
+                    val = spec.serializer(self)
+
+                # Skip None or empty collections/arrays
+                if val is None:
+                    continue
+                if isinstance(val, (list, tuple, dict, set)) and len(val) == 0:
+                    continue
+                if isinstance(val, np.ndarray) and val.size == 0:
+                    continue
+
+                # Merge dict or assign directly
+                if spec.merge:
+                    if not isinstance(val, dict):
+                        raise ValueError(f"Field {spec.name} expected to merge a dict, got {type(val)}")
+                    for k, v in val.items():
+                        if v in [None, [], {}, (), set()] or (isinstance(v, np.ndarray) and v.size == 0):
+                            continue
+                        out[k] = v
+                else:
+                    out[spec.tag or spec.name] = val
 
-            # Skip None or empty collections/arrays
-            if val is None:
-                continue
-            if isinstance(val, (list, tuple, dict, set)) and len(val) == 0:
-                continue
-            if isinstance(val, np.ndarray) and val.size == 0:
+            except Exception as e:
+                # Silently skip common NoneType attribute access errors (e.g., s.name.to_json_dict())
+                if isinstance(e, AttributeError) and "'NoneType'" in str(e):
+                    continue
+                warnings.warn(
+                    f"Serialization of field {spec.name or spec.tag} failed in {self.__class__.__name__}: {e}",
+                    RuntimeWarning
+                )
                 continue
 
-            # Merge dict or assign directly
-            if spec.merge:
-                if not isinstance(val, dict):
-                    raise ValueError(f"Field {spec.name} expected to merge a dict, got {type(val)}")
-                for k, v in val.items():
-                    # Also treat any empty collections in merged dict as skip
-                    if v is None:
-                        continue
-                    if isinstance(v, (list, tuple, dict, set)) and len(v) == 0:
-                        continue
-                    if isinstance(v, np.ndarray) and v.size == 0:
-                        continue
-                    out[k] = v
-            else:
-                out[spec.tag or spec.name] = val
-
         return out
 
     def to_json_dict(self) -> dict:

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/src/parseUncertainties.py

@@ -51,6 +51,7 @@ def parseUncertainties(jsonDict: dict, data: list, relativeUncertainty: dict = N
 
 def parseExpandedUnc(jsonDict: dict, data: list, relativeUncertainty: dict = None):
     uncData = {}
+    #TODO we will lose keys if one of the predescending wasn't defined NEDS TO BE CHANGED ASAP
     if "si:expandedUnc" in jsonDict.keys():
         uncJsonData = jsonDict["si:expandedUnc"]
         uncData["uncertainty"] = uncJsonData["si:uncertainty"]
@@ -73,13 +74,13 @@ def parseExpandedUnc(jsonDict: dict, data: list, relativeUncertainty: dict = Non
         )
     elif "si:measurementUncertaintyUnivariate" in jsonDict.keys():
         try:
-            uncJsonData = jsonDict["si:measurementUncertaintyUnivariate"]
-            uncData["uncertainty"] = uncJsonData["si:measurementUncertaintyUnivariate"]
+            uncJsonData = jsonDict["si:measurementUncertaintyUnivariate"]['si:expandedMU']
+            uncData["uncertainty"] = uncJsonData['si:valueExpandedMU']
             uncData["coverageFactor"] = uncJsonData["si:coverageFactor"]
             uncData["coverageProbability"] = uncJsonData["si:coverageProbability"]
             uncData["distribution"] = (
-                uncJsonData["si:distributionXMLList"]
-                if "si:distributionXMLList" in uncJsonData.keys()
+                uncJsonData["si:distribution"]
+                if "si:distribution" in uncJsonData.keys()
                 else ["normal"]
             )
         except Exception as e:

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/tests/test_dccName.py

@@ -1,11 +1,11 @@
 import pytest
 from DccName import DccName
 
-def test_toJsonDict():
+def test_to_json_dict():
     jsonDict = {'dcc:name':{'dcc:content': [{'@lang': 'en', '$': 'Room temperature during calibration'}, {'@lang': 'de', '$': 'Raumtemperatur währenden der Kalibration'}]}}
     parsedDict = {'en': 'Room temperature during calibration', 'de': 'Raumtemperatur währenden der Kalibration'}
     nameInstance = DccName(parsedDict)
-    generatedJsonDict = nameInstance.toJsonDict()
+    generatedJsonDict = nameInstance.to_json_dict()
     assert jsonDict == generatedJsonDict
 
 def test_matches_with_subset_dict():

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/tests/test_parser.py

@@ -13,6 +13,71 @@ from helpers import replaceQuantitiesInDict,DCCJSONEncoder
 from dccXMLJSONConv.dccConv import XMLToDict,DictToXML
 from dccQuantityParser import parseItemFromJsonDict
 from xmlschema import XMLSchemaValidationError
+import copy
+
+@pytest.mark.filterwarnings("ignore:Parsing a correctly marked non D-SI unit")
+@pytest.mark.filterwarnings("ignore:The identifier .* does not match any D-SI units!")
+def test_allFilesBackAndForthSer():
+    # load our list of known-invalid files
+    filePath = get_test_file(
+        "tests", "data", "private", "1_7calibrationanddccsampledata",
+        "AndereScheine", "grabbedFiles", "validation_results.json"
+    )
+    dirPath = get_test_file(
+        "tests", "data", "private", "1_7calibrationanddccsampledata",
+        "AndereScheine", "grabbedFiles")
+    with open(filePath, "r") as validationFile:
+        validationDict = json.load(validationFile)
+    invalidFileNames = [
+        "dcc-2019-75056_mod.xml",
+        "DCCTableXMLStub.xml",
+        "test_xmlDumpingSingleQuantNoUncer.xml",
+        "test_dccQuantTabXMLDumping.xml",
+        "CalSchein_20220708_8305_SN1842876.xml",
+        "dcc-vacuumlab-CDG.xml",
+        "acoustics_refTypeDefinition.xml"
+    ]
+    # add any others flagged in the validation results
+    invalidFileNames += [
+        entry["Invalid File"] for entry in validationDict.values()
+    ]
+    allowed_reason = "value doesn't match any pattern of ['3\\\\.3\\\\.0']"
+    # iterate every XML that isn't already known-bad
+    #TODO test all files and fix things like quants WO a name
+    for fileCount,xmlFile in enumerate(dirPath.rglob("*.xml")):
+    #for xmlFile in [get_test_file( "tests", "data", "private", "1_7calibrationanddccsampledata","sinCal","sin_acceleration_example_dcc","sin_acceleration_example_dcc_WithExampleConformatyStatment.xml")]:
+        if xmlFile.name in invalidFileNames:
+            continue
+        with open(xmlFile, "r") as f:
+            xml_text = f.read()
+        xmlDict, errors = XMLToDict(xml_text)
+        # update schema Version brutaly to 3.3.0
+        xmlDict['@xsi:schemaLocation']=r'https://ptb.de/dcc https://ptb.de/dcc/v3.3.0/dcc.xsd'
+        xmlDict['@schemaVersion'] = '3.3.0'
+
+        xmlDictcopy=copy.deepcopy(xmlDict)
+
+        serDict, quantList = replaceQuantitiesInDict(xmlDictcopy, parser=parseItemFromJsonDict,returnQuantityList=True)
+        assert len(quantList) > 0
+        json_text = json.dumps(serDict, cls=DCCJSONEncoder)
+        dictForConversion=json.loads(json_text)
+        xml_out, root_elem, errors = DictToXML(dictForConversion)
+        assert xml_out, f"No XML produced for {xmlFile.name}"
+        # Filter out the one allowed schema‐validation complaint
+        remaining = [
+            err for err in errors
+            if not (
+                isinstance(err, XMLSchemaValidationError)
+                and err.reason.startswith("value doesn't match any pattern of ")
+            )
+        ]
+        # If anything unexpected remains, fail
+        assert not remaining, (
+            f"Unexpected validation errors in {xmlFile.name}:\n"
+            + "\n".join(f"  • {type(err).__name__}: {getattr(err, 'reason', err)}"
+                        for err in remaining)
+        )
+
 
 def test_parsedQuantValuesAndFunctions():    # Use the correct relative paths
     try:
@@ -152,55 +217,3 @@ def test_allFiles():
                 except Exception as e:
                     raise e
 
-@pytest.mark.filterwarnings("ignore:Parsing a correctly marked non D-SI unit")
-@pytest.mark.filterwarnings("ignore:The identifier .* does not match any D-SI units!")
-def test_allFilesBackAndForthSer():
-    # load our list of known-invalid files
-    filePath = get_test_file(
-        "tests", "data", "private", "1_7calibrationanddccsampledata",
-        "AndereScheine", "grabbedFiles", "validation_results.json"
-    )
-    dirPath = get_test_file(
-        "tests", "data", "private", "1_7calibrationanddccsampledata",
-        "AndereScheine", "grabbedFiles")
-    with open(filePath, "r") as validationFile:
-        validationDict = json.load(validationFile)
-    invalidFileNames = [
-        "dcc-2019-75056_mod.xml",
-        "DCCTableXMLStub.xml",
-        "test_xmlDumpingSingleQuantNoUncer.xml",
-        "test_dccQuantTabXMLDumping.xml",
-        "CalSchein_20220708_8305_SN1842876.xml",
-        "dcc-vacuumlab-CDG.xml",
-        "acoustics_refTypeDefinition.xml"
-    ]
-    # add any others flagged in the validation results
-    invalidFileNames += [
-        entry["Invalid File"] for entry in validationDict.values()
-    ]
-    allowed_reason = "value doesn't match any pattern of ['3\\\\.3\\\\.0']"
-    # iterate every XML that isn't already known-bad
-    for xmlFile in dirPath.rglob("*.xml"):
-        if xmlFile.name in invalidFileNames:
-            continue
-        with open(xmlFile, "r") as f:
-            xml_text = f.read()
-        xmlDict = XMLToDict(xml_text)
-        serDict, errors = replaceQuantitiesInDict(xmlDict, parser=parseItemFromJsonDict)
-        json_text = json.dumps(serDict, cls=DCCJSONEncoder)
-        xml_out, root_elem, errors = DictToXML(json.loads(json_text))
-        assert xml_out, f"No XML produced for {xmlFile.name}"
-        # Filter out the one allowed schema‐validation complaint
-        remaining = [
-            err for err in errors
-            if not (
-                isinstance(err, XMLSchemaValidationError)
-                and err.reason.startswith("value doesn't match any pattern of ")
-            )
-        ]
-        # If anything unexpected remains, fail
-        assert not remaining, (
-            f"Unexpected validation errors in {xmlFile.name}:\n"
-            + "\n".join(f"  • {type(err).__name__}: {getattr(err, 'reason', err)}"
-                        for err in remaining)
-        )

{dccquantities-2.0.0.dev1 → dccquantities-2.0.0.dev2}/tests/test_serilizer.py

@@ -38,12 +38,12 @@ def test_basic():
         warnings.warn(str(e))
     serilizedData=[]
     for q in dccQunats:
-        serilizedData.append(q.toJsonDict())
+        serilizedData.append(q.to_json_dict())
     # check if the first key is 'dcc:qunatity'
     for i,serilized in enumerate(serilizedData):
         try:
             jsonSTR=json.dumps(serilized, cls=DCCJSONEncoder)
         except TypeError as te:
             raise te # to catch unimplemented cases
-        simplejsonDict=loads(jsonSTR)['dcc:quantity']
+        simplejsonDict=loads(jsonSTR)
         inputJSONDict=quantityDict[i][1]

dccquantities-2.0.0.dev1/src/AbstractQuantityTypeData.py

@@ -1,10 +0,0 @@
-class AbstractQuantityTypeData:
-    def __init__(self) -> None:
-        self._sorted=None
-        pass
-
-    def __len__(self):
-        return NotImplemented
-    
-    def toJsonDict(self):
-        return NotImplemented