
     h'                          e             Z G d  d          Z G d d          Z G d d          Z G d de          Z G d d	e          Z G d
 d          Z G d d          Z G d d          Z	dS )c                       e Zd ZddZd ZdS )Limit    c                 "    || _         || _        d S N)offsetcount)selfr   r   s      ]/var/www/html/Sam_Eipo/venv/lib/python3.11/site-packages/redis/commands/search/aggregation.py__init__zLimit.__init__   s    


    c                 f    | j         r)dt          | j                  t          | j                   gS g S )NLIMIT)r   strr   r	   s    r
   
build_argszLimit.build_args	   s0    : 	S--s4:??Ir   N)r   r   __name__
__module____qualname__r   r    r   r
   r   r      s7               r   r   c                   8    e Zd ZdZdZd Zd Zed             ZdS )Reducerzr
    Base reducer object for all reducers.

    See the `redisearch.reducers` module for the actual reducers.
    Nc                 0    || _         d | _        d | _        d S r   )_args_field_aliasr	   argss     r
   r   zReducer.__init__   s    
r   c                 p    |t           u r%| j        st          d          | j        dd         }|| _        | S )a  
        Set the alias for this reducer.

        ### Parameters

        - **alias**: The value of the alias for this reducer. If this is the
            special value `aggregation.FIELDNAME` then this reducer will be
            aliased using the same name as the field upon which it operates.
            Note that using `FIELDNAME` is only possible on reducers which
            operate on a single field value.

        This method returns the `Reducer` object making it suitable for
        chaining.
        z(Cannot use FIELDNAME alias with no field   N)	FIELDNAMEr   
ValueErrorr   )r	   aliass     r
   r#   zReducer.alias   sD     I; M !KLLLKOEr   c                     | j         S r   )r   r   s    r
   r   zReducer.args5   s
    zr   )	r   r   r   __doc__NAMEr   r#   propertyr   r   r   r
   r   r      s^          D  
  .   X  r   r   c                       e Zd ZdZdZd ZdS )SortDirectionz@
    This special class is used to indicate sort direction.
    Nc                     || _         d S r   )field)r	   r+   s     r
   r   zSortDirection.__init__A   s    


r   )r   r   r   r%   	DIRSTRINGr   r   r   r
   r)   r)   :   s4          I    r   r)   c                       e Zd ZdZdZdS )AsczK
    Indicate that the given field should be sorted in ascending order
    ASCNr   r   r   r%   r,   r   r   r
   r.   r.   E   s          IIIr   r.   c                       e Zd ZdZdZdS )DesczL
    Indicate that the given field should be sorted in descending order
    DESCNr0   r   r   r
   r2   r2   M   s          IIIr   r2   c                   ^    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 Zd ZddZd Zd ZdS )AggregateRequestzH
    Aggregation request which can be passed to `Client.aggregate`.
    *c                     || _         g | _        g | _        d| _        d| _        d| _        d| _        g | _        d| _        dS )a}  
        Create an aggregation request. This request may then be passed to
        `client.aggregate()`.

        In order for the request to be usable, it must contain at least one
        group.

        - **query** Query string for filtering records.

        All member methods (except `build_args()`)
        return the object itself, making them useful for chaining.
        Fr   N)	_query_aggregateplan_loadfields_loadall_max_with_schema	_verbatim_cursor_dialect)r	   querys     r
   r   zAggregateRequest.__init__Z   sJ      	!r   c                 N    |r| j                             |           nd| _        | S )aC  
        Indicate the fields to be returned in the response. These fields are
        returned in addition to any others implicitly specified.

        ### Parameters

        - **fields**: If fields not specified, all the fields will be loaded.
        Otherwise, fields should be given in the format of `@field`.
        T)r:   extendr;   )r	   fieldss     r
   loadzAggregateRequest.loadq   s2      	!##F++++ DMr   c           	         t          |t                    r|gn|}t          |t                    r|gn|}dt          t          |                    g|}|D ][}|d|j        t          t          |j                            gz  }|                    |j                   |j        |d|j        gz  }\| j                            |           | S )a|  
        Specify by which fields to group the aggregation.

        ### Parameters

        - **fields**: Fields to group by. This can either be a single string,
            or a list of strings. 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)	
isinstancer   r   lenr&   r   rC   r   r9   )r	   rD   reducersretreducers        r
   group_byzAggregateRequest.group_by   s     (44@&&!+Hg!>!>LH::H#c&kk**4V4 	. 	.GHglCGL0A0A,B,BCCCJJw|$$$~)gn--""3'''r   c                     |                                 D ],\  }}d|g}||d|gz  }| j                            |           -| S )aQ  
        Specify one or more projection expressions to add to each result

        ### Parameters

        - **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)")`
        APPLYNrI   )itemsr9   rC   )r	   kwexprr#   exprrM   s        r
   applyzAggregateRequest.apply   s[     "<<>> 	, 	,KE4D/C e}$&&s++++r   c                 ~    t          ||          }| j                            |                                           | S )a  
        Sets the limit for the most recent group or query.

        If no group has been defined yet (via `group_by()`) then this sets
        the limit for the initial pool of results from the query. Otherwise,
        this limits the number of items operated on from the previous group.

        Setting a limit on the initial search results may be useful when
        attempting to execute an aggregation on a sample of a large data set.

        ### Parameters

        - **offset**: Result offset from which to begin paging
        - **num**: Number of results to return


        Example of sorting the initial results:

        ```
        AggregateRequest("@sale_amount:[10000, inf]")            .limit(0, 10)            .group_by("@state", r.count())
        ```

        Will only group by the states found in the first 10 results of the
        query `@sale_amount:[10000, inf]`. On the other hand,

        ```
        AggregateRequest("@sale_amount:[10000, inf]")            .limit(0, 1000)            .group_by("@state", r.count()            .limit(0, 10)
        ```

        Will group all the results matching the query, but only return the
        first 10 groups.

        If you only wish to return a *top-N* style query, consider using
        `sort_by()` instead.

        )r   r9   rC   r   )r	   r   num_limits       r
   limitzAggregateRequest.limit   s<    T vs##""6#4#4#6#6777r   c                    t          |t          t          f          r|g}g }|D ]/}t          |t                    r||j        |j        gz  })||gz  }0dt          t          |                    g}|                    |           |                    dd          }|dk    r|dt          |          gz  }| j                            |           | S )a,  
        Indicate how the results should be sorted. This can also be used for
        *top-N* style queries

        ### Parameters

        - **fields**: The fields by which to sort. This can be either a single
            field or a list of fields. If you wish to specify order, you can
            use the `Asc` or `Desc` wrapper classes.
        - **max**: Maximum number of results to return. This can be
            used instead of `LIMIT` and is also faster.


        Example of sorting by `foo` ascending and `bar` descending:

        ```
        sort_by(Asc("@foo"), Desc("@bar"))
        ```

        Return the top 10 customers:

        ```
        AggregateRequest()            .group_by("@customer", r.sum("@paid").alias(FIELDNAME))            .sort_by(Desc("@paid"), max=10)
        ```
        SORTBYmaxr   MAX)	rJ   r   r)   r+   r,   rK   rC   getr9   )r	   rD   kwargsfields_argsfrM   r\   s          r
   sort_byzAggregateRequest.sort_by   s    8 fsM233 	XF 	# 	#A!]++ #55s"S--../

;jj""77E3s88$$C""3'''r   c                 x    t          |t                    r|g}|D ]}| j                            d|g           | S )z
        Specify filter for post-query results using predicates relating to
        values in the result set.

        ### Parameters

        - **fields**: Fields to group by. This can either be a single string,
            or a list of strings.
        FILTER)rJ   r   r9   rC   )r	   expressions
expressions      r
   filterzAggregateRequest.filter	  sP     k3'' 	(&-K% 	? 	?J&&*'=>>>>r   c                     d| _         | S )z|
        If set, the `schema` property will contain a list of `[field, type]`
        entries in the result object.
        T)r=   r   s    r
   with_schemazAggregateRequest.with_schema  s    
 !r   c                     d| _         | S )NT)r>   r   s    r
   verbatimzAggregateRequest.verbatim#  s    r   r           c                 x    dg}|r|dt          |          gz  }|r|dt          |dz            gz  }|| _        | S )N
WITHCURSORCOUNTMAXIDLEi  )r   r?   )r	   r   max_idler   s       r
   cursorzAggregateRequest.cursor'  sU    ~ 	*Wc%jj))D 	6YHtO 4 455Dr   c                 Z   | j         g}| j        r|                    d           | j        r|                    d           | j        r
|| j        z  }| j        r+|                    d           |                    d           nj| j        rc|                    d           |                    t          t          | j                                       |	                    | j                   | j
        r|	                    d| j
        g           |	                    | j                   |S )N
WITHSCHEMAVERBATIMLOADr6   DIALECT)r8   r=   appendr>   r?   r;   r:   r   rK   rC   r@   r9   )r	   rM   s     r
   r   zAggregateRequest.build_args0  s   {m 	%JJ|$$$> 	#JJz"""< 	 4<C= 	)JJvJJsOOOO 	)JJvJJs3t/0011222JJt'(((= 	3JJ	4=1222

4&'''
r   c                     || _         | S )z
        Add a dialect field to the aggregate command.

        - **dialect** - dialect version to execute the query under
        )r@   )r	   dialects     r
   rz   zAggregateRequest.dialectL  s      r   N)r6   )r   rl   )r   r   r   r%   r   rE   rO   rU   rY   rb   rg   ri   rk   rr   r   rz   r   r   r
   r5   r5   U   s            .     2  $, , ,\- - -^  $         8    r   r5   c                       e Zd Zd Zd ZdS )Cursorc                 0    || _         d| _        d| _        d S )Nr   )cidrq   r   r	   r~   s     r
   r   zCursor.__init__W  s    


r   c                     t          | j                  g}| j        r|dt          | j                  gz  }| j        r|dt          | j                  gz  }|S )Nrp   ro   )r   r~   rq   r   r   s     r
   r   zCursor.build_args\  sZ    DH= 	4YDM 2 233D: 	/Wc$*oo..Dr   Nr   r   r   r
   r|   r|   V  s2          
    r   r|   c                       e Zd Zd Zd ZdS )AggregateResultc                 0    || _         || _        || _        d S r   )rowsrr   schema)r	   r   rr   r   s       r
   r   zAggregateResult.__init__f  s    	r   c           	          | j         r| j         j        nd}d| j        j         dt	          |           ddt          | j                   d| d	S )N<z at 0xxz Rows=z	, Cursor=>)rr   r~   	__class__r   idrK   r   r   s     r
   __repr__zAggregateResult.__repr__k  sm    !%4dkoo"4' 4 4r$xx< 4 4	NN4 4-04 4 4	
r   N)r   r   r   r   r   r   r   r
   r   r   e  s2          

 
 
 
 
r   r   N)
objectr!   r   r   r)   r.   r2   r5   r|   r   r   r   r
   <module>r      sh  FHH		 	 	 	 	 	 	 	' ' ' ' ' ' ' 'T           -       =   ~ ~ ~ ~ ~ ~ ~ ~B       
 
 
 
 
 
 
 
 
 
r   