py3plex 2.0.92__tar.gz → 2.0.93__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py3plex
-Version: 2.0.92
+Version: 2.0.93
 Summary: A Multilayer network analysis python3 library
 Author-email: Blaž Škrlj <blaz.skrlj@ijs.si>
 License: MIT
@@ -33,7 +33,7 @@ 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"
@@ -49,7 +49,7 @@ 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"
@@ -118,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-214.7K-blue)
-![Test Count](https://img.shields.io/badge/tests-9.9K-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.

{py3plex-2.0.92 → 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-214.7K-blue)
-![Test Count](https://img.shields.io/badge/tests-9.9K-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.

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

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

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

@@ -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.92 → 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.92 → 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.92 → 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.92 → py3plex-2.0.93}/py3plex/cli.py

@@ -232,6 +232,20 @@ def _load_network(file_path: str) -> "multinet.multi_layer_network":
                 first_line = f.readline().strip()
                 if first_line:
                     parts = first_line.split()
+                    if len(parts) == 3:
+                        try:
+                            float(parts[2])
+                        except ValueError:
+                            # Compact multilayer rows: source target layer.
+                            f.seek(0)
+                            for row in f:
+                                row = row.strip()
+                                if not row or row.startswith("#"):
+                                    continue
+                                source, target, layer = row.split()
+                                network.add_edges([{"source": source, "target": target,
+                                                    "source_type": layer, "target_type": layer}])
+                            return network
                     if len(parts) in [4, 5]:
                         # Multilayer format (with or without weight)
                         network.load_network(file_path, input_type="multiedgelist")
@@ -1038,6 +1052,9 @@ Examples:
         help="Output format (default: csv)",
     )
 
+    embed_parser.add_argument("--verbose", "-v", action="store_true",
+                               help="Print detailed progress information")
+
     # EXPERIMENT command group
     from py3plex.experiments.cli import add_experiment_subparser
 
@@ -3905,8 +3922,7 @@ def cmd_dynamics(args: argparse.Namespace) -> int:
             print(f"Loading network from: {args.input}")
 
         # Load network
-        net = multinet.multi_layer_network(directed=False)
-        net.load_network(args.input, input_type="multiedgelist")
+        net = _load_network(args.input)
 
         if args.verbose:
             print(f"Network loaded: {len(net.get_nodes())} nodes, {len(net.get_edges())} edges")
@@ -4110,11 +4126,10 @@ def cmd_embed(args: argparse.Namespace) -> int:
             print(f"Loading network from: {args.input}")
 
         # Load network
-        net = multinet.multi_layer_network(directed=False)
-        net.load_network(args.input, input_type="multiedgelist")
+        net = _load_network(args.input)
 
         if args.verbose:
-            print(f"Network loaded: {len(net.get_nodes())} nodes, {len(net.get_edges())} edges")
+            print(f"Network loaded: {net.core_network.number_of_nodes()} nodes, {net.core_network.number_of_edges()} edges")
 
         # Prepare embedding parameters
         embed_params = {
@@ -4160,7 +4175,10 @@ def cmd_embed(args: argparse.Namespace) -> int:
             print("Embeddings learned successfully!")
 
         # Prepare output
-        if hasattr(result, "embeddings"):
+        if hasattr(result, "vectors"):
+            embeddings = result.vectors
+            node_list = result.item_ids
+        elif hasattr(result, "embeddings"):
             # EmbeddingResult object
             embeddings = result.embeddings
             node_list = result.nodes if hasattr(result, "nodes") else list(embeddings.keys())
@@ -4180,9 +4198,9 @@ def cmd_embed(args: argparse.Namespace) -> int:
                 "seed": args.seed,
             },
             "network": {
-                "nodes": len(net.get_nodes()),
-                "edges": len(net.get_edges()),
-                "layers": net.get_layers(),
+                "nodes": net.core_network.number_of_nodes(),
+                "edges": net.core_network.number_of_edges(),
+                "layers": list(net.layers),
             },
             "embeddings": {},
         }

{py3plex-2.0.92 → py3plex-2.0.93}/py3plex/core/parsers.py

@@ -1,6 +1,7 @@
 # set of parsers used in Py3plex.
 
 import glob
+import base64
 import gzip
 import itertools
 import json
@@ -341,6 +342,8 @@ def parse_multi_edgelist(
             else:
                 continue
 
+            weight = float(weight)
+
             if layer_first == layer_second and node_first == node_second:
 
                 # first case
@@ -408,10 +411,24 @@ def parse_simple_edgelist(
             if len(parts) in (2, 3):
                 node_first_str, node_second_str = parts[:2]
                 layer_first = layer_second = "null"
-                weight = float(parts[2]) if len(parts) == 3 else 1.0
+                if len(parts) == 3 and parts[2].startswith("@json:"):
+                    edge_attributes = json.loads(
+                        base64.urlsafe_b64decode(parts[2][6:].encode("ascii"))
+                    )
+                else:
+                    edge_attributes = {"weight": 1.0}
+                    if len(parts) == 3:
+                        edge_attributes["weight"] = float(parts[2])
             elif len(parts) in (4, 5):
                 node_first_str, layer_first, node_second_str, layer_second = parts[:4]
-                weight = float(parts[4]) if len(parts) == 5 else 1.0
+                if len(parts) == 5 and parts[4].startswith("@json:"):
+                    edge_attributes = json.loads(
+                        base64.urlsafe_b64decode(parts[4][6:].encode("ascii"))
+                    )
+                else:
+                    edge_attributes = {"weight": 1.0}
+                    if len(parts) == 5:
+                        edge_attributes["weight"] = float(parts[4])
             else:
                 continue
 
@@ -421,7 +438,7 @@ def parse_simple_edgelist(
             G.add_node(node_first, type=layer_first)
             G.add_node(node_second, type=layer_second)
 
-            G.add_edge(node_first, node_second, weight=weight)
+            G.add_edge(node_first, node_second, **edge_attributes)
 
     return (G, None)
 
@@ -486,7 +503,12 @@ def parse_edgelist_multi_types(
 
             G.add_node((node_first, "null"), type="null")
             G.add_node((node_second, "null"), type="null")
-            G.add_edge(node_first, node_second, weight=weight, type=edge_type)
+            G.add_edge(
+                (node_first, "null"),
+                (node_second, "null"),
+                weight=weight,
+                type=edge_type,
+            )
     return (G, None)
 
 
@@ -502,13 +524,12 @@ def parse_spin_edgelist(input_name: str, directed: bool) -> Tuple[nx.Graph, None
 
     Args:
         input_name: Path to SPIN edgelist file
-        directed: Whether to create directed graph (currently creates undirected)
+        directed: Whether to create a directed graph
 
     Returns:
         Tuple[nx.Graph, None]: (parsed_graph, None for labels)
 
     Notes:
-        - Currently always returns nx.Graph (undirected) regardless of directed parameter
         - Edge tag is stored in edge 'type' attribute
         - Default weight is 1 if not specified (4th column)
 
@@ -519,7 +540,7 @@ def parse_spin_edgelist(input_name: str, directed: bool) -> Tuple[nx.Graph, None
         >>> graph, _ = parse_spin_edgelist('spin_edges.txt', directed=False)  # doctest: +SKIP
     """
 
-    G = nx.Graph()
+    G = nx.DiGraph() if directed else nx.Graph()
     with open(input_name) as IN:
         for line in IN:
             stripped = line.strip()
@@ -561,11 +582,21 @@ def parse_embedding(input_name: str) -> Tuple[np.ndarray, np.ndarray]:
     with open(input_name) as IN:
         for line in IN:
             parts = line.strip().split()
-            if len(parts) == 2:
-                pass
-            else:
-                embedding_matrix.append(parts[1:])
-                embedding_indices.append(parts[0])
+            if not parts:
+                continue
+            if not embedding_matrix and len(parts) == 2:
+                # Word2vec text files may start with a (count, dimensions)
+                # header. Do not treat every two-column row as a header: that
+                # is also the valid representation of 1D embeddings.
+                try:
+                    int(parts[0])
+                    int(parts[1])
+                except ValueError:
+                    pass
+                else:
+                    continue
+            embedding_matrix.append(parts[1:])
+            embedding_indices.append(parts[0])
     embedding_matrix_np = np.asarray(embedding_matrix)
     embedding_indices_np = np.array(embedding_indices)
     return (embedding_matrix_np, embedding_indices_np)
@@ -749,7 +780,7 @@ def parse_multiplex_folder(
                     n1, n2, timestamp, layer_name = parts[:4]
                     time_series_tuples.append(
                         {
-                            "node_first": 1,
+                            "node_first": n1,
                             "node_second": n2,
                             "layer": layer_dict[layer_name],
                             "timestamp": timestamp,
@@ -815,6 +846,29 @@ def parse_network(
         Tuple of (parsed_network, labels, time_series)
     """
 
+    supported_types = {
+        "gml",
+        "graphml",
+        "nx",
+        "multiplex_folder",
+        "sparse",
+        "sparse_network",
+        "gpickle_biomine",
+        "gpickle",
+        "multiedgelist",
+        "detangler_json",
+        "edgelist",
+        "edgelist_spin",
+        "edgelist_with_edge_types",
+        "multiedge_tuple_list",
+        "multiplex_edges",
+    }
+    if f_type not in supported_types:
+        raise ValueError(
+            f"Unsupported network format {f_type!r}. "
+            f"Supported formats: {', '.join(sorted(supported_types))}"
+        )
+
     time_series = None
     if f_type == "gml":
         parsed_network, labels = parse_gml(input_name, directed)
@@ -1027,15 +1081,37 @@ def save_edgelist(
             for edge in input_network.edges(data=attributes):
                 n1, l1 = edge[0]
                 n2, l2 = edge[1]
-                fh.write(f"{n1} {l1} {n2} {l2}\n")
+                suffix = (
+                    " "
+                    + "@json:"
+                    + base64.urlsafe_b64encode(
+                        json.dumps(
+                            edge[2], separators=(",", ":"), sort_keys=True
+                        ).encode("utf-8")
+                    ).decode("ascii")
+                    if attributes
+                    else ""
+                )
+                fh.write(f"{n1} {l1} {n2} {l2}{suffix}\n")
         else:
             # For regular networks, convert to integers as before
             input_network = nx.convert_node_labels_to_integers(
                 input_network, first_label=0, ordering="default", label_attribute=None
             )
             # Save in simple format: node1 node2
-            for edge in input_network.edges():
-                fh.write(f"{edge[0]} {edge[1]}\n")
+            for edge in input_network.edges(data=attributes):
+                suffix = (
+                    " "
+                    + "@json:"
+                    + base64.urlsafe_b64encode(
+                        json.dumps(
+                            edge[2], separators=(",", ":"), sort_keys=True
+                        ).encode("utf-8")
+                    ).decode("ascii")
+                    if attributes
+                    else ""
+                )
+                fh.write(f"{edge[0]} {edge[1]}{suffix}\n")
 
     logger.info("Finished writing the network..")
 

{py3plex-2.0.92 → py3plex-2.0.93}/py3plex/dsl/ast.py

@@ -1928,6 +1928,8 @@ def ast_to_json(query: Query, canonical: bool = True) -> str:
         >>> json_str = ast_to_json(ast)
         >>> # Can be deserialized with ast_from_json()
     """
+    from .layers import LayerExpr as LayerSetExpr, LayerSet
+
     if canonical:
         query = canonicalize_ast(query)
     
@@ -1943,9 +1945,12 @@ def ast_to_json(query: Query, canonical: bool = True) -> str:
             return [_serialize(item) for item in obj]
         if isinstance(obj, dict):
             return {k: _serialize(v) for k, v in obj.items()}
+        if isinstance(obj, LayerSet):
+            return {'__type__': 'LayerSet', 'expr': _serialize(obj.expr)}
         if hasattr(obj, '__dataclass_fields__'):
             # Dataclass
-            result = {'__type__': obj.__class__.__name__}
+            type_name = 'LayerSetExpr' if isinstance(obj, LayerSetExpr) else obj.__class__.__name__
+            result = {'__type__': type_name}
             for field_name in obj.__dataclass_fields__:
                 value = getattr(obj, field_name)
                 result[field_name] = _serialize(value)
@@ -1976,6 +1981,8 @@ def ast_from_json(json_str: str) -> Query:
         >>> reconstructed = ast_from_json(json_str)
         >>> ast_equals(ast, reconstructed)  # True
     """
+    from .layers import LayerExpr as LayerSetExpr, LayerSet
+
     data = json.loads(json_str)
     
     # Check schema version
@@ -2016,6 +2023,8 @@ def ast_from_json(json_str: str) -> Query:
                     'Query': Query,
                     'SelectStmt': SelectStmt,
                     'LayerExpr': LayerExpr,
+                    'LayerSet': LayerSet,
+                    'LayerSetExpr': LayerSetExpr,
                     'LayerTerm': LayerTerm,
                     'ConditionExpr': ConditionExpr,
                     'ConditionAtom': ConditionAtom,
@@ -2047,6 +2056,9 @@ def ast_from_json(json_str: str) -> Query:
                 for field_name, field_value in obj_data.items():
                     deserialized_data[field_name] = _deserialize(field_value)
                 
+                if target_class is LayerSet:
+                    return LayerSet(deserialized_data['expr'])
+
                 if target_class is SelectStmt and 'target' in deserialized_data:
                     # Schema 2.0 exports previously wrote str-backed Target enums
                     # as bare strings. Continue to accept those stored queries.