Clean code

src/chordparser/music/chordcomponents/basequality.py

@@ -0,0 +1,85 @@
+from enum import Enum
+
+from chordparser.music.scaledegree import ScaleDegree
+
+
+class BaseQuality(Enum):
+    """Enum for the base quality of a `Chord`.
+
+    The enum members available are MAJOR, MINOR, AUGMENTED, DIMINISHED,
+    SUS2, SUS4, DOMINANT, HALFDIMINISHED and POWER.
+
+    """
+
+    MAJOR = (
+        str.upper,
+        True,
+        ("1", "3", "5"),
+        "",
+    )
+    MINOR = (
+        str.lower,
+        True,
+        ("1", "b3", "5"),
+        "m",
+    )
+    AUGMENTED = (
+        str.upper,
+        False,
+        ("1", "3", "#5"),
+        "aug",
+    )
+    DIMINISHED = (
+        str.lower,
+        False,
+        ("1", "b3", "b5"),
+        "dim",
+    )
+    SUS2 = (
+        str.upper,
+        False,
+        ("1", "2", "5"),
+        "sus2",
+    )
+    SUS4 = (
+        str.upper,
+        False,
+        ("1", "4", "5"),
+        "sus4",
+    )
+    DOMINANT = (
+        str.upper,
+        True,
+        ("1", "3", "5"),
+        "",
+    )
+    HALFDIMINISHED = (
+        str.lower,
+        False,
+        ("1", "b3", "b5"),
+        "\u00f8",
+    )
+    POWER = (
+        str.upper,
+        False,
+        ("1", "5"),
+        "5",
+    )
+
+    def roman_letter_case_converter(self, roman):
+        """Convert the Roman numeral letter case based on quality."""
+        return self.value[0](roman)
+
+    def is_derived_from_scale(self):
+        """Return if the quality is derived from a scale mode."""
+        return self.value[1]
+
+    @property
+    def scale_degrees(self):
+        return tuple(ScaleDegree(notation) for notation in self.value[2])
+
+    def __str__(self):
+        return self.value[3]
+
+    def __repr__(self):
+        return f"BaseQuality.{self.name}"

src/chordparser/music/chordcomponents/extensionquality.py

@@ -0,0 +1,38 @@
+from enum import Enum
+
+
+class ExtensionQuality(Enum):
+    """Enum for the quality of the extension of an extended `Chord`.
+
+    The enum members available are DIMINISHED, HALFDIMINISHED, MINOR,
+    DOMINANT and MAJOR.
+
+    """
+
+    DIMINISHED = (-2, "")
+    HALFDIMINISHED = (-1, "")
+    MINOR = (-1, "")
+    DOMINANT = (-1, "")
+    MAJOR = (0, "maj")
+
+    def seventh_shift(self):
+        """Return the step shift of the seventh.
+
+        Returns
+        -------
+        int
+            The step shift of the seventh.
+
+        Examples
+        --------
+        >>> ExtensionQuality.DIMINISHED.seventh_shift()
+        -2
+
+        """
+        return self.value[0]
+
+    def __str__(self):
+        return self.value[1]
+
+    def __repr__(self):
+        return f"ExtensionQuality.{self.name}"

src/chordparser/music/chordtypes/power.py

@@ -0,0 +1,17 @@
+from chordparser.music.chordcomponents.basequality import BaseQuality
+from chordparser.music.notationparser import NotationParserTemplate
+from chordparser.utils.regex_patterns import power_pattern
+
+
+power_enum_dict = {
+    "power": BaseQuality.POWER,
+}
+
+
+class PowerChordNotationParser(NotationParserTemplate):
+    """Parse power chords."""
+
+    _pattern = f"({power_pattern})"
+
+    def _split_into_groups(self, regex):
+        return "power"

src/chordparser/music/chordtypes/suspended.py

@@ -0,0 +1,19 @@
+from chordparser.music.chordcomponents.basequality import BaseQuality
+from chordparser.music.notationparser import NotationParserTemplate
+from chordparser.utils.regex_patterns import sus2_pattern, sus4_pattern
+
+
+sus_enum_dict = {
+    "sus2": BaseQuality.SUS2,
+    "sus4": BaseQuality.SUS4,
+}
+
+
+class SusNotationParser(NotationParserTemplate):
+    """Parse suspended chords."""
+
+    # sus2 must come first since sus4 detects for "sus"
+    _pattern = f"({sus2_pattern})|({sus4_pattern})"
+
+    def _split_into_groups(self, regex):
+        return "sus2" if regex.group(1) else "sus4"

src/chordparser/music/chordtypes/triad.py

@@ -0,0 +1,42 @@
+from chordparser.music.chordcomponents.basequality import BaseQuality
+from chordparser.music.chordtypes.suspended import (SusNotationParser,
+                                                    sus_enum_dict)
+from chordparser.music.notationparser import NotationParserTemplate
+from chordparser.utils.regex_patterns import (dim_triad_pattern,
+                                              aug_triad_pattern,
+                                              minor_pattern, major_pattern)
+
+
+triad_enum_dict = {
+    "major": BaseQuality.MAJOR,
+    "minor": BaseQuality.MINOR,
+    "diminished": BaseQuality.DIMINISHED,
+    "augmented": BaseQuality.AUGMENTED,
+    **sus_enum_dict,
+}
+
+
+class TriadNotationParser(NotationParserTemplate):
+    """Parse triads."""
+
+    _SNP = SusNotationParser()
+
+    _pattern = (
+        f"({major_pattern})|({minor_pattern})|"
+        f"({dim_triad_pattern})|({aug_triad_pattern})|"
+        f"({_SNP.pattern})"
+    )
+
+    def _split_into_groups(self, regex):
+        triad_dict = {
+            0: "major",
+            1: "minor",
+            2: "diminished",
+            3: "augmented",
+            4: not regex.group(5) or self._SNP.parse_notation(regex.group(5)),
+        }
+        index = next(
+            idx for (idx, triad) in enumerate(regex.groups())
+            if triad is not None
+        )
+        return triad_dict[index]

src/chordparser/music/hassymbol.py

@@ -0,0 +1,137 @@
+from chordparser.music.notecomponents.symbol import Symbol
+
+
+class HasSymbol:
+    """Abstract class that contains a `Symbol`."""
+
+    _symbol: Symbol  # To be defined in concrete class
+
+    @property
+    def symbol(self):
+        return self._symbol
+
+    def raise_by(self, steps=1):
+        """Raise the pitch by changing only its `Symbol`.
+
+        The number of steps must be positive. If you wish to change
+        the pitch without knowing the number of steps, use shift_by()
+        instead.
+
+        Parameters
+        ----------
+        steps: int, Optional
+            The number of steps to raise by. Default 1 when optional.
+
+        Raises
+        ------
+        ValueError
+            If the number of steps is not positive.
+        IndexError
+            If the new Symbol is not within the range of DOUBLEFLAT and
+            DOUBLESHARP.
+
+        Examples
+        --------
+        The examples are given using `Notes`. They will apply similarly
+        to other classes with `Symbols`.
+
+        >>> note = Note("Cb")
+        >>> note.raise_by()
+        >>> note
+        C Note
+        >>> note.raise_by(2)
+        >>> note
+        C\U0001D12A Note
+
+        """
+        if steps <= 0:
+            raise ValueError(
+                f"Expected positive steps, {steps} given. Use lower_by() or "
+                "shift_by() instead"
+            )
+        self.shift_by(steps)
+
+    def lower_by(self, steps=1):
+        """Lower the pitch by changing only its `Symbol`.
+
+        The number of steps must be positive. If you wish to change
+        the pitch without knowing the number of steps, use shift_by()
+        instead.
+
+        Parameters
+        ----------
+        steps: int, Optional
+            The number of steps to lower by. Default 1 when optional.
+
+        Raises
+        ------
+        ValueError
+            If the number of steps is not positive.
+        IndexError
+            If the new Symbol is not within the range of DOUBLEFLAT and
+            DOUBLESHARP.
+
+        Examples
+        --------
+        The examples are given using `Notes`. They will apply similarly
+        to other classes with `Symbols`.
+
+        >>> note = Note("C#")
+        >>> note.lower_by()
+        >>> note
+        C Note
+        >>> note.lower_by(2)
+        >>> note
+        C\U0001D12B Note
+
+        """
+        if steps <= 0:
+            raise ValueError(
+                f"Expected positive steps, {steps} given. Use raise_by() or "
+                "shift_by() instead"
+            )
+        self.shift_by(-steps)
+
+    def shift_by(self, steps):
+        """Shift the pitch by changing only its `Symbol`.
+
+        A positive number of steps will raise the pitch, while a
+        negative number of steps will lower the pitch.
+
+        Parameters
+        ----------
+        steps: int
+            The number of steps to shift by.
+
+        Raises
+        ------
+        IndexError
+            If the new Symbol is not within the range of DOUBLEFLAT and
+            DOUBLESHARP.
+
+        Examples
+        --------
+        The examples are given using `Notes`. They will apply similarly
+        to other classes with `Symbols`.
+
+        >>> note = Note("C#")
+        >>> note.shift_by(-1)
+        >>> note
+        C Note
+        >>> note.shift_by(1)
+        >>> note
+        C\u266f Note
+
+        """
+        old_pitch = self._symbol.as_steps()
+        new_pitch = old_pitch + steps
+        try:
+            self._symbol = next(
+                symbol for symbol in list(Symbol)
+                if new_pitch == symbol.as_steps()
+            )
+        except StopIteration:
+            raise IndexError(
+                "New symbol is not within the range of DOUBLEFLAT and "
+                "DOUBLESHARP"
+            )