py3plex 2.0.6__tar.gz → 2.0.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py3plex
-Version: 2.0.6
+Version: 2.0.8
 Summary: A Multilayer network analysis python3 library
 Author-email: Blaž Škrlj <blaz.skrlj@ijs.si>
 License: MIT
@@ -120,7 +120,7 @@ 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)
+![Lines of Code](https://img.shields.io/badge/lines-213.8K-blue)
 ![Test Count](https://img.shields.io/badge/tests-9.7K-blue)
 
 *Multilayer networks* are complex networks with additional information assigned to nodes or edges (or both). This library includes

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

@@ -16,7 +16,7 @@
 [![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)
+![Lines of Code](https://img.shields.io/badge/lines-213.8K-blue)
 ![Test Count](https://img.shields.io/badge/tests-9.7K-blue)
 
 *Multilayer networks* are complex networks with additional information assigned to nodes or edges (or both). This library includes

{py3plex-2.0.6 → py3plex-2.0.8}/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.8/py3plex/_version.py

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

{py3plex-2.0.6 → py3plex-2.0.8}/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.8}/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.8}/py3plex/core/multinet.py

@@ -1089,23 +1089,26 @@ class multi_layer_network:
             - :meth:`get_edges` for filtering coupling edges (multiplex_edges param)
         """
         unique_layers = {n[1] for n in self.core_network.nodes()}
-        unique_nodes = {n[0] for n in self.core_network.nodes()}
-
-        #        for potential_node in itertools.product(unique_nodes,unique_layers):
-        #            self.core_network.add_node(potential_node)
-
-        # draw edges between same nodes across layers
-        for node in unique_nodes:
-            for layer_first in unique_layers:
-                for layer_second in unique_layers:
-                    if layer_first != layer_second:
-                        coupled_edge = ((node, layer_first), (node, layer_second))
-                        self.core_network.add_edge(
-                            coupled_edge[0],
-                            coupled_edge[1],
-                            type="coupling",
-                            weight=self.coupling_weight,
-                        )
+
+        # Add one undirected coupling edge per pair of replicas.  Iterating
+        # over ordered layer pairs creates parallel edges in a MultiGraph and
+        # also creates replicas for layers in which a node is absent.
+        for node in {n[0] for n in self.core_network.nodes()}:
+            node_layers = sorted(
+                layer for layer in unique_layers if (node, layer) in self.core_network
+            )
+            layer_pairs = (
+                itertools.combinations(node_layers, 2)
+                if not self.directed
+                else itertools.permutations(node_layers, 2)
+            )
+            for layer_first, layer_second in layer_pairs:
+                self.core_network.add_edge(
+                    (node, layer_first),
+                    (node, layer_second),
+                    type="coupling",
+                    weight=self.coupling_weight,
+                )
 
     def load_layer_name_mapping(self, mapping_name, header=False):
         """Layer-node mapping loader method

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex/dsl/builder.py

@@ -4723,7 +4723,7 @@ class CommunityQueryBuilder(QueryBuilder):
             uq_enabled = uq_config is not None
             
             if uq_enabled:
-                uq_method = uq_config.uq_method or "seed"
+                uq_method = uq_config.method or "seed"
                 uq_n_samples = uq_config.n_samples or 10
             else:
                 uq_method = "seed"

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex/dsl/executor.py

@@ -2614,6 +2614,8 @@ def _execute_select(
     # Step 4: Compute measures
     stage_start = time.monotonic()
     attributes: Dict[str, Dict] = {}
+    if select.select_cols or select.rename_map:
+        _add_intrinsic_node_attributes(attributes, items, select.target)
     
     # Track approximation usage for provenance (initialize before compute block)
     approx_used = []
@@ -2720,6 +2722,20 @@ def _execute_select(
                                 select=select,
                             )
 
+                        if compute_item.name in {"communities", "community"}:
+                            # Community computation is an analysis operation,
+                            # not merely a derived column: retain the
+                            # partition on the network for subsequent queries.
+                            partition = {
+                                item: (
+                                    value.get("mean", value)
+                                    if isinstance(value, dict)
+                                    else value
+                                )
+                                for item, value in values.items()
+                            }
+                            network.assign_partition(partition)
+
                         attributes[result_name] = values
                 except (UQResolutionError, UQSchemaValidationError):
                     # UQ errors should propagate (fail-fast)
@@ -3018,7 +3034,7 @@ def _execute_auto_community(
         uq_enabled = uq_config is not None
         
         if uq_enabled:
-            uq_method = uq_config.uq_method or "seed"
+            uq_method = uq_config.method or "seed"
             uq_n_samples = uq_config.n_samples or 10
         else:
             uq_method = "seed"
@@ -3717,6 +3733,8 @@ def _execute_select_with_items(
 
     # Compute measures if needed
     attributes: Dict[str, Dict] = {}
+    if select.select_cols or select.rename_map:
+        _add_intrinsic_node_attributes(attributes, items, select.target)
     if select.compute:
         if progress:
             logger.info(f"Computing {len(select.compute)} measure(s)")
@@ -3767,6 +3785,26 @@ def _execute_select_with_items(
     )
 
 
+def _add_intrinsic_node_attributes(
+    attributes: Dict[str, Dict], items: List[Any], target: Target
+) -> None:
+    """Expose node identifiers as query columns before post-processing."""
+    if target != Target.NODES:
+        return
+
+    attributes["id"] = {}
+    attributes["node"] = {}
+    attributes["layer"] = {}
+    for item in items:
+        if isinstance(item, tuple) and len(item) >= 2:
+            node, layer = item[0], item[1]
+        else:
+            node, layer = item, None
+        attributes["id"][item] = node
+        attributes["node"][item] = node
+        attributes["layer"][item] = layer
+
+
 def _execute_embedding(
     result: Any,
     network: Any,
@@ -6130,7 +6168,11 @@ def _apply_select(
     Returns:
         Filtered attributes dict
     """
-    return {col: attributes[col] for col in columns if col in attributes}
+    missing = [col for col in columns if col not in attributes]
+    if missing:
+        available = list(attributes)
+        raise UnknownAttributeError(missing[0], available)
+    return {col: attributes[col] for col in columns}
 
 
 def _apply_drop(
@@ -6757,6 +6799,15 @@ def _execute_nodes_with_community(
         provenance_builder=provenance_builder,
         provenance_record=provenance_record
     )
+
+    # Node attributes are not automatically materialized as query columns.
+    # Expose the partition assignment explicitly for community queries.
+    community_attr = "community" if partition_name == "default" else f"community_{partition_name}"
+    result.attributes[community_attr] = {
+        item: network.core_network.nodes[item].get(community_attr)
+        for item in result.items
+        if item in network.core_network
+    }
     
     # Add community metadata
     result.meta["community_detection"] = {

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex/dsl/program/program.py

@@ -756,10 +756,10 @@ class GraphProgram:
             )
 
         return cls(
-            canonical_ast=copy.deepcopy(ast),
-            type_signature=type_signature,
+            _canonical_ast=copy.deepcopy(ast),
+            _type_signature=type_signature,
             program_hash=program_hash,
-            metadata=metadata,
+            _metadata=metadata,
         )
 
     @classmethod

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex/dsl/result.py

@@ -19,6 +19,28 @@ _EXPLANATION_ATTRS = {
 }
 
 
+def _json_safe(value: Any) -> Any:
+    """Convert common scientific Python values to JSON-compatible values."""
+    if isinstance(value, dict):
+        return {
+            key if isinstance(key, str) else json.dumps(_json_safe(key), separators=(",", ":")): _json_safe(item)
+            for key, item in value.items()
+        }
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    if isinstance(value, set):
+        return [_json_safe(item) for item in sorted(value, key=repr)]
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+    if hasattr(value, "to_json_dict"):
+        return _json_safe(value.to_json_dict())
+    if hasattr(value, "tolist"):
+        return _json_safe(value.tolist())
+    if hasattr(value, "item"):
+        return _json_safe(value.item())
+    return repr(value)
+
+
 def _expand_embeddings_into_df(
     df: Any,
     embeddings: Dict[str, Any],
@@ -978,6 +1000,34 @@ class QueryResult:
 
         return subgraph
 
+    def to_csv(self, path: Union[str, "Path"], **kwargs) -> None:
+        """Write result rows to a CSV file.
+
+        Keyword arguments are passed to :meth:`pandas.DataFrame.to_csv`.
+        The DataFrame index is omitted by default because result fields
+        already identify each row.
+        """
+        kwargs.setdefault("index", False)
+        self.to_pandas().to_csv(path, **kwargs)
+
+    def to_json(self, path: Optional[Union[str, Path]] = None, **kwargs) -> str:
+        """Serialize the complete result to JSON, optionally writing it to *path*.
+
+        The JSON object contains ``target``, ``items``, ``attributes``, and
+        ``meta`` fields. Keyword arguments are passed to :func:`json.dumps`.
+        """
+        payload = {
+            "target": self.target,
+            "items": self.items,
+            "attributes": self.attributes,
+            "meta": self.meta,
+        }
+        kwargs.setdefault("indent", 2)
+        output = json.dumps(_json_safe(payload), **kwargs)
+        if path is not None:
+            Path(path).write_text(output, encoding="utf-8")
+        return output
+
     def to_arrow(self):
         """Export results to Apache Arrow table.
 
@@ -994,8 +1044,18 @@ class QueryResult:
                 "pyarrow is required for to_arrow(). Install with: pip install pyarrow"
             )
 
-        # Convert items to strings for Arrow compatibility
-        data = {"id": [str(item) for item in self.items]}
+        # Keep node replica identity in separate columns, matching to_pandas().
+        # Stringifying the (node, layer) tuple into one id loses the layer as a
+        # usable field in downstream Arrow/Parquet analysis.
+        if self.target == "nodes":
+            data = {
+                "id": [item[0] if isinstance(item, tuple) and len(item) >= 2 else item
+                       for item in self.items],
+                "layer": [item[1] if isinstance(item, tuple) and len(item) >= 2 else None
+                          for item in self.items],
+            }
+        else:
+            data = {"id": [str(item) for item in self.items]}
 
         for attr_name, values in self.attributes.items():
             if isinstance(values, dict):

py3plex-2.0.8/py3plex/safe_dsl_expression.py

@@ -0,0 +1,83 @@
+"""Safe interpreter for the CLI's documented Python-style DSL builder syntax."""
+import ast
+import operator
+
+
+_ALLOWED_METHODS = {
+    "nodes", "edges", "communities", "from_layers", "where", "compute",
+    "order_by", "limit", "top_k", "group_by", "per_layer", "coverage",
+    "end_grouping", "uq", "select", "drop", "rename", "distinct",
+    "summarize", "mutate", "rank_by", "zscore", "having", "during",
+    "window", "approx", "seed", "provenance", "hint", "to_ast",
+    "int", "float", "str", "ref",
+}
+_ALLOWED_BINOPS = {ast.Add: operator.add, ast.Sub: operator.sub, ast.BitOr: operator.or_, ast.BitAnd: operator.and_}
+_ALLOWED_UNARY = {ast.USub: operator.neg, ast.UAdd: operator.pos}
+
+
+def evaluate_dsl_expression(source):
+    """Evaluate a builder expression using explicit AST nodes and allowlists."""
+    from py3plex.dsl import Q, L, Param
+
+    try:
+        tree = ast.parse(source, mode="eval")
+    except SyntaxError as exc:
+        raise ValueError(f"Invalid DSL expression: {exc.msg}") from exc
+
+    def visit(node):
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, (str, int, float, bool, type(None))):
+                return node.value
+            raise ValueError("Unsupported literal in DSL expression")
+        if isinstance(node, ast.Name):
+            if node.id in {"Q", "L", "Param"}:
+                return {"Q": Q, "L": L, "Param": Param}[node.id]
+            raise ValueError(f"Name {node.id!r} is not allowed in DSL expressions")
+        if isinstance(node, ast.Attribute):
+            if node.attr.startswith("_"):
+                raise ValueError("Private attributes are not allowed in DSL expressions")
+            if isinstance(node.value, ast.Name) and node.value.id in {"Q", "L", "Param"}:
+                owner = visit(node.value)
+                is_layer = owner is L
+            elif isinstance(node.value, ast.Call) and isinstance(node.value.func, ast.Attribute):
+                if node.value.func.attr not in _ALLOWED_METHODS:
+                    raise ValueError("Method chain contains an unsupported operation")
+                owner = visit(node.value)
+                is_layer = False
+            else:
+                raise ValueError("Attribute access is allowed only on DSL namespaces or builder results")
+            if node.attr not in _ALLOWED_METHODS and not is_layer:
+                raise ValueError(f"Attribute {node.attr!r} is not allowed in DSL expressions")
+            try:
+                return getattr(owner, node.attr)
+            except AttributeError as exc:
+                raise ValueError(f"Unsupported DSL attribute {node.attr!r}") from exc
+        if isinstance(node, ast.Call):
+            if node.keywords and any(keyword.arg is None for keyword in node.keywords):
+                raise ValueError("Keyword argument unpacking is not allowed")
+            function = visit(node.func)
+            if isinstance(node.func, ast.Attribute) and node.func.attr not in _ALLOWED_METHODS:
+                raise ValueError(f"Method {node.func.attr!r} is not allowed in DSL expressions")
+            return function(*[visit(arg) for arg in node.args], **{kw.arg: visit(kw.value) for kw in node.keywords})
+        if isinstance(node, ast.Subscript):
+            if not isinstance(node.value, ast.Name) or node.value.id != "L":
+                raise ValueError("Subscripts are allowed only on L")
+            key = visit(node.slice)
+            if not isinstance(key, str):
+                raise ValueError("Layer names must be strings")
+            return L[key]
+        if isinstance(node, ast.BinOp) and type(node.op) in _ALLOWED_BINOPS:
+            return _ALLOWED_BINOPS[type(node.op)](visit(node.left), visit(node.right))
+        if isinstance(node, ast.UnaryOp) and type(node.op) in _ALLOWED_UNARY:
+            return _ALLOWED_UNARY[type(node.op)](visit(node.operand))
+        if isinstance(node, (ast.List, ast.Tuple, ast.Set)):
+            values = [visit(item) for item in node.elts]
+            return values if isinstance(node, ast.List) else tuple(values) if isinstance(node, ast.Tuple) else set(values)
+        if isinstance(node, ast.Dict):
+            return {visit(k): visit(v) for k, v in zip(node.keys, node.values)}
+        raise ValueError(f"Syntax {type(node).__name__} is not allowed in DSL expressions")
+
+    result = visit(tree.body)
+    if not callable(getattr(result, "to_ast", None)):
+        raise ValueError("DSL expression must produce a query builder")
+    return result

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py3plex
-Version: 2.0.6
+Version: 2.0.8
 Summary: A Multilayer network analysis python3 library
 Author-email: Blaž Škrlj <blaz.skrlj@ijs.si>
 License: MIT
@@ -120,7 +120,7 @@ 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)
+![Lines of Code](https://img.shields.io/badge/lines-213.8K-blue)
 ![Test Count](https://img.shields.io/badge/tests-9.7K-blue)
 
 *Multilayer networks* are complex networks with additional information assigned to nodes or edges (or both). This library includes

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ py3plex/__init__.py
 py3plex/__main__.py
 py3plex/_parallel.py
 py3plex/_safe_expression.py
+py3plex/_version.py
 py3plex/agent.py
 py3plex/cli.py
 py3plex/config.py
@@ -20,6 +21,7 @@ py3plex/logging_config.py
 py3plex/pipeline.py
 py3plex/profiling.py
 py3plex/requirements.py
+py3plex/safe_dsl_expression.py
 py3plex/temporal_utils.py
 py3plex/temporal_utils_extended.py
 py3plex/temporal_view.py

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex_mcp/__init__.py

@@ -7,10 +7,10 @@ Usage:
     pip install py3plex[mcp]
     py3plex-mcp
 
-Version: 2.0.6
+Version: 2.0.8
 """
 
-__version__ = "2.0.6"
+from py3plex._version import __version__
 
 __all__ = [
     "__version__",

{py3plex-2.0.6 → py3plex-2.0.8}/py3plex_mcp/server.py

@@ -35,7 +35,7 @@ except ImportError:
 
 from py3plex.core import multinet
 from py3plex.dsl_legacy import execute_query
-from py3plex.dsl import Q, L, Param, QueryResult  # DSL v2 support
+from py3plex.safe_dsl_expression import evaluate_dsl_expression
 from py3plex_mcp.errors import (
     MCPError,
     NetworkNotFoundError,
@@ -216,18 +216,9 @@ async def py3plex_run_query(
         # Execute query based on DSL version
         try:
             if use_v2:
-                # DSL v2: Evaluate Python expression to build query
-                # Security: We only expose Q, L, Param from dsl module
-                safe_globals = {
-                    "Q": Q,
-                    "L": L,
-                    "Param": Param,
-                    "__builtins__": {},
-                }
-                # Evaluate the query expression
-                query_builder = eval(query, safe_globals, {})
-                
-                # Execute the query
+                # MCP query strings are untrusted input. Parse only the
+                # documented DSL builder expression grammar.
+                query_builder = evaluate_dsl_expression(query)
                 result = query_builder.execute(net, progress=False)
             else:
                 # Legacy DSL: String-based query

{py3plex-2.0.6 → py3plex-2.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "py3plex"
-version = "2.0.6"
+dynamic = ["version"]
 description = "A Multilayer network analysis python3 library"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -151,6 +151,9 @@ Repository = "https://github.com/SkBlaz/py3plex"
 py3plex = "py3plex.cli:main"
 py3plex-mcp = "py3plex_mcp.server:main"
 
+[tool.setuptools.dynamic]
+version = {attr = "py3plex._version.__version__"}
+
 [tool.setuptools]
 zip-safe = false
 include-package-data = true

{py3plex-2.0.6 → py3plex-2.0.8}/tests/test_book_conf.py

@@ -38,7 +38,7 @@ def test_conf_exposes_expected_metadata(conf_module):
     module, expected_path = conf_module
 
     assert module.project == "Practical Multilayer Network Analysis with Py3plex"
-    assert module.version == module.release == "2.0.6"
+    assert module.version == module.release == "2.0.8"
     assert module.language == "en"
     assert module.master_doc == "index"
     assert module.templates_path == ["_templates"]

{py3plex-2.0.6 → py3plex-2.0.8}/tests/test_book_manuscript_integrity.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-import tomllib
+import re
 
 
 BOOK_ROOT = Path(__file__).resolve().parents[1] / "book"
@@ -83,13 +83,13 @@ def _book_mentions_package_dir(combined_book: str, package_dir: str) -> bool:
 
 def test_front_matter_uses_canonical_version():
     text = _read("front_matter.rst")
-    assert "version 2.0.6 (2026)" in text
+    assert "version 2.0.8 (2026)" in text
     assert "version 1.0 (2025)" not in text
 
 
 def test_book_version_matches_project_version():
-    project_data = tomllib.loads((BOOK_ROOT.parent / "pyproject.toml").read_text(encoding="utf-8"))
-    project_version = project_data["project"]["version"]
+    version_source = (BOOK_ROOT.parent / "py3plex/_version.py").read_text(encoding="utf-8")
+    project_version = re.search(r'^__version__\s*=\s*"([^"]+)"', version_source, re.MULTILINE).group(1)
     assert f"version {project_version} (2026)" in _read("front_matter.rst")
     assert f"Version {project_version}" in _read("bibliography.rst")
 

{py3plex-2.0.6 → py3plex-2.0.8}/tests/test_cli.py

@@ -1587,3 +1587,33 @@ class TestCLITutorial:
         # Should include code snippets
         assert "from py3plex.core import multinet" in captured.out
         assert "network.add_edges" in captured.out
+
+
+class TestSafeDSLExpression:
+    def test_accepts_documented_builder_chains(self):
+        from py3plex.dsl.builder import QueryBuilder
+        from py3plex.safe_dsl_expression import evaluate_dsl_expression
+
+        builder = evaluate_dsl_expression(
+            'Q.nodes().from_layers(L["social"] + L["work"]).compute("degree").order_by("degree")'
+        )
+        assert isinstance(builder, QueryBuilder)
+        assert builder.to_ast().select.compute[0].name == "degree"
+
+    @pytest.mark.parametrize(
+        "expression",
+        [
+            '__import__("os").system("touch /tmp/py3plex_cli_pwned")',
+            'Q.nodes().__class__',
+            'L.__class__',
+            'Q.nodes().execute.__globals__',
+            '[x for x in (1, 2)]',
+            'lambda: Q.nodes()',
+            'Q.nodes().where(degree__gt=(1).__class__)',
+        ],
+    )
+    def test_rejects_python_execution_and_introspection(self, expression):
+        from py3plex.safe_dsl_expression import evaluate_dsl_expression
+
+        with pytest.raises(ValueError):
+            evaluate_dsl_expression(expression)

{py3plex-2.0.6 → py3plex-2.0.8}/tests/test_create_showcase_flow.py

@@ -49,6 +49,7 @@ def test_create_showcase_network_structure():
 
 
 def test_create_publication_quality_visualization_draws_and_saves(monkeypatch, capsys):
+    existing_figures = set(csf.plt.get_fignums())
     draw_calls = {}
 
     def fake_draw(graphs, multilinks, labels=None, ax=None, **kwargs):
@@ -109,4 +110,4 @@ def test_create_publication_quality_visualization_draws_and_saves(monkeypatch, c
     assert any("Multilayer Flow Visualization" in text for text in saved["texts"])
     assert any("Nodes sized and colored by network activity" in text for text in saved["texts"])
 
-    assert csf.plt.get_fignums() == []
+    assert set(csf.plt.get_fignums()) == existing_figures