Config

config

Configuration

Classes:

Name	Description
LazyModelConfig	A lazily validated model configuration.
AudioIOConfig
TorchCompileConfig
InferenceConfig
ChunkingConfig
SubtractConfig
SumConfig
OutputConfig
Config

Attributes:

Name	Type	Description
Tuple
NonEmptyUnique
ModelInputStemName	TypeAlias
ModelOutputStemName	TypeAlias
DerivedStemName	TypeAlias	The name of a derived stem, e.g. vocals_minus_drums.
StemName	TypeAlias	A name of a stem, either a model output stem or a derived stem.
DerivedStemRule	TypeAlias
DerivedStemsConfig	TypeAlias

Tuple module-attribute

Tuple = Annotated[
    tuple[_Item, ...], BeforeValidator(_to_tuple)
]

NonEmptyUnique module-attribute

NonEmptyUnique = Annotated[
    _S,
    Len(min_length=1),
    AfterValidator(_validate_unique_sequence),
    Field(json_schema_extra={"unique_items": True}),
]

ModelInputStemName module-attribute

ModelInputStemName: TypeAlias = Literal['mixture']

ModelOutputStemName module-attribute

ModelOutputStemName: TypeAlias = Annotated[
    ModelOutputStemName, StringConstraints(min_length=1)
]

LazyModelConfig

Bases: BaseModel

A lazily validated model configuration.

Note that it is not guaranteed to be fully valid until to_concrete is called.

Methods:

Name	Description
to_concrete	Validate against a real model configuration and convert to it.

Attributes:

Name	Type	Description
chunk_size	ChunkSize
output_stem_names	NonEmptyUnique[Tuple[ModelOutputStemName]]
stem_names	tuple[ModelInputStemName | ModelOutputStemName, ...]	Returns the model's input and output stem names.
model_config

chunk_size instance-attribute

chunk_size: ChunkSize

output_stem_names instance-attribute

output_stem_names: NonEmptyUnique[
    Tuple[ModelOutputStemName]
]

to_concrete

to_concrete(
    model_config: type[ModelConfigLikeT],
    *,
    pydantic_config: ConfigDict = ConfigDict(
        extra="forbid"
    ),
) -> ModelConfigLikeT

Validate against a real model configuration and convert to it.

Raises:

Type	Description
pydantic.ValidationError	if extra fields are present in the model configuration that doesn't exist in the concrete model configuration.

Source code in src/splifft/config.py

def to_concrete(
    self,
    model_config: type[ModelConfigLikeT],
    *,
    pydantic_config: ConfigDict = ConfigDict(extra="forbid"),
) -> ModelConfigLikeT:
    """Validate against a real model configuration and convert to it.

    :raises pydantic.ValidationError: if extra fields are present in the model configuration
        that doesn't exist in the concrete model configuration.
    """
    model_config_concrete: ModelConfigLikeT = TypeAdapter(
        type(
            f"{model_config.__name__}Validator",
            (model_config,),
            {"__pydantic_config__": pydantic_config},
        )  # needed for https://docs.pydantic.dev/latest/errors/usage_errors/#type-adapter-config-unused
    ).validate_python(self.model_dump())  # type: ignore
    return model_config_concrete

stem_names property

stem_names: tuple[
    ModelInputStemName | ModelOutputStemName, ...
]

Returns the model's input and output stem names.

model_config class-attribute instance-attribute

model_config = ConfigDict(strict=True, extra='allow')

AudioIOConfig

Bases: BaseModel

Attributes:

Name	Type	Description
target_sample_rate	SampleRate
force_channels	Channels | None	Whether to force mono or stereo audio input. If None, keep original.
model_config

target_sample_rate class-attribute instance-attribute

target_sample_rate: SampleRate = 44100

force_channels class-attribute instance-attribute

force_channels: Channels | None = 2

Whether to force mono or stereo audio input. If None, keep original.

model_config class-attribute instance-attribute

model_config = _PYDANTIC_STRICT_CONFIG

TorchCompileConfig

Bases: BaseModel

Attributes:

Name	Type	Description
fullgraph	bool
dynamic	bool
mode	Literal['default', 'reduce-overhead', 'max-autotune', 'max-autotune-no-cudagraphs']

fullgraph class-attribute instance-attribute

fullgraph: bool = True

dynamic class-attribute instance-attribute

dynamic: bool = True

mode class-attribute instance-attribute

mode: Literal[
    "default",
    "reduce-overhead",
    "max-autotune",
    "max-autotune-no-cudagraphs",
] = "reduce-overhead"

InferenceConfig

Bases: BaseModel

Attributes:

Name	Type	Description
normalize_input_audio	bool
batch_size	BatchSize
force_weights_dtype	Dtype | None
use_autocast_dtype	Dtype | None
compile_model	TorchCompileConfig | None
apply_tta	bool
model_config

normalize_input_audio class-attribute instance-attribute

normalize_input_audio: bool = False

batch_size class-attribute instance-attribute

batch_size: BatchSize = 8

force_weights_dtype class-attribute instance-attribute

force_weights_dtype: Dtype | None = None

use_autocast_dtype class-attribute instance-attribute

use_autocast_dtype: Dtype | None = None

compile_model class-attribute instance-attribute

compile_model: TorchCompileConfig | None = None

apply_tta class-attribute instance-attribute

apply_tta: bool = False

model_config class-attribute instance-attribute

model_config = _PYDANTIC_STRICT_CONFIG

ChunkingConfig

Bases: BaseModel

Attributes:

Name	Type	Description
method	Literal['overlap_add_windowed']
overlap_ratio	OverlapRatio
window_shape	WindowShape
padding_mode	PaddingMode
model_config

method class-attribute instance-attribute

method: Literal["overlap_add_windowed"] = (
    "overlap_add_windowed"
)

overlap_ratio class-attribute instance-attribute

overlap_ratio: OverlapRatio = 0.5

window_shape class-attribute instance-attribute

window_shape: WindowShape = 'hann'

padding_mode class-attribute instance-attribute

padding_mode: PaddingMode = 'reflect'

model_config class-attribute instance-attribute

model_config = _PYDANTIC_STRICT_CONFIG

DerivedStemName module-attribute

DerivedStemName: TypeAlias = Annotated[
    str, StringConstraints(min_length=1)
]

The name of a derived stem, e.g. vocals_minus_drums.

StemName module-attribute

StemName: TypeAlias = Union[
    ModelOutputStemName, DerivedStemName
]

A name of a stem, either a model output stem or a derived stem.

SubtractConfig

Bases: BaseModel

Attributes:

Name	Type	Description
operation	Literal['subtract']
stem_name	StemName
by_stem_name	StemName
model_config

operation instance-attribute

operation: Literal['subtract']

stem_name instance-attribute

stem_name: StemName

by_stem_name instance-attribute

by_stem_name: StemName

model_config class-attribute instance-attribute

model_config = _PYDANTIC_STRICT_CONFIG

SumConfig

Bases: BaseModel

Attributes:

Name	Type	Description
operation	Literal['sum']
stem_names	NonEmptyUnique[Tuple[StemName]]
model_config

operation instance-attribute

operation: Literal['sum']

stem_names instance-attribute

stem_names: NonEmptyUnique[Tuple[StemName]]

model_config class-attribute instance-attribute

model_config = _PYDANTIC_STRICT_CONFIG

DerivedStemRule module-attribute

DerivedStemRule: TypeAlias = Annotated[
    Union[SubtractConfig, SumConfig],
    Discriminator("operation"),
]

DerivedStemsConfig module-attribute

DerivedStemsConfig: TypeAlias = dict[
    DerivedStemName, DerivedStemRule
]

OutputConfig

Bases: BaseModel

Attributes:

Name	Type	Description
stem_names	Literal['all'] | NonEmptyUnique[Tuple[StemName]]
file_format	FileFormat
audio_encoding	AudioEncoding
bit_depth	BitDepth
model_config

stem_names class-attribute instance-attribute

stem_names: (
    Literal["all"] | NonEmptyUnique[Tuple[StemName]]
) = "all"

file_format class-attribute instance-attribute

file_format: FileFormat = 'wav'

audio_encoding class-attribute instance-attribute

audio_encoding: AudioEncoding = 'PCM_F'

bit_depth class-attribute instance-attribute

bit_depth: BitDepth = 32

model_config class-attribute instance-attribute

model_config = _PYDANTIC_STRICT_CONFIG

Config

Bases: BaseModel

Methods:

Name	Description
check_derived_stems
from_file

Attributes:

Name	Type	Description
identifier	str	Unique identifier for this configuration
model_type	ModelType
model	LazyModelConfig
audio_io	AudioIOConfig
inference	InferenceConfig
chunking	ChunkingConfig
derived_stems	DerivedStemsConfig | None
output	OutputConfig
experimental	dict[str, Any] | None	Any extra experimental configurations outside of the splifft core.
model_config

identifier instance-attribute

identifier: str

Unique identifier for this configuration

model_type instance-attribute

model_type: ModelType

model instance-attribute

model: LazyModelConfig

audio_io class-attribute instance-attribute

audio_io: AudioIOConfig = Field(
    default_factory=AudioIOConfig
)

inference class-attribute instance-attribute

inference: InferenceConfig = Field(
    default_factory=InferenceConfig
)

chunking class-attribute instance-attribute

chunking: ChunkingConfig = Field(
    default_factory=ChunkingConfig
)

derived_stems class-attribute instance-attribute

derived_stems: DerivedStemsConfig | None = None

output class-attribute instance-attribute

output: OutputConfig = Field(default_factory=OutputConfig)

experimental class-attribute instance-attribute

experimental: dict[str, Any] | None = None

Any extra experimental configurations outside of the splifft core.

check_derived_stems

check_derived_stems() -> Self

Source code in src/splifft/config.py

@model_validator(mode="after")
def check_derived_stems(self) -> Self:
    if self.derived_stems is None:
        return self
    # accumulate valid stem names
    existing_stem_names: list[StemName] = list(self.model.stem_names)
    for derived_stem_name, definition in self.derived_stems.items():
        if derived_stem_name in existing_stem_names:
            raise PydanticCustomError(
                "derived_stem_name_conflict",
                "Derived stem `{derived_stem_name}` must not conflict with existing stem names: `{existing_stem_names}`",
                {
                    "derived_stem_name": derived_stem_name,
                    "existing_stem_names": existing_stem_names,
                },
            )
        required_stems: tuple[StemName, ...] = tuple()
        if isinstance(definition, SubtractConfig):
            required_stems = (definition.stem_name, definition.by_stem_name)
        elif isinstance(definition, SumConfig):
            required_stems = definition.stem_names
        for stem_name in required_stems:
            if stem_name not in existing_stem_names:
                raise PydanticCustomError(
                    "invalid_derived_stem",
                    "Derived stem `{derived_stem_name}` requires stem `{stem_name}` but is not found in `{existing_stem_names}`",
                    {
                        "derived_stem_name": derived_stem_name,
                        "stem_name": stem_name,
                        "existing_stem_names": existing_stem_names,
                    },
                )
        existing_stem_names.append(derived_stem_name)
    return self

from_file classmethod

from_file(path: Path) -> Config

Source code in src/splifft/config.py

@classmethod
def from_file(cls, path: Path) -> Config:
    with open(path, "r") as f:
        config_data = json.load(f)
    return Config.model_validate(config_data)

model_config class-attribute instance-attribute

model_config = ConfigDict(
    arbitrary_types_allowed=True,
    strict=True,
    extra="forbid",
)