phd-ms 0.0.0__py3-none-any.whl

phd-ms/__init__.py

@@ -0,0 +1,8 @@
+# __init__ file
+import warnings
+warnings.filterwarnings('ignore')
+
+from . import tools as tl
+
+import sys
+sys.modules.update({f'{__name__}.{m}': globals()[m] for m in ['tl']})

phd-ms/_utils/__init__.py

@@ -0,0 +1,3 @@
+from ._leiden import leiden
+from ._filtration import filt_to_matrix, union_find_dmat,get_sub_features
+from ._benchmark import clusters_to_distribution

phd-ms/_utils/_benchmark.py

@@ -0,0 +1,28 @@
+import numpy as np
+import ot
+import matplotlib.pyplot as plt
+from scipy.special import logit
+import pandas as pd
+
+def clusters_to_distribution(clusters):
+    if isinstance(clusters,pd.Series):
+        distribution = np.zeros((len(clusters.cat.categories.tolist()),len(clusters)))
+        for i in range(len(clusters)):
+            if isinstance(clusters.iloc[i],float):
+                continue
+            index = next(j for j in range(len(clusters.cat.categories.tolist())) if clusters.cat.categories.tolist()[j] == clusters.iloc[i])
+            distribution[index,i] = 1
+        cmat = distribution.transpose().copy()
+            
+    elif isinstance(clusters,np.ndarray):
+        cmat = clusters.copy()
+        distribution = np.zeros((clusters.shape[1],clusters.shape[0]))
+        for i in range(clusters.shape[0]):  # Iterate over rows
+            for j in range(clusters.shape[1]):  # Iterate over columns
+                if clusters[i,j] < 0.01:
+                    distribution[j,i] = 0
+                else:
+                    distribution[j,i] = 1
+    
+    distribution /= np.sum(distribution,axis=1,keepdims=True)
+    return distribution,cmat

phd-ms/_utils/_filtration.py

@@ -0,0 +1,141 @@
+import numpy as np
+import gudhi as gd
+
+def filt_to_matrix(simp_tree,threshold=.05):
+    matrix = np.ones((simp_tree.num_vertices(),simp_tree.num_vertices()))
+    #print(simp_tree.num_vertices())
+    max_node = np.max(list(x[1] for x in simp_tree.get_filtration() if len(x[0])==1))
+    for simplex in simp_tree.get_filtration():
+        
+        if len(simplex[0]) == 2:
+            
+            #if simp_tree.filtration([simplex[0][0]]) < threshold and simp_tree.filtration([simplex[0][1]]) < threshold:
+            matrix[simplex[0][0],simplex[0][1]] = simplex[1]
+            
+            if matrix[simplex[0][0],simplex[0][1]] == 0:
+                matrix[simplex[0][0],simplex[0][1]] = matrix[simplex[0][0],simplex[0][1]]+.0001
+            
+            matrix[simplex[0][1],simplex[0][0]] = matrix[simplex[0][0],simplex[0][1]]
+                
+    return matrix
+
+def union_find_dmat(dmat, edge_cut):
+
+    N = dmat.shape[0]
+
+    class Node:
+        def __init__ (self, loc, birth = 0):
+            self.loc = loc
+            self.parent = self.loc
+            self.birth = birth
+        def __str__(self):
+            return self.label
+        def __int__(self):
+            return self.loc
+
+    def Union(x, y, L):
+        xRoot = Find(x,L)
+        yRoot = Find(y,L)
+        if xRoot.loc != yRoot.loc:
+            if xRoot.birth > yRoot.birth:
+                xRoot.parent = yRoot.loc
+                return xRoot.loc # This should return the one that got killed
+            else:
+                yRoot.parent = xRoot.loc
+                return yRoot.loc # This should return the one that got killed
+
+    def Find(x,L):
+        if x.parent == x.loc:
+            return L[x.parent]
+        else:
+            return Find(L[x.parent], L)
+
+    # A list of allowed neighbors for each node
+    nb_dic = {}
+    for i in range(N):
+        tmp_list = []
+        for j in range(N):
+            if dmat[i][j] <= edge_cut and i!=j:
+                tmp_list.append(j)
+        nb_dic[i] = tmp_list
+
+    simplex_collection = []
+    simplex_index = {}
+    for i in range(N):
+        simplex_collection.append( ( [i], 0.0 ) )
+    for i in range(N-1):
+        for j in range(i+1, N):
+            if j in nb_dic[i]:
+                simplex_collection.append( ([i,j], dmat[i][j]))
+
+    filtration = []
+    tmp_list = []
+    for s in simplex_collection:
+        tmp_list.append(s[1])
+    simplex_order = np.argsort(tmp_list)
+    simplex_order[:N] = np.arange(N)[:]
+    cnt = 0; complex_filtration_detail = [];
+    for i in simplex_order:
+        if len(simplex_collection[i][0]) == 1:
+            complex_filtration_detail.append( [ (0,[]), simplex_collection[i][1], set(simplex_collection[i][0]) ] )
+            simplex_index[(i)] = cnt
+            cnt += 1
+        elif len(simplex_collection[i][0]) == 2:
+            n1 = simplex_collection[i][0][0];
+            n2 = simplex_collection[i][0][1];
+            complex_filtration_detail.append( [ (1, [n1,n2]), simplex_collection[i][1], set(simplex_collection[i][0]) ] )
+            simplex_index[(n1,n2)] = cnt
+            cnt += 1
+    persDgm_pairs = []
+    L = {0: Node(0, birth = 0)}
+    Cocycles = [[i] for i in range(N)]
+    Cocycle_fvalues = [[0.0] for i in range(N)]
+    for i in range(1, len(complex_filtration_detail)):
+        f = complex_filtration_detail[i]
+        if f[0][0] == 0:
+            L[i] = Node(i, birth=i)
+        else:
+            [n1,n2] = f[0][1]
+            killed = Union(L[n1], L[n2], L)
+            if n1 == killed:
+                lived = n2;
+            else:
+                lived = n1
+            if killed != None:
+                pair = (L[killed].birth, i)
+                persDgm_pairs.append(pair)
+                # print killed, n1, n2, dmat[n1,n2], L[killed].parent
+                Cocycles[L[killed].parent].extend(Cocycles[killed])
+                Cocycle_fvalues[L[killed].parent].extend([dmat[n1,n2] for i in range(len(Cocycles[killed]))])
+
+    setReps = [Find(L[v],L).loc for v in L.keys()]
+    persDgm = []
+    pair_births = []
+    for d in persDgm_pairs:
+        persDgm.append([complex_filtration_detail[d[0]][1], complex_filtration_detail[d[1]][1]])
+        pair_births.append(d[0])
+    unpaired = list(set(setReps))
+    for i in unpaired:
+        persDgm.append([complex_filtration_detail[i][1], np.inf])
+        pair_births.append(i)
+    pair_births = np.asarray(pair_births)
+    pair_births_index = np.argsort(pair_births)
+    diagram_0d = []
+    for i in pair_births_index:
+        d = persDgm[i]
+        diagram_0d.append([0,d[0],d[1]])
+    # print diagram_0d
+
+    # print Cocycles
+    # print Cocycle_fvalues
+    return [diagram_0d, Cocycles, Cocycle_fvalues]
+
+def get_sub_features(cocycles,diagram_0d,feature,feature_list):
+    
+    t,j = next(((set(cocycles[j]),j) for j in range(len(cocycles)) if set(cocycles[j])<feature),([],[])) 
+    if t != []:
+        feature_list.append((feature-t,diagram_0d[j][2]))
+            #feature_list.append((t,diagram_0d[j][2]))
+            #cocycles.remove(cocycles[j])
+        feature_list = get_sub_features(cocycles,diagram_0d,feature-t,feature_list)
+    return feature_list

phd-ms/_utils/_leiden.py

@@ -0,0 +1,41 @@
+import numpy as np
+import scanpy as sc
+from sklearn.metrics import adjusted_rand_score,adjusted_mutual_info_score
+
+def leiden(adata,res=np.linspace(start=0.2,stop=1.2,num=6),show=True,scores=False,embedding='X_gst',res_keys=[],ground_truth='cluster'):
+    if not res_keys:
+        res_keys = ['leiden_'+str(r) for r in res]
+    sc.pp.neighbors(adata,use_rep=embedding,n_neighbors=5)
+    
+    sc.tl.umap(adata)
+    for i in range(len(res)):
+        sc.tl.leiden(
+        adata,
+        key_added=res_keys[i],
+        resolution=res[i],
+        n_iterations=2,
+        directed=False,
+        )
+        if show:
+            sc.pl.umap(adata, color=res_keys[i])
+            sc.pl.embedding(adata, basis="spatial", color=res_keys[i])
+        if scores:
+            print('Resolution, adjusted mutual info, adjusted rand:')
+            print(cluster_metrics(adata.obs[ground_truth],adata.obs[res_keys[i]]))
+    
+    return adata
+
+def cluster_metrics(cluster,r,truth=None):
+    clusters = set(int(j) for j in cluster.cat.categories.tolist())
+    if not(truth is None):
+        l1 = np.zeros(len(truth))
+        l2 = np.zeros(len(truth))
+        for i in range(0,len(truth.cat.categories.tolist())):
+            guy = list(n for n in range(0,len(truth)) if truth.iloc[n]==truth.cat.categories.tolist()[i])
+            l1[guy] = i
+        for i in range(0,len(cluster.cat.categories.tolist())):
+            guy = list(n for n in range(0,len(cluster)) if cluster.iloc[n]==cluster.cat.categories.tolist()[i])
+            l2[guy] = i
+        return r,len(clusters),adjusted_mutual_info_score(l1,l2),adjusted_rand_score(l1,l2)
+    else:
+        return r,len(clusters)

phd-ms/tools/__init__.py

@@ -0,0 +1,8 @@
+
+from ._phdms import map_multiscale
+from ._phdms import preprocess_leiden
+from ._phdms import cluster_filtration
+from ._phdms import ground_truth_benchmark
+from ._phdms import plot_multiscale
+from ._phdms import construct_clustering
+from ._phdms import point_click_multiscale

phd-ms/tools/_phdms.py

@@ -0,0 +1,293 @@
+
+
+import numpy as np
+import scanpy as sc
+import gudhi as gd
+from .._utils import leiden, filt_to_matrix, union_find_dmat, get_sub_features, clusters_to_distribution
+import matplotlib.pyplot as plt
+from scipy.special import logit
+import ot
+import pandas as pd
+
+def preprocess_leiden(input_file,output_file='',emb='X_gst',resolution=np.linspace(start=0.05,stop=.95,num=10),res_keys=[],ground_truth='cluster'):
+    
+    adata = sc.read_h5ad(input_file+'.h5ad')
+    leiden(adata,res=resolution,show=False,embedding=emb,res_keys=res_keys,ground_truth=ground_truth)
+    adata.write_h5ad(output_file+'.h5ad')
+
+def cluster_filtration(adata,res_keys,index='containment',order=[]):
+
+    num_cells = adata.obsm['spatial'].shape[0]
+
+    #Reorder resolutions if order is given
+    if order:
+        res_keys = [res_keys[i] for i in reversed(order)]
+
+    #Create the filtration
+    leiden_complex = gd.SimplexTree()
+    
+    #List of number of clusters at each resolution
+    num_clusters = []
+    #List of sets of indices for each cluster at each resolution
+    clusters = []
+
+    #We want to iterate through pairs of neighboring resolutions
+    for i in range(0,len(res_keys)-1):
+        
+        #Initialize the pair of resolutions we look at
+        fine = adata.obs[res_keys[i]]
+        coarse = adata.obs[res_keys[i+1]]
+        fine_clusters = [int(j) for j in fine.cat.categories.tolist()]
+        coarse_clusters = [int(j) for j in coarse.cat.categories.tolist()]
+        
+        #Update number of clusters and clusters
+        #We want to add this information only on the first iteration
+        if i == 0:
+            num_clusters.append(len(fine_clusters))
+            for j in fine_clusters:
+                fine_j = set(n for n in range(0,len(fine)) if int(fine.iloc[n])==j)
+                clusters.append(fine_j)
+        
+        for k in coarse_clusters:
+            coarse_k = set(n for n in range(0,len(coarse)) if int(coarse.iloc[n])==k)
+            clusters.append(coarse_k)
+        num_clusters.append(len(coarse_clusters))
+        
+        #Now, we compare every cluster in the fine resolution with every cluster in the coarse resolution
+        for j in fine_clusters:
+            
+            #The j-th cluster in the fine resolution
+            fine_j = set(n for n in range(0,len(fine)) if int(fine.iloc[n])==j)
+
+            for k in coarse_clusters:
+                #The k-th cluster in the coarse resolution
+                coarse_k = set(n for n in range(0,len(coarse)) if int(coarse.iloc[n])==k)
+
+                #Compute union and intersection of the fine and coarse clusters
+                intersection = fine_j.intersection(coarse_k)
+                union = fine_j.union(coarse_k)
+                
+                #If they intersect, we compute a filtration value
+                if intersection:
+                    #Compute filtration value as either containment or Jaccard index
+                    if index == 'containment':
+                        filt = 1 - len(intersection)/len(fine_j)
+                    elif index == 'jaccard':
+                        filt = 1 - len(intersection)/len(union)
+                    
+                    #Add edge between clusters with this filtration value
+                    leiden_complex.insert([sum(num_clusters[:-2])+j,sum(num_clusters[0:-1])+k],filt)
+                                        
+    #Make sure that all the clusters have filtration value 0
+    for i in range(0,sum(num_clusters)):
+        leiden_complex.assign_filtration([i],0)
+    return leiden_complex,clusters
+
+def map_multiscale(spatial,cluster_complex,clusterings,num_domains=0,filt=0,plots="on",order='persistence',redundant_filter=False):
+
+    dmat = filt_to_matrix(cluster_complex)
+    diagram_0d,cocycles,_= union_find_dmat(dmat,edge_cut=1)
+    if num_domains == 0:
+        num_domains = len(cocycles)
+    
+    #Sort persistent homology results by death time
+    diagram_0d,cocycles = zip(*sorted(zip(diagram_0d,cocycles),key=lambda x: x[0][2],reverse=True))
+    #Filter out non-persistent results if desired.
+    if filt > 0:
+        index = next(i for i in range(len(diagram_0d)) if diagram_0d[i][2]<filt)
+        diagram_0d = diagram_0d[:index]
+        cocycles = list(cocycles[:index])
+    domains = []
+
+    #Iterate through persistent components
+    for n in range(len(cocycles)+1):
+        if n == 0:
+            feature_list = [(set(cocycles[n]),1)]
+        elif n == len(cocycles):
+            break
+        else:
+            feature_list = [(set(cocycles[n]),diagram_0d[n][2])]
+        #find all the clusters that belong to the multiscale domain
+        feature_list = get_sub_features(cocycles,diagram_0d,feature_list[0][0],feature_list)
+        
+                
+        x = spatial[:,0]
+        y = spatial[:,1]
+        coreness = np.ones(len(x))
+        #Compute coreness score for each point in the tissue
+        #iterate backwards through features to find filtration value where point first appears in multiscale domain
+        feature_list = sorted(feature_list,key= lambda x: x[1],reverse=True)
+        tracker = set()
+        for i in range(len(feature_list)-1, -1, -1):
+            
+            spots = set()
+            for clust in feature_list[i][0]:
+                spots = set.union(spots,clusterings[clust])
+            
+            coreness[list(spots-tracker)] = feature_list[i][1]
+            tracker = set.union(tracker,spots)
+
+        nontrivial = True
+        #Filter out results which share too similar proportions to previously examined domains
+        if redundant_filter:
+            for guy in domains:
+                zz = set(i for i in range(len(coreness)) if guy[i] < 1)
+                gg = set(i for i in range(len(coreness)) if coreness[i] < 1)
+                if len(gg.intersection(zz)) > redundant_filter*len(gg.union(zz)):
+                    nontrivial = False
+                    break
+        if nontrivial:
+            domains.append(coreness) 
+    
+    #Default order is by death time
+    #Ordered by size of domain if specified
+    if order == 'size':   
+        domains = sorted(domains,key = lambda x : sum(x)) 
+    elif order == 'persistence':
+        domains = domains
+
+    if len(domains) > num_domains:
+        domains = domains[:num_domains]
+
+    #Normalize the coreness values to be between 0 and 1
+    for i in range(len(domains)):
+        max = np.max(list(z for z in domains[i]))
+        min = np.min(list(z for z in domains[i]))
+        z  = list(1-(domains[i][j]-min)/(max-min) for j in range(len(domains[i])))
+         
+        domains[i] = np.array(z)
+
+    if plots == 'on':
+        for d in domains:
+            plot_multiscale(d,spatial)
+        plt.show()
+
+    return np.array(domains).transpose()
+
+
+#Currently broken
+def point_click_multiscale(spatial,cluster_complex,clusterings,filt=0,order='persistence',redundant_filter=True):
+    from mpl_point_clicker import clicker
+
+    domains = map_multiscale(spatial,cluster_complex,clusterings,num_domains=0,filt=filt,plots='off',order=order,redundant_filter=redundant_filter)
+    tracker = []
+    exit = False
+    while not exit:
+        
+        plt.figure(figsize=[15,15])
+        plt.rcParams.update({'font.size': 25})
+        ax = plt.gca()
+        ax.scatter(spatial[:,0],spatial[:,1],c='k')
+        ax.set_title('Click once to specify spot. Close to visualize domains')
+        ax.axes.xaxis.set_ticklabels([])
+        ax.axes.yaxis.set_ticklabels([])
+        klicker = clicker(ax, ["spot"], markers=["*"],markersize=20,colors=['red'])
+
+
+        plt.tight_layout()
+        plt.show()
+        xy = klicker.get_positions()['spot']
+        
+        input_ind = np.argmin((spatial[:,0]-xy[-1][0])**2+(spatial[:,1]-xy[-1][1])**2)
+        #print(input_ind)
+        input_cluster = list(i for i in range(len(clusterings)) if input_ind in clusterings[i])
+        #print(input_cluster)
+        x = spatial[:,0]
+        y = spatial[:,1]
+        
+        for d in domains.transpose():
+            if d[input_ind] > .95:
+                tracker.append(d)
+                plot_multiscale(d,spatial,marker=xy[-1])
+            plt.show()
+
+        exit = input('Press E to exit.')
+        if exit == 'E':
+            return tracker
+        
+
+def ground_truth_benchmark(ground_truth,multiscale,spatial,plots=False,conversion_factor=1):
+    
+    ground_truth_distributions,gmat = clusters_to_distribution(ground_truth)
+    multiscale_distributions,mmat = clusters_to_distribution(multiscale)
+    
+    dmat = ot.dist(spatial*conversion_factor,spatial*conversion_factor,metric='euclidean')
+    ma = np.max(dmat)
+    M = dmat/ma
+    optimal_costs = []
+    print('Wasserstein distance, index of optimal multiscale domain:')
+    for g in ground_truth_distributions:
+        g_cost = []
+        
+        for m in multiscale_distributions:
+            
+            d = ot.emd2(g,m,M)
+            g_cost.append(d)
+        optimal_costs.append((min(g_cost)*ma,np.argmin(g_cost)))
+        print((min(g_cost)*ma,int(np.argmin(g_cost))))
+
+    if plots:
+        for j in range(len(optimal_costs)):
+            plot_multiscale(gmat[:,j],spatial,title='Ground truth domain '+str(j))
+            plot_multiscale(mmat[:,optimal_costs[j][1]],spatial,title='Best match '+str(j))
+        plt.show()
+    return optimal_costs,ma
+
+def construct_clustering(adata,domains):
+    category = np.zeros(adata.shape[0])
+    spatial = adata.obsm['spatial']
+    #Identify cell spots by the domain they most belong to.
+    for n in range(len(category)):
+        #Find the max scoring domain
+        arg_max = int(np.argmax(list(adata.obsm['multiscale'][n,domain] for domain in domains)))
+        #Exclude cells which don't belong to any domain
+        max_score = np.max(list(adata.obsm['multiscale'][n,domain] for domain in domains))
+        if max_score > 0.05:
+            category[n] = str(arg_max+1)
+        else:
+            category[n] = str(len(domains)+2)
+    
+    # We want to get rid of unassigned spots
+    unassigned = list(n for n in range(len(category)) if category[n] == str(len(domains)+2))
+    new_spatial = spatial.copy()
+    new_spatial[unassigned,0] = 10**10
+    new_spatial[unassigned,1] = 10**10
+    for n in unassigned:
+        nearest_spot = np.argmin((new_spatial[:,0]-spatial[n,0])**2+(new_spatial[:,1]-spatial[n,1])**2)
+        category[n] = category[nearest_spot]
+
+    
+    plt.figure()
+    df = pd.DataFrame({"x":np.array(adata.obsm['spatial'][:,0]).flatten(), 
+                   "y":np.array(adata.obsm['spatial'][:,1]).flatten(), 
+                   "colors":np.array(category).flatten()})
+    cmap = plt.cm.Set1
+    norm = plt.Normalize(df['colors'].values.min(), df['colors'].values.max())
+    for i, dff in df.groupby("colors"):
+        plt.scatter(dff['x'], dff['y'], c=cmap(norm(dff['colors'])), 
+                edgecolors='none', label="Feature {:g}".format(i))
+
+    plt.legend()
+    plt.show()
+    category = list(str(int(n)) for n in category)
+    #print(category)
+    return pd.Categorical(category,categories=list(str(i) for i in range(1,len(domains)+1)))
+
+def plot_multiscale(multiscale,spatial,title='',marker=np.array([False])):
+    x = spatial[:,0]
+    y = spatial[:,1]
+    z = multiscale.copy()
+    z[z < .00002] = .00002
+    z[z > 1-.00002] = 1-.00002
+    
+    plt.figure(figsize=(8, 20/3))
+    plt.title(title)
+    plt.scatter(x,y,c=logit(z),cmap='magma',s=30,edgecolors='k',linewidths=.5)
+    if np.any(marker):
+        plt.scatter(marker[0],marker[1],c='r',s=40,edgecolors='k',linewidths=.5,marker='*')
+    cbar = plt.colorbar()
+    cbar.ax.set_ylabel('logit(coreness)')
+    frame1 = plt.gca()
+    frame1.axes.xaxis.set_ticklabels([])
+    frame1.axes.yaxis.set_ticklabels([])
+

phd_ms-0.0.0.dist-info/METADATA

@@ -0,0 +1,70 @@
+Metadata-Version: 2.4
+Name: phd-ms
+Version: 0.0.0
+Summary: Identifying multiscale tissue domains for spatial transcriptomic data using persistent homology.
+Author: Perry Beamer
+License: MIT License
+Keywords: multiscale domains,spatial transcriptomics,topological data analysis
+Classifier: Programming Language :: Python :: 3.9
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: gudhi>=3.8.0
+Requires-Dist: leidenalg>=0.9.0
+Requires-Dist: matplotlib==3.10.3
+Requires-Dist: mpl_point_clicker
+Requires-Dist: numpy>=1.23.4
+Requires-Dist: pandas>=2.2.0
+Requires-Dist: pot>=0.8.0
+Requires-Dist: scanpy==1.9.6
+Requires-Dist: scipy>=1.9.1
+Requires-Dist: scikit-learn>=1.5.1
+Requires-Dist: importlib-metadata
+Dynamic: license-file
+
+
+# PHD-MS: Persistent Homology for Domains at Multiple Scales
+
+Multiscale domain identification for spatial transcriptomic data.
+
+
+## Installation
+
+Simply install with pip:
+
+
+    pip install phd-ms
+
+Or install from source by downloading, cd to this directory, using:
+     
+    pip install .
+
+## Usage/Examples
+
+Detailed jupyter notebook tutorials are available in the examples folder. 
+Or simply download the file titled 'point_and_click.py' and run the file to use our clickable graphical interface. When using the point_and_click.py interface, update the directory where your data is stored by changing this line:
+```python
+DATA = '/home/pbeamer/Documents/graphst/visium_hne_graphst'
+```
+
+Here we'll show a simple example with Visium DLPFC data, using default parameters.
+First, import necessary components.
+```python
+import phd-ms
+import scanpy
+```
+Preprocessing steps here (note that we assume a spatially-aware embedding has already been computed for your data):
+```python
+INPUT_FILE= '/home/pbeamer/Documents/graphst/adata_151673
+phd_ms.tl.preprocess_leiden(INPUT_FILE,output_file=INPUT_FILE)
+```
+Compute persistent homology and plot 10 most prominent multiscale domains:
+```python
+cluster_complex,clusterings= phd_ms.tl.cluster_filtration(adata)
+phd_ms.tl.map_multiscale(adata.obsm['spatial'],cluster_complex,clusterings,num_domains=10)
+```

phd_ms-0.0.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+phd-ms/__init__.py,sha256=4eLPtR0jGYEKv5XFzeV6znhzTT4YY9qMyFharNe32HU,174
+phd-ms/_utils/__init__.py,sha256=FiNfN0yjfM-r8K9puwb8tfv_2AaQu05Am7lPLxUj9wo,150
+phd-ms/_utils/_benchmark.py,sha256=g4hhjNDt9volWpfMIwlknq0TuYehfVSBZmY-1jJCTxU,1156
+phd-ms/_utils/_filtration.py,sha256=QDtshEVaua4QE8aD5arhoXkX6TTH0L1QGRxLSqwqTYU,5106
+phd-ms/_utils/_leiden.py,sha256=KRwU7e1DrZ0AHEoHhMgWpgYnpFczUhSat9YRk4MbVXk,1655
+phd-ms/tools/__init__.py,sha256=OtrsN0G41ij-4yzlL1ttOHbpRDO1sMBB4VVMHvlaRnk,275
+phd-ms/tools/_phdms.py,sha256=K9FnPcRAthCEbgajCb0TV8lS5YvraPRBNqlYIC_l6-c,11645
+phd_ms-0.0.0.dist-info/licenses/LICENSE.md,sha256=Zil4ZnX79GtBY8AHDwyKlzSjb75MOMMg9GXsYJMs434,1069
+phd_ms-0.0.0.dist-info/METADATA,sha256=tN333bBq_Rtv6BvmHEP5LR2Sqo3wLhqcdnqteJR7sf8,2366
+phd_ms-0.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+phd_ms-0.0.0.dist-info/top_level.txt,sha256=wr28LuzNsdR9Qwox6lNBOd-Q1hakdumUHcXy8n7bTrA,7
+phd_ms-0.0.0.dist-info/RECORD,,

phd_ms-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

phd_ms-0.0.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Perry Beamer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

phd_ms-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+phd-ms