cdiscbuilder 1.2.3__tar.gz → 1.3.1__tar.gz

{cdiscbuilder-1.2.3/src/cdiscbuilder.egg-info → cdiscbuilder-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cdiscbuilder
-Version: 1.2.3
+Version: 1.3.1
 Summary: A package to convert ODM XML to SDTM/ADaM Datasets
 Author-email: Ming-Chun Chen <hellomingchun@gmail.com>
 Requires-Python: >=3.9

{cdiscbuilder-1.2.3 → cdiscbuilder-1.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cdiscbuilder"
-version = "1.2.3"
+version = "1.3.1"
 description = "A package to convert ODM XML to SDTM/ADaM Datasets"
 readme = "README.md"
 authors = [{name = "Ming-Chun Chen", email = "hellomingchun@gmail.com"}]
@@ -20,7 +20,7 @@ requires-python = ">=3.9"
 cdisc-sdtm = "cdiscbuilder.cli:main"
 
 [tool.setuptools.package-data]
-cdiscbuilder = ["adam/schema.yaml", "adam/adam_spec/tests/data/scenarios/**/*.yaml"]
+cdiscbuilder = ["adam/schema.yaml", "adam/adam_spec/tests/data/scenarios/**/*.yaml", "sdtm/specs/schema.yaml"]
 
 [tool.setuptools.packages.find]
 where = ["src"]

{cdiscbuilder-1.2.3 → cdiscbuilder-1.3.1}/src/cdiscbuilder/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.2.3"
+__version__ = "1.3.1"
 
 from . import adam as adam
 from . import tlf as tlf

{cdiscbuilder-1.2.3 → cdiscbuilder-1.3.1}/src/cdiscbuilder/functions/__init__.py

@@ -6,6 +6,10 @@ Maps short function names to full module paths for cleaner specifications.
 from .get_bmi import get_bmi
 from .calculate_study_day import calculate_study_day
 from .extract_value import extract_value
+from .get_dose_dates import get_first_dose_date, get_last_dose_date
+from .coalesce import coalesce
+from .get_last_participation_date import get_last_participation_date
+from .get_earliest_informed_consent_date import get_earliest_informed_consent_date
 
 # Function registry mapping short names to full paths
 FUNCTION_REGISTRY = {
@@ -15,6 +19,11 @@ FUNCTION_REGISTRY = {
     # SDTM functions
     "calculate_study_day": "cdiscbuilder.functions.calculate_study_day.calculate_study_day",
     "extract_value": "cdiscbuilder.functions.extract_value.extract_value",
+    "get_first_dose_date": "cdiscbuilder.functions.get_dose_dates.get_first_dose_date",
+    "get_last_dose_date": "cdiscbuilder.functions.get_dose_dates.get_last_dose_date",
+    "coalesce": "cdiscbuilder.functions.coalesce.coalesce",
+    "get_last_participation_date": "cdiscbuilder.functions.get_last_participation_date.get_last_participation_date",
+    "get_earliest_informed_consent_date": "cdiscbuilder.functions.get_earliest_informed_consent_date.get_earliest_informed_consent_date",
 }
 
 
@@ -61,6 +70,11 @@ __all__ = [
     "get_bmi",
     "calculate_study_day",
     "extract_value",
+    "get_first_dose_date",
+    "get_last_dose_date",
+    "coalesce",
+    "get_last_participation_date",
+    "get_earliest_informed_consent_date",
     "get_function_path",
     "list_available_functions",
     "register_function",

cdiscbuilder-1.3.1/src/cdiscbuilder/functions/calculate_study_day.py

@@ -0,0 +1,33 @@
+import pandas as pd
+
+
+def calculate_study_day(date_series, rfstdtc_series):
+    """
+    Calculates SDTM Study Day (--DY).
+    SDTM Rule:
+    - If date is on or after RFSTDTC: (date - RFSTDTC) + 1
+    - If date is before RFSTDTC: (date - RFSTDTC)
+    - There is no Day 0.
+    - Partial dates (missing day or month) cannot be used to calculate study day.
+    """
+    # Filter out partial dates (ISO 8601 YYYY-MM-DD is at least 10 chars)
+    # This prevents pd.to_datetime from assuming the 1st of the month for 'YYYY-MM'
+    valid_d = date_series.where(date_series.astype(str).str.len() >= 10)
+    valid_rf = rfstdtc_series.where(rfstdtc_series.astype(str).str.len() >= 10)
+    
+    # Convert to datetime (utc=True prevents tz-naive/tz-aware subtraction issues if times exist)
+    d = pd.to_datetime(valid_d, errors="coerce", utc=True)
+    rf = pd.to_datetime(valid_rf, errors="coerce", utc=True)
+
+    # Normalize to midnight to remove time components safely
+    d = d.dt.normalize()
+    rf = rf.dt.normalize()
+
+    # Calculate difference in days
+    diff = (d - rf).dt.days
+
+    # Apply SDTM rules (no Day 0)
+    dy = diff.apply(lambda x: (x + 1) if pd.notnull(x) and x >= 0 else x)
+    
+    # Cast to Int64 (nullable integer)
+    return dy.astype("Int64")

cdiscbuilder-1.3.1/src/cdiscbuilder/functions/coalesce.py

@@ -0,0 +1,22 @@
+import pandas as pd
+
+def coalesce(*series_list, **kwargs):
+    """
+    Returns the first non-null value across a list of Pandas Series.
+    Similar to SQL COALESCE.
+    """
+    if not series_list:
+        raise ValueError("coalesce requires at least one argument")
+        
+    # Start with the first series
+    result = series_list[0].copy()
+    
+    # Iterate through remaining series and fill missing values
+    for s in series_list[1:]:
+        # Ensure 's' is a Series (in case a literal was passed somehow, though general.py doesn't currently do that)
+        if not isinstance(s, pd.Series):
+            s = pd.Series([s] * len(result), index=result.index)
+            
+        result = result.combine_first(s)
+        
+    return result

cdiscbuilder-1.3.1/src/cdiscbuilder/functions/get_dose_dates.py

@@ -0,0 +1,86 @@
+import pandas as pd
+
+def _get_dose_date(usubjid_series, built_domains, mode="first", **kwargs):
+    """
+    Core logic to find the first or last dose date from EX or EC domains
+    where the dose > 0.
+    """
+    if not built_domains:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    ex_df = built_domains.get("EX")
+    ec_df = built_domains.get("EC")
+    
+    # Get custom dose column names if provided in kwargs
+    ex_dose_col = kwargs.get("ex_dose_col", "EXDOSE")
+    ec_dose_col = kwargs.get("ec_dose_col", "ECDOSE")
+    
+    dfs = []
+    
+    # Process EX
+    if ex_df is not None and not ex_df.empty:
+        if "USUBJID" in ex_df.columns:
+            date_col = "EXSTDTC" if mode == "first" else "EXENDTC"
+            if date_col in ex_df.columns:
+                valid = ex_df
+                if ex_dose_col in ex_df.columns:
+                    dose = pd.to_numeric(ex_df[ex_dose_col], errors='coerce')
+                    valid = ex_df[dose > 0]
+                dfs.append(valid[["USUBJID", date_col]].rename(columns={date_col: "DATE"}))
+                
+    # Process EC
+    if ec_df is not None and not ec_df.empty:
+        if "USUBJID" in ec_df.columns:
+            date_col = "ECSTDTC" if mode == "first" else "ECENDTC"
+            if date_col in ec_df.columns:
+                valid = ec_df
+                if ec_dose_col in ec_df.columns:
+                    dose = pd.to_numeric(ec_df[ec_dose_col], errors='coerce')
+                    valid = ec_df[dose > 0]
+                dfs.append(valid[["USUBJID", date_col]].rename(columns={date_col: "DATE"}))
+                
+    if not dfs:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    combined = pd.concat(dfs, ignore_index=True)
+    combined = combined.dropna(subset=["DATE"])
+    
+    if combined.empty:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+    
+    # Convert to proper datetime objects for robust chronological sorting
+    # We do this to ensure "2026-05-01T08:00" and "2026-05-01" sort correctly as actual time
+    # rather than just alphabetical strings.
+    combined["DATETIME"] = pd.to_datetime(combined["DATE"], errors='coerce', utc=True)
+    
+    # Drop rows that couldn't be parsed as dates (e.g. completely invalid garbage)
+    combined = combined.dropna(subset=["DATETIME"])
+    
+    if combined.empty:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+    
+    # Find the index of the min/max datetime per subject
+    if mode == "first":
+        idx = combined.groupby("USUBJID")["DATETIME"].idxmin()
+    else:
+        idx = combined.groupby("USUBJID")["DATETIME"].idxmax()
+        
+    # Extract the original string format (with the 'T') using the found indices
+    res = combined.loc[idx].set_index("USUBJID")["DATE"]
+    
+    # Map back to the exact input series sequence
+    return usubjid_series.map(res)
+
+def get_first_dose_date(usubjid_series, built_domains=None, **kwargs):
+    """
+    Calculates RFXSTDTC (First Study Treatment Date).
+    Extracts minimum start date from EX or EC domains where dose > 0.
+    """
+    return _get_dose_date(usubjid_series, built_domains, mode="first", **kwargs)
+    
+def get_last_dose_date(usubjid_series, built_domains=None, **kwargs):
+    """
+    Calculates RFXENDTC (Last Study Treatment Date).
+    Extracts maximum end date from EX or EC domains where dose > 0.
+    """
+    return _get_dose_date(usubjid_series, built_domains, mode="last", **kwargs)

cdiscbuilder-1.3.1/src/cdiscbuilder/functions/get_earliest_informed_consent_date.py

@@ -0,0 +1,93 @@
+import pandas as pd
+
+def get_earliest_informed_consent_date(usubjid_series, built_domains=None, df_long=None, **kwargs):
+    """
+    Calculates RFICDTC (Date/Time of Informed Consent).
+    Can scan the built DS domain OR raw df_long (to avoid circular dependencies).
+    
+    kwargs:
+      raw_mode: bool. If True, searches df_long instead of built_domains (default: False)
+      raw_formoid: If raw_mode=True, the FormOID to filter on (optional)
+      term_col: The column (or ItemOID) to check for consent terms (default: 'DSDECOD' or 'DSTERM')
+      consent_terms: List of terms indicating consent (default: ['INFORMED CONSENT OBTAINED'])
+      date_col: The date column (or ItemOID) to extract (default: 'DSSTDTC' or 'DSSTDAT')
+    """
+    raw_mode = kwargs.get("raw_mode", False)
+    consent_terms = kwargs.get("consent_terms", ["INFORMED CONSENT OBTAINED"])
+    upper_terms = [t.upper() for t in consent_terms]
+    
+    if raw_mode:
+        if df_long is None or df_long.empty:
+            return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+            
+        term_col = kwargs.get("term_col", "DSTERM")
+        date_col = kwargs.get("date_col", "DSSTDAT")
+        formoid = kwargs.get("raw_formoid")
+        
+        subset = df_long
+        if formoid:
+            subset = df_long[df_long["FormOID"] == formoid]
+            
+        # We need to find the SubjectKey where term_col has a consent term
+        term_mask = (subset["ItemOID"] == term_col) & (subset["Value"].astype(str).str.upper().isin(upper_terms))
+        consent_subjects = subset[term_mask]["SubjectKey"].unique()
+        
+        # Now find the date_col for those subjects
+        # Wait, if multiple repeats exist, we should match on ItemGroupRepeatKey too
+        # To keep it robust, let's just get all date_cols for those subjects on that form
+        # and take the minimum date.
+        date_mask = (subset["ItemOID"] == date_col) & (subset["SubjectKey"].isin(consent_subjects))
+        valid = subset[date_mask].copy()
+        
+        if valid.empty:
+            return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+            
+        valid["DATETIME"] = pd.to_datetime(valid["Value"], errors='coerce', utc=True)
+        valid = valid.dropna(subset=["DATETIME"])
+        
+        if valid.empty:
+            return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+            
+        idx = valid.groupby("SubjectKey")["DATETIME"].idxmin()
+        # Map raw SubjectKey to our usubjid_series (assuming USUBJID ends with SubjectKey)
+        # Note: In CDISC, USUBJID = STUDYID-SubjectKey.
+        # But this function receives usubjid_series, so we might need to map via raw SubjectKey.
+        # Instead, let's just match SubjectKey directly.
+        res = valid.loc[idx].set_index("SubjectKey")["Value"]
+        
+        # Because usubjid_series is standard USUBJID (e.g. 'STUDY-001'), we need to strip study to match
+        # Let's extract the subject key from the end
+        subject_keys_from_usubjid = usubjid_series.astype(str).str.split("-").str[-1]
+        mapped = subject_keys_from_usubjid.map(res)
+        return mapped
+
+    # --- BUILT DOMAIN MODE ---
+    if not built_domains:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    ds = built_domains.get("DS")
+    if ds is None or ds.empty or "USUBJID" not in ds.columns:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    term_col = kwargs.get("term_col", "DSDECOD")
+    date_col = kwargs.get("date_col", "DSSTDTC")
+    
+    if term_col not in ds.columns or date_col not in ds.columns:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    mask = ds[term_col].astype(str).str.upper().isin(upper_terms)
+    valid = ds[mask].copy()
+    
+    if valid.empty:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    valid["DATETIME"] = pd.to_datetime(valid[date_col], errors='coerce', utc=True)
+    valid = valid.dropna(subset=["DATETIME"])
+    
+    if valid.empty:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    idx = valid.groupby("USUBJID")["DATETIME"].idxmin()
+    res = valid.loc[idx].set_index("USUBJID")[date_col]
+    
+    return usubjid_series.map(res)

cdiscbuilder-1.3.1/src/cdiscbuilder/functions/get_last_participation_date.py

@@ -0,0 +1,55 @@
+import pandas as pd
+
+def get_last_participation_date(usubjid_series, built_domains=None, **kwargs):
+    """
+    Calculates RFENDTC (Reference End Date).
+    Finds the absolute maximum date across specified domains and date columns
+    for each subject.
+    
+    kwargs:
+      domain_dates: dictionary mapping domain names to a list of date columns to check.
+                    Defaults to scanning DS, EX, AE, and SV.
+    """
+    if not built_domains:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    # Default domains and columns to scan if not explicitly provided
+    domain_dates = kwargs.get("domain_dates", {
+        "DS": ["DSSTDTC"],
+        "EX": ["EXSTDTC", "EXENDTC"],
+        "EC": ["ECSTDTC", "ECENDTC"],
+        "AE": ["AESTDTC", "AEENDTC"],
+        "SV": ["SVSTDTC", "SVENDTC"]
+    })
+    
+    dfs = []
+    
+    for domain, cols in domain_dates.items():
+        df = built_domains.get(domain)
+        if df is not None and not df.empty and "USUBJID" in df.columns:
+            # For each specified date column, melt it down so we can find the global max
+            for col in cols:
+                if col in df.columns:
+                    valid = df[["USUBJID", col]].dropna(subset=[col]).rename(columns={col: "DATE"})
+                    dfs.append(valid)
+                    
+    if not dfs:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    combined = pd.concat(dfs, ignore_index=True)
+    
+    # Convert to datetime for mathematical maximum comparison
+    combined["DATETIME"] = pd.to_datetime(combined["DATE"], errors='coerce', utc=True)
+    combined = combined.dropna(subset=["DATETIME"])
+    
+    if combined.empty:
+        return pd.Series([None] * len(usubjid_series), index=usubjid_series.index)
+        
+    # Find the index of the max datetime per subject
+    idx = combined.groupby("USUBJID")["DATETIME"].idxmax()
+    
+    # Extract the exact string (preserving any 'T' time component)
+    res = combined.loc[idx].set_index("USUBJID")["DATE"]
+    
+    # Map back to the input series sequence
+    return usubjid_series.map(res)

{cdiscbuilder-1.2.3 → cdiscbuilder-1.3.1}/src/cdiscbuilder/sdtm/engine/classes/base.py

@@ -7,7 +7,7 @@ class BaseProcessor(ABC):
         self.class_name = "GENERAL"
 
     @abstractmethod
-    def process(self, domain_name, sources, df_long, default_keys):
+    def process(self, domain_name, sources, df_long, default_keys, built_domains=None):
         """Main entry point for processing a domain."""
         pass
 
@@ -55,6 +55,9 @@ class BaseProcessor(ABC):
                     series = pd.to_datetime(
                         series, errors="coerce", format="mixed"
                     ).dt.strftime("%Y-%m-%d")
+                elif target_type == "iso8601":
+                    from cdiscbuilder.sdtm.engine.utils.iso8601 import parse_iso8601
+                    series = series.apply(parse_iso8601)
                 elif target_type == "str":
                     series = series.astype(str).replace("nan", None)
             except Exception as e:

{cdiscbuilder-1.2.3 → cdiscbuilder-1.3.1}/src/cdiscbuilder/sdtm/engine/classes/findings.py

@@ -10,7 +10,7 @@ class FindingsProcessor:
     def __init__(self):
         self.class_name = "FINDINGS"
 
-    def process(self, domain_name, sources, df_long, default_keys, custom_to_standard=None):
+    def process(self, domain_name, sources, df_long, default_keys, custom_to_standard=None, built_domains=None):
         domain_dfs = []
 
         for settings in sources:

{cdiscbuilder-1.2.3 → cdiscbuilder-1.3.1}/src/cdiscbuilder/sdtm/engine/classes/general.py

@@ -59,7 +59,54 @@ class GeneralProcessor:
 
         return expanded_list
 
-    def process(self, domain_name, sources, df_long, default_keys, custom_to_standard=None):
+    def _resolve_cross_domain(self, source_expr, col_config, final_df, pivoted, built_domains):
+        """
+        Resolve a cross-domain reference (e.g., 'DM.RFSTDTC') by merging from built_domains.
+        Returns (series, resolved) where resolved is True if successfully resolved.
+        """
+        if not (isinstance(source_expr, str) and "." in source_expr):
+            return None, False
+
+        ref_domain, ref_col = source_expr.split(".", 1)
+        if not (ref_domain.isupper() and 2 <= len(ref_domain) <= 4):
+            return None, False
+
+        if not built_domains or ref_domain not in built_domains:
+            print(f"Warning: Referenced domain '{ref_domain}' not available for cross-domain ref '{source_expr}'")
+            return pd.Series([None] * len(pivoted)), True
+
+        ref_df = built_domains[ref_domain]
+        if ref_col not in ref_df.columns:
+            print(f"Warning: Column '{ref_col}' not found in domain '{ref_domain}' for cross-domain ref '{source_expr}'")
+            return pd.Series([None] * len(pivoted)), True
+
+        # Determine merge key
+        merge_key = col_config.get("merge_on", ["USUBJID"]) if isinstance(col_config, dict) else ["USUBJID"]
+        if isinstance(merge_key, str):
+            merge_key = [merge_key]
+
+        # Validate merge keys exist in both DataFrames
+        valid_keys = [k for k in merge_key if k in final_df.columns and k in ref_df.columns]
+
+        if not valid_keys:
+            print(f"Warning: Merge keys {merge_key} missing for cross-domain ref '{source_expr}'")
+            return pd.Series([None] * len(pivoted)), True
+
+        # Get unique ref values to avoid duplicating rows
+        ref_cols_needed = valid_keys + [ref_col]
+        ref_subset = ref_df[ref_cols_needed].drop_duplicates(subset=valid_keys)
+
+        # Merge into final_df temporarily
+        merged = final_df[valid_keys].merge(ref_subset, on=valid_keys, how="left")
+        series = merged[ref_col]
+        series.index = final_df.index  # Re-align index
+
+        match_count = series.notna().sum()
+        print(f"  ↳ Resolved cross-domain ref: {source_expr} ({match_count} matches via {valid_keys})")
+
+        return series, True
+
+    def process(self, domain_name, sources, df_long, default_keys, custom_to_standard=None, built_domains=None):
         domain_dfs = []
 
         # Pre-expand sources if they contain lists
@@ -214,35 +261,27 @@ class GeneralProcessor:
                 elif isinstance(col_config, dict) and col_config.get("function"):
                     func_name = col_config.get("function")
                     args = col_config.get("args", [])
+                    kwargs = col_config.get("kwargs", {})
 
                     # Resolve Args
                     arg_series = []
                     for arg in args:
-                        # Support cross-domain lookup? For now support local columns in final_df or pivoted
+                        # Support cross-domain lookup
                         if arg in final_df.columns:
                             arg_series.append(final_df[arg])
                         elif arg in pivoted.columns:
                             arg_series.append(pivoted[arg])
                         else:
-                            # Try loading from DM if it looks like DM.RFSTDTC
+                            # Try cross-domain resolution
                             if isinstance(arg, str) and "." in arg:
-                                dname, vname = arg.split(".")
-                                # Only DM supported for now as reference
-                                if dname == "DM":
-
-                                    # Locate output_dir? (We don't have output_dir here easily)
-                                    # For now, let's assume RFSTDTC was merged into DM block or AE block already
-                                    # Or we pass it in.
-                                    # For the demo, let's assume RFSTDTC is in the dataset or handled as a string
-                                    print(
-                                        f"Warning: Cross-domain arg {arg} resolution not fully implemented in GeneralProcessor"
-                                    )
-                                    arg_series.append(pd.Series([None] * len(pivoted)))
+                                cross_series, resolved = self._resolve_cross_domain(
+                                    arg, {}, final_df, pivoted, built_domains
+                                )
+                                if resolved and cross_series is not None:
+                                    arg_series.append(cross_series)
                                 else:
                                     arg_series.append(pd.Series([None] * len(pivoted)))
                             else:
-                                # Not found locally, and not a string with a dot. Treat as a literal or unresolved?
-                                # Wait, ADaM's args might be string constants. Let's just append None for now as before.
                                 arg_series.append(pd.Series([None] * len(pivoted)))
 
                     import importlib
@@ -272,8 +311,18 @@ class GeneralProcessor:
                             raise ImportError(f"Function {fname} not found")
 
                     try:
+                        import inspect
                         func = _load_function(func_name)
-                        series = func(*arg_series)
+                        sig = inspect.signature(func)
+                        
+                        func_kwargs = kwargs.copy()
+                        if "built_domains" in sig.parameters:
+                            func_kwargs["built_domains"] = built_domains
+                        if "df_long" in sig.parameters:
+                            func_kwargs["df_long"] = df_long
+                            
+                        series = func(*arg_series, **func_kwargs)
+                            
                         if not isinstance(series, pd.Series):
                             series = pd.Series(series)
                     except Exception as e:
@@ -282,11 +331,49 @@ class GeneralProcessor:
                         )
                         series = pd.Series([None] * len(pivoted))
 
+                elif isinstance(col_config, dict) and col_config.get("conditions"):
+                    import numpy as np
+                    conditions_config = col_config.get("conditions")
+                    
+                    # Create an evaluation context combining raw domain data and current final_df
+                    eval_df = pivoted.copy()
+                    for c in final_df.columns:
+                        eval_df[c] = final_df[c]
+                        
+                    cond_list = []
+                    choice_list = []
+                    
+                    for cond in conditions_config:
+                        expr = cond.get("if")
+                        then_val = cond.get("then")
+                        try:
+                            # Evaluate condition string
+                            mask = eval_df.eval(expr)
+                            cond_list.append(mask)
+                            choice_list.append(then_val)
+                        except Exception as e:
+                            print(f"Warning: Failed to evaluate condition '{expr}': {e}")
+                            cond_list.append(pd.Series(False, index=eval_df.index))
+                            choice_list.append(then_val)
+                            
+                    default_val = col_config.get("default", None)
+                    if cond_list:
+                        # np.select evaluates conditions in order
+                        series = pd.Series(np.select(cond_list, choice_list, default=default_val), index=eval_df.index)
+                    else:
+                        series = pd.Series([default_val] * len(eval_df), index=eval_df.index)
+
                 elif literal_expr is not None:
                     # Explicit literal value
                     series = pd.Series([literal_expr] * len(pivoted))
                 elif source_expr:
-                    if source_expr in pivoted.columns:
+                    # Check for cross-domain reference first
+                    cross_series, resolved = self._resolve_cross_domain(
+                        source_expr, col_config, final_df, pivoted, built_domains
+                    )
+                    if resolved:
+                        series = cross_series
+                    elif source_expr in pivoted.columns:
                         series = pivoted[source_expr].copy()
                     elif source_expr in final_df.columns:
                         series = final_df[source_expr].copy()