.
675 |
--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | VERSION=$(shell python3 -c "from configparser import ConfigParser; p = ConfigParser(); p.read('setup.cfg'); print(p['metadata']['version'])")
2 |
3 | default:
4 | @echo "\"make publish\"?"
5 |
6 | tag:
7 | # Make sure we're on the main branch
8 | @if [ "$(shell git rev-parse --abbrev-ref HEAD)" != "main" ]; then exit 1; fi
9 | # @echo "Tagging v$(VERSION)..."
10 | # git tag v$(VERSION)
11 | # git push --tags
12 | curl -H "Authorization: token `cat $(HOME)/.github-access-token`" -d '{"tag_name": "v$(VERSION)"}' https://api.github.com/repos/nschloe/stressberry/releases
13 |
14 | upload:
15 | @if [ "$(shell git rev-parse --abbrev-ref HEAD)" != "main" ]; then exit 1; fi
16 | rm -f dist/*
17 | # python3 setup.py sdist bdist_wheel
18 | # https://stackoverflow.com/a/58756491/353337
19 | python3 -m build --sdist --wheel .
20 | twine upload dist/*
21 |
22 | publish: tag upload
23 |
24 | clean:
25 | @find . | grep -E "(__pycache__|\.pyc|\.pyo$\)" | xargs rm -rf
26 | @rm -rf *.egg-info/ build/ dist/
27 |
28 | format:
29 | isort .
30 | black .
31 | blacken-docs README.md
32 |
33 | lint:
34 | black --check .
35 | flake8 .
36 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
2 | 
3 |
Stress tests and temperature plots for the Raspberry Pi
4 |
5 |
6 | [](https://pypi.org/project/stressberry)
7 | [](https://pypi.org/pypi/stressberry/)
8 | [](https://github.com/nschloe/stressberry)
9 | [](https://pypistats.org/packages/stressberry)
10 |
11 | [](https://github.com/nschloe/stressberry/actions?query=workflow%3Aci)
12 | [](https://codecov.io/gh/nschloe/stressberry)
13 | [](https://github.com/psf/black)
14 |
15 | There are a million ways to cool down your Raspberry Pi: Small heat sinks, specific
16 | cases, and some [extreme DIY solutions](https://youtu.be/WfQMLInuwws). stressberry is a
17 | package for testing the core temperature under different loads, and it produces nice
18 | plots which can easily be compared.
19 |
20 | ### Raspberry Pi 4B
21 | 
| 
22 | :--------------------------------------:|:----------------------:|
23 | active | passive
24 |
25 | 
| 
| 
26 | :--------------------------------------:|:----------------------:|:------:|
27 | custom case with fans (@flyingferret, [#21](https://github.com/nschloe/stressberry/issues/21)) | [KKSB case](https://kksb-cases.com/products/kksb-raspberry-pi-4-case-aluminium) (@JohBod, [#31](https://github.com/nschloe/stressberry/issues/31)) | [Argon One case](https://www.argon40.com/argon1/argon-one-pi4.html) (@jholloway, [#37](https://github.com/nschloe/stressberry/issues/37))
28 | 
| 
| 
29 | [hex wrench case](https://www.amazon.ca/Aluminum-Model-Raspberry-Wrench-Enclosure/dp/B07W6FT1DD?th=1) (@patrickpoirier51, [#45](https://github.com/nschloe/stressberry/issues/45)) | [CooliPi](https://www.coolipi.com/) (@CooliPi, [#47](https://github.com/nschloe/stressberry/issues/47), [#48](https://github.com/nschloe/stressberry/issues/48)) | [low-profile ice tower case](https://www.aliexpress.com/i/4000288119233.html) (@leonhess, [#54](https://github.com/nschloe/stressberry/issues/54))
30 | 
| 
|
31 | [Flirc case](https://flirc.tv/more/raspberry-pi-4-case) (@RichardKav, [#73](https://github.com/nschloe/stressberry/issues/73)) | [Armor Case](https://www.amazon.com/Geekworm-Raspberry-Computer-Aluminum-Compatible/dp/B07VD568FB) |
32 |
33 |
34 | ### Raspberry Pi 3B+
35 | 
36 |
37 | #### FLIRC case
38 |
39 | 
40 |
41 | The famous [FLIRC case](https://flirc.tv/more/raspberry-pi-case).
42 | Thanks to @RichardKav for the measurements!
43 |
44 | ### Raspberry Pi 3B
45 | 
46 |
47 | 
| 
| 
48 | :-------------------:|:------------------:|:----------:|
49 | No fans, heat sinks, or case. | Your average acrylic case from eBay. | [FastTech case](https://www.fasttech.com/p/5299000), full-body aluminum alloy with heat pads for CPU and RAM.
50 |
51 | ### How to
52 |
53 | To run stressberry on your computer, simply install it with
54 | ```bash
55 | [sudo] apt install stress
56 | python3 -m pip install stressberry
57 | ```
58 | Users of [Arch Linux ARM](https://archlinuxarm.org/) can install from the official repos
59 | ```
60 | [sudo] pacman -S stressberry
61 | ```
62 | and run it with
63 | ```
64 | stressberry-run out.dat
65 | stressberry-plot out.dat -o out.png
66 | ```
67 | (Use `MPLBACKEND=Agg stressberry-plot out.dat -o out.png` if you're running the script
68 | on the Raspberry Pi itself.)
69 |
70 | If it your computer can't find the stressberry tools after installation,
71 | you might have to add the directory `$HOME/.local/bin` to your path:
72 | ```
73 | export PATH=$PATH:/home/pi/.local/bin
74 | ```
75 | (You can also put this line in your `.bashrc`.)
76 |
77 | The run lets the CPU idle for a bit, then stresses it with maximum load for 5 minutes,
78 | and lets it cool down afterwards. The entire process takes 10 minutes. The resulting
79 | data is displayed to a screen or, if specified, written to a PNG file.
80 |
81 | If you'd like to submit your own data for display here, feel free to [open an
82 | issue](https://github.com/nschloe/stressberry/issues) and include the data file, a
83 | photograph of your setup, and perhaps some further information.
84 |
85 |
86 | ### Testing
87 |
88 | To run the tests, just check out this repository and type
89 | ```
90 | pytest
91 | ```
92 |
93 | ### License
94 | This software is published under the [GPLv3 license](https://www.gnu.org/licenses/gpl-3.0.en.html).
95 |
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
1 | [build-system]
2 | requires = ["setuptools>=42", "wheel"]
3 | build-backend = "setuptools.build_meta"
4 |
--------------------------------------------------------------------------------
/setup.cfg:
--------------------------------------------------------------------------------
1 | [metadata]
2 | name = stressberry
3 | version = 0.3.3
4 | author = Nico Schlömer
5 | author_email = nico.schloemer@gmail.com
6 | description = Stress tests for the Raspberry Pi
7 | url = https://github.com/nschloe/stressberry
8 | project_urls =
9 | Code=https://github.com/nschloe/stressberry
10 | Issues=https://github.com/nschloe/stressberry/issues
11 | Funding=https://github.com/sponsors/nschloe
12 | long_description = file: README.md
13 | long_description_content_type = text/markdown
14 | license = GPL-3.0-or-later
15 | classifiers =
16 | Development Status :: 4 - Beta
17 | License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
18 | Operating System :: OS Independent
19 | Programming Language :: Python
20 | Programming Language :: Python :: 3
21 | Programming Language :: Python :: 3.7
22 | Programming Language :: Python :: 3.8
23 | Programming Language :: Python :: 3.9
24 | Topic :: Utilities
25 |
26 | [options]
27 | packages = find:
28 | install_requires =
29 | importlib_metadata;python_version<"3.8"
30 | matplotlib
31 | matplotx
32 | pyyaml
33 | python_requires = >=3.7
34 |
35 | [options.entry_points]
36 | console_scripts =
37 | stressberry-run = stressberry.cli:run
38 | stressberry-plot = stressberry.cli:plot
39 |
--------------------------------------------------------------------------------
/stressberry/__about__.py:
--------------------------------------------------------------------------------
1 | try:
2 | # Python 3.8
3 | from importlib import metadata
4 | except ImportError:
5 | import importlib_metadata as metadata
6 |
7 | try:
8 | __version__ = metadata.version("stressberry")
9 | except Exception:
10 | __version__ = "unknown"
11 |
--------------------------------------------------------------------------------
/stressberry/__init__.py:
--------------------------------------------------------------------------------
1 | from . import cli
2 | from .__about__ import __version__
3 | from .main import stress_cpu
4 |
5 | __all__ = ["__version__", "cli", "stress_cpu"]
6 |
--------------------------------------------------------------------------------
/stressberry/cli/__init__.py:
--------------------------------------------------------------------------------
1 | from .plot import plot
2 | from .run import run
3 |
4 | __all__ = ["plot", "run"]
5 |
--------------------------------------------------------------------------------
/stressberry/cli/helpers.py:
--------------------------------------------------------------------------------
1 | import sys
2 |
3 | from ..__about__ import __version__
4 |
5 |
6 | def _get_version_text():
7 | return "\n".join(
8 | [
9 | "stressberry {} [Python {}.{}.{}]".format(
10 | __version__,
11 | sys.version_info.major,
12 | sys.version_info.minor,
13 | sys.version_info.micro,
14 | ),
15 | "Copyright (c) 2017-2020 Nico Schlömer ",
16 | ]
17 | )
18 |
--------------------------------------------------------------------------------
/stressberry/cli/plot.py:
--------------------------------------------------------------------------------
1 | import argparse
2 |
3 | import yaml
4 |
5 | from .helpers import _get_version_text
6 |
7 |
8 | def plot(argv=None):
9 | import matplotx
10 | import matplotlib.pyplot as plt
11 |
12 | plt.style.use(matplotx.styles.dufte)
13 |
14 | parser = _get_parser_plot()
15 | args = parser.parse_args(argv)
16 |
17 | data = [yaml.load(f, Loader=yaml.SafeLoader) for f in args.infiles]
18 |
19 | # actually plot it
20 | fig = plt.figure()
21 | ax1 = fig.add_subplot(1, 1, 1)
22 | for d in data:
23 | temperature_data = d["temperature"]
24 | if args.delta_t:
25 | temperature_data = []
26 | zip_object = zip(d["temperature"], d["ambient"])
27 | for d["temperature"], d["ambient"] in zip_object:
28 | temperature_data.append(d["temperature"] - d["ambient"])
29 |
30 | plt.plot(d["time"], temperature_data, label=d["name"])
31 |
32 | matplotx.line_labels()
33 |
34 | if args.delta_t:
35 | plot_yaxis_label = "Δ temperature [°C over ambient]"
36 | else:
37 | plot_yaxis_label = "temperature [°C]"
38 | plt.xlabel("time [s]")
39 | plt.ylabel(plot_yaxis_label)
40 |
41 | if args.temp_lims:
42 | ax1.set_ylim(*args.temp_lims)
43 |
44 | # Only plot frequencies when using a single input file
45 | if len(data) == 1 and args.frequency:
46 | ax2 = plt.twinx()
47 | ax2.set_ylabel("core frequency (MHz)")
48 | if args.freq_lims:
49 | ax2.set_ylim(*args.freq_lims)
50 | try:
51 | for d in data:
52 | ax2.plot(
53 | d["time"],
54 | d["cpu frequency"],
55 | label=d["name"],
56 | color="C1",
57 | alpha=0.9,
58 | )
59 | ax1.set_zorder(ax2.get_zorder() + 1) # put ax1 plot in front of ax2
60 | ax1.patch.set_visible(False) # hide the 'canvas'
61 | except KeyError():
62 | print("Source data does not contain CPU frequency data.")
63 |
64 | if args.outfile is not None:
65 | plt.savefig(
66 | args.outfile,
67 | transparent=args.transparent,
68 | bbox_inches="tight",
69 | dpi=args.dpi,
70 | )
71 | else:
72 | plt.show()
73 | return
74 |
75 |
76 | def _get_parser_plot():
77 | parser = argparse.ArgumentParser(description="Plot stress test data.")
78 | parser.add_argument(
79 | "--version", "-v", action="version", version=_get_version_text()
80 | )
81 | parser.add_argument(
82 | "infiles",
83 | nargs="+",
84 | type=argparse.FileType("r"),
85 | help="input YAML file(s) (default: stdin)",
86 | )
87 | parser.add_argument(
88 | "-o",
89 | "--outfile",
90 | help=(
91 | "if specified, the plot is written to this file "
92 | "(default: show on screen)"
93 | ),
94 | )
95 | parser.add_argument(
96 | "-t",
97 | "--temp-lims",
98 | type=float,
99 | nargs=2,
100 | default=None,
101 | help="limits for the temperature (default: data limits)",
102 | )
103 | parser.add_argument(
104 | "-d",
105 | "--dpi",
106 | type=int,
107 | default=None,
108 | help="image resolution in dots per inch when written to file",
109 | )
110 | parser.add_argument(
111 | "-f",
112 | "--frequency",
113 | help="plot CPU core frequency (single input files only)",
114 | action="store_true",
115 | )
116 | parser.add_argument(
117 | "-l",
118 | "--freq-lims",
119 | type=float,
120 | nargs=2,
121 | default=None,
122 | help="limits for the frequency scale (default: data limits)",
123 | )
124 | parser.add_argument(
125 | "--not-transparent",
126 | dest="transparent",
127 | help="do not make images transparent",
128 | action="store_false",
129 | default=True,
130 | )
131 | parser.add_argument(
132 | "--delta-t",
133 | action="store_true",
134 | default=False,
135 | help="Use Delta-T (core - ambient) temperature instead of CPU core temperature",
136 | )
137 | return parser
138 |
--------------------------------------------------------------------------------
/stressberry/cli/run.py:
--------------------------------------------------------------------------------
1 | import argparse
2 | import datetime
3 | import threading
4 | import time
5 |
6 | import yaml
7 |
8 | from ..__about__ import __version__
9 | from ..main import (
10 | cooldown,
11 | measure_ambient_temperature,
12 | measure_core_frequency,
13 | measure_temp,
14 | test,
15 | )
16 | from .helpers import _get_version_text
17 |
18 |
19 | def _get_parser_run():
20 | parser = argparse.ArgumentParser(
21 | description="Run stress test for the Raspberry Pi."
22 | )
23 | parser.add_argument(
24 | "--version", "-v", action="version", version=_get_version_text()
25 | )
26 | parser.add_argument(
27 | "-n",
28 | "--name",
29 | type=str,
30 | default="stressberry data",
31 | help="name the data set (default: 'stressberry data')",
32 | )
33 | parser.add_argument(
34 | "-t",
35 | "--temperature-file",
36 | type=str,
37 | default=None,
38 | help="temperature file e.g /sys/class/thermal/thermal_zone0/temp (default: vcgencmd)",
39 | )
40 | parser.add_argument(
41 | "-d",
42 | "--duration",
43 | type=int,
44 | default=300,
45 | help="stress test duration in seconds (default: 300)",
46 | )
47 | parser.add_argument(
48 | "-i",
49 | "--idle",
50 | type=int,
51 | default=150,
52 | help="idle time in seconds at start and end of stress test (default: 150)",
53 | )
54 | parser.add_argument(
55 | "--cooldown",
56 | type=int,
57 | default=60,
58 | help="poll interval seconds to check for stable temperature (default: 60)",
59 | )
60 | parser.add_argument(
61 | "-c",
62 | "--cores",
63 | type=int,
64 | default=None,
65 | help="number of CPU cores to stress (default: all)",
66 | )
67 | parser.add_argument(
68 | "-f",
69 | "--frequency-file",
70 | type=str,
71 | default=None,
72 | help="CPU core frequency file e.g. /sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq (default: vcgencmd)",
73 | )
74 | parser.add_argument(
75 | "-a",
76 | "--ambient",
77 | type=str,
78 | nargs=2,
79 | default=None,
80 | help="measure ambient temperature. Sensor Type [11|22|2302] e.g. 2302 26",
81 | )
82 | parser.add_argument("outfile", type=argparse.FileType("w"), help="output data file")
83 | return parser
84 |
85 |
86 | def run(argv=None):
87 | parser = _get_parser_run()
88 | args = parser.parse_args(argv)
89 |
90 | # Cool down first
91 | print("Awaiting stable baseline temperature...")
92 | cooldown(interval=args.cooldown, filename=args.temperature_file)
93 |
94 | # Start the stress test in another thread
95 | t = threading.Thread(
96 | target=lambda: test(args.duration, args.idle, args.cores), args=()
97 | )
98 | t.start()
99 |
100 | times = []
101 | temps = []
102 | freqs = []
103 | ambient = []
104 | while t.is_alive():
105 | times.append(time.time())
106 | temps.append(measure_temp(args.temperature_file))
107 | freqs.append(measure_core_frequency(args.frequency_file))
108 | if args.ambient:
109 | ambient_temperature = measure_ambient_temperature(
110 | sensor_type=args.ambient[0], pin=args.ambient[1]
111 | )
112 | if ambient_temperature is None:
113 | # Reading the sensor can return None if it times out.
114 | # If never had a good result, probably configuration error
115 | # Else use last known value if available or worst case set to zero
116 | if not ambient:
117 | print(
118 | f"Could not read ambient temperature sensor {args.ambient[0]} "
119 | f"on pin {args.ambient[1]}"
120 | )
121 | else:
122 | print(
123 | "WARN - Could not read ambient temperature, "
124 | "using last good value"
125 | )
126 | ambient_temperature = next(
127 | (temp for temp in reversed(ambient) if temp is not None), 0
128 | )
129 | ambient.append(ambient_temperature)
130 | delta_t = temps[-1] - ambient[-1]
131 | print(
132 | "Temperature (current | ambient | ΔT): "
133 | f"{temps[-1]:4.1f}°C | {ambient[-1]:4.1f}°C | {delta_t:4.1f}°C "
134 | f"- Frequency: {freqs[-1]:4.0f}MHz"
135 | )
136 | else:
137 | print(
138 | f"Current temperature: {temps[-1]:4.1f}°C "
139 | f"- Frequency: {freqs[-1]:4.0f}MHz"
140 | )
141 | # Choose the sample interval such that we have a respectable number of
142 | # data points
143 | t.join(2.0)
144 |
145 | # normalize times
146 | time0 = times[0]
147 | times = [tm - time0 for tm in times]
148 |
149 | args.outfile.write(
150 | f"# This file was created by stressberry v{__version__} "
151 | f"on {datetime.datetime.now()}\n"
152 | )
153 | yaml.dump(
154 | {
155 | "name": args.name,
156 | "time": times,
157 | "temperature": temps,
158 | "cpu frequency": freqs,
159 | "ambient": ambient,
160 | },
161 | args.outfile,
162 | )
163 |
--------------------------------------------------------------------------------
/stressberry/main.py:
--------------------------------------------------------------------------------
1 | import subprocess
2 | import time as tme
3 | from os import cpu_count
4 |
5 |
6 | def stress_cpu(num_cpus, time):
7 | subprocess.check_call(["stress", "--cpu", str(num_cpus), "--timeout", f"{time}s"])
8 | return
9 |
10 |
11 | def cooldown(interval=60, filename=None):
12 | """Lets the CPU cool down until the temperature does not change anymore."""
13 | prev_tmp = measure_temp(filename=filename)
14 | while True:
15 | tme.sleep(interval)
16 | tmp = measure_temp(filename=filename)
17 | print(
18 | f"Current temperature: {tmp:4.1f}°C - "
19 | f"Previous temperature: {prev_tmp:4.1f}°C"
20 | )
21 | if abs(tmp - prev_tmp) < 0.2:
22 | break
23 | prev_tmp = tmp
24 | return tmp
25 |
26 |
27 | def measure_temp(filename=None):
28 | """Returns the core temperature in Celsius."""
29 | if filename is not None:
30 | with open(filename) as f:
31 | temp = float(f.read()) / 1000
32 | else:
33 | # Using vcgencmd is specific to the raspberry pi
34 | out = subprocess.check_output(["vcgencmd", "measure_temp"]).decode("utf-8")
35 | temp = float(out.replace("temp=", "").replace("'C", ""))
36 | return temp
37 |
38 |
39 | def measure_core_frequency(filename=None):
40 | """Returns the CPU frequency in MHz"""
41 | if filename is not None:
42 | with open(filename) as f:
43 | frequency = float(f.read()) / 1000
44 | else:
45 | # Only vcgencmd measure_clock arm is accurate on Raspberry Pi.
46 | # Per: https://www.raspberrypi.org/forums/viewtopic.php?f=63&t=219358&start=25
47 | out = subprocess.check_output(["vcgencmd", "measure_clock arm"]).decode("utf-8")
48 | frequency = float(out.split("=")[1]) / 1000000
49 | return frequency
50 |
51 |
52 | def measure_ambient_temperature(sensor_type="2302", pin="23"):
53 | """Uses Adafruit temperature sensor to measure ambient temperature"""
54 | try:
55 | import Adafruit_DHT # Late import so that library is only needed if requested
56 | except ImportError as e:
57 | print("Install adafruit_dht python module: pip install Adafruit_DHT")
58 | raise e
59 |
60 | sensor_map = {
61 | "11": Adafruit_DHT.DHT11,
62 | "22": Adafruit_DHT.DHT22,
63 | "2302": Adafruit_DHT.AM2302,
64 | }
65 | try:
66 | sensor = sensor_map[sensor_type]
67 | except KeyError as e:
68 | print("Invalid ambient temperature sensor")
69 | raise e
70 | _, temperature = Adafruit_DHT.read_retry(sensor, pin)
71 | # Note that sometimes you won't get a reading and the results will be null (because
72 | # Linux can't guarantee the timing of calls to read the sensor). The read_retry
73 | # call will attempt to read the sensor 15 times with a 2 second delay. Care should
74 | # be taken when reading if on a time sensitive path Temperature is in °C but can
75 | # also be None
76 | return temperature
77 |
78 |
79 | def test(stress_duration, idle_duration, cores):
80 | """Run stress test for specified duration with specified idle times
81 | at the start and end of the test.
82 | """
83 | if cores is None:
84 | cores = cpu_count()
85 |
86 | print(f"Preparing to stress [{cores}] CPU Cores for [{stress_duration}] seconds")
87 | print(f"Idling for {idle_duration} seconds...")
88 | tme.sleep(idle_duration)
89 |
90 | stress_cpu(num_cpus=cores, time=stress_duration)
91 |
92 | print(f"Idling for {idle_duration} seconds...")
93 | tme.sleep(idle_duration)
94 |
--------------------------------------------------------------------------------
/test/test_cli.py:
--------------------------------------------------------------------------------
1 | import tempfile
2 |
3 | import stressberry
4 |
5 |
6 | def test_run():
7 | temperature_file = tempfile.NamedTemporaryFile().name
8 | with open(temperature_file, "w") as f:
9 | f.write("12345")
10 |
11 | frequency_file = tempfile.NamedTemporaryFile().name
12 | with open(frequency_file, "w") as f:
13 | f.write("1500000")
14 |
15 | # TODO: Need to mock call to subprocess.check_output
16 | # outfile1 = tempfile.NamedTemporaryFile().name
17 | # stressberry.cli.run(
18 | # [outfile1, "-d", "12", "-i", "2", "--cooldown", "1"]
19 | # )
20 |
21 | outfile = tempfile.NamedTemporaryFile().name
22 | stressberry.cli.run(
23 | [
24 | outfile,
25 | "-t",
26 | temperature_file,
27 | "-f",
28 | frequency_file,
29 | "-d",
30 | "12",
31 | "-i",
32 | "2",
33 | "--cooldown",
34 | "1",
35 | ]
36 | )
37 |
38 | stressberry.cli.plot(
39 | [outfile, "-f", "--temp-lims", "20", "90", "--freq-lims", "500", "2000"]
40 | )
41 | plotoutfile = tempfile.NamedTemporaryFile().name
42 | stressberry.cli.plot(
43 | [
44 | outfile,
45 | "-f",
46 | "--temp-lims",
47 | "20",
48 | "90",
49 | "--freq-lims",
50 | "500",
51 | "2000",
52 | "-o",
53 | plotoutfile,
54 | ]
55 | )
56 | return
57 |
--------------------------------------------------------------------------------
/test/test_stressberry.py:
--------------------------------------------------------------------------------
1 | import stressberry
2 |
3 |
4 | def test_stressberry():
5 | stressberry.stress_cpu(1, 5)
6 | return
7 |
--------------------------------------------------------------------------------
/tox.ini:
--------------------------------------------------------------------------------
1 | [tox]
2 | envlist = py3
3 | isolated_build = True
4 |
5 | [testenv]
6 | deps =
7 | pytest
8 | pytest-cov
9 | extras = all
10 | commands =
11 | pytest --cov {envsitepackagesdir}/stressberry --cov-report xml --cov-report term
12 |
--------------------------------------------------------------------------------