From d7a78d7da583eefbea942b434a1a65def864ca87 Mon Sep 17 00:00:00 2001
From: Mario Kanetscheider <m.kanne@ymail.com>
Date: Fri, 9 Aug 2024 16:35:43 +0200
Subject: [PATCH 1/8] added file with logoplot calculation function and import
 function name

---
 src/scirpy/pl/__init__.py   |   1 +
 src/scirpy/pl/_logoplots.py | 163 ++++++++++++++++++++++++++++++++++++
 2 files changed, 164 insertions(+)
 create mode 100644 src/scirpy/pl/_logoplots.py

diff --git a/src/scirpy/pl/__init__.py b/src/scirpy/pl/__init__.py
index 1559e7d3e..ee3920c69 100644
--- a/src/scirpy/pl/__init__.py
+++ b/src/scirpy/pl/__init__.py
@@ -8,4 +8,5 @@
 from ._repertoire_overlap import repertoire_overlap
 from ._spectratype import spectratype
 from ._vdj_usage import vdj_usage
+from ._logoplots import logoplot_cdr3_motif
 from .base import embedding
diff --git a/src/scirpy/pl/_logoplots.py b/src/scirpy/pl/_logoplots.py
new file mode 100644
index 000000000..a94026613
--- /dev/null
+++ b/src/scirpy/pl/_logoplots.py
@@ -0,0 +1,163 @@
+from scirpy.util import DataHandler
+from typing import Callable, Literal, Union
+from collections.abc import Sequence
+from scirpy.get import obs_context
+from scirpy.get import airr as get_airr
+
+import numpy as np
+import pandas as pd
+
+import palmotif as palm
+from IPython.display import SVG
+
+@DataHandler.inject_param_docs()
+def logoplot_cdr3_motif(
+    adata: DataHandler.TYPE,
+    chains: Union[
+    Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
+    Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
+    ] = "VDJ_1",
+    airr_mod="airr",
+    airr_key="airr",
+    chain_idx_key="chain_indices",
+    cdr3_col: str = "junction_aa",
+    *,
+    by: Sequence[Literal["gene_segment", "clonotype", "length"]] = "length",
+    target_col: Union[None, str] = None,
+    gene_annotation: Union[None, list] = None,
+    clonotype_id: Union[None, list] = None,
+    clonotype_key: Union[None, str] = None,
+    cdr_len: int,
+    plot: bool = True,
+    color_scheme: Sequence[Literal["nucleotide", "base_pairing", "hydrophobicity", "chemistry", "charge", "taylor",
+                      "logojs", "shapely"]] = "taylor"
+):
+    """
+    A user friendly wrapper function for the palmotif python package.
+    Enables the analysis of potential amino acid motifs by displaying logo plots.
+
+    Parameters
+    ----------
+    {adata}
+    chains
+        One or multiple chains from which to use CDR3 sequences
+    {airr_mod}
+    {airr_key}
+    {chain_idx_key}
+    cdr3_col
+        key inside awkward array to retrieve junction information (aa)
+    by
+        Three options for convenient customisation:
+        length -- compares all sequences that match the selected length
+        clonotype -- compares all sequences that match the selected clonotype cluster(s)
+            -> need to define `clonotype_id` and `clonotype_key`
+        gene_segment -- compares all sequences that match the selected gene segment(s)
+            -> need to define `gene_annotation` and `target_col`
+    target_col
+        key inside awkward array to retrieve gene annotation information e.g. v_call, j_call
+    gene_annotation
+        a list of predefined genes deemed interesting to include in a logoplot
+    clonotype_id
+        predefined clonotype cluster id to investigate as a logoplot
+    clonotype_key
+        key inside .obs column under which clonotype cluster ids are stored
+    cdr_len
+        Specify one exact sequence length t compute sequence motifs
+    plot
+        defaults to true to return a SVG logoplot for direct investigation
+        set to false to retrieve the raw sequence motif for customised use
+    color_scheme
+        different color schemes used by palmotif. see https://github.com/agartland/palmotif/blob/master/palmotif/aacolors.py for more details
+    
+    Returns
+    ----------
+    Depending on `plot` either returns a SVG object or the calculated sequence motif as a pd.DataFrame
+    """
+    params = DataHandler(adata, airr_mod, airr_key, chain_idx_key)
+
+    if by is "length":
+        
+        airr_df = get_airr(params, [cdr3_col], chains)
+        if type(chains) is list:
+            if len(chains) > 2:
+                raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
+
+            else:
+                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][chains[0] + "_" + cdr3_col].to_list()
+                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][chains[1] + "_" + cdr3_col].to_list()
+                motif = palm.compute_motif(cdr3_list)
+        else:
+            motif = palm.compute_motif(
+                airr_df[airr_df[chains + "_" + cdr3_col].str.len() == cdr_len][chains + "_" + cdr3_col].to_list()
+                )
+            
+        if plot:
+            return SVG(palm.svg_logo(motif, return_str = False, color_scheme=color_scheme))
+        else:
+            return motif
+
+
+    if by is "gene_segment":
+        if target_col is None or gene_annotation is None:
+            raise Exception("Please specify where the gene information is stored (`target_col`) and which genes to include (`gene_annotation`) as a list")
+        if type(gene_annotation) is not list:
+            gene_annotation = list(gene_annotation.split(" "))
+
+        airr_df = get_airr(params, [cdr3_col, target_col], chains)
+        if type(chains) is list:
+            if len(chains) > 2:
+                raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
+
+            cdr3_list = airr_df[(airr_df[chains[0] + "_" + target_col].isin(gene_annotation)) &
+            (airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len)][chains[0] + "_" + cdr3_col].to_list()
+            cdr3_list += airr_df[(airr_df[chains[1] + "_" + target_col].isin(gene_annotation)) &
+            (airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len)][chains[1] + "_" + cdr3_col].to_list()
+            motif = palm.compute_motif(cdr3_list)
+            
+        else:
+            motif = palm.compute_motif(
+            airr_df[(airr_df[chains + "_" + target_col].isin(gene_annotation)) &
+            (airr_df[chains + "_" + cdr3_col].str.len() == cdr_len)][chains + "_" + cdr3_col].to_list()
+        )
+
+        if plot:
+            return SVG(palm.svg_logo(motif, return_str = False, color_scheme=color_scheme))
+        else:
+            return motif
+    
+    if by is "clonotype":
+        if clonotype_id is None or clonotype_key is None:
+            raise Exception("Please select desired clonotype cluster and the name of the column where this information is stored!")
+        
+        if type(clonotype_id) is not list:
+            clonotype_id = list(clonotype_id.split(" "))
+
+        if type(chains) is list:
+            airr_df = get_airr(params, [cdr3_col], chains)
+        else:
+            airr_df = get_airr(params, [cdr3_col], [chains])
+        airr_df = pd.concat([airr_df, params.get_obs(clonotype_key)])
+        airr_df = airr_df.loc[params.get_obs(clonotype_key).isin(clonotype_id)]
+
+   
+
+        if type(chains) is list:
+            if len(chains) > 2:
+                raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
+
+            else:
+                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][chains[0] + "_" + cdr3_col].to_list()
+                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][chains[1] + "_" + cdr3_col].to_list()
+                motif = palm.compute_motif(cdr3_list)
+        else:
+            motif = palm.compute_motif(
+                airr_df[airr_df[chains + "_" + cdr3_col].str.len() == cdr_len][chains + "_" + cdr3_col].to_list()
+                )
+            
+        if plot:
+            return SVG(palm.svg_logo(motif, return_str = False, color_scheme=color_scheme))
+        else:
+            return motif
+
+    else:
+        raise Exception("Invalid input for parameter `by`!")
\ No newline at end of file

From 2e9cde01c882e3401de5f7372cfb7b5e77b99caa Mon Sep 17 00:00:00 2001
From: Mario Kanetscheider <m.kanne@ymail.com>
Date: Fri, 9 Aug 2024 16:36:20 +0200
Subject: [PATCH 2/8] added palmotif and IPython asdependencies

---
 pyproject.toml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/pyproject.toml b/pyproject.toml
index c27ca6527..2e60a5c30 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -42,6 +42,8 @@ dependencies = [
     'pooch>=1.7.0',
     'pycairo>=1.20; sys_platform == "win32"',
     'joblib>=1.3.1',
+    'palmotif',
+    'IPython',
 ]
 
 [project.optional-dependencies]

From 8c9da93e7ff9a3b813ea416da360251b1cd295f4 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 9 Aug 2024 14:40:07 +0000
Subject: [PATCH 3/8] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/scirpy/pl/__init__.py   |   2 +-
 src/scirpy/pl/_logoplots.py | 102 ++++++++++++++++++++----------------
 2 files changed, 59 insertions(+), 45 deletions(-)

diff --git a/src/scirpy/pl/__init__.py b/src/scirpy/pl/__init__.py
index ee3920c69..e7135fa4d 100644
--- a/src/scirpy/pl/__init__.py
+++ b/src/scirpy/pl/__init__.py
@@ -5,8 +5,8 @@
 from ._clonotypes import COLORMAP_EDGES, clonotype_network
 from ._diversity import alpha_diversity
 from ._group_abundance import group_abundance
+from ._logoplots import logoplot_cdr3_motif
 from ._repertoire_overlap import repertoire_overlap
 from ._spectratype import spectratype
 from ._vdj_usage import vdj_usage
-from ._logoplots import logoplot_cdr3_motif
 from .base import embedding
diff --git a/src/scirpy/pl/_logoplots.py b/src/scirpy/pl/_logoplots.py
index a94026613..91df93ed5 100644
--- a/src/scirpy/pl/_logoplots.py
+++ b/src/scirpy/pl/_logoplots.py
@@ -1,21 +1,20 @@
-from scirpy.util import DataHandler
-from typing import Callable, Literal, Union
 from collections.abc import Sequence
-from scirpy.get import obs_context
-from scirpy.get import airr as get_airr
-
-import numpy as np
-import pandas as pd
+from typing import Literal, Union
 
 import palmotif as palm
+import pandas as pd
 from IPython.display import SVG
 
+from scirpy.get import airr as get_airr
+from scirpy.util import DataHandler
+
+
 @DataHandler.inject_param_docs()
 def logoplot_cdr3_motif(
     adata: DataHandler.TYPE,
     chains: Union[
-    Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
-    Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
+        Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
+        Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
     ] = "VDJ_1",
     airr_mod="airr",
     airr_key="airr",
@@ -29,8 +28,9 @@ def logoplot_cdr3_motif(
     clonotype_key: Union[None, str] = None,
     cdr_len: int,
     plot: bool = True,
-    color_scheme: Sequence[Literal["nucleotide", "base_pairing", "hydrophobicity", "chemistry", "charge", "taylor",
-                      "logojs", "shapely"]] = "taylor"
+    color_scheme: Sequence[
+        Literal["nucleotide", "base_pairing", "hydrophobicity", "chemistry", "charge", "taylor", "logojs", "shapely"]
+    ] = "taylor",
 ):
     """
     A user friendly wrapper function for the palmotif python package.
@@ -68,38 +68,42 @@ def logoplot_cdr3_motif(
         set to false to retrieve the raw sequence motif for customised use
     color_scheme
         different color schemes used by palmotif. see https://github.com/agartland/palmotif/blob/master/palmotif/aacolors.py for more details
-    
+
     Returns
-    ----------
+    -------
     Depending on `plot` either returns a SVG object or the calculated sequence motif as a pd.DataFrame
     """
     params = DataHandler(adata, airr_mod, airr_key, chain_idx_key)
 
-    if by is "length":
-        
+    if by == "length":
         airr_df = get_airr(params, [cdr3_col], chains)
         if type(chains) is list:
             if len(chains) > 2:
                 raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
 
             else:
-                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][chains[0] + "_" + cdr3_col].to_list()
-                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][chains[1] + "_" + cdr3_col].to_list()
+                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][
+                    chains[0] + "_" + cdr3_col
+                ].to_list()
+                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][
+                    chains[1] + "_" + cdr3_col
+                ].to_list()
                 motif = palm.compute_motif(cdr3_list)
         else:
             motif = palm.compute_motif(
                 airr_df[airr_df[chains + "_" + cdr3_col].str.len() == cdr_len][chains + "_" + cdr3_col].to_list()
-                )
-            
+            )
+
         if plot:
-            return SVG(palm.svg_logo(motif, return_str = False, color_scheme=color_scheme))
+            return SVG(palm.svg_logo(motif, return_str=False, color_scheme=color_scheme))
         else:
             return motif
 
-
-    if by is "gene_segment":
+    if by == "gene_segment":
         if target_col is None or gene_annotation is None:
-            raise Exception("Please specify where the gene information is stored (`target_col`) and which genes to include (`gene_annotation`) as a list")
+            raise Exception(
+                "Please specify where the gene information is stored (`target_col`) and which genes to include (`gene_annotation`) as a list"
+            )
         if type(gene_annotation) is not list:
             gene_annotation = list(gene_annotation.split(" "))
 
@@ -108,27 +112,35 @@ def logoplot_cdr3_motif(
             if len(chains) > 2:
                 raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
 
-            cdr3_list = airr_df[(airr_df[chains[0] + "_" + target_col].isin(gene_annotation)) &
-            (airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len)][chains[0] + "_" + cdr3_col].to_list()
-            cdr3_list += airr_df[(airr_df[chains[1] + "_" + target_col].isin(gene_annotation)) &
-            (airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len)][chains[1] + "_" + cdr3_col].to_list()
+            cdr3_list = airr_df[
+                (airr_df[chains[0] + "_" + target_col].isin(gene_annotation))
+                & (airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len)
+            ][chains[0] + "_" + cdr3_col].to_list()
+            cdr3_list += airr_df[
+                (airr_df[chains[1] + "_" + target_col].isin(gene_annotation))
+                & (airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len)
+            ][chains[1] + "_" + cdr3_col].to_list()
             motif = palm.compute_motif(cdr3_list)
-            
+
         else:
             motif = palm.compute_motif(
-            airr_df[(airr_df[chains + "_" + target_col].isin(gene_annotation)) &
-            (airr_df[chains + "_" + cdr3_col].str.len() == cdr_len)][chains + "_" + cdr3_col].to_list()
-        )
+                airr_df[
+                    (airr_df[chains + "_" + target_col].isin(gene_annotation))
+                    & (airr_df[chains + "_" + cdr3_col].str.len() == cdr_len)
+                ][chains + "_" + cdr3_col].to_list()
+            )
 
         if plot:
-            return SVG(palm.svg_logo(motif, return_str = False, color_scheme=color_scheme))
+            return SVG(palm.svg_logo(motif, return_str=False, color_scheme=color_scheme))
         else:
             return motif
-    
-    if by is "clonotype":
+
+    if by == "clonotype":
         if clonotype_id is None or clonotype_key is None:
-            raise Exception("Please select desired clonotype cluster and the name of the column where this information is stored!")
-        
+            raise Exception(
+                "Please select desired clonotype cluster and the name of the column where this information is stored!"
+            )
+
         if type(clonotype_id) is not list:
             clonotype_id = list(clonotype_id.split(" "))
 
@@ -139,25 +151,27 @@ def logoplot_cdr3_motif(
         airr_df = pd.concat([airr_df, params.get_obs(clonotype_key)])
         airr_df = airr_df.loc[params.get_obs(clonotype_key).isin(clonotype_id)]
 
-   
-
         if type(chains) is list:
             if len(chains) > 2:
                 raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
 
             else:
-                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][chains[0] + "_" + cdr3_col].to_list()
-                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][chains[1] + "_" + cdr3_col].to_list()
+                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][
+                    chains[0] + "_" + cdr3_col
+                ].to_list()
+                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][
+                    chains[1] + "_" + cdr3_col
+                ].to_list()
                 motif = palm.compute_motif(cdr3_list)
         else:
             motif = palm.compute_motif(
                 airr_df[airr_df[chains + "_" + cdr3_col].str.len() == cdr_len][chains + "_" + cdr3_col].to_list()
-                )
-            
+            )
+
         if plot:
-            return SVG(palm.svg_logo(motif, return_str = False, color_scheme=color_scheme))
+            return SVG(palm.svg_logo(motif, return_str=False, color_scheme=color_scheme))
         else:
             return motif
 
     else:
-        raise Exception("Invalid input for parameter `by`!")
\ No newline at end of file
+        raise Exception("Invalid input for parameter `by`!")

From e21db85c784390483151774d4fce97131b9f22dc Mon Sep 17 00:00:00 2001
From: Mario Kanetscheider <m.kanne@ymail.com>
Date: Mon, 19 Aug 2024 12:53:24 +0200
Subject: [PATCH 4/8] Restructured logoplot function to use logomaker instead
 of palmotif; Removed AnnData filter functionality

---
 .conda/meta.yaml            |   1 +
 docs/api.rst                |   2 +-
 pyproject.toml              |   3 +-
 src/scirpy/pl/_logoplots.py | 217 ++++++++++++------------------------
 4 files changed, 72 insertions(+), 151 deletions(-)

diff --git a/.conda/meta.yaml b/.conda/meta.yaml
index da8808a92..ad1fc05dc 100644
--- a/.conda/meta.yaml
+++ b/.conda/meta.yaml
@@ -41,6 +41,7 @@ requirements:
     - numba >=0.41.0
     - pooch >=1.7.0
     - joblib >=1.3.1
+    - logomaker
 
 test:
   source_files:
diff --git a/docs/api.rst b/docs/api.rst
index 1c4a41282..b58545a3e 100644
--- a/docs/api.rst
+++ b/docs/api.rst
@@ -204,7 +204,7 @@ when calling the plotting function or need to be precomputed and stored in
    pl.clonotype_modularity
    pl.clonotype_network
    pl.clonotype_imbalance
-
+   pl.logoplot_cdr3_motif
 
 
 Base plotting functions: `pl.base`
diff --git a/pyproject.toml b/pyproject.toml
index 2e60a5c30..eab83b8f7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -42,8 +42,7 @@ dependencies = [
     'pooch>=1.7.0',
     'pycairo>=1.20; sys_platform == "win32"',
     'joblib>=1.3.1',
-    'palmotif',
-    'IPython',
+    'logomaker'
 ]
 
 [project.optional-dependencies]
diff --git a/src/scirpy/pl/_logoplots.py b/src/scirpy/pl/_logoplots.py
index 91df93ed5..018733b38 100644
--- a/src/scirpy/pl/_logoplots.py
+++ b/src/scirpy/pl/_logoplots.py
@@ -2,39 +2,33 @@
 from typing import Literal, Union
 
 import palmotif as palm
+from logomaker import alignment_to_matrix, Logo
 import pandas as pd
 from IPython.display import SVG
 
 from scirpy.get import airr as get_airr
 from scirpy.util import DataHandler
 
-
 @DataHandler.inject_param_docs()
-def logoplot_cdr3_motif(
-    adata: DataHandler.TYPE,
-    chains: Union[
-        Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
-        Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
-    ] = "VDJ_1",
-    airr_mod="airr",
-    airr_key="airr",
-    chain_idx_key="chain_indices",
-    cdr3_col: str = "junction_aa",
-    *,
-    by: Sequence[Literal["gene_segment", "clonotype", "length"]] = "length",
-    target_col: Union[None, str] = None,
-    gene_annotation: Union[None, list] = None,
-    clonotype_id: Union[None, list] = None,
-    clonotype_key: Union[None, str] = None,
-    cdr_len: int,
-    plot: bool = True,
-    color_scheme: Sequence[
-        Literal["nucleotide", "base_pairing", "hydrophobicity", "chemistry", "charge", "taylor", "logojs", "shapely"]
-    ] = "taylor",
-):
+def logoplot_cdr3_motif(adata: DataHandler.TYPE,
+                     chains: Union[
+                            Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
+                            Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
+                            ] = "VDJ_1",
+                    airr_mod="airr",
+                    airr_key="airr",
+                    chain_idx_key="chain_indices",
+                    cdr3_col: str = "junction_aa",
+                    to_type: Sequence[Literal["information", "counts", "probability", "weight"]] = "information",
+                    pseudocount: float = 0,
+                    background = None,
+                    center_weights: bool = False,
+                    plot_default = True,
+                    **kwargs):
     """
-    A user friendly wrapper function for the palmotif python package.
+    A user friendly wrapper function for the logomaker python package.
     Enables the analysis of potential amino acid motifs by displaying logo plots.
+    Subsetting of AnnData/MuData has to be performed manually beforehand (or while calling) and only cells with equal cdr3 sequence lengths are permitted.
 
     Parameters
     ----------
@@ -45,133 +39,60 @@ def logoplot_cdr3_motif(
     {airr_key}
     {chain_idx_key}
     cdr3_col
-        key inside awkward array to retrieve junction information (aa)
-    by
-        Three options for convenient customisation:
-        length -- compares all sequences that match the selected length
-        clonotype -- compares all sequences that match the selected clonotype cluster(s)
-            -> need to define `clonotype_id` and `clonotype_key`
-        gene_segment -- compares all sequences that match the selected gene segment(s)
-            -> need to define `gene_annotation` and `target_col`
-    target_col
-        key inside awkward array to retrieve gene annotation information e.g. v_call, j_call
-    gene_annotation
-        a list of predefined genes deemed interesting to include in a logoplot
-    clonotype_id
-        predefined clonotype cluster id to investigate as a logoplot
-    clonotype_key
-        key inside .obs column under which clonotype cluster ids are stored
-    cdr_len
-        Specify one exact sequence length t compute sequence motifs
-    plot
-        defaults to true to return a SVG logoplot for direct investigation
-        set to false to retrieve the raw sequence motif for customised use
-    color_scheme
-        different color schemes used by palmotif. see https://github.com/agartland/palmotif/blob/master/palmotif/aacolors.py for more details
+        Key inside awkward array to retrieve junction information (should be in aa)
+    to_type
+        Choose one of matrix types as defined by logomaker:
+        * `"information"`
+        * `"counts"`
+        * `"probability"`
+        * `"weight"` 
+    pseudocount
+        Pseudocount to use when converting from counts to probabilities
+    background
+        Background probabilities. Both arrays with the same length as ouput or df with same shape as ouput are permitted.
+    center_weights
+        Whether to subtract the mean of each row, but only if to_type == `weight`
+    plot_default
+        If true does some basic formatting for the user i.e:
+        * `"font_name"` = 'Arial Rounded MT Bold'
+        * `"color_scheme"` = 'chemistry'
+        * `"vpad"`= .05
+        * `"width"` = .9
+        And some additional styling. If false, the user needs to adapt`**kwargs` accordingly.
+    **kwargs
+        Additional arguments passed to logomaker.Logo() for comprehensive customization. For a full list of parameters please refer to logomaker documentation (https://logomaker.readthedocs.io/en/latest/implementation.html#logo-class)
 
     Returns
     -------
-    Depending on `plot` either returns a SVG object or the calculated sequence motif as a pd.DataFrame
+    Returns a object of class logomaker.Logo (see here for more information https://logomaker.readthedocs.io/en/latest/implementation.html#matrix-functions)
     """
+    
     params = DataHandler(adata, airr_mod, airr_key, chain_idx_key)
-
-    if by == "length":
-        airr_df = get_airr(params, [cdr3_col], chains)
-        if type(chains) is list:
-            if len(chains) > 2:
-                raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
-
-            else:
-                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][
-                    chains[0] + "_" + cdr3_col
-                ].to_list()
-                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][
-                    chains[1] + "_" + cdr3_col
-                ].to_list()
-                motif = palm.compute_motif(cdr3_list)
-        else:
-            motif = palm.compute_motif(
-                airr_df[airr_df[chains + "_" + cdr3_col].str.len() == cdr_len][chains + "_" + cdr3_col].to_list()
-            )
-
-        if plot:
-            return SVG(palm.svg_logo(motif, return_str=False, color_scheme=color_scheme))
-        else:
-            return motif
-
-    if by == "gene_segment":
-        if target_col is None or gene_annotation is None:
-            raise Exception(
-                "Please specify where the gene information is stored (`target_col`) and which genes to include (`gene_annotation`) as a list"
-            )
-        if type(gene_annotation) is not list:
-            gene_annotation = list(gene_annotation.split(" "))
-
-        airr_df = get_airr(params, [cdr3_col, target_col], chains)
-        if type(chains) is list:
-            if len(chains) > 2:
-                raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
-
-            cdr3_list = airr_df[
-                (airr_df[chains[0] + "_" + target_col].isin(gene_annotation))
-                & (airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len)
-            ][chains[0] + "_" + cdr3_col].to_list()
-            cdr3_list += airr_df[
-                (airr_df[chains[1] + "_" + target_col].isin(gene_annotation))
-                & (airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len)
-            ][chains[1] + "_" + cdr3_col].to_list()
-            motif = palm.compute_motif(cdr3_list)
-
-        else:
-            motif = palm.compute_motif(
-                airr_df[
-                    (airr_df[chains + "_" + target_col].isin(gene_annotation))
-                    & (airr_df[chains + "_" + cdr3_col].str.len() == cdr_len)
-                ][chains + "_" + cdr3_col].to_list()
-            )
-
-        if plot:
-            return SVG(palm.svg_logo(motif, return_str=False, color_scheme=color_scheme))
-        else:
-            return motif
-
-    if by == "clonotype":
-        if clonotype_id is None or clonotype_key is None:
-            raise Exception(
-                "Please select desired clonotype cluster and the name of the column where this information is stored!"
-            )
-
-        if type(clonotype_id) is not list:
-            clonotype_id = list(clonotype_id.split(" "))
-
-        if type(chains) is list:
-            airr_df = get_airr(params, [cdr3_col], chains)
-        else:
-            airr_df = get_airr(params, [cdr3_col], [chains])
-        airr_df = pd.concat([airr_df, params.get_obs(clonotype_key)])
-        airr_df = airr_df.loc[params.get_obs(clonotype_key).isin(clonotype_id)]
-
-        if type(chains) is list:
-            if len(chains) > 2:
-                raise Exception("Only two different chains are allowed e.g. VDJ_1 and VDJ_2")
-
-            else:
-                cdr3_list = airr_df[airr_df[chains[0] + "_" + cdr3_col].str.len() == cdr_len][
-                    chains[0] + "_" + cdr3_col
-                ].to_list()
-                cdr3_list += airr_df[airr_df[chains[1] + "_" + cdr3_col].str.len() == cdr_len][
-                    chains[1] + "_" + cdr3_col
-                ].to_list()
-                motif = palm.compute_motif(cdr3_list)
-        else:
-            motif = palm.compute_motif(
-                airr_df[airr_df[chains + "_" + cdr3_col].str.len() == cdr_len][chains + "_" + cdr3_col].to_list()
-            )
-
-        if plot:
-            return SVG(palm.svg_logo(motif, return_str=False, color_scheme=color_scheme))
-        else:
-            return motif
-
+    #make sure that sequences are prealigned i.e. they need to have the the same length
+    airr_df = get_airr(params, [cdr3_col], chains)
+    sequence_list = []
+    for chain in chains:
+        for sequence in airr_df[chain + "_" + cdr3_col]:
+            if sequence is not None:
+                sequence_list.append(sequence)
+
+    motif = alignment_to_matrix(sequence_list,
+                                to_type = to_type, 
+                                pseudocount = pseudocount,
+                                background=background,
+                                center_weights=center_weights)
+    if plot_default:
+        cdr3_logo = Logo(motif,
+        font_name='Arial Rounded MT Bold',
+        color_scheme='chemistry',
+        vpad=.05,
+        width=.9,
+        **kwargs)
+    
+        cdr3_logo.style_xticks(anchor=0, spacing=1, rotation=45)
+        cdr3_logo.ax.set_ylabel(f"{to_type}")
+        cdr3_logo.ax.set_xlim([-1, len(motif)])
+        return cdr3_logo
     else:
-        raise Exception("Invalid input for parameter `by`!")
+        cdr3_logo = Logo(motif, **kwargs)
+        return cdr3_logo

From a14d42b731c5e103f2b86b960bef27c13e266ef2 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Mon, 19 Aug 2024 10:55:21 +0000
Subject: [PATCH 5/8] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/scirpy/pl/_logoplots.py | 62 +++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 34 deletions(-)

diff --git a/src/scirpy/pl/_logoplots.py b/src/scirpy/pl/_logoplots.py
index 018733b38..a2ae621e4 100644
--- a/src/scirpy/pl/_logoplots.py
+++ b/src/scirpy/pl/_logoplots.py
@@ -1,30 +1,30 @@
 from collections.abc import Sequence
 from typing import Literal, Union
 
-import palmotif as palm
-from logomaker import alignment_to_matrix, Logo
-import pandas as pd
-from IPython.display import SVG
+from logomaker import Logo, alignment_to_matrix
 
 from scirpy.get import airr as get_airr
 from scirpy.util import DataHandler
 
+
 @DataHandler.inject_param_docs()
-def logoplot_cdr3_motif(adata: DataHandler.TYPE,
-                     chains: Union[
-                            Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
-                            Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
-                            ] = "VDJ_1",
-                    airr_mod="airr",
-                    airr_key="airr",
-                    chain_idx_key="chain_indices",
-                    cdr3_col: str = "junction_aa",
-                    to_type: Sequence[Literal["information", "counts", "probability", "weight"]] = "information",
-                    pseudocount: float = 0,
-                    background = None,
-                    center_weights: bool = False,
-                    plot_default = True,
-                    **kwargs):
+def logoplot_cdr3_motif(
+    adata: DataHandler.TYPE,
+    chains: Union[
+        Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
+        Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
+    ] = "VDJ_1",
+    airr_mod="airr",
+    airr_key="airr",
+    chain_idx_key="chain_indices",
+    cdr3_col: str = "junction_aa",
+    to_type: Sequence[Literal["information", "counts", "probability", "weight"]] = "information",
+    pseudocount: float = 0,
+    background=None,
+    center_weights: bool = False,
+    plot_default=True,
+    **kwargs,
+):
     """
     A user friendly wrapper function for the logomaker python package.
     Enables the analysis of potential amino acid motifs by displaying logo plots.
@@ -45,7 +45,7 @@ def logoplot_cdr3_motif(adata: DataHandler.TYPE,
         * `"information"`
         * `"counts"`
         * `"probability"`
-        * `"weight"` 
+        * `"weight"`
     pseudocount
         Pseudocount to use when converting from counts to probabilities
     background
@@ -66,9 +66,8 @@ def logoplot_cdr3_motif(adata: DataHandler.TYPE,
     -------
     Returns a object of class logomaker.Logo (see here for more information https://logomaker.readthedocs.io/en/latest/implementation.html#matrix-functions)
     """
-    
     params = DataHandler(adata, airr_mod, airr_key, chain_idx_key)
-    #make sure that sequences are prealigned i.e. they need to have the the same length
+    # make sure that sequences are prealigned i.e. they need to have the the same length
     airr_df = get_airr(params, [cdr3_col], chains)
     sequence_list = []
     for chain in chains:
@@ -76,19 +75,14 @@ def logoplot_cdr3_motif(adata: DataHandler.TYPE,
             if sequence is not None:
                 sequence_list.append(sequence)
 
-    motif = alignment_to_matrix(sequence_list,
-                                to_type = to_type, 
-                                pseudocount = pseudocount,
-                                background=background,
-                                center_weights=center_weights)
+    motif = alignment_to_matrix(
+        sequence_list, to_type=to_type, pseudocount=pseudocount, background=background, center_weights=center_weights
+    )
     if plot_default:
-        cdr3_logo = Logo(motif,
-        font_name='Arial Rounded MT Bold',
-        color_scheme='chemistry',
-        vpad=.05,
-        width=.9,
-        **kwargs)
-    
+        cdr3_logo = Logo(
+            motif, font_name="Arial Rounded MT Bold", color_scheme="chemistry", vpad=0.05, width=0.9, **kwargs
+        )
+
         cdr3_logo.style_xticks(anchor=0, spacing=1, rotation=45)
         cdr3_logo.ax.set_ylabel(f"{to_type}")
         cdr3_logo.ax.set_xlim([-1, len(motif)])

From 6bfd819fe7899623e7663c3618f0bad868f91aaa Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Tue, 10 Sep 2024 05:09:06 +0000
Subject: [PATCH 6/8] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/scirpy/pl/_logoplots.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/scirpy/pl/_logoplots.py b/src/scirpy/pl/_logoplots.py
index a2ae621e4..a3d6461e9 100644
--- a/src/scirpy/pl/_logoplots.py
+++ b/src/scirpy/pl/_logoplots.py
@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Literal, Union
+from typing import Literal
 
 from logomaker import Logo, alignment_to_matrix
 
@@ -10,10 +10,7 @@
 @DataHandler.inject_param_docs()
 def logoplot_cdr3_motif(
     adata: DataHandler.TYPE,
-    chains: Union[
-        Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"],
-        Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]],
-    ] = "VDJ_1",
+    chains: Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"] | Sequence[Literal["VJ_1", "VDJ_1", "VJ_2", "VDJ_2"]] = "VDJ_1",
     airr_mod="airr",
     airr_key="airr",
     chain_idx_key="chain_indices",

From ffcc7079403b3ca319a32e4c77fee029a1e3bfbb Mon Sep 17 00:00:00 2001
From: Mario Kanetscheider <m.kanne@ymail.com>
Date: Tue, 15 Oct 2024 12:22:52 +0200
Subject: [PATCH 7/8] Update of logoplot_cdr3_motif docs

---
 src/scirpy/pl/_logoplots.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/scirpy/pl/_logoplots.py b/src/scirpy/pl/_logoplots.py
index a3d6461e9..7110460ba 100644
--- a/src/scirpy/pl/_logoplots.py
+++ b/src/scirpy/pl/_logoplots.py
@@ -23,7 +23,9 @@ def logoplot_cdr3_motif(
     **kwargs,
 ):
     """
-    A user friendly wrapper function for the logomaker python package.
+    Generates logoplots of CDR3 sequences
+
+    This is a user friendly wrapper function around the logomaker python package.
     Enables the analysis of potential amino acid motifs by displaying logo plots.
     Subsetting of AnnData/MuData has to be performed manually beforehand (or while calling) and only cells with equal cdr3 sequence lengths are permitted.
 
@@ -31,7 +33,7 @@ def logoplot_cdr3_motif(
     ----------
     {adata}
     chains
-        One or multiple chains from which to use CDR3 sequences
+        One or up to two chains from which to use CDR3 sequences i.e. primary and/or secondary VJ/VDJ chains. Mixing VJ and VDJ chains will likely not lead to a meaningful result.
     {airr_mod}
     {airr_key}
     {chain_idx_key}

From 2b7a0eae516a18e45db34c450802d60c907ef198 Mon Sep 17 00:00:00 2001
From: Gregor Sturm <mail@gregor-sturm.de>
Date: Thu, 17 Oct 2024 21:46:02 +0200
Subject: [PATCH 8/8] Add tutorial section about logoplots

---
 docs/tutorials/tutorial_5k_bcr.ipynb | 124 +++++++++++++++++++++++++++
 1 file changed, 124 insertions(+)
 create mode 100644 docs/tutorials/tutorial_5k_bcr.ipynb

diff --git a/docs/tutorials/tutorial_5k_bcr.ipynb b/docs/tutorials/tutorial_5k_bcr.ipynb
new file mode 100644
index 000000000..dc0abc321
--- /dev/null
+++ b/docs/tutorials/tutorial_5k_bcr.ipynb
@@ -0,0 +1,124 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "b7a12e3b",
+   "metadata": {},
+   "source": [
+    "## Logoplots\n",
+    "Motif sequence analysis is a crucial analysis step and is often executed through generation of logoplots with respective tools. Here, we represent a *Scirpy* native wrapper function `scirpy.pl.logoplot_cdr3_motif` to a well established python package called [logomaker](https://logomaker.readthedocs.io/en/latest/index.html). With `to_type` we can specify, how  the logoplot is calculated and `plot_default`offers a convenient \"pre-styling\" that can be easily adapted. As logomaker offers a lot of further customization opportunities and `scirpy.pl.logoplot_cdr3_motif`, will allow any input that is accepted by logomaker we suggest to head to their [documentation](https://logomaker.readthedocs.io/en/latest/implementation.html#logo-class) to maximize the use of this amazing package.\n",
+    "\n",
+    ":::{note}\n",
+    "The input to \n",
+    "`scirpy.pl.logoplot_cdr3_motif` is expected to include only sequences that have the same junction length, because it is not possible to perform multiple sequence alignment with *Scirpy*. Therefore, the user has to manually filter the MuData object prior or while the function call.\n",
+    ":::\n",
+    "\n",
+    "The logoplot below shows the likelihood of any amino acid to occur among expanded clonotype clusters with a spectratype of 20. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 61,
+   "id": "3d369688",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 191,
+       "width": 668
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "with ir.get.obs_context(\n",
+    "    mdata[\"airr\"], {\"junction_len\": [len(a) for a in ir.get.airr(mdata, \"junction_aa\", \"VDJ_1\")]}\n",
+    ") as m:\n",
+    "    ir.pl.logoplot_cdr3_motif(\n",
+    "        m[(m.obs[\"junction_len\"] == 20) & (m.obs[\"clonal_expansion\"].isin([\"<= 2\", \"> 2\"]))],\n",
+    "        chains=[\"VDJ_1\"],\n",
+    "        plot_default=True,\n",
+    "        to_type=\"information\",\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4c8af91",
+   "metadata": {},
+   "source": [
+    "The next logoplot is similar to the previous one, but should demonstrate that it is very easy to generate logoplots of certain clonotype clusters, as they always have the same junction length due to the nature of the used hamming distance. As expected there is only small variation inside the same clonotype cluster, but interestingly position 10 and 12 differs the most."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "id": "6ba93984",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<logomaker.src.Logo.Logo at 0x177da0f9a20>"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x200 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "image/png": {
+       "height": 191,
+       "width": 668
+      }
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ir.pl.logoplot_cdr3_motif(\n",
+    "    mdata[mdata.obs[\"airr:clone_id_85_similarity\"] == \"2707\"],\n",
+    "    chains=[\"VDJ_1\"],\n",
+    "    plot_default=True,\n",
+    "    to_type=\"information\",\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "BCR",
+   "language": "python",
+   "name": "bcr"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}