xml2xlsx-lidilem 0.1.0__tar.gz

xml2xlsx_lidilem-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: xml2xlsx-lidilem
+Version: 0.1.0
+Summary: Convert annotated XML to Excel
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: numpy

xml2xlsx_lidilem-0.1.0/pyproject.toml

@@ -0,0 +1,19 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xml2xlsx-lidilem"
+version = "0.1.0"
+description = "Convert annotated XML to Excel"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+dependencies = [
+    "openpyxl",
+    "pandas",
+    "numpy",
+]
+
+[project.scripts]
+xml2xlsx = "xml2xlsx.xml2xlsx:main"

xml2xlsx_lidilem-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xml2xlsx_lidilem-0.1.0/xml2xlsx/format_excel.py

@@ -0,0 +1,287 @@
+import re
+import pandas as pd
+import math
+from openpyxl.utils import get_column_letter
+from openpyxl.styles import Alignment, PatternFill
+from openpyxl.utils import get_column_letter
+import sys
+
+# Color map: tag name -> hex RGB text color (for write_rich_string, xlsxwriter font color)
+TAG_COLORS = {
+    'INTRODD':   '#1F4E79',  # dark blue
+    'VDD':       '#7030A0',  # purple
+    'EXPANSION': '#C55A11',  # dark orange
+    'MOD':       '#833C00',  # brown
+    'PPI':       '#C00000',  # dark red
+    'NONPPI':    '#375623',  # dark green
+    'MD':        '#2E75B6',  # medium blue
+    'APP':       '#595959',  # dark grey
+    'DD': '#1D6B5E',  # teal foncé
+}
+TAG_COLOR_DEFAULT = '#000000'  # black for unknown tags
+
+
+def _parse_tagged_text(text):
+    """
+    Parse a string containing XML-like tags and return a list of segments:
+    [{'type': 'text'|'open_tag'|'close_tag', 'value': str, 'tag': str or None}]
+    """
+    pattern = re.compile(r'(</?(\w+)>)')
+    segments = []
+    pos = 0
+    for m in pattern.finditer(text):
+        start, end = m.start(), m.end()
+        if pos < start:
+            segments.append({'type': 'text', 'value': text[pos:start], 'tag': None})
+        full_tag = m.group(1)
+        tag_name = m.group(2)
+        is_close = full_tag.startswith('</')
+        segments.append({
+            'type': 'close_tag' if is_close else 'open_tag',
+            'value': full_tag,
+            'tag': tag_name
+        })
+        pos = end
+    if pos < len(text):
+        segments.append({'type': 'text', 'value': text[pos:], 'tag': None})
+    return segments
+
+
+def _build_rich_string_args(text, workbook):
+    """
+    Build args list for worksheet.write_rich_string() from a tagged paragraph_text.
+    Tags are shown in grey italic, tag content is colored per TAG_COLORS.
+    Plain text (outside any tag) is black.
+    Returns None if the text has no tags (use plain write instead).
+    """
+    segments = _parse_tagged_text(text)
+    if not any(s['type'] in ('open_tag', 'close_tag') for s in segments):
+        return None
+
+    tag_fmt_cache = {}
+    plain_fmt = workbook.add_format({'font_color': '#000000', 'text_wrap': True, 'valign': 'top'})
+    tag_label_fmt = workbook.add_format({'font_color': '#AAAAAA', 'italic': True, 'text_wrap': True, 'valign': 'top'})
+
+    def get_tag_fmt(tag_name):
+        if tag_name not in tag_fmt_cache:
+            color = TAG_COLORS.get(tag_name, TAG_COLOR_DEFAULT)
+            tag_fmt_cache[tag_name] = workbook.add_format({
+                'font_color': color,
+                'text_wrap': True,
+                'valign': 'top',
+                'bold': True, 
+            })
+        return tag_fmt_cache[tag_name]
+
+    args = []
+    # Track current open tag for coloring content
+    tag_stack = []
+
+    for seg in segments:
+        if seg['type'] == 'open_tag':
+            tag_stack.append(seg['tag'])
+            args.append(tag_label_fmt)
+            args.append(seg['value'])
+        elif seg['type'] == 'close_tag':
+            args.append(tag_label_fmt)
+            args.append(seg['value'])
+            if tag_stack and tag_stack[-1] == seg['tag']:
+                tag_stack.pop()
+        else:  # plain text
+            val = seg['value']
+            if not val:
+                continue
+            if tag_stack:
+                # Color by innermost tag
+                args.append(get_tag_fmt(tag_stack[-1]))
+            else:
+                args.append(plain_fmt)
+            args.append(val)
+
+    # write_rich_string needs at least one format+string pair
+    # Filter empty strings
+    filtered = []
+    i = 0
+    while i < len(args):
+        if isinstance(args[i], str):
+            if args[i]:
+                filtered.append(args[i])
+            i += 1
+        else:
+            # it's a format object, pair with next string
+            if i + 1 < len(args) and isinstance(args[i+1], str) and args[i+1]:
+                filtered.append(args[i])
+                filtered.append(args[i+1])
+            i += 2
+
+    if not filtered:
+        return None
+    return filtered
+
+
+def format_ppi_bold(df, filename):
+    for col in df.columns:
+        if df[col].dtype == object:
+            df[col] = df[col].apply(
+                lambda v: v.replace('–', '\n–').replace('\n\n', '\n') if isinstance(v, str) else v
+            )
+
+    df = df.loc[:, ~df.columns.str.contains('^Unnamed')]
+    df = df.reset_index(drop=True)
+
+    with pd.ExcelWriter(filename, engine='xlsxwriter') as writer:
+        workbook = writer.book
+        worksheet = workbook.add_worksheet('Sheet1')
+        writer.sheets['Sheet1'] = worksheet
+
+        bold = workbook.add_format({'bold': True})
+        regular = workbook.add_format({'text_wrap': True, 'valign': 'top'})
+        header_format = workbook.add_format({'bold': True, 'valign': 'top', 'bg_color': '#F2F2F2'})
+
+        for col_num, col_name in enumerate(df.columns):
+            worksheet.write(0, col_num, col_name, header_format)
+
+        # Calculate column widths
+        col_widths = {col: len(str(col)) for col in df.columns}
+        for row_num in range(len(df)):
+            for col_num, col_name in enumerate(df.columns):
+                cell_value = df.iloc[row_num][col_name]
+                if pd.notna(cell_value):
+                    text = str(cell_value)
+                    if not text.strip():
+                        continue
+                    clean = re.sub(r'<[^>]+>', '', text)
+                    clean = re.sub(r'\*\*', '', clean)
+                    col_widths[col_name] = max(col_widths[col_name], len(clean) + 2)
+
+        for col_name in col_widths:
+            col_widths[col_name] = min(col_widths[col_name], 100)
+
+        # Calculate row heights
+        base_height = 15
+        row_heights = {}
+        for row_num in range(len(df)):
+            excel_row = row_num + 1
+            max_height = base_height
+            for col_num, col_name in enumerate(df.columns):
+                cell_value = df.iloc[row_num][col_name]
+                if pd.notna(cell_value):
+                    text = str(cell_value)
+                    clean = re.sub(r'<[^>]+>', '', text)
+                    clean = re.sub(r'\*\*', '', clean)
+                    col_width = col_widths[col_name]
+                    chars_per_line = int(col_width * 1.1)
+                    lines_needed = max(1, math.ceil(len(clean) / chars_per_line)) if chars_per_line > 0 else 1
+                    max_height = max(max_height, base_height * lines_needed)
+            row_heights[excel_row] = max_height
+
+        # Set column widths
+        for col_num, col_name in enumerate(df.columns):
+            worksheet.set_column(col_num, col_num, col_widths[col_name], regular)
+
+        # Write content
+        for row_num in range(len(df)):
+            excel_row = row_num + 1
+            worksheet.set_row(excel_row, row_heights[excel_row])
+
+            for col_num, col_name in enumerate(df.columns):
+                cell_value = df.iloc[row_num][col_name]
+
+                if pd.notna(cell_value):
+                    text = str(cell_value)
+
+                    if col_name in ['paragraph_text','paragraph_text_dd']:
+                        # Rich string with tag color coding
+                        rich_args = _build_rich_string_args(text, workbook)
+                        if rich_args:
+                            worksheet.write_rich_string(excel_row, col_num, *rich_args)
+                        else:
+                            worksheet.write(excel_row, col_num, text, regular)
+                    else:
+                        # Existing PPI bold logic for other columns
+                        text = re.sub(r'\*\*(.*?)\*\*', r'<PPI>\1</PPI>', text)
+                        text = re.sub(r'<strong>(.*?)</strong>', r'<PPI>\1</PPI>', text)
+                        parts = re.split(r'(<PPI>|</PPI>)', text)
+
+                        if len(parts) > 1:
+                            rich_string = []
+                            is_bold = False
+                            for part in parts:
+                                if part == '<PPI>':
+                                    is_bold = True
+                                    rich_string.append('<PPI>')
+                                elif part == '</PPI>':
+                                    is_bold = False
+                                    rich_string.append('</PPI>')
+                                else:
+                                    if part:
+                                        if is_bold:
+                                            rich_string.append(bold)
+                                            rich_string.append(part)
+                                        else:
+                                            rich_string.append(part)
+                            rich_string = [item for item in rich_string if item != '']
+                            if rich_string:
+                                worksheet.write_rich_string(excel_row, col_num, *rich_string)
+                            else:
+                                worksheet.write(excel_row, col_num, text, regular)
+                        else:
+                            worksheet.write(excel_row, col_num, text, regular)
+
+
+def color_compare_pairs(df, filename):
+    df_copy = df.copy()
+    human_cols = [col for col in df_copy.columns if col.endswith('_human')]
+    pairs = []
+    for human_col in human_cols:
+        ia_col = human_col.replace('_human', '_ia')
+        if ia_col in df_copy.columns:
+            pairs.append((human_col, ia_col))
+
+    if not pairs:
+        print("No '_human' and '_ia' column pairs found")
+        return
+
+    with pd.ExcelWriter(filename, engine='openpyxl', mode='w') as writer:
+        df_copy.to_excel(writer, index=False, sheet_name='Sheet1')
+        workbook = writer.book
+        worksheet = writer.sheets['Sheet1']
+
+        green_fill = PatternFill(start_color='C6EFCE', end_color='C6EFCE', fill_type='solid')
+        red_fill = PatternFill(start_color='FFC7CE', end_color='FFC7CE', fill_type='solid')
+
+        for row_num in range(len(df_copy)):
+            excel_row = row_num + 2
+            for human_col, ia_col in pairs:
+                human_val = df_copy.iloc[row_num][human_col]
+                ia_val = df_copy.iloc[row_num][ia_col]
+                human_str = str(human_val) if pd.notna(human_val) else ""
+                ia_str = str(ia_val) if pd.notna(ia_val) else ""
+                are_equal = human_str.strip().lower() == ia_str.strip().lower()
+                human_col_idx = df_copy.columns.get_loc(human_col)
+                ia_col_idx = df_copy.columns.get_loc(ia_col)
+                fill = green_fill if are_equal else red_fill
+                worksheet.cell(row=excel_row, column=human_col_idx + 1).fill = fill
+                worksheet.cell(row=excel_row, column=ia_col_idx + 1).fill = fill
+
+        for column in worksheet.columns:
+            max_length = 0
+            column_letter = get_column_letter(column[0].column)
+            for cell in column:
+                try:
+                    if len(str(cell.value)) > max_length:
+                        max_length = len(str(cell.value))
+                except:
+                    pass
+            worksheet.column_dimensions[column_letter].width = min(max_length + 2, 50)
+
+
+def format_and_compare(df, filename):
+    format_ppi_bold(df, filename)
+    temp_df = pd.read_excel(filename)
+    color_compare_pairs(temp_df, filename)
+
+
+if __name__ == "__main__":
+    df = pd.read_excel(sys.argv[1])
+    format_ppi_bold(df, sys.argv[1].replace(".xlsx", "_formatted.xlsx"))

xml2xlsx_lidilem-0.1.0/xml2xlsx/xml2xlsx.py

@@ -0,0 +1,386 @@
+import pandas as pd
+import xml.etree.ElementTree as ET
+import sys
+import os
+import re
+from xml2xlsx.format_excel import format_ppi_bold
+import numpy as np
+
+
+def clean_text(text):
+    if not text:
+        return None
+    result = ' '.join(text.split())
+    return result if result else None
+
+
+def clean_lower(text):
+    return ' '.join(text.split()).lower() if text else None
+
+
+NO_LOWER = {'INTRODD_text', 'paragraph_text', 'APP_text', 'INTRODD_EXPANSION_text', 'INTRODD_EXPANSION_2_text','INTRODD_EXPANSION_3_text'}
+
+# Tags to preserve in paragraph_text (order matters for nested: deepest first)
+PRESERVE_TAGS = ['INTRODD', 'VDD', 'EXPANSION', 'MOD', 'PPI', 'NONPPI', 'MD', 'APP']
+
+
+def serialize_paragraph(p_elem):
+    """Rebuild paragraph text preserving XML tags as literal text."""
+    def _serialize(elem):
+        result = ''
+        tag = elem.tag
+        if tag != 'p':
+            result += f'<{tag}>'
+        if elem.text:
+            result += elem.text
+        for child in elem:
+            result += _serialize(child)
+        if tag != 'p':
+            result += f'</{tag}>'
+        if elem.tail:
+            result += elem.tail
+        return result
+
+    raw = _serialize(p_elem)
+    return ' '.join(raw.split()) if raw.strip() else None
+
+
+def get_introdd_position(p_elem):
+    """
+    Returns 'ANTE' if INTRODD appears before the first PPI in element order,
+    'POST' if INTRODD appears after the first PPI,
+    'AUTRE' if INTRODD is present but no PPI exists,
+    None if no INTRODD at all.
+    """
+    tags = [child.tag for child in p_elem]
+    has_introdd = 'INTRODD' in tags
+    has_ppi = 'PPI' in tags
+
+    if not has_introdd:
+        return None
+    if not has_ppi:
+        return 'AUTRE'
+
+    introdd_idx = tags.index('INTRODD')
+    ppi_idx = tags.index('PPI')
+
+    if introdd_idx < ppi_idx:
+        return 'ANTE'
+    elif introdd_idx > ppi_idx:
+        return 'POST'
+    else:
+        return 'AUTRE'
+
+
+def get_introdd_position_dd(paragraph_text, ignore_multi_ppi=True):
+    if not paragraph_text:
+        return None
+
+    if ignore_multi_ppi:
+        if len(re.findall(r'<PPI>', paragraph_text)) > 1:
+            return None
+
+    introdd_start = re.search(r'<INTRODD>', paragraph_text)
+    introdd_end   = re.search(r'</INTRODD>', paragraph_text)
+
+    if not introdd_start:
+        return None
+
+    intro_open  = introdd_start.start()
+    intro_close = introdd_end.end() if introdd_end else intro_open
+
+    # Build all DD spans: (open_start, close_end, full_text_of_DD)
+    dd_spans = []
+    for m_open in re.finditer(r'<DD>', paragraph_text):
+        m_close = re.search(r'</DD>', paragraph_text[m_open.end():])
+        if m_close:
+            close_end = m_open.end() + m_close.end()
+            dd_text = paragraph_text[m_open.start():close_end]
+            dd_spans.append((m_open.start(), close_end, dd_text))
+
+    if not dd_spans:
+        return None
+
+    def has_ppi(dd_text):
+        return bool(re.search(r'<PPI>', dd_text))
+
+    # --- INCISE case 1: INTRODD is fully inside a single DD ---
+    for (dd_open, dd_close_end, dd_text) in dd_spans:
+        if dd_open <= intro_open and intro_close <= dd_close_end:
+            if has_ppi(dd_text):
+                return 'INCISE'
+
+    # --- INCISE case 2: INTRODD is sandwiched between two immediate DDs ---
+    # Find the closest DD ending at or before intro_open
+    dds_before = [(o, ce, t) for (o, ce, t) in dd_spans if ce <= intro_open]
+    # Find the closest DD starting at or after intro_close
+    dds_after  = [(o, ce, t) for (o, ce, t) in dd_spans if o >= intro_close]
+
+    if dds_before and dds_after:
+        nearest_before = dds_before[-1]   # last DD before INTRODD
+        nearest_after  = dds_after[0]     # first DD after INTRODD
+        # "Immediate": no other DD boundary exists between them and INTRODD
+        no_dd_between_before = not any(
+            o > nearest_before[1] and ce <= intro_open
+            for (o, ce, t) in dd_spans
+        )
+        no_dd_between_after = not any(
+            o >= intro_close and o < nearest_after[0]
+            for (o, ce, t) in dd_spans
+        )
+        if no_dd_between_before and no_dd_between_after:
+            # INCISE only if there is nothing between the two DDs except the INTRODD
+            # (and punctuation/whitespace). Any narrator text outside INTRODD → POST/ANTE.
+            between = paragraph_text[nearest_before[1]:nearest_after[0]]
+            without_introdd = re.sub(r'<INTRODD>.*?</INTRODD>', '', between, flags=re.DOTALL)
+            without_tags = re.sub(r'<[^>]+>', '', without_introdd)
+
+            # A dash after removing the INTRODD signals a new speaker turn → not INCISE
+            has_turn_change = bool(re.search(r'[–—]', without_tags))
+
+            residual = re.sub(r'[\s\W]+', '', without_tags)
+
+            if residual == '' and not has_turn_change:
+                if has_ppi(nearest_before[2]) or has_ppi(nearest_after[2]):
+                    return 'INCISE'
+    # --- ANTE: INTRODD comes before a DD that contains PPI ---
+    if dds_after and any(has_ppi(t) for (o, ce, t) in dds_after):
+        return 'ANTE'
+
+    # --- POST: INTRODD comes after a DD that contains PPI ---
+    if dds_before and any(has_ppi(t) for (o, ce, t) in dds_before):
+        return 'POST'
+
+    return None
+
+
+def extract_paragraphs(xml_path):
+    tree = ET.parse(xml_path)
+    root = tree.getroot()
+    rows = []
+
+    for p in root.findall('p'):
+        full_text = ''.join(p.itertext())
+        match = re.search(r'[«"]["\s]*([^"»]+)["\s]*[»"]', full_text)
+        p_id = match.group(1).strip() if match else None
+
+        row = {
+            'p_id': p_id,
+            'paragraph_text': serialize_paragraph(p)
+        }
+
+        # --- INTRODD (multiple) ---
+        introdds = p.findall('INTRODD')
+        for i, introdd in enumerate(introdds):
+            suffix = '' if i == 0 else f'_{i+1}'
+            row[f'INTRODD{suffix}_text'] = clean_text(''.join(introdd.itertext()))
+            
+            # --- INTRODD EXPANSION ---
+            expansions = introdd.findall('EXPANSION')
+            for j, exp in enumerate(expansions):
+                exp_suffix = '' if j == 0 else f'_{j+1}'
+                row[f'INTRODD{suffix}_EXPANSION{exp_suffix}_text'] = clean_text(''.join(exp.itertext()))
+                row[f'INTRODD{suffix}_EXPANSION{exp_suffix}_constr'] = exp.get('constr')
+                row[f'INTRODD{suffix}_EXPANSION{exp_suffix}_type'] = exp.get('type')
+            if not expansions:
+                row[f'INTRODD{suffix}_EXPANSION_text'] = None
+                row[f'INTRODD{suffix}_EXPANSION_constr'] = None
+                row[f'INTRODD{suffix}_EXPANSION_type'] = None
+            
+            # --- INTRODD MOD (multiple) ---
+            mods = introdd.findall('MOD')
+            for j, mod in enumerate(mods):
+                mod_suffix = '' if j == 0 else f'_{j+1}'
+                row[f'INTRODD{suffix}_MOD{mod_suffix}_text'] = clean_text(''.join(mod.itertext()))
+            if not mods:
+                row[f'INTRODD{suffix}_MOD_text'] = None
+            
+            # --- INTRODD VDD (multiple) ---
+            vdds = introdd.findall('VDD')
+            for j, vdd in enumerate(vdds):
+                vdd_suffix = '' if j == 0 else f'_{j+1}'
+                row[f'INTRODD{suffix}_VDD{vdd_suffix}_text'] = clean_text(''.join(vdd.itertext()))
+                row[f'INTRODD{suffix}_VDD{vdd_suffix}_type'] = vdd.get('type')
+                
+                # --- VDD EXPANSION ---
+                vdd_expansions = vdd.findall('EXPANSION')
+                for k, exp in enumerate(vdd_expansions):
+                    vdd_exp_suffix = '' if k == 0 else f'_{k+1}'
+                    row[f'INTRODD{suffix}_VDD{vdd_suffix}_EXPANSION{vdd_exp_suffix}_text'] = clean_text(''.join(exp.itertext()))
+                    row[f'INTRODD{suffix}_VDD{vdd_suffix}_EXPANSION{vdd_exp_suffix}_constr'] = exp.get('constr')
+                    row[f'INTRODD{suffix}_VDD{vdd_suffix}_EXPANSION{vdd_exp_suffix}_type'] = exp.get('type')
+                if not vdd_expansions:
+                    row[f'INTRODD{suffix}_VDD{vdd_suffix}_EXPANSION_text'] = None
+                    row[f'INTRODD{suffix}_VDD{vdd_suffix}_EXPANSION_constr'] = None
+                    row[f'INTRODD{suffix}_VDD{vdd_suffix}_EXPANSION_type'] = None
+            if not vdds:
+                row[f'INTRODD{suffix}_VDD_text'] = None
+                row[f'INTRODD{suffix}_VDD_type'] = None
+                row[f'INTRODD{suffix}_VDD_EXPANSION_text'] = None
+                row[f'INTRODD{suffix}_VDD_EXPANSION_constr'] = None
+                row[f'INTRODD{suffix}_VDD_EXPANSION_type'] = None
+        
+        if not introdds:
+            row['INTRODD_text'] = None
+            row['INTRODD_EXPANSION_text'] = None
+            row['INTRODD_EXPANSION_constr'] = None
+            row['INTRODD_EXPANSION_type'] = None
+            row['INTRODD_MOD_text'] = None
+            row['INTRODD_VDD_text'] = None
+            row['INTRODD_VDD_type'] = None
+            row['INTRODD_VDD_EXPANSION_text'] = None
+            row['INTRODD_VDD_EXPANSION_constr'] = None
+            row['INTRODD_VDD_EXPANSION_type'] = None
+
+        # --- POSITION_INTRODD ---
+        row['POSITION_INTRODD'] = get_introdd_position(p)
+
+        # --- All PPIs (multiple MD in each PPI) ---
+        ppis = p.findall('PPI')
+        for i, ppi in enumerate(ppis):
+            suffix = '' if i == 0 else f'_{i+1}'
+            row[f'PPI{suffix}_text'] = clean_text(''.join(ppi.itertext()))
+            row[f'PPI{suffix}_decl'] = ppi.get('decl')
+            row[f'PPI{suffix}_type'] = ppi.get('type')
+            
+            # --- MD in PPI (multiple) ---
+            mds_in_ppi = ppi.findall('MD')
+            for j, md in enumerate(mds_in_ppi):
+                md_suffix = '' if j == 0 else f'_{j+1}'
+                row[f'PPI{suffix}_MD{md_suffix}_text'] = clean_text(''.join(md.itertext()))
+            if not mds_in_ppi:
+                row[f'PPI{suffix}_MD_text'] = None
+        
+        if not ppis:
+            row['PPI_text'] = None
+            row['PPI_decl'] = None
+            row['PPI_type'] = None
+            row['PPI_MD_text'] = None
+
+        # --- All NONPPIs ---
+        nonppis = p.findall('NONPPI')
+        for i, nonppi in enumerate(nonppis):
+            suffix = '' if i == 0 else f'_{i+1}'
+            row[f'NONPPI{suffix}_text'] = clean_text(''.join(nonppi.itertext()))
+        if not nonppis:
+            row['NONPPI_text'] = None
+
+        # --- Standalone MD ---
+        standalone_mds = [child for child in p if child.tag == 'MD']
+        for i, md in enumerate(standalone_mds):
+            suffix = '' if i == 0 else f'_{i+1}'
+            row[f'MD{suffix}_text'] = clean_text(''.join(md.itertext()))
+        if not standalone_mds:
+            row['MD_text'] = None
+
+        # --- All APPs ---
+        apps = p.findall('APP')
+        for i, app in enumerate(apps):
+            suffix = '' if i == 0 else f'_{i+1}'
+            row[f'APP{suffix}_text'] = clean_text(''.join(app.itertext()))
+        if not apps:
+            row['APP_text'] = None
+
+        rows.append(row)
+
+    return rows
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: xml2xlsx <xml_file_or_folder> [output_file] [ignore_multi_ppi=true|false]")
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+
+    # argv[3]: ignore_multi_ppi flag (default True; pass 'false' to disable)
+    ignore_multi_ppi = True
+    if len(sys.argv) >= 4:
+        flag = sys.argv[3].strip().lower()
+        if flag == 'false':
+            ignore_multi_ppi = False
+        elif flag == 'true':
+            ignore_multi_ppi = True
+        else:
+            print(f"Warning: unrecognized value '{sys.argv[3]}' for ignore_multi_ppi — defaulting to True")
+    print(f"[config] ignore_multi_ppi = {ignore_multi_ppi}")
+    all_rows = []
+
+    if os.path.isfile(input_path) and input_path.endswith('.xml'):
+        rows = extract_paragraphs(input_path)
+        for row in rows:
+            row['source_file'] = os.path.basename(input_path)
+        all_rows = rows
+        output_file = input_path.replace(".xml", ".xlsx")
+
+    elif os.path.isdir(input_path):
+        output_file = os.path.join(input_path, "master_output.xlsx")
+        for f in sorted(os.listdir(input_path)):
+            if f.endswith('.xml'):
+                file_path = os.path.join(input_path, f)
+                rows = extract_paragraphs(file_path)
+                if rows:
+                    individual_df = pd.DataFrame(rows)
+                    individual_df = individual_df.replace('', np.nan)
+                    individual_df.dropna(axis=1, how='all', inplace=True)
+                    text_cols = [c for c in individual_df.columns if c.endswith('_text') and c not in NO_LOWER]
+                    individual_df[text_cols] = individual_df[text_cols].apply(
+                        lambda col: col.map(lambda v: v.lower() if isinstance(v, str) else v)
+                    )
+                    individual_output = file_path.replace(".xml", ".xlsx")
+                    if 'paragraph_text_dd' in individual_df.columns:
+                        pos = individual_df.columns.get_loc('paragraph_text_dd') + 1
+                        individual_df.insert(pos, 'POSITION_INTRODD_DD',
+                                             individual_df['paragraph_text_dd'].map(
+                                                 lambda t: get_introdd_position_dd(t, ignore_multi_ppi),
+                                                 na_action='ignore'))
+                    format_ppi_bold(individual_df, individual_output)
+                    print(f"Saved individual file: {individual_output}")
+                for row in rows:
+                    row['source_file'] = f
+                all_rows.extend(rows)
+
+    elif os.path.isfile(input_path) and input_path.endswith('.xlsx'):
+        df = pd.read_excel(input_path)
+        if 'paragraph_text_dd' not in df.columns:
+            print("Error: column 'paragraph_text_dd' not found in the xlsx file.")
+            sys.exit(1)
+        if 'POSITION_INTRODD_DD' in df.columns:
+            df['POSITION_INTRODD_DD'] = df['paragraph_text_dd'].map(
+                lambda t: get_introdd_position_dd(t, ignore_multi_ppi), na_action='ignore')
+        else:
+            pos = df.columns.get_loc('paragraph_text_dd') + 1
+            df.insert(pos, 'POSITION_INTRODD_DD', df['paragraph_text_dd'].map(
+                lambda t: get_introdd_position_dd(t, ignore_multi_ppi), na_action='ignore'))
+        format_ppi_bold(df, input_path)
+        print(f"Updated {input_path}")
+        sys.exit(0)
+
+    else:
+        print("Please provide a valid .xml file, .xlsx file, or folder containing .xml files")
+        sys.exit(1)
+
+    if all_rows:
+        df = pd.DataFrame(all_rows)
+        cols = ['source_file'] + [c for c in df.columns if c != 'source_file']
+        df = df[cols]
+        text_cols = [c for c in df.columns if c.endswith('_text') and c not in NO_LOWER]
+        df[text_cols] = df[text_cols].apply(
+            lambda col: col.map(lambda v: v.lower() if isinstance(v, str) else v)
+        )
+        df = df.replace('', np.nan)
+        df.dropna(axis=1, how='all', inplace=True)
+        if 'paragraph_text_dd' in df.columns:
+            pos = df.columns.get_loc('paragraph_text_dd') + 1
+            df.insert(pos, 'POSITION_INTRODD_DD',
+                      df['paragraph_text_dd'].map(
+                          lambda t: get_introdd_position_dd(t, ignore_multi_ppi),
+                          na_action='ignore'))
+        format_ppi_bold(df, output_file)
+        print(f"Saved master file to {output_file}")
+    else:
+        print("No data extracted from input")
+
+
+if __name__ == '__main__':
+    main()

xml2xlsx_lidilem-0.1.0/xml2xlsx_lidilem.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: xml2xlsx-lidilem
+Version: 0.1.0
+Summary: Convert annotated XML to Excel
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: openpyxl
+Requires-Dist: pandas
+Requires-Dist: numpy

xml2xlsx_lidilem-0.1.0/xml2xlsx_lidilem.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+xml2xlsx/__init__.py
+xml2xlsx/format_excel.py
+xml2xlsx/xml2xlsx.py
+xml2xlsx_lidilem.egg-info/PKG-INFO
+xml2xlsx_lidilem.egg-info/SOURCES.txt
+xml2xlsx_lidilem.egg-info/dependency_links.txt
+xml2xlsx_lidilem.egg-info/entry_points.txt
+xml2xlsx_lidilem.egg-info/requires.txt
+xml2xlsx_lidilem.egg-info/top_level.txt

xml2xlsx_lidilem-0.1.0/xml2xlsx_lidilem.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xml2xlsx_lidilem-0.1.0/xml2xlsx_lidilem.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xml2xlsx = xml2xlsx.xml2xlsx:main

xml2xlsx_lidilem-0.1.0/xml2xlsx_lidilem.egg-info/requires.txt

@@ -0,0 +1,3 @@
+openpyxl
+pandas
+numpy

xml2xlsx_lidilem-0.1.0/xml2xlsx_lidilem.egg-info/top_level.txt

@@ -0,0 +1 @@
+xml2xlsx