o Si@sddlZddlmZmZddlmZmZddlmZddl m Z ddl m Z ddl mZmZmZmZmZmZmZmZmZmZddlZddlZddlmZdd lmZmZdd l m!Z!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(ddl)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmCZCmDZDeGddde*e(edZEdS)N)ABCMetaabstractmethod) dataclassfield) ROUND_DOWN)isclose)Path) AnyCallableDict GeneratorIterableListLiteralOptionalTupleUnion) IntervalTreeArray TemporalArray) Recording VideoInfo) AugmentFn)Codec)CustomFieldMixin)Cut)FeatureExtractorFeatures)FeaturesWriterImage)SupervisionSegment) LOG_EPSILONPathlikeSecondsTimeSpan add_durations asdict_nonullcompute_num_framescompute_num_samplesfastcopyis_module_availablemeasure_overlapoverlaps overspansperturb_num_samplesrich_exception_infouuid4c@seZdZUdZeed<eed<eed<eee efed<e e dZ e e ed<dZeeed <dZeeed <dZeeeefed <d efd dZd eeeeeeeeeffddffddZed efddZ ed efddZ!ed efddZ"ed efddZ#ed efddZ$ed ee%fddZ&ded efddZ'ed eefd d!Z(ed eefd"d#Z)ed eefd$d%Z*ed eefd&d'Z+ee,d eefd(d)Z-ed eefd*d+Z.ed efd,d-Z/e0e,d ee1j2fd.d/Z3e0e,d ee1j2fd0d1Z4e0e,d eee5j6ee5j6ffd2d3Z7 4 5 5 5dd6ed7ed8ed9ed d:f d;d<Z8   =dd>ed?ee1j2e5j6fd@eedAeedBed d:f dCdDZ9ddEdFZ:ddGdHZ;ddIdJZ =ddOedPed dfdQdRZ? ddSe@dTeAdUeeBd dfdVdWZCdXdd5d=ddYdZedeed[ed\ed]eeeeDfd df d^d_ZEd`d=d5dadedbed\edced eFf dddeZGdddeHdfd=dfdedgedhedieIdbed\edjeeeeeeIffd eFfdkdlZJ = ddmednedoeed dfdpdqZKddreIdned dfdsdtZLddreIdned dfdudvZMddreIdned dfdwdxZN 5ddyedzedned dfd{d|ZO =dd}eIdned dfd~dZPddned dfddZQe,dd5d=d5dgddfdeddedednede edeedeed dfddZR = X 5 5ddedeIdedeedned df ddZS =ddyeTdeIded dfddZUdeVe ge fd dfddZWdeVe gefd dfddZXe, ddedeeVeeYegefd dfddZZe[e,d?ed dfddZ\de]d dfddZ^de]d dfddZ_dedeee1j2e`fd dfddZadS)DataCuta :class:`~lhotse.cut.DataCut` is a base class for cuts that point to actual audio data. It can be either a :class:`~lhotse.cut.MonoCut` or a :class:`~lhotse.cut.MultiCut`. This is as opposed to :class:`~lhotse.cut.MixedCut`, which is simply an operation on a collection of cuts. See also: - :class:`lhotse.cut.MonoCut` - :class:`lhotse.cut.MultiCut` idstartdurationchannel)default_factory supervisionsNfeatures recordingcustomreturncCsjt|}|jr|j|d<|jdur*|jD]\}}t|tr)||d|<qi|dt|j iS)Nr;r<type) r( has_recordingr;to_dictr<items isinstancerr>__name__)selfdkvrHC/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/cut/data.pyr@Zs  zDataCut.to_dictccs`|jr d|jfV|jrd|jfV|jpiD]\}}t|ttt t t fr-||fVqdS)a Iterate over each data piece attached to this cut. Returns a generator yielding tuples of ``(key, manifest)``, where ``key`` is the name of the attribute under which ``manifest`` is found. ``manifest`` is of type :class:`~lhotse.Recording`, :class:`~lhotse.Features`, :class:`~lhotse.TemporalArray`, :class:`~lhotse.Array`, or :class:`~lhotse.Image`. For example, if ``key`` is ``recording``, then ``manifest`` is ``self.recording``. r;r:N) r?r; has_featuresr:r<rArBrrrrr!)rDrFrGrHrHrI iter_datads   zDataCut.iter_datacCstdd|DS)Ncss|]\}}|jVqdSN) is_in_memory.0rFrGrHrHrI |sz'DataCut.is_in_memory..)anyrKrDrHrHrIrMzzDataCut.is_in_memorycCs|jr|jjS|jjSrL)r?r;r4r: recording_idrRrHrHrIrT~rSzDataCut.recording_idcC |jduSrLr:rRrHrHrIrJ zDataCut.has_featurescCrUrLr;rRrHrHrIr?rWzDataCut.has_recordingcCs|jo|jjSrL)r?r; has_videorRrHrHrIrYszDataCut.has_videocCs,|jr|jj}|jt|j|jtddSdS)N)rounding) num_frames)r?r;video copy_withr*r6fpsr)rDrGrHrHrIr\s z DataCut.videorcCs>|dkr|jS|dkr|jS|dkr|jS|jduo||jvS)Nr;r:r\)r?rJrYr<)rDrrHrHrIhassz DataCut.hascC|jr|jjSdSrL)rJr: frame_shiftrRrHrHrIrazDataCut.frame_shiftcCs|jr t|j|j|jdSdS)N)r6ra sampling_rate)rJr)r6rarcrRrHrHrIr[szDataCut.num_framescCs|jr t|j|jSdSrL)r?r*r6rcrRrHrHrI num_sampless zDataCut.num_samplescCr`rL)rJr: num_featuresrRrHrHrIrerbzDataCut.num_featurescCdSrLrHrRrHrHrI num_channelszDataCut.num_channelscCr`rL)rJr:r>rRrHrHrI features_typerbzDataCut.features_typecCs|jr|jjS|jjSrL)rJr:rcr;rRrHrHrIrcs zDataCut.sampling_ratecKrfrLrHrDkwargsrHrHrI load_featuresrhzDataCut.load_featurescKrfrLrHrjrHrHrI load_audiorhzDataCut.load_audiocKrfrLrHrjrHrHrI load_videoszDataCut.load_videoflacT audio_formatrmrl load_customrc s|rjs j}n jjjjj|d}|rjsj}n jjjjd}|r0jdur4j}nddl m m fddj D}t d|||d }|S) a Load data (audio, features, or custom arrays) into memory and attach them to a copy of the manifest. This is useful when you want to store cuts together with the actual data in some binary format that enables sequential data reads. Audio is encoded with ``audio_format`` (compatible with ``torchaudio.save``), floating point features are encoded with lilcom, and other arrays are pickled. )channelsoffsetr6formatr5r6NrrcsDi|]\}}|t|r|nt|r|jjjdn|qS)ru)rBmove_to_memoryr5r6rNrrrDrHrI sz*DataCut.move_to_memory..)r5r;r:r<)r?r;rvr7r5r6rJr:r< lhotse.arrayrrrAr+) rDrprmrlrqr;r:r<cutrHrwrIrvs6    zDataCut.move_to_memoryFnamedatara temporal_dim compressedc Csddlm}m}t||jdur|jnid}|r|n|} t|tjr*| }| t ||| j |j ||||j dWd|S1sHwY|S)a Attach a tensor to this MonoCut, described with an :class:`~lhotse.array.Array` manifest. The attached data is stored in-memory for later use, and can be accessed by calling ``cut.load_()`` or :meth:`cut.load_custom`. This is useful if you want actions such as truncate/pad to propagate to the tensor, e.g.:: >>> cut = MonoCut(id="c1", start=2, duration=8, ...) >>> cut = cut.attach_tensor( ... "alignment", ... torch.tensor([0, 0, 0, ...]), ... frame_shift=0.1, ... temporal_dim=0, ... ) >>> half_alignment = cut.truncate(duration=4.0).load_alignment() .. note:: This object can't be stored in JSON/JSONL manifests anymore. :param name: attribute under which the data can be found. :param data: PyTorch tensor or numpy array. :param frame_shift: Optional float, when the array has a temporal dimension it indicates how much time has passed between the starts of consecutive frames (expressed in seconds). :param temporal_dim: Optional int, when the array has a temporal dimension, it indicates which dim to interpret as temporal. :param compressed: When True, we will apply lilcom compression to the array. Only applicable to arrays of floats. :return: r)MemoryLilcomWriterMemoryRawWriterNr<)keyvaluerar~r5)lhotse.features.iorrr+r<copyrBtorchTensornumpysetattr store_arrayr4r5) rDr|r}rar~rrrcpywriterrHrHrI attach_tensor!s.%    zDataCut.attach_tensorcC$|js Jd|jdt|ddS)zKReturn a copy of the current :class:`.DataCut`, detached from ``features``.zBCannot detach features from a DataCut with no Recording (cut ID = ).NrV)r?r4r+rRrHrHrI drop_features\   zDataCut.drop_featurescCr)zLReturn a copy of the current :class:`.DataCut`, detached from ``recording``.zBCannot detach recording from a DataCut with no Features (cut ID = rNrX)rJr4r+rRrHrHrIdrop_recordingcrzDataCut.drop_recordingcCs t|gdS)zOReturn a copy of the current :class:`.DataCut`, detached from ``supervisions``.r9r+rRrHrHrIdrop_supervisionsjs zDataCut.drop_supervisionscCst|dd|jDdS)zMReturn a copy of the current :class:`.DataCut`, detached from ``alignments``.cSsg|]}t|idqS)) alignmentrrOsrHrHrI qz+DataCut.drop_alignments..rr+r9rRrHrHrIdrop_alignmentsnszDataCut.drop_alignmentscCsddlm}d}|jdur-|j}|D]}||}t|ttttfr,|j r,||||<qt ||j r;|j j r;||j n|j |j rL|jj rL||j|dS|j|dS)a  Return a copy of the current :class:`.DataCut`, detached from any in-memory data. The manifests for in-memory data are converted into placeholders that can still be looked up for metadata, but will fail on attempts to load the data. r)to_shar_placeholderN)r;r:r<)lhotse.shar.utilsrr<rrBrrrrrMr+r?r;rJr:)rDrr<rFrGrHrHrIdrop_in_memory_datats8      zDataCut.drop_in_memory_data add_empty shrink_okcCst|jdkr|s |St|j|jd|j|jdg}nMt|jdks,Jdt|jd|jd}t|jdr@t|j|jr@|S|jdksK|j |j kr^|s^t d|jd|j d|jd t |d|jd g}t ||d S) a Fills the whole duration of a cut with a supervision segment. If the cut has one supervision, its start is set to 0 and duration is set to ``cut.duration``. Note: this may either expand a supervision that was shorter than a cut, or shrink a supervision that exceeds the cut. If there are no supervisions, we will add an empty one when ``add_empty==True``, otherwise we won't change anything. If there are two or more supervisions, we will raise an exception. :param add_empty: should we add an empty supervision with identical time bounds as the cut. :param shrink_ok: should we raise an error if a supervision would be shrank as a result of calling this method. r)r4rTr5r6r7z/Cannot expand more than one supervision (found .z!Cannot shrink supervision (start=z, end=z) to cut (start=0, duration=aU) because the argument `shrink_ok` is `False`. Note: this check prevents accidental data loss for speech recognition, as supervision exceeding a cut indicates there might be some spoken content beyond cuts start or end (an ASR model would be trained to predict more text than spoken in the audio). If this is okay, set `shrink_ok` to `True`.rur) lenr9r"r4rTr6r7rr5end ValueErrorr+)rDrrsupsold_suprHrHrIfill_supervisions2   zDataCut.fill_supervision extractorstorage augment_fncOs,|j|||j|j|j|d}t||dS)a Compute the features from this cut, store them on disk, and attach a feature manifest to this cut. This cut has to be able to load audio. :param extractor: a ``FeatureExtractor`` instance used to compute the features. :param storage: a ``FeaturesWriter`` instance used to write the features to a storage. :param augment_fn: an optional callable used for audio augmentation. :return: a new ``MonoCut`` instance with a ``Features`` manifest attached to it. )samplesrrcrsr7rrV)extract_from_samples_and_storermrcr5r7r+)rDrrrargsrk features_inforHrHrIcompute_and_store_featuress z"DataCut.compute_and_store_featuresry)rsr6keep_excessive_supervisions preserve_id_supervisions_indexrsrrrc sdks Jddtt|j|jdd}t|dur |n|j|jd}t| |jd}|dks;Jd|t|||j |j |jd} | dkrVt|| |jd}|dur{|r^tnttd|dfd d |jD} fd d | D} n>||j } |r| j |d } n | j d|dd } g} | D]}t |j t|}|dkr| |j  qt||r|j ntt||t| ddddS)a Returns a new MonoCut that is a sub-region of the current DataCut. Note that no operation is done on the actual features or recording - it's only during the call to :meth:`DataCut.load_features` / :meth:`DataCut.load_audio` when the actual changes happen (a subset of features/audio is loaded). .. hint:: To extend a cut by a fixed duration, use the :meth:`DataCut.extend_by` method. :param offset: float (seconds), controls the start of the new cut relative to the current DataCut's start. E.g., if the current DataCut starts at 10.0, and offset is 2.0, the new start is 12.0. :param duration: optional float (seconds), controls the duration of the resulting DataCut. By default, the duration is (end of the cut before truncation) - (offset). :param keep_excessive_supervisions: bool. Since trimming may happen inside a SupervisionSegment, the caller has an option to either keep or discard such supervisions. :param preserve_id: bool. Should the truncated cut keep the same ID or get a new, random one. :param _supervisions_index: an IntervalTree; when passed, allows to speed up processing of Cuts with a very large number of supervisions. Intended as an internal parameter. :return: a new MonoCut instance. If the current DataCut is shorter than the duration, return None. rz3Offset for truncate must be non-negative (provided rrcNryz new_duration=)r5rc3s|] }| VqdSrL) with_offsetrOsegment)rsrHrIrPs  z#DataCut.truncate..csg|] }|r|qSrHrHr) criterion new_time_spanrHrIr s z$DataCut.truncate..)beginrgMbP?g{Gz?cS|jSrLr5rrHrHrICz"DataCut.truncate..rr4r5r6r9)maxr'r5rcr6r.r/r&r9r4overlapenvelopr-r}appendrr+strr2sorted)rDrsr6rrr new_startuntil new_durationduration_past_endnew_supervisionsr9tree intervalsinterval olap_ratiorH)rrrsrItruncatesl       zDataCut.truncateboth) directionr pad_silencerrc sddlm}|dksJd|djjd\}}|dks%|dkr;j|dkr3|r3|j}tj|d|dksC|dkraj|jjkrW|rW|jjj}tj|jjt j d }fd d j D} d t t |fd t ffdd } i} jr| jrtdd| d<i} jdurĈjD]\} }|| | <t||r| |rtd| dd| | <qtf|r̈jntt|t| dddd| d| i}|dkr|j|j|d|d}|dkr|j|j|d|d}|S)aD Returns a new Cut (DataCut or MixedCut) that is an extended region of the current DataCut by extending the cut by a fixed duration in the specified direction. Note that no operation is done on the actual features or recording - it's only during the call to :meth:`DataCut.load_features` / :meth:`DataCut.load_audio` when the actual changes happen (an extended version of features/audio is loaded). .. hint:: This method extends a cut by a given duration, either to the left or to the right (or both), using the "real" content of the recording that the cut is part of. For example, a DataCut spanning the region from 2s to 5s in a recording, when extended by 2s to the right, will now span the region from 2s to 7s in the same recording (provided the recording length exceeds 7s). If the recording is shorter, additional silence will be padded to achieve the desired duration by default. This behavior can be changed by setting ``pad_silence=False``. Also see :meth:`DataCut.pad` which pads a cut "to" a specified length. To "truncate" a cut, use :meth:`DataCut.truncate`. .. hint:: If `pad_silence` is set to False, then the cut will be extended only as much as allowed within the recording's boundary. .. hint:: If `direction` is "both", the resulting cut will be extended by the specified duration in both directions. This is different from the usage in :meth:`MonoCut.pad` where a padding equal to 0.5*duration is added to both sides. :param duration: float (seconds), specifies the duration by which the cut should be extended. :param direction: string, 'left', 'right' or 'both'. Determines whether to extend on the left, right, or both sides. If 'both', extend on both sides by the duration specified in `duration`. :param preserve_id: bool. Should the extended cut keep the same ID or get a new, random one. :param pad_silence: bool. Should the cut be padded with silence if the recording is shorter than the desired duration. If False, the cut will be extended only as much as allowed within the recording's boundary. :return: a new MonoCut instance. r)rz(Duration must be non-negative (provided r)rrleftrrightrc3s*|]}|tj jdVqdS)rN)rr'r5rcr)rrDrHrIrPs z$DataCut.extend_by.. attributer=csTt|jj}t|jj}t|j|jj}||j}||dkp)||dkS)Nr)r)rarcr5r[)rnew_start_framesnew_end_framesattribute_start attribute_endnew_endrrDrHrI_this_exceeds_durations      z1DataCut.extend_by.._this_exceeds_durationzvAttempting to extend a MonoCut that exceeds the range of pre-computed features. The feature manifest will be detached.Nr:zSAttempting to extend a MonoCut that exceeds the range of pre-computed custom data 'z$'. The custom data will be detached.cSrrLrrrHrHrIrrz#DataCut.extend_by..rrr<)r6rr)rzrr5rrr;r6minr'rcr9rrboolrJr:loggingwarningr<rArBr+r4rr2rpad)rDr6rrrrpad_left pad_rightrrrfeature_kwargs custom_kwargsr|arrayr{rHrrI extend_byFs| /   "      zDataCut.extend_byrr[rdpad_feat_valuepad_value_dictc Cs$ddlm}|||||||||dS)a Return a new MixedCut, padded with zeros in the recording, and ``pad_feat_value`` in each feature bin. The user can choose to pad either to a specific `duration`; a specific number of frames `num_frames`; or a specific number of samples `num_samples`. The three arguments are mutually exclusive. :param duration: The cut's minimal duration after padding. :param num_frames: The cut's total number of frames after padding. :param num_samples: The cut's total number of samples after padding. :param pad_feat_value: A float value that's used for padding the features. By default we assume a log-energy floor of approx. -23 (1e-10 after exp). :param direction: string, 'left', 'right' or 'both'. Determines whether the padding is added before or after the cut. :param preserve_id: When ``True``, preserves the cut ID before padding. Otherwise, a new random ID is generated for the padded cut (default). :param pad_value_dict: Optional dict that specifies what value should be used for padding arrays in custom attributes. :return: a padded MixedCut if duration is greater than this cut's duration, otherwise ``self``. r)r)r6r[rdrrrr)setr) rDr6r[rdrrrrrrHrHrIrs z DataCut.padrcaffix_idrecording_fieldcCsp|jsJd|j}|j}|dur||}n i|||||i}t||r0|jd|n|j|d|dS)a Return a new ``DataCut`` that will lazily resample the audio while reading it. This operation will drop the feature manifest, if attached. It does not affect the supervision. :param sampling_rate: The new sampling rate. :param affix_id: Should we modify the ID (useful if both versions of the same cut are going to be present in a single manifest). :param recording_field: which recording field to resample. :return: a modified copy of the current ``DataCut``. z,Cannot resample a DataCut without Recording.N_rs)r4r;r:r<)r?r<r;resampler+r4)rDrcrrr<r;rHrHrIrs" zDataCut.resamplefactorc jsJdjrtdd_jjd}fddjD}tt j j }|j }tj }|j }t rLjdnj||||dS) am Return a new ``DataCut`` that will lazily perturb the speed while loading audio. The ``num_samples``, ``start`` and ``duration`` fields are updated to reflect the shrinking/extending effect of speed. We are also updating the time markers of the underlying ``Recording`` and the supervisions. :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 ``MonoCut.id`` field by affixing it with "_sp{factor}". :return: a modified copy of the current ``DataCut``. 4Cannot perturb speed on a DataCut without Recording.zAttempting to perturb speed on a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain speed perturbation.Nrrcg|] }|jjdqS)rrcr) perturb_speedrcrrrrDrHrIr9 z)DataCut.perturb_speed.._spr4r;r9r6r5)r?rJrrr:r;rr9r0r*r5rcrdr+r4 rDrr recording_spsupervisions_sp start_samplesrnew_num_samplesrrHrrIrs6   zDataCut.perturb_speedc r) a Return a new ``DataCut`` that will lazily perturb the tempo while loading audio. Compared to speed perturbation, tempo preserves pitch. The ``num_samples``, ``start`` and ``duration`` fields are updated to reflect the shrinking/extending effect of speed. We are also updating the time markers of the underlying ``Recording`` and the supervisions. :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 ``MonoCut.id`` field by affixing it with "_tp{factor}". :return: a modified copy of the current ``DataCut``. rzAttempting to perturb tempo on a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain speed perturbation.Nrcrr) perturb_temporcrrrHrIrmrz)DataCut.perturb_tempo.._tpr)r?rJrrr:r;rr9r0r*r5rcrdr+r4rrHrrIrOs6   zDataCut.perturb_tempocsp|jsJd|jrtdd|_|jjd}fdd|jD}t|r1|j dn|j ||dS) a Return a new ``DataCut`` that will lazily perturb the volume while loading audio. :param factor: The volume will be adjusted this many times (e.g. factor=1.1 means 1.1x louder). :param affix_id: When true, we will modify the ``DataCut.id`` field by affixing it with "_vp{factor}". :return: a modified copy of the current ``DataCut``. z5Cannot perturb volume on a DataCut without Recording.zAttempting to perturb volume on a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain volume perturbation.Nrcg|] }|jdqS)r)perturb_volumerrrrHrIrs z*DataCut.perturb_volume.._vpr4r;r9) r?rJrrr:r;rr9r+r4)rDrr recording_vpsupervisions_vprHrrIrs&  zDataCut.perturb_volumecodecrestore_orig_srcsr|jsJd|jrtdd|_|jj|d}fdd|jD}t|r2|j dn|j ||dS) ao Return a new ``DataCut`` that will lazily apply narrowband effect. :param codec: Codec name. :param restore_orig_sr: Restore original sampling rate. :param affix_id: When true, we will modify the ``DataCut.id`` field by affixing it with "_nb_{codec}". :return: a modified copy of the current ``DataCut``. z>Cannot apply narrowband effect on a DataCut without Recording.zAttempting to apply narrowband effect on a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain volume perturbation.N)r r rcr))r r) narrowbandrrr rHrIrsz&DataCut.narrowband.._nb_r ) r?rJrrr:r;rr9r+r4)rDr r r recording_nbsupervisions_nbrHrrIrs* zDataCut.narrowbandtargetc sp|jsJd|jrtdd|_|jjd}fdd|jD}t|r1|j dn|j ||dS) aF Return a new ``DataCut`` that will lazily apply loudness normalization. :param target: The target loudness in dBFS. :param affix_id: When true, we will modify the ``DataCut.id`` field by affixing it with "_ln{target}". :return: a modified copy of the current ``DataCut``. zCCannot apply loudness normalization on a DataCut without Recording.zAttempting to normalize loudness on a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain loudness normalization.N)rrcsFg|]}t|r|jdn|jr|jdn|jdqS)_lnr4rTr+r4rTrrrrHrIrsz.DataCut.normalize_loudness..rr ) r?rJrrr:r;normalize_loudnessr9r+r4)rDrrrk recording_lnsupervisions_lnrHrrIrs*   zDataCut.normalize_loudnesscsh|jsJd|jrtdd|_|jjd}fdd|jD}t|r-|j dn|j ||dS) a Return a new ``DataCut`` that will lazily apply WPE dereverberation. :param affix_id: When true, we will modify the ``DataCut.id`` field by affixing it with "_wpe". :return: a modified copy of the current ``DataCut``. z0Cannot apply WPE on a DataCut without Recording.zAttempting to de-reverberate a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain de-reverberation.Nrcs>g|]}t|r|jdn|jr|jdn|jdqS)_wperrrrrHrIrsz(DataCut.dereverb_wpe..rr ) r?rJrrr:r; dereverb_wper9r+r4)rDr recording_wpesupervisions_wperHrrIrs   zDataCut.dereverb_wper rir_recordingrnormalize_output early_only rir_channels room_rng_seedsource_rng_seedcCrfrLrH)rDr r!r"rr#r$r%rHrHrI reverb_rirs zDataCut.reverb_rirhardgain_db normalize oversamplingcCs^|jsJd|jrtd|jj|||||d}t||r)|jd||dS|j|dS)a Return a new ``DataCut`` that will lazily apply clipping while loading audio. :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. :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 ``DataCut.id`` field by affixing it with "_cl{gain_db}". :return: a modified copy of the current ``DataCut``. z7Cannot apply saturation on a DataCut without Recording.zAttempting to apply saturation on a DataCut that references pre-computed features. The feature manifest will be detached, as we do not support feature-domain saturation.)r(r)r*r+r_cl)r4r;)r?rJrrr;clip_amplituder+r4)rDr(r)r*r+rrecording_saturatedrHrHrIr-+s.zDataCut.clip_amplitudeopusGz?compression_levelcompress_custom_fieldscsh|jsJd|j}|r(t|tr(tdd|Dr(fdd|D}t||j |dS)a Return a copy of this Cut that has its Recordings processed by a lossy audio encoder. :param codec: The codec to use for compression. Supported codecs are "opus", "mp3", "vorbis", "gsm". :param compression_level: The level of compression (from 0.0 to 1.0, higher values correspond to higher compression). :param compress_custom_fields: Whether to also compress any custom recording fields in the Cut. :return: A modified :class:`~lhotse.DataCut` containing audio processed by a codec z.Cannot compress a DataCut without a Recording.css|]}t|tVqdSrL)rBr)rOrGrHrHrIrPis  z#DataCut.compress..cs,i|]\}}|t|tr|n|qSrH)rBrcompressrNr r1rHrIrxlsz$DataCut.compress..)r;r<) r?r<rBdictrQvaluesrAr+r;r3)rDr r1r2r<rHr4rIr3Vs  zDataCut.compress transform_fnc t|fdd|jDd}|S)z Return a copy of the cut that has its supervisions transformed by ``transform_fn``. :param transform_fn: a function that modifies a supervision as an argument. :return: a modified MonoCut. csg|]}|qSrH)maprr7rHrIrsz,DataCut.map_supervisions..rr)rDr7new_cutrHr:rImap_supervisionsys zDataCut.map_supervisions predicatecr8)a Return a copy of the cut that only has supervisions accepted by ``predicate``. Example:: >>> cut = cut.filter_supervisions(lambda s: s.id in supervision_ids) >>> cut = cut.filter_supervisions(lambda s: s.duration < 5.0) >>> cut = cut.filter_supervisions(lambda s: s.text is not None) :param predicate: A callable that accepts `SupervisionSegment` and returns bool :return: a modified MonoCut csg|]}|r|qSrHrHrr=rHrIrrz/DataCut.filter_supervisions..rr)rDr=r;rHr>rIfilter_supervisionsszDataCut.filter_supervisions delimiter merge_policycustom_merge_fncKrfrLrH)rDrArBrkrHrHrImerge_supervisionsszDataCut.merge_supervisionscCrfrLrH)r}rHrHrI from_dictrhzDataCut.from_dictpathcC|js|St||j|dS)NrV)rJr+r:with_path_prefixrDrErHrHrIwith_features_path_prefixz!DataCut.with_features_path_prefixcCrF)NrX)r?r+r;rGrHrHrHrIwith_recording_path_prefixrJz"DataCut.with_recording_path_prefixrpath_or_objectcCs tdsJdddlm}ddlm}t||jdur |jnid}t|t t frcddl m}| | }|j \}} Wdn1sFwYt |} t | j} t | j} |d| | || d } n|}||||} Wdn1sywY| |j|<|S) a Attach an image to this cut, wrapped in an Image class and stored under `key` in the `custom` dict. The image can be specified as: - A path to an image file - A numpy array with shape (height, width, channels) - Raw bytes of an image file Example:: >>> cut = cut.attach_image('thumbnail', 'path/to/image.jpg') >>> # Access the image later >>> img_array = cut.load_thumbnail() # Returns numpy array :param key: The key to store the image under in the custom dict. :param path_or_object: The image as a path, numpy array, or bytes. :return: A new DataCut with the image attached. PILz7In order to use images, please run 'pip install pillow'rr )PillowInMemoryWriterNr pillow_files) storage_type storage_path storage_keywidthheight)r,lhotse.image.imager!lhotse.image.iorNr+r<rrBrr PIL.Imageopensizer|parent store_image)rDrrLr!rNrPILImageimgrSrTrErRrQimage_manifestrrHrHrI attach_images>         zDataCut.attach_image)roTTT)NNF)r=r3)TFrL)FN)T)TT)F)FryTr'T)r/r0F)r@N)brC __module__ __qualname____doc__r__annotations__r%rintrrlistr9r"r:rrr;rr<r r r5r@r rrrr!rKpropertyrrMrTrJr?rYrr\r_rar[rdrerrgrircr1npndarrayrlrmrrrnrvrrrrrrrrrrrrrrrr#floatrrrrrrrrr&r-rr3r r<r?r rC staticmethodrDr$rIrKbytesr_rHrHrHrIr36s<        D ;     7  j   - %24$ ( -$  - #     r3) metaclass)Frabcrr dataclassesrrdecimalrmathrpathlibrtypingr r r r r rrrrrrrgr intervaltreerrzrr lhotse.audiorrlhotse.augmentationrlhotse.augmentation.compressr lhotse.customrlhotse.cut.baserlhotse.featuresrrrr lhotse.imager!lhotse.supervisionr" lhotse.utilsr#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3rHrHrHrIs.   0         H