diff --git a/.gitignore b/.gitignore
index 4a776706c427d9eb694a1bffe990f521cf40064d..3324633eaeb2ed34929634f60f565af6c4dc09fd 100644
--- a/.gitignore
+++ b/.gitignore
@@ -11,6 +11,7 @@ __pycache__
!/.gitlab
!/.vscode
!/tests
+!/tests_automatic
!/plot_serializer
!/doc
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8ccba999bd62567b38762c9f3bd1d4e50518bd5e..88b59c389273c74e341da73fb42e0e790a2d3d6b 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -181,3 +181,10 @@ pytest tests --update-tests=confirm
The first type of files created being all the tests accomodating the new model under the tests_updated folder. They have to be manually checked for correctness and then moved into the initial [plots](./tests/plots) folder.
The second being the new model under [specification](./doc/static/specification) where it will have to be renamed according to the current version of PlotSerializer to be pushed.
The third being pictures of every plottype deserialized into a figure to broadly confirm the deserializer is still functioning. Once again the contents must me renamed and replace the old files in [folder](./tests/deserializer_matrix) upon confirming correctness.
+
+Besides the manual tests comparing generated JSON files to the expected result there are automatic tests checking if errors are thrown for automatically generated input arguments and testing if the returned JSON is empty. So far these tests mostly only support the main parameters of the functions and only some keyword parameters.
+It is recommended to run the test for the specific plot under scrutiny, not the entire testfolder via pytest as the . An example for boxplot:
+
+```cmd
+pytest tests_automatic test_box_automatic.py
+```
\ No newline at end of file
diff --git a/plot_serializer/matplotlib/serializer.py b/plot_serializer/matplotlib/serializer.py
index 5af88b57c5701520972f0893e47c7c9cb7996c3a..6cd93f3c1eea0bb8aa826ed2ce5f1ec3cef12f74 100644
--- a/plot_serializer/matplotlib/serializer.py
+++ b/plot_serializer/matplotlib/serializer.py
@@ -181,7 +181,7 @@ class _AxesProxy(Proxy[MplAxes]):
color_list = c
color_list = _convert_matplotlib_color(self, color_list, len(x), cmap="viridis", norm="linear")[0]
- x = np.asarray(x, np.float32)
+ x = np.asarray(x)
if not explode_list:
explode_list = itertools.repeat(None)
if not label_list:
@@ -224,13 +224,16 @@ class _AxesProxy(Proxy[MplAxes]):
try:
bars: List[Bar2D] = []
-
- if isinstance(x, float):
+ if isinstance(x, np.generic):
+ x = x.item()
+ if isinstance(x, (float, int, str)):
x = [x]
else:
x = np.asarray(x)
- if isinstance(height, float):
+ if isinstance(height, np.generic):
+ height = height.item()
+ if isinstance(height, (float, int, str)):
height = [height]
else:
height = np.asarray(height)
@@ -298,7 +301,6 @@ class _AxesProxy(Proxy[MplAxes]):
xdata = mpl_line.get_xdata()
ydata = mpl_line.get_ydata()
- print(type(xdata))
points: List[Point2D] = []
@@ -362,6 +364,11 @@ class _AxesProxy(Proxy[MplAxes]):
cmap = kwargs.get("cmap") or "viridis"
norm = kwargs.get("norm") or "linear"
+ if isinstance(x, np.generic):
+ x = x.item()
+ if isinstance(x, (float, int, str)):
+ x = [x]
+
(color_list, cmap_used) = _convert_matplotlib_color(self, color_list, len(x), cmap, norm)
if sizes_list is not None:
@@ -437,7 +444,7 @@ class _AxesProxy(Proxy[MplAxes]):
conf_intervals = itertools.repeat(None)
for dataset, label, umedian, cintervals in zip(x, labels, usermedians, conf_intervals):
- x = np.ma.asarray(x)
+ x = np.ma.asarray(x, dtype="object")
x = x.data[~x.mask].ravel()
boxes.append(
Box(
@@ -508,21 +515,22 @@ class _AxesProxy(Proxy[MplAxes]):
if yerr is not None and not isinstance(yerr, np.ndarray):
yerr = _upcast_err(yerr)
np.broadcast_to(xerr, (2, len(y)))
+
if xerr is None:
xerr = itertools.repeat(None)
+ else:
+ if xerr.ndim == 0 or xerr.ndim == 1:
+ xerr = np.broadcast_to(xerr, (2, len(x)))
+ xerr = xerr.T
if yerr is None:
yerr = itertools.repeat(None)
-
- print(xerr)
- print(xerr.ndim)
-
- if xerr.ndim == 0 or xerr.ndim == 1:
- xerr = np.broadcast_to(xerr, (2, len(x)))
- if yerr.ndim == 0 or yerr.ndim == 1:
- yerr = np.broadcast_to(yerr, (2, len(y)))
+ else:
+ if yerr.ndim == 0 or yerr.ndim == 1:
+ yerr = np.broadcast_to(yerr, (2, len(y)))
+ yerr = yerr.T
errorpoints: List[ErrorPoint2D] = []
- for xi, yi, x_error, y_error in zip(x, y, xerr.T, yerr.T):
+ for xi, yi, x_error, y_error in zip(x, y, xerr, yerr):
errorpoints.append(
ErrorPoint2D(
x=xi,
@@ -572,9 +580,9 @@ class _AxesProxy(Proxy[MplAxes]):
raise
try:
- bins = kwargs.get("bins") or 10
- density = kwargs.get("density") or False
- cumulative = kwargs.get("cumulative") or False
+ bins = kwargs.get("bins", 10)
+ density = kwargs.get("density", False)
+ cumulative = kwargs.get("cumulative", False)
label_list = kwargs.get("label")
color_list = kwargs.get("color")
c = kwargs.get("c")
@@ -589,7 +597,6 @@ class _AxesProxy(Proxy[MplAxes]):
if np.isscalar(x):
x = [x]
x = _reshape_2D(x, "x")
- print(x)
color_list = _convert_matplotlib_color(self, color_list, len(x), "viridis", "linear")[0]
@@ -699,6 +706,12 @@ class _AxesProxy3D(Proxy[MplAxes3D]):
color_list = color
cmap = kwargs.get("cmap") or "viridis"
norm = kwargs.get("norm") or "linear"
+
+ if isinstance(xs, np.generic):
+ xs = xs.item()
+ if isinstance(xs, (float, int, str)):
+ xs = [xs]
+
(color_list, cmap_used) = _convert_matplotlib_color(self, color_list, len(xs), cmap, norm)
trace: List[ScatterTrace3D] = []
@@ -745,8 +758,8 @@ class _AxesProxy3D(Proxy[MplAxes3D]):
def plot(
self,
- x_values: list[float],
- y_values: list[float],
+ x_values,
+ y_values,
*args: Any,
**kwargs: Any,
) -> Path3DCollection:
@@ -806,9 +819,9 @@ class _AxesProxy3D(Proxy[MplAxes3D]):
def plot_surface(
self,
- x: list[list[float]],
- y: list[list[float]],
- z: list[list[float]],
+ x,
+ y,
+ z,
*args: Any,
**kwargs: Any,
) -> Poly3DCollection:
diff --git a/plot_serializer/model.py b/plot_serializer/model.py
index fd6575d33cd765ef896dad37726dbc7262f40571..bda764924404c736f974ece2842a7878e3bbbc8e 100644
--- a/plot_serializer/model.py
+++ b/plot_serializer/model.py
@@ -82,9 +82,9 @@ class Point2D(BaseModel):
class Point3D(BaseModel):
metadata: Metadata = {}
- x: Any # used to be: float
- y: Any # used to be: float
- z: Any # used to be: float
+ x: Any
+ y: Any
+ z: Any
color: Optional[Color] = None
size: Any = None
@@ -184,7 +184,7 @@ class LineTrace2D(BaseModel):
color: Optional[Color] = None
linewidth: Optional[float] = None
linestyle: Optional[str] = None
- marker: Optional[str] = None # used to be MarkerStyle, however Markerstyle is a collection of markers
+ marker: Optional[str] = None
label: Optional[str] = None
datapoints: List[Point2D]
diff --git a/requirements.txt b/requirements.txt
index b5494a836a76085ae4e9a99742d57c33e08a6512..6bbe74db48b87634b2005a09ce865de44484db0b 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -22,6 +22,7 @@ types-docutils
# Unit testing
pytest
+hypothesis
#Debug
debugpy
\ No newline at end of file
diff --git a/tests/test_hist_plot.py b/tests/test_hist_plot.py
index d7f3c51001278dca125291620ad31ef914235485..4beebfc4482ca32376a570bfc572f9d98d187481 100644
--- a/tests/test_hist_plot.py
+++ b/tests/test_hist_plot.py
@@ -109,6 +109,9 @@ def test_hist_plot(
update_tests = request.config.getoption("--update-tests")
_, ax = serializer.subplots()
+ if bins is None and cumulative is None and density is None:
+ # giving arguments the none value throws errors, might need a test overhaul overall
+ ax.hist(x)
ax.hist(
x,
bins=bins,
@@ -126,7 +129,7 @@ def test_hist_plot(
ax.set_ylabel(ylabel)
if metadata:
- ax.hist(x, bins=bins, color=color, label=label, cumulative=cumulative, density=density)
+ ax.hist(x)
serializer.add_custom_metadata_figure(metadata)
serializer.add_custom_metadata_plot(metadata, plot_selector=0)
serializer.add_custom_metadata_axis(metadata, axis="y", plot_selector=0)
diff --git a/tests_automatic/__init__.py b/tests_automatic/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/tests_automatic/test_bar_automatic.py b/tests_automatic/test_bar_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..58c669bc1343b91931b323f7a78100021fde1249
--- /dev/null
+++ b/tests_automatic/test_bar_automatic.py
@@ -0,0 +1,48 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.integers(),
+ st.floats(),
+ st.text(),
+ st.lists(st.text()),
+ st.lists(st.integers()),
+ st.lists(st.floats()),
+ arrays(np.int64, st.integers(min_value=0, max_value=10)),
+ arrays(np.float64, st.integers(min_value=0, max_value=10)),
+)
+heights_strategy = st.one_of(
+ st.integers(),
+ st.floats(),
+ st.lists(st.integers()),
+ st.lists(st.floats()),
+ arrays(np.int64, st.integers(min_value=0, max_value=10)),
+ arrays(np.float64, st.integers(min_value=0, max_value=10)),
+)
+
+
+@given(x=x_strategy, heights=heights_strategy)
+def test_bar_properties(
+ x: Any,
+ heights: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.bar(x, heights)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.bar(x, heights)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_box_automatic.py b/tests_automatic/test_box_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..91fcb9b3fcd1ba05330e8aed65533d7aef5c174c
--- /dev/null
+++ b/tests_automatic/test_box_automatic.py
@@ -0,0 +1,90 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given, settings
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.lists(st.lists(st.floats(), min_size=1), min_size=1),
+ st.lists(arrays(np.float64, st.integers(min_value=1, max_value=10)), min_size=1),
+ arrays(np.float64, st.integers(min_value=1, max_value=10)),
+ arrays(np.int64, st.integers(min_value=1, max_value=10)),
+)
+notch_strategy = st.one_of(st.none(), st.booleans())
+whis_strategy = st.one_of(
+ st.none(),
+ st.floats(),
+ st.tuples(st.floats(), st.floats()),
+)
+bootstrap_strategy = st.one_of(st.none(), st.integers(min_value=0))
+usermedians_strategy = st.one_of(
+ st.none(),
+ st.lists(st.one_of(st.floats(), st.none()), min_size=1),
+ arrays(np.float64, st.integers(min_value=1, max_value=10)),
+)
+conf_intervals_strategy = st.one_of(
+ st.none(),
+ st.lists(
+ st.tuples(
+ st.one_of(st.floats(), st.none()),
+ st.one_of(st.floats(), st.none()),
+ ),
+ min_size=1,
+ ),
+ arrays(np.float64, st.integers(min_value=1, max_value=10)),
+)
+tick_labels_strategy = st.one_of(st.none(), st.lists(st.text(), min_size=1))
+
+
+@given(
+ x=x_strategy,
+ notch=notch_strategy,
+ whis=whis_strategy,
+ bootstrap=bootstrap_strategy,
+ usermedians=usermedians_strategy,
+ conf_intervals=conf_intervals_strategy,
+ tick_labels=tick_labels_strategy,
+)
+@settings(deadline=500)
+def test_box_properties(
+ x: Any,
+ notch: Any,
+ whis: Any,
+ bootstrap: Any,
+ usermedians: Any,
+ conf_intervals: Any,
+ tick_labels: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.boxplot(
+ x=x,
+ notch=notch,
+ whis=whis,
+ bootstrap=bootstrap,
+ usermedians=usermedians,
+ conf_intervals=conf_intervals,
+ tick_labels=tick_labels,
+ )
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.boxplot(
+ x=x,
+ notch=notch,
+ whis=whis,
+ bootstrap=bootstrap,
+ usermedians=usermedians,
+ conf_intervals=conf_intervals,
+ tick_labels=tick_labels,
+ )
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_errorbar_automatic.py b/tests_automatic/test_errorbar_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..c2b688fe8e416c37a4109f9bc6d4237108c52837
--- /dev/null
+++ b/tests_automatic/test_errorbar_automatic.py
@@ -0,0 +1,65 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+y_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+xerr_strategy = st.one_of(
+ st.none(),
+ st.floats(min_value=0, allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(min_value=0, allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(np.float64, shape=st.integers(min_value=1, max_value=10)),
+ arrays(np.float64, shape=st.tuples(st.just(2), st.integers(min_value=1, max_value=10))),
+)
+
+yerr_strategy = st.one_of(
+ st.none(),
+ st.floats(min_value=0, allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(min_value=0, allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(np.float64, shape=st.integers(min_value=1, max_value=10)),
+ arrays(np.float64, shape=st.tuples(st.just(2), st.integers(min_value=1, max_value=10))),
+)
+
+marker_strategy = st.one_of(st.none(), st.text())
+
+label_strategy = st.one_of(st.none(), st.text())
+
+
+@given(x=x_strategy, y=y_strategy, xerr=xerr_strategy, yerr=yerr_strategy, marker=marker_strategy, label=label_strategy)
+def test_bar_properties(
+ x: Any,
+ y: Any,
+ xerr: Any,
+ yerr: Any,
+ marker: Any,
+ label: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.errorbar(x, y, xerr=xerr, yerr=yerr, marker=marker, label=label)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.errorbar(x, y, xerr=xerr, yerr=yerr, marker=marker, label=label)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_hist_automatic.py b/tests_automatic/test_hist_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..35dba2b5b6055f6aa7a4c084a8b0ebf1529d3932
--- /dev/null
+++ b/tests_automatic/test_hist_automatic.py
@@ -0,0 +1,53 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+ st.lists(st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1), min_size=1),
+ st.lists(arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)), min_size=1),
+ arrays(
+ dtype=np.float64,
+ shape=st.tuples(st.integers(min_value=1, max_value=10), st.integers(min_value=1, max_value=10)),
+ ),
+)
+bins_strategy = st.one_of(
+ st.integers(min_value=1, max_value=50),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=50)),
+)
+density_strategy = st.booleans()
+cumulative_strategy = st.one_of(st.booleans(), st.just(-1))
+label_strategy = st.one_of(st.none(), st.text())
+
+
+@given(
+ x=x_strategy, bins=bins_strategy, label=label_strategy, densitiy=density_strategy, culumative=cumulative_strategy
+)
+def test_hist_properties(
+ x: Any,
+ bins: Any,
+ label: Any,
+ densitiy: Any,
+ culumative: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.hist(x, bins=bins, label=label, density=densitiy, cumulative=culumative)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.hist(x, bins=bins, label=label, density=densitiy, cumulative=culumative)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_line3d_automatic.py b/tests_automatic/test_line3d_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..4490649a73a702972d6dfa4db7c828cec0dd4552
--- /dev/null
+++ b/tests_automatic/test_line3d_automatic.py
@@ -0,0 +1,54 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+y_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+z_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+label_strategy = st.one_of(st.none(), st.text())
+
+linewidth_strategy = st.one_of(st.floats(allow_nan=False, allow_infinity=False), st.integers())
+
+
+@given(x=x_strategy, y=y_strategy, z=z_strategy, label=label_strategy, linewidth=linewidth_strategy)
+def test_line_properties(
+ x: Any,
+ y: Any,
+ z: Any,
+ label: Any,
+ linewidth: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.plot(x, y, z, label=label, linewidth=linewidth)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.plot(x, y, z, label=label, linewidth=linewidth)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_line_automatic.py b/tests_automatic/test_line_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..26844012e56bcd94766514416c3d773125d10b94
--- /dev/null
+++ b/tests_automatic/test_line_automatic.py
@@ -0,0 +1,47 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+y_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+label_strategy = st.one_of(st.none(), st.text())
+
+linewidth_strategy = st.one_of(st.floats(allow_nan=False, allow_infinity=False), st.integers())
+
+
+@given(x=x_strategy, y=y_strategy, label=label_strategy, linewidth=linewidth_strategy)
+def test_line_properties(
+ x: Any,
+ y: Any,
+ label: Any,
+ linewidth: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.plot(x, y, label=label, linewidth=linewidth)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.plot(x, y, label=label, linewidth=linewidth)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_pie_automatic.py b/tests_automatic/test_pie_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..44d14bb013fc95273e9ae26d6f16cdce5544f3f6
--- /dev/null
+++ b/tests_automatic/test_pie_automatic.py
@@ -0,0 +1,46 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+explode_strategy = st.one_of(
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+ st.none(),
+)
+
+radius_strategy = st.floats(allow_nan=False, allow_infinity=False)
+
+labels_strategy = st.one_of(st.lists(st.text(), min_size=1), st.none())
+
+
+@given(x=x_strategy, explode=explode_strategy, labels=labels_strategy, radius=radius_strategy)
+def test_pie_properties(
+ x: Any,
+ explode: Any,
+ labels: Any,
+ radius: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.pie(x, explode=explode, labels=labels, radius=radius)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.pie(x, explode=explode, labels=labels, radius=radius)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_scatter3d_automatic.py b/tests_automatic/test_scatter3d_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..5eb4d42545ca7769b4f5a7d45ca9d6cbf7055b6b
--- /dev/null
+++ b/tests_automatic/test_scatter3d_automatic.py
@@ -0,0 +1,58 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+y_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+z_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+s_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+label_strategy = st.one_of(st.none(), st.text())
+
+
+@given(x=x_strategy, y=y_strategy, z=z_strategy, s=s_strategy, label=label_strategy)
+def test_scatter3d_properties(
+ x: Any,
+ y: Any,
+ z: Any,
+ s: Any,
+ label: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots(subplot_kw={"projection": "3d"})
+ _fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+ try:
+ ax.scatter(x, y, z, s=s, label=label) # type: ignore
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.scatter(x, y, z, s=s, label=label)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_scatter_automatic.py b/tests_automatic/test_scatter_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f2631501c212ce7f192a09a88249f3da88e38a1
--- /dev/null
+++ b/tests_automatic/test_scatter_automatic.py
@@ -0,0 +1,51 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+x_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+y_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+s_strategy = st.one_of(
+ st.floats(allow_nan=False, allow_infinity=False),
+ st.lists(st.floats(allow_nan=False, allow_infinity=False), min_size=1),
+ arrays(dtype=np.float64, shape=st.integers(min_value=1, max_value=10)),
+)
+
+label_strategy = st.one_of(st.none(), st.text())
+
+
+@given(x=x_strategy, y=y_strategy, s=s_strategy, label=label_strategy)
+def test_scatter_properties(
+ x: Any,
+ y: Any,
+ s: Any,
+ label: Any,
+) -> None:
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots()
+ _fig, ax = plt.subplots()
+ try:
+ ax.scatter(x, y, s=s, label=label)
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.scatter(x, y, s=s, label=label)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)
diff --git a/tests_automatic/test_surface3d_automatic.py b/tests_automatic/test_surface3d_automatic.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd8573af6c04bcdaba3bcc356bd8865801c10e6e
--- /dev/null
+++ b/tests_automatic/test_surface3d_automatic.py
@@ -0,0 +1,50 @@
+from typing import Any
+
+import numpy as np
+from hypothesis import given
+from hypothesis import strategies as st
+from hypothesis.extra.numpy import arrays
+from matplotlib import pyplot as plt
+
+from plot_serializer.matplotlib.serializer import MatplotlibSerializer
+
+
+@st.composite
+def matrix_triplet_strategy(draw, min_dim=1, max_dim=10, min_value=0, max_value=100): # type: ignore
+ rows = draw(st.integers(min_value=min_dim, max_value=max_dim))
+ cols = draw(st.integers(min_value=min_dim, max_value=max_dim))
+
+ matrix_strategy = st.one_of(
+ st.lists(
+ st.lists(st.integers(min_value=min_value, max_value=max_value), min_size=cols, max_size=cols),
+ min_size=rows,
+ max_size=rows,
+ ),
+ arrays(dtype=np.int64, shape=(rows, cols)),
+ )
+
+ matrix1 = draw(matrix_strategy)
+ matrix2 = draw(matrix_strategy)
+ matrix3 = draw(matrix_strategy)
+
+ return matrix1, matrix2, matrix3
+
+
+@given(matrix_triplet_strategy())
+def test_surface_properties(
+ matrix_triplet: Any,
+) -> None:
+ x, y, z = matrix_triplet
+ serializer = MatplotlibSerializer()
+ _, serializer_ax = serializer.subplots(subplot_kw={"projection": "3d"})
+ _fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
+ try:
+ ax.plot_surface(x, y, z) # type: ignore
+ except Exception as _e:
+ pass
+ else:
+ serializer_ax.plot_surface(x, y, z)
+ assert serializer.to_json() != "{}", "Serialized JSON is empty check input"
+ finally:
+ plt.close(_)
+ plt.close(_fig)