ó
    üÞ j‘  ã                  óˆ   • S r SSKJr  SSKrSSKJr  SSKJr  SSKJrJ	r	  SSK
JrJr  SSKJr  SS	 jr\ " S
 S5      5       rg)u‹  ``TranslatedSpan`` â€” the mutable draft handlers rewrite before export.

Split out of :mod:`langsmith._internal.voice.base_span_processor` so the base
processor stays focused on span lifecycle and export wiring. The framework
subclasses (Pipecat, LiveKit) rewrite one of these per span while translating
``lk.*`` / ``pipecat.*`` data into LangSmith's ``gen_ai.*`` / ``langsmith.*``
namespaces.
é    )ÚannotationsN)Úcopy)Ú	dataclass)ÚAnyÚOptional)ÚEventÚReadableSpan)Úrebuild_readable_spanc           	     ó¶   • U (       d  0 $ U R                  5        VVs0 sH.  u  p[        U[        [        45      (       d  M"  U[        U5      _M0     snn$ s  snnf )zFKeep only the int-valued detail keys, dropping ``None`` / non-numeric.)ÚitemsÚ
isinstanceÚintÚfloat)ÚdetailsÚkÚvs      Úc/var/www/html/gaurav/venv/lib/python3.13/site-packages/langsmith/_internal/voice/translated_span.pyÚ_clean_token_detailsr      sA   € æØˆ	Ø")§-¡-¤/ÔQ¡/™$˜!´ZÀÄCÌÀ<×5P‹IˆAŒs�1‹vŠI¡/ÒQÐQùÓQs   � AÁAc                  ó  • \ rS rSr% SrS\S'   S\S'   S\S'   \SS	 j5       rSS
 jrSS jr	SS jr
S S jrS!S jrS"S jrS#S jrS$S jrS%S jrS&S jrSSSSSS.           S'S jjrSSS.     S(S jjrS)S jrS*S jrSrg)+ÚTranslatedSpané   u©  A span being translated into LangSmith's namespaces before export.

Wraps a shallow copy of the original read-only OTel ``ReadableSpan`` with
mutable ``attributes`` and ``events`` seeded from it. Handlers rewrite the
draft while translating; :meth:`finalize` builds a fresh ``ReadableSpan``
from it â€” so the original span is never mutated.

Created per span in :meth:`BaseLangSmithSpanProcessor.on_end` and threaded
through dispatch â€” no global state. A processor that defers a span (see
:meth:`BaseLangSmithSpanProcessor._dispatch`) simply holds the
``TranslatedSpan`` itself until it exports it later, so the in-progress
translation outlives the originating ``on_end`` call.
r	   Úspanzdict[str, Any]Ú
attributeszlist[Event]Úeventsc                ó˜   • U " [        U5      [        UR                  =(       d    0 5      [        UR                  =(       d    / 5      5      $ )z>Seed a draft from a span's own fields, attributes, and events.)r   Údictr   Úlistr   )Úclsr   s     r   ÚofÚTranslatedSpan.of1   s:   € ñ Ü�‹JÜ�—‘×& BÓ'Ü�—‘×" Ó#ó
ð 	
ó    c                óT   • [        U R                  U R                  U R                  S9$ )zDBuild the export span from the draft and its rewritten attrs/events.)r   r   )r
   r   r   r   ©Úselfs    r   ÚfinalizeÚTranslatedSpan.finalize:   s"   € ä$Ø�I‰I $§/¡/¸$¿+¹+ñ
ð 	
r!   c                ó$   • XR                   l        g)z6Set the exported span's name (the LangSmith run name).N)r   Ú_name)r$   Únames     r   Úset_nameÚTranslatedSpan.set_name@   s   € à�	‰	�r!   c                ó$   • XR                   l        g)uº   Set the exported span's end time (epoch ns).

Lets a span merged from two sources report a duration that runs past its
own end â€” e.g. a tool span spanning from the call to the result.
N)r   Ú	_end_time)r$   Úend_time_nss     r   Úset_end_timeÚTranslatedSpan.set_end_timeD   s   € ð *�	‰	Õr!   c                ó    • XR                   S'   g)uC   Set ``langsmith.span.kind`` (``llm`` / ``chain`` / ``tool`` / â€¦).zlangsmith.span.kindN©r   )r$   Úkinds     r   Úset_kindÚTranslatedSpan.set_kindL   s   € à15�‰Ð-Ò.r!   c                ó    • XR                   S'   g)zBSet ``langsmith.metadata.thread_id`` (the conversation/thread id).zlangsmith.metadata.thread_idNr2   )r$   Ú	thread_ids     r   Úset_thread_idÚTranslatedSpan.set_thread_idP   s   € à:C�‰Ð6Ò7r!   c                óL   • U(       a  XR                   S'   XR                   S'   gg)u+  Set ``provider`` on both gen_ai.* provider keys (no-op if empty).

LangSmith maps either ``gen_ai.provider.name`` (newer) or the legacy
``gen_ai.system`` to ``ls_provider``; writing both is version-agnostic.
The caller passes an already-resolved slug â€” normalization is the
integration's concern.
zgen_ai.provider.namezgen_ai.systemNr2   )r$   Úproviders     r   Úset_providerÚTranslatedSpan.set_providerT   s%   € ö Ø6>�O‰OÐ2Ñ3Ø/7�O‰O˜OÒ,ð r!   c                ót   • U(       a1  [        U5      U R                  S'   [        U5      U R                  S'   gg)zJSet the request model on ``gen_ai.request.model`` and its metadata mirror.zgen_ai.request.modelzlangsmith.metadata.model_nameN)Ústrr   )r$   Úmodels     r   Ú	set_modelÚTranslatedSpan.set_model`   s0   € æÜ69¸%³jˆD�O‰OÐ2Ñ3Ü?BÀ5»zˆD�O‰OÐ;Ò<ð r!   c                ó"   • SU R                   S'   g)u   Drop this span from the conversation Messages view (still in the tree).

That view reconstructs the chat from ``llm``/``tool`` runs. STT/TTS spans
are tagged ``llm``-kind for the tree but would otherwise add fake turns
(raw transcripts, "Generated audio for: â€¦"), so they opt out here.
Tz*langsmith.metadata.ls_message_view_excludeNr2   r#   s    r   Úexclude_from_message_viewÚ(TranslatedSpan.exclude_from_message_viewf   s   € ð IMˆ�‰ÐDÒEr!   c                ó    • XR                   S'   g)z:Mark the span as the trace root (``langsmith.root_span``).zlangsmith.root_spanNr2   )r$   Úis_roots     r   Úset_root_spanÚTranslatedSpan.set_root_spano   s   € à18�‰Ð-Ò.r!   c                ó&   • X R                   SU 3'   g)u3  Set ``langsmith.metadata.<key>`` to the given value.

LangSmith surfaces everything under ``langsmith.metadata.*`` as run
metadata. Note ``langsmith.root_span`` and ``langsmith.span.kind`` are NOT
metadata â€” they live in the top-level ``langsmith.*`` namespace and have
their own setters / direct writes.
zlangsmith.metadata.Nr2   )r$   ÚkeyÚvalues      r   Úset_metadataÚTranslatedSpan.set_metadatas   s   € ð 8=�‰Ð-¨c¨UÐ3Ò4r!   N)Úinput_tokensÚoutput_tokensÚtotal_tokensÚinput_token_detailsÚoutput_token_detailsc               ó  • 0 nUb  [        U5      US'   Ub  [        U5      US'   Ub  [        U5      US'   [        U5      =n(       a  XvS'   [        U5      =n(       a  XvS'   U(       a$  [        R                  " U5      U R                  S'   gg)u¹   Write the given token usage as ``langsmith.usage_metadata`` (JSON).

Callers pass the complete usage â€” it replaces the flat ``gen_ai.usage.*``
at ingest. No-op when nothing is given.
NrO   rP   rQ   rR   rS   zlangsmith.usage_metadata)r   r   ÚjsonÚdumpsr   )r$   rO   rP   rQ   rR   rS   Úusager   s           r   Ú	set_usageÚTranslatedSpan.set_usage}   sœ   € ð !#ˆØÑ#Ü$'¨Ó$5ˆE�.Ñ!ØÑ$Ü%(¨Ó%7ˆE�/Ñ"ØÑ#Ü$'¨Ó$5ˆE�.Ñ!Ü*Ð+>Ó?Ð?ˆ7Õ?Ø+2Ð'Ñ(Ü*Ð+?Ó@Ð@ˆ7Õ@Ø,3Ð(Ñ)ÞÜ:>¿*º*ÀUÓ:KˆD�O‰OÐ6Ò7ð r!   )ÚpromptÚ
completionc               ó¦   • Ub%  [         R                  " SU05      U R                  S'   Ub&  [         R                  " SU05      U R                  S'   gg)zIWrite ``gen_ai.prompt``/``gen_ai.completion`` as ``{"messages": [...]}``.NÚmessagesúgen_ai.promptúgen_ai.completion)rU   rV   r   )r$   rZ   r[   s      r   Úset_messagesÚTranslatedSpan.set_messages™   sN   € ð ÑÜ/3¯zªz¸:ÀvÐ:NÓ/OˆD�O‰O˜OÑ,ØÑ!Ü37·:²:¸zÈ:Ð>VÓ3WˆD�O‰OÐ/Ò0ð "r!   c                óx   • [        U[        5      (       a  UO[        R                  " U5      U R                  S'   g)z’Write a tool run's input to ``gen_ai.prompt`` as raw I/O (not messages).

A ``str`` is passed through unchanged; any other value is JSON-encoded.
r^   N©r   r?   rU   rV   r   )r$   Ú
tool_inputs     r   Úset_tool_inputÚTranslatedSpan.set_tool_input¥   s,   € ô % Z´×5Ñ5‰J¼4¿:º:ÀjÓ;Qð 	�‰˜Ò(r!   c                óx   • [        U[        5      (       a  UO[        R                  " U5      U R                  S'   g)z—Write a tool run's output to ``gen_ai.completion`` as raw I/O (not messages).

A ``str`` is passed through unchanged; any other value is JSON-encoded.
r_   Nrc   )r$   Útool_outputs     r   Úset_tool_outputÚTranslatedSpan.set_tool_output®   s-   € ô & k´3×7Ñ7‰K¼T¿ZºZÈÓ=Tð 	�‰Ð+Ò,r!   © )r   r	   Úreturnr   )rl   r	   )r)   r?   rl   ÚNone)r.   r   rl   rm   )r3   r?   rl   rm   )r7   r?   rl   rm   )r;   úOptional[str]rl   rm   )r@   rn   rl   rm   )rl   rm   )rG   Úboolrl   rm   )rK   r?   rL   r   rl   rm   )rO   úOptional[int]rP   rp   rQ   rp   rR   úOptional[dict[str, int]]rS   rq   rl   rm   )rZ   úOptional[list[dict]]r[   rr   rl   rm   )rd   r   rl   rm   )rh   r   rl   rm   )Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__annotations__Úclassmethodr   r%   r*   r/   r4   r8   r<   rA   rD   rH   rM   rX   r`   re   ri   Ú__static_attributes__rk   r!   r   r   r      sô   ‡ ñð ÓØÓØÓàó
ó ð
ô
ôô*ô6ôDô
8ôJôMô9ô=ð '+Ø'+Ø&*Ø8<Ø9=ñLð $ðLð %ð	Lð
 $ðLð 6ðLð 7ðLð 
õLð> (,Ø+/ñ	
Xð %ð
Xð )ð	
Xð
 
õ
Xô
÷
r!   r   )r   zOptional[dict[str, Any]]rl   zdict[str, int])rw   Ú
__future__r   rU   r   Údataclassesr   Útypingr   r   Úopentelemetry.sdk.tracer   r	   Ú$langsmith._internal.otel._span_utilsr
   r   r   rk   r!   r   Ú<module>r€      sC   ðñõ #ã Ý Ý !ß  ç 7å FôRð ÷W
ð W
ó ñW
r!   