https://github.com/pckroon/hypothesis-networkx
Hypothesis strategy to generate NetworkX graphs.
https://github.com/pckroon/hypothesis-networkx
graph graph-generation hacktoberfest hypothesis networkx python testing
Last synced: about 1 year ago
JSON representation
Hypothesis strategy to generate NetworkX graphs.
- Host: GitHub
- URL: https://github.com/pckroon/hypothesis-networkx
- Owner: pckroon
- License: apache-2.0
- Created: 2018-07-11T12:43:07.000Z (almost 8 years ago)
- Default Branch: master
- Last Pushed: 2023-09-15T12:47:26.000Z (almost 3 years ago)
- Last Synced: 2025-03-28T17:48:06.618Z (about 1 year ago)
- Topics: graph, graph-generation, hacktoberfest, hypothesis, networkx, python, testing
- Language: Python
- Homepage:
- Size: 71.3 KB
- Stars: 18
- Watchers: 1
- Forks: 4
- Open Issues: 1
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
[](https://travis-ci.org/pckroon/hypothesis-networkx)
[](https://codecov.io/gh/pckroon/hypothesis-networkx)
# Hypothesis-networkx
This module provides a Hypothesis strategy for generating networkx graphs.
This can be used to efficiently and thoroughly test your code.
## Installation
This module can be installed via `pip`:
```
pip install hypothesis-networkx
```
## User guide
The module exposes a single function: `graph_builder`. This function is a
hypothesis composite strategy for building graphs. You can use it as follows:
```python3
from hypothesis_networkx import graph_builder
from hypothesis import strategies as st
import networkx as nx
node_data = st.fixed_dictionaries({'name': st.text(),
'number': st.integers()})
edge_data = st.fixed_dictionaries({'weight': st.floats(allow_nan=False,
allow_infinity=False)})
builder = graph_builder(graph_type=nx.Graph,
node_keys=st.integers(),
node_data=node_data,
edge_data=edge_data,
min_nodes=2, max_nodes=10,
min_edges=1, max_edges=None,
self_loops=False,
connected=True)
graph = builder.example()
print(graph.nodes(data=True))
print(graph.edges(data=True))
```
Of course this builder is a valid hypothesis strategy, and using it to just
make examples is not super useful. Instead, you can (and should) use it in
your testing framework:
```python3
from hypothesis import given
@given(graph=builder)
def test_my_function(graph):
assert my_function(graph) == known_function(graph)
```
The meaning of the arguments given to `graph_builder` are pretty
self-explanatory, but they *must* be given as keyword arguments.
- `node_data`: The strategy from which node attributes will be drawn.
- `edge_data`: The strategy from which edge attributes will be drawn.
- `node_keys`: Either the strategy from which node keys will be draw, or
None. If None, node keys will be integers from the range (0, number of nodes).
- `min_nodes` and `max_nodes`: The minimum and maximum number of nodes the
produced graphs will contain.
- `min_edges` and `max_edges`: The minimum and maximum number of edges the
produced graphs will contain. Note that less
edges than `min_edges` may be added if there
are not enough nodes, and more than
`max_edges` if `connected` is True.
- `graph_type`: This function (or class) will be called without arguments to
create an empty initial graph.
- `connected`: If True, the generated graph is guaranteed to be a single
connected component.
- `self_loops`: If False, there will be no self-loops in the generated graph.
Self-loops are edges between a node and itself.
## Known limitations
There are a few (minor) outstanding issues with this module:
- Graph generation may be slow for large graphs.
- The `min_edges` argument is not always respected when the produced graph
is too small.
- The `max_edges` argument is not always respected if `connected` is True.
- It currently works for Python 2.7, but this is considered deprecated and
may stop working without notice.
## See also
[Networkx](https://networkx.github.io/documentation/stable/index.html)
[Hypothesis](https://hypothesis.readthedocs.io/en/latest/index.html)