py2ls 0.2.4.2__py3-none-any.whl → 0.2.4.3__py3-none-any.whl

py2ls/bio.py

@@ -4,8 +4,13 @@ import pandas as pd
 import os
 import logging
 from . import ips
+from . import plot 
+import matplotlib.pyplot as plt 
+
 def load_geo(
-    datasets: Union[list, str] = ["GSE00000", "GSE00001"], dir_save: str = "./datasets", verbose=False
+    datasets: Union[list, str] = ["GSE00000", "GSE00001"],
+    dir_save: str = "./datasets",
+    verbose=False,
 ) -> dict:
     """
     Check if GEO datasets are already in the directory, and download them if not.
@@ -17,7 +22,7 @@ def load_geo(
     Returns:
     dict: A dictionary containing the GEO objects for each dataset.
     """
-    use_str="""
+    use_str = """
     get_meta(geo: dict, dataset: str = "GSE25097")
     get_expression_data(geo: dict, dataset: str = "GSE25097")
     get_probe(geo: dict, dataset: str = "GSE25097", platform_id: str = "GPL10687")
@@ -51,7 +56,7 @@ def load_geo(
     return geo_data
 
 
-def get_meta(geo: dict, dataset: str = "GSE25097",verbose=True) -> pd.DataFrame:
+def get_meta(geo: dict, dataset: str = "GSE25097", verbose=True) -> pd.DataFrame:
     """
     df_meta = get_meta(geo, dataset="GSE25097")
     Extracts metadata from a specific GEO dataset and returns it as a DataFrame.
@@ -122,23 +127,29 @@ def get_meta(geo: dict, dataset: str = "GSE25097",verbose=True) -> pd.DataFrame:
         print(
             f"Meta info columns for dataset '{dataset}': \n{sorted(meta_df.columns.tolist())}"
         )
-    return meta_df 
+        display(meta_df[:3].T)
+    return meta_df
+
 
-def get_probe(geo: dict, dataset: str = "GSE25097", platform_id: str = None, verbose=True):
+def get_probe(
+    geo: dict, dataset: str = "GSE25097", platform_id: str = None, verbose=True
+):
     """
     df_probe = get_probe(geo, dataset="GSE25097", platform_id: str = "GPL10687")
     """
     # try to find the platform_id from meta
     if platform_id is None:
-        df_meta=get_meta(geo=geo, dataset=dataset,verbose=False)
-        platform_id=df_meta["platform_id"].unique().tolist()
-        platform_id = platform_id[0] if len(platform_id)==1 else platform_id
+        df_meta = get_meta(geo=geo, dataset=dataset, verbose=False)
+        platform_id = df_meta["platform_id"].unique().tolist()
+        platform_id = platform_id[0] if len(platform_id) == 1 else platform_id
         print(platform_id)
     df_probe = geo[dataset].gpls[platform_id].table
     if df_probe.empty:
-        print(f"above is meta info, failed to find the probe info. 看一下是不是在单独的文件中包含了probe信息")
+        print(
+            f"above is meta info, failed to find the probe info. 看一下是不是在单独的文件中包含了probe信息"
+        )
         return get_meta(geo, dataset, verbose=True)
-    if verbose: 
+    if verbose:
         print(f"columns in the probe table: \n{sorted(df_probe.columns.tolist())}")
     return df_probe
 
@@ -170,17 +181,18 @@ def get_expression_data(geo: dict, dataset: str = "GSE25097") -> pd.DataFrame:
     return expression_values
 
 
-
-def get_data(geo: dict, dataset: str = "GSE25097",verbose=True):
+def get_data(geo: dict, dataset: str = "GSE25097", verbose=True):
     # get probe info
-    df_probe = get_probe(geo,dataset=dataset,verbose=False)
+    df_probe = get_probe(geo, dataset=dataset, verbose=False)
     # get expression values
-    df_expression = get_expression_data(geo, dataset=dataset )
+    df_expression = get_expression_data(geo, dataset=dataset)
     print(
         f"df_expression.shape: {df_expression.shape} \ndf_probe.shape: {df_probe.shape}"
     )
     if any([df_probe.empty, df_expression.empty]):
-        print(f"above is meta info, failed to find the probe info. 看一下是不是在单独的文件中包含了probe信息")
+        print(
+            f"above is meta info, failed to find the probe info. 看一下是不是在单独的文件中包含了probe信息"
+        )
         return get_meta(geo, dataset, verbose=True)
     df_exp = pd.merge(
         df_probe,
@@ -191,27 +203,48 @@ def get_data(geo: dict, dataset: str = "GSE25097",verbose=True):
     )
 
     # get meta info
-    df_meta=get_meta(geo, dataset=dataset,verbose=False)
-    col_rm=['channel_count','contact_web_link','contact_address', 'contact_city', 'contact_country', 'contact_department', 'contact_email', 'contact_institute', 'contact_laboratory', 'contact_name', 'contact_phone', 'contact_state', 'contact_zip/postal_code', 'contributor', 'manufacture_protocol', 'taxid','web_link']
+    df_meta = get_meta(geo, dataset=dataset, verbose=False)
+    col_rm = [
+        "channel_count",
+        "contact_web_link",
+        "contact_address",
+        "contact_city",
+        "contact_country",
+        "contact_department",
+        "contact_email",
+        "contact_institute",
+        "contact_laboratory",
+        "contact_name",
+        "contact_phone",
+        "contact_state",
+        "contact_zip/postal_code",
+        "contributor",
+        "manufacture_protocol",
+        "taxid",
+        "web_link",
+    ]
     # rm unrelavent columns
     df_meta = df_meta.drop(columns=[col for col in col_rm if col in df_meta.columns])
     # sorte columns
-    df_meta = df_meta.reindex(sorted(df_meta.columns),axis=1)
+    df_meta = df_meta.reindex(sorted(df_meta.columns), axis=1)
     # find a proper column
-    col_sample_id = ips.strcmp("sample_id",df_meta.columns.tolist())[0]
-    df_meta.set_index(col_sample_id, inplace=True) # set gene symbol as index
-    
-    col_gene_symbol = ips.strcmp("GeneSymbol",df_exp.columns.tolist())[0]
+    col_sample_id = ips.strcmp("sample_id", df_meta.columns.tolist())[0]
+    df_meta.set_index(col_sample_id, inplace=True)  # set gene symbol as index
+
+    col_gene_symbol = ips.strcmp("GeneSymbol", df_exp.columns.tolist())[0]
     # select the 'GSM' columns
     col_gsm = df_exp.columns[df_exp.columns.str.startswith("GSM")].tolist()
     df_exp.set_index(col_gene_symbol, inplace=True)
-    df_exp=df_exp[col_gsm].T # transpose, so that could add meta info
-    
-    df_merged=ips.df_merge(df_meta,df_exp)
+    df_exp = df_exp[col_gsm].T  # transpose, so that could add meta info
+
+    df_merged = ips.df_merge(df_meta, df_exp)
     if verbose:
-        print(f"\ndataset:'{dataset}' n_sample = {df_merged.shape[0]}, n_gene={df_exp.shape[1]}")
-        display(df_merged.sample(10))
-    return df_merged 
+        print(
+            f"\ndataset:'{dataset}' n_sample = {df_merged.shape[0]}, n_gene={df_exp.shape[1]}"
+        )
+        display(df_merged.sample(5))
+    return df_merged
+
 
 def split_at_lower_upper(lst):
     """
@@ -228,16 +261,17 @@ def split_at_lower_upper(lst):
                 return lst[: i + 1], lst[i + 1 :]
     return lst, []
 
-def get_condition(
+
+def add_condition(
     data: pd.DataFrame,
-    column:str="characteristics_ch1",#在哪一行进行分类
-    column_new:str="condition",# 新col的命名
-    by:str="tissue: tumor liver",# 通过by来命名
-    by_not:str=": tumor",  # 健康的选择条件
-    by_name:str="non-tumor",  # 健康的命名
-    by_not_name:str="tumor",  # 不健康的命名
-    inplace: bool = True, #replace the data
-    verbose:bool = True
+    column: str = "characteristics_ch1",  # 在哪一行进行分类
+    column_new: str = "condition",  # 新col的命名
+    by: str = "tissue: tumor liver",  # 通过by来命名
+    by_not: str = ": tumor",  # 健康的选择条件
+    by_name: str = "non-tumor",  # 健康的命名
+    by_not_name: str = "tumor",  # 不健康的命名
+    inplace: bool = True,  # replace the data
+    verbose: bool = True,
 ):
     """
     Add a new column to the DataFrame based on the presence of a specific substring in another column.
@@ -255,18 +289,225 @@ def get_condition(
 
     """
     # first check the content in column
-    content=data[column].unique().tolist()
+    content = data[column].unique().tolist()
     if verbose:
-        if len(content)>10:
+        if len(content) > 10:
             display(content[:10])
         else:
             display(content)
     # 优先by
     if by:
-        data[column_new] = data[column].apply(lambda x: by_name if by in x else by_not_name)
+        data[column_new] = data[column].apply(
+            lambda x: by_name if by in x else by_not_name
+        )
     elif by_not:
-        data[column_new] = data[column].apply(lambda x: by_not_name if not by_not in x else by_name)
+        data[column_new] = data[column].apply(
+            lambda x: by_not_name if not by_not in x else by_name
+        )
+    if verbose:
+        display(data)
+    if not inplace:
+        return data
+
+
+def add_condition_multi(
+    data: pd.DataFrame,
+    column: str = "characteristics_ch1",  # Column to classify
+    column_new: str = "condition",  # New column name
+    conditions: dict = {
+        "low": "low",
+        "high": "high",
+        "intermediate": "intermediate",
+    },  # A dictionary where keys are substrings and values are condition names
+    default_name: str = "unknown",  # Default name if no condition matches
+    inplace: bool = True,  # Whether to replace the data
+    verbose: bool = True,
+):
+    """
+    Add a new column to the DataFrame based on the presence of specific substrings in another column.
+
+    Parameters
+    ----------
+    data : pd.DataFrame
+        The input DataFrame containing the data.
+    column : str, optional
+        The name of the column in which to search for the substrings (default is 'characteristics_ch1').
+    column_new : str, optional
+        The name of the new column to be created (default is 'condition').
+    conditions : dict, optional
+        A dictionary where keys are substrings to search for and values are the corresponding labels.
+    default_name : str, optional
+        The name to assign if no condition matches (default is 'unknown').
+    inplace : bool, optional
+        Whether to modify the original DataFrame (default is True).
+    verbose : bool, optional
+        Whether to display the unique values and final DataFrame (default is True).
+    """
+
+    # Display the unique values in the column
+    content = data[column].unique().tolist()
+    if verbose:
+        if len(content) > 10:
+            display(content[:10])
+        else:
+            display(content)
+
+    # Check if conditions are provided
+    if conditions is None:
+        raise ValueError(
+            "Conditions must be provided as a dictionary with substrings and corresponding labels."
+        )
+
+    # Define a helper function to map the conditions
+    def map_condition(value):
+        for substring, label in conditions.items():
+            if substring in value:
+                return label
+        return default_name  # If no condition matches, return the default name
+
+    # Apply the mapping function to create the new column
+    data[column_new] = data[column].apply(map_condition)
+
+    # Display the updated DataFrame if verbose is True
     if verbose:
         display(data)
+
     if not inplace:
-        return data
+        return data
+
+def clean_dataset(
+    data: pd.DataFrame, dataset: str = "GSE25097", condition: str = "condition",sep="///"
+):
+    """
+    #* it has been involved in bio.batch_effects(), but default: False
+    1. clean data set and prepare super_datasets
+    2. if "///" in index, then extend it, or others.
+    3. drop duplicates and dropna()
+    4. add the 'condition' and 'dataset info' to the columns
+    5. set genes as index
+    """
+    #! (4.1) clean data set and prepare super_datasets
+    # df_data_2, 左边的列是meta,右边的列是gene_symbol
+    col_gene = split_at_lower_upper(data.columns.tolist())[1][0]
+    idx = ips.strcmp(col_gene, data.columns.tolist())[1]
+    df_gene = data.iloc[:, idx:].T  # keep the last 'condition'
+
+    #! if "///" in index, then extend it, or others.
+    print(f"before extend shape: {df_gene.shape}")
+    df = df_gene.reset_index()
+    df_gene = ips.df_extend(df, column="index", sep=sep)
+    # reset 'index' column as index
+    # df_gene = df_gene.set_index("index")
+    print(f"after extended by '{sep}' shape: {df_gene.shape}")
+
+    # *alternative:
+    # df_unique = df.reset_index().drop_duplicates(subset="index").set_index("index")
+    #! 4.2 drop duplicates and dropna()
+    df_gene = df_gene.drop_duplicates(subset=["index"]).dropna()
+    print(f"drop duplicates and dropna: shape: {df_gene.shape}")
+
+    #! add the 'condition' and 'dataset info' to the columns
+    ds = [data["dataset"][0]] * len(df_gene.columns[1:])
+    samp = df_gene.columns.tolist()[1:]
+    cond = df_gene[df_gene["index"] == condition].values.tolist()[0][1:]
+    df_gene.columns = ["index"] + [
+        f"{ds}_{sam}_{cond}" for (ds, sam, cond) in zip(ds, samp, cond)
+    ]
+    df_gene.drop(df_gene[df_gene["index"] == condition].index, inplace=True)
+    #! set genes as index
+    df_gene.set_index("index",inplace=True)
+    display(df_gene.head())
+    return df_gene
+
+def batch_effect(
+    data: list = "[df_gene_1, df_gene_2, df_gene_3]",
+    datasets: list = ["GSE25097", "GSE62232", "GSE65372"],
+    clean_data:bool=False, # default, not do data cleaning
+    top_genes:int=10,# only for plotting
+    plot_=True,
+    dir_save="./res/",
+    kws_clean_dataset:dict={},
+    **kwargs
+):
+    """
+    usage 1: 
+        bio.batch_effect(
+                data=[df_gene_1, df_gene_2, df_gene_3],
+                datasets=["GSE25097", "GSE62232", "GSE65372"],
+                clean_data=False,
+                dir_save="./res/")
+    
+    #! # or conbine clean_dataset and batch_effect together
+        # # data = [bio.clean_dataset(data=dt, dataset=ds) for (dt, ds) in zip(data, datasets)]
+        data_common = bio.batch_effect(
+                    data=[df_data_1, df_data_2, df_data_3],
+                    datasets=["GSE25097", "GSE62232", "GSE65372"], clean_data=True
+                    )
+    """
+    # data = [df_gene_1, df_gene_2, df_gene_3]
+    # datasets = ["GSE25097", "GSE62232", "GSE65372"]
+    # top_genes = 10  # show top 10 genes
+    # plot_ = True
+    from combat.pycombat import pycombat
+    if clean_data:
+        data=[clean_dataset(data=dt,dataset=ds,**kws_clean_dataset) for (dt,ds) in zip(data,datasets)]
+    #! prepare data
+    # the datasets are dataframes where:
+    # the indexes correspond to the gene names
+    # the column names correspond to the sample names
+    #! merge batchs
+    # https://epigenelabs.github.io/pyComBat/
+    # we merge all the datasets into one, by keeping the common genes only
+    df_expression_common_genes = pd.concat(data, join="inner", axis=1)
+    #! convert to float
+    ips.df_astype(df_expression_common_genes, astype="float", inplace=True)
+
+    #!to visualise results, use Mini datasets, only take the first 10 samples of each batch(dataset)
+    if plot_:
+        col2plot = []
+        for ds in datasets:
+            # select the first 10 samples to plot, to see the diff
+            dat_tmp = df_expression_common_genes.columns[
+                df_expression_common_genes.columns.str.startswith(ds)
+            ][:top_genes].tolist()
+            col2plot.extend(dat_tmp)
+        # visualise results
+        _, axs = plt.subplots(2, 1, figsize=(15, 10))
+        plot.plotxy(
+            ax=axs[0],
+            data=df_expression_common_genes.loc[:, col2plot],
+            kind="bar",
+            figsets=dict(
+                title="Samples expression distribution (non-correction)",
+                ylabel="Observations",
+                xangle=90,
+            ),
+        )
+    # prepare batch list
+    batch = [
+        ips.ssplit(i, by="_")[0] for i in df_expression_common_genes.columns.tolist()
+    ]
+    # run pyComBat
+    df_corrected = pycombat(df_expression_common_genes, batch, **kwargs)
+    print(f"df_corrected.shape: {df_corrected.shape}")
+    display(df_corrected.head())
+    # visualise results again
+    if plot_:
+
+        plot.plotxy(
+            ax=axs[1],
+            data=df_corrected.loc[:, col2plot],
+            kind="bar",
+            figsets=dict(
+                title="Samples expression distribution (corrected)",
+                ylabel="Observations",
+                xangle=90,
+            ),
+        )
+        if dir_save is not None:
+            ips.figsave(dir_save + "batch_sample_exp_distri.pdf")
+    return df_corrected
+
+def get_common_genes(elment1, elment2):
+    common_genes=ips.shared(elment1, elment2)
+    return common_genes

py2ls/ips.py

@@ -51,8 +51,6 @@ from bs4 import BeautifulSoup
 
 from . import netfinder
 
-# from .plot import get_color
-
 try:
     get_ipython().run_line_magic("load_ext", "autoreload")
     get_ipython().run_line_magic("autoreload", "2")
@@ -518,6 +516,59 @@ def is_text(s):
     return has_alpha and has_non_alpha
 
 
+from typing import Any, Union
+
+def shared(lst1:Any, lst2:Any,*args, verbose=True):
+    """
+    check the shared elelements in two list.
+    usage:
+        list1 = [1, 2, 3, 4, 5]
+        list2 = [4, 5, 6, 7, 8]
+        list3 = [5, 6, 9, 10]   
+        a = shared(list1, list2,list3)
+    """
+    if verbose:
+        print("\n********* checking shared elements *********")
+    if any([not isinstance(lst1,list),not isinstance(lst1,list)]):
+        print(f"{' '*2}type(list1):\t{type(lst1)},\n{' '*2}type(list2):\t{type(lst2)}>")
+    shared_elements=set(flatten(lst1,verbose=verbose)).intersection(flatten(lst2,verbose=verbose))
+    # support more lists
+    if args:
+        for arg in args:
+            shared_elements=shared_elements.intersection(set(flatten(arg,verbose=verbose)))
+    shared_elements = list(shared_elements)
+    if verbose:
+        elements2show = shared_elements if len(shared_elements)<10 else shared_elements[:5]
+        print(f"{' '*2}{len(shared_elements)} elements shared: {' '*2}{elements2show}")
+        print("********* checking shared elements *********")
+    return shared_elements
+
+def flatten(nested: Any, unique_list=True,verbose=True):
+    """
+    Recursively flattens a nested structure (lists, tuples, dictionaries, sets) into a single list.
+    Parameters:
+        nested : Any, Can be a list, tuple, dictionary, or set.
+    Returns: list, A flattened list.
+    """ 
+    flattened_list = []
+    stack = [nested]
+    while stack:
+        current = stack.pop()
+        if isinstance(current, dict):
+            stack.extend(current.values())
+        elif isinstance(current, (list, tuple, set)):
+            stack.extend(current)
+        elif isinstance(current, pd.Series):
+            stack.extend(current)
+        else:
+            flattened_list.append(current)
+    if verbose:
+        print(f"{' '*2}<in info: {len(unique(flattened_list))} elements after flattened>")
+    if unique_list:
+        return unique(flattened_list)
+    else:
+        return flattened_list
+    
 def strcmp(search_term, candidates, ignore_case=True, verbose=False, scorer="WR"):
     """
     Compares a search term with a list of candidate strings and finds the best match based on similarity score.
@@ -548,7 +599,7 @@ def strcmp(search_term, candidates, ignore_case=True, verbose=False, scorer="WR"
             similarity_scores = [fuzz.partial_ratio(str1_, word) for word in str2_]
         elif "W" in scorer.lower():
             similarity_scores = [fuzz.WRatio(str1_, word) for word in str2_]
-        elif "ratio" in scorer.lower():#Ratio (Strictest)
+        elif "ratio" in scorer.lower() or "stri" in scorer.lower():#Ratio (Strictest)
             similarity_scores = [fuzz.ratio(str1_, word) for word in str2_]
         else:
             similarity_scores = [fuzz.WRatio(str1_, word) for word in str2_]
@@ -1721,7 +1772,7 @@ def fload(fpath, kind=None, **kwargs):
         fmt=kwargs.pop("fmt",False)
         verbose=kwargs.pop("verbose",False)
         if verbose:
-            print_pd_usage("read_csv", verbose=verbose)
+            use_pd("read_csv", verbose=verbose)
             return
         
         if comment is None:
@@ -1853,7 +1904,7 @@ def fload(fpath, kind=None, **kwargs):
         engine = kwargs.get("engine", "openpyxl")
         verbose=kwargs.pop("verbose",False)
         if verbose:
-            print_pd_usage("read_excel", verbose=verbose)
+            use_pd("read_excel", verbose=verbose)
         df = pd.read_excel(fpath, engine=engine, **kwargs)
         try:
             meata=pd.ExcelFile(fpath)
@@ -2263,7 +2314,7 @@ def fsave(
 
         verbose=kwargs.pop("verbose",False)
         if verbose:
-            print_pd_usage("to_csv", verbose=verbose)
+            use_pd("to_csv", verbose=verbose)
         kwargs_csv = dict(
             path_or_buf=None,
             sep=",",
@@ -2295,7 +2346,7 @@ def fsave(
         verbose=kwargs.pop("verbose",False)
         sheet_name = kwargs.pop("sheet_name", "Sheet1")
         if verbose:
-            print_pd_usage("to_excel", verbose=verbose)
+            use_pd("to_excel", verbose=verbose)
         if any(kwargs):
             format_excel(df=data, filename=fpath, **kwargs)
         else:
@@ -4444,7 +4495,42 @@ def preview(var):
 # preview("# This is a Markdown header")
 # preview(pd.DataFrame({"Name": ["Alice", "Bob"], "Age": [25, 30]}))
 # preview({"key": "value", "numbers": [1, 2, 3]})
-
+def df_extend(data: pd.DataFrame, column, axis=0, sep=None, prefix="col"):
+    """
+    Extend a DataFrame by the list elecments in the column.
+    
+    Parameters:
+    ----------
+    data : pd.DataFrame
+        The input DataFrame to be extended.
+    
+    column : str
+        The name of the column to be split.
+    
+    axis : int, optional
+        The axis along which to expand the DataFrame. 
+        - 0 (default): Expand the specified column into multiple rows.
+        - 1: Expand the specified column into multiple columns.
+    
+    sep : str, optional
+        The separator used to split the values in the specified column.
+        Must be provided for the function to work correctly.
+    """
+    
+    data = data.copy() 
+    mask = data[column].str.contains(sep, na=False)
+    data = data.copy()
+    if mask.any():
+        data[column] = (
+            data[column]
+            .apply(lambda x: x.split(sep) if isinstance(x, str) else x)  # Only split if x is a string
+        )
+        
+        # Strip spaces from each item in the lists
+        data[column] = data[column].apply(lambda x: [item.strip() for item in x] if isinstance(x, list) else x)
+        
+    data = data.explode(column, ignore_index=True)
+    return data
 # ! DataFrame
 def df_astype(
     data: pd.DataFrame,
@@ -4731,7 +4817,7 @@ def df_merge(
     """
 
     # 1. Check if indices are comparable (same length and types)
-    if use_index or df1.index.equals(df2.index):
+    if use_index:
         print(f"Merging based on index using '{how}' join...")
         df_merged = pd.merge(df1, df2, left_index=True, right_index=True, how=how)
         return df_merged
@@ -4984,7 +5070,7 @@ def df_cluster(
         X = scaler.fit_transform(X)
 
     for n_cluster in range_n_clusters:
-        kmeans = KMeans(n_clusters=n_cluster, random_state=42)
+        kmeans = KMeans(n_clusters=n_cluster, random_state=1)
         cluster_labels = kmeans.fit_predict(X)
 
         silhouette_avg = silhouette_score(X, cluster_labels)
@@ -5000,7 +5086,7 @@ def df_cluster(
     print(f"n_clusters = {n_clusters}")
 
     # Apply K-Means Clustering with Optimal Number of Clusters
-    kmeans = KMeans(n_clusters=n_clusters, random_state=42)
+    kmeans = KMeans(n_clusters=n_clusters, random_state=1)
     cluster_labels = kmeans.fit_predict(X)
 
     if plot:
@@ -5101,7 +5187,7 @@ def df_cluster(
         # n_clusters = (
         #     np.argmax(silhouette_avg_scores) + 2
         # )  # Optimal clusters based on max silhouette score
-        # kmeans = KMeans(n_clusters=n_clusters, random_state=42)
+        # kmeans = KMeans(n_clusters=n_clusters, random_state=1)
         # cluster_labels = kmeans.fit_predict(X)
         silhouette_vals = silhouette_samples(X, cluster_labels)
 
@@ -5252,12 +5338,14 @@ def df_reducer(
     columns: Optional[List[str]] = None,
     method: str = "umap",  # 'pca', 'umap'
     n_components: int = 2,  # Default for umap, but 50 for PCA
-    umap_neighbors: int = 15,  # Default
-    umap_min_dist: float = 0.1,  # Default
+    umap_neighbors: int = 15,  # UMAP-specific
+    umap_min_dist: float = 0.1,  # UMAP-specific
+    tsne_perplexity: int = 30,  # t-SNE-specific
     scale: bool = True,
     fill_missing: bool = True,
     debug: bool = False,
     inplace: bool = True,  # replace the oringinal data
+    plot_:bool = False,# plot scatterplot, but no 'hue',so it is meaningless
 ) -> pd.DataFrame:
     """
     Reduces the dimensionality of the selected DataFrame using PCA or UMAP.
@@ -5293,9 +5381,35 @@ def df_reducer(
     reduced_df : pd.DataFrame
         DataFrame with the reduced dimensions.
     """
-    from sklearn.decomposition import PCA
+    
+    """
+       PCA: explained_variance: 
+            indicates the proportion of the dataset's total variance that each principal 
+            component (PC) explains. It gives you a sense of how much information
+            (or variance) is captured by each PC
+        Interpretation:
+            - Higher values indicate that the corresponding PC captures more variance.
+            - The sum of the explained variances for all PCs equals 1 (or 100%).
+            - If the first few components explain a high percentage (e.g., 90%), 
+            it means you can reduce the dimensionality of the data significantly without losing much information.
+        Use case: 
+            You may plot a scree plot, which shows the explained variance for each PC, to help decide 
+            how many components to keep for analysis.
+
+        PCA: Singular values:
+            represent the magnitude of variance along each principal component. Mathematically, 
+            they are the square roots of the eigenvalues of the covariance matrix.
+        Interpretation:
+            Larger singular values indicate that the associated PC captures more variance.
+            Singular values are related to the scale of the data. If the data are scaled
+            before PCA (e.g., standardized), then the singular values will provide a measure
+            of the spread of data along each PC.
+        Use case: 
+            Singular values help quantify the contribution of each principal component in a
+            similar way to the explained variance. They are useful in understanding the overall 
+            structure of the data.
+    """
     from sklearn.preprocessing import StandardScaler
-    import umap
     from sklearn.impute import SimpleImputer
 
     # Select columns if specified, else use all columns
@@ -5312,76 +5426,211 @@ def df_reducer(
         X = scaler.fit_transform(X)
 
     # Check valid method input
-    if method not in ["pca", "umap"]:
-        raise ValueError(f"Invalid method '{method}'. Choose 'pca' or 'umap'.")
-
+    methods=["pca", "umap","tsne","factor","isolation_forest"]
+    method=strcmp(method, methods)[0]
     # Apply PCA if selected
-    if method == "pca":
-        if n_components is None:
-            # to get the n_components with threshold method:
-            pca = PCA()
-            pca_result = pca.fit_transform(X)
-
-            # Calculate explained variance
-            explained_variance = pca.explained_variance_ratio_
-            # Cumulative explained variance
-            cumulative_variance = np.cumsum(explained_variance)
-            # Set a threshold for cumulative variance
-            threshold = 0.95  # Example threshold
-            n_components = (
-                np.argmax(cumulative_variance >= threshold) + 1
-            )  # Number of components to retain
-            if debug:
-                # debug:
-                # Plot the cumulative explained variance
-                plt.figure(figsize=(8, 5))
-                plt.plot(
-                    range(1, len(cumulative_variance) + 1),
-                    cumulative_variance,
-                    marker="o",
-                    linestyle="-",
-                )
-                plt.title("Cumulative Explained Variance by Principal Components")
-                plt.xlabel("Number of Principal Components")
-                plt.ylabel("Cumulative Explained Variance")
-                plt.xticks(range(1, len(cumulative_variance) + 1))
-                # Add horizontal line for the threshold
-                plt.axhline(
-                    y=threshold, color="r", linestyle="--", label="Threshold (95%)"
-                )
-                # Add vertical line for n_components
-                plt.axvline(
-                    x=n_components,
-                    color="g",
-                    linestyle="--",
-                    label=f"n_components = {n_components}",
-                )
-                plt.legend()
-                plt.grid()
+    if method == "pca": 
+        from sklearn.decomposition import PCA
         pca = PCA(n_components=n_components)
         X_reduced = pca.fit_transform(X)
-        print(f"PCA completed: Reduced to {n_components} components.")
+        
+        # Additional PCA information
+        explained_variance = pca.explained_variance_ratio_
+        singular_values = pca.singular_values_
+        loadings = pca.components_.T * np.sqrt(pca.explained_variance_)
+
+        if debug:
+            print(f"PCA completed: Reduced to {n_components} components.")
+            print(f"Explained Variance: {explained_variance}")
+            print(f"Singular Values: {singular_values}")
+
+        # Plot explained variance if debug=True
+        if debug:
+            # Plot explained variance
+            cumulative_variance = np.cumsum(explained_variance)
+            plt.figure(figsize=(8, 5))
+            plt.plot(range(1, len(cumulative_variance) + 1), cumulative_variance, marker="o")
+            plt.title("Cumulative Explained Variance by Principal Components")
+            plt.xlabel("Number of Principal Components")
+            plt.ylabel("Cumulative Explained Variance")
+            plt.axhline(y=0.95, color="r", linestyle="--", label="Threshold (95%)")
+            plt.axvline(x=n_components, color="g", linestyle="--", label=f"n_components = {n_components}")
+            plt.legend()
+            plt.grid()
+            plt.show()
+
+        # Prepare reduced DataFrame with additional PCA info
+        pca_df = pd.DataFrame(
+            X_reduced, index=data.index,
+            columns=[f"PC_{i+1}" for i in range(n_components)]
+        ) 
+        # pca_df["Explained Variance"] = np.tile(explained_variance[:n_components], (pca_df.shape[0], 1))
+        # pca_df["Singular Values"] = np.tile(singular_values[:n_components], (pca_df.shape[0], 1))
+        # Expand explained variance to multiple columns if needed
+        for i in range(n_components):
+            pca_df[f"Explained Variance PC_{i+1}"] = np.tile(format(explained_variance[i]*100,".3f")+"%", (pca_df.shape[0], 1))
+        for i in range(n_components):
+            pca_df[f"Singular Values PC_{i+1}"] = np.tile(singular_values[i], (pca_df.shape[0], 1))
 
     # Apply UMAP if selected
     elif method == "umap":
+        import umap
         umap_reducer = umap.UMAP(
             n_neighbors=umap_neighbors,
             min_dist=umap_min_dist,
-            n_components=n_components,
+            n_components=n_components
         )
         X_reduced = umap_reducer.fit_transform(X)
-        print(f"UMAP completed: Reduced to {n_components} components.")
 
-    # Return reduced data as a new DataFrame with the same index
-    reduced_df = pd.DataFrame(X_reduced, index=data.index)
+        # Additional UMAP information
+        embedding = umap_reducer.embedding_
+        trustworthiness = umap_reducer._raw_data[:, :n_components]
+
+        if debug:
+            print(f"UMAP completed: Reduced to {n_components} components.")
+            print(f"Embedding Shape: {embedding.shape}")
+            print(f"Trustworthiness: {trustworthiness}")
+
+        # Prepare reduced DataFrame with additional UMAP info
+        umap_df = pd.DataFrame(
+            X_reduced, index=data.index,
+            columns=[f"UMAP_{i+1}" for i in range(n_components)]
+        )
+        umap_df["Embedding"] = embedding[:, 0]  # Example of embedding data
+        umap_df["Trustworthiness"] = trustworthiness[:, 0]  # Trustworthiness metric
+    elif method == "tsne":
+        from sklearn.manifold import TSNE
+        tsne = TSNE(n_components=n_components, perplexity=tsne_perplexity, random_state=1)
+        X_reduced = tsne.fit_transform(X)
+
+        # Prepare reduced DataFrame with additional t-SNE info
+        tsne_df = pd.DataFrame(
+            X_reduced, index=data.index,
+            columns=[f"tSNE_{i+1}" for i in range(n_components)]
+        )
+        tsne_df["Perplexity"] = np.tile(f"Perplexity: {tsne_perplexity}", (tsne_df.shape[0], 1))
+
+    # Apply Factor Analysis if selected
+    elif method == "factor":
+        from sklearn.decomposition import FactorAnalysis
+        factor = FactorAnalysis(n_components=n_components, random_state=1)
+        X_reduced = factor.fit_transform(X)
+        # Factor Analysis does not directly provide explained variance, but we can approximate it
+        fa_variance = factor.noise_variance_
+        # Prepare reduced DataFrame with additional Factor Analysis info
+        factor_df = pd.DataFrame(
+            X_reduced, index=data.index,
+            columns=[f"Factor_{i+1}" for i in range(n_components)]
+        )
+        factor_df["Noise Variance"] = np.tile(format(np.mean(fa_variance) * 100, ".3f") + "%", (factor_df.shape[0], 1))
+
+    # Apply Isolation Forest for outlier detection if selected
+    elif method == "isolation_forest":
+        from sklearn.decomposition import PCA
+        from sklearn.ensemble import IsolationForest
+        # Step 1: Apply PCA for dimensionality reduction to 2 components
+        pca = PCA(n_components=n_components)
+        X_pca = pca.fit_transform(X)
+
+        explained_variance = pca.explained_variance_ratio_
+        singular_values = pca.singular_values_
+
+        # Prepare reduced DataFrame with additional PCA info
+        iso_forest_df = pd.DataFrame(
+            X_pca, index=data.index,
+            columns=[f"PC_{i+1}" for i in range(n_components)]
+        )
+
+        isolation_forest = IsolationForest(n_estimators=100, contamination='auto',random_state=1)
+        isolation_forest.fit(X)
+        anomaly_scores = isolation_forest.decision_function(X)  # Anomaly score: larger is less anomalous
+        # Predict labels: 1 (normal), -1 (anomaly)
+        anomaly_labels = isolation_forest.fit_predict(X) 
+        # Add anomaly scores and labels to the DataFrame
+        iso_forest_df["Anomaly Score"] = anomaly_scores
+        iso_forest_df["Anomaly Label"] = anomaly_labels
+        # add info from pca
+        for i in range(n_components):
+            iso_forest_df[f"Explained Variance PC_{i+1}"] = np.tile(format(explained_variance[i]*100,".3f")+"%", (iso_forest_df.shape[0], 1))
+        for i in range(n_components):
+            iso_forest_df[f"Singular Values PC_{i+1}"] = np.tile(singular_values[i], (iso_forest_df.shape[0], 1))
+
+    # Return reduced data and info as a new DataFrame with the same index
+    if method == "pca":
+        reduced_df = pca_df
+        colname_met = "PC_"
+        if plot_:
+            sns.scatterplot(
+                data=pca_df,
+                x="PC_1",
+                y="PC_2",
+                # hue="condition",
+            )
+    elif method == "umap":
+        reduced_df = umap_df
+        colname_met = "UMAP_"
+        if plot_:
+            sns.scatterplot(
+                data=umap_df,
+                x="UMAP_1",
+                y="UMAP_2",
+                # hue="condition",
+            )
+    elif method == "tsne":
+        reduced_df = tsne_df
+        colname_met = "t-SNE_"
+        if plot_:
+            sns.scatterplot(
+                data=tsne_df,
+                x="tSNE_1",
+                y="tSNE_2",
+                # hue="batch",
+            )
+    elif method == "factor":
+        reduced_df = factor_df
+        colname_met = "Factor_"
+        if plot_:
+            sns.scatterplot(
+                data=factor_df,
+                x="Factor_1",
+                y="Factor_2",
+                # hue="batch",
+            )
+    elif method == "isolation_forest":
+        reduced_df = iso_forest_df  # Already a DataFrame for outliers
+        colname_met = "PC_"
+        if plot_:
+            ax = sns.scatterplot(
+                data=iso_forest_df[iso_forest_df["Anomaly Label"] == 1],
+                x="PC_1",
+                y="PC_2",
+                label="normal", c="b",
+            )
+            ax = sns.scatterplot(
+                ax=ax,
+                data=iso_forest_df[iso_forest_df["Anomaly Label"] == -1],
+                x="PC_1",
+                y="PC_2",
+                c="r",
+                label="outlier", marker="+", s=30,
+            )
+
 
     if inplace:
-        # Replace or add new columns based on n_components
+        # If inplace=True, add components back into the original data
         for col_idx in range(n_components):
-            data[f"Component_{col_idx+1}"] = reduced_df.iloc[:, col_idx]
+            data[f"{colname_met}{col_idx+1}"] = reduced_df.iloc[:, col_idx]
+        
+        # Add extra info for PCA/UMAP
+        if method == "pca":
+            data["Explained Variance"] = reduced_df["Explained Variance"]
+            data["Singular Values"] = reduced_df["Singular Values"]
+        elif method == "umap":
+            data["Embedding"] = reduced_df["Embedding"]
+            data["Trustworthiness"] = reduced_df["Trustworthiness"]
         return None  # No return when inplace=True
 
-    return reduced_df
+    return reduced_df 
 
 
 # example:
@@ -5636,7 +5885,7 @@ def evaluate_cluster(
     return metrics
 
 
-def print_pd_usage(
+def use_pd(
     func_name="excel",
     verbose=True,
     dir_json="/Users/macjianfeng/Dropbox/github/python/py2ls/py2ls/data/usages_pd.json",

py2ls/plot.py

@@ -16,7 +16,9 @@ from .stats import *
 from .netfinder import get_soup, fetch
 
 # Suppress INFO messages from fontTools
-logging.getLogger("fontTools").setLevel(logging.WARNING)
+logging.getLogger("fontTools").setLevel(logging.ERROR)
+logging.getLogger('matplotlib').setLevel(logging.ERROR)
+
 
 
 def add_text(ax=None, height_offset=0.5, fmt=".1f", **kwargs):
@@ -3149,7 +3151,7 @@ def volcano(
     x:str,
     y:str,
     gene_col=None,
-    top_genes=5,
+    top_genes=[5, 5], # [down-regulated, up-regulated]
     thr_x=np.log2(1.5),
     thr_y=-np.log10(0.05),
     colors=("#00BFFF", "#9d9a9a", "#FF3030"),
@@ -3163,7 +3165,11 @@ def volcano(
     ax=None,
     verbose=False,
     kws_text=dict(fontsize=10, color="k"),
-    kws_arrow=dict(style="-", color="k", lw=0.5),
+    kws_bbox=dict(facecolor='none', 
+                  alpha=0.5, 
+                  edgecolor='black',
+                  boxstyle='round,pad=0.3'),# '{}' to hide
+    kws_arrow={},
     **kwargs,
 ):
     """
@@ -3179,7 +3185,7 @@ def volcano(
         Column name for y-axis values (e.g., -log10(FDR)).
     gene_col : str, optional
         Column name for gene names. If provided, gene names will be displayed. Default is None.
-    top_genes : int, optional
+    top_genes : int, list, optional
         Number of top genes to label based on y-axis values. Default is 5.
     thr_x : float, optional
         Threshold for x-axis values. Default is 0.585.
@@ -3239,14 +3245,22 @@ def volcano(
         colors[2],
         np.where((data[x] < -thr_x) & (data[y] > thr_y), colors[0], colors[1]),
     )
+    top_genes=[top_genes, top_genes] if isinstance(top_genes,int) else top_genes
+
+    down_reg_genes = data[
+        (data["color"] == colors[0]) & 
+        (data[x].abs() > thr_x) & 
+        (data[y] > thr_y)
+    ].sort_values(by=[y, x], ascending=[False, True]).head(top_genes[0])
+
+    # Selecting top upregulated genes based on both p-value and fold change
+    up_reg_genes = data[
+        (data["color"] == colors[2]) & 
+        (data[x].abs() > thr_x) & 
+        (data[y] > thr_y)
+    ].sort_values(by=[y, x], ascending=[False, False]).head(top_genes[1])
+    sele_gene = pd.concat([down_reg_genes, up_reg_genes])
 
-    # Selecting top significant points for labeling
-    sele_gene = (
-        data.query("color != @colors[2]")  # Exclude gray points
-        .groupby("color", axis=0)
-        .apply(lambda x: x.sort_values(y, ascending=False).head(top_genes))
-        .droplevel(level=0)
-    )
     palette = {colors[0]: colors[0], colors[1]: colors[1], colors[2]: colors[2]}
     # Plot setup
     if ax is None:
@@ -3277,9 +3291,9 @@ def volcano(
     )
 
     # Add threshold lines for x and y axes
-    plt.axhline(y=thr_y, color="black", linestyle="--")
-    plt.axvline(x=-thr_x, color="black", linestyle="--")
-    plt.axvline(x=thr_x, color="black", linestyle="--")
+    ax.axhline(y=thr_y, color="black", linestyle="--",lw=1)
+    ax.axvline(x=-thr_x, color="black", linestyle="--",lw=1)
+    ax.axvline(x=thr_x, color="black", linestyle="--",lw=1)
 
     # Add gene labels for selected significant points
     if gene_col:
@@ -3288,14 +3302,29 @@ def volcano(
             fontname = kws_text.pop("fontname", "Arial")
             textcolor = kws_text.pop("color", "k")
             fontsize = kws_text.pop("fontsize", 10)
+            arrowstyles = [
+                "->","<-","<->","<|-","-|>","<|-|>",
+                "-","-[","-[",
+                "fancy","simple","wedge",
+            ]
+            arrowstyle = kws_arrow.pop("style", "<|-")
+            arrowstyle = strcmp(arrowstyle, arrowstyles,scorer='strict')[0]
+            expand=kws_arrow.pop("expand",(1.05,1.1))
+            arrowcolor = kws_arrow.pop("color", "0.4")
+            arrowlinewidth = kws_arrow.pop("lw", 0.75)
+            shrinkA = kws_arrow.pop("shrinkA", 0)
+            shrinkB = kws_arrow.pop("shrinkB", 0)
+            mutation_scale = kws_arrow.pop("head", 10)
+            arrow_fill=kws_arrow.pop("fill", False)
             for i in range(sele_gene.shape[0]):
                 if isinstance(textcolor, list):  # be consistant with dots's color
                     textcolor = colors[0] if sele_gene[x].iloc[i] > 0 else colors[1]
                 texts.append(
-                    plt.text(
+                    ax.text(
                         x=sele_gene[x].iloc[i],
                         y=sele_gene[y].iloc[i],
                         s=sele_gene[gene_col].iloc[i],
+                        bbox=kws_bbox if kws_bbox else None,
                         fontdict={
                             "fontsize": fontsize,
                             "color": textcolor,
@@ -3303,40 +3332,31 @@ def volcano(
                         },
                     )
                 )
-
-                arrowstyles = [
-                    "-",
-                    "->",
-                    "-[",
-                    "|->",
-                    "<-",
-                    "<->",
-                    "<|-",
-                    "<|-|>",
-                    "-|>",
-                    "-[ ",
-                    "fancy",
-                    "simple",
-                    "wedge",
-                ]
-                arrowstyle = kws_arrow.pop("style", "-")
-                arrowcolor = kws_arrow.pop("color", "0.5")
-                arrowlinewidth = kws_arrow.pop("lw", 0.5)
-                shrinkA = kws_arrow.pop("shrinkA", 5)
-                shrinkB = kws_arrow.pop("shrinkB", 5)
-                arrowstyle = strcmp(arrowstyle, arrowstyles)[0]
-                adjust_text(
-                    texts,
-                    expand_text=(1.05, 1.2),
-                    arrowprops=dict(
-                        arrowstyle=arrowstyle,
-                        color=arrowcolor,
-                        lw=arrowlinewidth,
-                        shrinkA=shrinkA,
-                        shrinkB=shrinkB,
-                        **kws_arrow,
-                    ),
+            print(arrowstyle)
+            adjust_text(
+                texts,
+                expand=expand,
+                min_arrow_len=5,
+                # force_explode=(0.1, 0.5), 
+                # force_text=(0.1, 0.5), 
+                # force_points=(0.1, 0.5),
+                # explode_radius=10,
+                # expand_text=(1, 1), 
+                # expand_points=(1, 1),
+                # ha='center', 
+                # va='top',
+                ax=ax,
+                arrowprops=dict(
+                    arrowstyle=arrowstyle,
+                    fill=arrow_fill,
+                    color=arrowcolor,
+                    lw=arrowlinewidth,
+                    shrinkA=shrinkA,
+                    shrinkB=shrinkB,
+                    mutation_scale=mutation_scale,
+                    **kws_arrow,
                 )
+            )
 
     figsets(**kws_figsets)
 

{py2ls-0.2.4.2.dist-info → py2ls-0.2.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: py2ls
-Version: 0.2.4.2
+Version: 0.2.4.3
 Summary: py(thon)2(too)ls
 Author: Jianfeng
 Author-email: Jianfeng.Liu0413@gmail.com

{py2ls-0.2.4.2.dist-info → py2ls-0.2.4.3.dist-info}/RECORD

@@ -173,7 +173,7 @@ py2ls/LICENSE,sha256=UOZ1F5fFDe3XXvG4oNnkL1-Ecun7zpHzRxjp-XsMeAo,11324
 py2ls/README.md,sha256=CwvJWAnSXnCnrVHlnEbrxxi6MbjbE_MT6DH2D53S818,11572
 py2ls/__init__.py,sha256=Nn8jTIvySX7t7DMJ8VNRVctTStgXGjHldOIdZ35PdW8,165
 py2ls/batman.py,sha256=E7gYofbDzN7S5oCmO_dd5Z1bxxhoYMJSD6s-VaF388E,11398
-py2ls/bio.py,sha256=5q7T_LXmDg0MJoKXwO0kWnfbpshXNvUR5kCnYyLqm2w,10711
+py2ls/bio.py,sha256=FnEf4RV4LBUQfLefWIpIFszVRYeXjnRlc5261DINIdg,18835
 py2ls/brain_atlas.py,sha256=w1o5EelRjq89zuFJUNSz4Da8HnTCwAwDAZ4NU4a-bAY,5486
 py2ls/chat.py,sha256=Yr22GoIvoWhpV3m4fdwV_I0Mn77La346_ymSinR-ORA,3793
 py2ls/correlators.py,sha256=RbOaJIPLCHJtUm5SFi_4dCJ7VFUPWR0PErfK3K26ad4,18243
@@ -213,15 +213,15 @@ py2ls/export_requirements.py,sha256=x2WgUF0jYKz9GfA1MVKN-MdsM-oQ8yUeC6Ua8oCymio,
 py2ls/fetch_update.py,sha256=9LXj661GpCEFII2wx_99aINYctDiHni6DOruDs_fdt8,4752
 py2ls/freqanalysis.py,sha256=F4218VSPbgL5tnngh6xNCYuNnfR-F_QjECUUxrPYZss,32594
 py2ls/ich2ls.py,sha256=3E9R8oVpyYZXH5PiIQgT3CN5NxLe4Dwtm2LwaeacE6I,21381
-py2ls/ips.py,sha256=46nrt6RRl8Lc-tMh03dRqxF4nUlLfMElnETE1ipu-DM,210309
+py2ls/ips.py,sha256=yYSpbHIGDfLK2SXtTX4f--H5oa885pggXePEbhiNRsw,220887
 py2ls/netfinder.py,sha256=LwBkGITB_4BTNtY6RlKdEZVFW6epzMWlnqy2g03KtyU,56117
 py2ls/ocr.py,sha256=5lhUbJufIKRSOL6wAWVLEo8TqMYSjoI_Q-IO-_4u3DE,31419
-py2ls/plot.py,sha256=A4NiRDItVyrc80qPtLgT1mpzvebU_iMVVownjsu_YFc,135976
+py2ls/plot.py,sha256=B_npRfO2rZJJjcYSQ7YMZt2LZTG0mU08JCDnM6zAVx4,136956
 py2ls/setuptools-70.1.0-py3-none-any.whl,sha256=2bi3cUVal8ip86s0SOvgspteEF8SKLukECi-EWmFomc,882588
 py2ls/sleep_events_detectors.py,sha256=bQA3HJqv5qnYKJJEIhCyhlDtkXQfIzqksnD0YRXso68,52145
 py2ls/stats.py,sha256=DMoJd8Z5YV9T1wB-4P52F5K5scfVK55DT8UP4Twcebo,38627
 py2ls/translator.py,sha256=zBeq4pYZeroqw3DT-5g7uHfVqKd-EQptT6LJ-Adi8JY,34244
 py2ls/wb_detector.py,sha256=7y6TmBUj9exCZeIgBAJ_9hwuhkDh1x_-yg4dvNY1_GQ,6284
-py2ls-0.2.4.2.dist-info/METADATA,sha256=_YQg86nAdjPWqkaIrH6p9nSPhjNHbY1AU0BGV6o3wU0,20038
-py2ls-0.2.4.2.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-py2ls-0.2.4.2.dist-info/RECORD,,
+py2ls-0.2.4.3.dist-info/METADATA,sha256=S4Il5phQ0Vx8U7VrlEUopkX-hfwcKKQi-qkfD2EYI1g,20038
+py2ls-0.2.4.3.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+py2ls-0.2.4.3.dist-info/RECORD,,