o Ei! @s^ddlmZmZmZddlmZddlmZddlmZddl m Z e ees,e eddZ dd Z d d Ze ee eeeeeeeeiZiZGd d d eZGdddeZddddZ d"ddZddZe e eeeeeiZiZddZddeDddeDZ ddZ!eeefZ"  d#d d!Z#e#j$e j$ej$ej$ej$ej$ej$fZ%[[[ [[[[dS)$)MutableMappingMutableSequence MutableSet)Enum)MappingProxyType)array frozendictcCs0ddlm}t||jot|t ot|d S)Nrabcisalpha) collectionsr isinstanceIterable memoryviewhasattror rL/home/ubuntu/veenaModal/venv/lib/python3.10/site-packages/frozendict/cool.pyisIterableNotStrings    rcCs6ddlm}t||jstdt||jrtjStS)Nrr zobject must be an iterable) r r rr TypeErrorMappingdictitems enumeraterrrrgetItemss   rcCs|SNr)xrrrnil&src@ eZdZdS) FreezeErrorN__name__ __module__ __qualname__rrrrr!5r!c@r ) FreezeWarningNr"rrrrr'9r&r'F)inversecCstt|tstd|dz|jWnty$td|dw|r+t}nt}||vr@ddl}||j dt |rEt }nt }|||<dS)a Adds a `converter` for a type `to_convert`. `converter` must be callable. The new converter will be used by `deepfreeze()` and has precedence over any previous converter. If `to_covert` has already a converter, a FreezeWarning is raised. If `inverse` is True, the conversion is considered from an immutable type to a mutable one. This make it possible to convert mutable objects nested in the registered immutable one. z'`to_convert` parameter must be a type, z foundz*`converter` parameter must be a callable, foundrNz! is already in the conversion map) issubclasstype ValueError__call__AttributeErrorgetFreezeConversionInverseMapgetFreezeConversionMapwarningswarnr#r'%_freeze_conversion_inverse_map_custom_freeze_conversion_map_custom) to_convert converterr(freeze_conversion_mapr1rrrregister=s4      r8cCs:|rt}nt}z||=WdStyt|jdw)z Unregister a type from custom conversion. If `inverse` is `True`, the unregistered conversion is an inverse conversion (see `register()`). z is not registeredN)r3r4KeyErrorr!r#)r+r(r7rrr unregisterls  r:cCttBSr)_freeze_conversion_mapr4rrrrr0~sr0cCr;r)_freeze_conversion_inverse_mapr3rrrrr/sr/cCg|]}|qSrr.0rrrr rAcCr>rrr?rrrrArBcCs$ttddtDddtDS)NcSr>rrr?rrrrArBz"getFreezeTypes..cSr>rrr?rrrrArB)tuple _freeze_typesr4r3rrrrgetFreezeTypess  rENc Csxddlm}|dur |}|dur|}|D]*\}}tt|ts,t|ddz|jWqtyBtd|ddw|D]*\}}tt|ts[t|d d z|jWqGtyqtd|d d wt|}t|t }d}|D] } t || r| }nq|durz|j Wn tyYnw||j Szt |W|St yYnwd dd|D} d|dd| } t | t} | |B} |tvr| ||St|s| ||St} | |B} || v}|r| ||}ddlm}||}t||D]\}}t|||d||<qz | |}W||Sty;|r5|}nY||Sw)a  Converts the object and all the objects nested in it in its immutable counterparts. The conversion map is in getFreezeConversionMap(). You can register a new conversion using `register()` You can also pass a map of custom converters with `custom_converters` and a map of custom inverse converters with `custom_inverse_converters`, without using `register()`. By default, if the type is not registered and has a `__dict__` attribute, it's converted to the `frozendict` of that `__dict__`. This function assumes that hashable == immutable (that is not always true). This function uses recursion, with all the limits of recursions in Python. Where is a good old tail call when you need it? rrNz+ in `custom_converters` parameter is not a r+zconverter for z in `custom_converters` zparameter is not a callablez* in `custom_inverse_converters` parameter z is not a typez in z6`custom_inverse_converters`parameter is not a callablez, css|]}|jVqdSr)r#r?rrr szdeepfreeze..ztype z& is not hashable or is not equal or a z!subclass of the supported types: )copy)custom_converterscustom_inverse_converters)r rr*r+r,r-r.rCkeysrEr__dict__hashrjoinr0_freeze_types_plainrr/rGr deepfreezer9)rrHrIr type_ir6type_o freeze_types base_type_o freeze_typesupported_typeserrr7freeze_conversion_inverse_map frozen_typerGo_copykvfreezerrrrOs                   rO)F)NN)&collections.abcrrrenumrtypesrrr r*r8rrr bytearraybytesrC frozensetr<r4 Exceptionr! UserWarningr'r:r0rlistr=r3r/rDrErNrOr#__all__rrrrsn         /