SYMBOL INDEX (159 symbols across 25 files)

FILE: spleeter/__init__.py
  class SpleeterError (line 21) | class SpleeterError(Exception):

FILE: spleeter/__main__.py
  function default (line 53) | def default(
  function train (line 60) | def train(
  function separate (line 110) | def separate(
  function _compile_metrics (line 163) | def _compile_metrics(metrics_output_directory: str) -> Dict:
  function evaluate (line 206) | def evaluate(
  function entrypoint (line 264) | def entrypoint():

FILE: spleeter/audio/__init__.py
  class StrEnum (line 20) | class StrEnum(str, Enum):
  class Codec (line 29) | class Codec(StrEnum):

FILE: spleeter/audio/adapter.py
  class AudioAdapter (line 30) | class AudioAdapter(ABC):
    method load (line 37) | def load(
    method load_waveform (line 68) | def load_waveform(
    method save (line 135) | def save(
    method default (line 162) | def default(cls) -> "AudioAdapter":
    method get (line 177) | def get(cls, descriptor: str) -> "AudioAdapter":

FILE: spleeter/audio/convertor.py
  function to_n_channels (line 20) | def to_n_channels(waveform: tf.Tensor, n_channels: int) -> tf.Tensor:
  function to_stereo (line 42) | def to_stereo(waveform: np.ndarray) -> np.ndarray:
  function gain_to_db (line 62) | def gain_to_db(tensor: tf.Tensor, espilon: float = 10e-10) -> tf.Tensor:
  function db_to_gain (line 79) | def db_to_gain(tensor: tf.Tensor) -> tf.Tensor:
  function spectrogram_to_db_uint (line 94) | def spectrogram_to_db_uint(
  function db_uint_spectrogram_to_gain (line 118) | def db_uint_spectrogram_to_gain(

FILE: spleeter/audio/ffmpeg.py
  class FFMPEGProcessAudioAdapter (line 35) | class FFMPEGProcessAudioAdapter(AudioAdapter):
    method __init__ (line 52) | def __init__(_) -> None:
    method load (line 64) | def load(
    method save (line 132) | def save(

FILE: spleeter/audio/spectrogram.py
  function compute_spectrogram_tf (line 18) | def compute_spectrogram_tf(
  function time_stretch (line 63) | def time_stretch(
  function random_time_stretch (line 93) | def random_time_stretch(
  function pitch_shift (line 121) | def pitch_shift(
  function random_pitch_shift (line 153) | def random_pitch_shift(

FILE: spleeter/dataset.py
  function get_training_dataset (line 60) | def get_training_dataset(
  function get_validation_dataset (line 96) | def get_validation_dataset(
  class InstrumentDatasetBuilder (line 131) | class InstrumentDatasetBuilder(object):
    method __init__ (line 134) | def __init__(self, parent: Any, instrument: Any) -> None:
    method load_waveform (line 150) | def load_waveform(self, sample: Dict) -> Dict:
    method compute_spectrogram (line 163) | def compute_spectrogram(self, sample: Dict) -> Dict:
    method filter_frequencies (line 178) | def filter_frequencies(self, sample: Dict) -> Dict:
    method convert_to_uint (line 188) | def convert_to_uint(self, sample: Dict) -> Dict:
    method filter_infinity (line 200) | def filter_infinity(self, sample: Dict) -> tf.Tensor:
    method convert_to_float32 (line 204) | def convert_to_float32(self, sample: Dict) -> Dict:
    method time_crop (line 217) | def time_crop(self, sample: Dict) -> Dict:
    method filter_shape (line 238) | def filter_shape(self, sample: Dict) -> bool:
    method reshape_spectrogram (line 245) | def reshape_spectrogram(self, sample: Dict) -> Dict:
  class DatasetBuilder (line 258) | class DatasetBuilder(object):
    method __init__ (line 265) | def __init__(
    method check_parameters_compatibility (line 297) | def check_parameters_compatibility(self):
    method expand_path (line 313) | def expand_path(self, sample: Dict) -> Dict:
    method filter_error (line 325) | def filter_error(self, sample: Dict) -> tf.Tensor:
    method filter_waveform (line 329) | def filter_waveform(self, sample: Dict) -> Dict:
    method harmonize_spectrogram (line 333) | def harmonize_spectrogram(self, sample: Dict) -> Dict:
    method filter_short_segments (line 354) | def filter_short_segments(self, sample: Dict) -> tf.Tensor:
    method random_time_crop (line 363) | def random_time_crop(self, sample: Dict) -> Dict:
    method random_time_stretch (line 380) | def random_time_stretch(self, sample: Dict) -> Dict:
    method random_pitch_shift (line 393) | def random_pitch_shift(self, sample: Dict) -> Dict:
    method map_features (line 407) | def map_features(self, sample: Dict) -> Tuple[Dict, Dict]:
    method compute_segments (line 418) | def compute_segments(self, dataset: Any, n_chunks_per_song: int) -> Any:
    method instruments (line 472) | def instruments(self) -> Any:
    method cache (line 489) | def cache(self, dataset: Any, cache: Optional[str], wait: bool) -> Any:
    method build (line 517) | def build(

FILE: spleeter/model/__init__.py
  function get_model_function (line 27) | def get_model_function(model_type):
  class InputProvider (line 51) | class InputProvider(object):
    method __init__ (line 52) | def __init__(self, params):
    method get_input_dict_placeholders (line 55) | def get_input_dict_placeholders(self):
    method input_names (line 59) | def input_names(self):
    method get_feed_dict (line 62) | def get_feed_dict(self, features, *args):
  class WaveformInputProvider (line 66) | class WaveformInputProvider(InputProvider):
    method input_names (line 68) | def input_names(self):
    method get_input_dict_placeholders (line 71) | def get_input_dict_placeholders(self):
    method get_feed_dict (line 79) | def get_feed_dict(self, features, waveform, audio_id):
  class InputProviderFactory (line 83) | class InputProviderFactory(object):
    method get (line 85) | def get(params):
  class EstimatorSpecBuilder (line 89) | class EstimatorSpecBuilder(object):
    method __init__ (line 129) | def __init__(self, features: Dict, params: Dict) -> None:
    method _build_model_outputs (line 160) | def _build_model_outputs(self):
    method _build_loss (line 184) | def _build_loss(self, labels: Dict) -> Tuple[tf.Tensor, Dict]:
    method _build_optimizer (line 220) | def _build_optimizer(self) -> tf.Tensor:
    method instruments (line 238) | def instruments(self):
    method stft_name (line 242) | def stft_name(self):
    method spectrogram_name (line 246) | def spectrogram_name(self):
    method _build_stft_feature (line 249) | def _build_stft_feature(self):
    method model_outputs (line 285) | def model_outputs(self):
    method outputs (line 291) | def outputs(self):
    method stft_feature (line 297) | def stft_feature(self):
    method spectrogram_feature (line 303) | def spectrogram_feature(self):
    method masks (line 309) | def masks(self):
    method masked_stfts (line 315) | def masked_stfts(self):
    method _inverse_stft (line 320) | def _inverse_stft(
    method _build_mwf_output_waveform (line 352) | def _build_mwf_output_waveform(self) -> Dict:
    method _extend_mask (line 392) | def _extend_mask(self, mask: tf.Tensor) -> tf.Tensor:
    method _build_masks (line 425) | def _build_masks(self):
    method _build_masked_stfts (line 459) | def _build_masked_stfts(self):
    method _build_manual_output_waveform (line 466) | def _build_manual_output_waveform(self, masked_stft: Dict) -> Dict:
    method _build_output_waveform (line 485) | def _build_output_waveform(self, masked_stft: Dict) -> Dict:
    method _build_outputs (line 506) | def _build_outputs(self):
    method build_predict_model (line 512) | def build_predict_model(self) -> tf.Tensor:
    method build_evaluation_model (line 528) | def build_evaluation_model(self, labels: Dict) -> tf.Tensor:
    method build_train_model (line 549) | def build_train_model(self, labels: Dict) -> tf.Tensor:
  function model_fn (line 577) | def model_fn(features, labels, mode, params):

FILE: spleeter/model/functions/__init__.py
  function apply (line 19) | def apply(

FILE: spleeter/model/functions/blstm.py
  function apply_blstm (line 47) | def apply_blstm(
  function blstm (line 94) | def blstm(

FILE: spleeter/model/functions/unet.py
  function _get_conv_activation_layer (line 46) | def _get_conv_activation_layer(params: Dict) -> Any:
  function _get_deconv_activation_layer (line 64) | def _get_deconv_activation_layer(params: Dict) -> Any:
  function apply_unet (line 82) | def apply_unet(
  function unet (line 199) | def unet(
  function softmax_unet (line 206) | def softmax_unet(

FILE: spleeter/model/provider/__init__.py
  class ModelProvider (line 24) | class ModelProvider(ABC):
    method download (line 34) | def download(_, name: str, path: str) -> None:
    method writeProbe (line 47) | def writeProbe(directory: str) -> None:
    method get (line 59) | def get(self, model_directory: str) -> str:
    method default (line 88) | def default(_: type) -> "ModelProvider":

FILE: spleeter/model/provider/github.py
  function compute_file_checksum (line 40) | def compute_file_checksum(path):
  class GithubModelProvider (line 59) | class GithubModelProvider(ModelProvider):
    method __init__ (line 69) | def __init__(self, host: str, repository: str, release: str) -> None:
    method from_environ (line 85) | def from_environ(cls) -> "GithubModelProvider":
    method checksum (line 99) | def checksum(self, name: str) -> str:
    method download (line 131) | def download(self, name: str, path: str) -> None:

FILE: spleeter/options.py
  function version_callback (line 119) | def version_callback(value: bool):

FILE: spleeter/separator.py
  function create_estimator (line 44) | def create_estimator(params: Dict, MWF: bool) -> tf.Tensor:
  class Separator (line 73) | class Separator(object):
    method __init__ (line 76) | def __init__(
    method _get_prediction_generator (line 110) | def _get_prediction_generator(self, data: dict) -> Generator:
    method join (line 127) | def join(self, timeout: int = 200) -> None:
    method _get_input_provider (line 140) | def _get_input_provider(self):
    method _get_features (line 145) | def _get_features(self):
    method _get_builder (line 151) | def _get_builder(self):
    method _get_session (line 156) | def _get_session(self):
    method _separate_tensorflow (line 166) | def _separate_tensorflow(
    method separate (line 193) | def separate(
    method separate_to_file (line 211) | def separate_to_file(
    method save_to_file (line 277) | def save_to_file(

FILE: spleeter/utils/configuration.py
  function load_configuration (line 20) | def load_configuration(descriptor: str) -> Dict:

FILE: spleeter/utils/logging.py
  class TyperLoggerHandler (line 23) | class TyperLoggerHandler(logging.Handler):
    method emit (line 26) | def emit(self, record: logging.LogRecord) -> None:
  function configure_logger (line 38) | def configure_logger(verbose: bool) -> None:

FILE: spleeter/utils/tensor.py
  function sync_apply (line 21) | def sync_apply(
  function from_float32_to_uint8 (line 70) | def from_float32_to_uint8(
  function from_uint8_to_float32 (line 88) | def from_uint8_to_float32(
  function pad_and_partition (line 96) | def pad_and_partition(tensor: tf.Tensor, segment_len: int) -> tf.Tensor:
  function pad_and_reshape (line 129) | def pad_and_reshape(instr_spec, frame_length, F) -> Any:
  function dataset_from_csv (line 141) | def dataset_from_csv(csv_path: str, **kwargs) -> Any:
  function check_tensor_shape (line 159) | def check_tensor_shape(tensor_tf: tf.Tensor, target_shape: Any) -> bool:
  function set_tensor_shape (line 184) | def set_tensor_shape(tensor: tf.Tensor, tensor_shape: Any) -> tf.Tensor:

FILE: tests/test_command.py
  function test_version (line 15) | def test_version():

FILE: tests/test_eval.py
  function generate_fake_eval_dataset (line 27) | def generate_fake_eval_dataset(path):
  function test_evaluate (line 46) | def test_evaluate():

FILE: tests/test_ffmpeg_adapter.py
  function adapter (line 33) | def adapter():
  function audio_data (line 39) | def audio_data(adapter):
  function test_default_adapter (line 46) | def test_default_adapter(adapter):
  function test_load (line 52) | def test_load(audio_data):
  function test_load_error (line 63) | def test_load_error(adapter):
  function test_save (line 69) | def test_save(adapter, audio_data):

FILE: tests/test_github_model_provider.py
  function test_checksum (line 11) | def test_checksum():

FILE: tests/test_separator.py
  function test_separate (line 40) | def test_separate(test_file, configuration):
  function test_separate_to_file (line 60) | def test_separate_to_file(test_file, configuration):
  function test_filename_format (line 72) | def test_filename_format(test_file, configuration):
  function test_filename_conflict (line 88) | def test_filename_conflict(test_file, configuration):

FILE: tests/test_train.py
  function generate_fake_training_dataset (line 50) | def generate_fake_training_dataset(
  function test_train (line 84) | def test_train():