py-flow-mapper 0.1.0b7.dev0__tar.gz → 0.1.0b9.dev0__tar.gz

{py_flow_mapper-0.1.0b7.dev0/src/py_flow_mapper.egg-info → py_flow_mapper-0.1.0b9.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-flow-mapper
-Version: 0.1.0b7.dev0
+Version: 0.1.0b9.dev0
 Summary: Python project analyzer and visualization tool
 Home-page: https://github.com/ArunKoundinya/py-flow-mapper
 Author: Arun Koundinya Parasa

{py_flow_mapper-0.1.0b7.dev0 → py_flow_mapper-0.1.0b9.dev0}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="py-flow-mapper",
-    version="0.1.0b7.dev",
+    version="0.1.0b9.dev",
     author="Arun Koundinya Parasa",
     author_email="parasa.arunkoundinya@gmail.com",
     description="Python project analyzer and visualization tool",

{py_flow_mapper-0.1.0b7.dev0 → py_flow_mapper-0.1.0b9.dev0}/src/py_flow_mapper/__init__.py

@@ -2,7 +2,7 @@
 PyFlowMapper - A Python project analyzer and visualization tool.
 """
 
-__version__ = "0.1.0b7.dev"
+__version__ = "0.1.0b9.dev"
 __author__ = "Arun Koundinya Parasa"
 __description__ = "Analyze Python projects and generate dependency graphs"
 __github__ = "https://github.com/ArunKoundinya/py-flow-mapper"

{py_flow_mapper-0.1.0b7.dev0 → py_flow_mapper-0.1.0b9.dev0}/src/py_flow_mapper/analyzer.py

@@ -32,6 +32,7 @@ class FunctionInfo:
     docstring: Optional[str] = None
     return_assignments: Dict[str, List[str]] = field(default_factory=dict)  # {var_name: [called_functions]}
     call_arguments: Dict[str, List[str]] = field(default_factory=dict)
+    call_edges: List[Tuple[str, str, str]] = field(default_factory=list)
     
     def __post_init__(self):
         if self.decorators is None:
@@ -118,7 +119,7 @@ class ProjectAnalyzer:
             "site-packages", "node_modules", "bower_components",
             "docs", "doc", "site", "_site", "mkdocs",
             ".ipynb_checkpoints", "notebooks", "examples", "experiments", "scratch",
-            "data", "datasets", "models", "checkpoints", "outputs", "results",
+            "datasets", "models", "checkpoints", "outputs", "results",
             "logs", "tmp", "temp", "cache",
             ".idea", ".vscode", ".DS_Store", "__MACOSX",
             ".github", ".gitlab", ".circleci",
@@ -291,7 +292,8 @@ class ProjectAnalyzer:
                 'call_arguments': getattr(func, "call_arguments", {}),
                 'module': func.module,
                 'file_path': func.file_path,
-                'lineno': func.lineno
+                'lineno': func.lineno,
+                'call_edges': getattr(func, "call_edges", []),
             }
         
         # Data flow edges
@@ -304,6 +306,16 @@ class ProjectAnalyzer:
             }
             for edge in self.data_flow_edges
         ]
+
+        call_edges = []
+        seen = set()
+        for _, func in self.function_map.items():
+            for src, tgt, mod in getattr(func, "call_edges", []):
+                k = (src, tgt, mod)
+                if k in seen:
+                    continue
+                seen.add(k)
+                call_edges.append({"source": src, "target": tgt, "module": mod})
         
         metadata = {
             'project': {
@@ -321,6 +333,7 @@ class ProjectAnalyzer:
             },
             'function_map': function_map,
             'data_flow_edges': data_flow_edges,
+            'call_edges': call_edges,
             'call_graph': self._generate_call_graph_data(),
             'import_graph': self._generate_import_graph_data()
         }
@@ -429,6 +442,7 @@ class ModuleVisitor(ast.NodeVisitor):
             decorators=decorators,
             docstring=docstring,
             call_arguments=flow_analyzer.call_arguments,
+            call_edges=flow_analyzer.call_edges,
         )
         
         # Store return assignments for data flow analysis
@@ -518,43 +532,143 @@ class DataFlowAnalyzer(ast.NodeVisitor):
         self.return_assignments: Dict[str, List[str]] = {}  # var_name -> [called_functions]
         self.current_assignment = None
         self.call_arguments: Dict[str, List[str]] = {}
+        self.call_edges: List[Tuple[str, str, str]] = []
         
     def visit_Assign(self, node):
         """Track assignments of function return values."""
-        # Get the variable name being assigned to
-        if isinstance(node.targets[0], ast.Name):
+        if node.targets and isinstance(node.targets[0], ast.Name):
             var_name = node.targets[0].id
-            
-            # Check if the value is a function call
+
             if isinstance(node.value, ast.Call):
                 call_info = self._extract_call_info(node.value)
                 if call_info:
-                    self.calls.append(call_info['func_name'])
-                    if var_name not in self.return_assignments:
-                        self.return_assignments[var_name] = []
-                    self.return_assignments[var_name].append(call_info['func_name'])
-            
-            # Check if the value is a Name (could be a variable holding a return value)
+                    func_name = call_info["func_name"]
+
+                    if func_name not in self.calls:
+                        self.calls.append(func_name)
+                    self.return_assignments.setdefault(var_name, []).append(func_name)
+
             elif isinstance(node.value, ast.Name):
-                # Track variable assignments for data flow
                 pass
-        
+
         self.generic_visit(node)
     
     def visit_Call(self, node):
         call_info = self._extract_call_info(node)
         if call_info:
             func_name = call_info['func_name']
-            self.calls.append(func_name)
+            ## Avoid Duplicates
+            if func_name not in self.calls:
+                self.calls.append(func_name)
 
             arg_vars = []
             for arg in node.args:
                 if isinstance(arg, ast.Name):
                     arg_vars.append(arg.id)
 
+                elif isinstance(arg, ast.Constant):
+                    ## Added handling for string constants
+                    val = repr(arg.value) if isinstance(arg.value, str) else str(arg.value)
+                    arg_vars.append(val)
+
             if arg_vars:
+                # Record positional arguments
                 self.call_arguments.setdefault(func_name, []).extend(arg_vars)
 
+            ## Adding New Block for Keyword Arguments
+            for kwarg in node.keywords:
+                # Keyword arguments
+                if kwarg.arg is not None:
+                    # Regular kwarg case
+                    key = kwarg.arg 
+                    if isinstance(kwarg.value, ast.Name):
+                        val = kwarg.value.id
+
+                    elif isinstance(kwarg.value, ast.Constant):
+                        val = repr(kwarg.value.value) if isinstance(kwarg.value.value, str) else str(kwarg.value.value)
+
+                    elif isinstance(kwarg.value, ast.List):
+                        items = []
+                        mappings = []  # <-- NEW: for ColumnTransformer-style mapping
+                        payloads = []
+                        if kwarg.value.elts and all(isinstance(e, ast.Tuple) and len(e.elts) >= 2 for e in kwarg.value.elts):
+                            for e in kwarg.value.elts:
+                                payload = e.elts[1]
+                                if isinstance(payload, ast.Name):
+                                    payloads.append(payload.id)
+
+                        # If we successfully extracted payload names, store them and skip pretty string for this kwarg
+                        if payloads:
+                            self.call_arguments.setdefault(func_name, []).extend(payloads)
+                            continue
+
+                        for elt in kwarg.value.elts:
+                            if isinstance(elt, ast.Tuple) and len(elt.elts) >= 3:
+                                transformer_node = elt.elts[1]
+                                cols_node = elt.elts[2]
+
+                                transformer_name = None
+                                cols_name = None
+
+                                if isinstance(transformer_node, ast.Call):
+                                    ci = self._extract_call_info(transformer_node)
+                                    transformer_name = ci["func_name"] if ci else "<Call>"
+
+                                if isinstance(cols_node, ast.Name):
+                                    cols_name = cols_node.id
+                                elif isinstance(cols_node, ast.Constant):
+                                    cols_name = repr(cols_node.value) if isinstance(cols_node.value, str) else str(cols_node.value)
+
+                                if transformer_name and cols_name:
+                                    mappings.append({transformer_name: cols_name})
+                                    self.call_edges.append((func_name, transformer_name, self.module_name))
+
+                            # ---- your existing pretty rendering ----
+                            if isinstance(elt, ast.Tuple):
+                                parts = []
+                                for t in elt.elts:
+                                    if isinstance(t, ast.Name):
+                                        parts.append(t.id)
+                                    elif isinstance(t, ast.Constant):
+                                        parts.append(repr(t.value) if isinstance(t.value, str) else str(t.value))
+                                    elif isinstance(t, ast.Call):
+                                        ci = self._extract_call_info(t)
+                                        parts.append(ci["func_name"] if ci else "<Call>")
+                                    else:
+                                        parts.append(f"<{t.__class__.__name__}>")
+
+                                items.append("(" + ", ".join(parts) + ")")
+                            elif isinstance(elt, ast.Name):
+                                items.append(elt.id)
+                            elif isinstance(elt, ast.Constant):
+                                items.append(repr(elt.value) if isinstance(elt.value, str) else str(elt.value))
+                            else:
+                                items.append(f"<{elt.__class__.__name__}>")
+
+                        val = "[" + ", ".join(items) + "]"
+
+                        # Store BOTH mapping dict(s) and the pretty string, under the same outer function call
+                        if mappings:
+                            self.call_arguments.setdefault(func_name, []).extend(mappings)
+                        self.call_arguments.setdefault(func_name, []).append(f"{key}={val}")
+                        continue
+
+                    else:
+                        val = f"<{kwarg.value.__class__.__name__}>"
+
+                    self.call_arguments.setdefault(func_name, []).append(f"{key}={val}")
+
+                else:
+                    # **kwargs case
+                    if isinstance(kwarg.value, ast.Name):
+                        self.call_arguments.setdefault(func_name, []).append(f"**{kwarg.value.id}")
+                    elif isinstance(kwarg.value, ast.Constant):
+                        val = repr(kwarg.value.value) if isinstance(kwarg.value.value, str) else str(kwarg.value.value)
+                        self.call_arguments.setdefault(func_name, []).append(f"**={val}")
+
+                    else:
+                        self.call_arguments.setdefault(func_name, []).append(f"**=<${kwarg.value.__class__.__name__}>")
+
         self.generic_visit(node)
 
     

{py_flow_mapper-0.1.0b7.dev0 → py_flow_mapper-0.1.0b9.dev0}/src/py_flow_mapper/mermaid_generator.py

@@ -71,23 +71,16 @@ class MermaidGenerator:
                 return ""
             return ",".join(sorted(set(cleaned)))
         
-        current_module_ctx = ""
 
-        def module_import_mapping() -> dict:
-            return (modules.get(current_module_ctx, {}) or {}).get("import_mapping", {}) or {}
+        def module_import_mapping(mod: str) -> dict:
+            return (modules.get(mod, {}) or {}).get("import_mapping", {}) or {}
 
-        def external_root_name(call_name: str) -> str:
+        def external_root_name(call_name: str, current_module: str) -> str:
             if not call_name:
                 return ""
-
             root = call_name.split(".")[0]
-
-            # module-specific import mapping (from analyzer)
-            imp_map = module_import_mapping() or {}
-
-            # merge common aliases (module imports override defaults)
+            imp_map = module_import_mapping(current_module)
             merged_map = {**COMMON_ALIAS_MAP, **imp_map}
-
             return merged_map.get(root, root)
 
         # Keep the graph clean: ignore common builtins + attribute-noise
@@ -99,52 +92,74 @@ class MermaidGenerator:
             "Path",
         }
 
-        def keep_external(call_name: str) -> bool:
+        def keep_external(call_name: str, current_module: str) -> bool:
             if not call_name:
                 return False
 
             base = short_label(call_name)
 
-            # forced external always wins
-            root = external_root_name(call_name)
+            root = external_root_name(call_name, current_module)
             if root and root in self.force_external:
                 return True
             if base in self.force_external:
                 return True
 
-            # ✅ NEW: module-specific import mapping
-            imp_map = module_import_mapping() or {}
+            imp_map = module_import_mapping(current_module)
             if base in imp_map:
                 mapped = imp_map[base]
                 mapped_module = ".".join(mapped.split(".")[:-1])
-
                 if mapped_module in modules:
                     return False
-
                 return True
 
-            # internal class => NOT external
             if base in internal_classes:
                 return False
 
             if base in NOISY_EXTERNAL:
                 return False
 
-            # dotted calls like obj.method: too noisy at this level
             if "." in call_name:
                 return False
 
-            # keep CamelCase (tool-ish classes / constructors)
             return is_camel_case(base)
 
         def resolve_internal(call: str, current_module: str) -> str:
-            # First try your normal resolver
+            call = call or ""
+
+            # 1) existing resolver
             target = self._find_function_full_name(call, current_module)
             if target and target in internal_funcs:
                 return target
 
-            # ✅ NEW: if call is like "obj.method", try to map by method name
-            if "." in (call or ""):
+            imp_map = module_import_mapping(current_module)
+
+            # 2) If call is a bare name imported via "from X import name"
+            # import_mapping might contain:  name -> "pkg.mod.name"
+            if call in imp_map:
+                mapped = imp_map[call]
+                if mapped in internal_funcs:
+                    return mapped
+                # if mapped is "pkg.mod.name", try resolving it (or its tail)
+                target = self._find_function_full_name(mapped, current_module)
+                if target and target in internal_funcs:
+                    return target
+
+            # 3) If call is "alias.something", rewrite alias using import_mapping
+            # import_mapping might contain: alias -> "pkg.mod"
+            if "." in call:
+                root, rest = call.split(".", 1)
+                if root in imp_map:
+                    mapped_root = imp_map[root]
+                    # If mapping is to a specific object like "pkg.mod.func",
+                    # treat it as root too (best-effort)
+                    candidate = f"{mapped_root}.{rest}"
+                    if candidate in internal_funcs:
+                        return candidate
+                    target = self._find_function_full_name(candidate, current_module)
+                    if target and target in internal_funcs:
+                        return target
+
+                # 4) your existing "obj.method" heuristic
                 method = call.split(".")[-1]
                 matches = [k for k in internal_funcs if k.endswith("." + method)]
                 if len(matches) == 1:
@@ -159,7 +174,7 @@ class MermaidGenerator:
 
         def is_fileish_arg(arg: str) -> bool:
             a = (arg or "").lower()
-            return any(k in a for k in ("meta", "json", "yaml", "yml", "config", "path", "file"))
+            return any(k in a for k in ("meta", "json", "yaml", "yml", "config", "file", ".json", ".yaml", ".yml", ".cfg", ".ini", ".txt", ".csv")) 
 
         def ordered_functions_from_entry(entry_key: str) -> list[str]:
             """DFS from entry, preserving call order from metadata."""
@@ -174,7 +189,7 @@ class MermaidGenerator:
 
                 info = function_map.get(fn_key, {})
                 current_module = info.get("module", "") or ""
-                current_module_ctx = current_module
+                #current_module_ctx = current_module
                 for c in (info.get("calls") or []):
                     target = self._find_function_full_name(c, current_module)
                     if target and target in function_map:
@@ -210,15 +225,15 @@ class MermaidGenerator:
 
         for _, info in function_map.items():
             current_module = info.get("module", "") or ""
-            current_module_ctx = current_module
+            #current_module_ctx = current_module
 
             # prefer call_arguments keys
             call_args = info.get("call_arguments", {}) or {}
             for callee in call_args.keys():
                 if resolve_internal(callee, current_module):
                     continue
-                if keep_external(callee):
-                    external_nodes.add(external_root_name(callee) or callee)
+                if keep_external(callee, current_module):
+                    external_nodes.add(external_root_name(callee, current_module) or callee)
 
             # scan raw calls for Done + missed externals
             for callee in (info.get("calls") or []):
@@ -227,8 +242,8 @@ class MermaidGenerator:
 
                 if resolve_internal(callee, current_module):
                     continue
-                if keep_external(callee):
-                    external_nodes.add(external_root_name(callee) or callee)
+                if keep_external(callee, current_module):
+                    external_nodes.add(external_root_name(callee, current_module) or callee)
 
         if external_nodes or uses_done:
             lines.append("    subgraph External [External]")
@@ -238,6 +253,37 @@ class MermaidGenerator:
                 lines.append("        Done((Done))")
             lines.append("    end")
 
+            # ---- External composition edges (e.g., ColumnTransformer -> OneHotEncoder) ----
+            extra_call_edges = self.metadata.get("call_edges", []) or []
+            extra_seen = set()
+
+            for e in extra_call_edges:
+                src_call = e.get("source") or ""
+                tgt_call = e.get("target") or ""
+                mod = e.get("module") or ""
+
+                if not src_call or not tgt_call:
+                    continue
+
+                # Keep only external-resolved calls in this module context
+                if not keep_external(src_call, mod):
+                    continue
+                if not keep_external(tgt_call, mod):
+                    continue
+
+                src_ext = external_root_name(src_call, mod) or src_call
+                tgt_ext = external_root_name(tgt_call, mod) or tgt_call
+
+                # Only draw if the target/source nodes exist in the External subgraph set
+                if src_ext not in external_nodes or tgt_ext not in external_nodes:
+                    continue
+
+                k = (src_ext, tgt_ext)
+                if k in extra_seen:
+                    continue
+                extra_seen.add(k)
+
+                lines.append(f"    {nid('ext:' + src_ext)} --> {nid('ext:' + tgt_ext)}")
         # ---------- call edges (internal -> internal/external), ordered from entry ----------
         caller_order = ordered_functions_from_entry("main.main")
 
@@ -247,16 +293,48 @@ class MermaidGenerator:
 
             info = function_map[caller]
             current_module = info.get("module", "") or ""
-            current_module_ctx = current_module
+            #current_module_ctx = current_module
             src = nid(caller)
 
             call_args = info.get("call_arguments", {}) or {}
             seen = set()
 
+            extra_call_edges = self.metadata.get("call_edges", []) or []
+
+            caller_external_roots = set()
+            for c in (info.get("calls") or []):
+                if keep_external(c, current_module) and not resolve_internal(c, current_module):
+                    caller_external_roots.add(external_root_name(c, current_module) or c)
+
+            suppressed_external_roots = set()
+            for e in extra_call_edges:
+                src_call = e.get("source") or ""
+                tgt_call = e.get("target") or ""
+                mod = e.get("module") or ""
+
+                if not src_call or not tgt_call:
+                    continue
+
+                # apply only when edge was discovered in same module context
+                if mod and mod != current_module:
+                    continue
+
+                src_root = external_root_name(src_call, current_module) or src_call
+                tgt_root = external_root_name(tgt_call, current_module) or tgt_call
+
+                if src_root in caller_external_roots:
+                    suppressed_external_roots.add(tgt_root)
+
+
             for callee in (info.get("calls") or []):
                 if not callee:
                     continue
 
+                if keep_external(callee, current_module) and not resolve_internal(callee, current_module):
+                    callee_root = external_root_name(callee, current_module) or callee
+                    if callee_root in suppressed_external_roots:
+                        continue
+
                 target_internal = resolve_internal(callee, current_module)
 
                 # label (if any)
@@ -274,8 +352,8 @@ class MermaidGenerator:
                     else:
                         lines.append(f"    {src} --> {nid(target_internal)}")
                 else:
-                    if keep_external(callee):
-                        ext = external_root_name(callee) or callee
+                    if keep_external(callee, current_module):
+                        ext = external_root_name(callee, current_module) or callee
                         edge_key = (src, nid("ext:" + callee), label)
                         if edge_key in seen:
                             continue
@@ -294,7 +372,7 @@ class MermaidGenerator:
             info = function_map[fn]
             dst = nid(fn)
             current_module = info.get("module", "") or ""
-            current_module_ctx = current_module
+            #current_module_ctx = current_module
 
             return_assignments = info.get("return_assignments", {}) or {}
             for var_name, producers in return_assignments.items():
@@ -303,20 +381,20 @@ class MermaidGenerator:
                     if internal_p:
                         lines.append(f"    {nid(internal_p)} -.->|{var_name}| {dst}")
                     else:
-                        if keep_external(p):
-                            ext = external_root_name(p) or p
+                        if keep_external(p, current_module):
+                            ext = external_root_name(p,current_module) or p
                             lines.append(f"    {nid('ext:' + ext)} -.->|{var_name}| {dst}")
 
         # ---------- pipeline heuristic: external tool A -> external tool B ----------
         for _, info in function_map.items():
             current_module = info.get("module", "") or ""
-            current_module_ctx = current_module
+            #current_module_ctx = current_module
             calls = info.get("calls") or []
             call_args = info.get("call_arguments") or {}
 
             meaningful = []
             for c in calls:
-                if c and keep_external(c) and not resolve_internal(c, current_module):
+                if c and keep_external(c,current_module) and not resolve_internal(c, current_module):
                     if c not in meaningful:
                         meaningful.append(c)
 
@@ -325,7 +403,7 @@ class MermaidGenerator:
 
             fileish_callee = None
             for callee, args in call_args.items():
-                if keep_external(callee) and any(is_fileish_arg(a) for a in (args or []) if isinstance(a, str)):
+                if keep_external(callee, current_module) and any(is_fileish_arg(a) for a in (args or []) if isinstance(a, str)):
                     fileish_callee = callee
                     break
 
@@ -338,8 +416,8 @@ class MermaidGenerator:
 
             vars_passed = call_args.get(fileish_callee, []) or []
             label = normalize_vars(vars_passed) or "value"
-            prod_ext = external_root_name(producer) or producer
-            file_ext = external_root_name(fileish_callee) or fileish_callee
+            prod_ext = external_root_name(producer,current_module) or producer
+            file_ext = external_root_name(fileish_callee,current_module) or fileish_callee
             lines.append(f"    {nid('ext:' + prod_ext)} -->|{label}| {nid('ext:' + file_ext)}")
 
         # ---------- Done edge ----------

{py_flow_mapper-0.1.0b7.dev0 → py_flow_mapper-0.1.0b9.dev0/src/py_flow_mapper.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-flow-mapper
-Version: 0.1.0b7.dev0
+Version: 0.1.0b9.dev0
 Summary: Python project analyzer and visualization tool
 Home-page: https://github.com/ArunKoundinya/py-flow-mapper
 Author: Arun Koundinya Parasa