chord-romanizer 0.1.1__tar.gz

chord_romanizer-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 anime-song
+
+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.

chord_romanizer-0.1.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

chord_romanizer-0.1.1/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.1
+Name: chord_romanizer
+Version: 0.1.1
+Summary: A library to analyze chord progressions and convert them to Roman numeral analysis.
+Home-page: https://github.com/anime-song/chord-romanizer
+Author: anime-song
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Chord Romanizer
+
+Chord Romanizerは、コード進行の解析とディグリーネーム（ローマ数字）表記への変換を行うPythonライブラリです。
+複雑なコードや転回形、ハイブリッドコード（分数コード）にも対応しており、文脈（前後のコード）を考慮した解析を行います。
+
+## 特徴
+- **文脈考慮**: キーと前後のコードから最適な度数表記を判定（例: 半音進行や解決先を考慮）。
+- **分数コード対応**: 転回形 (`C/E`)、ハイブリッドコード (`F/G`)、UST (`upper structure triad`) などを識別し、適切に表記 (`I/3`, `V9sus4`, etc.)。
+- **柔軟な入力**: 一般的なコードシンボル表記 (`Cm7`, `F#aug`, `Bb/C` など) をパース可能。
+
+## インストール
+
+現在のところ、PyPIには公開されていません。リポジトリをクローンしてプロジェクトに含めてください。
+
+```bash
+git clone https://github.com/your-username/chord-romanizer.git
+```
+
+## クイックスタート
+
+```python
+from chord_romanizer import Romanizer, ChordParser
+
+# 1. インスタンス生成 (デフォルトキーを指定可能)
+romanizer = Romanizer(default_tonic="C")
+
+# 2. コード進行の準備 (文字列からParsedChordへ変換)
+progression_str = ["Dm7", "G7", "Cmaj7", "A7(b9)", "Dm7"]
+chords = [ChordParser.parse(c) for c in progression_str if c]
+
+# 3. 解析 (annotate_progression)
+# 結果は RomanizedChord オブジェクトのリスト
+results = romanizer.annotate_progression(chords)
+
+# 4. 結果の表示
+for res in results:
+    input_symbol = res.chord.symbol
+    roman = res.roman
+    key = romanizer.default_tonic
+    print(f"{input_symbol} (Key: {key}) -> {roman}")
+
+# 出力例:
+# Dm7 (Key: C) -> IIm7
+# G7 (Key: C) -> V7
+# Cmaj7 (Key: C) -> IM7
+# A7(b9) (Key: C) -> VI7(b9)
+# Dm7 (Key: C) -> IIm7
+```
+
+## 主なクラスと機能
+
+### `Romanizer`
+解析のメインクラスです。
+- `annotate_progression(progression)`: コードのリストを受け取り、解析結果 (`RomanizedChord`) のリストを返します。リストの各要素は `ParsedChord` または `(ParsedChord, Key)` のタプルを受け付けます（転調に対応する場合）。
+
+### `ChordParser`
+コードシンボル文字列を解析用オブジェクトに変換します。
+- `parse(symbol_str)`: 文字列をパースして `ParsedChord` を返します。
+
+### `RomanizedChord`
+解析結果を保持するデータクラスです。
+- `roman`: 最終的なローマ数字表記（例: `IIm7`, `V7/VI`）。
+- `degree_root`: ルートの度数（例: `II`, `V`）。
+- `degree_bass`: ベース音の度数（転回形の場合）。
+- `is_hybrid`: ハイブリッドコード（機能的な分数コード）として解釈されたかフラグ。
+- `is_ii_v_start`: ツーファイブ進行の起点（II）と判定されたか。
+- `is_resolution_target`: ドミナントモーションの解決先（I）と判定されたか。
+
+## ライセンス
+[MIT License](LICENSE)

chord_romanizer-0.1.1/README.md

@@ -0,0 +1,70 @@
+# Chord Romanizer
+
+Chord Romanizerは、コード進行の解析とディグリーネーム（ローマ数字）表記への変換を行うPythonライブラリです。
+複雑なコードや転回形、ハイブリッドコード（分数コード）にも対応しており、文脈（前後のコード）を考慮した解析を行います。
+
+## 特徴
+- **文脈考慮**: キーと前後のコードから最適な度数表記を判定（例: 半音進行や解決先を考慮）。
+- **分数コード対応**: 転回形 (`C/E`)、ハイブリッドコード (`F/G`)、UST (`upper structure triad`) などを識別し、適切に表記 (`I/3`, `V9sus4`, etc.)。
+- **柔軟な入力**: 一般的なコードシンボル表記 (`Cm7`, `F#aug`, `Bb/C` など) をパース可能。
+
+## インストール
+
+現在のところ、PyPIには公開されていません。リポジトリをクローンしてプロジェクトに含めてください。
+
+```bash
+git clone https://github.com/your-username/chord-romanizer.git
+```
+
+## クイックスタート
+
+```python
+from chord_romanizer import Romanizer, ChordParser
+
+# 1. インスタンス生成 (デフォルトキーを指定可能)
+romanizer = Romanizer(default_tonic="C")
+
+# 2. コード進行の準備 (文字列からParsedChordへ変換)
+progression_str = ["Dm7", "G7", "Cmaj7", "A7(b9)", "Dm7"]
+chords = [ChordParser.parse(c) for c in progression_str if c]
+
+# 3. 解析 (annotate_progression)
+# 結果は RomanizedChord オブジェクトのリスト
+results = romanizer.annotate_progression(chords)
+
+# 4. 結果の表示
+for res in results:
+    input_symbol = res.chord.symbol
+    roman = res.roman
+    key = romanizer.default_tonic
+    print(f"{input_symbol} (Key: {key}) -> {roman}")
+
+# 出力例:
+# Dm7 (Key: C) -> IIm7
+# G7 (Key: C) -> V7
+# Cmaj7 (Key: C) -> IM7
+# A7(b9) (Key: C) -> VI7(b9)
+# Dm7 (Key: C) -> IIm7
+```
+
+## 主なクラスと機能
+
+### `Romanizer`
+解析のメインクラスです。
+- `annotate_progression(progression)`: コードのリストを受け取り、解析結果 (`RomanizedChord`) のリストを返します。リストの各要素は `ParsedChord` または `(ParsedChord, Key)` のタプルを受け付けます（転調に対応する場合）。
+
+### `ChordParser`
+コードシンボル文字列を解析用オブジェクトに変換します。
+- `parse(symbol_str)`: 文字列をパースして `ParsedChord` を返します。
+
+### `RomanizedChord`
+解析結果を保持するデータクラスです。
+- `roman`: 最終的なローマ数字表記（例: `IIm7`, `V7/VI`）。
+- `degree_root`: ルートの度数（例: `II`, `V`）。
+- `degree_bass`: ベース音の度数（転回形の場合）。
+- `is_hybrid`: ハイブリッドコード（機能的な分数コード）として解釈されたかフラグ。
+- `is_ii_v_start`: ツーファイブ進行の起点（II）と判定されたか。
+- `is_resolution_target`: ドミナントモーションの解決先（I）と判定されたか。
+
+## ライセンス
+[MIT License](LICENSE)

chord_romanizer-0.1.1/chord_romanizer/__init__.py

@@ -0,0 +1,13 @@
+from .romanizer import Romanizer, RomanizedChord
+from .chord_parser import ChordParser, ParsedChord
+from .chord_interpreter import ChordInterpreter, HybridAnalysis, HybridKind
+
+__all__ = [
+    "Romanizer",
+    "RomanizedChord",
+    "ChordParser",
+    "ParsedChord",
+    "ChordInterpreter",
+    "HybridAnalysis", 
+    "HybridKind",
+]

chord_romanizer-0.1.1/chord_romanizer/chord_interpreter.py

@@ -0,0 +1,228 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional, Tuple
+
+from .chord_parser import ParsedChord
+from .note_speller import NoteSpeller
+from .chord_structure import ChordStructure
+
+
+class HybridKind(str, Enum):
+    """ハイブリッドコードの分類ID"""
+
+    NONE = "none"
+    BLACKADDER = "blackadder"
+    SEC_DOM_3_IN_BASS = "sec_dom_3inbass"
+    HALFDIM_9 = "halfdim9"
+    SUS4_9 = "9sus4"
+    SUS4_7_B9 = "7sus4(b9)"
+
+
+@dataclass
+class HybridAnalysis:
+    """ハイブリッド/スラッシュコードの解析結果"""
+
+    is_hybrid: bool = False
+    alter: Optional[str] = None  # "Gb7(9,#11)" など
+    bass_preference: Optional[bool] = None  # Bassの#b優先度
+    root_override: Optional[str] = None  # Blackadder時のアンカーなど
+    kind: HybridKind = HybridKind.NONE  # "blackadder", "halfdim9" など
+
+
+class ChordInterpreter:
+    """
+    複雑なコード（AugSlash, Blackadderなど）の機能的な解釈を行うクラス。
+    Romanizerから複雑な条件分岐を隠蔽する。
+    """
+
+    # --- Scoring Configuration ---
+    SCORE_SEMITONE_RESOLUTION = 3.0  # 半音解決
+    SCORE_BACKDOOR_RESOLUTION = 5.0  # 裏コード/Backdoor解決
+    SCORE_STRONG_RESOLUTION = 6.0  # 強進行 (V->I)
+    SCORE_WEAK_RESOLUTION = 2.0  # 弱進行 (Dominantへの解決など)
+    SCORE_BASE_BIAS = 0.5  # 同点時の下駄
+
+    # -----------------------------
+    # public
+    # -----------------------------
+    def analyze_slash_chord(
+        self,
+        chord: ParsedChord,
+        next_chord: Optional[ParsedChord],
+    ) -> HybridAnalysis:
+        if not chord.bass:
+            return HybridAnalysis(is_hybrid=False)
+
+        # 1. 転回形 (Structureに委譲)
+        if ChordStructure.is_inversion(chord.root, chord.bass, chord.quality):
+            return HybridAnalysis(is_hybrid=False)
+
+        # 2. Aug slash (文脈解釈)
+        if ChordStructure.is_aug_quality(chord.quality):
+            aug_result = self._infer_aug_slash(chord, next_chord)
+            if aug_result:
+                return aug_result
+
+        # 3. 通常の hybrid (簡易定義に基づく)
+        alter, kind = self._infer_normal_hybrid(chord)
+        if alter:
+            return HybridAnalysis(is_hybrid=True, alter=alter, kind=kind)
+
+        return HybridAnalysis(is_hybrid=True, kind=HybridKind.NONE)
+
+    # --- Internal Logic ---
+
+    def _infer_aug_slash(
+        self, chord: ParsedChord, next_chord: Optional[ParsedChord]
+    ) -> Optional[HybridAnalysis]:
+        candidates: List[Tuple[float, HybridAnalysis]] = []
+
+        blackadder = self._check_blackadder(chord, next_chord)
+        if blackadder:
+            candidates.append(blackadder)
+
+        halfdim = self._check_halfdim(chord, next_chord)
+        if halfdim:
+            candidates.append(halfdim)
+
+        if not candidates:
+            return None
+
+        # スコア最大を採用
+        return max(candidates, key=lambda x: x[0])[1]
+
+    def _check_blackadder(
+        self, chord: ParsedChord, next_chord: Optional[ParsedChord]
+    ) -> Optional[Tuple[float, HybridAnalysis]]:
+        bass_pitch_class = NoteSpeller.pitch_class_of(chord.bass)
+        triad_pitch_classes = ChordStructure.get_aug_triad_pitch_classes(chord.root)
+
+        if bass_pitch_class is None or triad_pitch_classes is None:
+            return None
+
+        # Anchor check: bass + 6 semitones が構成音に含まれるか
+        anchor_pitch_class = (bass_pitch_class + 6) % 12
+        if anchor_pitch_class not in triad_pitch_classes:
+            return None
+
+        # --- Context Analysis ---
+        score = 0.0
+        bass_to_next = (
+            NoteSpeller.semitone_distance(next_chord.root, chord.bass)
+            if next_chord
+            else None
+        )
+
+        # Determine Bass Preference (Sharp or Flat)
+        bass_preference = self._bass_pref_from_resolution(chord.bass, next_chord) or False
+        bass_fixed = NoteSpeller.name_of_pitch_class(bass_pitch_class, bass_preference)
+        anchor_name = NoteSpeller.name_of_pitch_class(anchor_pitch_class)  # Canonical
+
+        # Default Interpretation
+        alter = f"{bass_fixed}7(9,#11)"
+        kind = HybridKind.BLACKADDER
+
+        # Rule 1: 半音解決 (Tritone substitution behavior)
+        if bass_to_next in (1, 11):
+            score += self.SCORE_SEMITONE_RESOLUTION
+
+        # Rule 2: Backdoor (bVII -> I)
+        if (
+            next_chord
+            and bass_to_next == 2
+            and ChordStructure.is_tonic_quality(next_chord.quality)
+        ):
+            score += self.SCORE_BACKDOOR_RESOLUTION
+
+        # Rule 3: 3rd in Bass Secondary Dominant (e.g., Faug/B -> C)
+        # Anchor(F) -> Dominant(G) -> Target(C)
+        anchor_parsed = NoteSpeller.parse_note(anchor_name)
+        if anchor_parsed and next_chord:
+            dominant_letter = NoteSpeller.shift_letter(anchor_parsed[0], 1)
+            dominant_pc = (anchor_pitch_class + 2) % 12
+            dominant_name = NoteSpeller.spell_pitch_class(dominant_letter, dominant_pc)
+
+            dominant_to_next = NoteSpeller.semitone_distance(next_chord.root, dominant_name)
+            # Dominant resolution check (V->I)
+            if dominant_to_next in (5, 7) and ChordStructure.is_tonic_quality(
+                next_chord.quality
+            ):
+                alter = f"{dominant_name}7(9,#11)/{bass_fixed}"
+                kind = HybridKind.SEC_DOM_3_IN_BASS
+                score += self.SCORE_STRONG_RESOLUTION
+
+        return score, HybridAnalysis(
+            is_hybrid=True,
+            kind=kind,
+            alter=alter,
+            bass_preference=bass_preference,
+            root_override=anchor_name,
+        )
+
+    def _check_halfdim(
+        self, chord: ParsedChord, next_chord: Optional[ParsedChord]
+    ) -> Optional[Tuple[float, HybridAnalysis]]:
+        bass_pitch_class = NoteSpeller.pitch_class_of(chord.bass)
+        triad_pitch_classes = ChordStructure.get_aug_triad_pitch_classes(chord.root)
+        if bass_pitch_class is None or triad_pitch_classes is None:
+            return None
+
+        # Half-dim check: relative intervals {2, 6, 10}
+        relative_intervals = {(pc - bass_pitch_class) % 12 for pc in triad_pitch_classes}
+        if not {2, 6, 10}.issubset(relative_intervals):
+            return None
+
+        score = self.SCORE_BASE_BIAS
+        bass_preference = (
+            True if "#" in chord.bass else (False if "b" in chord.bass else None)
+        )
+        bass_fixed = NoteSpeller.name_of_pitch_class(bass_pitch_class, bass_preference)
+
+        if next_chord:
+            bass_to_next = NoteSpeller.semitone_distance(next_chord.root, chord.bass)
+            next_is_dominant = ChordStructure.is_dominant_quality(next_chord.quality)
+
+            # iiø -> V (Strong)
+            if bass_to_next in (5, 7) and next_is_dominant:
+                score += self.SCORE_STRONG_RESOLUTION
+            # Any resolution to Dominant (Weak)
+            elif next_is_dominant:
+                score += self.SCORE_WEAK_RESOLUTION
+
+        return score, HybridAnalysis(
+            is_hybrid=True,
+            kind=HybridKind.HALFDIM_9,
+            alter=f"{bass_fixed}m7-5(9)",
+            bass_preference=bass_preference,
+        )
+
+    def _infer_normal_hybrid(
+        self, chord: ParsedChord
+    ) -> Tuple[Optional[str], HybridKind]:
+        dist = NoteSpeller.semitone_distance(chord.root, chord.bass)
+        if dist is None:
+            return None, HybridKind.NONE
+
+        intervals = ChordStructure.get_intervals(chord.quality)
+        relative_intervals = {(i + dist) % 12 for i in intervals}
+
+        has_third = (3 in relative_intervals) or (4 in relative_intervals)
+        if not has_third:
+            if {2, 5, 10}.issubset(relative_intervals):
+                return f"{chord.bass}9sus4", HybridKind.SUS4_9
+            if {1, 5, 10}.issubset(relative_intervals):
+                return f"{chord.bass}7sus4(b9)", HybridKind.SUS4_7_B9
+        return None, HybridKind.NONE
+
+    # Helper: Bass preference logic
+    def _bass_pref_from_resolution(
+        self, bass: str, next_chord: Optional[ParsedChord]
+    ) -> Optional[bool]:
+        if not next_chord:
+            return None
+        bass_to_next = NoteSpeller.semitone_distance(next_chord.root, bass)
+        if bass_to_next == 1:
+            return True  # Ascending -> Sharp
+        if bass_to_next == 11:
+            return False  # Descending -> Flat
+        return None

chord_romanizer-0.1.1/chord_romanizer/chord_parser.py

@@ -0,0 +1,114 @@
+from dataclasses import dataclass
+from typing import Optional
+
+# Pitch-class canonical names (all sharps)
+NOTE_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
+
+# Aliases for normalization (flats, H, etc.)
+NOTE_ALIASES = {
+    "CB": "B",
+    "B#": "C",
+    "DB": "C#",
+    "EB": "D#",
+    "E#": "F",
+    "FB": "E",
+    "GB": "F#",
+    "AB": "G#",
+    "BB": "A#",
+    "HB": "B",
+    "H": "B",
+}
+
+
+def normalize_note_pc(note: str) -> Optional[str]:
+    """Normalize pitch-class spelling to canonical sharp-based representation."""
+    up = note.strip().upper()
+    # Handle double sharp x
+    if up.endswith("X"):
+        base = up[:-1]
+        if base in NOTE_NAMES or base in NOTE_ALIASES:
+             # Recursively normalize base and add 2 semitones
+             base_pc = normalize_note_pc(base)
+             if base_pc:
+                 idx = NOTE_NAMES.index(base_pc)
+                 return NOTE_NAMES[(idx + 2) % 12]
+    
+    if up in NOTE_ALIASES:
+        return NOTE_ALIASES[up]
+    if up in NOTE_NAMES:
+        return up
+    return None
+
+
+def normalize_spelling(token: str) -> str:
+    """Keep user spelling but capitalize first letter (Db -> Db, c# -> C#)."""
+    token = token.strip()
+    if not token:
+        return token
+    return token[0].upper() + token[1:]
+
+
+@dataclass
+class ParsedChord:
+    symbol: str
+    root: str  # user spelling (e.g., Db / C#)
+    quality: str
+    bass: Optional[str] = None  # user spelling (e.g., F#, Gb)
+
+
+class ChordParser:
+    @staticmethod
+    def parse(symbol: str) -> Optional[ParsedChord]:
+        """Parse chord symbol like 'C#m7/G#' into components."""
+        if not symbol:
+            return None
+
+        text = symbol.strip()
+
+        # Allow no-chord markers
+        normalized_nc = text.replace(".", "").replace(" ", "").upper()
+        if normalized_nc in {"NC", "NOCHORD"}:
+            return ParsedChord(symbol=text, root="NC", quality="", bass=None)
+
+        # Split slash bass if present
+        if "/" in text:
+            body, bass = text.split("/", 1)
+            bass_token = bass.strip()
+            if normalize_note_pc(bass_token) is None:
+                return None
+        else:
+            body, bass_token = text, None
+
+        body = body.strip()
+        if not body:
+            return None
+
+        # Root token: A-G plus optional accidentals (#, b, x, bb)
+        # Check for 2-char accidentals first (bb) or just double #?
+        # Actually user input might be "Cbb". body="Cbb".
+        # Or "Cx". body="Cx".
+        
+        # Simple parser approach:
+        # Take 1 char. Check next chars for accidentals.
+        root_len = 1
+        if len(body) > 1 and body[1] in ("#", "b", "B", "x", "X"):
+             root_len = 2
+             # Check for double accidentals like "bb" or "##"
+             if len(body) > 2 and body[2] == body[1] and body[1] in ("#", "b", "B"):
+                 root_len = 3
+        
+        root_token = body[:root_len]
+        rest = body[root_len:]
+
+        # Validate root
+        if normalize_note_pc(root_token) is None:
+            return None
+
+        root = normalize_spelling(root_token)
+        quality = rest or ""
+
+        bass: Optional[str] = None
+        if bass_token:
+            bass = normalize_spelling(bass_token)
+
+        return ParsedChord(symbol=text, root=root, quality=quality, bass=bass)

chord_romanizer-0.1.1/chord_romanizer/chord_structure.py

@@ -0,0 +1,126 @@
+from typing import Dict, Optional, Set, Tuple
+
+from .chord_parser import NOTE_NAMES
+from .note_speller import NATURAL_PITCH_CLASS, NoteSpeller
+
+
+class ChordStructure:
+    """
+    コードの「静的な定義」のみを扱う。
+    「文脈によってこう解釈する」というロジックは Interpreter へ移動。
+    """
+
+    @staticmethod
+    def get_intervals(quality: str) -> Set[int]:
+        if "M7" in quality:
+            return {0, 4, 7, 11}
+
+        quality_lower = (quality or "").lower()
+        if ("m7-5" in quality_lower) or ("m7b5" in quality_lower):
+            return {0, 3, 6, 10}
+        if "dim" in quality_lower or "o" in quality_lower:
+            return {0, 3, 6}
+        if ("maj7" in quality_lower) or ("ma7" in quality_lower):
+            return {0, 4, 7, 11}
+        if "m7" in quality_lower:
+            return {0, 3, 7, 10}
+        if "7" in quality_lower:
+            return {0, 4, 7, 10}
+        if "m" in quality_lower:
+            return {0, 3, 7}
+        return {0, 4, 7}
+
+    @staticmethod
+    def is_inversion(root: str, bass: str, quality: str) -> bool:
+        dist = NoteSpeller.semitone_distance(bass, root)
+        if dist is None:
+            return False
+        return dist in ChordStructure.get_intervals(quality)
+
+    @staticmethod
+    def get_spelled_tones(root: str, quality: str) -> Dict[int, str]:
+        root_parsed = NoteSpeller.parse_note(root)
+        if root_parsed is None:
+            return {}
+        root_letter, root_accidental = root_parsed
+        root_pitch_class = (NATURAL_PITCH_CLASS[root_letter] + root_accidental) % 12
+
+        quality_lower = quality.lower()
+        if "M7" in quality:
+             definition = ([(0, 0), (4, 2), (7, 4)], (11, 6))
+        elif "m7" in quality_lower:
+            definition = ([(0, 0), (3, 2), (7, 4)], (10, 6))
+        elif "maj7" in quality_lower:
+            definition = ([(0, 0), (4, 2), (7, 4)], (11, 6))
+        elif "7" in quality_lower:
+            definition = ([(0, 0), (4, 2), (7, 4)], (10, 6))
+        else:
+            definition = ([(0, 0), (4, 2), (7, 4)], None)
+
+        triad, seventh = definition
+        tones = {}
+        for semitone, step in triad:
+            target_letter = NoteSpeller.shift_letter(root_letter, step)
+            current_pitch_class = (root_pitch_class + semitone) % 12
+            tones[current_pitch_class] = NoteSpeller.spell_pitch_class(
+                target_letter, current_pitch_class
+            )
+            
+        if seventh:
+            semitone, step = seventh
+            target_letter = NoteSpeller.shift_letter(root_letter, step)
+            current_pitch_class = (root_pitch_class + semitone) % 12
+            tones[current_pitch_class] = NoteSpeller.spell_pitch_class(
+                target_letter, current_pitch_class
+            )
+        return tones
+
+    @staticmethod
+    def is_aug_quality(quality: str) -> bool:
+        quality_lower = (quality or "").lower()
+        return ("aug" in quality_lower) or ("+" in (quality or ""))
+
+    @staticmethod
+    def get_aug_triad_pitch_classes(root: str) -> Optional[Set[int]]:
+        root_pc = NoteSpeller.pitch_class_of(root)
+        if root_pc is None:
+            return None
+        return {(root_pc + 0) % 12, (root_pc + 4) % 12, (root_pc + 8) % 12}
+
+    @staticmethod
+    def is_dominant_quality(quality: str) -> bool:
+        """機能的にドミナントになり得るQualityか判定"""
+        # "M7" は Major 7th なのでドミナントではない (case-sensitive check)
+        if "M7" in quality:
+            return False
+            
+        quality_lower = (quality or "").lower()
+        # maj7 は除外、7を含むものをドミナント候補とする
+        if ("maj7" in quality_lower) or ("ma7" in quality_lower):
+            return False
+            
+        # マイナー系 (m7 など) はドミナントではない (ただし dim7 はドミナント機能を持つことがあるので除外しない)
+        if ("m" in quality_lower) and ("dim" not in quality_lower):
+            return False
+            
+        return "7" in quality_lower
+
+    @staticmethod
+    def is_tonic_quality(quality: str) -> bool:
+        """機能的にトニックになり得るQualityか判定"""
+        if ChordStructure.is_dominant_quality(quality):
+            return False
+        # m, maj7, M7, 6, または無印(Triad)など
+        return True
+
+    @staticmethod
+    def is_minor_quality(quality: str) -> bool:
+        """機能的にマイナーになり得るQualityか判定（m, m7, m9など）"""
+        # "M7" は Major 7th -> Not Minor
+        if "M7" in quality:
+            return False
+            
+        quality_lower = (quality or "").lower()
+        if ("m" in quality_lower) and ("maj" not in quality_lower) and ("dim" not in quality_lower):
+            return True
+        return False