sql-glider 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

{sql_glider-0.1.25.dist-info → sql_glider-0.1.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sql-glider
-Version: 0.1.25
+Version: 0.1.27
 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/
@@ -30,6 +30,7 @@ Provides-Extra: databricks
 Requires-Dist: databricks-sdk>=0.20.0; extra == 'databricks'
 Provides-Extra: plotly
 Requires-Dist: plotly>=5.0.0; extra == 'plotly'
+Requires-Dist: pygraphviz>=1.11; extra == 'plotly'
 Description-Content-Type: text/markdown
 
 # SQL Glider

{sql_glider-0.1.25.dist-info → sql_glider-0.1.27.dist-info}/RECORD

@@ -1,6 +1,6 @@
 sqlglider/__init__.py,sha256=gDf7s52dMcX7JuCZ1SLawcB1vb3U0yJCohu9RQAATBY,125
-sqlglider/_version.py,sha256=VIORluFSyo8DggJNI3m2ltXngK-bmCHX8hSwlGrwopY,706
-sqlglider/cli.py,sha256=h0dAx-Dz_LkSfrWlxD8wU_G2WzWqzn14EjHAwajWVyQ,69591
+sqlglider/_version.py,sha256=o2dyLbB_Uhc2yY2R7iheES_lRnDBGV9Hc4iNgiJ_XTo,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=-7BFG3z4EZrmiwnOAco-R-Axs5OL57ytMXGHuTh0z68,25321
+sqlglider/graph/diagram_formatters.py,sha256=Qibe8GSnDyco5YqAms0nRXxuveA1PnWwHa8MV5FgvOA,29328
 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.25.dist-info/METADATA,sha256=qCGtZ5ROBNQbi-9NDmWUNdf9WtIG9NQoEVrplFzXsxs,31197
-sql_glider-0.1.25.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sql_glider-0.1.25.dist-info/entry_points.txt,sha256=HDuakHqHS5C0HFKsMIxMYmDU7-BLBGrnIJcYaVRu-s0,251
-sql_glider-0.1.25.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sql_glider-0.1.25.dist-info/RECORD,,
+sql_glider-0.1.27.dist-info/METADATA,sha256=rq45QV36gpouCXs42p2-kgpArng9wSmX2EuNT2tVRTs,31248
+sql_glider-0.1.27.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sql_glider-0.1.27.dist-info/entry_points.txt,sha256=HDuakHqHS5C0HFKsMIxMYmDU7-BLBGrnIJcYaVRu-s0,251
+sql_glider-0.1.27.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sql_glider-0.1.27.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.25'
-__version_tuple__ = version_tuple = (0, 1, 25)
+__version__ = version = '0.1.27'
+__version_tuple__ = version_tuple = (0, 1, 27)
 
 __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
 

sqlglider/graph/diagram_formatters.py

@@ -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```"
 
 
@@ -338,7 +364,11 @@ def _compute_layered_layout(
     x_spacing: float = 250.0,
     y_spacing: float = 100.0,
 ) -> dict[str, tuple[float, float]]:
-    """Compute layered layout positions for nodes using topological ordering.
+    """Compute layered layout positions for nodes using Graphviz's dot algorithm.
+
+    Uses Graphviz's dot layout engine (Sugiyama algorithm) which minimizes edge
+    crossings by using the barycenter heuristic to optimize node ordering within
+    each layer.
 
     Positions nodes in layers from left to right based on their dependencies.
     Nodes with no incoming edges are placed in layer 0, their dependents in
@@ -356,6 +386,89 @@ def _compute_layered_layout(
     if not nodes:
         return {}
 
+    try:
+        import pygraphviz  # noqa: F401  # type: ignore[import-not-found]
+
+        return _compute_graphviz_layout(nodes, edges, x_spacing, y_spacing)
+    except ImportError:
+        # Fallback to simple layered layout if pygraphviz not available
+        return _compute_simple_layered_layout(nodes, edges, x_spacing, y_spacing)
+
+
+def _compute_graphviz_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 layout using Graphviz's dot algorithm with crossing minimization.
+
+    Args:
+        nodes: List of node identifiers
+        edges: List of (source, target) edge tuples
+        x_spacing: Horizontal spacing between layers
+        y_spacing: Vertical spacing between nodes in the same layer
+
+    Returns:
+        Dictionary mapping node identifiers to (x, y) positions
+    """
+    import pygraphviz as pgv  # type: ignore[import-not-found]
+
+    # Create directed graph
+    g = pgv.AGraph(directed=True, rankdir="LR")
+
+    # Set graph attributes for spacing
+    g.graph_attr["ranksep"] = str(x_spacing / 72.0)  # Convert pixels to inches
+    g.graph_attr["nodesep"] = str(y_spacing / 72.0)
+
+    # Add nodes
+    for node in nodes:
+        g.add_node(node)
+
+    # Add edges (only for nodes that exist in our node list)
+    node_set = set(nodes)
+    for src, tgt in edges:
+        if src in node_set and tgt in node_set:
+            g.add_edge(src, tgt)
+
+    # Compute layout using dot algorithm
+    g.layout(prog="dot")
+
+    # Extract positions
+    positions: dict[str, tuple[float, float]] = {}
+    for node in nodes:
+        n = g.get_node(node)
+        # Position is returned as "x,y" string in points (1/72 inch)
+        pos_str = n.attr.get("pos", "0,0")
+        if pos_str:
+            x_str, y_str = pos_str.split(",")
+            # Convert from points to our coordinate system
+            x = float(x_str)
+            y = float(y_str)
+            positions[node] = (x, y)
+
+    return positions
+
+
+def _compute_simple_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]]:
+    """Fallback simple layered layout using topological ordering.
+
+    Used when pygraphviz is not available. Does not minimize edge crossings.
+
+    Args:
+        nodes: List of node identifiers
+        edges: List of (source, target) edge tuples
+        x_spacing: Horizontal spacing between layers
+        y_spacing: Vertical spacing between nodes in the same layer
+
+    Returns:
+        Dictionary mapping node identifiers to (x, y) positions
+    """
     # Build adjacency structures
     incoming: dict[str, set[str]] = defaultdict(set)
     outgoing: dict[str, set[str]] = defaultdict(set)