sql-glider 0.1.24__py3-none-any.whl → 0.1.26__py3-none-any.whl

{sql_glider-0.1.24.dist-info → sql_glider-0.1.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-glider
-Version: 0.1.24
+Version: 0.1.26
 Summary: SQL Utility Toolkit for better understanding, use, and governance of your queries in a native environment.
 Project-URL: Homepage, https://github.com/rycowhi/sql-glider/
 Project-URL: Repository, https://github.com/rycowhi/sql-glider/

{sql_glider-0.1.24.dist-info → sql_glider-0.1.26.dist-info}/RECORD

@@ -1,6 +1,6 @@
 sqlglider/__init__.py,sha256=gDf7s52dMcX7JuCZ1SLawcB1vb3U0yJCohu9RQAATBY,125
-sqlglider/_version.py,sha256=IV4a2R7tlzuACf6FAyPEbprLKNroeE-n_UPSKi1QJSc,706
-sqlglider/cli.py,sha256=oML-M3PW8Cjddii4_Tx_tfYAxYh6Q-inU4eehx0gzC0,69570
+sqlglider/_version.py,sha256=Y9o7KiJWiG6n9XbSpMICgNgajFRbL4an-gN1BQc-jwM,706
+sqlglider/cli.py,sha256=If-USLXwbTcP_ehacyPcahD5aygmkqI9ycxJDqIpalg,69701
 sqlglider/global_models.py,sha256=2vyJXAuXOsXQpE-D3F0ejj7eR9z0nDWFjTkielhzM8k,356
 sqlglider/catalog/__init__.py,sha256=2PqFPyzFXJ14FpSUcBmVK2L-a_ypWQHAbHFHxLDk_LE,814
 sqlglider/catalog/base.py,sha256=R7htHC43InpH4uRjYk33dMYYji6oylHns7Ye_mgfjJE,3116
@@ -12,7 +12,7 @@ sqlglider/dissection/formatters.py,sha256=M7gsmTNljRIeLIRv4D0vHvqJVrTqWSpsg7vem8
 sqlglider/dissection/models.py,sha256=RRD3RIteqbUBY6e-74skKDvMH3qeAUaqA2sFcrjP5GQ,3618
 sqlglider/graph/__init__.py,sha256=4DDdrPM75CmeQWt7wHdBsjCm1s70BHGLYdijIbaUEKY,871
 sqlglider/graph/builder.py,sha256=VNBdsDlkiaId3JGvr2G4h6OIFek_9zPsGMIYL9GpJlk,15796
-sqlglider/graph/diagram_formatters.py,sha256=6EdNwU23k4CL3hSBtM1lgZ5Gyc95o7vUMRdQa-a1Fko,22021
+sqlglider/graph/diagram_formatters.py,sha256=S8K0pjSzRTcwT1yi7QJUP1gdfPR2p3Om93bVdtJZuxA,26465
 sqlglider/graph/formatters.py,sha256=p85-WN9oPmEETsAtWSo1sIQELF36w85QoFEJyfBZGoM,4800
 sqlglider/graph/merge.py,sha256=uUZlm4BN3S9gRL66Cc2mzhbtuh4SVAv2n4cN4eUEQBU,4077
 sqlglider/graph/models.py,sha256=EYmjv_WzDSNp_WfhJ6H-qBIOkAcoNKS7GRUryfKrHuY,9330
@@ -32,8 +32,8 @@ sqlglider/utils/__init__.py,sha256=KGp9-UzKz_OFBOTFoSy-g-NXDZsvyWXG_9-1zcC6ePE,2
 sqlglider/utils/config.py,sha256=qx5zE9pjLCCzHQDFVPLVd7LgJ-lghxUa2x-aZOAHByY,4962
 sqlglider/utils/file_utils.py,sha256=5_ff28E0r1R7emZzsOnRuHd-7zIX6873eyr1SuPEr4E,1093
 sqlglider/utils/schema.py,sha256=LiWrYDunXKJdoSlpKmIaIQ2hLSaIN1iQHqkXjMpGzRE,1883
-sql_glider-0.1.24.dist-info/METADATA,sha256=5giBXU7edyyoMBfbFVficYatA60-To2D_P3eMc6PdQQ,31197
-sql_glider-0.1.24.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sql_glider-0.1.24.dist-info/entry_points.txt,sha256=HDuakHqHS5C0HFKsMIxMYmDU7-BLBGrnIJcYaVRu-s0,251
-sql_glider-0.1.24.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sql_glider-0.1.24.dist-info/RECORD,,
+sql_glider-0.1.26.dist-info/METADATA,sha256=xgItNGWc-KIxIsKFKj-sC6Dl1rCPuMuEyzk7XeDi2a4,31197
+sql_glider-0.1.26.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sql_glider-0.1.26.dist-info/entry_points.txt,sha256=HDuakHqHS5C0HFKsMIxMYmDU7-BLBGrnIJcYaVRu-s0,251
+sql_glider-0.1.26.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sql_glider-0.1.26.dist-info/RECORD,,

sqlglider/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.1.24'
-__version_tuple__ = version_tuple = (0, 1, 24)
+__version__ = version = '0.1.26'
+__version_tuple__ = version_tuple = (0, 1, 26)
 
 __commit_id__ = commit_id = None

sqlglider/cli.py

@@ -1715,11 +1715,15 @@ def graph_query(
         elif output_format == "mermaid":
             from sqlglider.graph.diagram_formatters import MermaidFormatter
 
-            print(MermaidFormatter.format_query_result(result))
+            print(MermaidFormatter.format_query_result(result, graph=querier.graph))
         elif output_format == "mermaid-markdown":
             from sqlglider.graph.diagram_formatters import MermaidMarkdownFormatter
 
-            print(MermaidMarkdownFormatter.format_query_result(result))
+            print(
+                MermaidMarkdownFormatter.format_query_result(
+                    result, graph=querier.graph
+                )
+            )
         elif output_format == "dot":
             from sqlglider.graph.diagram_formatters import DotFormatter
 
@@ -1727,7 +1731,7 @@ def graph_query(
         elif output_format == "plotly":
             from sqlglider.graph.diagram_formatters import PlotlyFormatter
 
-            print(PlotlyFormatter.format_query_result(result))
+            print(PlotlyFormatter.format_query_result(result, graph=querier.graph))
 
     except ImportError as e:
         err_console.print(f"[red]Error:[/red] {e}")

sqlglider/graph/diagram_formatters.py

@@ -3,7 +3,7 @@
 import json
 import re
 from collections import defaultdict
-from typing import Any, Set
+from typing import Any, Optional, Set
 
 from sqlglider.graph.models import LineageGraph
 from sqlglider.graph.query import LineageQueryResult
@@ -102,16 +102,26 @@ class MermaidFormatter:
             node_id = _sanitize_mermaid_id(node.identifier)
             lines.append(f'    {node_id}["{node.identifier}"]')
 
-        # Add edges
+        # Add edges with file path labels
         for edge in graph.edges:
             src = _sanitize_mermaid_id(edge.source_node)
             tgt = _sanitize_mermaid_id(edge.target_node)
-            lines.append(f"    {src} --> {tgt}")
+            # Extract filename from path
+            file_name = (
+                edge.file_path.split("/")[-1].split("\\")[-1] if edge.file_path else ""
+            )
+            if file_name:
+                lines.append(f"    {src} -->|{file_name}| {tgt}")
+            else:
+                lines.append(f"    {src} --> {tgt}")
 
         return "\n".join(lines)
 
     @staticmethod
-    def format_query_result(result: LineageQueryResult) -> str:
+    def format_query_result(
+        result: LineageQueryResult,
+        graph: Optional[LineageGraph] = None,
+    ) -> str:
         """Format query result as a Mermaid flowchart with styling.
 
         The queried column is highlighted in amber, root nodes in teal,
@@ -119,6 +129,7 @@ class MermaidFormatter:
 
         Args:
             result: LineageQueryResult from upstream/downstream query
+            graph: Optional LineageGraph for edge file path labels
 
         Returns:
             Mermaid diagram string with style directives and legend
@@ -134,16 +145,27 @@ class MermaidFormatter:
         all_nodes = _collect_query_nodes(result)
         edges = _collect_query_edges(result)
 
+        # Build edge file path lookup if graph is provided
+        edge_file_paths: dict[tuple[str, str], str] = {}
+        if graph:
+            for e in graph.edges:
+                edge_file_paths[(e.source_node, e.target_node)] = e.file_path
+
         # Declare nodes
         for identifier in sorted(all_nodes):
             node_id = _sanitize_mermaid_id(identifier)
             lines.append(f'    {node_id}["{identifier}"]')
 
-        # Add edges
+        # Add edges with optional file path labels
         for src, tgt in sorted(edges):
-            lines.append(
-                f"    {_sanitize_mermaid_id(src)} --> {_sanitize_mermaid_id(tgt)}"
-            )
+            src_id = _sanitize_mermaid_id(src)
+            tgt_id = _sanitize_mermaid_id(tgt)
+            file_path = edge_file_paths.get((src, tgt), "")
+            file_name = file_path.split("/")[-1].split("\\")[-1] if file_path else ""
+            if file_name:
+                lines.append(f"    {src_id} -->|{file_name}| {tgt_id}")
+            else:
+                lines.append(f"    {src_id} --> {tgt_id}")
 
         # Style directives
         queried_id = _sanitize_mermaid_id(result.query_column)
@@ -200,16 +222,20 @@ class MermaidMarkdownFormatter:
         return f"```mermaid\n{mermaid}\n```"
 
     @staticmethod
-    def format_query_result(result: LineageQueryResult) -> str:
+    def format_query_result(
+        result: LineageQueryResult,
+        graph: Optional[LineageGraph] = None,
+    ) -> str:
         """Format query result as a Mermaid diagram in a markdown code block.
 
         Args:
             result: LineageQueryResult from upstream/downstream query
+            graph: Optional LineageGraph for edge file path labels
 
         Returns:
             Markdown string with fenced Mermaid diagram
         """
-        mermaid = MermaidFormatter.format_query_result(result)
+        mermaid = MermaidFormatter.format_query_result(result, graph=graph)
         return f"```mermaid\n{mermaid}\n```"
 
 
@@ -335,6 +361,8 @@ class DotFormatter:
 def _compute_layered_layout(
     nodes: list[str],
     edges: list[tuple[str, str]],
+    x_spacing: float = 250.0,
+    y_spacing: float = 100.0,
 ) -> dict[str, tuple[float, float]]:
     """Compute layered layout positions for nodes using topological ordering.
 
@@ -345,6 +373,8 @@ def _compute_layered_layout(
     Args:
         nodes: List of node identifiers
         edges: List of (source, target) edge tuples
+        x_spacing: Horizontal spacing between layers (default: 250 pixels)
+        y_spacing: Vertical spacing between nodes in the same layer (default: 100 pixels)
 
     Returns:
         Dictionary mapping node identifiers to (x, y) positions
@@ -395,15 +425,13 @@ def _compute_layered_layout(
 
     # Compute positions: x based on layer, y spread vertically within layer
     positions: dict[str, tuple[float, float]] = {}
-    max_layer = max(layers.values()) if layers else 0
-    x_spacing = 1.0 if max_layer == 0 else 1.0
 
     for layer, layer_nodes in layer_groups.items():
         x = layer * x_spacing
         n = len(layer_nodes)
         for i, node in enumerate(sorted(layer_nodes)):
-            # Center nodes vertically, spread them out
-            y = (i - (n - 1) / 2) * 0.5
+            # Center nodes vertically, spread them out uniformly
+            y = (i - (n - 1) / 2) * y_spacing
             positions[node] = (x, y)
 
     return positions
@@ -444,6 +472,11 @@ class PlotlyFormatter:
         node_ids = [n.identifier for n in graph.nodes]
         edge_tuples = [(e.source_node, e.target_node) for e in graph.edges]
 
+        # Build lookup for edge file paths
+        edge_file_paths: dict[tuple[str, str], str] = {}
+        for e in graph.edges:
+            edge_file_paths[(e.source_node, e.target_node)] = e.file_path
+
         if not node_ids:
             # Empty graph
             figure: dict[str, Any] = {
@@ -459,24 +492,46 @@ class PlotlyFormatter:
 
         positions = _compute_layered_layout(node_ids, edge_tuples)
 
-        # Build edge traces (one trace per edge for simplicity)
+        # Build edge traces with hover text for file path
         edge_traces: list[dict[str, Any]] = []
+        edge_annotations: list[dict[str, Any]] = []
         for src, tgt in edge_tuples:
             if src in positions and tgt in positions:
                 x0, y0 = positions[src]
                 x1, y1 = positions[tgt]
+                file_path = edge_file_paths.get((src, tgt), "")
+                # Extract just the filename for display
+                file_name = (
+                    file_path.split("/")[-1].split("\\")[-1] if file_path else ""
+                )
+
                 edge_traces.append(
                     {
                         "type": "scatter",
                         "x": [x0, x1, None],
                         "y": [y0, y1, None],
                         "mode": "lines",
-                        "line": {"width": 1, "color": "#888"},
-                        "hoverinfo": "none",
+                        "line": {"width": 1.5, "color": "#888"},
+                        "hoverinfo": "text",
+                        "hovertext": file_path,
                         "showlegend": False,
                     }
                 )
 
+                # Add annotation at midpoint of edge
+                mid_x = (x0 + x1) / 2
+                mid_y = (y0 + y1) / 2
+                edge_annotations.append(
+                    {
+                        "x": mid_x,
+                        "y": mid_y,
+                        "text": file_name,
+                        "showarrow": False,
+                        "font": {"size": 9, "color": "#666"},
+                        "bgcolor": "rgba(255,255,255,0.8)",
+                    }
+                )
+
         # Build node trace
         node_x = [positions[n][0] for n in node_ids if n in positions]
         node_y = [positions[n][1] for n in node_ids if n in positions]
@@ -489,15 +544,21 @@ class PlotlyFormatter:
             "mode": "markers+text",
             "text": node_text,
             "textposition": "top center",
+            "textfont": {"size": 11},
             "hoverinfo": "text",
             "marker": {
-                "size": 20,
+                "size": 15,
                 "color": "#6495ED",
                 "line": {"width": 2, "color": "#4169E1"},
             },
             "showlegend": False,
         }
 
+        # Calculate figure dimensions based on graph size
+        min_height = 400
+        height_per_node = 50
+        calculated_height = max(min_height, len(node_ids) * height_per_node)
+
         figure = {
             "data": edge_traces + [node_trace],
             "layout": {
@@ -506,14 +567,19 @@ class PlotlyFormatter:
                 "hovermode": "closest",
                 "xaxis": {"visible": False},
                 "yaxis": {"visible": False},
-                "margin": {"l": 40, "r": 40, "t": 60, "b": 40},
+                "height": calculated_height,
+                "margin": {"l": 50, "r": 50, "t": 60, "b": 40},
+                "annotations": edge_annotations,
             },
         }
 
         return json.dumps(figure, indent=2)
 
     @staticmethod
-    def format_query_result(result: LineageQueryResult) -> str:
+    def format_query_result(
+        result: LineageQueryResult,
+        graph: Optional[LineageGraph] = None,
+    ) -> str:
         """Format query result as a Plotly JSON figure with styling.
 
         The queried column is highlighted in amber, root nodes in teal,
@@ -521,6 +587,7 @@ class PlotlyFormatter:
 
         Args:
             result: LineageQueryResult from upstream/downstream query
+            graph: Optional LineageGraph for edge file path labels
 
         Returns:
             JSON string representing a Plotly figure specification
@@ -530,6 +597,12 @@ class PlotlyFormatter:
         all_nodes = _collect_query_nodes(result)
         edges = _collect_query_edges(result)
 
+        # Build edge file path lookup if graph is provided
+        edge_file_paths: dict[tuple[str, str], str] = {}
+        if graph:
+            for e in graph.edges:
+                edge_file_paths[(e.source_node, e.target_node)] = e.file_path
+
         if not all_nodes:
             # Should not happen, but handle gracefully
             figure: dict[str, Any] = {
@@ -568,12 +641,18 @@ class PlotlyFormatter:
             else:
                 node_colors.append("#6495ED")  # Default blue
 
-        # Build edge traces
+        # Build edge traces with optional file path labels
         edge_traces: list[dict[str, Any]] = []
+        edge_annotations: list[dict[str, Any]] = []
         for src, tgt in sorted(edges):
             if src in positions and tgt in positions:
                 x0, y0 = positions[src]
                 x1, y1 = positions[tgt]
+                file_path = edge_file_paths.get((src, tgt), "")
+                file_name = (
+                    file_path.split("/")[-1].split("\\")[-1] if file_path else ""
+                )
+
                 edge_traces.append(
                     {
                         "type": "scatter",
@@ -581,11 +660,27 @@ class PlotlyFormatter:
                         "y": [y0, y1, None],
                         "mode": "lines",
                         "line": {"width": 1.5, "color": "#888"},
-                        "hoverinfo": "none",
+                        "hoverinfo": "text" if file_path else "none",
+                        "hovertext": file_path if file_path else None,
                         "showlegend": False,
                     }
                 )
 
+                # Add annotation at midpoint of edge if we have file path info
+                if file_name:
+                    mid_x = (x0 + x1) / 2
+                    mid_y = (y0 + y1) / 2
+                    edge_annotations.append(
+                        {
+                            "x": mid_x,
+                            "y": mid_y,
+                            "text": file_name,
+                            "showarrow": False,
+                            "font": {"size": 9, "color": "#666"},
+                            "bgcolor": "rgba(255,255,255,0.8)",
+                        }
+                    )
+
         # Build node trace
         node_x = [positions[n][0] for n in node_list if n in positions]
         node_y = [positions[n][1] for n in node_list if n in positions]
@@ -597,9 +692,10 @@ class PlotlyFormatter:
             "mode": "markers+text",
             "text": node_list,
             "textposition": "top center",
+            "textfont": {"size": 11},
             "hoverinfo": "text",
             "marker": {
-                "size": 20,
+                "size": 15,
                 "color": node_colors,
                 "line": {"width": 2, "color": "#333"},
             },
@@ -637,22 +733,32 @@ class PlotlyFormatter:
             },
         ]
 
-        direction_label = (
-            "Upstream" if result.direction == "upstream" else "Downstream"
-        )
+        direction_label = "Upstream" if result.direction == "upstream" else "Downstream"
         title = f"{direction_label} Lineage: {result.query_column}"
 
+        # Calculate figure dimensions based on graph size
+        min_height = 400
+        height_per_node = 50
+        calculated_height = max(min_height, len(node_list) * height_per_node)
+
+        layout: dict[str, Any] = {
+            "title": {"text": title},
+            "showlegend": True,
+            "legend": {"x": 1, "y": 1, "xanchor": "right"},
+            "hovermode": "closest",
+            "xaxis": {"visible": False},
+            "yaxis": {"visible": False},
+            "height": calculated_height,
+            "margin": {"l": 50, "r": 50, "t": 60, "b": 40},
+        }
+
+        # Add edge annotations if we have file path info
+        if edge_annotations:
+            layout["annotations"] = edge_annotations
+
         figure = {
             "data": edge_traces + [node_trace] + legend_traces,
-            "layout": {
-                "title": {"text": title},
-                "showlegend": True,
-                "legend": {"x": 1, "y": 1, "xanchor": "right"},
-                "hovermode": "closest",
-                "xaxis": {"visible": False},
-                "yaxis": {"visible": False},
-                "margin": {"l": 40, "r": 40, "t": 60, "b": 40},
-            },
+            "layout": layout,
         }
 
         return json.dumps(figure, indent=2)