o Sio@shUddlZddlZddlZddlZddlZddlmZmZddlm Z ddl m Z ddl m Z mZddlmZddlmZmZmZmZmZmZmZmZddlZddlmZdd lmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&eZ'dyd ed e(fddZ)dZ*e de+fddZ,e ddZ-ded eddfddZ.d ede/fddZ0GdddZ1ded eddfddZ2d edee/e3ffdd Z4Gd!d"d"Z5deee(efd eddfd#d$Z6d edeee(efddffd%d&Z7Gd'd(d(Z8Gd)d*d*e9Z:Gd+d,d,Z;Gd-d.d.Zd3e(d ede+fd4d5Z?dzd ed6eede'fd7d8Z@d edee'fd9d:ZA dzd edee'fd;d<ZBd=d>ZCGd?d@d@eDZEdAe'd eddfdBdCZFGdDdEdEe5et |r=t d|dt dw)a Auto-determine the best way to open the input path or URI. Uses ``smart_open`` when available to handle URLs and URIs. Supports providing "-" as input to read from stdin or save to stdout. If the input is prefixed with "pipe:", it will open a subprocess and redirect either stdin or stdout depending on the mode. The concept is similar to Kaldi's "generalized pipes", but uses WebDataset syntax. zUnexpected identifier type z for object z. Expected str or pathlib.Path.z.Error trying to open what seems to be a URI: 'z' In order to open URLs/URIs please run 'pip install smart_open' (if you're trying to use AIStore, either the Python SDK is not installed (pip install aistore) or z is not defined.) isinstancerrrrstrrtypeget_current_io_backendopen Exceptionr ValueErrorAIS_ENDPOINT_ENVVAR)rrr%H/home/ubuntu/.local/lib/python3.10/site-packages/lhotse/serialization.py open_bests$  r' AIS_ENDPOINTreturncCsttjvo ttjtSN)r$osenvironrr%r%r%r&is_aistore_available?s r-cCsNtdstdtstdddl}tjd}t|j}|j |ddd|fS) NaistorezDPlease run 'pip install aistore' in order to read data from AIStore.zWSet a valid URL as AIS_ENDPOINT environment variable's value to read data from AIStore.rr()2)timeout max_pool_size) r ImportErrorr-r#r.r+r, parse_version __version__Client)r. endpoint_urlversionr%r%r&get_aistore_clientFs  r:datac Cs|t|d/}z tj||tjdWnty#tj||tjdYn wWddSWddS1s7wYdS)Nw)streamDumper)r'yamldump CSafeDumperAttributeError SafeDumperr;rfr%r%r& save_to_yamlWs  "rFc Csrt|d*}ztj|tjdWWdSty.tj|tjdYWdSw1s2wYdS)Nr)r=Loader)r'r?load CSafeLoaderrB SafeLoaderrrEr%r%r& load_yaml`s  rLc@4eZdZdeddfddZededefddZdS) YamlMixinrr)NcCtt||dSr*)rFlistto_dictsselfrr%r%r&to_yamljzYamlMixin.to_yamlcCt|}||Sr*)rL from_dictsclsrr;r%r%r& from_yamlm zYamlMixin.from_yaml)__name__ __module__ __qualname__rrT classmethodManifestrZr%r%r%r&rNirNcCsBt|d}tj||dddWddS1swYdS)eSave the data to a JSON file. Will use GZip to compress it if the path ends with a ``.gz`` extension.r<F)indent ensure_asciiN)r'jsonr@rDr%r%r& save_to_jsonss "rgcCs8t|d }t|WdS1swYdSzILoad a JSON file. Also supports compressed JSON with a ``.gz`` extension.rN)r'rfrHrKr%r%r& load_jsonys $ric@rM) JsonMixinrr)NcCrOr*)rgrPrQrRr%r%r&to_jsonrUzJsonMixin.to_jsoncCrVr*)rirWrXr%r%r& from_jsonr[zJsonMixin.from_json)r\r]r^rrkr_r`rlr%r%r%r&rjrarjcCsPt|d}|D] }ttj|dd|dqWddS1s!wYdS)rbr<FrefileN)r'printrfdumps)r;rrEitemr%r%r& save_to_jsonls "rsccsJt|d}|D] }t|}|Vq WddS1swYdSrh)r'decode_json_line)rrElineretr%r%r& load_jsonls "rwc@seZdZdZddededdfddZdd d Zdd d Zd e e e fdefddZ ddZ ddZd e e e fdefddZd de deddfddZdeefddZdS)!SequentialJsonlWritera SequentialJsonlWriter allows to store the manifests one by one, without the necessity of storing the whole manifest set in-memory. Supports writing to JSONL format (``.jsonl``), with optional gzip compression (``.jsonl.gz``). Example: >>> from lhotse import RecordingSet ... recordings = [...] ... with RecordingSet.open_writer('recordings.jsonl.gz') as writer: ... for recording in recordings: ... writer.write(recording) This writer can be useful for continuing to write files that were previously stopped -- it will open the existing file and scan it for item IDs to skip writing them later. It can also be queried for existing IDs so that the user code may skip preparing the corresponding manifests. Example: >>> from lhotse import RecordingSet, Recording ... with RecordingSet.open_writer('recordings.jsonl.gz', overwrite=False) as writer: ... for path in Path('.').rglob('*.wav'): ... recording_id = path.stem ... if writer.contains(recording_id): ... # Item already written previously - skip processing. ... continue ... # Item doesn't exist yet - run extra work to prepare the manifest ... # and store it. ... recording = Recording.from_file(path, recording_id=recording_id) ... writer.write(recording) Tr overwriter)NcCs||_d|_d|_t|_t|jr?|sAd|_t|jd}dddd|DD|_WddS1s8wYdSdSdS)Nr<arcSsh|] }d|vr|dqS)idr%).0r;r%r%r& s z1SequentialJsonlWriter.__init__..css|]}t|VqdSr*)rt)r|rur%r%r& z1SequentialJsonlWriter.__init__..)rrorset ignore_idsris_filer')rSrryrEr%r%r&__init__s  "zSequentialJsonlWriter.__init__cCs ||Sr*) _maybe_openrSr%r%r& __enter__szSequentialJsonlWriter.__enter__cOs |dSr*)closerSargskwargsr%r%r&__exit__ zSequentialJsonlWriter.__exit__rrcCs8t|tr ||jvSz|j|jvWStyYdSwNF)rrrr{rBrSrrr%r%r& __contains__s   z"SequentialJsonlWriter.__contains__cCs"|jdurt|j|j|_dSdSr*)ror'rrrr%r%r&rs z!SequentialJsonlWriter._maybe_opencCs"|jdur|jd|_dSdSr*)rorrr%r%r&rs   zSequentialJsonlWriter.closecC||vSr*r%rr%r%r&containszSequentialJsonlWriter.containsFmanifestflushcCsrz |j|jvr WdSWn tyYnw|t|ts"|}ttj |dd|j d|r7|j dSdS)az Serializes a manifest item (e.g. :class:`~lhotse.audio.Recording`, :class:`~lhotse.cut.Cut`, etc.) to JSON and stores it in a JSONL file. :param manifest: the manifest to be written. :param flush: should we flush the file after writing (ensures the changes are synced with the disk and not just buffered for later writing). NFrmrn) r{rrBrrdictto_dictrprfrqrorrSrrr%r%r&writes   zSequentialJsonlWriter.writecCs8t|js dS|jdur|jjs|jt|jS)z Opens the manifest that this writer has been writing to. The manifest is opened in a lazy mode. Returns ``None`` when the manifest is empty. N)rrexistsroclosedrload_manifest_lazyrr%r%r& open_manifests   z#SequentialJsonlWriter.open_manifestT)r)rxr)NF)r\r]r^__doc__rboolrrrrrr rrrrrrr`rr%r%r%r&rxs"   rxc@ eZdZdS)InvalidPathExtensionNr\r]r^r%r%r%r&r rc@szeZdZdZddZdddZddd Zdefd d Zd e e e fdefd dZ ddeddfddZ deefddZdS)InMemoryWriterz Mimics :class:`.SequentialJsonlWriter` API but doesn't actually perform any I/O. It is used internally to create manifest sets without writing them to disk. cCsg|_t|_dSr*)items frozensetrrr%r%r&rs zInMemoryWriter.__init__r)cCs|Sr*r%rr%r%r&rzInMemoryWriter.__enter__NcOdSr*r%rr%r%r&rrzInMemoryWriter.__exit__cCdSrr%rr%r%r&r rzInMemoryWriter.__contains__rrcCrr*r%rr%r%r&r#rzInMemoryWriter.containsFrcCs|j|dSr*)rappendrr%r%r&r&szInMemoryWriter.writecCs$|jsdSt|jd}||jS)z Return a manifest set. Resolves the proper manifest set class by itself. Returns ``None`` when the manifest is empty. Nr)rresolve_manifest_set_class from_itemsrSrYr%r%r&r)s zInMemoryWriter.open_manifest)r)rrr)r\r]r^rrrrrrrrr rrrr`rr%r%r%r&rs  rc @sbeZdZdeddfddZededefddZe d deedfd e dee e ffd d Z dS) JsonlMixinrr)NcCst||dSr*)rsrQrRr%r%r&to_jsonl5szJsonlMixin.to_jsonlcCrVr*)rwrWrXr%r%r& from_jsonl8r[zJsonlMixin.from_jsonlTrycCs|durtSt||dS)a$ Open a sequential writer that allows to store the manifests one by one, without the necessity of storing the whole manifest set in-memory. Supports writing to JSONL format (``.jsonl``), with optional gzip compression (``.jsonl.gz``). .. note:: when ``path`` is ``None``, we will return a :class:`.InMemoryWriter` instead has the same API but stores the manifests in memory. It is convenient when you want to make disk saving optional. Example: >>> from lhotse import RecordingSet ... recordings = [...] ... with RecordingSet.open_writer('recordings.jsonl.gz') as writer: ... for recording in recordings: ... writer.write(recording) This writer can be useful for continuing to write files that were previously stopped -- it will open the existing file and scan it for item IDs to skip writing them later. It can also be queried for existing IDs so that the user code may skip preparing the corresponding manifests. Example: >>> from lhotse import RecordingSet, Recording ... with RecordingSet.open_writer('recordings.jsonl.gz', overwrite=False) as writer: ... for path in Path('.').rglob('*.wav'): ... recording_id = path.stem ... if writer.contains(recording_id): ... # Item already written previously - skip processing. ... continue ... # Item doesn't exist yet - run extra work to prepare the manifest ... # and store it. ... recording = Recording.from_file(path, recording_id=recording_id) ... writer.write(recording) N)ry)rrx)rYrryr%r%r& open_writer=s) zJsonlMixin.open_writerr) r\r]r^rrr_r`rrrrxrrr%r%r%r&r4s  rc@speZdZdefddZedeeee fee ffddZ ddZ ede fd d Z ed edefd d ZdS) LazyMixinr;cCt)z Function to be implemented by every sub-class of this mixin. It's expected to create a sub-class instance out of an iterable of items that are held by the sub-class (e.g., ``CutSet.from_items(iterable_of_cuts)``). NotImplemented)rSr;r%r%r&rlszLazyMixin.from_itemsr)cCr)z Property to be implemented by every sub-class of this mixin. It can either be a regular Python dict holding manifests for eager mode, or a special iterator class for lazy mode. rrr%r%r&r;tszLazyMixin.datacCs|js|St|}||S)z Evaluates all lazy operations on this manifest, if any, and returns a copy that keeps all items in memory. If the manifest was "eager" already, this is a no-op and won't copy anything. )is_lazyrrrr%r%r&to_eager}s zLazyMixin.to_eagercCst|jtttf S)zc Indicates whether this manifest was opened in lazy (read-on-the-fly) mode or not. )rr;rrPtuplerr%r%r&rszLazyMixin.is_lazyrcCsddlm}|||S)a0 Read a JSONL manifest in a lazy manner, which opens the file but does not read it immediately. It is only suitable for sequential reads and iteration. .. warning:: Opening the manifest in this way might cause some methods that rely on random access to fail. r)LazyManifestIterator) lhotse.lazyr)rYrrr%r%r&from_jsonl_lazys zLazyMixin.from_jsonl_lazyN)r\r]r^r rpropertyrr rr r;rrrr_rr`rr%r%r%r&rks$ rccs,t|} tt||}|sdS|Vq)zXhttps://stackoverflow.com/questions/8991506/iterate-an-iterator-by-chunks-of-n-in-pythonTN)iterr itertoolsislice)niterableitchunkr%r%r&groupersrextcstfddt|jDS)Nc3s|]}|kVqdSr*r%)r|sfxrr%r&r~rz%extension_contains..)anyrsuffixes)rrr%rr&extension_containssr manifest_clsc Csddlm}m}m}m}td|rt|}|durt|}ntd|r(t|}ntd|r2t |}nt d|d}|durC|g}n||||g}|D]} z| |}t |dkr\t Wn tygYqKw|durst d||S) z2Generic utility for reading an arbitrary manifest.r)CutSet FeatureSet RecordingSetSupervisionSet.jsonlN.json.yamlz-Not a valid manifest (does the path exist?): zUnknown type of manifest: )lhotserrrrrrwrPrirLr#rWlen RuntimeErrorr") rrrrrrraw_datadata_set candidates manifest_typer%r%r& load_manifests6         rcCsbtd|s t|dks Jtt|}zt|}Wn ty#YdSwt|}t|}||S)z{ Generic utility for reading an arbitrary manifest from a JSONL file. Returns None when the manifest is empty. r-N) rrrrwnext StopIterationdeserialize_itemrr)rrfirstrrrYr%r%r&rs    rcCs*td|s t|dkrt|St||dS)z Generic utility for reading an arbitrary manifest. If possible, opens the manifest lazily, otherwise reads everything into memory. rrr)rrrr)rrr%r%r&load_manifest_lazy_or_eagers rc Cszddlm}m}m}m}m}m}ddlm}m }t ||r|St ||r&|St ||r-|St ||r4|St dt |)zLReturns the right *Set class for a manifest, e.g. Recording -> RecordingSet.r)Featuresr RecordingrSupervisionSegmentr)Cutrz8No corresponding 'Set' class is known for item of type: ) rrrrrrr lhotse.cutrrrNotALhotseManifestr) rrrrrrrrrrr%r%r&rs      rc@r)rNrr%r%r%r&r rrrcCsbtd|s t|dkr||dStd|r||dStd|r*||dStd|)Nrrrrz"Unknown serialization format for: )rrrrkrTr#)rrr%r%r&store_manifest s  rc@s4eZdZededefddZdeddfddZdS) Serializablerr)cCs t||dS)Nr)r)rYrr%r%r& from_files zSerializable.from_fileNcCst||dSr*)rrRr%r%r&to_filezSerializable.to_file)r\r]r^r_rr`rrr%r%r%r&rsrc Csddlm}m}m}m}m}m}ddlm}ddl m }d|vr%| |Sd|vs-d|vr1||Sd|vr:| |Sd |vrC| |Sd |vrL| |S| d } | d krZ| |S| d krc| |S| d krqt d| |S| dkrz| |Std| d)Nr)rImageMonoCutMultiCutrrdeserialize_array)MixedCutwidthshapearraysources num_featuresrrrraYour manifest was created with Lhotse version earlier than v0.8, when MonoCut was called Cut. Please re-generate it with Lhotse v0.8 as it might stop working in a future version (using manifest.from_file() and then manifest.to_file() should be sufficient).rz-Unexpected cut type during deserialization: '')rrrrrrr lhotse.arrayrrr from_dictpopwarningswarnr#) r;rrrrrrrrcut_typer%r%r&r!s4            rcs|durdSddlm}ddlm}ddlm}|D]5\}ttrQt fdddDr8| ||<qd vrC| ||<z|||<WqYqq|S) a} Handles deserialization of manifests inside the custom field dictionary (e.g. from :class:`~lhotse.SupervisionSegment` or :class:`~lhotse.MonoCut`). Mutates the input in-place, and returns it. :param data: the contents of ``manifest.custom`` field. :return: ``custom`` field dict with deserialized manifests (if any), or None when input is None. Nr)rr)rc3s|]}|vVqdSr*r%)r|kvaluer%r&r~[rz+deserialize_custom_field..)r{r sampling_rater) rrrr lhotse.audiorrrrallr)r;rrrkeyr%rr&deserialize_custom_fieldCs$      rorjsoncCs"zt|WSt|YSr*)r loadsrf)rur%r%r&rtks rtc@s:eZdZddZddZddZddZd efd d Zd S) StdStreamWrappercC ||_dSr*r=)rSr=r%r%r&rv zStdStreamWrapper.__init__cCrr*r%rr%r%r&ryrzStdStreamWrapper.closecCs|jSr*r rr%r%r&r|zStdStreamWrapper.__enter__cCrr*r%)rSexc_typeexc_valexc_tbr%r%r&rrzStdStreamWrapper.__exit__rrcCs|dkr|jSt|j|S)Nr)rgetattrr=rr%r%r& __getattr__s zStdStreamWrapper.__getattr__N) r\r]r^rrrrrrr%r%r%r&r us r cseZdZdZiZfddZededdfddZde d efd d Z ede fd d Z de de fddZ de de fddZZS) IOBackendax Base class for IO backends supported by Lhotse. An IO backend supports open() operations for reads and/or writes to file-like objects. Deriving classes are auto-registered under their class name, and auto-discoverable through functions: * :func:`~lhotse.serialization.available_io_backends` * :func:`~lhotse.serialization.get_current_io_backend` * :func:`~lhotse.serialization.set_current_io_backend` The default composite backend that tries to figure out the best solution can be obtained via :func:`~lhotse.serialization.get_default_io_backend`. New IO backends are expected to define the following methods: * `open(identifier: str, mode: str)` which returns a file-like object. Must be implemented. * `is_applicable(identifier: str) -> bool` returns `True` if a given backend can be used for a given identifier. True by default. * `is_available(identifier: str) -> bool` Class method. Only define it when the availability of the backend depends on some special actions, such as installing an option dependency. * `handles_special_case(identifier: str) -> bool` defined ONLY when a given IO Backend MUST be selected for a specific identifier. For example, only :class:`~lhotse.serialization.PipeIOBackend` handles piped commands like `"pipe:gunzip -c manifest.jsonl.gz"`. c s.|jtjvr |tj|j<tjdi|dS)Nr%)r\rKNOWN_BACKENDSsuper__init_subclass__)rYr __class__r%r&rs  zIOBackend.__init_subclass__namer)cCs$||jvr td||j|S)NzUnknown IO backend name: )rr)rYrr%r%r&news  z IOBackend.new identifierrcCstr*)NotImplementedErrorrSrrr%r%r&r!rzIOBackend.opencCrNTr%rYr%r%r& is_availableszIOBackend.is_availablecCrrr%rSrr%r%r&handles_special_caserzIOBackend.handles_special_casecCrr r%r#r%r%r& is_applicablerzIOBackend.is_applicable)r\r]r^rrrr_rrrr!rr"r$r% __classcell__r%r%rr&rs! rc@s4eZdZdZdedefddZdedefddZd S) BuiltinIOBackendzCalls Python's built-in `open`.rrcCs t||dS)N)r)r!rr%r%r&r!rzBuiltinIOBackend.openr)cCs t| Sr*rr#r%r%r&r%rzBuiltinIOBackend.is_applicableN) r\r]r^rrrr!rr%r%r%r%r&r'sr'c@FeZdZdZdedefddZdedefddZdedefd d Z d S) RedirectIOBackendz"Opens a stream to stdin or stdout.rrcCs4|dkr ttjS|dkrttjStd|d)Nrr<z=Cannot open stream for '-' with mode other 'r' or 'w' (got: 'z'))r sysstdinstdoutr#rr%r%r&r!s   zRedirectIOBackend.openr)cCs|dkS)Nrr%r#r%r%r&r$rz&RedirectIOBackend.handles_special_casecC ||Sr*r$r#r%r%r&r%rzRedirectIOBackend.is_applicableN r\r]r^rrrr!rr$r%r%r%r%r&r*s  r*c@r)) PipeIOBackendzJExecutes the provided command / pipe and wraps it into a file-like object.rrcCstt|dd|dddS)z Runs the command and redirects stdin/stdout depending on the mode. Returns a file-like object that can be read from or written to. r/NTi)rshellbufsize)rrrr%r%r&r!szPipeIOBackend.openr)cCt|dS)Nzpipe:r startswithr#r%r%r&r$rz"PipeIOBackend.handles_special_casecCr.r*r/r#r%r%r&r%rzPipeIOBackend.is_applicableNr0r%r%r%r&r1s r1c@r)) GzipIOBackendz-Uses gzip.open to automatically (de)compress.rrcCs"d|vr d|vr |d}t||S)Ntbrrr%r%r&r!s zGzipIOBackend.openr)cCst|}|do t| S)N.gz)rendswithrr#r%r%r&r$sz"GzipIOBackend.handles_special_casecCr.r*r/r#r%r%r&r%rzGzipIOBackend.is_applicableNr0r%r%r%r&r7s r7c@s4eZdZdZdedefddZedefddZ d S) SmartOpenIOBackendzQUses `smart_open` library (if installed) to auto-determine how to handle the URI.rrcCs t||Sr*)rr!rr%r%r&r!rzSmartOpenIOBackend.openr)cCtdS)N smart_openrr!r%r%r&r" zSmartOpenIOBackend.is_availableN) r\r]r^rrrr!r_rr"r%r%r%r&r<s r<c@sXeZdZdZdedefddZedefddZde defd d Z de defd d Z d S)AIStoreIOBackendz Uses `aistore` client (if installed and enabled via AIS_ENDPOINT env var) to download data from AIStore if the identifier is a URL/URI. rrcCst\}}||}d|vr.rrjr#r%rgr&r$z'CompositeIOBackend.handles_special_casecrl)Nc3rmr*)r%rnrgr%r&r~roz3CompositeIOBackend.is_applicable..rpr#r%rgr&r%rqz CompositeIOBackend.is_applicableN) r\r]r^rr rrrrr!rr$r%r%r%r%r&ris   riCURRENT_IO_BACKENDcCsdgtddtjDS)zO Return a list of names of available IO backends, including "default". defaultcss"|] }tj|r|VqdSr*)rrr"rnr%r%r&r~s  z(available_io_backends..)sortedrrr%r%r%r&available_io_backendss  rubackend)rNNccs"t}t|}|Vt|dS)a" Context manager that sets Lhotse's IO backend to the specified value and restores the previous IO backend at the end of its scope. Example:: >>> with io_backend("AIStoreIOBackend"): ... cuts = CutSet.from_file(...) # forced open() via AIStore client N)r set_current_io_backend)rvpreviousr9r%r%r& io_backends   rycCs0tdurtStjd}|durt|StdS)zC Return the backend currently set by the user, or default. NLHOTSE_IO_BACKENDrs)rrr+r,rDrw) maybe_backendr%r%r&r s  r cCsb|dkr t}|atSt|trt|}|atSt|tr!|}t|ts-Jd||atS)a Force Lhotse to use a specific IO backend to open every path/URL/URI, overriding the default behaviour of "educated guessing". Example forcing Lhotse to use ``aistore`` library for every IO open() operation:: >>> set_current_io_backend(AIStoreIOBackend()) rsz Expected str or IOBackend, got: )get_default_io_backendrrrrrrr)rvr%r%r&rws"    rw)maxsizecCsdtttg}tr|ttr|ttr&|t|tt g7}t |S)a+ Return a composite backend that auto-infers which internal backend can support reading from a given identifier. It first looks for special cases that need very specific handling (such as: stdin/stdout redirects, pipes) and tries to match them against relevant IO backends. ) r*r1TarAsDirBackendrZr"rrAr<r7r'rirkr%r%r&r|s    r|c@s:eZdZd ddZdedefddZdedefdd Zd S) rrc Ksddl}ddl}t|}dD]Y}|d|vrg||dd}t|dkrg|d|} |d} tj| r_z|| d} | | WS|j t fy^} z t d| d | d | d} ~ wwt d | d q|j||fi|S) z Enhanced open() function that supports accessing files inside tar archives using the syntax: /path/to/archive.tar/internal/file.txt rNz.tarz.tar.gzz.tar.bz2z.tar.xz/r}rcrzFile 'z' not found in 'z': z Tar file 'z ' not found) builtinstarfilerr^rr+rrr! extractfileTarErrorKeyErrorFileNotFoundError) rSrorrrr file_pathtar_extpartstar_path internal_pathtarrer%r%r&r!2s,     zTarAsDirBackend.openrr)cCs(t|}dD] }|d|vrdSqdS)NrrTF)r)rSrrr%r%r&r$Ws  z$TarAsDirBackend.handles_special_casecCr.r*r/r#r%r%r&r%^rzTarAsDirBackend.is_applicableNr)r\r]r^r!rrr$r%r%r%r%r&r1s %rrr*)r)r)crrfr+r+rcodecsrr contextlibr functoolsriorrpathlibrtypingr r r r r rrrr?packaging.versionrr5 lhotse.utilsrrrrrrlhotse.workaroundsrr`rr'r$rr-r:rFrrLrNrgrPrirjrsrwrxr#rrrrrrrrrrr"rrrrrr rtr r rr'r*r1r7r<rArPrRrXr`rZrirr__annotations__ruryr rwr|rr%r%r%r&s    (       " $ r%72 (    " % =  .W!