kececilayout 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

kececilayout/kececi_layout.py

@@ -51,16 +51,37 @@ except ImportError:
 
 
 def find_max_node_id(edges):
-    """Verilen kenar listesindeki en büyük düğüm ID'sini bulur."""
+    """
+    Finds the highest node ID from a list of edges.
+
+    This function is robust and handles empty lists or malformed edge data
+    gracefully by returning 0.
+
+    Args:
+        edges (iterable): An iterable of edge tuples, e.g., [(1, 2), (3, 2)].
+
+    Returns:
+        int: The highest node ID found, or 0 if the list is empty.
+    """
+    # 1. Handle the most common case first: an empty list of edges.
     if not edges:
         return 0
+
     try:
-      # Tüm düğüm ID'lerini tek bir kümede topla ve en büyüğünü bul
-      all_nodes = set(itertools.chain.from_iterable(edges))
-      return max(all_nodes) if all_nodes else 0
-    except TypeError: # Eğer kenarlar (node, node) formatında değilse
-      print("Uyarı: Kenar formatı beklenenden farklı, max node ID 0 varsayıldı.")
-      return 0
+        # 2. Efficiently flatten the list of tuples into a single sequence
+        #    and use a set to get unique node IDs.
+        #    e.g., [(1, 2), (3, 2)] -> {1, 2, 3}
+        all_nodes = set(itertools.chain.from_iterable(edges))
+
+        # 3. Return the maximum ID from the set. If the set is somehow empty
+        #    after processing, return 0 as a fallback.
+        return max(all_nodes) if all_nodes else 0
+        
+    except TypeError:
+        # 4. If the edge data is not in the expected format (e.g., not a list
+        #    of tuples), catch the error and return 0 safely.
+        print("Warning: Edge format was unexpected. Assuming max node ID is 0.")
+        return 0
 
 
 def kececi_layout(graph, primary_spacing=1.0, secondary_spacing=1.0,
@@ -94,7 +115,7 @@ def kececi_layout(graph, primary_spacing=1.0, secondary_spacing=1.0,
     pos = {}
     
     # --- DOĞRULANMIŞ KONTROL BLOĞU ---
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
     if not (is_vertical or is_horizontal):
@@ -107,9 +128,9 @@ def kececi_layout(graph, primary_spacing=1.0, secondary_spacing=1.0,
 
     for i, node_id in enumerate(nodes):
         primary_coord, secondary_axis = 0.0, ''
-        if primary_direction == 'top-down':
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up':
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
@@ -194,7 +215,7 @@ def kececi_layout_v4(graph, primary_spacing=1.0, secondary_spacing=1.0,
 
     for i, node_id in enumerate(nodes):
         primary_coord, secondary_axis = 0.0, ''
-        if primary_direction == 'top-down':
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
         elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
@@ -220,649 +241,714 @@ def kececi_layout_v4(graph, primary_spacing=1.0, secondary_spacing=1.0,
 
     return pos
 
-def kececi_layout_v4_nx(graph, primary_spacing=1.0, secondary_spacing=1.0,
-                     primary_direction='top-down', secondary_start='right'):
+def kececi_layout_nx(graph, primary_spacing=1.0, secondary_spacing=1.0,
+                           primary_direction='top_down', secondary_start='right',
+                           expanding=True):
     """
-    Genişletilmiş Keçeci Düzeni: Ana eksen boyunca ilerler, ikincil eksende artan şekilde sapar.
-    Düğümler ikincil eksende daha geniş bir alana yayılır.
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+
+    Args:
+        graph (networkx.Graph): A NetworkX graph object.
+        primary_spacing (float): The distance between nodes along the primary axis.
+        secondary_spacing (float): The base unit for the zigzag offset.
+        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İ
+
+    Returns:
+        dict: A dictionary of positions keyed by node ID.
     """
     pos = {}
-    # NetworkX 2.x ve 3.x uyumluluğu için listeye çevirme
     nodes = sorted(list(graph.nodes()))
-    num_nodes = len(nodes)
-    if num_nodes == 0: 
+    if not nodes:
         return {}
 
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
-    if not (is_vertical or is_horizontal): 
+    if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
-    if is_vertical and secondary_start not in ['right', 'left']: 
-        raise ValueError(f"Invalid secondary_start for vertical: {secondary_start}")
-    if is_horizontal and secondary_start not in ['up', 'down']: 
-        raise ValueError(f"Invalid secondary_start for horizontal: {secondary_start}")
+    if is_vertical and secondary_start not in ['right', 'left']:
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
+    if is_horizontal and secondary_start not in ['up', 'down']:
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
+
 
     for i, node_id in enumerate(nodes):
-        # 1. Ana Eksen Koordinatını Hesapla
-        if primary_direction == 'top-down': 
+        # 1. Calculate Primary Axis Coordinate
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up': 
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
-        elif primary_direction == 'left-to-right': 
+        elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: # right-to-left
+        else:
             primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        # 2. İkincil Eksen Koordinatını Hesapla (Genişletilmiş Sapma)
-        if i == 0:
-            secondary_offset_multiplier = 0.0
-        else:
-            # Sapma yönünü belirle (sağ/yukarı +1, sol/aşağı -1)
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            # Sapma büyüklüğünü belirle (i arttıkça artar: 1, 1, 2, 2, 3, 3, ...)
-            magnitude = math.ceil(i / 2.0)
-            # Sapma tarafını belirle (tek i için pozitif, çift i için negatif)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
-
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        # 3. (x, y) Koordinatlarını Ata
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_id] = (x, y)
 
     return pos
 
-def kececi_layout_v4_networkx(graph, primary_spacing=1.0, secondary_spacing=1.0,
-                     primary_direction='top-down', secondary_start='right'):
+def kececi_layout_networkx(graph, primary_spacing=1.0, secondary_spacing=1.0,
+                           primary_direction='top_down', secondary_start='right',
+                           expanding=True):
     """
-    Genişletilmiş Keçeci Düzeni: Ana eksen boyunca ilerler, ikincil eksende artan şekilde sapar.
-    Düğümler ikincil eksende daha geniş bir alana yayılır.
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+
+    Args:
+        graph (networkx.Graph): A NetworkX graph object.
+        primary_spacing (float): The distance between nodes along the primary axis.
+        secondary_spacing (float): The base unit for the zigzag offset.
+        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İ
+
+    Returns:
+        dict: A dictionary of positions keyed by node ID.
     """
     pos = {}
-    # NetworkX 2.x ve 3.x uyumluluğu için listeye çevirme
     nodes = sorted(list(graph.nodes()))
-    num_nodes = len(nodes)
-    if num_nodes == 0: 
+    if not nodes:
         return {}
 
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
-    if not (is_vertical or is_horizontal): 
+    if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
-    if is_vertical and secondary_start not in ['right', 'left']: 
-        raise ValueError(f"Invalid secondary_start for vertical: {secondary_start}")
-    if is_horizontal and secondary_start not in ['up', 'down']: 
-        raise ValueError(f"Invalid secondary_start for horizontal: {secondary_start}")
+    if is_vertical and secondary_start not in ['right', 'left']:
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
+    if is_horizontal and secondary_start not in ['up', 'down']:
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
+
 
     for i, node_id in enumerate(nodes):
-        # 1. Ana Eksen Koordinatını Hesapla
-        if primary_direction == 'top-down': 
+        # 1. Calculate Primary Axis Coordinate
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up': 
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
-        elif primary_direction == 'left-to-right': 
+        elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: # right-to-left
+        else:
             primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        # 2. İkincil Eksen Koordinatını Hesapla (Genişletilmiş Sapma)
-        if i == 0:
-            secondary_offset_multiplier = 0.0
-        else:
-            # Sapma yönünü belirle (sağ/yukarı +1, sol/aşağı -1)
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            # Sapma büyüklüğünü belirle (i arttıkça artar: 1, 1, 2, 2, 3, 3, ...)
-            magnitude = math.ceil(i / 2.0)
-            # Sapma tarafını belirle (tek i için pozitif, çift i için negatif)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
-
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        # 3. (x, y) Koordinatlarını Ata
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_id] = (x, y)
 
     return pos
 
 
-def kececi_layout_v4_ig(graph: ig.Graph, primary_spacing=1.0, secondary_spacing=1.0,
-                            primary_direction='top-down', secondary_start='right'):
-    """igraph.Graph nesnesi için Keçeci layout.
+def kececi_layout_ig(graph: "ig.Graph", primary_spacing=1.0, secondary_spacing=1.0,
+                         primary_direction='top_down', secondary_start='right',
+                           expanding=True):
+    """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi layout for an igraph.Graph object.
 
     Args:
-        graph: igraph.Graph nesnesi.
-        primary_spacing: Ana eksendeki düğümler arasındaki boşluk.
-        secondary_spacing: İkincil eksendeki ofset boşluğu.
-        primary_direction: Ana eksenin yönü ('top-down', 'bottom-up', 'left-to-right', 'right-to-left').
-        secondary_start: İkincil eksendeki ilk ofsetin yönü ('right', 'left', 'up', 'down').
+        graph (igraph.Graph): An igraph.Graph object.
+        primary_spacing (float): The spacing between nodes on the primary axis.
+        secondary_spacing (float): The offset spacing on the secondary axis.
+        primary_direction (str): Direction of the primary axis ('top_down', 'bottom_up', 'left-to-right', 'right-to-left').
+        secondary_start (str): Direction of the initial offset on the secondary axis ('right', 'left', 'up', 'down').
 
     Returns:
-        Vertex ID'lerine göre sıralanmış koordinatların listesi (ör: [[x0,y0], [x1,y1], ...]).
+        list: A list of coordinates sorted by vertex ID (e.g., [[x0,y0], [x1,y1], ...]).
     """
     num_nodes = graph.vcount()
     if num_nodes == 0:
         return []
 
-    # Koordinat listesi oluştur (vertex ID'leri 0'dan N-1'e sıralı olacak şekilde)
+    # Create coordinate list (will be ordered by vertex IDs 0 to N-1)
     pos_list = [[0.0, 0.0]] * num_nodes
-    # Vertex ID'leri zaten 0'dan N-1'e olduğu için doğrudan range kullanabiliriz
-    nodes = range(num_nodes) # Vertex ID'leri
+    # Since vertex IDs are already 0 to N-1, we can use range directly
+    nodes = range(num_nodes)  # Vertex IDs
 
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
     if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
     if is_vertical and secondary_start not in ['right', 'left']:
-        raise ValueError(f"Invalid secondary_start for vertical: {secondary_start}")
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
     if is_horizontal and secondary_start not in ['up', 'down']:
-        raise ValueError(f"Invalid secondary_start for horizontal: {secondary_start}")
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
 
-    for i in nodes: # i burada vertex index'i (0, 1, 2...)
-        if primary_direction == 'top-down':
+    for i in nodes:  # Here, i is the vertex index (0, 1, 2...)
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up':
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: # right-to-left
+        else:  # right-to-left
             primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        if i == 0:
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
+        pos_list[i] = [x, y]  # Add [x, y] to the list at the correct index
 
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
-        pos_list[i] = [x, y] # Listeye doğru index'e [x, y] olarak ekle
+    # Returning a direct list is the most common and flexible approach.
+    # The plot function accepts a list of coordinates directly.
+    return pos_list
 
-    # igraph Layout nesnesi gibi davranması için basit bir nesne döndürelim
-    # veya doğrudan koordinat listesini kullanalım. Çizim fonksiyonu listeyi kabul eder.
-    # return ig.Layout(pos_list) # İsterseniz Layout nesnesi de döndürebilirsiniz
-    return pos_list # Doğrudan liste döndürmek en yaygın ve esnek yoldur
 
-def kececi_layout_v4_igraph(graph: ig.Graph, primary_spacing=1.0, secondary_spacing=1.0,
-                            primary_direction='top-down', secondary_start='right'):
-    """igraph.Graph nesnesi için Keçeci layout.
+def kececi_layout_igraph(graph: "ig.Graph", primary_spacing=1.0, secondary_spacing=1.0,
+                         primary_direction='top_down', secondary_start='right',
+                           expanding=True):
+    """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi layout for an igraph.Graph object.
 
     Args:
-        graph: igraph.Graph nesnesi.
-        primary_spacing: Ana eksendeki düğümler arasındaki boşluk.
-        secondary_spacing: İkincil eksendeki ofset boşluğu.
-        primary_direction: Ana eksenin yönü ('top-down', 'bottom-up', 'left-to-right', 'right-to-left').
-        secondary_start: İkincil eksendeki ilk ofsetin yönü ('right', 'left', 'up', 'down').
+        graph (igraph.Graph): An igraph.Graph object.
+        primary_spacing (float): The spacing between nodes on the primary axis.
+        secondary_spacing (float): The offset spacing on the secondary axis.
+        primary_direction (str): Direction of the primary axis ('top_down', 'bottom_up', 'left-to-right', 'right-to-left').
+        secondary_start (str): Direction of the initial offset on the secondary axis ('right', 'left', 'up', 'down').
 
     Returns:
-        Vertex ID'lerine göre sıralanmış koordinatların listesi (ör: [[x0,y0], [x1,y1], ...]).
+        list: A list of coordinates sorted by vertex ID (e.g., [[x0,y0], [x1,y1], ...]).
     """
     num_nodes = graph.vcount()
     if num_nodes == 0:
         return []
 
-    # Koordinat listesi oluştur (vertex ID'leri 0'dan N-1'e sıralı olacak şekilde)
+    # Create coordinate list (will be ordered by vertex IDs 0 to N-1)
     pos_list = [[0.0, 0.0]] * num_nodes
-    # Vertex ID'leri zaten 0'dan N-1'e olduğu için doğrudan range kullanabiliriz
-    nodes = range(num_nodes) # Vertex ID'leri
+    # Since vertex IDs are already 0 to N-1, we can use range directly
+    nodes = range(num_nodes)  # Vertex IDs
 
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
     if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
     if is_vertical and secondary_start not in ['right', 'left']:
-        raise ValueError(f"Invalid secondary_start for vertical: {secondary_start}")
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
     if is_horizontal and secondary_start not in ['up', 'down']:
-        raise ValueError(f"Invalid secondary_start for horizontal: {secondary_start}")
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
 
-    for i in nodes: # i burada vertex index'i (0, 1, 2...)
-        if primary_direction == 'top-down':
+    for i in nodes:  # Here, i is the vertex index (0, 1, 2...)
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up':
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: # right-to-left
+        else:  # right-to-left
             primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        if i == 0:
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
+        pos_list[i] = [x, y]  # Add [x, y] to the list at the correct index
 
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
-        pos_list[i] = [x, y] # Listeye doğru index'e [x, y] olarak ekle
+    # Returning a direct list is the most common and flexible approach.
+    # The plot function accepts a list of coordinates directly.
+    return pos_list
 
-    # igraph Layout nesnesi gibi davranması için basit bir nesne döndürelim
-    # veya doğrudan koordinat listesini kullanalım. Çizim fonksiyonu listeyi kabul eder.
-    # return ig.Layout(pos_list) # İsterseniz Layout nesnesi de döndürebilirsiniz
-    return pos_list # Doğrudan liste döndürmek en yaygın ve esnek yoldur
 
-def kececi_layout_v4_nk(graph: nk.graph.Graph,
-                               primary_spacing=1.0,
-                               secondary_spacing=1.0,
-                               primary_direction='top-down',
-                               secondary_start='right'):
-    """
-    Keçeci Layout v4 - Networkit graf düğümlerine sıralı-zigzag yerleşimi sağlar.
-
-    Parametreler:
-    -------------
-    graph : networkit.graph.Graph
-        Kenar ve düğüm bilgisi içeren Networkit graf nesnesi.
-    primary_spacing : float
-        Ana yön mesafesi.
-    secondary_spacing : float
-        Yan yön mesafesi.
-    primary_direction : str
-        'top-down', 'bottom-up', 'left-to-right', 'right-to-left'.
-    secondary_start : str
-        Başlangıç yönü ('right', 'left', 'up', 'down').
-
-    Dönüş:
-    ------
-    dict[int, tuple[float, float]]
-        Her düğüm ID'sinin (Networkit'te genelde integer olur)
-        koordinatını içeren sözlük.
+def kececi_layout_nk(graph: "nk.graph.Graph", primary_spacing=1.0, secondary_spacing=1.0,
+                            primary_direction='top_down', secondary_start='right',
+                           expanding=True):
     """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi Layout - Provides a sequential-zigzag layout for nodes in a NetworKit graph.
 
-    # Networkit'te düğüm ID'leri genellikle 0'dan N-1'e sıralıdır,
-    # ancak garantiye almak için sıralı bir liste alalım.
-    # iterNodes() düğüm ID'lerini döndürür.
+    Args:
+        graph (networkit.graph.Graph): A NetworKit graph object.
+        primary_spacing (float): The distance on the primary axis.
+        secondary_spacing (float): The distance on the secondary axis.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
+        secondary_start (str): The starting direction for the offset ('right', 'left', 'up', 'down').
+
+    Returns:
+        dict[int, tuple[float, float]]: A dictionary containing the coordinate
+        for each node ID (typically an integer in NetworKit).
+    """
+    # In NetworKit, node IDs are generally sequential, but let's get a sorted
+    # list to be safe. iterNodes() returns the node IDs.
     try:
-        # Networkit'te node ID'lerinin contiguous (0..n-1) olup olmadığını kontrol edebiliriz
-        # ama her zaman böyle olmayabilir. iterNodes en genel yöntem.
         nodes = sorted(list(graph.iterNodes()))
     except Exception as e:
-        print(f"Networkit düğüm listesi alınırken hata: {e}")
-        # Alternatif olarak, eğer ID'lerin 0'dan başladığı varsayılıyorsa:
-        # nodes = list(range(graph.numberOfNodes()))
-        # Ancak iterNodes daha güvenlidir.
-        return {} # Hata durumunda boş dön
+        print(f"Error getting NetworKit node list: {e}")
+        return {}  # Return empty on error
 
-    num_nodes = len(nodes) # Veya graph.numberOfNodes()
+    num_nodes = len(nodes)
     if num_nodes == 0:
-        return {}  # Boş graf için boş sözlük döndür
+        return {}
 
-    pos = {}  # Sonuç sözlüğü
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    pos = {}
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
-    # Parametre kontrolleri
     if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
     if is_vertical and secondary_start not in ['right', 'left']:
-        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for vertical primary_direction ('{primary_direction}'). Use 'right' or 'left'.")
+        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for vertical primary_direction. Use 'right' or 'left'.")
     if is_horizontal and secondary_start not in ['up', 'down']:
-         raise ValueError(f"Invalid secondary_start ('{secondary_start}') for horizontal primary_direction ('{primary_direction}'). Use 'up' or 'down'.")
+        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for horizontal primary_direction. Use 'up' or 'down'.")
 
-    # Ana döngü
+    # Main loop
     for i, node_id in enumerate(nodes):
-        # i: Düğümün sıralı listedeki indeksi (0, 1, 2, ...) - Yerleşim için kullanılır
-        # node_id: Gerçek Networkit düğüm ID'si - Sonuç sözlüğünün anahtarı
-
-        # 1. Ana eksen koordinatını hesapla
-        if 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'
+        # i: The index in the sorted list (0, 1, 2, ...), used for positioning.
+        # node_id: The actual NetworKit node ID, used as the key in the result dictionary.
+        
+        # 1. Calculate Primary Axis Coordinate
+        if primary_direction == 'top_down':
+            primary_coord, secondary_axis = i * -primary_spacing, 'x'
+        elif primary_direction == 'bottom_up':
+            primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
-            primary_coord = i * primary_spacing
-            secondary_axis = 'y'
-        else: # primary_direction == 'right-to-left'
-            primary_coord = i * -primary_spacing
-            secondary_axis = 'y'
-
-        # 2. Yan eksen ofsetini hesapla (zigzag)
-        if i == 0:
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
-            side = 1 if i % 2 != 0 else -1
-            secondary_offset_multiplier = start_mult * magnitude * side
-
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            primary_coord, secondary_axis = i * primary_spacing, 'y'
+        else: # 'right-to-left'
+            primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        # 3. (x, y) koordinatlarını ata
-        if secondary_axis == 'x':
-            x, y = secondary_coord, primary_coord
-        else: # secondary_axis == 'y'
-            x, y = primary_coord, secondary_coord
+        # 2. Calculate Secondary Axis Offset
+        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
 
-        # Sonuç sözlüğüne ekle: anahtar=düğüm ID, değer=(x, y) tuple'ı
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_id] = (x, y)
 
     return pos
 
-def kececi_layout_v4_networkit(graph: nk.graph.Graph,
-                               primary_spacing=1.0,
-                               secondary_spacing=1.0,
-                               primary_direction='top-down',
-                               secondary_start='right'):
-    """
-    Keçeci Layout v4 - Networkit graf düğümlerine sıralı-zigzag yerleşimi sağlar.
-
-    Parametreler:
-    -------------
-    graph : networkit.graph.Graph
-        Kenar ve düğüm bilgisi içeren Networkit graf nesnesi.
-    primary_spacing : float
-        Ana yön mesafesi.
-    secondary_spacing : float
-        Yan yön mesafesi.
-    primary_direction : str
-        'top-down', 'bottom-up', 'left-to-right', 'right-to-left'.
-    secondary_start : str
-        Başlangıç yönü ('right', 'left', 'up', 'down').
-
-    Dönüş:
-    ------
-    dict[int, tuple[float, float]]
-        Her düğüm ID'sinin (Networkit'te genelde integer olur)
-        koordinatını içeren sözlük.
+
+def kececi_layout_networkit(graph: "nk.graph.Graph", primary_spacing=1.0, secondary_spacing=1.0,
+                            primary_direction='top_down', secondary_start='right',
+                           expanding=True):
     """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi Layout - Provides a sequential-zigzag layout for nodes in a NetworKit graph.
 
-    # Networkit'te düğüm ID'leri genellikle 0'dan N-1'e sıralıdır,
-    # ancak garantiye almak için sıralı bir liste alalım.
-    # iterNodes() düğüm ID'lerini döndürür.
+    Args:
+        graph (networkit.graph.Graph): A NetworKit graph object.
+        primary_spacing (float): The distance on the primary axis.
+        secondary_spacing (float): The distance on the secondary axis.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
+        secondary_start (str): The starting direction for the offset ('right', 'left', 'up', 'down').
+
+    Returns:
+        dict[int, tuple[float, float]]: A dictionary containing the coordinate
+        for each node ID (typically an integer in NetworKit).
+    """
+    # In NetworKit, node IDs are generally sequential, but let's get a sorted
+    # list to be safe. iterNodes() returns the node IDs.
     try:
-        # Networkit'te node ID'lerinin contiguous (0..n-1) olup olmadığını kontrol edebiliriz
-        # ama her zaman böyle olmayabilir. iterNodes en genel yöntem.
         nodes = sorted(list(graph.iterNodes()))
     except Exception as e:
-        print(f"Networkit düğüm listesi alınırken hata: {e}")
-        # Alternatif olarak, eğer ID'lerin 0'dan başladığı varsayılıyorsa:
-        # nodes = list(range(graph.numberOfNodes()))
-        # Ancak iterNodes daha güvenlidir.
-        return {} # Hata durumunda boş dön
+        print(f"Error getting NetworKit node list: {e}")
+        return {}  # Return empty on error
 
-    num_nodes = len(nodes) # Veya graph.numberOfNodes()
+    num_nodes = len(nodes)
     if num_nodes == 0:
-        return {}  # Boş graf için boş sözlük döndür
+        return {}
 
-    pos = {}  # Sonuç sözlüğü
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    pos = {}
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
-    # Parametre kontrolleri
     if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
     if is_vertical and secondary_start not in ['right', 'left']:
-        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for vertical primary_direction ('{primary_direction}'). Use 'right' or 'left'.")
+        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for vertical primary_direction. Use 'right' or 'left'.")
     if is_horizontal and secondary_start not in ['up', 'down']:
-         raise ValueError(f"Invalid secondary_start ('{secondary_start}') for horizontal primary_direction ('{primary_direction}'). Use 'up' or 'down'.")
+        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for horizontal primary_direction. Use 'up' or 'down'.")
 
-    # Ana döngü
+    # Main loop
     for i, node_id in enumerate(nodes):
-        # i: Düğümün sıralı listedeki indeksi (0, 1, 2, ...) - Yerleşim için kullanılır
-        # node_id: Gerçek Networkit düğüm ID'si - Sonuç sözlüğünün anahtarı
-
-        # 1. Ana eksen koordinatını hesapla
-        if 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'
+        # i: The index in the sorted list (0, 1, 2, ...), used for positioning.
+        # node_id: The actual NetworKit node ID, used as the key in the result dictionary.
+        
+        # 1. Calculate Primary Axis Coordinate
+        if primary_direction == 'top_down':
+            primary_coord, secondary_axis = i * -primary_spacing, 'x'
+        elif primary_direction == 'bottom_up':
+            primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
-            primary_coord = i * primary_spacing
-            secondary_axis = 'y'
-        else: # primary_direction == 'right-to-left'
-            primary_coord = i * -primary_spacing
-            secondary_axis = 'y'
-
-        # 2. Yan eksen ofsetini hesapla (zigzag)
-        if i == 0:
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
-            side = 1 if i % 2 != 0 else -1
-            secondary_offset_multiplier = start_mult * magnitude * side
-
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            primary_coord, secondary_axis = i * primary_spacing, 'y'
+        else: # 'right-to-left'
+            primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        # 3. (x, y) koordinatlarını ata
-        if secondary_axis == 'x':
-            x, y = secondary_coord, primary_coord
-        else: # secondary_axis == 'y'
-            x, y = primary_coord, secondary_coord
+        # 2. Calculate Secondary Axis Offset
+        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
 
-        # Sonuç sözlüğüne ekle: anahtar=düğüm ID, değer=(x, y) tuple'ı
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_id] = (x, y)
 
     return pos
 
-def kececi_layout_v4_gg(graph_set: gg.GraphSet,
-                                 primary_spacing=1.0,
-                                 secondary_spacing=1.0,
-                                 primary_direction='top-down',
-                                 secondary_start='right'):
-    """
-    Keçeci Layout v4 - Graphillion evren grafının düğümlerine
-    sıralı-zigzag yerleşimi sağlar.
+
+def kececi_layout_gg(graph_set: "gg.GraphSet", primary_spacing=1.0, secondary_spacing=1.0,
+                              primary_direction='top_down', secondary_start='right',
+                           expanding=True):
     """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi Layout - Provides a sequential-zigzag layout for nodes in a Graphillion universe.
 
-    # DÜZELTME: Evrenden kenar listesini al
+    Args:
+        graph_set (graphillion.GraphSet): A Graphillion GraphSet object.
+        primary_spacing (float): The distance on the primary axis.
+        secondary_spacing (float): The distance on the secondary axis.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
+        secondary_start (str): The starting direction for the offset ('right', 'left', 'up', 'down').
+    Returns:
+        dict: A dictionary of positions keyed by node ID.
+    """
+    # CORRECTION: Get the edge list from the universe.
     edges_in_universe = graph_set.universe()
-
-    # DÜZELTME: Düğüm sayısını kenarlardan türet
+    # CORRECTION: Derive the number of nodes from the edges.
     num_vertices = find_max_node_id(edges_in_universe)
 
     if num_vertices == 0:
         return {}
 
-    # Graphillion genellikle 1-tabanlı düğüm indekslemesi kullanır.
-    # Düğüm ID listesini oluştur: 1, 2, ..., num_vertices
-    nodes = list(range(1, num_vertices + 1)) # En yüksek ID'ye kadar tüm nodları varsay
+    # Graphillion often uses 1-based node indexing.
+    # Create the node ID list: 1, 2, ..., num_vertices
+    nodes = list(range(1, num_vertices + 1))
 
-    pos = {}  # Sonuç sözlüğü
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    pos = {}
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
-    # Parametre kontrolleri (değişiklik yok)
     if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
     if is_vertical and secondary_start not in ['right', 'left']:
-        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for vertical primary_direction ('{primary_direction}'). Use 'right' or 'left'.")
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
     if is_horizontal and secondary_start not in ['up', 'down']:
-         raise ValueError(f"Invalid secondary_start ('{secondary_start}') for horizontal primary_direction ('{primary_direction}'). Use 'up' or 'down'.")
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
 
-    # Ana döngü (değişiklik yok)
     for i, node_id in enumerate(nodes):
-        # ... (Koordinat hesaplama kısmı aynı kalır) ...
-        if 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'
+        if primary_direction == 'top_down':
+            primary_coord, secondary_axis = i * -primary_spacing, 'x'
+        elif primary_direction == 'bottom_up':
+            primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
-            primary_coord = i * primary_spacing; 
-            secondary_axis = 'y'
+            primary_coord, secondary_axis = i * primary_spacing, 'y'
         else: # right-to-left
-            primary_coord = i * -primary_spacing; 
-            secondary_axis = 'y'
+            primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        if i == 0: 
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        if secondary_axis == 'x': 
-            x, y = secondary_coord, primary_coord
-        else: 
-            x, y = primary_coord, secondary_coord
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_id] = (x, y)
 
     return pos
 
-def kececi_layout_v4_graphillion(graph_set: gg.GraphSet,
-                                 primary_spacing=1.0,
-                                 secondary_spacing=1.0,
-                                 primary_direction='top-down',
-                                 secondary_start='right'):
-    """
-    Keçeci Layout v4 - Graphillion evren grafının düğümlerine
-    sıralı-zigzag yerleşimi sağlar.
+
+def kececi_layout_graphillion(graph_set: "gg.GraphSet", primary_spacing=1.0, secondary_spacing=1.0,
+                              primary_direction='top_down', secondary_start='right',
+                           expanding=True):
     """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi Layout - Provides a sequential-zigzag layout for nodes in a Graphillion universe.
 
-    # DÜZELTME: Evrenden kenar listesini al
+    Args:
+        graph_set (graphillion.GraphSet): A Graphillion GraphSet object.
+        primary_spacing (float): The distance on the primary axis.
+        secondary_spacing (float): The distance on the secondary axis.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
+        secondary_start (str): The starting direction for the offset ('right', 'left', 'up', 'down').
+    Returns:
+        dict: A dictionary of positions keyed by node ID.
+    """
+    # CORRECTION: Get the edge list from the universe.
     edges_in_universe = graph_set.universe()
-
-    # DÜZELTME: Düğüm sayısını kenarlardan türet
+    # CORRECTION: Derive the number of nodes from the edges.
     num_vertices = find_max_node_id(edges_in_universe)
 
     if num_vertices == 0:
         return {}
 
-    # Graphillion genellikle 1-tabanlı düğüm indekslemesi kullanır.
-    # Düğüm ID listesini oluştur: 1, 2, ..., num_vertices
-    nodes = list(range(1, num_vertices + 1)) # En yüksek ID'ye kadar tüm nodları varsay
+    # Graphillion often uses 1-based node indexing.
+    # Create the node ID list: 1, 2, ..., num_vertices
+    nodes = list(range(1, num_vertices + 1))
 
-    pos = {}  # Sonuç sözlüğü
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    pos = {}
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
 
-    # Parametre kontrolleri (değişiklik yok)
     if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
     if is_vertical and secondary_start not in ['right', 'left']:
-        raise ValueError(f"Invalid secondary_start ('{secondary_start}') for vertical primary_direction ('{primary_direction}'). Use 'right' or 'left'.")
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
     if is_horizontal and secondary_start not in ['up', 'down']:
-         raise ValueError(f"Invalid secondary_start ('{secondary_start}') for horizontal primary_direction ('{primary_direction}'). Use 'up' or 'down'.")
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
 
-    # Ana döngü (değişiklik yok)
     for i, node_id in enumerate(nodes):
-        # ... (Koordinat hesaplama kısmı aynı kalır) ...
-        if 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'
+        if primary_direction == 'top_down':
+            primary_coord, secondary_axis = i * -primary_spacing, 'x'
+        elif primary_direction == 'bottom_up':
+            primary_coord, secondary_axis = i * primary_spacing, 'x'
         elif primary_direction == 'left-to-right':
-            primary_coord = i * primary_spacing; 
-            secondary_axis = 'y'
+            primary_coord, secondary_axis = i * primary_spacing, 'y'
         else: # right-to-left
-            primary_coord = i * -primary_spacing; 
-            secondary_axis = 'y'
+            primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        if i == 0: 
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        if secondary_axis == 'x': 
-            x, y = secondary_coord, primary_coord
-        else: 
-            x, y = primary_coord, secondary_coord
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_id] = (x, y)
 
     return pos
 
-def kececi_layout_v4_rx(graph: 
-                        rx.PyGraph, primary_spacing=1.0, secondary_spacing=1.0,
-                        primary_direction='top-down', secondary_start='right'):
+
+def kececi_layout_rx(graph: "rx.PyGraph", primary_spacing=1.0, secondary_spacing=1.0,
+                            primary_direction='top_down', secondary_start='right',
+                           expanding=True):
+    """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi layout for a Rustworkx PyGraph object.
+
+    Args:
+        graph (rustworkx.PyGraph): A Rustworkx graph object.
+        primary_spacing (float): The spacing between nodes on the primary axis.
+        secondary_spacing (float): The offset spacing on the secondary axis.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
+        secondary_start (str): Initial direction for the offset ('right', 'left', 'up', 'down').
+
+    Returns:
+        dict: A dictionary of positions keyed by node index, where values are numpy arrays.
+    """
     pos = {}
     nodes = sorted(graph.node_indices())
     num_nodes = len(nodes)
-    if num_nodes == 0: 
+    if num_nodes == 0:
         return {}
 
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
-    if not (is_vertical or is_horizontal): 
+    if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
-    if is_vertical and secondary_start not in ['right', 'left']: 
-        raise ValueError(f"Invalid secondary_start for vertical: {secondary_start}")
-    if is_horizontal and secondary_start not in ['up', 'down']: 
-        raise ValueError(f"Invalid secondary_start for horizontal: {secondary_start}")
+    if is_vertical and secondary_start not in ['right', 'left']:
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
+    if is_horizontal and secondary_start not in ['up', 'down']:
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
 
     for i, node_index in enumerate(nodes):
-        if primary_direction == 'top-down': 
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up': 
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
-        elif primary_direction == 'left-to-right': 
+        elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: 
+        else:
             primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        if i == 0: 
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_index] = np.array([x, y])
+        
     return pos
 
-def kececi_layout_v4_rustworkx(graph: 
-                               rx.PyGraph, primary_spacing=1.0, secondary_spacing=1.0,
-                        primary_direction='top-down', secondary_start='right'):
+
+def kececi_layout_rustworkx(graph: "rx.PyGraph", primary_spacing=1.0, secondary_spacing=1.0,
+                            primary_direction='top_down', secondary_start='right',
+                           expanding=True):
+    """
+    Expanding Kececi Layout: Progresses along the primary axis, with an offset
+    on the secondary axis.
+    Kececi layout for a Rustworkx PyGraph object.
+
+    Args:
+        graph (rustworkx.PyGraph): A Rustworkx graph object.
+        primary_spacing (float): The spacing between nodes on the primary axis.
+        secondary_spacing (float): The offset spacing on the secondary axis.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', 'right-to-left'.
+        secondary_start (str): Initial direction for the offset ('right', 'left', 'up', 'down').
+
+    Returns:
+        dict: A dictionary of positions keyed by node index, where values are numpy arrays.
+    """
     pos = {}
     nodes = sorted(graph.node_indices())
     num_nodes = len(nodes)
-    if num_nodes == 0: 
+    if num_nodes == 0:
         return {}
 
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
     is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
-    if not (is_vertical or is_horizontal): 
+    if not (is_vertical or is_horizontal):
         raise ValueError(f"Invalid primary_direction: {primary_direction}")
-    if is_vertical and secondary_start not in ['right', 'left']: 
-        raise ValueError(f"Invalid secondary_start for vertical: {secondary_start}")
-    if is_horizontal and secondary_start not in ['up', 'down']: 
-        raise ValueError(f"Invalid secondary_start for horizontal: {secondary_start}")
+    if is_vertical and secondary_start not in ['right', 'left']:
+        raise ValueError(f"Invalid secondary_start for vertical direction: {secondary_start}")
+    if is_horizontal and secondary_start not in ['up', 'down']:
+        raise ValueError(f"Invalid secondary_start for horizontal direction: {secondary_start}")
 
     for i, node_index in enumerate(nodes):
-        if primary_direction == 'top-down': 
+        if primary_direction == 'top_down':
             primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up': 
+        elif primary_direction == 'bottom_up':
             primary_coord, secondary_axis = i * primary_spacing, 'x'
-        elif primary_direction == 'left-to-right': 
+        elif primary_direction == 'left-to-right':
             primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: 
+        else:
             primary_coord, secondary_axis = i * -primary_spacing, 'y'
 
-        if i == 0: 
-            secondary_offset_multiplier = 0.0
-        else:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
+        # 2. Calculate Secondary Axis Offset
+        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_multiplier = start_mult * magnitude * side
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
 
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
+        # 3. Assign Coordinates
+        x, y = (secondary_offset, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_offset)
         pos[node_index] = np.array([x, y])
+        
+    return pos
+
+def kececi_layout_pure(nodes, primary_spacing=1.0, secondary_spacing=1.0,
+                         primary_direction='top_down', secondary_start='right',
+                         expanding=True):
+    """
+    Calculates 2D sequential-zigzag coordinates for a given list of nodes.
+    This function does not require any external graph library.
+
+    Args:
+        nodes (iterable): A list or other iterable containing the node IDs to be positioned.
+        primary_spacing (float): The distance between nodes along the primary axis.
+        secondary_spacing (float): The base unit for the zigzag offset.
+        primary_direction (str): 'top_down', 'bottom_up', 'left-to-right', or 'right-to-left'.
+        secondary_start (str): The initial direction for the zigzag ('up', 'down', 'left', 'right').
+        expanding (bool): If True (default), the zigzag offset grows.
+                          If False, the offset is constant (resulting in parallel lines).
+
+    Returns:
+        dict: A dictionary of positions formatted as {node_id: (x, y)}.
+    """
+    try:
+        # Try to sort the nodes for a consistent output.
+        sorted_nodes = sorted(list(nodes))
+    except TypeError:
+        # For unsortable nodes (e.g., mixed types), keep the original order.
+        sorted_nodes = list(nodes)
+
+    pos = {}
+    
+    # --- Direction Validation Block ---
+    is_vertical = primary_direction in ['top_down', 'bottom_up']
+    is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
+
+    if not (is_vertical or is_horizontal):
+        raise ValueError(f"Invalid primary_direction: '{primary_direction}'")
+    if is_vertical and secondary_start not in ['right', 'left']:
+        raise ValueError(f"Invalid secondary_start for vertical direction: '{secondary_start}'")
+    if is_horizontal and secondary_start not in ['up', 'down']:
+        raise ValueError(f"Invalid secondary_start for horizontal direction: '{secondary_start}'")
+    # --- End of Block ---
+
+    for i, node_id in enumerate(sorted_nodes):
+        # 1. Calculate the Primary Axis Coordinate
+        primary_coord = 0.0
+        secondary_axis = ''
+        if primary_direction == 'top_down':
+            primary_coord, secondary_axis = i * -primary_spacing, 'x'
+        elif primary_direction == 'bottom_up':
+            primary_coord, secondary_axis = i * primary_spacing, 'x'
+        elif primary_direction == 'left-to-right':
+            primary_coord, secondary_axis = i * primary_spacing, 'y'
+        else:  # 'right-to-left'
+            primary_coord, secondary_axis = i * -primary_spacing, 'y'
+
+        # 2. Calculate the Secondary Axis Offset
+        secondary_offset = 0.0
+        if i > 0:
+            start_multiplier = 1.0 if secondary_start in ['right', 'up'] else -1.0
+            
+            # Determine the offset magnitude based on the 'expanding' flag.
+            magnitude = math.ceil(i / 2.0) if expanding else 1.0
+            
+            # Determine the zigzag side (e.g., left vs. right).
+            side = 1 if i % 2 != 0 else -1
+
+            # Calculate the final offset.
+            secondary_offset = start_multiplier * magnitude * side * secondary_spacing
+
+        # 3. Assign the (x, y) Coordinates
+        x, y = ((secondary_offset, primary_coord) if secondary_axis == 'x' else
+                (primary_coord, secondary_offset))
+        pos[node_id] = (x, y)
+        
     return pos
 
 # =============================================================================
@@ -909,61 +995,8 @@ def generate_random_rx_graph(min_nodes=5, max_nodes=15, edge_prob_min=0.15, edge
     print(f"Oluşturulan Rustworkx Graf: {G.num_nodes()} Düğüm, {G.num_edges()} Kenar (Başlangıç p={edge_probability:.3f})")
     return G
 
-
-def kececi_layout_v4_pure(nodes, primary_spacing=1.0, secondary_spacing=1.0,
-                              primary_direction='top-down', secondary_start='right'):
-    """
-    Keçeci layout mantığını kullanarak düğüm pozisyonlarını hesaplar.
-    Sadece standart Python ve math modülünü kullanır.
-    """
-    pos = {}
-    # Tutarlı sıra garantisi için düğümleri sırala
-    # Girdi zaten liste/tuple olsa bile kopyasını oluşturup sırala
-    # ... (Bir önceki cevaptaki fonksiyonun TAMAMI buraya yapıştırılacak) ...
-    try:
-        sorted_nodes = sorted(list(nodes))
-    except TypeError:
-        print("Uyarı: Düğümler sıralanamadı...")
-        sorted_nodes = list(nodes)
-
-    num_nodes = len(sorted_nodes)
-    if num_nodes == 0: 
-        return {}
-    is_vertical = primary_direction in ['top-down', 'bottom-up']
-    is_horizontal = primary_direction in ['left-to-right', 'right-to-left']
-    if not (is_vertical or is_horizontal): 
-        raise ValueError(f"Invalid primary_direction: {primary_direction}")
-    if is_vertical and secondary_start not in ['right', 'left']: 
-        raise ValueError(f"Dikey yön için geçersiz secondary_start: {secondary_start}")
-    if is_horizontal and secondary_start not in ['up', 'down']: 
-        raise ValueError(f"Yatay yön için geçersiz secondary_start: {secondary_start}")
-
-    for i, node_id in enumerate(sorted_nodes):
-        primary_coord = 0.0
-        secondary_axis = ''
-        if primary_direction == 'top-down': 
-            primary_coord, secondary_axis = i * -primary_spacing, 'x'
-        elif primary_direction == 'bottom-up': 
-            primary_coord, secondary_axis = i * primary_spacing, 'x'
-        elif primary_direction == 'left-to-right': 
-            primary_coord, secondary_axis = i * primary_spacing, 'y'
-        else: 
-            primary_coord, secondary_axis = i * -primary_spacing, 'y'
-
-        secondary_offset_multiplier = 0.0
-        if i > 0:
-            start_mult = 1.0 if secondary_start in ['right', 'up'] else -1.0
-            magnitude = math.ceil(i / 2.0)
-            side = 1 if i % 2 != 0 else -1
-            secondary_offset_multiplier = start_mult * magnitude * side
-        secondary_coord = secondary_offset_multiplier * secondary_spacing
-
-        x, y = (secondary_coord, primary_coord) if secondary_axis == 'x' else (primary_coord, secondary_coord)
-        pos[node_id] = (x, y)
-    return pos
-
 # =============================================================================
-# Rastgele Graf Oluşturma Fonksiyonu (NetworkX) - Değişiklik yok
+# Rastgele Graf Oluşturma Fonksiyonu (NetworkX)
 # =============================================================================
 def generate_random_graph(min_nodes=0, max_nodes=200, edge_prob_min=0.15, edge_prob_max=0.4):
 
@@ -1237,3 +1270,5 @@ if __name__ == '__main__':
     plt.tight_layout(rect=[0, 0, 1, 0.96])
     plt.show()
 
+
+