update enviroments

Dockerfile

@@ -23,11 +23,13 @@ RUN pip list
 # Copy the rest of your application's code
 COPY . /app/
 
+# Replace the librosa notation.py with notation.py from your project
+COPY notation.py /usr/local/lib/python3.10/site-packages/librosa/core/notation.py
+
 # RUN cd /tmp && mkdir cache1
 
 ENV NUMBA_CACHE_DIR=/tmp
 
-
 # Expose the port your app runs on
 EXPOSE 7860
 

notation.py

@@ -0,0 +1,1011 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""Music notation utilities"""
+
+import re
+import numpy as np
+from numba import jit
+from .intervals import INTERVALS
+from .._cache import cache
+from ..util.exceptions import ParameterError
+from typing import Dict, List, Union, overload
+from ..util.decorators import vectorize
+from .._typing import _ScalarOrSequence, _FloatLike_co, _SequenceLike
+
+
+__all__ = [
+    "key_to_degrees",
+    "key_to_notes",
+    "mela_to_degrees",
+    "mela_to_svara",
+    "thaat_to_degrees",
+    "list_mela",
+    "list_thaat",
+    "fifths_to_note",
+    "interval_to_fjs",
+]
+
+THAAT_MAP = dict(
+    bilaval=[0, 2, 4, 5, 7, 9, 11],
+    khamaj=[0, 2, 4, 5, 7, 9, 10],
+    kafi=[0, 2, 3, 5, 7, 9, 10],
+    asavari=[0, 2, 3, 5, 7, 8, 10],
+    bhairavi=[0, 1, 3, 5, 7, 8, 10],
+    kalyan=[0, 2, 4, 6, 7, 9, 11],
+    marva=[0, 1, 4, 6, 7, 9, 11],
+    poorvi=[0, 1, 4, 6, 7, 8, 11],
+    todi=[0, 1, 3, 6, 7, 8, 11],
+    bhairav=[0, 1, 4, 5, 7, 8, 11],
+)
+
+# Enumeration will start from 1
+MELAKARTA_MAP = {
+    k: i
+    for i, k in enumerate(
+        [
+            "kanakangi",
+            "ratnangi",
+            "ganamurthi",
+            "vanaspathi",
+            "manavathi",
+            "tanarupi",
+            "senavathi",
+            "hanumathodi",
+            "dhenuka",
+            "natakapriya",
+            "kokilapriya",
+            "rupavathi",
+            "gayakapriya",
+            "vakulabharanam",
+            "mayamalavagaula",
+            "chakravakom",
+            "suryakantham",
+            "hatakambari",
+            "jhankaradhwani",
+            "natabhairavi",
+            "keeravani",
+            "kharaharapriya",
+            "gaurimanohari",
+            "varunapriya",
+            "mararanjini",
+            "charukesi",
+            "sarasangi",
+            "harikambhoji",
+            "dheerasankarabharanam",
+            "naganandini",
+            "yagapriya",
+            "ragavardhini",
+            "gangeyabhushani",
+            "vagadheeswari",
+            "sulini",
+            "chalanatta",
+            "salagam",
+            "jalarnavam",
+            "jhalavarali",
+            "navaneetham",
+            "pavani",
+            "raghupriya",
+            "gavambodhi",
+            "bhavapriya",
+            "subhapanthuvarali",
+            "shadvidhamargini",
+            "suvarnangi",
+            "divyamani",
+            "dhavalambari",
+            "namanarayani",
+            "kamavardhini",
+            "ramapriya",
+            "gamanasrama",
+            "viswambhari",
+            "syamalangi",
+            "shanmukhapriya",
+            "simhendramadhyamam",
+            "hemavathi",
+            "dharmavathi",
+            "neethimathi",
+            "kanthamani",
+            "rishabhapriya",
+            "latangi",
+            "vachaspathi",
+            "mechakalyani",
+            "chitrambari",
+            "sucharitra",
+            "jyotisvarupini",
+            "dhatuvardhini",
+            "nasikabhushani",
+            "kosalam",
+            "rasikapriya",
+        ],
+        1,
+    )
+}
+
+
+# Pre-compiled regular expressions for note and key parsing
+NOTE_RE = re.compile(
+    r"^(?P<note>[A-Ga-g])"
+    r"(?P<accidental>[#♯𝄪b!♭𝄫♮]*)"
+    r"(?P<octave>[+-]?\d+)?"
+    r"(?P<cents>[+-]\d+)?$"
+)
+
+KEY_RE = re.compile(
+    r"^(?P<tonic>[A-Ga-g])" r"(?P<accidental>[#♯b!♭]?)" r":(?P<scale>(maj|min)(or)?)$"
+)
+
+
+def thaat_to_degrees(thaat: str) -> np.ndarray:
+    """Construct the svara indices (degrees) for a given thaat
+
+    Parameters
+    ----------
+    thaat : str
+        The name of the thaat
+
+    Returns
+    -------
+    indices : np.ndarray
+        A list of the seven svara indices (starting from 0=Sa)
+        contained in the specified thaat
+
+    See Also
+    --------
+    key_to_degrees
+    mela_to_degrees
+    list_thaat
+
+    Examples
+    --------
+    >>> librosa.thaat_to_degrees('bilaval')
+    array([ 0,  2,  4,  5,  7,  9, 11])
+
+    >>> librosa.thaat_to_degrees('todi')
+    array([ 0,  1,  3,  6,  7,  8, 11])
+    """
+    return np.asarray(THAAT_MAP[thaat.lower()])
+
+
+def mela_to_degrees(mela: Union[str, int]) -> np.ndarray:
+    """Construct the svara indices (degrees) for a given melakarta raga
+
+    Parameters
+    ----------
+    mela : str or int
+        Either the name or integer index ([1, 2, ..., 72]) of the melakarta raga
+
+    Returns
+    -------
+    degrees : np.ndarray
+        A list of the seven svara indices (starting from 0=Sa)
+        contained in the specified raga
+
+    See Also
+    --------
+    thaat_to_degrees
+    key_to_degrees
+    list_mela
+
+    Examples
+    --------
+    Melakarta #1 (kanakangi):
+
+    >>> librosa.mela_to_degrees(1)
+    array([0, 1, 2, 5, 7, 8, 9])
+
+    Or using a name directly:
+
+    >>> librosa.mela_to_degrees('kanakangi')
+    array([0, 1, 2, 5, 7, 8, 9])
+    """
+
+    if isinstance(mela, str):
+        index = MELAKARTA_MAP[mela.lower()] - 1
+    elif 0 < mela <= 72:
+        index = mela - 1
+    else:
+        raise ParameterError(f"mela={mela} must be in range [1, 72]")
+
+    # always have Sa [0]
+    degrees = [0]
+
+    # Fill in Ri and Ga
+    lower = index % 36
+    if 0 <= lower < 6:
+        # Ri1, Ga1
+        degrees.extend([1, 2])
+    elif 6 <= lower < 12:
+        # Ri1, Ga2
+        degrees.extend([1, 3])
+    elif 12 <= lower < 18:
+        # Ri1, Ga3
+        degrees.extend([1, 4])
+    elif 18 <= lower < 24:
+        # Ri2, Ga2
+        degrees.extend([2, 3])
+    elif 24 <= lower < 30:
+        # Ri2, Ga3
+        degrees.extend([2, 4])
+    else:
+        # Ri3, Ga3
+        degrees.extend([3, 4])
+
+    # Determine Ma
+    if index < 36:
+        # Ma1
+        degrees.append(5)
+    else:
+        # Ma2
+        degrees.append(6)
+
+    # always have Pa [7]
+    degrees.append(7)
+
+    # Determine Dha and Ni
+    upper = index % 6
+    if upper == 0:
+        # Dha1, Ni1
+        degrees.extend([8, 9])
+    elif upper == 1:
+        # Dha1, Ni2
+        degrees.extend([8, 10])
+    elif upper == 2:
+        # Dha1, Ni3
+        degrees.extend([8, 11])
+    elif upper == 3:
+        # Dha2, Ni2
+        degrees.extend([9, 10])
+    elif upper == 4:
+        # Dha2, Ni3
+        degrees.extend([9, 11])
+    else:
+        # Dha3, Ni3
+        degrees.extend([10, 11])
+
+    return np.array(degrees)
+
+
+@cache(level=10)
+def mela_to_svara(
+    mela: Union[str, int], *, abbr: bool = True, unicode: bool = True
+) -> List[str]:
+    """Spell the Carnatic svara names for a given melakarta raga
+
+    This function exists to resolve enharmonic equivalences between
+    pitch classes:
+
+        - Ri2 / Ga1
+        - Ri3 / Ga2
+        - Dha2 / Ni1
+        - Dha3 / Ni2
+
+    For svara outside the raga, names are chosen to preserve orderings
+    so that all Ri precede all Ga, and all Dha precede all Ni.
+
+    Parameters
+    ----------
+    mela : str or int
+        the name or numerical index of the melakarta raga
+
+    abbr : bool
+        If `True`, use single-letter svara names: S, R, G, ...
+
+        If `False`, use full names: Sa, Ri, Ga, ...
+
+    unicode : bool
+        If `True`, use unicode symbols for numberings, e.g., Ri\u2081
+
+        If `False`, use low-order ASCII, e.g., Ri1.
+
+    Returns
+    -------
+    svara : list of strings
+
+        The svara names for each of the 12 pitch classes.
+
+    See Also
+    --------
+    key_to_notes
+    mela_to_degrees
+    list_mela
+
+    Examples
+    --------
+    Melakarta #1 (Kanakangi) uses R1, G1, D1, N1
+
+    >>> librosa.mela_to_svara(1)
+    ['S', 'R₁', 'G₁', 'G₂', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'N₁', 'N₂', 'N₃']
+
+    #19 (Jhankaradhwani) uses R2 and G2 so the third svara are Ri:
+
+    >>> librosa.mela_to_svara(19)
+    ['S', 'R₁', 'R₂', 'G₂', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'N₁', 'N₂', 'N₃']
+
+    #31 (Yagapriya) uses R3 and G3, so third and fourth svara are Ri:
+
+    >>> librosa.mela_to_svara(31)
+    ['S', 'R₁', 'R₂', 'R₃', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'N₁', 'N₂', 'N₃']
+
+    #34 (Vagadheeswari) uses D2 and N2, so Ni1 becomes Dha2:
+
+    >>> librosa.mela_to_svara(34)
+    ['S', 'R₁', 'R₂', 'R₃', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'D₂', 'N₂', 'N₃']
+
+    #36 (Chalanatta) uses D3 and N3, so Ni2 becomes Dha3:
+
+    >>> librosa.mela_to_svara(36)
+    ['S', 'R₁', 'R₂', 'R₃', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'D₂', 'D₃', 'N₃']
+
+    # You can also query by raga name instead of index:
+
+    >>> librosa.mela_to_svara('chalanatta')
+    ['S', 'R₁', 'R₂', 'R₃', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'D₂', 'D₃', 'N₃']
+    """
+
+    # The following will be constant for all ragas
+    svara_map = [
+        "Sa",
+        "Ri\u2081",
+        "",  # Ri2/Ga1
+        "",  # Ri3/Ga2
+        "Ga\u2083",
+        "Ma\u2081",
+        "Ma\u2082",
+        "Pa",
+        "Dha\u2081",
+        "",  # Dha2/Ni1
+        "",  # Dha3/Ni2
+        "Ni\u2083",
+    ]
+
+    if isinstance(mela, str):
+        mela_idx = MELAKARTA_MAP[mela.lower()] - 1
+    elif 0 < mela <= 72:
+        mela_idx = mela - 1
+    else:
+        raise ParameterError(f"mela={mela} must be in range [1, 72]")
+
+    # Determine Ri2/Ga1
+    lower = mela_idx % 36
+    if lower < 6:
+        # First six will have Ri1/Ga1
+        svara_map[2] = "Ga\u2081"
+    else:
+        # All others have either Ga2/Ga3
+        # So we'll call this Ri2
+        svara_map[2] = "Ri\u2082"
+
+    # Determine Ri3/Ga2
+    if lower < 30:
+        # First thirty should get Ga2
+        svara_map[3] = "Ga\u2082"
+    else:
+        # Only the last six have Ri3
+        svara_map[3] = "Ri\u2083"
+
+    upper = mela_idx % 6
+
+    # Determine Dha2/Ni1
+    if upper == 0:
+        # these are the only ones with Ni1
+        svara_map[9] = "Ni\u2081"
+    else:
+        # Everyone else has Dha2
+        svara_map[9] = "Dha\u2082"
+
+    # Determine Dha3/Ni2
+    if upper == 5:
+        # This one has Dha3
+        svara_map[10] = "Dha\u2083"
+    else:
+        # Everyone else has Ni2
+        svara_map[10] = "Ni\u2082"
+
+    if abbr:
+        t_abbr = str.maketrans({"a": "", "h": "", "i": ""})
+        svara_map = [s.translate(t_abbr) for s in svara_map]
+
+    if not unicode:
+        t_uni = str.maketrans({"\u2081": "1", "\u2082": "2", "\u2083": "3"})
+        svara_map = [s.translate(t_uni) for s in svara_map]
+
+    return list(svara_map)
+
+
+def list_mela() -> Dict[str, int]:
+    """List melakarta ragas by name and index.
+
+    Melakarta raga names are transcribed from [#]_, with the exception of #45
+    (subhapanthuvarali).
+
+    .. [#] Bhagyalekshmy, S. (1990).
+        Ragas in Carnatic music.
+        South Asia Books.
+
+    Returns
+    -------
+    mela_map : dict
+        A dictionary mapping melakarta raga names to indices (1, 2, ..., 72)
+
+    Examples
+    --------
+    >>> librosa.list_mela()
+    {'kanakangi': 1,
+     'ratnangi': 2,
+     'ganamurthi': 3,
+     'vanaspathi': 4,
+     ...}
+
+    See Also
+    --------
+    mela_to_degrees
+    mela_to_svara
+    list_thaat
+    """
+    return MELAKARTA_MAP.copy()
+
+
+def list_thaat() -> List[str]:
+    """List supported thaats by name.
+
+    Returns
+    -------
+    thaats : list
+        A list of supported thaats
+
+    Examples
+    --------
+    >>> librosa.list_thaat()
+    ['bilaval',
+     'khamaj',
+     'kafi',
+     'asavari',
+     'bhairavi',
+     'kalyan',
+     'marva',
+     'poorvi',
+     'todi',
+     'bhairav']
+
+    See Also
+    --------
+    list_mela
+    thaat_to_degrees
+    """
+    return list(THAAT_MAP.keys())
+
+
+@cache(level=10)
+def key_to_notes(key: str, *, unicode: bool = True) -> List[str]:
+    """Lists all 12 note names in the chromatic scale, as spelled according to
+    a given key (major or minor).
+
+    This function exists to resolve enharmonic equivalences between different
+    spellings for the same pitch (e.g. C♯ vs D♭), and is primarily useful when producing
+    human-readable outputs (e.g. plotting) for pitch content.
+
+    Note names are decided by the following rules:
+
+    1. If the tonic of the key has an accidental (sharp or flat), that accidental will be
+       used consistently for all notes.
+
+    2. If the tonic does not have an accidental, accidentals will be inferred to minimize
+       the total number used for diatonic scale degrees.
+
+    3. If there is a tie (e.g., in the case of C:maj vs A:min), sharps will be preferred.
+
+    Parameters
+    ----------
+    key : string
+        Must be in the form TONIC:key.  Tonic must be upper case (``CDEFGAB``),
+        key must be lower-case (``maj`` or ``min``).
+
+        Single accidentals (``b!♭`` for flat, or ``#♯`` for sharp) are supported.
+
+        Examples: ``C:maj, Db:min, A♭:min``.
+
+    unicode : bool
+        If ``True`` (default), use Unicode symbols (♯𝄪♭𝄫)for accidentals.
+
+        If ``False``, Unicode symbols will be mapped to low-order ASCII representations::
+
+            ♯ -> #, 𝄪 -> ##, ♭ -> b, 𝄫 -> bb
+
+    Returns
+    -------
+    notes : list
+        ``notes[k]`` is the name for semitone ``k`` (starting from C)
+        under the given key.  All chromatic notes (0 through 11) are
+        included.
+
+    See Also
+    --------
+    midi_to_note
+
+    Examples
+    --------
+    `C:maj` will use all sharps
+
+    >>> librosa.key_to_notes('C:maj')
+    ['C', 'C♯', 'D', 'D♯', 'E', 'F', 'F♯', 'G', 'G♯', 'A', 'A♯', 'B']
+
+    `A:min` has the same notes
+
+    >>> librosa.key_to_notes('A:min')
+    ['C', 'C♯', 'D', 'D♯', 'E', 'F', 'F♯', 'G', 'G♯', 'A', 'A♯', 'B']
+
+    `A♯:min` will use sharps, but spell note 0 (`C`) as `B♯`
+
+    >>> librosa.key_to_notes('A#:min')
+    ['B♯', 'C♯', 'D', 'D♯', 'E', 'E♯', 'F♯', 'G', 'G♯', 'A', 'A♯', 'B']
+
+    `G♯:maj` will use a double-sharp to spell note 7 (`G`) as `F𝄪`:
+
+    >>> librosa.key_to_notes('G#:maj')
+    ['B♯', 'C♯', 'D', 'D♯', 'E', 'E♯', 'F♯', 'F𝄪', 'G♯', 'A', 'A♯', 'B']
+
+    `F♭:min` will use double-flats
+
+    >>> librosa.key_to_notes('Fb:min')
+    ['D𝄫', 'D♭', 'E𝄫', 'E♭', 'F♭', 'F', 'G♭', 'A𝄫', 'A♭', 'B𝄫', 'B♭', 'C♭']
+    """
+
+    # Parse the key signature
+    match = KEY_RE.match(key)
+
+    if not match:
+        raise ParameterError(f"Improper key format: {key:s}")
+
+    pitch_map = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
+    acc_map = {"#": 1, "": 0, "b": -1, "!": -1, "♯": 1, "♭": -1}
+
+    tonic = match.group("tonic").upper()
+    accidental = match.group("accidental")
+    offset = acc_map[accidental]
+
+    scale = match.group("scale")[:3].lower()
+
+    # Determine major or minor
+    major = scale == "maj"
+
+    # calculate how many clockwise steps we are on CoF (== # sharps)
+    if major:
+        tonic_number = ((pitch_map[tonic] + offset) * 7) % 12
+    else:
+        tonic_number = ((pitch_map[tonic] + offset) * 7 + 9) % 12
+
+    # Decide if using flats or sharps
+    # Logic here is as follows:
+    #   1. respect the given notation for the tonic.
+    #      Sharp tonics will always use sharps, likewise flats.
+    #   2. If no accidental in the tonic, try to minimize accidentals.
+    #   3. If there's a tie for accidentals, use sharp for major and flat for minor.
+
+    if offset < 0:
+        # use flats explicitly
+        use_sharps = False
+
+    elif offset > 0:
+        # use sharps explicitly
+        use_sharps = True
+
+    elif 0 <= tonic_number < 6:
+        use_sharps = True
+
+    elif tonic_number > 6:
+        use_sharps = False
+
+    # Basic note sequences for simple keys
+    notes_sharp = ["C", "C♯", "D", "D♯", "E", "F", "F♯", "G", "G♯", "A", "A♯", "B"]
+    notes_flat = ["C", "D♭", "D", "E♭", "E", "F", "G♭", "G", "A♭", "A", "B♭", "B"]
+
+    # These apply when we have >= 6 sharps
+    sharp_corrections = [
+        (5, "E♯"),
+        (0, "B♯"),
+        (7, "F𝄪"),
+        (2, "C𝄪"),
+        (9, "G𝄪"),
+        (4, "D𝄪"),
+        (11, "A𝄪"),
+    ]
+
+    # These apply when we have >= 6 flats
+    flat_corrections = [
+        (11, "C♭"),
+        (4, "F♭"),
+        (9, "B𝄫"),
+        (2, "E𝄫"),
+        (7, "A𝄫"),
+        (0, "D𝄫"),
+    ]  # last would be (5, 'G𝄫')
+
+    # Apply a mod-12 correction to distinguish B#:maj from C:maj
+    n_sharps = tonic_number
+    if tonic_number == 0 and tonic == "B":
+        n_sharps = 12
+
+    if use_sharps:
+        # This will only execute if n_sharps >= 6
+        for n in range(0, n_sharps - 6 + 1):
+            index, name = sharp_corrections[n]
+            notes_sharp[index] = name
+
+        notes = notes_sharp
+    else:
+        n_flats = (12 - tonic_number) % 12
+
+        # This will only execute if tonic_number <= 6
+        for n in range(0, n_flats - 6 + 1):
+            index, name = flat_corrections[n]
+            notes_flat[index] = name
+
+        notes = notes_flat
+
+    # Finally, apply any unicode down-translation if necessary
+    if not unicode:
+        translations = str.maketrans({"♯": "#", "𝄪": "##", "♭": "b", "𝄫": "bb"})
+        notes = list(n.translate(translations) for n in notes)
+
+    return notes
+
+
+def key_to_degrees(key: str) -> np.ndarray:
+    """Construct the diatonic scale degrees for a given key.
+
+    Parameters
+    ----------
+    key : str
+        Must be in the form TONIC:key.  Tonic must be upper case (``CDEFGAB``),
+        key must be lower-case (``maj`` or ``min``).
+
+        Single accidentals (``b!♭`` for flat, or ``#♯`` for sharp) are supported.
+
+        Examples: ``C:maj, Db:min, A♭:min``.
+
+    Returns
+    -------
+    degrees : np.ndarray
+        An array containing the semitone numbers (0=C, 1=C#, ... 11=B)
+        for each of the seven scale degrees in the given key, starting
+        from the tonic.
+
+    See Also
+    --------
+    key_to_notes
+
+    Examples
+    --------
+    >>> librosa.key_to_degrees('C:maj')
+    array([ 0,  2,  4,  5,  7,  9, 11])
+
+    >>> librosa.key_to_degrees('C#:maj')
+    array([ 1,  3,  5,  6,  8, 10,  0])
+
+    >>> librosa.key_to_degrees('A:min')
+    array([ 9, 11,  0,  2,  4,  5,  7])
+
+    """
+    notes = dict(
+        maj=np.array([0, 2, 4, 5, 7, 9, 11]), min=np.array([0, 2, 3, 5, 7, 8, 10])
+    )
+
+    match = KEY_RE.match(key)
+
+    if not match:
+        raise ParameterError(f"Improper key format: {key:s}")
+
+    pitch_map = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11}
+    acc_map = {"#": 1, "": 0, "b": -1, "!": -1, "♯": 1, "♭": -1}
+    tonic = match.group("tonic").upper()
+    accidental = match.group("accidental")
+    offset = acc_map[accidental]
+
+    scale = match.group("scale")[:3].lower()
+
+    return (notes[scale] + pitch_map[tonic] + offset) % 12
+
+
+@cache(level=10)
+def fifths_to_note(*, unison: str, fifths: int, unicode: bool = True) -> str:
+    """Calculate the note name for a given number of perfect fifths
+    from a specified unison.
+
+    This function is primarily intended as a utility routine for
+    Functional Just System (FJS) notation conversions.
+
+    This function does not assume the "circle of fifths" or equal temperament,
+    so 12 fifths will not generally produce a note of the same pitch class
+    due to the accumulation of accidentals.
+
+    Parameters
+    ----------
+    unison : str
+        The name of the starting (unison) note, e.g., 'C' or 'Bb'.
+        Unicode accidentals are supported.
+
+    fifths : integer
+        The number of perfect fifths to deviate from unison.
+
+    unicode : bool
+        If ``True`` (default), use Unicode symbols (♯𝄪♭𝄫)for accidentals.
+
+        If ``False``, accidentals will be encoded as low-order ASCII representations::
+
+            ♯ -> #, 𝄪 -> ##, ♭ -> b, 𝄫 -> bb
+
+    Returns
+    -------
+    note : str
+        The name of the requested note
+
+    Examples
+    --------
+    >>> librosa.fifths_to_note(unison='C', fifths=6)
+    'F♯'
+
+    >>> librosa.fifths_to_note(unison='G', fifths=-3)
+    'B♭'
+
+    >>> librosa.fifths_to_note(unison='Eb', fifths=11, unicode=False)
+    'G#'
+    """
+    # Starting the circle of fifths at F makes accidentals easier to count
+    COFMAP = "FCGDAEB"
+
+    acc_map = {
+        "#": 1,
+        "": 0,
+        "b": -1,
+        "!": -1,
+        "♯": 1,
+        "𝄪": 2,
+        "♭": -1,
+        "𝄫": -2,
+        "♮": 0,
+    }
+
+    if unicode:
+        acc_map_inv = {1: "♯", 2: "𝄪", -1: "♭", -2: "𝄫", 0: ""}
+    else:
+        acc_map_inv = {1: "#", 2: "##", -1: "b", -2: "bb", 0: ""}
+
+    match = NOTE_RE.match(unison)
+
+    if not match:
+        raise ParameterError(f"Improper note format: {unison:s}")
+
+    # Find unison in the alphabet
+    pitch = match.group("note").upper()
+
+    # Find the number of accidentals to start from
+    offset = np.sum([acc_map[o] for o in match.group("accidental")])
+
+    # Find the raw target note
+    circle_idx = COFMAP.index(pitch)
+    raw_output = COFMAP[(circle_idx + fifths) % 7]
+
+    # Now how many accidentals have we accrued?
+    # Equivalently, count times we cross a B<->F boundary
+    acc_index = offset + (circle_idx + fifths) // 7
+
+    # Compress multiple-accidentals as needed
+    acc_str = acc_map_inv[np.sign(acc_index) * 2] * int(
+        abs(acc_index) // 2
+    ) + acc_map_inv[np.sign(acc_index)] * int(abs(acc_index) % 2)
+
+    return raw_output + acc_str
+
+
+@jit(nopython=True, nogil=True, cache=False)
+def __o_fold(d):
+    """Compute the octave-folded interval.
+
+    This maps intervals to the range [1, 2).
+
+    This is part of the FJS notation converter.
+    It is equivalent to the `red` function described in the FJS
+    documentation.
+    """
+    return d * (2.0 ** -np.floor(np.log2(d)))
+
+
+@jit(nopython=True, nogil=True, cache=False)
+def __bo_fold(d):
+    """Compute the balanced, octave-folded interval.
+
+    This maps intervals to the range [sqrt(2)/2, sqrt(2)).
+
+    This is part of the FJS notation converter.
+    It is equivalent to the `reb` function described in the FJS
+    documentation, but with a simpler implementation.
+    """
+    return d * (2.0 ** -np.round(np.log2(d)))
+
+
+@jit(nopython=True, nogil=True, cache=False)
+def __fifth_search(interval, tolerance):
+    """Accelerated helper function for finding the number of fifths
+    to get within tolerance of a given interval.
+
+    This implementation will give up after 32 fifths
+    """
+    log_tolerance = np.abs(np.log2(tolerance))
+    for power in range(32):
+        for sign in [1, -1]:
+            if (
+                np.abs(np.log2(__bo_fold(interval / 3.0 ** (power * sign))))
+                <= log_tolerance
+            ):
+                return power * sign
+        power += 1
+    return power
+
+
+# Translation grids for superscripts and subscripts
+SUPER_TRANS = str.maketrans("0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹")
+SUB_TRANS = str.maketrans("0123456789", "₀₁₂₃₄₅₆₇₈₉")
+
+
+@overload
+def interval_to_fjs(
+    interval: _FloatLike_co,
+    *,
+    unison: str = ...,
+    tolerance: float = ...,
+    unicode: bool = ...,
+) -> str:
+    ...
+
+
+@overload
+def interval_to_fjs(
+    interval: _SequenceLike[_FloatLike_co],
+    *,
+    unison: str = ...,
+    tolerance: float = ...,
+    unicode: bool = ...,
+) -> np.ndarray:
+    ...
+
+
+@overload
+def interval_to_fjs(
+    interval: _ScalarOrSequence[_FloatLike_co],
+    *,
+    unison: str = ...,
+    tolerance: float = ...,
+    unicode: bool = ...,
+) -> Union[str, np.ndarray]:
+    ...
+
+
+@vectorize(otypes="U", excluded=set(["unison", "tolerance", "unicode"]))
+def interval_to_fjs(
+    interval: _ScalarOrSequence[_FloatLike_co],
+    *,
+    unison: str = "C",
+    tolerance: float = 65.0 / 63,
+    unicode: bool = True,
+) -> Union[str, np.ndarray]:
+    """Convert an interval to Functional Just System (FJS) notation.
+
+    See https://misotanni.github.io/fjs/en/index.html for a thorough overview
+    of the FJS notation system, and the examples below.
+
+    FJS conversion works by identifying a Pythagorean interval which is within
+    a specified tolerance of the target interval, which provides the core note
+    name.  If the interval is derived from ratios other than perfect fifths,
+    then the remaining factors are encoded as superscripts for otonal
+    (increasing) intervals and subscripts for utonal (decreasing) intervals.
+
+    Parameters
+    ----------
+    interval : float > 0 or iterable of floats
+        A (just) interval to notate in FJS.
+
+    unison : str
+        The name of the unison note (corresponding to `interval=1`).
+
+    tolerance : float
+        The tolerance threshold for identifying the core note name.
+
+    unicode : bool
+        If ``True`` (default), use Unicode symbols (♯𝄪♭𝄫)for accidentals,
+        and superscripts/subscripts for otonal and utonal accidentals.
+
+        If ``False``, accidentals will be encoded as low-order ASCII representations::
+
+            ♯ -> #, 𝄪 -> ##, ♭ -> b, 𝄫 -> bb
+
+        Otonal and utonal accidentals will be denoted by `^##` and `_##`
+        respectively (see examples below).
+
+    Raises
+    ------
+    ParameterError
+        If the provided interval is not positive
+
+        If the provided interval cannot be identified with a
+        just intonation prime factorization.
+
+    Returns
+    -------
+    note_fjs : str or np.ndarray(dtype=str)
+        The interval(s) relative to the given unison in FJS notation.
+
+    Examples
+    --------
+    Pythagorean intervals appear as expected, with no otonal
+    or utonal extensions:
+
+    >>> librosa.interval_to_fjs(3/2, unison='C')
+    'G'
+    >>> librosa.interval_to_fjs(4/3, unison='F')
+    'B♭'
+
+    A ptolemaic major third will appear with an otonal '5':
+
+    >>> librosa.interval_to_fjs(5/4, unison='A')
+    'C♯⁵'
+
+    And a ptolemaic minor third will appear with utonal '5':
+
+    >>> librosa.interval_to_fjs(6/5, unison='A')
+    'C₅'
+
+    More complex intervals will have compound accidentals.
+    For example:
+
+    >>> librosa.interval_to_fjs(25/14, unison='F#')
+    'E²⁵₇'
+    >>> librosa.interval_to_fjs(25/14, unison='F#', unicode=False)
+    'E^25_7'
+
+    Array inputs are also supported:
+
+    >>> librosa.interval_to_fjs([3/2, 4/3, 5/3])
+    array(['G', 'F', 'A⁵'], dtype='<U2')
+
+    """
+    # suppressing the type check here because mypy won't introspect through
+    # numpy vectorization
+    if interval <= 0:  # type: ignore
+        raise ParameterError(f"Interval={interval} must be strictly positive")
+
+    # Find the approximate number of fifth-steps to get within tolerance
+    # of the target interval
+    fifths = __fifth_search(interval, tolerance)
+
+    # determine the base note name
+    note_name = fifths_to_note(unison=unison, fifths=fifths, unicode=unicode)
+
+    # Get the prime factor expansion from the interval table
+    try:
+        # Balance the interval into the octave for lookup
+        interval_b = __o_fold(interval)
+        powers = INTERVALS[np.around(interval_b, decimals=6)]
+    except KeyError as exc:
+        raise ParameterError(f"Unknown interval={interval}") from exc
+
+    # Ignore pythagorean spelling
+    powers = {p: powers[p] for p in powers if p > 3}
+
+    # Split into otonal and utonal accidentals
+    otonal = np.prod([p ** powers[p] for p in powers if powers[p] > 0])
+    utonal = np.prod([p ** -powers[p] for p in powers if powers[p] < 0])
+
+    suffix = ""
+    if otonal > 1:
+        if unicode:
+            suffix += f"{otonal:d}".translate(SUPER_TRANS)
+        else:
+            suffix += f"^{otonal}"
+
+    if utonal > 1:
+        if unicode:
+            suffix += f"{utonal:d}".translate(SUB_TRANS)
+        else:
+            suffix += f"_{utonal}"
+
+    return note_name + suffix
+