informatica-python 1.0.0__py3-none-any.whl

informatica_python/generators/mapping_gen.py

@@ -0,0 +1,649 @@
+from typing import List, Dict
+from informatica_python.models import (
+    MappingDef, FolderDef, SourceDef, TargetDef,
+    TransformationDef, ConnectorDef, InstanceDef,
+)
+from informatica_python.utils.expression_converter import convert_expression, convert_sql_expression
+from informatica_python.utils.datatype_map import get_python_type
+
+
+def generate_mapping_code(mapping: MappingDef, folder: FolderDef,
+                          data_lib: str = "pandas", mapping_index: int = 1) -> str:
+    lines = []
+    lines.append('"""')
+    lines.append(f"Mapping: {mapping.name}")
+    lines.append(f"Description: {mapping.description or 'N/A'}")
+    lines.append(f"Auto-generated by informatica-python")
+    lines.append('"""')
+    lines.append("")
+    lines.append("from helper_functions import *")
+    lines.append("")
+    lines.append("")
+
+    source_map = _build_source_map(mapping, folder)
+    target_map = _build_target_map(mapping, folder)
+    transform_map = {t.name: t for t in mapping.transformations}
+    connector_graph = _build_connector_graph(mapping.connectors)
+    instance_map = {i.name: i for i in mapping.instances}
+
+    lines.append(f"def run_{_safe_name(mapping.name)}(config):")
+    lines.append(f'    """Execute mapping: {mapping.name}"""')
+    lines.append(f"    start_time = log_mapping_start('{mapping.name}')")
+    lines.append("")
+
+    if mapping.variables:
+        lines.append("    # Mapping Variables")
+        for var in mapping.variables:
+            safe_var = _safe_name(var.name.replace("$$", ""))
+            default = var.default_value or "''"
+            if var.datatype.lower() in ("integer", "bigint", "int"):
+                default = var.default_value or "0"
+            lines.append(f"    {safe_var} = {default}")
+        lines.append("")
+
+    source_dfs = {}
+    for src_name, src_def in source_map.items():
+        safe = _safe_name(src_name)
+        source_dfs[src_name] = f"df_{safe}"
+
+    sq_transforms = [t for t in mapping.transformations
+                     if t.type in ("Source Qualifier", "Application Source Qualifier")]
+    if sq_transforms:
+        for sq in sq_transforms:
+            _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_graph, instance_map)
+    else:
+        for src_name, src_def in source_map.items():
+            safe = _safe_name(src_name)
+            lines.append(f"    # Read source: {src_name}")
+            if src_def.database_type and src_def.database_type != "Flat File":
+                conn_name = _safe_name(src_def.db_name) if src_def.db_name else "default"
+                schema = src_def.owner_name or "dbo"
+                lines.append(f"    df_{safe} = read_from_db(config, 'SELECT * FROM {schema}.{src_name}', '{conn_name}')")
+            else:
+                lines.append(f"    df_{safe} = read_file(config.get('sources', {{}}).get('{src_name}', {{}}).get('file_path', '{src_name}'),")
+                lines.append(f"                          config.get('sources', {{}}).get('{src_name}', {{}}))")
+            lines.append("")
+
+    processing_order = _get_processing_order(mapping.transformations, connector_graph, sq_transforms)
+
+    for tx in processing_order:
+        if tx.type in ("Source Qualifier", "Application Source Qualifier"):
+            continue
+        _generate_transformation(lines, tx, connector_graph, source_dfs, transform_map, instance_map)
+
+    for tgt_name, tgt_def in target_map.items():
+        _generate_target_write(lines, tgt_name, tgt_def, connector_graph, source_dfs, transform_map, instance_map)
+
+    lines.append("")
+    lines.append(f"    log_mapping_end('{mapping.name}', start_time)")
+    lines.append(f"    logger.info('Mapping {mapping.name} completed successfully')")
+    lines.append("")
+    lines.append("")
+    lines.append("if __name__ == '__main__':")
+    lines.append("    config = load_config()")
+    lines.append(f"    run_{_safe_name(mapping.name)}(config)")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def _safe_name(name):
+    import re
+    safe = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+    if safe and safe[0].isdigit():
+        safe = '_' + safe
+    return safe.lower()
+
+
+def _build_source_map(mapping, folder):
+    source_map = {}
+    for inst in mapping.instances:
+        if inst.type == "Source Definition":
+            tx_name = inst.transformation_name or inst.name
+            for src in folder.sources:
+                if src.name == tx_name:
+                    source_map[inst.name] = src
+                    break
+            else:
+                source_map[inst.name] = SourceDef(name=tx_name)
+    return source_map
+
+
+def _build_target_map(mapping, folder):
+    target_map = {}
+    for inst in mapping.instances:
+        if inst.type == "Target Definition":
+            tx_name = inst.transformation_name or inst.name
+            for tgt in folder.targets:
+                if tgt.name == tx_name:
+                    target_map[inst.name] = tgt
+                    break
+            else:
+                target_map[inst.name] = TargetDef(name=tx_name)
+    return target_map
+
+
+def _build_connector_graph(connectors: List[ConnectorDef]) -> Dict:
+    graph = {
+        "from": {},
+        "to": {},
+    }
+    for conn in connectors:
+        key_from = conn.from_instance
+        key_to = conn.to_instance
+        if key_from not in graph["from"]:
+            graph["from"][key_from] = []
+        graph["from"][key_from].append(conn)
+        if key_to not in graph["to"]:
+            graph["to"][key_to] = []
+        graph["to"][key_to].append(conn)
+    return graph
+
+
+def _get_processing_order(transformations, connector_graph, sq_transforms):
+    sq_names = {t.name for t in sq_transforms}
+    remaining = [t for t in transformations if t.name not in sq_names]
+
+    ordered = []
+    processed = set(sq_names)
+    max_iterations = len(remaining) * 2 + 1
+
+    for _ in range(max_iterations):
+        if not remaining:
+            break
+        for tx in list(remaining):
+            inputs = connector_graph.get("to", {}).get(tx.name, [])
+            input_instances = {c.from_instance for c in inputs}
+            if not input_instances or input_instances.issubset(processed):
+                ordered.append(tx)
+                processed.add(tx.name)
+                remaining.remove(tx)
+
+    ordered.extend(remaining)
+    return ordered
+
+
+def _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_graph, instance_map):
+    sq_safe = _safe_name(sq.name)
+    sql_override = ""
+    pre_sql = ""
+    post_sql = ""
+    for attr in sq.attributes:
+        if attr.name == "Sql Query" and attr.value:
+            sql_override = convert_sql_expression(attr.value)
+        elif attr.name == "Pre SQL" and attr.value:
+            pre_sql = convert_sql_expression(attr.value)
+        elif attr.name == "Post SQL" and attr.value:
+            post_sql = convert_sql_expression(attr.value)
+
+    connected_sources = set()
+    to_conns = connector_graph.get("to", {}).get(sq.name, [])
+    for c in to_conns:
+        if c.from_instance in source_map:
+            connected_sources.add(c.from_instance)
+    if not connected_sources:
+        for src_name in source_map:
+            if sq.name.upper().startswith("SQ_") and src_name.upper() in sq.name.upper():
+                connected_sources.add(src_name)
+        if not connected_sources and source_map:
+            connected_sources.add(next(iter(source_map)))
+
+    lines.append(f"    # Source Qualifier: {sq.name}")
+
+    if pre_sql:
+        lines.append(f"    # Pre-SQL")
+        for sql_line in pre_sql.strip().split("\n"):
+            lines.append(f"    # {sql_line}")
+        lines.append(f"    execute_sql(config, '''{pre_sql}''')")
+        lines.append("")
+
+    if sql_override:
+        src_name = next(iter(connected_sources)) if connected_sources else "source"
+        src_def = source_map.get(src_name, SourceDef(name=src_name))
+        conn_name = _safe_name(src_def.db_name) if src_def.db_name else "default"
+
+        lines.append(f"    sql_{sq_safe} = '''")
+        for sql_line in sql_override.strip().split("\n"):
+            lines.append(f"    {sql_line}")
+        lines.append(f"    '''")
+        lines.append(f"    df_{sq_safe} = read_from_db(config, sql_{sq_safe}, '{conn_name}')")
+    else:
+        if len(connected_sources) == 1:
+            src_name = next(iter(connected_sources))
+            src_def = source_map.get(src_name, SourceDef(name=src_name))
+            safe_src = _safe_name(src_name)
+            if src_def.database_type and src_def.database_type != "Flat File":
+                conn_name = _safe_name(src_def.db_name) if src_def.db_name else "default"
+                schema = src_def.owner_name or "dbo"
+                cols = ", ".join(f.name for f in src_def.fields) if src_def.fields else "*"
+                lines.append(f"    df_{sq_safe} = read_from_db(config, 'SELECT {cols} FROM {schema}.{src_def.name}', '{conn_name}')")
+            else:
+                lines.append(f"    df_{sq_safe} = read_file(config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path', '{src_def.name}'),")
+                lines.append(f"                              config.get('sources', {{}}).get('{src_def.name}', {{}}))")
+        else:
+            for src_name in connected_sources:
+                src_def = source_map.get(src_name, SourceDef(name=src_name))
+                safe_src = _safe_name(src_name)
+                if src_def.database_type and src_def.database_type != "Flat File":
+                    conn_name = _safe_name(src_def.db_name) if src_def.db_name else "default"
+                    schema = src_def.owner_name or "dbo"
+                    lines.append(f"    df_{safe_src} = read_from_db(config, 'SELECT * FROM {schema}.{src_def.name}', '{conn_name}')")
+                else:
+                    lines.append(f"    df_{safe_src} = read_file(config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path', '{src_def.name}'),")
+                    lines.append(f"                              config.get('sources', {{}}).get('{src_def.name}', {{}}))")
+            lines.append(f"    df_{sq_safe} = df_{_safe_name(next(iter(connected_sources)))}")
+
+    source_dfs[sq.name] = f"df_{sq_safe}"
+
+    if post_sql:
+        lines.append(f"    # Post-SQL")
+        lines.append(f"    execute_sql(config, '''{post_sql}''')")
+
+    lines.append("")
+
+
+def _generate_transformation(lines, tx, connector_graph, source_dfs, transform_map, instance_map):
+    tx_safe = _safe_name(tx.name)
+    tx_type = tx.type.lower().strip()
+
+    input_conns = connector_graph.get("to", {}).get(tx.name, [])
+    input_sources = set()
+    for c in input_conns:
+        input_sources.add(c.from_instance)
+
+    input_df = None
+    for src in input_sources:
+        if src in source_dfs:
+            input_df = source_dfs[src]
+            break
+    if not input_df:
+        for src in input_sources:
+            input_df = f"df_{_safe_name(src)}"
+            break
+    if not input_df:
+        input_df = "df_input"
+
+    lines.append(f"    # Transformation: {tx.name} (Type: {tx.type})")
+
+    if tx_type == "expression":
+        _gen_expression_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type == "filter":
+        _gen_filter_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("aggregator",):
+        _gen_aggregator_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type == "sorter":
+        _gen_sorter_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("joiner",):
+        _gen_joiner_transform(lines, tx, tx_safe, input_df, input_sources, source_dfs)
+    elif tx_type in ("lookup procedure", "lookup"):
+        _gen_lookup_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type == "router":
+        _gen_router_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("union",):
+        _gen_union_transform(lines, tx, tx_safe, input_sources, source_dfs)
+    elif tx_type in ("update strategy",):
+        _gen_update_strategy(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type == "sequence generator":
+        _gen_sequence_generator(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("normalizer",):
+        _gen_normalizer_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("rank",):
+        _gen_rank_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("custom transformation",):
+        _gen_custom_transform(lines, tx, tx_safe, input_df, input_sources, source_dfs)
+    elif tx_type in ("stored procedure",):
+        _gen_stored_proc(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("java",):
+        _gen_java_transform(lines, tx, tx_safe, input_df, source_dfs)
+    elif tx_type in ("sql",):
+        _gen_sql_transform(lines, tx, tx_safe, input_df, source_dfs)
+    else:
+        lines.append(f"    # TODO: Unsupported transformation type '{tx.type}' - passing through")
+        lines.append(f"    df_{tx_safe} = {input_df}.copy() if hasattr({input_df}, 'copy') else {input_df}")
+        source_dfs[tx.name] = f"df_{tx_safe}"
+
+    lines.append("")
+
+
+def _gen_expression_transform(lines, tx, tx_safe, input_df, source_dfs):
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    has_expressions = False
+    for fld in tx.fields:
+        if fld.expression and fld.expression.strip() and fld.expression.strip() != fld.name:
+            has_expressions = True
+            expr_py = convert_expression(fld.expression)
+            lines.append(f"    # {fld.name} = {fld.expression}")
+            if fld.porttype and "OUTPUT" in fld.porttype.upper() and "INPUT" not in fld.porttype.upper():
+                lines.append(f"    df_{tx_safe}['{fld.name}'] = {expr_py}  # output-only port")
+            else:
+                lines.append(f"    df_{tx_safe}['{fld.name}'] = {expr_py}")
+    if not has_expressions:
+        lines.append(f"    # Pass-through expression (no transformations)")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_filter_transform(lines, tx, tx_safe, input_df, source_dfs):
+    filter_condition = ""
+    for attr in tx.attributes:
+        if attr.name == "Filter Condition":
+            filter_condition = attr.value
+    if filter_condition:
+        expr_py = convert_expression(filter_condition)
+        lines.append(f"    # Filter: {filter_condition}")
+        lines.append(f"    df_{tx_safe} = {input_df}[{expr_py}].copy()")
+    else:
+        lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_aggregator_transform(lines, tx, tx_safe, input_df, source_dfs):
+    group_by_ports = []
+    agg_ports = []
+    for fld in tx.fields:
+        if "INPUT" in (fld.porttype or "").upper() and "OUTPUT" in (fld.porttype or "").upper():
+            group_by_ports.append(fld.name)
+        elif "OUTPUT" in (fld.porttype or "").upper():
+            agg_ports.append(fld)
+
+    if group_by_ports:
+        lines.append(f"    df_{tx_safe} = {input_df}.groupby({group_by_ports}).agg(")
+        for ap in agg_ports:
+            expr = ap.expression or ap.name
+            lines.append(f"        # {ap.name}: {expr}")
+        lines.append(f"    ).reset_index()")
+    else:
+        lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_sorter_transform(lines, tx, tx_safe, input_df, source_dfs):
+    sort_keys = []
+    sort_dirs = []
+    for fld in tx.fields:
+        sort_keys.append(fld.name)
+        sort_dirs.append(True)
+    if sort_keys:
+        lines.append(f"    df_{tx_safe} = {input_df}.sort_values(by={sort_keys}, ascending={sort_dirs}).reset_index(drop=True)")
+    else:
+        lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_joiner_transform(lines, tx, tx_safe, input_df, input_sources, source_dfs):
+    join_type = "inner"
+    join_condition = ""
+    for attr in tx.attributes:
+        if attr.name == "Join Type":
+            jt = attr.value.upper()
+            if "FULL" in jt:
+                join_type = "outer"
+            elif "MASTER" in jt:
+                join_type = "left"
+            elif "DETAIL" in jt:
+                join_type = "right"
+        elif attr.name == "Join Condition":
+            join_condition = attr.value
+
+    src_list = list(input_sources)
+    if len(src_list) >= 2:
+        df1 = source_dfs.get(src_list[0], f"df_{_safe_name(src_list[0])}")
+        df2 = source_dfs.get(src_list[1], f"df_{_safe_name(src_list[1])}")
+        lines.append(f"    # Join: {join_condition or 'auto'}")
+        lines.append(f"    df_{tx_safe} = {df1}.merge({df2}, how='{join_type}')")
+    else:
+        lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_lookup_transform(lines, tx, tx_safe, input_df, source_dfs):
+    lookup_table = ""
+    lookup_sql = ""
+    lookup_condition = ""
+    lookup_cache = "YES"
+    for attr in tx.attributes:
+        if attr.name == "Lookup table name":
+            lookup_table = attr.value
+        elif attr.name == "Lookup Sql Override" and attr.value:
+            lookup_sql = convert_sql_expression(attr.value)
+        elif attr.name == "Lookup condition":
+            lookup_condition = attr.value
+        elif attr.name == "Lookup caching enabled":
+            lookup_cache = attr.value
+
+    return_fields = [f for f in tx.fields if "RETURN" in (f.porttype or "").upper() or
+                     ("LOOKUP" in (f.porttype or "").upper() and "OUTPUT" in (f.porttype or "").upper()
+                      and "INPUT" not in (f.porttype or "").upper())]
+    input_fields = [f for f in tx.fields if "INPUT" in (f.porttype or "").upper()]
+
+    lines.append(f"    # Lookup: {lookup_table or tx.name}")
+    if lookup_sql:
+        lines.append(f"    lkp_sql_{tx_safe} = '''")
+        for sql_line in lookup_sql.strip().split("\n"):
+            lines.append(f"    {sql_line}")
+        lines.append(f"    '''")
+        lines.append(f"    df_lkp_{tx_safe} = read_from_db(config, lkp_sql_{tx_safe}, 'default')")
+    elif lookup_table:
+        lines.append(f"    df_lkp_{tx_safe} = read_from_db(config, 'SELECT * FROM {lookup_table}', 'default')")
+    else:
+        lines.append(f"    df_lkp_{tx_safe} = pd.DataFrame()  # TODO: Configure lookup source")
+
+    if lookup_condition:
+        lines.append(f"    # Condition: {lookup_condition}")
+
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+
+    if return_fields:
+        ret_names = [f.name for f in return_fields]
+        lines.append(f"    # Lookup returns: {ret_names}")
+        lines.append(f"    # TODO: Implement lookup merge logic based on condition: {lookup_condition}")
+        for rf in return_fields:
+            lines.append(f"    df_{tx_safe}['{rf.name}'] = None  # From lookup")
+
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_router_transform(lines, tx, tx_safe, input_df, source_dfs):
+    lines.append(f"    # Router groups:")
+    group_conditions = {}
+    for attr in tx.attributes:
+        if "Group Filter Condition" in attr.name:
+            group_conditions[attr.name] = attr.value
+
+    if group_conditions:
+        for i, (gname, cond) in enumerate(group_conditions.items()):
+            expr_py = convert_expression(cond) if cond else "True"
+            lines.append(f"    df_{tx_safe}_group{i} = {input_df}[{expr_py}].copy()  # {gname}")
+            source_dfs[f"{tx.name}_group{i}"] = f"df_{tx_safe}_group{i}"
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()  # Default group")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_union_transform(lines, tx, tx_safe, input_sources, source_dfs):
+    dfs_to_union = []
+    for src in input_sources:
+        df_name = source_dfs.get(src, f"df_{_safe_name(src)}")
+        dfs_to_union.append(df_name)
+
+    if len(dfs_to_union) > 1:
+        df_list = ", ".join(dfs_to_union)
+        lines.append(f"    df_{tx_safe} = pd.concat([{df_list}], ignore_index=True)")
+    elif dfs_to_union:
+        lines.append(f"    df_{tx_safe} = {dfs_to_union[0]}.copy()")
+    else:
+        lines.append(f"    df_{tx_safe} = pd.DataFrame()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_update_strategy(lines, tx, tx_safe, input_df, source_dfs):
+    strategy_expr = "0"
+    for attr in tx.attributes:
+        if attr.name == "Update Strategy Expression":
+            strategy_expr = attr.value
+    strategy_map = {"0": "INSERT", "1": "UPDATE", "2": "DELETE", "3": "REJECT"}
+    strategy_name = strategy_map.get(strategy_expr, f"EXPR({strategy_expr})")
+    lines.append(f"    # Update Strategy: {strategy_name}")
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    lines.append(f"    df_{tx_safe}['_update_strategy'] = '{strategy_name}'")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_sequence_generator(lines, tx, tx_safe, input_df, source_dfs):
+    start_val = "1"
+    increment = "1"
+    for attr in tx.attributes:
+        if attr.name == "Start Value":
+            start_val = attr.value or "1"
+        elif attr.name == "Increment By":
+            increment = attr.value or "1"
+
+    seq_field = None
+    for fld in tx.fields:
+        if fld.porttype and "OUTPUT" in fld.porttype.upper() and "NEXTVAL" in fld.name.upper():
+            seq_field = fld.name
+            break
+    if not seq_field:
+        for fld in tx.fields:
+            if fld.porttype and "OUTPUT" in fld.porttype.upper():
+                seq_field = fld.name
+                break
+
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    if seq_field:
+        lines.append(f"    df_{tx_safe}['{seq_field}'] = range({start_val}, {start_val} + len(df_{tx_safe}) * {increment}, {increment})")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_normalizer_transform(lines, tx, tx_safe, input_df, source_dfs):
+    lines.append(f"    # TODO: Normalizer transformation - implement based on specific normalization logic")
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_rank_transform(lines, tx, tx_safe, input_df, source_dfs):
+    rank_port = None
+    group_by = []
+    for fld in tx.fields:
+        if "RANK" in fld.name.upper():
+            rank_port = fld.name
+    top_bottom = "TOP"
+    for attr in tx.attributes:
+        if attr.name == "Top/Bottom":
+            top_bottom = attr.value
+
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    if rank_port:
+        ascending = top_bottom.upper() != "TOP"
+        lines.append(f"    df_{tx_safe}['RANK_INDEX'] = df_{tx_safe}['{rank_port}'].rank(ascending={ascending})")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_custom_transform(lines, tx, tx_safe, input_df, input_sources, source_dfs):
+    is_union = False
+    output_fields = []
+    input_groups = {}
+
+    for fld in tx.fields:
+        if "OUTPUT" in (fld.porttype or "").upper():
+            output_fields.append(fld)
+        group_suffix_match = None
+        import re
+        m = re.match(r'^(.+?)(\d+)$', fld.name)
+        if m and "INPUT" in (fld.porttype or "").upper():
+            base_name = m.group(1)
+            group_idx = m.group(2)
+            if group_idx not in input_groups:
+                input_groups[group_idx] = []
+            input_groups[group_idx].append(fld)
+
+    if len(input_groups) > 1:
+        is_union = True
+
+    if is_union:
+        dfs_to_union = []
+        for src in input_sources:
+            df_name = source_dfs.get(src, f"df_{_safe_name(src)}")
+            dfs_to_union.append(df_name)
+        if len(dfs_to_union) > 1:
+            df_list = ", ".join(dfs_to_union)
+            lines.append(f"    df_{tx_safe} = pd.concat([{df_list}], ignore_index=True)")
+        elif dfs_to_union:
+            lines.append(f"    df_{tx_safe} = {dfs_to_union[0]}.copy()")
+        else:
+            lines.append(f"    df_{tx_safe} = pd.DataFrame()")
+    else:
+        lines.append(f"    # Custom transformation: {tx.name}")
+        lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_stored_proc(lines, tx, tx_safe, input_df, source_dfs):
+    proc_name = ""
+    for attr in tx.attributes:
+        if attr.name in ("Stored Procedure Name", "sp name"):
+            proc_name = attr.value
+
+    lines.append(f"    # Stored Procedure: {proc_name or tx.name}")
+    lines.append(f"    # TODO: Execute stored procedure and capture results")
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_java_transform(lines, tx, tx_safe, input_df, source_dfs):
+    lines.append(f"    # Java Transformation: {tx.name}")
+    lines.append(f"    # TODO: Port Java logic to Python")
+    lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _gen_sql_transform(lines, tx, tx_safe, input_df, source_dfs):
+    sql_query = ""
+    for attr in tx.attributes:
+        if attr.name == "Sql Query" and attr.value:
+            sql_query = convert_sql_expression(attr.value)
+    lines.append(f"    # SQL Transformation: {tx.name}")
+    if sql_query:
+        lines.append(f"    sql_{tx_safe} = '''{sql_query}'''")
+        lines.append(f"    df_{tx_safe} = read_from_db(config, sql_{tx_safe}, 'default')")
+    else:
+        lines.append(f"    df_{tx_safe} = {input_df}.copy()")
+    source_dfs[tx.name] = f"df_{tx_safe}"
+
+
+def _generate_target_write(lines, tgt_name, tgt_def, connector_graph, source_dfs, transform_map, instance_map):
+    tgt_safe = _safe_name(tgt_name)
+
+    to_conns = connector_graph.get("to", {}).get(tgt_name, [])
+    input_df = None
+    for c in to_conns:
+        if c.from_instance in source_dfs:
+            input_df = source_dfs[c.from_instance]
+            break
+    if not input_df:
+        for c in to_conns:
+            input_df = f"df_{_safe_name(c.from_instance)}"
+            break
+
+    if not input_df:
+        input_df = "df_output"
+
+    col_mapping = {}
+    for c in to_conns:
+        col_mapping[c.to_field] = c.from_field
+
+    lines.append(f"    # Write to target: {tgt_def.name}")
+    if col_mapping:
+        lines.append(f"    target_columns_{tgt_safe} = {col_mapping}")
+        lines.append(f"    df_target_{tgt_safe} = {input_df}.rename(columns={{v: k for k, v in target_columns_{tgt_safe}.items()}})")
+        target_cols = [f.name for f in tgt_def.fields] if tgt_def.fields else None
+        if target_cols:
+            lines.append(f"    available_cols = [c for c in {target_cols} if c in df_target_{tgt_safe}.columns]")
+            lines.append(f"    df_target_{tgt_safe} = df_target_{tgt_safe}[available_cols]")
+    else:
+        lines.append(f"    df_target_{tgt_safe} = {input_df}")
+
+    if tgt_def.database_type and tgt_def.database_type != "Flat File":
+        lines.append(f"    write_to_db(config, df_target_{tgt_safe}, '{tgt_def.name}', 'target')")
+    else:
+        lines.append(f"    write_file(df_target_{tgt_safe}, config.get('targets', {{}}).get('{tgt_def.name}', {{}}).get('file_path', '{tgt_def.name}'),")
+        lines.append(f"              config.get('targets', {{}}).get('{tgt_def.name}', {{}}))")