o 2wi@sUddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZmZddlmZmZddlmZmZmZddlmZddlmZmZddlmZddlmZmZm 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,m-Z-ddl.Z.ddl/Z0ddl1Z1dd l2m3Z3e*ee4fZ5e)d Z6e7Z8e7Z9d Z:d Z;eda?e&ee@d<GdddZAde4deBfddZCdeDfddZEddZFde e4effddZGGdddZHeGdddZId ed!edeBfd"d#ZJdd%ed&ed'e7deBfd(d)ZKd*e8d+e8d,e8deDfd-d.ZL /dd0e5d1e4d2e&eBde$efd3d4ZMed5eDfd6d7ZNd8e6de6fd9d:ZO ; < dd=e"ed>e5d?eDd@e4dAeDdBeDde$fdCdDZP EddFe'edGeDdHeBdIeBde$e$ef dJdKZQdLe8d,e8dMeDdeDfdNdOZRdPeDd,e8dMeDdeDfdQdRZSdSe8dTe8dUe8deDfdVdWZTdeBfdXdYZU E  EddZe4d[e5d\eBd]e&eDd^eBddf d_d`ZVdaedbefdcddZW e ddEdfdged0e5dhe&e$e4dieBddf djdkZX e ddled0e5dhe&e$e4ddfdmdnZYGdodpdpeZZdPeDdqe7deDfdrdsZ[efdLe8dMe*eDe7fdeDfdtduZ\dve8dMeDde8fdwdxZ] yddze8dLe8d{e8d|e%d}de(e8e8ff d~dZ^ Edde"e4d@e4de4deBde&e4f ddZ_deBfddZ` dd,e8dMeDde&eDde(eDeDffddZa ddMeDde&eDde(eDeDffddZbdeBfddZcde*e6e'e6fde*e6e'e6fdeBfddZdde4deBfddZed ed!ede7fddZfde&ededefddZgde*ee'efde$efddZhdedefddZidde4de&eDdeDfddZjde1jkde1jlfddZmddZnGdddeoZpGdddeqZrddZsGdddZt dde#e6deDde&ejude!e6ddffddZvddZwGdddZxGddde.jyZzdeBfddZ{de*eDe%dfdejufddÄZ|dEZ}deBfddńZ~ddDŽZdS)N)AbstractContextManagercontextmanager)asdict dataclass)ROUND_HALF_DOWN ROUND_HALF_UPDecimal)chain)ceilisclose)Path) AnyCallableDict GeneratorIterableIteratorListLiteralOptionalSequenceTupleTypeVarUnion)urlparse urlunparse)tqdmTig|= _lhotse_uuidc@s\eZdZUdZdZeeed<dZdZ ee ed<e d dee fddZ e d d d ZdS) SmartOpenaWrapper class around smart_open.open method The smart_open.open attributes are cached as classed attributes - they play the role of singleton pattern. The SmartOpen.setup method is intended for initial setup. It imports the `open` method from the optional `smart_open` Python package, and sets the parameters which are shared between all calls of the `smart_open.open` method. If you do not call the setup method it is called automatically in SmartOpen.open with the provided parameters. The example demonstrates that instantiating S3 `session.client` once, instead using the defaults and leaving the smart_open creating it every time has dramatic performance benefits. Example:: >>> import boto3 >>> session = boto3.Session() >>> client = session.client('s3') >>> from lhotse.utils import SmartOpen >>> >>> if not slow: >>> # Reusing a single client speeds up the smart_open.open calls >>> SmartOpen.setup(transport_params=dict(client=client)) >>> >>> # Simulating SmartOpen usage as in Lhotse data structures: AudioSource, Features, etc. >>> for i in range(1000): >>> SmartOpen.open(s3_url, 'rb') as f: >>> source = f.read() Ntransport_paramszPlease do 'pip install smart_open' - if you are using S3/GCP/Azure/other cloud-specific URIs, do 'pip install smart_open[s3]' (or smart_open[gcp], etc.) instead. smart_opencCsfzddlm}Wn tyt|jw|jdur+|j|kr+td|jd|||_||_dS)Nr)openzSSmartOpen.setup second call overwrites existing transport_params with new version z vs )r!r" ImportErrorimport_err_msgr loggingwarning)clsr sm_openr)I/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/lhotse/utils.pysetupds      zSmartOpen.setuprbcKs<|jdur |j|d|r|n|j}|j|f||d|S)N)r )moder )r!r+r )r'urir-r kwargsr)r)r*r"us   zSmartOpen.openN)r,N)__name__ __module__ __qualname____doc__r rr__annotations__r$r!r classmethoddictr+r"r)r)r)r*r<s rvaluereturncCs4zt|}t|jot|jWStyYdSw)NF)rboolschemenetlocAttributeError)r8resultr)r)r* is_valid_urls  r? random_seedcsDt|tj|tj|t|fddadS)z Set the same random seed for the libraries and modules that Lhotse interacts with. Includes the ``random`` module, numpy, torch, and ``uuid4()`` function defined in this file. cstjddS)N)int)uuidUUID getrandbitsr)rdr)r*sz!fix_random_seed..N)randomseednptorch manual_seedRandomr)r@r)rFr*fix_random_seeds    rOcCstdurtStS)z Generates uuid4's exactly like Python's uuid.uuid4() function. When ``fix_random_seed()`` is called, it will instead generate deterministic IDs. N)rrCuuid4r)r)r)r*rPsrPcCsdd}t||dS)z Recursively convert a dataclass into a dict, removing all the fields with `None` value. Intended to use in place of dataclasses.asdict(), when the null values are not desired in the serialized document. cSsDt|}g}|D] \}}|dur||q |D]}||=q|Sr0)r7itemsappend) collectiond remove_keyskeyvalkr)r)r*non_null_dict_factorys z,asdict_nonull..non_null_dict_factory) dict_factory)r)dclassrYr)r)r* asdict_nonulls r\c@seZdZddZddZdS)SetContainingAnythingcCdSNTr))selfitemr)r)r* __contains__z"SetContainingAnything.__contains__cCr^r_r))r`iterabler)r)r* intersectionrcz"SetContainingAnything.intersectionN)r1r2r3rbrer)r)r)r*r]s r]c@s4eZdZUdZeed<eed<edefddZdS)TimeSpanz(Helper class for specifying a time span.startendr9cCs |j|jSr0)rhrgr`r)r)r*duration zTimeSpan.durationN)r1r2r3r4Secondsr5propertyrjr)r)r)r*rfs rflhsrhscCs8|j|jko|j|jkot|j|j ot|j|j S)zAIndicates whether two time-spans/segments are overlapping or not.)rgrhr )rnror)r)r*overlapss  rpMbP?spanningspanned tolerancecCs2|j||jko|jko|j|kSS)zjIndicates whether the left-hand-side time-span/segment covers the whole right-hand-side time-span/segment.)rgrh)rrrsrtr)r)r* overspanssru time_diff frame_length frame_shiftcCs"t|drdStt|||S)zUConvert duration to an equivalent number of frames, so as to not exceed the duration.r)r rBr )rvrwrxr)r)r*time_diff_to_num_framess rzTpathpatternstrictcCsTt|}|sJd|t||}t|dks(|r(Jd|d||S)z Asserts that ``path`` exists, is a directory and contains at least one file satisfying the ``pattern``. If `strict` is False, then zero matches are allowed. :returns: a list of paths to files matching the ``pattern``. zNo such directory: rzNo files matching pattern "z" in directory: )r is_dirsortedrgloblen)r{r|r}matchesr)r)r*check_and_rglobs r stack_sizec cs@ddl}|}||z dVW||dS||w)z Code executed in this context will be able to recurse up to the specified recursion limit (or will hit a StackOverflow error if that number is too high). Usage: >>> with recursion_limit(1000): >>> pass rN)sysgetrecursionlimitsetrecursionlimit)rrold_sizer)r)r*recursion_limits  r dataclass_objcKst|dii|j|S)a< Returns a new object with the same member values. Selected members can be overwritten with kwargs. It's supposed to work only with dataclasses. It's 10X faster than the other methods I've tried... Example: >>> ts1 = TimeSpan(start=5, end=10) >>> ts2 = fastcopy(ts1, end=12) Nr))type__dict__)rr/r)r)r*fastcopys rit output_dir chunk_sizeprefix num_digits start_idxc CsVddlm}t|}|jddd|dkrd}|}g}t|} zt| } Wn ty0|YSw zhz@d} ||} |||d| d} | |kr_| | | d 7} t| } | |ksNWd n1siwY|d 7}WntyYW| }|d ur| ||SwW| }|d ur| |n| }|d ur| |wwq2) 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. :param num_digits: the width of ``split_idx``, which will be left padded with zeros to achieve it. :param start_idx: The split index to start counting from (default is ``0``). :return: a list of lazily opened chunk manifests. r)SequentialJsonlWriterT)parentsexist_okrsplit.z .jsonl.gzN) lhotse.serializationrr mkdiriternext StopIterationzfill with_suffixwrite open_manifestrR)rrrrrrr split_idxsplitsrQrawrittenidxwriter subcutsetr)r)r*split_manifest_lazys\          rFseq num_splitsshuffle drop_lastc stt}||krtd|d||rt||||}|r2dg|}dg|}nttd|d|g||}dg|dd}fddtt|||D}fd d|D} | S) a Split a sequence into ``num_splits`` equal parts. The element order can be randomized. Raises a ``ValueError`` if ``num_splits`` is larger than ``len(seq)``. :param seq: an input iterable (can be a Lhotse manifest). :param num_splits: how many output splits should be created. :param shuffle: optionally shuffle the sequence before splitting. :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 length ``num_splits`` containing smaller lists (the splits). z(Cannot split iterable into more chunks (z) than its number of items rrNcs.g|]\}}}|||d|gqS)rr)).0i begin_shift end_shift)rr)r* sz"split_sequence..csg|] \}}||qSr)r))rbeginrh)rr)r*rs)listr ValueErrorrIrrangezip) rrrr num_items num_shifts end_shifts begin_shifts split_indicesrr))rrr*split_sequence`s0     rrj sampling_ratecCs0t||}t||}t||d|}|S)zS Compute the number of frames from duration and frame_shift in a safe way. roundrB)rjrxr num_samples window_hop num_framesr)r)r*compute_num_framess  rrcCs$t||}t||d|}|S)z\ Compute the number of frames from number of samples and frame_shift in a safe way. rr)rrxrrrr)r)r*compute_num_frames_from_sampless rsig_lenwin_lenhopcCs:tt||d|}|||dk}|dk|t|S)a, Return a number of windows obtained from signal of length equal to ``sig_len`` with windows of ``win_len`` and ``hop`` denoting shift between windows. Examples: ``` (sig_len,win_len,hop) -> num_windows # list of windows times (1, 6.1, 3) -> 1 # 0-1 (3, 1, 6.1) -> 1 # 0-1 (3, 6.1, 1) -> 1 # 0-3 (5.9, 1, 3) -> 2 # 0-1, 3-4 (5.9, 3, 1) -> 4 # 0-3, 1-4, 2-5, 3-5.9 (6.1, 1, 3) -> 3 # 0-1, 3-4, 6-6.1 (6.1, 3, 1) -> 5 # 0-3, 1-4, 2-5, 3-6, 4-6.1 (5.9, 3, 3) -> 2 # 0-3, 3-5.9 (6.1, 3, 3) -> 3 # 0-3, 3-6, 6-6.1 (0.0, 3, 3) -> 0 ``` :param sig_len: Signal length in seconds. :param win_len: Window length in seconds :param hop: Shift between windows in seconds. :return: Number of windows in signal. r)r maxrB)rrrnbr)r)r*compute_num_windowssrcCsddl}t|jdS)Nr READTHEDOCS)osr:environget)rr)r)r*during_docs_buildsrurlfilenameforce_downloadcompleted_file_size missing_okc stj}|r&|rtdttj}|r%||kr%dSnd}ddi}dd|i|}tj j ||d} |rAdnd } t | fd d } z| | |Wntj j y} zv| jd kr||r|t|d tr{tnU| jdkr| jdd} | durtj j |dd}tj |}|jdddkr|jd}d|} | d|krtdntd| tj j ||ddn| WYd} ~ n d} ~ wwWddSWddS1swYdS)NzQRemoving existing file and downloading from scratch because force_download=True: rz User-AgentzuMozilla/5.0 (Macintosh; Intel Mac OS X 10_12_4) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.1 Safari/603.1.30Rangez bytes={}-)headerszr+bwbc s|dtj|O}d}t|jdd|}t||ddt d} | |}|s3n || t |q+Wdn1sJwYWddSWddS1sbwYdS)Nrizcontent-lengthBT)totalinitialunit unit_scaledesc)seektruncateurllibrequesturlopenrBrrrstrreadrupdater)rqsizeresponser total_sizepbarchunkfrr)r* _downloads2   "z%resumable_download.._downloadiz0 does not exist (error 404). Skipping this file.iz Content-RangeHEAD)methodz Accept-RangesnonezContent-Lengthzbytes */zFile already downloaded: zLServer does not support range requests - attempting downloading from scratch)rr{existsr%infounlinkgetsizeformatrrRequestr"error HTTPErrorcoder&r is_fileremoverrr)rrrrr file_exists file_size ua_headersrreqr-re content_rangehead_reqhead_rescontent_lengthr)rr*resumable_downloadsj             "r  directorytargetcCs|}|}||jvSr0)resolver)r r abs_directory abs_targetr)r)r*_is_within_directory6s rr numeric_ownertarmembersrcCsFt|}|D]}||j}t||stdq|j|||ddS)z Extracts a tar file in a safe way, avoiding path traversal attacks. See: https://github.com/lhotse-speech/lhotse/pull/872 z$Attempted Path Traversal in Tar FilerN)r getmembersnamer Exception extractall)rr{rrmember member_pathr)r)r* safe_extract>s   rrarcCsBt|}|D]}||j}t||stdq|||dS)zM Extracts a rar file in a safe way, avoiding path traversal attacks. z$Attempted Path Traversal in Rar FileN)r infolistrrrr)rr{rrrr)r)r*safe_extract_rarTs   r c@s*eZdZdZd ddZddZddZdS) nullcontextaContext manager that does no additional processing. Used as a stand-in for a normal context manager, when a particular block of code is only sometimes used with a normal context manager: cm = optional_cm if condition else nullcontext() with cm: # Perform operation, using optional_cm if condition is True Note(pzelasko): This is copied from Python 3.7 stdlib so that we can use it in 3.6. NcOs ||_dSr0 enter_result)r`r#argsr/r)r)r*__init__ts znullcontext.__init__cC|jSr0r"rir)r)r* __enter__wsznullcontext.__enter__cGdSr0r))r`excinfor)r)r*__exit__zrcznullcontext.__exit__r0)r1r2r3r4r%r'r*r)r)r)r*r!gs   r!factorcCs2|dkrtnt}ttt||ddjd|dS)zHMimicks the behavior of the speed perturbation on the number of samples.?rndigitsrrounding)rrrBrrquantize)rr+r0r)r)r*perturb_num_samples~sr2cCs"ttt||ddjd|dS)a Convert a time quantity to the number of samples given a specific sampling rate. Performs consistent rounding up or down for ``duration`` that is not a multiply of the sampling interval (unlike Python's built-in ``round()`` that implements banker's rounding). rr-rr/)rBrrr1)rjrr0r)r)r*compute_num_sampless r3durscstfdd|D}|S)z Adds two durations in a way that avoids floating point precision issues. The durations in seconds are first converted to audio sample counts, then added, and finally converted back to floating point seconds. c3s|] }t|dVqdS)rN)r3)rrTr5r)r* s  z add_durations..sum)rr4tot_num_samplesr)r5r* add_durationss r:centerrg new_duration direction)r;leftrightrIcCs||kr||fS|dkr|||d}n(|dkr |||}n|dkr'|}n|dkr6t||||}ntd||dkrKt||dd }d}t|dd |fS) a Compute the new value of "start" for a time interval characterized by ``start`` and ``duration`` that is being extended to ``new_duration`` towards ``direction``. :return: a new value of ``start`` and ``new_duration`` -- adjusted for possible negative start. r;rr>r?rIzUnexpected direction: rr-)rIuniformrr)rgrjr<r= new_startr)r)r*'compute_start_duration_for_extended_cuts rCcat#values delimiter return_firstcCsBt|}t|dkr dSt|dks|r|dS|t|g|S)Nrr)rrjoinr )rFrrGrHr)r)r*merge_items_with_delimiters  rJcGsdd|D}t|dkS)NcSsg|]}|duqSr0r))rargr)r)r*rsz(exactly_one_not_null..rr7)r$not_nullr)r)r*exactly_one_not_nulls rM max_framescCsHt|j||d}t|j||d}|r |||}|dkr ||8}||fS)z Utility to convert a supervision's time span into a tuple of ``(start_frame, num_frames)``. When ``max_frames`` is specified, it will truncate the ``num_frames`` (if necessary). )rxrr)rrgrj) supervisionrxrrN start_framerdiffr)r)r*supervision_to_framess  rR max_samplescCsDt|j|d}t|j|d}|r|||}|dkr||8}||fS)z Utility to convert a supervision's time span into a tuple of ``(start_sample num_samples)``. When ``max_samples`` is specified, it will truncate the ``num_samples`` (if necessary). r5r)r3rgrj)rOrrS start_samplerrQr)r)r*supervision_to_sampless rUcCs|dup||kSr0r))r8 thresholdr)r)r* is_none_or_gtsrWothercCs"t|}t|}t|t|Sr0)to_listsetissubset)r8rXr)r)r*is_equal_or_containssr\modulescsddltfdd|DS)aReturns if a top-level module with :attr:`name` exists *without** importing it. This is generally safer than try-catch block around a `import X`. It avoids third party libraries breaking assumptions of some of our tests, e.g., setting multiprocessing start method when imported (see librosa/#747, torchvision/#544). Note: "borrowed" from torchaudio: https://github.com/pytorch/audio/blob/6bad3a66a7a1c7cc05755e9ee5931b7391d2b94c/torchaudio/_internal/module_utils.py#L9 rNc3s |] }j|duVqdSr0)util find_spec)rm importlibr)r*r6sz&is_module_available..)rball)r]r)rar*is_module_availables rdcCsRt||gddd\}}|j|j}|dkrdSt|j|j|j|j}||S)z Given two objects with "start" and "end" attributes, return the % of their overlapped time with regard to the shorter of the two spans. .cSr&r0)rgrar)r)r*rH#sz!measure_overlap..)rVrry)rrhrgmin)rnrooverlapped_areadurr)r)r*measure_overlaps  riraalt_itemcCs|dur|S|S)z.wrapper functoolswraps)rrr)rr*rich_exception_infoLsrc@ eZdZdS)NonPositiveEnergyErrorNr1r2r3r)r)r)r*rYrc@r)DeprecatedWarningNrr)r)r)r*r_rrcsfdd}|S)zFlags a method as deprecated. Args: message: A human-friendly string of instructions, such as: 'Please migrate to add_proxy() ASAP.' cstfdd}|S)zThis is a decorator which can be used to mark functions as deprecated. It will result in a warning being emitted when the function is used.cs4tj}tjtt|j|jd|i|S)N)categoryrlineno) inspect currentframef_backwarnings warn_explicitrgetfilef_codef_lineno)r$r/frame)funcmessager)r*ros  z.deprecated..decorator..wrapperr)rrr)rr* decoratorjs zdeprecated..decoratorr))rrr)rr* deprecatedcs rc@s4eZdZdZdddefddZddZd d Zd S) suppress_and_warnaqContext manager to suppress specified exceptions that logs the error message. After the exception is suppressed, execution proceeds with the next statement following the with statement. >>> with suppress_and_warn(FileNotFoundError): ... os.remove(somefile) >>> # Execution still resumes here if the file was already removed T)enabledrcGs||_||_dSr0)_enabled _exceptions)r`r exceptionsr)r)r*r%s zsuppress_and_warn.__init__cCr(r0r)rir)r)r*r'rczsuppress_and_warn.__enter__cCs>|jsdS|duot||j}|rtd|jd||S)Nz [Suppressed z] Error message: )r issubclassrr%r&r3)r`exctypeexcinstexctbshould_suppressr)r)r*r*szsuppress_and_warn.__exit__N)r1r2r3r4r:r%r'r*r)r)r)r*rs   r'databufsizerngc cs|durt}g}d}|D]G}t||kr(z |t|Wn ty'Ynwt|dkrA|dt|d}|||}||<|rOt||krO||q d}|Vq |D]}|VqWdS)a* Shuffle the data in the stream. This uses a buffer of size ``bufsize``. Shuffling at startup is less random; this is traded off against yielding samples quickly. This code is mostly borrowed from WebDataset; note that we use much larger default buffer size because Cuts are very lightweight and fast to read. https://github.com/webdataset/webdataset/blob/master/webdataset/iterators.py#L145 .. warning: The order of the elements is expected to be much less random than if the whole sequence was shuffled before-hand with standard methods like ``random.shuffle``. :param data: iterator :param bufsize: buffer size for shuffling :param rng: either random module or random.Random instance :return: a generator of cuts, shuffled on-the-fly. NTrrF)rIrrRrrrandint)rrrbufstartupsamplerXr)r)r*streaming_shuffles.    rcCs,ddlm}||\}}t|dt||S)z$s -> (s0,s1), (s1,s2), (s2, s3), ...r)teeN) itertoolsrrr)rdrarr)r)r*pairwises    rc @seZdZdZdddddededed eefd d Z d d Z ddZ defddZ ddZ ddZddZddZddZddZdd Zd!d"ZdS)#PipeaWrapper class for subprocess.Pipe. This class looks like a stream from the outside, but it checks subprocess status and handles timeouts with exceptions. This way, clients of the class do not need to know that they are dealing with subprocesses. Note: This class is based on WebDataset and modified here. Original source is in https://github.com/webdataset/webdataset :param *args: passed to `subprocess.Pipe` :param **kw: passed to `subprocess.Pipe` :param timeout: timeout for closing/waiting :param ignore_errors: don't raise exceptions on subprocess errors :param ignore_status: list of status codes to ignore g @FN)timeout ignore_errors ignore_statusr-rrrc Osddlm}m}||_ddgt|g|_||_||f|_|ddkrB|||d|vd||_|jj |_ |j durAt |dn$|dd krf|||d|vd ||_|jj |_ |j durft |dd|_ dS) zCreate an IO Pipe.r)PIPEPopenrr)stdouttextNz: couldn't openw)stdinr) subprocessrrrrkrrr$procrstreamrrstatus) r`r-rrrr$kwrrr)r)r*r%s"         z Pipe.__init__cCsd|jdS)Nz)r$rir)r)r*__str__ z Pipe.__str__cCs"|j}|dur|dSdS)z'Poll the process and handle any errors.N)rpollwait_for_child)r`rr)r)r* check_status s  zPipe.check_statusr9cCs|jduSr0)rrrir)r)r* is_runningrzPipe.is_runningcCsL|jdurdS|j|_|j|jvr"|js$t|jd|jddSdS)z>Check the status variable and raise an exception if necessary.Nz: exit z (read))rrwaitrrrr$rir)r)r*rs  zPipe.wait_for_childcO|jj|i|}||S)z#Wrap stream.read and checks status.)rrrr`r$rr>r)r)r*rz Pipe.readcOr)z$Wrap stream.write and checks status.)rrrrr)r)r*r#rz Pipe.writecOs*|jj|i|}|j|_||S)z'Wrap stream.readLine and checks status.)rreadlinerrrrrr)r)r*r)s z Pipe.readlinecCs&|j|j|j|_|dS)z>Wrap stream.close, wait for the subprocess, and handle errors.N)rcloserrrrrrir)r)r*r0s  z Pipe.closeccs(|}|r|V|}|sdSdSr0)r)r`retvalr)r)r*__iter__6s  z Pipe.__iter__cCs|S)Context handler.r)rir)r)r*r'<szPipe.__enter__cCs |dS)rN)r)r`etyper8 tracebackr)r)r*r*@rkz Pipe.__exit__)r1r2r3r4rfloatr:rrr%rrrrrrrrrr'r*r)r)r)r*rs2  rc@seZdZddZdS)PythonLiteralOptioncCsNz t|}t|tst|trt|dkr|dWS|WS|WSYdS)Nrr)ast literal_evalrlrrmr)r`ctxr8rWr)r)r*type_cast_valueGs z#PythonLiteralOption.type_cast_valueN)r1r2r3rr)r)r)r*rFs rcCstdS)N torchaudio)rdr)r)r)r*is_torchaudio_availableRsrrJtrngcCs|dkrtSt|S)Nr)secrets SystemRandomrIrN)rJr)r)r* build_rngVs rcCstptjdS)NLHOTSE_DILL_ENABLED)_LHOTSE_DILL_ENABLEDrrr)r)r)r*is_dill_enabled`rrcCst|}|j|d}t|S)N)r<)r_replacer) identifier profile_nameparsed_identifierupdated_identifierr)r)r* replace_bucket_with_profile_nameds r)rq)T)rrr)FF)FNF)rN)r;)rDrEFr0)rN)rrrsrr%mathrrIrrrrCr contextlibrr dataclassesrrdecimalrrrrr r r pathlibr typingr rrrrrrrrrrrr urllib.parserrclicknumpyrKrL tqdm.autorrPathlikerrrlDecibelsINT16MAXEPSILONlog LOG_EPSILONDEFAULT_PADDING_VALUErr5rr:r?rBrOrPr\r]rfrprurzrrrrrrrrrr rrr r!r2r3r:rCrJrMrRrUrWr\rdrirkrYrnrw IntTensorTensorrrrr UserWarningrrrrNrrrOptionrrrrrrr)r)r)r*s   <   H        B  4     e          &        "  !  / m