Sweep(slow): Review the codebase and make suggestions to make the code more readable and Pythonic

[axeldelafosse]

Please focus on the following files:

• ableton.py
• stem.py
• stemgen.py

Bonus points if you unify the programming style across those files. Thank you!

[sweep-ai]

Here's the PR! #24.

⚡ Sweep Free Trial: I used GPT-4 to create this ticket. You have 3 GPT-4 tickets left. For more GPT-4 tickets, visit our payment portal.

• Install Sweep Configs: Pull Request

---

Step 1: 🔍 Code Search

I found the following snippets in your repository. I will now analyze these snippets and come up with a plan.

Some code snippets I looked at (click to expand). If some file is missing from here, you can mention the path in the ticket description.

stemgen/stemgen.py

Lines 1 to 405 in 1fe4ccb

	#!/usr/bin/env python3
	import argparse
	import os
	import platform
	import shutil
	import sys
	import subprocess
	from pathlib import Path
	import time
	import unicodedata
	from metadata import get_cover, get_metadata
	LOGO = r"""
	_____ _____ _____ _____ _____ _____ _____
	| __|_ _| __| | __| __| | |
	|__ | | | | __| | | | | | __| | | |
	|_____| |_| |_____|_|_|_|_____|_____|_|___|
	"""
	SUPPORTED_FILES = [".wave", ".wav", ".aiff", ".aif", ".flac"]
	REQUIRED_PACKAGES = ["ffmpeg", "sox"]
	USAGE = f"""{LOGO}
	Stemgen is a Stem file generator. Convert any track into a stem and have fun with Traktor.
	Usage: python3 stemgen.py -i [INPUT_PATH] -o [OUTPUT_PATH]
	Supported input file format: {SUPPORTED_FILES}
	"""
	VERSION = "5.0.0"
	parser = argparse.ArgumentParser(
	description=USAGE, formatter_class=argparse.RawTextHelpFormatter
	)
	parser.add_argument(
	"-i", dest="INPUT_PATH", required=True, help="the path to the input file"
	)
	parser.add_argument(
	"-o", dest="OUTPUT_PATH", default="output", help="the path to the output folder"
	)
	parser.add_argument("-f", dest="FORMAT", default="alac", help="aac or alac")
	parser.add_argument("-v", "--version", action="version", version=VERSION)
	args = parser.parse_args()
	INPUT_PATH = args.INPUT_PATH
	OUTPUT_PATH = args.OUTPUT_PATH
	FORMAT = args.FORMAT
	DIR = Path(__file__).parent.absolute()
	PYTHON_EXEC = sys.executable if not None else "python3"
	# CONVERSION AND GENERATION
	def convert():
	print("Converting to wav and/or downsampling...")
	# We downsample to 44.1kHz to avoid problems with the separation software
	# because the models are trained on 44.1kHz audio files
	# QUALITY WIDTH REJ dB TYPICAL USE
	# -v very high 95% 175 24-bit mastering
	# -M/-I/-L Phase response = minimum/intermediate/linear(default)
	# -s Steep filter (band-width = 99%)
	# -a Allow aliasing above the pass-band
	global BIT_DEPTH
	global SAMPLE_RATE
	converted_file_path = os.path.join(OUTPUT_PATH, FILE_NAME, FILE_NAME + ".wav")
	if BIT_DEPTH == 32:
	# Downconvert to 24-bit
	if FILE_PATH == converted_file_path:
	subprocess.run(
	[
	"sox",
	FILE_PATH,
	"--show-progress",
	"-b",
	"24",
	os.path.join(OUTPUT_PATH, FILE_NAME, FILE_NAME + ".24bit.wav"),
	"rate",
	"-v",
	"-a",
	"-I",
	"-s",
	"44100",
	],
	check=True,
	)
	os.remove(converted_file_path)
	os.rename(
	os.path.join(OUTPUT_PATH, FILE_NAME, FILE_NAME + ".24bit.wav"),
	converted_file_path,
	)
	else:
	subprocess.run(
	[
	"sox",
	FILE_PATH,
	"--show-progress",
	"-b",
	"24",
	converted_file_path,
	"rate",
	"-v",
	"-a",
	"-I",
	"-s",
	"44100",
	],
	check=True,
	)
	BIT_DEPTH = 24
	else:
	if (
	FILE_EXTENSION == ".wav" or FILE_EXTENSION == ".wave"
	) and SAMPLE_RATE == 44100:
	print("No conversion needed.")
	else:
	if FILE_PATH == converted_file_path:
	subprocess.run(
	[
	"sox",
	FILE_PATH,
	"--show-progress",
	"--no-dither",
	os.path.join(
	OUTPUT_PATH, FILE_NAME, FILE_NAME + ".44100Hz.wav"
	),
	"rate",
	"-v",
	"-a",
	"-I",
	"-s",
	"44100",
	],
	check=True,
	)
	os.remove(converted_file_path)
	os.rename(
	os.path.join(OUTPUT_PATH, FILE_NAME, FILE_NAME + ".44100Hz.wav"),
	converted_file_path,
	)
	else:
	subprocess.run(
	[
	"sox",
	FILE_PATH,
	"--show-progress",
	"--no-dither",
	converted_file_path,
	"rate",
	"-v",
	"-a",
	"-I",
	"-s",
	"44100",
	],
	check=True,
	)
	print("Done.")
	def split_stems():
	print("Splitting stems...")
	if BIT_DEPTH == 24:
	print("Using 24-bit model...")
	subprocess.run(
	[
	PYTHON_EXEC,
	"-m",
	"demucs",
	"--int24",
	"-n",
	"htdemucs",
	"-d",
	"cpu",
	FILE_PATH,
	"-o",
	f"{OUTPUT_PATH}/{FILE_NAME}",
	]
	)
	else:
	print("Using 16-bit model...")
	subprocess.run(
	[
	PYTHON_EXEC,
	"-m",
	"demucs",
	"-n",
	"htdemucs",
	"-d",
	"cpu",
	FILE_PATH,
	"-o",
	f"{OUTPUT_PATH}/{FILE_NAME}",
	]
	)
	print("Done.")
	def create_stem():
	print("Creating stem...")
	cd_root()
	stem_args = [PYTHON_EXEC, "ni-stem/ni-stem", "create", "-s"]
	stem_args += [
	f"{OUTPUT_PATH}/{FILE_NAME}/htdemucs/{FILE_NAME}/drums.wav",
	f"{OUTPUT_PATH}/{FILE_NAME}/htdemucs/{FILE_NAME}/bass.wav",
	f"{OUTPUT_PATH}/{FILE_NAME}/htdemucs/{FILE_NAME}/other.wav",
	f"{OUTPUT_PATH}/{FILE_NAME}/htdemucs/{FILE_NAME}/vocals.wav",
	]
	stem_args += [
	"-x",
	f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME}.wav",
	"-t",
	f"{OUTPUT_PATH}/{FILE_NAME}/tags.json",
	"-m",
	"metadata.json",
	"-f",
	FORMAT,
	]
	subprocess.run(stem_args)
	print("Done.")
	# SETUP
	def cd_root():
	os.chdir(DIR)
	def setup():
	for package in REQUIRED_PACKAGES:
	if not shutil.which(package):
	print(f"Please install {package} before running Stemgen.")
	sys.exit(2)
	if (
	subprocess.run(
	[PYTHON_EXEC, "-m", "demucs", "-h"], capture_output=True, text=True
	).stdout.strip()
	== ""
	):
	print("Please install demucs before running Stemgen.")
	sys.exit(2)
	if not os.path.exists(OUTPUT_PATH):
	os.mkdir(OUTPUT_PATH)
	print("Output dir created.")
	else:
	print("Output dir already exists.")
	global BASE_PATH, FILE_EXTENSION
	BASE_PATH = os.path.basename(INPUT_PATH)
	FILE_EXTENSION = os.path.splitext(BASE_PATH)[1]
	if FILE_EXTENSION not in SUPPORTED_FILES:
	print("Invalid input file format. File should be one of:", SUPPORTED_FILES)
	sys.exit(1)
	setup_file()
	get_bit_depth()
	get_sample_rate()
	get_cover(FILE_EXTENSION, FILE_PATH, OUTPUT_PATH, FILE_NAME)
	get_metadata(DIR, FILE_PATH, OUTPUT_PATH, FILE_NAME)
	convert()
	print("Ready!")
	def run():
	print(f"Creating a Stem file for {FILE_NAME}...")
	split_stems()
	create_stem()
	clean_dir()
	print("Success! Have fun :)")
	def get_bit_depth():
	print("Extracting bit depth...")
	global BIT_DEPTH
	if FILE_EXTENSION == ".flac":
	BIT_DEPTH = int(
	subprocess.check_output(
	[
	"ffprobe",
	"-v",
	"error",
	"-select_streams",
	"a",
	"-show_entries",
	"stream=bits_per_raw_sample",
	"-of",
	"default=noprint_wrappers=1:nokey=1",
	FILE_PATH,
	]
	)
	)
	else:
	BIT_DEPTH = int(
	subprocess.check_output(
	[
	"ffprobe",
	"-v",
	"error",
	"-select_streams",
	"a",
	"-show_entries",
	"stream=bits_per_sample",
	"-of",
	"default=noprint_wrappers=1:nokey=1",
	FILE_PATH,
	]
	)
	)
	print(f"bits_per_sample={BIT_DEPTH}")
	print("Done.")
	def get_sample_rate():
	print("Extracting sample rate...")
	global SAMPLE_RATE
	SAMPLE_RATE = int(
	subprocess.check_output(
	[
	"ffprobe",
	"-v",
	"error",
	"-select_streams",
	"a",
	"-show_entries",
	"stream=sample_rate",
	"-of",
	"default=noprint_wrappers=1:nokey=1",
	FILE_PATH,
	]
	)
	)
	print(f"sample_rate={SAMPLE_RATE}")
	print("Done.")
	def strip_accents(text):
	text = unicodedata.normalize("NFKD", text)
	text = text.encode("ascii", "ignore")
	text = text.decode("utf-8")
	return str(text)
	def setup_file():
	global FILE_NAME, INPUT_FOLDER, FILE_PATH
	FILE_NAME = strip_accents(BASE_PATH.removesuffix(FILE_EXTENSION))
	INPUT_FOLDER = os.path.dirname(INPUT_PATH)
	if os.path.exists(f"{OUTPUT_PATH}/{FILE_NAME}"):
	print("Working dir already exists.")
	else:
	os.mkdir(f"{OUTPUT_PATH}/{FILE_NAME}")
	print("Working dir created.")
	shutil.copy(INPUT_PATH, f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME}{FILE_EXTENSION}")
	FILE_PATH = f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME}{FILE_EXTENSION}"
	print("Done.")
	def clean_dir():
	print("Cleaning...")
	if platform.system() == "Windows":
	time.sleep(5)
	os.chdir(os.path.join(OUTPUT_PATH, FILE_NAME))
	if os.path.isfile(f"{FILE_NAME}.stem.m4a"):
	os.rename(f"{FILE_NAME}.stem.m4a", os.path.join("..", f"{FILE_NAME}.stem.m4a"))
	shutil.rmtree(os.path.join(DIR, OUTPUT_PATH + "/" + FILE_NAME))
	input_dir = os.path.join(DIR, INPUT_FOLDER)
	for file in os.listdir(input_dir):
	if file.endswith(".m4a"):
	os.remove(os.path.join(input_dir, file))
	print("Done.")
	cd_root()
	setup()
	run()

stemgen/ableton.py

Lines 1 to 92 in 1fe4ccb

	#!/usr/bin/env python3
	# Stemgen for Ableton Live
	# Installation:
	# `pip install opencv-python`
	# Only on macOS: `pip install pyobjc-core`
	# Only on macOS: `pip install pyobjc`
	# `pip install pyautogui`
	# `pip install pylive`
	# Also install https://github.com/ideoforms/AbletonOSC as a Remote Script
	# Only on Windows: you can install https://github.com/p-groarke/wsay/releases to get audio feedback
	# Usage:
	# Open Ableton Live
	# Open the project you want to export
	# Check your export settings and make sure that the export folder is set to "stemgen/input"
	# Solo the tracks you want to export as stems
	# Run `python3 ableton.py`
	# Enter the name of the file
	# Don't touch your computer until it's done
	# Enjoy your stems!
	import os
	import platform
	import sys
	import subprocess
	import live
	import pyautogui
	import time
	import logging
	from metadata import create_metadata_json, ableton_color_index_to_hex
	# Settings
	NAME = "track"
	IS_RETINA = False
	OS = "windows" if platform.system() == "Windows" else "macos"
	PYTHON_EXEC = sys.executable if not None else "python3"
	STEMS = []
	# https://github.com/asweigart/pyautogui/issues/790
	if OS == "macos":
	import pyscreeze
	import PIL
	__PIL_TUPLE_VERSION = tuple(int(x) for x in PIL.__version__.split("."))
	pyscreeze.PIL__version__ = __PIL_TUPLE_VERSION
	def say(text):
	if OS == "windows":
	os.system("wsay " + text)
	else:
	os.system("say " + text)
	return
	# Switch to Ableton Live
	def switch_to_ableton():
	print("Looking for Ableton Live...")
	if OS == "windows":
	ableton = pyautogui.getWindowsWithTitle("Ableton Live")[0]
	if ableton != None:
	print("Found it!")
	ableton.activate()
	ableton.maximize()
	return
	pyautogui.keyDown("command")
	pyautogui.press("tab")
	time.sleep(1)
	x, y = pyautogui.locateCenterOnScreen(
	"screenshots/" + OS + "/logo.png", confidence=0.9
	)
	print("Found it!")
	if IS_RETINA == True:
	x = x / 2
	y = y / 2
	pyautogui.moveTo(x, y)
	pyautogui.keyUp("command")
	return
	# Export a track based on a solo location
	def export(track, position):
	# Solo the track (if not exporting master)
	if position != 0:
	track.solo = True
	# Get the track name and color
	print(track.name)
	name = track.name
	color = ableton_color_index_to_hex[track.color_index]

stemgen/stem.py

Lines 122 to 251 in 1fe4ccb

	]
	stem_args += [
	"-x",
	INPUT_PATH,
	"-t",
	f"{OUTPUT_PATH}/{FILE_NAME}/tags.json",
	"-m",
	"metadata.part2.json",
	"-f",
	FORMAT,
	"-o",
	f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME} [part 2].stem.m4a",
	]
	subprocess.run(stem_args)
	else:
	stem_args = [PYTHON_EXEC, "ni-stem/ni-stem", "create", "-s"]
	stem_args += [
	f"{INPUT_FOLDER}/{FILE_NAME}.1{FILE_EXTENSION}",
	f"{INPUT_FOLDER}/{FILE_NAME}.2{FILE_EXTENSION}",
	f"{INPUT_FOLDER}/{FILE_NAME}.3{FILE_EXTENSION}",
	f"{INPUT_FOLDER}/{FILE_NAME}.4{FILE_EXTENSION}",
	]
	stem_args += [
	"-x",
	INPUT_PATH,
	"-t",
	f"{OUTPUT_PATH}/{FILE_NAME}/tags.json",
	"-m",
	"metadata.json",
	"-f",
	FORMAT,
	"-o",
	f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME}.stem.m4a",
	]
	subprocess.run(stem_args)
	print("Done.")
	# SETUP
	def cd_root():
	os.chdir(DIR)
	def setup():
	for package in REQUIRED_PACKAGES:
	if not shutil.which(package):
	print(f"Please install {package} before running Stem.")
	sys.exit(2)
	if not os.path.exists("ni-stem/ni-stem"):
	print("Please install ni-stem before running Stem.")
	sys.exit(2)
	if not os.path.exists(OUTPUT_PATH):
	os.mkdir(OUTPUT_PATH)
	print("Output dir created.")
	else:
	print("Output dir already exists.")
	global BASE_PATH, FILE_EXTENSION
	BASE_PATH = os.path.basename(INPUT_PATH)
	FILE_EXTENSION = os.path.splitext(BASE_PATH)[1]
	if FILE_EXTENSION not in SUPPORTED_FILES:
	print("Invalid input file format. File should be one of:", SUPPORTED_FILES)
	sys.exit(1)
	setup_file()
	get_cover(FILE_EXTENSION, FILE_PATH, OUTPUT_PATH, FILE_NAME)
	get_metadata(DIR, FILE_PATH, OUTPUT_PATH, FILE_NAME)
	print("Ready!")
	def run():
	print(f"Creating a Stem file for {FILE_NAME}...")
	create_stem()
	clean_dir()
	print("Success! Have fun :)")
	def strip_accents(text):
	text = unicodedata.normalize("NFKD", text)
	text = text.encode("ascii", "ignore")
	text = text.decode("utf-8")
	return str(text)
	def setup_file():
	global FILE_NAME, INPUT_FOLDER, FILE_PATH
	FILE_NAME = BASE_PATH.removesuffix(FILE_EXTENSION).removesuffix(".0")
	INPUT_FOLDER = os.path.dirname(INPUT_PATH)
	if os.path.exists(f"{OUTPUT_PATH}/{FILE_NAME}"):
	print("Working dir already exists.")
	else:
	os.mkdir(f"{OUTPUT_PATH}/{FILE_NAME}")
	print("Working dir created.")
	shutil.copy(INPUT_PATH, f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME}{FILE_EXTENSION}")
	FILE_PATH = f"{OUTPUT_PATH}/{FILE_NAME}/{FILE_NAME}{FILE_EXTENSION}"
	print("Done.")
	def clean_dir():
	print("Cleaning...")
	if platform.system() == "Windows":
	time.sleep(5)
	os.chdir(os.path.join(OUTPUT_PATH, FILE_NAME))
	if os.path.isfile(f"{FILE_NAME}.stem.m4a"):
	os.rename(f"{FILE_NAME}.stem.m4a", os.path.join("..", f"{FILE_NAME}.stem.m4a"))
	if os.path.isfile(f"{FILE_NAME} [part 1].stem.m4a"):
	os.rename(
	f"{FILE_NAME} [part 1].stem.m4a",
	os.path.join("..", f"{FILE_NAME} [part 1].stem.m4a"),
	)
	if os.path.isfile(f"{FILE_NAME} [part 2].stem.m4a"):
	os.rename(
	f"{FILE_NAME} [part 2].stem.m4a",
	os.path.join("..", f"{FILE_NAME} [part 2].stem.m4a"),
	)

stemgen/ni-stem/mutagen/_senf/_fsnative.py

Lines 1 to 73 in 1fe4ccb

	# -*- coding: utf-8 -*-
	# Copyright 2016 Christoph Reiter
	#
	# 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.
	import os
	import sys
	import ctypes
	import codecs
	from . import _winapi as winapi
	from ._compat import text_type, PY3, PY2, urlparse, quote, unquote, urlunparse
	is_win = os.name == "nt"
	is_unix = not is_win
	is_darwin = sys.platform == "darwin"
	_surrogatepass = "strict" if PY2 else "surrogatepass"
	def _normalize_codec(codec, _cache={}):
	"""Raises LookupError"""
	try:
	return _cache[codec]
	except KeyError:
	_cache[codec] = codecs.lookup(codec).name
	return _cache[codec]
	def _swap_bytes(data):
	"""swaps bytes for 16 bit, leaves remaining trailing bytes alone"""
	a, b = data[1::2], data[::2]
	data = bytearray().join(bytearray(x) for x in zip(a, b))
	if len(b) > len(a):
	data += b[-1:]
	return bytes(data)
	def _decode_surrogatepass(data, codec):
	"""Like data.decode(codec, 'surrogatepass') but makes utf-16-le/be work
	on Python 2.
	https://bugs.python.org/issue27971
	Raises UnicodeDecodeError, LookupError
	"""
	try:
	return data.decode(codec, _surrogatepass)
	except UnicodeDecodeError:
	if PY2:
	if _normalize_codec(codec) == "utf-16-be":
	data = _swap_bytes(data)

stemgen/ni-stem/mutagen/id3/_frames.py

Lines 706 to 892 in 1fe4ccb

	class TFLT(TextFrame):
	"File type"
	class TGID(TextFrame):
	"iTunes Podcast Identifier"
	class TIME(TextFrame):
	"Time of recording (HHMM)"
	class TIT1(TextFrame):
	"Content group description"
	class TIT2(TextFrame):
	"Title"
	class TIT3(TextFrame):
	"Subtitle/Description refinement"
	class TKEY(TextFrame):
	"Starting Key"
	class TLAN(TextFrame):
	"Audio Languages"
	class TLEN(NumericTextFrame):
	"Audio Length (ms)"
	class TMED(TextFrame):
	"Source Media Type"
	class TMOO(TextFrame):
	"Mood"
	class TOAL(TextFrame):
	"Original Album"
	class TOFN(TextFrame):
	"Original Filename"
	class TOLY(TextFrame):
	"Original Lyricist"
	class TOPE(TextFrame):
	"Original Artist/Performer"
	class TORY(NumericTextFrame):
	"Original Release Year"
	class TOWN(TextFrame):
	"Owner/Licensee"
	class TPE1(TextFrame):
	"Lead Artist/Performer/Soloist/Group"
	class TPE2(TextFrame):
	"Band/Orchestra/Accompaniment"
	class TPE3(TextFrame):
	"Conductor"
	class TPE4(TextFrame):
	"Interpreter/Remixer/Modifier"
	class TPOS(NumericPartTextFrame):
	"Part of set"
	class TPRO(TextFrame):
	"Produced (P)"
	class TPUB(TextFrame):
	"Publisher"
	class TRCK(NumericPartTextFrame):
	"Track Number"
	class TRDA(TextFrame):
	"Recording Dates"
	class TRSN(TextFrame):
	"Internet Radio Station Name"
	class TRSO(TextFrame):
	"Internet Radio Station Owner"
	class TSIZ(NumericTextFrame):
	"Size of audio data (bytes)"
	class TSO2(TextFrame):
	"iTunes Album Artist Sort"
	class TSOA(TextFrame):
	"Album Sort Order key"
	class TSOC(TextFrame):
	"iTunes Composer Sort"
	class TSOP(TextFrame):
	"Perfomer Sort Order key"
	class TSOT(TextFrame):
	"Title Sort Order key"
	class TSRC(TextFrame):
	"International Standard Recording Code (ISRC)"
	class TSSE(TextFrame):
	"Encoder settings"
	class TSST(TextFrame):
	"Set Subtitle"
	class TYER(NumericTextFrame):
	"Year of recording"
	class TXXX(TextFrame):
	"""User-defined text data.
	TXXX frames have a 'desc' attribute which is set to any Unicode
	value (though the encoding of the text and the description must be
	the same). Many taggers use this frame to store freeform keys.
	"""
	_framespec = [
	EncodingSpec('encoding'),
	EncodedTextSpec('desc'),
	MultiSpec('text', EncodedTextSpec('text'), sep=u'\u0000', default=[]),
	]
	@property
	def HashKey(self):
	return '%s:%s' % (self.FrameID, self.desc)
	def _pprint(self):
	return "%s=%s" % (self.desc, " / ".join(self.text))
	class WCOM(UrlFrameU):
	"Commercial Information"
	class WCOP(UrlFrame):
	"Copyright Information"
	class WFED(UrlFrame):
	"iTunes Podcast Feed"
	class WOAF(UrlFrame):

I also found the following external resources that might be helpful:

Summaries of links found in the content:

---

Step 2: 🧐 Snippet Analysis

From looking through the relevant snippets, I decided to make the following modifications:

File Path	Proposed Changes
stemgen.py	Refactor the code to adhere to the unified style guide. This includes renaming variables and functions to follow the naming conventions, reformatting the code to improve readability, and using Python idioms where appropriate.
ableton.py	Apply the same refactoring process as in stemgen.py to ensure consistency in the programming style across the files.
stem.py	Refactor the code in the same manner as the other two files to unify the programming style across the codebase.

---

Step 3: 📝 Planning

I have created a plan for writing the pull request. I am now working my plan and coding the required changes to address this issue. Here is the planned pull request:

Refactor codebase to improve readability and Pythonic style
sweep/refactor-codebase

Description

This pull request aims to address the issue #23 by refactoring the codebase to improve readability and make it more Pythonic. The code in ableton.py, stem.py, and stemgen.py has been reviewed and modified to adhere to a unified style guide that follows Python's PEP 8 style guide while also considering any unique conventions used in the existing codebase.

Summary of Changes

• Renamed variables and functions to follow the naming conventions specified in the style guide.
• Reformatted the code to improve readability, including consistent indentation, spacing, and line breaks.
• Applied Python idioms where appropriate to make the code more concise and expressive.
• Documented the changes made and the reasons behind them for future reference and review.

Please review the changes and provide any feedback or suggestions for further improvement. Thank you!

---

Step 4: ⌨️ Coding

I have finished coding the issue. I am now reviewing it for completeness.

---

Step 5: 🔁 Code Review

Success! 🚀

---

I'm a bot that handles simple bugs and feature requests but I might make mistakes. Please be kind!
^{Join Our Discord}