makoview 0.1.2__tar.gz

makoview-0.1.2/.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,75 @@
+name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
+
+on: push
+
+jobs:
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Install Python 3.13
+        run: uv python install 3.13
+
+      - name: Build
+        run: uv build
+
+      - name: Store the distribution packages
+        uses: actions/upload-artifact@v5
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/') # only publish to PyPI on tag pushes
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/makoview # Replace <package-name> with your PyPI project name
+    permissions:
+      id-token: write # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v6
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-to-testpypi:
+    name: Publish Python 🐍 distribution 📦 to TestPyPI
+    needs:
+      - build
+    runs-on: ubuntu-latest
+
+    environment:
+      name: testpypi
+      url: https://test.pypi.org/p/makoview
+
+    permissions:
+      id-token: write # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v6
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: https://test.pypi.org/legacy/
+          verbose: true

makoview-0.1.2/.gitignore

@@ -0,0 +1,220 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml
+
+# DuckDB database files used in testing
+**/*.duckdb
+**/.DS_Store

makoview-0.1.2/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: makoview
+Version: 0.1.2
+Summary: Visualise the results from Mako
+Requires-Python: <3.13,>=3.9
+Requires-Dist: duckdb>=1.0.0
+Requires-Dist: matplotlib>=3.9.4
+Requires-Dist: pandas>=2.3.3
+Requires-Dist: seaborn>=0.13.2
+Requires-Dist: shiny>=0.10.0
+Requires-Dist: shinyswatch>=0.9.0
+Description-Content-Type: text/markdown
+
+# makoview

makoview-0.1.2/README.md

@@ -0,0 +1 @@
+# makoview

makoview-0.1.2/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "makoview"
+version = "0.1.2"
+description = "Visualise the results from Mako"
+readme = "README.md"
+requires-python = ">=3.9,<3.13"
+dependencies = [
+    "shiny>=0.10.0",
+    "duckdb>=1.0.0",
+    "pandas>=2.3.3",
+    "matplotlib>=3.9.4",
+    "seaborn>=0.13.2",
+    "shinyswatch>=0.9.0",
+]
+
+[build-system]
+build-backend  = 'hatchling.build'
+requires       = ['hatchling']
+
+
+[tool.uv_build]
+src-layout = true
+
+
+[tool.uv]
+dev-dependencies = []
+package = true
+
+
+[project.scripts]
+makoview = "makoview.wrapper:main"

makoview-0.1.2/src/makoview/app.py

@@ -0,0 +1,179 @@
+from shiny.types import SilentException
+from shiny.express import input, render, ui
+from shiny import reactive
+import duckdb
+import os
+import pandas as pd
+from pathlib import Path
+
+import shinyswatch
+
+import plots
+
+_db_path = os.environ["MAKO_DIFFERENTIAL_DB"]
+_reads_path = os.environ["MAKO_MODIFICATION_DB"]
+
+# Validate that database files exist
+if not os.path.exists(_db_path):
+    raise FileNotFoundError(f"Differential sites database not found: {_db_path}")
+if not os.path.exists(_reads_path):
+    raise FileNotFoundError(f"Modification database not found: {_reads_path}")
+
+
+# load from db into a Pandas dataframe in-memory for faster access
+def load_data_into_memory(db_path) -> pd.DataFrame:
+    conn = duckdb.connect(database=db_path, read_only=True)
+    df = conn.execute("SELECT * FROM sites").fetchdf()
+    conn.close()
+    return df
+
+
+df = load_data_into_memory(_db_path)
+
+
+# UI Definition
+ui.page_opts(title="makoview", theme=shinyswatch.theme.lumen)
+ui.include_css(Path(__file__).parent / "styles.css")
+# ui.page_opts(title="Mako modification lookup", fillable=True)
+
+read_cache: reactive.Value[pd.DataFrame] = reactive.value()
+
+
+with ui.sidebar(width="400px", open="always"):
+    with ui.card(fill=False):
+        ui.card_header("Search for a transcript...")
+        # with ui.layout_columns(col_widths=(8, 4), gap="0.75rem", row_heights="auto"):
+        ui.input_text(
+            "transcript_id",
+            "Transcript ID",
+            placeholder="e.g. ENST00000000233.10",
+            width="100%",
+        )
+
+        ui.input_selectize(
+            "transcript_position",
+            "Transcript Position",
+            choices=[],
+            multiple=False,
+            options={
+                "placeholder": "transcript not found...",
+                "dropdownParent": "body",
+            },
+            width="100%",
+        )
+        ui.input_action_button(
+            "search_btn", "Search", class_="btn-primary", style="margin-top: 0.5rem;"
+        )
+
+    @render.data_frame
+    @reactive.event(input.search_btn, ignore_none=False)
+    def on_search():
+        """Generate boxplot of probability_modified by group and sample."""
+        transcript_id: str = input.transcript_id()
+        transcript_position: int = input.transcript_position()
+
+        if not transcript_id or not transcript_id.strip():
+            return None
+
+        # Get matching reads as a dataframe
+        reads_df = get_matching_reads(transcript_id.strip(), int(transcript_position))
+
+        site_df = df.loc[
+            (df["transcript_id"] == transcript_id.strip())
+            & (df["transcript_position"] == int(transcript_position))
+        ]
+        site_df_tidy = site_df.melt(var_name="column", value_name="value")
+
+        read_cache.set(reads_df)
+
+        return render.DataGrid(data=site_df_tidy, width="100%", height="auto")
+
+
+def get_matching_reads(transcript_id: str, transcript_position: int) -> pd.DataFrame:
+    """
+    Find rnames for the given transcript_id and transcript_position,
+    then query reads database for matching non-ignored reads.
+    """
+    # Find matching rnames from the sites dataframe
+    matching_rnames = (
+        df.loc[
+            (df["transcript_id"] == transcript_id)
+            & (df["transcript_position"] == transcript_position),
+            "rname",
+        ]
+        .unique()
+        .tolist()
+    )
+
+    print(matching_rnames)
+
+    if not matching_rnames:
+        return pd.DataFrame()
+
+    # Query reads database for matching, non-ignored reads
+    conn = duckdb.connect(database=_reads_path, read_only=True)
+
+    # Use parameterized query to avoid SQL injection
+    placeholders = ", ".join(["?" for _ in matching_rnames])
+    query = f"""
+        SELECT * FROM reads
+        WHERE rname IN ({placeholders})
+          AND transcript_position = {transcript_position}
+          AND ignored = FALSE
+    """
+
+    reads_df = conn.execute(query, matching_rnames).fetchdf()
+    conn.close()
+
+    return reads_df
+
+
+# Server logic
+@reactive.effect
+@reactive.event(input.transcript_id)
+def update_transcript_pos():
+    """Update the transcript position options based on the entered transcript ID."""
+    transcript_id: str = input.transcript_id()
+
+    if transcript_id and transcript_id.strip():
+        positions = df.loc[
+            df["transcript_id"] == transcript_id.strip(), "transcript_position"
+        ].unique()
+        positions = sorted(positions.tolist())
+    else:
+        positions = []
+
+    ui.update_selectize(
+        "transcript_position",
+        choices=positions,
+    )
+
+
+@render.data_frame
+def plot_counts():
+    try:
+        subset = read_cache.get()
+    except SilentException:
+        return None
+
+    binarized_df = (
+        subset.groupby(["sample_name", "group_name"])
+        .agg(
+            successes=("probability_modified", lambda x: (x >= 0.5).sum()),
+            failures=("probability_modified", lambda x: (x < 0.5).sum()),
+        )
+        .sort_values(["group_name", "sample_name"])
+        .reset_index()
+    )
+
+    return binarized_df
+
+
+@render.plot(height=750)
+def plot_modification():
+    try:
+        subset = read_cache.get()
+    except SilentException:
+        return None
+
+    return plots.plot_binarised_violin_by_site(subset)

makoview-0.1.2/src/makoview/plots.py

@@ -0,0 +1,105 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+
+
+def plot_binarised_violin_by_site(subset):
+    # Binarise probability (threshold 0.5)
+    subset["binarised_probability_modified"] = (
+        subset["probability_modified"] >= 0.5
+    ).astype(int)
+
+    # Add combined label and sort
+    subset["label"] = subset["sample_name"] + " (" + subset["group_name"] + ")"
+    subset.sort_values(["group_name", "sample_name"], inplace=True)
+    label_order = subset["label"].unique()
+
+    # Compute counts per label
+    counts = subset.groupby("label")["binarised_probability_modified"]
+    n = counts.size().reindex(label_order)
+    T = counts.sum().reindex(label_order)
+    F = n - T
+    T_over_n = (T / n).round(3)
+
+    label_order_with_stats = [
+        f"{lbl}\n(n={n[lbl]}, T={T[lbl]}, F={F[lbl]}, T/n={T_over_n[lbl]})"
+        for lbl in label_order
+    ]
+
+    # Plot
+    fig, ax = plt.subplots(1, 1, figsize=(max(10, len(label_order) * 1.5), 8))
+
+    sns.violinplot(
+        data=subset,
+        x="label",
+        y="binarised_probability_modified",
+        order=label_order,
+        inner=None,
+        density_norm="width",
+        cut=0,
+        color="skyblue",
+        ax=ax,
+    )
+
+    sns.boxplot(
+        data=subset,
+        x="label",
+        y="binarised_probability_modified",
+        order=label_order,
+        showcaps=True,
+        width=0.15,
+        boxprops={"facecolor": "white", "edgecolor": "black", "linewidth": 1},
+        whiskerprops={"color": "black", "linewidth": 1},
+        capprops={"color": "black", "linewidth": 1},
+        medianprops={"color": "black", "linewidth": 1},
+        showfliers=False,
+        ax=ax,
+    )
+
+    sns.stripplot(
+        data=subset,
+        x="label",
+        y="binarised_probability_modified",
+        order=label_order,
+        color="black",
+        size=3,
+        jitter=True,
+        alpha=0.5,
+        ax=ax,
+    )
+
+    # Mean ± SD
+    stats = (
+        subset.groupby("label")["binarised_probability_modified"]
+        .agg(["mean", "std"])
+        .reindex(label_order)
+    )
+
+    for j, label in enumerate(label_order):
+        mean_val = stats.loc[label, "mean"]
+        std_val = stats.loc[label, "std"]
+
+        ax.plot(j, mean_val, "o", color="red", markersize=6)
+
+        ymin = max(0, mean_val - std_val)
+        ymax = min(1, mean_val + std_val)
+        ax.errorbar(
+            j,
+            mean_val,
+            yerr=[[mean_val - ymin], [ymax - mean_val]],
+            fmt="none",
+            ecolor="red",
+            elinewidth=1,
+            capsize=5,
+        )
+
+    ax.set_xticks(range(len(label_order)))
+    ax.set_xticklabels(label_order_with_stats, rotation=45, ha="right")
+    ax.set_xlabel("Sample (Group)")
+    ax.set_ylabel("Binarised Probability Modified")
+    ax.set_title("Violin Plot of Binarised Probability Modified for each Sample")
+    ax.set_ylim(-0.05, 1.05)
+    ax.grid(True, linestyle="--", alpha=0.6)
+
+    return fig

makoview-0.1.2/src/makoview/styles.css

@@ -0,0 +1,3 @@
+.navbar {
+    border: none;
+}

makoview-0.1.2/src/makoview/wrapper.py

@@ -0,0 +1,63 @@
+from shiny import run_app
+import os
+import argparse
+from pathlib import Path
+
+
+def main():
+    """Launch the MakoView Shiny visualization application."""
+
+    parser = argparse.ArgumentParser(
+        description="Launch makoview",
+    )
+
+    parser.add_argument(
+        "--differential-results",
+        type=Path,
+        required=True,
+        dest="differential_results",
+        help="Path to differential sites database file",
+    )
+
+    parser.add_argument(
+        "--modification-db",
+        type=Path,
+        required=True,
+        dest="modification_db",
+        help="Path to modification database file",
+    )
+
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8000,
+        help="Port for the Shiny application (default: 8000)",
+    )
+
+    args = parser.parse_args()
+
+    # Use explicitly provided paths
+    diff_db_path = args.differential_results
+    mod_db_path = args.modification_db
+
+    # Validate files exist
+    if not diff_db_path.exists():
+        parser.error(f"Differential results file not found: {diff_db_path}")
+    if not mod_db_path.exists():
+        parser.error(f"Modification database file not found: {mod_db_path}")
+
+    # Set environment variables for app.py to consume
+    os.environ["MAKO_DIFFERENTIAL_DB"] = str(diff_db_path.absolute())
+    os.environ["MAKO_MODIFICATION_DB"] = str(mod_db_path.absolute())
+
+    print(f"Starting Mako Shiny app on port {args.port}...")
+    print(f"  Differential DB: {diff_db_path.absolute()}")
+    print(f"  Modification DB: {mod_db_path.absolute()}")
+
+    path = Path(__file__).parent.resolve()
+
+    run_app(str(path / "app.py"), port=args.port)  # type: ignore[call-non-callable]
+
+
+if __name__ == "__main__":
+    main()