harte-rs 0.17.0__tar.gz

harte_rs-0.17.0/.gitignore

@@ -0,0 +1,38 @@
+/target/
+/python-parity/target/
+/python/target/
+/venv/
+__pycache__/
+/examples/web/pkg/
+/examples/web/pkg-*/
+/examples/web/chord/pkg/
+/examples/web/*.js
+/examples/web/chord/*.js
+/examples/web/chords/*.js
+/examples/web/polyrhythm/*.js
+/examples/web/tuning/*.js
+/examples/web/harte/*.js
+/examples/web/roman/*.js
+/examples/web/scales/*.js
+/examples/web/serial/*.js
+/examples/web/listen/*.js
+/examples/web/score/*.js
+
+# What `maturin develop` builds into the wheel's own package directory.
+/python/pysrc/music21_rs/*.pyd
+/python/pysrc/music21_rs/*.so
+/python/pysrc/music21_rs/*.dylib
+/python/pysrc/music21_rs/*.pdb
+
+# OS/editor noise
+.DS_Store
+Thumbs.db
+.idea/
+.codex/
+.m21venv/
+.wheelvenv/
+CLAUDE.md
+AGENTS.md
+.serena
+/result
+/result-*

harte_rs-0.17.0/LICENSE-harte-library

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Andrea Poltronieri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

harte_rs-0.17.0/PKG-INFO

@@ -0,0 +1,105 @@
+Metadata-Version: 2.5
+Name: harte-rs
+Version: 0.17.0
+Summary: Harte chord notation read into music21-rs chords; a replacement for harte-library
+Project-URL: Repository, https://github.com/float3/music21-rs
+Author-email: hill <hill@hilll.dev>
+License-Expression: AGPL-3.0-only
+License-File: LICENSE-harte-library
+Keywords: chords,harte,music,music-theory,music21
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Multimedia :: Sound/Audio :: Analysis
+Requires-Python: >=3.9
+Requires-Dist: music21-rs==0.17.0
+Description-Content-Type: text/markdown
+
+# harte-rs
+
+[![CI](https://github.com/float3/music21-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/float3/music21-rs/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/harte-rs.svg)](https://pypi.org/project/harte-rs/)
+
+Harte chord notation, `C:maj7/3`, `Bb:(b3,5,b7,9)`, `F:sus4(*3,9)`, `N`,
+read into [music21-rs](https://pypi.org/project/music21-rs/) chords. it is
+a replacement for [harte-library](https://github.com/andreamust/harte-library):
+it is imported as `harte`, has the same modules and names, and builds the
+chord harte-library builds for every label in that library's coverage set.
+the label is read by the [harte](https://crates.io/crates/harte) Rust crate,
+and the chord is a music21-rs `Chord`, so neither music21 nor lark is
+needed.
+
+```bash
+pip install harte-rs
+```
+
+harte-rs and harte-library both install the `harte` package, so uninstall
+harte-library first.
+
+```python
+from harte.harte import Harte
+from harte.interval import HarteInterval
+from harte.utils import convert_interval
+
+chord = Harte("Bb:min7/b3")
+chord.pitches         # (<music21.pitch.Pitch B-4>, <music21.pitch.Pitch D-3>, <music21.pitch.Pitch F5>, <music21.pitch.Pitch A-5>)
+chord.bass()          # <music21.pitch.Pitch D-3>
+chord.commonName      # 'minor seventh chord'
+chord.get_root()      # 'Bb'
+chord.get_shorthand() # 'min7'
+chord.get_bass()      # 'b3'
+
+Harte("C:(b3,5)").prettify()            # 'C:min'
+Harte("G:7").get_midi_pitches()         # [67, 71, 74, 77]
+Harte("G:7").multi_hot_encoding()       # [0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1]
+Harte("F:sus4(*5,9)").unwrap_shorthand() # ['1', '4', '9']
+
+HarteInterval("b6").name                # 'm6'
+convert_interval("#11")                 # 'A4'
+```
+
+`Harte` is a music21-rs `Chord` and `HarteInterval` a music21-rs
+`Interval`, so every member those have works on them. with music21
+installed and `music21_rs.install_into_music21()` called before `harte` is
+imported, a `Harte` is a music21 `Chord` too, and goes in music21's streams
+as harte-library's does.
+
+## differences from harte-library
+
+- a label that is not Harte notation raises music21-rs's `ChordException`,
+  where harte-library raises lark's parse errors. `harte.parse_harte`, the
+  lark grammar, is not included.
+- `str()` and `repr()` give the label in its canonical spelling,
+  `Harte(C:maj7(9)/3)`. harte-library's raise `TypeError` for every label
+  but `N`.
+- two labels are equal when they sound the same chord: `C:maj` equals
+  `C:(3,5)`. harte-library's compares the degrees as written.
+- `bass_is_root()` answers whether the bass is the root. harte-library's
+  compares the root's name with the bass degree, and answers `False` for
+  every chord.
+- `N` and `X` have no shorthand: `get_shorthand()` is `None` and
+  `contains_shorthand()` is `False`.
+
+## development
+
+harte-rs lives in the [music21-rs](https://github.com/float3/music21-rs)
+repository, in `harte/python`, and is released with the music21-rs wheel at
+the same version. it builds on that wheel's `_HarteLabel`, so it needs the
+wheel built from the same checkout:
+
+```bash
+maturin build --release --manifest-path python/Cargo.toml --out target/wheels
+pip install target/wheels/music21_rs-*.whl ./harte/python pytest
+python -m pytest harte/python/tests
+```
+
+the tests check every label in harte-library's coverage set against
+`harte/data/harte_expectations.toml`, which records what harte-library makes
+of each.
+
+## credits
+
+harte-rs is released under the
+[AGPL-3.0](https://github.com/float3/music21-rs/blob/master/LICENSE). it is
+a port of [harte-library](https://github.com/andreamust/harte-library) by
+Andrea Poltronieri, licensed MIT; its licence is included as
+`LICENSE-harte-library`.

harte_rs-0.17.0/README.md

@@ -0,0 +1,89 @@
+# harte-rs
+
+[![CI](https://github.com/float3/music21-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/float3/music21-rs/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/harte-rs.svg)](https://pypi.org/project/harte-rs/)
+
+Harte chord notation, `C:maj7/3`, `Bb:(b3,5,b7,9)`, `F:sus4(*3,9)`, `N`,
+read into [music21-rs](https://pypi.org/project/music21-rs/) chords. it is
+a replacement for [harte-library](https://github.com/andreamust/harte-library):
+it is imported as `harte`, has the same modules and names, and builds the
+chord harte-library builds for every label in that library's coverage set.
+the label is read by the [harte](https://crates.io/crates/harte) Rust crate,
+and the chord is a music21-rs `Chord`, so neither music21 nor lark is
+needed.
+
+```bash
+pip install harte-rs
+```
+
+harte-rs and harte-library both install the `harte` package, so uninstall
+harte-library first.
+
+```python
+from harte.harte import Harte
+from harte.interval import HarteInterval
+from harte.utils import convert_interval
+
+chord = Harte("Bb:min7/b3")
+chord.pitches         # (<music21.pitch.Pitch B-4>, <music21.pitch.Pitch D-3>, <music21.pitch.Pitch F5>, <music21.pitch.Pitch A-5>)
+chord.bass()          # <music21.pitch.Pitch D-3>
+chord.commonName      # 'minor seventh chord'
+chord.get_root()      # 'Bb'
+chord.get_shorthand() # 'min7'
+chord.get_bass()      # 'b3'
+
+Harte("C:(b3,5)").prettify()            # 'C:min'
+Harte("G:7").get_midi_pitches()         # [67, 71, 74, 77]
+Harte("G:7").multi_hot_encoding()       # [0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1]
+Harte("F:sus4(*5,9)").unwrap_shorthand() # ['1', '4', '9']
+
+HarteInterval("b6").name                # 'm6'
+convert_interval("#11")                 # 'A4'
+```
+
+`Harte` is a music21-rs `Chord` and `HarteInterval` a music21-rs
+`Interval`, so every member those have works on them. with music21
+installed and `music21_rs.install_into_music21()` called before `harte` is
+imported, a `Harte` is a music21 `Chord` too, and goes in music21's streams
+as harte-library's does.
+
+## differences from harte-library
+
+- a label that is not Harte notation raises music21-rs's `ChordException`,
+  where harte-library raises lark's parse errors. `harte.parse_harte`, the
+  lark grammar, is not included.
+- `str()` and `repr()` give the label in its canonical spelling,
+  `Harte(C:maj7(9)/3)`. harte-library's raise `TypeError` for every label
+  but `N`.
+- two labels are equal when they sound the same chord: `C:maj` equals
+  `C:(3,5)`. harte-library's compares the degrees as written.
+- `bass_is_root()` answers whether the bass is the root. harte-library's
+  compares the root's name with the bass degree, and answers `False` for
+  every chord.
+- `N` and `X` have no shorthand: `get_shorthand()` is `None` and
+  `contains_shorthand()` is `False`.
+
+## development
+
+harte-rs lives in the [music21-rs](https://github.com/float3/music21-rs)
+repository, in `harte/python`, and is released with the music21-rs wheel at
+the same version. it builds on that wheel's `_HarteLabel`, so it needs the
+wheel built from the same checkout:
+
+```bash
+maturin build --release --manifest-path python/Cargo.toml --out target/wheels
+pip install target/wheels/music21_rs-*.whl ./harte/python pytest
+python -m pytest harte/python/tests
+```
+
+the tests check every label in harte-library's coverage set against
+`harte/data/harte_expectations.toml`, which records what harte-library makes
+of each.
+
+## credits
+
+harte-rs is released under the
+[AGPL-3.0](https://github.com/float3/music21-rs/blob/master/LICENSE). it is
+a port of [harte-library](https://github.com/andreamust/harte-library) by
+Andrea Poltronieri, licensed MIT; its licence is included as
+`LICENSE-harte-library`.

harte_rs-0.17.0/harte/__init__.py

@@ -0,0 +1,14 @@
+"""Harte chord notation, read into music21-rs chords.
+
+A replacement for harte-library: the same modules and names, with the label
+read by the `harte` Rust crate and the chord a music21-rs `Chord`.
+
+>>> from harte.harte import Harte
+>>> Harte("Bb:min7/b3").pitches
+(<music21.pitch.Pitch B-4>, <music21.pitch.Pitch D-3>, <music21.pitch.Pitch F5>, <music21.pitch.Pitch A-5>)
+"""
+
+from harte.harte import Harte
+from harte.interval import HarteInterval
+
+__all__ = ["Harte", "HarteInterval"]

harte_rs-0.17.0/harte/harte.py

@@ -0,0 +1,102 @@
+"""harte-library's `Harte`: a chord read from a Harte label."""
+
+import sys
+from typing import List, Optional
+
+import music21_rs
+from music21_rs.music21_rs import _HarteLabel
+
+
+def _chord_class():
+    """music21's `Chord` where `music21_rs.install_into_music21()` has put
+    music21-rs's in its place, so a `Harte` goes in music21's streams; the
+    wheel's own `Chord` otherwise."""
+    music21_chord = sys.modules.get("music21.chord")
+    installed = getattr(music21_chord, "Chord", None)
+    if isinstance(installed, type) and issubclass(installed, music21_rs.Chord):
+        return installed
+    return music21_rs.Chord
+
+
+class Harte(_chord_class()):
+    """A music21-rs `Chord` read from a Harte label, such as `C:maj7/3`.
+
+    The pitches stand in degree order above the root in octave 4, the bass an
+    octave lower where it is not the root. `N` and `X` are an empty chord.
+    A label that is not Harte notation raises `ChordException`.
+    """
+
+    def __init__(self, chord: str, **keywords):
+        label = _HarteLabel(chord)
+        super().__init__(**keywords)
+        label.fill(self)
+        self.chord = chord
+        self._label = label
+
+    def __deepcopy__(self, *args, **kwargs):
+        return Harte(self.chord)
+
+    def __reduce__(self):
+        return (Harte, (self.chord,))
+
+    def get_degrees(self) -> Optional[List[str]]:
+        """The degrees written in parentheses, or `None` when there are none."""
+        return self._label.degrees
+
+    def get_midi_pitches(self) -> List[int]:
+        """The MIDI numbers of the pitches, lowest first."""
+        return sorted(pitch.midi for pitch in self.pitches)
+
+    def multi_hot_encoding(self, transpose: bool = False) -> List[int]:
+        """Which of the twelve pitch classes the chord sounds, one flag each,
+        counted from C, or from the root with `transpose`."""
+        pitch_classes = [pitch.pitchClass for pitch in self.pitches]
+        if transpose:
+            root = self.root().pitchClass
+            pitch_classes = [(pitch_class - root) % 12 for pitch_class in pitch_classes]
+        return [1 if i in pitch_classes else 0 for i in range(12)]
+
+    def get_root(self) -> Optional[str]:
+        """The root as written, `C#`, or `None` for no chord."""
+        return self._label.root
+
+    def get_bass(self) -> Optional[str]:
+        """The bass as a degree above the root, `1` when none was written."""
+        return self._label.bass
+
+    def bass_is_root(self) -> bool:
+        """Whether the bass is the root."""
+        return self._label.bass_is_root()
+
+    def contains_shorthand(self) -> bool:
+        """Whether the label carries a shorthand."""
+        return self._label.contains_shorthand()
+
+    def get_shorthand(self) -> Optional[str]:
+        """The shorthand, `maj7`, or `None` when there is none."""
+        return self._label.shorthand
+
+    def prettify(self) -> str:
+        """The label rewritten with the largest shorthand its degrees contain:
+        `C:(b3,5)` is `C:min`. A label no shorthand fits comes back as written."""
+        return self._label.prettify()
+
+    def unwrap_shorthand(self) -> Optional[List[str]]:
+        """Every degree the chord sounds where the label has a shorthand, the
+        written degrees where it has none, and `None` where it has neither."""
+        return self._label.unwrapped
+
+    def __eq__(self, other):
+        """Two labels are equal when they sound the same chord: `C:maj` equals
+        `C:(3,5)`."""
+        if isinstance(other, Harte):
+            return self._label == other._label
+        return False
+
+    __hash__ = None
+
+    def __repr__(self):
+        return f"Harte({self})"
+
+    def __str__(self):
+        return str(self._label)

harte_rs-0.17.0/harte/interval.py

@@ -0,0 +1,31 @@
+"""harte-library's `HarteInterval`: an interval read from a Harte degree."""
+
+from music21_rs import Interval, IntervalException
+
+from harte.utils import convert_interval
+
+
+class HarteInterval(Interval):
+    """A music21-rs `Interval` read from a Harte degree: `b6` is a minor
+    sixth. A degree that is not one raises `IntervalException`."""
+
+    def __init__(self, harte_interval: str, **keywords) -> None:
+        self._harte_interval = harte_interval
+        try:
+            self._converted_interval = convert_interval(harte_interval)
+        except ValueError as value_error:
+            raise IntervalException("Harte Interval cannot be converted") from value_error
+        super().__init__(self._converted_interval, **keywords)
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, HarteInterval):
+            return self._harte_interval == other._harte_interval
+        return self._harte_interval == other
+
+    __hash__ = None
+
+    def __repr__(self) -> str:
+        return f"HarteInterval({self._harte_interval})"
+
+    def __str__(self) -> str:
+        return self._harte_interval

harte_rs-0.17.0/harte/mappings.py

@@ -0,0 +1,35 @@
+"""harte-library's tables of Harte shorthands and the degrees they stand for."""
+
+from collections import OrderedDict
+
+from music21_rs.music21_rs import _HarteLabel
+
+# Each shorthand and the degrees it stands for, the root included.
+SHORTHAND_DEGREES = {
+    name: list(degrees) for name, degrees in _HarteLabel.SHORTHAND_DEGREES
+}
+
+# The degrees `Harte.prettify` folds into each shorthand, in the order tried.
+DEGREE_SHORTHAND_MAP = OrderedDict(
+    (tuple(degrees), name) for degrees, name in _HarteLabel.DEGREE_SHORTHANDS
+)
+
+# The common shorthands and their degrees above the root.
+SHORTHAND_DEGREE_MAP = {
+    "maj": ("3", "5"),
+    "min": ("b3", "5"),
+    "aug": ("3", "#5"),
+    "dim": ("b3", "b5"),
+    "maj7": ("3", "5", "7"),
+    "min7": ("b3", "5", "b7"),
+    "7": ("3", "5", "b7"),
+    "minmaj7": ("b3", "5", "7"),
+    "dim7": ("b3", "b5", "bb7"),
+    "hdim7": ("b3", "b5", "b7"),
+    "maj6": ("3", "5", "6"),
+    "min6": ("b3", "5", "6"),
+    "9": ("3", "5", "b7", "9"),
+    "maj9": ("3", "5", "7", "9"),
+    "min9": ("b3", "5", "b7", "9"),
+    "sus4": ("4", "5"),
+}

harte_rs-0.17.0/harte/utils.py

@@ -0,0 +1,29 @@
+"""harte-library's helpers for Harte degrees."""
+
+from typing import List
+
+from music21_rs.music21_rs import _HarteLabel
+
+from harte.mappings import SHORTHAND_DEGREES
+
+
+def convert_interval(harte_interval: str) -> str:
+    """The music21 interval a Harte degree stands for: `b3` is `m3`, `#11` is
+    `A4`. A degree that is not one raises `ValueError`."""
+    return _HarteLabel.convert_interval(harte_interval)
+
+
+def degree_to_sort_key(degree: str) -> float:
+    """Where a degree sorts among the others: by its number, a flat just
+    below it and a sharp just above."""
+    return _HarteLabel.degree_sort_key(degree)
+
+
+def unwrap_shorthand(harte_shorthand: str, harte_degrees: list) -> List[str]:
+    """The degrees of a shorthand together with `harte_degrees`, ordered by
+    their number. Deprecated in harte-library; `Harte.unwrap_shorthand` is
+    what to use."""
+    assert harte_shorthand in SHORTHAND_DEGREES, "The Harte shorthand is not valid. "
+    degrees = list(set(SHORTHAND_DEGREES[harte_shorthand] + harte_degrees))
+    degrees.sort(key=lambda x: [k for k in x if k.isdigit()][0])
+    return degrees

harte_rs-0.17.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+build-backend = "hatchling.build"
+requires = ["hatchling>=1.26"]
+
+[project]
+authors = [{ name = "hill", email = "hill@hilll.dev" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Topic :: Multimedia :: Sound/Audio :: Analysis",
+]
+# Released with the music21-rs wheel and at its version, since it builds on
+# that wheel's `_HarteLabel`: `harte_rs_requires_its_own_music21_rs` holds
+# both numbers to python/Cargo.toml's.
+dependencies = ["music21-rs==0.17.0"]
+description = "Harte chord notation read into music21-rs chords; a replacement for harte-library"
+keywords = ["music", "music-theory", "chords", "harte", "music21"]
+license = "AGPL-3.0-only"
+license-files = ["LICENSE-harte-library"]
+name = "harte-rs"
+readme = "README.md"
+requires-python = ">=3.9"
+version = "0.17.0"
+
+[project.urls]
+Repository = "https://github.com/float3/music21-rs"
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["harte"]

harte_rs-0.17.0/tests/test_harte.py

@@ -0,0 +1,245 @@
+"""harte-rs against harte-library.
+
+`harte/data/harte_expectations.toml` records what harte-library, on music21,
+makes of every label in its own coverage set; each is checked here. The other
+cases are harte-library's own tests.
+"""
+
+import copy
+import pathlib
+import pickle
+
+import pytest
+
+from harte.harte import Harte
+from harte.interval import HarteInterval
+from harte.mappings import DEGREE_SHORTHAND_MAP, SHORTHAND_DEGREES
+from harte.utils import convert_interval, degree_to_sort_key, unwrap_shorthand
+from music21_rs import Chord, ChordException, Interval, IntervalException
+
+EXPECTATIONS = pathlib.Path(__file__).resolve().parents[2] / "data" / "harte_expectations.toml"
+
+
+def _cases():
+    """The fixture's labels, where it can be read: it needs tomllib, Python
+    3.11+, and the repository, which the sdist does not carry."""
+    try:
+        import tomllib
+    except ImportError:
+        return []
+    if not EXPECTATIONS.is_file():
+        return []
+    return tomllib.loads(EXPECTATIONS.read_text(encoding="utf-8"))["chord"]
+
+
+CASES = _cases()
+
+
+def _sort_parenthesised(label):
+    """`C:maj7(#11,9)` with the degrees in its parentheses sorted, as the
+    fixture writes them."""
+    head, _, rest = label.partition("(")
+    inside, closed, tail = rest.partition(")")
+    if not closed:
+        return label
+    return f"{head}({','.join(sorted(inside.split(',')))}){tail}"
+
+
+def _in_degree_order(degrees, pitches):
+    """Degrees and their pitches in harte-library's degree order, its ties
+    broken by spelling: the library breaks them by set order, which is not
+    fixed from one run to the next."""
+    return sorted(zip(degrees, pitches), key=lambda pair: (degree_to_sort_key(pair[0]), pair[0]))
+
+
+@pytest.mark.skipif(not CASES, reason="the fixture needs tomllib and the repository")
+def test_the_fixture_covers_harte_librarys_coverage_set():
+    assert len(CASES) == 8064
+
+
+@pytest.mark.parametrize("case", CASES, ids=[case["label"] for case in CASES])
+def test_every_label_builds_the_chord_harte_library_builds(case):
+    if "error" in case:
+        with pytest.raises(ChordException):
+            Harte(case["label"])
+        return
+    chord = Harte(case["label"])
+    pitches = [pitch.nameWithOctave for pitch in chord.pitches]
+    sounding = chord._label.sounding_degrees
+    assert _in_degree_order(sounding, pitches) == _in_degree_order(
+        case["degrees"], case["pitches"]
+    )
+    if case.get("root") is None:
+        assert chord.get_root() is None
+        return
+    assert chord.root().nameWithOctave == case["root"]
+    assert chord.bass().nameWithOctave == case["bass"]
+    assert _sort_parenthesised(chord.prettify()) == case["pretty"]
+
+
+@pytest.mark.parametrize(
+    "label,intervals",
+    [
+        ("C", ["P5", "M3"]),
+        ("A", ["P5", "M3"]),
+        ("C:maj", ["P5", "M3"]),
+        ("C:min", ["P5", "m3"]),
+        ("C:dim", ["d5", "m3"]),
+        ("C:aug", ["A5", "M3"]),
+        ("N", []),
+    ],
+)
+def test_interval_extraction(label, intervals):
+    annotated = Harte(label).annotateIntervals(
+        inPlace=False, returnList=True, stripSpecifiers=False
+    )
+    assert set(intervals) == set(annotated)
+
+
+@pytest.mark.parametrize(
+    "label,pitches",
+    [
+        ("F:(b3, 5, b7, 11)", ["F", "A-", "C", "E-", "B-"]),
+        ("F:(b3, 11, b7, 5)", ["F", "A-", "C", "E-", "B-"]),
+        ("F:maj7(#11)", ["F", "A", "C", "E", "B"]),
+    ],
+)
+def test_ordering_of_degrees(label, pitches):
+    assert [pitch.name for pitch in Harte(label).pitches] == pitches
+
+
+@pytest.mark.parametrize(
+    "harte_interval,music21_interval",
+    [
+        (f"{accidental}{number}", f"{quality}{(number - 1) % 7 + 1}")
+        for number in range(1, 15)
+        for accidental, quality in zip(
+            ("b", "", "#"),
+            ("dPA" if (number - 1) % 7 + 1 in (1, 4, 5) else "mMA"),
+        )
+    ],
+)
+def test_harte_interval(harte_interval, music21_interval):
+    assert convert_interval(harte_interval) == music21_interval
+
+
+def test_the_parts_of_a_label():
+    chord = Harte("Bb:min7/b3")
+    assert isinstance(chord, Chord)
+    assert chord.chord == "Bb:min7/b3"
+    assert chord.get_root() == "Bb"
+    assert chord.get_shorthand() == "min7"
+    assert chord.contains_shorthand()
+    assert chord.get_bass() == "b3"
+    assert not chord.bass_is_root()
+    assert chord.get_degrees() is None
+    assert chord.unwrap_shorthand() == ["1", "b3", "5", "b7"]
+    assert chord.root().nameWithOctave == "B-4"
+    assert chord.bass().nameWithOctave == "D-3"
+    assert chord.commonName == "minor seventh chord"
+    assert str(chord) == "Bb:min7/b3"
+    assert repr(chord) == "Harte(Bb:min7/b3)"
+
+
+def test_midi_pitches_and_multi_hot_encoding():
+    chord = Harte("G:7")
+    assert chord.get_midi_pitches() == [67, 71, 74, 77]
+    assert chord.multi_hot_encoding() == [0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1]
+    assert chord.multi_hot_encoding(True) == [1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0]
+
+
+def test_degrees_and_unwrapping():
+    chord = Harte("F:sus4(*5,9)")
+    assert chord.get_degrees() == ["*5", "9"]
+    assert chord.unwrap_shorthand() == ["1", "4", "9"]
+    assert Harte("C:(b3,5)").unwrap_shorthand() == ["b3", "5"]
+    assert Harte("C").unwrap_shorthand() is None
+    assert Harte("C").bass_is_root()
+
+
+def test_prettify():
+    assert Harte("C:(b3,5)").prettify() == "C:min"
+    assert Harte("D:(b3,5,7,9)/b3").prettify() == "D:minmaj7(9)/b3"
+
+
+def test_no_chord():
+    for label in ("N", "X"):
+        chord = Harte(label)
+        assert chord.pitches == ()
+        assert chord.get_root() is None
+        assert chord.get_shorthand() is None
+        assert not chord.contains_shorthand()
+        assert str(chord) == "N"
+
+
+def test_equality_is_the_chord_sounded():
+    assert Harte("C:maj") == Harte("C:(3,5)")
+    assert Harte("C:maj") != Harte("C:min")
+    assert Harte("C:maj") != Chord("C4 E4 G4")
+
+
+def test_a_label_that_is_not_harte_notation():
+    with pytest.raises(ChordException):
+        Harte("C:foo")
+
+
+def test_keywords_reach_the_chord():
+    assert Harte("C", quarterLength=2).quarterLength == 2.0
+
+
+def test_copies_keep_the_label():
+    chord = Harte("Bb:min7/b3")
+    for copied in (copy.deepcopy(chord), pickle.loads(pickle.dumps(chord))):
+        assert type(copied) is Harte
+        assert str(copied) == "Bb:min7/b3"
+        assert copied.pitches == chord.pitches
+    transposed = chord.transpose("P5")
+    assert type(transposed) is Harte
+    assert transposed.get_root() == "Bb"
+    assert [pitch.nameWithOctave for pitch in transposed.pitches] == ["F5", "A-3", "C6", "E-6"]
+
+
+def test_harte_interval_class():
+    interval = HarteInterval("b6")
+    assert isinstance(interval, Interval)
+    assert interval.name == "m6"
+    assert interval.isConsonant()
+    assert str(interval) == "b6"
+    assert repr(interval) == "HarteInterval(b6)"
+    assert interval == "b6"
+    assert interval == HarteInterval("b6")
+    with pytest.raises(IntervalException):
+        HarteInterval("x")
+    with pytest.raises(ValueError):
+        convert_interval("x")
+
+
+def test_mappings():
+    assert len(SHORTHAND_DEGREES) == 48
+    assert SHORTHAND_DEGREES["hdim7"] == ["1", "b3", "b5", "b7"]
+    assert next(iter(DEGREE_SHORTHAND_MAP.items())) == (("3", "5", "b7", "9"), "9")
+    assert unwrap_shorthand("maj", ["9"]) == ["1", "3", "5", "9"]
+
+
+def test_a_harte_goes_in_music21s_streams_once_installed():
+    """With `install_into_music21()` called before `harte` is imported, a
+    `Harte` is music21's `Chord`, as harte-library's is."""
+    pytest.importorskip("music21.stream")
+    import subprocess
+    import sys
+
+    script = """
+import music21_rs
+music21_rs.install_into_music21()
+from music21 import base, chord, stream
+from harte.harte import Harte
+h = Harte('C:maj7')
+assert isinstance(h, chord.Chord) and isinstance(h, base.Music21Object)
+s = stream.Stream()
+s.append(h)
+s.append(Harte('G:7/3'))
+assert [p.nameWithOctave for p in s.pitches][-1] == 'F5'
+copied = h.transpose(2)
+assert copied.get_root() == 'C' and copied.pitches[0].nameWithOctave == 'D4'
+"""
+    subprocess.run([sys.executable, "-c", script], check=True)