cdiscbuilder 0.2.8__py3-none-any.whl

cdiscbuilder/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.2"

cdiscbuilder/cli.py

@@ -0,0 +1,42 @@
+import os
+import argparse
+from .odm import parse_odm_to_long_df
+from .sdtm import create_sdtm_datasets
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert ODM XML to SDTM Datasets")
+    # Determine default config path inside package
+    current_dir = os.path.dirname(__file__)
+    default_config_path = os.path.join(current_dir, "specs")
+    
+    parser.add_argument("--xml", required=True, help="Path to input ODM XML file")
+    parser.add_argument("--csv", default="odm_long.csv", help="Path to intermediate long CSV file")
+    parser.add_argument("--configs", default=default_config_path, help="Path to SDTM configuration directory")
+    parser.add_argument("--output", default="sdtm_output", help="Path to output SDTM directory")
+    
+    args = parser.parse_args()
+
+    # Step 1: ODM XML -> Long CSV
+    print(f"--- Step 1: Parsing ODM XML from {args.xml} ---")
+    try:
+        df = parse_odm_to_long_df(args.xml)
+        print(f"Parsed {len(df)} rows.")
+        df.to_csv(args.csv, index=False)
+        print(f"Saved intermediate data to {args.csv}")
+    except Exception as e:
+        print(f"Error parsing XML: {e}")
+        return
+
+    # Step 2: Long CSV -> SDTM Datasets
+    print(f"\n--- Step 2: Generating SDTM Datasets using configs from {args.configs} ---")
+    if not os.path.exists(args.output):
+        os.makedirs(args.output)
+        
+    try:
+        create_sdtm_datasets(args.configs, args.csv, args.output)
+        print(f"\nSuccess! SDTM datasets created in {args.output}")
+    except Exception as e:
+        print(f"Error creating SDTM datasets: {e}")
+
+if __name__ == "__main__":
+    main()

cdiscbuilder/engine/classes/finding.py

@@ -0,0 +1,113 @@
+import pandas as pd
+
+
+class FindingProcessor:
+    def __init__(self):
+        pass
+
+    def process(self, domain_name, sources, df_long, default_keys):
+        domain_dfs = []
+        
+        for settings in sources:
+            # 0. Filter by FormOID (optional but recommended)
+            form_oid = settings.get('formoid')
+            source_df = df_long.copy()
+            if form_oid:
+                if isinstance(form_oid, list):
+                    source_df = source_df[source_df['FormOID'].isin(form_oid)]
+                else:
+                    source_df = source_df[source_df['FormOID'] == form_oid]
+            
+            # 1. Filter by ItemGroupOID (regex or list)
+            item_group_match = settings.get('item_group_regex')
+            if item_group_match:
+                 source_df = source_df[source_df['ItemGroupOID'].str.match(item_group_match, na=False)]
+            
+            # 2. Filter by ItemOID (regex)
+            # This is crucial for "finding" domains - we want rows where ItemOID matches a pattern
+            item_oid_match = settings.get('item_oid_regex')
+            if item_oid_match:
+                source_df = source_df[source_df['ItemOID'].str.match(item_oid_match, na=False)]
+            
+            if source_df.empty:
+                continue
+                
+            # 3. Create Base DataFrame (No Pivot!)
+            # 3. Create Base DataFrame (No Pivot!)
+            # We treat every row as a potential finding
+            # Base columns: Keys + ItemOID + Value
+            keys = settings.get('keys', default_keys)
+            
+            # Check if Question exists in source_df (it should based on odm.py changes)
+            base_cols = keys + ['ItemOID', 'Value']
+            if 'Question' in source_df.columns:
+                 base_cols.append('Question')
+
+            final_df = source_df[base_cols].copy()
+            
+            # 4. Map Columns
+            mappings = settings.get('columns', {})
+            
+            for target_col, col_config in mappings.items():
+                series = None
+                
+                # Config can be simple string (source col) or dict
+                source_expr = None
+                literal_expr = None
+                target_type = None
+                regex_extract = None
+                
+                if isinstance(col_config, dict):
+                    source_expr = col_config.get('source')
+                    literal_expr = col_config.get('literal')
+                    target_type = col_config.get('type')
+                    regex_extract = col_config.get('regex_extract') # e.g. "I_ELIGI_(.*)"
+                else:
+                    source_expr = col_config # simplistic
+                
+                if literal_expr is not None:
+                     series = pd.Series([literal_expr] * len(final_df), index=final_df.index)
+                
+                elif source_expr:
+                    if source_expr == "ItemOID":
+                        series = final_df['ItemOID']
+                    elif source_expr == "Value":
+                        series = final_df['Value']
+                    elif source_expr in final_df.columns:
+                        series = final_df[source_expr]
+                    elif source_expr in source_df.columns:
+                         series = source_df[source_expr]
+                    
+                    # Regex Extraction from source
+                    if regex_extract and series is not None:
+                         # Extract group 1
+                         series = series.astype(str).str.extract(regex_extract)[0]
+                
+                # Apply Prefix
+                prefix = None
+                if isinstance(col_config, dict):
+                    prefix = col_config.get('prefix')
+                
+                if prefix and series is not None:
+                    series = prefix + series.astype(str)
+                
+                if series is not None:
+                    # Type Conversion
+                    if target_type:
+                        try:
+                            if target_type == 'int':
+                                series = pd.to_numeric(series, errors='coerce').astype('Int64')
+                            elif target_type == 'str':
+                                series = series.astype(str)
+                        except Exception:
+                            pass
+                    
+                    final_df[target_col] = series
+            
+            # Filter to keep only target columns
+            cols_to_keep = list(mappings.keys())
+            final_df = final_df[cols_to_keep]
+            
+            domain_dfs.append(final_df)
+            
+        return domain_dfs

cdiscbuilder/engine/classes/general.py

@@ -0,0 +1,240 @@
+import pandas as pd
+
+class GeneralProcessor:
+    def _expand_settings(self, settings):
+        """
+        Expands a settings dict with list-based sources/literals into multiple settings dicts.
+        """
+        # Find all columns that have a list for source or literal
+        list_cols = {}
+        list_len = 0
+        
+        columns = settings.get('columns', {})
+        for col_name, col_cfg in columns.items():
+            if isinstance(col_cfg, dict):
+                src = col_cfg.get('source')
+                lit = col_cfg.get('literal')
+                
+                # Check source
+                if isinstance(src, list):
+                    if list_len > 0 and len(src) != list_len:
+                        raise ValueError(f"Column '{col_name}' source list length {len(src)} mismatch with others {list_len}")
+                    list_len = len(src)
+                    list_cols[col_name] = 'source'
+                
+                # Check literal
+                if isinstance(lit, list):
+                    if list_len > 0 and len(lit) != list_len:
+                        raise ValueError(f"Column '{col_name}' literal list length {len(lit)} mismatch with others {list_len}")
+                    list_len = len(lit)
+                    list_cols[col_name] = 'literal'
+                    
+        if list_len == 0:
+            return [settings]
+            
+        # Expand
+        expanded_list = []
+        for i in range(list_len):
+            new_settings = settings.copy()
+            new_cols = {}
+            for col_name, col_cfg in columns.items():
+                if isinstance(col_cfg, dict):
+                    new_cfg = col_cfg.copy()
+                    if col_name in list_cols:
+                        param = list_cols[col_name] # 'source' or 'literal'
+                         # Extract the i-th element
+                        val_list = col_cfg.get(param)
+                        new_cfg[param] = val_list[i]
+                    new_cols[col_name] = new_cfg
+                else:
+                    new_cols[col_name] = col_cfg
+            
+            new_settings['columns'] = new_cols
+            expanded_list.append(new_settings)
+            
+        return expanded_list
+
+    def process(self, domain_name, sources, df_long, default_keys):
+        domain_dfs = []
+        
+        # Pre-expand sources if they contain lists
+        expanded_sources = []
+        for s in sources:
+            try:
+                expanded_sources.extend(self._expand_settings(s))
+            except Exception as e:
+                print(f"Error expanding settings for {domain_name}: {e}")
+                continue # Skip invalid blocks
+        
+        for settings in expanded_sources:
+            # 1. Filter by FormOID
+            form_oid = settings.get('formoid')
+            if form_oid:
+                try:
+                    # Filter for specific FormOID(s)
+                    if isinstance(form_oid, list):
+                        source_df = df_long[df_long['FormOID'].isin(form_oid)].copy()
+                    else:
+                        source_df = df_long[df_long['FormOID'] == form_oid].copy()
+                except Exception as e:
+                    print(f"Error filtering for {domain_name} (FormOID={form_oid}): {e}")
+                    continue
+            else:
+                print(f"Warning: No formoid specified for a block in {domain_name}")
+                continue
+                
+            if source_df.empty:
+                continue
+
+            # 2. Key columns for pivoting (use block keys or defaults)
+            keys = settings.get('keys', default_keys)
+            
+            # 3. Pivot
+            try:
+                pivoted = source_df.pivot_table(
+                    index=keys, 
+                    columns='ItemOID', 
+                    values='Value', 
+                    aggfunc='first'
+                ).reset_index()
+            except Exception as e:
+                print(f"Error pivoting for {domain_name}: {e}")
+                continue
+                
+            # 4. Map columns
+            final_df = pd.DataFrame()
+            mappings = settings.get('columns', {})
+            
+            for target_col, col_config in mappings.items():
+                source_expr = None
+                literal_expr = None
+                target_type = None
+                value_map = None
+
+                # Check if simple string or object config
+                if isinstance(col_config, dict):
+                    source_expr = col_config.get('source')
+                    literal_expr = col_config.get('literal')
+                    target_type = col_config.get('type')
+                    value_map = col_config.get('value_mapping')
+                else:
+                    source_expr = col_config
+                    literal_expr = None
+                
+                # Extract Data
+                series = None
+                if literal_expr is not None:
+                    # Explicit literal value
+                    series = pd.Series([literal_expr] * len(pivoted))
+                elif source_expr:
+                    if source_expr in pivoted.columns:
+                        series = pivoted[source_expr].copy()
+                    elif source_expr in final_df.columns:
+                        series = final_df[source_expr].copy()
+                    else:
+                        # Source defined but not found.
+                        print(f"Warning: Source column '{source_expr}' not found for '{domain_name}.{target_col}'. Filling with NaN.")
+                        series = pd.Series([None] * len(pivoted))
+                else:
+                    print(f"Warning: No source or literal defined for '{domain_name}.{target_col}'. Filling with NaN.")
+                    series = pd.Series([None] * len(pivoted))
+                
+                # Apply Dependency Logic (Assign only if dependency column is not null)
+                dependency = col_config.get('dependency') if isinstance(col_config, dict) else None
+                if dependency:
+                    dep_series = None
+                    if dependency in pivoted.columns:
+                        dep_series = pivoted[dependency]
+                    elif dependency in final_df.columns:
+                        dep_series = final_df[dependency]
+                    
+                    if dep_series is not None:
+                         # Mask: Keep values where dependency is NOT null, else fill with False Value (default None)
+                         false_val = col_config.get('dependency_false_value')
+                         # Make sure false_val is treated as literal of correct type? pandas usually handles mixed.
+                         
+                         series = series.where(dep_series.notna(), false_val)
+                    else:
+                         print(f"Warning: Dependency column '{dependency}' not found for '{domain_name}.{target_col}'. Treating as all-null dependency.")
+                         false_val = col_config.get('dependency_false_value')
+                         series = pd.Series([false_val] * len(pivoted))
+                
+                # Apply Substring Extraction (Before Value Mapping)
+                if isinstance(col_config, dict):
+                    sub_start = col_config.get('substring_start')
+                    sub_len = col_config.get('substring_length')
+                    if sub_start is not None and sub_len is not None:
+                        # Ensure series is string
+                        series = series.astype(str)
+                        # Slice 0-indexed or 1-indexed? Python is 0-indexed.
+                        # User said "position 3-5". If string is '1110023565' and target is '002',
+                        # indices are 3,4,5. So slice[3:6].
+                        # Let's assume user provides 0-based start index and length.
+                        series = series.str[sub_start : sub_start + sub_len]
+
+                # Apply Value Mapping
+                mapping_default = col_config.get('mapping_default') if isinstance(col_config, dict) else None
+                mapping_default_source = col_config.get('mapping_default_source') if isinstance(col_config, dict) else None
+
+                if value_map:
+                    # Perform mapping (non-matches become NaN)
+                    mapped_series = series.map(value_map)
+                    
+                    if mapping_default is not None:
+                         # Strict mapping with default literal
+                         series = mapped_series.fillna(mapping_default)
+                    elif mapping_default_source is not None:
+                         # Strict mapping with default from another column
+                         fallback = None
+                         if mapping_default_source in final_df.columns:
+                             fallback = final_df[mapping_default_source]
+                         elif mapping_default_source in pivoted.columns:
+                             fallback = pivoted[mapping_default_source]
+                        
+                         if fallback is not None:
+                             series = mapped_series.fillna(fallback)
+                         else:
+                             print(f"Warning: Default source '{mapping_default_source}' not found for '{domain_name}.{target_col}'")
+                             series = mapped_series # Leave as NaN or original? mapped_series has NaNs.
+                    else:
+                         # Partial replacement (legacy: keep original values if not in map)
+                         series = series.replace(value_map)
+
+                # Apply Prefix
+                prefix = col_config.get('prefix') if isinstance(col_config, dict) else None
+                if prefix:
+                    series = prefix + series.astype(str)
+
+                # Apply Type Conversion
+                if target_type:
+                    try:
+                        if target_type == 'int':
+                            series = pd.to_numeric(series, errors='coerce').astype('Int64')
+                        elif target_type == 'float':
+                             series = pd.to_numeric(series, errors='coerce')
+                        elif target_type == 'str':
+                            series = series.astype(str)
+                        elif target_type == 'bool':
+                            series = series.astype(bool)
+                    except Exception as e:
+                        print(f"Error converting {target_col} to {target_type}: {e}")
+
+                final_df[target_col] = series
+                
+                # Validation: max_missing_pct
+                if isinstance(col_config, dict):
+                    max_missing = col_config.get('max_missing_pct')
+                    if max_missing is not None:
+                        missing_count = series.isna().sum()
+                        if target_type == 'str':
+                             missing_count += (series.isin(['nan', 'None'])).sum()
+                        
+                        total = len(series)
+                        if total > 0:
+                            pct = (missing_count / total) * 100
+                            if pct > max_missing:
+                                print(f"WARNING: [Validation] {domain_name}.{target_col} missing {pct:.2f}% (Limit: {max_missing:})")
+            
+            domain_dfs.append(final_df)
+            
+        return domain_dfs

cdiscbuilder/engine/config.py

@@ -0,0 +1,57 @@
+import yaml
+import os
+
+from .validate import load_schema, validate_domain_config
+
+def load_config(config_dir):
+    """
+    Loads all YAML configuration files from the specified directory.
+    Validates them against schema.yaml.
+    """
+    config = {
+        'domains': {},
+        'defaults': {}
+    }
+
+    schema = load_schema()
+
+    if not os.path.exists(config_dir):
+        # Fallback to package data if default path doesn't exist?
+        # Assuming config_dir provided is valid or we expect empty.
+        return config
+
+    for filename in os.listdir(config_dir):
+        if filename.endswith(".yaml") or filename.endswith(".yml"):
+            file_path = os.path.join(config_dir, filename)
+            
+            # Skip schema itself if present in same dir
+            if filename == "schema.yaml":
+                continue
+
+            with open(file_path, "r") as f:
+                try:
+                    data = yaml.safe_load(f)
+                    
+                    if filename == 'defaults.yaml':
+                        # Defaults file - likely flat dict
+                        config['defaults'].update(data)
+                        continue
+
+                    # Merge data
+                    for key, value in data.items():
+                        if key == 'defaults':
+                             # Fallback if someone put defaults: inside another file
+                            config['defaults'].update(value)
+                        else:
+                            # It's a domain
+                            # Validate!
+                            if schema:
+                                if not validate_domain_config(key, value, schema):
+                                    print(f"Warning: {filename} failed schema validation. Proceeding with caution.")
+                                    
+                            config['domains'][key] = value
+
+                except yaml.YAMLError as exc:
+                    print(f"Error parsing YAML file {filename}: {exc}")
+    
+    return config

cdiscbuilder/engine/functions.py

@@ -0,0 +1,49 @@
+import pandas as pd
+
+def extract_value(df_long, form_oids, item_oids, return_col='Value', keys=None):
+    """
+    Generic extraction function for Findings.
+    Args:
+        df_long: The source long format dataframe.
+        form_oids: List of FormOIDs to filter.
+        item_oids: List (or single string) of ItemOIDs to filter.
+        return_col: 'Value' (default) or 'ItemOID'. What to return as the column data.
+        keys: List of key columns to include/index by.
+    Returns:
+        DataFrame containing Keys and the requested data column (renamed to 'Result' or similar).
+    """
+    # 1. Normalize inputs
+    if not isinstance(form_oids, list): 
+        form_oids = [form_oids] if form_oids else []
+    if isinstance(item_oids, str): 
+        item_oids = [item_oids]
+    
+    # 2. Filter Forms
+    # Optimization: pre-filter df_long if passed repeatedly? 
+    # For now, just filter.
+    subset = df_long[df_long['FormOID'].isin(form_oids)].copy()
+    
+    if subset.empty:
+        return pd.DataFrame()
+        
+    # 3. Filter Items
+    # Note: If item_oids is empty/None, do we return everything? No, usually specific.
+    if item_oids:
+        subset = subset[subset['ItemOID'].isin(item_oids)]
+    
+    if subset.empty:
+        return pd.DataFrame() # Return empty but valid DF?
+        
+    # 4. Select Columns
+    # We always need Keys + the Return Col
+    cols_to_keep = keys + [return_col] if keys else [return_col]
+    
+    # If keys are missing (logic error), handle gracefully
+    available_cols = [c for c in cols_to_keep if c in subset.columns]
+    result = subset[available_cols].copy()
+    
+    # 5. Rename return column for clarity? 
+    # The caller will rename it to the target column (e.g. FAORRES).
+    # But if return_col is 'Value' or 'ItemOID', we keep as is for now.
+    
+    return result

cdiscbuilder/engine/processor.py

@@ -0,0 +1,43 @@
+import pandas as pd
+import os
+from .classes.general import GeneralProcessor
+
+
+def process_domain(domain_name, sources, df_long, default_keys, output_dir):
+    # Determine type of the first block (assumes all blocks in a domain are same type)
+    # process_domain receives 'sources' which is settings_entry.
+    
+    # Normalize to list
+    if isinstance(sources, dict):
+        sources = [sources]
+        
+    if not sources:
+        print(f"Warning: No configuration found for {domain_name}")
+        return
+
+    from .classes.finding import FindingProcessor
+
+    # Check type of first source to decide processor
+    p_type = sources[0].get('type', 'general') if sources else 'general'
+
+    if p_type == 'finding':
+        processor = FindingProcessor()
+    else:
+        processor = GeneralProcessor()
+
+    domain_dfs = processor.process(domain_name, sources, df_long, default_keys)
+
+    if not domain_dfs:
+        print(f"Warning: No data found for domain {domain_name}")
+        return
+        
+    # Concatenate all sources for this domain
+    combined_df = pd.concat(domain_dfs, ignore_index=True)
+    
+    # Save to Parquet
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+        
+    output_path = os.path.join(output_dir, f"{domain_name}.parquet")
+    combined_df.to_parquet(output_path, index=False)
+    print(f"Saved {domain_name} to {output_path} (Shape: {combined_df.shape})")

cdiscbuilder/engine/validate.py

@@ -0,0 +1,99 @@
+import yaml
+import os
+
+def load_schema():
+    # config_data is parallel to engine/
+    pkg_root = os.path.dirname(os.path.dirname(__file__)) # src/cdiscbuilder
+    schema_path = os.path.join(pkg_root, "specs", "schema.yaml")
+    
+    if not os.path.exists(schema_path):
+        print(f"Warning: Schema file not found at {schema_path}")
+        return None
+        
+    with open(schema_path, 'r') as f:
+        return yaml.safe_load(f)
+
+def validate_domain_config(domain_name, config, schema):
+    """
+    Validates a single domain configuration against the schema.
+    """
+    if not schema:
+        return True
+
+    # Check if General (List) or Findings (Dict)
+    is_general = isinstance(config, list)
+    is_findings = isinstance(config, dict) and config.get('type') == 'FINDINGS'
+
+    if is_general:
+        return _validate_general(domain_name, config, schema['schemas']['general_domain'], schema['definitions'])
+    elif is_findings:
+        return _validate_findings(domain_name, config, schema['schemas']['findings_domain'], schema['definitions'])
+    else:
+        # Fallback or mixed type?
+        # If dict but not FINDINGS, maybe it's a single general block (normalized usually)
+        # But our loader usually normalizes.
+        print(f"Validation Warning: {domain_name} structure unrecognized (Not List or Findings Dict).")
+        return False
+
+def _validate_general(domain, config, schema, definitions):
+    if not isinstance(config, list):
+        print(f"Schema Error: {domain} must be a list (General Domain). Got {type(config)}")
+        return False
+        
+    for idx, block in enumerate(config):
+        if not isinstance(block, dict):
+            print(f"Schema Error: {domain}[{idx}] must be a dict. Got {type(block)}")
+            return False
+
+        # Validate required keys
+        item_schema = schema.get('item_schema', {})
+        for req in item_schema.get('required', []):
+            if req not in block:
+                print(f"Schema Error: {domain}[{idx}] missing required key '{req}'")
+                return False
+        
+        # Validate columns
+        columns = block.get('columns', {})
+        if not isinstance(columns, dict):
+             print(f"Schema Error: {domain}[{idx}].columns must be a dict.")
+             return False
+             
+        for col_name, col_def in columns.items():
+            # col_def must be dict usually, but we allow simple strings in some legacy?
+            # Schema says dict.
+            if not isinstance(col_def, dict):
+                 # Legacy: mapped directly?
+                 # Ignoring for strict schema
+                 pass
+            else:
+                 # Check properties
+                 pass # Detailed prop check can be added
+                 
+    return True
+
+def _validate_findings(domain, config, schema, definitions):
+    # Validate required
+    for req in schema.get('required', []):
+        if req not in config:
+            print(f"Schema Error: {domain} missing required key '{req}'")
+            return False
+
+    # Validate Columns List
+    cols = config.get('columns', [])
+    if not isinstance(cols, list):
+        print(f"Schema Error: {domain}.columns must be a list.")
+        return False
+        
+    col_schema = definitions['column_findings']
+    for idx, col in enumerate(cols):
+        if not isinstance(col, dict):
+             print(f"Schema Error: {domain}.columns[{idx}] must be a dict.")
+             return False
+             
+        # Check required
+        for req in col_schema.get('required', []):
+            if req not in col:
+                 print(f"Schema Error: {domain}.columns[{idx}] missing '{req}'")
+                 return False
+
+    return True

cdiscbuilder/odm.py

@@ -0,0 +1,103 @@
+import xml.etree.ElementTree as ET
+import pandas as pd
+
+def parse_odm_to_long_df(xml_file):
+    try:
+        tree = ET.parse(xml_file)
+        root = tree.getroot()
+    except Exception as e:
+        print(f"Error parsing XML file {xml_file}: {e}")
+        return pd.DataFrame()
+
+    def parse_metadata(root):
+        item_question_map = {}
+        ns = {'odm': 'http://www.cdisc.org/ns/odm/v1.3'}
+        # Find MetaDataVersion - simplified lookup
+        for study in root.findall('odm:Study', ns):
+            for mdv in study.findall('odm:MetaDataVersion', ns):
+                for item_def in mdv.findall('odm:ItemDef', ns):
+                    oid = item_def.get('OID')
+                    
+                    # Try to find Question/TranslatedText
+                    question = ""
+                    q_elem = item_def.find('odm:Question', ns)
+                    if q_elem is not None:
+                        tt_elem = q_elem.find('odm:TranslatedText', ns)
+                        if tt_elem is not None:
+                            question = tt_elem.text.strip() if tt_elem.text else ""
+                    
+                    item_question_map[oid] = question
+        return item_question_map
+
+    item_question_map = parse_metadata(root)
+
+    data_rows = []
+
+    def get_local_name(tag):
+        if '}' in tag:
+            return tag.split('}', 1)[1]
+        return tag
+
+    for cd in root:
+        if get_local_name(cd.tag) == 'ClinicalData':
+            study_oid = cd.get('StudyOID')
+            for sd in cd:
+                if get_local_name(sd.tag) == 'SubjectData':
+                    subject_key = sd.get('SubjectKey')
+                    
+                    # Helper for attributes
+                    def get_attrib(elem, partial_name):
+                        if partial_name in elem.attrib:
+                            return elem.attrib[partial_name]
+                        for k, v in elem.attrib.items():
+                            if k.endswith("}" + partial_name):
+                                return v
+                        return None
+
+                    study_subject_id = get_attrib(sd, 'StudySubjectID') or get_attrib(sd, 'studysubjectid')
+                    if not subject_key:
+                        subject_key = study_subject_id
+
+                    for child in sd:
+                        tag = get_local_name(child.tag)
+                        if tag == 'StudyEventData':
+                            study_event_oid = child.get('StudyEventOID')
+                            study_event_repeat_key = child.get('StudyEventRepeatKey')
+                            
+                            # Extract Namespaced StartDate
+                            start_date = get_attrib(child, 'StartDate')
+                            
+                            for form in child:
+                                f_tag = get_local_name(form.tag)
+                                if f_tag == 'FormData':
+                                    form_oid = form.get('FormOID')
+                                    
+                                    for ig in form:
+                                        ig_tag = get_local_name(ig.tag)
+                                        if ig_tag == 'ItemGroupData':
+                                            item_group_oid = ig.get('ItemGroupOID')
+                                            item_group_repeat_key = ig.get('ItemGroupRepeatKey')
+                                            
+                                            for item in ig:
+                                                i_tag = get_local_name(item.tag)
+                                                if i_tag == 'ItemData':
+                                                    item_oid = item.get('ItemOID')
+                                                    value = item.get('Value')
+                                                    
+                                                    data_rows.append({
+                                                        'StudyOID': study_oid,
+                                                        'SubjectKey': subject_key,
+                                                        'StudySubjectID': study_subject_id,
+                                                        'StudyEventOID': study_event_oid,
+                                                        'StudyEventRepeatKey': study_event_repeat_key,
+                                                        'StudyEventStartDate': start_date,
+                                                        'FormOID': form_oid,
+                                                        'ItemGroupOID': item_group_oid,
+                                                        'ItemGroupRepeatKey': item_group_repeat_key,
+                                                        'ItemOID': item_oid,
+                                                        'Value': value,
+                                                        'Question': item_question_map.get(item_oid, "")
+                                                    })
+
+    df = pd.DataFrame(data_rows)
+    return df

cdiscbuilder/sdtm.py

@@ -0,0 +1,30 @@
+import pandas as pd
+from .engine.config import load_config
+from .engine.processor import process_domain
+
+def create_sdtm_datasets(config_input, input_csv, output_dir):
+    if isinstance(config_input, dict):
+        config = config_input
+        # We assume it's already structured correctly or validated
+    else:
+        config = load_config(config_input)
+    
+    # Get global defaults
+    default_keys = config.get('defaults', {}).get('keys', ["StudyOID", "SubjectKey", "ItemGroupRepeatKey", "StudyEventOID"])
+
+    print(f"Loading data from {input_csv}...")
+    df_long = pd.read_csv(input_csv)
+
+    for domain, settings_entry in config['domains'].items():
+
+        print(f"Processing domain: {domain}")
+        
+        # Normalize to list.
+        if isinstance(settings_entry, list):
+            sources = settings_entry
+        else:
+            sources = [settings_entry]
+            
+        process_domain(domain, sources, df_long, default_keys, output_dir)
+
+

cdiscbuilder/specs/AE.yaml

@@ -0,0 +1,25 @@
+AE:
+  - formoid: "F_AE_1"
+    columns:
+      STUDYID: 
+        source: "StudyOID"
+        type: "str"
+      DOMAIN: 
+        literal: "AE"
+        type: "str"
+      USUBJID: 
+        source: "StudySubjectID"
+        prefix: "PPT-"
+        type: "str"
+      AESEQ: 
+        source: "ItemGroupRepeatKey"
+        type: "int"
+      AETERM: 
+        source: "I_AE_TERM"
+        type: "str"
+      AESTDTC: 
+        source: "I_AE_STARTDATE"
+        type: "str"
+      AESEV: 
+        source: "I_AE_SEVERITY"
+        type: "str"

cdiscbuilder/specs/CM.yaml

@@ -0,0 +1,26 @@
+CM:
+  - formoid: "F_CM_1"
+    keys: ["StudyOID", "StudySubjectID", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN:
+        literal: "CM"
+        type: "str"
+      USUBJID:
+        source: "StudySubjectID"
+        prefix: "PPT-"
+        type: "str"
+      CMSEQ:
+        source: "ItemGroupRepeatKey"
+        type: "int"
+      CMTRT:
+        source: "I_CM_TERM"
+        type: "str"
+      CMDOSE:
+        source: "I_CM_DOSE"
+        type: "float"
+      CMDOSEU:
+        source: "I_CM_UNIT"
+        type: "str"

cdiscbuilder/specs/DM.yaml

@@ -0,0 +1,51 @@
+DM:
+  - formoid: ["F_DEMOG_1", "F_DEMOG_2"] # Example of merging data from multiple forms
+    keys: ["StudyOID", "StudySubjectID"]
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN: 
+        literal: "DM"
+        type: "str"
+      USUBJID: 
+        source: "StudySubjectID"
+        prefix: "PPT-"
+        type: "str"
+        max_missing_pct: 0
+      SUBJID: 
+        source: "StudySubjectID"
+        type: "str"
+      SEX: 
+        source: "I_DEMOG_SEX"
+        type: "str"
+        value_mapping:
+          "F": "Female"
+          "M": "Male"
+      EDCSUBID: 
+        source: "StudySubjectID"
+        type: "str"
+      SITEID:
+        source: "EDCSUBID"
+        type: "str"
+        substring_start: 3
+        substring_length: 3
+        value_mapping:
+          "002": "LAX"
+      CUSTOMSITEID:
+        source: "SITEID"
+        type: "str"
+        value_mapping:
+          "LAX": "LAX"
+        mapping_default: "SFO" 
+        # mapping_default_source: "SEX"
+      RACE: 
+        source: "I_DEMOG_RACE"
+        type: "str"
+      COUNTRY: 
+        literal: "USA"
+        type: "str"
+      AGE:
+        source: "I_DEMOG_AGE"
+        type: "int"
+        max_missing_pct: 5

cdiscbuilder/specs/DS.yaml

@@ -0,0 +1,54 @@
+DS:
+  # Block 1: Informed Consent
+  - formoid: "F_IC_1"
+    keys: ["StudyOID", "SubjectKey", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN:
+        literal: "DS"
+        type: "str"
+      USUBJID:
+        source: "SubjectKey"
+        type: "str"
+      DSSEQ:
+        source: "ItemGroupRepeatKey" # Will likely be 1, duplicates allowed across events in raw output
+        type: "int"
+      DSTERM:
+        literal: "INFORMED CONSENT" # Enrolled/Screened etc
+        type: "str"
+      DSDECOD:
+        literal: "INFORMED CONSENT OBTAINED"
+        dependency: "I_IC_DATE"
+        dependency_false_value: "INFORMED CONSENT NOT OBTAINED"
+        type: "str"
+      DSSTDTC:
+        source: "I_IC_DATE"
+        type: "str"
+
+  # Block 2: Disposition (Termination)
+  - formoid: "F_DISP_1"
+    keys: ["StudyOID", "SubjectKey", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN:
+        literal: "DS"
+        type: "str"
+      USUBJID:
+        source: "SubjectKey"
+        type: "str"
+      DSSEQ:
+         source: "ItemGroupRepeatKey"
+         type: "int"
+      DSTERM:
+        source: "I_DISP_TERM"
+        type: "str"
+      DSDECOD:
+        source: "I_DISP_DECOD"
+        type: "str"
+      DSSTDTC:
+        source: "I_DISP_DTC"
+        type: "str"

cdiscbuilder/specs/FA.yaml

@@ -0,0 +1,32 @@
+FA:
+  # Findings About Adverse Events (Compact List)
+  - formoid: "F_AE_1"
+    keys: ["StudyOID", "SubjectKey", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID: {source: "StudyOID", type: "str"}
+      DOMAIN: {literal: "FA", type: "str"}
+      USUBJID: {source: "SubjectKey", type: "str"}
+      FASEQ: {source: "ItemGroupRepeatKey", type: "int"}
+      
+      FAOBJ: 
+        source: "I_AE_TERM" 
+        type: "str"
+        
+      # Compact List Expansion
+      FATESTCD: 
+        literal: ["SEV", "LOC"]
+        type: "str"
+      
+      FATEST: 
+        literal: ["Severity", "Location"]
+        type: "str"
+      
+      FAORRES: 
+        source: ["I_AE_SEVERITY", "I_AE_LOC_MOCK"] # LOC_MOCK will assume NaN
+        type: "str"
+        
+      FASTRESC: 
+        source: ["I_AE_SEVERITY", "I_AE_LOC_MOCK"]
+        type: "str"
+      
+      FADTC: {source: "I_AE_STARTDATE", type: "str"}

cdiscbuilder/specs/IE.yaml

@@ -0,0 +1,35 @@
+IE:
+  - formoid: "F_IE_1"
+    keys: ["StudyOID", "StudySubjectID", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN:
+        literal: "IE"
+        type: "str"
+      USUBJID:
+        source: "StudySubjectID"
+        prefix: "PPT-"
+        type: "str"
+      IESEQ:
+        source: "ItemGroupRepeatKey"
+        type: "int"
+      IETESTCD:
+        literal: ["INCL01", "EXCL01"]
+        type: "str"
+      IETEST:
+        literal: ["Age >= 18", "Pregnant"]
+        type: "str"
+      IECAT:
+        literal: ["INCLUSION", "EXCLUSION"]
+        type: "str"
+      IEORRES:
+        source: ["I_IE_INCL_01", "I_IE_EXCL_01"]
+        type: "str"
+      IESTRESC:
+        source: ["I_IE_INCL_01", "I_IE_EXCL_01"]
+        type: "str"
+      IEDTC:
+        source: "I_IE_DTC"
+        type: "str"

cdiscbuilder/specs/PE.yaml

@@ -0,0 +1,25 @@
+PE:
+  - formoid: "FORM.VITPHYEX"
+    keys: ["StudyOID", "SubjectKey", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN:
+        literal: "PE"
+        type: "str"
+      USUBJID:
+        source: "SubjectKey"
+        type: "str"
+      PESEQ:
+        source: "ItemGroupRepeatKey"
+        type: "int"
+      PETESTCD:
+        source: "IT.BODY_SYS"
+        type: "str"
+      PEORRES:
+        source: "IT.ABNORM"
+        type: "str"
+      PECOMM:
+        source: "IT.COMMT1"
+        type: "str"

cdiscbuilder/specs/SV.yaml

@@ -0,0 +1,23 @@
+SV:
+  # Compact SV: Trigger on any of these forms effectively finding all Visits
+  - formoid: ["F_DEMOG_1", "F_VS_1", "F_DISP_1", "F_LAB_1"]
+    
+    # Group by Event (Visit), ignoring which specific Form triggered it
+    keys: ["StudyOID", "SubjectKey", "StudyEventOID", "StudyEventRepeatKey"]
+    
+    columns:
+      STUDYID:
+        source: "StudyOID"
+        type: "str"
+      DOMAIN:
+        literal: "SV"
+        type: "str"
+      USUBJID:
+        source: "SubjectKey"
+        type: "str"
+      VISIT:
+        source: "StudyEventOID"
+        type: "str"
+      SVSTDTC:
+        source: "StudyEventStartDate"
+        type: "str"

cdiscbuilder/specs/VS.yaml

@@ -0,0 +1,38 @@
+VS:
+  - formoid: "F_VS_1"
+    keys: ["StudyOID", "SubjectKey", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]
+    columns:
+      STUDYID: {source: "StudyOID", type: "str"}
+      DOMAIN: {literal: "VS", type: "str"}
+      USUBJID: {source: "SubjectKey", type: "str"}
+      VSSEQ: {source: "ItemGroupRepeatKey", type: "int"}
+      
+      VSTESTCD: 
+        literal: ["HEIGHT", "WEIGHT", "SYSBP", "DIABP"]
+        type: "str"
+      
+      VSTEST:
+        literal: ["Height", "Weight", "Systolic Blood Pressure", "Diastolic Blood Pressure"]
+        type: "str"
+
+      VSORRES:
+        source: ["I_VS_HEIGHT", "I_VS_WEIGHT", "I_VS_SYSBP", "I_VS_DIABP"]
+        type: "str"
+      
+      VSORRESU:
+        literal: ["cm", "kg", "mmHg", "mmHg"]
+        type: "str"
+
+      VSSTRESC:
+        source: ["I_VS_HEIGHT", "I_VS_WEIGHT", "I_VS_SYSBP", "I_VS_DIABP"]
+        type: "str"
+
+      VSSTRESN:
+        source: ["I_VS_HEIGHT", "I_VS_WEIGHT", "I_VS_SYSBP", "I_VS_DIABP"]
+        type: "float"
+
+      VSSTRESU:
+        literal: ["cm", "kg", "mmHg", "mmHg"]
+        type: "str"
+        
+      VSDTC: {literal: "", type: "str"}

cdiscbuilder/specs/defaults.yaml

@@ -0,0 +1 @@
+keys: ["StudyOID", "StudySubjectID", "StudyEventOID", "StudyEventRepeatKey", "ItemGroupRepeatKey"]

cdiscbuilder/specs/schema.yaml

@@ -0,0 +1,63 @@
+version: "1.0"
+definitions:
+  column_general:
+    type: dict
+    properties:
+      source: {type: str}
+      literal: {type: [str, int, float, bool]}
+      type: {type: str, enum: [str, int, float, bool]}
+      max_missing_pct: {type: [int, float]}
+      value_mapping: {type: dict}
+      prefix: {type: str}
+      substring_start: {type: int}
+      substring_length: {type: int}
+      mapping_default: {type: [str, int, float, bool]}
+      mapping_default_source: {type: str}
+      dependency: {type: str}
+      dependency_false_value: {type: [str, int, float, bool]}
+      regex_extract: {type: str}
+
+  column_findings:
+    type: dict
+    required: [name]
+    properties:
+      name: {type: str}
+      label: {type: str}
+      type: {type: str}
+      literal: {type: [str, int, float, bool]}
+      source: {type: str}
+      function: {type: str}
+      formoid: {type: [str, list]}
+      itemoid: {type: [str, list]}
+      value_mapping: {type: dict}
+      prefix: {type: str}
+      substring_start: {type: int}
+      substring_length: {type: int}
+      mapping_default: {type: [str, int, float, bool]}
+      mapping_default_source: {type: str}
+
+schemas:
+  general_domain:
+    type: list
+    item_schema:
+      type: dict
+      required: [formoid, columns]
+      properties:
+        type: {type: str, enum: ["general", "finding"]}
+        item_group_regex: {type: str}
+        item_oid_regex: {type: str}
+        formoid: {type: [str, list]}
+        keys: {type: list}
+        columns:
+          type: dict
+          values_schema: {ref: column_general}
+
+  findings_domain:
+    type: dict
+    required: [type, columns]
+    properties:
+      type: {const: FINDINGS}
+      definitions: {type: dict} # YAML Anchors container
+      columns:
+        type: list
+        item_schema: {ref: column_findings}

cdiscbuilder-0.2.8.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: cdiscbuilder
+Version: 0.2.8
+Summary: A package to convert ODM XML to SDTM/ADaM Datasets
+Author-email: Ming-Chun Chen <hellomingchun@gmail.com>
+Requires-Python: >=3.8
+License-File: LICENSE
+Requires-Dist: pandas
+Requires-Dist: pyyaml
+Dynamic: license-file

cdiscbuilder-0.2.8.dist-info/RECORD

@@ -0,0 +1,29 @@
+cdiscbuilder/__init__.py,sha256=anBcPGggCP0f-o9w0IsZYV49rl6HvJbHcuDN39x3mxw,23
+cdiscbuilder/cli.py,sha256=RfSjnAgc7_BsNHDun2MKsHRvpl2aUnFHKok0gnK1HEw,1677
+cdiscbuilder/odm.py,sha256=lSEvceOMr0D0oPNrr1P8MMoaT7j4XqhCEW53TN2nI1U,5229
+cdiscbuilder/sdtm.py,sha256=yK4DIrAkCVNzOXae9oE-7RfqGiWkXPOrfxY6lNYCrPc,1000
+cdiscbuilder/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdiscbuilder/engine/config.py,sha256=WEcQ6ui8Ozb08GNrzcpVlK0etoVPI_5-Yb_VoDOXAhg,2093
+cdiscbuilder/engine/functions.py,sha256=SdyhFftFoxIzL-pzIcjVsf9CbZmxKKo7J1J0H7t28KU,1876
+cdiscbuilder/engine/processor.py,sha256=R5I6ZS2Yj49m_uBudJhvoNqmWn7A7-30xaQe59H5nnI,1457
+cdiscbuilder/engine/validate.py,sha256=vGUirL3yPk6a9D6MlRpmHf54tB-PMNH7FMKCxsXROgQ,3799
+cdiscbuilder/engine/classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cdiscbuilder/engine/classes/finding.py,sha256=J3y-VTMyX0WGqLxTJ1fC-OqfcEm7wK2987A-EuLyOgo,4845
+cdiscbuilder/engine/classes/general.py,sha256=gqndzK2A2Eqwe6_5qxLdYHq-bwjT9hnYn1HafdTgDyw,11755
+cdiscbuilder/specs/AE.yaml,sha256=xeTuR0uNOzHXgTJerIZl8K5ewP2hL3lbBSu175WHjeg,545
+cdiscbuilder/specs/CM.yaml,sha256=s-tV27tdw9c_EcnVukaZS3iONi188SVBzJ7mMqNROm8,635
+cdiscbuilder/specs/DM.yaml,sha256=3N7y_F2eMP2P7SWun8oxaHfxvn80PYdgVQ_eyE3pPGg,1258
+cdiscbuilder/specs/DS.yaml,sha256=YeJmkt5xjyHhYl6H7rroRzcyEvVtRxloDTpZgcRuruc,1498
+cdiscbuilder/specs/FA.yaml,sha256=oe9Hkoxfw0Zx9rPNiPxatgMEJTeZUBVZU7A0u-Hw9qA,960
+cdiscbuilder/specs/IE.yaml,sha256=E1U_ftpjm_76mBS10XFVg1h8Ez8TaXIPeXccFjvFUiY,913
+cdiscbuilder/specs/PE.yaml,sha256=-_L8dxYROif35DRtpmL03C2te7-qRNhTrL6npMLGm8k,613
+cdiscbuilder/specs/SV.yaml,sha256=M-Bo7d_gmhLRpqaKarQQpadmW9uc4Qolg1mRI36Mt4U,656
+cdiscbuilder/specs/VS.yaml,sha256=Xm0IVMzImAVmHzSEVbaHe372PqDYPZ-Vq1lED7T1SMk,1168
+cdiscbuilder/specs/defaults.yaml,sha256=5Hq2Yj00cC_watAGSXd6bKSqjb2fyp_AtU4nQgj5Ans,100
+cdiscbuilder/specs/schema.yaml,sha256=7iBdin4xvBAk3e5oAp6lC2uzbroGyZL_tJNrDxG2DSI,1864
+cdiscbuilder-0.2.8.dist-info/licenses/LICENSE,sha256=Da4Pm8tEdB1ycKkAkF2EwfHd-8l0wrJ_uwejzfBRHFE,1092
+cdiscbuilder-0.2.8.dist-info/METADATA,sha256=WQgqxUnUyFXpQ8WyLHwHM8ovG5Vnc-BgmTr3vLgXjTA,292
+cdiscbuilder-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cdiscbuilder-0.2.8.dist-info/entry_points.txt,sha256=KsuiJD4hsfjRqDkdvWgLFPeQCz7QBl73RA665BmF0Pw,53
+cdiscbuilder-0.2.8.dist-info/top_level.txt,sha256=3x5ENgnXBENgXKp5Zsht_4_OmA5wLVvDuk0UEkYOGNw,13
+cdiscbuilder-0.2.8.dist-info/RECORD,,

cdiscbuilder-0.2.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cdiscbuilder-0.2.8.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+cdisc-sdtm = cdiscbuilder.cli:main

cdiscbuilder-0.2.8.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ming-Chun Chen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cdiscbuilder-0.2.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+cdiscbuilder