Decouple from matplotlib and add Bokeh for backend

src/grid_strategy/_abc.py

@@ -7,6 +7,9 @@
 import matplotlib.pyplot as plt
 import numpy as np
 
+from .backends.mtpltlib import Matplotlib
+from .backends.bkh import Bokeh
+
 
 class GridStrategy(metaclass=ABCMeta):
     """
@@ -15,8 +18,38 @@ class GridStrategy(metaclass=ABCMeta):
     nearly square (nearly equal in both dimensions).
     """
 
-    def __init__(self, alignment="center"):
+    def __init__(self, alignment="center", backend="matplotlib"):
         self.alignment = alignment
+        self.supported_backends = ["matplotlib", "bokeh"]
+        self.library = None
+
+        assert (
+            backend in self.supported_backends
+        ), f"Library {backend} is not a supported backend."
+        if backend == "matplotlib":
+            try:
+                import matplotlib
+            except ImportError:
+                print(
+                    "matplotlib not installed. Please install it to use it with grid_strategy."
+                )
+            self.library = Matplotlib(alignment=self.alignment)
+
+        elif backend == "bokeh":
+            try:
+                import bokeh
+            except ImportError:
+                print(
+                    "Bokeh is not installed. Please install it to use it with grid_strategy."
+                )
+            self.library = Bokeh(alignment=self.alignment)
+
+        # elif backend == "plotly":
+        #     try:
+        #         import plotly
+        #     except ImportError:
+        #         print("plotly not installed. Please install it to use it with grid_strategy.")
+        #     self.library = Plotly(alignment=self.alignment)
 
     def get_grid(self, n):
         """  
@@ -30,70 +63,22 @@ def get_grid(self, n):
         where each x would be a subplot.
         """
 
+        if n < 0:
+            raise ValueError
         grid_arrangement = self.get_grid_arrangement(n)
-        return self.get_gridspec(grid_arrangement)
+        return self.get_figures(grid_arrangement)
 
     @classmethod
     @abstractmethod
     def get_grid_arrangement(cls, n):  # pragma: nocover
         pass
 
-    def get_gridspec(self, grid_arrangement):
+    def get_figures(self, grid_arrangement):
         nrows = len(grid_arrangement)
         ncols = max(grid_arrangement)
 
         # If it has justified alignment, will not be the same as the other alignments
         if self.alignment == "justified":
-            return self._justified(nrows, grid_arrangement)
-        else:
-            return self._ragged(nrows, ncols, grid_arrangement)
-
-    def _justified(self, nrows, grid_arrangement):
-        ax_specs = []
-        num_small_cols = np.lcm.reduce(grid_arrangement)
-        gs = gridspec.GridSpec(
-            nrows, num_small_cols, figure=plt.figure(constrained_layout=True)
-        )
-        for r, row_cols in enumerate(grid_arrangement):
-            skip = num_small_cols // row_cols
-            for col in range(row_cols):
-                s = col * skip
-                e = s + skip
-
-                ax_specs.append(gs[r, s:e])
-        return ax_specs
-
-    def _ragged(self, nrows, ncols, grid_arrangement):
-        if len(set(grid_arrangement)) > 1:
-            col_width = 2
+            return self.library._justified(nrows, grid_arrangement)
         else:
-            col_width = 1
-
-        gs = gridspec.GridSpec(
-            nrows, ncols * col_width, figure=plt.figure(constrained_layout=True)
-        )
-
-        ax_specs = []
-        for r, row_cols in enumerate(grid_arrangement):
-            # This is the number of missing columns in this row. If some rows
-            # are a different width than others, the column width is 2 so every
-            # column skipped at the beginning is also a missing slot at the end.
-            if self.alignment == "left":
-                # This is left-justified (or possibly full justification)
-                # so no need to skip anything
-                skip = 0
-            elif self.alignment == "right":
-                # Skip two slots for every missing plot - right justified.
-                skip = (ncols - row_cols) * 2
-            else:
-                # Defaults to centered, as that is the default value for the class.
-                # Skip one for each missing column - centered
-                skip = ncols - row_cols
-
-            for col in range(row_cols):
-                s = skip + col * col_width
-                e = s + col_width
-
-                ax_specs.append(gs[r, s:e])
-
-        return ax_specs
+            return self.library._ragged(nrows, ncols, grid_arrangement)

src/grid_strategy/backends/bkh.py

@@ -0,0 +1,81 @@
+from bokeh.layouts import layout, Spacer
+from bokeh.io import show, output_file
+
+
+class JustifiedGrid:
+    def __init__(self, nrows, grid_arrangement):
+        self.plots = [[]]
+        self.grid_arrangement = grid_arrangement
+        self.current_row = 0
+        self.nrows = nrows
+
+    def add_plot(self, plot):
+        self.plots[self.current_row].append(plot)
+        if len(self.plots[self.current_row]) == self.grid_arrangement[self.current_row]:
+            self.plots.append([])
+            self.current_row += 1
+            assert (
+                self.current_row <= self.nrows
+            ), "Error: More graphs added to layout than previously specified."
+
+    def add_plots(self, plot_list):
+        for plot in plot_list:
+            self.add_plot(plot)
+
+    def output_dest(self, file):
+        output_file(file)
+
+    def show_plot(self):
+        l = layout(self.plots, sizing_mode="stretch_width")
+        show(l)
+
+
+class AlignedGrid:
+    def __init__(self, nrows, ncols, grid_arrangement, alignment):
+        self.plots = [[]]
+        self.grid_arrangement = grid_arrangement
+        self.alignment = alignment
+        self.current_row = 0
+        self.nrows = nrows
+
+    def add_plot(self, plot):
+        self.plots[self.current_row].append(plot)
+        if len(self.plots[self.current_row]) == self.grid_arrangement[self.current_row]:
+            self.plots.append([])
+            self.current_row += 1
+        assert (
+            self.current_row <= self.nrows
+        ), "Error: More graphs added to the layout than previously specified."
+
+    def add_plots(self, plots):
+        for plot in plots:
+            self.add_plot(plot)
+
+    def output_dest(self, file):
+        output_file(file)
+
+    def show_plot(self):
+        for row in self.plots:
+            if len(row) == max(self.grid_arrangement):
+                continue
+            else:
+                if self.alignment == "left":
+                    row.append(Spacer())
+                elif self.alignment == "right":
+                    row.insert(0, Spacer())
+                elif self.alignment == "center":
+                    row.append(Spacer())
+                    row.insert(0, Spacer())
+        l = layout(self.plots, sizing_mode="scale_both")
+        show(l)
+
+
+class Bokeh:
+    def __init__(self, alignment):
+        self.alignment = alignment
+
+    def _justified(self, nrows, grid_arrangement):
+        return JustifiedGrid(nrows, grid_arrangement)
+
+    def _ragged(self, nrows, ncols, grid_arrangement):
+        return AlignedGrid(nrows, ncols, grid_arrangement, self.alignment)

src/grid_strategy/backends/mtpltlib.py

@@ -0,0 +1,90 @@
+from matplotlib import gridspec
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class Matplotlib:
+    def __init__(self, alignment="center"):
+        self.alignment = alignment
+
+    def _justified(self, nrows, grid_arrangement):
+        ax_specs = []
+        num_small_cols = np.lcm.reduce(grid_arrangement)
+        gs = gridspec.GridSpec(
+            nrows, num_small_cols, figure=plt.figure(constrained_layout=True)
+        )
+        for r, row_cols in enumerate(grid_arrangement):
+            skip = num_small_cols // row_cols
+            for col in range(row_cols):
+                s = col * skip
+                e = s + skip
+
+                ax_specs.append(gs[r, s:e])
+        return ax_specs
+
+    def _ragged(self, nrows, ncols, grid_arrangement):
+        if len(set(grid_arrangement)) > 1:
+            col_width = 2
+        else:
+            col_width = 1
+
+        gs = gridspec.GridSpec(
+            nrows, ncols * col_width, figure=plt.figure(constrained_layout=True)
+        )
+
+        ax_specs = []
+        for r, row_cols in enumerate(grid_arrangement):
+            # This is the number of missing columns in this row. If some rows
+            # are a different width than others, the column width is 2 so every
+            # column skipped at the beginning is also a missing slot at the end.
+            if self.alignment == "left":
+                # This is left-justified (or possibly full justification)
+                # so no need to skip anything
+                skip = 0
+            elif self.alignment == "right":
+                # Skip two slots for every missing plot - right justified.
+                skip = (ncols - row_cols) * 2
+            else:
+                # Defaults to centered, as that is the default value for the class.
+                # Skip one for each missing column - centered
+                skip = ncols - row_cols
+
+            for col in range(row_cols):
+                s = skip + col * col_width
+                e = s + col_width
+
+                ax_specs.append(gs[r, s:e])
+
+        return ax_specs
+
+
+# class Plotly:
+#     from plotly.subplots import make_subplots
+#     import numpy as np
+
+#     def __init__(self, alignment="center"):
+#         self.alignment = alignment
+
+#     def _justified(self, nrows, grid_arrangement):
+#         num_small_cols = int(self.np.lcm.reduce(grid_arrangement))
+
+#         specs = []
+
+#         for row_cols in grid_arrangement:
+#             width = num_small_cols // row_cols
+
+#             row = []
+#             for _ in range(row_cols):
+#                 row.append({"colspan":width})
+#                 row.extend([None]*(width-1))
+#             specs.append(row)
+
+#         fig = self.make_subplots(
+#             nrows,
+#             num_small_cols,
+#             specs = specs
+#         )
+#         return fig, grid_arrangement
+
+#     def _ragged(self, nrows, ncols, grid_arrangement):
+#         pass

tests/test_grids.py

@@ -2,6 +2,7 @@
 from unittest import mock
 
 from grid_strategy.strategies import SquareStrategy
+import grid_strategy.backends
 
 
 class SpecValue:

tox.ini

@@ -1,5 +1,5 @@
 [tox]
-envlist = py36, py37, black-check
+envlist = py36, py37, py38, black-check
 skip_missing_interpreters = true
 isolated_build = true
 
@@ -10,6 +10,7 @@ deps =
     pytest
     pytest-cov >= 2.0.0
     coverage
+    bokeh
 commands = pytest --cov-config="{toxinidir}/tox.ini" \
                   --cov="{envsitepackagesdir}/grid_strategy" \
                   --cov="{toxinidir}/tests" \
@@ -40,6 +41,7 @@ show_missing = True
 description = test if black works
 deps =
     pytest-black
+    bokeh
 commands = pytest --black
 
 [testenv:docs]