o 2wiA@sddlZddlmZddlmZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZmZddlmZddlmZddlmZdd lmZdd lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'Gd d d eZ(eGd ddeZ)GdddeeZ*dS)N) defaultdict) dataclass)groupbyislice) AnyCallableDictIterableListMapping NamedTupleOptionalUnion)tqdm)CustomFieldMixin)AlgorithmMixin) Serializable)PathlikeSecondsTimeSpan add_durations asdict_nonullcompute_num_samplesexactly_one_not_nullfastcopyifnoneis_equal_or_contains overspansperturb_num_samplessplit_manifest_lazysplit_sequencec@seZdZUdZeed<eed<eed<dZee ed<e de e e fddfd d Zdefd d Zedefd dZdeddfddZde deddfddZddededdfddZdeegefddfddZdS) AlignmentItemz This class contains an alignment item, for example a word, along with its start time (w.r.t. the start of recording) and duration. It can potentially be used to store other kinds of alignment items, such as subwords, pdfid's etc. symbolstartdurationNscoredatareturncCs"t|tr tt|St|SN) isinstancedictr!listvaluesr&r.O/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/lhotse/supervision.py deserialize8s zAlignmentItem.deserializecCst|Sr(r+selfr.r.r/ serialize?szAlignmentItem.serializecCt|j|jddSNndigitsroundr#r$r2r.r.r/endBzAlignmentItem.endoffsetcCs"tt|j|dd|j|j|jdS)z\Return an identical ``AlignmentItem``, but with the ``offset`` added to the ``start`` field.逻 sampling_rate)r#r$r"r%)r!rr#r$r"r%r3r>r.r.r/ with_offsetFs zAlignmentItem.with_offsetfactorrAcCsHt|j|}t|j|}t|||}t|||}t|j|||jdS)z Return an ``AlignmentItem`` that has time boundaries matching the recording/cut perturbed with the same factor. See :meth:`SupervisionSegment.perturb_speed` for details. r"r#r$r%)rr#r$rr!r"r%)r3rDrA start_sample num_samples new_start new_durationr.r.r/ perturb_speedOs   zAlignmentItem.perturb_speedrr<c CsZ|dksJttd|j|}td|j|}t|jt||jt|j| | dddS)z6 See :meth:`SupervisionSegment.trim`. rr?r@)r"r#r$) absminr#maxr<r!r"rr$r3r<r#start_exceeds_byend_exceeds_byr.r.r/trim]s  zAlignmentItem.trim transform_fncCst||j|j|j|jdS)zL Perform specified transformation on the alignment content. rE)r!r"r#r$r%r3rRr.r.r/ transformls zAlignmentItem.transformr)__name__ __module__ __qualname____doc__str__annotations__rr%r float staticmethodrr rr0r+r4propertyr<rCintrJrQrrTr.r.r.r/r!(s   r!c @s0eZdZUdZeed<eed<eed<eed<dZee e e fed<dZ e eed <dZ e eed <dZe eed <dZe eed <dZe eeefed <dZe eee efed<edefddZdede eddfddZdeddfddZ d8dede deddfddZ d8dede deddfddZ d8dededdfd d!Zd8d"ededdfd#d$Z d9dede ee e e fddfd%d&Zd:d'ededdfd(d)Z d*e!dgdfddfd+d,Z"d*e!egefddfd-d.Z# /d;d*e!egefd0e eddfd1d2Z$de%fd3d4Z&e'd5e%ddfd6d7Z(dS)<SupervisionSegmenta :class:`~lhotse.supervsion.SupervisionSegment` represents a time interval (segment) annotated with some supervision labels and/or metadata, such as the transcription, the speaker identity, the language, etc. Each supervision has unique ``id`` and always refers to a specific recording (via ``recording_id``) and one or more ``channel`` (by default, 0). Note that multiple channels of the recording may share the same supervision, in which case the ``channel`` field will be a list of integers. It's also characterized by the start time (relative to the beginning of a :class:`~lhotse.audio.Recording` or a :class:`~lhotse.cut.Cut`) and a duration, both expressed in seconds. The remaining fields are all optional, and their availability depends on specific corpora. Since it is difficult to predict all possible types of metadata, the ``custom`` field (a dict) can be used to insert types of supervisions that are not supported out of the box. :class:`~lhotse.supervsion.SupervisionSegment` may contain multiple types of alignments. The ``alignment`` field is a dict, indexed by alignment's type (e.g., ``word`` or ``phone``), and contains a list of :class:`~lhotse.supervision.AlignmentItem` objects -- simple structures that contain a given symbol and its time interval. Alignments can be read from CTM files or created programatically. Examples A simple segment with no supervision information:: >>> from lhotse import SupervisionSegment >>> sup0 = SupervisionSegment( ... id='rec00001-sup00000', recording_id='rec00001', ... start=0.5, duration=5.0, channel=0 ... ) Typical supervision containing transcript, speaker ID, gender, and language:: >>> sup1 = SupervisionSegment( ... id='rec00001-sup00001', recording_id='rec00001', ... start=5.5, duration=3.0, channel=0, ... text='transcript of the second segment', ... speaker='Norman Dyhrentfurth', language='English', gender='M' ... ) Two supervisions denoting overlapping speech on two separate channels in a microphone array/multiple headsets (pay attention to ``start``, ``duration``, and ``channel``):: >>> sup2 = SupervisionSegment( ... id='rec00001-sup00002', recording_id='rec00001', ... start=15.0, duration=5.0, channel=0, ... text="i have incredibly good news for you", ... speaker='Norman Dyhrentfurth', language='English', gender='M' ... ) >>> sup3 = SupervisionSegment( ... id='rec00001-sup00003', recording_id='rec00001', ... start=18.0, duration=3.0, channel=1, ... text="say what", ... speaker='Hervey Arman', language='English', gender='M' ... ) A supervision with a phone alignment:: >>> from lhotse.supervision import AlignmentItem >>> sup4 = SupervisionSegment( ... id='rec00001-sup00004', recording_id='rec00001', ... start=33.0, duration=1.0, channel=0, ... text="ice", ... speaker='Maryla Zechariah', language='English', gender='F', ... alignment={ ... 'phone': [ ... AlignmentItem(symbol='AY0', start=33.0, duration=0.6), ... AlignmentItem(symbol='S', start=33.6, duration=0.4) ... ] ... } ... ) A supervision shared across multiple channels of a recording (e.g. a microphone array):: >>> sup5 = SupervisionSegment( ... id='rec00001-sup00005', recording_id='rec00001', ... start=33.0, duration=1.0, channel=[0, 1], ... text="ice", ... speaker='Maryla Zechariah', ... ) Converting :class:`~lhotse.supervsion.SupervisionSegment` to a ``dict``:: >>> sup0.to_dict() {'id': 'rec00001-sup00000', 'recording_id': 'rec00001', 'start': 0.5, 'duration': 5.0, 'channel': 0} id recording_idr#r$rchannelNtextlanguagespeakergendercustom alignmentr'cCr5r6r:r2r.r.r/r<r=zSupervisionSegment.endkindcCs&|j}|dur i}|||<t||dS)Nri)rir)r3rjrialisr.r.r/with_alignments  z!SupervisionSegment.with_alignmentr>c Cs@t|j|jt|j|dd|j|j|j|j|j |j |j |j d S)zaReturn an identical ``SupervisionSegment``, but with the ``offset`` added to the ``start`` field.r7r8) rarbr#r$rcrdrerfrgrhri) r`rarbr;r#r$rcrdrerfrgrhrirBr.r.r/rCszSupervisionSegment.with_offsetTrDrAaffix_idc st|j}t|j}t|}t|}t||r&|jdn|j|r2|jdn|j|||jrHfdd|jDdSddS)a_ Return a ``SupervisionSegment`` that has time boundaries matching the recording/cut perturbed with the same factor. :param factor: The speed will be adjusted this many times (e.g. factor=1.1 means 1.1x faster). :param sampling_rate: The sampling rate is necessary to accurately perturb the start and duration (going through the sample counts). :param affix_id: When true, we will modify the ``id`` and ``recording_id`` fields by affixing it with "_sp{factor}". :return: a modified copy of the current ``SupervisionSegment``. _spc&i|]\}}|fdd|DqS)cg|] }|jdqS)rDrA)rJ.0itemrrr.r/ s z?SupervisionSegment.perturb_speed...r.rttypealirrr.r/ s z4SupervisionSegment.perturb_speed..N)rarbr#r$ri) rr#r$rrrarbriitems)r3rDrArnrFrGrHrIr.rrr/rJs&  z SupervisionSegment.perturb_speedcCsN|j||dd}t||r|jd|n|j|r"|jd|dS|jdS)a_ Return a ``SupervisionSegment`` that has time boundaries matching the recording/cut perturbed with the same factor. :param factor: The tempo will be adjusted this many times (e.g. factor=1.1 means 1.1x faster). :param sampling_rate: The sampling rate is necessary to accurately perturb the start and duration (going through the sample counts). :param affix_id: When true, we will modify the ``id`` and ``recording_id`` fields by affixing it with "_tp{factor}". :return: a modified copy of the current ``SupervisionSegment``. F)rn_tprarb)rJrrarb)r3rDrArn perturbedr.r.r/ perturb_tempo!sz SupervisionSegment.perturb_tempocC>t||r |jd|n|j|r|jd|dS|jdS)a~ Return a ``SupervisionSegment`` with modified ids. :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 ``id`` and ``recording_id`` fields by affixing it with "_vp{factor}". :return: a modified copy of the current ``SupervisionSegment``. _vpr}rrarb)r3rDrnr.r.r/perturb_volume:s z!SupervisionSegment.perturb_volumecodeccCr)a8 Return a ``SupervisionSegment`` with modified ids. :param codec: Codec name. :param affix_id: When true, we will modify the ``id`` and ``recording_id`` fields by affixing it with "_nb_{codec}". :return: a modified copy of the current ``SupervisionSegment``. _nb_r}r)r3rrnr.r.r/ narrowbandNs zSupervisionSegment.narrowbandcCsFt||r |jdn|j|r|jdn|j|dur|dS|jdS)a Return a ``SupervisionSegment`` with modified ids. :param affix_id: When true, we will modify the ``id`` and ``recording_id`` fields by affixing it with "_rvb". :return: a modified copy of the current ``SupervisionSegment``. _rvbN)rarbrc)rrarbrc)r3rnrcr.r.r/ reverb_rir`s  zSupervisionSegment.reverb_rirr<c s~dksJttd|j}td|j}t|t|jt|j| | dd|jr;fdd|j DdSddS)a. Return an identical ``SupervisionSegment``, but ensure that ``self.start`` is not negative (in which case it's set to 0) and ``self.end`` does not exceed the ``end`` parameter. If a `start` is optionally provided, the supervision is trimmed from the left (note that start should be relative to the cut times). This method is useful for ensuring that the supervision does not exceed a cut's bounds, in which case pass ``cut.duration`` as the ``end`` argument, since supervision times are relative to the cut. rr?r@crp)crq)r<r#)rQrsrr.r/rvz6SupervisionSegment.trim...r.rwrr.r/rzsz+SupervisionSegment.trim..N)r#r$ri) rKrLr#rMr<rrr$rir{rNr.rr/rQrs   zSupervisionSegment.trimrRcCs||S)z Return a copy of the current segment, transformed with ``transform_fn``. :param transform_fn: a function that takes a segment as input, transforms it and returns a new segment. :return: a modified ``SupervisionSegment``. r.rSr.r.r/maps zSupervisionSegment.mapcCs |jdur|St|||jdS)a. Return a copy of the current segment with transformed ``text`` field. Useful for text normalization, phonetic transcription, etc. :param transform_fn: a function that accepts a string and returns a string. :return: a ``SupervisionSegment`` with adjusted text. N)rd)rdrrSr.r.r/transform_texts z!SupervisionSegment.transform_textwordrxcs0|jdur|St|fdd|jDdS)a Return a copy of the current segment with transformed ``alignment`` field. Useful for text normalization, phonetic transcription, etc. :param type: alignment type to transform (key for alignment dict). :param transform_fn: a function that accepts a string and returns a string. :return: a ``SupervisionSegment`` with adjusted alignments. Ncs(i|]\}fdd|DqS)cs$g|]}kr|jdn|qS)rR)rTrs)ali_typerRrxr.r/rvs  zESupervisionSegment.transform_alignment...r.)rtryrRrx)rr/rzs z:SupervisionSegment.transform_alignment..rk)rirr{r3rRrxr.rr/transform_alignments  z&SupervisionSegment.transform_alignmentcCsB|jdur t|Sdd|jD}tt|dd}||d<|S)NcS i|] \}}|dd|DqS)cSsg|]}|qSr.)r4rsr.r.r/rvsz9SupervisionSegment.to_dict...r.)rtrjryr.r.r/rzz.SupervisionSegment.to_dict..rkri)rirr{r)r3rlr&r.r.r/to_dicts zSupervisionSegment.to_dictr&cCsPddlm}d|vr||dd|vr!dd|dD|d<tdi|S)Nr)deserialize_custom_fieldrhricSr)cSg|]}t|qSr.)r!r0)rtxr.r.r/rvsz;SupervisionSegment.from_dict...r.rtkvr.r.r/rzrz0SupervisionSegment.from_dict..r.)lhotse.serializationrr{r`)r&rr.r.r/ from_dicts    zSupervisionSegment.from_dict)T)TNrUr))rVrWrXrYrZr[rrcrr_r rdr rerfrgrhrrrir!r^r<rmrCr\boolrJrrrrrQrrrrr*rr]rr.r.r.r/r`xs Y   &          r`c@seZdZUdZdNdeeeddfddZdddefdd Z e de e e efeeffd d Ze dee fd d ZedeeddfddZeZedee ddfddZede eeefddfddZ   dOdede dededdf ddZdPdede ddfddZdeefd d!Z dQd"ed#ed$ededfd%d&Z 'dRd(ed)ed*e dedfd+d,Z dSd-eed.eeddfd/d0Zd1ee ge fddfd2d3Z dPd1ee ge fde ddfd4d5Z!  6   7dTd8e d9eed:e"d;ee"dd?Z#dZ$ee e eefe%d@<dAdBZ&de fdCdDZ'dEe ee fdefdFdGZ(de e efdefdHdIZ)deefdJdKZ*defdLdMZ+dS)USupervisionSetaI :class:`~lhotse.supervision.SupervisionSet` represents a collection of segments containing some supervision information (see :class:`~lhotse.supervision.SupervisionSegment`). It acts as a Python ``list``, extended with an efficient ``find`` operation that indexes and caches the supervision segments in an interval tree. It allows to quickly find supervision segments that correspond to a specific time interval. However, it can also work with lazy iterables. When coming from Kaldi, think of :class:`~lhotse.supervision.SupervisionSet` as a ``segments`` file on steroids, that may also contain *text*, *utt2spk*, *utt2gender*, *utt2dur*, etc. Examples Building a :class:`~lhotse.supervision.SupervisionSet`:: >>> from lhotse import SupervisionSet, SupervisionSegment >>> sups = SupervisionSet.from_segments([SupervisionSegment(...), ...]) Writing/reading a :class:`~lhotse.supervision.SupervisionSet`:: >>> sups.to_file('supervisions.jsonl.gz') >>> sups2 = SupervisionSet.from_file('supervisions.jsonl.gz') Using :class:`~lhotse.supervision.SupervisionSet` like a dict:: >>> 'rec00001-sup00000' in sups True >>> sups['rec00001-sup00000'] SupervisionSegment(id='rec00001-sup00000', recording_id='rec00001', start=0.5, ...) >>> for segment in sups: ... pass Searching by ``recording_id`` and time interval:: >>> matched_segments = sups.find(recording_id='rec00001', start_after=17.0, end_before=25.0) Manipulation:: >>> longer_than_5s = sups.filter(lambda s: s.duration > 5) >>> first_100 = sups.subset(first=100) >>> split_into_4 = sups.split(num_splits=4) >>> shuffled = sups.shuffle() Nsegmentsr'cCst|i|_dSr()rr)r3rr.r.r/__init__ zSupervisionSet.__init__othercCs |j|jkSr(rr3rr.r.r/__eq__ s zSupervisionSet.__eq__cC|jS)z$Alias property for ``self.segments``rr2r.r.r/r&szSupervisionSet.datacCdd|DS)Ncss|]}|jVqdSr(rartsr.r.r/ sz%SupervisionSet.ids..r.r2r.r.r/idsszSupervisionSet.idscCs tt|Sr()rr+rr.r.r/ from_segmentss zSupervisionSet.from_segmentsr&cCstdd|DS)Ncss|]}t|VqdSr()r`rrr.r.r/r"  z,SupervisionSet.from_dicts..rrr-r.r.r/ from_dicts s zSupervisionSet.from_dictspathc Csddlm}t||tfr|gn|}g}|D]d}t|dU}t|D]H\}}|}t|dks>> from lhotse import SupervisionSet >>> sup1 = SupervisionSet.from_rttm('/path/to/rttm_file') >>> sup2 = SupervisionSet.from_rttm(Path('/path/to/rttm_dir').rglob('ref_*')) The following description is taken from the [dscore](https://github.com/nryant/dscore#rttm) toolkit: Rich Transcription Time Marked (RTTM) files are space-delimited text files containing one turn per line, each line containing ten fields: - ``Type`` -- segment type; should always by ``SPEAKER`` - ``File ID`` -- file name; basename of the recording minus extension (e.g., ``rec1_a``) - ``Channel ID`` -- channel (1-indexed) that turn is on; should always be ``1`` - ``Turn Onset`` -- onset of turn in seconds from beginning of recording - ``Turn Duration`` -- duration of turn in seconds - ``Orthography Field`` -- should always by ```` - ``Speaker Type`` -- should always be ```` - ``Speaker Name`` -- name of speaker of turn; should be unique within scope of each file - ``Confidence Score`` -- system confidence (probability) that information is correct; should always be ```` - ``Signal Lookahead Time`` -- should always be ```` For instance: SPEAKER CMU_20020319-1400_d01_NONE 1 130.430000 2.350 juliet SPEAKER CMU_20020319-1400_d01_NONE 1 157.610000 3.060 tbc SPEAKER CMU_20020319-1400_d01_NONE 1 130.490000 0.450 chek :param path: Path to RTTM file or an iterator of paths to RTTM files. :return: a new ``SupervisionSet`` instance containing segments from the RTTM file. r)Pathr zInvalid RTTM line in file z: -06d)rarbrcr#r$rfN)pathlibrr)rZopen enumeratestripsplitlenr\appendr`r_rr) rrrfilefidxlinepartsrbr.r.r/ from_rttm&s2 )       zSupervisionSet.from_rttmrFctm_filerx match_channelverbosec sg}i}t|<}|rt|ddn|}|D]'}|^} } } } } }|| t| t| t| | |r8t|dndfqWdn1sGwYt|ddd}tt dd t |d ddD}g}t |}d}t d d |D}|r}t|d dn|}|D]=} | |vr|j | dD]fdd || D}|t |7}|t|idqq|fdd |j | dDqt|d|dt|S)a Add alignments from CTM file to the supervision set. :param ctm: Path to CTM file. :param type: Alignment type (optional, default = `word`). :param match_channel: if True, also match channel between CTM and SupervisionSegment :param verbose: if True, show progress bar :return: A new SupervisionSet with AlignmentItem objects added to the segments. zReading words from CTM file)descrNcSs|d|dfS)Nrrr.rr.r.r/sz8SupervisionSet.with_alignment_from_ctm..)keycSsi|] \}}|t|qSr.r1rr.r.r/rzrz:SupervisionSet.with_alignment_from_ctm..cSs|dS)Nrr.rr.r.r/rscSsg|]}|jqSr.rbrr.r.r/rvsz:SupervisionSet.with_alignment_from_ctm..zAdding alignmentsrc s^g|]+}tt|d|d|dr-j|dksst|d|d|d|ddqS)rrrrrE)rrrcr!)rtr)rsegr.r/rvs rkcsg|] }t|gidqS)rk)rrrxr.r/rvsz alignments added out of zH total. If there are several missing, there could be a mismatch problem.)rrrrrr_r\sortedrr+rrsetfindrextendlogginginforr)r3rrxrr ctm_wordschannel_to_intrrreco_idrcr#r$r"r% reco_to_ctmr num_totalnum_overspanned recordingsrir.)rrrxr/with_alignment_from_ctmhsZ      z&SupervisionSet.with_alignment_from_ctmcCst|dh}|D]\}||jvrd|j|D]O}t|jtr!|jdn|j}|jdurD||jd|d|jdd|j dd|j d q||jd|d|jdd|j dd|j d|jdd qqWddS1spwYdS)z Write alignments to CTM file. :param ctm_file: Path to output CTM file (will be created if not exists) :param type: Alignment type to write (default = `word`) wrN z.02f ) rrir)rcr+r%writerbr#r$r")r3rrxrrrycr.r.r/write_alignment_to_ctms   ,6"z%SupervisionSet.write_alignment_to_ctmcCr)Ncss|]}|VqdSr()rrr.r.r/rsz*SupervisionSet.to_dicts..r.r2r.r.r/to_dictsszSupervisionSet.to_dicts num_splitsshuffle drop_lastcCsddt||||dDS)a^ Split the :class:`~lhotse.SupervisionSet` 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.SupervisionSet` pieces. cSrr.r)rtsubsetr.r.r/rvsz(SupervisionSet.split..)rrr)r )r3rrrr.r.r/rs zSupervisionSet.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 it: any iterable of Lhotse manifests. :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. )rrr)r)r3rrrr.r.r/ split_lazyszSupervisionSet.split_lazyfirstlastcCst||s Jd|dur|dksJtt||}|S|dur>|dks'J|t|kr/|Stt|t||t|SdS)aq Return a new ``SupervisionSet`` according to the selected subset criterion. Only a single argument to ``subset`` is supported at this time. :param first: int, the number of first supervisions to keep. :param last: int, the number of last supervisions to keep. :return: a new ``SupervisionSet`` with the subset results. z*subset() can handle only one non-None arg.Nr)rr from_itemsrrr)r3rroutr.r.r/rs"    zSupervisionSet.subsetrRcstfdd|DS)aK Return a copy of the current ``SupervisionSet`` with the segments having a transformed ``text`` field. Useful for text normalization, phonetic transcription, etc. :param transform_fn: a function that accepts a string and returns a string. :return: a ``SupervisionSet`` with adjusted text. c3s|]}|VqdSr()rrrr.r/rrz0SupervisionSet.transform_text..rrSr.rr/rszSupervisionSet.transform_textcstfdd|DS)a Return a copy of the current ``SupervisionSet`` with the segments having a transformed ``alignment`` field. Useful for text normalization, phonetic transcription, etc. :param transform_fn: a function that accepts a string and returns a string. :param type: alignment type to transform (key for alignment dict). :return: a ``SupervisionSet`` with adjusted text. c3s|] }|jdVqdS)rN)rrrr.r/r)s z5SupervisionSet.transform_alignment..rrr.rr/rs z"SupervisionSet.transform_alignmentrMbP?rbrc start_after end_before adjust_offset tolerancecs*|}fdd||gDS)a Return an iterable of segments that match the provided ``recording_id``. :param recording_id: Desired recording ID. :param channel: When specified, return supervisions in that channel - otherwise, in all channels. :param start_after: When specified, return segments that start after the given value. :param end_before: When specified, return segments that end before the given value. :param adjust_offset: When true, return segments as if the recordings had started at ``start_after``. This is useful for creating Cuts. From a user perspective, when dealing with a Cut, it is no longer helpful to know when the supervisions starts in a recording - instead, it's useful to know when the supervision starts relative to the start of the Cut. In the anticipated use-case, ``start_after`` and ``end_before`` would be the beginning and end of a cut; this option converts the times to be relative to the start of the cut. :param tolerance: Additional margin to account for floating point rounding errors when comparing segment boundaries. :return: An iterator over supervision segments satisfying all criteria. c3s\|])}dust|jr+|jkr+dus |jkrr(| n|VqdSr()rrcr#r<rC)rtsegmentrrcrrrr.r/rIsz&SupervisionSet.find..) _index_by_recording_id_and_cacheget)r3rbrcrrrrsegment_by_recording_idr.rr/r-s zSupervisionSet.find_segments_by_recording_idcCs,|jdurddlm}|dd||_|jS)Nr)rcSrr(r)rr.r.r/rZszASupervisionSet._index_by_recording_id_and_cache..)rcytoolzr)r3rr.r.r/rVs  z/SupervisionSet._index_by_recording_id_and_cachecCsdt|dS)NzSupervisionSet(len=))rr2r.r.r/__repr__]rzSupervisionSet.__repr__ index_or_idcsZz|jWSty,|jrtfddt|DYStfdd|DYSw)Nc3s |] \}}|kr|VqdSr(r.)rtrrurr.r/rfsz-SupervisionSet.__getitem__..c3s|] }|jkr|VqdSr(rrsrr.r/ris)r TypeErroris_lazynextr)r3rr.rr/ __getitem__`s  zSupervisionSet.__getitem__cs6ttrtfdd|DStfdd|DS)Nc3s|]}|jkVqdSr(rrsrr.r/rmsz.SupervisionSet.__contains__..c3s|] }j|jkVqdSr(rrsr r.r/ros)r)rZanyrr.r r/ __contains__ks zSupervisionSet.__contains__ccs|jEdHdSr(rr2r.r.r/__iter__qszSupervisionSet.__iter__cCs t|jSr()rrr2r.r.r/__len__ts zSupervisionSet.__len__r()rFFr)FF)r)NN)NrNFr),rVrWrXrYr r r`rrrr^rrrZr&rr]rrrrrrrr*rr_r rrrrrrrrrr[rrr rrrr.r.r.r/rs -  D I       ' r)+r collectionsr dataclassesr itertoolsrrtypingrrrr r r r r rr lhotse.customr lhotse.lazyrrr lhotse.utilsrrrrrrrrrrrrrr r!r`rr.r.r.r/s   ,   @Pd