py3plex 2.0.6__tar.gz → 2.0.92__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py3plex
-Version: 2.0.6
+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.6K-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.6 → 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.6K-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.6 → py3plex-2.0.92}/py3plex/__init__.py

@@ -51,8 +51,9 @@ For detailed documentation, see: https://skblaz.github.io/py3plex/
 """
 
 # Version information
-__version__ = "2.0.6"
-__api_version__ = "2.0.6"
+from ._version import __version__
+
+__api_version__ = __version__
 
 from py3plex.core.multinet import multi_layer_network
 from py3plex.core.types import (

py3plex-2.0.92/py3plex/_version.py

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

{py3plex-2.0.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → py3plex-2.0.92}/py3plex/cli.py

@@ -1779,11 +1779,10 @@ def cmd_query(args: argparse.Namespace) -> int:
         # Execute query. Some lower-level layout/progress utilities print
         # diagnostics directly to stdout; keep command stdout parseable.
         if args.dsl:
-            # Interpret as Python DSL builder syntax
-            from py3plex.dsl.builder_parser import parse_builder_query
+            # Parse builder syntax as a restricted AST expression; never run it as Python.
+            from py3plex.safe_dsl_expression import evaluate_dsl_expression
 
-            query_builder = parse_builder_query(query_str)
-            
+            query_builder = evaluate_dsl_expression(query_str)
             with contextlib.redirect_stdout(sys.stderr):
                 result = query_builder.execute(network)
         else:
@@ -1927,20 +1926,18 @@ def cmd_dsl_lint(args: argparse.Namespace) -> int:
                 logger.error(f"Failed to load network: {e}")
                 return 2
         
-        # Parse query using the restricted builder syntax.
+        # Parse documented builder expressions without evaluating Python code.
         from py3plex.dsl import lint, explain
-        from py3plex.dsl.builder_parser import parse_builder_query
-        
-        # Try to parse as builder syntax first
+        from py3plex.safe_dsl_expression import evaluate_dsl_expression
+
         try:
-            query_builder = parse_builder_query(query_str)
+            query_builder = evaluate_dsl_expression(query_str)
             query_ast = query_builder.to_ast()
-        except Exception:
-            # Fall back to treating it as a note that we need string DSL support
-            logger.error("String DSL syntax not yet supported for linting.")
-            logger.error("Please use builder syntax: Q.nodes().from_layers(L['social']).where(degree__gt=5)")
+        except (ValueError, TypeError) as exc:
+            logger.error("Invalid DSL builder expression: %s", exc)
+            logger.error("Use builder syntax such as Q.nodes().from_layers(L['social']).where(degree__gt=5)")
             return 2
-        
+
         # Run linting
         if args.explain:
             # Get detailed explanation

{py3plex-2.0.6 → 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.6 → py3plex-2.0.92}/py3plex/config.py

@@ -218,8 +218,9 @@ WARN_DEPRECATED: bool = True
 # Library Metadata
 # ─────────────────────────────────────────────────────────────────────────────
 
-__api_version__ = "2.0.6"
-__version__ = "2.0.6"
+from ._version import __version__
+
+__api_version__ = __version__
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Helper Functions

{py3plex-2.0.6 → 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