Merge pull request #221 from lucasimi/use-pytest

Refactored tests to use pytest instead of unittest

Author: lucasimi

.github/workflows/test-bench.yml

@@ -53,7 +53,7 @@ jobs:
 
  - name: Run benchmarks
  run: | 
- python -m unittest discover -s tests -p 'test_bench_*.py'
+ python -m pytest tests/test_bench_*.py -s
 
  test-bench-job:
  needs: test-bench-matrix-job

.github/workflows/test-unit.yml

@@ -53,7 +53,7 @@ jobs:
 
  - name: Run tests and code coverage
  run: | 
- coverage run --source=src -m unittest discover -s tests -p 'test_unit_*.py'
+ coverage run --source=src -m pytest tests/test_unit_*.py
  coverage report -m
 
  - name: Upload coverage reports to Codecov

CONTRIBUTING.md

@@ -67,17 +67,17 @@ Follow these steps to contribute:
  the naming convention `test_bench_*.py`.
 
 4. **Run Tests**.
- Ensure your changes pass all tests before committing. We use `unittest` as
+ Ensure your changes pass all tests before committing. We use `pytest` as
  test framework:
 
  ```bash
- python -m unittest discover -s tests -p 'test_*.py'
+ python -m pytest tests/test_*.py
  ```
 
  Before each commit make sure to check code coverage:
 
  ```bash
- coverage run --source=src -m unittest discover -s tests -p 'test_*.py'
+ coverage run --source=src -m pytest tests/test_*.py
  ```
 
 5. **Commit and Push Your Changes**.

app/streamlit_app.py

@@ -22,7 +22,6 @@
 from sklearn.decomposition import PCA
 from umap import UMAP
 
-from tdamapper._plot_plotly import _marker_size
 from tdamapper.core import aggregate_graph
 from tdamapper.cover import BallCover, CubicalCover
 from tdamapper.learn import MapperAlgorithm
@@ -137,14 +136,14 @@ def _check_limits_mapper_graph(mapper_graph):
  if LIMITS_ENABLED:
  num_nodes = mapper_graph.number_of_nodes()
  if num_nodes > LIMITS_NUM_NODES:
- logging.warn("Too many nodes.")
+ logging.warning("Too many nodes.")
  raise ValueError(
  "Too many nodes: select different parameters or run the app "
  "locally on your machine."
  )
  num_edges = mapper_graph.number_of_edges()
  if num_edges > LIMITS_NUM_EDGES:
- logging.warn("Too many edges.")
+ logging.warning("Too many edges.")
  raise ValueError(
  "Too many edges: select different parameters or run the app "
  "locally on your machine."
@@ -155,14 +154,14 @@ def _check_limits_dataset(df_X, df_y):
  if LIMITS_ENABLED:
  num_samples = len(df_X)
  if num_samples > LIMITS_NUM_SAMPLES:
- logging.warn("Dataset too big.")
+ logging.warning("Dataset too big.")
  raise ValueError(
  "Dataset too big: select a different dataset or run the app "
  "locally on your machine."
  )
  num_features = len(df_X.columns) + len(df_y.columns)
  if num_features > LIMITS_NUM_FEATURES:
- logging.warn("Too many features.")
+ logging.warning("Too many features.")
  raise ValueError(
  "Too many features: select a different dataset or run the app "
  "locally on your machine."
@@ -529,8 +528,8 @@ def mapper_input_section(X):
  mapper_algo = MapperAlgorithm(
  cover=cover,
  clustering=clustering,
- verbose=True,
- n_jobs=1,
+ verbose=False,
+ n_jobs=-2,
  )
  mapper_graph = compute_mapper(mapper_algo, X, lens)
  return mapper_graph
@@ -628,11 +627,12 @@ def compute_mapper_fig(mapper_plot, colors, node_size, cmap, _agg, agg_name):
  colors,
  node_size=node_size,
  agg=_agg,
- title=[f"{agg_name} of {c}" for c in colors.columns],
+ title=[f"{c}" for c in colors.columns],
  cmap=cmap,
  width=600,
  height=600,
  )
+ logger.info("Done")
  return mapper_fig
 
 

pyproject.toml

@@ -46,6 +46,7 @@ dev = [
  "coverage[toml]",
  "pandas",
  "scikit-learn<1.6.0",
+ "pytest",
  "black[jupyter]",
  "isort",
  "flake8",

src/tdamapper/_plot_plotly.py

@@ -57,7 +57,7 @@ def plot_plotly(
  mapper_plot,
  width: int,
  height: int,
- node_size: int = DEFAULT_NODE_SIZE,
+ node_size: Optional[Union[int, List[int]]] = DEFAULT_NODE_SIZE,
  colors=None,
  title: Optional[Union[str, List[str]]] = None,
  agg=np.nanmean,
@@ -73,8 +73,9 @@ def plot_plotly(
  titles = [title for _ in range(colors_num)]
  elif isinstance(title, list) and len(title) == colors_num:
  titles = title
- fig = _figure(mapper_plot, width, height, node_size, colors, titles, agg, cmaps)
- _add_ui_to_layout(mapper_plot, fig, colors, titles, node_size, agg, cmaps)
+ node_sizes = [node_size] if isinstance(node_size, int) else node_size
+ fig = _figure(mapper_plot, width, height, node_sizes, colors, titles, agg, cmaps)
+ _add_ui_to_layout(mapper_plot, fig, colors, titles, node_sizes, agg, cmaps)
  return fig
 
 
@@ -220,7 +221,7 @@ def _update_layout(fig, width, height):
  )
 
 
-def _figure(mapper_plot, width, height, node_size, colors, titles, agg, cmaps):
+def _figure(mapper_plot, width, height, node_sizes, colors, titles, agg, cmaps):
  node_pos = mapper_plot.positions
  node_pos_arr = _node_pos_array(
  mapper_plot.graph,
@@ -239,7 +240,7 @@ def _figure(mapper_plot, width, height, node_size, colors, titles, agg, cmaps):
 
  _set_cmap(mapper_plot, fig, cmaps[0])
  _set_colors(mapper_plot, fig, colors[:, 0], agg)
- _set_node_size(mapper_plot, fig, node_size)
+ _set_node_size(mapper_plot, fig, node_sizes[len(node_sizes) // 2])
  _set_title(mapper_plot, fig, titles[0])
 
  return fig
@@ -387,7 +388,7 @@ def _layout(width, height):
  )
 
 
-def _add_ui_to_layout(mapper_plot, mapper_fig, colors, titles, node_size, agg, cmaps):
+def _add_ui_to_layout(mapper_plot, mapper_fig, colors, titles, node_sizes, agg, cmaps):
  cmaps_plotly = [PLOTLY_CMAPS.get(c.lower()) for c in cmaps]
  menu_color = _ui_color(mapper_plot, colors, titles, agg)
  if menu_color["buttons"]:
@@ -396,7 +397,7 @@ def _add_ui_to_layout(mapper_plot, mapper_fig, colors, titles, node_size, agg, c
  menu_color["x"] = -0.25
  menu_cmap = _ui_cmap(mapper_plot, cmaps_plotly)
  menu_cmap["x"] = menu_color["x"] + 0.25
- slider_size = _ui_node_size(mapper_plot, node_size)
+ slider_size = _ui_node_size(mapper_plot, node_sizes)
  mapper_fig.update_layout(
  updatemenus=[menu_cmap, menu_color],
  sliders=[slider_size],
@@ -441,7 +442,7 @@ def _update_cmap(cmap):
  )
 
 
-def _ui_node_size(mapper_plot, node_size):
+def _ui_node_size(mapper_plot, node_sizes):
  steps = [
  dict(
  method="restyle",
@@ -451,7 +452,7 @@ def _ui_node_size(mapper_plot, node_size):
  [1],
  ],
  )
- for size in [node_size * x / 10.0 for x in range(1, 20)]
+ for size in node_sizes
  ]
 
  return dict(

src/tdamapper/utils/vptree_flat/ball_search.py

@@ -5,18 +5,18 @@ class BallSearch:
 
  def __init__(self, vpt, point, eps, inclusive=True):
  self._arr = vpt._get_arr()
- self.__distance = vpt._get_distance()
- self.__point = point
- self.__eps = eps
- self.__inclusive = inclusive
+ self._distance = vpt._get_distance()
+ self._point = point
+ self._eps = eps
+ self._inclusive = inclusive
 
  def search(self):
  return self._search_iter()
 
  def _inside(self, dist):
- if self.__inclusive:
- return dist <= self.__eps
- return dist < self.__eps
+ if self._inclusive:
+ return dist <= self._eps
+ return dist < self._eps
 
  def _search_iter(self):
  stack = [(0, self._arr.size())]
@@ -28,11 +28,11 @@ def _search_iter(self):
  is_terminal = self._arr.is_terminal(start)
  if is_terminal:
  for x in self._arr.get_points(start, end):
- dist = self.__distance(self.__point, x)
+ dist = self._distance(self._point, x)
  if self._inside(dist):
  result.append(x)
  else:
- dist = self.__distance(self.__point, v_point)
+ dist = self._distance(self._point, v_point)
  mid = _mid(start, end)
  if self._inside(dist):
  result.append(v_point)
@@ -42,7 +42,7 @@ def _search_iter(self):
  else:
  fst = (mid, end)
  snd = (start + 1, mid)
- if abs(dist - v_radius) <= self.__eps:
+ if abs(dist - v_radius) <= self._eps:
  stack.append(snd)
  stack.append(fst)
  return result

src/tdamapper/utils/vptree_flat/builder.py

@@ -12,22 +12,22 @@ def _mid(start, end):
 class Builder:
 
  def __init__(self, vpt, X):
- self.__distance = vpt._get_distance()
+ self._distance = vpt._get_distance()
 
  dataset = [x for x in X]
  indices = np.array([i for i in range(len(dataset))])
  distances = np.array([0.0 for _ in X])
  is_terminal = np.array([False for _ in X])
  self._arr = VPArray(dataset, distances, indices, is_terminal)
 
- self.__leaf_capacity = vpt.get_leaf_capacity()
- self.__leaf_radius = vpt.get_leaf_radius()
+ self._leaf_capacity = vpt.get_leaf_capacity()
+ self._leaf_radius = vpt.get_leaf_radius()
  pivoting = vpt.get_pivoting()
- self.__pivoting = self._pivoting_disabled
+ self._pivoting = self._pivoting_disabled
  if pivoting == "random":
- self.__pivoting = self._pivoting_random
+ self._pivoting = self._pivoting_random
  elif pivoting == "furthest":
- self.__pivoting = self._pivoting_furthest
+ self._pivoting = self._pivoting_furthest
 
  def _pivoting_disabled(self, start, end):
  pass
@@ -45,7 +45,7 @@ def _furthest(self, start, end, i):
  i_point = self._arr.get_point(i)
  for j in range(start, end):
  j_point = self._arr.get_point(j)
- j_dist = self.__distance(i_point, j_point)
+ j_dist = self._distance(i_point, j_point)
  if j_dist > furthest_dist:
  furthest = j
  furthest_dist = j_dist
@@ -61,12 +61,12 @@ def _pivoting_furthest(self, start, end):
  self._arr.swap(start, furthest)
 
  def _update(self, start, end):
- self.__pivoting(start, end)
+ self._pivoting(start, end)
  v_point = self._arr.get_point(start)
  is_terminal = self._arr.is_terminal(start)
  for i in range(start + 1, end):
  point = self._arr.get_point(i)
- self._arr.set_distance(i, self.__distance(v_point, point))
+ self._arr.set_distance(i, self._distance(v_point, point))
  self._arr.set_terminal(i, is_terminal)
 
  def build(self):
@@ -81,8 +81,8 @@ def _build_iter(self):
  self._update(start, end)
  self._arr.partition(start + 1, end, mid)
  v_radius = self._arr.get_distance(mid)
- if (end - start > 2 * self.__leaf_capacity) and (
- v_radius > self.__leaf_radius
+ if (end - start > 2 * self._leaf_capacity) and (
+ v_radius > self._leaf_radius
  ):
  self._arr.set_distance(start, v_radius)
  self._arr.set_terminal(start, False)

src/tdamapper/utils/vptree_flat/knn_search.py

@@ -1,41 +1,43 @@
 from tdamapper.utils.heap import MaxHeap
 from tdamapper.utils.vptree_flat.common import _mid
 
+_PRE = 0
+_POST = 1
+
 
 class KnnSearch:
 
  def __init__(self, vpt, point, neighbors):
  self._arr = vpt._get_arr()
- self.__distance = vpt._get_distance()
- self.__point = point
- self.__neighbors = neighbors
- self.__radius = float("inf")
- self.__result = MaxHeap()
+ self._distance = vpt._get_distance()
+ self._point = point
+ self._neighbors = neighbors
+ self._radius = float("inf")
+ self._result = MaxHeap()
 
  def _get_items(self):
- while len(self.__result) > self.__neighbors:
- self.__result.pop()
- return [x for (_, x) in self.__result]
+ while len(self._result) > self._neighbors:
+ self._result.pop()
+ return [x for (_, x) in self._result]
 
  def search(self):
  self._search_iter()
  return self._get_items()
 
  def _process(self, x):
- dist = self.__distance(self.__point, x)
- if dist >= self.__radius:
+ dist = self._distance(self._point, x)
+ if dist >= self._radius:
  return dist
- self.__result.add(dist, x)
- while len(self.__result) > self.__neighbors:
- self.__result.pop()
- if len(self.__result) == self.__neighbors:
- self.__radius, _ = self.__result.top()
+ self._result.add(dist, x)
+ while len(self._result) > self._neighbors:
+ self._result.pop()
+ if len(self._result) == self._neighbors:
+ self._radius, _ = self._result.top()
  return dist
 
  def _search_iter(self):
- PRE, POST = 0, 1
- self.__result = MaxHeap()
- stack = [(0, self._arr.size(), 0.0, PRE)]
+ self._result = MaxHeap()
+ stack = [(0, self._arr.size(), 0.0, _PRE)]
  while stack:
  start, end, thr, action = stack.pop()
 
@@ -47,7 +49,7 @@ def _search_iter(self):
  for x in self._arr.get_points(start, end):
  self._process(x)
  else:
- if action == PRE:
+ if action == _PRE:
  mid = _mid(start, end)
  dist = self._process(v_point)
  if dist <= v_radius:
@@ -56,9 +58,9 @@ def _search_iter(self):
  else:
  fst_start, fst_end = mid, end
  snd_start, snd_end = start + 1, mid
- stack.append((snd_start, snd_end, abs(v_radius - dist), POST))
- stack.append((fst_start, fst_end, 0.0, PRE))
- elif action == POST:
- if self.__radius > thr:
- stack.append((start, end, 0.0, PRE))
+ stack.append((snd_start, snd_end, abs(v_radius - dist), _POST))
+ stack.append((fst_start, fst_end, 0.0, _PRE))
+ elif action == _POST:
+ if self._radius > thr:
+ stack.append((start, end, 0.0, _PRE))
  return self._get_items()