a [gnN@sHUdZddlmZddlZddlZddlZddlZddlmZddlmZddlm Z ddlm Z ddlm Z dd lm Z dd lm Z dd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlZddlmZddlmZddlmZddlm Z ej!shesddl"m#Z#ddl"m$Z$ddl"m%Z%dd l"m&Z&dd!l"m'Z'dd"l"m(Z(nHddl)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,<d-d-d-d.d/d0Z3d1d2d3d4d5Z4e#Z5d6e1d7<Gd8d9d9e&e,e-fZ6ed:ed$Z7ed;ed$Z8Gdd?d?e9e+Z:Gd@dAdAe%e9e+Z;dtdBdCZe>> 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,overlapresultcurrentotherelementr9j/var/www/html/cobodadashboardai.evdpl.com/venv/lib/python3.9/site-packages/sqlalchemy/util/_collections.pymerge_lists_w_orderingLs#    r;zMapping[_KT, _VT]zimmutabledict[_KT, _VT])dr-cCs"|stSt|tr|St|SdSN) EMPTY_DICT isinstancerr<r9r9r:coerce_to_immutabledicts  rAzimmutabledict[Any, Any]r>c@s\eZdZdZdddddZddd d Zddd d Zd dddddZddddZdS) FacadeDictz*A dictionary that is not publicly mutable.rzFacadeDict[Any, Any])argsr-cGst|}|Sr=)r__new__)clsrCnewr9r9r:rDs zFacadeDict.__new__rr-cCs tddS)Nz\an immutabledict shouldn't need to be copied. use dict(d) if you need a mutable dictionary.)NotImplementedErrorselfr9r9r:copyszFacadeDict.copycCstt|ffSr=)rBdictrIr9r9r: __reduce__szFacadeDict.__reduce__r$r%Nonekeyvaluer-cCst|||dS)z,insert an item into the dictionary directly.N)rL __setitem__rJrPrQr9r9r: _insert_itemszFacadeDict._insert_itemstrcCsdt|S)NzFacadeDict(%s))rL__repr__rIr9r9r:rVszFacadeDict.__repr__N) __name__ __module__ __qualname____doc__rDrKrMrTrVr9r9r9r:rBs rB_DT_FcseZdZUdZdZded<ddddZdd d d Zd d d dZdd fdd Z dddddZ ddddddZ dddddZ dddd d!Z ddddd"d#Zd$d d%d&Zd$dd'd(d)Zdddd*d+Zdd,dd-d.Zd/d d0d1Zddd2d3d4Zedd5dd6d7Zedd8d8d9d:d7ZdKddd7Zdd d?d@ZdAd dBdCZdDd dEdFZdd,ddGdHZdd dIdJZZS)L Propertiesz8Provide a __getattr__/__setattr__ interface over a dict._dataz Dict[str, _T]r_)datacCst|d|dSNr_object __setattr__)rJr`r9r9r:__init__szProperties.__init__intrGcCs t|jSr=lenr_rIr9r9r:__len__szProperties.__len__ Iterator[_T]cCstt|jSr=)r0listr_valuesrIr9r9r:__iter__szProperties.__iter__z List[str]csttdd|jDS)NcSsg|] }t|qSr9)rU.0kr9r9r: z&Properties.__dir__..)dirsuperr_keysrI __class__r9r:__dir__szProperties.__dir__zProperties[_F]zList[Union[_T, _F]])r7r-cCst|t|Sr=)rk)rJr7r9r9r:__add__szProperties.__add__rUr"rN)rPobjr-cCs||j|<dSr=r^rJrPrzr9r9r:rRszProperties.__setitem__rPr-cCs |j|Sr=r^rJrPr9r9r: __getitem__szProperties.__getitem__cCs |j|=dSr=r^r}r9r9r: __delitem__szProperties.__delitem__cCs||j|<dSr=r^r{r9r9r:rdszProperties.__setattr__zDict[str, Any]cCs d|jiSrar^rIr9r9r: __getstate__szProperties.__getstate__)stater-cCst|d|ddSrarb)rJrr9r9r: __setstate__szProperties.__setstate__cCs,z |j|WSty&t|Yn0dSr=)r_KeyErrorAttributeErrorr}r9r9r: __getattr__s  zProperties.__getattr__boolcCs ||jvSr=r^r}r9r9r: __contains__szProperties.__contains__zReadOnlyProperties[_T]cCs t|jS)z8Return an immutable proxy for this :class:`.Properties`.)ReadOnlyPropertiesr_rIr9r9r: as_readonlyszProperties.as_readonly)rQr-cCs|j|dSr=)r_update)rJrQr9r9r:rszProperties.updatez Optional[_T]cCsdSr=r9r}r9r9r:getszProperties.getzUnion[_DT, _T]rPdefaultr-cCsdSr=r9rJrPrr9r9r:rsNzOptional[Union[_DT, _T]]zOptional[Union[_T, _DT]]cCs||vr||S|SdSr=r9rr9r9r:rscCs t|jSr=)rkr_rIr9r9r:ruszProperties.keysList[_T]cCst|jSr=)rkr_rlrIr9r9r:rlszProperties.valueszList[Tuple[str, _T]]cCst|jSr=)rkr_itemsrIr9r9r:rszProperties.itemscCs ||jvSr=r^r}r9r9r:has_keyszProperties.has_keycCs|jdSr=)r_clearrIr9r9r:rszProperties.clear)N)rWrXrYrZ __slots____annotations__rerirmrxryrRr~rrdrrrrrrrrrurlrrr __classcell__r9r9rvr:r]s: r]c@seZdZdZdZddZdS)OrderedPropertieszUProvide a __getattr__/__setattr__ interface with an OrderedDict as backing store.r9cCst|tdSr=)r]re OrderedDictrIr9r9r:re szOrderedProperties.__init__N)rWrXrYrZrrer9r9r9r:rsrc@seZdZdZdZdS)rzDProvide immutable dict/object attribute to an underlying dictionary.r9N)rWrXrYrZrr9r9r9r:rsrcs0fddt|dD}|dS)zSort an OrderedDict in-place.csg|]}||fqSr9r9rnr@r9r:rqrrz,_ordered_dictionary_sort..)rPN)sortedrr)r<rPrr9r@r:_ordered_dictionary_sortsrc@s<eZdZdddddZddZdd Zd d Zd d ZdS) WeakSequencer9z Sequence[_T])_WeakSequence__elementscs0t|fdd|_fdd|D|_dS)NcSs|}|dur|j|dSr=)_storageremove)itemselfrefrJr9r9r:_remove&sz&WeakSequence.__init__.._removecsg|]}t|qSr9)weakrefref)ror8rr9r:rq,sz)WeakSequence.__init__..)rrrr)rJrr9rr:re#s  zWeakSequence.__init__cCs|jt||jdSr=)rr2rrr)rJrr9r9r:r20szWeakSequence.appendcCs t|jSr=)rhrrIr9r9r:ri3szWeakSequence.__len__cCsdddd|jDDS)Ncss|]}|dur|VqdSr=r9)rorzr9r9r: 7sz(WeakSequence.__iter__..css|] }|VqdSr=r9)rorr9r9r:r8rr)rrIr9r9r:rm6szWeakSequence.__iter__cCs8z|j|}Wnty,td|Yn0|SdS)NzIndex %s out of range)rr IndexError)rJindexrzr9r9r:r~;s  zWeakSequence.__getitem__N)r9)rWrXrYrer2rirmr~r9r9r9r:r"s  rc@seZdZdddddZdS)OrderedIdentitySetNzOptional[Iterable[Any]])iterablecCs.t|t|_|r*|D]}||qdSr=)rrerZ_membersadd)rJror9r9r:reEs  zOrderedIdentitySet.__init__)N)rWrXrYrer9r9r9r:rDsrc@s.eZdZdZddddZddddd Zd S) PopulateDictzA dict which populates missing values via a creation function. Note the creation function takes a key, unlike collections.defaultdict. zCallable[[_KT], _VT]creatorcCs ||_dSr=r)rJrr9r9r:reUszPopulateDict.__init__rr|cCs||||<}|Sr=rrJrPvalr9r9r: __missing__XszPopulateDict.__missing__NrWrXrYrZrerr9r9r9r:rMsrc@s.eZdZdZddddZddddd Zd S) WeakPopulateDictzaLike PopulateDict, but assumes a self + a method and does not create a reference cycle. ztypes.MethodType)creator_methodcCs|j|_|j}t||_dSr=)__func__r__self__rrweakself)rJrrr9r9r:recszWeakPopulateDict.__init__rr|cCs|||||<}|Sr=)rrrr9r9r:rhszWeakPopulateDict.__missing__Nrr9r9r9r:r]src@s^eZdZUdZdZded<ded<ded<ddd d d d ZdddddZddddZd 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 (``==``). )r`_data_appender_uniquez&Union[Iterable[_T], Set[_T], List[_T]]r`zCallable[[_T], None]rzDict[int, Literal[True]]rNz Optional[str])r`viacCsT||_i|_|rt|||_n2t|dr8td|j|_nt|drPtd|j|_dS)Nr2rrzSet[_T])r`rgetattrrhasattrrr2r)rJr`rr9r9r:res  zUniqueAppender.__init__r"rN)rr-cCs*t|}||jvr&||d|j|<dS)NT)idrr)rJrZid_r9r9r:r2s  zUniqueAppender.appendrjrGcCs t|jSr=)r0r`rIr9r9r:rmszUniqueAppender.__iter__)N) rWrXrYrZrrrer2rmr9r9r9r:rvs rr)argr-cCs6t|dkr(t|dtjr(t|dStd|SdS)Nrrr*)rhr?types GeneratorTyperkr)rr9r9r:coerce_generator_args rzOptional[List[Any]])xrr-cCs4|dur |St|s|gSt|tr(|St|SdSr=)rr?rk)rrr9r9r:to_lists rzContainer[Any]z Iterable[Any]r)set_rr-cstfdd|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__)roirr9r:rrrz#has_intersection..)any)rrr9rr:has_intersectionsrcCs,|durtSt|ts$tt|S|SdSr=)r.r?rrr9r9r:to_sets   rzSet[Any])rr-cCs,|durtSt|ts$tt|S|SdSr=) column_setr?rrr9r9r: to_column_sets   rcKs*|}|r|||jfi||S)z5Copy the given dict and update with the given values.)rKr)r<_newkwr9r9r: update_copys  rz Iterable[_T]rjccs8|D].}t|ts,t|dr,t|EdHq|VqdS)zGiven an iterator of which further sub-elements may also be iterators, flatten the sub-elements into a single iterator. rmN)r?rUrflatten_iterator)relemr9r9r:rsrc@seZdZUdZdZded<ded<ded<d3ddd d ddZddZedddddZ eddddddZ d4ddddddZ dddddZ dd d!d"Z dd d#d$Z d%d d&d'Z ddd(d)d*d+Zdd(d,d-d.Zedd d/d0Zd(d d1d2Zd S)5LRUCachezDictionary 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_alertr__counter_mutexrfrfloatrz.Optional[Callable[[LRUCache[_KT, _VT]], None]]rd?NzOptional[Callable[..., None]])rrrcCs,||_||_||_d|_t|_i|_dS)Nr)rrrr threadingLockrr_)rJrrrr9r9r:res  zLRUCache.__init__cCs|jd7_|jS)Nr)rrIr9r9r: _inc_counterszLRUCache._inc_counterr$z Optional[_VT]r|cCsdSr=r9r}r9r9r:rsz LRUCache.getzUnion[_VT, _T]rcCsdSr=r9rr9r9r:r szOptional[Union[_VT, _T]]cCs4|j|}|dur,||dd<|dS|SdSNrr)r_rr)rJrPrrr9r9r:rs  r%cCs"|j|}||dd<|dSr)r_r)rJrPrr9r9r:r~s zLRUCache.__getitem__z Iterator[_KT]rGcCs t|jSr=)r0r_rIr9r9r:rmszLRUCache.__iter__cCs t|jSr=rgrIr9r9r:ri szLRUCache.__len__zValuesView[_VT]cCstdd|jDS)NcSsi|]\}}||dqS)rr9)rorprr9r9r: $rrz#LRUCache.values..)typingrr_rrIr9r9r:rl#szLRUCache.valuesrNrOcCs"|||gf|j|<|dSr=)rr_ _manage_sizerSr9r9r:rR&szLRUCache.__setitem__) _LRUCache__vr-cCs |j|=dSr=r^)rJrr9r9r:r*szLRUCache.__delitem__cCs|j|j|jSr=)rrrIr9r9r:size_threshold-szLRUCache.size_thresholdc Cs|jdsdSzt|j}t||j|j|jkr|rHd}||t|j t ddd}||jdD],}z|j|d=Wqpt yYqpYqp0qpqW|j n |j 0dS)NFrT)rPreverser)racquirerrrhrrrr_rloperator itemgetterrrelease)rJrZ by_counterrr9r9r:r1s&    zLRUCache._manage_size)rrN)N)rWrXrYrZrrrerrrr~rmrirlrRrpropertyrrr9r9r9r:rs2     rc@seZdZddddZdS)_CreateFuncTyper&rGcCsdSr=r9rIr9r9r:__call__Jrrz_CreateFuncType.__call__NrWrXrYrr9r9r9r:rIsrc@seZdZddddZdS)_ScopeFuncTyperrGcCsdSr=r9rIr9r9r:rNrrz_ScopeFuncType.__call__Nrr9r9r9r:rMsrc@sxeZdZUdZdZded<ded<ded<d d d d d ZddddZddddZdddddZ ddddZ 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]rrrrrCallable[[], _T]zCallable[[], Any])rrcCs||_||_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)rJrrr9r9r:refs zScopedRegistry.__init__r"rGcCs>|}z |j|WSty8|j||YS0dSr=)rrr setdefaultrr}r9r9r:rws   zScopedRegistry.__call__rcCs||jvS)z9Return True if an object is present in the current scope.)rrrIr9r9r:has~szScopedRegistry.hasrNrzr-cCs||j|<dS)z$Set the value for the current scope.N)rrrJrzr9r9r:r.szScopedRegistry.setcCs(z|j|=Wnty"Yn0dS)z Clear the current scope, if any.N)rrrrIr9r9r:rs zScopedRegistry.clearN) rWrXrYrZrrrerrr.rr9r9r9r:rQs rc@sXeZdZdZddddZdddd Zd dd d Zdd dddZd dddZdS)ThreadLocalRegistryz\A :class:`.ScopedRegistry` that uses a ``threading.local()`` variable for storage. r)rcCs||_t|_dSr=)rrlocalr)rJrr9r9r:reszThreadLocalRegistry.__init__r"rGcCs6z |jjWSty0|}|j_|YS0dSr=)rrQrr)rJrr9r9r:rs   zThreadLocalRegistry.__call__rcCs t|jdS)NrQ)rrrIr9r9r:rszThreadLocalRegistry.hasrNrcCs ||j_dSr=)rrQrr9r9r:r.szThreadLocalRegistry.setcCs"z |j`WntyYn0dSr=)rrQrrIr9r9r:rs  zThreadLocalRegistry.clearN) rWrXrYrZrerrr.rr9r9r9r:rs rcCs0d}|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 r)N)N)N)WrZ __future__rrrrrrrrrrrr r r r r rrrrrrrrrrZ_has_cyrrrr TYPE_CHECKINGZ_py_collectionsrrrrr r!Z$sqlalchemy.cyextension.immutabledictZ"sqlalchemy.cyextension.collectionsr"r$r%r& frozensetr(rr)r;rAr>rBr[r\r]rrrrLrZsort_dictionaryrrrrr.rZ column_dictZordered_column_setrrrrrrrrMutableMappingrrrrrrr9r9r9r: s                                        8   W  " %     i@