diff --git a/.codeboarding/Core_Utilities.md b/.codeboarding/Core_Utilities.md
new file mode 100644
index 000000000..02bfa8d94
--- /dev/null
+++ b/.codeboarding/Core_Utilities.md
@@ -0,0 +1,295 @@
+```mermaid
+
+graph LR
+
+ Core_Utilities["Core Utilities"]
+
+ Input_Output["Input/Output"]
+
+ Preprocessing["Preprocessing"]
+
+ Immune_Receptor_Distance["Immune Receptor Distance"]
+
+ Tools_Analysis["Tools/Analysis"]
+
+ Plotting["Plotting"]
+
+ Datasets["Datasets"]
+
+ Getters["Getters"]
+
+ Tests["Tests"]
+
+ Input_Output -- "uses" --> Core_Utilities
+
+ Preprocessing -- "uses" --> Core_Utilities
+
+ Immune_Receptor_Distance -- "uses" --> Core_Utilities
+
+ Tools_Analysis -- "uses" --> Core_Utilities
+
+ Plotting -- "uses" --> Core_Utilities
+
+ Datasets -- "uses" --> Core_Utilities
+
+ Getters -- "uses" --> Core_Utilities
+
+ Tests -- "uses" --> Core_Utilities
+
+ click Core_Utilities href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Core_Utilities.md" "Details"
+
+ click Preprocessing href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Preprocessing.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+Analysis of the scirpy library components and their relationships, focusing on the central role of the Core Utilities component.
+
+
+
+### Core Utilities [[Expand]](./Core_Utilities.md)
+
+This foundational component provides common helper functions used across the entire `scirpy` library. This includes utilities for documentation injection, data type checks, sequence translation, parallelization, various mathematical helpers (e.g., negative binomial), and functionalities for graph creation, manipulation, and layout algorithms, particularly for clonotype networks. It acts as a support layer for all other components.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.util` (1:1)
+
+- `scirpy.util._negative_binomial` (1:1)
+
+- `scirpy.util.graph` (1:1)
+
+- `scirpy.util.graph._component_layout` (1:1)
+
+- `scirpy.util.graph._fr_size_aware_layout` (1:1)
+
+
+
+
+
+### Input/Output
+
+Handles all data input and output operations, including reading and writing `AnnData` objects and other relevant data formats.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.io` (1:1)
+
+- `scirpy.io._convert_anndata` (1:1)
+
+- `scirpy.io._datastructures` (1:1)
+
+- `scirpy.io._io` (1:1)
+
+- `scirpy.io._legacy` (1:1)
+
+
+
+
+
+### Preprocessing [[Expand]](./Preprocessing.md)
+
+Contains functions for preprocessing raw immune receptor sequencing data, preparing it for downstream analysis. This includes tasks like chain indexing and merging `AnnData` objects.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.pp` (1:1)
+
+- `scirpy.pp._index_chains` (1:1)
+
+- `scirpy.pp._merge_adata` (1:1)
+
+
+
+
+
+### Immune Receptor Distance
+
+Implements algorithms for calculating distances between immune receptors, crucial for identifying similar clonotypes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.ir_dist` (1:1)
+
+- `scirpy.ir_dist._clonotype_neighbors` (1:1)
+
+- `scirpy.ir_dist.metrics` (1:1)
+
+
+
+
+
+### Tools/Analysis
+
+Provides a suite of analytical tools for immune repertoire analysis, including clonotype expansion, diversity metrics, and repertoire overlap.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl` (1:1)
+
+- `scirpy.tl._chain_qc` (1:1)
+
+- `scirpy.tl._clonal_expansion` (1:1)
+
+- `scirpy.tl._clonotype_imbalance` (1:1)
+
+- `scirpy.tl._clonotype_modularity` (1:1)
+
+- `scirpy.tl._clonotypes` (1:1)
+
+- `scirpy.tl._convergence` (1:1)
+
+- `scirpy.tl._diversity` (1:1)
+
+- `scirpy.tl._group_abundance` (12:55)
+
+- `scirpy.tl._ir_query` (1:1)
+
+- `scirpy.tl._mutational_load` (1:1)
+
+- `scirpy.tl._repertoire_overlap` (1:1)
+
+- `scirpy.tl._spectratype` (1:1)
+
+
+
+
+
+### Plotting
+
+Offers a comprehensive set of plotting functionalities for visualizing immune repertoire data and analysis results.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.pl` (1:1)
+
+- `scirpy.pl._clonal_expansion` (1:1)
+
+- `scirpy.pl._clonotype_imbalance` (1:1)
+
+- `scirpy.pl._clonotypes` (1:1)
+
+- `scirpy.pl._diversity` (1:1)
+
+- `scirpy.pl._group_abundance` (1:1)
+
+- `scirpy.pl._logoplots` (1:1)
+
+- `scirpy.pl._repertoire_overlap` (1:1)
+
+- `scirpy.pl._spectratype` (1:1)
+
+- `scirpy.pl._vdj_usage` (1:1)
+
+- `scirpy.pl.base` (1:1)
+
+- `scirpy.pl.styling` (1:1)
+
+
+
+
+
+### Datasets
+
+Provides access to example and benchmark datasets for testing and demonstrating `scirpy` functionalities.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.datasets` (1:1)
+
+
+
+
+
+### Getters
+
+Contains functions for retrieving specific data attributes or subsets from `AnnData` objects.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.get` (1:1)
+
+
+
+
+
+### Tests
+
+Houses the unit and integration tests for the `scirpy` library, ensuring code correctness and reliability.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tests` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/I_O_Data_Management.md b/.codeboarding/I_O_Data_Management.md
new file mode 100644
index 000000000..bc68585ac
--- /dev/null
+++ b/.codeboarding/I_O_Data_Management.md
@@ -0,0 +1,129 @@
+```mermaid
+
+graph LR
+
+ scirpy_io["scirpy.io"]
+
+ scirpy_get["scirpy.get"]
+
+ scirpy_datasets["scirpy.datasets"]
+
+ scirpy_util_DataHandler["scirpy.util.DataHandler"]
+
+ scirpy_io -- "leverages for AnnData manipulation" --> scirpy_util_DataHandler
+
+ scirpy_datasets -- "depends on to load data" --> scirpy_io
+
+ scirpy_get -- "provides data access to" --> scirpy_tl
+
+ scirpy_get -- "provides data access to" --> scirpy_pl
+
+ scirpy_get -- "provides data access to" --> scirpy_ir_dist
+
+ scirpy_util_DataHandler -- "supports by providing data manipulation" --> scirpy_tl
+
+ scirpy_util_DataHandler -- "supports by providing data manipulation" --> scirpy_pl
+
+ scirpy_util_DataHandler -- "supports by providing data manipulation" --> scirpy_pp
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The I/O & Data Management component in scirpy is a foundational subsystem responsible for the entire lifecycle of immune receptor data, from ingestion to consistent access and manipulation within the central AnnData object. It adheres to the "Data-Centric Design" and "Modular Architecture" patterns, ensuring data integrity and seamless integration with other scirpy modules.
+
+
+
+### scirpy.io
+
+This is the primary entry point for ingesting raw immune receptor data from diverse external formats (e.g., 10x VDJ, AIRR) and converting it into the AnnData object. It handles the complexities of parsing, validating, and structuring the data according to scirpy's internal schema and the AIRR (Adaptive Immune Receptor Repertoire) standard.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.io._io`
+
+- `scirpy.io._convert_anndata`
+
+- `scirpy.io._datastructures`
+
+- `scirpy.io._legacy`
+
+- `scirpy.io._util`
+
+
+
+
+
+### scirpy.get
+
+This module provides a consistent, validated, and safe API for retrieving specific immune receptor (IR) related data fields from the AnnData object. It acts as a facade, abstracting away the internal complexities of AnnData for common IR-related queries, ensuring that downstream analysis and plotting functions receive data in the expected format and that data integrity is maintained.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.get`
+
+
+
+
+
+### scirpy.datasets
+
+This component offers access to curated, pre-processed immune receptor datasets. While not directly involved in raw data ingestion from user files, it serves as a crucial part of the data management lifecycle by providing readily available, validated data for examples, testing, and benchmarking. It often leverages scirpy.io internally to load these datasets.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.datasets`
+
+
+
+
+
+### scirpy.util.DataHandler
+
+This utility class (or set of functions within scirpy.util) provides a robust interface for low-level interactions with the AnnData object. It centralizes common data manipulation tasks, such as injecting parameter documentation, retrieving observation data (.obs), and setting observation data, thereby simplifying data access and ensuring data integrity and consistency for all analysis functions across scirpy.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.util._data`
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Immune_Receptor_Distance_Calculation.md b/.codeboarding/Immune_Receptor_Distance_Calculation.md
new file mode 100644
index 000000000..4fcf11e87
--- /dev/null
+++ b/.codeboarding/Immune_Receptor_Distance_Calculation.md
@@ -0,0 +1,105 @@
+```mermaid
+
+graph LR
+
+ Immune_Receptor_Distance_Calculation_Core["Immune Receptor Distance Calculation Core"]
+
+ Clonotype_Neighbor_Discovery["Clonotype Neighbor Discovery"]
+
+ Distance_Utility_Functions["Distance Utility Functions"]
+
+ Clonotype_Neighbor_Discovery -- "uses" --> Immune_Receptor_Distance_Calculation_Core
+
+ Clonotype_Neighbor_Discovery -- "uses" --> Distance_Utility_Functions
+
+ Immune_Receptor_Distance_Calculation_Core -- "may use" --> Distance_Utility_Functions
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `Immune Receptor Distance Calculation` subsystem provides essential functionality for quantifying the similarity between immune receptor sequences, emphasizing modularity, performance, and clear API boundaries. It includes core algorithms, neighbor discovery, and utility functions to support clonotype analysis.
+
+
+
+### Immune Receptor Distance Calculation Core
+
+This component provides the foundational algorithms and infrastructure for computing various sequence-based distances between immune receptors. It includes a base `DistanceCalculator` and specialized implementations for different metrics (e.g., Hamming, Levenshtein, Alignment, TCRdist, Identity), often leveraging parallelization for performance.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `DistanceCalculator` (1:1)
+
+- `ParallelDistanceCalculator` (1:1)
+
+- `HammingDistanceCalculator` (1:1)
+
+- `LevenshteinDistanceCalculator` (1:1)
+
+- `AlignmentDistanceCalculator` (1:1)
+
+- `TCRdistDistanceCalculator` (1:1)
+
+- `IdentityDistanceCalculator` (1:1)
+
+- `_MetricDistanceCalculator` (1:1)
+
+
+
+
+
+### Clonotype Neighbor Discovery
+
+This component is responsible for identifying and managing neighboring immune receptors or clonotypes based on the distances computed by the `Immune Receptor Distance Calculation Core`. It translates raw distance metrics into meaningful relationships, which are crucial for downstream clonotype analysis.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `ClonotypeNeighbors` (1:1)
+
+
+
+
+
+### Distance Utility Functions
+
+This component provides helper functions and specialized utilities that support the distance calculation and neighbor discovery processes. These utilities often focus on optimizing performance or facilitating efficient data handling within the `ir_dist` module.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `DoubleLookupNeighborFinder` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Preprocessing.md b/.codeboarding/Preprocessing.md
new file mode 100644
index 000000000..6fe05f77f
--- /dev/null
+++ b/.codeboarding/Preprocessing.md
@@ -0,0 +1,123 @@
+```mermaid
+
+graph LR
+
+ Preprocessing["Preprocessing"]
+
+ scirpy_io["scirpy.io"]
+
+ scirpy_tl["scirpy.tl"]
+
+ scirpy_util["scirpy.util"]
+
+ scirpy_ir_dist["scirpy.ir_dist"]
+
+ scirpy_datasets["scirpy.datasets"]
+
+ scirpy_io -- "provides data to" --> Preprocessing
+
+ Preprocessing -- "provides data to" --> scirpy_tl
+
+ Preprocessing -- "utilizes" --> scirpy_util
+
+ scirpy_datasets -- "uses" --> Preprocessing
+
+ click Preprocessing href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Preprocessing.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+One paragraph explaining the functionality which is represented by this graph. What the main flow is and what is its purpose.
+
+
+
+### Preprocessing [[Expand]](./Preprocessing.md)
+
+This component is responsible for transforming raw or loaded immune receptor data into a standardized and analysis-ready format, primarily within AnnData objects. Its core functions include `index_chains` for structuring and validating chain information and `merge_adata` for combining multiple AnnData objects. This ensures data quality and consistency across the entire analysis pipeline.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+
+
+
+
+### scirpy.io
+
+Handles loading and saving of immune receptor data.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### scirpy.tl
+
+Provides tools for various analytical tasks on immune receptor data.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### scirpy.util
+
+Contains utility functions used across the scirpy library.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### scirpy.ir_dist
+
+Calculates immune receptor distances.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+### scirpy.datasets
+
+Provides example datasets for scirpy.
+
+
+
+
+
+**Related Classes/Methods**: _None_
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Repertoire_Analysis_Tools.md b/.codeboarding/Repertoire_Analysis_Tools.md
new file mode 100644
index 000000000..3f25d2d15
--- /dev/null
+++ b/.codeboarding/Repertoire_Analysis_Tools.md
@@ -0,0 +1,249 @@
+```mermaid
+
+graph LR
+
+ Core_Analysis_Module["Core Analysis Module"]
+
+ Clonotype_Definition_and_Manipulation["Clonotype Definition and Manipulation"]
+
+ Clonal_Expansion_Analysis["Clonal Expansion Analysis"]
+
+ Repertoire_Diversity_Metrics["Repertoire Diversity Metrics"]
+
+ Repertoire_Overlap_Analysis["Repertoire Overlap Analysis"]
+
+ Chain_Quality_Control["Chain Quality Control"]
+
+ Immune_Receptor_Querying["Immune Receptor Querying"]
+
+ Statistical_Utilities["Statistical Utilities"]
+
+ Clonotype_Imbalance_Analysis["Clonotype Imbalance Analysis"]
+
+ Clonotype_Modularity_Analysis["Clonotype Modularity Analysis"]
+
+ Core_Analysis_Module -- "uses" --> Clonotype_Definition_and_Manipulation
+
+ Core_Analysis_Module -- "uses" --> Clonal_Expansion_Analysis
+
+ Core_Analysis_Module -- "uses" --> Repertoire_Diversity_Metrics
+
+ Core_Analysis_Module -- "uses" --> Repertoire_Overlap_Analysis
+
+ Core_Analysis_Module -- "uses" --> Chain_Quality_Control
+
+ Core_Analysis_Module -- "uses" --> Immune_Receptor_Querying
+
+ Core_Analysis_Module -- "uses" --> Clonotype_Imbalance_Analysis
+
+ Core_Analysis_Module -- "uses" --> Clonotype_Modularity_Analysis
+
+ Clonal_Expansion_Analysis -- "uses" --> Statistical_Utilities
+
+ Repertoire_Diversity_Metrics -- "uses" --> Statistical_Utilities
+
+ Repertoire_Overlap_Analysis -- "uses" --> Statistical_Utilities
+
+ Immune_Receptor_Querying -- "uses" --> Clonotype_Definition_and_Manipulation
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+Abstract Components Overview
+
+
+
+### Core Analysis Module
+
+This is the main entry point for repertoire analysis functions. It provides a high-level API for users to perform various analytical tasks. It orchestrates calls to specialized sub-modules for specific analyses.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl` (1:1)
+
+
+
+
+
+### Clonotype Definition and Manipulation
+
+This component is responsible for defining and manipulating clonotypes based on various criteria (e.g., CDR3 sequences, V/J genes). It provides functions for grouping cells into clonotypes and managing clonotype-related metadata.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._clonotypes` (1:1)
+
+
+
+
+
+### Clonal Expansion Analysis
+
+This component focuses on analyzing the expansion of specific clonotypes within a repertoire. It provides functions to quantify clonal expansion and identify highly expanded clones.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._clonal_expansion` (1:1)
+
+
+
+
+
+### Repertoire Diversity Metrics
+
+This component calculates various diversity metrics to characterize the richness and evenness of immune repertoires.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._diversity` (1:1)
+
+
+
+
+
+### Repertoire Overlap Analysis
+
+This component quantifies the overlap between different immune repertoires, allowing for comparisons between samples or conditions.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._repertoire_overlap` (1:1)
+
+
+
+
+
+### Chain Quality Control
+
+This component provides functions for performing quality control on immune receptor chains, identifying and flagging potential issues or inconsistencies in the data.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._chain_qc` (1:1)
+
+
+
+
+
+### Immune Receptor Querying
+
+This component enables querying and filtering immune receptor data based on various criteria, facilitating targeted analysis of specific receptors or clonotypes.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._ir_query` (1:1)
+
+
+
+
+
+### Statistical Utilities
+
+This component provides general statistical utility functions that are commonly used across various analytical tasks within scirpy.tl.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.util` (1:1)
+
+
+
+
+
+### Clonotype Imbalance Analysis
+
+This component analyzes the imbalance of clonotypes, often in the context of different groups or conditions, to identify shifts in repertoire composition.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._clonotype_imbalance` (1:1)
+
+
+
+
+
+### Clonotype Modularity Analysis
+
+This component investigates the modular structure of clonotypes, potentially identifying groups of clonotypes that co-occur or share characteristics.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl._clonotype_modularity` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/Visualization.md b/.codeboarding/Visualization.md
new file mode 100644
index 000000000..83dc0d83d
--- /dev/null
+++ b/.codeboarding/Visualization.md
@@ -0,0 +1,125 @@
+```mermaid
+
+graph LR
+
+ Plotting_Module_scirpy_pl_["Plotting Module (scirpy.pl)"]
+
+ Base_Plotting_Functions_scirpy_pl_base_["Base Plotting Functions (scirpy.pl.base)"]
+
+ Plotting_Styling_scirpy_pl_styling_["Plotting Styling (scirpy.pl.styling)"]
+
+ Plotting_Module_scirpy_pl_ -- "Uses" --> Tools_Module_scirpy_tl_
+
+ Plotting_Module_scirpy_pl_ -- "Uses" --> Utility_Module_scirpy_util_
+
+ Plotting_Module_scirpy_pl_ -- "Comprises" --> Base_Plotting_Functions_scirpy_pl_base_
+
+ Plotting_Module_scirpy_pl_ -- "Comprises" --> Plotting_Styling_scirpy_pl_styling_
+
+ Base_Plotting_Functions_scirpy_pl_base_ -- "Part of" --> Plotting_Module_scirpy_pl_
+
+ Base_Plotting_Functions_scirpy_pl_base_ -- "Uses" --> Plotting_Styling_scirpy_pl_styling_
+
+ Base_Plotting_Functions_scirpy_pl_base_ -- "Uses" --> Utility_Module_scirpy_util_
+
+ Plotting_Styling_scirpy_pl_styling_ -- "Part of" --> Plotting_Module_scirpy_pl_
+
+ Plotting_Styling_scirpy_pl_styling_ -- "Used by" --> Base_Plotting_Functions_scirpy_pl_base_
+
+ Plotting_Styling_scirpy_pl_styling_ -- "Uses" --> Utility_Module_scirpy_util_
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `scirpy.pl` package, as a specialized scientific computing library, is designed with a clear modular architecture, focusing on data visualization. These components are fundamental because they represent a clear separation of concerns within the visualization subsystem, aligning with the "Modular Architecture" and "Facade Pattern" principles.
+
+
+
+### Plotting Module (scirpy.pl)
+
+This is the top-level module for all visualization functionalities. It acts as a facade, providing high-level functions for generating various plots related to IR-seq data. It orchestrates calls to lower-level plotting primitives and styling utilities, ensuring a consistent and user-friendly interface for data visualization.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy/pl/__init__.py` (1:1)
+
+- `scirpy/pl/_clonal_expansion.py` (1:1)
+
+- `scirpy/pl/_clonotype_imbalance.py` (1:1)
+
+- `scirpy/pl/_clonotype_modularity.py` (1:1)
+
+- `scirpy/pl/_clonotypes.py` (1:1)
+
+- `scirpy/pl/_diversity.py` (1:1)
+
+- `scirpy/pl/_group_abundance.py` (1:1)
+
+- `scirpy/pl/_logoplots.py` (1:1)
+
+- `scirpy/pl/_repertoire_overlap.py` (1:1)
+
+- `scirpy/pl/_spectratype.py` (1:1)
+
+- `scirpy/pl/_vdj_usage.py` (1:1)
+
+
+
+
+
+### Base Plotting Functions (scirpy.pl.base)
+
+This sub-module provides fundamental, reusable plotting primitives. These functions are the building blocks for more complex and specialized visualizations within the `scirpy.pl` module. They ensure consistency in basic plot types (e.g., bar, line, scatter) across the library.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy/pl/base.py` (1:1)
+
+
+
+
+
+### Plotting Styling (scirpy.pl.styling)
+
+This sub-module centralizes all styling parameters, color palettes, and functions. Its purpose is to ensure a uniform and high-quality aesthetic for all plots generated by `scirpy.pl`, which is crucial for scientific publications and presentations.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy/pl/styling.py` (1:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file
diff --git a/.codeboarding/on_boarding.md b/.codeboarding/on_boarding.md
new file mode 100644
index 000000000..b7d46a428
--- /dev/null
+++ b/.codeboarding/on_boarding.md
@@ -0,0 +1,227 @@
+```mermaid
+
+graph LR
+
+ I_O_Data_Management["I/O & Data Management"]
+
+ Preprocessing["Preprocessing"]
+
+ Immune_Receptor_Distance_Calculation["Immune Receptor Distance Calculation"]
+
+ Repertoire_Analysis_Tools["Repertoire Analysis Tools"]
+
+ Visualization["Visualization"]
+
+ Core_Utilities["Core Utilities"]
+
+ I_O_Data_Management -- "Provides Data To" --> Preprocessing
+
+ I_O_Data_Management -- "Provides Data To" --> Immune_Receptor_Distance_Calculation
+
+ I_O_Data_Management -- "Provides Data To" --> Repertoire_Analysis_Tools
+
+ I_O_Data_Management -- "Provides Data To" --> Visualization
+
+ Preprocessing -- "Receives Data From" --> I_O_Data_Management
+
+ Immune_Receptor_Distance_Calculation -- "Receives Data From" --> I_O_Data_Management
+
+ Repertoire_Analysis_Tools -- "Receives Data From" --> I_O_Data_Management
+
+ I_O_Data_Management -- "Utilizes" --> Core_Utilities
+
+ Preprocessing -- "Receives Data From" --> I_O_Data_Management
+
+ Preprocessing -- "Provides Data To" --> I_O_Data_Management
+
+ Preprocessing -- "Provides Data To" --> Immune_Receptor_Distance_Calculation
+
+ Preprocessing -- "Provides Data To" --> Repertoire_Analysis_Tools
+
+ Preprocessing -- "Utilizes" --> Core_Utilities
+
+ Immune_Receptor_Distance_Calculation -- "Receives Data From" --> I_O_Data_Management
+
+ Immune_Receptor_Distance_Calculation -- "Receives Data From" --> Preprocessing
+
+ Immune_Receptor_Distance_Calculation -- "Provides Data To" --> I_O_Data_Management
+
+ Immune_Receptor_Distance_Calculation -- "Provides Data To" --> Repertoire_Analysis_Tools
+
+ Immune_Receptor_Distance_Calculation -- "Utilizes" --> Core_Utilities
+
+ Repertoire_Analysis_Tools -- "Receives Data From" --> I_O_Data_Management
+
+ Repertoire_Analysis_Tools -- "Receives Data From" --> Preprocessing
+
+ Repertoire_Analysis_Tools -- "Receives Data From" --> Immune_Receptor_Distance_Calculation
+
+ Repertoire_Analysis_Tools -- "Provides Data To" --> I_O_Data_Management
+
+ Repertoire_Analysis_Tools -- "Provides Data To" --> Visualization
+
+ Repertoire_Analysis_Tools -- "Utilizes" --> Core_Utilities
+
+ Visualization -- "Receives Data From" --> I_O_Data_Management
+
+ Visualization -- "Receives Data From" --> Repertoire_Analysis_Tools
+
+ Visualization -- "Utilizes" --> Core_Utilities
+
+ Core_Utilities -- "Supports" --> I_O_Data_Management
+
+ Core_Utilities -- "Supports" --> Preprocessing
+
+ Core_Utilities -- "Supports" --> Immune_Receptor_Distance_Calculation
+
+ Core_Utilities -- "Supports" --> Repertoire_Analysis_Tools
+
+ Core_Utilities -- "Supports" --> Visualization
+
+ click I_O_Data_Management href "https://github.com/scverse/scirpy/blob/main/.codeboarding//I_O_Data_Management.md" "Details"
+
+ click Preprocessing href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Preprocessing.md" "Details"
+
+ click Immune_Receptor_Distance_Calculation href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Immune_Receptor_Distance_Calculation.md" "Details"
+
+ click Repertoire_Analysis_Tools href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Repertoire_Analysis_Tools.md" "Details"
+
+ click Visualization href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Visualization.md" "Details"
+
+ click Core_Utilities href "https://github.com/scverse/scirpy/blob/main/.codeboarding//Core_Utilities.md" "Details"
+
+```
+
+
+
+[](https://github.com/CodeBoarding/GeneratedOnBoardings)[](https://www.codeboarding.org/demo)[](mailto:contact@codeboarding.org)
+
+
+
+## Details
+
+
+
+The `scirpy` library, designed as a Specialized Scientific Computing Library/Bioinformatics Toolkit, exhibits a modular and data-centric architecture, with the AnnData object serving as the central data container. The system is structured around six core components, each with distinct responsibilities and clear interaction patterns, facilitating a robust and extensible framework for immune repertoire analysis.
+
+
+
+### I/O & Data Management [[Expand]](./I_O_Data_Management.md)
+
+This foundational component is responsible for the entire lifecycle of immune receptor data. It handles the ingestion of raw data from diverse formats (e.g., 10x VDJ, AIRR) into the central AnnData object, manages schema compatibility, and provides a consistent, validated API for accessing and manipulating data within AnnData. It acts as the primary interface for data persistence and retrieval.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.datasets` (0:1)
+
+- `scirpy.io` (0:1)
+
+- `scirpy.util.DataHandler` (0:1)
+
+- `scirpy.get` (0:1)
+
+
+
+
+
+### Preprocessing [[Expand]](./Preprocessing.md)
+
+This component prepares raw or loaded immune receptor data for downstream analysis. Its key functions include indexing chains within the AnnData object to ensure proper structure and merging multiple AnnData objects for combined analysis, ensuring data readiness and consistency.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.pp` (0:1)
+
+
+
+
+
+### Immune Receptor Distance Calculation [[Expand]](./Immune_Receptor_Distance_Calculation.md)
+
+This specialized component implements various algorithms for calculating sequence-based distances between immune receptor sequences (e.g., CDR3s). It computes distance matrices and identifies clonotype neighbors based on these metrics, often leveraging performance optimizations like parallelization.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.ir_dist` (0:1)
+
+
+
+
+
+### Repertoire Analysis Tools [[Expand]](./Repertoire_Analysis_Tools.md)
+
+This is the core analytical engine of the library, offering a comprehensive suite of tools for in-depth analysis of immune repertoires. Functions include defining clonotypes, analyzing clonal expansion, assessing diversity, quantifying repertoire overlap, and performing quality control on chains.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.tl` (0:1)
+
+
+
+
+
+### Visualization [[Expand]](./Visualization.md)
+
+This component is dedicated to generating various plots that visualize repertoire characteristics and the results of analyses. It includes base plotting utilities and styling functions to ensure consistent and high-quality visualizations, aiding in exploratory data analysis and presentation.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.pl` (0:1)
+
+
+
+
+
+### Core Utilities [[Expand]](./Core_Utilities.md)
+
+This foundational component provides common helper functions used across the entire library. This includes utilities for documentation injection, data type checks, sequence translation, parallelization, various mathematical helpers, and functionalities for graph creation, manipulation, and layout algorithms, particularly for clonotype networks. It acts as a support layer for all other components.
+
+
+
+
+
+**Related Classes/Methods**:
+
+
+
+- `scirpy.util` (0:1)
+
+
+
+
+
+
+
+
+
+### [FAQ](https://github.com/CodeBoarding/GeneratedOnBoardings/tree/main?tab=readme-ov-file#faq)
\ No newline at end of file