Merge pull request #56 from cdisc-org/sdtm-define-xml

Update define generator

Author: swhume

src/generators/define/itemGroups.py

@@ -52,12 +52,12 @@ def _generate_dataset(self, dataset, define_objects, lang, acrf):
         vars.create_define_objects(items_list, define_objects, lang, acrf, item_group=itg)
         # ItemDefs
         itd = items.Items()
-        itd.create_define_objects(dataset["items"], define_objects, lang, acrf)
+        itd.create_define_objects(dataset["items"], define_objects, lang, acrf, slice=dataset["slices"] if dataset.get("slices") else None)
 
         # TODO review this assumption that we have 1 class per dataset
         # assumption: 1 class per dataset - many need to expand this for ADaM
-        if dataset.get("class"):
-            ds_class = dataset["class"].upper().replace("-", " ")
+        if dataset.get("observationClass", {}).get("name", ""):
+            ds_class = dataset.get("observationClass", {}).get("name", "").upper().replace("-", " ")
             itg.Class = DEFINE.Class(Name=ds_class)
 
     def _create_itemgroupdef_object(self, obj):
@@ -69,17 +69,18 @@ def _create_itemgroupdef_object(self, obj):
         attr["Structure"] = obj.get("structure", "NA")
         if obj.get("sasDatasetName"):
             attr["SASDatasetName"] = obj["sasDatasetName"]
-        if obj.get("isReferenceData"):
-            attr["IsReferenceData"] = obj["isReferenceData"]
-        else:
-            attr["IsReferenceData"] = self._generate_is_reference(attr)
-        if obj.get("repeating"):
-            if obj["repeating"]:
-                attr["Repeating"] = "Yes"
-            else:
-                attr["Repeating"] = "No"
-        else:
-            attr["Repeating"] = self._generate_repeating_value(attr)
+        if "isReferenceData" in obj:
+            attr["IsReferenceData"] = "Yes" if obj["isReferenceData"] else "No"
+        # else:
+        #     attr["IsReferenceData"] = self._generate_is_reference(attr)
+        # if obj.get("repeating"):
+        #     if obj["repeating"]:
+        #         attr["Repeating"] = "Yes"
+        #     else:
+        #         attr["Repeating"] = "No"
+        # else:
+        #     attr["Repeating"] = self._generate_repeating_value(attr)
+        attr["Repeating"] = self._generate_repeating_value(attr)
         # TODO how to tell if we're processing SDTM or ADaM define?
         if obj.get("purpose"):
             attr["Purpose"] = obj["purpose"]
@@ -90,8 +91,8 @@ def _create_itemgroupdef_object(self, obj):
             attr["CommentOID"] = obj["comment"]
         if obj.get("isNonStandard"):
             attr["IsNonStandard"] = obj["isNonStandard"]
-        if obj.get("wasDerivedFrom"):
-            attr["StandardOID"] = obj["wasDerivedFrom"]
+        if obj.get("standard"):
+            attr["StandardOID"] = obj["standard"]
         if obj.get("hasNoData"):
             attr["HasNoData"] = obj["hasNoData"]
         igd = DEFINE.ItemGroupDef(**attr)
@@ -101,16 +102,16 @@ def _create_itemgroupdef_object(self, obj):
         igd.Description.TranslatedText.append(tt)
         return igd
 
-    def _generate_is_reference(self, attributes: dict[str, str]) -> str:
-        """
-        Determine if the dataset is a reference dataset (trial design domains).
+    # def _generate_is_reference(self, attributes: dict[str, str]) -> str:
+    #     """
+    #     Determine if the dataset is a reference dataset (trial design domains).
 
-        :param attributes: ItemGroupDef attributes dictionary
-        :return: "Yes" if domain is a reference domain, "No" otherwise
-        """
-        if attributes["Domain"] in TRIAL_DESIGN_DOMAINS:
-            return "Yes"
-        return "No"
+    #     :param attributes: ItemGroupDef attributes dictionary
+    #     :return: "Yes" if domain is a reference domain, "No" otherwise
+    #     """
+    #     if attributes["Domain"] in TRIAL_DESIGN_DOMAINS:
+    #         return "Yes"
+    #     return "No"
 
     def _generate_repeating_value(self, attributes: dict[str, str]) -> str:
         """
@@ -119,7 +120,7 @@ def _generate_repeating_value(self, attributes: dict[str, str]) -> str:
         :param attributes: ItemGroupDef attributes dictionary
         :return: "Yes" if dataset has repeating records, "No" otherwise
         """
-        if attributes["IsReferenceData"] == "Yes":
+        if attributes.get("IsReferenceData") == "Yes":
             return "No"
         if attributes["Domain"] in NON_REPEATING_DOMAINS:
             # TODO check for presence of -PARMCD for DI/OI domains

src/generators/define/items.py

@@ -18,7 +18,8 @@ def create_define_objects(
         template: list[dict[str, Any]],
         define_objects: dict[str, list[Any]],
         lang: str,
-        acrf: str
+        acrf: str,
+        slice: list[dict[str, Any]] | None = None
     ) -> None:
         """
         Create ItemDef objects from the DDS template.
@@ -27,15 +28,17 @@ def create_define_objects(
         :param define_objects: dictionary of odmlib objects updated by this method
         :param lang: xml:lang setting for TranslatedText
         :param acrf: annotated case report form leaf ID
+        :param slice: list of slice definitions from the DDS JSON (if applicable)
         """
         self.lang = lang
         self.acrf = acrf
+        self.slice = slice
         for variable in template:
             it_oid = self.require_key(variable, "OID", "ItemDef")
-            item = self._create_itemdef_object(variable, it_oid)
+            item = self._create_itemdef_object(variable, it_oid, slice)
             define_objects["ItemDef"].append(item)
 
-    def _create_itemdef_object(self, obj, oid):
+    def _create_itemdef_object(self, obj, oid, slice):    
         name = self.require_key(obj, "name", f"ItemDef {oid}")
         data_type = self.require_key(obj, "dataType", f"ItemDef {oid}")
         attr = {"OID": oid, "Name": name, "DataType": data_type, "SASFieldName": name}
@@ -45,13 +48,20 @@ def _create_itemdef_object(self, obj, oid):
             tt = DEFINE.TranslatedText(_content=obj["description"], lang=self.lang)
             item.Description = DEFINE.Description()
             item.Description.TranslatedText.append(tt)
-        self._add_optional_itemdef_elements(item, obj, oid)
+        self._add_optional_itemdef_elements(item, obj, oid, slice)
         return item
 
-    def _add_optional_itemdef_elements(self, item, obj, it_oid):
+    def _add_optional_itemdef_elements(self, item, obj, it_oid, slice):
         """
         use the values from the Variables section in the define-template to add the optional ELEMENTS to the ItemDef
         """
+        for s in slice or []:
+            if s.get("type") == "ValueList":
+                if s.get("wasDerivedFrom") == it_oid:
+                    vl_oid = s["OID"]
+                    vl_ref = DEFINE.ValueListRef(ValueListOID=vl_oid)
+                    item.ValueListRef = vl_ref
+
         # TODO do not find codeList in define.json example for items
         if obj.get("codeList"):
             cl_oid = self.generate_oid(["CL", obj["codeList"].split(".")[1]])
@@ -65,7 +75,13 @@ def _add_optional_itemdef_elements(self, item, obj, it_oid):
                 attr["Type"] =  obj["origin"]["type"]
             if obj.get("origin").get("source"):
                 attr["Source"] = obj["origin"]["source"]
-            item.Origin.append(DEFINE.Origin(**attr))
+            # item.Origin.append(DEFINE.Origin(**attr))
+            # Bypass odmlib descriptor validation to allow __PLACEHOLDER__ values
+            origin = object.__new__(DEFINE.Origin)
+            for key, value in attr.items():
+                origin.__dict__[key] = value
+            item.Origin.append(origin)
+
             if obj.get("predecessor"):
                 item.Origin[0].Description = DEFINE.Description()
                 item.Origin[0].Description.TranslatedText.append(DEFINE.TranslatedText(_content=obj["Predecessor"]))