py3plex 2.0.8__tar.gz → 2.0.92__tar.gz

{py3plex-2.0.8/py3plex.egg-info → py3plex-2.0.92}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py3plex
-Version: 2.0.8
+Version: 2.0.92
 Summary: A Multilayer network analysis python3 library
 Author-email: Blaž Škrlj <blaz.skrlj@ijs.si>
 License: MIT
@@ -34,6 +34,7 @@ Requires-Dist: bitarray>=2.0.0
 Requires-Dist: seaborn>=0.11.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: tomli>=1.1.0; python_version < "3.11" and extra == "dev"
 Requires-Dist: pytest-timeout>=2.1; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
 Requires-Dist: pytest-benchmark<5.0,>=4.0; extra == "dev"
@@ -49,6 +50,7 @@ Requires-Dist: z3-solver>=4.12.0; extra == "dev"
 Requires-Dist: hypothesis>=6.0; extra == "dev"
 Provides-Extra: tests
 Requires-Dist: pytest>=7.0; extra == "tests"
+Requires-Dist: tomli>=1.1.0; python_version < "3.11" and extra == "tests"
 Requires-Dist: pytest-timeout>=2.1; extra == "tests"
 Requires-Dist: pytest-cov>=4.0; extra == "tests"
 Requires-Dist: pytest-rerunfailures>=12.0; extra == "tests"
@@ -120,8 +122,8 @@ Dynamic: license-file
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/py3plex)](https://pypistats.org/packages/py3plex)
 ![CLI Tool](https://img.shields.io/badge/CLI%20Tool-Available-brightgreen)
 ![Docker](https://img.shields.io/badge/Docker-Available-blue)
-![Lines of Code](https://img.shields.io/badge/lines-213.8K-blue)
-![Test Count](https://img.shields.io/badge/tests-9.7K-blue)
+![Lines of Code](https://img.shields.io/badge/lines-214.7K-blue)
+![Test Count](https://img.shields.io/badge/tests-9.9K-blue)
 
 *Multilayer networks* are complex networks with additional information assigned to nodes or edges (or both). This library includes
 some of the state-of-the-art algorithms for decomposition, visualization and analysis of such networks.
@@ -301,6 +303,8 @@ Safety notes for contributors:
 - Prefer running targeted tests first, then broader checks before opening a PR.
 - For docs-only updates, run `make docs-check` before opening a PR.
 
+To report a bug, request a feature, or ask for help using py3plex, open an issue in the [issue tracker](https://github.com/SkBlaz/py3plex/issues). Include a minimal example and the py3plex and Python versions where relevant.
+
 ### MCP Integration (AI Agents)
 
 py3plex provides a Model Context Protocol (MCP) server for integration with AI coding assistants:

{py3plex-2.0.8 → py3plex-2.0.92}/README.md

@@ -16,8 +16,8 @@
 [![PyPI - Downloads](https://img.shields.io/pypi/dm/py3plex)](https://pypistats.org/packages/py3plex)
 ![CLI Tool](https://img.shields.io/badge/CLI%20Tool-Available-brightgreen)
 ![Docker](https://img.shields.io/badge/Docker-Available-blue)
-![Lines of Code](https://img.shields.io/badge/lines-213.8K-blue)
-![Test Count](https://img.shields.io/badge/tests-9.7K-blue)
+![Lines of Code](https://img.shields.io/badge/lines-214.7K-blue)
+![Test Count](https://img.shields.io/badge/tests-9.9K-blue)
 
 *Multilayer networks* are complex networks with additional information assigned to nodes or edges (or both). This library includes
 some of the state-of-the-art algorithms for decomposition, visualization and analysis of such networks.
@@ -197,6 +197,8 @@ Safety notes for contributors:
 - Prefer running targeted tests first, then broader checks before opening a PR.
 - For docs-only updates, run `make docs-check` before opening a PR.
 
+To report a bug, request a feature, or ask for help using py3plex, open an issue in the [issue tracker](https://github.com/SkBlaz/py3plex/issues). Include a minimal example and the py3plex and Python versions where relevant.
+
 ### MCP Integration (AI Agents)
 
 py3plex provides a Model Context Protocol (MCP) server for integration with AI coding assistants:

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/_version.py

@@ -1,3 +1,3 @@
 """Single source for py3plex release version metadata."""
 
-__version__ = "2.0.8"
+__version__ = "2.0.92"

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/agent.py

@@ -46,7 +46,7 @@ def load_network_from_path(
     """Load a network from path and return stable machine-facing payload."""
     net = multinet.multi_layer_network(directed=directed)
     net.load_network(path, input_type=input_type)
-    layers = list(net.get_layers())
+    layers = net.layers
     return {
         "status": "ok",
         "assumptions": ["Network path is trusted and readable."],

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/algorithms/attribute_correlation.py

@@ -200,11 +200,11 @@ def correlate_attributes_across_layers(
     for i, l1 in enumerate(layers):
         for l2 in layers[i+1:]:
             # Find common nodes
-            common_nodes = set(layer_attrs[l1].keys()) & set(layer_attrs[l2].keys())
+            common_nodes = [node for node in layer_attrs[l1] if node in layer_attrs[l2]]
             
             if len(common_nodes) > 1:
-                vals1 = np.array([layer_attrs[l1][node] for node in sorted(common_nodes)])
-                vals2 = np.array([layer_attrs[l2][node] for node in sorted(common_nodes)])
+                vals1 = np.array([layer_attrs[l1][node] for node in common_nodes])
+                vals2 = np.array([layer_attrs[l2][node] for node in common_nodes])
                 
                 corr, pval = _compute_correlation(vals1, vals2, correlation_method)
                 results[(l1, l2)] = (corr, pval)

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/algorithms/centrality/approx_betweenness.py

@@ -77,7 +77,8 @@ def _brandes_sssp_weighted(
         - dist: Dict mapping each node to distance from source (inf if unreachable)
     """
     import heapq
-    
+    from itertools import count
+
     S = []
     P = {v: [] for v in G}
     sigma = dict.fromkeys(G, 0.0)
@@ -85,22 +86,28 @@ def _brandes_sssp_weighted(
     dist = {v: float('inf') for v in G}
     dist[source] = 0.0
     seen = {source: 0.0}
-    # Priority queue: (distance, node)
-    Q = [(0.0, source)]
+    # A unique tie-breaker avoids comparing arbitrary node identifiers.
+    counter = count()
+    Q = [(0.0, next(counter), source)]
     
     while Q:
-        (dist_v, v) = heapq.heappop(Q)
+        (dist_v, _, v) = heapq.heappop(Q)
         if dist_v > seen.get(v, float('inf')):
             continue  # Already processed with shorter distance
         S.append(v)
         
         for w in G.neighbors(v):
-            # Get edge weight
-            vw_dist = dist[v] + G[v][w].get(weight, 1.0)
+            # NetworkX shortest paths use the minimum parallel-edge weight.
+            edge_data = G[v][w]
+            if G.is_multigraph():
+                edge_weight = min(data.get(weight, 1.0) for data in edge_data.values())
+            else:
+                edge_weight = edge_data.get(weight, 1.0)
+            vw_dist = dist[v] + edge_weight
             if vw_dist < dist[w]:
                 dist[w] = vw_dist
                 seen[w] = vw_dist
-                heapq.heappush(Q, (vw_dist, w))
+                heapq.heappush(Q, (vw_dist, next(counter), w))
                 sigma[w] = 0.0
                 P[w] = []
             if vw_dist == dist[w]:
@@ -204,9 +211,9 @@ def approximate_betweenness_sampling(
                 sumsq_c[v] += x * x
     
     # Scale to estimate sum over all sources
-    # Estimator: (N-1) / n_samples * sum_over_samples
-    # This is unbiased when sampling with replacement
-    scale = (N - 1) / float(n_samples)
+    # Sources are sampled uniformly from all N nodes, including each target.
+    # The estimated population total is N times the sample mean.
+    scale = N / float(n_samples)
     betw = {v: scale * sum_c[v] for v in nodes}
     
     # Compute standard error if requested
@@ -217,8 +224,9 @@ def approximate_betweenness_sampling(
             mean = sum_c[v] / n_samples
             # Sample variance: E[X^2] - E[X]^2
             var = max(0.0, (sumsq_c[v] / n_samples) - mean * mean)
-            # Standard error of scaled mean: scale * sqrt(var / n_samples)
-            stderr[v] = scale * math.sqrt(var / n_samples) if var > 0 else 0.0
+            # The estimate is N times the sample mean, so its standard error
+            # scales by N (not the N / n_samples factor applied to the sum).
+            stderr[v] = N * math.sqrt(var / n_samples) if var > 0 else 0.0
     
     # Apply normalization and undirected correction
     # For undirected graphs, betweenness counts each path twice

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/algorithms/centrality/approx_closeness.py

@@ -56,7 +56,8 @@ def _allocate_landmarks(
     
     Args:
         components: List of connected components (sets of nodes)
-        n_landmarks: Total number of landmarks to allocate
+        n_landmarks: Requested total, expanded if needed to cover each
+            non-trivial component
         
     Returns:
         List of landmark counts for each component (at least 1 for each non-trivial component)
@@ -64,31 +65,24 @@ def _allocate_landmarks(
     if not components:
         return []
     
-    # Compute component sizes
-    sizes = [len(c) for c in components]
-    total_size = sum(sizes)
-    
-    if total_size == 0:
-        return [0] * len(components)
-    
-    # Allocate proportionally, with at least 1 for non-trivial components
-    allocation = []
-    remaining = n_landmarks
-    
-    for i, size in enumerate(sizes):
-        if size == 1:
-            # Singleton component - no landmarks needed
-            allocation.append(0)
-        elif i == len(sizes) - 1:
-            # Last component gets remaining landmarks
-            allocation.append(max(1, remaining))
-        else:
-            # Allocate proportionally, at least 1
-            count = max(1, int(round(n_landmarks * size / total_size)))
-            count = min(count, remaining - (len(sizes) - i - 1))  # Save at least 1 for each remaining
-            allocation.append(count)
-            remaining -= count
-    
+    allocation = [0] * len(components)
+    active = [i for i, comp in enumerate(components) if len(comp) > 1]
+    if not active:
+        return allocation
+
+    # Cover every non-trivial component, then apportion the remaining budget.
+    # A budget below the component count is expanded to retain that guarantee.
+    remaining = max(n_landmarks, len(active)) - len(active)
+    total_size = sum(len(components[i]) for i in active)
+    remainders = {}
+    for i in active:
+        extra, remainder = divmod(remaining * len(components[i]), total_size)
+        allocation[i] = 1 + extra
+        remainders[i] = remainder
+
+    leftover = max(n_landmarks, len(active)) - sum(allocation)
+    for i in sorted(active, key=lambda i: (-remainders[i], i))[:leftover]:
+        allocation[i] += 1
     return allocation
 
 
@@ -102,7 +96,8 @@ def approximate_closeness_landmarks(
     """Compute approximate closeness centrality using landmark sampling.
     
     For each node, this estimates closeness by computing average distance
-    to randomly sampled landmark nodes. For undirected graphs, components
+    from randomly sampled landmark nodes, matching NetworkX inward
+    closeness for directed graphs. For undirected graphs, components
     are handled separately to avoid biasing estimates.
     
     Args:
@@ -118,9 +113,12 @@ def approximate_closeness_landmarks(
         - stderr_dict: Per-node standard error (None if diagnostics=False)
         
     Note:
-        - For undirected graphs, landmarks are sampled per component
+        - For undirected graphs, landmarks are sampled per component, with at
+          least one per non-trivial component even if this exceeds n_landmarks
         - For directed graphs, landmarks are sampled globally
-        - Closeness is defined as 1 / (average distance to reachable nodes)
+        - Directed closeness uses inward distances from reachable nodes
+        - Self-landmarks are excluded from the average and reachable fraction
+        - Uses NetworkX default Wasserman-Faust scaling for disconnected graphs
         - Time complexity: O(n_landmarks * (m + n log n)) for weighted graphs
     """
     rng = random.Random(seed)
@@ -139,9 +137,11 @@ def approximate_closeness_landmarks(
         comp_landmarks = _allocate_landmarks(comps, n_landmarks)
         
         # Sample landmarks from each component
+        # Preserve graph insertion order; component sets vary with PYTHONHASHSEED.
+        node_order = {node: i for i, node in enumerate(nodes)}
         landmarks = []
         for comp, k in zip(comps, comp_landmarks):
-            comp_nodes = list(comp)
+            comp_nodes = sorted(comp, key=node_order.__getitem__)
             for _ in range(k):
                 landmarks.append(comp_nodes[rng.randrange(len(comp_nodes))])
         
@@ -156,11 +156,11 @@ def approximate_closeness_landmarks(
         node_to_comp = None
     
     # Compute distances from each landmark
-    # For directed graphs, we want distances TO landmarks, so we reverse
+    # Distances FROM landmarks estimate inward closeness for directed graphs.
     dist_maps = []
     for l in landmarks:
         dist = _single_source_shortest_path_lengths(
-            G, l, weight=weight, reverse_for_directed=G.is_directed()
+            G, l, weight=weight
         )
         dist_maps.append(dist)
     
@@ -169,7 +169,7 @@ def approximate_closeness_landmarks(
     stderr = {} if diagnostics else None
     
     for v in nodes:
-        # Collect distances from v to landmarks
+        # Collect distances from landmarks to v
         if node_to_comp is not None:
             # Undirected: use only landmarks from same component
             v_comp = node_to_comp[v]
@@ -177,11 +177,12 @@ def approximate_closeness_landmarks(
             for i, dist in enumerate(dist_maps):
                 landmark = landmarks[i]
                 l_comp = node_to_comp[landmark]
-                if l_comp == v_comp and v in dist:
+                if l_comp == v_comp and landmark != v and v in dist:
                     dists.append(dist[v])
         else:
             # Directed: use all landmarks
-            dists = [dist[v] for dist in dist_maps if v in dist]
+            dists = [dist[v] for landmark, dist in zip(landmarks, dist_maps)
+                     if landmark != v and v in dist]
         
         if not dists:
             # No reachable landmarks
@@ -199,12 +200,14 @@ def approximate_closeness_landmarks(
         else:
             base_closeness = 1.0 / mean_d
         
-        # For directed graphs, adjust by reachable fraction
+        # NetworkX excludes the node itself and applies the Wasserman-Faust
+        # reachable fraction. Self-landmarks are not draws from other nodes.
         if G.is_directed():
-            reachable_frac = len(dists) / float(len(landmarks)) if landmarks else 0.0
-            closeness[v] = base_closeness * reachable_frac
+            other_landmarks = sum(landmark != v for landmark in landmarks)
+            reachable_frac = len(dists) / float(other_landmarks)
         else:
-            closeness[v] = base_closeness
+            reachable_frac = (len(comps[v_comp]) - 1) / float(N - 1)
+        closeness[v] = base_closeness * reachable_frac
         
         # Compute standard error using delta method
         if diagnostics:
@@ -214,14 +217,10 @@ def approximate_closeness_landmarks(
                 # Standard error of mean
                 se_mean = math.sqrt(var_d / len(dists))
                 # Delta method: var(1/X) ≈ (se/mean^2)^2 for small se
-                stderr[v] = se_mean / (mean_d * mean_d)
+                stderr[v] = reachable_frac * se_mean / (mean_d * mean_d)
             else:
                 stderr[v] = 0.0
     
-    # Optional normalization (consistent with NetworkX)
-    # NetworkX closeness_centrality normalizes by (N-1) for simple graphs
-    # We keep raw estimates for now, but could add normalization flag if needed
-    
     return closeness, stderr
 
 

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/algorithms/layer_similarity.py

@@ -60,10 +60,12 @@ def jaccard_layer_similarity(
                 if isinstance(node, tuple) and len(node) >= 2 and node[1] == layer2}
     
     elif element == "edges":
-        set1 = {(u[0], v[0]) for u, v in G.edges() 
+        # Undirected edges are unordered, regardless of node insertion order.
+        edge_identity = tuple if G.is_directed() else frozenset
+        set1 = {edge_identity((u[0], v[0])) for u, v in G.edges()
                 if isinstance(u, tuple) and isinstance(v, tuple) and 
                 len(u) >= 2 and len(v) >= 2 and u[1] == layer1 and v[1] == layer1}
-        set2 = {(u[0], v[0]) for u, v in G.edges() 
+        set2 = {edge_identity((u[0], v[0])) for u, v in G.edges()
                 if isinstance(u, tuple) and isinstance(v, tuple) and 
                 len(u) >= 2 and len(v) >= 2 and u[1] == layer2 and v[1] == layer2}
     else:

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/algorithms/multilayer_algorithms/centrality.py

@@ -1011,7 +1011,7 @@ class MultilayerCentrality:
         # Map back to node-layer pairs
         results = {}
         for node_layer, idx in node_layer_mapping.items():
-            results[node_layer] = nx_current_flow.get(idx, 0.0)
+            results[node_layer] = max(0.0, nx_current_flow.get(idx, 0.0))
 
         return results
 

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/algorithms/temporal/centrality.py

@@ -28,6 +28,9 @@ def streaming_pagerank(
     incrementally, using the previous window's scores as the starting point
     for the next window. This is much faster than recomputing from scratch
     for each window.
+
+    Scores held by nodes without outgoing edges are redistributed uniformly
+    among the current window's nodes at each power iteration.
     
     Args:
         temporal_network: TemporalMultiLayerNetwork instance
@@ -97,6 +100,11 @@ def streaming_pagerank(
         # Run limited power iteration
         for _ in range(max_iter_per_window):
             new_scores = {}
+            dangling_mass = sum(
+                scores[node]
+                for node in nodes
+                if (graph.out_degree(node) if graph.is_directed() else graph.degree(node)) == 0
+            ) / len(nodes)
             
             for node in nodes:
                 # Compute incoming contribution
@@ -105,16 +113,24 @@ def streaming_pagerank(
                     if pred in scores:
                         # Get out-degree of predecessor
                         out_degree = graph.out_degree(pred) if graph.is_directed() else graph.degree(pred)
+                        if not graph.is_directed():
+                            # Degree counts self-loops twice; PageRank traverses them once.
+                            out_degree -= graph.number_of_edges(pred, pred)
                         if out_degree > 0:
-                            incoming_score += scores[pred] / out_degree
+                            edge_count = graph.number_of_edges(pred, node)
+                            incoming_score += scores[pred] * edge_count / out_degree
                 
                 # Apply damping
-                new_scores[node] = (1 - damping_factor) / len(nodes) + damping_factor * incoming_score
+                new_scores[node] = (
+                    (1 - damping_factor) / len(nodes)
+                    + damping_factor * (incoming_score + dangling_mass)
+                )
             
             # Check convergence
             if scores:
                 max_change = max(abs(new_scores.get(n, 0) - scores.get(n, 0)) for n in nodes)
                 if max_change < tolerance:
+                    scores = new_scores
                     break
             
             scores = new_scores
@@ -145,7 +161,8 @@ def streaming_degree_centrality(
         temporal_network: TemporalMultiLayerNetwork instance
         window_size: Size of each time window (required)
         step: Step size between windows (defaults to window_size)
-        normalize: Whether to normalize by max possible degree (default: True)
+        normalize: Whether to divide total degree by n - 1 (default: True).
+                   Directed, parallel, or self-loop degrees may yield values above 1.
         
     Yields:
         Tuples of (t_start, t_end, centrality_dict)
@@ -181,7 +198,7 @@ def streaming_degree_centrality(
         # Normalize if requested
         if normalize and degrees:
             n = graph.number_of_nodes()
-            max_degree = 2 * (n - 1) if not graph.is_directed() else (n - 1)
+            max_degree = n - 1
             if max_degree > 0:
                 degrees = {node: deg / max_degree for node, deg in degrees.items()}
         

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/benchmarks/runners.py

@@ -399,14 +399,19 @@ class AutoCommunityRunner(CommunityAlgorithmRunner):
         if uq_spec and uq_spec.get("n_samples", 0) > 1:
             uq_method = uq_spec.get("method", "seed")
             n_samples = uq_spec.get("n_samples", 10)
-            uq_seed = uq_spec.get("seed", seed or 42)
+            uq_seed = uq_spec.get("seed", seed if seed is not None else 42)
             ac = ac.uq(method=uq_method, n_samples=n_samples, seed=uq_seed)
 
         # Set selection mode
         if mode == "pareto":
             ac = ac.pareto()
         elif mode == "wins":
-            ac = ac.select_by_wins()
+            raise AlgorithmError(
+                "AutoCommunityRunner does not support mode='wins'. "
+                "Use mode='pareto' for benchmarks, or call "
+                "auto_select_community(..., mode='wins') directly.",
+                algorithm_name="autocommunity",
+            )
         else:
             ac = ac.pareto()
 

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/centrality/robustness.py

@@ -300,6 +300,15 @@ def _compute_avg_shortest_path(graph: multinet.multi_layer_network) -> float:
             continue
         
         subgraph = G.subgraph(comp)
+        if G.is_directed():
+            # Weak connectivity does not imply that every ordered pair is
+            # reachable. Count only reachable pairs, preserving direction.
+            for source, distances in nx.all_pairs_shortest_path_length(subgraph):
+                for target, distance in distances.items():
+                    if source != target:
+                        total_length += distance
+                        total_pairs += 1
+            continue
         try:
             # Use average_shortest_path_length for each component
             avg_len = nx.average_shortest_path_length(subgraph)

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/compat/sidecar.py

@@ -182,7 +182,9 @@ def _dict_to_dataframe(data: Dict[str, Any]) -> pd.DataFrame:
                 result[f"attrs_{col}"] = [
                     _encode_attr_value(item) for item in attrs_df[col].tolist()
                 ]
-        elif isinstance(value, list) and all(isinstance(item, dict) for item in value):
+        elif key == "attrs" and isinstance(value, list) and all(
+            isinstance(item, dict) for item in value
+        ):
             # List of dicts (attrs as records)
             attrs_df = pd.DataFrame(value)
             if row_count is not None:

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/core/lazy_evaluation.py

@@ -57,6 +57,19 @@ class LazyProperty:
         setattr(obj, cache_attr, value)
 
 
+class _IdentityKey:
+    """Hash a receiver by identity, keeping it alive while its entry is cached."""
+
+    def __init__(self, obj: Any) -> None:
+        self.obj = obj
+
+    def __hash__(self) -> int:
+        return id(self.obj)
+
+    def __eq__(self, other: Any) -> bool:
+        return isinstance(other, _IdentityKey) and self.obj is other.obj
+
+
 class CacheManager:
     """Manages caching for expensive network computations.
     
@@ -127,8 +140,13 @@ class CacheManager:
         def decorator(func: Callable) -> Callable:
             @functools.wraps(func)
             def wrapper(obj_self, *args, **kwargs):
-                # Generate cache key from function name and arguments
-                cache_key = cache_manager._generate_cache_key(func.__name__, args, kwargs)
+                # Scope results to the method and receiver as well as its arguments.
+                # Retaining the receiver prevents reuse of its identity after GC.
+                cache_key = (
+                    func,
+                    _IdentityKey(obj_self),
+                    cache_manager._generate_cache_key(func.__name__, args, kwargs),
+                )
                 cache = cache_manager.get_cache(cache_name)
                 
                 # Check if result is cached

{py3plex-2.0.8 → py3plex-2.0.92}/py3plex/core/multinet.py

@@ -360,7 +360,10 @@ def _encode_multilayer_network(core_network, directed):
         except (KeyError, IndexError, ValueError, TypeError):
             weight = 1
 
-        simple_graph.add_edge(nmap[node_first], nmap[node_second], weight=weight)
+        # A numeric adjacency entry is the sum of parallel edge weights.
+        u, v = nmap[node_first], nmap[node_second]
+        previous_weight = simple_graph.get_edge_data(u, v, {}).get("weight", 0.0)
+        simple_graph.add_edge(u, v, weight=previous_weight + weight)
 
     vectors = nx_to_scipy_sparse_matrix(simple_graph)
     return vectors, simple_graph.nodes()
@@ -620,6 +623,9 @@ class multi_layer_network:
         """Increment the mutation counter by 1 (no-op when suspended)."""
         if not self._suspend_version_bump:
             self._network_version += 1
+            # Matrix exports must be rebuilt from the new graph structure.
+            self.numeric_core_network = None
+            self.node_order_in_matrix = None
 
     # ═════════════════════════════════════════════════════════════════════════
     # Core Data Access Methods
@@ -824,8 +830,11 @@ class multi_layer_network:
     def layers(self) -> List[Any]:
         """List of unique layer identifiers in the network.
 
+        Comparable identifiers are sorted. Otherwise, layers retain their
+        first-occurrence order in the network.
+
         Returns:
-            list: Sorted list of layer identifiers
+            list: Layer identifiers in sorted or first-occurrence order
 
         Examples:
             >>> net = multi_layer_network()
@@ -839,9 +848,14 @@ class multi_layer_network:
         if self.core_network is None:
             return []
         try:
-            unique_layers = {n[1] for n in self.core_network.nodes()
-                            if isinstance(n, tuple) and len(n) >= 2}
-            return sorted(unique_layers)
+            unique_layers = dict.fromkeys(
+                n[1] for n in self.core_network.nodes()
+                if isinstance(n, tuple) and len(n) >= 2
+            )
+            try:
+                return sorted(unique_layers)
+            except TypeError:
+                return list(unique_layers)
         except (TypeError, IndexError):
             return []
 
@@ -871,7 +885,7 @@ class multi_layer_network:
         `split_to_layers()`) or defaults to the `layers` property.
 
         Returns:
-            list: Sorted list of layer identifiers
+            list: Layer identifiers using the ordering of the layers property
 
         Examples:
             >>> net = multi_layer_network()
@@ -973,7 +987,7 @@ class multi_layer_network:
     def load_network(
         self,
         input_file: Optional[str] = None,
-        directed: bool = False,
+        directed: Optional[bool] = None,
         input_type: str = "gml",
         label_delimiter: str = "---",
     ) -> "multi_layer_network":
@@ -989,10 +1003,12 @@ class multi_layer_network:
 
         Args:
             input_file: Path to the network file to load
-            directed: Whether the network is directed
+            directed: Whether the network is directed. If omitted or None,
+                retain the current setting (initially set by the constructor).
             input_type: Format of the input file. Supported values:
                 - 'gml': Graph Modeling Language format
-                - 'graphml': GraphML XML format
+                - 'graphml': GraphML XML format (node 'type' selects layer;
+                  missing types use the GraphML default or 'generic')
                 - 'edgelist': Simple edge list (source target [weight])
                 - 'multiedgelist': Multilayer edge list (node1 layer1 node2 layer2 weight)
                 - 'multiplex_edges': Multiplex format (layer node1 node2 weight)
@@ -1030,6 +1046,9 @@ class multi_layer_network:
         if input_type != "nx":
             assert input_file is not None, "input_file must be provided for non-nx input types"
 
+        if directed is None:
+            directed = self.directed
+
         self.input_file = input_file
         self.input_type = input_type
         self.directed = directed
@@ -1285,23 +1304,13 @@ class multi_layer_network:
             parsers.save_gpickle(self.core_network, output_file=output_file)
 
     def add_dummy_layers(self):
-        """
-        Internal function, for conversion between objects
-        """
-
-        self.tmp_core_network = self.core_network
-        self.core_network = self._create_graph()
-
-        for edge in self.tmp_core_network.edges():
-            self.add_edges(
-                {
-                    "source": edge[0],
-                    "target": edge[1],
-                    "source_type": self.dummy_layer,
-                    "target_type": self.dummy_layer,
-                }
-            )
-        del self.tmp_core_network
+        """Wrap monoplex nodes in the dummy layer, preserving graph data."""
+        graph_type = nx.MultiDiGraph if self.directed else nx.MultiGraph
+        # Copy the complete graph so isolates, attributes and multiedge keys
+        # survive. Rebuilding from bare edges loses all of that information.
+        self.core_network = nx.relabel_nodes(
+            graph_type(self.core_network), lambda node: (node, self.dummy_layer)
+        )
         return self
 
     def sparse_to_px(self, directed=None):
@@ -1317,6 +1326,7 @@ class multi_layer_network:
         self.core_network = nx_from_scipy_sparse_matrix(
             self.core_network, create_using=(nx.DiGraph() if directed else nx.Graph())
         )
+        self.directed = directed
         self.add_dummy_layers()
         self.sparse_enabled = False