w;3hH 0dZddlmZddlZddlZddlmZddlZddlZeje Z dZ dZ dZdje je gd ze d egZd j#dje jd e zd zgd ze d d ed gZdZdZdZdZej.eZej.dZej.dj#eeeeeej4ZedZddfddfddffZdZdZdZ dZ! e"ejFfZ$ejLGdd e'Z(d!Z)d"Z*d#Z+d/d$Z,d%Z-d0d&Z.d'Z/ d1d(Z0Gd)d*e1Z2Gd+d,e3Z4Gd-d.e1Z5y#e%$rejFfZ$YlwxYw)2z?A tiny library for parsing, modifying, and composing SRT files.)unicode_literalsN) timedeltau[,.:，．。：]z[0-9]+z[0-9]*?z^{}$()z-?[0-9]+\.?[0-9]*z[^\r\n]*z.*?z\r?\nz\n\n+z\s*(?:({idx})\s*{eof})?({ts}) *-[ -] *> *({ts}) ?({proprietary})(?:{eof}|\Z)({content})(?:{eof}|\Z)(?:{eof}|\Z|(?=(?:{idx}\s*{eof}{ts})))(?=(?:(?:{idx}\s*{eof})?{ts}|\Z)))idxts proprietarycontenteofz No contentc8|jj SN)r stripsubs C/var/www/html/audio-gradio/venv/lib/python3.12/site-packages/srt.pyrQs3;;#4#4#66zStart time < 0 secondsc(|jtkSr)startZERO_TIMEDELTArs rrrRs399~+ErzSubtitle start time >= end timec4|j|jk\Sr)rendrs rrrSsCII4Hri<ic8eZdZdZd dZdZdZdZdZd dZ y) Subtitlea: The metadata relating to a single subtitle. Subtitles are sorted by start time by default. If no index was provided, index 0 will be used on writing an SRT block. :param index: The SRT index for this subtitle :type index: int or None :param start: The time that the subtitle should start being shown :type start: :py:class:`datetime.timedelta` :param end: The time that the subtitle should stop being shown :type end: :py:class:`datetime.timedelta` :param str proprietary: Proprietary metadata for this subtitle :param str content: The subtitle content. Should not contain OS-specific line separators, only \\n. This is taken care of already if you use :py:func:`srt.parse` to generate Subtitle objects. cJ||_||_||_||_||_yrindexrrr r )selfr"rrr r s r__init__zSubtitle.__init__vs&   &rcXttt|jSr)hash frozensetvarsitems)r#s r__hash__zSubtitle.__hash__}sId4j..0122rc0t|t|k(Sr)r(r#others r__eq__zSubtitle.__eq__sDzT%[((rc|j|j|jf|j|j|jfkSr)rrr"r,s r__lt__zSubtitle.__lt__s< DHHdjj1 KK II KK5   rc tt|dtt|d}djd|D}t|jd|dS)N iteritemsr)z, c30K|]\}}|d|yw)=N).0kvs r z$Subtitle.__repr__..sG41aA.Gsrr )getattrr(jointype__name__)r# var_items item_lists r__repr__zSubtitle.__repr__sJDJ WT$Z5QR IIG9;GG :.. ::rc,|j}|j}|rd|z}|r t|}|d}n|dk7r|jd|}d}|j |j xsdt |jt |j|||S)a Convert the current :py:class:`Subtitle` to an SRT block. :param bool strict: If disabled, will allow blank lines in the content of the SRT block, which is a violation of the SRT standard and may cause your media player to explode :param str eol: The end of line string to use (default "\\n") :returns: The metadata of the current :py:class:`Subtitle` object as an SRT formatted subtitle block :rtype: str   z9{idx}{eol}{start} --> {end}{prop}{eol}{content}{eol}{eol}r)r rrpropr eol) r r make_legal_contentreplaceformatr"timedelta_to_srt_timestamprr)r#strictrEoutput_contentoutput_proprietarytemplates rto_srtzSubtitle.to_srts!-- "%'9!9  /?N ;C D[+33D#>NN a,TZZ8*4884#"   rN)r)TrC) r= __module__ __qualname____doc__r$r*r.r0r@rNr5rrrras%&'3) ; $ rrc|r|ddk7rd|vr|Stjd|jd}tj d|||S)aL Remove illegal content from a content block. Illegal content includes: * Blank lines * Starting or ending with a blank line .. doctest:: >>> make_legal_content('\nfoo\n\nbar\n') 'foo\nbar' :param str content: The content to make legal :returns: The legalised content :rtype: srt rrCz zLegalised content %r to %r)MULTI_WS_REGEXrrLOGinfo)r legal_contents rrFrFsP&71:%&*?"&&tW]]4-@AMHH )7MB rct|jt\}}||jtzz }t|t \}}|j tz}d||||fzS)a Convert a :py:class:`~datetime.timedelta` to an SRT timestamp. .. doctest:: >>> import datetime >>> delta = datetime.timedelta(hours=1, minutes=23, seconds=4) >>> timedelta_to_srt_timestamp(delta) '01:23:04,000' :param datetime.timedelta timedelta_timestamp: A datetime to convert to an SRT timestamp :returns: The timestamp in SRT format :rtype: str z%02d:%02d:%02d,%03d)divmodsecondsSECONDS_IN_HOURdays HOURS_IN_DAYSECONDS_IN_MINUTE microsecondsMICROSECONDS_IN_MILLISECOND)timedelta_timestamphrssecs_remainderminssecsmsecss rrIrIsh"!!4!>> srt_timestamp_to_timedelta('01:23:04,000') datetime.timedelta(seconds=4984) :param str timestamp: A timestamp in SRT format :returns: The timestamp as a :py:class:`~datetime.timedelta` :rtype: datetime.timedelta :raises TimestampParseError: If the timestamp is not parseable zUnparseable timestamp: {}r)hoursminutesrY milliseconds)TS_REGEXmatchTimestampParseErrorrHgroupsintr) timestamprkmrarcrdres rsrt_timestamp_to_timedeltarqso NN9 %E }!"="D"DY"OPP:?,,.IQc!fq0ICtU 3d OOJsA1c#nKd}tt||D]7\}}|stdit|}|r t |||z |_|9y#t $rS}|j tjd|n!tjd|j ||dz }Yd}~d}~wwxYww)a Reorder subtitles to be sorted by start time order, and rewrite the indexes to be in that same order. This ensures that the SRT file will play in an expected fashion after, for example, times were changed in some subtitles and they may need to be resorted. If skip=True, subtitles will also be skipped if they are considered not to be useful. Currently, the conditions to be considered "not useful" are as follows: - Content is empty, or only whitespace - The start time is negative - The start time is equal to or later than the end time .. doctest:: >>> from datetime import timedelta >>> one = timedelta(seconds=1) >>> two = timedelta(seconds=2) >>> three = timedelta(seconds=3) >>> subs = [ ... Subtitle(index=999, start=one, end=two, content='1'), ... Subtitle(index=0, start=two, end=three, content='2'), ... ] >>> list(sort_and_reindex(subs)) # doctest: +ELLIPSIS [Subtitle(...index=1...), Subtitle(...index=2...)] :param subtitles: :py:class:`Subtitle` objects in any order :param int start_index: The index to start from :param bool in_place: Whether to modify subs in-place for performance (version <=1.0.0 behaviour) :param bool skip: Whether to skip subtitles considered not useful (see above for rules) :returns: The sorted subtitles :rtype: :term:`generator` of :py:class:`Subtitle` objects r)rNz"Skipped subtitle with no index: %sz Skipped subtitle at index %d: %sr5) enumeratesortedrr(_should_skip_sub_ShouldSkipExceptionr"rTrU) subtitles start_indexin_placeskip skipped_subssub_numsubtitle thrown_excs rsort_and_reindexrsJL&vi'8 L1$x.1H   *!</'( >>)HHA:NHH:HNNJ!  s/7B5 AB5 B2A B-(B5-B22B5cFtD]\}}||st|y)z Check if a subtitle should be skipped based on the rules in SUBTITLE_SKIP_CONDITIONS. :param subtitle: A :py:class:`Subtitle` to check whether to skip :raises _ShouldSkipException: If the subtitle should be skipped N)SUBTITLE_SKIP_CONDITIONSrw)r~info_msg sub_skippers rrvrv<s+":1+ x &x0 01rc#*Kd}t|tr|j}tj |D]}|j }t |||||j\}}}}} | jdd} t|}t|t|t|| ||j}t ||t!||y#t$r t|jdd}Yvt$rYwxYww)aZ Convert an SRT formatted string (in Python 2, a :class:`unicode` object) to a :term:`generator` of Subtitle objects. This function works around bugs present in many SRT files, most notably that it is designed to not bork when presented with a blank line as part of a subtitle's content. .. doctest:: >>> subs = parse("""\ ... 422 ... 00:31:39,931 --> 00:31:41,931 ... Using mainly spoons, ... ... 423 ... 00:31:41,933 --> 00:31:43,435 ... we dig a tunnel under the city and release it into the wild. ... ... """) >>> list(subs) # doctest: +ELLIPSIS [Subtitle(...index=422...), Subtitle(...index=423...)] :param srt: Subtitles in SRT format :type srt: str or a file-like object :param ignore_errors: If True, garbled SRT data will be ignored, and we'll continue trying to parse the rest of the file, instead of raising :py:class:`SRTParseError` and stopping execution. :returns: The subtitles contained in the SRT file as :py:class:`Subtitle` objects :rtype: :term:`generator` of :py:class:`Subtitle` objects :raises SRTParseError: If the matches are not contiguous and ``ignore_errors`` is False. rz rC.r!N) isinstance FILE_TYPESread SRT_REGEXfinditerr_check_contiguityrmrGrn ValueErrorsplit TypeErrorrrqrlen) srt ignore_errorsexpected_startrk actual_start raw_index raw_startraw_endr r s rparserIsJN#z"hhj##C(%{{} #~|]K>Clln; 9g{G //&$/ II,Y7*73#   ?%Bc>3s8]C+ 5 IOOC034I   s7BD CAD&DDD DDDc||k7rF|||}|dk(r|js|dk(ry|rtjd|yt|||y)a< If ``warn_only`` is False, raise :py:class:`SRTParseError` with diagnostic info if expected_start does not equal actual_start. Otherwise, log a warning. :param str srt: The data being matched :param int expected_start: The expected next start, as from the last iteration's match.end() :param int actual_start: The actual start, as from this iteration's match.start() :raises SRTParseError: If the matches are not contiguous and ``warn_only`` is False ruNz Skipped unparseable SRT data: %r)isspacerTwarning SRTParseError)rrr warn_onlyunmatched_contents rrrsb%|< Q   % % '+<+H   KK:OP P&rc\|rt|||}djfd|DS)a Convert an iterator of :py:class:`Subtitle` objects to a string of joined SRT blocks. .. doctest:: >>> from datetime import timedelta >>> start = timedelta(seconds=1) >>> end = timedelta(seconds=2) >>> subs = [ ... Subtitle(index=1, start=start, end=end, content='x'), ... Subtitle(index=2, start=start, end=end, content='y'), ... ] >>> compose(subs) # doctest: +ELLIPSIS '1\n00:00:01,000 --> 00:00:02,000\nx\n\n2\n00:00:01,000 --> ...' :param subtitles: The subtitles to convert to SRT blocks :type subtitles: :term:`iterator` of :py:class:`Subtitle` objects :param bool reindex: Whether to reindex subtitles based on start time :param int start_index: If reindexing, the index to start reindexing from :param bool strict: Whether to enable strict mode, see :py:func:`Subtitle.to_srt` for more information :param str eol: The end of line string to use (default "\\n") :returns: A single SRT formatted string, with each input :py:class:`Subtitle` represented as an SRT block :param bool in_place: Whether to reindex subs in-place for performance (version <=1.0.0 behaviour) :rtype: str )ryrzrc3DK|]}|jyw))rJrEN)rN)r6r~rErJs rr9zcompose..sUx8??&c?:Us )rr;)rxreindexryrJrErzs `` rcomposers1@$ ;  77U9U UUrc"eZdZdZfdZxZS)raR Raised when part of an SRT block could not be parsed. :param int expected_start: The expected contiguous start index :param int actual_start: The actual non-contiguous start index :param str unmatched_content: The content between the expected start index and the actual start index cfd|||fz}tt| |||_||_||_y)NzmExpected contiguous start of match or end of input at char %d, but started at char %d (unmatched content: %r))superrr$rrr)r#rrrmessage __class__s rr$zSRTParseError.__init__sG =|->? @  mT+G4,(!2r)r=rOrPrQr$ __classcell__)rs@rrrs 3 3rrceZdZdZy)rlz; Raised when an SRT timestamp could not be parsed. Nr=rOrPrQr5rrrlrlrrlceZdZdZy)rwz3 Raised when a subtitle should be skipped. Nrr5rrrwrwrrrw)rsFT)F)TrsTNF)6rQ __future__r functoolsredatetimerloggingio getLoggerr=rTRGX_TIMESTAMP_MAGNITUDE_DELIMRGX_TIMESTAMP_FIELDRGX_TIMESTAMP_FIELD_OPTIONALr; RGX_TIMESTAMPrHRGX_TIMESTAMP_PARSEABLE RGX_INDEXRGX_PROPRIETARY RGX_CONTENTRGX_POSSIBLE_CRLFcompilerjrSDOTALLrrrrZr]r\r_fileIOBaser NameErrortotal_orderingobjectrrFrIrqrrvrrr Exceptionrrrlrwr5rrrs9F'  g! !5(%**,?+@1+DE% $  "..GG ) . .6I0IC0O/PST/T U )   (      !   2::- .H% BJJ)"*0  #  *0*II3  8167EF&(HI  " "J  R vR R j6<0P,9x 1MD`Q>MR%VP3I3.* 9 ))JsFFF