yj8cddlZddlZddlZddlZddlmZddlmZmZddl m Z m Z m Z m Z ddlZddlmZddlmZddlmZdd lmZmZmZejeZe d Zd d d ededeede degeefde!defdZ"d edede de de#de dde$dzde!ddfdZ%Gdde Z&GddZ'ded ee d!e d"ej(dee)ee ff d#Z*Gd$d%Z+e+Z,dS)&N) defaultdict) AwaitableCallable)AnyLiteral NamedTupleTypeVar)genai)types) AsyncOpenAI)EmbeddingModelConfigresolve_embedding_model_configsettings_TT)is_final_attemptprovidermodeltextsinput_tokens_estimatefnrreturnc Ktj}d} |d{V |d}nt|tjrd}nd}t ||t ||tj|z dz|||S#t$r} | }d} ~ wwxYw#|d}nt|tjrd}nd}t ||t ||tj|z dz|||wxYw)utime a single embedding-provider call, emit `embedding.call.completed` on both success and exception, and return the call's result. Errors propagate unchanged — telemetry never bleeds into the caller's control flow. Caller-supplied `texts` is used only for `input_count`; we don't keep the list around for the event to avoid leaking content into telemetry. `is_final_attempt` defaults to True so one-shot callers (`embed`, `simple_batch_embed`) get correct semantics without changes. Retry-loop callers (`_process_batch`) pass the real attempt index so dashboards can distinguish exhausted retries from mid-retry failures. Nsuccess cancellederrori)rr input_countr duration_msoutcomerr)time perf_counter isinstanceasyncioCancelledError_publish_embedding_eventlen BaseException) rrrrrrstartrrexcs X % %> ? !=>>>? 'AAAA  7 ? !=>>>%DK)9D %"&D  A/7/J4:/V/VDMM A A A$1-@@DMMM A5K---s-D #D21D2rc|jSN)r_rms r*rz_EmbeddingClient.providers ~rP embeddingc t||jkr>T3 3 3SDNSSTZSSSMd4MMC NNMMMN rPquerycKtj}|jkrt djd|dt jtjrFjdttffd }tj j g||d{VSjdttffd }tj j g||d{VS)Nz%Query exceeds maximum token limit of z tokens (got z tokens)rc Kjjjdjid{V}|jr|jdjstd|jdjS)Noutput_dimensionalityrcontentsrSrz%No embedding returned from Gemini API) aiomodels embed_contentrrT embeddingsvaluesr<rv)response gemini_clientrwrms r* _call_geminiz,_EmbeddingClient.embed.._call_geminis!.!2!9!G!G*"3T5KL"H""  *N(2Ea2H2ON$%LMMM::'*1rPrrrrrcKjgd}jr j|d<jjdi|d{V}|jdjS)Nrinput dimensionsrrO)rrWrTrcreatervdatarr) openai_kwargsr openai_clientrwrms r* _call_openaiz,_EmbeddingClient.embed.._call_openais|6:jE7,S,SM# E.2.D l+<]5<MM}MMMMMMMMH66x}Q7G7QRR RrP)r&riencoderer<r"rcr rblistfloatr+r_r)rmrwrHrrrrs`` @@r*embedz_EmbeddingClient.embeds$-..u5566 2 2 2u8Quu`kuuu  dk5< 0 0  KM U        .jg&1    SDK S S S S S S S S*^*'"-           rPrc6Kg}tdt|jD]}|||jz}|fdttdttt ffd } t fd|D}tjj |||d{V}| |#t$rB}dt | vrtd jd |d}~wwxYw|S) a# Simple batch embedding for a list of text strings. Args: texts: List of text strings to embed Returns: List of embedding vectors corresponding to input texts Raises: ValueError: If any text exceeds token limits rbatchrcKg}tjtjrjjjj|djid{V}|j r>|j D]6}|j r-|  |j 7n^|jd}j r j|d<jj jdi|d{V}|fd|jD|S)zOne provider call for one batch. Lifted into a closure so _emit_embedding_call can time + emit + propagate errors.rzr{N)rrrcDg|]}|jSrO)rvrr).0rrms r* zM_EmbeddingClient.simple_batch_embed.._embed_batch..'s9 $!??OOrPrO)r"rcr rbr}r~rrrTrrappendrvrWrextendr)rbatch_embeddingsrembrrms r* _embed_batchz9_EmbeddingClient.simple_batch_embed.._embed_batch sv79 dk5<88%)[_%;%I%I"j!& 79OP&J&&      H  *"#+#6""C"z" 0 7 7$($G$G $S$S!"!"!" "'!%55M+M6:6L l3%BT[%;%B%S%S]%S%SSSSSSSH$++(0  ('rPc3fK|]+}tj|V,dSrp)r&rir)rtrms r* z6_EmbeddingClient.simple_batch_embed..1s;%R%Rqc$-*>*>q*A*A&B&B%R%R%R%R%R%RrPrNtokenz,Text content exceeds maximum token limit of ru)ranger&rfrrLrsumr+r_rrrAlowerr<re) rmrrirrtokens_estimateres ` r*simple_batch_embedz#_EmbeddingClient.simple_batch_embeds)+ q#e**d&9::6 6 A!a$"5556E6; ( ($s) (T%[@Q ( ( ( ( ( (B #&%R%R%R%RE%R%R%R"R"R)=!^**9# ***$$$$$$ !!"23333   c!ffllnn,,$ctG`ccc  s5AC  D=DDid_resource_dictcK|siS|}|}tjfd|Dd{V}|S)z Embed multiple texts, chunking long ones and batching API calls. Args: id_resource_dict: Maps text IDs to text content Returns: Maps text IDs to lists of embedding vectors (one per chunk) c:g|]}|SrO)_process_batch)rrrms r*rz0_EmbeddingClient.batch_embed..[s' > > >Ud!!%(( > > >rPN)_prepare_chunks_create_batchesr#gather_accumulate_embeddings)rmr text_chunksbatches batch_resultss` r* batch_embedz_EmbeddingClient.batch_embedDs  I**+;<< &&{33&n > > > >g > > >       **=999rPc i}|D]l\}}|j|}t||jkr t |||j|j||<W|t|fg||<m|S)a} Chunk texts that exceed token limits. Args: id_resource_dict: Maps text IDs to text content. We tokenize with the embedding client's own encoding so token IDs match the decoder vocabulary used by the target embedding API. Returns: Maps text IDs to lists of (chunk_text, token_count) tuples )itemsrirr&re_chunk_text_with_tokens)rmroutrFrEtokenss r*rz _EmbeddingClient._prepare_chunksas13-3355 5 5MGT]))$//F6{{T6666&$";T]  G "&s6{{ 34G  rPrc g}g}d}|D]\}}t|D]w\}\}} || z|jk} t||jk} |r| s| r||g}d}|t |||| || z }x|r|||S)z Group chunks into batches that fit API limits. Args: text_chunks: Maps text IDs to lists of (chunk_text, token_count) tuples Returns: List of batches, each containing BatchItem objects r)r enumeraterlr&rfrrD) rmrr current_batchcurrent_tokensrFchunks chunk_idx chunk_text chunk_tokenswould_exceed_tokenswould_exceed_counts r*rz _EmbeddingClient._create_batcheszs*,)+ *0022 / /OGV9B69J9J / /5 5J #\1;<$&)%7%74;N%N" '&9'=O'NN=111$&M%&N$$j'9lKK,.! /$  * NN= ) ) )rPr max_retriesc Kd}dttttttffffd }t dD}dD}t |D]} tjj |||||dz kd{V}t|cS#t$r|} | }||dz krMd|z} t d |dzd |d d | d | ztj| d{VntdYd} ~ d} ~ wwxYw|pt!d)a= Process a single batch through the embeddings API with retry logic. Args: batch: List of BatchItem objects to embed max_retries: Maximum number of retry attempts (default: 3) Returns: Maps text IDs to {chunk_index: embedding_vector} dictionaries NrcKtt}tjtjrjjjj dDdj id{V}|j rQt|j dD]9\}}|j r-|j ||j|j<:nj dDd}jr j |d <jj jd i|d{V}t|jdD]2\}}|j||j|j<3|S) uOne provider call. Lifted out of the retry loop so _emit_embedding_call emits a separate event per attempt — each attempt is a distinct provider hit and shows up as its own line item in analytics.cg|] }|j SrOrEritems r*rzK_EmbeddingClient._process_batch.._call_provider..:::Ddi:::rPrzr{NT)strictcg|] }|j SrOrrs r*rzK_EmbeddingClient._process_batch.._call_provider..rrPrrrO)rdictr"rcr rbr}r~rrrTrziprrvrFrGrWrrrr)resultrrrrrembedding_datarrms r*_call_providerz7_EmbeddingClient._process_batch.._call_providers 9DD8I8IF$+u|44 !%!7!E!E*::E:::3T5KL"F"" &+.uh6IRV+W+W+Wi$+ $ C CIDT U U#4<01AB "Z::E:::11 'I262HM,/!>!7!>!O!O!O!OOOOOOO,/x}T,R,R,R(D.;;N.s%#G#GD$4#G#G#G#G#G#GrPcg|] }|j SrOrrs r*rz3_EmbeddingClient._process_batch..s333Tty333rPr )rrrrrrz Embedding batch failed (attempt /z), z retrying in zs: z(Error processing batch after all retrieszBatch processing failed)rrLrNrrrrr+r_rrAr=warningr#sleep exception RuntimeError) rmrrlast_exceptionrbatch_tokens_estimate batch_textsattemptrr wait_times `` r*rz_EmbeddingClient._process_batchs,0 d3S$u+5E0F+F&G       D!$#G#G#G#G#G G G33U333 [)) Q QG Q3!^*%*?%&-q&@    F||### Q Q Q!"[1_,, !7 INNY7Q;YYYYY:::q::;"- 2222222222$$%OPPP QG -F G GGs;:B88 D>A2D99D>rctt}|D]7}|D] \}}|||!8d|DS)z Combine batch results into final output, preserving chunk order. Args: batch_results: List of batch results from _process_batch Returns: Maps text IDs to ordered lists of embedding vectors cri|]3\}|fdtD4S)c g|] }| SrOrO)rr chunk_dicts r*rzF_EmbeddingClient._accumulate_embeddings...sGGGjmGGGrP)sortedkeys)rrFrs @r* z;_EmbeddingClient._accumulate_embeddings..sV   # GGGGVJOO4E4E-F-FGGG   rP)rrrupdate)rmrall_embeddings batch_resultrFrs r*rz'_EmbeddingClient._accumulate_embeddingss=H.$ss     s>"" " " OON1q:~+=> ? ?  C//!3 4 4 # " "rPr)r&rNr)rErrrioverlap_tokens step_sizes ``` r*rr s$ >j((s>**+,,c)**N^+I       q#n--y99    rPceZdZUdZdZded<dZeedfdzed<e j Z e j ed<dZ ded <fd Z d efd Zd efd Zd eedffdZded eefdZdeed eeefdZdeeefd eeeeeffdZed efdZed efdZed efdZed efdZed efdZ ed e!j"fdZ#xZ$S)EmbeddingClientz Singleton wrapper for the embedding client with deferred loading. The actual client is only initialized on first use, improving startup time and allowing the application to start even if API keys are not yet configured. Nz_EmbeddingClient | None _instance._instance_signature_lockzEmbeddingClient | None_wrapper_instancecl|j&t||_|jS)z3Ensure only one instance of EmbeddingClient exists.)rsuper__new__)cls __class__s r*rzEmbeddingClient.__new__;s/  ($)GGOOC$8$8C !$$rPrc |}|j |j|kr|j5|j |j|kr|}t |t jjt jj t jj t j |_||_t d|j|jdddn #1swxYwY|jS)z Get or create the underlying embedding client instance. Uses double-checked locking for thread-safe lazy initialization. N)rTrUrVrWz9Initialized embedding client with transport: %s model: %s)_get_settings_signaturerrr_resolve_runtime_configrRr EMBEDDINGVECTOR_DIMENSIONSMAX_INPUT_TOKENSMAX_TOKENS_PER_REQUESTresolve_send_dimensionsr=r>r_r)rm signatureruntime_configs r* _get_clientzEmbeddingClient._get_clientBs, 0022 > !T%=%J%J  >)T-E-R-R%)%A%A%C%CN%5&*2*<*N)1);)L/7/A/X(0(:(R(R(T(T &&&DN09D,LLS&0&,               "~sB6C00C47C4c>ttjjSrp)rrr MODEL_CONFIGrqs r*rz'EmbeddingClient._resolve_runtime_config]s-h.@.MNNNrPc |}|j|j|j|jt jjt jjt jj t j fSrp) rr_rr[rZrrrrrr)rmr s r*rz'EmbeddingClient._get_settings_signature`sb5577  $   "  #   0   /   5   6 6 8 8  rPrwc`K||d{VS)zEmbed a single query string.N)r r)rmrws r*rzEmbeddingClient.embedms8%%''--e444444444rPrc`K||d{VS)z2Simple batch embedding for a list of text strings.N)r r)rmrs r*rz"EmbeddingClient.simple_batch_embedqs8%%''::5AAAAAAAAArPrc`K||d{VS)z@Embed multiple texts, chunking long ones and batching API calls.N)r r)rmrs r*rzEmbeddingClient.batch_embedus;%%''334DEEEEEEEEErPc4|jS)zGet the provider name.)r rrqs r*rzEmbeddingClient.provider{!!**rPc4|jS)zGet the model name.)r rrqs r*rzEmbeddingClient.models!!''rPc4|jS)zGet the transport name.)r r_rqs r*r_zEmbeddingClient.transports!!++rPc4|jS)z!Get the maximum embedding tokens.)r rerqs r*rez$EmbeddingClient.max_embedding_tokenss!!66rPc4|jS)z(Get the configured embedding dimensions.)r rTrqs r*rTz!EmbeddingClient.vector_dimensionss!!33rPc4|jS)zGet the tiktoken encoding.)r rirqs r*rizEmbeddingClient.encodingrrP)%r@rIrJrKrrMrrobject threadingLockrrrrRr rrrrLrrrrrrrrrr_rNrerTrgEncodingri __classcell__)rs@r*rr.s,0I(///59vs{+d2999*IN,,E9>,,,26/666%%%%%-6O)=OOOO  vs{);     55e5555Bd3iBDer&s ######////////444444444444------RRRRRRRRRR  8 $ $ WT]]"- - - -  -  9 -  - Yr]"# - - - - - - `8R8R 8R 8R  8R  8R4 58R 4 8R8R 8R8R8R8Rv         D   I     %S/    Fi+i+i+i+i+i+i+i+Z#?$$rP