mpl-spaceplot 0.1.1__py3-none-any.whl

mpl_spaceplot-0.1.1.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: mpl-spaceplot
+Version: 0.1.1
+Summary: layout wrappers for matplotlib
+Author-email: Florian Raths <raths.f@gmail.com>
+License: MIT
+Keywords: matplotlib,plotting,wrappers
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: cmcrameri>=1.9
+Dynamic: license-file
+
+# spaceplot

mpl_spaceplot-0.1.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+mpl_spaceplot-0.1.1.dist-info/licenses/LICENSE,sha256=_vaCZw15E27W2FRa7fXnfzoCvRPLfJdvjZYnW-JgDXQ,1070
+spaceplot/__init__.py,sha256=j8LDw-mYSuYJaTGrHKdWA0kxypSb0XMViWUGAmUppfQ,535
+spaceplot/aligner.py,sha256=JZu9bVtM3Z7NlVB6BxeKRpw_XZU0zFWvEG0hsIs9N8I,2871
+spaceplot/montage_plot.py,sha256=vRwvjza81VAJzaqN6EKbBcta6wIT9yo8hiPTXySX_84,9717
+spaceplot/simulate_data.py,sha256=ojgaA3Rj_nWZup-UXsYHptQxx5FmgFiTbU0x22fibIg,2556
+spaceplot/utils.py,sha256=8yA2k9-juq-jSmAzbBgM3z_rd_OHYPHe3Mn_2_h8B6o,1332
+spaceplot/appearance/__init__.py,sha256=r8WmWsdbrdVlwG6wA2E-lTUAjXPh4KWmQN8TRd-u5R0,237
+spaceplot/appearance/display.py,sha256=aW-I-RmxDw4-_RSoY54HnSby6HVMf68xEO5NxZqNkUA,7328
+spaceplot/appearance/inline.py,sha256=_czkKGmHHu3EXGIYd1r0UwDMcP__bt1-Qq-Ir3z6V_o,1186
+spaceplot/appearance/layout.py,sha256=WMgt_nXz9_9rw-uTBbcn-i9bTS_Rc8uUWIs2Q3a5L_k,7781
+spaceplot/appearance/palettes.py,sha256=uVu-9EmP8m07jcUVu-7JgDKJTLbUpOmkrQHrfizCuno,7288
+spaceplot/appearance/styles.py,sha256=YXZiVQ9UZqo3XFqKrlmAsDli7ZFtPWmawru4hAq0NtU,1480
+spaceplot/appearance/tools.py,sha256=S6FXhACX5PUnfIbZ1ILloWdv_zeCrKW9wJk_4FRl3Vk,7406
+spaceplot/decorators/__init__.py,sha256=EY9yo6QBmq9fmbsd7k2-BaimBnF4ldglgKDfAKa9vpc,208
+spaceplot/decorators/decorators.py,sha256=S8ekPl7Wq1fV97GA9v2e53kutGIcJv2vZx6QdpaTIzk,12610
+spaceplot/decorators/tools.py,sha256=KjtBjhJ0v2xtU-Es2J6n4EkwTawhYMaSWagBi4oonV4,2876
+spaceplot/plotting/__init__.py,sha256=8fUm0IVPZCWvd-QY7Os2xQldxFGv3UsjCCzHm_xJXG8,134
+spaceplot/plotting/plotting.py,sha256=Pt2AcNOpMHPhjO8qZCYjx0i-085j-Rw-DnRr_lwfFvk,5315
+spaceplot/plotting/tools.py,sha256=4x9ciSWgVCHbmBfOUi0JWEgV9O0SHplVwkqsAvO1fyM,2359
+spaceplot/resources/font_loader.py,sha256=xFJk9DdyucFTwvoj1q2TLdp0Cw43vnXoa2lXxkgt-GQ,270
+mpl_spaceplot-0.1.1.dist-info/METADATA,sha256=9TlN5ihQi5Yo6zexDnRJ84n2JY5LBLFwD6W-DIL2ZFM,525
+mpl_spaceplot-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mpl_spaceplot-0.1.1.dist-info/top_level.txt,sha256=p7OWPWO7oZw08wku3-XvgUCcPpiMfIKe_sRVqHE82r8,10
+mpl_spaceplot-0.1.1.dist-info/RECORD,,

mpl_spaceplot-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mpl_spaceplot-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Florian Raths
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mpl_spaceplot-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+spaceplot

spaceplot/__init__.py

@@ -0,0 +1,25 @@
+import matplotlib.pyplot as plt
+
+from . import aligner
+from . import decorators as decs
+from . import utils as ut
+from .appearance import palettes as plts
+from .appearance.display import Theme, display
+from .appearance.layout import layout
+from .montage_plot import montage_plot
+from .plotting import plt_category, plt_continous, plt_image
+
+__all__ = [
+    'aligner',
+    'decs',
+    'ut',
+    'plts',
+    'Theme',
+    'display',
+    'layout',
+    'montage_plot',
+    'plt_category',
+    'plt_continous',
+    'plt_image',
+    'plt',
+]

spaceplot/aligner.py

@@ -0,0 +1,112 @@
+from typing import Literal
+
+import numpy as np
+
+aligns = Literal[
+    'top_left',
+    'top_right',
+    'bottom_left',
+    'bottom_right',
+    'center_left',
+    'center_right',
+    'center_top',
+    'center_bottom',
+]
+
+align_map = {
+    'c': 0.5,
+    'l': 0,
+    'r': 1,
+    'b': 0,
+    't': 1,
+}
+
+align_full_names = {
+    'c': 'center',
+    'l': 'left',
+    'r': 'right',
+    'b': 'bottom',
+    't': 'top',
+}
+
+
+def translate_align(how: aligns, format: str = 'frac', xfact: float = None, yfact: float = None) -> tuple[float, float]:
+    if how is None and (xfact is None or yfact is None):
+        raise ValueError("Either 'how' must be provided or both 'xfact' and 'yfact' must be specified.")
+
+    if how is not None:
+        x_a, y_a = parse_alignment(how)
+    else:
+        x_a, y_a = 'c', 'c'
+
+    x = xfact if xfact else align_map[x_a]
+    y = yfact if yfact else align_map[y_a]
+
+    if format == 'name':
+        x = align_full_names[x_a] if xfact is None else xfact
+        y = align_full_names[y_a] if yfact is None else yfact
+
+    return x, y
+
+
+def parse_alignment(inpt: aligns) -> tuple[aligns, aligns]:
+    """reutrns a tuple of (x, y) alignment based on the input string."""
+
+    def get_inpt_type(inpt):
+        if inpt in ['l', 'r']:
+            inpt_type = 'horizontal'
+        elif inpt in ['t', 'b']:
+            inpt_type = 'vertical'
+        else:
+            inpt_type = 'centered'
+        return inpt_type
+
+    if len(inpt) > 2:
+        if '_' in inpt:
+            parts = inpt.split('_')
+
+            if len(parts) == 2:
+                inpt = parts[0][0] + parts[1][0]
+            else:
+                raise ValueError('Input must be a two-part string separated by an underscore.')
+        else:
+            inpt = inpt[0]
+
+    x = y = None
+    if len(inpt) == 1:
+        in_type = get_inpt_type(inpt)
+        if in_type == 'horizontal':
+            x, y = inpt, 'c'
+        elif in_type == 'vertical':
+            x, y = 'c', inpt
+        else:
+            x = y = 'c'
+
+    elif len(inpt) == 2:
+        in_type_a = get_inpt_type(inpt[0])
+        in_type_b = get_inpt_type(inpt[1])
+
+        types = np.array([in_type_a, in_type_b])
+
+        if in_type_a == in_type_b:
+            raise ValueError('Both inputs cannot be of the same kind.')
+
+        h_idx = np.where(types == 'horizontal')[0]
+        v_idx = np.where(types == 'vertical')[0]
+
+        if len(h_idx) == 0:
+            x = 'c'
+        elif len(h_idx) == 1:
+            x = inpt[h_idx[0]]
+        else:
+            raise ValueError('More than one horizontal input provided.')
+        if len(v_idx) == 0:
+            y = 'c'
+        elif len(v_idx) == 1:
+            y = inpt[v_idx[0]]
+        else:
+            raise ValueError('More than one vertical input provided.')
+    else:
+        raise ValueError('Input must be a single character or a two-character string.')
+
+    return x, y

spaceplot/appearance/__init__.py

@@ -0,0 +1,8 @@
+import importlib.resources as resources
+
+from ..resources.font_loader import register_fonts
+
+# register fonts supplied with package
+path = resources.files('spaceplot.resources.fonts')
+for cont in path.iterdir():
+    register_fonts(cont)

spaceplot/appearance/display.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+import matplotlib.pyplot as plt
+
+from .. import utils
+from . import inline, styles, tools
+
+
+def display(
+    theme: str | Theme = 'default',
+    **kwargs,
+):
+    theme = Theme(source_theme=theme, **kwargs) if isinstance(theme, str) else theme
+    theme.apply()
+
+
+@dataclass
+class Theme:
+    source_theme: str = None
+    explicit_rcParams: dict = None
+    retina: bool = False
+    transparent: bool = False
+    figsize: tuple[float, float] = None
+    dpi: int = None
+    palette: list[str] = None
+    cmap: str = None
+    text_color: str = None
+    line_color: str = None
+    ticks: list[str] = None
+    minor_visible: bool = None
+    spines: bool = None
+    margins: float = None
+    grid: bool = None
+    grid_color: str = None
+    grid_alpha: float = None
+    grid_linestyle: str = None
+    grid_linewidth: float = None
+    tick_linewidth: tuple[float, float] = (None, None)
+    tick_pad: tuple[float, float] = (None, None)
+    spine_linewidth: float = None
+    tick_size: tuple[float, float] = (None, None)
+    font_family: str = None
+    font_size: int = None
+    fig_facecolor: str = None
+    axes_facecolor: str = None
+    labelsize: dict = field(default_factory=lambda: {'axes': None, 'figure': None, 'ticks': None})
+    titlesize: dict = field(default_factory=lambda: {'axes': None, 'figure': None})
+    titleweight: dict = field(default_factory=lambda: {'axes': None, 'figure': None})
+    labelweight: dict = field(default_factory=lambda: {'axes': None, 'figure': None})
+    axes_labelpad: float = None
+    axes_titlepad: float = None
+    inline_config: dict = field(default_factory=dict)
+
+    def parse_source_theme(self):
+        if isinstance(self.source_theme, str):
+            base_theme = styles.themes.get(self.source_theme, {})
+            return Theme(source_theme=base_theme)
+
+        elif isinstance(self.source_theme, dict):
+            return Theme(**self.source_theme)
+
+        else:
+            return self.source_theme
+
+    def reset_defaults(self):
+        plt.rcdefaults()
+
+    @property
+    def rcDict(self):
+        from cycler import cycler
+
+        tick_unset_val = None if self.ticks is None else False
+        tick_t, tick_b, tick_l, tick_r = tools.set_position(positions=self.ticks, unset_value=tick_unset_val)
+
+        spine_unset_val = None if self.spines is None else False
+        spine_t, spine_b, spine_l, spine_r = tools.set_position(positions=self.spines, unset_value=spine_unset_val)
+
+        prop_cycle = None if self.palette is None else cycler('color', self.palette)
+
+        rc_dict = {
+            key: value
+            for key, value in {
+                'figure.figsize': self.figsize,
+                'figure.dpi': self.dpi,
+                'axes.prop_cycle': prop_cycle,
+                'image.cmap': self.cmap,
+                'xtick.color': self.line_color,
+                'ytick.color': self.line_color,
+                'axes.grid': self.grid,
+                'axes3d.grid': self.grid,
+                'polaraxes.grid': self.grid,
+                'grid.alpha': self.grid_alpha,
+                'grid.color': self.grid_color,
+                'grid.linestyle': self.grid_linestyle,
+                'grid.linewidth': self.grid_linewidth,
+                'text.color': self.text_color,
+                'axes.labelcolor': self.text_color,
+                'axes.titlecolor': self.text_color,
+                'ytick.labelcolor': self.text_color,
+                'xtick.labelcolor': self.text_color,
+                'axes.edgecolor': self.line_color,
+                'axes.facecolor': self.axes_facecolor,
+                'figure.facecolor': self.fig_facecolor,
+                'font.family': self.font_family,
+                'font.size': self.font_size,
+                'figure.titlesize': self.titlesize.get('figure', None),
+                'axes.titlesize': self.titlesize.get('axes', None),
+                'figure.titleweight': self.titleweight.get('figure', None),
+                'axes.titleweight': self.titleweight.get('axes', None),
+                'figure.labelsize': self.labelsize.get('figure', None),
+                'axes.labelsize': self.labelsize.get('axes', None),
+                'xtick.labelsize': self.labelsize.get('ticks', None),
+                'ytick.labelsize': self.labelsize.get('ticks', None),
+                'axes.labelpad': self.axes_labelpad,
+                'axes.titlepad': self.axes_titlepad,
+                'figure.labelweight': self.labelweight.get('figure', None),
+                'axes.labelweight': self.labelweight.get('axes', None),
+                'axes.linewidth': self.spine_linewidth,
+                'axes.xmargin': self.margins,
+                'axes.ymargin': self.margins,
+                'axes.zmargin': self.margins,
+                'axes.spines.top': spine_t,
+                'axes.spines.bottom': spine_b,
+                'axes.spines.left': spine_l,
+                'axes.spines.right': spine_r,
+                'xtick.top': tick_t,
+                'xtick.bottom': tick_b,
+                'ytick.left': tick_l,
+                'ytick.right': tick_r,
+                'ytick.major.left': tick_l,
+                'ytick.major.right': tick_r,
+                'xtick.major.top': tick_t,
+                'xtick.major.bottom': tick_b,
+                'ytick.minor.left': tick_l,
+                'ytick.minor.right': tick_r,
+                'xtick.minor.top': tick_t,
+                'xtick.minor.bottom': tick_b,
+                'ytick.labelleft': tick_l,
+                'ytick.labelright': tick_r,
+                'xtick.labeltop': tick_t,
+                'xtick.labelbottom': tick_b,
+                'xtick.major.pad': utils.maj_min_args(self.tick_pad)[0],
+                'xtick.minor.pad': utils.maj_min_args(self.tick_pad)[1],
+                'ytick.major.pad': utils.maj_min_args(self.tick_pad)[0],
+                'ytick.minor.pad': utils.maj_min_args(self.tick_pad)[1],
+                'xtick.major.size': utils.maj_min_args(self.tick_size)[0],
+                'xtick.minor.size': utils.maj_min_args(self.tick_size)[1],
+                'ytick.major.size': utils.maj_min_args(self.tick_size)[0],
+                'ytick.minor.size': utils.maj_min_args(self.tick_size)[1],
+                'xtick.major.width': utils.maj_min_args(self.tick_linewidth)[0],
+                'xtick.minor.width': utils.maj_min_args(self.tick_linewidth)[1],
+                'ytick.major.width': utils.maj_min_args(self.tick_linewidth)[0],
+                'ytick.minor.width': utils.maj_min_args(self.tick_linewidth)[1],
+                'ytick.minor.visible': self.minor_visible,
+                'xtick.minor.visible': self.minor_visible,
+            }.items()
+            if value is not None
+        }
+
+        if self.explicit_rcParams is not None:
+            rc_dict.update(self.explicit_rcParams)
+
+        if self.source_theme is not None:
+            source = self.parse_source_theme()
+            rc_dict = {**source.rcDict, **rc_dict}
+
+        return rc_dict
+
+    def apply(self):
+        if self.source_theme == 'default':
+            print('Theme: resetting to matplotlib defaults')
+            plt.rcdefaults()
+
+        plt.rcParams.update(self.rcDict)
+
+        inline.inline_config(retina=self.retina, transparent=self.transparent, **self.inline_config)

spaceplot/appearance/inline.py

@@ -0,0 +1,45 @@
+import matplotlib_inline.backend_inline as mpl_inline
+from matplotlib import rcParams
+
+rc_mapping = {
+    'dpi': 'figure.dpi',
+    'pad_inches': 'savefig.pad_inches',
+    'facecolor': 'figure.facecolor',
+    'bbox_inches': 'savefig.bbox',
+}
+
+
+def from_rc(key):
+    return rcParams[rc_mapping[key]] if key in rc_mapping else None
+
+
+def inline_config(
+    retina: bool = None,
+    facecolor: str = 'rc',
+    dpi: int | str = 'rc',
+    pad_inches: float | str = 'rc',
+    bbox_inches: float | str = 'tight',
+    transparent: bool = False,
+    **kwargs,
+):
+    dpi = from_rc('dpi') if dpi == 'rc' else dpi
+    pad_inches = from_rc('pad_inches') if pad_inches == 'rc' else pad_inches
+    bbox_inches = from_rc('bbox_inches') if bbox_inches == 'rc' else bbox_inches
+    facecolor = from_rc('facecolor') if facecolor == 'rc' else facecolor
+
+    facecolor = 'none' if transparent else facecolor
+
+    if retina:
+        inl_format = 'retina'
+        dpi = dpi * 2
+    else:
+        inl_format = 'png'
+
+    mpl_inline.set_matplotlib_formats(
+        inl_format,
+        facecolor=facecolor,
+        bbox_inches=bbox_inches,
+        dpi=dpi,
+        pad_inches=pad_inches,
+        **kwargs,
+    )

spaceplot/appearance/layout.py

@@ -0,0 +1,237 @@
+from collections.abc import Iterable
+from itertools import cycle
+
+import numpy as np
+
+from .. import decorators as decs
+from .. import utils
+from . import tools
+
+major_grid_style = 'solid'
+minor_grid_style = (0, (1, 2))
+
+
+def layout(
+    axs,
+    *,
+    axis: str = 'both',
+    title: str = None,
+    x_label: str = None,
+    y_label: str = None,
+    abc: str | bool = None,
+    make_square: bool = None,
+    margins: float = None,
+    aspect: str | float | tuple = None,
+    ticks: tools._tick_vis = None,
+    grid: tools._grid_vis = None,
+    minor: bool = None,
+    spines: tools._tick_vis = None,
+    x_breaks: list[float] = None,
+    y_breaks: list[float] = None,
+    x_lims: list[float] = None,
+    y_lims: list[float] = None,
+    x_scale: str = None,
+    y_scale: str = None,
+    x_tick_labels: list[str] = None,
+    y_tick_labels: list[str] = None,
+    **kwargs,
+):
+    # decompose kwargs into title, label, tick, and grid settings
+    title_settings = utils.get_hook_dict(kwargs, 'title', remove_hook=True)
+    label_settings = utils.get_hook_dict(kwargs, 'label', remove_hook=True)
+
+    tick_settings = utils.get_hook_dict(kwargs, 'tick', remove_hook=True)
+    grid_settings = utils.get_hook_dict(kwargs, 'grid', remove_hook=False)
+    tick_settings.update(grid_settings)
+
+    # ensure axs is a list
+    if not isinstance(axs, Iterable):
+        axs = [axs]
+    if not isinstance(title, Iterable):
+        title = [title]
+
+    handle_abc_labels(axs, abc, **kwargs)
+
+    pairs = list(zip(axs, cycle(title)))
+
+    for ax, title in pairs:
+        # handle ticks, grid, and spine visibility
+        # NOTE when axis != 'both', ticks=True does weird things... seems to be a matplotlib issue
+        handle_tick_settings(ax, axis, ticks, minor, grid, tick_settings)
+
+        # handle other layout elements
+        handle_title(ax, title, title_settings)
+        handle_labels(ax, axis, x_label, y_label, label_settings)
+        handle_tick_labels(ax, x_tick_labels, y_tick_labels)
+
+        handle_spines(ax, spines)
+        handle_breaks(ax, x_breaks, y_breaks)
+        handle_scales(ax, x_scale, y_scale)
+        handle_lims(ax, x_lims, y_lims)
+
+        handle_aspect(ax, aspect)
+
+        # TODO when x_lim/y_lim are set, margins don't work as expected
+        handle_margins(ax, margins, make_square)
+
+        if make_square is True:
+            tools.axis_ratio(ax, yx_ratio=1, margins=margins, how='lims')
+
+
+def handle_abc_labels(axs, abc=None, **kwargs):
+    if abc:
+        ax_labels = np.arange(1, len(axs) + 1)
+        if abc == 'ABC':
+            ax_labels = [chr(64 + num) for num in ax_labels]
+        elif abc == 'abc':
+            ax_labels = [chr(96 + num) for num in ax_labels]
+
+        abc_params = utils.get_hook_dict(kwargs, 'abc')
+        abc_params['loc'] = abc_params['loc'] if 'loc' in abc_params else 'tl'
+        abc_params['size'] = abc_params['size'] if 'size' in abc_params else 18
+        for i, ax in enumerate(axs):
+            decs.place_abc_label(
+                ax,
+                label=ax_labels[i],
+                pad=0.2,
+                **abc_params,
+            )
+
+
+def handle_tick_grid_vis(ax, axis, ticks, minor, grid, tick_settings):
+    tools.set_minor_ticks_by_axis(ax, axis=axis)
+    minor = False if minor is None else minor
+
+    tools.set_tick_visibility(ax, axis=axis, ticks=ticks, minor=minor)
+
+    # set axis below if no grid zorder is specified to make sure grid lines are below other plot elements
+    ax_below = False if 'grid_zorder' in tick_settings else True
+    ax.set_axisbelow(ax_below)
+
+    maj_grid, min_grid = tools.set_grid_visibility(ax, axis=axis, grid=grid, minor=minor, apply=False)
+    tick_settings['gridOn'] = [maj_grid, min_grid]
+
+    # Set default grid style, since rcParams don't offer minor grid style
+    if 'grid_linestyle' not in tick_settings:
+        tick_settings['grid_linestyle'] = [major_grid_style, minor_grid_style]
+
+
+def handle_text_element(getter, setter, text: str = None, params: dict = {}):
+    """Generic helper to get current text if needed and set it with params."""
+    if text is None and len(params) == 0:
+        return
+
+    if text is None and len(params) > 0:
+        text = getter()
+
+    setter(text, **params)
+
+
+def handle_tick_settings(ax, axis, ticks, minor, grid, tick_settings):
+    if ticks is None and minor is None and grid is None and len(tick_settings) == 0:
+        return
+
+    # first all the visibility settings
+    handle_tick_grid_vis(ax, axis, ticks, minor, grid, tick_settings)
+
+    # tick (and grid) settings are applied separately for major and minor ticks
+    majmin_settings = {k: utils.maj_min_args(maj_min=v) for k, v in tick_settings.items()}
+
+    for i, which in enumerate(['major', 'minor']):
+        tick_settings_select = {k: v[i] for k, v in majmin_settings.items()}
+        ax.tick_params(axis=axis, which=which, **tick_settings_select)
+
+
+def handle_spines(ax, spines):
+    if spines is not None:
+        tools.set_spine_visibility(ax, spines)
+
+
+def handle_aspect(ax, aspect):
+    if aspect is not None:
+        aspect = [aspect] if not isinstance(aspect, (list, tuple)) else aspect
+        adjustable = None if len(aspect) < 2 else aspect[1]
+        aspect_params = {'aspect': aspect[0], 'adjustable': adjustable}
+        ax.set_aspect(**aspect_params)
+
+
+def handle_breaks(ax, x_breaks, y_breaks):
+    if x_breaks is not None:
+        ax.set_xticks(x_breaks)
+
+    if y_breaks is not None:
+        ax.set_yticks(y_breaks)
+
+
+def handle_scales(ax, x_scale, y_scale):
+    if y_scale is not None:
+        scale_params = tools.parse_scale(scale=y_scale)
+        ax.set_yscale(**scale_params)
+
+    if x_scale is not None:
+        scale_params = tools.parse_scale(scale=x_scale)
+        ax.set_xscale(**scale_params)
+
+
+def handle_lims(ax, x_lims, y_lims):
+    if y_lims is not None:
+        ax.set_ylim(y_lims)
+
+    if x_lims is not None:
+        ax.set_xlim(x_lims)
+
+
+def handle_title(ax, title, title_params):
+    if title is None and len(title_params) == 0:
+        return
+
+    if title is None:
+        title = ax.get_title()
+        title = None if len(title) == 0 else title
+
+    if title is not None or len(title_params) > 0:
+        handle_text_element(ax.get_title, ax.set_title, title, title_params)
+
+
+def handle_labels(ax, axis, x_label, y_label, label_params):
+    if x_label is None and y_label is None and len(label_params) == 0:
+        return
+
+    loc_lookup = {
+        'x': {'start': 'left', 'center': 'center', 'end': 'right'},
+        'y': {'start': 'bottom', 'center': 'center', 'end': 'top'},
+    }
+
+    def normalize_params(axis_key: str, params: dict | None) -> dict:
+        params = params or {}
+        loc = params.get('loc')
+        if loc is not None:
+            try:
+                params['loc'] = loc_lookup[axis_key][loc]
+            except KeyError:
+                raise ValueError(
+                    f"Invalid {axis_key} label loc '{loc}'. Valid options are {list(loc_lookup[axis_key])}."
+                )
+        return params
+
+    x_label_params = normalize_params('x', label_params.copy()) if axis in ['x', 'both'] else {}
+    y_label_params = normalize_params('y', label_params.copy()) if axis in ['y', 'both'] else {}
+
+    handle_text_element(ax.get_xlabel, ax.set_xlabel, x_label, x_label_params)
+    handle_text_element(ax.get_ylabel, ax.set_ylabel, y_label, y_label_params)
+
+
+def handle_tick_labels(ax, x_tick_labels, y_tick_labels):
+    if x_tick_labels is not None:
+        ax.set_xticklabels(x_tick_labels)
+
+    if y_tick_labels is not None:
+        ax.set_yticklabels(y_tick_labels)
+
+
+def handle_margins(ax, margins, make_square):
+    if margins is not None and not make_square:
+        xmargin, ymargin = utils.maj_min_args(margins)
+
+        ax.set_xmargin(xmargin)
+        ax.set_ymargin(ymargin)