PyEvoMotion 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

share/generate_sequences_from_synthdata.py

@@ -0,0 +1,85 @@
+#´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
+#                           IMPORTS                          #
+#.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•#
+
+import numpy as np
+import pandas as pd
+
+from Bio import SeqIO
+from Bio.SeqRecord import SeqRecord
+
+#´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
+#                          CONSTANTS                         #
+#.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•#
+
+WUHAN_REF_PATH = "tests/data/test3/test3UK.fasta"
+DATE_MAP = dict(zip(
+    range(41),
+    pd.date_range(start="2020-01-01", periods=41, freq="7D")
+))
+NUCLEOTIDES = {"A", "C", "G", "T"}
+
+#´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
+#                          FUNCTIONS                         #
+#.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•#
+
+def load_synthdata(path: str) -> pd.DataFrame:
+    """Loads the synthdata from the given path.
+    """
+
+    df = pd.read_csv(path, sep="\t", index_col=0)
+    df.columns = [f"seq{k}" for k in range(len(df.columns))]
+
+    return df
+
+def get_wuhan_ref() -> SeqRecord:
+    """Returns the Wuhan reference sequence.
+    """
+    # We know the Wuhan sequence is the first one in the file
+    with open(WUHAN_REF_PATH, "r") as f:
+        for record in SeqIO.parse(f, "fasta"):
+            return record
+
+def create_synthetic_sequence(mut_num: int, wuhan_ref: SeqRecord) -> str:
+    """Creates a synthetic sequence from the Wuhan reference sequence.
+    """
+    _seq = list(wuhan_ref.seq)
+    mut_positions = np.random.choice(range(len(_seq)), mut_num, replace=False)
+    nucleotides = [
+        np.random.choice(list(NUCLEOTIDES - {_seq[i]}))
+        for i in mut_positions
+    ]
+    for pos, nuc in zip(mut_positions, nucleotides):
+        _seq[pos] = nuc
+    return "".join(_seq)
+
+
+def create_synthetic_sequences(output_path: str, synthdata: pd.DataFrame, wuhan_ref: SeqRecord) -> None:
+    """Creates the synthetic dataset from the synthdata reference and the Wuhan reference sequence.
+    """
+    with open(f"{output_path}.fasta", "w") as f, open(f"{output_path}.tsv", "w") as g:
+        f.write(f">{wuhan_ref.id}\n{wuhan_ref.seq}\n")
+        g.write(f"id\tdate\n{wuhan_ref.id}\t2019-12-29\n")
+        for row_idx, row in synthdata.iterrows():
+            for col_name, col in row.items():
+                # Fetch the row number, the column name and the entry in the synthdata
+                f.write(f">{col_name}_{row_idx}\n{create_synthetic_sequence(col, wuhan_ref)}\n")
+                g.write(f"{col_name}_{row_idx}\t{DATE_MAP[row_idx].strftime('%Y-%m-%d')}\n")
+
+#´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
+#                           MAIN                             #
+#.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•#
+
+def main():
+    WUHAN_REF = get_wuhan_ref()
+
+    for name in ("synthdata1", "synthdata2"):
+        create_synthetic_sequences(
+            f"{name}",
+            load_synthdata(f"tests/data/test4/{name}.txt"),
+            WUHAN_REF
+        )
+    print("Synthetic datasets created successfully.")
+
+if __name__ == "__main__":
+    main()

share/manuscript_figure.py

@@ -4,12 +4,21 @@ import json
 import zipfile
 import warnings
 import urllib.request
+import subprocess
 
 import numpy as np
 import pandas as pd
 import matplotlib as mpl
 import matplotlib.pyplot as plt
 
+#´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
+#                         CONSTANTS                          #
+#.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•#
+
+COLORS = {
+    "UK": "#76d6ff",
+    "USA": "#FF6346",
+}
 
 #´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
 #                         FUNCTIONS                          #
@@ -202,15 +211,10 @@ def safe_map(f: callable, x: list[int | float]) -> list[int | float]:
             _results.append(None)
     return _results
 
-def plot(df: pd.DataFrame, models: dict[str, any], export: bool = False, show: bool = True) -> None:
+def plot_main_figure(df: pd.DataFrame, models: dict[str, any], export: bool = False, show: bool = True) -> None:
     set_matplotlib_global_params()
     fig, ax = plt.subplots(2, 1, figsize=(6, 10))
 
-    colors = {
-        "UK": "#76d6ff",
-        "USA": "#FF6346",
-    }
-
     for idx, case in enumerate(("mean", "var")):
         for col in (f"{case} number of mutations USA", f"{case} number of mutations UK"):
 
@@ -219,16 +223,16 @@ def plot(df: pd.DataFrame, models: dict[str, any], export: bool = False, show: b
             ax[idx].scatter(
                 df.index,
                 df[col] - (df[col].min() if idx == 1 else 0),
-                color=colors[_country],
+                color=COLORS[_country],
                 edgecolor="k",
                 zorder=2,   
             )
             
-            _x = np.arange(-10, 50, 0.5) 
+            _x = np.arange(-10, 60, 0.5) 
             ax[idx].plot(
                 _x + (8 if _country == "USA" else 0),
                 safe_map(models[_country][case][0], _x),
-                color=colors[_country],
+                color=COLORS[_country],
                 label=rf"{_country} ($R^2 = {round(models[_country][case][1], 2):.2f})$",
                 linewidth=3,
                 zorder=1,
@@ -268,6 +272,432 @@ def plot(df: pd.DataFrame, models: dict[str, any], export: bool = False, show: b
 
     if show: plt.show()
 
+def size_plot(df: pd.DataFrame, export: bool = False, show: bool = True) -> None:
+    set_matplotlib_global_params()
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+
+    # Plot UK first
+    markerline, stemlines, baseline = ax.stem(df.index, df[f"size UK"], label="UK")
+    plt.setp(stemlines, color=COLORS["UK"])
+    plt.setp(markerline, color=COLORS["UK"], markeredgecolor="k")
+    plt.setp(baseline, color="#ffffff")
+
+    # Plot USA
+    markerline, stemlines, baseline = ax.stem(df.index, df[f"size USA"], label="USA")
+    plt.setp(stemlines, color=COLORS["USA"])
+    plt.setp(markerline, color=COLORS["USA"], markeredgecolor="k")
+    plt.setp(baseline, color="#ffffff")
+
+    # Plot UK again but with slight transparency on the stem
+    markerline, stemlines, baseline = ax.stem(df.index, df[f"size UK"])
+    plt.setp(stemlines, color=COLORS["UK"], alpha=0.5)
+    plt.setp(markerline, color=COLORS["UK"], markeredgecolor="#000000")
+    plt.setp(baseline, color="#ffffff")
+
+    ax.set_ylim(0, 405)
+    ax.set_xlim(-0.5, 40.5)
+
+    ax.set_xlabel("time (wk)")
+    ax.set_ylabel("Number of sequences")
+    
+    ax.legend(
+        fontsize=16,
+        loc="upper right",
+        bbox_to_anchor=(1.08, 1.08)
+    )
+
+    if export:
+        fig.savefig(
+            "share/weekly_size.pdf",
+            dpi=400,
+            bbox_inches="tight",
+        )
+        print("Figure saved as share/weekly_size.pdf")
+
+    if show: plt.show()
+
+def anomalous_diffusion_plot(export: bool = False, show: bool = True) -> None:
+    set_matplotlib_global_params()
+    fig, ax = plt.subplots(1, 1, figsize=(6, 6))
+
+    x = np.linspace(0, 10, 100)
+
+    plt.plot(x, x**0.8, label=r"$\alpha = 0.8$" + "\n(subdiffusion)", color=COLORS["UK"], linewidth=3)
+    plt.plot(x, x**1, label=r"$\alpha = 1$" + "\n(normal diffusion)", color="#000000", linewidth=3)
+    plt.plot(x, x**1.2, label=r"$\alpha = 1.2$" + "\n(superdiffusion)", color=COLORS["USA"], linewidth=3)
+    
+    plt.legend(
+        fontsize=13,
+        loc="upper left",
+        title=r"variance $\propto \text{time}^\alpha$",
+        title_fontsize=15
+    )
+    
+    plt.xlabel("time")
+    plt.ylabel("variance")
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+    
+    plt.xlim(0, 10)
+    plt.ylim(0, 10)
+
+    if export:
+        fig.savefig(
+            "share/anomalous_diffusion.pdf",
+            dpi=400,
+            bbox_inches="tight",
+        )
+        print("Figure saved as share/anomalous_diffusion.pdf")
+
+    if show: plt.show()
+
+def check_synthetic_data_exists() -> bool:
+    """
+    Check if the synthetic data output files exist.
+    """
+    _files = [
+        "tests/data/test4/synthdata1_out_stats.tsv",
+        "tests/data/test4/synthdata2_out_stats.tsv",
+        "tests/data/test4/synthdata1_out_regression_results.json",
+        "tests/data/test4/synthdata2_out_regression_results.json"
+    ]
+
+    for file in _files:
+        if not os.path.exists(file):
+            return False
+
+    return True
+
+def run_synthetic_data_tests() -> None:
+    """
+    Run the synthetic data tests to generate the required files.
+    """
+    print("Running synthetic data tests to generate required files...")
+    
+    # Create output directory
+    os.makedirs("tests/data/test4", exist_ok=True)
+    
+    # Run tests for S1 dataset
+    result1 = subprocess.run(
+        [
+            "PyEvoMotion",
+            "S1.fasta",
+            "S1.tsv",
+            "tests/data/test4/synthdata1_out",
+            "-ep"
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    
+    if result1.stderr:
+        print(result1.stdout)
+        print(result1.stderr)
+        raise RuntimeError("Failed to process S1 dataset")
+    
+    # Run tests for S2 dataset
+    result2 = subprocess.run(
+        [
+            "PyEvoMotion",
+            "S2.fasta",
+            "S2.tsv",
+            "tests/data/test4/synthdata2_out",
+            "-ep"
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        text=True
+    )
+    
+    if result2.stderr:
+        print(result2.stdout)
+        print(result2.stderr)
+        raise RuntimeError("Failed to process S2 dataset")
+
+def load_synthetic_data_df() -> pd.DataFrame:
+    if not check_synthetic_data_exists():
+        run_synthetic_data_tests()
+    
+    return pd.read_csv(
+        "tests/data/test4/synthdata1_out_stats.tsv",
+        sep="\t",
+    ).merge(
+        pd.read_csv(
+            "tests/data/test4/synthdata2_out_stats.tsv",
+            sep="\t",
+        ),
+        on="date",
+        how="outer",
+        suffixes=(" synt1", " synt2"),
+    )
+
+def load_synthetic_data_models() -> dict[str, dict[str, callable]]:
+    if not check_synthetic_data_exists():
+        run_synthetic_data_tests()
+    
+    _kinds = ("synt1", "synt2")
+    _file = "tests/data/test4/synthdata{}_out_regression_results.json"
+
+    _contents = {}
+
+    for k in _kinds:
+        with open(_file.format(k[-1])) as f:
+            _contents[k] = json.load(f)
+
+    return {
+        "synt1": {
+            "mean": [
+                lambda x: (
+                    _contents["synt1"]["mean number of mutations per 7D model"]["parameters"]["m"]*x
+                    + _contents["synt1"]["mean number of mutations per 7D model"]["parameters"]["b"]
+                ),
+                _contents["synt1"]["mean number of mutations per 7D model"]["r2"],
+            ],
+            "var": [
+                lambda x: (
+                    _contents["synt1"]["scaled var number of mutations per 7D model"]["parameters"]["m"]*x
+                ),
+                _contents["synt1"]["scaled var number of mutations per 7D model"]["r2"],
+            ]
+        },
+        "synt2": {
+            "mean": [
+                lambda x: (
+                    _contents["synt2"]["mean number of mutations per 7D model"]["parameters"]["m"]*x
+                    + _contents["synt2"]["mean number of mutations per 7D model"]["parameters"]["b"]
+                ),
+                _contents["synt2"]["mean number of mutations per 7D model"]["r2"],
+            ],
+            "var": [
+                lambda x: (
+                    _contents["synt2"]["scaled var number of mutations per 7D model"]["parameters"]["d"]
+                    *(x**_contents["synt2"]["scaled var number of mutations per 7D model"]["parameters"]["alpha"])
+                ),
+                _contents["synt2"]["scaled var number of mutations per 7D model"]["r2"],
+            ]
+        },
+    }
+
+def synthetic_data_plot(df: pd.DataFrame, models: dict[str, any], export: bool = False, show: bool = True) -> None:
+    set_matplotlib_global_params()
+    fig, ax = plt.subplots(2, 2, figsize=(12, 10))
+
+    # Flatten axes for easier iteration
+    ax = ax.flatten()
+
+    # Plot counter for subplot index
+    plot_idx = 0
+
+    for case in ("mean", "var"):
+        for col in (f"{case} number of mutations synt1", f"{case} number of mutations synt2"):
+            _type = col.split()[-1].upper()
+
+            # Scatter plot  
+            ax[plot_idx].scatter(
+                df.index,
+                df[col],
+                color="#76d6ff",
+                edgecolor="k",
+                zorder=2,   
+            )
+            
+            # Line plot
+            _x = np.arange(-10, 50, 0.5)
+            ax[plot_idx].plot(
+                _x,
+                safe_map(models[_type.lower()][case][0], _x),
+                color="#76d6ff",
+                label=rf"$R^2 = {round(models[_type.lower()][case][1], 2):.2f}$",
+                linewidth=3,
+                zorder=1,
+            )
+
+            # Styling
+            ax[plot_idx].set_xlim(-0.5, 40.5)
+            if case == "mean":
+                ax[plot_idx].set_ylim(-0.25, 20.25)
+                ax[plot_idx].set_ylabel(f"{case}  (# mutations)")
+            else:  # var case
+                if _type == "SYNT1":
+                    ax[plot_idx].set_ylim(-0.5, 40.5)
+                else:
+                    ax[plot_idx].set_ylim(-0.1, 10.1)
+                ax[plot_idx].set_ylabel(f"{case}iance  (# mutations)")
+
+            ax[plot_idx].set_xlabel("time (wk)")
+            ax[plot_idx].legend(
+                fontsize=16,
+                loc="upper left",
+            )
+
+            plot_idx += 1
+
+    fig.suptitle(" ", fontsize=1) # To get some space on top
+    fig.tight_layout()
+    
+    # Add subplot annotations
+    plt.annotate("a", (0.02, 0.935), xycoords="figure fraction", fontsize=28, fontweight="bold")
+    plt.annotate("b", (0.505, 0.935), xycoords="figure fraction", fontsize=28, fontweight="bold")
+    plt.annotate("c", (0.02, 0.465), xycoords="figure fraction", fontsize=28, fontweight="bold")
+    plt.annotate("d", (0.505, 0.465), xycoords="figure fraction", fontsize=28, fontweight="bold")
+
+    if export:
+        fig.savefig(
+            "share/synth_figure.pdf",
+            dpi=400,
+            bbox_inches="tight",
+        )
+        print("Figure saved as share/synth_figure.pdf")
+
+    if show: plt.show()
+    
+
+def load_additional_uk_stats() -> dict[str, pd.DataFrame]:
+    """
+    Load the additional UK stats files for different time windows.
+    """
+    _files = {
+        "5D": "tests/data/test3/output/20250517164757/UKout_5D_stats.tsv",
+        "10D": "tests/data/test3/output/20250517173133/UKout_10D_stats.tsv",
+        "14D": "tests/data/test3/output/20250517181004/UKout_14D_stats.tsv",
+        "7D": "share/figUK_stats.tsv"
+    }
+    
+    return {
+        k: pd.read_csv(v, sep="\t")
+        for k, v in _files.items()
+    }
+
+def load_additional_uk_models() -> dict[str, dict[str, callable]]:
+    """
+    Load the additional UK models for different time windows.
+    """
+    _files = {
+        "5D": "tests/data/test3/output/20250517164757/UKout_5D_regression_results.json",
+        "10D": "tests/data/test3/output/20250517173133/UKout_10D_regression_results.json",
+        "14D": "tests/data/test3/output/20250517181004/UKout_14D_regression_results.json",
+        "7D": "share/figUK_regression_results.json"
+    }
+    
+    _contents = {}
+    for k, v in _files.items():
+        with open(v) as f:
+            _contents[k] = json.load(f)
+    return {
+        k: {
+            "mean": [
+                {
+                    "m": _contents[k][f"mean number of mutations per {k} model"]["parameters"]["m"],
+                    "b": _contents[k][f"mean number of mutations per {k} model"]["parameters"]["b"]
+                },
+                _contents[k][f"mean number of mutations per {k} model"]["r2"]
+            ],
+            "var": [
+                {
+                    "d": _contents[k][f"scaled var number of mutations per {k} model"]["parameters"]["d"],
+                    "alpha": _contents[k][f"scaled var number of mutations per {k} model"]["parameters"]["alpha"]
+                },
+                _contents[k][f"scaled var number of mutations per {k} model"]["r2"],
+            ]
+        }
+        for k in _files.keys()
+    }
+
+def plot_uk_time_windows(stats: dict[str, pd.DataFrame], models: dict[str, dict[str, callable]], export: bool = False, show: bool = True) -> None:
+    """
+    Plot a 1x4 subplot of UK data with different time windows.
+    
+    Args:
+        stats: Dictionary of dataframes containing the stats for each time window
+        models: Dictionary of models for each time window
+        export: Whether to export the figure
+        show: Whether to show the figure
+    """
+    set_matplotlib_global_params()
+    fig, ax = plt.subplots(2, 4, figsize=(24, 12))
+    
+    # Order of time windows to plot
+    windows = ["5D", "7D", "10D", "14D"]
+
+    for idx, window in enumerate(windows):
+        df = stats[window]
+        model = models[window]
+        scaling = {
+            "5D": 5/7,
+            "7D": 1,
+            "10D": 10/7,
+            "14D": 14/7,
+        }
+        for idx2, case in enumerate(("mean", "var")):
+
+            if case == "mean":
+                # Plot mean
+                ax[idx2, idx].scatter(
+                    df.index.to_numpy()*scaling[window],
+                    df["mean number of mutations"],
+                    color=COLORS["UK"],
+                    edgecolor="k",
+                    zorder=2,
+                )
+            
+                _x = np.arange(-0.5, 51, 0.5)
+                ax[idx2, idx].plot(
+                    _x,
+                    model["mean"][0]["m"]*(_x/scaling[window]) + model["mean"][0]["b"],
+                    color=COLORS["UK"],
+                    label=rf"Mean ($R^2 = {round(model['mean'][1], 2):.2f})$",
+                    linewidth=3,
+                    zorder=1,
+                )
+
+            elif case == "var":
+                # Plot variance 
+                ax[idx2, idx].scatter(
+                    df.index.to_numpy()*scaling[window],
+                    df["var number of mutations"] - df["var number of mutations"].min(),
+                    color=COLORS["UK"],
+                    edgecolor="k",
+                    zorder=2,
+                )
+                
+                ax[idx2, idx].plot(
+                    _x,
+                    model["var"][0]["d"]*(_x/scaling[window])**model["var"][0]["alpha"],
+                    color=COLORS["UK"],
+                    label=rf"Var ($R^2 = {round(model['var'][1], 2):.2f})$",
+                    linewidth=3,
+                    zorder=1,
+                )
+            
+            # Styling
+            ax[idx2, idx].set_xlim(-0.5, 40.5)
+            
+            if case == "mean":
+                ax[idx2, idx].set_ylim(29.5, 45.5)
+            else:
+                ax[idx2, idx].set_ylim(-0.5, 10.5)
+            
+            ax[idx2, idx].set_xlabel("time (wk)")
+            if idx == 0:
+                ax[idx2, idx].set_ylabel(f"{case} (# mutations)")
+
+            ax[idx2, idx].legend(
+                fontsize=12,
+                loc="upper left",
+            )
+    
+    if export:
+        fig.savefig(
+            "share/uk_time_windows.pdf",
+            dpi=400,
+            bbox_inches="tight",
+        )
+    
+    if show:
+        plt.show()
+
 #´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:#
 #                           MAIN                             #
 #.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•#
@@ -290,7 +720,6 @@ def main(export: bool = False) -> None:
                 f"share/figdata{country}.tsv",
                 f"share/fig{country}",
                 "-k", "total",
-                "-n", "5",
                 "-dt", "7D",
                 "-dr", "2020-10-01..2021-08-01",
                 "-ep",
@@ -301,8 +730,24 @@ def main(export: bool = False) -> None:
     df = load_final_data_df()
     models = load_models()
 
-    # Plot
-    plot(df, models, export=export)
+    # Main plot
+    plot_main_figure(df, models, export=export)
+
+    # Size plot
+    size_plot(df, export=export)
+
+    # Anomalous diffusion plot
+    anomalous_diffusion_plot(export=export)
+
+    # Synthetic data plot
+    synth_df = load_synthetic_data_df()
+    synth_models = load_synthetic_data_models()
+    synthetic_data_plot(synth_df, synth_models, export=export)
+
+    # UK time windows plot
+    additional_uk_stats = load_additional_uk_stats()
+    additional_uk_models = load_additional_uk_models()
+    plot_uk_time_windows(additional_uk_stats, additional_uk_models, export=export)
 
 
 if __name__ == "__main__":

pyevomotion-0.1.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-PyEvoMotion/__init__.py,sha256=NqFDD-EZBzouzTwXozZqhPC9sLr7GQaElRKtP0tkHoE,568
-PyEvoMotion/cli.py,sha256=424ATWV3P89sMYhXT2-i3eHN-VwmujWjcue0coxY-lQ,15498
-PyEvoMotion/core/__init__.py,sha256=1I-NkFFh6ljLgB_mqQVFLNvCrVKEHLVxa_5dsv3ihWQ,450
-PyEvoMotion/core/base.py,sha256=SvvJAuYx__NAI8Mzye9lZJM6mPsEuKnulcJuztiPU_E,13226
-PyEvoMotion/core/core.py,sha256=xCVGZxNvIKge0KINHO-tHK6aD4tdL7Zgua10eONAbi0,18311
-PyEvoMotion/core/parser.py,sha256=xbjTbIvNy6ta-8WBWwDdnUoTjARPE9eZyaHOXfQKW4U,17144
-PyEvoMotion/utils.py,sha256=Ye3eL1RXZOZzzs2KZy0R45u06DOtLYo-zqE45tN2t7g,2859
-share/mafft_install.sh,sha256=pCw70UsKkkNXUsZMwQlQ2b4zSXFrBA7jAj9iOfGLzUw,1007
-share/manuscript_figure.py,sha256=czznZchVsb7qsCXEGJo-NFG7DJuAE2XxydLmqsAQ66g,9704
-pyevomotion-0.1.0.dist-info/METADATA,sha256=tEv8So175_nhi-FAr_aCM3lo052xgIh-_HPJBGWCc6k,5950
-pyevomotion-0.1.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pyevomotion-0.1.0.dist-info/entry_points.txt,sha256=UMzoojYwQi-713hRggkQXUIfGNygUARhTdGs77Usp7s,53
-pyevomotion-0.1.0.dist-info/RECORD,,