py3plex 2.0.8__tar.gz → 2.0.93__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py3plex
-Version: 2.0.8
+Version: 2.0.93
 Summary: A Multilayer network analysis python3 library
 Author-email: Blaž Škrlj <blaz.skrlj@ijs.si>
 License: MIT
@@ -33,7 +33,8 @@ Requires-Dist: scikit-learn>=0.24.0
 Requires-Dist: bitarray>=2.0.0
 Requires-Dist: seaborn>=0.11.0
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest<9,>=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"
@@ -48,7 +49,8 @@ Requires-Dist: icontract>=2.6.0; extra == "dev"
 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: pytest<9,>=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"
@@ -116,12 +118,12 @@ Dynamic: license-file
 [![Formal Verification](https://github.com/SkBlaz/py3plex/actions/workflows/verify.yml/badge.svg)](https://github.com/SkBlaz/py3plex/actions/workflows/verify.yml)
 [![Lean formal verification](https://github.com/SkBlaz/py3plex/actions/workflows/formal.yml/badge.svg)](https://github.com/SkBlaz/py3plex/actions/workflows/formal.yml)
 [![Fuzzing](https://github.com/SkBlaz/py3plex/actions/workflows/fuzzing.yml/badge.svg)](https://github.com/SkBlaz/py3plex/actions/workflows/fuzzing.yml)
-[![PyPI version](https://img.shields.io/pypi/v/py3plex.svg?cacheSeconds=300)](https://pypi.org/project/py3plex/)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/py3plex)](https://pypistats.org/packages/py3plex)
+[![PyPI version](https://img.shields.io/pypi/v/py3plex)](https://pypi.org/project/py3plex/)
+[![PyPI downloads (last month)](https://img.shields.io/pypi/dm/py3plex?cacheSeconds=3600)](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.9K-blue)
+![Test Count](https://img.shields.io/badge/tests-10.0K-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.93}/README.md

@@ -12,12 +12,12 @@
 [![Formal Verification](https://github.com/SkBlaz/py3plex/actions/workflows/verify.yml/badge.svg)](https://github.com/SkBlaz/py3plex/actions/workflows/verify.yml)
 [![Lean formal verification](https://github.com/SkBlaz/py3plex/actions/workflows/formal.yml/badge.svg)](https://github.com/SkBlaz/py3plex/actions/workflows/formal.yml)
 [![Fuzzing](https://github.com/SkBlaz/py3plex/actions/workflows/fuzzing.yml/badge.svg)](https://github.com/SkBlaz/py3plex/actions/workflows/fuzzing.yml)
-[![PyPI version](https://img.shields.io/pypi/v/py3plex.svg?cacheSeconds=300)](https://pypi.org/project/py3plex/)
-[![PyPI - Downloads](https://img.shields.io/pypi/dm/py3plex)](https://pypistats.org/packages/py3plex)
+[![PyPI version](https://img.shields.io/pypi/v/py3plex)](https://pypi.org/project/py3plex/)
+[![PyPI downloads (last month)](https://img.shields.io/pypi/dm/py3plex?cacheSeconds=3600)](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.9K-blue)
+![Test Count](https://img.shields.io/badge/tests-10.0K-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.93}/py3plex/_version.py

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

{py3plex-2.0.8 → py3plex-2.0.93}/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.93}/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)
@@ -329,11 +329,11 @@ def _compute_correlation(x: np.ndarray, y: np.ndarray, method: str) -> Tuple[flo
     """
     valid_methods = ["pearson", "spearman", "kendall"]
     if method == "pearson":
-        return pearsonr(x, y)
+        result = pearsonr(x, y)
     elif method == "spearman":
-        return spearmanr(x, y)
+        result = spearmanr(x, y)
     elif method == "kendall":
-        return kendalltau(x, y)
+        result = kendalltau(x, y)
     else:
         from py3plex.errors import find_similar
         did_you_mean = find_similar(method, valid_methods)
@@ -349,6 +349,9 @@ def _compute_correlation(x: np.ndarray, y: np.ndarray, method: str) -> Tuple[flo
             did_you_mean=did_you_mean
         )
 
+    corr, pval = result
+    return float(np.clip(corr, -1.0, 1.0)), float(np.clip(pval, 0.0, 1.0))
+
 
 def multilayer_assortativity(
     network: Any,
@@ -613,3 +616,4 @@ def attribute_centrality_independence_test(
             'n_nodes': len(attrs)
         }
 
+

{py3plex-2.0.8 → py3plex-2.0.93}/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.93}/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.93}/py3plex/algorithms/hedwig/core/kb.py

@@ -44,7 +44,7 @@ class ExperimentKB:
         self._calc_predicate_members(triplets)
         self._find_roots(all_annotations)
         self._calc_members_closure()
-        self._calc_binary_members()
+        self._calc_binary_members(triplets)
         self._propagate_annotation_names(triplets)
 
         # Statistics
@@ -236,7 +236,7 @@ class ExperimentKB:
         # Run the closure from root
         closure(self.dummy_root, 0)
 
-    def _calc_binary_members(self):
+    def _calc_binary_members(self, g):
         self.binary_members = defaultdict(dict)
         self.reverse_binary_members = defaultdict(dict)
 
@@ -245,13 +245,13 @@ class ExperimentKB:
 
             for pair in pairs:
                 el1, el2 = self.uri_to_idx[pair[0]], self.uri_to_idx[pair[1]]
-                if self.binary_members[pred].has_key(el1):
+                if el1 in self.binary_members[pred]:
                     self.binary_members[pred][el1].append(el2)
                 else:
                     self.binary_members[pred][el1] = [el2]
 
                 # Add the reverse as well
-                if self.reverse_binary_members[pred].has_key(el2):
+                if el2 in self.reverse_binary_members[pred]:
                     self.reverse_binary_members[pred][el2].append(el1)
                 else:
                     self.reverse_binary_members[pred][el2] = [el1]

{py3plex-2.0.8 → py3plex-2.0.93}/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.93}/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.93}/py3plex/algorithms/statistics/bayesiantests.py

@@ -649,15 +649,6 @@ def plot_simplex(points, names=("C1", "C2"), proba_triplet=None):
     fig = plt.figure()
     fig.set_size_inches(8, 7)
 
-    nl, ne, nr = np.max(points, axis=0)
-    for i, n in enumerate((nl, ne, nr)):
-        if n < 0.001:
-            print(
-                "p{} is too small, switching to 2d plot".format(names[::-1] + ["rope"])
-            )
-            coords = sorted(set(range(3)) - i)
-            return plot2d(points[:, coords], labels[coords])
-
     # triangle
     fig.gca().add_line(
         Line2D([0, 0.5, 1.0, 0], [0, np.sqrt(3) / 2, 0, 0], color="black")
@@ -669,6 +660,10 @@ def plot_simplex(points, names=("C1", "C2"), proba_triplet=None):
                 [vert0[0, 0], vert0[i, 0]], [vert0[0, 1], vert0[i, 1]], color="black"
             )
         )
+    # Degenerate posteriors remain valid points on a simplex edge.
+    if proba_triplet is None:
+        proba_triplet = np.mean(points, axis=0)
+
     # vertex labels
     rcParams.update({"font.size": 16})
     fig.gca().text(-0.08, -0.08, f"p({names[0]} ({proba_triplet[0]}))", color="black")

{py3plex-2.0.8 → py3plex-2.0.93}/py3plex/algorithms/statistics/critical_distances.py

@@ -35,13 +35,14 @@ def diagram(
     the_algorithm_candidate: Optional[str],
     output_figure_file: Optional[str],
     fontsize: int = 10,
+    critical_distance: Optional[float] = None,
 ) -> Optional[str]:
     """
     Draws critical distance diagram for Nemenyi or Bonferroni-Dunn post-hoc test.
     The diagram is shown if output_figure_file is None, and saved otherwise
     to the file.
     :param list_of_algorithms: [[(alg_name1, avg_rank1)], ...]
-    :param critical_distance:
+    :param critical_distance: Optional positive Nemenyi critical distance.
     :param output_figure_file: If not none, the diagram produced is saved to the specified file.
     Otherwise, the diagram is shown.
     :param the_algorithm_candidate: If we were performing Bonferroni-Dunn post-hcc test (1 vs all),
@@ -50,6 +51,10 @@ def diagram(
     :return: output_figure_file
     """
 
+    if critical_distance is not None and (
+        not np.isfinite(critical_distance) or critical_distance <= 0
+    ):
+        raise ValueError("critical_distance must be a positive finite number")
     n = len(list_of_algorithms)
     sorted_algorithms = sorted(list_of_algorithms, key=lambda t: t[1])
     the_index = None
@@ -96,7 +101,7 @@ def diagram(
         weight="normal",
         stretch="normal",
     )
-    rc("text", usetex=True)
+    # Respect the caller's text renderer; plotting does not require LaTeX.
     rc("font", **fontProperties)
 
     def name_length(name: str) -> float:
@@ -256,9 +261,9 @@ def diagram(
         plot_algorithm(i, alg_rank_tuple[0], alg_rank_tuple[1])
     # critical distance
 
-    #    plot_critical_distance()
-    # algorithm groups
-    #    plot_groups(algorithm_groups())
+    if critical_distance is not None:
+        plot_critical_distance()
+        plot_groups(algorithm_groups())
     # save / show the results
     if output_figure_file is not None:
         folder_end = output_figure_file.rfind("/")
@@ -333,7 +338,6 @@ def plot_critical_distance(
     fontsize: int = 10,
 ) -> None:
 
-    import operator
     from collections import defaultdict
 
     if groupby is None:
@@ -350,10 +354,12 @@ def plot_critical_distance(
 
     for _k, v in ranks.items():
         a = dict(v)
-        sorted_d = sorted(a.items(), key=operator.itemgetter(1))
-        for en, j in enumerate(sorted_d):
-            logger.debug("Rank %d: %s", en, j[0])
-            clf_ranks[j[0]].append(len(sorted_d) - en)
+        from scipy.stats import rankdata
+        names = list(a)
+        # Higher scores are better; ties receive their shared average rank.
+        dataset_ranks = rankdata([-a[name] for name in names], method="average")
+        for name, rank in zip(names, dataset_ranks):
+            clf_ranks[name].append(float(rank))
 
     fname[groupby[0]].nunique()
     clf_score = {k: np.mean(v) for k, v in clf_ranks.items()}
@@ -361,9 +367,22 @@ def plot_critical_distance(
     avranks = list(clf_score.values())
     pairs = list(zip(names, avranks))
     if crit_dist:
-        cd = Orange.evaluation.compute_CD(  # type: ignore[name-defined]
-            avranks[0 : (len(avranks) - 1)], comparisons, alpha="0.05"  # type: ignore[name-defined]
-        )
+        # Nemenyi's CD uses the full algorithm count and independent datasets.
+        k = len(avranks)
+        comparisons = len(ranks)
+        if k < 2 or comparisons < 1:
+            raise ValueError("Critical distance requires at least two algorithms and one dataset")
+        algorithms = set(clf_score)
+        if any({name for name, _ in rows} != algorithms for rows in ranks.values()):
+            raise ValueError("Critical distance requires the same algorithms in every dataset")
+        if not np.all(np.isfinite(rkx.to_numpy())):
+            raise ValueError("Critical distance requires finite scores")
+        try:
+            from scipy.stats import studentized_range
+        except ImportError as exc:
+            raise ImportError("Critical distance plotting requires scipy>=1.7") from exc
+        q_alpha = studentized_range.ppf(0.95, k, np.inf) / np.sqrt(2)
+        cd = float(q_alpha * np.sqrt(k * (k + 1) / (6 * comparisons)))
+        diagram(pairs, None, outfile, fontsize=fontsize, critical_distance=cd)
     else:
-        cd = None
-    diagram(pairs, cd, outfile, fontsize=fontsize)
+        diagram(pairs, None, outfile, fontsize=fontsize)

{py3plex-2.0.8 → py3plex-2.0.93}/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()}