
    ^h7"                     |    S r SSKrSSKrSSKJr  SSKJrJrJrJr  SSK	J
r
  SSKJr   " S S5      r " S	 S
5      rg)zA
Class to handle llm wildcard routing and regex pattern matching
    N)Match)DictListOptionalTuple)get_llm_provider)verbose_router_loggerc            	       |    \ rS rSr\S\S\\\4   4S j5       r\S\	\\
\	   4   S\
\\\
\	   4      4S j5       rSrg)	PatternUtils   patternreturnc                 P   ^  / SQn[        T 5      [        U 4S jU 5       5      4nU$ )z
Calculate pattern specificity based on length and complexity.

Args:
    pattern: Regex pattern to analyze

Returns:
    Tuple of (length, complexity) for sorting
)	*+?\^$|()c              3   F   >#    U  H  nTR                  U5      v   M     g 7fN)count).0charr   s     h/home/james-whalen/.local/lib/python3.13/site-packages/litellm/router_utils/pattern_match_deployments.py	<genexpr>=PatternUtils.calculate_pattern_specificity.<locals>.<genexpr>   s!      0@d##0@s   !)lensum)r   complexity_charsret_vals   `  r   calculate_pattern_specificity*PatternUtils.calculate_pattern_specificity   s6     JL 0@ 
     patternsc                 6    [        U R                  5       S SS9$ )zl
Cached property for patterns sorted by specificity.

Returns:
    Sorted list of pattern-deployment tuples
c                 2    [         R                  U S   5      $ )Nr   )r   r%   )xs    r   <lambda>.PatternUtils.sorted_patterns.<locals>.<lambda>/   s    ,DDQqTJr'   T)keyreverse)sorteditemsr(   s    r   sorted_patternsPatternUtils.sorted_patterns#   s!     NNJ
 	
r'    N)__name__
__module____qualname____firstlineno__staticmethodstrr   intr%   r   r   r3   __static_attributes__r5   r'   r   r   r      sm    s uS#X  & 
sDJ'
	eCdO$	%
 
r'   r   c            	          \ rS rSrSrS rS\S\4S jrS\S\4S jr	S	\
S
\\   S\\   4S jr SS\\   S\\\      S\\\      4S jjr\S	\
S\S\4S j5       r SS\S\\   S\\\      4S jjr SS\S\\   S\\   4S jjrSrg)PatternMatchRouter4   z
Class to handle llm wildcard routing and regex pattern matching

doc: https://docs.litellm.ai/docs/proxy/configs#provider-specific-wildcard-routing

This class will store a mapping for regex pattern: List[Deployments]
c                     0 U l         g r   r2   )selfs    r   __init__PatternMatchRouter.__init__=   s	    )+r'   r   llm_deploymentc                     U R                  U5      nX0R                  ;  a  / U R                  U'   U R                  U   R                  U5        g)z
Add a regex pattern and the corresponding llm deployments to the patterns

Args:
    pattern: str
    llm_deployment: str or List[str]
N)_pattern_to_regexr(   append)rB   r   rE   regexs       r   add_patternPatternMatchRouter.add_pattern@   sC     &&w/%#%DMM% e##N3r'   r   c                 N    [         R                  " U5      R                  SS5      $ )z
Convert a wildcard pattern to a regex pattern

example:
pattern: openai/*
regex: openai/.*

pattern: openai/fo::*::static::*
regex: openai/fo::.*::static::.*

Args:
    pattern: str

Returns:
    str: regex pattern
z\*z(.*))reescapereplace)rB   r   s     r   rG   $PatternMatchRouter._pattern_to_regexN   s     , yy!))%88r'   matched_patterndeploymentsc                     / nU HJ  n[         R                  " U5      n[        R                  UUS   S   S9US   S'   UR	                  U5        ML     U$ )Nlitellm_paramsmodel)rQ    litellm_deployment_litellm_model)copydeepcopyr?   set_deployment_model_namerH   )rB   rQ   rR   new_deployments
deploymentnew_deployments         r   #_return_pattern_matched_deployments6PatternMatchRouter._return_pattern_matched_deploymentsf   sp     %J!]]:6N"<<$35?@P5Q6 =  +,W5 "">2 & r'   Nrequestfiltered_model_namesc                     Uc  g[         R                  U R                  5      nUb!  U Vs/ s H  o@R                  U5      PM     snO/ nU H=  u  pgUb  Xe;  a  M  [        R
                  " Xa5      nU(       d  M.  U R                  XS9s  $    gs  snf ! [         a,  n	[        R                  " S[        U	5       35         Sn	A	gSn	A	ff = f)a  
Route a requested model to the corresponding llm deployments based on the regex pattern

loop through all the patterns and find the matching pattern
if a pattern is found, return the corresponding llm deployments
if no pattern is found, return None

Args:
    request: Optional[str]
    filtered_model_names: Optional[List[str]] - if provided, only return deployments that match the filtered_model_names
Returns:
    Optional[List[Deployment]]: llm deployments
N)rQ   rR   z#Error in PatternMatchRouter.route: )r   r3   r(   rG   rM   matchr]   	Exceptionr	   debugr;   )
rB   r_   r`   r3   mregex_filtered_model_namesr   llm_deploymentspattern_matches
             r   routePatternMatchRouter.routex   s     	X*::4==IO (3 5II4Hq''*4HI '
 -<((4A " : =CC(5 D   -< % J  	X!''*McRSfX(VWW	Xs9   B &B B1B ;B B B 
C
"CC
rV   c                     SU;  a  U$ UR                  S5      nU R                  5       n[        U5      U:  a  U R                  $ U H  nUR	                  SUS5      nM     U$ )aV  
Set the model name for the matched pattern llm deployment

E.g.:

Case 1:
model_name: llmengine/* (can be any regex pattern or wildcard pattern)
litellm_params:
    model: openai/*

if model_name = "llmengine/foo" -> model = "openai/foo"

Case 2:
model_name: llmengine/fo::*::static::*
litellm_params:
    model: openai/fo::*::static::*

if model_name = "llmengine/foo::bar::static::baz" -> model = "openai/foo::bar::static::baz"

Case 3:
model_name: *meta.llama3*
litellm_params:
    model: bedrock/meta.llama3*

if model_name = "hello-world-meta.llama3-70b" -> model = "bedrock/meta.llama3-70b"
r      )r   groupsr!   stringrO   )rQ   rV   wildcard_countdynamic_segmentssegments        r   rY   ,PatternMatchRouter.set_deployment_model_name   s}    B 66339??D +113 >1&& (G/O/W/WWa0, (
 0/r'   rU   custom_llm_providerc                     Uc   [        US9u  nnnnU R                  U5      =(       d    U R                  U SU 35      $ ! [         a     N:f = f)z
Check if a pattern exists for the given model and custom llm provider

Args:
    model: str
    custom_llm_provider: Optional[str]

Returns:
    bool: True if pattern exists, False otherwise
)rU   /)r   rc   rj   )rB   rU   rt   _s       r   get_patternPatternMatchRouter.get_pattern   sj     &	 %51'
 zz% PDJJ2E1Faw/O$PP  s   A 
AAc                 :    U R                  X5      nU(       a  U$ / $ )z
Get the deployments by pattern

Args:
    model: str
    custom_llm_provider: Optional[str]

Returns:
    List[Dict]: llm deployments matching the pattern
)rx   )rB   rU   rt   rh   s       r   get_deployments_by_pattern-PatternMatchRouter.get_deployments_by_pattern   s"     ((D  	r'   r2   r   )r6   r7   r8   r9   __doc__rC   r;   r   rJ   rG   r   r   r]   r   rj   r:   rY   rx   r{   r=   r5   r'   r   r?   r?   4   s'   ,43 4 49 9 90$37:	d& SW(}(<DT#Y<O(	$t*	(T 2020*-20 
20 20j @DQQ/7}Q	$t*	Q6 @D/7}	d r'   r?   )r}   rW   rM   r   typingr   r   r   r   litellmr   litellm._loggingr	   r   r?   r5   r'   r   <module>r      s8     	  . . $ 2#
 #
LM Mr'   