o i'@sxdZddlZddlZddlZddlmZddlmZmZm Z e e Z e dZedZdddfd d dfd d dffZd ZdZdZdZejGdddZdedefddZdedefddZ   d,de eeddfeefdeded edeeddff d!d"Zd#eddfd$d%Z    d-de eeddfeefd&eded'e edfdedef d(d)ZGd*d+d+eZ dS).aA tiny library for composing SRT files. Based on https://github.com/cdown/srt with parsing, subtitle modifying functionality and Python 2 support removed. This is because of https://github.com/rany2/edge-tts/issues/383. Typing support was added, and more Python 3 features were used. Copyright (c) 2014-2023 Christopher Down Copyright (c) 2025- rany This file is licensed under the MIT License (MIT). See the LICENSE-MIT file for details. N) timedelta) GeneratorListUnionz\n\n+z No contentcCs |j SN)contentstripsubr O/home/kim/smarthome/.venv/lib/python3.10/site-packages/edge_tts/srt_composer.py r zStart time < 0 secondscCs |jtkSr)startZERO_TIMEDELTAr r r r r s zSubtitle start time >= end timecCs |j|jkSr)rendr r r r r ri<ic @seZdZdZdeedfdedededdf dd Zdefd d Z d e de fd dZ d e de fddZ defddZddeedfdefddZdS)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 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. indexNrrrreturncCs||_||_||_||_dSr)rrrr)selfrrrrr r r __init__=s zSubtitle.__init__cCsttt|Sr)hash frozensetvarsitems)rr r r __hash__EszSubtitle.__hash__othercCst|tstSt|t|kSr) isinstancerNotImplementedrrrr r r __eq__Hs zSubtitle.__eq__cCs.t|tstS|j|j|jf|j|j|jfkSr)rrr rrrr!r r r __lt__Ns zSubtitle.__lt__cCsFtt|dtt|d}ddd|D}t|jd|dS)N iteritemsrz, css"|] \}}|d|VqdS)=Nr ).0kvr r r [s z$Subtitle.__repr__..())getattrrjointype__name__)rZ var_itemsZ item_listr r r __repr__XszSubtitle.__repr__eolcCsVt|j}|dur d}n |dkr|d|}d}|j|jpdt|jt|j||dS)a% Convert the current :py:class:`Subtitle` to an SRT block. :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 N z3{idx}{eol}{start} --> {end}{eol}{content}{eol}{eol}r)idxrrrr1)make_legal_contentrreplaceformatrtimedelta_to_srt_timestamprr)rr1Zoutput_contenttemplater r r to_srt^s  zSubtitle.to_srtr)r/ __module__ __qualname____doc__rintrstrrrobjectboolr"r#r0r9r r r r r)s$   rrrcCs@|r|ddkrd|vr|Std|d}td|||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 rr2z zLegalised content %r to %r)MULTI_WS_REGEXr rLOGinfo)rZ legal_contentr r r r4xs r4timedelta_timestampcCsht|jt\}}||jt7}t|t\}}|jt}t|ddt|ddt|ddt|dS)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 Z02:,Z03) divmodsecondsSECONDS_IN_HOURdays HOURS_IN_DAYSECONDS_IN_MINUTE microsecondsMICROSECONDS_IN_MILLISECONDr=)rDZhrsZsecs_remainderZminsZsecsmsecsr r r r7s  2r7FT subtitles start_indexin_placeskipc csd}tt||dD]J\}}|stdit|}|rMzt|Wn*tyL}z|jdur6td|ntd|j||d7}WYd}~q d}~ww|||_|Vq dS)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: %srPr ) enumeratesortedrr_should_skip_sub_ShouldSkipExceptionrrBrC)rQrRrSrTZ skipped_subsZsub_numsubtitleZ thrown_excr r r sort_and_reindexs**    rZrYcCs"tD] \}}||rt|qdS)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_CONDITIONSrX)rYZinfo_msgZ sub_skipperr r r rWs rWreindexr1cs*|r t|||d}dfdd|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 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 )rRrSc3s|] }|jdVqdS)r1N)r9)r&rYr^r r r) szcompose..)rZr-)rQr\rRr1rSr r^r composes "r_c@seZdZdZdS)rXz3 Raised when a subtitle should be skipped. N)r/r:r;r<r r r r rX#srX)rPFT)TrPNF)!r< functoolsloggingredatetimertypingrrr getLoggerr/rBcompilerArr[rIrLrKrNtotal_orderingrr>r4r7r=r@rZrWr_ ExceptionrXr r r r sl      N  A  *