o gnN@sUdZddlmZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZddlm Z ej!sesddl"m#Z#ddl"m$Z$ddl"m%Z%dd l"m&Z&dd!l"m'Z'dd"l"m(Z(n$ddl)m%Z%dd l)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/Z0d*e1d+<e/dgZ2d*e1d,<dwd1d2Z3dxd6d7Z4e#Z5d8e1d9<Gd:d;d;e&e,e-fZ6edd?d?e e+Z9Gd@dAdAe9e+Z:GdBdCdCe%e9e+Z;dydDdEZe>> 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,overlapresultcurrentotherelementr9X/var/www/html/flaskapp/venv/lib/python3.10/site-packages/sqlalchemy/util/_collections.pymerge_lists_w_orderingLs#    r;dMapping[_KT, _VT]immutabledict[_KT, _VT]cCs|stSt|tr |St|SN) EMPTY_DICT isinstancerr<r9r9r:coerce_to_immutabledicts  rCzimmutabledict[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__)clsrEnewr9r9r:rGs zFacadeDict.__new__rcCstd)Nz\an immutabledict shouldn't need to be copied. use dict(d) if you need a mutable dictionary.)NotImplementedErrorselfr9r9r:copyszFacadeDict.copycCstt|ffSr?)rDdictrKr9r9r: __reduce__zFacadeDict.__reduce__keyr$valuer%NonecCst|||dS)z,insert an item into the dictionary directly.N)rN __setitem__rLrQrRr9r9r: _insert_itemzFacadeDict._insert_itemstrcCsdt|S)NzFacadeDict(%s))rN__repr__rKr9r9r:rYrPzFacadeDict.__repr__N)rErr-rF)r-rr-rrQr$rRr%r-rS)r-rX) __name__ __module__ __qualname____doc__rGrMrOrVrYr9r9r9r:rDs    rD_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]rddatacCst|d|dSNrdobject __setattr__)rLrfr9r9r:__init__zProperties.__init__r-intcC t|jSr?lenrdrKr9r9r:__len__ zProperties.__len__ Iterator[_T]cCstt|jSr?)r0listrdvaluesrKr9r9r:__iter__rlzProperties.__iter__ List[str]csttdd|jDS)NcSsg|]}t|qSr9)rX.0kr9r9r: sz&Properties.__dir__..)dirsuperrdkeysrK __class__r9r:__dir__szProperties.__dir__r7Properties[_F]List[Union[_T, _F]]cCst|t|Sr?)rt)rLr7r9r9r:__add__zProperties.__add__rQrXobjr"rScC||j|<dSr?rcrLrQrr9r9r:rTrPzProperties.__setitem__cCs |j|Sr?rcrLrQr9r9r: __getitem__rrzProperties.__getitem__cC |j|=dSr?rcrr9r9r: __delitem__ zProperties.__delitem__cCrr?rcrr9r9r:rjrPzProperties.__setattr__Dict[str, Any]cCs d|jiSrgrcrKr9r9r: __getstate__rrzProperties.__getstate__statecCst|d|ddSrgrh)rLrr9r9r: __setstate__szProperties.__setstate__cCs$z|j|WStyt|wr?)rdKeyErrorAttributeErrorrr9r9r: __getattr__s   zProperties.__getattr__boolcC ||jvSr?rcrr9r9r: __contains__rrzProperties.__contains__ReadOnlyProperties[_T]cCrn)z8Return an immutable proxy for this :class:`.Properties`.)ReadOnlyPropertiesrdrKr9r9r: as_readonlys zProperties.as_readonlyrRcCs|j|dSr?)rdupdate)rLrRr9r9r:rrzProperties.update Optional[_T]cCdSr?r9rr9r9r:getzProperties.getdefaultUnion[_DT, _T]cCrr?r9rLrQrr9r9r:rrNOptional[Union[_DT, _T]]Optional[Union[_T, _DT]]cCs||vr||S|Sr?r9rr9r9r:rscCrnr?)rtrdrKr9r9r:r~rrzProperties.keysList[_T]cCt|jSr?)rtrdrurKr9r9r:rurPzProperties.valuesList[Tuple[str, _T]]cCrr?)rtrditemsrKr9r9r:rrPzProperties.itemscCrr?rcrr9r9r:has_keyrrzProperties.has_keycCs|jdSr?)rdclearrKr9r9r:rrPzProperties.clear)rfrer-rmr-rs)r-rw)r7rr-r)rQrXrr"r-rS)rQrXr-r")rQrXr-rS)r-r)rrr-rS)rQrXr-r)r-r)rRrer-rS)rQrXr-r)rQrXrrr-rr?)rQrXrrr-r)r-r)r-rr-rS)r\r]r^r_ __slots____annotations__rkrqrvrrrTrrrjrrrrrrrrr~rurrr __classcell__r9r9rr:rbs<                     rbc@seZdZdZdZddZdS)OrderedPropertieszUProvide a __getattr__/__setattr__ interface with an OrderedDict as backing store.r9cCst|tdSr?)rbrk OrderedDictrKr9r9r:rk rlzOrderedProperties.__init__N)r\r]r^r_rrkr9r9r9r:rs rc@seZdZdZdZdS)rzDProvide immutable dict/object attribute to an underlying dictionary.r9N)r\r]r^r_rr9r9r9r:rsrcs0fddt|dD}|dS)zSort an OrderedDict in-place.csg|]}||fqSr9r9rxrBr9r:r{sz,_ordered_dictionary_sort..)rQN)sortedrr)r<rQrr9rBr:_ordered_dictionary_sortsrc@s8eZdZddddZddZdd Zd d Zd d ZdS) WeakSequencer9_WeakSequence__elements Sequence[_T]cs0t|fdd|_fdd|D|_dS)NcSs"|}|dur|j|dSdSr?)_storageremove)itemselfrefrLr9r9r:_remove&sz&WeakSequence.__init__.._removecsg|]}t|qSr9)weakrefref)ryr8rr9r:r{,s z)WeakSequence.__init__..)rrrr)rLrr9rr:rk#s   zWeakSequence.__init__cCs|jt||jdSr?)rr2rrr)rLrr9r9r:r20zWeakSequence.appendcCrnr?)rprrKr9r9r:rq3rrzWeakSequence.__len__cCsdddd|jDDS)Ncss|] }|dur|VqdSr?r9)ryrr9r9r: 7sz(WeakSequence.__iter__..css|]}|VqdSr?r9)ryrr9r9r:r8s)rrKr9r9r:rv6szWeakSequence.__iter__cCs.z |j|}W|Stytd|w)NzIndex %s out of range)rr IndexError)rLindexrr9r9r:r;s   zWeakSequence.__getitem__N)r9)rr)r\r]r^rkr2rqrvrr9r9r9r:r"s    rc@seZdZddddZdS)OrderedIdentitySetNiterableOptional[Iterable[Any]]cCs2t|t|_|r|D] }||q dSdSr?)rrkr_membersadd)rLror9r9r:rkEs  zOrderedIdentitySet.__init__r?)rr)r\r]r^rkr9r9r9r:rDsrc@$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)rLrr9r9r:rkUrrzPopulateDict.__init__rQrr-cCs||||<}|Sr?rrLrQvalr9r9r: __missing__XszPopulateDict.__missing__N)rrrQrr-rr\r]r^r_rkrr9r9r9r:rMs 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)rLrrr9r9r:rkcszWeakPopulateDict.__init__rQrr-cCs|||||<}|Sr?)rrrr9r9r:rhszWeakPopulateDict.__missing__N)rrrrr9r9r9r:r]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 (``==``). )rf_data_appender_unique&Union[Iterable[_T], Set[_T], List[_T]]rfzCallable[[_T], None]rzDict[int, Literal[True]]rNvia Optional[str]cCs\||_i|_|rt|||_dSt|drtd|j|_dSt|dr,td|j|_dSdS)Nr2rrzSet[_T])rfrgetattrrhasattrrr2r)rLrfrr9r9r:rks  zUniqueAppender.__init__rr"r-rScCs.t|}||jvr||d|j|<dSdS)NT)idrr)rLrid_r9r9r:r2s   zUniqueAppender.appendrscCrnr?)r0rfrKr9r9r:rvrrzUniqueAppender.__iter__r?)rfrrr)rr"r-rSr) r\r]r^r_rrrkr2rvr9r9r9r:rvs  rargrcCs2t|dkrt|dtjrt|dStd|S)Nrrr+)rprAtypes GeneratorTypertr)rr9r9r:coerce_generator_args  rxrOptional[List[Any]]cCs0|dur|St|s |gSt|tr|St|Sr?)rrArt)rrr9r9r:to_lists rset_Container[Any]r Iterable[Any]rcstfdd|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. c3s|] }|jr|vVqdSr?)__hash__)ryirr9r:rsz#has_intersection..)any)rrr9rr:has_intersectionsrcC(|durtSt|tstt|S|Sr?)r.rArrr9r9r:to_set   rSet[Any]cCrr?) column_setrArrr9r9r: to_column_setrrcKs*|}|r |||jdi||S)z5Copy the given dict and update with the given values.Nr9)rMr)r<_newkwr9r9r: update_copys  r Iterable[_T]rsccs:|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. rvN)rArXrflatten_iterator)relemr9r9r:rs 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_alertrd_counter_mutexrmrfloatrz.Optional[Callable[[LRUCache[_KT, _VT]], None]]rd?NOptional[Callable[..., None]]cCs,||_||_||_d|_t|_i|_dS)Nr)rrrr threadingLockrrd)rLrrrr9r9r:rks   zLRUCache.__init__cCs|jd7_|jS)Nr)rrKr9r9r: _inc_counterszLRUCache._inc_counterrQr$r- Optional[_VT]cCrr?r9rr9r9r:rrz LRUCache.getrUnion[_VT, _T]cCrr?r9rr9r9r:r rOptional[Union[_VT, _T]]cCs0|j|}|dur||dd<|dS|SNrr)rdrr )rLrQrrr9r9r:rs r%cCs"|j|}||dd<|dSr)rdr )rLrQrr9r9r:rs zLRUCache.__getitem__ Iterator[_KT]cCrnr?)r0rdrKr9r9r:rvrrzLRUCache.__iter__cCrnr?rorKr9r9r:rq rrzLRUCache.__len__ValuesView[_VT]cCstdd|jDS)NcSsi|] \}}||dqS)rr9)ryrzrr9r9r: $sz#LRUCache.values..)typingrrdrrKr9r9r:ru#rzLRUCache.valuesrRrScCs"|||gf|j|<|dSr?)r rd _manage_sizerUr9r9r:rT&s zLRUCache.__setitem__ _LRUCache__vcCrr?rc)rLrr9r9r:r*rzLRUCache.__delitem__cCs|j|j|jSr?)rrrKr9r9r:size_threshold-rWzLRUCache.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)NFrT)rQreverser)racquirerrrprrrrdruoperator itemgetterrrelease)rLr by_counterrr9r9r:r1s.    zLRUCache._manage_size)rrN)rrmrrrr )rQr$r-r )rQr$rrr-rr?)rQr$rrr-r)rQr$r-r%)r-rr)r-rr[)rr$r-rS)r-rr)r\r]r^r_rrrkr rrrrvrqrurTrpropertyrrr9r9r9r:rs4             rc@eZdZdddZdS)_CreateFuncTyper-r&cCrr?r9rKr9r9r:__call__Jz_CreateFuncType.__call__N)r-r&r\r]r^r"r9r9r9r:r!Ir!c@r )_ScopeFuncTyper-rcCrr?r9rKr9r9r:r"Nr#z_ScopeFuncType.__call__NrZr$r9r9r9r:r&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()rLr)r*r9r9r:rkfs  zScopedRegistry.__init__r-r"cCs:|}z|j|WSty|j||YSwr?)r*r+r setdefaultr)rr9r9r:r"ws   zScopedRegistry.__call__rcCs||jvS)z9Return True if an object is present in the current scope.)r*r+rKr9r9r:has~szScopedRegistry.hasrrScCs||j|<dS)z$Set the value for the current scope.N)r+r*rLrr9r9r:r.szScopedRegistry.setcCs(z |j|=WdStyYdSw)z Clear the current scope, if any.N)r+r*rrKr9r9r:rs  zScopedRegistry.clearN)r)r,r*r-r-r"r-rrr"r-rSr) r\r]r^r_rrrkr"r/r.rr9r9r9r:r'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)r localr+)rLr)r9r9r:rkszThreadLocalRegistry.__init__r-r"cCs2z|jjWSty|}|j_|YSwr?)r+rRrr))rLrr9r9r:r"s   zThreadLocalRegistry.__call__rcCs t|jdS)NrR)rr+rKr9r9r:r/rzThreadLocalRegistry.hasrrScCs ||j_dSr?)r+rRr0r9r9r:r.rzThreadLocalRegistry.setcCs"z|j`WdStyYdSwr?)r+rRrrKr9r9r:rs   zThreadLocalRegistry.clearN)r)r,r1r2r3r) r\r]r^r_rkr"r/r.rr9r9r9r:r4s    r4cCs0d}|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. rrTFr9)sequencetargetcrr9r9r: has_dupess r9)r*r+r,r+r-r+)r<r=r-r>r?)rrr-r+)rrrrr-r+)rrrrr-r)rrr-r)rrr-rs)Wr_ __future__rrr rrrrrrrrr r r r r rrrrrrrrrr_has_cyrrrr TYPE_CHECKING_py_collectionsrrrrr r!$sqlalchemy.cyextension.immutabledict"sqlalchemy.cyextension.collectionsr"r$r%r& frozensetr(rr)r;rCr@rDr`rarbrrrrNrsort_dictionaryrrrrr.r column_dictordered_column_setrrrrrrrrMutableMappingrr!r&r'r4r9r9r9r9r:s                                           8   W  "  %    i@