scFates 1.2.2__tar.gz → 1.2.3__tar.gz

{scfates-1.2.2/scFates.egg-info → scfates-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scFates
-Version: 1.2.2
+Version: 1.2.3
 Summary: scanpy compatible python suite for fast tree inference and advanced pseudotime downstream analysis
 Author: Louis Faure
 Project-URL: Repository, https://github.com/LouisFaure/scFates

{scfates-1.2.2 → scfates-1.2.3}/scFates/tools/dendrogram.py

@@ -82,12 +82,17 @@ def dendrogram(adata: anndata.AnnData, crowdedness: float = 1):
     df["seg_pos"] = df.seg.astype(str)
     df["t"] = -df.t
 
-    for i, x in enumerate(newseg):
-        df.loc[df.seg == newseg.index[i], "seg_pos"] = x
-
-    df.seg_pos = df.seg_pos.astype("category").cat.rename_categories(
-        range(len(df.seg_pos.unique()))
-    )
+    # Sort newseg BEFORE assigning positions to cells
+    # This ensures the categorical mapping matches the dendrogram segment order
+    newseg_sorted = newseg.iloc[newseg.argsort()]
+    
+    # Create mapping from segment ID to sorted position index
+    seg_to_pos = {seg_id: i for i, seg_id in enumerate(newseg_sorted.index)}
+    
+    # Assign positions to cells based on sorted order
+    for seg_id, pos_idx in seg_to_pos.items():
+        df.loc[df.seg == seg_id, "seg_pos"] = pos_idx
+    
     df.seg_pos = df.seg_pos.astype(int).astype("category")
 
     dend = stripplot(

{scfates-1.2.2 → scfates-1.2.3}/scFates/tools/graph_fitting.py

@@ -23,6 +23,132 @@ from .. import settings
 from .utils import get_X
 
 
+def _patch_elpigraph_grammar():
+    """Monkey-patch elpigraph's AddNode2Node to fix numpy 2.x scalar assignment.
+
+    In elpigraph 0.3.2, ``ineighbour`` is a 1-element array but is used as a
+    scalar index, causing ``ValueError: setting an array element with a sequence``
+    on numpy ≥ 2.0 (Linux x86 build) because:
+      - ``Mus[ineighbour]`` returns shape ``(1,)`` assigned to a scalar slot
+      - ``NodePositions[ineighbour,]`` returns shape ``(1, ndims)`` instead of ``(ndims,)``
+    """
+    try:
+        import elpigraph.src.grammar_operations as _go
+    except ImportError:
+        return
+
+    _orig = _go.AddNode2Node
+
+    def _patched_AddNode2Node(
+        X,
+        NodePositions,
+        ElasticMatrix,
+        partition,
+        AdjustVect,
+        FixNodesAtPoints,
+        Max_K=float("inf"),
+        MaxNumberOfGraphCandidates=float("inf"),
+        PointWeights=None,
+    ):
+        import numpy as _np
+
+        nNodes = NodePositions.shape[0]
+        Mus = ElasticMatrix.diagonal()
+        Lambda = ElasticMatrix.copy()
+        _np.fill_diagonal(Lambda, 0)
+        indL = Lambda > 0
+        Connectivities = indL.sum(axis=0)
+
+        if PointWeights is not None:
+            assoc = _np.bincount(
+                partition[partition > -1].ravel(),
+                weights=PointWeights[partition > -1].ravel(),
+                minlength=nNodes,
+            )
+        else:
+            assoc = _np.bincount(
+                partition[partition > -1].ravel(), minlength=nNodes
+            )
+
+        npProt = _np.vstack(
+            (NodePositions, _np.zeros((1, NodePositions.shape[1])))
+        )
+        emProt = _np.vstack(
+            (
+                _np.hstack((Lambda, _np.zeros((nNodes, 1)))),
+                _np.zeros((1, nNodes + 1)),
+            )
+        )
+        niProt = _np.arange(nNodes + 1, dtype=int)
+        MuProt = _np.zeros(nNodes + 1)
+        MuProt[:-1] = Mus
+
+        if not _np.isinf(Max_K):
+            Degree = _np.sum(ElasticMatrix > 0, axis=1)
+            Degree[Degree > 1] = Degree[Degree > 1] - 1
+            if _np.sum(Degree <= Max_K) > 1:
+                idx_nodes = _np.where(Degree <= Max_K)[0]
+            else:
+                raise ValueError(
+                    "AddNode2Node impossible with the current parameters!"
+                )
+        else:
+            idx_nodes = _np.array(range(nNodes))
+
+        if MaxNumberOfGraphCandidates < len(idx_nodes) and _np.isinf(Max_K):
+            idx_nodes = _np.argsort(assoc)[::-1][:MaxNumberOfGraphCandidates]
+        elif MaxNumberOfGraphCandidates < len(idx_nodes) and not (
+            _np.isinf(Max_K)
+        ):
+            nGraphs = [
+                i
+                for i in _np.argsort(assoc)[::-1]
+                if i in idx_nodes
+            ]
+            idx_nodes = _np.array(nGraphs)[:MaxNumberOfGraphCandidates]
+
+        if FixNodesAtPoints != []:
+            idx_nodes = idx_nodes[
+                ~_np.isin(idx_nodes, _np.arange(len(FixNodesAtPoints)))
+            ]
+
+        NodePositionsArray = [npProt.copy() for i in range(len(idx_nodes))]
+        ElasticMatrices = [emProt.copy() for i in range(len(idx_nodes))]
+        NodeIndicesArray = _np.repeat(
+            niProt[:, _np.newaxis], len(idx_nodes), axis=1
+        )
+        AdjustVectArray = [AdjustVect + [False] for i in range(len(idx_nodes))]
+
+        for j, i in enumerate(idx_nodes):
+            MuProt[-1] = 0
+            meanL = Lambda[i, indL[i,]].mean(axis=0)
+            ElasticMatrices[j][nNodes, i] = ElasticMatrices[j][i, nNodes] = meanL
+
+            if Connectivities[i] == 1:
+                ineighbour = _np.nonzero(indL[i,])[0][0]  # scalar, not array
+                NewNodePosition = (
+                    2 * NodePositions[i,] - NodePositions[ineighbour,]
+                )
+                MuProt[i] = Mus[ineighbour]  # scalar assignment
+            else:
+                if assoc[i] == 0:
+                    NewNodePosition = NodePositions[indL[:, i]].mean(axis=0)
+                else:
+                    NewNodePosition = X[(partition == i).ravel()].mean(axis=0)
+
+            NodePositionsArray[j][nNodes, :] = NewNodePosition
+            _np.fill_diagonal(ElasticMatrices[j], MuProt)
+
+        return (
+            NodePositionsArray,
+            ElasticMatrices,
+            AdjustVectArray,
+            NodeIndicesArray,
+        )
+
+    _go.AddNode2Node = _patched_AddNode2Node
+
+
 def curve(
     adata: AnnData,
     Nodes: int = None,
@@ -466,6 +592,8 @@ def tree_epg(
 
     import elpigraph
 
+    _patch_elpigraph_grammar()
+
     logg.hint(
         "parameters used \n"
         "    "
@@ -528,6 +656,8 @@ def curve_epg(
 ):
     import elpigraph
 
+    _patch_elpigraph_grammar()
+
     X, use_rep = get_data(adata, use_rep, ndims_rep)
     X = X.values
 
@@ -593,6 +723,8 @@ def circle_epg(
 ):
     import elpigraph
 
+    _patch_elpigraph_grammar()
+
     X, use_rep = get_data(adata, use_rep, ndims_rep)
     X = X.values
 

{scfates-1.2.2 → scfates-1.2.3/scFates.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scFates
-Version: 1.2.2
+Version: 1.2.3
 Summary: scanpy compatible python suite for fast tree inference and advanced pseudotime downstream analysis
 Author: Louis Faure
 Project-URL: Repository, https://github.com/LouisFaure/scFates