o )f_N@sUdZddlmZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZddlmZej sesddl!m"Z"ddl!m#Z#ddl!m$Z$ddl!m%Z%dd l!m&Z&dd!l!m'Z'n$ddl(m$Z$ddl(m%Z%ddl(m"Z"ddl)m#Z#dd l)m&Z&dd!l)m'Z'ed"ed#Z*ed$ed#Z+ed%ed#Z,ed&d'd(Z-e.Z/d)e0d*<e.dgZ1d)e0d+<dqd0d1Z2drd5d6Z3e"Z4d7e0d8<Gd9d:d:e%e+e,fZ5ed;ed#Z6edd>e e*Z8Gd?d@d@e8e*Z9GdAdBdBe$e8e*Z:dsdCdDZ;eGdEdFdFee*Z?GdGdHdHe#Z@GdIdJdJe e+e,fZAGdKdLdLe e+e,fZBeCZDe>> a = ['__tablename__', 'id', 'x', 'created_at'] >>> b = ['id', 'name', 'data', 'y', 'created_at'] >>> merge_lists_w_ordering(a, b) ['__tablename__', 'id', 'name', 'data', 'y', 'x', 'created_at'] This is not necessarily the ordering that things had on the class, in this case the class is:: class User(Base): __tablename__ = "users" id: Mapped[int] = mapped_column(primary_key=True) name: Mapped[str] data: Mapped[Optional[str]] x = Column(Integer) y: Mapped[int] created_at: Mapped[datetime.datetime] = mapped_column() But things are *mostly* ordered. The algorithm could also be done by creating a partial ordering for all items in both lists and then using topological_sort(), but that is too much overhead. Background on how I came up with this is at: https://gist.github.com/zzzeek/89de958cf0803d148e74861bd682ebae )set intersectioniterdiscardappendextend)r)r+overlapresultcurrentotherelementr8Y/var/www/html/flask-app/venv/lib/python3.12/site-packages/sqlalchemy/util/_collections.pymerge_lists_w_orderingKs#    r:dMapping[_KT, _VT]immutabledict[_KT, _VT]cCs|stSt|tr |St|SN) EMPTY_DICT isinstancerr;r8r8r9coerce_to_immutabledicts  rBzimmutabledict[Any, Any]r?c@sBeZdZdZdddZdd d Zdd d ZdddZdddZdS) FacadeDictz*A dictionary that is not publicly mutable.argsrr,FacadeDict[Any, Any]cGst|}|Sr>)r__new__)clsrDnewr8r8r9rFs zFacadeDict.__new__r cCstd)Nz\an immutabledict shouldn't need to be copied. use dict(d) if you need a mutable dictionary.)NotImplementedErrorselfr8r8r9copyszFacadeDict.copycCstt|ffSr>)rCdictrJr8r8r9 __reduce__zFacadeDict.__reduce__keyr#valuer$NonecCst|||dS)z,insert an item into the dictionary directly.N)rM __setitem__rKrPrQr8r8r9 _insert_itemzFacadeDict._insert_itemstrcCsdt|S)NzFacadeDict(%s))rM__repr__rJr8r8r9rXrOzFacadeDict.__repr__N)rDrr,rE)r,r r,rrPr#rQr$r,rR)r,rW) __name__ __module__ __qualname____doc__rFrLrNrUrXr8r8r8r9rCs    rC_DT_FcseZdZUdZdZded<dKddZdLd d ZdMd dZdNfdd Z dOddZ dPddZ dQddZ dRd d!Z dPd"d#ZdSd%d&ZdTd(d)ZdQd*d+ZdUd-d.ZdVd0d1ZdWd3d4ZedXd6d7ZedYd:d7Z ;dZd[d>d7ZdNd?d@Zd\dBdCZd]dEdFZdUdGdHZd^dIdJZZS)_ Propertiesz8Provide a __getattr__/__setattr__ interface over a dict._data Dict[str, _T]rcdatacCst|d|dSNrcobject __setattr__)rKrer8r8r9__init__zProperties.__init__r,intcC t|jSr>lenrcrJr8r8r9__len__ zProperties.__len__ Iterator[_T]cCstt|jSr>)r/listrcvaluesrJr8r8r9__iter__rkzProperties.__iter__ List[str]csttdd|jDS)NcSsg|]}t|qSr8)rW.0kr8r8r9 sz&Properties.__dir__..)dirsuperrckeysrJ __class__r8r9__dir__szProperties.__dir__r6Properties[_F]List[Union[_T, _F]]cCst|t|Sr>)rs)rKr6r8r8r9__add__zProperties.__add__rPrWobjr!rRcC||j|<dSr>rbrKrPrr8r8r9rSrOzProperties.__setitem__cCs |j|Sr>rbrKrPr8r8r9 __getitem__rqzProperties.__getitem__cC |j|=dSr>rbrr8r8r9 __delitem__ zProperties.__delitem__cCrr>rbrr8r8r9rirOzProperties.__setattr__Dict[str, Any]cCs d|jiSrfrbrJr8r8r9 __getstate__rqzProperties.__getstate__statecCst|d|ddSrfrg)rKrr8r8r9 __setstate__szProperties.__setstate__cCs$z|j|WStyt|wr>)rcKeyErrorAttributeErrorrr8r8r9 __getattr__s   zProperties.__getattr__boolcC ||jvSr>rbrr8r8r9 __contains__rqzProperties.__contains__ReadOnlyProperties[_T]cCrm)z8Return an immutable proxy for this :class:`.Properties`.)ReadOnlyPropertiesrcrJr8r8r9 as_readonlys zProperties.as_readonlyrQcCs|j|dSr>)rcupdate)rKrQr8r8r9rrzProperties.update Optional[_T]cCdSr>r8rr8r8r9getzProperties.getdefaultUnion[_DT, _T]cCrr>r8rKrPrr8r8r9rrNOptional[Union[_DT, _T]]Optional[Union[_T, _DT]]cCs||vr||S|Sr>r8rr8r8r9rscCrmr>)rsrcrJr8r8r9r}rqzProperties.keysList[_T]cCt|jSr>)rsrcrtrJr8r8r9rtrOzProperties.valuesList[Tuple[str, _T]]cCrr>)rsrcitemsrJr8r8r9rrOzProperties.itemscCrr>rbrr8r8r9has_keyrqzProperties.has_keycCs|jdSr>)rcclearrJr8r8r9rrOzProperties.clear)rerdr,rlr,rr)r,rv)r6rr,r)rPrWrr!r,rR)rPrWr,r!)rPrWr,rR)r,r)rrr,rR)rPrWr,r)r,r)rQrdr,rR)rPrWr,r)rPrWrrr,rr>)rPrWrrr,r)r,r)r,rr,rR)r[r\r]r^ __slots____annotations__rjrprurrrSrrrirrrrrrrrr}rtrrr __classcell__r8r8r~r9ras<                     rac@seZdZdZdZddZdS)OrderedPropertieszUProvide a __getattr__/__setattr__ interface with an OrderedDict as backing store.r8cCst|tdSr>)rarj OrderedDictrJr8r8r9rj rkzOrderedProperties.__init__N)r[r\r]r^rrjr8r8r8r9rs rc@seZdZdZdZdS)rzDProvide immutable dict/object attribute to an underlying dictionary.r8N)r[r\r]r^rr8r8r8r9r srcs0fddt|dD}|dS)zSort an OrderedDict in-place.csg|]}||fqSr8r8rwrAr8r9rzsz,_ordered_dictionary_sort..)rPN)sortedrr)r;rPrr8rAr9_ordered_dictionary_sortsrc@s8eZdZddddZddZdd Zd d Zd d ZdS) WeakSequencer8_WeakSequence__elements Sequence[_T]cs0t|fdd|_fdd|D|_dS)NcSs"|}|dur|j|dSdSr>)_storageremove)itemselfrefrKr8r8r9_remove%sz&WeakSequence.__init__.._removecsg|]}t|qSr8)weakrefref)rxr7rr8r9rz+s z)WeakSequence.__init__..)rrrr)rKrr8rr9rj"s   zWeakSequence.__init__cCs|jt||jdSr>)rr1rrr)rKrr8r8r9r1/zWeakSequence.appendcCrmr>)rorrJr8r8r9rp2rqzWeakSequence.__len__cCsdddd|jDDS)Ncss|] }|dur|VqdSr>r8)rxrr8r8r9 6sz(WeakSequence.__iter__..css|]}|VqdSr>r8)rxrr8r8r9r7s)rrJr8r8r9ru5szWeakSequence.__iter__cCs.z |j|}W|Stytd|w)NzIndex %s out of range)rr IndexError)rKindexrr8r8r9r:s   zWeakSequence.__getitem__N)r8)rr)r[r\r]rjr1rprurr8r8r8r9r!s    rc@seZdZddddZdS)OrderedIdentitySetNiterableOptional[Iterable[Any]]cCs2t|t|_|r|D] }||q dSdSr>)rrjr_membersadd)rKror8r8r9rjDs  zOrderedIdentitySet.__init__r>)rr)r[r\r]rjr8r8r8r9rCsrc@$eZdZdZd ddZd d d Zd S) PopulateDictzA dict which populates missing values via a creation function. Note the creation function takes a key, unlike collections.defaultdict. creatorCallable[[_KT], _VT]cCs ||_dSr>r)rKrr8r8r9rjTrqzPopulateDict.__init__rPrr,cCs||||<}|Sr>rrKrPvalr8r8r9 __missing__WszPopulateDict.__missing__N)rrrPrr,rr[r\r]r^rjrr8r8r8r9rLs rc@r)WeakPopulateDictzaLike PopulateDict, but assumes a self + a method and does not create a reference cycle. creator_methodtypes.MethodTypecCs|j|_|j}t||_dSr>)__func__r__self__rrweakself)rKrrr8r8r9rjbszWeakPopulateDict.__init__rPrr,cCs|||||<}|Sr>)rrrr8r8r9rgszWeakPopulateDict.__missing__N)rrrrr8r8r8r9r\s rc@sPeZdZUdZdZded<ded<ded< ddd d ZdddZdddZd S)UniqueAppenderzAppends items to a collection ensuring uniqueness. Additional appends() of the same object are ignored. Membership is determined by identity (``is a``) not equality (``==``). )re_data_appender_unique&Union[Iterable[_T], Set[_T], List[_T]]rezCallable[[_T], None]rzDict[int, Literal[True]]rNvia Optional[str]cCs\||_i|_|rt|||_dSt|drtd|j|_dSt|dr,td|j|_dSdS)Nr1rrzSet[_T])rergetattrrhasattrrr1r)rKrerr8r8r9rjs  zUniqueAppender.__init__rr!r,rRcCs.t|}||jvr||d|j|<dSdS)NT)idrr)rKrid_r8r8r9r1s   zUniqueAppender.appendrrcCrmr>)r/rerJr8r8r9rurqzUniqueAppender.__iter__r>)rerrr)rr!r,rRr) r[r\r]r^rrrjr1rur8r8r8r9rus  rargrcCs2t|dkrt|dtjrt|dStd|S)Nrrr*)ror@types GeneratorTypersr)rr8r8r9coerce_generator_args  rxrOptional[List[Any]]cCs0|dur|St|s |gSt|tr|St|Sr>)rr@rs)rrr8r8r9to_lists rcCst|dd|DS)zreturn True if any items of set\_ are present in iterable. Goes through special effort to ensure __hash__ is not called on items in iterable that don't support it. cSsg|]}|jr|qSr8)__hash__)rxir8r8r9rzsz$has_intersection..)rr.)set_rr8r8r9has_intersectionsrcC(|durtSt|tstt|S|Sr>)r-r@rrr8r8r9to_set   rSet[Any]cCrr>) column_setr@rrr8r8r9 to_column_setrrcKs*|}|r |||jdi||S)z5Copy the given dict and update with the given values.Nr8)rLr)r;_newkwr8r8r9 update_copys  r Iterable[_T]rrccs:|D]}t|tst|drt|EdHq|VqdS)zGiven an iterator of which further sub-elements may also be iterators, flatten the sub-elements into a single iterator. ruN)r@rWrflatten_iterator)relemr8r8r9rs rc@seZdZUdZdZded<ded<ded< d2d3d dZddZed4ddZ ed5ddZ d6d7ddZ d8ddZ d9d d!Z d:d"d#Z d;d%d&Z dd.d/Zd?d0d1Zd S)@LRUCachezDictionary with 'squishy' removal of least recently used items. Note that either get() or [] should be used here, but generally its not safe to do an "in" check first as the dictionary can change subsequent to that call. )capacity threshold size_alertrc_counter_mutexrlrfloatrz.Optional[Callable[[LRUCache[_KT, _VT]], None]]rd?NOptional[Callable[..., None]]cCs,||_||_||_d|_t|_i|_dS)Nr)rrrr threadingLockrrc)rKrrrr8r8r9rjs   zLRUCache.__init__cCs|jd7_|jS)Nr)rrJr8r8r9 _inc_counterszLRUCache._inc_counterrPr#r, Optional[_VT]cCrr>r8rr8r8r9rrz LRUCache.getrUnion[_VT, _T]cCrr>r8rr8r8r9r rOptional[Union[_VT, _T]]cCs0|j|}|dur||dd<|dS|SNrr)rcrr)rKrPrrr8r8r9rs r$cCs"|j|}||dd<|dSr )rcr)rKrPrr8r8r9rs zLRUCache.__getitem__ Iterator[_KT]cCrmr>)r/rcrJr8r8r9rurqzLRUCache.__iter__cCrmr>rnrJr8r8r9rp rqzLRUCache.__len__ValuesView[_VT]cCstdd|jDS)NcSsi|] \}}||dqS)rr8)rxryrr8r8r9 $sz#LRUCache.values..)typingrrcrrJr8r8r9rt#rzLRUCache.valuesrQrRcCs"|||gf|j|<|dSr>)rrc _manage_sizerTr8r8r9rS&s zLRUCache.__setitem__ _LRUCache__vcCrr>rb)rKrr8r8r9r*rzLRUCache.__delitem__cCs|j|j|jSr>)rrrJr8r8r9size_threshold-rVzLRUCache.size_thresholdc Cs|jdsdSz`t|j}t||j|j|jkra|r$d}||t|j t ddd}||jdD]}z|j|d=Wq8t yKYq8wt||j|j|jksW|j dSW|j dS|j w)NFr T)rPreverser)racquirerrrorrrrcrtoperator itemgetterrrelease)rKr by_counterrr8r8r9r1s.    zLRUCache._manage_size)rrN)rrlrrrr)rPr#r,r)rPr#rr r,r r>)rPr#rr r,r )rPr#r,r$)r,r r)r,rrZ)rr#r,rR)r,rr)r[r\r]r^rrrjrrrrrurprtrSrpropertyrrr8r8r8r9rs4             rc@eZdZdddZdS)_CreateFuncTyper,r%cCrr>r8rJr8r8r9__call__Jz_CreateFuncType.__call__N)r,r%r[r\r]rr8r8r8r9rIrc@r)_ScopeFuncTyper,rcCrr>r8rJr8r8r9rNrz_ScopeFuncType.__call__NrYrr8r8r8r9r!Mr r!c@s`eZdZUdZdZded<ded<ded<dd d ZdddZdddZdddZ dddZ dS) ScopedRegistryaA Registry that can store one or multiple instances of a single class on the basis of a "scope" function. The object implements ``__call__`` as the "getter", so by calling ``myregistry()`` the contained object is returned for the current scope. :param createfunc: a callable that returns a new object to be placed in the registry :param scopefunc: a callable that will return a key to store/retrieve an object.  createfunc scopefuncregistryz_CreateFuncType[_T]r$r!r%rr&Callable[[], _T]Callable[[], Any]cCs||_||_i|_dS)aVConstruct a new :class:`.ScopedRegistry`. :param createfunc: A creation function that will generate a new value for the current scope, if none is present. :param scopefunc: A function that returns a hashable token representing the current scope (such as, current thread identifier). Nr#)rKr$r%r8r8r9rjfs  zScopedRegistry.__init__r,r!cCs:|}z|j|WSty|j||YSwr>)r%r&r setdefaultr$rr8r8r9rws   zScopedRegistry.__call__rcCs||jvS)z9Return True if an object is present in the current scope.)r%r&rJr8r8r9has~szScopedRegistry.hasrrRcCs||j|<dS)z$Set the value for the current scope.N)r&r%rKrr8r8r9r-szScopedRegistry.setcCs(z |j|=WdStyYdSw)z Clear the current scope, if any.N)r&r%rrJr8r8r9rs  zScopedRegistry.clearN)r$r'r%r(r,r!r,rrr!r,rRr) r[r\r]r^rrrjrr*r-rr8r8r8r9r"Qs     r"c@sBeZdZdZdddZddd Zdd d ZdddZdddZdS)ThreadLocalRegistryz\A :class:`.ScopedRegistry` that uses a ``threading.local()`` variable for storage. r$r'cCs||_t|_dSr>)r$rlocalr&)rKr$r8r8r9rjszThreadLocalRegistry.__init__r,r!cCs2z|jjWSty|}|j_|YSwr>)r&rQrr$)rKrr8r8r9rs   zThreadLocalRegistry.__call__rcCs t|jdS)NrQ)rr&rJr8r8r9r*rzThreadLocalRegistry.hasrrRcCs ||j_dSr>)r&rQr+r8r8r9r-rzThreadLocalRegistry.setcCs"z|j`WdStyYdSwr>)r&rQrrJr8r8r9rs   zThreadLocalRegistry.clearN)r$r'r,r-r.r) r[r\r]r^rjrr*r-rr8r8r8r9r/s    r/cCs0d}|D]}||ur|d7}|dkrdSqdS)zrGiven a sequence and search object, return True if there's more than one, False if zero or one of them. rrTFr8)sequencetargetcrr8r8r9 has_dupess r4)r)r*r+r*r,r*)r;r<r,r=r>)rrr,r*)rrrrr,r*)rrr,r)rrr,rr)Vr^ __future__rrrrrrrrrrrr r r r r rrrrrrrrr_has_cyrrrr TYPE_CHECKING_py_collectionsrrrrrr $sqlalchemy.cyextension.immutabledict"sqlalchemy.cyextension.collectionsr!r#r$r% frozensetr'rr(r:rBr?rCr_r`rarrrrMrsort_dictionaryrrrrr-r column_dictordered_column_setrrrrrrrrMutableMappingrrr!r"r/r4r8r8r8r9s                                          8   W  "  %    i@