
    k
i                       d Z ddlmZ ddlZddlZddlZddlZddlmZ ddl	m	Z	 ddl
mZ ddlmZmZmZmZmZmZmZmZmZ ddlmZ dd	lmZmZmZmZmZmZmZ dd
l m!Z! ddl"m#Z$ ddl%m&Z& ddl'm(Z( ddl)m*Z*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4 ddl5m6Z6m7Z7  ej8        e9          Z:dZ; G d de4e$e&f                   Z<dS )zCAsync shallow Redis implementation for LangGraph checkpoint saving.    )annotationsN)asynccontextmanager)datetime)TracebackType)	AnyAsyncIteratorDictListOptionalSequenceTupleTypecast)RunnableConfig)WRITES_IDX_MAPChannelVersions
CheckpointCheckpointMetadataCheckpointTuplePendingWriteget_checkpoint_id)TASKS)Redis)AsyncSearchIndex)FilterQuery)NumTag)RedisConnectionFactory)ULID)CHECKPOINT_PREFIXCHECKPOINT_WRITE_PREFIXREDIS_KEY_SEPARATORBaseRedisSaver)to_storage_safe_idto_storage_safe_str  c            	          e Zd ZU dZded<   ded<   ded<   ded<   	 d]d	d	d	eed
d^ fdZd_dZd`dZ	e
e	 d]d	d	d	eed
dad                         Zdbd!Zdbd"Zdcd+Zd	d	d	d,ddd4Zded6Z	 dfdgd<Z	 d]dhdBZdidDZdjdFZ	 	 	 dkdldGZdbdHZdedIZdcdJZ	 dfdmdLZ	 d]dhdMZdndNZedndO            ZdodQZedndR            Z dpdTZ!dqdUZ"dVd	dWdrd\Z# xZ$S )sAsyncShallowRedisSaverzAsync Redis implementation that only stores the most recent checkpoint.

    Supports standard Redis URLs (redis://), SSL (rediss://), and
    Sentinel URLs (redis+sentinel://host:26379/service_name/db).
    str
_redis_urlr   checkpoints_indexcheckpoint_writes_index
AsyncRedis_redisN)redis_clientconnection_argsttlcheckpoint_prefixcheckpoint_write_prefix	redis_urlOptional[str]r/   Optional[AsyncRedis]r0   Optional[dict[str, Any]]r1   r2   r3   returnNonec                   t                                          ||||||           t          j                    | _        i | _        d| _        i | _        t          | _	        d S )Nr4   r/   r0   r1   r2   r3   r&   )
super__init__asyncioget_running_looploop
_key_cache_key_cache_max_size_channel_cacher"   
_separator)selfr4   r/   r0   r1   r2   r3   	__class__s          C:\Users\Dell Inspiron 16\Desktop\tws\AgrotaPowerBi\back-agrota-powerbi\mcp-client-agrota\venv\Lib\site-packages\langgraph/checkpoint/redis/ashallow.pyr=   zAsyncShallowRedisSaver.__init__>   sn     	%+/$; 	 	
 	
 	
 ,..	 +-#' .0-    c                r   K   |                                   d{V  |                                  d{V  | S )zAsync context manager enter.N)asetupaset_client_inforE   s    rG   
__aenter__z!AsyncShallowRedisSaver.__aenter__Y   sQ      kkmm ##%%%%%%%%%rH   	_exc_typeOptional[Type[BaseException]]_excOptional[BaseException]_tbOptional[TracebackType]c                  K   | j         rw| j                                         d {V  t          | j        dd           r(| j        j                                        }|r| d {V  d | j        _        d | j        _        d S d S )Nconnection_pool)	_owns_its_clientr.   aclosegetattrrU   
disconnectr+   _redis_clientr,   )rE   rN   rP   rR   coros        rG   	__aexit__z AsyncShallowRedisSaver.__aexit__b   s         	>+$$&&&&&&&&&t{$5t<< {2==?? JJJJJJJ 48D"09=D(666	> 	>rH   %AsyncIterator[AsyncShallowRedisSaver]c                 K    | ||||||          4 d{V 	 }|W V  ddd          d{V  dS # 1 d{V swxY w Y   dS )z-Create a new AsyncShallowRedisSaver instance.r;   N )clsr4   r/   r0   r1   r2   r3   savers           rG   from_conn_stringz'AsyncShallowRedisSaver.from_conn_stringu   s       3%+/$;
 
 
 	 	 	 	 	 	 	 	 KKKK	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	s   4
>>c                   K   | j                             d           d{V  | j                            d           d{V  dS )z(Initialize Redis indexes asynchronously.F)	overwriteN)r+   creater,   rL   s    rG   rJ   zAsyncShallowRedisSaver.asetup   sd      $++e+<<<<<<<<<*11E1BBBBBBBBBBBrH   c                >   K   |                                   d{V  dS )a  Set up the checkpoint saver asynchronously.

        This method creates the necessary indices in Redis.
        It MUST be called before using the checkpointer.

        This async method follows the canonical pattern used by other
        async checkpointers in the LangGraph ecosystem. The type ignore is necessary because
        the base class defines a sync setup() method, but async checkpointers require
        an async setup() method to properly handle coroutines.
        N)rJ   rL   s    rG   setupzAsyncShallowRedisSaver.setup   s.       kkmmrH   configr   
checkpointr   metadatar   new_versionsr   c           	     0  K   |d                                          }|                    d                    d                    }|                    d          }|                    d          }|                                 }	d|||d         di}
	 d}|d         rH	 t          j        |d                   }|j        }n%# t          $ r |                     |          }Y nw xY w|                    di           |	d<   ||rt          |          nd	||d         || 	                    |	          | 
                              d
}t          fddD                       rd         |d<   d         |d<   |                     ||          }| j                            d          }|                                                    |d|           |                                 d{V  | j        rd| j        v rxt'          | j                            d          dz            }	 | j                            ||           d{V  n+# t          $ r t*                              d|           Y nw xY w|
S # t.          j        $ r  t          $ r}|d}~ww xY w)a2  Store checkpoint with INLINE channel values

        Stores all channel values directly in main checkpoint JSON

        Args:
            config: The config to associate with the checkpoint
            checkpoint: The checkpoint data to store
            metadata: Additional metadata to save with the checkpoint
            new_versions: New channel versions as of this write

        Returns:
            Updated configuration after storing the checkpoint

        Raises:
            asyncio.CancelledError: If the operation is cancelled/interrupted
        configurablerun_id	thread_idcheckpoint_nsidro   rp   checkpoint_idNchannel_values )ro   rn   rp   rs   checkpoint_tsri   rj   c              3      K   | ]}|v V  	d S Nr_   ).0keyrj   s     rG   	<genexpr>z.AsyncShallowRedisSaver.aput.<locals>.<genexpr>   s'      AAs3(?AAAAAArH   )sourcestepr|   r}   Ftransaction$default_ttl<   z)Failed to apply TTL to checkpoint key: %s)copypopgetr   from_str	timestamp	Exception_extract_fallback_timestampr$   _dump_checkpoint_dump_metadataall)_make_shallow_redis_checkpoint_key_cachedr.   pipelinejsonsetexecute
ttl_configintexpireloggerwarningr>   CancelledError)rE   rh   ri   rj   rk   rm   rn   ro   rp   r   next_configrv   ulid_objcheckpoint_datacheckpoint_keyr   ttl_secondses      `              rG   aputzAsyncShallowRedisSaver.aput   s3     . n-2244!!(HLL,B,BCC $$[11	$((99  &!.!+D!1 
N	 !M$ QQ#}Z-=>>H$,$6MM  Q Q Q %)$D$DZ$P$PMMMQ &0^^4Db%I%ID!" '8>F,V444B!.!+D!1!."33D99 //99	 	O AAAA.@AAAAA ;,4X,>)*26*:' "KK= N {+++>>HMMOO_EEE""$$$$$$$$$  =DO#C#C!$/"5"5m"D"Dr"IJJ+,,^[IIIIIIIIII    NNC^    $ % 	 	 	  	 	 	G	sa   
I5 !C  I5 C# I5 "C##EI5 &!I I5 %I0-I5 /I00I5 5JJJ)filterbeforelimitOptional[RunnableConfig]r   Optional[Dict[str, Any]]r   r   Optional[int]AsyncIterator[CheckpointTuple]c                K   g }|r|                     t          d          t          |d         d                   k               |d                             d          x}r3|                     t          d          t          |          k               |d                             d          x}r3|                     t          d          t	          |          k               |r|                                D ]\  }}	|dk    r'|                     t          d          |	k               2|dk    r'|                     t          d          |	k               _|dk    r4|                     t          d          t          |	          k               |dk    r3|                     t          d          t          |	          k               |rdt          |          }
|
rS	 t          j	        |
          }|j
        }|                     t          d          |k                n# t          $ r Y nw xY w|r|d         nd	}|d
d         D ]}||z  }t          |g d|pdd          }| j                            |           d{V }|j        D ]}t!          dt#          |dd          t#          |dd          t#          |dd          did
t#          |dd          t#          |dd          i i i g dt#          |dd          t%          t#          |dd                    i t'          t#          |dd                    dg           W V  dS )z+List checkpoints from Redis asynchronously.ro   rm   rn   rp   r|   r}   rv   r   *   N)ro   rp   rs   r|   r}   scoretsd   )rs   DESC)filter_expressionreturn_fieldsnum_resultssort_byru   rs   rr   r   )vr   rq   rt   channel_versionsversions_seenpending_sendsinputr   )r|   r}   writesr   )rh   ri   rj   pending_writes)appendr   r$   r   r%   itemsr   r   r   r   r   r   r   r+   searchdocsr   rX   r   float)rE   rh   r   r   r   query_filterrn   rp   rz   valuebefore_checkpoint_idbefore_ulid	before_tscombined_filterexprqueryresultsdocs                     rG   alistzAsyncShallowRedisSaver.alist  s       
	K  %f^&<[&IJJK    /33H===v Q##CMM5G5O5O$OPPP &~ 6 : :? K KK} ##((,?,N,NN    		T$llnn T T
U(?? ''H(>????F]] ''Fu(<====K'' ''K(8(8<Nu<U<U(UVVVVH__ ''H9KE9R9R(RSSS 
	#4V#<#< # "&-0D"E"EK + 5I ''O(<(<y(HIIII    D .:B,q//s $ 	$ 	$Dt#OO -   -
 
 
 .55e<<<<<<<<< 	 	C!"%,S+r%B%B)0or)J)J)0or)J)J% % !#tR00!#;;&((*%'%'  &c8W==VQ 7 788 "73#;#;<<	   "/       	 	s   #AH% %
H21H2Optional[CheckpointTuple]c                  K   |d         d         }|d                              dd          }|                     ||          }| j                                                             |           d{V }|rt	          |t
                    sdS | j        r| j                             d          r{| j                             dd          }t          |dz            }	 | j                            ||           d{V  n+# t          $ r t                              d	|           Y nw xY w|                     d
i           }t	          |t                    rt          j        |          }|                     di           }	|                     |	          }	|                     di           }
t	          |
t                    rt          j        |
          }
d |
                                D             }g }d|||d         di}|                     t          j        |          |	|          }|                     |||d                    d{V }t'          ||t)          t*          |          d|          S )z6Retrieve a checkpoint tuple from Redis asynchronously.rm   ro   rp   ru   Nrefresh_on_readr   r   z+Failed to refresh TTL on checkpoint key: %sri   rt   rj   c                    i | ]G\  }}|                     d d          t          |t                    r|                     d d          n|HS ) ru   )replace
isinstancer)   )ry   kr   s      rG   
<dictcomp>z5AsyncShallowRedisSaver.aget_tuple.<locals>.<dictcomp>  sa     
 
 
 1 IIh##+5a+=+=D		(B'''1
 
 
rH   rq   rr   )rh   ri   rj   parent_configr   )r   r   r.   r   r   dictr   r   r   r   r   r   r)   loads_deserialize_channel_valuesr   _load_checkpointdumps_aload_pending_writesr   r   r   )rE   rh   ro   rp   r   full_checkpoint_datadefault_ttl_minutesr   ri   rt   rj   sanitized_metadatar   config_paramcheckpoint_paramr   s                   rG   
aget_tuplez!AsyncShallowRedisSaver.aget_tupleq  s     >*;7	~.22?BGG GG}
 

 &*[%5%5%7%7%;%;N%K%KKKKKKK# 	:6JD+Q+Q 	4 ? 	t223DEE 	"&/"5"5mR"H"H1B677Kk((EEEEEEEEEE   A>     *--lB??
j#&& 	0J//J *48H")M)M99.II (++J;;h$$ 	,z(++H
 
 !((	
 
 
 24 &!.!+D!1 (
  00Jz""
 
  $99}&6t&< 
  
 
 
 
 
 
 
 ',.@AA)
 
 
 	
s   !C? ?%D'&D'ru   r   Sequence[tuple[str, Any]]task_id	task_pathc                  K   |sdS |d         d         }|d                              dd          }|d         d         }	 | j                            d          }g }	t          |          D ]l\  }
\  }}| j                            |          \  }}|||||t          j         ||
          |||                     |          d		}|	                    |           mt          |          }d
| d| d}g }|	D ]6}| 
                    |||||d                   }|                    |           7t          |	          D ]6\  }
}||
         }|                                                    |d|           7d t          |          D             }|                    ||           |                    d           d{V }|D ]}t          |t                     r|| j        rd| j        v rt%          | j                             d          dz            }|D ]O}	 | j                            ||           d{V  %# t           $ r t(                              d|           Y Lw xY w	 | j                            ||           d{V  dS # t           $ r! t(                              d|d           Y dS w xY wdS dS # t,          j        $ r  t           $ r}|d}~ww xY w)a  Store intermediate writes for the latest checkpoint and clean up old writes with transaction handling.

        This method uses Redis pipeline with transaction=True to ensure atomicity of all
        write operations. In case of interruption, all operations will be aborted.

        Args:
            config (RunnableConfig): Configuration of the related checkpoint.
            writes (List[Tuple[str, Any]]): List of writes to store.
            task_id (str): Identifier for the task creating the writes.
            task_path (str): Path of the task creating the writes.

        Raises:
            asyncio.CancelledError: If the operation is cancelled/interrupted
        Nrm   ro   rp   ru   rs   Fr~   )	ro   rp   rs   r   r   idxchanneltypeblobwrite_keys_zset:::shallowr   r   c                    i | ]\  }}||	S r_   r_   )ry   r   rz   s      rG   r   z6AsyncShallowRedisSaver.aput_writes.<locals>.<dictcomp>  s    KKKcCKKKrH   )raise_on_errorr   r   z/Failed to apply TTL to checkpoint write key: %sz-Failed to apply TTL to write registry key: %sT)exc_info)r   r.   r   	enumerateserdedumps_typedr   _encode_blobr   r%   (_make_redis_checkpoint_writes_key_cachedr   r   zaddr   r   r   r   r   r   r   r   r>   r   )rE   rh   r   r   r   ro   rp   rs   r   writes_objectsr   r   r   type_r   	write_objsafe_checkpoint_nsthread_zset_key
write_keysrz   zadd_mappingr   resultr   r   s                            rG   aput_writesz"AsyncShallowRedisSaver.aput_writes  s     *  	F>*;7	~.22?BGG~.?Y	{+++>>H  N)26):): 1 1%%gu"j44U;;t!*%2%2&!*)-gs;;&! --  	 %%i0000 "5]!C!CK9KK/AKKK 
 J+ ' '	CC!!e$  !!#&&&&
 #,N";"; 9 9Y o##Ci8888 LKYz5J5JKKKLMM/<888 %,,E,BBBBBBBBG " ! !fi00 ! L!  =DO#C#C!$/"5"5m"D"Dr"IJJ%  C"k00kBBBBBBBBBB$   Ms    +,,_kJJJJJJJJJJJ    NNG'!% #       #C#C$ % 	 	 	  	 	 	G	s[    GJ; !H:9J; :%I"J; !I""J; &!J	 	'J40J; 3J44J; ;KKKro   rp   rs   r   dict[str, Any]c                4  K   |                      ||          }| j                                                            |d           d{V }|si S t	          |t
                    r|d         n|}|                    di           }|                     |          S )z?Retrieve channel_values dictionary from inline checkpoint data.z$.checkpointNr   rt   )r   r.   r   r   r   listr   )	rE   ro   rp   rs   r   r   r   ri   rt   s	            rG   aget_channel_valuesz*AsyncShallowRedisSaver.aget_channel_values8  s       GG}
 

 !% 0 0 2 2 6 6~~ V VVVVVVV 	I #-_d"C"CXOA 	 $(8"== //???rH   list[tuple[str, bytes]]c                P  K   t          t          d          |k    t          d          t          |          k    z  t          d          t          k    z  g dd          }| j                            |           d{V }t          |j        d 	          }fd
|D             S )a3  Load pending sends for a parent checkpoint.

        Args:
            thread_id: The thread ID
            checkpoint_ns: The checkpoint namespace
            parent_checkpoint_id: The ID of the parent checkpoint

        Returns:
            List of (type, blob) tuples representing pending sends
        ro   rp   r   )r   $.blobr   r   r   r   r   r   r   Nc                f    t          | dd          t          | dd          t          | dd          fS )Nr   ru   r   r   r   rX   )xs    rG   <lambda>z=AsyncShallowRedisSaver._aload_pending_sends.<locals>.<lambda>r  s6    ;++9b))5!$$ rH   )rz   c                z    g | ]7}t          |d t          |dd                    x$t          |dd          f8S )r  r   Nr   ru   r  )ry   r   r   s     rG   
<listcomp>z?AsyncShallowRedisSaver._aload_pending_sends.<locals>.<listcomp>|  sW     
 
 
XwsFD/I/IJJJW S&"%%t,WWWrH   )r   r   r%   r   r,   r   sortedr   )rE   ro   rp   parent_writes_queryparent_writes_resultssorted_writesr   s         @rG   _aload_pending_sendsz+AsyncShallowRedisSaver._aload_pending_sendsT  s        *";//9<?##':='I'IIK9~~&( LKK
 
 
 '+&B&I&I'
 '
 !
 !
 !
 !
 !
 !

 !& 
 
 

 
 
 
$
 
 
 	
rH   List[PendingWrite]c                  K   |g S t          |          }d| d| d}	 | j                            |           d{V }|dk    rg S | j                            |dd           d{V }|rd |D             }| j                            d	          }	|D ])}
|	                                                    |
           *|	                                 d{V }i }|D ]7}|r3|                    d
d          }|                    dd          }||||f<   8t          j	        | j
        |          S n# t          $ r Y nw xY wg S )z;Load pending writes using thread-level sorted set registry.Nr   r   r   r   c                d    g | ]-}t          |t                    r|                                n|.S r_   )r   bytesdecode)ry   rz   s     rG   r  z@AsyncShallowRedisSaver._aload_pending_writes.<locals>.<listcomp>  sC           %/sE$:$:CCJJLLL     rH   Fr~   r   ru   r   )r%   r.   zcardzranger   r   r   r   r#   _load_writesr   r   )rE   ro   rp   rs   r   r   write_countr   decoded_keysr   rz   r   writes_dict
write_datar   r   s                   rG   r   z,AsyncShallowRedisSaver._aload_pending_writes  s       I 1??UYUU9KUUU&	 $ 1 1/ B BBBBBBBKa	  ${11/1bIIIIIIIIJ L   )       ;//E/BB' - -CMMOO'',,,, ( 0 0 2 2222222 FH") A AJ! A",..B"?"?(nnUA666@WcN3 &24:{KKK1L4  	 	 	D	 	s   'D0 C&D0 0
D=<D=c                `    |du | _         |t          j        |fi |pi | _        dS || _        dS )zConfigure the Redis client.

        Supports standard Redis URLs (redis://), SSL (rediss://), and
        Sentinel URLs (redis+sentinel://host:26379/service_name/db).
        N)rV   r   get_async_redis_connectionr.   )rE   r4   r/   r0   s       rG   configure_clientz'AsyncShallowRedisSaver.configure_client  sQ     !- 40K -3 DKKK 'DKKKrH   c                    t          j        | j        | j                  | _        t          j        | j        | j                  | _        dS )z+Create indexes without connecting to Redis.)r/   N)r   	from_dictcheckpoints_schemar.   r+   writes_schemar,   rL   s    rG   create_indexesz%AsyncShallowRedisSaver.create_indexes  sR    !1!;#$+"
 "
 "
 (8'AT[(
 (
 (
$$$rH   c                    	 t          j                    | j        u rt          j        d          n# t          $ r Y nw xY wt          j        |                     |          | j                                                  S )z5Retrieve a checkpoint tuple from Redis synchronously.zSynchronous calls to AsyncShallowRedisSaver are only allowed from a different thread. From the main thread, use the async interface.For example, use `await checkpointer.aget_tuple(...)` or `await graph.ainvoke(...)`.)r>   r?   r@   InvalidStateErrorRuntimeErrorrun_coroutine_threadsafer   r   )rE   rh   s     rG   	get_tuplez AsyncShallowRedisSaver.get_tuple  s    		'))TY66/+   7  	 	 	D	/OOF##TY
 

&((	   .1 
>>c                    t          j        |                     ||||          | j                                                  S )z/Store only the latest checkpoint synchronously.)r>   r&  r   r@   r   )rE   rh   ri   rj   rk   s        rG   putzAsyncShallowRedisSaver.put  s;     /IIfj(LAA49
 

&((	rH   Sequence[Tuple[str, Any]]c                    t          j        |                     |||          | j                                                  S )z(Store intermediate writes synchronously.)r>   r&  r   r@   r   )rE   rh   r   r   r   s        rG   
put_writesz!AsyncShallowRedisSaver.put_writes  s;     /VVW55ty
 

&((	rH   c                   	 t          j                    | j        u rt          j        d          n# t          $ r Y nw xY wt          j        |                     ||||          | j                                                  S )z\Retrieve channel_values dictionary with properly constructed message objects (sync wrapper).zSynchronous calls to AsyncShallowRedisSaver are only allowed from a different thread. From the main thread, use the async interface.For example, use `await checkpointer.aget_channel_values(...)`.)r>   r?   r@   r$  r%  r&  r   r   )rE   ro   rp   rs   r   s        rG   get_channel_valuesz)AsyncShallowRedisSaver.get_channel_values  s    	'))TY66/V   7  	 	 	D	/$$=-9I  I	
 

 &((	r(  c                    d| d| }|| j         vr*| j                            | j        ||g          | j         |<   | j         |         S )zSCreate a cached key for shallow checkpoints using only thread_id and checkpoint_ns.zshallow_checkpoint:r   )rA   rD   join_checkpoint_prefix)rE   ro   rp   	cache_keys       rG   r   z@AsyncShallowRedisSaver._make_shallow_redis_checkpoint_key_cached  sa     F)EEmEE	DO++)-)=)=()]C* *DOI& y))rH   c                :    t          j        t          | |g          S )zLCreate a key for shallow checkpoints using only thread_id and checkpoint_ns.)r"   r1  r    ro   rp   s     rG   "_make_shallow_redis_checkpoint_keyz9AsyncShallowRedisSaver._make_shallow_redis_checkpoint_key!  s     #'):I}(UVVVrH   r   c           
         d| d| d| d| d| 
}|| j         vr!|                     |||||          | j         |<   | j         |         S )z*Create a cached key for checkpoint writes.zwrites:r   )rA   !_make_redis_checkpoint_writes_key)rE   ro   rp   rs   r   r   r3  s          rG   r   z?AsyncShallowRedisSaver._make_redis_checkpoint_writes_key_cached&  sz     RiQQ-QQ-QQ'QQCQQ 	 DO++)-)O)O=-#* *DOI& y))rH   c                    t          j        t          t          t	          |                     t          |          g          dz   S )zECreate a pattern to match all writes keys for a thread and namespace.z:*)r"   r1  r!   r)   r$   r%   r5  s     rG   1_make_shallow_redis_checkpoint_writes_key_patternzHAsyncShallowRedisSaver._make_shallow_redis_checkpoint_writes_key_pattern8  sJ      $+*95566'66  		
rH   r   c                t   |                     d          }|rt          |t                    rp	 t          j        |                    dd                    }|                                t          z  S # t          $ r t          j	                    t          z  cY S w xY w|S t          j	                    t          z  S )ai  Extract timestamp from checkpoint's ts field or use current time.

        This is used when the checkpoint_id is not a valid ULID (e.g., UUIDv6 format).
        See Issue #136 for details.

        Args:
            checkpoint: The checkpoint object containing an optional ts field.

        Returns:
            Timestamp in milliseconds since epoch.
        r   Zz+00:00)
r   r   r)   r   fromisoformatr   r   MILLISECONDS_PER_SECONDr   time)rE   ri   ts_valuedts       rG   r   z2AsyncShallowRedisSaver._extract_fallback_timestampH  s     >>$'' 		 (C((  A!/0@0@h0O0OPPB<<>>,CCC  A A A9;;)@@@@@A  y{{444s   AA2 2%BBc           	     *  K   t          |          }t          t          d          |k    ddgd          }| j                            |           d{V }g }t                      }|j        D ]S}t          |dd          }|                    |           | 	                    ||          }	|
                    |	           Tt          t          d          |k    g dd          }
| j                            |
           d{V }|j        D ]}t          |dd          }t          |dd          }t          |d	d          }t          |d
d          }|                     |||||          }|
                    |           |                    |           |D ]+}|
                    d| dt          |           d           ,| j                                        }|D ]}|                    |           |                                 d{V  dS )zDelete checkpoint and writes associated with a specific thread ID.

        Args:
            thread_id: The thread ID which checkpoint should be deleted.
        ro   rp   rs   i'  r  Nru   )rp   rs   r   r   r   r   r   r   r   r   )r$   r   r   r+   r   r   r   rX   addr6  r   r,   r8  r%   r.   r   deleter   )rE   ro   storage_safe_thread_idcheckpoint_querycheckpoint_resultskeys_to_deletecheckpoint_namespacesr   rp   r   checkpoint_writes_querycheckpoint_writes_resultsrs   r   r   	write_keyr   rz   s                     rG   adelete_threadz%AsyncShallowRedisSaver.adelete_threada  s      "4I!>!> '!+..);*O<
 
 
 $(#9#@#@AQ#R#RRRRRRR  #%* 		2 		2C#C"==M!%%m444 "DD= N !!.1111"-!+..);NNN#
 #
 #

 +/*F*M*M#+
 +
 %
 %
 %
 %
 %
 %
! -1 		5 		5C#C"==M#C"==Mc9b11G#ua((C>>=-# I !!),,,!%%m44442 	 	M!!h#9hh<OP]<^<^hhh   
 ;''))! 	! 	!COOC               rH   keep_latest)strategy	keep_last
thread_idsSequence[str]rO  rP  c                  K   ||dk    rd}nd}|st          d          |dk     rt          d|           |dk    rdS |D ]}|                     |           d{V  dS )a  Prune checkpoints for the given threads.

        ``AsyncShallowRedisSaver`` stores at most one checkpoint per namespace
        by design, so ``strategy="keep_latest"`` (or ``keep_last >= 1``) is
        always a no-op.  ``strategy="delete"`` (or ``keep_last=0``) removes
        all checkpoints for each thread (equivalent to ``adelete_thread``).

        Args:
            thread_ids: Thread IDs to prune.
            strategy: Pruning strategy.  ``"keep_latest"`` is a no-op for
                shallow savers (default).  ``"delete"`` removes all.
            keep_last: Optional override.  Any value >= 1 is a no-op.
                Pass ``0`` to delete all.
        NrD  r   r   z+``thread_ids`` must be a non-empty sequencez ``keep_last`` must be >= 0, got )
ValueErrorrM  )rE   rQ  rO  rP  ro   s        rG   aprunezAsyncShallowRedisSaver.aprune  s      , 8##			  	LJKKKq==K	KKLLL>>F# 	1 	1I%%i0000000000	1 	1rH   rx   )r4   r5   r/   r6   r0   r7   r1   r7   r2   r)   r3   r)   r8   r9   )r8   r(   )rN   rO   rP   rQ   rR   rS   r8   r9   )r4   r5   r/   r6   r0   r7   r1   r7   r2   r)   r3   r)   r8   r]   )r8   r9   )
rh   r   ri   r   rj   r   rk   r   r8   r   )
rh   r   r   r   r   r   r   r   r8   r   )rh   r   r8   r   )ru   )
rh   r   r   r   r   r)   r   r)   r8   r9   )
ro   r)   rp   r)   rs   r)   r   r   r8   r   )ro   r)   rp   r)   r8   r   )ro   r)   rp   r)   rs   r)   r8   r  )NNN)r4   r5   r/   r6   r0   r7   r8   r9   )
rh   r   r   r+  r   r)   r   r)   r8   r9   )ro   r)   rp   r)   r8   r)   )ro   r)   rp   r)   rs   r)   r   r)   r   r   r8   r)   )ri   r   r8   r   )ro   r)   r8   r9   )rQ  rR  rO  r)   rP  r   r8   r9   )%__name__
__module____qualname____doc____annotations__r    r!   r=   rM   r\   classmethodr   rb   rJ   rg   r   r   r   r   r   r  r   r  r"  r'  r*  r-  r/  r   staticmethodr6  r   r:  r   rM  rU  __classcell__)rF   s   @rG   r(   r(   1   sk          OOO''''---- $(. .248(,!2'>. . . . . . . .6   > > > >&  $( .248(,!2'>      [*C C C C
   s s s sr ,0+/#\ \ \ \ \ \|N
 N
 N
 N
j u u u u ux 6:@ @ @ @ @8,
 ,
 ,
 ,
\5 5 5 5r $(-148	' ' ' ' '(
 
 
 
    
 
 
 
" 
 
 
 
 
" 6:    0	* 	* 	* 	* W W W \W* * * *$ 
 
 
 \
5 5 5 52=! =! =! =!F &#'&1 &1 &1 &1 &1 &1 &1 &1 &1 &1rH   r(   )=rY  
__future__r   r>   r   loggingr?  
contextlibr   r   typesr   typingr   r   r	   r
   r   r   r   r   r   langchain_core.runnablesr   langgraph.checkpoint.baser   r   r   r   r   r   r   langgraph.constantsr   redis.asyncior   r-   redisvl.indexr   redisvl.queryr   redisvl.query.filterr   r   redisvl.redis.connectionr   ulidr   langgraph.checkpoint.redis.baser    r!   r"   r#   langgraph.checkpoint.redis.utilr$   r%   	getLoggerrV  r   r>  r(   r_   rH   rG   <module>ro     st   I I " " " " " "     * * * * * *             X X X X X X X X X X X X X X X X X X X X X X 3 3 3 3 3 3                  & % % % % % - - - - - - * * * * * * % % % % % % ) ) ) ) ) ) ) ) ; ; ; ; ; ;                        
 
	8	$	$  U1 U1 U1 U1 U1^J8H,HI U1 U1 U1 U1 U1rH   