pymaftools 0.1__tar.gz

pymaftools-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 xu62u4u6
+
+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.

pymaftools-0.1/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: pymaftools
+Version: 0.1
+Summary: pymaftools is a Python package for handling and analyzing Mutation Annotation Format (MAF) files. It provides utilities for data manipulation and visualization, including classes for MAF parsing and oncoplot generation.
+Home-page: https://github.com/xu62u4u6/pymaftools
+Author: xu62u4u6
+Author-email: 199928ltyos@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# pymaftools
+
+`pymaftools` is a Python package designed to handle and analyze MAF (Mutation Annotation Format) files. It provides utilities for working with mutation data, including the `MAF` and `PivotTable` classes for data manipulation, and functions for visualizing mutation data with oncoplots.
+
+## Features
+
+- **MAF Class**: A utility to load, parse, and manipulate MAF files.
+- **PivotTable Class**: A custom pivot table implementation for summarizing mutation frequencies and sorting genes and samples.
+- **Oncoplot Visualization**: Generate oncoplot visualizations with mutation data and frequencies.
+
+## Installation
+
+### Using pip (from PyPI)
+You can install the `pymaftools` package directly from PyPI using pip:
+
+```bash
+pip install pymaftools
+```
+
+### Using GitHub (for the latest version)
+To install directly from GitHub (if you want the latest changes):
+
+```bash
+pip install git+https://github.com/xu62u4u6/pymaftools.git
+```
+
+
+## Usage
+
+### Importing the Package
+
+```python
+from pymaftools.maf_utils import MAF, PivotTable
+from pymaftools.maf_plots import create_oncoplot
+```
+
+### Example
+
+```python
+# Load the MAF file
+all_case_maf = MAF.read_maf("path_to_maf_file.maf")
+
+# Filter to keep only nonsynonymous mutations
+filtered_all_case_maf = all_case_maf.filter_maf(MAF.nonsynonymous_types)
+
+# Convert to pivot table (genes x samples table, mutation classification as values)
+pivot_table = filtered_all_case_maf.to_pivot_table()
+
+# Calculate mutation frequencies
+pivot_table = pivot_table.add_freq()
+
+# Sort the pivot table (by gene frequency and sample mutation count)
+sorted_pivot_table = (pivot_table
+                       .sort_genes_by_freq()  
+                       .sort_samples_by_mutations()
+                    )
+
+# Generate an oncoplot to show the top 50 genes with the highest mutation frequencies
+create_oncoplot(sorted_pivot_table.top(50), 
+                figsize=(26, 15),
+                ax_main_range=(0, 28), 
+                ax_freq_range=(28, 29), 
+                ax_legend_range=(29, 31),
+                mutation_counts=True)
+
+```
+
+### Requirements
+Python 3.x
+pandas, numpy, matplotlib, seaborn
+### License
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+### Author
+xu62u4u6
+

pymaftools-0.1/README.md

@@ -0,0 +1,77 @@
+
+# pymaftools
+
+`pymaftools` is a Python package designed to handle and analyze MAF (Mutation Annotation Format) files. It provides utilities for working with mutation data, including the `MAF` and `PivotTable` classes for data manipulation, and functions for visualizing mutation data with oncoplots.
+
+## Features
+
+- **MAF Class**: A utility to load, parse, and manipulate MAF files.
+- **PivotTable Class**: A custom pivot table implementation for summarizing mutation frequencies and sorting genes and samples.
+- **Oncoplot Visualization**: Generate oncoplot visualizations with mutation data and frequencies.
+
+## Installation
+
+### Using pip (from PyPI)
+You can install the `pymaftools` package directly from PyPI using pip:
+
+```bash
+pip install pymaftools
+```
+
+### Using GitHub (for the latest version)
+To install directly from GitHub (if you want the latest changes):
+
+```bash
+pip install git+https://github.com/xu62u4u6/pymaftools.git
+```
+
+
+## Usage
+
+### Importing the Package
+
+```python
+from pymaftools.maf_utils import MAF, PivotTable
+from pymaftools.maf_plots import create_oncoplot
+```
+
+### Example
+
+```python
+# Load the MAF file
+all_case_maf = MAF.read_maf("path_to_maf_file.maf")
+
+# Filter to keep only nonsynonymous mutations
+filtered_all_case_maf = all_case_maf.filter_maf(MAF.nonsynonymous_types)
+
+# Convert to pivot table (genes x samples table, mutation classification as values)
+pivot_table = filtered_all_case_maf.to_pivot_table()
+
+# Calculate mutation frequencies
+pivot_table = pivot_table.add_freq()
+
+# Sort the pivot table (by gene frequency and sample mutation count)
+sorted_pivot_table = (pivot_table
+                       .sort_genes_by_freq()  
+                       .sort_samples_by_mutations()
+                    )
+
+# Generate an oncoplot to show the top 50 genes with the highest mutation frequencies
+create_oncoplot(sorted_pivot_table.top(50), 
+                figsize=(26, 15),
+                ax_main_range=(0, 28), 
+                ax_freq_range=(28, 29), 
+                ax_legend_range=(29, 31),
+                mutation_counts=True)
+
+```
+
+### Requirements
+Python 3.x
+pandas, numpy, matplotlib, seaborn
+### License
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+### Author
+xu62u4u6
+

pymaftools-0.1/pymaftools/__init__.py

@@ -0,0 +1,3 @@
+# pyMAF/__init__.py
+from .maf_utils import MAF, PivotTable
+from .maf_plots import create_oncoplot, plot_bar, plot_heatmap, plot_freq, plot_legend

pymaftools-0.1/pymaftools/maf_plots.py

@@ -0,0 +1,180 @@
+import pandas as pd
+import numpy as np
+import os 
+import matplotlib.pyplot as plt
+import seaborn as sns
+import matplotlib.colors as mcolors
+from matplotlib.patches import Rectangle
+from typing import Union
+
+target_col = [
+        "Hugo_Symbol",
+        "Start_Position",
+        "End_Position",
+        "Reference_Allele",
+        "Tumor_Seq_Allele1",
+        "Tumor_Seq_Allele2"
+    ]
+
+
+def create_oncoplot(pivot_table, 
+                    color_map=None, 
+                    mutation_counts : Union[bool, pd.Series]=True, 
+                    figsize=(18, 16),
+                    wspace=0.5, 
+                    hspace=0.01, 
+                    freq_columns=["freq"], 
+                    ax_main_range=(0, 24), 
+                    ax_freq_range=(24, 28), 
+                    ax_legend_range=(29, 31),
+                    square=False,
+                    show_frame=False,
+                    bar_annot_fontsize=7):
+    
+    # freq_columns = freq_columns or [f"{sample_type}_freq" for sample_type in ["A", "T", "S"]] + ['all_freq']
+    heatmap_data = pivot_table#sorted_df.drop(columns=freq_columns)
+    freq_data = pivot_table.gene_metadata[freq_columns].values
+    
+    # 預設的顏色映射
+    color_map = color_map or {
+        'False': '#FFFFFF',          # 白色 (無突變)
+        'Missense_Mutation': 'gray',  # 淺灰色
+        'Frame_Shift_Ins':'#FF4500',       # 較深色紅  
+        'Frame_Shift_Del': '#4682B4',       # 較深色藍
+        'In_Frame_Ins': '#FF707A',    # 淺色紅
+        'In_Frame_Del':'#ADD8E6',    # 淺色藍
+        'Nonsense_Mutation': '#90EE90',  # 低飽和度綠色
+        'Splice_Site': '#CB704D',        # 低飽和度咖啡色
+        'Multi_Hit': '#000000',           # 黑色 (多重突變)
+        "Silent": "#eeeeee",
+        "3'UTR": "#bbbbcc",
+        "5'UTR": "#bbbbcc",
+        "IGR": "#bbbbcc",
+        "Intron": "#bbbbcc",
+        "RNA": "#bbbbcc",
+    }
+
+    fig = plt.figure(figsize=figsize)
+    gs = plt.GridSpec(2, 32, height_ratios=[1, 12], wspace=wspace, hspace=hspace)
+    
+    if mutation_counts is not None:
+        if mutation_counts == True:
+            mutation_counts = pivot_table.sample_metadata.mutations_count.values
+        ax_bar = fig.add_subplot(gs[0, ax_main_range[0]:ax_main_range[1]])     # Bar chart
+        plot_bar(ax_bar, mutation_counts, fontsize=bar_annot_fontsize)
+    else:
+        ax_bar = None  # 如果沒有 bar chart, 不繪製上方區域
+    
+    ax_main = fig.add_subplot(gs[1, ax_main_range[0]:ax_main_range[1]])    # Main heatmap
+    ax_freq = fig.add_subplot(gs[1, ax_freq_range[0]:ax_freq_range[1]])   # Frequency heatmap
+    ax_legend = fig.add_subplot(gs[1, ax_legend_range[0]:ax_legend_range[1]]) # Legend
+
+    plot_heatmap(ax_main, heatmap_data, color_map, square=square, show_frame=show_frame)
+    plot_freq(ax_freq, freq_data, freq_columns, square=square)
+    plot_legend(ax_legend, color_map)
+
+    ax_main.set_xlabel("Mutations")
+    #if mutation_counts is None:
+        #gs.tight_layout(fig, rect=[0, 0, 1, 0.9])  # 調整繪圖佈局，避免空白區域過多
+    #else:
+        #plt.tight_layout()
+
+    
+def plot_bar(ax_bar, mutation_counts, fontsize=6):    
+
+    x = np.arange(len(mutation_counts))
+    width = 0.95
+
+    # Create bars
+    tmbs = np.where(mutation_counts == 0, 0, mutation_counts/40)
+    ax_bar.bar(x, tmbs, width=width, color='gray', edgecolor='white')
+    
+    # Set x-axis limits to exactly match the heatmap
+    # The -0.5 ensures the bars align perfectly with heatmap cells
+    ax_bar.set_xlim(-0.5, len(mutation_counts) - 0.5)
+    
+    # 在柱子上添加數值標籤
+    for i, tmb in enumerate(tmbs):
+        ax_bar.text(i, tmb + 2, f"{tmb:.1f}", ha='center', fontsize=fontsize)
+
+    # 隐藏柱状图的边框和刻度
+    ax_bar.spines['top'].set_visible(False)
+    ax_bar.spines['right'].set_visible(False)
+    ax_bar.spines['left'].set_visible(True)
+    ax_bar.spines['bottom'].set_visible(False)
+    ax_bar.set_xticks([])
+    ax_bar.set_xlabel('TMB')
+
+
+def plot_heatmap(ax_main, heatmap_data, color_map, linecolor="white", square=True, show_frame=False):
+
+    # 創建數值映射
+    def color_encode(val):
+        return color_map.get(val, '#FFFFFF')
+
+    # 轉換數據
+    data_matrix = heatmap_data.map(color_encode)
+
+    # 創建熱圖
+    sns.heatmap(
+        heatmap_data.notna(),
+        cmap=['white', 'grey'],  # 使用白色和灰色表示數據存在與否
+        cbar=False,
+        linewidths=1,
+        linecolor=linecolor,
+        ax=ax_main,
+        square=square
+    )
+    ax_main.set_yticklabels(ax_main.get_yticklabels(), rotation=0)
+
+    # 添加顏色
+    for i in range(data_matrix.shape[0]):
+        for j in range(data_matrix.shape[1]):
+            ax_main.add_patch(plt.Rectangle(
+                (j, i), 1, 1,
+                fill=True,
+                facecolor=data_matrix.iloc[i, j],
+                edgecolor=linecolor,
+                lw=1
+            ))
+
+     # 添加每三個樣本的淺色框
+    if show_frame:
+        for i in range(0, heatmap_data.shape[1], 3):  # 每三個樣本
+            rect = Rectangle((i, -0.5), 3, heatmap_data.shape[0] + 1,
+                            linewidth=1, edgecolor='lightgray', facecolor='none')
+            ax_main.add_patch(rect)
+
+def plot_freq(ax_freq, freq_data, freq_columns, square=True, show_frame=True):
+    # 繪製頻率熱圖
+    sns.heatmap(freq_data,
+                cmap='Blues',
+                linewidths=0.5,
+                ax=ax_freq,
+                cbar=False,  # 不顯示頻率熱圖的colorbar
+                vmin=0,
+                vmax=freq_data.max(),
+                alpha=0.8,
+                square=square)  # 根據頻率數據的最大值設置vmax
+
+    # 隱藏頻率熱圖的索引
+    ax_freq.set_xticks([])  # 隱藏 x 軸的標籤
+    ax_freq.set_yticks([])  # 隱藏 y 軸的標籤
+
+    # 設置頻率熱圖的標籤和數值，並隱藏索引
+    for i in range(freq_data.shape[0]):  # 每行
+        for j in range(freq_data.shape[1]):  # 每列
+            value = freq_data[i, j]
+            color = 'black' if value < 0.6 * freq_data.max() else 'white'  # 高频率用白色，低频率用黑色
+            ax_freq.text(j + 0.5, i + 0.5, f"{value:.2f}",
+                         va='center', ha='center', color=color)
+            
+    ax_freq.set_title('Frequency', pad=20)  # 頻率熱圖的標題
+    ax_freq.set_xticks(np.arange(len(freq_columns))+0.5)  # 設置 x 軸刻度數量
+    ax_freq.set_xticklabels(freq_columns, rotation=90)  # 設置 x 軸標籤並旋轉90度
+
+def plot_legend(ax_legend, color_map):
+    # 修正圖例
+    legend_elements = [Rectangle((0, 0), 1, 1, color=color_map[key], label=key) for key in color_map.keys()]
+    ax_legend.legend(handles=legend_elements, title="Variant Types", loc='center', fontsize='small', frameon=False)
+    ax_legend.axis('off')  # 隱藏圖例軸的坐標系

pymaftools-0.1/pymaftools/maf_utils.py

@@ -0,0 +1,158 @@
+import pandas as pd
+
+class PivotTable(pd.DataFrame):
+    # columns: gene or mutation, row: sample or case
+    _metadata = ["gene_metadata", "sample_metadata"]
+    def __init__(self, data, mutations_count: pd.Series=None, *args, **kwargs):
+        super().__init__(data, *args, **kwargs)
+        self.gene_metadata = pd.DataFrame(index=self.index)
+        self.sample_metadata = pd.DataFrame(index=self.columns)
+        
+    @property
+    def _constructor(self):
+        return PivotTable
+    
+    @staticmethod
+    def calculate_frequency(df: pd.DataFrame) -> pd.Series:
+        return (df != False).sum(axis=1) / df.shape[1]
+    
+    def add_freq(self, groups: dict={}) -> "PivotTable":
+        """
+        example:
+        groups: {"S": pd.dataframe, 
+                 "A": pd.dataframe....} 
+        groupname: subset of pivot table
+        """
+        pivot_table = self.copy()
+        freq_data = pd.DataFrame()
+        for group in groups.keys():
+            freq_data[f"{group}_freq"] = PivotTable.calculate_frequency(groups[group])
+        freq_data["freq"] = PivotTable.calculate_frequency(pivot_table)
+        pivot_table.gene_metadata[freq_data.columns] = freq_data
+        return pivot_table
+    
+    def sort_genes_by_freq(self, by="freq", ascending=False):
+        pivot_table = self.copy()
+        sorted_index = pivot_table.gene_metadata.sort_values(by=by, ascending=ascending).index
+        
+        # sort pivot table
+        pivot_table = pivot_table.loc[sorted_index]
+
+        # also sort gene_metadata
+        pivot_table.gene_metadata = pivot_table.gene_metadata.loc[sorted_index]
+        return pivot_table
+
+    def sort_samples_by_mutations(self, top: int = 10):
+        def binary_sort_key(column: pd.Series) -> int: 
+            # binary column to int  
+            binary_str = "".join(column.astype(int).astype(str))
+            return int(binary_str, 2)
+        
+        # tmp_pivot_table = pivot_table.drop(columns=freq_columns)
+        pivot_table = self.copy()
+        binary_pivot_table = pivot_table != False
+        mutations_weight = binary_pivot_table.head(top).apply(binary_sort_key, axis=0)
+        pivot_table.sample_metadata["mutations_weight"] = mutations_weight
+        sorted_samples = (mutations_weight
+                    .sort_values(ascending=False)  
+                    .index)                        
+        
+        # sort by order
+        pivot_table = pivot_table.loc[:, sorted_samples]
+        pivot_table.sample_metadata = pivot_table.sample_metadata.loc[sorted_samples, :]
+        return pivot_table
+    
+    def top(self, n_top = 50):
+        pivot_table = self.copy()
+        pivot_table = pivot_table.head(n_top)
+        pivot_table.gene_metadata = pivot_table.gene_metadata.head(n_top)
+        return pivot_table
+
+class MAF(pd.DataFrame):
+    index_col = [
+        "Hugo_Symbol",
+        "Start_Position",
+        "End_Position",
+        "Reference_Allele",
+        "Tumor_Seq_Allele1",
+        "Tumor_Seq_Allele2"
+    ]
+
+    # GDC MAF file fields:
+    # https://docs.gdc.cancer.gov/Encyclopedia/pages/Mutation_Annotation_Format_TCGAv2/
+        
+    vaild_variant_classfication = [
+            "Frame_Shift_Del", 
+            "Frame_Shift_Ins",
+            "In_Frame_Del", 
+            "In_Frame_Ins",
+            "Missense_Mutation",
+            "Nonsense_Mutation",
+            "Silent",
+            "Splice_Site",
+            "Translation_Start_Site",
+            "Nonstop_Mutation",
+            "3'UTR",
+            "3'Flank",
+            "5'UTR",
+            "5'Flank",
+            "IGR",
+            "Intron",
+            "RNA",
+            "Targeted_Region"
+        ]
+    
+    nonsynonymous_types = [
+        "Frame_Shift_Del", "Frame_Shift_Ins", "In_Frame_Del", "In_Frame_Ins",
+        "Missense_Mutation", "Nonsense_Mutation", "Splice_Site",
+        "Translation_Start_Site", "Nonstop_Mutation"
+    ]
+    
+    @classmethod
+    def read_maf(cls, maf_path, case_ID, preffix="", suffix=""):
+        maf = cls(pd.read_csv(maf_path, skiprows=1, sep="\t"))
+        maf["case_ID"] = f"{preffix}{case_ID}{suffix}"
+        maf.index = maf.loc[:, cls.target_col].apply(lambda row: "|".join(row.astype(str)), axis=1) # concat column
+        maf = maf.filter_maf(cls.vaild_variant_classfication)
+        return cls(maf)
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        
+    @property
+    def _constructor(self):
+        # make sure returned object is MAF type
+        return MAF
+    
+    def filter_maf(self, mutation_types):
+        return self[self.Variant_Classification.isin(mutation_types)]
+    
+    # def calculate_frequency(self) -> pd.Series:
+    #     return (self != False).sum(axis=1) / self.shape[1]
+
+    @staticmethod
+    def merge_mutations(column):
+        if (column == False).all() :
+            return False
+        # Get unique non-False mutation types
+        unique_mutations = column[column != False].unique()
+        if len(unique_mutations) > 1:
+            return "Multi_Hit"
+        elif len(unique_mutations) == 1:
+            return unique_mutations[0]
+        
+    def to_pivot_table(self) -> PivotTable: 
+        pivot_table =  self.pivot_table(
+                            values="Variant_Classification",
+                            index="Hugo_Symbol",
+                            columns="case_ID",
+                            aggfunc=MAF.merge_mutations
+                            ).fillna(False)
+        pivot_table = PivotTable(pivot_table)
+        pivot_table.sample_metadata["mutations_count"] = self.mutations_count
+        pivot_table.sample_metadata["TMB"] = self.mutations_count / 40
+        return pivot_table
+    
+    @property
+    def mutations_count(self) -> pd.Series: 
+        return self.groupby(self.case_ID).size()

pymaftools-0.1/pymaftools.egg-info/PKG-INFO

@@ -0,0 +1,91 @@
+Metadata-Version: 2.1
+Name: pymaftools
+Version: 0.1
+Summary: pymaftools is a Python package for handling and analyzing Mutation Annotation Format (MAF) files. It provides utilities for data manipulation and visualization, including classes for MAF parsing and oncoplot generation.
+Home-page: https://github.com/xu62u4u6/pymaftools
+Author: xu62u4u6
+Author-email: 199928ltyos@gmail.com
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+
+# pymaftools
+
+`pymaftools` is a Python package designed to handle and analyze MAF (Mutation Annotation Format) files. It provides utilities for working with mutation data, including the `MAF` and `PivotTable` classes for data manipulation, and functions for visualizing mutation data with oncoplots.
+
+## Features
+
+- **MAF Class**: A utility to load, parse, and manipulate MAF files.
+- **PivotTable Class**: A custom pivot table implementation for summarizing mutation frequencies and sorting genes and samples.
+- **Oncoplot Visualization**: Generate oncoplot visualizations with mutation data and frequencies.
+
+## Installation
+
+### Using pip (from PyPI)
+You can install the `pymaftools` package directly from PyPI using pip:
+
+```bash
+pip install pymaftools
+```
+
+### Using GitHub (for the latest version)
+To install directly from GitHub (if you want the latest changes):
+
+```bash
+pip install git+https://github.com/xu62u4u6/pymaftools.git
+```
+
+
+## Usage
+
+### Importing the Package
+
+```python
+from pymaftools.maf_utils import MAF, PivotTable
+from pymaftools.maf_plots import create_oncoplot
+```
+
+### Example
+
+```python
+# Load the MAF file
+all_case_maf = MAF.read_maf("path_to_maf_file.maf")
+
+# Filter to keep only nonsynonymous mutations
+filtered_all_case_maf = all_case_maf.filter_maf(MAF.nonsynonymous_types)
+
+# Convert to pivot table (genes x samples table, mutation classification as values)
+pivot_table = filtered_all_case_maf.to_pivot_table()
+
+# Calculate mutation frequencies
+pivot_table = pivot_table.add_freq()
+
+# Sort the pivot table (by gene frequency and sample mutation count)
+sorted_pivot_table = (pivot_table
+                       .sort_genes_by_freq()  
+                       .sort_samples_by_mutations()
+                    )
+
+# Generate an oncoplot to show the top 50 genes with the highest mutation frequencies
+create_oncoplot(sorted_pivot_table.top(50), 
+                figsize=(26, 15),
+                ax_main_range=(0, 28), 
+                ax_freq_range=(28, 29), 
+                ax_legend_range=(29, 31),
+                mutation_counts=True)
+
+```
+
+### Requirements
+Python 3.x
+pandas, numpy, matplotlib, seaborn
+### License
+This project is licensed under the MIT License - see the LICENSE file for details.
+
+### Author
+xu62u4u6
+

pymaftools-0.1/pymaftools.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+setup.py
+pymaftools/__init__.py
+pymaftools/maf_plots.py
+pymaftools/maf_utils.py
+pymaftools.egg-info/PKG-INFO
+pymaftools.egg-info/SOURCES.txt
+pymaftools.egg-info/dependency_links.txt
+pymaftools.egg-info/requires.txt
+pymaftools.egg-info/top_level.txt

pymaftools-0.1/pymaftools.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pymaftools-0.1/pymaftools.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pandas
+numpy
+matplotlib
+seaborn

pymaftools-0.1/pymaftools.egg-info/top_level.txt

@@ -0,0 +1 @@
+pymaftools

pymaftools-0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pymaftools-0.1/setup.py

@@ -0,0 +1,25 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='pymaftools',
+    version='0.1',
+    author = "xu62u4u6",
+    author_email="199928ltyos@gmail.com",
+    description='pymaftools is a Python package for handling and analyzing Mutation Annotation Format (MAF) files. It provides utilities for data manipulation and visualization, including classes for MAF parsing and oncoplot generation.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    packages=find_packages(),
+    install_requires=[
+        'pandas', 
+        'numpy', 
+        'matplotlib', 
+        'seaborn', 
+    ],
+    classifiers = [
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    license='MIT',
+    url='https://github.com/xu62u4u6/pymaftools',
+)