kececilayout 0.4.9__py3-none-any.whl → 0.5.1__py3-none-any.whl

kececilayout/kececi_layout.py

@@ -5,8 +5,25 @@ kececilayout.py
 
 This module provides sequential-zigzag ("Keçeci Layout") and advanced visualization styles for various Python graph libraries.
 Bu modül, çeşitli Python graf kütüphaneleri için sıralı-zigzag ("Keçeci Layout") ve gelişmiş görselleştirme stilleri sağlar.
+
+**Key Features:**
+*   **Linear Focus:** Ideal for visualizing paths, chains, or ordered processes.
+*   **Deterministic:** Produces identical results for the same input.
+*   **Overlap Reduction:** Prevents node collisions by spreading them across axes.
+*   **Parametric:** Fully customizable with parameters like `primary_spacing`, `secondary_spacing`, `primary_direction`, and `secondary_start`.
+
+**v0.2.7**: Curved, transparent, 3D, and `expanding=True` styles supported.
+
+**v0.5.0:** 
+
+layouts = ['2d', 'cylindrical', 'cubic', 'spherical', 'elliptical', 'toric']
+
+styles = ['standard', 'default', 'curved', 'helix', '3d', 'weighted', 'colored']
+
+**v0.5.1:** edge (kececi_layout_edge)
 """
 
+from collections import defaultdict
 import graphillion as gg
 import igraph as ig
 import itertools # Graphillion için eklendi
@@ -16,9 +33,11 @@ from mpl_toolkits.mplot3d import Axes3D
 import networkit as nk
 import networkx as nx
 import numpy as np # rustworkx
+from numba import jit
 import platform # graph_tool için
 import random
 import rustworkx as rx
+from typing import Any, Dict, List, Optional, Tuple, Union
 import warnings
 
 
@@ -58,6 +77,79 @@ if platform.system() == "Linux":
 else:
     gt = None
 
+"""
+@jit(nopython=True)
+def calculate_coordinates(nodes, primary_spacing, secondary_spacing, primary_direction, secondary_start, expanding):
+    #Numba ile hızlandırılmış koordinat hesaplama.
+    pos = {}
+    for i, node_id in enumerate(nodes):
+        # Koordinat hesaplama mantığı...
+        pos[node_id] = (x, y)
+    return pos
+"""
+
+@jit(nopython=True)
+def calculate_coordinates(
+    nodes: list,
+    primary_spacing: float,
+    secondary_spacing: float,
+    primary_direction: str,
+    secondary_start: str,
+    expanding: bool
+) -> dict:
+    """
+    Numba ile hızlandırılmış koordinat hesaplama fonksiyonu.
+
+    Args:
+        nodes: Düğümlerin listesi.
+        primary_spacing: Birincil eksendeki düğümler arası mesafe.
+        secondary_spacing: İkincil eksendeki zigzag ofseti.
+        primary_direction: Birincil yön ('left-to-right', 'right-to-left', 'top_down', 'bottom_up').
+        secondary_start: Zigzag'ın başlangıç yönü ('up', 'down', 'left', 'right').
+        expanding: Zigzag ofsetinin büyümesi gerekip gerekmediği (True/False).
+
+    Returns:
+        dict: Düğümlerin koordinatlarını içeren sözlük. Örneğin: {0: (x, y), 1: (x, y), ...}.
+    """
+    pos = {}
+    n = len(nodes)
+
+    for i in range(n):
+        node_id = nodes[i]
+        primary_coord = 0.0
+        secondary_axis = ''
+
+        # Birincil eksen koordinatını hesapla
+        if primary_direction == 'left-to-right':
+            primary_coord = i * primary_spacing
+            secondary_axis = 'y'
+        elif primary_direction == 'right-to-left':
+            primary_coord = -i * primary_spacing
+            secondary_axis = 'y'
+        elif primary_direction == 'top_down':
+            primary_coord = -i * primary_spacing
+            secondary_axis = 'x'
+        elif primary_direction == 'bottom_up':
+            primary_coord = i * primary_spacing
+            secondary_axis = 'x'
+
+        # İkincil eksen ofsetini hesapla
+        secondary_offset = 0.0
+        if i > 0:
+            start_multiplier = 1.0 if secondary_start in ['right', 'up'] else -1.0
+            magnitude = math.ceil(i / 2.0) if expanding else 1.0
+            side = 1 if i % 2 != 0 else -1
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
+
+        # Koordinatları ata
+        if secondary_axis == 'x':
+            x, y = (secondary_offset, primary_coord)
+        else:
+            x, y = (primary_coord, secondary_offset)
+
+        pos[node_id] = (x, y)
+
+    return pos
 
 def find_max_node_id(edges):
     """
@@ -170,12 +262,104 @@ def kececi_layout(graph, primary_spacing=1.0, secondary_spacing=1.0,
         pos[node_id] = (x, y)
     return pos
 
+def kececi_layout_edge(graph: Any,
+                  primary_spacing: float = 1.0,
+                  secondary_spacing: float = 1.0,
+                  primary_direction: str = 'top_down',
+                  secondary_start: str = 'right',
+                  expanding: bool = True,
+                  edge: bool = True) -> Dict[Any, Tuple[float, float]]:
+    """Deterministik O(n) layout — edge farkındalıklı mod ile."""
+    nodes, edges = _extract_graph_data(graph)
+    _validate_directions(primary_direction, secondary_start)
+    
+    if edge and edges:
+        degree = defaultdict(int)
+        for u, v in edges:
+            degree[u] += 1
+            degree[v] += 1
+        nodes = sorted(nodes, key=lambda n: (-degree.get(n, 0), str(n)))
+    
+    return _compute_positions(
+        nodes, primary_spacing, secondary_spacing,
+        primary_direction, secondary_start, expanding
+    )
+
+def _validate_directions(pd: str, ss: str) -> None:
+    VERTICAL = {'top_down', 'bottom_up'}
+    HORIZONTAL = {'left-to-right', 'right-to-left'}
+    
+    if pd in VERTICAL and ss not in {'left', 'right'}:
+        raise ValueError(
+            f"Invalid secondary_start '{ss}' for vertical direction '{pd}'\n"
+            f"✓ Use: 'left' or 'right' (e.g., secondary_start='right')"
+        )
+    if pd in HORIZONTAL and ss not in {'up', 'down'}:
+        raise ValueError(
+            f"Invalid secondary_start '{ss}' for horizontal direction '{pd}'\n"
+            f"✓ Use: 'up' or 'down' (e.g., secondary_start='up')"
+        )
+    if pd not in VERTICAL and pd not in HORIZONTAL:
+        raise ValueError(f"Invalid primary_direction: '{pd}'")
+
+def _extract_graph_data(graph: Any) -> Tuple[List[Any], List[Tuple[Any, Any]]]:
+    # Rustworkx
+    try:
+        import rustworkx as rx
+        if isinstance(graph, (rx.PyGraph, rx.PyDiGraph)):
+            nodes = sorted(int(u) for u in graph.node_indices())
+            edges = [(int(u), int(v)) for u, v in graph.edge_list()]
+            return nodes, edges
+    except (ImportError, AttributeError, NameError):
+        pass
+    
+    # NetworkX (fallback)
+    try:
+        import networkx as nx
+        if isinstance(graph, (nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph)):
+            try:
+                nodes = sorted(graph.nodes())
+            except TypeError:
+                nodes = list(graph.nodes())
+            edges = [(u, v) for u, v in graph.edges()]
+            return nodes, edges
+    except (ImportError, AttributeError, NameError):
+        pass
+    
+    raise TypeError(
+        f"Unsupported graph type: {type(graph).__name__}\n"
+        "Supported: NetworkX, Rustworkx"
+    )
+
+def _compute_positions(nodes: List[Any],
+                       ps: float, ss: float,
+                       pd: str, sc: str, exp: bool) -> Dict[Any, Tuple[float, float]]:
+    pos = {}
+    for i, node in enumerate(nodes):
+        if pd == 'top_down':
+            pc, sa = i * -ps, 'x'
+        elif pd == 'bottom_up':
+            pc, sa = i * ps, 'x'
+        elif pd == 'left-to-right':
+            pc, sa = i * ps, 'y'
+        else:  # right-to-left
+            pc, sa = i * -ps, 'y'
+        
+        so = 0.0
+        if i > 0:
+            sm = 1.0 if sc in {'right', 'up'} else -1.0
+            mag = math.ceil(i / 2.0) if exp else 1.0
+            side = 1 if i % 2 else -1
+            so = sm * mag * side * ss
+        
+        pos[node] = (so, pc) if sa == 'x' else (pc, so)
+    return pos
+
 # =============================================================================
 # 1. TEMEL LAYOUT HESAPLAMA FONKSİYONU (2D)
 # Bu fonksiyon sadece koordinatları hesaplar, çizim yapmaz.
 # 1. LAYOUT CALCULATION FUNCTION (UNIFIED AND IMPROVED)
 # =============================================================================
-
 def kececi_layout_v4(graph, primary_spacing=1.0, secondary_spacing=1.0,
                   primary_direction='top_down', secondary_start='right',
                   expanding=True):
@@ -268,7 +452,7 @@ def kececi_layout_nx(graph, primary_spacing=1.0, secondary_spacing=1.0,
         primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
         secondary_start (str): Initial direction for the zigzag offset.
         expanding (bool): If True (default), the zigzag offset grows.
-                          If False, the offset is constant (parallel lines). # <-- 2. DOKÜMANTASYON GÜNCELLENDİ
+                          If False, the offset is constant (parallel lines).
 
     Returns:
         dict: A dictionary of positions keyed by node ID.
@@ -327,7 +511,7 @@ def kececi_layout_networkx(graph, primary_spacing=1.0, secondary_spacing=1.0,
         primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
         secondary_start (str): Initial direction for the zigzag offset.
         expanding (bool): If True (default), the zigzag offset grows.
-                          If False, the offset is constant (parallel lines). # <-- 2. DOKÜMANTASYON GÜNCELLENDİ
+                          If False, the offset is constant (parallel lines).
 
     Returns:
         dict: A dictionary of positions keyed by node ID.
@@ -1420,6 +1604,228 @@ def generate_distinct_colors(n):
         colors.append(adjusted_rgb)
     return colors
 
+# 2D Layout
+def kececi_layout_2d(
+    nx_graph: nx.Graph,
+    primary_spacing: float = 1.0,
+    secondary_spacing: float = 1.0,
+    primary_direction: str = 'left-to-right',
+    secondary_start: str = 'up',
+    expanding: bool = True
+) -> Dict[int, Tuple[float, float]]:
+    pos = {}
+    nodes = sorted(list(nx_graph.nodes()))
+
+    for i, node_id in enumerate(nodes):
+        if primary_direction == 'left-to-right':
+            primary_coord, secondary_axis = i * primary_spacing, 'y'
+        elif primary_direction == 'right-to-left':
+            primary_coord, secondary_axis = i * -primary_spacing, 'y'
+        elif primary_direction == 'top_down':
+            primary_coord, secondary_axis = i * -primary_spacing, 'x'
+        else:  # 'bottom_up'
+            primary_coord, secondary_axis = i * primary_spacing, 'x'
+
+        secondary_offset = 0.0
+        if i > 0:
+            start_multiplier = 1.0 if secondary_start in ['right', 'up'] else -1.0
+            magnitude = math.ceil(i / 2.0) if expanding else 1.0
+            side = 1 if i % 2 != 0 else -1
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
+
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
+        pos[node_id] = (x, y)
+
+    return pos
+
+# Silindirik Layout
+def kececi_layout_cylindrical(
+    nx_graph: nx.Graph,
+    radius: float = 5.0,
+    height: float = 10.0
+) -> Dict[int, Tuple[float, float, float]]:
+    pos_3d = {}
+    nodes = sorted(list(nx_graph.nodes()))
+    num_nodes = len(nodes)
+
+    for i, node_id in enumerate(nodes):
+        theta = 2 * np.pi * i / num_nodes
+        x = radius * np.cos(theta)
+        y = radius * np.sin(theta)
+        z = height * i / num_nodes
+        pos_3d[node_id] = (x, y, z)
+
+    return pos_3d
+
+# Kübik Layout
+def kececi_layout_cubic(
+    nx_graph: nx.Graph,
+    size: float = 5.0
+) -> Dict[int, Tuple[float, float, float]]:
+    pos_3d = {}
+    nodes = sorted(list(nx_graph.nodes()))
+    num_nodes = len(nodes)
+    cube_size = int(np.cbrt(num_nodes)) + 1
+
+    for i, node_id in enumerate(nodes):
+        x = size * (i % cube_size)
+        y = size * ((i // cube_size) % cube_size)
+        z = size * ((i // (cube_size ** 2)) % cube_size)
+        pos_3d[node_id] = (x, y, z)
+
+    return pos_3d
+
+# Küresel Layout
+def kececi_layout_spherical(
+    nx_graph: nx.Graph,
+    radius: float = 5.0
+) -> Dict[int, Tuple[float, float, float]]:
+    pos_3d = {}
+    nodes = sorted(list(nx_graph.nodes()))
+    num_nodes = len(nodes)
+
+    for i, node_id in enumerate(nodes):
+        theta = 2 * np.pi * i / num_nodes
+        phi = np.arccos(1 - 2 * (i + 0.5) / num_nodes)
+        x = radius * np.sin(phi) * np.cos(theta)
+        y = radius * np.sin(phi) * np.sin(theta)
+        z = radius * np.cos(phi)
+        pos_3d[node_id] = (x, y, z)
+
+    return pos_3d
+
+# Eliptik Layout
+def kececi_layout_elliptical(
+    nx_graph: nx.Graph,
+    a: float = 5.0,
+    b: float = 3.0
+) -> Dict[int, Tuple[float, float]]:
+    pos = {}
+    nodes = sorted(list(nx_graph.nodes()))
+    num_nodes = len(nodes)
+
+    for i, node_id in enumerate(nodes):
+        theta = 2 * np.pi * i / num_nodes
+        x = a * np.cos(theta)
+        y = b * np.sin(theta)
+        pos[node_id] = (x, y)
+
+    return pos
+
+# Torik (Halkasal) Layout
+def kececi_layout_toric(
+    nx_graph: nx.Graph,
+    major_radius: float = 5.0,
+    minor_radius: float = 2.0
+) -> Dict[int, Tuple[float, float, float]]:
+    pos_3d = {}
+    nodes = sorted(list(nx_graph.nodes()))
+    num_nodes = len(nodes)
+
+    for i, node_id in enumerate(nodes):
+        theta = 2 * np.pi * i / num_nodes
+        phi = 2 * np.pi * i / num_nodes
+        x = (major_radius + minor_radius * np.cos(phi)) * np.cos(theta)
+        y = (major_radius + minor_radius * np.cos(phi)) * np.sin(theta)
+        z = minor_radius * np.sin(phi)
+        pos_3d[node_id] = (x, y, z)
+
+    return pos_3d
+
+# Ağırlıklı Çizim (draw_kececi_weighted)
+def draw_kececi_weighted(
+    nx_graph: nx.Graph,
+    pos: Dict[int, Tuple[float, ...]],
+    ax: Optional[plt.Axes] = None,
+    node_size: int = 300,
+    edge_width_scale: float = 2.0,
+    **kwargs
+) -> plt.Axes:
+    if ax is None:
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111)
+
+    weights = nx.get_edge_attributes(nx_graph, 'weight')
+    if not weights:
+        weights = {edge: 1.0 for edge in nx_graph.edges()}
+
+    nx.draw_networkx_nodes(nx_graph, pos, ax=ax, node_size=node_size, **kwargs)
+
+    is_3d = len(pos[next(iter(pos))]) == 3
+    if is_3d:
+        for node, coord in pos.items():
+            ax.text(coord[0], coord[1], coord[2], f'  {node}', size=10, zorder=1, color='black')
+    else:
+        nx.draw_networkx_labels(nx_graph, pos, ax=ax)
+
+    for (u, v), weight in weights.items():
+        width = weight * edge_width_scale
+        if is_3d:
+            ax.plot(
+                [pos[u][0], pos[v][0]],
+                [pos[u][1], pos[v][1]],
+                [pos[u][2], pos[v][2]],
+                linewidth=width,
+                color='gray',
+                alpha=0.7
+            )
+        else:
+            ax.plot(
+                [pos[u][0], pos[v][0]],
+                [pos[u][1], pos[v][1]],
+                linewidth=width,
+                color='gray',
+                alpha=0.7
+            )
+
+    ax.set_title("Keçeci Layout: Weighted Edges")
+    return ax
+    
+# Renkli Çizim (draw_kececi_colored)
+def draw_kececi_colored(
+    nx_graph: nx.Graph,
+    pos: Dict[int, Tuple[float, ...]],
+    ax: Optional[plt.Axes] = None,
+    node_size: int = 300,
+    **kwargs
+) -> plt.Axes:
+    if ax is None:
+        fig = plt.figure(figsize=(10, 8))
+        ax = fig.add_subplot(111)
+
+    degrees = dict(nx_graph.degree())
+    max_degree = max(degrees.values()) if degrees else 1
+    node_colors = [plt.cm.viridis(deg / max_degree) for deg in degrees.values()]
+
+    nx.draw_networkx_nodes(
+        nx_graph, pos, ax=ax,
+        node_color=node_colors,
+        node_size=node_size,
+        **kwargs
+    )
+
+    is_3d = len(pos[next(iter(pos))]) == 3
+    if is_3d:
+        for node, coord in pos.items():
+            ax.text(coord[0], coord[1], coord[2], f'  {node}', size=10, zorder=1, color='black')
+    else:
+        nx.draw_networkx_labels(nx_graph, pos, ax=ax)
+
+    if is_3d:
+        for u, v in nx_graph.edges():
+            ax.plot(
+                [pos[u][0], pos[v][0]],
+                [pos[u][1], pos[v][1]],
+                [pos[u][2], pos[v][2]],
+                color='gray',
+                alpha=0.5
+            )
+    else:
+        nx.draw_networkx_edges(nx_graph, pos, ax=ax, alpha=0.5)
+
+    ax.set_title("Keçeci Layout: Colored Nodes")
+    return ax
+
 # =============================================================================
 # 3. INTERNAL DRAWING STYLE IMPLEMENTATIONS
 # =============================================================================
@@ -1523,9 +1929,181 @@ def _draw_internal(nx_graph, ax, style, **kwargs):
 # =============================================================================
 # 4. MAIN USER-FACING DRAWING FUNCTION
 # =============================================================================
+def draw_kececi(
+    graph,
+    pos: Optional[Dict[int, Tuple[float, ...]]] = None,
+    layout: Optional[str] = None,
+    style: str = 'default',
+    ax: Optional[plt.Axes] = None,
+    with_labels: bool = True,
+    node_color: str = 'lightblue',
+    node_size: int = 500,
+    font_weight: str = 'bold',
+    **kwargs
+) -> plt.Axes:
+    """
+    Keçeci Layout ile graf çizimi.
 
-def draw_kececi(graph, style='curved', ax=None, **kwargs):
+    Args:
+        graph: Graf objesi (NetworkX, igraph, vb.).
+        pos: Önceden hesaplanmış koordinatlar (opsiyonel).
+        layout: '2d', 'cylindrical', 'cubic', 'spherical', 'elliptical', 'toric' (opsiyonel).
+        style: 'default', 'weighted', 'colored'.
+        ax: Matplotlib ekseni.
+        with_labels: Düğüm etiketlerini göster.
+        node_color: Düğüm rengi.
+        node_size: Düğüm boyutu.
+        font_weight: Yazı kalınlığı.
+        **kwargs: Ek parametreler.
+
+    Returns:
+        Matplotlib ekseni.
     """
+    nx_graph = to_networkx(graph)
+
+    # Eğer pos verilmemişse, layout'a göre hesapla
+    if pos is None:
+        if layout is None:
+            layout = '2d'  # Varsayılan layout
+
+        if layout == '2d':
+            pos = kececi_layout_2d(nx_graph, **kwargs)
+        elif layout == 'cylindrical':
+            pos = kececi_layout_cylindrical(nx_graph, **kwargs)
+        elif layout == 'cubic':
+            pos = kececi_layout_cubic(nx_graph, **kwargs)
+        elif layout == 'spherical':
+            pos = kececi_layout_spherical(nx_graph, **kwargs)
+        elif layout == 'elliptical':
+            pos = kececi_layout_elliptical(nx_graph, **kwargs)
+        elif layout == 'toric':
+            pos = kececi_layout_toric(nx_graph, **kwargs)
+        else:
+            raise ValueError(f"Geçersiz layout: {layout}")
+
+    # 3D için eksen ayarlaması
+    is_3d = len(pos[next(iter(pos))]) == 3
+    if ax is None:
+        fig = plt.figure(figsize=(10, 8))
+        if is_3d:
+            ax = fig.add_subplot(111, projection='3d')
+        else:
+            ax = fig.add_subplot(111)
+
+    # Stile göre çizim yap
+    if style == 'weighted':
+        draw_kececi_weighted(nx_graph, pos, ax, **kwargs)
+    elif style == 'colored':
+        draw_kececi_colored(nx_graph, pos, ax, **kwargs)
+    else:  # 'default'
+        nx.draw_networkx_nodes(nx_graph, pos, ax=ax, node_color=node_color, node_size=node_size)
+
+        # Düğüm etiketlerini çiz
+        if with_labels:
+            if is_3d:
+                for node, coord in pos.items():
+                    ax.text(coord[0], coord[1], coord[2], f'  {node}', size=10, zorder=1, color='black', fontweight=font_weight)
+            else:
+                nx.draw_networkx_labels(nx_graph, pos, ax=ax, font_weight=font_weight)
+
+        # Kenarları çiz
+        if is_3d:
+            for u, v in nx_graph.edges():
+                ax.plot(
+                    [pos[u][0], pos[v][0]],
+                    [pos[u][1], pos[v][1]],
+                    [pos[u][2], pos[v][2]],
+                    color='gray',
+                    alpha=0.5
+                )
+        else:
+            nx.draw_networkx_edges(nx_graph, pos, ax=ax, alpha=0.5)
+
+    ax.set_title(f"Keçeci Layout: {layout.capitalize() if layout else 'Custom'} ({style})")
+    return ax
+"""
+def draw_kececi(
+    graph,
+    layout: str = '2d',
+    style: str = 'default',
+    ax: Optional[plt.Axes] = None,
+    **kwargs
+) -> plt.Axes:
+
+    Keçeci Layout ile graf çizimi.
+
+    Args:
+        graph: Graf objesi (NetworkX, igraph, vb.).
+        layout: '2d', 'cylindrical', 'cubic', 'spherical', 'elliptical', 'toric'.
+        style: 'default', 'weighted', 'colored'.
+        ax: Matplotlib ekseni.
+        **kwargs: Ek parametreler.
+
+    Returns:
+        Matplotlib ekseni.
+
+    nx_graph = to_networkx(graph)
+
+    # Layout'a göre koordinatları hesapla
+    if layout == '2d':
+        pos = kececi_layout_2d(nx_graph, **kwargs)
+    elif layout == 'cylindrical':
+        pos = kececi_layout_cylindrical(nx_graph, **kwargs)
+    elif layout == 'cubic':
+        pos = kececi_layout_cubic(nx_graph, **kwargs)
+    elif layout == 'spherical':
+        pos = kececi_layout_spherical(nx_graph, **kwargs)
+    elif layout == 'elliptical':
+        pos = kececi_layout_elliptical(nx_graph, **kwargs)
+    elif layout == 'toric':
+        pos = kececi_layout_toric(nx_graph, **kwargs)
+    else:
+        raise ValueError(f"Invalid layout: {layout}")
+
+    # 3D için eksen ayarlaması
+    is_3d = len(pos[next(iter(pos))]) == 3
+    if ax is None:
+        fig = plt.figure(figsize=(10, 8))
+        if is_3d:
+            ax = fig.add_subplot(111, projection='3d')
+        else:
+            ax = fig.add_subplot(111)
+
+    # Stile göre çizim yap
+    if style == 'weighted':
+        draw_kececi_weighted(nx_graph, pos, ax, **kwargs)
+    elif style == 'colored':
+        draw_kececi_colored(nx_graph, pos, ax, **kwargs)
+    else:  # 'default'
+        nx.draw_networkx_nodes(nx_graph, pos, ax=ax, **kwargs)
+
+        # Düğüm etiketlerini çiz
+        if is_3d:
+            for node, coord in pos.items():
+                ax.text(coord[0], coord[1], coord[2], f'  {node}', size=10, zorder=1, color='black')
+        else:
+            nx.draw_networkx_labels(nx_graph, pos, ax=ax)
+
+        # Kenarları çiz
+        if is_3d:
+            for u, v in nx_graph.edges():
+                ax.plot(
+                    [pos[u][0], pos[v][0]],
+                    [pos[u][1], pos[v][1]],
+                    [pos[u][2], pos[v][2]],
+                    color='gray',
+                    alpha=0.5
+                )
+        else:
+            nx.draw_networkx_edges(nx_graph, pos, ax=ax, alpha=0.5)
+
+    ax.set_title(f"Keçeci Layout: {layout.capitalize()} ({style})")
+    return ax
+"""
+
+"""
+def draw_kececi(graph, style='curved', ax=None, **kwargs):
+
     Draws a graph using the Keçeci Layout with a specified style.
 
     This function automatically handles graphs from different libraries
@@ -1541,7 +2119,7 @@ def draw_kececi(graph, style='curved', ax=None, **kwargs):
 
     Returns:
         matplotlib.axis.Axis: The axis object where the graph was drawn.
-    """
+
     nx_graph = to_networkx(graph)
     is_3d = (style.lower() == '3d')
 
@@ -1559,7 +2137,7 @@ def draw_kececi(graph, style='curved', ax=None, **kwargs):
 
     _draw_internal(nx_graph, ax, style.lower(), **kwargs)
     return ax
-
+"""
 
 # =============================================================================
 # MODULE TEST CODE
@@ -1606,3 +2184,6 @@ if __name__ == '__main__':
     draw_kececi(G_test, style='3d', ax=fig_styles.add_subplot(2, 2, (3, 4), projection='3d'))
     plt.tight_layout(rect=[0, 0, 1, 0.96])
     plt.show()
+
+
+