Merge branch 'main' into uv-actions

lizliz · web-flow · commit 2db9803ed72e · 2025-08-01T12:23:53.000-06:00
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
@@ -22,8 +22,6 @@
 <!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
 <!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
 - [ ] My code follows the code style of this project. (`make clean`)
-- [ ] My change requires a change to the documentation.
-- [ ] I have updated the documentation accordingly. (`make html`)
 - [ ] I have incremented the version number in the `pyproject.toml` file.
 - [ ] I have added tests to cover my changes.
 - [ ] All new and existing tests passed. (`make tests`)
diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
@@ -34,7 +34,7 @@ jobs:
           python benchmarks/run_benchmarks.py
         
       - name: Store benchmark results
-        uses: actions/upload-artifact@v3
+        uses: actions/upload-artifact@v4
         with:
           name: benchmark-results
           path: benchmark_results/
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
@@ -0,0 +1,55 @@
+name: Build and Deploy Docs
+on:
+  push:
+    branches: [ "main" ]
+    paths:
+      - 'doc_source/**'
+      - 'src/ect/**'
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - 'doc_source/**'
+      - 'src/ect/**'
+
+jobs:
+  docs:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version-file: "pyproject.toml"
+          
+      - name: Install system dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y pandoc
+          
+      - name: Create venv and install dependencies
+        run: |
+          uv venv
+          source .venv/bin/activate
+          uv pip install -e .
+          uv pip install sphinx sphinx-rtd-theme nbsphinx autopep8 myst-parser
+          
+      - name: Build documentation
+        run: |
+          source .venv/bin/activate
+          make html
+          
+      - name: Deploy to GitHub Pages
+        if: github.event_name == 'push'
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./docs
+          force_orphan: true 
diff --git a/Makefile b/Makefile
@@ -23,12 +23,10 @@ release:
 	python setup.py sdist bdist_wheel
 
 html:
-	# Running sphinx-build to build html files in build folder.
-	rm -r docs
+	# Running sphinx-build to build html files in docs folder
+	rm -rf docs
 	mkdir docs
-	sphinx-build -M html doc_source docs
-	rsync -a docs/html/ docs/
-	rm -r docs/html
+	sphinx-build -b html doc_source docs
 
 benchmark:
 	python benchmarks/run_benchmarks.py
diff --git a/doc_source/directions.md b/doc_source/directions.md
@@ -0,0 +1,6 @@
+# Directions 
+
+```{eval-rst}
+.. automodule:: ect.directions
+   :members:
+```
diff --git a/doc_source/ect_on_graphs.md b/doc_source/ect_on_graphs.md
@@ -4,3 +4,8 @@
 .. automodule:: ect.ect_graph
    :members:
 ```
+
+```{eval-rst}
+.. automodule:: ect.sect
+   :members:
+```
diff --git a/doc_source/modules.rst b/doc_source/modules.rst
@@ -7,4 +7,5 @@ Table of Contents
    
    Embedded graphs <embed_graph.md>
    Embedded CW complex <embed_cw.md>
-   ECT on graphs <ect_on_graphs.md>
+   ECT on graphs <ect_on_graphs.md>
+   Directions <directions.md>
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "ect"
-version = "1.0.0"
+version = "1.0.3"
 authors = [
   { name="Liz Munch", email="muncheli@msu.edu" },
 ]
diff --git a/src/ect/__init__.py b/src/ect/__init__.py
@@ -12,12 +12,14 @@
 from .embed_graph import EmbeddedGraph
 from .embed_cw import EmbeddedCW
 from .directions import Directions
+from .sect import SECT
 from .utils import examples
 
 __all__ = [
-    'ECT',
-    'EmbeddedGraph',
-    'EmbeddedCW',
-    'Directions',
-    'examples',
+    "ECT",
+    "SECT",
+    "EmbeddedGraph",
+    "EmbeddedCW",
+    "Directions",
+    "examples",
 ]
diff --git a/src/ect/ect_graph.py b/src/ect/ect_graph.py
@@ -1,5 +1,6 @@
 import numpy as np
 from numba import prange, njit
+from numba.typed import List
 from typing import Optional, Union
 
 from .embed_cw import EmbeddedCW
@@ -55,8 +56,7 @@ def _ensure_directions(self, graph_dim, theta=None):
         """Ensures directions is a valid Directions object of correct dimension"""
         if self.directions is None:
             if self.num_dirs is None:
-                raise ValueError(
-                    "Either 'directions' or 'num_dirs' must be provided.")
+                raise ValueError("Either 'directions' or 'num_dirs' must be provided.")
             self.directions = Directions.uniform(self.num_dirs, dim=graph_dim)
         elif isinstance(self.directions, list):
             # if list of vectors, convert to Directions object
@@ -127,12 +127,10 @@ def calculate(
 
         # override with theta if provided
         directions = (
-            self.directions if theta is None else Directions.from_angles([
-                                                                         theta])
+            self.directions if theta is None else Directions.from_angles([theta])
         )
 
-        simplex_projections = self._compute_simplex_projections(
-            graph, directions)
+        simplex_projections = self._compute_simplex_projections(graph, directions)
 
         ect_matrix = self._compute_directional_transform(
             simplex_projections, self.thresholds, self.shape_descriptor, self.dtype
@@ -148,7 +146,7 @@ def _compute_simplex_projections(
         self, graph: Union[EmbeddedGraph, EmbeddedCW], directions
     ):
         """Compute projections of each simplex (vertices, edges, faces)"""
-        simplex_projections = []
+        simplex_projections = List()
         node_projections = self._compute_node_projections(
             graph.coord_matrix, directions
         )
@@ -162,11 +160,9 @@ def _compute_simplex_projections(
 
         if isinstance(graph, EmbeddedCW) and len(graph.faces) > 0:
             node_to_index = {n: i for i, n in enumerate(graph.node_list)}
-            face_indices = [[node_to_index[v] for v in face]
-                            for face in graph.faces]
+            face_indices = [[node_to_index[v] for v in face] for face in graph.faces]
             face_maxes = np.array(
-                [np.max(node_projections[face, :], axis=0)
-                 for face in face_indices]
+                [np.max(node_projections[face, :], axis=0) for face in face_indices]
             )
             simplex_projections.append(face_maxes)
 
@@ -192,7 +188,7 @@ def _compute_directional_transform(
         num_thresh = thresholds.shape[0]
         result = np.empty((num_dir, num_thresh), dtype=dtype)
 
-        sorted_projections = []
+        sorted_projections = List()
         for proj in simplex_projections_list:
             sorted_proj = np.empty_like(proj)
             for i in prange(num_dir):
@@ -202,7 +198,7 @@ def _compute_directional_transform(
         for j in prange(num_thresh):
             thresh = thresholds[j]
             for i in range(num_dir):
-                simplex_counts_list = []
+                simplex_counts_list = List()
                 for k in range(len(sorted_projections)):
                     projs = sorted_projections[k][:, i]
                     simplex_counts_list.append(
@@ -212,7 +208,7 @@ def _compute_directional_transform(
         return result
 
     @staticmethod
-    @njit(parallel=True, fastmath=True)
+    @njit(fastmath=True)
     def shape_descriptor(simplex_counts_list):
         """Calculate shape descriptor from simplex counts (Euler characteristic)"""
         chi = 0
diff --git a/src/ect/sect.py b/src/ect/sect.py
@@ -0,0 +1,59 @@
+from ect import ECT
+from .embed_graph import EmbeddedGraph
+from .embed_cw import EmbeddedCW
+from .directions import Directions
+from .results import ECTResult
+from typing import Optional, Union
+import numpy as np
+
+
+class SECT(ECT):
+    """
+    A class to calculate the Smooth Euler Characteristic Transform (SECT).
+    Inherits from ECT and applies smoothing to the final result.
+    """
+
+    def __init__(
+        self,
+        directions: Optional[Directions] = None,
+        num_dirs: Optional[int] = None,
+        num_thresh: Optional[int] = None,
+        bound_radius: Optional[float] = None,
+        thresholds: Optional[np.ndarray] = None,
+        dtype=np.float32,
+    ):
+        """Initialize SECT calculator with smoothing parameter
+
+        Args:
+            directions: Optional pre-configured Directions object
+            num_dirs: Number of directions to sample (ignored if directions provided)
+            num_thresh: Number of threshold values (required if directions not provided)
+            bound_radius: Optional radius for bounding circle
+            thresholds: Optional array of thresholds
+            dtype: Data type for output array
+        """
+        super().__init__(
+            directions, num_dirs, num_thresh, bound_radius, thresholds, dtype
+        )
+
+    def calculate(
+        self,
+        graph: Union[EmbeddedGraph, EmbeddedCW],
+        theta: Optional[float] = None,
+        override_bound_radius: Optional[float] = None,
+    ) -> ECTResult:
+        """Calculate Smooth Euler Characteristic Transform (SECT)
+
+        Args:
+            graph: The input graph to calculate the SECT for
+            theta: The angle in [0,2π] for the direction to calculate the SECT
+            override_bound_radius: Optional override for bounding radius
+
+        Returns:
+            ECTResult: The smoothed transform result containing the matrix,
+                      directions, and thresholds
+        """
+        ect_result = super().calculate(graph, theta, override_bound_radius)
+        return ECTResult(
+            ect_result, ect_result.directions, ect_result.thresholds
+        ).smooth()
diff --git a/tests/test_sect.py b/tests/test_sect.py
@@ -0,0 +1,76 @@
+import unittest
+import numpy as np
+from ect import SECT, ECT
+from ect.utils.examples import create_example_graph
+from ect.directions import Directions
+
+
+class TestSECT(unittest.TestCase):
+    def setUp(self):
+        """Set up test fixtures"""
+        self.graph = create_example_graph()
+        self.num_dirs = 8
+        self.num_thresh = 10
+        self.sect = SECT(num_dirs=self.num_dirs, num_thresh=self.num_thresh)
+
+    def test_inheritance(self):
+        """Test that SECT properly inherits from ECT"""
+        self.assertIsInstance(self.sect, ECT)
+        self.assertTrue(hasattr(self.sect, "calculate"))
+
+    def test_calculate_output_shape(self):
+        """Test that SECT calculation returns correct shape"""
+        result = self.sect.calculate(self.graph)
+
+        self.assertEqual(result.shape[0], self.num_dirs)
+        self.assertEqual(result.shape[1], self.num_thresh)
+        self.assertEqual(len(result.thresholds), self.num_thresh)
+        self.assertEqual(len(result.directions), self.num_dirs)
+
+    def test_smoothing_effect(self):
+        """Test that smoothing is actually applied"""
+        # Calculate both ECT and SECT
+        ect = ECT(num_dirs=self.num_dirs, num_thresh=self.num_thresh)
+        sect = SECT(num_dirs=self.num_dirs, num_thresh=self.num_thresh)
+
+        ect_result = ect.calculate(self.graph)
+        sect_result = sect.calculate(self.graph)
+
+        # Verify results are different due to smoothing
+        self.assertFalse(np.allclose(ect_result, sect_result))
+
+        # Verify smoothing preserves direction count
+        self.assertEqual(
+            np.sum(ect_result, axis=1).shape,
+            np.sum(sect_result, axis=1).shape,
+        )
+
+    def test_with_theta(self):
+        """Test SECT calculation with specific theta value"""
+        theta = np.pi / 4
+        result = self.sect.calculate(self.graph, theta=theta)
+
+        # Should only have one direction when theta is specified
+        self.assertEqual(result.shape[0], 1)
+        self.assertEqual(result.shape[1], self.num_thresh)
+
+    def test_with_override_radius(self):
+        """Test SECT calculation with override_bound_radius"""
+        override_radius = 2.0
+        result = self.sect.calculate(self.graph, override_bound_radius=override_radius)
+
+        # Check that thresholds are within the override radius
+        self.assertLessEqual(np.max(np.abs(result.thresholds)), override_radius)
+
+    def test_smooth_matrix_properties(self):
+        """Test properties of the smoothed matrix"""
+        result = self.sect.calculate(self.graph)
+
+        # Smoothed values should be finite
+        self.assertTrue(np.all(np.isfinite(result)))
+
+        # Shape should be preserved after smoothing
+        self.assertEqual(result.shape, (self.num_dirs, self.num_thresh))
+
+        # Verify result is float type after smoothing
+        self.assertTrue(np.issubdtype(result.dtype, np.floating))

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`[project]`
`2`	`2`	`name = "ect"`
`3`		`-version = "1.0.0"`
	`3`	`+version = "1.0.3"`
`4`	`4`	`authors = [`
`5`	`5`	`{ name="Liz Munch", email="muncheli@msu.edu" },`
`6`	`6`	`]`