o SijA@sddlZddlZddlZddlmZddlmZddlmZddl m Z ddl m Z m Z mZmZmZmZmZddlZddlmZddlmZmZdd lmZdd lmZdd lmZm Z m!Z!m"Z"m#Z#m$Z$Gd d d eeZ%dS)N)ProcessPoolExecutor)partial)islice)Path)CallableDictIterableListMappingOptionalUnion)tqdm)Channels Recording)AlgorithmMixin) Serializable)PathlikeSecondsexactly_one_not_nullifnonesplit_manifest_lazysplit_sequencec@seZdZdZd^deeeddfddZdddefdd Z e de e e efeeffd d Ze dee fd d ZedeeddfddZeZe    d_dede dedeedeeege fdee f ddZedeeddfddZdeefddZ d`ded ed!ededfd"d#Z $dad%ed&ed'e dedfd(d)Z dbd*eed+eeddfd,d-Z  . dcde d/eed0e d1ee de!j"f d2d3Z#deddfd4d5Z$de defd6d7Z%de defd8d9Z&de defd:d;Z'de de(fddd>dGgddfdHeddIedJed@edKeedLeedMeeddfdNdOZ-dPeddfdQdRZ.de fdSdTZ/dUe ee fdefdVdWZ0de e efdefdXdYZ1deefdZd[Z2defd\d]Z3dS)e RecordingSeta :class:`~lhotse.audio.RecordingSet` represents a collection of recordings. It does not contain any annotation such as the transcript or the speaker identity -- just the information needed to retrieve a recording such as its path, URL, number of channels, and some recording metadata (duration, number of samples). It also supports (de)serialization to/from YAML/JSON/etc. and takes care of mapping between rich Python classes and YAML/JSON/etc. primitives during conversion. When coming from Kaldi, think of it as ``wav.scp`` on steroids: :class:`~lhotse.audio.RecordingSet` also has the information from *reco2dur* and *reco2num_samples*, is able to represent multi-channel recordings and read a specified subset of channels, and support reading audio files directly, via a unix pipe, or downloading them on-the-fly from a URL (HTTPS/S3/Azure/GCP/etc.). Examples: :class:`~lhotse.audio.RecordingSet` can be created from an iterable of :class:`~lhotse.audio.Recording` objects:: >>> from lhotse import RecordingSet >>> audio_paths = ['123-5678.wav', ...] >>> recs = RecordingSet.from_recordings(Recording.from_file(p) for p in audio_paths) As well as from a directory, which will be scanned recursively for files with parallel processing:: >>> recs2 = RecordingSet.from_dir('/data/audio', pattern='*.flac', num_jobs=4) It behaves similarly to a ``dict``:: >>> '123-5678' in recs True >>> recording = recs['123-5678'] >>> for recording in recs: >>> pass >>> len(recs) 127 It also provides some utilities for I/O:: >>> recs.to_file('recordings.jsonl') >>> recs.to_file('recordings.json.gz') # auto-compression >>> recs2 = RecordingSet.from_file('recordings.jsonl') Manipulation:: >>> longer_than_5s = recs.filter(lambda r: r.duration > 5) >>> first_100 = recs.subset(first=100) >>> split_into_4 = recs.split(num_splits=4) >>> shuffled = recs.shuffle() And lazy data augmentation/transformation, that requires to adjust some information in the manifest (e.g., ``num_samples`` or ``duration``). Note that in the following examples, the audio is untouched -- the operations are stored in the manifest, and executed upon reading the audio:: >>> recs_sp = recs.perturb_speed(factor=1.1) >>> recs_vp = recs.perturb_volume(factor=2.) >>> recs_rvb = recs.reverb_rir(rir_recs) >>> recs_24k = recs.resample(24000) N recordingsreturncCst|i|_dSN)rr)selfrrN/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/audio/recording_set.py__init__XzRecordingSet.__init__othercCs |j|jkSrrrr!rrr__eq__[s zRecordingSet.__eq__cCs|jS)z&Alias property for ``self.recordings``r"rrrrdata^szRecordingSet.datacCdd|DS)Ncss|]}|jVqdSrid.0rrrr esz#RecordingSet.ids..rr%rrridscszRecordingSet.idscCs tt|Sr)rlistr"rrrfrom_recordingsgs zRecordingSet.from_recordingspathpatternnum_jobsforce_opus_sampling_rate recording_idexclude_patternc sd|d}ttj||d}t||}dur'ttfdd|}|dkr7t t t |||dSt |} t t | |||dWdS1sSwYdS) a Recursively scan a directory ``path`` for audio files that match the given ``pattern`` and create a :class:`.RecordingSet` manifest for them. Suitable to use when each physical file represents a separate recording session. .. caution:: If a recording session consists of multiple files (e.g. one per channel), it is advisable to create each :class:`.Recording` object manually, with each file represented as a separate :class:`.AudioSource` object, and then a :class:`RecordingSet` that contains all the recordings. :param path: Path to a directory of audio of files (possibly with sub-directories). :param pattern: A bash-like pattern specifying allowed filenames, e.g. ``*.wav`` or ``session1-*.flac``. :param num_jobs: The number of parallel workers for reading audio files to get their metadata. :param force_opus_sampling_rate: when specified, this value will be used as the sampling rate instead of the one we read from the manifest. This is useful for OPUS files that always have 48kHz rate and need to be resampled to the real one -- we will perform that operation "under-the-hood". For non-OPUS files this input does nothing. :param recording_id: A function which takes the audio file path and returns the recording ID. If not specified, the filename will be used as the recording ID. :param exclude_pattern: optional regex string for identifying file name patterns to exclude. There has to be a full regex match to trigger exclusion. :return: a new ``Recording`` instance pointing to the audio file. zScanning audio files ())r5r6Ncs|jduSr)matchname)pr7rrsz'RecordingSet.from_dir..r1)desc) rr from_filerrglobrecompilefilterrr0r mapr) r2r3r4r5r6r7msgfile_read_workeritexrr<rfrom_dirms, !   $zRecordingSet.from_dirr&cCstdd|DS)Ncss|]}t|VqdSr)r from_dict)r+raw_recrrrr-s  z*RecordingSet.from_dicts..rr0)r&rrr from_dictss zRecordingSet.from_dictscCr')Ncss|]}|VqdSr)to_dictr*rrrr-sz(RecordingSet.to_dicts..rr%rrrto_dictsszRecordingSet.to_dictsF num_splitsshuffle drop_lastcCsddt||||dDS)aZ Split the :class:`~lhotse.RecordingSet` into ``num_splits`` pieces of equal size. :param num_splits: Requested number of splits. :param shuffle: Optionally shuffle the recordings order first. :param drop_last: determines how to handle splitting when ``len(seq)`` is not divisible by ``num_splits``. When ``False`` (default), the splits might have unequal lengths. When ``True``, it may discard the last element in some splits to ensure they are equally long. :return: A list of :class:`~lhotse.RecordingSet` pieces. cSsg|]}t|qSrrL)r+subsetrrr sz&RecordingSet.split..)rPrQrR)r)rrPrQrRrrrsplits zRecordingSet.split output_dir chunk_sizeprefixcCst||||dS)a Splits a manifest (either lazily or eagerly opened) into chunks, each with ``chunk_size`` items (except for the last one, typically). In order to be memory efficient, this implementation saves each chunk to disk in a ``.jsonl.gz`` format as the input manifest is sampled. .. note:: For lowest memory usage, use ``load_manifest_lazy`` to open the input manifest for this method. :param output_dir: directory where the split manifests are saved. Each manifest is saved at: ``{output_dir}/{prefix}.{split_idx}.jsonl.gz`` :param chunk_size: the number of items in each chunk. :param prefix: the prefix of each manifest. :return: a list of lazily opened chunk manifests. )rWrXrY)r)rrWrXrYrrr split_lazyszRecordingSet.split_lazyfirstlastcCst||s Jd|dur|dksJtt||}|S|dur>|dks'J|t|kr/|Stt|t||t|SdS)ai Return a new ``RecordingSet`` according to the selected subset criterion. Only a single argument to ``subset`` is supported at this time. :param first: int, the number of first recordings to keep. :param last: int, the number of last recordings to keep. :return: a new ``RecordingSet`` with the subset results. z*subset() can handle only one non-None arg.Nr)rr from_itemsrlenr0)rr[r\outrrrrSs"    zRecordingSet.subsetchannelsoffset_secondsduration_secondscCs||j|||dS)N)raoffsetduration) load_audio)rr6rarbrcrrrrfszRecordingSet.load_audioctfdd|DS)Nc3|]}|VqdSr)with_path_prefixr*r2rrr-z0RecordingSet.with_path_prefix..rL)rr2rrjrriszRecordingSet.with_path_prefixcC ||jSr) num_channelsrr6rrrrm zRecordingSet.num_channelscCrlr sampling_raternrrrrq rozRecordingSet.sampling_ratecCrlr) num_samplesrnrrrrr rozRecordingSet.num_samplescCrlr)rernrrrrerozRecordingSet.durationTfactoraffix_idctfdd|DS)a Return a new ``RecordingSet`` that will lazily perturb the speed while loading audio. The ``num_samples`` and ``duration`` fields are updated to reflect the shrinking/extending effect of speed. :param factor: The speed will be adjusted this many times (e.g. factor=1.1 means 1.1x faster). :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_sp{factor}". :return: a ``RecordingSet`` containing the perturbed ``Recording`` objects. c3|] }|jdVqdS)rsrtN) perturb_speedr*rtrsrrr- z-RecordingSet.perturb_speed..rLrrsrtrryrrx zRecordingSet.perturb_speedcru)a Return a new ``RecordingSet`` that will lazily perturb the tempo while loading audio. The ``num_samples`` and ``duration`` fields are updated to reflect the shrinking/extending effect of tempo. :param factor: The speed will be adjusted this many times (e.g. factor=1.1 means 1.1x faster). :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_sp{factor}". :return: a ``RecordingSet`` containing the perturbed ``Recording`` objects. c3rvrw) perturb_tempor*ryrrr--rzz-RecordingSet.perturb_tempo..rLr{rryrr}"r|zRecordingSet.perturb_tempocru)a Return a new ``RecordingSet`` that will lazily perturb the volume while loading audio. :param factor: The volume scale to be applied (e.g. factor=1.1 means 1.1x louder). :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_sp{factor}". :return: a ``RecordingSet`` containing the perturbed ``Recording`` objects. c3rvrw)perturb_volumer*ryrrr-:rzz.RecordingSet.perturb_volume..rLr{rryrr~1s zRecordingSet.perturb_volumerrir_recordingsnormalize_output early_only rir_channels room_rng_seedsource_rng_seedc s,ttfdd|DS)a Return a new ``RecordingSet`` that will lazily apply reverberation based on provided impulse responses while loading audio. If no ``rir_recordings`` are provided, we will generate a set of impulse responses using a fast random generator (https://arxiv.org/abs/2208.04101). :param rir_recordings: The impulse responses to be used. :param normalize_output: When true, output will be normalized to have energy as input. :param early_only: When true, only the early reflections (first 50 ms) will be used. :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_rvb". :param rir_channels: The channels to be used for the RIRs (if multi-channel). Uses first channel by default. If no RIR is provided, we will generate one with as many channels as this argument specifies. :param room_rng_seed: The seed to be used for the room configuration. :param source_rng_seed: The seed to be used for the source positions. :return: a ``RecordingSet`` containing the perturbed ``Recording`` objects. c 3s6|]}|jr tnddVqdS)N) rir_recordingrrrtrrr) reverb_rirrandomchoicer*rtrrrrrrrrr-Zs  z*RecordingSet.reverb_rir..)r/rr0)rrrrrtrrrrrrr>s zRecordingSet.reverb_rirrqcrg)z Apply resampling to all recordings in the ``RecordingSet`` and return a new ``RecordingSet``. :param sampling_rate: The new sampling rate. :return: a new ``RecordingSet`` with lazily resampled ``Recording`` objects. c3rhr)resampler*rprrr-mrkz(RecordingSet.resample..rL)rrqrrprrgszRecordingSet.resamplecCsdt|dS)NzRecordingSet(len=r8)r^r%rrr__repr__or zRecordingSet.__repr__ index_or_idcsZz|jWSty,|jrtfddt|DYStfdd|DYSw)Nc3s |] \}}|kr|VqdSrr)r+idxitemrrrr-xsz+RecordingSet.__getitem__..c3s|] }|jkr|VqdSrr(r+rrrrr-{s)r TypeErroris_lazynext enumerate)rrrrr __getitem__rs  zRecordingSet.__getitem__cs6ttrtfdd|DStfdd|DS)Nc3s|]}|jkVqdSrr(rr!rrr-rkz,RecordingSet.__contains__..c3s|] }j|jkVqdSrr(rrrrr-s) isinstancestranyr#rrr __contains__}s zRecordingSet.__contains__ccs|jEdHdSrr"r%rrr__iter__szRecordingSet.__iter__cCs t|jSr)r^rr%rrr__len__rozRecordingSet.__len__r)r1NNN)FF)rV)NN)Nr`N)T)4__name__ __module__ __qualname____doc__r rrrboolr$propertyr rrr&r. staticmethodr0r]rintrrrIdictrMrOr rUrZrSrfloatnpndarrayrfrirmrqrrrrerxr}r~rrrrrrrrrrrrs=$ :      ) r)&loggingrrAconcurrent.futuresr functoolsr itertoolsrpathlibrtypingrrrr r r r numpyr tqdm.asyncior lhotse.audio.recordingrr lhotse.lazyrlhotse.serializationr lhotse.utilsrrrrrrrrrrrs    $