
    <ia2                        d dl mZ d dlmZmZmZmZmZ d dlm	Z	 	 d dlm
Z
 n# e$ r	 d dlm
Z
 Y nw xY wd dlmZmZ d dlmZmZ e	 G d d                      Z G d	 d
e          Ze	 G d d                      Z G d d          Z G d de          Ze	 G d d                      Ze	 G d d                      Ze	 G d de                      Ze	 G d d                      ZdS )    )Enum)AnyDictListOptionalUnion)experimental)Self)LimitReducer)FilterSortbyFieldc            	           e Zd Z	 	 ddedee         dee         ddfdZdefdZdedd fdZd	edd fd
Zde	e         fdZ
dS )HybridSearchQueryNquery_stringscoreryield_score_asreturnc                 0    || _         || _        || _        dS )a  
        Create a new hybrid search query object.

        Args:
            query_string: The query string.
            scorer: The scorer to use. Allowed values are "TFIDF" or "BM25".
            yield_score_as: The name of the field to yield the score as.
        N)_query_string_scorer_yield_score_as)selfr   r   r   s       /Users/kimhansen/Desktop/03 Workspace/ceo-agents/chl-effectiveness/mcp-servers/whoop/.venv/lib/python3.11/site-packages/redis/commands/search/hybrid_query.py__init__zHybridSearchQuery.__init__   s!     *-    c                     | j         S )z-Return the query string of this query object.)r   r   s    r   r   zHybridSearchQuery.query_string#       !!r   c                     || _         | S )a$  
        Scoring algorithm for text search query.
        Allowed values are "TFIDF", "DISMAX", "DOCSCORE", "BM25", etc.

        For more information about supported scroring algorithms,
        see https://redis.io/docs/latest/develop/ai/search-and-query/advanced-concepts/scoring/
        )r   )r   r   s     r   r   zHybridSearchQuery.scorer'   s     r   aliasc                     || _         | S )z-
        Yield the score as a field.
        r   r   r!   s     r   r   z HybridSearchQuery.yield_score_as2         %r   c                     d| j         g}| j        r|                    d| j        f           | j        r|                    d| j        f           |S )NSEARCHSCORERYIELD_SCORE_AS)r   r   extendr   r   argss     r   get_argszHybridSearchQuery.get_args9   s^    $,-< 	2KK4<0111 	BKK)4+?@AAAr   )NN)__name__
__module____qualname__strr   r   r   r   r   r   r-    r   r   r   r      s        
 !%(,	. .. . !	.
 
. . . .$"c " " " "	S 	%8 	 	 	 	C ,?    $s)      r   r   c                       e Zd ZdZdZdS )VectorSearchMethodsKNNRANGEN)r.   r/   r0   r5   r6   r2   r   r   r4   r4   B   s        
CEEEr   r4   c                       e Zd Z	 	 	 	 ddedeeef         dee         deeee	f                  ded         dee         d	dfd
Z
d	efdZd	eeef         fdZded	d fdZddZded	d fdZd	ee         fdZdS )HybridVsimQueryNvector_field_namevector_datavsim_search_methodvsim_search_method_paramsfilterr   r   r   c                 r    || _         || _        |r|r | j        |fi | nd| _        || _        || _        dS )a5  
        Create a new hybrid vsim query object.

        Args:
            vector_field_name: Vector field name.

            vector_data: Vector data for the search.

            vsim_search_method: Search method that will be used for the vsim search.

            vsim_search_method_params: Search method parameters. Use the param names
                for keys and the values for the values.
                Example for KNN: {"K": 10, "EF_RUNTIME": 100}
                                    where K is mandatory and defines the number of results
                                    and EF_RUNTIME is optional and definesthe exploration factor.
                Example for RANGE: {"RADIUS": 10, "EPSILON": 0.1}
                                    where RADIUS is mandatory and defines the radius of the search
                                    and EPSILON is optional and defines the accuracy of the search.
            yield_score_as: The name of the field to yield the score as.

            filter: If defined, a filter will be applied on the vsim query results.
        N)_vector_field_vector_datavsim_method_params_vsim_method_params_filterr   )r   r9   r:   r;   r<   r=   r   s          r   r   zHybridVsimQuery.__init__I   sa    > /' 	,"; 	,#D#$6TT:STTTT'+D$-r   c                     | j         S )z2Return the vector field name of this query object.)r?   r   s    r   vector_fieldzHybridVsimQuery.vector_fieldq   r   r   c                     | j         S )z,Return the vector data of this query object.)r@   r   s    r   r:   zHybridVsimQuery.vector_datau   s      r   methodc                     |j         g}|rh|                    t          |                                          dz             |                                D ]\  }}|                    ||f           || _        | S )aB  
        Add search method parameters to the query.

        Args:
            method: Vector search method name. Supported values are "KNN" or "RANGE".
            kwargs: Search method parameters. Use the param names for keys and the
                values for the values. Example: {"K": 10, "EF_RUNTIME": 100}.
           )valueappendlenitemsr*   rB   )r   rG   kwargsrA   keyrJ   s         r   rA   z"HybridVsimQuery.vsim_method_paramsy   s     6<\N 	8%%c&,,..&9&9A&=>>>$llnn 8 8
U"))3,7777#5 r   fltHybridFilterc                     || _         | S )z
        Add a filter to the query.

        Args:
            flt: A HybridFilter object, used on a corresponding field.
        rC   )r   rP   s     r   r=   zHybridVsimQuery.filter   s     r   r!   c                     || _         | S )z@
        Return the score as a field with name `alias`.
        r#   r$   s     r   r   zHybridVsimQuery.yield_score_as   r%   r   c                     d| j         | j        g}| j        r|                    | j                   | j        r|                    | j        j                   | j        r|                    d| j        f           |S )NVSIMr)   )r?   r@   rB   r*   rC   r,   r   r+   s     r   r-   zHybridVsimQuery.get_args   s    *D,=># 	2KK0111< 	+KK)*** 	BKK)4+?@AAAr   )NNNN)rP   rQ   r   r8   )r.   r/   r0   r1   r   bytesr   r4   r   r   r   rE   r:   rA   r=   r   r   r-   r2   r   r   r8   r8   G   sa        =A>B%)(,&. &.&. 5#:&&. %%89	&.
 $,DcN#;&. "&. !&. 
&. &. &. &.P"c " " " "!U5#:. ! ! ! !# 
	   ,   C ,=    	$s) 	 	 	 	 	 	r   r8   c                   :    e Zd ZdededdfdZdee         fdZdS )HybridQuerysearch_queryvector_similarity_queryr   Nc                 "    || _         || _        dS )z
        Create a new hybrid query object.

        Args:
            search_query: HybridSearchQuery object containing the text query.
            vector_similarity_query: HybridVsimQuery object containing the vector similarity query.
        N)_search_query_vector_similarity_query)r   rZ   r[   s      r   r   zHybridQuery.__init__   s     *(?%%%r   c                     g }|                     | j                                                   |                     | j                                                   |S )N)r*   r]   r-   r^   r+   s     r   r-   zHybridQuery.get_args   sN    D&//11222D1::<<===r   )	r.   r/   r0   r   r8   r   r   r1   r-   r2   r   r   rY   rY      sj        @'@ "1@ 
	@ @ @ @$s)      r   rY   c                       e Zd ZdZdZdS )CombinationMethodsRRFLINEARN)r.   r/   r0   rb   rc   r2   r   r   ra   ra      s        
CFFFr   ra   c                   F    e Zd ZdeddfdZdeeeef                  fdZ	dS )CombineResultsMethodrG   r   Nc                 "    || _         || _        dS )a  
        Create a new combine results method object.

        Args:
            method: The combine method to use - RRF or LINEAR.
            kwargs: Additional combine parameters.
                    For RRF, the following parameters are supported(at least one should be provided):
                                WINDOW: Limits fusion scopeLimits fusion scope.
                                CONSTANT: Controls decay of rank influence.
                                YIELD_SCORE_AS: The name of the field to yield the calculated score as.
                    For LINEAR, supported parameters (at least one should be provided):
                                ALPHA: The weight of the first query.
                                BETA: The weight of the second query.
                                YIELD_SCORE_AS: The name of the field to yield the calculated score as.

                    The additional parameters are not validated and are passed as is to the server.
                    The supported format is to provide the parameter names and values like the following:
                        CombineResultsMethod(CombinationMethods.RRF, WINDOW=3, CONSTANT=0.5)
                        CombineResultsMethod(CombinationMethods.LINEAR, ALPHA=0.5, BETA=0.5)
        N)_method_kwargs)r   rG   rN   s      r   r   zCombineResultsMethod.__init__   s    * r   c                    d| j         j        g}| j        rr|                    t	          | j                                                  dz             | j                                        D ]\  }}|                    ||f           |S )NCOMBINErI   )rg   rJ   rh   rK   rL   rM   r*   )r   r,   rO   rJ   s       r   r-   zCombineResultsMethod.get_args   s    '0$,2D&E< 	*KKDL..0011A5666"l0022 * *
US%L))))r   )
r.   r/   r0   ra   r   r   r   r1   intr-   r2   r   r   re   re      s_        1     0$uS#X/      r   re   c                       e Zd ZddZdedefdZdee         dedefdZ	defdZ
d	d
defdZdddefdZdededefdZdee         fdZdS )HybridPostProcessingConfigr   Nc                 Z    g | _         g | _        g | _        g | _        d| _        d| _        dS )zK
        Create a new hybrid post processing configuration object.
        N)_load_statements_apply_statements_groupby_statements_sortby_fieldsrC   _limitr   s    r   r   z#HybridPostProcessingConfig.__init__   s6     !#!##%  r   fieldsc                     |rVd                     |          }|                    d          }| j                            dt	          |          g|R            | S )z=
        Add load statement parameters to the query.
         LOAD)joinsplitro   r*   rL   )r   rt   
fields_strfields_lists       r   loadzHybridPostProcessingConfig.load   sb      	S&))J$**3//K!((&#k2B2B)Q[)Q)QRRRr   reducersc           
         t          |t                    r|gn|}dt          t          |                    g|}|D ]{}|                    d|j        t          t          |j                            f           |                    |j                   |j        |                    d|j        f           || j                            |           | S )al  
        Specify by which fields to group the aggregation.

        Args:
            fields: Fields to group by. This can either be a single string or a list
                of strings. In both cases, the field should be specified as `@field`.
            reducers: One or more reducers. Reducers may be found in the
                `aggregation` module.
        GROUPBYREDUCENAS)
isinstancer1   rL   r*   NAMEr,   _aliasrq   )r   rt   r}   retreducers        r   group_byz#HybridPostProcessingConfig.group_by  s     (44@&&#c&kk**4V4 	3 	3GJJ',C4E4E0F0FGHHHJJw|$$$~)

D'.1222 '',,,r   c                     g }|                                 D ]7\  }}d|g}||                    d|f           |                    |           8| j                            |           | S )aO  
        Specify one or more projection expressions to add to each result.

        Args:
            kwexpr: One or more key-value pairs for a projection. The key is
                the alias for the projection, and the value is the projection
                expression itself, for example `apply(square_root="sqrt(@foo)")`.
        APPLYNr   )rM   r*   rp   )r   kwexpr
apply_argsr!   exprr   s         r   applyz HybridPostProcessingConfig.apply  s|     
!<<>> 	# 	#KE4D/C 

D%=)))c""""%%j111r   sortbyr   c                     g || _         | S )z5
        Add sortby parameters to the query.
        )rr   )r   r   s     r   sort_byz"HybridPostProcessingConfig.sort_by-  s     (ir   r=   rQ   c                     || _         | S )z
        Add a numeric or string filter to the query.

        Currently, only one of each filter is supported by the engine.

        Args:
            filter: A NumericFilter or GeoFilter object, used on a corresponding field.
        rS   )r   r=   s     r   r=   z!HybridPostProcessingConfig.filter4  s     r   offsetnumc                 0    t          ||          | _        | S )z4
        Add limit parameters to the query.
        )r   rs   )r   r   r   s      r   limitz HybridPostProcessingConfig.limit@  s     FC((r   c                 *   g }| j         r|                    | j                    | j        r|                    | j                   | j        r|                    | j                   | j        rMg }| j        D ]}|                    |j                   |                    dt          |          g|R            | j        r|                    | j        j                   | j        r,|                    | j        	                                           |S )NSORTBY)
ro   r*   rq   rp   rr   r,   rL   rC   rs   
build_args)r   r,   sortby_argsfs       r   r   z%HybridPostProcessingConfig.build_argsG  s     	/KK-...# 	2KK0111! 	0KK./// 	DK( + +""16****KK3{#3#3BkBBCCC< 	+KK)***; 	2KK..00111r   )r   N)r.   r/   r0   r   r1   r
   r|   r   r   r   r   r   r=   rk   r   r   r2   r   r   rm   rm      s       	 	 	 	C D    tCy W     .    (}     
^ 
 
 
 
 
C c d    DI      r   rm   c                       e Zd ZdeddfdZdS )rQ   
conditionsr   Nc                 2    |g}t          j        | dg|R   dS )zn
        Create a new hybrid filter object.

        Args:
            conditions: Filter conditions.
        FILTERN)r   r   )r   r   r,   s      r   r   zHybridFilter.__init__^  s+     |h.......r   )r.   r/   r0   r1   r   r2   r   r   rQ   rQ   \  s:        // 
/ / / / / /r   rQ   c                   *    e Zd ZddededdfdZd ZdS )	HybridCursorQueryr   countmax_idler   Nc                 "    || _         || _        dS )z
        Create a new hybrid cursor query object.

        Args:
            count: Number of results to return per cursor iteration.
            max_idle: Maximum idle time for the cursor.
        N)r   r   )r   r   r   s      r   r   zHybridCursorQuery.__init__n  s     
 r   c                     dg}| j         r|dt          | j                   gz  }| j        r|dt          | j                  gz  }|S )N
WITHCURSORCOUNTMAXIDLE)r   r1   r   r+   s     r   r   zHybridCursorQuery.build_argsy  sR    ~: 	/Wc$*oo..D= 	4YDM 2 233Dr   )r   r   )r.   r/   r0   rk   r   r   r2   r   r   r   r   l  sQ        	! 	!c 	! 	!T 	! 	! 	! 	!    r   r   N)enumr   typingr   r   r   r   r   redis.utilsr	   r
   ImportErrortyping_extensions!redis.commands.search.aggregationr   r   redis.commands.search.queryr   r   r   r4   r8   rY   ra   re   rm   rQ   r   r2   r   r   <module>r      s         3 3 3 3 3 3 3 3 3 3 3 3 3 3 $ $ $ $ $ $' ' ' '&&&&&&&&' = < < < < < < < ; ; ; ; ; ; ; ; / / / / / / / /d    $   
 a a a a a a a aH       .       
        D m m m m m m m m` / / / / /6 / / /          s   # 11