dataplot 0.1.6__tar.gz → 0.1.8__tar.gz

{dataplot-0.1.6 → dataplot-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataplot
-Version: 0.1.6
+Version: 0.1.8
 Summary: Provides plotting tools useful in datascience.
 Project-URL: Documentation, https://github.com/Chitaoji/dataplot/blob/main/README.md
 Project-URL: Repository, https://github.com/Chitaoji/dataplot/
@@ -10,9 +10,10 @@ License-Expression: BSD-3-Clause
 License-File: LICENSE
 Keywords: plot
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Requires-Dist: lazyr
+Requires-Dist: loggings
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: pandas
@@ -33,6 +34,7 @@ $ pip install dataplot
 ```txt
 validating
 lazyr
+loggings
 matplotlib
 numpy
 pandas
@@ -51,6 +53,19 @@ seaborn
 This project falls under the BSD 3-Clause License.
 
 ## History
+### v0.1.8
+* Improved naming inference in `dp.data(...)` when decorators from `validating` are involved.
+* Refined module exports around artist helpers to make wildcard-style artist imports behave consistently.
+* Refactored plot-setting fallback behavior to use `dp.defaults` as the global source of defaults.
+* Enhanced `get_setting(...)` (including overload/type-hint coverage) so default values align with the corresponding setting types, and dict defaults are handled more safely.
+* Removed legacy `set_default()` usage and simplified setting application paths across artists/containers.
+* Added dependency `loggings` and updated warning emission in figure setting flows.
+
+### v0.1.7
+* `dp.data(...)` can accept `PlotDataSet` objects now.
+* `FigWrapper.__enter__()` now returns a copy safely via `_entered_copy`.
+* Internal maintenance and stability refinements.
+
 ### v0.1.6
 * New method `PlotDataSet.scatter()` to draw true scatter charts while keeping `PlotDataSet.plot()` as line chart behavior.
 * Improved automatic label inference for `dp.data(...)`, plotting labels, and x-axis labels in interactive contexts.

{dataplot-0.1.6 → dataplot-0.1.8}/README.md

@@ -10,6 +10,7 @@ $ pip install dataplot
 ```txt
 validating
 lazyr
+loggings
 matplotlib
 numpy
 pandas
@@ -28,6 +29,19 @@ seaborn
 This project falls under the BSD 3-Clause License.
 
 ## History
+### v0.1.8
+* Improved naming inference in `dp.data(...)` when decorators from `validating` are involved.
+* Refined module exports around artist helpers to make wildcard-style artist imports behave consistently.
+* Refactored plot-setting fallback behavior to use `dp.defaults` as the global source of defaults.
+* Enhanced `get_setting(...)` (including overload/type-hint coverage) so default values align with the corresponding setting types, and dict defaults are handled more safely.
+* Removed legacy `set_default()` usage and simplified setting application paths across artists/containers.
+* Added dependency `loggings` and updated warning emission in figure setting flows.
+
+### v0.1.7
+* `dp.data(...)` can accept `PlotDataSet` objects now.
+* `FigWrapper.__enter__()` now returns a copy safely via `_entered_copy`.
+* Internal maintenance and stability refinements.
+
 ### v0.1.6
 * New method `PlotDataSet.scatter()` to draw true scatter charts while keeping `PlotDataSet.plot()` as line chart behavior.
 * Improved automatic label inference for `dp.data(...)`, plotting labels, and x-axis labels in interactive contexts.

{dataplot-0.1.6 → dataplot-0.1.8}/examples/test.ipynb

@@ -126,7 +126,7 @@
    "outputs": [],
    "source": [
     "dp.figure(\n",
-    "    [a0, a1, a2, a3, a4, a5], title=\"Figure Collections\", subplots_adjust={\"top\": 0.92}\n",
+    "    a0, a1, a2, a3, a4, a5, title=\"Figure Collections\", subplots_adjust={\"top\": 0.92}\n",
     ")"
    ]
   }

{dataplot-0.1.6 → dataplot-0.1.8}/pyproject.toml

@@ -4,10 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "dataplot"
-version = "0.1.6"
+version = "0.1.8"
 dependencies = [
     "validating",
     "lazyr",
+    "loggings",
     "matplotlib",
     "numpy",
     "pandas",
@@ -28,7 +29,7 @@ license-files = ["LICENSE"]
 keywords = ["plot"]
 classifiers = [
   "Programming Language :: Python :: 3",
-  "Programming Language :: Python :: 3.12"
+  "Programming Language :: Python :: 3.13"
 ]
 
 [project.urls]

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/_typing.py

@@ -12,7 +12,6 @@ if TYPE_CHECKING:
 
 
 PlotSettableVar = TypeVar("PlotSettableVar", bound="PlotSettable")
-DefaultVar = TypeVar("DefaultVar")
 StyleName = Literal[
     "Solarize_Light2",
     "_classic_test_patch",

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/corrmap.py

@@ -45,7 +45,7 @@ class CorrMap(Plotter):
         arrays.append(self.data)
         labels.append(self.label)
         if __multi_is_final__:
-            ax.set_default(title="Correlation Heatmap")
+            ax.set_axes(title=ax.get_setting("title", "Correlation Heatmap"))
             ax.load(self.settings)
             self.__plot(ax, arrays, labels)
         return arrays, labels

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/histogram.py

@@ -41,11 +41,11 @@ class Histogram(Plotter):
         __multi_prev_returned__: Optional[tuple[str, np.ndarray]] = None,
         __multi_is_final__: bool = True,
     ) -> list[float]:
-        ax.set_default(
-            title="Histogram",
-            alpha=0.8,
-            xlabel="value",
-            ylabel="density" if self.density else "count",
+        ax.set_axes(
+            title=ax.get_setting("title", "Histogram"),
+            alpha=ax.get_setting("alpha", 0.8),
+            xlabel=ax.get_setting("xlabel", "value"),
+            ylabel=ax.get_setting("ylabel", "density" if self.density else "count"),
         )
         ax.load(self.settings)
         if __multi_prev_returned__ is None:

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/ksplot.py

@@ -27,10 +27,10 @@ class KSPlot(QQPlot):
     """
 
     def paint(self, ax: "AxesWrapper", **_) -> None:
-        ax.set_default(
-            title="Kolmogorov-Smirnov Plot",
-            xlabel="value",
-            ylabel="cummulative probability",
+        ax.set_axes(
+            title=ax.get_setting("title", "Kolmogorov-Smirnov Plot"),
+            xlabel=ax.get_setting("xlabel", "value"),
+            ylabel=ax.get_setting("ylabel", "cummulative probability"),
         )
         ax.load(self.settings)
         self.__plot(ax)

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/linechart.py

@@ -34,7 +34,7 @@ class LineChart(Plotter):
     sorted: bool
 
     def paint(self, ax: "AxesWrapper", **_) -> None:
-        ax.set_default(title="Line Chart")
+        ax.set_axes(title=ax.get_setting("title", "Line Chart"))
         ax.load(self.settings)
         self.__plot(ax)
 

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/ppplot.py

@@ -26,10 +26,10 @@ class PPPlot(QQPlot):
     """
 
     def paint(self, ax: "AxesWrapper", **_) -> None:
-        ax.set_default(
-            title="Probability-Probability Plot",
-            xlabel="cumulative probility",
-            ylabel="cumulative probility",
+        ax.set_axes(
+            title=ax.get_setting("title", "Probability-Probability Plot"),
+            xlabel=ax.get_setting("xlabel", "cumulative probility"),
+            ylabel=ax.get_setting("ylabel", "cumulative probility"),
         )
         ax.load(self.settings)
         self.__plot(ax)

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/qqplot.py

@@ -37,10 +37,10 @@ class QQPlot(Plotter):
     fmt: str
 
     def paint(self, ax: "AxesWrapper", **_) -> None:
-        ax.set_default(
-            title="Quantile-Quantile Plot",
-            xlabel="quantiles",
-            ylabel="quantiles",
+        ax.set_axes(
+            title=ax.get_setting("title", "Quantile-Quantile Plot"),
+            xlabel=ax.get_setting("xlabel", "quantiles"),
+            ylabel=ax.get_setting("ylabel", "quantiles"),
         )
         ax.load(self.settings)
         self.__plot(ax)

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/artist/scatterchart.py

@@ -33,7 +33,7 @@ class ScatterChart(Plotter):
     sorted: bool
 
     def paint(self, ax: "AxesWrapper", **_) -> None:
-        ax.set_default(title="Scatter Chart")
+        ax.set_axes(title=ax.get_setting("title", "Scatter Chart"))
         ax.load(self.settings)
         self.__plot(ax)
 

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/container.py

@@ -6,17 +6,17 @@ NOTE: this module is private. All functions and objects are available in the mai
 
 """
 
-import logging
-from typing import TYPE_CHECKING, Any, Self, Unpack
+from typing import TYPE_CHECKING, Self, Unpack
 
+import loggings
 import matplotlib.pyplot as plt
 import numpy as np
 from matplotlib.figure import Figure
 from matplotlib.pyplot import Axes
 from validating import attr, dataclass
 
-from ._typing import AxesSettingDict, FigureSettingDict, SettingKey
-from .setting import PlotSettable
+from ._typing import AxesSettingDict, FigureSettingDict
+from .setting import PlotSettable, defaults
 
 if TYPE_CHECKING:
     from .artist import Artist
@@ -74,13 +74,19 @@ class AxesWrapper(PlotSettable):
         self.ax.set_xlabel(self.settings.xlabel)
         self.ax.set_ylabel(self.settings.ylabel)
         if len(self.ax.get_legend_handles_labels()[0]):
-            self.ax.legend(loc=self.settings.legend_loc)
-        if self.get_setting("grid", True):
-            alpha = self.get_setting("alpha", 1.0)
-            self.ax.grid(alpha=self.get_setting("grid_alpha", alpha / 2))
+            self.ax.legend(loc=self.get_setting("legend_loc"))
+        if self.get_setting("grid"):
+            alpha = self.get_setting("alpha")
+            default_grid_alpha = (
+                alpha / 2 if defaults.grid_alpha is None else defaults.grid_alpha
+            )
+            self.ax.grid(alpha=self.get_setting("grid_alpha", default_grid_alpha))
         else:
             self.ax.grid(False)
-        self.ax.set_title(self.settings.title, **self.get_setting("fontdict", {}))
+        self.ax.set_title(
+            self.settings.title,
+            **(self.get_setting("fontdict") or {}),
+        )
 
 
 @dataclass(validate_methods=True)
@@ -96,10 +102,16 @@ class FigWrapper(PlotSettable):
     nrows: int = 1
     ncols: int = 1
     active: bool = attr(repr=False, default=True)
-    entered: bool = attr(init=False, repr=False, default=False)
     fig: Figure = attr(init=False, repr=False)
     axes: list[AxesWrapper] = attr(init=False, repr=False)
     artists: "list[Artist]" = attr(default_factory=list, init=False, repr=False)
+    _copy: "FigWrapper | None" = attr(init=False, repr=False, default=None)
+
+    def __repr__(self) -> str:
+        with self as fig:
+            for artist, ax in zip(self.artists, fig.axes[: len(self.artists)]):
+                artist.paint(ax)
+        return f"<{self.__class__.__name__} {self.nrows}x{self.ncols}>"
 
     def __enter__(self) -> Self:
         """
@@ -111,59 +123,61 @@ class FigWrapper(PlotSettable):
             An instance of self.
 
         """
-        if not self.active:
-            return self
-        if self.entered:
+        if self._copy is not None:
             raise DoubleEnteredError(
-                f"can't enter an instance of {self.__class__.__name__!r} for twice; "
-                "please do all the operations in one single context manager"
+                f"calling {self.__class__.__name__}.__enter__() for twice"
             )
 
-        self.set_default(
-            style="seaborn-v0_8-darkgrid",
-            figsize=(10 * self.ncols, 5 * self.nrows),
-            subplots_adjust={"hspace": 0.5},
-            fontdict={"fontsize": "x-large"},
-        )
-        plt.style.use(self.settings.style)
-        self.fig, axes = plt.subplots(self.nrows, self.ncols)
-        self.axes: list[AxesWrapper] = [AxesWrapper(x) for x in np.reshape(axes, -1)]
-        self.entered = True
-        return self
+        figw = self.copy()
+        if not figw.active:
+            self._copy = figw
+            return figw
+
+        plt.style.use(figw.get_setting("style"))
+        figw.fig, axes = plt.subplots(figw.nrows, figw.ncols)
+        figw.axes = [AxesWrapper(x) for x in np.reshape(axes, -1)]
+        self._copy = figw
+        return figw
 
     def __exit__(self, *args) -> None:
         """
         Set various properties for the figure and paint it.
 
         """
-        if not self.active:
+        figw = self._copy
+        if figw is None:
+            raise NotEnteredError(
+                f"calling {self.__class__.__name__}.__exit__(...) before entering"
+            )
+
+        if not figw.active:
+            self._copy = None
             return
 
-        if len(self.axes) > 1:
-            self.fig.suptitle(self.settings.title, **self.settings.fontdict)
+        fontdict = figw.get_setting("fontdict") or {}
+        if len(figw.axes) > 1:
+            figw.fig.suptitle(figw.settings.title, **fontdict)
         else:
-            self.axes[0].ax.set_title(self.settings.title, **self.settings.fontdict)
+            figw.axes[0].ax.set_title(figw.settings.title, **fontdict)
 
-        self.fig.set_size_inches(*self.settings.figsize)
-        self.fig.subplots_adjust(**self.settings.subplots_adjust)
-        self.fig.set_dpi(self.get_setting("dpi", 100))
+        default_figsize = (
+            defaults.figsize[0] * figw.ncols if defaults.figsize else 10 * figw.ncols,
+            defaults.figsize[1] * figw.nrows if defaults.figsize else 5 * figw.nrows,
+        )
+        figw.fig.set_size_inches(*figw.get_setting("figsize", default_figsize))
+        figw.fig.subplots_adjust(**(figw.get_setting("subplots_adjust") or {}))
+        figw.fig.set_dpi(figw.get_setting("dpi"))
 
-        for ax in self.axes:
+        for ax in figw.axes:
             ax.exit()
             if not ax.ax.has_data():
-                self.fig.delaxes(ax.ax)
+                figw.fig.delaxes(ax.ax)
 
         plt.show()
-        plt.close(self.fig)
+        plt.close(figw.fig)
         plt.style.use("default")
 
-        self.entered = False
-
-    def __repr__(self) -> str:
-        with self as fig:
-            for artist, ax in zip(self.artists, fig.axes[: len(self.artists)]):
-                artist.paint(ax)
-        return f"<{self.__class__.__name__}(nrows={self.nrows}, ncols={self.ncols})>"
+        self._copy = None
 
     def set_figure(self, **kwargs: Unpack[FigureSettingDict]) -> None:
         """
@@ -173,7 +187,7 @@ class FigWrapper(PlotSettable):
         ----------
         title : str, optional
             Title of figure. Please note that there's another parameter with
-            the same name in `.set_axis()`.
+            the same name in `.set_axes()`.
         dpi : float, optional
             Sets the resolution of figure in dots-per-inch.
         style : StyleName, optional
@@ -188,16 +202,33 @@ class FigWrapper(PlotSettable):
             top, wspace, and hspace. See `SubplotDict` for more details.
 
         """
-        self._set(inplace=True, **kwargs)
-
-    def setting_check(self, key: SettingKey, value: Any) -> None:
-        if self.entered and key == "style":
-            logging.warning(
-                "setting the '%s' of a figure has no effect unless it's done "
+        if "style" in kwargs and (self._copy is not None):
+            loggings.warning(
+                "setting the 'style' of a figure has no effect unless it's done "
                 "before invoking context manager",
-                key,
             )
+        self._set(inplace=True, **kwargs)
+
+    def copy(self) -> Self:
+        """Get a copy of self."""
+        obj = self.customize(
+            self.__class__,
+            nrows=self.nrows,
+            ncols=self.ncols,
+            active=self.active,
+        )
+        obj.artists = self.artists
+        obj._copy = None
+        return obj
+
+    def set_artists(self, *artist: "Artist") -> None:
+        """Set artists."""
+        self.artists = list(artist)
 
 
 class DoubleEnteredError(Exception):
     """Raised when entering a Figwrapper for twice."""
+
+
+class NotEnteredError(Exception):
+    """Raised when exiting a Figwrapper that is not entered yet."""

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/core.py

@@ -10,9 +10,11 @@ import dis
 import re
 import sys
 from math import ceil, sqrt
+from types import FrameType
 from typing import TYPE_CHECKING, Any, Optional, Unpack
 
 import numpy as np
+from validating import validate
 
 from ._typing import FigureSettingDict
 from .container import FigWrapper
@@ -25,10 +27,32 @@ if TYPE_CHECKING:
 __all__ = ["data", "figure"]
 
 
-def _infer_var_names(*values: Any) -> list[Optional[str]]:
+def _find_user_frame(start_depth: int = 1) -> FrameType | None:
+    """
+    Find the nearest frame belonging to user code.
+
+    This skips internal dataplot core frames and validating wrappers so helper
+    functions keep working when `data()`/`figure()` are decorated.
+    """
     try:
-        search_frame = sys._getframe(1)
+        current = sys._getframe(start_depth)
     except ValueError:
+        return None
+
+    try:
+        while current is not None:
+            module_name = str(current.f_globals.get("__name__", ""))
+            if module_name != __name__ and not module_name.startswith("validating"):
+                return current
+            current = current.f_back
+        return None
+    finally:
+        del current
+
+
+def _infer_var_names(*values: Any) -> list[Optional[str]]:
+    search_frame = _find_user_frame(start_depth=2)
+    if search_frame is None:
         return [None] * len(values)
 
     labels: list[Optional[str]] = []
@@ -51,9 +75,8 @@ def _infer_var_names(*values: Any) -> list[Optional[str]]:
 
 def _infer_assigned_name() -> Optional[str]:
     """Try inferring assignment target name from call-site."""
-    try:
-        frame = sys._getframe(2)
-    except ValueError:
+    frame = _find_user_frame(start_depth=2)
+    if frame is None:
         return None
 
     # Bytecode inspection works in REPL/notebook contexts where source code file
@@ -101,6 +124,7 @@ def _infer_assigned_name() -> Optional[str]:
     return m.group(1) if m else None
 
 
+@validate
 def data(*x: Any, label: Optional[str | list[str]] = None) -> PlotDataSet:
     """
     Initializes a dataset interface which provides methods for mathematical
@@ -126,21 +150,43 @@ def data(*x: Any, label: Optional[str | list[str]] = None) -> PlotDataSet:
     if not x:
         raise ValueError("at least one dataset should be provided")
 
-    if len(x) > 1:
+    expanded_data: list[Any] = []
+    expanded_names: list[Optional[str]] = []
+    inferred_names = _infer_var_names(*x)
+    for i, value in enumerate(x):
+        if isinstance(value, PlotDataSets):
+            expanded_data.extend(value.__multiobjects__)
+            expanded_names.extend([None] * len(value.__multiobjects__))
+        else:
+            expanded_data.append(value)
+            expanded_names.append(inferred_names[i])
+
+    normalized_data: list[np.ndarray] = []
+    for value in expanded_data:
+        if isinstance(value, PlotDataSet):
+            normalized_data.append(np.array(value.data))
+        else:
+            normalized_data.append(np.array(value))
+
+    if len(expanded_data) > 1:
         if label is None:
-            label = [
-                lb if lb is not None else f"x{i}"
-                for i, lb in enumerate(_infer_var_names(*x), start=1)
-            ]
+            label = []
+            for i, (d, inferred_name) in enumerate(
+                zip(expanded_data, expanded_names), start=1
+            ):
+                if isinstance(d, PlotDataSet):
+                    label.append(d.formatted_label())
+                else:
+                    label.append(
+                        inferred_name if inferred_name is not None else f"x{i}"
+                    )
         elif isinstance(label, str):
             raise ValueError(
                 "for multiple datasets, please provide labels as a list of strings"
             )
-        elif len(label) != len(x):
-            raise ValueError(
-                f"label should have the same length as x ({len(x)}), got {len(label)}"
-            )
-        datas = [PlotDataSet(np.array(d), lb) for d, lb in zip(x, label)]
+        elif len(label) != len(expanded_data):
+            raise ValueError(f"expected {len(expanded_data)} labels, got {len(label)}")
+        datas = [PlotDataSet(d, lb) for d, lb in zip(normalized_data, label)]
         return PlotDataSets(*datas)
 
     if isinstance(label, list):
@@ -149,12 +195,18 @@ def data(*x: Any, label: Optional[str | list[str]] = None) -> PlotDataSet:
             "the data has only one dimension"
         )
     if label is None:
-        label = _infer_assigned_name() or _infer_var_names(x[0])[0] or "x1"
-    return PlotDataSet(np.array(x[0]), label=label)
+        original_label = (
+            expanded_data[0].label
+            if isinstance(expanded_data[0], PlotDataSet)
+            else None
+        )
+        label = original_label or _infer_assigned_name() or expanded_names[0] or "x1"
+    return PlotDataSet(normalized_data[0], label=label)
 
 
+@validate
 def figure(
-    artist: "Artist | list[Artist]",
+    *artists: "Artist",
     nrows: int | None = None,
     ncols: int | None = None,
     **kwargs: Unpack[FigureSettingDict],
@@ -165,8 +217,8 @@ def figure(
 
     Parameters
     ----------
-    artist : Artist | list[Artist]
-        Artist or list of artists.
+    *artist : Artist
+        List of artists.
     nrows : int, optional
         Determines how many subplots can be arranged vertically in the figure,
         If None, will be automatically set according to ``len(artist)``. By default
@@ -184,9 +236,7 @@ def figure(
         A wrapper of figure.
 
     """
-    if not isinstance(artist, list):
-        artist = [artist]
-    len_a = max(len(artist), 1)
+    len_a = max(len(artists), 1)
     if nrows is None and ncols is None:
         ncols = int(sqrt(len_a))
         nrows = ceil(len_a / ncols)
@@ -198,5 +248,5 @@ def figure(
         nrows = ceil(len_a / ncols)
     figw = FigWrapper(nrows=nrows, ncols=ncols)
     figw.set_figure(**kwargs)
-    figw.artists = artist
+    figw.set_artists(*artists)
     return figw

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/dataset.py

@@ -131,7 +131,7 @@ class PlotDataSet(PlotSettable, metaclass=ABCMeta):
             A string indicating the data label and the plot settings.
 
         """
-        not_none = self.settings.repr_not_none()
+        not_none = self.settings._repr_changes()
         return f"{self.formatted_label()}{': ' if not_none else ''}{not_none}"
 
     def __getitem__(self, __key: int) -> Self | Any:

{dataplot-0.1.6 → dataplot-0.1.8}/src/dataplot/setting.py

@@ -7,12 +7,11 @@ NOTE: this module is private. All functions and objects are available in the mai
 """
 
 from dataclasses import asdict
-from typing import Any, Optional, Self, Unpack
+from typing import Any, Literal, Optional, Self, Unpack, overload
 
 from validating import attr, dataclass
 
 from ._typing import (
-    DefaultVar,
     FontDict,
     PlotSettableVar,
     SettingDict,
@@ -21,7 +20,7 @@ from ._typing import (
     SubplotDict,
 )
 
-__all__ = ["PlotSettings", "PlotSettable"]
+__all__ = ["PlotSettings", "PlotSettable", "defaults"]
 
 
 @dataclass(validate_methods=True)
@@ -32,7 +31,7 @@ class PlotSettings:
     xlabel: Optional[str] = None
     ylabel: Optional[str] = None
     alpha: Optional[float] = None
-    dpi: Optional[float] = None
+    dpi: Optional[int | float] = None
     grid: Optional[bool] = None
     grid_alpha: Optional[float] = None
     style: Optional[StyleName] = None
@@ -41,16 +40,87 @@ class PlotSettings:
     legend_loc: Optional[str] = None
     subplots_adjust: Optional[SubplotDict] = None
 
+    @overload
+    def __getitem__(
+        self, __key: Literal["title", "xlabel", "ylabel"]
+    ) -> Optional[str]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["alpha", "grid_alpha"]) -> Optional[float]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["dpi"]) -> Optional[int | float]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["grid"]) -> Optional[bool]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["style"]) -> Optional[StyleName]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["figsize"]) -> Optional[tuple[int, int]]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["fontdict"]) -> Optional[FontDict]: ...
+
+    @overload
+    def __getitem__(self, __key: Literal["legend_loc"]) -> Optional[str]: ...
+
+    @overload
+    def __getitem__(
+        self, __key: Literal["subplots_adjust"]
+    ) -> Optional[SubplotDict]: ...
+
     def __getitem__(self, __key: SettingKey) -> Any:
         return getattr(self, __key)
 
+    @overload
+    def __setitem__(
+        self,
+        __key: Literal["title", "xlabel", "ylabel", "legend_loc"],
+        __value: Optional[str],
+    ) -> None: ...
+
+    @overload
+    def __setitem__(
+        self, __key: Literal["alpha", "grid_alpha"], __value: Optional[float]
+    ) -> None: ...
+
+    @overload
+    def __setitem__(
+        self, __key: Literal["dpi"], __value: Optional[int | float]
+    ) -> None: ...
+
+    @overload
+    def __setitem__(self, __key: Literal["grid"], __value: Optional[bool]) -> None: ...
+
+    @overload
+    def __setitem__(
+        self, __key: Literal["style"], __value: Optional[StyleName]
+    ) -> None: ...
+
+    @overload
+    def __setitem__(
+        self, __key: Literal["figsize"], __value: Optional[tuple[int, int]]
+    ) -> None: ...
+
+    @overload
+    def __setitem__(
+        self, __key: Literal["fontdict"], __value: Optional[FontDict]
+    ) -> None: ...
+
+    @overload
+    def __setitem__(
+        self, __key: Literal["subplots_adjust"], __value: Optional[SubplotDict]
+    ) -> None: ...
+
     def __setitem__(self, __key: SettingKey, __value: Any) -> None:
         setattr(self, __key, __value)
 
     def __repr__(self) -> str:
-        return self.__class__.__name__ + "(" + self.repr_not_none() + ")"
+        return self.__class__.__name__ + "(" + self._repr_changes() + ")"
 
-    def repr_not_none(self) -> str:
+    def _repr_changes(self) -> str:
         """
         Returns a string representation of attributes with not-None values.
 
@@ -70,11 +140,23 @@ class PlotSettings:
         Returns
         -------
         list[SettingKey]
-            Keys of the settings.
+            List of keys.
 
         """
         return getattr(self, "__match_args__")
 
+    def values(self) -> list:
+        """
+        Values of settings.
+
+        Returns
+        -------
+        list
+            List of values.
+
+        """
+        return [self[x] for x in self.keys()]
+
     def reset(self) -> None:
         """
         Reset all the settings to None.
@@ -84,6 +166,18 @@ class PlotSettings:
             self[k] = None
 
 
+defaults = PlotSettings(
+    alpha=1.0,
+    dpi=100,
+    grid=True,
+    grid_alpha=0.5,
+    style="seaborn-v0_8-darkgrid",
+    figsize=(10, 5),
+    fontdict={"fontsize": "x-large"},
+    subplots_adjust={"hspace": 0.5},
+)
+
+
 @dataclass(init=False)
 class PlotSettable:
     """Contains an attribute of plot settings, and provides methods for
@@ -101,7 +195,6 @@ class PlotSettable:
         for k, v in kwargs.items():
             if v is None or k not in keys:
                 continue
-            obj.setting_check(k, v)
             if isinstance(v, dict) and isinstance(d := obj.settings[k], dict):
                 d.update(v)
             else:
@@ -109,38 +202,6 @@ class PlotSettable:
         if not inplace:
             return obj
 
-    def setting_check(self, key: SettingKey, value: Any) -> None:
-        """
-        Checks if a new setting is legal.
-
-        Parameters
-        ----------
-        key : SettingKey
-            Key of the setting.
-        value : Any
-            Value of the setting.
-
-        """
-
-    def set_default(self, **kwargs: Unpack[SettingDict]) -> None:
-        """
-        Sets the default settings.
-
-        Parameters
-        ----------
-        **kwargs : Unpack[SettingDict]
-            Specifies the settings.
-
-        """
-        keys = self.settings.keys()
-        for k, v in kwargs.items():
-            if k not in keys:
-                continue
-            if self.settings[k] is None:
-                self.settings[k] = v
-            elif isinstance(d := self.settings[k], dict):
-                self.settings[k] = {**v, **d}
-
     def load(self, settings: "PlotSettings | SettingDict") -> None:
         """
         Load in the settings.
@@ -155,9 +216,49 @@ class PlotSettable:
             settings = asdict(settings)
         self._set(inplace=True, **settings)
 
+    @overload
+    def get_setting(
+        self,
+        key: Literal["title", "xlabel", "ylabel", "legend_loc"],
+        default: Optional[str] = None,
+    ) -> Optional[str]: ...
+
+    @overload
     def get_setting(
-        self, key: SettingKey, default: Optional[DefaultVar] = None
-    ) -> "DefaultVar | Any":
+        self, key: Literal["alpha", "grid_alpha"], default: Optional[float] = None
+    ) -> Optional[float]: ...
+
+    @overload
+    def get_setting(
+        self, key: Literal["dpi"], default: Optional[int | float] = None
+    ) -> Optional[int | float]: ...
+
+    @overload
+    def get_setting(
+        self, key: Literal["grid"], default: Optional[bool] = None
+    ) -> Optional[bool]: ...
+
+    @overload
+    def get_setting(
+        self, key: Literal["style"], default: Optional[StyleName] = None
+    ) -> Optional[StyleName]: ...
+
+    @overload
+    def get_setting(
+        self, key: Literal["figsize"], default: Optional[tuple[int, int]] = None
+    ) -> Optional[tuple[int, int]]: ...
+
+    @overload
+    def get_setting(
+        self, key: Literal["fontdict"], default: Optional[FontDict] = None
+    ) -> Optional[FontDict]: ...
+
+    @overload
+    def get_setting(
+        self, key: Literal["subplots_adjust"], default: Optional[SubplotDict] = None
+    ) -> Optional[SubplotDict]: ...
+
+    def get_setting(self, key: SettingKey, default: Any = None) -> Any:
         """
         Returns the value of a setting if it is not None, otherwise returns the
         default value.
@@ -166,17 +267,24 @@ class PlotSettable:
         ----------
         key : SettingKey
             Key of the setting.
-        default : DefaultVar, optional
+        default : Any, optional
             Specifies the default value to be returned if the requested value
-            is None, by default None.
+            is None. If None, falls back to ``defaults[key]``. By default None.
 
         Returns
         -------
-        DefaultVar | Any
+        Any
             Value of the setting.
 
         """
-        return default if (value := self.settings[key]) is None else value
+        if default is None:
+            default = defaults[key]
+
+        if (value := self.settings[key]) is None:
+            return default
+        if isinstance(value, dict) and isinstance(default, dict):
+            return {**default, **value}
+        return value
 
     def customize(
         self, cls: type["PlotSettableVar"], *args, **kwargs