edsger 0.1.0__tar.gz → 0.1.2__tar.gz

{edsger-0.1.0 → edsger-0.1.2}/.github/workflows/publish.yml

@@ -10,7 +10,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ["3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v4
@@ -54,6 +54,7 @@ jobs:
 
       - uses: actions/upload-artifact@v4
         with:
+          name: cibw-sdist
           path: ./dist/*.tar.gz
 
   build_wheels:
@@ -95,7 +96,8 @@ jobs:
     - name: Download all the dists
       uses: actions/download-artifact@v4
       with:
-        name: artifact
+        pattern: cibw-*
         path: ./dist/
+        merge-multiple: true
     - name: Publish distribution to PyPI
       uses: pypa/gh-action-pypi-publish@release/v1

edsger-0.1.2/.github/workflows/tests.yml

@@ -0,0 +1,41 @@
+name: ci-test
+
+on:
+  push:
+    branches: 
+      - release
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, windows-2022, macos-14]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v5
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements-dev.txt
+        pip install .
+    - name: Format Python code with black
+      run: |
+        black --check --diff .
+    - name: Lint Cython code
+      run: |
+        cython-lint src/edsger/commons.pyx src/edsger/dijkstra.pyx src/edsger/path_tracking.pyx src/edsger/pq_4ary_dec_0b.pyx src/edsger/spiess_florian.pyx src/edsger/star.pyx src/edsger/commons.pxd src/edsger/pq_4ary_dec_0b.pxd
+    - name: Testing
+      run: |
+        python -m pytest --cov=src/edsger --cov-report=xml tests/
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v4
+      with:
+        file: ./coverage.xml
+        flags: unittests
+        name: codecov-umbrella
+        fail_ci_if_error: false

edsger-0.1.2/.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+repos:
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+        files: '\.(py)$'
+        exclude: 'src/edsger/.*\.pyx$'
+
+  - repo: https://github.com/MarcoGorelli/cython-lint
+    rev: v0.16.2
+    hooks:
+      - id: cython-lint
+        files: '\.(pyx|pxd)$'
+        args: [--max-line-length=88]

edsger-0.1.2/PKG-INFO

@@ -0,0 +1,118 @@
+Metadata-Version: 2.4
+Name: edsger
+Version: 0.1.2
+Summary: Graph algorithms in Cython.
+Author-email: François Pacull <francois.pacull@architecture-performance.fr>
+Maintainer-email: François Pacull <francois.pacull@architecture-performance.fr>
+License: MIT License
+Project-URL: Repository, https://github.com/aetperf/Edsger
+Project-URL: Documentation, https://edsger.readthedocs.io
+Keywords: python,graph,shortest path,Dijkstra
+Platform: any
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: AUTHORS.rst
+Requires-Dist: setuptools
+Requires-Dist: setuptools_scm
+Requires-Dist: numpy>=1.26
+Requires-Dist: Cython>=3
+Requires-Dist: pandas
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: scipy<1.11; extra == "test"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx_design; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"
+Dynamic: license-file
+
+
+![Tests Status](https://github.com/aetperf/edsger/actions/workflows/tests.yml/badge.svg?branch=release)
+[![codecov](https://codecov.io/gh/aetperf/edsger/branch/release/graph/badge.svg)](https://codecov.io/gh/aetperf/edsger)
+[![PyPI version](https://img.shields.io/pypi/v/edsger.svg)](https://pypi.org/project/edsger/)
+[![Downloads](https://static.pepy.tech/badge/edsger)](https://pepy.tech/project/edsger)
+[![Python 3.9 | 3.10 | 3.11 | 3.12 | 3.13](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/project/edsger/)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Cython lint: cython-lint](https://img.shields.io/badge/cython--lint-enabled-brightgreen.svg)](https://github.com/MarcoGorelli/cython-lint)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# Edsger
+
+*Graph algorithms in Cython*
+
+Welcome to our Python library for graph algorithms. So far, the library only includes Dijkstra's algorithm but we should add a range of common path algorithms later. It is also open-source and easy to integrate with other Python libraries. To get started, simply install the library using pip, and import it into your Python project.
+
+Documentation : [https://edsger.readthedocs.io/en/latest/](https://edsger.readthedocs.io/en/latest/)
+
+## Small example : Dijkstra's Algorithm
+
+To use Dijkstra's algorithm, you can import the `Dijkstra` class from the `path` module. The function takes a graph and a source node as input, and returns the shortest path from the source node to all other nodes in the graph.
+
+```python
+import pandas as pd
+
+from edsger.path import Dijkstra
+
+# Create a DataFrame with the edges of the graph
+edges = pd.DataFrame({
+    'tail': [0, 0, 1, 2, 2, 3],
+    'head': [1, 2, 2, 3, 4, 4],
+    'weight': [1, 4, 2, 1.5, 3, 1]
+})
+edges
+```
+
+    |    |   tail |   head |   weight |
+    |---:|-------:|-------:|---------:|
+    |  0 |      0 |      1 |      1.0 |
+    |  1 |      0 |      2 |      4.0 |
+    |  2 |      1 |      2 |      2.0 |
+    |  3 |      2 |      3 |      1.5 |
+    |  4 |      2 |      4 |      3.0 |
+    |  5 |      3 |      4 |      1.0 |
+
+```python
+# Initialize the Dijkstra object
+dijkstra = Dijkstra(edges)
+
+# Run the algorithm from a source vertex
+shortest_paths = dijkstra.run(vertex_idx=0)
+print("Shortest paths:", shortest_paths)
+```
+
+    Shortest paths: [0.  1.  3.  4.5 5.5]
+
+We get the shortest paths from the source node 0 to all other nodes in the graph. The output is an array with the shortest path length to each node. A path length is the sum of the weights of the edges in the path.
+
+## Why Use Edsger?
+
+Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
+
+<img src="docs/source/assets/dijkstra_benchmark_comparison.png" alt="Dijkstra Performance Comparison" width="700">
+
+*Benchmark performed on Intel i9-12900H laptop.*
+
+## Contributing
+
+We welcome contributions to the Edsger library. If you have any suggestions, bug reports, or feature requests, please open an issue on our [GitHub repository](https://github.com/aetperf/Edsger).
+
+## License
+
+Edsger is licensed under the MIT License. See the LICENSE file for more details.
+
+## Contact
+
+For any questions or inquiries, please contact François Pacull at [francois.pacull@architecture-performance.fr](mailto:francois.pacull@architecture-performance.fr).

edsger-0.1.2/README.md

@@ -0,0 +1,77 @@
+
+![Tests Status](https://github.com/aetperf/edsger/actions/workflows/tests.yml/badge.svg?branch=release)
+[![codecov](https://codecov.io/gh/aetperf/edsger/branch/release/graph/badge.svg)](https://codecov.io/gh/aetperf/edsger)
+[![PyPI version](https://img.shields.io/pypi/v/edsger.svg)](https://pypi.org/project/edsger/)
+[![Downloads](https://static.pepy.tech/badge/edsger)](https://pepy.tech/project/edsger)
+[![Python 3.9 | 3.10 | 3.11 | 3.12 | 3.13](https://img.shields.io/badge/python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://pypi.org/project/edsger/)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Cython lint: cython-lint](https://img.shields.io/badge/cython--lint-enabled-brightgreen.svg)](https://github.com/MarcoGorelli/cython-lint)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+# Edsger
+
+*Graph algorithms in Cython*
+
+Welcome to our Python library for graph algorithms. So far, the library only includes Dijkstra's algorithm but we should add a range of common path algorithms later. It is also open-source and easy to integrate with other Python libraries. To get started, simply install the library using pip, and import it into your Python project.
+
+Documentation : [https://edsger.readthedocs.io/en/latest/](https://edsger.readthedocs.io/en/latest/)
+
+## Small example : Dijkstra's Algorithm
+
+To use Dijkstra's algorithm, you can import the `Dijkstra` class from the `path` module. The function takes a graph and a source node as input, and returns the shortest path from the source node to all other nodes in the graph.
+
+```python
+import pandas as pd
+
+from edsger.path import Dijkstra
+
+# Create a DataFrame with the edges of the graph
+edges = pd.DataFrame({
+    'tail': [0, 0, 1, 2, 2, 3],
+    'head': [1, 2, 2, 3, 4, 4],
+    'weight': [1, 4, 2, 1.5, 3, 1]
+})
+edges
+```
+
+    |    |   tail |   head |   weight |
+    |---:|-------:|-------:|---------:|
+    |  0 |      0 |      1 |      1.0 |
+    |  1 |      0 |      2 |      4.0 |
+    |  2 |      1 |      2 |      2.0 |
+    |  3 |      2 |      3 |      1.5 |
+    |  4 |      2 |      4 |      3.0 |
+    |  5 |      3 |      4 |      1.0 |
+
+```python
+# Initialize the Dijkstra object
+dijkstra = Dijkstra(edges)
+
+# Run the algorithm from a source vertex
+shortest_paths = dijkstra.run(vertex_idx=0)
+print("Shortest paths:", shortest_paths)
+```
+
+    Shortest paths: [0.  1.  3.  4.5 5.5]
+
+We get the shortest paths from the source node 0 to all other nodes in the graph. The output is an array with the shortest path length to each node. A path length is the sum of the weights of the edges in the path.
+
+## Why Use Edsger?
+
+Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
+
+<img src="docs/source/assets/dijkstra_benchmark_comparison.png" alt="Dijkstra Performance Comparison" width="700">
+
+*Benchmark performed on Intel i9-12900H laptop.*
+
+## Contributing
+
+We welcome contributions to the Edsger library. If you have any suggestions, bug reports, or feature requests, please open an issue on our [GitHub repository](https://github.com/aetperf/Edsger).
+
+## License
+
+Edsger is licensed under the MIT License. See the LICENSE file for more details.
+
+## Contact
+
+For any questions or inquiries, please contact François Pacull at [francois.pacull@architecture-performance.fr](mailto:francois.pacull@architecture-performance.fr).

{edsger-0.1.0 → edsger-0.1.2}/docs/source/api.md

@@ -114,23 +114,3 @@ paths = dijkstra.run(
     heap_length_ratio=0.5
 )
 ```
-
-### Graph Data Format
-
-Edsger expects graph data as a pandas DataFrame with the following structure:
-
-| Column | Type    | Description                          |
-|--------|---------|--------------------------------------|
-| tail   | int     | Source vertex ID                     |
-| head   | int     | Destination vertex ID                |
-| weight | float   | Edge weight (must be non-negative)   |
-
-Example:
-```python
-edges = pd.DataFrame({
-    'tail': [0, 0, 1, 2],
-    'head': [1, 2, 2, 3],
-    'weight': [1.0, 4.0, 2.0, 1.0]
-})
-```
-

{edsger-0.1.0 → edsger-0.1.2}/docs/source/conf.py

@@ -18,12 +18,13 @@ sys.path.insert(0, os.path.abspath("../../src/"))
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
 project = "Edsger"
-copyright = "2024, Architecture & Performance"
+copyright = "2025, Architecture & Performance"
 author = "Francois Pacull"
 
 # Get version from the package
 try:
     from edsger._version import __version__
+
     release = __version__
     version = __version__
 except ImportError:
@@ -69,6 +70,6 @@ myst_enable_extensions = [
 
 # Source suffix
 source_suffix = {
-    '.rst': 'restructuredtext',
-    '.md': 'markdown',
-}
+    ".rst": "restructuredtext",
+    ".md": "markdown",
+}

edsger-0.1.2/docs/source/index.md

@@ -0,0 +1,80 @@
+---
+github_url: https://github.com/aetperf/Edsger
+---
+
+# Edsger
+
+*Graph algorithms in Cython*
+
+Welcome to the Edsger documentation! Edsger is a Python library for efficient graph algorithms implemented in Cython. The library currently focuses on shortest path algorithms, with Dijkstra's algorithm fully implemented and additional algorithms planned for future releases.
+
+## Why Use Edsger?
+
+Edsger is designed to be **dataframe-friendly**, providing seamless integration with pandas workflows for graph algorithms. Also it is rather efficient. Our benchmarks on the USA road network (23.9M vertices, 57.7M edges) demonstrate nice performance:
+
+<img src="assets/dijkstra_benchmark_comparison.png" alt="Dijkstra Performance Comparison" width="700">
+
+*Benchmark performed on Intel i9-12900H laptop.*
+
+### Pandas Integration Made Simple
+
+```python
+import pandas as pd
+from edsger.path import Dijkstra
+
+# Your graph data is already in a DataFrame
+edges = pd.DataFrame({
+    'tail': [0, 0, 1, 2],
+    'head': [1, 2, 2, 3], 
+    'weight': [1.0, 2.0, 1.5, 1.0]
+})
+
+# No conversion needed - use directly!
+dijkstra = Dijkstra(edges, orientation="out")
+distances = dijkstra.run(vertex_idx=0)
+```
+
+## Key Features
+
+- **Native pandas DataFrame support** - No graph object conversion required
+- **High performance** - Cython implementation with aggressive optimizations
+- **Memory efficient** - Optimized for large-scale real-world datasets
+- **Easy integration** with NumPy and pandas workflows
+- **Production ready** - Comprehensive testing across Python 3.9-3.13
+
+## Quick Links
+
+- [Installation](installation.md) - How to install Edsger
+- [Quick Start](quickstart.md) - Get started quickly with basic examples
+- [API Reference](api.md) - Complete API reference
+
+## Table of Contents
+
+```{toctree}
+:maxdepth: 2
+:caption: User Guide
+
+installation
+quickstart
+```
+
+```{toctree}
+:maxdepth: 2
+:caption: API Reference
+
+api
+```
+
+```{toctree}
+:maxdepth: 1
+:caption: Development
+
+contributing
+```
+
+## Indices
+
+- {ref}`genindex`
+- {ref}`modindex`
+- {ref}`search`
+

{edsger-0.1.0 → edsger-0.1.2}/docs/source/quickstart.md

@@ -2,22 +2,27 @@
 
 Welcome to our Python library for graph algorithms. So far, the library only includes Dijkstra's algorithm but we should add a range of common path algorithms later. It is also open-source and easy to integrate with other Python libraries.
 
-## Dijkstra's Algorithm
 
-To use Dijkstra's algorithm, you can import the `Dijkstra` class from the `path` module. The function takes a graph and a source node as input, and returns the shortest path from the source node to all other nodes in the graph.
+## Graph Data Format
+
+Edsger expects graph data as a pandas DataFrame with the following structure:
+
+| Column | Type    | Description                          |
+|--------|---------|--------------------------------------|
+| tail   | int     | Source vertex ID                     |
+| head   | int     | Destination vertex ID                |
+| weight | float   | Edge weight (must be non-negative)   |
 
+Example:
 ```python
 import pandas as pd
 
-from edsger.path import Dijkstra
-
-# Create a DataFrame with the edges of the graph
 edges = pd.DataFrame({
-    'tail': [0, 0, 1, 2, 2, 3],
-    'head': [1, 2, 2, 3, 4, 4],
-    'weight': [1, 4, 2, 1, 3, 1]
+    'tail': [0, 0, 1, 2],
+    'head': [1, 2, 2, 3],
+    'weight': [1.0, 4.0, 2.0, 1.0]
 })
-edges
+edsges
 ```
 
 |    |   tail |   head |   weight |
@@ -26,8 +31,32 @@ edges
 |  1 |      0 |      2 |        4 |
 |  2 |      1 |      2 |        2 |
 |  3 |      2 |      3 |        1 |
-|  4 |      2 |      4 |        3 |
-|  5 |      3 |      4 |        1 |
+
+
+## Dijkstra's Algorithm
+
+To use Dijkstra's algorithm, you can import the `Dijkstra` class from the `path` module. The function takes a graph and a source node as input, and returns the shortest path from the source node to all other nodes in the graph.
+
+```python
+from edsger.path import Dijkstra
+
+# Create a DataFrame with the edges of the graph
+edges = pd.DataFrame({
+    'tail': [0, 0, 1, 2, 2, 3],
+    'head': [1, 2, 2, 3, 4, 4],
+    'weight': [1, 4, 2, 1.5, 3, 1]
+})
+edges
+```
+
+    |    |   tail |   head |   weight |
+    |---:|-------:|-------:|---------:|
+    |  0 |      0 |      1 |      1.0 |
+    |  1 |      0 |      2 |      4.0 |
+    |  2 |      1 |      2 |      2.0 |
+    |  3 |      2 |      3 |      1.5 |
+    |  4 |      2 |      4 |      3.0 |
+    |  5 |      3 |      4 |      1.0 |
 
 
 ```python
@@ -39,7 +68,7 @@ shortest_paths = dijkstra.run(vertex_idx=0)
 print("Shortest paths:", shortest_paths)
 ```
 
-    Shortest paths: [0. 1. 3. 4. 5.]
+    Shortest paths: [0.  1.  3.  4.5 5.5]
 
 We get the shortest paths from the source node 0 to all other nodes in the graph. The output is an array with the shortest path length to each node. A path length is the sum of the weights of the edges in the path.
 
@@ -49,12 +78,12 @@ It is also possible to use a graph with different column names for the tail, hea
 other_edges = pd.DataFrame({
     'from': [0, 0, 1, 2, 2, 3],
     'to': [1, 2, 2, 3, 4, 4],
-    'travel_time': [1, 4, 2, 1, 3, 1]
+    'travel_time': [1, 4, 2, 1.5, 3, 1]
 })
-other_dijkstra = Dijkstra(edges, tail='from', head='to', weight='travel_time')
+other_dijkstra = Dijkstra(other_edges, tail='from', head='to', weight='travel_time')
 ```
 
-## Orientation
+### Orientation
 
 The `orientation` argument (a string with a default value of `'out'`) specifies the orientation of the algorithm. It can be either `'out'` for single source shortest paths or `'in'` for single target shortest path.
 
@@ -68,7 +97,7 @@ print("Shortest paths:", shortest_paths)
 
     Shortest paths: [ 0. inf inf inf inf]
 
-## Run Multiple Times
+### Run Multiple Times
 
 Once the Dijkstra is instantiated with a given graph and orientation, the `run` method can be called multiple times with different source vertices.
 
@@ -78,9 +107,9 @@ shortest_paths = dijkstra.run(vertex_idx=4)
 print("Shortest paths:", shortest_paths)
 ```
 
-    Shortest paths: [5. 4. 2. 1. 0.]
+    Shortest paths: [5.5 4.5 2.5 1.  0. ]
 
-## Check Edges
+### Check Edges
 
 The `check_edges` argument (a boolean with a default value of `False`) validates the given graph. When set to `True`, it ensures the DataFrame is well-formed by:
 
@@ -101,7 +130,7 @@ dijkstra = Dijkstra(invalid_edges, check_edges=True)
 
     ValueError: edges['weight'] should be nonnegative
 
-## Permute
+### Permute
 
 Finally, the `permute` argument (boolean with a default value of `False`) allows to permute the IDs of the nodes. If set to `True`, the node IDs will be reindexed to start from 0 and be contiguous for the inner computations, and the output will be reindexed to the original IDs, loading the same result as if the IDs were not permuted. The permutation may save memory and computation time for large graphs, for example if a significant ratio of the nodes are not actually used in the graph.
 
@@ -111,7 +140,7 @@ SHIFT = 1000
 shifted_edges = pd.DataFrame({
     'tail': [0, 0, 1, 2, 2, 3],
     'head': [1, 2, 2, 3, 4, 4],
-    'weight': [1, 4, 2, 1, 3, 1]
+    'weight': [1, 4, 2, 1.5, 3, 1]
 })
 shifted_edges["tail"] += SHIFT
 shifted_edges["head"] += SHIFT
@@ -120,9 +149,9 @@ shifted_edges.head(3)
 
 |    |   tail |   head |   weight |
 |---:|-------:|-------:|---------:|
-|  0 |   1000 |   1001 |        1 |
-|  1 |   1000 |   1002 |        4 |
-|  2 |   1001 |   1002 |        2 |
+|  0 |   1000 |   1001 |      1.0 |
+|  1 |   1000 |   1002 |      4.0 |
+|  2 |   1001 |   1002 |      2.0 |
 
 
 
@@ -132,15 +161,16 @@ shortest_paths = dijkstra.run(vertex_idx=0 + SHIFT)
 print("Shortest paths:", shortest_paths)
 ```
 
-    Shortest paths: [inf inf inf ...  3.  4.  5.]
+    Shortest paths: [inf inf inf ... 3.  4.5 5.5]
 
 ```python
 shortest_paths[-5:]
 ```
 
-    array([0., 1., 3., 4., 5.])
+    array([0. , 1. , 3. , 4.5, 5.5])
+
 
-## Run Method Options
+### Run Method Options
 
 The `run` method can take the following arguments besides the source/target vertex index:
 
@@ -190,11 +220,11 @@ shortest_paths
 
 |   vertex_idx |   path_length |
 |-------------:|--------------:|
-|            0 |             5 |
-|            1 |             4 |
-|            2 |             2 |
-|            3 |             1 |
-|            4 |             0 |
+|            0 |           5.5 |
+|            1 |           4.5 |
+|            2 |           2.5 |
+|            3 |           1.0 |
+|            4 |           0.0 |
 
 
 - `heap_length_ratio` : float, optional (default=1.0)

{edsger-0.1.0 → edsger-0.1.2}/pyproject.toml

@@ -7,7 +7,7 @@ name = "edsger"
 dynamic = ["version"]
 description = "Graph algorithms in Cython."
 readme = "README.md"
-requires-python = ">=3.11"
+requires-python = ">=3.9"
 license = {text = "MIT License"}
 authors = [
     { name = "François Pacull", email = "francois.pacull@architecture-performance.fr" },
@@ -19,6 +19,11 @@ keywords = ["python", "graph", "shortest path", "Dijkstra"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Topic :: Scientific/Engineering"
@@ -61,4 +66,8 @@ write_to_template = '__version__ = "{version}"'
 [tool.pytest.ini_options]
 testpaths = [
     "tests"
-]
+]
+
+[tool.cibuildwheel]
+# Skip 32-bit i686 architectures (outdated, rarely needed)
+skip = "*_i686"

{edsger-0.1.0 → edsger-0.1.2}/requirements-dev.txt

@@ -4,12 +4,15 @@
 # Testing
 scipy
 pytest
+pytest-cov
 
 # Scripts
 loguru
 pyarrow
 
 # Linting/Tooling
+cython-lint
+black
 
 # Documentation
 sphinx