@'h7ddZddlZddlZddlZddlmZmZmZmZm Z m Z ddl m Z ee e geeefZ ee e geeeefZ de e eee dfde fdZGdd e Zd ed e e ee fdee fd Zd e dee fd ZdedefdZej0deee ge ffdZgdZy)anUtilities for working with embedding functions and LangChain's Embeddings interface. This module provides tools to wrap arbitrary embedding functions (both sync and async) into LangChain's Embeddings interface. This enables using custom embedding functions with LangChain-compatible tools while maintaining support for both synchronous and asynchronous operations. N)Any AwaitableCallableOptionalSequenceUnion) Embeddingsembedreturnc | tdt|tr=t}|)ddlm}m} |d}d|d}td|d |d ||St|tr|St|S#|$rd}Y@wxYw) aEnsure that an embedding function conforms to LangChain's Embeddings interface. This function wraps arbitrary embedding functions to make them compatible with LangChain's Embeddings interface. It handles both synchronous and asynchronous functions. Args: embed: Either an existing Embeddings instance, or a function that converts text to embeddings. If the function is async, it will be used for both sync and async operations. Returns: An Embeddings instance that wraps the provided function(s). ??? example "Examples" Wrap a synchronous embedding function: ```python def my_embed_fn(texts): return [[0.1, 0.2] for _ in texts] embeddings = ensure_embeddings(my_embed_fn) result = embeddings.embed_query("hello") # Returns [0.1, 0.2] ``` Wrap an asynchronous embedding function: ```python async def my_async_fn(texts): return [[0.1, 0.2] for _ in texts] embeddings = ensure_embeddings(my_async_fn) result = await embeddings.aembed_query("hello") # Returns [0.1, 0.2] ``` Initialize embeddings using a provider string: ```python # Requires langchain>=0.3.9 and langgraph-checkpoint>=2.0.11 embeddings = ensure_embeddings("openai:text-embedding-3-small") result = embeddings.embed_query("hello") ``` zembed must be providedr)PackageNotFoundErrorversion langchainzFound langchain version z, butzlangchain is not installed;z'Could not load embeddings from string 'z'. aF loading embeddings by provider:identifier string requires langchain>=0.3.9 as well as the provider-specific package. Install LangChain with: pip install 'langchain>=0.3.9' and the provider-specific package (e.g., 'langchain-openai>=0.3.0'). Alternatively, specify 'embed' as a compatible Embeddings object or python function.) ValueError isinstancestr_get_init_embeddingsimportlib.metadatar rr EmbeddingsLambda)r init_embeddingsr r lc_version version_infos a/home/kushmeetdev/Regenta/Chatbot/venv/lib/python3.12/site-packages/langgraph/store/base/embed.pyensure_embeddingsrsV }122%.0  " H =$[1 !9*UK 9%L>Rgg u%%%$ E ""( =<  =sA88BBceZdZdZdeeefddfdZdee deee fdZ de dee fd Z dee deee ffd Z de dee ffd ZxZS) ra#Wrapper to convert embedding functions into LangChain's Embeddings interface. This class allows arbitrary embedding functions to be used with LangChain-compatible tools. It supports both synchronous and asynchronous operations, and can handle: 1. A synchronous function for sync operations (async operations will use sync function) 2. An async function for both sync/async operations (sync operations will raise an error) The embedding functions should convert text into fixed-dimensional vectors that capture the semantic meaning of the text. Args: func: Function that converts text to embeddings. Can be sync or async. If async, it will be used for async operations, but sync operations will raise an error. If sync, it will be used for both sync and async operations. ??? example "Examples" With a sync function: ```python def my_embed_fn(texts): # Return 2D embeddings for each text return [[0.1, 0.2] for _ in texts] embeddings = EmbeddingsLambda(my_embed_fn) result = embeddings.embed_query("hello") # Returns [0.1, 0.2] await embeddings.aembed_query("hello") # Also returns [0.1, 0.2] ``` With an async function: ```python async def my_async_fn(texts): return [[0.1, 0.2] for _ in texts] embeddings = EmbeddingsLambda(my_async_fn) await embeddings.aembed_query("hello") # Returns [0.1, 0.2] # Note: embed_query() would raise an error ``` funcr NcR| tdt|r||_y||_y)Nzfunc must be provided)r_is_async_callableafuncr)selfrs r__init__zEmbeddingsLambda.__init__s+ <45 5 d #DJDItextscFt|dd}| td||S)aFEmbed a list of texts into vectors. Args: texts: list of texts to convert to embeddings. Returns: list of embeddings, one per input text. Each embedding is a list of floats. Raises: ValueError: If the instance was initialized with only an async function. rNzEmbeddingsLambda was initialized with an async function but no sync function. Use aembed_documents for async operation or provide a sync function.)getattrr)r r#rs rembed_documentsz EmbeddingsLambda.embed_documentss6tVT* <W E{r"textc,|j|gdS)a1Embed a single piece of text. Args: text: Text to convert to an embedding. Returns: Embedding vector as a list of floats. Note: This is equivalent to calling embed_documents with a single text and taking the first result. r)r&)r r's r embed_queryzEmbeddingsLambda.embed_querys##TF+A..r"cKt|dd}|t| |d{S||d{S77w)aYAsynchronously embed a list of texts into vectors. Args: texts: list of texts to convert to embeddings. Returns: list of embeddings, one per input text. Each embedding is a list of floats. Note: If no async function was provided, this falls back to the sync implementation. rN)r%superaembed_documents)r r#r __class__s rr,z!EmbeddingsLambda.aembed_documentssEgt, =1%88 85\!!9!s">:><>>cKt|dd}|t| |d{S||gd{dS77 w)aAAsynchronously embed a single piece of text. Args: text: Text to convert to an embedding. Returns: Embedding vector as a list of floats. Note: This is equivalent to calling aembed_documents with a single text and taking the first result. rNr)r%r+ aembed_query)r r'rr-s rr/zEmbeddingsLambda.aembed_querysLgt, =-d33 3TFm#Q''4#s"A>AAAA)__name__ __module__ __qualname____doc__rEmbeddingsFuncAEmbeddingsFuncr!listrfloatr&r)r,r/ __classcell__)r-s@rrrfs$L NO34   T#Y4U 3D( / /U /"DI"$tE{:K""(s(tE{((r"robjpathc |r|dk(rtj|dgSt|tr t |n|}dt dt tdtdt tffd ||d S) aExtract text from an object using a path expression or pre-tokenized path. Args: obj: The object to extract text from path: Either a path string or pre-tokenized path list. !!! info "Path types handled" - Simple paths: "field1.field2" - Array indexing: "[0]", "[*]", "[-1]" - Wildcards: "*" - Multi-field selection: "{field1,field2}" - Nested paths in multi-field: "{field1,nested.field2}" $T sort_keysr9tokensposr c 6|t|k\r`t|tttt fr t|gS|gSt|t tfrtj|dgSgS||}g}|jdr|jdrt|t sgS|dd}|dk(r%|D]}|j|||dz |S t|}|dkrt||z}d|cxkrt|kr"nn|j||||dz|S|jd r |jd rt|tsgS|ddjd Dcgc]}|j!} }| D]} t#| } | s|} | D]} t| tr | | vr| | } d} n| :t| tttt fr|j%t| ut| t tfs|j%tj| d|S|dk(rxt|tr3|j'D]}|j|||dz |St|t r#|D]}|j|||dz |St|tr#||vr|j||||dz|S#ttf$rgcYSwxYwcc}w) NTr=[]*r{},)lenrrintr7boolr6dictjsondumps startswithendswithextendr IndexErrorsplitstrip tokenize_pathappendvalues)r9r?r@tokenresultsindexitemidxffieldsfield nested_tokens current_obj nested_tokenvalue_extract_from_objs rrez+get_text_at_path.._extract_from_objs #f+ #S%67Cz! C$. 3$788Is    C U^^C%8c4( !BKE|MDNN#4T637#KLMd_e*CQw!#hnC*#c(*'8S63QR7'STTM  c "u~~c':c4( ).q):):3)?@Aaggi@F@ T -e 4  25K(5" &{D9 , ;*5l*CK*.K!"#.%kCeT3JK#NN3{+;<' dD\B#NN4::kT+RS# TBc\#t$ ZZ\NENN#4UFC!G#LMNC&MDNN#4T637#KLM#t$#0UVS1WMNS#J/IAsAK?<L?LLr)rNrOrrrVrr6rK)r9r:r?res @rget_text_at_pathrfsw 43; 3$/00$.tS$9]4 tFEsEDIECEDIEN S&! ,,r"c|sgSg}g}d}|t|kr||}|dk(r|r"|jdj|g}d}dg}|dz }|t|krM|dkDrH||dk(r|dz }n ||dk(r|dz}|j|||dz }|t|kr|dkDrH|jdj||dk(r|r"|jdj|g}d}dg}|dz }|t|krM|dkDrH||dk(r|dz }n ||dk(r|dz}|j|||dz }|t|kr|dkDrH|jdj|s|dk(r%|r4|jdj|g}n|j||dz }|t|kr|r |jdj||S) zTokenize a path into components. !!! info "Types handled" - Simple paths: "field1.field2" - Array indexing: "[0]", "[*]", "[-1]" - Wildcards: "*" - Multi-field selection: "{field1,field2}" rrBrDrCrGrH.)rJrWjoin) r:r?currentichar bracket_count index_chars brace_count field_charss rrVrV?s  FG A c$i-Aw 3; bggg./M%K FAc$i-MA$57c>!Q&M!W^!Q&M""47+Q c$i-MA$5 MM"''+. /  S[ bggg./K%K FAc$i-K!O7c>1$K!W^1$K""47+Q c$i-K!O MM"''+. /  S[ bggg./ NN4  QW c$i-Z bggg&' Mr"rctj|xs-t|dxrtj|jS)zCheck if a function is async. This includes both async def functions and classes with async __call__ methods. Args: func: Function or callable object to check. Returns: True if the function is async, False otherwise. __call__)asyncioiscoroutinefunctionhasattrrs)rs rrrs= ##D) 7 4 $ 7  ' ' 6r"c2 ddlm}|S#t$rYywxYw)Nrr)langchain.embeddingsr ImportErrorrxs rrrs"8 s  )rr4r5)r3rt functoolsrNtypingrrrrrrlangchain_core.embeddingsr rr6r7r4r5rrrfrVrLr lru_cacher__all__r"rrs9 FF08C=/4U +<<=HSM?Id4;6G,HHI D# ^_c4G HD#D#Nv(zv(rZ-#Z-U3S >%:Z-tCyZ-@??S ?D  ( hxz0A'BC r"