logic2ableton 2.3.2__tar.gz → 2.3.4__tar.gz

{logic2ableton-2.3.2 → logic2ableton-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logic2ableton
-Version: 2.3.2
+Version: 2.3.4
 Summary: Session transfer between Logic Pro, Ableton Live, and Pro Tools - six conversion lanes with evidence-first reports
 Author: evilander
 License-Expression: MIT
@@ -125,6 +125,8 @@ The product goal is **speed with evidence**: every run emits a report showing ex
 - Regions that start before bar 1 are moved to bar 1 (audio is trimmed by the same amount) because a Live arrangement cannot start earlier
 - Looped audio regions are written as repeated clips, spaced at the project tempo. If the tempo changes under a looped audio region, check the repeats; the report lists every region it unrolled
 - Logic tracks that share a name are kept apart by numbering the later ones (`Guitar`, `Guitar (2)`), and the report says which were renamed
+- A Live track plays one clip at a time. Where audio regions overlap on one Logic track, the later region is kept whole and the earlier one is cut around it; overlapping MIDI regions become one clip holding all their notes. The report lists each case. No real project with overlapping regions has been checked yet, so compare those spots with Logic
+- Region fades, crossfades and region gain are not transferred, so edit points are plain cuts in Live. Take folders are untested; flatten them in Logic first
 - Logic's tempo track is not decoded (only the project tempo is); supply tempo changes with `--timeline`
 - `--smpte-start` only matters for the timestamp fallback; it must then match the project's own synchronization setting (default `01:00:00:00`), and the report lists any files placed at bar 1 because their timestamp precedes it
 - Automation is not recreated

{logic2ableton-2.3.2 → logic2ableton-2.3.4}/README.md

@@ -101,6 +101,8 @@ The product goal is **speed with evidence**: every run emits a report showing ex
 - Regions that start before bar 1 are moved to bar 1 (audio is trimmed by the same amount) because a Live arrangement cannot start earlier
 - Looped audio regions are written as repeated clips, spaced at the project tempo. If the tempo changes under a looped audio region, check the repeats; the report lists every region it unrolled
 - Logic tracks that share a name are kept apart by numbering the later ones (`Guitar`, `Guitar (2)`), and the report says which were renamed
+- A Live track plays one clip at a time. Where audio regions overlap on one Logic track, the later region is kept whole and the earlier one is cut around it; overlapping MIDI regions become one clip holding all their notes. The report lists each case. No real project with overlapping regions has been checked yet, so compare those spots with Logic
+- Region fades, crossfades and region gain are not transferred, so edit points are plain cuts in Live. Take folders are untested; flatten them in Logic first
 - Logic's tempo track is not decoded (only the project tempo is); supply tempo changes with `--timeline`
 - `--smpte-start` only matters for the timestamp fallback; it must then match the project's own synchronization setting (default `01:00:00:00`), and the report lists any files placed at bar 1 because their timestamp precedes it
 - Automation is not recreated

logic2ableton-2.3.4/logic2ableton/__init__.py

@@ -0,0 +1 @@
+__version__ = "2.3.4"

{logic2ableton-2.3.2 → logic2ableton-2.3.4}/logic2ableton/logic_parser.py

@@ -8,6 +8,7 @@ from pathlib import Path
 import bisect
 from dataclasses import replace
 
+from logic2ableton.audio import read_audio_info
 from logic2ableton.logic_project_data import (
     PPQ,
     SEQUENCE_ORIGIN_TICKS,
@@ -912,6 +913,145 @@ def _unroll_regions(regions: list[LogicMidiRegion]) -> list[LogicMidiNote]:
     return notes
 
 
+def _without_stacked_notes(notes: list[LogicMidiNote]) -> list[LogicMidiNote]:
+    """Drop duplicate notes and end a note where the next one of its pitch starts."""
+    by_pitch: dict[int, list[LogicMidiNote]] = {}
+    for note in sorted(notes, key=lambda note: (note.start_beats, -note.duration_beats)):
+        same_pitch = by_pitch.setdefault(note.pitch, [])
+        if same_pitch:
+            previous = same_pitch[-1]
+            if note.start_beats - previous.start_beats < 1e-9:
+                previous.velocity = max(previous.velocity, note.velocity)
+                continue
+            previous.duration_beats = min(previous.duration_beats, note.start_beats - previous.start_beats)
+        same_pitch.append(replace(note))
+    return sorted((note for group in by_pitch.values() for note in group), key=lambda note: (note.start_beats, note.pitch))
+
+
+def _merge_overlapping_midi(regions: list[LogicMidiRegion]) -> tuple[list[LogicMidiRegion], list[str]]:
+    """Join MIDI regions that overlap on one track into a single region.
+
+    Logic plays overlapping MIDI regions together. A Live track plays one clip
+    at a time, so each overlapping group becomes one clip with every note the
+    group plays (loops unrolled). Returns the regions and the merged groups' names.
+    """
+    half_tick = 0.5 / PPQ
+    groups: list[list[LogicMidiRegion]] = []
+    group_end = 0.0
+    for region in sorted(regions, key=lambda region: region.start_beats):
+        if groups and region.start_beats < group_end - half_tick:
+            groups[-1].append(region)
+            group_end = max(group_end, region.end_beats)
+        else:
+            groups.append([region])
+            group_end = region.end_beats
+
+    out: list[LogicMidiRegion] = []
+    merged_names: list[str] = []
+    for group in groups:
+        if len(group) == 1:
+            out.append(group[0])
+            continue
+        start = group[0].start_beats
+        end = max(region.end_beats for region in group)
+        notes = _without_stacked_notes([
+            replace(note, start_beats=note.start_beats - start) for note in _unroll_regions(group)
+        ])
+        out.append(LogicMidiRegion(name=group[0].name, start_beats=start, length_beats=end - start, notes=notes))
+        merged_names.append(" + ".join(region.name for region in group))
+    return out, merged_names
+
+
+# Adjacent regions can overlap by a fraction of a tick, because positions are
+# stored in ticks and lengths in samples. Overlaps this short are trimmed
+# without a report line.
+_OVERLAP_REPORT_BEATS = 0.01
+
+
+def _cut_overlapping_audio(refs: list[AudioFileRef], *, tempo: float, warnings: list[str]) -> list[AudioFileRef]:
+    """Cut audio regions that overlap on one track so no two clips overlap.
+
+    A Logic audio track plays one region at a time, and where two overlap the
+    one that starts later plays. A Live track holds one clip at a time, so the
+    earlier region is cut where the later one starts. If the earlier region
+    runs past the end of the later one, that remainder is kept as its own
+    clip: whether Logic plays it has not been checked against a real project,
+    and a clip that can be deleted is easier to deal with than missing audio.
+    Every cut is reported.
+    """
+    spans: list[tuple[float, float, float]] = []
+    by_track: dict[str, list[int]] = {}
+    for index, ref in enumerate(refs):
+        samples_per_beat = 60.0 / tempo * _get_audio_sample_rate(ref.file_path)
+        length = ref.content_duration_samples
+        if length is None:
+            try:
+                length = max(0, read_audio_info(ref.file_path).frame_count - ref.content_offset_samples)
+            except (OSError, ValueError):
+                length = 0
+        spans.append((ref.start_beats, ref.start_beats + length / samples_per_beat, samples_per_beat))
+        by_track.setdefault(ref.track_name, []).append(index)
+
+    pieces_by_index: dict[int, list[tuple[float, float]]] = {}
+    cut: list[str] = []
+    for indices in by_track.values():
+        ordered = sorted(indices, key=lambda index: (spans[index][0], index))
+        for position, index in enumerate(ordered):
+            start, end, _ = spans[index]
+            pieces = [(start, end)]
+            first_later: int | None = None
+            for later in ordered[position + 1:]:
+                later_start, later_end, _ = spans[later]
+                if later_end <= later_start or later_start >= end - 1e-9:
+                    continue
+                first_later = later if first_later is None else first_later
+                remaining: list[tuple[float, float]] = []
+                for piece_start, piece_end in pieces:
+                    if later_end <= piece_start or later_start >= piece_end:
+                        remaining.append((piece_start, piece_end))
+                        continue
+                    if later_start > piece_start:
+                        remaining.append((piece_start, later_start))
+                    if later_end < piece_end:
+                        remaining.append((later_end, piece_end))
+                pieces = remaining
+            if pieces == [(start, end)]:
+                continue
+            pieces_by_index[index] = pieces
+            if (end - start) - sum(piece_end - piece_start for piece_start, piece_end in pieces) >= _OVERLAP_REPORT_BEATS:
+                ref, later_ref = refs[index], refs[first_later]
+                cut.append(
+                    f"{ref.track_name}: {ref.clip_name or ref.filename} under {later_ref.clip_name or later_ref.filename}"
+                )
+
+    if not pieces_by_index:
+        return refs
+    out: list[AudioFileRef] = []
+    for index, ref in enumerate(refs):
+        if index not in pieces_by_index:
+            out.append(ref)
+            continue
+        start, _, samples_per_beat = spans[index]
+        for piece_start, piece_end in pieces_by_index[index]:
+            if piece_end - piece_start < _OVERLAP_REPORT_BEATS:
+                continue
+            out.append(replace(
+                ref,
+                start_position_samples=max(0, round(piece_start * samples_per_beat)),
+                content_offset_samples=ref.content_offset_samples + round((piece_start - start) * samples_per_beat),
+                content_duration_samples=int((piece_end - piece_start) * samples_per_beat + 1e-6),
+                start_beats=piece_start,
+            ))
+    if cut:
+        examples = ", ".join(cut[:5]) + (", ..." if len(cut) > 5 else "")
+        warnings.append(
+            f"{len(cut)} audio region(s) overlap a later region on the same track. A track plays one clip at a "
+            f"time, so the later region was kept whole and the earlier one cut around it; compare these with "
+            f"Logic: {examples}"
+        )
+    return out
+
+
 def _unique_track_names(arrangement: LogicArrangement, warnings: list[str]) -> dict[int, str]:
     """Display name per Logic track id, numbering tracks that share a name.
 
@@ -971,6 +1111,7 @@ def _arrangement_midi_tracks(
 
     tracks: list[LogicMidiTrack] = []
     muted: list[str] = []
+    merged: list[str] = []
     for track_id, placements in sorted(
         by_track.items(), key=lambda item: (min(p.lane for p in item[1]), min(p.tick for p in item[1]))
     ):
@@ -1014,7 +1155,15 @@ def _arrangement_midi_tracks(
                 loop_span_beats=placement.loop_span / PPQ if placement.looped else None,
             ))
         if regions:
+            regions, merged_names = _merge_overlapping_midi(regions)
+            merged.extend(f"{track_name}: {names}" for names in merged_names)
             tracks.append(LogicMidiTrack(name=track_name, notes=_unroll_regions(regions), regions=regions))
+    if merged:
+        examples = ", ".join(merged[:5]) + (", ..." if len(merged) > 5 else "")
+        warnings.append(
+            f"{len(merged)} group(s) of overlapping MIDI regions were each written as one clip holding all "
+            f"their notes, because a Live track plays one clip at a time: {examples}"
+        )
     if muted:
         examples = ", ".join(muted[:5]) + (", ..." if len(muted) > 5 else "")
         warnings.append(f"Skipped {len(muted)} muted MIDI region(s) as Logic would not play them: {examples}")
@@ -1107,6 +1256,7 @@ def _arrangement_audio_refs(
                 start_beats=pass_start,
             ))
             lanes.setdefault(track_name, placement.lane)
+    refs = _cut_overlapping_audio(refs, tempo=tempo, warnings=warnings)
     if looped:
         examples = ", ".join(looped[:5]) + (", ..." if len(looped) > 5 else "")
         warnings.append(

{logic2ableton-2.3.2 → logic2ableton-2.3.4}/logic2ableton/logic_project_data.py

@@ -35,6 +35,11 @@ and later) and a u32 payload size. The objects read here:
   first id is the AuFl id; the second id tells apart regions cut from one
   file.
 
+The file opens with a ``Song`` object (its payload holds the header fields
+read below). A project saved with undo history has further ``Song`` objects
+after the current state, one per history step, each followed by old copies of
+the objects that step changed; decoding stops at the second ``Song``.
+
 Ticks are 960 per quarter note and three tick frames coexist: note ticks are
 region-relative with the content origin at 38400; marker ticks count from
 38400 = bar 1; region placements count from 34560 = the project start, whose
@@ -175,6 +180,7 @@ class LogicArrangement:
     audio_files: dict[int, str] = field(default_factory=dict)
     audio_regions: dict[tuple[int, int], LogicAudioRegion] = field(default_factory=dict)
     warnings: list[str] = field(default_factory=list)
+    history_steps: int = 0  # undo-history snapshots found after the current state and ignored
 
     @property
     def regions(self) -> list[LogicPlacement]:
@@ -435,6 +441,16 @@ def decode_project_data(data: bytes, *, beats_per_bar: float = 4.0) -> LogicArra
     objects = scan_objects(data)
     if not objects:
         return arrangement
+    # A project saved with undo history carries one extra Song object per
+    # history step, each followed by the old copies of whatever that step
+    # changed (arrangement sequences, regions, tracks, audio regions). Only
+    # the objects before the second Song are the project's current state;
+    # reading the rest would stack every past arrangement on top of it and let
+    # stale names and trims overwrite current ones.
+    song_offsets = [obj.offset for obj in objects if obj.tag == "Song"]
+    if len(song_offsets) > 1:
+        arrangement.history_steps = len(song_offsets) - 1
+        objects = [obj for obj in objects if obj.offset < song_offsets[1]]
     arrangement.format_version = max(set(obj.version for obj in objects), key=[obj.version for obj in objects].count)
     arrangement.sequences = _sequences(data, objects)
     arrangement.track_names = _track_names(data, objects)

{logic2ableton-2.3.2 → logic2ableton-2.3.4}/logic2ableton.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: logic2ableton
-Version: 2.3.2
+Version: 2.3.4
 Summary: Session transfer between Logic Pro, Ableton Live, and Pro Tools - six conversion lanes with evidence-first reports
 Author: evilander
 License-Expression: MIT
@@ -125,6 +125,8 @@ The product goal is **speed with evidence**: every run emits a report showing ex
 - Regions that start before bar 1 are moved to bar 1 (audio is trimmed by the same amount) because a Live arrangement cannot start earlier
 - Looped audio regions are written as repeated clips, spaced at the project tempo. If the tempo changes under a looped audio region, check the repeats; the report lists every region it unrolled
 - Logic tracks that share a name are kept apart by numbering the later ones (`Guitar`, `Guitar (2)`), and the report says which were renamed
+- A Live track plays one clip at a time. Where audio regions overlap on one Logic track, the later region is kept whole and the earlier one is cut around it; overlapping MIDI regions become one clip holding all their notes. The report lists each case. No real project with overlapping regions has been checked yet, so compare those spots with Logic
+- Region fades, crossfades and region gain are not transferred, so edit points are plain cuts in Live. Take folders are untested; flatten them in Logic first
 - Logic's tempo track is not decoded (only the project tempo is); supply tempo changes with `--timeline`
 - `--smpte-start` only matters for the timestamp fallback; it must then match the project's own synchronization setting (default `01:00:00:00`), and the report lists any files placed at bar 1 because their timestamp precedes it
 - Automation is not recreated

{logic2ableton-2.3.2 → logic2ableton-2.3.4}/tests/test_arrangement_regressions.py

@@ -178,3 +178,158 @@ def test_generation_failure_is_written_into_the_saved_report(tmp_path, capsys):
     saved = Path(event["report_path"]).read_text(encoding="utf-8")
     assert "CONVERSION FAILED" in saved and "No AudioTrack found" in saved
     assert "TRACKS TRANSFERRED" in saved  # the analysis report is kept
+
+
+def test_undo_history_snapshots_are_not_read_as_the_current_arrangement(tmp_path):
+    """Logic keeps undo history in the save: extra Song objects followed by old copies of
+    whatever each step changed. Only the state before the second Song is current."""
+    old_state = dict(
+        tracks={1: "Gtr old name"},
+        sequences=[{"id": 44, "name": "Riff", "length": 3840, "notes": [(0, 40, 90, 240), (960, 41, 90, 240)]}],
+        midi_regions=[{"bar": 9, "track": 2, "sequence": 44, "lane": 2}],
+        audio_files={10: "Guitar.wav"},
+        audio_regions=[{"file": 10, "index": 0, "name": "Old trim", "offset": 0, "length": RATE}],
+        audio_placements=[{"bar": 5, "track": 1, "file": 10, "lane": 1}],
+        markers=[(17, 12, "Old marker")],
+    )
+    data = build_logic_arrangement_project_data(
+        tracks={1: "Guitar", 2: "Keys"},
+        sequences=[{"id": 44, "name": "Riff", "length": 3840, "notes": [(0, 60, 100, 240)]}],
+        midi_regions=[{"bar": 2, "track": 2, "sequence": 44, "lane": 2}],
+        audio_files={10: "Guitar.wav"},
+        audio_regions=[{"file": 10, "index": 0, "name": "Middle", "offset": 2 * RATE, "length": 2 * RATE}],
+        audio_placements=[{"bar": 3, "track": 1, "file": 10, "lane": 1}],
+        markers=[(5, 12, "Verse")],
+        history=[old_state, old_state, old_state],
+    )
+    arrangement = decode_project_data(data)
+    assert arrangement.history_steps == 3
+    assert len(arrangement.regions) == 2
+    assert arrangement.track_names == {1: "Guitar", 2: "Keys"}
+
+    logicx = build_synthetic_logicx(tmp_path / "source", project_data=data)
+    _three_level_wav(logicx / "Media" / "Audio Files" / "Guitar.wav")
+    project = parse_logic_project(logicx)
+
+    assert [(c.track_name, c.clip_name, c.start_beats, c.content_offset_samples) for c in project.audio_files] == [
+        ("Guitar", "Middle", 8.0, 2 * RATE),
+    ]
+    assert [(t.name, len(t.regions), t.regions[0].start_beats) for t in project.midi_tracks] == [("Keys", 1, 4.0)]
+    assert [(n.pitch, n.start_beats) for n in project.midi_tracks[0].notes] == [(60, 4.0)]
+    assert [(m.beat, m.name) for m in project.timeline.markers] == [(16.0, "Verse")]
+
+
+def _overlap_project(tmp_path: Path, *, audio_regions, audio_placements, sequences=(), midi_regions=()) -> Path:
+    """A 120 BPM project (two beats per second) over a 12-second Guitar.wav."""
+    data = build_logic_arrangement_project_data(
+        tracks={1: "Guitar", 2: "Keys"},
+        sequences=list(sequences),
+        midi_regions=list(midi_regions),
+        audio_files={10: "Guitar.wav"},
+        audio_regions=audio_regions,
+        audio_placements=audio_placements,
+    )
+    logicx = build_synthetic_logicx(tmp_path / "source", project_data=data)
+    wav = logicx / "Media" / "Audio Files" / "Guitar.wav"
+    wav.parent.mkdir(parents=True, exist_ok=True)
+    with wave.open(str(wav), "wb") as handle:
+        handle.setparams((1, 2, RATE, 0, "NONE", "not compressed"))
+        handle.writeframes(struct.pack("<h", 1000) * RATE * 12)
+    return logicx
+
+
+def test_audio_region_on_top_of_a_longer_one_cuts_it_instead_of_overlapping(tmp_path):
+    # "Long" covers beats 0-16; "Patch" is dropped on top of it at beats 4-8.
+    logicx = _overlap_project(
+        tmp_path,
+        audio_regions=[
+            {"file": 10, "index": 0, "name": "Long", "offset": 0, "length": 8 * RATE},
+            {"file": 10, "index": 1, "name": "Patch", "offset": 8 * RATE, "length": 2 * RATE},
+        ],
+        audio_placements=[
+            {"bar": 1, "track": 1, "file": 10, "lane": 1},
+            {"bar": 2, "track": 1, "file": 10, "lane": 1, "index": 1},
+        ],
+    )
+    project = parse_logic_project(logicx)
+
+    clips = sorted((c.start_beats, c.clip_name, c.content_offset_samples, c.content_duration_samples) for c in project.audio_files)
+    assert clips == [
+        (0.0, "Long", 0, 2 * RATE),
+        (4.0, "Patch", 8 * RATE, 2 * RATE),
+        (8.0, "Long", 4 * RATE, 4 * RATE),
+    ]
+    assert any("Guitar: Long under Patch" in warning for warning in project.compatibility_warnings)
+
+    als = generate_als(project, tmp_path / "out", copy_audio=False, template_path=_BUNDLED_TEMPLATE)
+    rendered = sorted((c.start_beats, c.end_beats) for c in parse_ableton_project(als).clips)
+    assert rendered == [(0.0, 4.0), (4.0, 8.0), (8.0, 16.0)]
+
+
+def test_audio_region_running_into_the_next_one_ends_where_it_starts(tmp_path):
+    logicx = _overlap_project(
+        tmp_path,
+        audio_regions=[
+            {"file": 10, "index": 0, "name": "First", "offset": 0, "length": 4 * RATE},
+            {"file": 10, "index": 1, "name": "Second", "offset": 6 * RATE, "length": 4 * RATE},
+        ],
+        audio_placements=[
+            {"bar": 1, "track": 1, "file": 10, "lane": 1},
+            {"bar": 2, "track": 1, "file": 10, "lane": 1, "index": 1},
+        ],
+    )
+    project = parse_logic_project(logicx)
+
+    clips = [(c.start_beats, c.clip_name, c.content_offset_samples, c.content_duration_samples) for c in project.audio_files]
+    assert clips == [(0.0, "First", 0, 2 * RATE), (4.0, "Second", 6 * RATE, 4 * RATE)]
+
+
+def test_regions_that_only_touch_are_left_alone(tmp_path):
+    logicx = _overlap_project(
+        tmp_path,
+        audio_regions=[
+            {"file": 10, "index": 0, "name": "First", "offset": 0, "length": 2 * RATE},
+            {"file": 10, "index": 1, "name": "Second", "offset": 2 * RATE, "length": 2 * RATE},
+        ],
+        audio_placements=[
+            {"bar": 1, "track": 1, "file": 10, "lane": 1},
+            {"bar": 2, "track": 1, "file": 10, "lane": 1, "index": 1},
+            # the same slice again on another track at the same time is not an overlap
+            {"bar": 1, "track": 2, "file": 10, "lane": 2},
+        ],
+    )
+    project = parse_logic_project(logicx)
+
+    clips = sorted((c.track_name, c.start_beats, c.content_offset_samples, c.content_duration_samples) for c in project.audio_files)
+    assert clips == [("Guitar", 0.0, 0, 2 * RATE), ("Guitar", 4.0, 2 * RATE, 2 * RATE), ("Keys", 0.0, 0, 2 * RATE)]
+    assert not any("overlap" in warning for warning in project.compatibility_warnings)
+
+
+def test_overlapping_midi_regions_become_one_clip_with_all_their_notes(tmp_path):
+    # A four-bar region with a note on every beat, and a one-bar region laid over its second bar.
+    logicx = _overlap_project(
+        tmp_path,
+        audio_regions=[],
+        audio_placements=[],
+        sequences=[
+            {"id": 44, "name": "Long", "length": 4 * 3840, "notes": [(960 * beat, 60, 100, 240) for beat in range(16)]},
+            {"id": 45, "name": "Short", "length": 3840, "notes": [(0, 72, 90, 240), (0, 60, 127, 240)]},
+        ],
+        midi_regions=[
+            {"bar": 1, "track": 2, "sequence": 44, "lane": 2},
+            {"bar": 2, "track": 2, "sequence": 45, "lane": 2},
+        ],
+    )
+    project = parse_logic_project(logicx)
+
+    track = project.midi_tracks[0]
+    assert [(r.start_beats, r.end_beats, r.is_looping) for r in track.regions] == [(0.0, 16.0, False)]
+    # 16 notes from the long region, one new pitch from the short one; the doubled note at beat 4 is kept once
+    assert len(track.notes) == 17
+    assert [(n.pitch, n.velocity) for n in track.notes if n.start_beats == 4.0] == [(60, 127), (72, 90)]
+    assert any("Keys: Long + Short" in warning for warning in project.compatibility_warnings)
+
+    als = generate_als(project, tmp_path / "out", copy_audio=False, template_path=_BUNDLED_TEMPLATE)
+    root = ET.fromstring(gzip.decompress(als.read_bytes()))
+    clips = root.findall(".//Tracks/MidiTrack//ArrangerAutomation/Events/MidiClip")
+    assert [(c.find("CurrentStart").get("Value"), c.find("CurrentEnd").get("Value")) for c in clips] == [("0", "16")]

logic2ableton-2.3.2/logic2ableton/__init__.py

@@ -1 +0,0 @@
-__version__ = "2.3.2"