RefgenDetector 3.0.5__tar.gz → 3.0.7__tar.gz

{refgendetector-3.0.5/src/RefgenDetector.egg-info → refgendetector-3.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RefgenDetector
-Version: 3.0.5
+Version: 3.0.7
 Author: Mireia Marin i Ginestar
 Author-email: <mireia.marin@crg.eu>
 Keywords: python
@@ -180,7 +180,9 @@ To infer the reference genome from a VCF the tool will read the VCF file in chun
 
 The msgpack files were created comparing the nucleotides in each position for hg18, GRCh37, GRCh38 and T2T. Each file contains a list of the positions where each reference had a different nucleotide (distinguishing positions). 
 
-By getting the number of matches between these distinguishing positions and the `REF` present in the VCF we infer the reference genome version used to call the variants. 
+By getting the number of matches between these distinguishing positions and the `REF` present in the VCF we infer the reference genome version used to call the variants.
+
+**Bear in mind** that the input VCF must be sorted to improve runtime performance.
 
 ## Requirements
 
@@ -197,15 +199,16 @@ Depending on how you want to install the package:
 
 1. Clone this repository
 
-2.```git clone https://github.com/EGA-archive/refgenDetector.git
+```git clone https://github.com/EGA-archive/refgenDetector.git
 cd refgenDetector
-pip install -e . ```
+pip install -e . 
+```
 
-3. ``$ python3 refgenDetector_main.py -h ``
+2. ``$ python3 refgenDetector_main.py -h ``
 
-4. Download the `msgpack` files for the inference with VCFs: [Download the msgpack reference](https://crgcnag-my.sharepoint.com/:u:/g/personal/mimarin_crg_es/IQDa5CICZDAoRZmbfhBG3ZPEAWdVnNqvefFJB_r5Hc8aM70?e=kID7zn)
+3. Download the `msgpack` files for the inference with VCFs: [Download the msgpack reference](https://crgcnag-my.sharepoint.com/:u:/g/personal/mimarin_crg_es/IQDa5CICZDAoRZmbfhBG3ZPEAWdVnNqvefFJB_r5Hc8aM70?e=kID7zn)
 
-5. Move the `msgpack` to the correct path:
+4. Move the `msgpack` to the correct path:
 
 ```
 mv msgpacks.zip /refgenDetector/src/refgenDetector/
@@ -216,9 +219,91 @@ unzip /refgenDetector/src/refgenDetector/msgpacks.zip
 
 ``$ pip install refgenDetector``
 
+The reference files for the VCF inference will be automatically downloaded after the first execution of refgenDetector
+
+### With Docker
+
+refgenDetector can be run using Docker, allowing it to work on Linux, Windows, and macOS without installing Python or other dependencies locally.
+
+#### 1. Requirements
+
+- [Docker](https://www.docker.com/) with Docker Compose installed
+- The refgenDetector repository cloned locally
+
+#### 2. Build and start the container
+
+From the root directory of the repository, run:
+
+```bash
+docker compose up -d --build
+```
+
+This builds the Docker image and starts the container in the background.
+
+For subsequent starts, use:
+
+```bash
+docker compose up -d
+```
+
+#### 3. Add input files
+
+Place the files you want to analyse in the `data/` directory of the repository.
+
+This folder is automatically mounted inside the container, so files can be added or removed without rebuilding it.
+
+#### 4. Run refgenDetector
+
+Execute refgenDetector using:
+
+```bash
+docker compose exec refgendetector refgenDetector -t VCF -f sample.vcf.gz
+```
+
+Replace `sample.vcf.gz` with your input filename.
+
+Supported input types include:
+
+- `VCF` — VCF files
+- `BAM/CRAM` — BAM or CRAM files
+- `Header` — extracted BAM/CRAM headers
+
+For example, to analyse a BAM file:
+
+```bash
+docker compose exec refgendetector refgenDetector -t BAM/CRAM -f sample.bam
+```
+
+To display the available options:
+
+```bash
+docker compose exec refgendetector refgenDetector -h
+```
+
+**Note:** On the first execution requiring reference databases, refgenDetector automatically downloads them. These files are stored in a persistent Docker volume and reused in subsequent executions, including after rebuilding the container.
+
+#### 5. Stop the container
+
+```bash
+docker compose down
+```
+
+This stops and removes the container while preserving the downloaded reference databases.
+
+To start it again:
+
+```bash
+docker compose up -d
+```
+
+**Important:** Avoid using `docker compose down -v`, as this will also remove the persistent volume containing the reference databases.
+
 
 ## Usage
 
+
+**Bear in mind that the VCF must be sorted for optimal execution.**
+
 You can get the help menu by running:
 
 ```

{refgendetector-3.0.5 → refgendetector-3.0.7}/README.md

@@ -154,7 +154,9 @@ To infer the reference genome from a VCF the tool will read the VCF file in chun
 
 The msgpack files were created comparing the nucleotides in each position for hg18, GRCh37, GRCh38 and T2T. Each file contains a list of the positions where each reference had a different nucleotide (distinguishing positions). 
 
-By getting the number of matches between these distinguishing positions and the `REF` present in the VCF we infer the reference genome version used to call the variants. 
+By getting the number of matches between these distinguishing positions and the `REF` present in the VCF we infer the reference genome version used to call the variants.
+
+**Bear in mind** that the input VCF must be sorted to improve runtime performance.
 
 ## Requirements
 
@@ -171,15 +173,16 @@ Depending on how you want to install the package:
 
 1. Clone this repository
 
-2.```git clone https://github.com/EGA-archive/refgenDetector.git
+```git clone https://github.com/EGA-archive/refgenDetector.git
 cd refgenDetector
-pip install -e . ```
+pip install -e . 
+```
 
-3. ``$ python3 refgenDetector_main.py -h ``
+2. ``$ python3 refgenDetector_main.py -h ``
 
-4. Download the `msgpack` files for the inference with VCFs: [Download the msgpack reference](https://crgcnag-my.sharepoint.com/:u:/g/personal/mimarin_crg_es/IQDa5CICZDAoRZmbfhBG3ZPEAWdVnNqvefFJB_r5Hc8aM70?e=kID7zn)
+3. Download the `msgpack` files for the inference with VCFs: [Download the msgpack reference](https://crgcnag-my.sharepoint.com/:u:/g/personal/mimarin_crg_es/IQDa5CICZDAoRZmbfhBG3ZPEAWdVnNqvefFJB_r5Hc8aM70?e=kID7zn)
 
-5. Move the `msgpack` to the correct path:
+4. Move the `msgpack` to the correct path:
 
 ```
 mv msgpacks.zip /refgenDetector/src/refgenDetector/
@@ -190,9 +193,91 @@ unzip /refgenDetector/src/refgenDetector/msgpacks.zip
 
 ``$ pip install refgenDetector``
 
+The reference files for the VCF inference will be automatically downloaded after the first execution of refgenDetector
+
+### With Docker
+
+refgenDetector can be run using Docker, allowing it to work on Linux, Windows, and macOS without installing Python or other dependencies locally.
+
+#### 1. Requirements
+
+- [Docker](https://www.docker.com/) with Docker Compose installed
+- The refgenDetector repository cloned locally
+
+#### 2. Build and start the container
+
+From the root directory of the repository, run:
+
+```bash
+docker compose up -d --build
+```
+
+This builds the Docker image and starts the container in the background.
+
+For subsequent starts, use:
+
+```bash
+docker compose up -d
+```
+
+#### 3. Add input files
+
+Place the files you want to analyse in the `data/` directory of the repository.
+
+This folder is automatically mounted inside the container, so files can be added or removed without rebuilding it.
+
+#### 4. Run refgenDetector
+
+Execute refgenDetector using:
+
+```bash
+docker compose exec refgendetector refgenDetector -t VCF -f sample.vcf.gz
+```
+
+Replace `sample.vcf.gz` with your input filename.
+
+Supported input types include:
+
+- `VCF` — VCF files
+- `BAM/CRAM` — BAM or CRAM files
+- `Header` — extracted BAM/CRAM headers
+
+For example, to analyse a BAM file:
+
+```bash
+docker compose exec refgendetector refgenDetector -t BAM/CRAM -f sample.bam
+```
+
+To display the available options:
+
+```bash
+docker compose exec refgendetector refgenDetector -h
+```
+
+**Note:** On the first execution requiring reference databases, refgenDetector automatically downloads them. These files are stored in a persistent Docker volume and reused in subsequent executions, including after rebuilding the container.
+
+#### 5. Stop the container
+
+```bash
+docker compose down
+```
+
+This stops and removes the container while preserving the downloaded reference databases.
+
+To start it again:
+
+```bash
+docker compose up -d
+```
+
+**Important:** Avoid using `docker compose down -v`, as this will also remove the persistent volume containing the reference databases.
+
 
 ## Usage
 
+
+**Bear in mind that the VCF must be sorted for optimal execution.**
+
 You can get the help menu by running:
 
 ```

{refgendetector-3.0.5 → refgendetector-3.0.7}/setup.py

@@ -5,7 +5,7 @@ from pathlib import Path
 
 this_directory = Path(__file__).parent
 long_description = (this_directory / "README.md").read_text()
-VERSION = '3.0.5'
+VERSION = '3.0.7'
 DESCRIPTION = 'RefgenDetector'
 
 

{refgendetector-3.0.5 → refgendetector-3.0.7/src/RefgenDetector.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: RefgenDetector
-Version: 3.0.5
+Version: 3.0.7
 Author: Mireia Marin i Ginestar
 Author-email: <mireia.marin@crg.eu>
 Keywords: python
@@ -180,7 +180,9 @@ To infer the reference genome from a VCF the tool will read the VCF file in chun
 
 The msgpack files were created comparing the nucleotides in each position for hg18, GRCh37, GRCh38 and T2T. Each file contains a list of the positions where each reference had a different nucleotide (distinguishing positions). 
 
-By getting the number of matches between these distinguishing positions and the `REF` present in the VCF we infer the reference genome version used to call the variants. 
+By getting the number of matches between these distinguishing positions and the `REF` present in the VCF we infer the reference genome version used to call the variants.
+
+**Bear in mind** that the input VCF must be sorted to improve runtime performance.
 
 ## Requirements
 
@@ -197,15 +199,16 @@ Depending on how you want to install the package:
 
 1. Clone this repository
 
-2.```git clone https://github.com/EGA-archive/refgenDetector.git
+```git clone https://github.com/EGA-archive/refgenDetector.git
 cd refgenDetector
-pip install -e . ```
+pip install -e . 
+```
 
-3. ``$ python3 refgenDetector_main.py -h ``
+2. ``$ python3 refgenDetector_main.py -h ``
 
-4. Download the `msgpack` files for the inference with VCFs: [Download the msgpack reference](https://crgcnag-my.sharepoint.com/:u:/g/personal/mimarin_crg_es/IQDa5CICZDAoRZmbfhBG3ZPEAWdVnNqvefFJB_r5Hc8aM70?e=kID7zn)
+3. Download the `msgpack` files for the inference with VCFs: [Download the msgpack reference](https://crgcnag-my.sharepoint.com/:u:/g/personal/mimarin_crg_es/IQDa5CICZDAoRZmbfhBG3ZPEAWdVnNqvefFJB_r5Hc8aM70?e=kID7zn)
 
-5. Move the `msgpack` to the correct path:
+4. Move the `msgpack` to the correct path:
 
 ```
 mv msgpacks.zip /refgenDetector/src/refgenDetector/
@@ -216,9 +219,91 @@ unzip /refgenDetector/src/refgenDetector/msgpacks.zip
 
 ``$ pip install refgenDetector``
 
+The reference files for the VCF inference will be automatically downloaded after the first execution of refgenDetector
+
+### With Docker
+
+refgenDetector can be run using Docker, allowing it to work on Linux, Windows, and macOS without installing Python or other dependencies locally.
+
+#### 1. Requirements
+
+- [Docker](https://www.docker.com/) with Docker Compose installed
+- The refgenDetector repository cloned locally
+
+#### 2. Build and start the container
+
+From the root directory of the repository, run:
+
+```bash
+docker compose up -d --build
+```
+
+This builds the Docker image and starts the container in the background.
+
+For subsequent starts, use:
+
+```bash
+docker compose up -d
+```
+
+#### 3. Add input files
+
+Place the files you want to analyse in the `data/` directory of the repository.
+
+This folder is automatically mounted inside the container, so files can be added or removed without rebuilding it.
+
+#### 4. Run refgenDetector
+
+Execute refgenDetector using:
+
+```bash
+docker compose exec refgendetector refgenDetector -t VCF -f sample.vcf.gz
+```
+
+Replace `sample.vcf.gz` with your input filename.
+
+Supported input types include:
+
+- `VCF` — VCF files
+- `BAM/CRAM` — BAM or CRAM files
+- `Header` — extracted BAM/CRAM headers
+
+For example, to analyse a BAM file:
+
+```bash
+docker compose exec refgendetector refgenDetector -t BAM/CRAM -f sample.bam
+```
+
+To display the available options:
+
+```bash
+docker compose exec refgendetector refgenDetector -h
+```
+
+**Note:** On the first execution requiring reference databases, refgenDetector automatically downloads them. These files are stored in a persistent Docker volume and reused in subsequent executions, including after rebuilding the container.
+
+#### 5. Stop the container
+
+```bash
+docker compose down
+```
+
+This stops and removes the container while preserving the downloaded reference databases.
+
+To start it again:
+
+```bash
+docker compose up -d
+```
+
+**Important:** Avoid using `docker compose down -v`, as this will also remove the persistent volume containing the reference databases.
+
 
 ## Usage
 
+
+**Bear in mind that the VCF must be sorted for optimal execution.**
+
 You can get the help menu by running:
 
 ```

{refgendetector-3.0.5 → refgendetector-3.0.7}/src/RefgenDetector.egg-info/SOURCES.txt

@@ -17,4 +17,8 @@ src/refgenDetector/refgenDetector_main.py
 src/refgenDetector/variant_files.py
 src/refgenDetector/exceptions/NoFileException.py
 src/refgenDetector/exceptions/__init__.py
-src/refgenDetector/msgpacks/__init__.py
+src/refgenDetector/github_msgpacks/__init__.py
+src/refgenDetector/msgpacks/__init__.py
+src/refgenDetector/msgpacks/create-plots.py
+src/refgenDetector/msgpacks/create-plots2.py
+src/refgenDetector/msgpacks/open_file.py

{refgendetector-3.0.5 → refgendetector-3.0.7}/src/refgenDetector/aligment_files.py

@@ -250,33 +250,36 @@ def get_info_txt(header_txt, md5, assembly):
 
 def process_data_txt(target_file, md5, assembly):
     """
-    First function of the txt module. It opens each header in --path. gzip or uncompressed and encoded in utf-8 or
-    iso-8859-1.
-
-    Args:
-        target_file (str): path to the file
-
-    Returns:
-        header_txt (io.TextIOWrapper): text object
+    Read a BAM/CRAM header from a plain-text or gzip-compressed file.
+    Supports UTF-8 and ISO-8859-1 encodings.
     """
     try:
-        if os.path.isfile(target_file):
-            with open(target_file, "r") as header_txt:
-                get_info_txt(header_txt, md5, assembly)
-        else:
+        if not os.path.isfile(target_file):
             raise NoFileException()
-    except UnicodeError:
-        with open(target_file, "r", encoding="iso-8859-1") as header_txt:
-            get_info_txt(header_txt, md5, assembly)
-    except OSError:
+
+        # Detect gzip from its magic bytes
+        with open(target_file, "rb") as f:
+            is_gzip = f.read(2) == b"\x1f\x8b"
+
+        opener = gzip.open if is_gzip else open
+
         try:
-            with gzip.open(target_file, "rt") as header_txt:
+            with opener(target_file, "rt", encoding="utf-8") as header_txt:
                 get_info_txt(header_txt, md5, assembly)
-        except UnicodeError:
-            with gzip.open(target_file, "rt", encoding="iso-8859-1") as header_txt:
+        except UnicodeDecodeError:
+            with opener(target_file, "rt", encoding="iso-8859-1") as header_txt:
                 get_info_txt(header_txt, md5, assembly)
+
     except NoFileException:
-        console.print(f"[bold]File:[/bold] {target_file} \n[bold][red]Error:[/bold][red] The path provided is not "
-                      f"found or you are using the incorrect --type option.")
+        console.print(
+            f"[bold]File:[/bold] {target_file}\n"
+            "[bold red]Error:[/bold red] File not found."
+        )
+
+    except (OSError, EOFError) as e:
+        console.print(
+            f"[bold red]Error reading file:[/bold red] {e}"
+        )
+
     except Exception as e:
         print("Unexpected error:\n", e)

{refgendetector-3.0.5 → refgendetector-3.0.7}/src/refgenDetector/download_reference.py

@@ -57,6 +57,7 @@ def get_paths():
 
 def is_already_setup(dst: Path) -> bool:
     """Return True if at least one .msgpack file exists in dst."""
+    print(dst)
     if not dst.exists():
         return False
     return any(dst.glob("*.msgpack"))

refgendetector-3.0.7/src/refgenDetector/msgpacks/create-plots.py

@@ -0,0 +1,243 @@
+"""
+count_and_plot.py
+-----------------
+Reads all msgpack files (one per assembly × chromosome) and produces:
+  1. A stacked bar chart  – positions per chromosome, coloured by assembly
+  2. A donut / bar summary – total positions per assembly
+  3. A heatmap             – positions (chromosome × assembly)
+
+Usage:
+    python count_and_plot.py --dir /path/to/msgpack/folder --out /path/to/output/dir
+
+Defaults to the current directory for both --dir and --out.
+"""
+
+import argparse
+import os
+import re
+import collections
+import msgpack
+import matplotlib
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+import numpy as np
+
+# ── helpers ──────────────────────────────────────────────────────────────────
+
+ASSEMBLIES = ["hg18", "GRCh37", "GRCh38", "T2T"]
+
+# Natural sort order for chromosomes: 1-22, X, Y
+def _chr_sort_key(c):
+    c = c.replace("chr", "")
+    if c == "X":  return (23, 0)
+    if c == "Y":  return (24, 0)
+    try:          return (int(c), 0)
+    except:       return (99, 0)
+
+ASSEMBLY_COLORS = {
+    "hg18":   "#4C72B0",
+    "GRCh37": "#DD8452",
+    "GRCh38": "#55A868",
+    "T2T":    "#C44E52",
+}
+
+def load_counts(msgpack_dir: str) -> dict:
+    """
+    Returns counts[assembly][chrom] = int  (number of distinguishing positions).
+    """
+    counts = {asm: {} for asm in ASSEMBLIES}
+    pattern = re.compile(r"^(hg18|GRCh37|GRCh38|T2T)-(chr[0-9XY]+)\.msgpack$")
+
+    for fname in sorted(os.listdir(msgpack_dir)):
+        m = pattern.match(fname)
+        if not m:
+            continue
+        assembly, chrom = m.group(1), m.group(2)
+        fpath = os.path.join(msgpack_dir, fname)
+        with open(fpath, "rb") as fh:
+            data = msgpack.unpack(fh, raw=False, strict_map_key=False)
+        counts[assembly][chrom] = len(data)
+
+    return counts
+
+
+# ── plot 1 : stacked bar per chromosome ──────────────────────────────────────
+
+def plot_stacked_bar(counts, out_path):
+    # collect all chromosomes present
+    all_chroms = sorted(
+        {c for asm in counts.values() for c in asm.keys()},
+        key=_chr_sort_key
+    )
+
+    x = np.arange(len(all_chroms))
+    width = 0.55
+
+    fig, ax = plt.subplots(figsize=(14, 5))
+    bottoms = np.zeros(len(all_chroms))
+
+    for asm in ASSEMBLIES:
+        vals = np.array([counts[asm].get(c, 0) for c in all_chroms])
+        ax.bar(x, vals, width, bottom=bottoms,
+               label=asm, color=ASSEMBLY_COLORS[asm], alpha=0.88)
+        bottoms += vals
+
+    ax.set_xticks(x)
+    ax.set_xticklabels(all_chroms, rotation=45, ha="right", fontsize=9)
+    ax.yaxis.set_major_formatter(mticker.FuncFormatter(lambda v, _: f"{int(v):,}"))
+    ax.set_ylabel("Distinguishing positions", fontsize=11)
+    ax.set_title("Distinguishing positions per chromosome\n(stacked by assembly)", fontsize=13)
+    ax.legend(title="Assembly", framealpha=0.9)
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+    print(f"  Saved: {out_path}")
+
+
+# ── plot 2 : total per assembly (horizontal bar) ──────────────────────────────
+
+def plot_totals(counts, out_path):
+    totals = {asm: sum(counts[asm].values()) for asm in ASSEMBLIES}
+    asms   = list(totals.keys())
+    vals   = [totals[a] for a in asms]
+    colors = [ASSEMBLY_COLORS[a] for a in asms]
+
+    fig, ax = plt.subplots(figsize=(7, 3.5))
+    bars = ax.barh(asms, vals, color=colors, height=0.5, alpha=0.9)
+    ax.bar_label(bars, labels=[f"{v:,}" for v in vals],
+                 padding=6, fontsize=10)
+    ax.xaxis.set_major_formatter(mticker.FuncFormatter(lambda v, _: f"{int(v):,}"))
+    ax.set_xlabel("Total distinguishing positions", fontsize=11)
+    ax.set_title("Total distinguishing positions per assembly", fontsize=13)
+    ax.spines[["top", "right"]].set_visible(False)
+    max_val = max(vals) if vals else 1
+    ax.set_xlim(0, max_val * 1.15)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+    print(f"  Saved: {out_path}")
+
+
+# ── plot 3 : heatmap (chromosome × assembly) ─────────────────────────────────
+
+def plot_heatmap(counts, out_path):
+    all_chroms = sorted(
+        {c for asm in counts.values() for c in asm.keys()},
+        key=_chr_sort_key
+    )
+
+    matrix = np.array(
+        [[counts[asm].get(c, 0) for asm in ASSEMBLIES] for c in all_chroms],
+        dtype=float
+    )
+
+    fig, ax = plt.subplots(figsize=(6, 9))
+    im = ax.imshow(matrix, aspect="auto", cmap="YlOrRd")
+
+    ax.set_xticks(range(len(ASSEMBLIES)))
+    ax.set_xticklabels(ASSEMBLIES, fontsize=10)
+    ax.set_yticks(range(len(all_chroms)))
+    ax.set_yticklabels(all_chroms, fontsize=8)
+    ax.set_title("Distinguishing positions\n(chromosome × assembly)", fontsize=12)
+
+    cb = fig.colorbar(im, ax=ax, shrink=0.6, pad=0.02)
+    cb.set_label("# positions", fontsize=9)
+    cb.formatter = mticker.FuncFormatter(lambda v, _: f"{int(v):,}")
+    cb.update_ticks()
+
+    # annotate cells if the matrix is not too large
+    if matrix.size <= 200:
+        for i in range(len(all_chroms)):
+            for j in range(len(ASSEMBLIES)):
+                v = int(matrix[i, j])
+                ax.text(j, i, f"{v:,}", ha="center", va="center",
+                        fontsize=6.5, color="black" if v < matrix.max() * 0.7 else "white")
+
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+    print(f"  Saved: {out_path}")
+
+
+# ── plot 4 : grouped bar (per-chrom, side-by-side assemblies) ─────────────────
+
+def plot_grouped_bar(counts, out_path):
+    all_chroms = sorted(
+        {c for asm in counts.values() for c in asm.keys()},
+        key=_chr_sort_key
+    )
+
+    n_chr = len(all_chroms)
+    n_asm = len(ASSEMBLIES)
+    group_w = 0.8
+    bar_w = group_w / n_asm
+    x = np.arange(n_chr)
+
+    fig, ax = plt.subplots(figsize=(16, 5))
+    for i, asm in enumerate(ASSEMBLIES):
+        offsets = x - group_w / 2 + bar_w * (i + 0.5)
+        vals = [counts[asm].get(c, 0) for c in all_chroms]
+        ax.bar(offsets, vals, width=bar_w * 0.92,
+               label=asm, color=ASSEMBLY_COLORS[asm], alpha=0.88)
+
+    ax.set_xticks(x)
+    ax.set_xticklabels(all_chroms, rotation=45, ha="right", fontsize=9)
+    ax.yaxis.set_major_formatter(mticker.FuncFormatter(lambda v, _: f"{int(v):,}"))
+    ax.set_ylabel("Distinguishing positions", fontsize=11)
+    ax.set_title("Distinguishing positions per chromosome per assembly", fontsize=13)
+    ax.legend(title="Assembly", framealpha=0.9)
+    ax.spines[["top", "right"]].set_visible(False)
+    fig.tight_layout()
+    fig.savefig(out_path, dpi=150)
+    plt.close(fig)
+    print(f"  Saved: {out_path}")
+
+
+# ── main ──────────────────────────────────────────────────────────────────────
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--dir", default=".", help="Folder containing the msgpack files")
+    parser.add_argument("--out", default=".", help="Output folder for PNG plots")
+    args = parser.parse_args()
+
+    os.makedirs(args.out, exist_ok=True)
+
+    print(f"Loading msgpack files from: {os.path.abspath(args.dir)}")
+    counts = load_counts(args.dir)
+
+    # Print a summary table
+    all_chroms = sorted(
+        {c for asm in counts.values() for c in asm.keys()},
+        key=_chr_sort_key
+    )
+    print(f"\n{'Chrom':<10}", end="")
+    for asm in ASSEMBLIES:
+        print(f"{asm:>12}", end="")
+    print()
+    print("-" * (10 + 12 * len(ASSEMBLIES)))
+    for chrom in all_chroms:
+        print(f"{chrom:<10}", end="")
+        for asm in ASSEMBLIES:
+            print(f"{counts[asm].get(chrom, 0):>12,}", end="")
+        print()
+    print("-" * (10 + 12 * len(ASSEMBLIES)))
+    print(f"{'TOTAL':<10}", end="")
+    for asm in ASSEMBLIES:
+        print(f"{sum(counts[asm].values()):>12,}", end="")
+    print("\n")
+
+    print("Generating plots...")
+    plot_stacked_bar(counts, os.path.join(args.out, "01_stacked_bar_per_chrom.png"))
+    plot_totals     (counts, os.path.join(args.out, "02_total_per_assembly.png"))
+    plot_heatmap    (counts, os.path.join(args.out, "03_heatmap_chrom_x_assembly.png"))
+    plot_grouped_bar(counts, os.path.join(args.out, "04_grouped_bar_per_chrom.png"))
+
+    print("\nDone.")
+
+
+if __name__ == "__main__":
+    main()

refgendetector-3.0.7/src/refgenDetector/msgpacks/create-plots2.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+
+"""
+count_and_plot.py
+-----------------
+Reads msgpack files named as:
+
+    hg18-chr1.msgpack
+    GRCh37-chr1.msgpack
+    GRCh38-chr1.msgpack
+    T2T-chr1.msgpack
+
+and creates one plot showing the number of distinguishing variants per
+chromosome. Because all assemblies are expected to contain the same number
+of variants, only one bar is shown per chromosome.
+
+Usage:
+    python count_and_plot.py \
+        --dir /path/to/msgpack/folder \
+        --out /path/to/output/dir
+
+Defaults to the current directory for both --dir and --out.
+"""
+
+import argparse
+import os
+import re
+
+import msgpack
+import matplotlib
+
+matplotlib.use("Agg")
+
+import matplotlib.pyplot as plt
+import matplotlib.ticker as mticker
+import numpy as np
+
+
+ASSEMBLIES = ["hg18", "GRCh37", "GRCh38", "T2T"]
+
+
+def chromosome_sort_key(chromosome):
+    """Natural chromosome order: chr1-chr22, chrX, chrY."""
+    chromosome = chromosome.removeprefix("chr")
+
+    if chromosome == "X":
+        return 23
+    if chromosome == "Y":
+        return 24
+
+    try:
+        return int(chromosome)
+    except ValueError:
+        return 99
+
+
+def load_counts(msgpack_dir):
+    """
+    Return:
+
+        counts[chromosome][assembly] = number of variants
+    """
+    counts = {}
+
+    pattern = re.compile(
+        r"^(hg18|GRCh37|GRCh38|T2T)-(chr[0-9XY]+)\.msgpack$"
+    )
+
+    for filename in sorted(os.listdir(msgpack_dir)):
+        match = pattern.match(filename)
+
+        if not match:
+            continue
+
+        assembly, chromosome = match.groups()
+        file_path = os.path.join(msgpack_dir, filename)
+
+        with open(file_path, "rb") as file_handle:
+            data = msgpack.unpack(
+                file_handle,
+                raw=False,
+                strict_map_key=False,
+            )
+
+        counts.setdefault(chromosome, {})
+        counts[chromosome][assembly] = len(data)
+
+    if not counts:
+        raise RuntimeError(
+            f"No matching msgpack files found in: {msgpack_dir}"
+        )
+
+    return counts
+
+
+def get_chromosome_counts(counts):
+    """
+    Return one count per chromosome.
+
+    All available assemblies must have the same count for a chromosome.
+    """
+    chromosome_counts = {}
+
+    for chromosome, assembly_counts in counts.items():
+        unique_counts = set(assembly_counts.values())
+
+        if len(unique_counts) != 1:
+            details = ", ".join(
+                f"{assembly}={count:,}"
+                for assembly, count in sorted(assembly_counts.items())
+            )
+
+            raise ValueError(
+                f"Assemblies have different counts for {chromosome}: "
+                f"{details}"
+            )
+
+        chromosome_counts[chromosome] = next(iter(unique_counts))
+
+    return chromosome_counts
+
+
+def plot_variants_per_chromosome(chromosome_counts, output_path):
+    chromosomes = sorted(
+        chromosome_counts,
+        key=chromosome_sort_key,
+    )
+
+    values = [chromosome_counts[chromosome] for chromosome in chromosomes]
+    x_positions = np.arange(len(chromosomes))
+
+    figure, axis = plt.subplots(figsize=(14, 5))
+
+    axis.bar(
+        x_positions,
+        values,
+        width=0.7,
+        alpha=0.9,
+    )
+
+    axis.set_xticks(x_positions)
+    axis.set_xticklabels(
+        chromosomes,
+        rotation=45,
+        ha="right",
+        fontsize=9,
+    )
+
+    axis.yaxis.set_major_formatter(
+        mticker.FuncFormatter(lambda value, _: f"{int(value):,}")
+    )
+
+    axis.set_xlabel("Chromosome", fontsize=11)
+    axis.set_ylabel("Number of distinguishing variants", fontsize=11)
+    axis.set_title(
+        "Number of distinguishing variants per chromosome",
+        fontsize=13,
+    )
+
+    axis.spines[["top", "right"]].set_visible(False)
+
+    figure.tight_layout()
+    figure.savefig(output_path, dpi=150)
+    plt.close(figure)
+
+    print(f"Saved: {output_path}")
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument(
+        "--dir",
+        default=".",
+        help="Folder containing the msgpack files",
+    )
+
+    parser.add_argument(
+        "--out",
+        default=".",
+        help="Output folder for the PNG plot",
+    )
+
+    args = parser.parse_args()
+
+    os.makedirs(args.out, exist_ok=True)
+
+    print(f"Loading msgpack files from: {os.path.abspath(args.dir)}")
+
+    counts = load_counts(args.dir)
+    chromosome_counts = get_chromosome_counts(counts)
+
+    print(f"\n{'Chromosome':<12}{'Variants':>15}")
+    print("-" * 27)
+
+    for chromosome in sorted(
+        chromosome_counts,
+        key=chromosome_sort_key,
+    ):
+        print(
+            f"{chromosome:<12}"
+            f"{chromosome_counts[chromosome]:>15,}"
+        )
+
+    output_path = os.path.join(
+        args.out,
+        "variants_per_chromosome.png",
+    )
+
+    plot_variants_per_chromosome(
+        chromosome_counts,
+        output_path,
+    )
+
+
+if __name__ == "__main__":
+    main()

refgendetector-3.0.7/src/refgenDetector/msgpacks/open_file.py

@@ -0,0 +1,15 @@
+import msgpack
+
+path = "/home/mireia/GitHub/refgenDetector/src/refgenDetector/msgpacks/GRCh37-chr1.msgpack"
+
+with open(path, "rb") as f:
+    unpacker = msgpack.Unpacker(
+        f,
+        raw=False,
+        strict_map_key=False   # <-- THIS fixes your error
+    )
+
+    for i, obj in enumerate(unpacker):
+        print(obj)
+        if i == 10:
+            break

{refgendetector-3.0.5 → refgendetector-3.0.7}/src/refgenDetector/refgenDetector_main.py

@@ -8,7 +8,7 @@ __maintainer__ = "Mireia Marin Ginestar"
 __email__ = "mireia.marin@crg.eu"
 __status__ = "Developement"
 
-version = "3.0.5"
+version = "3.0.6"
 
 import os
 import sys

{refgendetector-3.0.5 → refgendetector-3.0.7}/src/refgenDetector/variant_files.py

@@ -24,6 +24,7 @@ MSGPACK_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "msgpacks
 final_results = []
 console = Console(highlight=False)
 _msgpack_cache = {}
+_current_chr = None
 
 def gather_and_sum(lists):
     """
@@ -54,13 +55,18 @@ def get_matches(snps_dict, chr_):
         A list with the number of matches for each version, which is used to infer the reference genome version.
     """
     
-    global _msgpack_cache
+    global _msgpack_cache, _current_chr
     start = time.time()
 
     genome_versions = ["hg18", "GRCh37", "GRCh38", "T2T"]
     matches = []
 
-    # Extract arrays once
+    # If we've moved on to a different chromosome, drop the previous
+    # chromosome's msgpacks before loading the new ones.
+    if chr_ != _current_chr:
+        _msgpack_cache.clear()
+        _current_chr = chr_
+
     positions = np.array(list(snps_dict.keys()), dtype=np.int64)
     nucleotides = np.array(list(snps_dict.values()))
 
@@ -76,16 +82,15 @@ def get_matches(snps_dict, chr_):
 
         ref_dict = _msgpack_cache[cache_key]
 
-        # Vectorized: look up all positions at once, compare arrays
         ref_nucs = np.array([ref_dict.get(p, None) for p in positions])
         match_count = int(np.sum(ref_nucs == nucleotides))
 
         matches.append([version_name, match_count])
 
-    #console.print("Getting matches. Took:", time.time() - start, "s")
     return matches
 
 
+
 def trimming_indels(content, ref):
     """
     If a row is longer than one position it is deleted, deleting this way any indels