datavizlib 0.1.0__tar.gz

datavizlib-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Philipp Melzer
+
+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.

datavizlib-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: datavizlib
+Version: 0.1.0
+Summary: Opinionated matplotlib-based library for clean, presentation-ready charts and visual storytelling.
+Author-email: Philipp Melzer <philipp.melzer@icloud.com>
+License: MIT License
+        
+        Copyright (c) 2026 Philipp Melzer
+        
+        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.
+        
+Project-URL: Repository, https://github.com/phmelzer/datavizlib
+Keywords: data visualization,matplotlib,charting,plotting
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: pandas>=2.0
+Dynamic: license-file
+
+# 📊 datavizlib
+
+Opinionated matplotlib-based Python tooling for building clean, consistent, presentation-ready charts.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install datavizlib
+```
+
+Or install locally for development:
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from datavizlib import LineChart
+
+chart = LineChart(
+    title="Monthly revenue",
+    subtitle="Actual vs forecast",
+    x_label="Month",
+    y_label="Revenue"
+)
+
+chart.build()
+chart.add_data(df, x="month", y="revenue", linestyle="solid")
+chart.add_data(df, x="month", y="forecast", linestyle="dotted")
+chart.render()
+```
+
+## Contributing
+
+Contributions are welcome.
+
+## License
+
+`datavizlib` is released under the MIT License. See `LICENSE` for details.

datavizlib-0.1.0/README.md

@@ -0,0 +1,43 @@
+# 📊 datavizlib
+
+Opinionated matplotlib-based Python tooling for building clean, consistent, presentation-ready charts.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install datavizlib
+```
+
+Or install locally for development:
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from datavizlib import LineChart
+
+chart = LineChart(
+    title="Monthly revenue",
+    subtitle="Actual vs forecast",
+    x_label="Month",
+    y_label="Revenue"
+)
+
+chart.build()
+chart.add_data(df, x="month", y="revenue", linestyle="solid")
+chart.add_data(df, x="month", y="forecast", linestyle="dotted")
+chart.render()
+```
+
+## Contributing
+
+Contributions are welcome.
+
+## License
+
+`datavizlib` is released under the MIT License. See `LICENSE` for details.

datavizlib-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "datavizlib"
+version = "0.1.0"
+authors = [
+    {name = "Philipp Melzer", email = "philipp.melzer@icloud.com"}
+]
+description = "Opinionated matplotlib-based library for clean, presentation-ready charts and visual storytelling."
+readme = "README.md"
+requires-python = ">=3.8"
+keywords = ["data visualization", "matplotlib", "charting", "plotting"]
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent"
+]
+dependencies = [
+    "matplotlib>=3.8",
+    "pandas>=2.0"
+]
+
+license = {file = "LICENSE"}
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[project.urls]
+Repository = "https://github.com/phmelzer/datavizlib"

datavizlib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

datavizlib-0.1.0/src/datavizlib/__init__.py

@@ -0,0 +1,6 @@
+"""datavizlib - An opinionated Python library for building clean, consistent data visualizations."""
+
+from datavizlib.charts.base import BaseChart
+from datavizlib.charts.line import LineChart
+
+__all__ = ["BaseChart", "LineChart"]

datavizlib-0.1.0/src/datavizlib/charts/__init__.py

@@ -0,0 +1,4 @@
+from .base import BaseChart
+from .line import LineChart
+
+__all__ = ["BaseChart", "LineChart"]

datavizlib-0.1.0/src/datavizlib/charts/base.py

@@ -0,0 +1,329 @@
+"""
+BaseChart - Base class for building consistent charts.
+
+A minimal, opinionated layer on top of matplotlib that helps create
+charts that are easy to read and quick to understand.
+
+It enforces a consistent layout and visual structure, focusing on alignment, hierarchy,
+and clarity.
+"""
+
+import matplotlib.pyplot as plt
+
+
+class BaseChart:
+    """
+    Base chart class enforcing a clear and consistent layout for data visualizations.
+    """
+
+    # ALDI color palette
+    ALDI_PALETTE = [
+        "#00005F",  # Navy
+        "#FF7800",  # Orange
+        "#FFC800",  # Yellow
+        "#55C3F0",  # Light blue
+        "#D70000",  # Red
+        "#439538",  # Green
+    ]
+
+    FONT_SIZES = {
+        "title": 14,
+        "subtitle": 10,
+        "axis_label": 10,
+        "tick_label": 10,
+        "footnote": 8,
+    }
+
+    def __init__(self, title, x_label, y_label, footnote, subtitle=None):
+        """
+        Initialize chart with required elements.
+
+        Args:
+            title (str)
+            subtitle (str, optional)
+            x_label (str)
+            y_label (str)
+            footnote (str)
+
+        Raises:
+            ValueError: If required parameters are missing.
+        """
+
+        self._validate_inputs(title, x_label, y_label, footnote)
+
+        self.fig, self.ax = plt.subplots()
+
+        self.title = title
+        self.subtitle = subtitle
+        self.x_label = x_label
+        self.y_label = y_label
+        self.footnote = footnote
+
+        self._configure_layout()
+
+        self.color_palette = self.ALDI_PALETTE.copy()
+
+        # Grey as background color leaving black and other colors for stronger contrast
+        self.background_color = "#808080"
+
+        self.black_color = "#000000"
+
+    def _validate_inputs(self, title, x_label, y_label, footnote):
+        """Ensure required elements are provided."""
+        if not title:
+            raise ValueError("title is required")
+        if not x_label or not y_label:
+            raise ValueError("x_label and y_label are required")
+        if not footnote:
+            raise ValueError("footnote is required")
+
+    def _configure_layout(self):
+        """
+        Configure layout with intentional white space.
+
+        Ensures that titles and subtitles have sufficient space and do not
+        overlap with the chart area.
+        """
+
+        if self.subtitle:
+            top_margin = 0.80  # More space for subtitle
+        else:
+            top_margin = 0.88  # Less space needed
+
+        self.fig.subplots_adjust(
+            left=0.0,
+            right=1.0,
+            top=top_margin,
+            bottom=0.15,
+        )
+
+    def _get_color_palette(self):
+        """Return the chart color palette."""
+        return self.color_palette
+
+    def _get_next_color(self, index=0):
+        """Return a color from the palette."""
+        return self.color_palette[index % len(self.color_palette)]
+
+    def add_data(self, df, **kwargs):
+        """
+        Add data to the chart.
+
+        This is a standard interface for all chart types. Subclasses must
+        override this method to implement their specific data handling logic.
+
+        Args:
+            df: pandas DataFrame containing the data
+            **kwargs: Chart-specific arguments (e.g., x, y for LineChart)
+
+        Returns:
+            self for method chaining
+
+        Raises:
+            NotImplementedError: Always (must be overridden by subclass)
+        """
+        raise NotImplementedError("Subclasses must implement add_data()")
+
+    def build(self):
+        """
+        Assemble chart following best practices.
+
+        Steps:
+        1. Remove visual clutter
+        2. Add and style axis labels
+        3. Align labels for readability
+        4. Add title, subtitle, and footnote
+
+        Returns:
+            tuple: (Figure, Axes)
+        """
+
+        # Remove unnecessary spines for better readability
+        self._clean_spines()
+
+        # Add axis labels with proper styling
+        self._add_axis_labels()
+
+        # Style tick labels
+        self.ax.tick_params(
+            axis="both",
+            colors=self.background_color,
+            labelsize=self.FONT_SIZES["tick_label"],
+        )
+
+        # Force layout calculation
+        self.fig.canvas.draw()
+
+        # Align labels to axis boundaries
+        self._align_y_label_to_tick()
+        self._align_x_label_to_tick()
+
+        # Re-draw after label movement
+        self.fig.canvas.draw()
+
+        # Add title elements
+        self._add_title()
+        self._add_subtitle()
+        self._add_footnote()
+
+        return self.fig, self.ax
+
+    def _clean_spines(self):
+        """
+        Remove unnecessary spines.
+
+        Reduces cognitive load and keeps the focus on the data.
+        """
+        self.ax.spines["top"].set_visible(False)
+        self.ax.spines["right"].set_visible(False)
+        self.ax.spines["left"].set_color(self.background_color)
+        self.ax.spines["bottom"].set_color(self.background_color)
+
+    def _add_axis_labels(self):
+        """
+        Add axis labels.
+
+        Labels are styled and positioned to be easy to locate and read quickly.
+        """
+        self.ax.set_xlabel(
+            self.x_label.upper(),
+            rotation=0,
+            ha="left",
+            va="top",
+            fontsize=self.FONT_SIZES["axis_label"],
+            color=self.background_color,
+        )
+        self.ax.xaxis.label.set_color(self.background_color)
+
+        self.ax.set_ylabel(
+            self.y_label.upper(),
+            rotation=90,
+            ha="left",
+            va="top",
+            fontsize=self.FONT_SIZES["axis_label"],
+            color=self.background_color,
+        )
+        self.ax.yaxis.label.set_color(self.background_color)
+
+    def _align_y_label_to_tick(self):
+        """
+        Align y-label top with the top of the y-axis.
+
+        The label's top edge aligns with where the axis line ends,
+        improving scanability and reducing unnecessary eye movement.
+        """
+        renderer = self.fig.canvas.get_renderer()
+
+        # Place at a known reference point to measure offset
+        ref_y = 0.5
+        self.ax.yaxis.set_label_coords(-0.10, ref_y)
+        self.fig.canvas.draw()
+
+        # Measure where the top of the label ended up in axes coords
+        bbox = self.ax.yaxis.label.get_window_extent(renderer=renderer)
+        bbox_axes = bbox.transformed(self.ax.transAxes.inverted())
+
+        # Shift so the label's top (y1) aligns with axis top (1.0)
+        shift = 1.0 - bbox_axes.y1
+        self.ax.yaxis.set_label_coords(-0.10, ref_y + shift)
+
+    def _align_x_label_to_tick(self):
+        """
+        Align x-label left with the start of the x-axis.
+
+        The label's left edge aligns with where the axis line begins,
+        supporting natural left-to-right reading flow.
+        """
+        renderer = self.fig.canvas.get_renderer()
+
+        # Place at a known reference point to measure offset
+        ref_x = 0.5
+        self.ax.xaxis.set_label_coords(ref_x, -0.10)
+        self.fig.canvas.draw()
+
+        # Measure where the left of the label ended up in axes coords
+        bbox = self.ax.xaxis.label.get_window_extent(renderer=renderer)
+        bbox_axes = bbox.transformed(self.ax.transAxes.inverted())
+
+        # Shift so the label's left (x0) aligns with axis start (0.0)
+        shift = 0.0 - bbox_axes.x0
+        self.ax.xaxis.set_label_coords(ref_x + shift, -0.10)
+
+    def _get_ylabel_bbox(self):
+        """Get y-label bounding box in figure coordinates."""
+        renderer = self.fig.canvas.get_renderer()
+        bbox = self.ax.yaxis.label.get_window_extent(renderer=renderer)
+        bbox_fig = bbox.transformed(self.fig.transFigure.inverted())
+
+        return {
+            "x0": bbox_fig.x0,
+            "x1": bbox_fig.x1,
+            "y0": bbox_fig.y0,
+            "y1": bbox_fig.y1,
+            "width": bbox_fig.width,
+            "height": bbox_fig.height,
+        }
+
+    def _add_title(self):
+        """
+        Add main title.
+
+        The title should communicate the key message or insight,
+        not just describe the data.
+        """
+        ylabel_bbox = self._get_ylabel_bbox()
+
+        # Position based on whether subtitle exists
+        y_pos = 0.91 if self.subtitle else 0.94
+
+        self.title_bbox = self.fig.text(
+            ylabel_bbox["x0"],
+            y_pos,
+            self.title,
+            fontsize=self.FONT_SIZES["title"],
+            ha="left",
+        )
+
+    def _add_subtitle(self):
+        """
+        Add subtitle below title.
+
+        Provides context without overloading the main message.
+        """
+        if not self.subtitle:
+            return
+
+        ylabel_bbox = self._get_ylabel_bbox()
+
+        # Fixed offset below title
+        self.fig.text(
+            ylabel_bbox["x0"],
+            0.86,
+            self.subtitle,
+            fontsize=self.FONT_SIZES["subtitle"],
+            ha="left",
+            color=self.background_color,
+        )
+
+    def _add_footnote(self):
+        """
+        Add footnote below chart.
+
+        Aligns with the start of the x-axis for visual consistency.
+        Should include data source and assumptions.
+        """
+        if not self.footnote:
+            return
+
+        # Get the x-axis start (x=0 in axes coords) in figure coordinates
+        x_display, _ = self.ax.transAxes.transform((0, 0))
+        x_fig, _ = self.fig.transFigure.inverted().transform((x_display, 0))
+
+        self.fig.text(
+            x_fig,
+            0.00,
+            self.footnote,
+            fontsize=self.FONT_SIZES["footnote"],
+            ha="left",
+            color=self.background_color,
+        )

datavizlib-0.1.0/src/datavizlib/charts/line.py

@@ -0,0 +1,121 @@
+from datavizlib.charts.base import BaseChart
+import pandas as pd
+
+
+class LineChart(BaseChart):
+    """Line chart implementation for visualizing time series or continuous data."""
+
+    def __init__(self, title, x_label, y_label, footnote, subtitle=None):
+        super().__init__(title, x_label, y_label, footnote, subtitle)
+
+        self._lines = []
+
+    def add_data(
+        self,
+        df,
+        x,
+        y,
+        linestyle="solid",
+        color=None,
+        linewidth=2,
+        marker=None,
+        markersize=6,
+        alpha=1.0,
+        label=None,
+    ):
+        """
+        Add a line to the chart.
+
+        Args:
+            df: pandas DataFrame containing the data
+            x: column name for x-axis
+            y: column name for y-axis
+            linestyle: line style - "solid", "dashed", "dotted", "dashdot" (default: "solid")
+            color: hex color code (e.g., "#FF0000") or None to use palette color (default: None)
+            linewidth: line thickness in points (default: 2)
+            marker: marker style - "o" (circle), "s" (square), "^" (triangle), "D" (diamond),
+                   "*" (star), "x" (X), "+" (plus), None (no marker) (default: None)
+            markersize: size of markers in points (default: 6)
+            alpha: transparency from 0.0 (invisible) to 1.0 (opaque) (default: 1.0)
+            label: label for legend (default: None, no legend entry)
+
+        Returns:
+            self for method chaining
+
+        Raises:
+            ValueError: if df is not a DataFrame or missing required columns
+        """
+
+        if not isinstance(df, pd.DataFrame):
+            raise ValueError("df must be a pandas DataFrame")
+
+        if x not in df.columns:
+            raise ValueError(f"Column '{x}' not found in DataFrame")
+        if y not in df.columns:
+            raise ValueError(f"Column '{y}' not found in DataFrame")
+
+        if color is None:
+            color = self._get_next_color(len(self._lines))
+
+        self._lines.append(
+            {
+                "df": df,
+                "x": x,
+                "y": y,
+                "linestyle": linestyle,
+                "color": color,
+                "linewidth": linewidth,
+                "marker": marker,
+                "markersize": markersize,
+                "alpha": alpha,
+                "label": label,
+            }
+        )
+
+        return self
+
+    def render(self):
+        """
+        Render the line chart with all added lines.
+
+        Returns:
+            tuple: (Figure, Axes)
+        """
+        if not self._lines:
+            raise ValueError("No data added. Call add_data() first.")
+
+        # Track if any lines have labels for legend
+        has_labels = any(line.get("label") for line in self._lines)
+
+        for line in self._lines:
+            df = line["df"]
+            x_col = line["x"]
+            y_col = line["y"]
+            linestyle = line["linestyle"]
+            color = line["color"]
+            linewidth = line["linewidth"]
+            marker = line["marker"]
+            markersize = line["markersize"]
+            alpha = line["alpha"]
+            label = line.get("label")
+
+            x_data = df[x_col]
+            y_data = df[y_col]
+
+            self.ax.plot(
+                x_data,
+                y_data,
+                color=color,
+                linestyle=linestyle,
+                linewidth=linewidth,
+                marker=marker,
+                markersize=markersize,
+                alpha=alpha,
+                label=label,
+            )
+
+        # Add legend if any lines have labels
+        if has_labels:
+            self.ax.legend(loc="best", frameon=False)
+
+        return self.build()

datavizlib-0.1.0/src/datavizlib.egg-info/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: datavizlib
+Version: 0.1.0
+Summary: Opinionated matplotlib-based library for clean, presentation-ready charts and visual storytelling.
+Author-email: Philipp Melzer <philipp.melzer@icloud.com>
+License: MIT License
+        
+        Copyright (c) 2026 Philipp Melzer
+        
+        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.
+        
+Project-URL: Repository, https://github.com/phmelzer/datavizlib
+Keywords: data visualization,matplotlib,charting,plotting
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: matplotlib>=3.8
+Requires-Dist: pandas>=2.0
+Dynamic: license-file
+
+# 📊 datavizlib
+
+Opinionated matplotlib-based Python tooling for building clean, consistent, presentation-ready charts.
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install datavizlib
+```
+
+Or install locally for development:
+
+```bash
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from datavizlib import LineChart
+
+chart = LineChart(
+    title="Monthly revenue",
+    subtitle="Actual vs forecast",
+    x_label="Month",
+    y_label="Revenue"
+)
+
+chart.build()
+chart.add_data(df, x="month", y="revenue", linestyle="solid")
+chart.add_data(df, x="month", y="forecast", linestyle="dotted")
+chart.render()
+```
+
+## Contributing
+
+Contributions are welcome.
+
+## License
+
+`datavizlib` is released under the MIT License. See `LICENSE` for details.

datavizlib-0.1.0/src/datavizlib.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+LICENSE
+README.md
+pyproject.toml
+src/datavizlib/__init__.py
+src/datavizlib.egg-info/PKG-INFO
+src/datavizlib.egg-info/SOURCES.txt
+src/datavizlib.egg-info/dependency_links.txt
+src/datavizlib.egg-info/requires.txt
+src/datavizlib.egg-info/top_level.txt
+src/datavizlib/charts/__init__.py
+src/datavizlib/charts/base.py
+src/datavizlib/charts/line.py
+tests/test_base.py
+tests/test_line.py

datavizlib-0.1.0/src/datavizlib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

datavizlib-0.1.0/src/datavizlib.egg-info/requires.txt

@@ -0,0 +1,2 @@
+matplotlib>=3.8
+pandas>=2.0

datavizlib-0.1.0/src/datavizlib.egg-info/top_level.txt

@@ -0,0 +1 @@
+datavizlib

datavizlib-0.1.0/tests/test_base.py

@@ -0,0 +1,50 @@
+# filepath: tests/test_base.py
+"""Lean tests for BaseChart class."""
+
+import pytest
+
+from datavizlib.charts.base import BaseChart
+
+
+@pytest.fixture
+def base_chart():
+    return BaseChart(title="Test", x_label="X", y_label="Y", footnote="Source")
+
+
+def test_constructor_and_attrs(base_chart):
+    assert base_chart.title == "Test"
+    assert base_chart.x_label == "X"
+    assert base_chart.y_label == "Y"
+    assert base_chart.footnote == "Source"
+
+
+def test_optional_subtitle():
+    chart = BaseChart(title="T", x_label="X", y_label="Y", footnote="S", subtitle="Sub")
+    assert chart.subtitle == "Sub"
+
+
+def test_validation_errors():
+    with pytest.raises(ValueError, match="title"):
+        BaseChart(title="", x_label="X", y_label="Y", footnote="S")
+
+    with pytest.raises(ValueError, match="x_label"):
+        BaseChart(title="T", x_label="", y_label="Y", footnote="S")
+
+    with pytest.raises(ValueError, match="y_label"):
+        BaseChart(title="T", x_label="X", y_label="", footnote="S")
+
+
+def test_color_palette_and_helpers(base_chart):
+    assert getattr(base_chart, "color_palette")
+    assert len(base_chart.color_palette) >= 1
+    assert base_chart._get_color_palette() == base_chart.color_palette
+    assert base_chart._get_next_color(0) == base_chart.color_palette[0]
+    assert (
+        base_chart._get_next_color(len(base_chart.color_palette))
+        == base_chart.color_palette[0]
+    )
+
+
+def test_build_returns_fig_and_ax(base_chart):
+    fig, ax = base_chart.build()
+    assert fig is not None and ax is not None

datavizlib-0.1.0/tests/test_line.py

@@ -0,0 +1,75 @@
+# filepath: tests/test_line.py
+"""Lean tests for LineChart class."""
+
+import pandas as pd
+import pytest
+
+from datavizlib.charts.line import LineChart
+
+
+@pytest.fixture
+def sample_data():
+    return pd.DataFrame({"year": [2020, 2021, 2022], "sales": [100, 150, 130]})
+
+
+@pytest.fixture
+def line_chart():
+    return LineChart(title="Test", x_label="X", y_label="Y", footnote="Source")
+
+
+def test_constructor(line_chart):
+    assert line_chart.title == "Test"
+    assert getattr(line_chart, "_lines", []) == []
+
+
+def test_add_data_basic(line_chart, sample_data):
+    result = line_chart.add_data(sample_data, x="year", y="sales")
+    assert result is line_chart
+    entry = line_chart._lines[0]
+    assert entry["df"] is sample_data
+    assert entry["x"] == "year" and entry["y"] == "sales"
+    assert entry["linestyle"] == "solid"
+    assert entry["color"]
+
+
+@pytest.mark.parametrize("linestyle,color", [("dotted", None), ("solid", "#FF0000")])
+def test_add_data_styles(line_chart, sample_data, linestyle, color):
+    line_chart.add_data(
+        sample_data, x="year", y="sales", linestyle=linestyle, color=color
+    )
+    entry = line_chart._lines[-1]
+    assert entry["linestyle"] == linestyle
+    if color:
+        assert entry["color"] == color
+    else:
+        assert entry["color"]
+
+
+def test_add_data_validation(line_chart):
+    with pytest.raises(ValueError):
+        line_chart.add_data([1, 2, 3], x="a", y="b")
+
+    with pytest.raises(ValueError):
+        line_chart.add_data(pd.DataFrame({"a": [1]}), x="invalid", y="a")
+
+    with pytest.raises(ValueError):
+        line_chart.add_data(pd.DataFrame({"a": [1]}), x="a", y="invalid")
+
+
+def test_render_flow(line_chart, sample_data):
+    with pytest.raises(ValueError):
+        line_chart.render()
+
+    line_chart.build()
+    line_chart.add_data(sample_data, x="year", y="sales")
+    fig, ax = line_chart.render()
+    assert fig is not None and ax is not None
+
+
+def test_multiple_lines_render(line_chart, sample_data):
+    line_chart.add_data(sample_data, x="year", y="sales")
+    line_chart.add_data(
+        sample_data, x="year", y="sales", linestyle="dotted", color="#FF0000"
+    )
+    fig, ax = line_chart.render()
+    assert len(ax.lines) == 2