s2r_parser.py

import re
import uuid
import glob
import os

class DRLParser:
    def __init__(self):
        # Mapping DRL Objects to DMN Input Variables
        self.obj_mappings = {
            "p": "person", 
            "Person": "person",
            "h": "household",
            "Household": "household",
            "RequestExpense": "expense",
            "IncomeHeadAndSpouseEarnedYearly": "incomeEarnedYearly",
            "IncomeHouseholdTotalYearly": "incomeHouseholdYearly",
            "IncomeHouseholdMonthlyCAMinusWorkExpense": "incomeCA",
            "IncomeHouseholdTotalMonthly": "incomeMonthly",
            "IncomeHouseholdHasCashAssistance": "hasCashAssistance",
            "IncomeHouseholdHasSSI": "hasSSI",
            "MembersPlusPregnant": "membersPlusPregnant",
            "HeadOfHouseholdMarried": "isMarried",
            "ChildrenStudentBlindDisabledEITC": "childEITC",
            "IncomeOwnersTotalYearly": "incomeOwnersYearly",
            "IncomeAdultsTotalMonthly": "incomeAdultsMonthly",
            "IncomeMedicaidTotalYearly": "incomeMedicaidYearly",
            "MembersMedicaid": "membersMedicaid",
            "IncomeChildCareVoucherTotalMonthly": "incomeVoucherMonthly",
            "IncomeHouseholdHasBenefit": "hasBenefit"
            # Add more as discovered
        }
        
    def parse_file(self, filepath):
        with open(filepath, 'r') as f:
            content = f.read()
            
        rule_name = os.path.basename(filepath).replace(".drl", "")
        
        # logical_groups is a list of lists of constraints
        all_logical_groups = []
        
        # Extract 'when' block (FIND ALL RULES)
        matches = re.finditer(r'when\s+(.*?)\s+then', content, re.DOTALL)
        
        for match in matches:
            condition_block = match.group(1).strip()
            
            # Strip comments (// and /* */)
            def replacer(match):
                s = match.group(0)
                if s.startswith('/'): return " " # note: a space
                else: return s
            pattern = re.compile(r'//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"', re.DOTALL | re.MULTILINE)
            condition_block = re.sub(pattern, replacer, condition_block)

            # Normalize whitespace
            condition_block = re.sub(r'\s+', ' ', condition_block)
            
            # Normalize legacy operators (Regex to handle spacing like a||b)
            condition_block = re.sub(r'\|\|', ' or ', condition_block)
            condition_block = re.sub(r'&&', ', ', condition_block)
            
            # Logic parsing for this rule...
            current_rule_groups = []
            
            cursor = 0
            while cursor < len(condition_block):
                # Check for block start "("
                if condition_block[cursor] == '(':
                    # Find matching paren
                    end = self._find_matching_paren(condition_block, cursor)
                    if end == -1: break
                    
                    block = condition_block[cursor+1:end].strip()
                    
                    # Check if this block is an OR group
                    if " or " in block:
                        sub_variants = self._split_logic(block, " or ")
                        
                        # Expand atoms within variants?
                        expanded_variants = []
                        for v in sub_variants:
                            # v might be "Household(a) and Person(b)"
                            # We need to preserve the AND structure of the variant
                            # But if "Household(a or b)" is inside, we need to explode it?
                            # This gets complicated. 
                            # Simplification: Assume variants at this level are mostly clear.
                            # But let's run _expand_atom on them just in case they are single atoms?
                            if v.startswith("(") or " and " in v:
                                # It's a composite. Leave it for now or recurse? 
                                # Recursive splitting handled by main loop structure usually.
                                expanded_variants.append(v)
                            else:
                                expanded_variants.extend(self._expand_atom(v))
                        
                        current_rule_groups.append(expanded_variants)
                    else:
                        if block.startswith("Household") or block.startswith("Person"):
                             current_rule_groups.append(self._expand_atom(block))
                        else:
                             current_rule_groups.append(self._expand_atom(block))
                             
                    cursor = end + 1
                else:
                    # Look for Object(...) start
                    match_obj = re.match(r'([A-Z][a-zA-Z0-9]+)\s*\(', condition_block[cursor:])
                    if match_obj:
                        # Found Object(
                        start_paren_idx = cursor + condition_block[cursor:].find('(')
                        end = self._find_matching_paren(condition_block, start_paren_idx)
                        whole_str = condition_block[cursor:end+1]
                        current_rule_groups.append(self._expand_atom(whole_str)) # Explode if internal logic
                        cursor = end + 1
                    else:
                        cursor += 1
            
            # Add this rule's logic as a separate set of rows?
            # Actually, DIFFERENT rules in a file usually mean "OR" (Rule 1 OR Rule 2 OR Rule 3).
            # So we should process `current_rule_groups` (which are ANDed) into rows, and add them to the master list.
            
            # Cartesian product for THIS rule
            import itertools
            rule_rows_combinations = list(itertools.product(*current_rule_groups))
            all_logical_groups.extend(rule_rows_combinations)
            
        return self._generate_dmn_model_from_rows(rule_name, all_logical_groups)

    def _find_matching_paren(self, text, start_index):
        count = 0
        for i in range(start_index, len(text)):
            if text[i] == '(': count += 1
            elif text[i] == ')': count -= 1
            if count == 0: return i
        return -1

    def _split_logic(self, text, separator):
        # Split by separator but respect parentheses
        parts = []
        last_split = 0
        depth = 0
        for i in range(len(text)):
            if text[i] == '(': depth += 1
            elif text[i] == ')': depth -= 1
            
            if depth == 0 and text[i:i+len(separator)] == separator:
                parts.append(text[last_split:i].strip())
                last_split = i + len(separator)
        parts.append(text[last_split:].strip())
        return parts

    def _expand_atom(self, atom):
        # atom: "Income(type in X, (A or B))" -> ["Income(type in X, A)", "Income(type in X, B)"]
        match = re.match(r'([A-Z][a-zA-Z0-9]+)\s*\((.*)\)', atom)
        if not match:
            return [atom]
            
        obj_name = match.group(1)
        content = match.group(2)
        
        # Recursively strip outer parens from content if it wraps the whole thing
        # e.g. "( (A, B) )" -> "A, B"
        # Be careful not to strip "(A) and (B)" if parens match but logic is inside?
        # Only strip if the outer parens correspond to each other and cover length 
        while content.startswith('(') and content.endswith(')') and self._find_matching_paren(content, 0) == len(content)-1:
             content = content[1:-1].strip()
        
        # Split content by comma (AND inside object)
        parts = self._split_logic(content, ",")
        
        # Expand each part if it has OR
        expanded_parts = [] # List of lists of variants for each part
        for p in parts:
            p = p.strip()
            if not p: continue
            
            # Check for " or " inside
            # Handle recursive parens: "(A or B)" -> "A or B"
            while p.startswith("(") and p.endswith(")") and self._find_matching_paren(p, 0) == len(p)-1:
                p = p[1:-1].strip()
                
            if " or " in p:
                 # Check if the 'or' is real branching logic or part of string?
                 # Assuming logic for now
                 variants = self._split_logic(p, " or ")
                 expanded_parts.append(variants)
            else:
                expanded_parts.append([p])
                
        # Cartesian product of parts
        import itertools
        product = list(itertools.product(*expanded_parts))
        
        results = []
        for combo in product:
            # Reassemble: "type in X, A"
            new_content = ", ".join(combo)
            results.append(f"{obj_name}({new_content})")
            
        return results

    def _generate_dmn_model_from_rows(self, rule_name, rows_combinations):
        
        # Now we parse the specific constraints in each row to build the table columns
        # We need a unified set of inputs (columns)
        
        all_inputs = set()
        parsed_rows = []
        
        for combination in rows_combinations:
            # combination is tuple of strings, e.g. ("Person(age < 5)", "Household(...)")
            row_constraints = {}
            for segment in combination:
                # Segment might be "(Household(x=1) and Income(y=2))"
                # Recursively strip outer parens from segment if fully enclosed
                while segment.startswith('(') and segment.endswith(')') and self._find_matching_paren(segment, 0) == len(segment)-1:
                    segment = segment[1:-1].strip()

                # Split by " and "
                atoms = self._split_logic(segment, " and ")
                for atom in atoms:
                    atom = atom.strip()
                    while atom.startswith('(') and atom.endswith(')') and self._find_matching_paren(atom, 0) == len(atom)-1:
                        atom = atom[1:-1].strip()
                    
                    if not atom: continue

                    # atom: "Person( age < 13 )"
                    # Extract Object and content
                    m = re.match(r'([A-Z][a-zA-Z0-9]+)\s*\((.*)\)', atom)
                    if m:
                        obj_type = m.group(1)
                        content = m.group(2)
                        
                        # Parse content: "age < 13, disabled == true"
                        # Handle && as comma
                        content = content.replace(" && ", ", ")
                        
                        # Split by comma
                        field_pairs = self._split_logic(content, ",")
                        for pair in field_pairs:
                            pair = pair.strip()
                            while pair.startswith('(') and pair.endswith(')') and self._find_matching_paren(pair, 0) == len(pair)-1:
                                pair = pair[1:-1].strip()
                                
                            if not pair: continue
                            # Parse "field op value"
                            # Regex for "field op val"
                            # Op can be: <, >, <=, >=, ==, in, matches, && (handled by split?), not in
                            # Check for "not in" first
                            op_match = re.search(r'([a-zA-Z0-9_\.]+)\s*(not in|==|!=|>=|<=|>|<|in)\s*(.*)', pair)
                            if op_match:
                                field = op_match.group(1)
                                op = op_match.group(2)
                                val = op_match.group(3)
                                
                                # Clean value
                                val = val.strip().strip("'").strip('"')
                                while val.startswith("(") and val.endswith(")"):
                                    # Remove parens for DMN list
                                    val = val[1:-1].strip()
                                
                                # Final safety net: handle failed expansion artifacts
                                if " or " in val:
                                    val = val.replace(" or ", ", ")
                                    # Remove redundant "field ==" from list
                                    val = re.sub(r'[a-zA-Z0-9_\.]+\s*==\s*', '', val)
                                
                                # Build column key
                                if obj_type in self.obj_mappings:
                                    base = self.obj_mappings[obj_type]
                                else:
                                    base = obj_type.lower()
                                col_key = f"{base}.{field}"
                                all_inputs.add(col_key)
                                
                                # Format for DMN
                                dmn_val = self._format_dmn_value(op, val)
                                row_constraints[col_key] = dmn_val
            
            parsed_rows.append(row_constraints)
            
        # Generate XML
        return self._build_xml(rule_name, sorted(list(all_inputs)), parsed_rows)

    def _format_dmn_value(self, op, val):
        if op == "==": return f"{val}" # Exact match, but handle boolean "true"
        if op == "in": return f"{val}" # DMN can handle comma lists naturally? "A, B" is implicit OR.
        if op == "not in": return f"not({val})"
        if op == "<": return f"&lt; {val}"
        if op == ">": return f"&gt; {val}"
        if op == "<=": return f"&lt;= {val}"
        if op == ">=": return f"&gt;= {val}"
        return "-"

    def _build_xml(self, rule_name, inputs, rows):
        # inputs: list of "person.age"
        # rows: list of dicts {"person.age": "< 18"}
        
        # Build Input Columns
        input_xml_parts = []
        for i, inp in enumerate(inputs):
            # Simplistic typing
            type_ref = "string" # Default safe
            low = inp.lower()
            if "age" in low or "members" in low: type_ref = "integer"
            elif "amount" in low or "income" in low or "expense" in low: type_ref = "double"
            elif "disabled" in low or "blind" in low or "pregnant" in low or "married" in low or "has" in low or "headofhousehold" == low.split(".")[-1]: type_ref = "boolean"
            
            # Input Expression: we use the dot notation "person.age" which maps to the JSON variable structure
            input_xml_parts.append(f"""
      <input id="Input_{i}" label="{inp}">
        <inputExpression id="InputExpression_{i}" typeRef="{type_ref}">
          <text>{inp}</text>
        </inputExpression>
      </input>""")

        # Build Rules
        rule_xml_parts = []
        for row in rows:
            entries = []
            for inp in inputs:
                val = row.get(inp, "-")
                if val == "true" or val == "false":
                     # Ensure boolean is unquoted? DMN standard usually likes just true/false
                     pass
                # Wrap in <text>
                # Use standard XML quote for safety if needed, but we did basic escaping
                entries.append(f'<inputEntry id="Unary_{uuid.uuid4().hex}"><text>{val}</text></inputEntry>')
            
            entries.append(f'<outputEntry id="Lit_{uuid.uuid4().hex}"><text>true</text></outputEntry>')
            
            rule_xml_parts.append(f"""
      <rule id="Rule_{uuid.uuid4().hex}">
        { "".join(entries) }
      </rule>""")

        # Fallback Rule (Implicit Ineligible)
        fallback_entries = []
        for _ in inputs:
            fallback_entries.append(f'<inputEntry id="Unary_{uuid.uuid4().hex}"><text>-</text></inputEntry>')
        fallback_entries.append(f'<outputEntry id="Lit_{uuid.uuid4().hex}"><text>false</text></outputEntry>')
        
        rule_xml_parts.append(f"""
      <rule id="Rule_Fallback">
        { "".join(fallback_entries) }
      </rule>""")
        
        def_id = f"Definitions_{uuid.uuid4().hex}"
        dec_id = f"Decision_{rule_name}"
        
        return f"""<?xml version="1.0" encoding="UTF-8"?>
<definitions xmlns="https://www.omg.org/spec/DMN/20191111/MODEL/" xmlns:dmndi="https://www.omg.org/spec/DMN/20191111/DMNDI/" xmlns:dc="http://www.omg.org/spec/DMN/20180521/DC/" id="{def_id}" name="{rule_name}" namespace="http://camunda.org/schema/1.0/dmn" exporter="Camunda Modeler" exporterVersion="4.6.0">
  <decision id="{dec_id}" name="{rule_name}">
    <decisionTable id="Table_{uuid.uuid4().hex}" hitPolicy="FIRST">
      {"".join(input_xml_parts)}
      <output id="Output_1" label="Is Eligible" typeRef="boolean" />
      {"".join(rule_xml_parts)}
    </decisionTable>
  </decision>
  <dmndi:DMNDI>
    <dmndi:DMNDiagram>
      <dmndi:DMNShape dmnElementRef="{dec_id}">
        <dc:Bounds height="80" width="180" x="160" y="80" />
      </dmndi:DMNShape>
    </dmndi:DMNDiagram>
  </dmndi:DMNDI>
</definitions>"""

if __name__ == "__main__":
    parser = DRLParser()
    files = glob.glob("ACCESS-NYC-Rules/accessnyc/rules/S2R*.drl")
    
    # Test with S2R008
    # files = ["ACCESS-NYC-Rules/accessnyc/rules/S2R008.drl"]
    
    if not os.path.exists("dmn_output"):
        os.makedirs("dmn_output")
        
    for f in files:
        print(f"Converting {f}...")
        try:
            xml = parser.parse_file(f)
            if xml:
                name = os.path.basename(f).replace(".drl", ".dmn")
                with open(f"dmn_output/{name}", "w") as out:
                    out.write(xml)
        except Exception as e:
            print(f"Error converting {f}: {e}")