informatica-python 1.3.1__tar.gz → 1.4.1__tar.gz

{informatica_python-1.3.1 → informatica_python-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: informatica-python
-Version: 1.3.1
+Version: 1.4.1
 Summary: Convert Informatica PowerCenter workflow XML to Python/PySpark code
 License-Expression: MIT
 Requires-Python: >=3.8

{informatica_python-1.3.1 → informatica_python-1.4.1}/informatica_python/generators/mapping_gen.py

@@ -135,6 +135,46 @@ def _inline_mapplets(mapping, folder):
     return extra_transforms, extra_connectors + rewired_connectors, mapplet_instances
 
 
+def _build_session_conn_overrides(mapping, folder):
+    overrides = {}
+    for session in folder.sessions:
+        if session.mapping_name != mapping.name:
+            continue
+        for sti in session.transform_instances:
+            inst_name = sti.instance_name or sti.transformation_name
+            for conn_ref in sti.connections:
+                conn_key = conn_ref.connection_name or conn_ref.variable
+                if conn_key:
+                    overrides[inst_name] = {
+                        "connection_name": conn_ref.connection_name,
+                        "connection_type": conn_ref.connection_type,
+                        "connection_subtype": conn_ref.connection_subtype,
+                        "variable": conn_ref.variable,
+                    }
+            for attr in sti.attributes:
+                if attr.name == "Connection Information" and attr.value:
+                    if inst_name not in overrides:
+                        overrides[inst_name] = {}
+                    overrides[inst_name]["connection_info"] = attr.value
+                elif attr.name == "Source File Directory" and attr.value:
+                    if inst_name not in overrides:
+                        overrides[inst_name] = {}
+                    overrides[inst_name]["source_file_directory"] = attr.value
+                elif attr.name == "Source filename" and attr.value:
+                    if inst_name not in overrides:
+                        overrides[inst_name] = {}
+                    overrides[inst_name]["source_filename"] = attr.value
+                elif attr.name == "Output File Directory" and attr.value:
+                    if inst_name not in overrides:
+                        overrides[inst_name] = {}
+                    overrides[inst_name]["output_file_directory"] = attr.value
+                elif attr.name == "Output filename" and attr.value:
+                    if inst_name not in overrides:
+                        overrides[inst_name] = {}
+                    overrides[inst_name]["output_filename"] = attr.value
+    return overrides
+
+
 def generate_mapping_code(mapping: MappingDef, folder: FolderDef,
                           data_lib: str = "pandas", mapping_index: int = 1) -> str:
     lines = []
@@ -164,6 +204,7 @@ def generate_mapping_code(mapping: MappingDef, folder: FolderDef,
     transform_map = {t.name: t for t in all_transforms}
     connector_graph = _build_connector_graph(all_connectors)
     instance_map = {i.name: i for i in mapping.instances}
+    session_overrides = _build_session_conn_overrides(mapping, folder)
 
     lines.append(f"def run_{_safe_name(mapping.name)}(config):")
     lines.append(f'    """Execute mapping: {mapping.name}"""')
@@ -180,6 +221,11 @@ def generate_mapping_code(mapping: MappingDef, folder: FolderDef,
             lines.append(f"    {safe_var} = {default}")
         lines.append("")
 
+    if session_overrides:
+        lines.append("    # Session connection overrides")
+        lines.append(f"    _sess_overrides = {repr(session_overrides)}")
+        lines.append("")
+
     source_dfs = {}
     for src_name, src_def in source_map.items():
         safe = _safe_name(src_name)
@@ -189,13 +235,23 @@ def generate_mapping_code(mapping: MappingDef, folder: FolderDef,
                      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)
+            _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_graph, instance_map, session_overrides)
     else:
         for src_name, src_def in source_map.items():
             safe = _safe_name(src_name)
+            override = session_overrides.get(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"
+            if override.get("source_file_directory") or override.get("source_filename"):
+                src_dir = override.get("source_file_directory", ".")
+                src_file = override.get("source_filename", src_def.name)
+                lines.append(f"    _src_path_{safe} = config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path',")
+                lines.append(f"        os.path.join('{src_dir}', '{src_file}'))")
+                if src_def.flatfile:
+                    _emit_flatfile_read(lines, safe, src_def, file_path_override=True)
+                else:
+                    lines.append(f"    df_{safe} = read_file(_src_path_{safe}, config.get('sources', {{}}).get('{src_def.name}', {{}}))")
+            elif src_def.database_type and src_def.database_type != "Flat File":
+                conn_name = override.get("connection_name") or (_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}')")
             elif src_def.flatfile:
@@ -213,7 +269,7 @@ def generate_mapping_code(mapping: MappingDef, folder: FolderDef,
         _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)
+        _generate_target_write(lines, tgt_name, tgt_def, connector_graph, source_dfs, transform_map, instance_map, session_overrides)
 
     lines.append("")
     lines.append(f"    log_mapping_end('{mapping.name}', start_time)")
@@ -267,15 +323,16 @@ def _flatfile_config_dict(ff):
     return cfg
 
 
-def _emit_flatfile_read(lines, var_name, src_def, indent="    "):
+def _emit_flatfile_read(lines, var_name, src_def, indent="    ", file_path_override=None):
     ff = src_def.flatfile
     fc = _flatfile_config_dict(ff)
+    default_path = f"_src_path_{var_name}" if file_path_override else f"config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path', '{src_def.name}')"
     if fc.get("fixed_width"):
         widths = []
         for fld in src_def.fields:
             widths.append(fld.precision if fld.precision else 10)
         lines.append(f"{indent}df_{var_name} = pd.read_fwf(")
-        lines.append(f"{indent}    config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path', '{src_def.name}'),")
+        lines.append(f"{indent}    {default_path},")
         lines.append(f"{indent}    widths={widths},")
         hdr = fc.get("header_lines", 0)
         if hdr:
@@ -311,15 +368,22 @@ def _emit_flatfile_read(lines, var_name, src_def, indent="    "):
     if file_cfg:
         lines.append(f"{indent}ff_cfg_{var_name} = {repr(file_cfg)}")
         lines.append(f"{indent}ff_cfg_{var_name}.update(config.get('sources', {{}}).get('{src_def.name}', {{}}))")
-        lines.append(f"{indent}df_{var_name} = read_file(ff_cfg_{var_name}.get('file_path', '{src_def.name}'), ff_cfg_{var_name})")
+        if file_path_override:
+            lines.append(f"{indent}df_{var_name} = read_file({default_path}, ff_cfg_{var_name})")
+        else:
+            lines.append(f"{indent}df_{var_name} = read_file(ff_cfg_{var_name}.get('file_path', '{src_def.name}'), ff_cfg_{var_name})")
     else:
-        lines.append(f"{indent}df_{var_name} = read_file(config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path', '{src_def.name}'),")
-        lines.append(f"{indent}                          config.get('sources', {{}}).get('{src_def.name}', {{}}))")
+        if file_path_override:
+            lines.append(f"{indent}df_{var_name} = read_file({default_path}, config.get('sources', {{}}).get('{src_def.name}', {{}}))")
+        else:
+            lines.append(f"{indent}df_{var_name} = read_file(config.get('sources', {{}}).get('{src_def.name}', {{}}).get('file_path', '{src_def.name}'),")
+            lines.append(f"{indent}                          config.get('sources', {{}}).get('{src_def.name}', {{}}))")
 
 
-def _emit_flatfile_write(lines, var_name, tgt_def, indent="    "):
+def _emit_flatfile_write(lines, var_name, tgt_def, indent="    ", file_path_override=None):
     ff = tgt_def.flatfile
     fc = _flatfile_config_dict(ff)
+    default_path = f"_tgt_path_{var_name}" if file_path_override else f"config.get('targets', {{}}).get('{tgt_def.name}', {{}}).get('file_path', '{tgt_def.name}')"
     file_cfg = {}
     if "delimiter" in fc:
         file_cfg["delimiter"] = fc["delimiter"]
@@ -331,10 +395,16 @@ def _emit_flatfile_write(lines, var_name, tgt_def, indent="    "):
     if file_cfg:
         lines.append(f"{indent}ff_cfg_{var_name} = {repr(file_cfg)}")
         lines.append(f"{indent}ff_cfg_{var_name}.update(config.get('targets', {{}}).get('{tgt_def.name}', {{}}))")
-        lines.append(f"{indent}write_file(df_target_{var_name}, ff_cfg_{var_name}.get('file_path', '{tgt_def.name}'), ff_cfg_{var_name})")
+        if file_path_override:
+            lines.append(f"{indent}write_file(df_target_{var_name}, {default_path}, ff_cfg_{var_name})")
+        else:
+            lines.append(f"{indent}write_file(df_target_{var_name}, ff_cfg_{var_name}.get('file_path', '{tgt_def.name}'), ff_cfg_{var_name})")
     else:
-        lines.append(f"{indent}write_file(df_target_{var_name}, config.get('targets', {{}}).get('{tgt_def.name}', {{}}).get('file_path', '{tgt_def.name}'),")
-        lines.append(f"{indent}          config.get('targets', {{}}).get('{tgt_def.name}', {{}}))")
+        if file_path_override:
+            lines.append(f"{indent}write_file(df_target_{var_name}, {default_path}, config.get('targets', {{}}).get('{tgt_def.name}', {{}}))")
+        else:
+            lines.append(f"{indent}write_file(df_target_{var_name}, config.get('targets', {{}}).get('{tgt_def.name}', {{}}).get('file_path', '{tgt_def.name}'),")
+            lines.append(f"{indent}          config.get('targets', {{}}).get('{tgt_def.name}', {{}}))")
 
 
 def _build_source_map(mapping, folder):
@@ -405,7 +475,7 @@ def _get_processing_order(transformations, connector_graph, sq_transforms):
     return ordered
 
 
-def _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_graph, instance_map):
+def _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_graph, instance_map, session_overrides=None):
     sq_safe = _safe_name(sq.name)
     sql_override = ""
     pre_sql = ""
@@ -442,7 +512,8 @@ def _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_grap
     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"
+        sq_override = (session_overrides or {}).get(sq.name, {}) or (session_overrides or {}).get(src_name, {})
+        conn_name = sq_override.get("connection_name") or (_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"):
@@ -454,8 +525,9 @@ def _generate_source_qualifier(lines, sq, source_map, source_dfs, connector_grap
             src_name = next(iter(connected_sources))
             src_def = source_map.get(src_name, SourceDef(name=src_name))
             safe_src = _safe_name(src_name)
+            src_override = (session_overrides or {}).get(sq.name, {}) or (session_overrides or {}).get(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"
+                conn_name = src_override.get("connection_name") or (_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}')")
@@ -1101,7 +1173,7 @@ def _gen_sql_transform(lines, tx, tx_safe, input_df, source_dfs):
     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):
+def _generate_target_write(lines, tgt_name, tgt_def, connector_graph, source_dfs, transform_map, instance_map, session_overrides=None):
     tgt_safe = _safe_name(tgt_name)
 
     to_conns = connector_graph.get("to", {}).get(tgt_name, [])
@@ -1133,10 +1205,92 @@ def _generate_target_write(lines, tgt_name, tgt_def, connector_graph, source_dfs
     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')")
+    _emit_type_casting(lines, tgt_safe, tgt_def)
+
+    tgt_override = (session_overrides or {}).get(tgt_name, {})
+    tgt_conn = tgt_override.get("connection_name")
+
+    if tgt_override.get("output_file_directory") or tgt_override.get("output_filename"):
+        out_dir = tgt_override.get("output_file_directory", ".")
+        out_file = tgt_override.get("output_filename", tgt_def.name)
+        lines.append(f"    _tgt_path_{tgt_safe} = config.get('targets', {{}}).get('{tgt_def.name}', {{}}).get('file_path',")
+        lines.append(f"        os.path.join('{out_dir}', '{out_file}'))")
+        if tgt_def.flatfile:
+            _emit_flatfile_write(lines, tgt_safe, tgt_def, file_path_override=True)
+        else:
+            lines.append(f"    write_file(df_target_{tgt_safe}, _tgt_path_{tgt_safe}, config.get('targets', {{}}).get('{tgt_def.name}', {{}}))")
+    elif tgt_def.database_type and tgt_def.database_type != "Flat File":
+        conn_label = tgt_conn or "target"
+        lines.append(f"    write_to_db(config, df_target_{tgt_safe}, '{tgt_def.name}', '{conn_label}')")
     elif tgt_def.flatfile:
         _emit_flatfile_write(lines, tgt_safe, tgt_def)
     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}', {{}}))")
+
+
+CAST_MAP = {
+    "bigint": ("int", "Int64"),
+    "integer": ("int", "Int32"),
+    "int": ("int", "Int32"),
+    "small integer": ("int", "Int16"),
+    "smallint": ("int", "Int16"),
+    "tinyint": ("int", "Int8"),
+    "numeric": ("float", "float64"),
+    "decimal": ("float", "float64"),
+    "float": ("float", "float64"),
+    "double": ("float", "float64"),
+    "real": ("float", "float32"),
+    "money": ("float", "float64"),
+    "smallmoney": ("float", "float64"),
+    "string": ("str", "object"),
+    "nstring": ("str", "object"),
+    "text": ("str", "object"),
+    "ntext": ("str", "object"),
+    "varchar": ("str", "object"),
+    "nvarchar": ("str", "object"),
+    "char": ("str", "object"),
+    "nchar": ("str", "object"),
+    "date/time": ("str", "datetime64[ns]"),
+    "datetime": ("str", "datetime64[ns]"),
+    "datetime2": ("str", "datetime64[ns]"),
+    "date": ("str", "datetime64[ns]"),
+    "timestamp": ("str", "datetime64[ns]"),
+    "bit": ("bool", "boolean"),
+    "boolean": ("bool", "boolean"),
+}
+
+
+def _emit_type_casting(lines, tgt_safe, tgt_def):
+    cast_ops = []
+    for fld in tgt_def.fields:
+        dt_key = fld.datatype.lower().strip()
+        if dt_key not in CAST_MAP:
+            continue
+        py_type, pd_dtype = CAST_MAP[dt_key]
+        if pd_dtype in ("datetime64[ns]",):
+            cast_ops.append((fld.name, "datetime", pd_dtype, fld.nullable == "NULL"))
+        elif pd_dtype in ("Int64", "Int32", "Int16", "Int8"):
+            cast_ops.append((fld.name, "int", pd_dtype, fld.nullable == "NULL"))
+        elif pd_dtype in ("float64", "float32"):
+            cast_ops.append((fld.name, "float", pd_dtype, fld.nullable == "NULL"))
+        elif pd_dtype == "boolean":
+            cast_ops.append((fld.name, "bool", pd_dtype, fld.nullable == "NULL"))
+
+    if not cast_ops:
+        return
+
+    lines.append(f"    # Type casting for target fields")
+    for col_name, cast_type, pd_dtype, nullable in cast_ops:
+        lines.append(f"    if '{col_name}' in df_target_{tgt_safe}.columns:")
+        if cast_type == "datetime":
+            lines.append(f"        df_target_{tgt_safe}['{col_name}'] = pd.to_datetime(df_target_{tgt_safe}['{col_name}'], errors='coerce')")
+        elif cast_type == "int":
+            if nullable:
+                lines.append(f"        df_target_{tgt_safe}['{col_name}'] = pd.to_numeric(df_target_{tgt_safe}['{col_name}'], errors='coerce').astype('{pd_dtype}')")
+            else:
+                lines.append(f"        df_target_{tgt_safe}['{col_name}'] = pd.to_numeric(df_target_{tgt_safe}['{col_name}'], errors='coerce').fillna(0).astype(int)")
+        elif cast_type == "float":
+            lines.append(f"        df_target_{tgt_safe}['{col_name}'] = pd.to_numeric(df_target_{tgt_safe}['{col_name}'], errors='coerce')")
+        elif cast_type == "bool":
+            lines.append(f"        df_target_{tgt_safe}['{col_name}'] = df_target_{tgt_safe}['{col_name}'].astype('{pd_dtype}')")

informatica_python-1.4.1/informatica_python/generators/workflow_gen.py

@@ -0,0 +1,388 @@
+from informatica_python.models import FolderDef, WorkflowDef, TaskInstanceDef
+from informatica_python.utils.expression_converter import convert_expression
+
+
+def _is_worklet(wf: WorkflowDef) -> bool:
+    for ext in wf.metadata_extensions:
+        if ext.name == "is_worklet" and ext.value and ext.value.upper() == "YES":
+            return True
+    md = getattr(wf, "metadata", {})
+    if isinstance(md, dict) and md.get("is_worklet", "").upper() == "YES":
+        return True
+    return False
+
+
+def generate_workflow_code(folder: FolderDef) -> str:
+    lines = []
+    lines.append('"""')
+    lines.append(f"Workflow orchestration for folder: {folder.name}")
+    lines.append("Auto-generated by informatica-python")
+    lines.append('"""')
+    lines.append("")
+    lines.append("import sys")
+    lines.append("import logging")
+    lines.append("from datetime import datetime")
+    lines.append("from helper_functions import load_config, logger")
+    lines.append("")
+
+    for i, mapping in enumerate(folder.mappings, 1):
+        safe_name = _safe_name(mapping.name)
+        lines.append(f"from mapping_{i} import run_{safe_name}")
+    lines.append("")
+    lines.append("")
+
+    worklets = []
+    main_workflows = []
+    if folder.workflows:
+        for wf in folder.workflows:
+            if _is_worklet(wf):
+                worklets.append(wf)
+            else:
+                main_workflows.append(wf)
+
+    for wkl in worklets:
+        _generate_worklet_function(lines, wkl, folder)
+
+    if main_workflows:
+        for wf in main_workflows:
+            _generate_workflow_function(lines, wf, folder, worklets)
+    else:
+        _generate_default_workflow(lines, folder)
+
+    lines.append("")
+    lines.append("if __name__ == '__main__':")
+    lines.append("    config = load_config()")
+    lines.append("    success = run_workflow(config)")
+    lines.append("    sys.exit(0 if success else 1)")
+    lines.append("")
+
+    return "\n".join(lines)
+
+
+def _generate_worklet_function(lines, wkl: WorkflowDef, folder: FolderDef):
+    wkl_safe = _safe_name(wkl.name)
+    lines.append(f"def run_worklet_{wkl_safe}(config):")
+    lines.append(f'    """')
+    lines.append(f"    Execute worklet: {wkl.name}")
+    if wkl.description:
+        lines.append(f"    Description: {wkl.description}")
+    lines.append(f'    """')
+    lines.append(f"    logger.info(f'--- Starting Worklet: {wkl.name} ---')")
+    lines.append(f"    wkl_start = datetime.now()")
+    lines.append(f"    success = True")
+    lines.append(f"    failed_tasks = []")
+    lines.append("")
+
+    if wkl.variables:
+        lines.append("    # Worklet Variables")
+        for var in wkl.variables:
+            var_name = _safe_name(var.name.replace("$$", ""))
+            default = var.default_value or "''"
+            lines.append(f"    {var_name} = {default}")
+        lines.append("")
+
+    execution_order = _get_task_execution_order(wkl)
+
+    mapping_name_map = {}
+    for i, mapping in enumerate(folder.mappings, 1):
+        mapping_name_map[mapping.name] = f"run_{_safe_name(mapping.name)}"
+
+    session_to_mapping = {}
+    for session in folder.sessions:
+        if session.mapping_name:
+            session_to_mapping[session.name] = session.mapping_name
+
+    for task in execution_order:
+        _emit_task_code(lines, task, mapping_name_map, session_to_mapping, wkl, [])
+
+    lines.append(f"    elapsed = (datetime.now() - wkl_start).total_seconds()")
+    lines.append(f"    if success:")
+    lines.append(f"        logger.info(f'--- Worklet {wkl.name} completed successfully in {{elapsed:.2f}}s ---')")
+    lines.append(f"    else:")
+    lines.append(f"        logger.error(f'--- Worklet {wkl.name} failed in {{elapsed:.2f}}s. Failed tasks: {{failed_tasks}} ---')")
+    lines.append(f"    return success")
+    lines.append("")
+    lines.append("")
+
+
+def _generate_workflow_function(lines, wf: WorkflowDef, folder: FolderDef, worklets=None):
+    wf_safe = _safe_name(wf.name)
+    lines.append(f"def run_workflow(config, workflow_name='{wf.name}'):")
+    lines.append(f'    """')
+    lines.append(f"    Execute workflow: {wf.name}")
+    if wf.description:
+        lines.append(f"    Description: {wf.description}")
+    lines.append(f'    """')
+    lines.append(f"    logger.info(f'=== Starting Workflow: {wf.name} ===')")
+    lines.append(f"    wf_start = datetime.now()")
+    lines.append(f"    success = True")
+    lines.append(f"    failed_tasks = []")
+    lines.append("")
+
+    if wf.variables:
+        lines.append("    # Workflow Variables")
+        for var in wf.variables:
+            var_name = _safe_name(var.name.replace("$$", ""))
+            default = var.default_value or "''"
+            lines.append(f"    {var_name} = {default}")
+        lines.append("")
+
+    execution_order = _get_task_execution_order(wf)
+
+    mapping_name_map = {}
+    for i, mapping in enumerate(folder.mappings, 1):
+        mapping_name_map[mapping.name] = f"run_{_safe_name(mapping.name)}"
+
+    session_to_mapping = {}
+    for session in folder.sessions:
+        if session.mapping_name:
+            session_to_mapping[session.name] = session.mapping_name
+
+    for task in execution_order:
+        _emit_task_code(lines, task, mapping_name_map, session_to_mapping, wf, worklets or [])
+
+    lines.append(f"    elapsed = (datetime.now() - wf_start).total_seconds()")
+    lines.append(f"    if success:")
+    lines.append(f"        logger.info(f'=== Workflow {wf.name} completed successfully in {{elapsed:.2f}}s ===')")
+    lines.append(f"    else:")
+    lines.append(f"        logger.error(f'=== Workflow {wf.name} failed in {{elapsed:.2f}}s. Failed tasks: {{failed_tasks}} ===')")
+    lines.append(f"    return success")
+    lines.append("")
+
+
+def _emit_task_code(lines, task, mapping_name_map, session_to_mapping, wf, worklets):
+    task_safe = _safe_name(task.name)
+
+    if task.task_type == "Start Task":
+        lines.append(f"    # Start Task: {task.name}")
+        lines.append(f"    logger.info('Workflow started')")
+        lines.append("")
+        return
+
+    if task.task_type == "Session":
+        mapping_name = session_to_mapping.get(task.task_name or task.name, "")
+        run_func = mapping_name_map.get(mapping_name, None)
+
+        lines.append(f"    # Session: {task.name}")
+        lines.append(f"    try:")
+        lines.append(f"        logger.info('Executing session: {task.name}')")
+        if run_func:
+            lines.append(f"        {run_func}(config)")
+        else:
+            lines.append(f"        # TODO: Map session '{task.name}' to corresponding mapping function")
+            lines.append(f"        logger.warning('Session {task.name} has no mapped function')")
+        lines.append(f"    except Exception as e:")
+        lines.append(f"        logger.error(f'Session {task.name} failed: {{e}}')")
+
+        if task.fail_parent_if_instance_fails == "YES":
+            lines.append(f"        success = False")
+            lines.append(f"        failed_tasks.append('{task.name}')")
+        else:
+            lines.append(f"        logger.warning('Continuing despite failure (fail_parent=NO)')")
+        lines.append("")
+
+    elif task.task_type == "Worklet":
+        worklet_name = task.task_name or task.name
+        worklet_safe = _safe_name(worklet_name)
+        matched_worklet = None
+        for wkl in worklets:
+            if wkl.name == worklet_name:
+                matched_worklet = wkl
+                break
+
+        lines.append(f"    # Worklet: {task.name}")
+        lines.append(f"    try:")
+        lines.append(f"        logger.info('Executing worklet: {task.name}')")
+        if matched_worklet:
+            lines.append(f"        worklet_result_{task_safe} = run_worklet_{worklet_safe}(config)")
+            lines.append(f"        if not worklet_result_{task_safe}:")
+            lines.append(f"            raise RuntimeError('Worklet {worklet_name} returned failure')")
+        else:
+            lines.append(f"        # WARNING: Worklet '{worklet_name}' definition not found in folder")
+            lines.append(f"        logger.warning('Worklet {worklet_name} not found — skipping')")
+        lines.append(f"    except Exception as e:")
+        lines.append(f"        logger.error(f'Worklet {task.name} failed: {{e}}')")
+        if task.fail_parent_if_instance_fails == "YES":
+            lines.append(f"        success = False")
+            lines.append(f"        failed_tasks.append('{task.name}')")
+        else:
+            lines.append(f"        logger.warning('Continuing despite worklet failure (fail_parent=NO)')")
+        lines.append("")
+
+    elif task.task_type == "Command":
+        cmd = ""
+        for attr in task.attributes:
+            if attr.name in ("Command", "CmdLine"):
+                cmd = attr.value
+        lines.append(f"    # Command Task: {task.name}")
+        lines.append(f"    try:")
+        lines.append(f"        import subprocess, shlex")
+        if cmd:
+            lines.append(f"        subprocess.run(shlex.split({repr(cmd)}), check=True)")
+        else:
+            lines.append(f"        # TODO: Configure command for task '{task.name}'")
+            lines.append(f"        pass")
+        lines.append(f"    except Exception as e:")
+        lines.append(f"        logger.error(f'Command task {task.name} failed: {{e}}')")
+        if task.fail_parent_if_instance_fails == "YES":
+            lines.append(f"        success = False")
+            lines.append(f"        failed_tasks.append('{task.name}')")
+        lines.append("")
+
+    elif task.task_type == "Email Task":
+        lines.append(f"    # Email Task: {task.name}")
+        lines.append(f"    # TODO: Implement email notification logic")
+        lines.append(f"    logger.info('Email task: {task.name} - skipped (implement email logic)')")
+        lines.append("")
+
+    elif task.task_type == "Decision":
+        decision_cond = ""
+        decision_name = ""
+        for attr in task.attributes:
+            if attr.name == "Decision Condition":
+                decision_cond = attr.value
+            elif attr.name == "Decision Name":
+                decision_name = attr.value
+
+        lines.append(f"    # Decision Task: {task.name}")
+        if decision_cond:
+            py_cond = _convert_decision_condition(decision_cond)
+            lines.append(f"    # Original condition: {decision_cond}")
+            lines.append(f"    decision_{task_safe} = {py_cond}")
+            lines.append(f"    logger.info(f'Decision {task.name}: {{decision_{task_safe}}}')")
+
+            succ_targets = []
+            fail_targets = []
+            for link in wf.links:
+                if link.from_instance == task.name:
+                    cond_text = (link.condition or "").strip().upper()
+                    if "FAILED" in cond_text or "FALSE" in cond_text:
+                        fail_targets.append(link.to_instance)
+                    elif "SUCCEEDED" in cond_text or "TRUE" in cond_text or cond_text:
+                        succ_targets.append(link.to_instance)
+                    else:
+                        succ_targets.append(link.to_instance)
+
+            if succ_targets or fail_targets:
+                lines.append(f"    if decision_{task_safe}:")
+                if succ_targets:
+                    for t in succ_targets:
+                        lines.append(f"        logger.info('Decision {task.name} => proceeding to {t}')")
+                else:
+                    lines.append(f"        pass")
+                if fail_targets:
+                    lines.append(f"    else:")
+                    for t in fail_targets:
+                        lines.append(f"        logger.info('Decision {task.name} => proceeding to {t}')")
+            else:
+                lines.append(f"    if not decision_{task_safe}:")
+                lines.append(f"        logger.warning('Decision {task.name} evaluated to False')")
+        else:
+            lines.append(f"    logger.info('Decision task: {task.name} (no condition specified)')")
+        lines.append("")
+
+    elif task.task_type == "Timer":
+        lines.append(f"    # Timer Task: {task.name}")
+        lines.append(f"    import time")
+        lines.append(f"    # TODO: Configure timer delay")
+        lines.append(f"    logger.info('Timer task: {task.name}')")
+        lines.append("")
+
+    elif task.task_type == "Assignment":
+        lines.append(f"    # Assignment Task: {task.name}")
+        for attr in task.attributes:
+            if attr.name and attr.value:
+                lines.append(f"    # {attr.name} = {attr.value}")
+        lines.append(f"    logger.info('Assignment task: {task.name}')")
+        lines.append("")
+
+    else:
+        lines.append(f"    # Task: {task.name} (Type: {task.task_type})")
+        lines.append(f"    logger.info('Executing task: {task.name} ({task.task_type})')")
+        lines.append(f"    # TODO: Implement task logic")
+        lines.append("")
+
+
+def _generate_default_workflow(lines, folder):
+    lines.append("def run_workflow(config, workflow_name='default'):")
+    lines.append('    """Execute all mappings in order."""')
+    lines.append(f"    logger.info('=== Starting Default Workflow ===')")
+    lines.append(f"    wf_start = datetime.now()")
+    lines.append(f"    success = True")
+    lines.append("")
+
+    for i, mapping in enumerate(folder.mappings, 1):
+        safe_name = _safe_name(mapping.name)
+        lines.append(f"    try:")
+        lines.append(f"        logger.info('Executing mapping {i}: {mapping.name}')")
+        lines.append(f"        run_{safe_name}(config)")
+        lines.append(f"    except Exception as e:")
+        lines.append(f"        logger.error(f'Mapping {mapping.name} failed: {{e}}')")
+        lines.append(f"        success = False")
+        lines.append("")
+
+    lines.append(f"    elapsed = (datetime.now() - wf_start).total_seconds()")
+    lines.append(f"    logger.info(f'=== Workflow completed in {{elapsed:.2f}}s (success={{success}}) ===')")
+    lines.append(f"    return success")
+    lines.append("")
+
+
+def _get_task_execution_order(wf: WorkflowDef):
+    if not wf.task_instances:
+        return []
+
+    task_map = {t.name: t for t in wf.task_instances}
+    adj = {t.name: [] for t in wf.task_instances}
+    in_degree = {t.name: 0 for t in wf.task_instances}
+
+    for link in wf.links:
+        if link.from_instance in adj and link.to_instance in adj:
+            adj[link.from_instance].append(link.to_instance)
+            in_degree[link.to_instance] += 1
+
+    queue = []
+    for name, deg in in_degree.items():
+        if deg == 0:
+            queue.append(name)
+
+    ordered = []
+    while queue:
+        queue.sort()
+        node = queue.pop(0)
+        ordered.append(task_map[node])
+        for neighbor in adj.get(node, []):
+            in_degree[neighbor] -= 1
+            if in_degree[neighbor] == 0:
+                queue.append(neighbor)
+
+    for t in wf.task_instances:
+        if t not in ordered:
+            ordered.append(t)
+
+    return ordered
+
+
+def _convert_decision_condition(condition):
+    import re
+    cond = condition.strip()
+    cond = re.sub(r'\$\$(\w+)', r'\1', cond)
+    cond = re.sub(r'\$(\w+)\.(\w+)\.(Status|PrevTaskStatus)', r"'\2_status'", cond)
+    cond = re.sub(r'\bSUCCEEDED\b', "'SUCCEEDED'", cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bFAILED\b', "'FAILED'", cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bABORTED\b', "'ABORTED'", cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bAND\b', 'and', cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bOR\b', 'or', cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bNOT\b', 'not', cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bTRUE\b', 'True', cond, flags=re.IGNORECASE)
+    cond = re.sub(r'\bFALSE\b', 'False', cond, flags=re.IGNORECASE)
+    cond = re.sub(r'(?<!=)=(?!=)', '==', cond)
+    cond = cond.replace('<>', '!=')
+    return cond
+
+
+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()

{informatica_python-1.3.1 → informatica_python-1.4.1}/informatica_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: informatica-python
-Version: 1.3.1
+Version: 1.4.1
 Summary: Convert Informatica PowerCenter workflow XML to Python/PySpark code
 License-Expression: MIT
 Requires-Python: >=3.8

{informatica_python-1.3.1 → informatica_python-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "informatica-python"
-version = "1.3.1"
+version = "1.4.1"
 description = "Convert Informatica PowerCenter workflow XML to Python/PySpark code"
 readme = "README.md"
 license = "MIT"

{informatica_python-1.3.1 → informatica_python-1.4.1}/tests/test_converter.py

@@ -776,6 +776,200 @@ def test_inline_mapplet():
     print("PASS: test_inline_mapplet")
 
 
+def test_session_connection_overrides():
+    from informatica_python.models import (
+        MappingDef, FolderDef, SourceDef, TargetDef,
+        TransformationDef, ConnectorDef, InstanceDef, FieldDef,
+        SessionDef, SessionTransformInst, ConnectionRef, TableAttribute,
+    )
+    from informatica_python.generators.mapping_gen import generate_mapping_code
+
+    mapping = MappingDef(
+        name="m_sess_test",
+        transformations=[
+            TransformationDef(name="SQ_SRC", type="Source Qualifier",
+                              fields=[FieldDef(name="ID", datatype="integer", porttype="INPUT/OUTPUT")]),
+        ],
+        connectors=[
+            ConnectorDef(from_instance="MY_SRC", from_field="ID",
+                         from_instance_type="Source Definition",
+                         to_instance="SQ_SRC", to_field="ID",
+                         to_instance_type="Source Qualifier"),
+            ConnectorDef(from_instance="SQ_SRC", from_field="ID",
+                         from_instance_type="Source Qualifier",
+                         to_instance="MY_TGT", to_field="ID",
+                         to_instance_type="Target Definition"),
+        ],
+        instances=[
+            InstanceDef(name="MY_SRC", type="Source Definition", transformation_name="MY_SRC"),
+            InstanceDef(name="SQ_SRC", type="Source Qualifier"),
+            InstanceDef(name="MY_TGT", type="Target Definition", transformation_name="MY_TGT"),
+        ],
+    )
+    src = SourceDef(name="MY_SRC", database_type="Oracle", db_name="SRC_DB",
+                    owner_name="EDW",
+                    fields=[FieldDef(name="ID", datatype="integer")])
+    tgt = TargetDef(name="MY_TGT", database_type="Oracle",
+                    fields=[FieldDef(name="ID", datatype="integer")])
+
+    session = SessionDef(
+        name="s_m_sess_test",
+        mapping_name="m_sess_test",
+        transform_instances=[
+            SessionTransformInst(
+                instance_name="SQ_SRC",
+                transformation_name="SQ_SRC",
+                connections=[
+                    ConnectionRef(connection_name="PROD_ORA", connection_type="Oracle"),
+                ],
+            ),
+            SessionTransformInst(
+                instance_name="MY_TGT",
+                transformation_name="MY_TGT",
+                attributes=[
+                    TableAttribute(name="Output File Directory", value="/data/output"),
+                    TableAttribute(name="Output filename", value="result.csv"),
+                ],
+            ),
+        ],
+    )
+
+    folder = FolderDef(
+        name="test",
+        sources=[src],
+        targets=[tgt],
+        mappings=[mapping],
+        sessions=[session],
+    )
+    code = generate_mapping_code(mapping, folder)
+
+    assert "PROD_ORA" in code, "Session connection override should use PROD_ORA"
+    assert "_sess_overrides" in code, "Session overrides dict should be emitted"
+    assert "/data/output" in code, "Output file directory override should appear"
+    assert "result.csv" in code, "Output filename override should appear"
+    print("PASS: test_session_connection_overrides")
+
+
+def test_worklet_generation():
+    from informatica_python.models import (
+        FolderDef, WorkflowDef, TaskInstanceDef, WorkflowLink,
+        MetadataExtension,
+    )
+    from informatica_python.generators.workflow_gen import generate_workflow_code
+
+    worklet = WorkflowDef(
+        name="wklt_error_handler",
+        description="Error handling worklet",
+        metadata_extensions=[
+            MetadataExtension(name="is_worklet", value="YES"),
+        ],
+        task_instances=[
+            TaskInstanceDef(name="Start_wklt", task_type="Start Task"),
+            TaskInstanceDef(name="CMD_LOG", task_type="Command",
+                            attributes=[]),
+        ],
+        links=[
+            WorkflowLink(from_instance="Start_wklt", to_instance="CMD_LOG", condition=""),
+        ],
+    )
+
+    main_wf = WorkflowDef(
+        name="wf_main",
+        task_instances=[
+            TaskInstanceDef(name="Start_main", task_type="Start Task"),
+            TaskInstanceDef(name="WK_ERR", task_type="Worklet",
+                            task_name="wklt_error_handler"),
+        ],
+        links=[
+            WorkflowLink(from_instance="Start_main", to_instance="WK_ERR", condition=""),
+        ],
+    )
+
+    folder = FolderDef(
+        name="test",
+        workflows=[worklet, main_wf],
+    )
+    code = generate_workflow_code(folder)
+
+    assert "def run_worklet_wklt_error_handler(config):" in code, \
+        "Worklet function should be generated"
+    assert "run_worklet_wklt_error_handler(config)" in code, \
+        "Main workflow should call the worklet function"
+    assert "Worklet: WK_ERR" in code, \
+        "Worklet task should appear in workflow"
+    print("PASS: test_worklet_generation")
+
+
+def test_type_casting_at_target():
+    from informatica_python.models import (
+        MappingDef, FolderDef, SourceDef, TargetDef,
+        TransformationDef, ConnectorDef, InstanceDef, FieldDef,
+    )
+    from informatica_python.generators.mapping_gen import generate_mapping_code
+
+    mapping = MappingDef(
+        name="m_cast_test",
+        transformations=[
+            TransformationDef(name="SQ_DATA", type="Source Qualifier",
+                              fields=[
+                                  FieldDef(name="AMOUNT", datatype="decimal", porttype="INPUT/OUTPUT"),
+                                  FieldDef(name="REC_ID", datatype="bigint", porttype="INPUT/OUTPUT"),
+                                  FieldDef(name="CREATED", datatype="date/time", porttype="INPUT/OUTPUT"),
+                                  FieldDef(name="IS_ACTIVE", datatype="bit", porttype="INPUT/OUTPUT"),
+                              ]),
+        ],
+        connectors=[
+            ConnectorDef(from_instance="SRC", from_field="AMOUNT",
+                         from_instance_type="Source Definition",
+                         to_instance="SQ_DATA", to_field="AMOUNT",
+                         to_instance_type="Source Qualifier"),
+            ConnectorDef(from_instance="SQ_DATA", from_field="AMOUNT",
+                         from_instance_type="Source Qualifier",
+                         to_instance="TGT", to_field="AMOUNT",
+                         to_instance_type="Target Definition"),
+            ConnectorDef(from_instance="SQ_DATA", from_field="REC_ID",
+                         from_instance_type="Source Qualifier",
+                         to_instance="TGT", to_field="REC_ID",
+                         to_instance_type="Target Definition"),
+            ConnectorDef(from_instance="SQ_DATA", from_field="CREATED",
+                         from_instance_type="Source Qualifier",
+                         to_instance="TGT", to_field="CREATED",
+                         to_instance_type="Target Definition"),
+            ConnectorDef(from_instance="SQ_DATA", from_field="IS_ACTIVE",
+                         from_instance_type="Source Qualifier",
+                         to_instance="TGT", to_field="IS_ACTIVE",
+                         to_instance_type="Target Definition"),
+        ],
+        instances=[
+            InstanceDef(name="SRC", type="Source Definition", transformation_name="SRC"),
+            InstanceDef(name="SQ_DATA", type="Source Qualifier"),
+            InstanceDef(name="TGT", type="Target Definition", transformation_name="TGT"),
+        ],
+    )
+    src = SourceDef(name="SRC", fields=[
+        FieldDef(name="AMOUNT", datatype="decimal"),
+        FieldDef(name="REC_ID", datatype="bigint"),
+        FieldDef(name="CREATED", datatype="date/time"),
+        FieldDef(name="IS_ACTIVE", datatype="bit"),
+    ])
+    tgt = TargetDef(name="TGT", fields=[
+        FieldDef(name="AMOUNT", datatype="decimal"),
+        FieldDef(name="REC_ID", datatype="bigint", nullable="NOT NULL"),
+        FieldDef(name="PARENT_ID", datatype="bigint", nullable="NULL"),
+        FieldDef(name="CREATED", datatype="date/time"),
+        FieldDef(name="IS_ACTIVE", datatype="bit"),
+    ])
+    folder = FolderDef(name="test", sources=[src], targets=[tgt], mappings=[mapping])
+    code = generate_mapping_code(mapping, folder)
+
+    assert "pd.to_numeric" in code, "Numeric casting should use pd.to_numeric"
+    assert "Int64" in code, "Bigint should cast to Int64 (nullable)"
+    assert "pd.to_datetime" in code, "Date/time should use pd.to_datetime"
+    assert ".fillna(0).astype(int)" in code, "NOT NULL bigint should use fillna(0).astype(int)"
+    assert "Type casting for target fields" in code, "Type casting comment should appear"
+    print("PASS: test_type_casting_at_target")
+
+
 if __name__ == "__main__":
     print("=" * 60)
     print("Running informatica-python tests")
@@ -805,6 +999,9 @@ if __name__ == "__main__":
         test_rank_with_groupby,
         test_decision_task_if_else,
         test_inline_mapplet,
+        test_session_connection_overrides,
+        test_worklet_generation,
+        test_type_casting_at_target,
     ]
 
     passed = 0

informatica_python-1.3.1/informatica_python/generators/workflow_gen.py

@@ -1,288 +0,0 @@
-from informatica_python.models import FolderDef, WorkflowDef, TaskInstanceDef
-from informatica_python.utils.expression_converter import convert_expression
-
-
-def generate_workflow_code(folder: FolderDef) -> str:
-    lines = []
-    lines.append('"""')
-    lines.append(f"Workflow orchestration for folder: {folder.name}")
-    lines.append("Auto-generated by informatica-python")
-    lines.append('"""')
-    lines.append("")
-    lines.append("import sys")
-    lines.append("import logging")
-    lines.append("from datetime import datetime")
-    lines.append("from helper_functions import load_config, logger")
-    lines.append("")
-
-    for i, mapping in enumerate(folder.mappings, 1):
-        safe_name = _safe_name(mapping.name)
-        lines.append(f"from mapping_{i} import run_{safe_name}")
-    lines.append("")
-    lines.append("")
-
-    if folder.workflows:
-        for wf in folder.workflows:
-            _generate_workflow_function(lines, wf, folder)
-    else:
-        _generate_default_workflow(lines, folder)
-
-    lines.append("")
-    lines.append("if __name__ == '__main__':")
-    lines.append("    config = load_config()")
-    lines.append("    success = run_workflow(config)")
-    lines.append("    sys.exit(0 if success else 1)")
-    lines.append("")
-
-    return "\n".join(lines)
-
-
-def _generate_workflow_function(lines, wf: WorkflowDef, folder: FolderDef):
-    wf_safe = _safe_name(wf.name)
-    lines.append(f"def run_workflow(config, workflow_name='{wf.name}'):")
-    lines.append(f'    """')
-    lines.append(f"    Execute workflow: {wf.name}")
-    if wf.description:
-        lines.append(f"    Description: {wf.description}")
-    lines.append(f'    """')
-    lines.append(f"    logger.info(f'=== Starting Workflow: {wf.name} ===')")
-    lines.append(f"    wf_start = datetime.now()")
-    lines.append(f"    success = True")
-    lines.append(f"    failed_tasks = []")
-    lines.append("")
-
-    if wf.variables:
-        lines.append("    # Workflow Variables")
-        for var in wf.variables:
-            var_name = _safe_name(var.name.replace("$$", ""))
-            default = var.default_value or "''"
-            lines.append(f"    {var_name} = {default}")
-        lines.append("")
-
-    execution_order = _get_task_execution_order(wf)
-
-    mapping_name_map = {}
-    for i, mapping in enumerate(folder.mappings, 1):
-        mapping_name_map[mapping.name] = f"run_{_safe_name(mapping.name)}"
-
-    session_to_mapping = {}
-    for session in folder.sessions:
-        if session.mapping_name:
-            session_to_mapping[session.name] = session.mapping_name
-
-    for task in execution_order:
-        task_safe = _safe_name(task.name)
-
-        if task.task_type == "Start Task":
-            lines.append(f"    # Start Task: {task.name}")
-            lines.append(f"    logger.info('Workflow started')")
-            lines.append("")
-            continue
-
-        if task.task_type == "Session":
-            mapping_name = session_to_mapping.get(task.task_name or task.name, "")
-            run_func = mapping_name_map.get(mapping_name, None)
-
-            lines.append(f"    # Session: {task.name}")
-            lines.append(f"    try:")
-            lines.append(f"        logger.info('Executing session: {task.name}')")
-            if run_func:
-                lines.append(f"        {run_func}(config)")
-            else:
-                lines.append(f"        # TODO: Map session '{task.name}' to corresponding mapping function")
-                lines.append(f"        logger.warning('Session {task.name} has no mapped function')")
-            lines.append(f"    except Exception as e:")
-            lines.append(f"        logger.error(f'Session {task.name} failed: {{e}}')")
-
-            if task.fail_parent_if_instance_fails == "YES":
-                lines.append(f"        success = False")
-                lines.append(f"        failed_tasks.append('{task.name}')")
-            else:
-                lines.append(f"        logger.warning('Continuing despite failure (fail_parent=NO)')")
-            lines.append("")
-
-        elif task.task_type == "Command":
-            cmd = ""
-            for attr in task.attributes:
-                if attr.name in ("Command", "CmdLine"):
-                    cmd = attr.value
-            lines.append(f"    # Command Task: {task.name}")
-            lines.append(f"    try:")
-            lines.append(f"        import subprocess, shlex")
-            if cmd:
-                lines.append(f"        subprocess.run(shlex.split({repr(cmd)}), check=True)")
-            else:
-                lines.append(f"        # TODO: Configure command for task '{task.name}'")
-                lines.append(f"        pass")
-            lines.append(f"    except Exception as e:")
-            lines.append(f"        logger.error(f'Command task {task.name} failed: {{e}}')")
-            if task.fail_parent_if_instance_fails == "YES":
-                lines.append(f"        success = False")
-                lines.append(f"        failed_tasks.append('{task.name}')")
-            lines.append("")
-
-        elif task.task_type == "Email Task":
-            lines.append(f"    # Email Task: {task.name}")
-            lines.append(f"    # TODO: Implement email notification logic")
-            lines.append(f"    logger.info('Email task: {task.name} - skipped (implement email logic)')")
-            lines.append("")
-
-        elif task.task_type == "Decision":
-            decision_cond = ""
-            decision_name = ""
-            for attr in task.attributes:
-                if attr.name == "Decision Condition":
-                    decision_cond = attr.value
-                elif attr.name == "Decision Name":
-                    decision_name = attr.value
-
-            lines.append(f"    # Decision Task: {task.name}")
-            if decision_cond:
-                py_cond = _convert_decision_condition(decision_cond)
-                lines.append(f"    # Original condition: {decision_cond}")
-                lines.append(f"    decision_{task_safe} = {py_cond}")
-                lines.append(f"    logger.info(f'Decision {task.name}: {{decision_{task_safe}}}')")
-
-                succ_targets = []
-                fail_targets = []
-                for link in wf.links:
-                    if link.from_instance == task.name:
-                        cond_text = (link.condition or "").strip().upper()
-                        if "FAILED" in cond_text or "FALSE" in cond_text:
-                            fail_targets.append(link.to_instance)
-                        elif "SUCCEEDED" in cond_text or "TRUE" in cond_text or cond_text:
-                            succ_targets.append(link.to_instance)
-                        else:
-                            succ_targets.append(link.to_instance)
-
-                if succ_targets or fail_targets:
-                    lines.append(f"    if decision_{task_safe}:")
-                    if succ_targets:
-                        for t in succ_targets:
-                            lines.append(f"        logger.info('Decision {task.name} => proceeding to {t}')")
-                    else:
-                        lines.append(f"        pass")
-                    if fail_targets:
-                        lines.append(f"    else:")
-                        for t in fail_targets:
-                            lines.append(f"        logger.info('Decision {task.name} => proceeding to {t}')")
-                else:
-                    lines.append(f"    if not decision_{task_safe}:")
-                    lines.append(f"        logger.warning('Decision {task.name} evaluated to False')")
-            else:
-                lines.append(f"    logger.info('Decision task: {task.name} (no condition specified)')")
-            lines.append("")
-
-        elif task.task_type == "Timer":
-            lines.append(f"    # Timer Task: {task.name}")
-            lines.append(f"    import time")
-            lines.append(f"    # TODO: Configure timer delay")
-            lines.append(f"    logger.info('Timer task: {task.name}')")
-            lines.append("")
-
-        elif task.task_type == "Assignment":
-            lines.append(f"    # Assignment Task: {task.name}")
-            for attr in task.attributes:
-                if attr.name and attr.value:
-                    lines.append(f"    # {attr.name} = {attr.value}")
-            lines.append(f"    logger.info('Assignment task: {task.name}')")
-            lines.append("")
-
-        else:
-            lines.append(f"    # Task: {task.name} (Type: {task.task_type})")
-            lines.append(f"    logger.info('Executing task: {task.name} ({task.task_type})')")
-            lines.append(f"    # TODO: Implement task logic")
-            lines.append("")
-
-    lines.append(f"    elapsed = (datetime.now() - wf_start).total_seconds()")
-    lines.append(f"    if success:")
-    lines.append(f"        logger.info(f'=== Workflow {wf.name} completed successfully in {{elapsed:.2f}}s ===')")
-    lines.append(f"    else:")
-    lines.append(f"        logger.error(f'=== Workflow {wf.name} failed in {{elapsed:.2f}}s. Failed tasks: {{failed_tasks}} ===')")
-    lines.append(f"    return success")
-    lines.append("")
-
-
-def _generate_default_workflow(lines, folder):
-    lines.append("def run_workflow(config, workflow_name='default'):")
-    lines.append('    """Execute all mappings in order."""')
-    lines.append(f"    logger.info('=== Starting Default Workflow ===')")
-    lines.append(f"    wf_start = datetime.now()")
-    lines.append(f"    success = True")
-    lines.append("")
-
-    for i, mapping in enumerate(folder.mappings, 1):
-        safe_name = _safe_name(mapping.name)
-        lines.append(f"    try:")
-        lines.append(f"        logger.info('Executing mapping {i}: {mapping.name}')")
-        lines.append(f"        run_{safe_name}(config)")
-        lines.append(f"    except Exception as e:")
-        lines.append(f"        logger.error(f'Mapping {mapping.name} failed: {{e}}')")
-        lines.append(f"        success = False")
-        lines.append("")
-
-    lines.append(f"    elapsed = (datetime.now() - wf_start).total_seconds()")
-    lines.append(f"    logger.info(f'=== Workflow completed in {{elapsed:.2f}}s (success={{success}}) ===')")
-    lines.append(f"    return success")
-    lines.append("")
-
-
-def _get_task_execution_order(wf: WorkflowDef):
-    if not wf.task_instances:
-        return []
-
-    task_map = {t.name: t for t in wf.task_instances}
-    adj = {t.name: [] for t in wf.task_instances}
-    in_degree = {t.name: 0 for t in wf.task_instances}
-
-    for link in wf.links:
-        if link.from_instance in adj and link.to_instance in adj:
-            adj[link.from_instance].append(link.to_instance)
-            in_degree[link.to_instance] += 1
-
-    queue = []
-    for name, deg in in_degree.items():
-        if deg == 0:
-            queue.append(name)
-
-    ordered = []
-    while queue:
-        queue.sort()
-        node = queue.pop(0)
-        ordered.append(task_map[node])
-        for neighbor in adj.get(node, []):
-            in_degree[neighbor] -= 1
-            if in_degree[neighbor] == 0:
-                queue.append(neighbor)
-
-    for t in wf.task_instances:
-        if t not in ordered:
-            ordered.append(t)
-
-    return ordered
-
-
-def _convert_decision_condition(condition):
-    import re
-    cond = condition.strip()
-    cond = re.sub(r'\$\$(\w+)', r'\1', cond)
-    cond = re.sub(r'\$(\w+)\.(\w+)\.(Status|PrevTaskStatus)', r"'\2_status'", cond)
-    cond = re.sub(r'\bSUCCEEDED\b', "'SUCCEEDED'", cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bFAILED\b', "'FAILED'", cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bABORTED\b', "'ABORTED'", cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bAND\b', 'and', cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bOR\b', 'or', cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bNOT\b', 'not', cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bTRUE\b', 'True', cond, flags=re.IGNORECASE)
-    cond = re.sub(r'\bFALSE\b', 'False', cond, flags=re.IGNORECASE)
-    cond = re.sub(r'(?<!=)=(?!=)', '==', cond)
-    cond = cond.replace('<>', '!=')
-    return cond
-
-
-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()