^j<bddlmZddlmZddlmZmZddlmZm Z m Z ddd dZ Gd d Z y) ) annotations)Any)STREAMABLE_PARSERS process_field)ResponseTemplateResponseTemplateFieldload_response_templateNprefixc~t|}t||}|j||j\}}|S)zThe main function for response parsing when you don't want streaming. Takes generated output and the prompt prefix and parses them without streaming any events, then returns the parsed message. r )r ResponseParserfeedfinalize)textresponse_templater streammessage_s z/var/www/ramen.bs-engineer-server.com/venv/lib/python3.12/site-packages/transformers/utils/chat_parsing/response_parser.pyparse_responsers>//@A -f =F KK"JGQ Nc~eZdZdZdddZddZddZddZddZddZ dd Z dd Z dd Z dd Z dd ZddZy)raJThis class implements a streaming parser with a `response_template`. If you don't need streaming and just want to parse a complete message, use the `parse_response` function above. Streaming parsing emits events indicating when regions (message fields) are opened and closed, with the model writing to the region that is currently open. Usage: parser = ResponseParser(response_template, prefix=chat_prompt) for event in parser.initial_events: handle(event) for chunk in model_text_stream: for event in parser.feed(chunk): handle(event) message, final_events = parser.finalize() for event in final_events: handle(event) Events can be either "region_open", "region_chunk", or "region_close". ResponseParser requires the chat `prefix` (i.e. the chat history, the prefill before the current generation). This is because chat templates or assistant prefills can sometimes write part of the message, and if we only see the model output, and not the template, then we can't reliably parse the message in those cases. Any events produced while consuming the prefix are exposed as `initial_events`, so renderers can show prefill regions before the model writes anything; closed prefill regions also land in the output dict. Ncht||_| tdd|_d|_t |jj |_|jj|_ |j|_ i|_ d|_ d|_ d|_g|_|r|j!|yy)Nah`ResponseParser`/`parse_response` requires `prefix` (the chat prompt sent to the model before generation), because chat templates often pre-write part of the assistant message (e.g. an opening `` tag) that the parser must see to parse the output correctly. If the generation already contains the complete message, pass `prefix=""` to opt out explicitly.rF)r _spec ValueError_buffer_posdictdefaults_outputimplicit_implicit_name_current _captures_body_opened _finalizedinitial_events_consume_prefix)selfrr s r__init__zResponseParser.__init__<s+,=> >a    '+DJJ,?,?'@ *.***=*= %)$7$7 )+ " %*,    ( rc|jj|}|sy||_|j|jdy)aLoads the prefix (the chat prefill sent to the model), right-truncates it to the start of the assistant message (as determined by start_anchor) and then runs the remainder through the parser. Events produced while processing the prefix are stashed on `initial_events` so callers can replay them into a renderer before feeding model output. Think of this as the "get the parser up to speed on the story so far" method. NFeos)rtruncate_past_last_anchorr_processr*)r,r truncateds rr+zResponseParser._consume_prefixVs;JJ88@     d))u 5rc|jr td|r|xj|z c_g}|j|d|S)zFeeds more text/tokens from the model output into the tokenizer, and returns any events that result (regions entered or left). This is the method you want to call after each generation step. ResponseParser already finalizedFr/)r) RuntimeErrorrr2)r,reventss rrzResponseParser.feeddsB ??AB B  LLD L f% ( rcdd}|jr tdg}|j|d|jjj Dcgc]#\}}|j r||jvs"|%}}}|rtd||jj}|jj Dcic]\}}||vs ||r||c}}|_d|_|j|fScc}}wcc}}w)aClose the stream and return the final message dict together with any finalization events. This is necessary because some regions may only end at the end of the sequence, so you won't see the event telling you they're ready until the sequence is finalized.cN|duxs t|tttfxr| SN) isinstancelistr str)vs r _is_emptyz*ResponseParser.finalize.._is_emptyus&9LAdC/@!A!K!e Lrr5Tr/z>Required response_template fields missing from parsed output: )r>rreturnbool) r)r6r2rfieldsitemsoptionalr"rr!) r,r?r7nfmissingr!kr>s rrzResponseParser.finalizeos  M ??AB B f$ '!%!2!2!8!8!:gA!**QRZ^ZfZfQf1gg ]^e]fgh h::&&)-););)=cAhV_`aVb1c ||V## hdsC>-C><C>DDc| |j}|j||\}}||\}}}|j|jkDr7|j ||j |j|j|j |_|dk(r%|j||j|||nA|j} |j|| s"|j|j k(ry|rw|jt|j krC|j ||j |jdt|j |_|j|y||jkDr0|j ||j |j|||_y)Nopen) _watchlist_scanstartr _accumulaterend_close_current_open_explicitr(len) r,r7r0watchbest hold_startkindfieldm had_contents rr2zResponseParser._processsjOO%E#zz%5 D*!%eQ779tyy($$VT\\$))aggi-PQEEG 6>''/''q9#',,K''/'1779+?99s4<<00$$VT\\$))+-FG #DLL 1DI##F+ DII%  dii*)MN& rc|jO|j|jk7r6|jj|j}|jd|fgSgSg}|jjj D]"}|j |jd|f$|jB|jj|j}|j|jd|f|S)zPatterns we care about right now: the close of the currently-open explicit region, or -- if we're in the implicit/null region -- every explicit open plus the implicit's own close (if any).closerJ)r%r$rrBclose_revaluesopen_reappend)r,rWrSimpls rrKzResponseParser._watchlists == $$:M:M)MJJ%%dmm4E).)CWe$% K K9;ZZ&&--/ .E}}( fe_- .    *::$$T%8%89D}}( gt_- rcd}d}t|j}|D]\}}|dk(r |jn |j}|r'|j |j|j } n(|j |j|j d} | x|s:| j s|j||| rt|| j}| j| j| jz |dk(rdnd|jf} || |ks| ||| f}} ||dj|k\rd}||fS)aHSingle pass over the watched delimiters, using the `regex` module's partial matching to decide -- per delimiter -- whether it can be committed now or must be held. Returns `(best, hold_start)`: * `best` is the earliest-starting delimiter we can safely commit *now* (longest on ties, opens before closes), or `None`. * `hold_start` is the leftmost buffer position occupied by a still-pending match: a partial (incomplete) delimiter, or a complete one ending at the buffer edge that more input could still grow. Bytes before it are safe to emit; bytes from it onward must be held. It stays `len(self._buffer)` when nothing is pending, letting the caller flush the whole buffer. A complete match is committable only if it starts strictly before `hold_start` -- otherwise an earlier (or co-located) pending delimiter could turn out to be the real one. At EOS nothing can grow, so partial matching is skipped and every complete match is committable. (The `regex` module always reports the empty string as a live prefix, so a partial search with no real match returns a zero-width match at the buffer end; that lands in the pending branch with `start == len(self._buffer)`, a no-op for `hold_start`.) NrJT)partialrr) rRrr^r\searchrrb _can_growminrMrOname) r,rSr0best_keyrTrUrVrWpatternrXkeys rrLzResponseParser._scans,2"&>B&   7KD%'+v~emm5>>GNN4<<;NN4<<DNIyAIIeQ)G QWWY7 779!'') 3446>aqRWR\R\]C3>!$tUA&6$ 7$  Q : =DZrc|jt|jk7ry|j|jk(ry|dk(r|j|j fn|j |jf\}}|duxs|S)a1Whether a *complete* match ending at the current buffer edge could still change as more input arrives -- in which case we defer rather than commit. A match ending before the edge has already seen its terminating byte and is final. At the edge: zero-width matches (`$` / `\Z`) are only real at true EOS; a fully-present literal that no other literal in its set extends cannot grow (the fast path that keeps literal delimiters zero-latency); anything else (regex delimiters, prefix-overlapping literal lists) might.FTrJN)rOrRrrM open_literalsopen_literal_can_extendclose_literalsclose_literal_can_extend)r,rVrWrXliterals can_extends rrezResponseParser._can_grows 557c$,,' ' 779 v~ %"?"? @&&(F(FG * 4-:-rcX|r |jy|jj|j}|js%|j d|jdd|_|xj |z c_|j tv}|j d|j||dy)aRoute `text` into the currently active region. When the current region is the null sink (no implicit declared, no explicit open), we silently discard. Every routed chunk emits a `region_chunk` event so consumers can render live; `dirty=True` flags chunks from structured parsers (json, xml-inline, kv-lines) whose raw bytes will only be parsed into the final value on close.N region_opentyperWT region_chunk)rurWrdirty)r%rrBr(r_r'contentr)r,r7rrWrws rrNzResponseParser._accumulatest}},  !!$--0|| MM=4==I JDL d  %77 ~ t^cderc|j|_|jjDcic] \}}| || c}}|_d|_d|_|jd|jdycc}}w)NrTrsrt)rgr% groupdictrCr&r'r(r_)r,r7rWrXrHr>s rrQzResponseParser._open_explicitsc  +,;;=+>+>+@R41aAM!Q$R   }uzzBCSs A9A9c|j |js|jy|jj|j}t |j ||j}|jr6|jj|jgj|n||j|j<|jd|j|d|jy)zClose the current region and reset to the implicit/null region. Skipped (aside from the reset) when the current region never opened -- avoids vacuous open/close pairs at every explicit boundary.N region_close)rurWvalue) r%r(_reset_to_implicitrrBrr'r&repeatsr" setdefaultr_)r,r7rWr}s rrPzResponseParser._close_currents ==   # # %  !!$--0djj%@ == LL # #DMM2 6 = =e D*/DLL ' ~ PUVW !rcP|j|_i|_d|_d|_y)NrF)r$r%r&r'r()r,s rr~z!ResponseParser._reset_to_implicit)s$++   rr:)rdict | ResponseTemplater str | None)r r=r@None)rr=r@ list[dict])r@ztuple[dict, list[dict]])r7rr0rAr@r)r@'list[tuple[str, ResponseTemplateField]])rSrr0rAr@z9tuple[tuple[str, ResponseTemplateField, Any] | None, int])rVr=rWr rXrr@rA)r7rrr=r@r)r7rrWr rXrr@r)r7rr@r)r@r)__name__ __module__ __qualname____doc__r-r+rrr2rKrLrerNrQrPr~rrrr"s_2)4 6 $*%N"0 <0 CG0 B0 d.&f"D" rr)rr=rrr rr@r ) __future__rtypingrcontent_parsersrrresponse_templatesrr r rrrrrrs.#>__cgKKr