U [hN@sTUdZddlmZddlZddlZddlZddlZddlmZddlmZddlm 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;dwdBdCZe>> 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*Zoverlapresultcurrentotherelementr6B./venv/lib/python3.8/site-packages/sqlalchemy/util/_collections.pymerge_lists_w_orderingLs#    r8zMapping[_KT, _VT]zimmutabledict[_KT, _VT])dr+cCs"|stSt|tr|St|SdSN) EMPTY_DICT isinstancerr9r6r6r7coerce_to_immutabledicts  r>zimmutabledict[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__)clsr@newr6r6r7rAs zFacadeDict.__new__rr+cCs tddS)Nz\an immutabledict shouldn't need to be copied. use dict(d) if you need a mutable dictionary.)NotImplementedErrorselfr6r6r7copyszFacadeDict.copycCstt|ffSr:)r?dictrFr6r6r7 __reduce__szFacadeDict.__reduce__r#r$Nonekeyvaluer+cCst|||dS)z,insert an item into the dictionary directly.N)rI __setitem__rGrMrNr6r6r7 _insert_itemszFacadeDict._insert_itemstrcCsdt|S)NzFacadeDict(%s))rI__repr__rFr6r6r7rSszFacadeDict.__repr__N) __name__ __module__ __qualname____doc__rArHrJrQrSr6r6r6r7r?s r?_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__)rGr]r6r6r7__init__szProperties.__init__intrDcCs t|jSr:lenr\rFr6r6r7__len__szProperties.__len__ Iterator[_T]cCstt|jSr:)r.listr\valuesrFr6r6r7__iter__szProperties.__iter__z List[str]csttdd|jDS)NcSsg|] }t|qSr6)rR.0kr6r6r7 sz&Properties.__dir__..)dirsuperr\keysrF __class__r6r7__dir__szProperties.__dir__zProperties[_F]zList[Union[_T, _F]])r4r+cCst|t|Sr:)rh)rGr4r6r6r7__add__szProperties.__add__rRr"rK)rMobjr+cCs||j|<dSr:r[rGrMrvr6r6r7rOszProperties.__setitem__rMr+cCs |j|Sr:r[rGrMr6r6r7 __getitem__szProperties.__getitem__cCs |j|=dSr:r[ryr6r6r7 __delitem__szProperties.__delitem__cCs||j|<dSr:r[rwr6r6r7raszProperties.__setattr__zDict[str, Any]cCs d|jiSr^r[rFr6r6r7 __getstate__szProperties.__getstate__)stater+cCst|d|ddSr^r_)rGr}r6r6r7 __setstate__szProperties.__setstate__cCs.z |j|WStk r(t|YnXdSr:)r\KeyErrorAttributeErrorryr6r6r7 __getattr__s zProperties.__getattr__boolcCs ||jkSr:r[ryr6r6r7 __contains__szProperties.__contains__zReadOnlyProperties[_T]cCs t|jS)z8Return an immutable proxy for this :class:`.Properties`.)ReadOnlyPropertiesr\rFr6r6r7 as_readonlyszProperties.as_readonly)rNr+cCs|j|dSr:)r\update)rGrNr6r6r7rszProperties.updatez Optional[_T]cCsdSr:r6ryr6r6r7getszProperties.getzUnion[_DT, _T]rMdefaultr+cCsdSr:r6rGrMrr6r6r7rsNzOptional[Union[_DT, _T]]zOptional[Union[_T, _DT]]cCs||kr||S|SdSr:r6rr6r6r7rscCs t|jSr:)rhr\rFr6r6r7rqszProperties.keysList[_T]cCst|jSr:)rhr\rirFr6r6r7riszProperties.valueszList[Tuple[str, _T]]cCst|jSr:)rhr\itemsrFr6r6r7rszProperties.itemscCs ||jkSr:r[ryr6r6r7has_keyszProperties.has_keycCs|jdSr:)r\clearrFr6r6r7rszProperties.clear)N)rTrUrVrW __slots____annotations__rbrfrjrtrurOrzr{rar|r~rrrrrrrqrirrr __classcell__r6r6rrr7rZs: rZc@seZdZdZdZddZdS)OrderedPropertieszUProvide a __getattr__/__setattr__ interface with an OrderedDict as backing store.r6cCst|tdSr:)rZrb OrderedDictrFr6r6r7rb szOrderedProperties.__init__N)rTrUrVrWrrbr6r6r6r7rsrc@seZdZdZdZdS)rzDProvide immutable dict/object attribute to an underlying dictionary.r6N)rTrUrVrWrr6r6r6r7rsrcs0fddt|dD}|dS)zSort an OrderedDict in-place.csg|]}||fqSr6r6rkr=r6r7rnsz,_ordered_dictionary_sort..)rMN)sortedrr)r9rMrr6r=r7_ordered_dictionary_sortsrc@s<eZdZdddddZddZdd Zd d Zd d ZdS) WeakSequencer6z Sequence[_T])_WeakSequence__elementscs0t|fdd|_fdd|D|_dS)NcSs|}|dk r|j|dSr:)_storageremove)itemselfrefrGr6r6r7_remove&sz&WeakSequence.__init__.._removecsg|]}t|qSr6)weakrefref)rlr5rr6r7rn,sz)WeakSequence.__init__..)rrrr)rGrr6rr7rb#s  zWeakSequence.__init__cCs|jt||jdSr:)rr0rrr)rGrr6r6r7r00szWeakSequence.appendcCs t|jSr:)rerrFr6r6r7rf3szWeakSequence.__len__cCsdddd|jDDS)Ncss|]}|dk r|VqdSr:r6)rlrvr6r6r7 7sz(WeakSequence.__iter__..css|] }|VqdSr:r6)rlrr6r6r7r8s)rrFr6r6r7rj6szWeakSequence.__iter__cCs:z|j|}Wn tk r.td|YnX|SdS)NzIndex %s out of range)rr IndexError)rGindexrvr6r6r7rz;s zWeakSequence.__getitem__N)r6)rTrUrVrbr0rfrjrzr6r6r6r7r"s  rc@seZdZdddddZdS)OrderedIdentitySetNzOptional[Iterable[Any]])iterablecCs.t|t|_|r*|D]}||qdSr:)rrbrZ_membersadd)rGror6r6r7rbEs  zOrderedIdentitySet.__init__)N)rTrUrVrbr6r6r6r7rDsrc@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)rGrr6r6r7rbUszPopulateDict.__init__rrxcCs||||<}|Sr:rrGrMvalr6r6r7 __missing__XszPopulateDict.__missing__NrTrUrVrWrbrr6r6r6r7rMsrc@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)rGrrr6r6r7rbcszWeakPopulateDict.__init__rrxcCs|||||<}|Sr:)rrrr6r6r7rhszWeakPopulateDict.__missing__Nrr6r6r6r7r]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)Nr0rrzSet[_T])r]rgetattrrhasattrrr0r)rGr]rr6r6r7rbs  zUniqueAppender.__init__r"rK)rr+cCs*t|}||jkr&||d|j|<dS)NT)idrr)rGrZid_r6r6r7r0s  zUniqueAppender.appendrgrDcCs t|jSr:)r.r]rFr6r6r7rjszUniqueAppender.__iter__)N) rTrUrVrWrrrbr0rjr6r6r6r7rvs rr)argr+cCs6t|dkr(t|dtjr(t|dStd|SdS)Nrrr()rer<types GeneratorTyperhr)rr6r6r7coerce_generator_args rzOptional[List[Any]])xrr+cCs4|dkr |St|s|gSt|tr(|St|SdSr:)rr<rh)rrr6r6r7to_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|kVqdSr:)__hash__)rlirr6r7rsz#has_intersection..)any)rrr6rr7has_intersectionsrcCs,|dkrtSt|ts$tt|S|SdSr:)r,r<rrr6r6r7to_sets   rzSet[Any])rr+cCs,|dkrtSt|ts$tt|S|SdSr:) column_setr<rrr6r6r7 to_column_sets   rzDict[Any, Any]zOptional[Dict[Any, Any]])r9_newkwr+cKs&|}|r|||jf||S)z5Copy the given dict and update with the given values.)rHr)r9rrr6r6r7 update_copys   rz Iterable[_T]rgccs8|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. rjN)r<rRrflatten_iterator)relemr6r6r7rsrc@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_mutexrcrfloatrz.Optional[Callable[[LRUCache[_KT, _VT]], None]]rd?Nz$Optional[Callable[(Ellipsis, None)]])rrrcCs,||_||_||_d|_t|_i|_dS)Nr)rrrr threadingLockrr\)rGrrrr6r6r7rbs  zLRUCache.__init__cCs|jd7_|jS)Nr)rrFr6r6r7 _inc_counterszLRUCache._inc_counterr#z Optional[_VT]rxcCsdSr:r6ryr6r6r7r sz LRUCache.getzUnion[_VT, _T]rcCsdSr:r6rr6r6r7r szOptional[Union[_VT, _T]]cCs4|j|}|dk r,||dd<|dS|SdSNrr)r\rr)rGrMrrr6r6r7rs  r$cCs"|j|}||dd<|dSr)r\r)rGrMrr6r6r7rzs zLRUCache.__getitem__z Iterator[_KT]rDcCs t|jSr:)r.r\rFr6r6r7rjszLRUCache.__iter__cCs t|jSr:rdrFr6r6r7rf"szLRUCache.__len__zValuesView[_VT]cCstdd|jDS)NcSsi|]\}}||dqS)rr6)rlrmrr6r6r7 &sz#LRUCache.values..)typingrr\rrFr6r6r7ri%szLRUCache.valuesrKrLcCs"|||gf|j|<|dSr:)rr\ _manage_sizerPr6r6r7rO(szLRUCache.__setitem__) _LRUCache__vr+cCs |j|=dSr:r[)rGrr6r6r7r{,szLRUCache.__delitem__cCs|j|j|jSr:)rrrFr6r6r7size_threshold/szLRUCache.size_thresholdc Cs|jdsdSzt|j}t||j|j|jkr|rHd}||t|j t ddd}||jdD].}z|j |d=Wqpt k rYqpYqpXqpqW5|jXdS)NFrT)rMreverser)racquirereleaserrrerrrr\rioperator itemgetterr)rGrZ by_counterrr6r6r7r3s&   zLRUCache._manage_size)rrN)N)rTrUrVrWrrrbrrrrzrjrfrirOr{propertyrrr6r6r6r7rs2     rc@seZdZddddZdS)_CreateFuncTyper%rDcCsdSr:r6rFr6r6r7__call__Lz_CreateFuncType.__call__NrTrUrVrr6r6r6r7rKsrc@seZdZddddZdS)_ScopeFuncTyperrDcCsdSr:r6rFr6r6r7rPrz_ScopeFuncType.__call__Nrr6r6r6r7rOsrc@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)rGrrr6r6r7rbhs zScopedRegistry.__init__r"rDcCs@|}z |j|WStk r:|j||YSXdSr:)rrr setdefaultrryr6r6r7rys  zScopedRegistry.__call__rcCs||jkS)z9Return True if an object is present in the current scope.)rrrFr6r6r7hasszScopedRegistry.hasrKrvr+cCs||j|<dS)z$Set the value for the current scope.N)rrrGrvr6r6r7r,szScopedRegistry.setcCs*z|j|=Wntk r$YnXdS)z Clear the current scope, if any.N)rrrrFr6r6r7rszScopedRegistry.clearN) rTrUrVrWrrrbrrr,rr6r6r6r7rSs 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)rGrr6r6r7rbszThreadLocalRegistry.__init__r"rDcCs8z |jjWStk r2|}|j_|YSXdSr:)rrNrr)rGrr6r6r7rs  zThreadLocalRegistry.__call__rcCs t|jdS)NrN)rrrFr6r6r7rszThreadLocalRegistry.hasrKrcCs ||j_dSr:)rrNrr6r6r7r,szThreadLocalRegistry.setcCs$z |j`Wntk rYnXdSr:)rrNrrFr6r6r7rs zThreadLocalRegistry.clearN) rTrUrVrWrbrrr,rr6r6r6r7rs rcCs0d}|D]"}||kr|d7}|dkrdSqdS)zrGiven a sequence and search object, return True if there's more than one, False if zero or one of them. rrTFr6)Zsequencetargetcrr6r6r7 has_dupess r)N)N)N)WrWZ __future__rrrrrrrrrrrr r r r r rrrrrrrrrrZ_has_cyrrrrZ TYPE_CHECKINGZ_py_collectionsrrrrr r!Z$sqlalchemy.cyextension.immutabledictZ"sqlalchemy.cyextension.collectionsr"r#r$r% frozensetr&rr'r8r>r;r?rXrYrZrrrrIrZsort_dictionaryrrrrr,rZ column_dictZordered_column_setrrrrrrrrMutableMappingrrrrrrr6r6r6r7 s                                        8   W  " %      i@