Comments (1)
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.
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() |
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] |
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): |
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
, andstemgen.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
from stemgen.
Related Issues (20)
- Sweep: Refactor ableton.py to be cleaner, extracting any methods you can into separate files if that makes sense HOT 1
- Sweep: Add comments and docstrings to ableton.py. Clarify each method and global HOT 1
- Mutagen missing in installation instructions HOT 1
- Converting multiple songs at once? HOT 3
- [Feature request] Extract only vocals and instrumental HOT 2
- Error opening input: No such file or directory HOT 8
- How to know if qaac encoder is used on Windows? HOT 2
- [Feature request] Custom name & color for stem HOT 2
- [Bug] Windows cleaning step failing HOT 5
- [Feature Request] Following the Stem File Specification HOT 1
- [Bug] ALAC stems can't be read on Windows within Traktor HOT 4
- Google Colab version? HOT 1
- Extract audio files from STEM file? HOT 6
- [No such file or directory] \output/NoGoodbye/htdemucs/NoGoodbye/drums.wav HOT 1
- Getting an error, when running the docker script version. HOT 1
- Error opening input: no such file or directory
- Generated file has wrong file extension .stem.m4a instead of .stem.mp4 HOT 5
- mp3 processing HOT 1
- Processing without a metadata file as an input HOT 1
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.
from stemgen.