o Si@szddlmZddlmZddlmZmZddlmZddl m Z m Z m Z m Z mZmZmZmZddlZddlZddlmZddlmZmZmZdd lmZdd lmZmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/dd l0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ee:e e:fZ;eGdddZ<  ddej=de2dee2dedej=fddZ?dS)) dataclass)BytesIO)ceilisclose)Path)CallableDictListLiteralOptionalSequenceTupleUnionN) ROUND_HALF_UP)get_current_audio_backendinfo save_audio) AudioSource)AudioLoadingErrorDurationMismatchError VideoInfo%get_audio_duration_mismatch_tolerance) AudioTransformClippingCompress DereverbWPELoudnessNormalization NarrowbandResampleReverbWithImpulseResponseSpeedTempoVolume)Codec) PathlikeSecondsSetContainingAnything asdict_nonullcompute_num_samplesfastcopyifnoneperturb_num_samplesrich_exception_infoc@seZdZUdZeed<eeed<eed<eed<e ed<dZ e eeed<dZ e ee eefed <d d Zed e efd dZed efddZed e efddZed efddZed efddZed efddZed efddZe    dmdede e eeegeffde ede ed ed df d!d"Zed#e ded dfd$d%Z!    dnd&e e"d'e de e d(e ed df d)d*Z#d e$fd+d,Z%d-d.Z&e'  / dod&e e"d'e de e d e(j)fd0d1Z*e'  /  2 2dpd&e e"d'e de e d3ed4ed e+e,j-e e,j-ff d5d6Z.d7d8Z/d9ee(j)d e(j)fd:d;Z0d'e de e d efdd?Z2d@edAed dfdBdCZ3dqdDe4dEed dfdFdGZ5dqdDe4dEed dfdHdIZ6dqdDe4dEed dfdJdKZ7 2drdLedMedEed dfdNdOZ8dsdPe4dEed dfdQdRZ9dqdEed dfdSdTZ:  2  2   dtdUe ddVedWedEedXe e;edYe edZe ed dfd[d\Z gdvdLe?dhe4d dfdidjZ@ed#e$d dfdkdlZAdS)w Recordinga The :class:`~lhotse.audio.Recording` manifest describes the recordings in a given corpus. It contains information about the recording, such as its path(s), duration, the number of samples, etc. It allows to represent multiple channels coming from one or more files. This manifest does not specify any segmentation information or supervision such as the transcript or the speaker -- we use :class:`~lhotse.supervision.SupervisionSegment` for that. Note that :class:`~lhotse.audio.Recording` can represent both a single utterance (e.g., in LibriSpeech) and a 1-hour session with multiple channels and speakers (e.g., in AMI). In the latter case, it is partitioned into data suitable for model training using :class:`~lhotse.cut.Cut`. Internally, Lhotse supports multiple audio backends to read audio file. By default, we try to use libsoundfile, then torchaudio (with FFMPEG integration starting with torchaudio 2.1), and then audioread (which is an ffmpeg CLI wrapper). For sphere files we prefer to use sph2pipe binary as it can work with certain unique encodings such as "shorten". Audio backends in Lhotse are configurable. See: * :func:`~lhotse.audio.backend.available_audio_backends` * :func:`~lhotse.audio.backend.audio_backend`, * :func:`~lhotse.audio.backend.get_current_audio_backend` * :func:`~lhotse.audio.backend.set_current_audio_backend` * :func:`~lhotse.audio.backend.get_default_audio_backend` Examples A :class:`~lhotse.audio.Recording` can be simply created from a local audio file:: >>> from lhotse import RecordingSet, Recording, AudioSource >>> recording = Recording.from_file('meeting.wav') >>> recording Recording( id='meeting', sources=[AudioSource(type='file', channels=[0], source='meeting.wav')], sampling_rate=16000, num_samples=57600000, duration=3600.0, transforms=None ) This manifest can be easily converted to a Python dict and serialized to JSON/JSONL/YAML/etc:: >>> recording.to_dict() {'id': 'meeting', 'sources': [{'type': 'file', 'channels': [0], 'source': 'meeting.wav'}], 'sampling_rate': 16000, 'num_samples': 57600000, 'duration': 3600.0} Recordings can be also created programatically, e.g. when they refer to URLs stored in S3 or somewhere else:: >>> s3_audio_files = ['s3://my-bucket/123-5678.flac', ...] >>> recs = RecordingSet.from_recordings( ... Recording( ... id=url.split('/')[-1].replace('.flac', ''), ... sources=[AudioSource(type='url', source=url, channels=[0])], ... sampling_rate=16000, ... num_samples=get_num_samples(url), ... duration=get_duration(url) ... ) ... for url in s3_audio_files ... ) It allows reading a subset of the audio samples as a numpy array:: >>> samples = recording.load_audio() >>> assert samples.shape == (1, 16000) >>> samples2 = recording.load_audio(offset=0.5) >>> assert samples2.shape == (1, 8000) See also: :class:`~lhotse.audio.recording.Recording`, :class:`~lhotse.cut.Cut`, :class:`~lhotse.cut.CutSet`. idsources sampling_rate num_samplesdurationN channel_ids transformscCsD|jdurtdd|jD|_tdd|jDdks JddS)Ncss |] }|jD]}|VqqdSNchannels).0sourcecidr;J/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/audio/recording.py s  z*Recording.__post_init__..css|]}|jVqdSr5) has_video)r8r9r;r;r<r=szRLhotse does not currently support recordings with more than a single video stream.)r3sortedr/sumselfr;r;r< __post_init__s  zRecording.__post_init__returncCs|j}|dur dS|jSr5) _video_sourcevideorCsr;r;r<rGszRecording.videocCs |jduSr5)rFrBr;r;r<r> zRecording.has_videocCs|jD] }|jr |SqdSr5)r/r>rHr;r;r<rFs zRecording._video_sourcecCtdd|jDS)Ncs|]}|jdkVqdSmemoryNtyper8rIr;r;r<r=z)Recording.is_in_memory..anyr/rBr;r;r< is_in_memoryzRecording.is_in_memorycCrK)NcsrL)sharNrOrQr;r;r<r=rRz+Recording.is_placeholder..rSrBr;r;r<is_placeholderrVzRecording.is_placeholdercCs t|jSr5)lenr3rBr;r;r< num_channelsrJzRecording.num_channelscCs4ttdd|jD}t|dkr|dStd)zInfer format of the audio sources. If all sources have the same format, return it. If sources have different formats, raise an error. cSsg|]}|jqSr;formatrQr;r;r< sz+Recording.source_format..rzMSources have different formats. Resolving to a single format not implemented.)listsetr/rYNotImplementedError)rCsource_formatsr;r;r< source_formats  zRecording.source_formatFpath recording_idrelative_path_depthforce_opus_sampling_rateforce_read_audioc Cst|}|dur |jn t|r||n|}t|||d}|jdur,|jj}t||j}n|j}|j}t ||j||t dt t |j |durS|dkrSd|j| dnt||jdgdS)a Read an audio file's header and create the corresponding ``Recording``. 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 the ``Recording`` object manually, with each file represented as a separate ``AudioSource`` object. :param path: Path to an audio file supported by libsoundfile (pysoundfile). :param recording_id: recording id, when not specified ream the filename's stem ("x.wav" -> "x"). It can be specified as a string or a function that takes the recording path and returns a string. :param relative_path_depth: optional int specifying how many last parts of the file path should be retained in the ``AudioSource``. By default writes the path as is. :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 is undefined. :param force_read_audio: Set it to ``True`` for audio files that do not have any metadata in their headers (e.g., "The People's Speech" FLAC files). :return: a new ``Recording`` instance pointing to the audio file. N)rgrhfiler/)rPr7r9rGr.r0r1r2r/)rstemcallablerrGr2r( samplerateframesr-rr_ranger7joinpartsstr)rdrerfrgrh audio_infor2r1r;r;r< from_files@   zRecording.from_filedatac CsBt|}t|}t||j|j|jtdtt |j |dgdS)a Like :meth:`.Recording.from_file`, but creates a manifest for a byte string with raw encoded audio data. This data is first decoded to obtain info such as the sampling rate, number of channels, etc. Then, the binary data is attached to the manifest. Calling :meth:`.Recording.load_audio` does not perform any I/O and instead decodes the byte string contents in memory. .. note:: Intended use of this method is for packing Recordings into archives where metadata and data should be available together (e.g., in WebDataset style tarballs). .. caution:: Manifest created with this method cannot be stored as JSON because JSON doesn't allow serializing binary data. :param data: bytes, byte string containing encoded audio contents. :param recording_id: recording id, unique string identifier. :return: a new ``Recording`` instance that owns the byte string data. rNrPr7r9rk) rrrr-rnror2rr_rpr7)rvrestreamrtr;r;r< from_bytess  zRecording.from_bytesr7offsetr\c Cstdd|jDr |Sdd}tdd|||fDs:|dus'|||jkrH|dus0t|drH|dus:t||jrHdd |jD}t||d S|j|t|d |d }t}t |t ||j |d t||j}t |trp|g}t|jtd||dg|j |jdt||jdS)a? Read audio data and return a copy of the manifest with binary data attached. Calling :meth:`.Recording.load_audio` on that copy will not trigger I/O. If all arguments are left as defaults, we won't decode the audio and attach the bytes we read from disk/other source as-is. If ``channels``, ``duration``, or ``offset`` are specified, we'll decode the audio and re-encode it into ``format`` before attaching. The default format is FLAC, other formats compatible with torchaudio.save are also accepted. csrLrMrO)r8srcr;r;r<r==rRz+Recording.move_to_memory..cSst|tr|gS|Sr5) isinstanceint)xr;r;r<_aslist@s z)Recording.move_to_memory.._aslistcss|]}|duVqdSr5r;)r8optr;r;r<r=FsNcSs(g|]}td|jt|jddqS)rNrbrw)rr7openr9read)r8 old_sourcer;r;r<r]Ksz,Recording.move_to_memory..r/r)r7rzr2r[rNrwr^)r.r/r0r1r2)allr/r3rr2r) load_audior*rrtorch from_numpyr0r|r}r-r.rgetvalueshape) rCr7rzr2r\rmemory_sourcesaudiorxr;r;r<move_to_memory*s>     zRecording.move_to_memorycCs*t|}|jdurdd|jD|d<|S)NcSs"g|] }t|tr |n|qSr;)r|dictto_dictr8tr;r;r<r]psz%Recording.to_dict..r4)r'r4)rCdr;r;r<rms   zRecording.to_dictcCsTddlm}m}|jdkr|n|}||jd|j|jdkr$|jd|dS|j|dS)zz Create a Cut out of this recording --- MonoCut or MultiCut, depending on the number of channels. r)MonoCutMultiCutr^r)r.startr2channel recording) lhotse.cutrrrZr.r2r3)rCrrclsr;r;r<to_cutuszRecording.to_cutrcs||jksJd|jd|d|}|dur!t||jddr!d}dur)tn!tttr2gnt|j}|sJJd|dd d d |jpQgD}||}}t |D] } | j |||j d \}}q]g} |j D]-} | jsyqp| j|||j d } fdd t| jD} | rtj| | dd} | | qp|| }|D]} | ||j }q|jrt||||ddd}|St||||d}|S)a Read the audio samples from the underlying audio source (path, URL, unix pipe/command). :param channels: int or iterable of ints, a subset of channel IDs to read (reads all by default). :param offset: seconds, where to start reading the audio (at offset 0 by default). Note that it is only efficient for local filesystem files, i.e. URLs and commands will read all the samples first and discard the unneeded ones afterwards. :param duration: seconds, indicates the total audio time to read (starting from ``offset``). :return: a numpy array of audio samples with shape ``(num_channels, num_samples)``. 3Cannot load audio because the Recording's duration 's is smaller than the requested offset s.NMbP?abs_tolbRequested to load audio from a channel that does not exist in the recording: (recording channels:  -- requested channels: )cS$g|]}t|tr |nt|qSr;r|r from_dictr8tnfmr;r;r<r]z(Recording.load_audio..rzr2r0)rzr2rgcg|] \}}|vr|qSr;r;r8idxr:r6r;r<r]raxis.Aconstantrzr2r tolerancepad_mode)rzr2r)r2rr& frozensetr|r}r3issubsetr4reversedreverse_timestampsr0r/ intersectionr7r enumeratenpdeleteappend_stack_audio_channelsr> assert_and_maybe_fix_num_samples)rCr7rzr2 orig_durationrecording_channelsr4 offset_aug duration_augtfnsamples_per_sourcer9sampleschannels_to_removerr;r6r<rsz            zRecording.load_audioT with_audioforce_consistent_durationcsN|js Jd|jd||jksJd|jd|dt|jdD]}t|tr5|ddvs4Jd q#t|ttfr@Jd q#|sR|j j ||d d \}}|d fS|} |d urbt ||jd drbd }d urjt n!t ttrsgnt |j} | sJd| dddd|jpgD} ||} } t| D] }|j| | |jd\} } qg}d }|jD]8}|jr|j | | d\}}n|j| | d}|jsqfddt|jD}|rtj||dd}||q|d usJ||}| D]}|||j}q|rt|||jd|jj |ddd}n t||| |dd}|t!"|fS)a Read the video frames and audio samples from the underlying source (path, URL, unix pipe/command). :param channels: int or iterable of ints, a subset of channel IDs to read (reads all by default). :param offset: seconds, where to start reading the video (at offset 0 by default). Note that it is only efficient for local filesystem files, i.e. URLs and commands will read all the samples first and discard the unneeded ones afterwards. :param duration: seconds, indicates the total video time to read (starting from ``offset``). :param with_audio: bool, whether to load and return audio alongside video. True by default. :param force_consistent_duration: bool, if audio duration is different than video duration (as counted by ``num_frames / fps``), we'll either truncate or pad the audio with zeros. True by default. :return: a tuple of video tensor and optional audio tensor (or None). z Recording z has no video to load.rrrr;name)r r!zARecording.load_video() does not support speed/tempo perturbation.F)rzr2rNrrrrrcSrr;rrr;r;r<r]1rz(Recording.load_video..r)rzr2crr;r;rr6r;r<r]Qrrrrzerorreflect)rzr2rr)#r>r.r2r*r4r|rr r!rF load_videorr&rr}r3rrrr0r/rrr7rrrrrrrrGfpsrr)rCr7rzr2rrrrG_rrr4rrrrr9rrrr;r6r<rs                 zRecording.load_videocCs$|jrddlm}||jjdSdS)Nr)Video)filename)r>IPython.displayrrFr9)rCrr;r;r< play_videoys zRecording.play_videorc Csttt|jd}t|dkr\dd|D}tdd|D}t|D].\}}||jd|krFt |dd||jdffd }|||<q$t d |j d td tj |dd }|St |}|S)Nr0r^cSs*g|]}|jdkr|dddfn|qSr^N)ndimrQr;r;r<r]sz3Recording._stack_audio_channels..css|]}|jdVqdSr)rrQr;r;r<r=rRz2Recording._stack_audio_channels..rrrrzVThe mismatch between the number of samples in the different channels of the recording z' is greater than the allowed tolerance .r)r}r(rr0rYmaxrrrpadrr. concatenatevstack)rCr allowed_diff max_samplesirIrr;r;r<rs4    zRecording._stack_audio_channelscCs:|dkr |dur |jS|dur|n|j|}t||jdS)Nrr)r1r2r(r0)rCrzr2r;r;r<_expected_num_samplesszRecording._expected_num_samplescst|fdd|jDdS)Ncsg|]}|qSr;)with_path_prefixrQrdr;r<r]z.Recording.with_path_prefix..rr)r/)rCrdr;rr<rszRecording.with_path_prefixwidthheightcst|fdd|jDdS)Ncsg|] }|jdqS))rr)with_video_resolutionrQrrr;r<r]s z3Recording.with_video_resolution..rr)rCrrr;rr<rs  zRecording.with_video_resolutionfactoraffix_idcCf|jdur |jng}|t|dt|j|}||j}t||r+|jd|n|j|||dS)a Return a new ``Recording`` 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 modified copy of the current ``Recording``. Nr_spr.r1r2r4) r4copyrr r+r1r0r)r.rCrrr4new_num_samples new_durationr;r;r< perturb_speeds   zRecording.perturb_speedcCr)aD Return a new ``Recording`` that will lazily perturb the tempo while loading audio. Compared to speed perturbation, tempo preserves pitch. The ``num_samples`` and ``duration`` fields are updated to reflect the shrinking/extending effect of tempo. :param factor: The tempo 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 "_tp{factor}". :return: a modified copy of the current ``Recording``. Nr_tpr) r4rrr!r+r1r0r)r.rr;r;r< perturb_tempos   zRecording.perturb_tempocCR|jdur |jng}|t|dt||r#|jd||dS|j|dS)a} Return a new ``Recording`` 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 "_tp{factor}". :return: a modified copy of the current ``Recording``. Nr_vpr.r4)r4rrr"r)r.)rCrrr4r;r;r<perturb_volume zRecording.perturb_volumecodecrestore_orig_srcCs|jdur |jng}|t||j|dt|j|r!|jndtd}t ||r2|j d|n|j ||r=|j|dSd|dS)z Return a new ``Recording`` that will lazily apply narrowband effect while loading audio. by affixing it with "_nb_{codec}". :return: a modified copy of the current ``Recording``. N)rsource_sampling_rater@rounding_nb_)r.r1r0r4) r4rrrr0rr(r2rr)r.)rCrrrr4rr;r;r< narrowbands0  zRecording.narrowbandtargetcCr)aY Return a new ``Recording`` that will lazily apply WPE dereverberation. :param target: The target loudness (in dB) to normalize to. :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_ln{factor}". :return: a modified copy of the current ``Recording``. N)r_lnr)r4rrrr)r.)rCrrr4r;r;r<normalize_loudnessrzRecording.normalize_loudnesscCsJ|jdur |jng}|tt||r|jd|dS|j|dS)a Return a new ``Recording`` that will lazily apply WPE dereverberation. :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_wpe". :return: a modified copy of the current ``Recording``. N_wper)r4rrrr)r.)rCrr4r;r;r< dereverb_wpe#s zRecording.dereverb_wpe rir_recordingnormalize_output early_only rir_channels room_rng_seedsource_rng_seedc Cs|dur|j|jksJd|jd|jd|jdks&|dus&t|dkr*|j}nttt|}|durEddlm} | |j||d} nd} |jdurQ|j ng} | t ||||dur_|ndg| d t ||rp|j d n|j || d S) ao Return a new ``Recording`` that will lazily apply reverberation based on provided impulse response while loading audio. If no impulse response is provided, we will generate an RIR using a fast random generator (https://arxiv.org/abs/2208.04101). :param rir_recording: The impulse response 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 of the impulse response to be used (in case of multi-channel impulse responses). By default, only the first channel is used. 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 position. :return: the perturbed ``Recording``. Nz1Sampling rate mismatch between RIR vs recording: z vs rr^r)FastRandomRIRGenerator)sr room_seed source_seed)rirr r r rir_generator_rvb)r.r3r4)r0rZrYr3r_rplhotse.augmentation.utilsrr4rrrr)r.) rCr r r rrrrnew_channel_idsrrr4r;r;r< reverb_rir3s>   zRecording.reverb_rircCsh||jkr t|S|jdur|jng}|t|j|dt|j|td}||}t|||||dS)z Return a new ``Recording`` that will be lazily resampled while loading audio. :param sampling_rate: The new sampling rate. :return: A resampled ``Recording``. Nrtarget_sampling_rater)r2r1r0r4) r0r)r4rrrr(r2r)rCr0r4rrr;r;r<resamples( zRecording.resamplehardgain_db normalize oversamplingcCs|jdur |jng}|dur|t|j|j|d|t||||dur7|t|j||jdt||rG|jd|d|dS|j|dS)a Return a new ``Recording`` that will lazily apply a clipping effect while loading audio. Saturates input signal in [-1, 1] range. :param hard: If True, apply hard clipping (sharp cutoff); otherwise, apply soft clipping (saturation). :param gain_db: The amount of gain in decibels to apply before clipping (and to revert back to original level after). :param normalize: If True, normalize the input signal to 0 dBFS before applying clipping. :param oversampling: If provided, we will oversample the input signal by the given integer factor before applying saturation and then downsample back to the original sampling rate. :param affix_id: When true, we will modify the ``Recording.id`` field by affixing it with "_cl{gain_db}". :return: a modified copy of the current ``Recording`` with the saturation transform applied. Nr_clz.1fr)r4rrrr0rr)r.)rCrr r!r"rr4r;r;r<clip_amplitudes0zRecording.clip_amplitudeopusGz?compression_levelcCs|tjvrtd|ddtjd|krdks%ntd||jdur/|jng}|dkrW|jd krW|t|jd d |t|||td |jd n|t||t ||d S) a Return a new ``Recording`` that will lazily apply audio compression while loading audio. :param codec: The codec to use for compression. Supported codecs are "opus", "mp3", "vorbis", "gsm". :param compression_level: The compression level between 0.0 and 1.0 (higher means more compression). :return: a modified copy of the current ``Recording``. zInvalid codec: z. Must be one of: z, rg?z3Compression level must be between 0.0 and 1.0, got Ngsmrr)r4) rsupported_codecs ValueErrorrqr4rr0rrr))rCrr'r4r;r;r<compresss.  zRecording.compresscCs\|d}z|d}dd|D}Wn tyd}Ynwtddd|D|d|S)Nr/r4cSg|]}t|qSr;)rrrr;r;r<r]rz'Recording.from_dict..cSr,r;)rrrQr;r;r<r]r)r/r4r;)popKeyErrorr-)rv raw_sourcesr4r;r;r<rs    zRecording.from_dict)NNNF)NNNN)NrN)NrNTT)T)TT)F)NTFTNNN)FrTrF)r%r&)B__name__ __module__ __qualname____doc__rs__annotations__r rr}r%r3r r4rrrrDpropertyrrGboolr>rFrUrXrZrc staticmethodr$rrrubytesryChannelsrrrrr,rndarrayrr rTensorrrrrrrfloatrrrrrr r rrr$r#r+rr;r;r;r<r-0sf M   C ( C h        L" - $r-rrrzr2rrrrEc Cs|durt}t|dur|n|j||jd}||jd}|dkr$|Stt||j}d|kr7|krGnntj|dd|ff|d}|S| |krRdkr`nn |ddd|f}|St d|d|d|d |jd | ) N)r2r0r^rr)modezjThe number of declared samples in the recording diverged from the one obtained when loading audio (offset=z , duration=z). This could be internal Lhotse's error or a faulty transform implementation. Please report this issue in Lhotse and show the following: diff=z, audio.shape=z , recording=) rr(r2r0rr}rrrr) rrzr2rrrexpected_num_samplesdiffrr;r;r<rs: r)Nr)@ dataclassesriormathrrpathlibrtypingrrr r r r r rnumpyrr_decimalrlhotse.audio.backendrrrlhotse.audio.sourcerlhotse.audio.utilsrrrrlhotse.augmentationrrrrrrrrr r!r"lhotse.augmentation.compressr# lhotse.utilsr$r%r&r'r(r)r*r+r,r}r9r-r:rsrr;r;r;r<sR  (  4 , Y