informatica-python 1.1.0__tar.gz → 1.2.0__tar.gz

{informatica_python-1.1.0 → informatica_python-1.2.0}/PKG-INFO

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

{informatica_python-1.1.0 → informatica_python-1.2.0}/informatica_python/converter.py

@@ -235,7 +235,9 @@ class InformaticaConverter:
         if tgt.xmlinfo:
             d["xmlinfo"] = {"xml_type": tgt.xmlinfo.xml_type, "root_element": tgt.xmlinfo.root_element}
         if tgt.groups:
-            d["groups"] = [{"name": g.name, "type": g.type} for g in tgt.groups]
+            d["groups"] = [{"name": g.name, "type": g.type, "fields": [self._field_to_dict(f) for f in g.fields]} for g in tgt.groups]
+        if tgt.keywords:
+            d["keywords"] = [{"name": k.name, "value": k.value} for k in tgt.keywords]
         return d
 
     def _transformation_to_dict(self, tx):
@@ -257,7 +259,9 @@ class InformaticaConverter:
         if tx.erp_info:
             d["erp_info"] = {"name": tx.erp_info.name, "erp_type": tx.erp_info.erp_type}
         if tx.groups:
-            d["groups"] = [{"name": g.name, "type": g.type} for g in tx.groups]
+            d["groups"] = [{"name": g.name, "type": g.type, "fields": [self._field_to_dict(f) for f in g.fields]} for g in tx.groups]
+        if tx.metadata_extensions:
+            d["metadata_extensions"] = [self._meta_ext_to_dict(me) for me in tx.metadata_extensions]
         if tx.sap_functions:
             d["sap_functions"] = [self._sap_function_to_dict(sf) for sf in tx.sap_functions]
         return d
@@ -322,7 +326,13 @@ class InformaticaConverter:
             "transformations": [self._transformation_to_dict(tx) for tx in mapplet.transformations],
             "connectors": [{"from_field": c.from_field, "from_instance": c.from_instance,
                             "to_field": c.to_field, "to_instance": c.to_instance} for c in mapplet.connectors],
-            "instances": [{"name": i.name, "type": i.type, "transformation_name": i.transformation_name} for i in mapplet.instances],
+            "instances": [{"name": i.name, "type": i.type, "transformation_name": i.transformation_name,
+                           "associated_source_instances": [{"name": a.name, "source_instance": a.source_instance} for a in i.associated_source_instances]}
+                          for i in mapplet.instances],
+            "metadata_extensions": [self._meta_ext_to_dict(me) for me in mapplet.metadata_extensions],
+            "map_dependencies": [{"name": md.name, "from_mapping": md.from_mapping, "to_mapping": md.to_mapping} for md in mapplet.map_dependencies],
+            "field_dependencies": [{"name": fd.name, "from_field": fd.from_field, "from_instance": fd.from_instance,
+                                    "to_field": fd.to_field, "to_instance": fd.to_instance, "expression": fd.expression} for fd in mapplet.field_dependencies],
         }
 
     def _session_to_dict(self, session):
@@ -350,6 +360,7 @@ class InformaticaConverter:
             ],
             "config_references": session.config_references,
             "components": session.components,
+            "metadata_extensions": [self._meta_ext_to_dict(me) for me in session.metadata_extensions],
         }
 
     def _task_to_dict(self, task):
@@ -360,13 +371,17 @@ class InformaticaConverter:
         }
         if task.timer:
             d["timer"] = {"name": task.timer.name, "start_type": task.timer.start_type,
-                          "start_date": task.timer.start_date, "start_time": task.timer.start_time}
+                          "start_date": task.timer.start_date, "start_time": task.timer.start_time,
+                          "end_type": task.timer.end_type, "end_date": task.timer.end_date, "end_time": task.timer.end_time}
+        if task.metadata_extensions:
+            d["metadata_extensions"] = [self._meta_ext_to_dict(me) for me in task.metadata_extensions]
         return d
 
     def _config_to_dict(self, cfg):
         return {
             "name": cfg.name, "description": cfg.description, "is_valid": cfg.is_valid,
             "attributes": [{"name": a.name, "value": a.value} for a in cfg.attributes],
+            "metadata_extensions": [self._meta_ext_to_dict(me) for me in cfg.metadata_extensions],
         }
 
     def _scheduler_to_dict(self, sched):
@@ -380,10 +395,18 @@ class InformaticaConverter:
             d["start_options"] = sched.start_options.attributes
         if sched.end_options:
             d["end_options"] = sched.end_options.attributes
+        if sched.schedule_options:
+            d["schedule_options"] = sched.schedule_options.attributes
         if sched.recurring:
             d["recurring"] = sched.recurring.attributes
+        if sched.custom:
+            d["custom"] = sched.custom.attributes
         if sched.daily_frequency:
             d["daily_frequency"] = sched.daily_frequency.attributes
+        if sched.repeat:
+            d["repeat"] = sched.repeat.attributes
+        if sched.scheduler_filter:
+            d["filter"] = sched.scheduler_filter.attributes
         return d
 
     def _shortcut_to_dict(self, sc):
@@ -417,9 +440,11 @@ class InformaticaConverter:
                 for v in wf.variables
             ],
             "events": [
-                {"name": e.name, "event_type": e.event_type, "description": e.description}
+                {"name": e.name, "event_type": e.event_type, "description": e.description,
+                 "attributes": [{"name": a.name, "value": a.value} for a in e.attributes]}
                 for e in wf.events
             ],
             "attributes": [{"name": a.name, "value": a.value} for a in wf.attributes],
             "metadata": wf.metadata,
+            "metadata_extensions": [self._meta_ext_to_dict(me) for me in wf.metadata_extensions],
         }

{informatica_python-1.1.0 → informatica_python-1.2.0}/informatica_python/generators/error_log_gen.py

@@ -228,10 +228,36 @@ def generate_error_log(folder: FolderDef, parser_errors=None, parser_warnings=No
     lines.append("-" * 70)
     lines.append("")
 
+    all_transformations = list(folder.transformations)
+    for m in folder.mappings:
+        all_transformations.extend(m.transformations)
+    for mpl in folder.mapplets:
+        all_transformations.extend(mpl.transformations)
+
+    all_instances = []
+    for m in folder.mappings:
+        all_instances.extend(m.instances)
+    for mpl in folder.mapplets:
+        all_instances.extend(mpl.instances)
+
+    me_count = len(folder.metadata_extensions)
+    me_count += sum(len(s.metadata_extensions) for s in folder.sources)
+    me_count += sum(len(t.metadata_extensions) for t in folder.targets)
+    me_count += sum(len(m.metadata_extensions) for m in folder.mappings)
+    me_count += sum(len(mpl.metadata_extensions) for mpl in folder.mapplets)
+    me_count += sum(len(s.metadata_extensions) for s in folder.sessions)
+    me_count += sum(len(w.metadata_extensions) for w in folder.workflows)
+    me_count += sum(len(t.metadata_extensions) for t in folder.tasks)
+    me_count += sum(len(c.metadata_extensions) for c in folder.configs)
+    me_count += sum(len(tx.metadata_extensions) for tx in all_transformations)
+
+    group_count = (
+        sum(len(s.groups) for s in folder.sources)
+        + sum(len(t.groups) for t in folder.targets)
+        + sum(len(tx.groups) for tx in all_transformations)
+    )
+
     tag_counts = {
-        "POWERMART": 1,
-        "REPOSITORY": sum(1 for _ in [1]),
-        "FOLDER": 1,
         "FOLDERVERSION": len(folder.folder_versions),
         "SOURCE": len(folder.sources),
         "SOURCEFIELD": sum(len(s.fields) for s in folder.sources),
@@ -241,24 +267,24 @@ def generate_error_log(folder: FolderDef, parser_errors=None, parser_warnings=No
         "TARGETINDEXFIELD": sum(len(idx.fields) for t in folder.targets for idx in t.indexes),
         "FLATFILE": sum(1 for s in folder.sources if s.flatfile) + sum(1 for t in folder.targets if t.flatfile),
         "XMLINFO": sum(1 for s in folder.sources if s.xmlinfo) + sum(1 for t in folder.targets if t.xmlinfo),
-        "GROUP": sum(len(s.groups) for s in folder.sources) + sum(len(t.groups) for t in folder.targets),
-        "KEYWORD": sum(len(s.keywords) for s in folder.sources),
+        "GROUP": group_count,
+        "KEYWORD": sum(len(s.keywords) for s in folder.sources) + sum(len(t.keywords) for t in folder.targets),
         "ERPSRCINFO": sum(1 for s in folder.sources if s.erp_src_info),
         "MAPPING": len(folder.mappings),
         "MAPPLET": len(folder.mapplets),
-        "TRANSFORMATION": sum(len(m.transformations) for m in folder.mappings) + len(folder.transformations),
-        "TRANSFORMFIELD": sum(len(tx.fields) for m in folder.mappings for tx in m.transformations),
-        "TRANSFORMFIELDATTR": sum(len(tx.field_attrs) for m in folder.mappings for tx in m.transformations),
-        "TRANSFORMFIELDATTRDEF": sum(len(tx.field_attr_defs) for m in folder.mappings for tx in m.transformations),
-        "INITPROP": sum(len(tx.init_props) for m in folder.mappings for tx in m.transformations),
-        "ERPINFO": sum(1 for m in folder.mappings for tx in m.transformations if tx.erp_info),
-        "INSTANCE": sum(len(m.instances) for m in folder.mappings),
-        "ASSOCIATED_SOURCE_INSTANCE": sum(len(i.associated_source_instances) for m in folder.mappings for i in m.instances),
-        "CONNECTOR": sum(len(m.connectors) for m in folder.mappings),
+        "TRANSFORMATION": len(all_transformations),
+        "TRANSFORMFIELD": sum(len(tx.fields) for tx in all_transformations),
+        "TRANSFORMFIELDATTR": sum(len(tx.field_attrs) for tx in all_transformations),
+        "TRANSFORMFIELDATTRDEF": sum(len(tx.field_attr_defs) for tx in all_transformations),
+        "INITPROP": sum(len(tx.init_props) for tx in all_transformations),
+        "ERPINFO": sum(1 for tx in all_transformations if tx.erp_info),
+        "INSTANCE": len(all_instances),
+        "ASSOCIATED_SOURCE_INSTANCE": sum(len(i.associated_source_instances) for i in all_instances),
+        "CONNECTOR": sum(len(m.connectors) for m in folder.mappings) + sum(len(mpl.connectors) for mpl in folder.mapplets),
         "TARGETLOADORDER": sum(len(m.target_load_orders) for m in folder.mappings),
         "MAPPINGVARIABLE": sum(len(m.variables) for m in folder.mappings),
-        "MAPDEPENDENCY": sum(len(m.map_dependencies) for m in folder.mappings),
-        "FIELDDEPENDENCY": sum(len(m.field_dependencies) for m in folder.mappings),
+        "MAPDEPENDENCY": sum(len(m.map_dependencies) for m in folder.mappings) + sum(len(mpl.map_dependencies) for mpl in folder.mapplets),
+        "FIELDDEPENDENCY": sum(len(m.field_dependencies) for m in folder.mappings) + sum(len(mpl.field_dependencies) for mpl in folder.mapplets),
         "SESSION": len(folder.sessions),
         "SESSTRANSFORMATIONINST": sum(len(s.transform_instances) for s in folder.sessions),
         "SESSTRANSFORMATIONGROUP": sum(len(s.transform_groups) for s in folder.sessions),
@@ -273,15 +299,15 @@ def generate_error_log(folder: FolderDef, parser_errors=None, parser_warnings=No
         "TIMER": sum(1 for t in folder.tasks if t.timer),
         "CONFIG": len(folder.configs),
         "SCHEDULER": len(folder.schedulers),
-        "WORKFLOW": len(folder.workflows),
+        "WORKFLOW": sum(1 for w in folder.workflows if w.metadata.get("is_worklet") != "YES"),
         "WORKLET": sum(1 for w in folder.workflows if w.metadata.get("is_worklet") == "YES"),
         "TASKINSTANCE": sum(len(w.task_instances) for w in folder.workflows),
         "WORKFLOWLINK": sum(len(w.links) for w in folder.workflows),
         "WORKFLOWVARIABLE": sum(len(w.variables) for w in folder.workflows),
         "WORKFLOWEVENT": sum(len(w.events) for w in folder.workflows),
         "SHORTCUT": len(folder.shortcuts),
-        "METADATAEXTENSION": len(folder.metadata_extensions),
-        "SAPFUNCTION": sum(len(tx.sap_functions) for m in folder.mappings for tx in m.transformations),
+        "METADATAEXTENSION": me_count,
+        "SAPFUNCTION": sum(len(tx.sap_functions) for tx in all_transformations),
     }
 
     for tag, count in sorted(tag_counts.items()):

{informatica_python-1.1.0 → informatica_python-1.2.0}/informatica_python/generators/helper_gen.py

@@ -631,6 +631,402 @@ def _add_expression_helpers(lines):
     lines.append("    return date_val")
     lines.append("")
     lines.append("")
+    lines.append("def initcap(value):")
+    lines.append('    """Informatica INITCAP equivalent."""')
+    lines.append("    return str(value).title() if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def reverse_str(value):")
+    lines.append('    """Informatica REVERSE equivalent."""')
+    lines.append("    return str(value)[::-1] if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def chr_func(code):")
+    lines.append('    """Informatica CHR equivalent."""')
+    lines.append("    return chr(int(code)) if code is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def ascii_func(value):")
+    lines.append('    """Informatica ASCII equivalent."""')
+    lines.append("    if value is None or str(value) == '':")
+    lines.append("        return None")
+    lines.append("    return ord(str(value)[0])")
+    lines.append("")
+    lines.append("")
+    lines.append("def left_str(value, n):")
+    lines.append('    """Return leftmost n characters."""')
+    lines.append("    return str(value)[:int(n)] if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def right_str(value, n):")
+    lines.append('    """Return rightmost n characters."""')
+    lines.append("    return str(value)[-int(n):] if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def trim_func(value):")
+    lines.append('    """Informatica TRIM equivalent."""')
+    lines.append("    return str(value).strip() if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def indexof(value, search, start=1):")
+    lines.append('    """Informatica INDEXOF equivalent (1-based)."""')
+    lines.append("    if value is None or search is None:")
+    lines.append("        return 0")
+    lines.append("    idx = str(value).find(str(search), max(start - 1, 0))")
+    lines.append("    return idx + 1 if idx >= 0 else 0")
+    lines.append("")
+    lines.append("")
+    lines.append("def metaphone_func(value):")
+    lines.append('    """Informatica METAPHONE equivalent (simplified)."""')
+    lines.append("    if value is None:")
+    lines.append("        return None")
+    lines.append("    try:")
+    lines.append("        import jellyfish")
+    lines.append("        return jellyfish.metaphone(str(value))")
+    lines.append("    except ImportError:")
+    lines.append("        return str(value).upper()[:4]")
+    lines.append("")
+    lines.append("")
+    lines.append("def soundex_func(value):")
+    lines.append('    """Informatica SOUNDEX equivalent (simplified)."""')
+    lines.append("    if value is None:")
+    lines.append("        return None")
+    lines.append("    try:")
+    lines.append("        import jellyfish")
+    lines.append("        return jellyfish.soundex(str(value))")
+    lines.append("    except ImportError:")
+    lines.append("        s = str(value).upper()")
+    lines.append("        if not s:")
+    lines.append("            return '0000'")
+    lines.append("        codes = {'B':'1','F':'1','P':'1','V':'1','C':'2','G':'2','J':'2','K':'2','Q':'2','S':'2','X':'2','Z':'2','D':'3','T':'3','L':'4','M':'5','N':'5','R':'6'}")
+    lines.append("        result = s[0]")
+    lines.append("        for ch in s[1:]:")
+    lines.append("            code = codes.get(ch, '0')")
+    lines.append("            if code != '0' and code != result[-1]:")
+    lines.append("                result += code")
+    lines.append("        return (result + '0000')[:4]")
+    lines.append("")
+    lines.append("")
+    lines.append("def compress_func(value):")
+    lines.append('    """Informatica COMPRESS equivalent - removes spaces."""')
+    lines.append("    return str(value).replace(' ', '') if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def decompress_func(value):")
+    lines.append('    """Informatica DECOMPRESS equivalent."""')
+    lines.append("    return value")
+    lines.append("")
+    lines.append("")
+    lines.append("def to_timestamp_func(value, fmt=None):")
+    lines.append('    """Informatica TO_TIMESTAMP equivalent."""')
+    lines.append("    return to_date(value, fmt)")
+    lines.append("")
+    lines.append("")
+    lines.append("def cast_func(value, datatype):")
+    lines.append('    """Informatica CAST equivalent."""')
+    lines.append("    if value is None:")
+    lines.append("        return None")
+    lines.append("    dt = str(datatype).upper()")
+    lines.append("    if 'INT' in dt:")
+    lines.append("        return int(float(str(value)))")
+    lines.append("    elif 'FLOAT' in dt or 'DOUBLE' in dt or 'DECIMAL' in dt or 'NUMBER' in dt:")
+    lines.append("        return float(str(value))")
+    lines.append("    elif 'CHAR' in dt or 'STRING' in dt or 'VARCHAR' in dt:")
+    lines.append("        return str(value)")
+    lines.append("    elif 'DATE' in dt or 'TIMESTAMP' in dt:")
+    lines.append("        return to_date(value)")
+    lines.append("    return value")
+    lines.append("")
+    lines.append("")
+    lines.append("def set_date_part(part, date_val, value):")
+    lines.append('    """Informatica SET_DATE_PART equivalent."""')
+    lines.append("    if date_val is None:")
+    lines.append("        return None")
+    lines.append("    if isinstance(date_val, str):")
+    lines.append("        date_val = datetime.fromisoformat(date_val)")
+    lines.append("    p = part.upper()")
+    lines.append("    if p in ('YYYY', 'YY', 'YEAR'):")
+    lines.append("        return date_val.replace(year=int(value))")
+    lines.append("    elif p in ('MM', 'MON', 'MONTH'):")
+    lines.append("        return date_val.replace(month=int(value))")
+    lines.append("    elif p in ('DD', 'DAY'):")
+    lines.append("        return date_val.replace(day=int(value))")
+    lines.append("    elif p in ('HH', 'HH24', 'HOUR'):")
+    lines.append("        return date_val.replace(hour=int(value))")
+    lines.append("    elif p in ('MI', 'MINUTE'):")
+    lines.append("        return date_val.replace(minute=int(value))")
+    lines.append("    elif p in ('SS', 'SECOND'):")
+    lines.append("        return date_val.replace(second=int(value))")
+    lines.append("    return date_val")
+    lines.append("")
+    lines.append("")
+    lines.append("def date_diff(date1, date2, part='DD'):")
+    lines.append('    """Informatica DATE_DIFF equivalent."""')
+    lines.append("    if date1 is None or date2 is None:")
+    lines.append("        return None")
+    lines.append("    if isinstance(date1, str):")
+    lines.append("        date1 = datetime.fromisoformat(date1)")
+    lines.append("    if isinstance(date2, str):")
+    lines.append("        date2 = datetime.fromisoformat(date2)")
+    lines.append("    delta = date1 - date2")
+    lines.append("    p = part.upper()")
+    lines.append("    if p in ('DD', 'DAY', 'D'):")
+    lines.append("        return delta.days")
+    lines.append("    elif p in ('HH', 'HOUR'):")
+    lines.append("        return int(delta.total_seconds() / 3600)")
+    lines.append("    elif p in ('MI', 'MINUTE'):")
+    lines.append("        return int(delta.total_seconds() / 60)")
+    lines.append("    elif p in ('SS', 'SECOND'):")
+    lines.append("        return int(delta.total_seconds())")
+    lines.append("    elif p in ('MM', 'MONTH'):")
+    lines.append("        return (date1.year - date2.year) * 12 + (date1.month - date2.month)")
+    lines.append("    elif p in ('YYYY', 'YEAR'):")
+    lines.append("        return date1.year - date2.year")
+    lines.append("    return delta.days")
+    lines.append("")
+    lines.append("")
+    lines.append("def date_compare(date1, date2):")
+    lines.append('    """Informatica DATE_COMPARE equivalent. Returns -1, 0, or 1."""')
+    lines.append("    if date1 is None and date2 is None:")
+    lines.append("        return 0")
+    lines.append("    if date1 is None:")
+    lines.append("        return -1")
+    lines.append("    if date2 is None:")
+    lines.append("        return 1")
+    lines.append("    if isinstance(date1, str):")
+    lines.append("        date1 = datetime.fromisoformat(date1)")
+    lines.append("    if isinstance(date2, str):")
+    lines.append("        date2 = datetime.fromisoformat(date2)")
+    lines.append("    if date1 < date2:")
+    lines.append("        return -1")
+    lines.append("    elif date1 > date2:")
+    lines.append("        return 1")
+    lines.append("    return 0")
+    lines.append("")
+    lines.append("")
+    lines.append("def last_day(date_val):")
+    lines.append('    """Informatica LAST_DAY equivalent."""')
+    lines.append("    if date_val is None:")
+    lines.append("        return None")
+    lines.append("    if isinstance(date_val, str):")
+    lines.append("        date_val = datetime.fromisoformat(date_val)")
+    lines.append("    import calendar")
+    lines.append("    last = calendar.monthrange(date_val.year, date_val.month)[1]")
+    lines.append("    return date_val.replace(day=last)")
+    lines.append("")
+    lines.append("")
+    lines.append("def make_date_time(year, month, day, hour=0, minute=0, second=0):")
+    lines.append('    """Informatica MAKE_DATE_TIME equivalent."""')
+    lines.append("    return datetime(int(year), int(month), int(day), int(hour), int(minute), int(second))")
+    lines.append("")
+    lines.append("")
+    lines.append("def trunc(value, precision=0):")
+    lines.append('    """Informatica TRUNC equivalent (numeric or date)."""')
+    lines.append("    if value is None:")
+    lines.append("        return None")
+    lines.append("    if hasattr(value, 'replace') and hasattr(value, 'year'):")
+    lines.append("        return value.replace(hour=0, minute=0, second=0, microsecond=0)")
+    lines.append("    import math")
+    lines.append("    factor = 10 ** int(precision)")
+    lines.append("    return math.trunc(float(value) * factor) / factor")
+    lines.append("")
+    lines.append("")
+    lines.append("def round_val(value, precision=0):")
+    lines.append('    """Informatica ROUND equivalent."""')
+    lines.append("    if value is None:")
+    lines.append("        return None")
+    lines.append("    return round(float(value), int(precision))")
+    lines.append("")
+    lines.append("")
+    lines.append("def abs_val(value):")
+    lines.append('    """Informatica ABS equivalent."""')
+    lines.append("    return abs(float(value)) if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def ceil_val(value):")
+    lines.append('    """Informatica CEIL equivalent."""')
+    lines.append("    import math")
+    lines.append("    return math.ceil(float(value)) if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def floor_val(value):")
+    lines.append('    """Informatica FLOOR equivalent."""')
+    lines.append("    import math")
+    lines.append("    return math.floor(float(value)) if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def mod_val(a, b):")
+    lines.append('    """Informatica MOD equivalent."""')
+    lines.append("    if a is None or b is None or float(b) == 0:")
+    lines.append("        return None")
+    lines.append("    return float(a) % float(b)")
+    lines.append("")
+    lines.append("")
+    lines.append("def power_val(base, exp):")
+    lines.append('    """Informatica POWER equivalent."""')
+    lines.append("    if base is None or exp is None:")
+    lines.append("        return None")
+    lines.append("    return float(base) ** float(exp)")
+    lines.append("")
+    lines.append("")
+    lines.append("def sqrt_val(value):")
+    lines.append('    """Informatica SQRT equivalent."""')
+    lines.append("    import math")
+    lines.append("    return math.sqrt(float(value)) if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def log_val(base, value):")
+    lines.append('    """Informatica LOG equivalent."""')
+    lines.append("    import math")
+    lines.append("    if value is None or base is None:")
+    lines.append("        return None")
+    lines.append("    return math.log(float(value), float(base))")
+    lines.append("")
+    lines.append("")
+    lines.append("def ln_val(value):")
+    lines.append('    """Informatica LN (natural log) equivalent."""')
+    lines.append("    import math")
+    lines.append("    return math.log(float(value)) if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def exp_val(value):")
+    lines.append('    """Informatica EXP equivalent."""')
+    lines.append("    import math")
+    lines.append("    return math.exp(float(value)) if value is not None else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def sign_val(value):")
+    lines.append('    """Informatica SIGN equivalent."""')
+    lines.append("    if value is None:")
+    lines.append("        return None")
+    lines.append("    v = float(value)")
+    lines.append("    return 1 if v > 0 else (-1 if v < 0 else 0)")
+    lines.append("")
+    lines.append("")
+    lines.append("def rand_val(seed=None):")
+    lines.append('    """Informatica RAND equivalent."""')
+    lines.append("    import random")
+    lines.append("    if seed is not None:")
+    lines.append("        random.seed(seed)")
+    lines.append("    return random.random()")
+    lines.append("")
+    lines.append("")
+    lines.append("def greatest_val(*args):")
+    lines.append('    """Informatica GREATEST equivalent."""')
+    lines.append("    filtered = [a for a in args if a is not None]")
+    lines.append("    return max(filtered) if filtered else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def least_val(*args):")
+    lines.append('    """Informatica LEAST equivalent."""')
+    lines.append("    filtered = [a for a in args if a is not None]")
+    lines.append("    return min(filtered) if filtered else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def choose_expr(index, *values):")
+    lines.append('    """Informatica CHOOSE equivalent."""')
+    lines.append("    idx = int(index)")
+    lines.append("    if 1 <= idx <= len(values):")
+    lines.append("        return values[idx - 1]")
+    lines.append("    return None")
+    lines.append("")
+    lines.append("")
+    lines.append("def in_expr(value, *candidates):")
+    lines.append('    """Informatica IN equivalent."""')
+    lines.append("    return value in candidates")
+    lines.append("")
+    lines.append("")
+    lines.append("def max_val(*args):")
+    lines.append('    """Informatica MAX equivalent (row-level)."""')
+    lines.append("    filtered = [a for a in args if a is not None]")
+    lines.append("    return max(filtered) if filtered else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def min_val(*args):")
+    lines.append('    """Informatica MIN equivalent (row-level)."""')
+    lines.append("    filtered = [a for a in args if a is not None]")
+    lines.append("    return min(filtered) if filtered else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def sum_val(*args):")
+    lines.append('    """Informatica SUM equivalent (row-level)."""')
+    lines.append("    return sum(float(a) for a in args if a is not None)")
+    lines.append("")
+    lines.append("")
+    lines.append("def count_val(*args):")
+    lines.append('    """Informatica COUNT equivalent (row-level)."""')
+    lines.append("    return sum(1 for a in args if a is not None)")
+    lines.append("")
+    lines.append("")
+    lines.append("def avg_val(*args):")
+    lines.append('    """Informatica AVG equivalent (row-level)."""')
+    lines.append("    filtered = [float(a) for a in args if a is not None]")
+    lines.append("    return sum(filtered) / len(filtered) if filtered else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def median_val(*args):")
+    lines.append('    """Informatica MEDIAN equivalent (row-level)."""')
+    lines.append("    import statistics")
+    lines.append("    filtered = [float(a) for a in args if a is not None]")
+    lines.append("    return statistics.median(filtered) if filtered else None")
+    lines.append("")
+    lines.append("")
+    lines.append("def stddev_val(*args):")
+    lines.append('    """Informatica STDDEV equivalent (row-level)."""')
+    lines.append("    import statistics")
+    lines.append("    filtered = [float(a) for a in args if a is not None]")
+    lines.append("    return statistics.stdev(filtered) if len(filtered) > 1 else 0")
+    lines.append("")
+    lines.append("")
+    lines.append("def variance_val(*args):")
+    lines.append('    """Informatica VARIANCE equivalent (row-level)."""')
+    lines.append("    import statistics")
+    lines.append("    filtered = [float(a) for a in args if a is not None]")
+    lines.append("    return statistics.variance(filtered) if len(filtered) > 1 else 0")
+    lines.append("")
+    lines.append("")
+    lines.append("def percentile_val(value, pct):")
+    lines.append('    """Informatica PERCENTILE equivalent."""')
+    lines.append("    return value")
+    lines.append("")
+    lines.append("")
+    lines.append("def first_val(*args):")
+    lines.append('    """Informatica FIRST equivalent."""')
+    lines.append("    for a in args:")
+    lines.append("        if a is not None:")
+    lines.append("            return a")
+    lines.append("    return None")
+    lines.append("")
+    lines.append("")
+    lines.append("def last_val(*args):")
+    lines.append('    """Informatica LAST equivalent."""')
+    lines.append("    result = None")
+    lines.append("    for a in args:")
+    lines.append("        if a is not None:")
+    lines.append("            result = a")
+    lines.append("    return result")
+    lines.append("")
+    lines.append("")
+    lines.append("def moving_avg(value, window=3):")
+    lines.append('    """Informatica MOVINGAVG equivalent."""')
+    lines.append("    return value")
+    lines.append("")
+    lines.append("")
+    lines.append("def moving_sum(value, window=3):")
+    lines.append('    """Informatica MOVINGSUM equivalent."""')
+    lines.append("    return value")
+    lines.append("")
+    lines.append("")
+    lines.append("def cume(value):")
+    lines.append('    """Informatica CUME equivalent."""')
+    lines.append("    return value")
+    lines.append("")
+    lines.append("")
+    lines.append("def set_count_variable(var_name, value=1):")
+    lines.append('    """Informatica SETCOUNTVARIABLE equivalent."""')
+    lines.append("    return set_variable(var_name, value)")
+    lines.append("")
+    lines.append("")
     lines.append("def raise_error(message):")
     lines.append('    """Informatica ERROR function equivalent."""')
     lines.append("    logger.error(f'INFORMATICA ERROR: {message}')")