
    h>1                     *   d 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m	Z	 ddl
mZ ddlmZ ddlmZ  edd	      Z G d
 de      Z G d dee      Zd Z G d dej,                        Z G d d      Z G d d      ZddZd Zd Z G d d      Zy)z
Various data structures used in query construction.

Factored out from django.db.models.query to avoid making the main module very
large and/or so that they can be used by other modules without getting into
circular import difficulties.
    N)
namedtupleFieldDoesNotExist
FieldError)
LOOKUP_SEP)tree)RemovedInDjango40WarningPathInfozGfrom_opts to_opts target_fields join_field m2m direct filtered_relationc                   >     e Zd Zed        Zd Z fdZ fdZ xZS )InvalidQueryTypec                     t         t        fS Nr   selfs    _/var/www/html/ranktracker/api/venv/lib/python3.12/site-packages/django/db/models/query_utils.py_subclasseszInvalidQueryType._subclasses   s    !:..    c                 <    t        j                  dt        d       y )Nz\The InvalidQuery exception class is deprecated. Use FieldDoesNotExist or FieldError instead.   )category
stacklevel)warningswarnr	   r   s    r   __warnzInvalidQueryType.__warn   s    7-		
r   c                 r    | j                          t        || j                        xs t        |   |      S r   )_InvalidQueryType__warn
isinstancer   super__instancecheck__)r   instance	__class__s     r   r   z"InvalidQueryType.__instancecheck__&   /    (D$4$45\9RS[9\\r   c                 r    | j                          t        || j                        xs t        |   |      S r   )r   
issubclassr   r   __subclasscheck__)r   subclassr!   s     r   r%   z"InvalidQueryType.__subclasscheck__*   r"   r   )	__name__
__module____qualname__propertyr   r   r   r%   __classcell__r!   s   @r   r   r      s,    / /
]] ]r   r   c                       e Zd Zy)InvalidQueryN)r'   r(   r)    r   r   r.   r.   /   s    r   r.   )	metaclassc              #   h   K   |  | j                         D ]  }t        |      E d {     y 7 wr   )__subclasses__
subclassesclsr&   s     r   r3   r3   3   s4     
I&&( (h'''('s   &202c                   `     e Zd ZdZdZdZeZdZddd fd
Zd	 Z	d
 Z
d Zd ZddZd Z xZS )Qze
    Encapsulate filters as objects that can then be combined logically (using
    `&` and `|`).
    ANDORTNF)
_connector_negatedc                `    t         |   g |t        |j                               ||       y )N)children	connectornegated)r   __init__sorteditems)r   r:   r;   argskwargsr!   s        r   r@   z
Q.__init__D   s.    "BD"B6&,,.+A"Bjbjkr   c                    t        |t              st        |      |st        j                  |       S | st        j                  |      S  t        |              }||_        |j                  | |       |j                  ||       |S r   )r   r7   	TypeErrorcopydeepcopytyper>   add)r   otherconnobjs       r   _combinez
Q._combineG   sr    %#E"" ==&&==''d4jldt
r   c                 :    | j                  || j                        S r   )rN   r9   r   rK   s     r   __or__zQ.__or__X   s    }}UDGG,,r   c                 :    | j                  || j                        S r   )rN   r8   rP   s     r   __and__z	Q.__and__[   s    }}UDHH--r   c                 ~     t        |              }|j                  | | j                         |j                          |S r   )rI   rJ   r8   negate)r   rM   s     r   
__invert__zQ.__invert__^   s/    d4jldhh


r   c                 Z    |j                  | ||dd      \  }}|j                  |       |S )NF)allow_joins
split_subqcheck_filterable)_add_qpromote_joins)r   queryrX   reuse	summarizefor_saveclausejoinss           r   resolve_expressionzQ.resolve_expressiond   s<     %[U" % 
 	E"r   c                    | j                   j                  d| j                   j                  }|j                  d      r|j	                  dd      }di }}t        | j                        dk(  r7t        | j                  d   t              s| j                  d   }|d   |d   i}n<t        | j                        }| j                  | j                  k7  rd| j                  i}| j                  rd|d	<   |||fS )
N.zdjango.db.models.query_utilszdjango.db.modelsr/      r   r:   Tr;   )r!   r(   r'   
startswithreplacelenr=   r   r7   tupler>   defaultr?   )r   pathrC   rD   childs        r   deconstructzQ.deconstructn   s    ..33T^^5L5LM??9:<< >@RSD2ft}}":dmmA6F+JMM!$EAha)F'D~~-&7<<!%F:T6!!r   )NTNFF)r'   r(   r)   __doc__r8   r9   rk   conditionalr@   rN   rQ   rS   rV   rc   rn   r+   r,   s   @r   r7   r7   9   sG    
 C	BGK)- l"-."r   r7   c                   $    e Zd ZdZd ZddZd Zy)DeferredAttributez
    A wrapper for a deferred-loading field. When the value is read from this
    object the first time, the query is executed.
    c                     || _         y r   )field)r   rt   s     r   r@   zDeferredAttribute.__init__   s	    
r   Nc                     || S |j                   }| j                  j                  }||vr7| j                  |      }||j	                  |g       t        ||      }|||<   ||   S )zx
        Retrieve and caches the value from the datastore on the first lookup.
        Return the cached value.
        )fields)__dict__rt   attname_check_parent_chainrefresh_from_dbgetattr)r   r    r5   data
field_namevals         r   __get__zDeferredAttribute.__get__   s|    
 K  ZZ''
T! **84C{(((=h
3"DJr   c                     |j                   }|j                  | j                  j                        }| j                  j                  r%| j                  |k7  rt        ||j                        S y)z
        Check if the field value can be fetched from a parent field already
        loaded in the instance. This can be done if the to-be fetched
        field is a primary key field.
        N)_metaget_ancestor_linkrt   modelprimary_keyr{   rx   )r   r    opts
link_fields       r   ry   z%DeferredAttribute._check_parent_chain   sU     ~~++DJJ,<,<=
::!!djjJ&>8Z%7%788r   r   )r'   r(   r)   ro   r@   r   ry   r/   r   r   rr   rr      s     &
r   rr   c                       e Zd Zed        Ze ej                  d      d               Zd Zd Z	e
d        Zed        Zedd	       Zedd
       Zy)RegisterLookupMixinc                 B    | j                         j                  |d       S r   )get_lookupsget)r5   lookup_names     r   _get_lookupzRegisterLookupMixin._get_lookup   s     $$[$77r   N)maxsizec                     t        j                  |       D cg c]  }|j                  j                  di         }}| j	                  |      S c c}w Nclass_lookups)inspectgetmrorw   r   merge_dicts)r5   parentr   s      r   r   zRegisterLookupMixin.get_lookups   sK     QXP^P^_bPcdf,,_bAdd}-- es   #Ac                     ddl m} | j                  |      }|'t        | d      r| j                  j                  |      S |t        ||      sy |S )Nr   )Lookupoutput_field)django.db.models.lookupsr   r   hasattrr   
get_lookupr$   )r   r   r   founds       r   r   zRegisterLookupMixin.get_lookup   sQ    3  -=WT>:$$//<<Zv%>r   c                     ddl m} | j                  |      }|'t        | d      r| j                  j                  |      S |t        ||      sy |S )Nr   )	Transformr   )r   r   r   r   r   get_transformr$   )r   r   r   r   s       r   r   z!RegisterLookupMixin.get_transform   sQ    6  -=WT>:$$22;??Zy%Ar   c                 L    i }t        |       D ]  }|j                  |        |S )z
        Merge dicts in reverse to preference the order of the original list. e.g.,
        merge_dicts([a, b]) will preference the keys in 'a' over those in 'b'.
        )reversedupdate)dictsmergedds      r   r   zRegisterLookupMixin.merge_dicts   s-     % 	AMM!	r   c                 X    t        |       D ]  }|j                  j                           y r   )r3   r   cache_clearr4   s     r   _clear_cached_lookupsz)RegisterLookupMixin._clear_cached_lookups   s'    "3 	/H  ,,.	/r   c                     ||j                   }d| j                  vri | _        || j                  |<   | j                          |S r   )r   rw   r   r   r5   lookupr   s      r   register_lookupz#RegisterLookupMixin.register_lookup   sH     ,,K#,,. "C)/+&!!#r   c                 :    ||j                   }| j                  |= y)zn
        Remove given lookup from cls lookups. For use in tests only as it's
        not thread-safe.
        N)r   r   r   s      r   _unregister_lookupz&RegisterLookupMixin._unregister_lookup   s#      ,,Kk*r   r   )r'   r(   r)   classmethodr   	functools	lru_cacher   r   r   staticmethodr   r   r   r   r/   r   r   r   r      s    8 8 Y&. ' .   / /   + +r   r   c                 v   | j                   sy| j                   j                  r|sy|r&|r| j                         |vry|s| j                  |vry|s| j                  ry|rZ| j
                  |vrL|rJ| j                  |v r<d| j                  j                  j                  d| j                  d}t        |      y)au  
    Return True if this field should be used to descend deeper for
    select_related() purposes. Used by both the query construction code
    (sql.query.fill_related_selections()) and the model instance creation code
    (query.get_klass_info()).

    Arguments:
     * field - the field to be checked
     * restricted - a boolean field, indicating if the field list has been
       manually restricted using a requested clause)
     * requested - The select_related() dictionary.
     * load_fields - the set of fields to be loaded on this model
     * reverse - boolean, True if we are checking a reverse select related
    FzField re   zM cannot be both deferred and traversed using select_related at the same time.T)
remote_fieldparent_linkrelated_query_namenamenullrx   r   r   object_namer   )rt   
restricted	requestedload_fieldsreversemsgs         r   select_related_descendr      s     %%gu//1B5::Y6%**==+ejjI5 [[&&22EJJ@ !o%r   c                     t        dt        |       dz         D ]0  }t        j                  | d|       }||v s ||   s&||   | |d fc S  y)z
    Check if the lookup_parts contains references to the given annotations set.
    Because the LOOKUP_SEP is contained in the default annotation names, check
    each prefix of the lookup_parts for a match.
    rf   r   N)Fr/   )rangeri   r   join)lookup_partsannotationsnlevel_n_lookups       r   refs_expressionr     sf     1c,'!+, A#a):;[([-H~.QR0@@@A r   c                 x      fd} ||      xs+ t        |dd      xr  ||j                  j                        S )z
    Check that self.model is compatible with target_opts. Compatibility
    is OK if:
      1) model and opts match (where proxy inheritance is removed)
      2) model is parent of opts' model or the other way around
    c                     j                   j                  | j                  k(  xs: | j                  j                   j                         v xs | j                         v S r   )r   concrete_modelget_parent_list)r   r   s    r   checkz-check_rel_lookup_compatibility.<locals>.check#  sV    KK&&$*=*== ,5;;#>#>#@@,T))++	
r   r   F)r{   r   r   )r   target_optsrt   r   s   `   r   check_rel_lookup_compatibilityr     s=    
  	k 	L	u	-	J%8I8I2Jr   c                   >    e Zd ZdZ e       ddZd Zd Zd Zd Z	y)	FilteredRelationz7Specify custom filtering in the ON clause of SQL joins.	conditionc                    |st        d      || _        d | _        t        |t              st        d      || _        g | _        y )Nzrelation_name cannot be empty.z*condition argument must be a Q() instance.)
ValueErrorrelation_namealiasr   r7   r   rl   )r   r   r   s      r   r@   zFilteredRelation.__init__;  sD    =>>*
)Q'IJJ"	r   c                     t        || j                        st        S | j                  |j                  k(  xr4 | j                  |j                  k(  xr | j
                  |j
                  k(  S r   )r   r!   NotImplementedr   r   r   rP   s     r   __eq__zFilteredRelation.__eq__E  sY    %0!!%"5"55 .JJ%++%.NNeoo-	
r   c                     t        | j                  | j                        }| j                  |_        | j                  d d  |_        |S )Nr   )r   r   r   r   rl   )r   clones     r   r   zFilteredRelation.cloneN  s7     !3!3t~~NjjYYq\
r   c                     t        d      )zz
        QuerySet.annotate() only accepts expression-like arguments
        (with a resolve_expression() method).
        z0FilteredRelation.resolve_expression() is unused.)NotImplementedError)r   rC   rD   s      r   rc   z#FilteredRelation.resolve_expressionT  s    
 ""TUUr   c                     |j                   }|j                  | j                  t        | j                              }|j                  |      S )N)r^   )r]   build_filtered_relation_qr   setrl   compile)r   compiler
connectionr]   wheres        r   as_sqlzFilteredRelation.as_sql[  s=    //c$))n/U&&r   N)
r'   r(   r)   ro   r7   r@   r   r   rc   r   r/   r   r   r   r   8  s$    A343 
V'r   r   )F)ro   rG   r   r   r   collectionsr   django.core.exceptionsr   r   django.db.models.constantsr   django.utilsr   django.utils.deprecationr	   r
   rI   r   	Exceptionr.   r3   Noder7   rr   r   r   r   r   r   r/   r   r   <module>r      s        " @ 1  =
 j"kl]t ],	9(8 	(C"		 C"L% %P@+ @+F"J
8'' ''r   