%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/python3/dist-packages/reportlab/lib/__pycache__/
Upload File :
Create Path :
Current File : //lib/python3/dist-packages/reportlab/lib/__pycache__/rl_safe_eval.cpython-312.pyc

�

��d�����ddlZddlZddlZddlZddlZddlZddlZddlZddlZe	ejjdd��Ze
efZej dddk\Zeed�ZddlZGd�de�Zej.d	ej0d
ej2dej4dej6d
ej8dej:dej<dej>dej@dejBdejDdejFdi
Z$e%gd��Z&e%djO��Z(ejRddjUe(�zejV�Z,d�Z-Gd�dej\�Z/d�Z0Gd�d�Z1iZ2d(d �Z3ejhZ5e6�Z7Gd!�d"�Z8Gd#�d$�Z9Gd%�d&e9�Z:d)d'�Z;e:�Z<e9�Z=y)*�N�
EVAL_DEBUG�0�)��	�NameConstantc��eZdZy)�BadCodeN)�__name__�
__module__�__qualname__���</usr/lib/python3/dist-packages/reportlab/lib/rl_safe_eval.pyr
r
s��rr
�+=�-=�*=�/=�%=�**=�<<=�>>=�|=�^=�&=�//=z@=)�__init__�__contains__�__lt__�__le__�__eq__�__ne__�__gt__�__ge__aTbuiltins breakpoint __annotations__ co_argcount co_cellvars co_code co_consts
						__code__ co_filename co_firstlineno co_flags co_freevars co_kwonlyargcount
						co_lnotab co_name co_names co_nlocals co_posonlyargcount co_stacksize
						co_varnames cr_await cr_code cr_frame cr_origin cr_running __defaults__
						f_back f_builtins f_code f_exc_traceback f_exc_type f_exc_value f_globals
						f_lasti f_lineno f_locals f_restricted f_trace __func__ func_code func_defaults
						func_doc func_globals func_name gi_code gi_frame gi_running gi_yieldfrom
						__globals__ im_class im_func im_self __iter__ __kwdefaults__ __module__
						__name__ next __qualname__ __self__ tb_frame tb_lasti tb_lineno tb_next
						globals vars locals
						type eval exec aiter anext compile open
						dir print classmethod staticmethod __import__ super propertyz\b(?:%s)�|c�Z�tj||�tj|�y�N)�ast�
copy_location�fix_missing_locations)�new_node�old_nodes  r�copy_locationsr-?s �����8�X�&����8�$rc�f��eZdZd%�fd�	Zed��Zd�Zd�Zd�Zd�Z	d�Z
d&d�Zd	�Zd
�Z
d�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"e!Z#eZ$eZ%d �Z&d!�Z'�fd"�Z(e)d#k\rd$�Z*e'Z+e'Z,e'Z-e'Z.e'Z/e'Z0e'Z1e'Z2e'Z3e(Z4e(Z5e(Z6e(Z7e(Z8e(Z9e(Z:e(Z;e(Z<e(Z=e(Z>e(Z?e(Z@e(ZAe(ZBe(ZCe(ZDe(ZEe(ZFe(ZGe(ZHe(ZIe(ZJe(ZKe(ZLe(ZMe(ZNe(ZOe(ZPe(ZQe(ZRe(ZSe(ZTe(ZUe(ZVe(ZWe(ZXe(ZYe(ZZe(Z[e(Z\e(Z]e(Z^e(Z_e(Z`e(Zae(Zbe(Zce(Zde(Zee(Zfe(Zge(Zhe(Zie(Zje(Zke(Zle(Zme(Zne(Zoe(Zpe(Zqe(Zre(Zse(Zte(Zue(Zve(Zwe(Zxe(Zye(Zze(Z{e(Z|e(Z}e(Z~e(Z�xZ�S)'�UntrustedAstTransformerc����tt|��|�in||_||_d|_dt
tj��jdd�z|_	y)Nrz_tmp%s�.�)
�superr/r�
names_seen�
nameIsAllowed�_tmp_idx�repr�time�replace�_tmp_pfx)�selfr4r5�	__class__s   �rrz UntrustedAstTransformer.__init__EsT������/�1�$�,�B�*�$�/�$�$���$�-��T�$�)�)�+�.�6�6�s�2�>�>�$�-rc�d�|j�|j��}|xjdz
c_|S)N�)r:r6�r;�names  r�tmpNamezUntrustedAstTransformer.tmpNameNs'���=�=����	/�$��-�-�1��-�	
�+rc�:�tdt|dd��d|����)NzLine �linenoz??z: )r
�getattr)r;�node�msgs   r�errorzUntrustedAstTransformer.errorTs���'�$��$�"?��E�F�Frc
�V�|j|�}t|jtj�r�|j|j�}tjtjdtj��|j|tjdtj��gg��}nItjtjdtj��|jgg��}t||j�||_	|S)z�
		Converts:
			for x in expr
		to
			for x in __rl_getiter__(expr)

		Also used for
		* list comprehensions
		* dict comprehensions
		* set comprehensions
		* generator expresions
		�__rl_iter_unpack_sequence__�__rl_getiter__��func�args�keywords)�visit_children�
isinstance�targetr(�Tuple�gen_unpack_spec�Call�Name�Load�iterr-)r;rE�spec�new_iters    r�
guard_iterz"UntrustedAstTransformer.guard_iterWs���
�	�	�T�	"�$�����S�Y�Y�'�
�
�
�t�{�{�
+�4��h�h�	���/�����	<�
�)�)�T�3�8�8�$4�c�h�h�j�A�	B�
��8�
�h�h�	���"�C�H�H�J�	/�
�)�)��
��8�
��4�9�9�%��$�)�	
�+rc�6�t|tj�Sr')rPr(�Starred)r;�obs  r�
is_starredz"UntrustedAstTransformer.is_starredvs��	�B����	$�$rc�6�tjgg��}|jjtjd��|j
jtjgtj���t|jD�cgc]}|j|�r�|��c}�}d}t|j�D]�\}}|j|�r|dz}�t|tj�s�8tjgtj��}|jjtj||z
��|jj|j|��|j
djj|���|jjtjd��|j
jtj|��|Scc}w)a�Generate a specification for '__rl_unpack_sequence__'.

		This spec is used to protect sequence unpacking.
		The primary goal of this spec is to tell which elements in a sequence
		are sequences again. These 'child' sequences have to be protected
		again.

		For example there is a sequence like this:
			(a, (b, c), (d, (e, f))) = g

		On a higher level the spec says:
			- There is a sequence of len 3
			- The element at index 1 is a sequence again with len 2
			- The element at index 2 is a sequence again with len 2
			  - The element at index 1 in this subsequence is a sequence again
				with len 2

		With this spec '__rl_unpack_sequence__' does something like this for
		protection (len checks are omitted):

			t = list(__rl_getiter__(g))
			t[1] = list(__rl_getiter__(t[1]))
			t[2] = list(__rl_getiter__(t[2]))
			t[2][1] = list(__rl_getiter__(t[2][1]))
			return t

		The 'real' spec for the case above is then:
			spec = {
				'min_len': 3,
				'childs': (
					(1, {'min_len': 2, 'childs': ()}),
					(2, {
							'min_len': 2,
							'childs': (
								(1, {'min_len': 2, 'childs': ()})
							)
						}
					)
				)
			}

		So finally the assignment above is converted into:
			(a, (b, c), (d, (e, f))) = __rl_unpack_sequence__(g, spec)
		)�keys�values�childsrr>�min_len)r(�Dictr`�append�StrrarRrV�len�eltsr^�	enumeraterP�NumrS)	r;�tplrXr]rc�offset�idx�val�els	         rrSz'UntrustedAstTransformer.gen_unpack_specysl��Z

���r�"�	%�$��)�)���3�7�7�8�$�%��+�+���S�Y�Y�r�3�8�8�:�.�/�

�c�h�h�B��d�o�o�b�.A��B�C�'��&��C�H�H�%�
#�h�c�3��o�o�c��
�q�[�F��3��	�	�"�	���2�s�x�x�z�	"�B��G�G�N�N�3�7�7�3��<�(�)��G�G�N�N�4�'�'��,�-��K�K��N�����r�"�
#��)�)���3�7�7�9�%�&��+�+���S�W�W�W�%�&�	
�+��+Cs�H�1Hc
���|j|�}tjtjdtj��||tjdtj��gg��S)N�__rl_unpack_sequence__rJrK)rSr(rTrUrV)r;rQ�valuerXs    r�protect_unpack_sequencez/UntrustedAstTransformer.protect_unpack_sequence�sW��	
�	�	�f�	%�$�	������)�3�8�8�:�6�	��c�h�h�/�����<�=��
�rc��|j}|j|tj|tj���}tj
|g|��g}|j
|�g}tj||gg��}|dk(rtj�}n1|dk(rtj�}ntdt|�z��tj||�}	t|	|�t||�|	|fS)a2Helper function to protect tuple unpacks.

		node: used to copy the locations for the new nodes.
		target: is the tuple which must be protected.
		ctx: Defines the context of the returned temporary node.

		It returns a tuple with two element.

		Element 1: Is a temporary name node which must be used to
				   replace the target.
				   The context (store, param) is defined
				   by the 'ctx' parameter..

		Element 2: Is a try .. finally where the body performs the
				   protected tuple unpack of the temporary variable
				   into the original target.
		��targetsrr)�body�	finalbody�handlers�orelse�store�paramzbad ctx "%s")
rArsr(rUrV�Assign�gen_del_stmt�Try�Store�Param�NotImplementedError�typer-)
r;rErQ�ctx�tnam�	converter�try_bodyrx�cleanup�
tmp_targets
          r�gen_unpack_wrapperz*UntrustedAstTransformer.gen_unpack_wrapper�s���(
���$�
�*�*�	��8�8�D�#�(�(�*���)��j�j�&���;�
<�(�� � ��&�'�)��G�G��I��2�
?�'�	�G�^�	����3�
�g�~�	����3�
�^�d�3�i�7�	8�8��x�x��c�"�*���T�"���$��
�g�	�rc��trtjd��Stjdtj���S)N)rr�None)�idr�)�hasNameConstantr(rrUrV�r;s r�
gen_none_nodez%UntrustedAstTransformer.gen_none_nodes/��)8��	�	��	%�a�c�h�h�&�VY�V^�V^�V`�>a�arc�^�tjtj|ddg��|��S)N)rM�vararg�kwarg�defaults)rMrw)r(�Lambda�	arguments)r;rMrws   r�
gen_lambdaz"UntrustedAstTransformer.gen_lambda
s+��	����
�
�	
�d�$��	5��
�rc�|�tjtj|tj��g��S)N)rv)r(�DeleterU�Del)r;�name_to_dels  rr~z$UntrustedAstTransformer.gen_del_stmts%��	���S�X�X�k�3�7�7�9�=�>�	?�?rc���t|tj�r|jSt|tj��rg}|j
r|j
|j
�n|j
|j��|jr|j
|j�n|j
|j��|jr|j
|j�n|j
|j��tjtjdtj��|g��St|tj�retjgtj��}|jD],}|j j
|j#|���.|St$r|St'd|z��)z�Transform slices into function parameters.

		ast.Slice nodes are only allowed within a ast.Subscript node.
		To use a slice as an argument of ast.Call it has to be converted.
		Conversion is done by calling the 'slice' function from builtins
		�slicerKzUnknown slice type: %s)rPr(�Indexrr�Slice�lowerrer��upper�steprTrUrV�ExtSlicerR�dimsrh�transform_slice�isPy39r�)r;�slice_rMr��items     rr�z'UntrustedAstTransformer.transform_slicesT�����	�	�"�
�,�,���&�#�)�)�$�
�4��l�l��K�K������K�K��"�"�$�%��l�l��K�K������K�K��"�"�$�%��k�k��K�K������K�K��"�"�$�%�

�(�(�	���'�3�8�8�:�	&�	
�
���
�&�#�,�,�'�

�)�)�B����
�
#�4��{�{�1�t��I�I���T�)�)�$�/�0�1�
�;�
�
�=�
�5��>�	?�?rc�,�|�y|j|�yr'�r5�r;rEr@s   r�
isAllowedNamez%UntrustedAstTransformer.isAllowedNameCs��	�\�6����T�rc��|jjD]}|j||j�� |jjr0|j||jjj�|jjr0|j||jjj�|jj
D]}|j||j�� yr')rMr��argr�r��
kwonlyargs)r;rEr�s   r�check_function_argument_namesz5UntrustedAstTransformer.check_function_argument_namesGs����Y�Y�^�^�%�c����d�C�G�G�$�%�
�Y�Y������d�D�I�I�,�,�0�0�1�	�Y�Y�_�_����d�D�I�I�O�O�/�/�0�
�Y�Y�
!�
!�%�c����d�C�G�G�$�%rc��|jD]g}d|jvr|j|d�|j||j�|js�L|j||j��i|j|�S)z�Check the names being imported.

		This is a protection against rebinding dunder names like
		__rl_getitem__,__rl_set__ via imports.

		=> 'from _a import x' is ok, because '_a' is not added to the scope.
		�*z"*" imports are not allowed.)�namesr@rGr��asnamerOr�s   r�check_import_namesz*UntrustedAstTransformer.check_import_names[st���j�j�*�d�	�T�Y�Y���J�J�t�3�4����d�D�I�I�&�
�k�k����t�T�[�[�)�*�
�	�	�T�	"�"rc��tjtjdtj��|tj|�gg��}tj
tj�||g��S)zpCheck if 'attr_name' is allowed on the object in node.

		It generates (_getattr_(node, attr_name) and node).
		�__rl_getattr__rK)�opra)r(rTrUrVrf�BoolOp�And)r;rE�	attr_name�call_getattrs    r�gen_attr_checkz&UntrustedAstTransformer.gen_attr_checklsY��������!�3�8�8�:�.�	
�s�w�w�y�!�"���,�


���s�w�w�y�,��)=�	>�>rc�n�|jtur|j|d�y|j|�S)z�Allow constant literals with restriction for Ellipsis.

		Constant replaces Num, Str, Bytes, NameConstant and Ellipsis in
		Python 3.8+.
		:see: https://docs.python.org/dev/whatsnew/3.8.html#deprecated
		z$Ellipsis statements are not allowed.N)rr�EllipsisrGrO�r;rEs  r�visit_Constantz&UntrustedAstTransformer.visit_Constantys5��
�Z�Z�8���:�:�d�:�;�	�	
�	�	�T�	"�"rc��|j|�}t|jtj�r:|j
dk(r|j
|d�d|j|j
<|j||j
�|S)N�printzprint function is not allowedT)	rOrPr�r(rVr�rGr4r�r�s  r�
visit_Namez"UntrustedAstTransformer.visit_Name�sj��	
�	�	�T�	"�$�����#�(�(�#�
�g�g����J�J�t�3�4�"�4�?�?�4�7�7�����T�4�7�7�#�	
�+rc��t|jtj�rW|jjdk(r|j|d�n+|jjdk(r|j|d�d}|jD]}t|tj�s�d}�!|jD]}|j��d}�|j|�}|jjd|j�tjdtj��|_t|j|jd�|S)	a�Checks calls with '*args' and '**kwargs'.

		Note: The following happens only if '*args' or '**kwargs' is used.

		Transfroms 'foo(<all the possible ways of args>)' into
		__rl_apply__(foo, <all the possible ways for args>)

		The thing is that '__rl_apply__' has only '*args', '**kwargs', so it gets
		Python to collapse all the myriad ways to call functions
		into one manageable from.

		From there, '__rl_apply__()' wraps args and kws in guarded accessors,
		then calls the function, returning the value.
		�execzExec calls are not allowed.�evalzEval calls are not allowed.FTr�__rl_apply__)rPrLr(rUr�rGrMr\rNr�rO�insertrVr-)r;rE�
needs_wrap�pos_arg�keyword_args     r�
visit_Callz"UntrustedAstTransformer.visit_Call�s�� ��	�	�3�8�8�$�
�i�i�l�l�f���J�J�t�2�3��	�	������J�J�t�2�3��*�����g���#�+�+�&��J���]�]��k��o�o���J��
�	�	�T�	"�$�
�)�)���1�d�i�i� ��h�h�~�s�x�x�z�2�$�)�����D�I�I�a�L�)�	
�+rc��|jjd�r.|jdk7r|j|d|jz�t|jt
j�r�|j|�}tjtjdtj��|jtj|j�gg��}t||�|St|jt
jt
jf�ry|j|�}tjtjdtj��|jgg��}t||j�||_
|Stdt!|j�z��)z\Checks and mutates attribute access/assignment.

		'a.b' becomes '__rl_getattr__(a, "b")'
		�__z"%s" is an invalid attributer�rK�	__rl_sd__�Unknown ctx type: %s)�attr�
startswithrGrPr�r(rVrOrTrUrrrfr-r�r�r�r�)r;rEr+�	new_values    r�visit_Attributez'UntrustedAstTransformer.visit_Attribute�s;��

�Y�Y���$��D�I�I��$5��:�:�d�2�4�9�9�<�=�����#�(�(�#�
�
�
�d�
#�4��h�h�	���"�C�H�H�J�	/�
�*�*�c�g�g�d�i�i�(�	)�
��8�
�(�D�!�
�?��$�(�(�S�Y�Y����0�1�
�
�
�d�
#�4��x�x�	���+�s�x�x�z�	*�
�*�*��
��9�
�)�T�Z�Z�(��4�:�
�;�
�3�d�4�8�8�n�D�	E�Erc��|j|�}t|jtj�rqtj
tjdtj��|j|j|j�gg��}t||�|St|jtjtjf�r|Stdt|j�z��)a�Transforms all kinds of subscripts.

		'v[a]' becomes '__rl_getitem__(foo, a)'
		'v[:b]' becomes '__rl_getitem__(foo, slice(None, b, None))'
		'v[a:]' becomes '__rl_getitem__(foo, slice(a, None, None))'
		'v[a:b]' becomes '__rl_getitem__(foo, slice(a, b, None))'
		'v[a:b:c]' becomes '__rl_getitem__(foo, slice(a, b, c))'
		'v[a,b:c] becomes '__rl_getitem__(foo, (a, slice(b, c, None)))'
		#'v[a] = c' becomes '_rl_write__(v)[a] = c'
		#'del v[a]' becomes 'del __rl_sd__(v)[a]'
		�__rl_getitem__rKr�)rOrPr�r(rVrTrUrrr�r�r-r�r�r�r��r;rEr+s   r�visit_Subscriptz'UntrustedAstTransformer.visit_Subscript�s���
�	�	�T�	"�$�����#�(�(�#��h�h�	���"�C�H�H�J�	/�
�*�*�d�*�*�4�:�:�6�	7�
��8�
�(�D�!�
�?��$�(�(�S�W�W�c�i�i�0�1��;�
�3�d�4�8�8�n�D�	E�Erc���|j|�}td�|jD��s|Sg}t|j�D]�}t	|t
j�rDtj|g|j||j���}|j|��atj|g|j��}|j|���|D]}t||��|S)Nc3�PK�|]}t|tj���� y�wr')rPr(rR)�.0�ts  r�	<genexpr>z7UntrustedAstTransformer.visit_Assign.<locals>.<genexpr>s����<�!�Z��3�9�9�
%�<���$&ru)rO�anyrv�reversedrPr(rRr}rsrrrer-)r;rE�	new_nodesrQ�wrapperr+s      r�visit_Assignz$UntrustedAstTransformer.visit_Assign
s���	
�	�	�T�	"�$�	�<�t�|�|�<�	<�
�;�.�)�����&��f������#��j�j��X��'�'���
�
�;�=�G����W���z�z�6�(�$�*�*�=�H�
���X����"�h��(�D�!�"�
�rc�J�|j|�}t|jtj�r|j|d�yt|jtj�r|j|d�yt|jtj�r�tj|jgtjtjdtj��tjtt|j��tj|jjtj��|j gg����}t#||�|St%dt|j�z��)ajForbid certain kinds of AugAssign

		According to the language reference (and ast.c) the following nodes
		are are possible:
		Name, Attribute, Subscript

		Note that although augmented assignment of attributes and
		subscripts is disallowed, augmented assignment of names (such
		as 'n += 1') is allowed.
		'n += 1' becomes 'n = __rl_augAssign__("+=", n, 1)'
		z2Augmented assignment of attributes is not allowed.z?Augmented assignment of object items and slices is not allowed.�__rl_augAssign__rKruzUnknown target type: %sN)rOrPrQr(�	AttributerG�	SubscriptrUr}rTrVrf�augOpsr�r�r�rrr-r�r�s   r�visit_AugAssignz'UntrustedAstTransformer.visit_AugAssign:s��
�	�	�T�	"�$�����S�]�]�+��:�:�d�H�I��$�+�+�s�}�}�-��:�:�d�U�V��$�+�+�s�x�x�(��j�j�
�[�[�M�

�(�(�

�(�(�%�s�x�x�z�
2�	�g�g�f�T�$�'�'�]�#�$�	�h�h�t�{�{�~�~�s�x�x�z�*�
�j�j��
��	�8��(�D�!�
�?�
�6��d�k�k�9J�J�	K�Krc�0�tj|�|Sr')r;rO�rEs r�visit_Whilez#UntrustedAstTransformer.visit_Whilees�����d��	
�+rc�`�|j|�}|j||j�|S)z�Protect tuple unpacking on exception handlers.

		try:
			.....
		except Exception as (a, b):
			....

		becomes

		try:
			.....
		except Exception as tmp:
			try:
				(a, b) = __rl_getiter__(tmp)
			finally:
				del tmp
		)rOr�r@r�s  r�visit_ExceptHandlerz+UntrustedAstTransformer.visit_ExceptHandleris-��$
�	�	�T�	"�$����T�4�9�9�%�	
�+rc�.�|j|�}|j}t|�D]i}t|jt
j�s�(|j||j�\}}||_|jjd|��k|S)z+Protect tuple unpacking on with statements.r)
rO�itemsr�rP�
optional_varsr(rRr�rwr�)r;rEr�r�r��unpacks      r�
visit_Withz"UntrustedAstTransformer.visit_With�s���	
�	�	�T�	"�$�
�*�*�%��u�o� �d���#�#�S�Y�Y�/��0�0�	�	�����J��$�D���I�I���Q��� �
�+rc�`�|j||j�|j|�|S)z:Allow function definitions (`def`) with some restrictions.)r�r@r�r�s  r�visit_FunctionDefz)UntrustedAstTransformer.visit_FunctionDef�s)�����T�4�9�9�%��$�$�T�*�	
�+rc�J�|j|�|j|�}|S)z$Allow lambda with some restrictions.)r�rOr�s  r�visit_Lambdaz$UntrustedAstTransformer.visit_Lambda�s%���$�$�T�*�	
�	�	�T�	"�$�	
�+rc��|j||j�|j|�}td�|jD��r|j|d�t
jd|jz�}tj|�jd}|j|_
|j|_|j|_|S)z%Check the name of a class definition.c3�:K�|]}|jdk(���y�w)�	metaclassN)r�)r��keywords  rr�z9UntrustedAstTransformer.visit_ClassDef.<locals>.<genexpr>�s����A������	#�A�s�z0The keyword argument "metaclass" is not allowed.z1			class %s(metaclass=__metaclass__):
				pass
		r)
r�r@rOr�rNrG�textwrap�dedentr(�parserw�bases�decorator_list)r;rE�	CLASS_DEF�new_class_nodes    r�visit_ClassDefz&UntrustedAstTransformer.visit_ClassDef�s������T�4�9�9�%�	
�	�	�T�	"�$��A�4�=�=�A�A��:�:�d�F�G��o�o��	
�	�	���)��9�9�Y�'�,�,�Q�/�.��	�	�.�����.��"&�"5�"5�.��	�rc�$�|j|�Sr')	r�rOr(rTrUrV�left�rightr-r�s   r�visit_Importz$UntrustedAstTransformer.visit_Import�s��	
�	 �	 ��	&�&rc���|j|�}|j}t|tjtj
tjf�r�t|tj�rdnt|tj
�rdnd}tjtj|tj��|j|jgg��}t||�|S|S)N�__rl_mult__�
__rl_add__�
__rl_pow__rK)
rOr�rPr(�Mult�Add�PowrTrUrVrrr-)r;rEr��opfr+s     r�visit_BinOpz#UntrustedAstTransformer.visit_BinOp�s���	
�	�	�T�	"�$��w�w�"���C�H�H�S�W�W�S�W�W�-�.�%�b����2�-�$�R����0�,�
���h�h��8�8�C�����$�
�Y�Y��
�
�#���8��(�D�!�
�?�	
�+rc�&�|j|�y)z>Reject nodes which do not have a corresponding `visit` method.N)�not_allowedr�s  r�
generic_visitz%UntrustedAstTransformer.generic_visit�s�����4�rc�V�|j|d|jjz�y)Nz%s statements are not allowed.)rGr<rr�s  rrz#UntrustedAstTransformer.not_allowed�s ���*�*�T�3�D�N�N�4K�4K�K�Lrc�*��tt|�|�S)zVisit the contents of a node.)r3r/r)r;rEr<s  �rrOz&UntrustedAstTransformer.visit_children�s���	�&��	;�D�	A�Arrc��d|jjz}t|||j�}t	d|�d|�d|���||�S)N�visit_zvisitor=�=z node=)r<rrDrr�)r;rE�method�visitors    r�visitzUntrustedAstTransformer.visit�sC���t�~�~�.�.�.�6�
�T�6�4�#5�#5�
6�7��F�7�4�	8�9�
�$�-�r�NN)r{)�rrr
r�propertyrArGrZr^rSrsr�r�r�r~r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrr�visit_ImportFrom�	visit_For�visit_comprehensionrrrO�
eval_debugr�visit_Ellipsis�
visit_MatMult�
visit_Exec�visit_Nonlocal�visit_AsyncFunctionDef�visit_Await�visit_AsyncFor�visit_AsyncWith�visit_Print�	visit_Num�	visit_Str�visit_Bytes�
visit_List�visit_Tuple�	visit_Set�
visit_Dict�visit_FormattedValue�visit_JoinedStr�visit_NameConstant�
visit_Load�visit_Store�	visit_Del�
visit_Starred�visit_Expression�
visit_Expr�
visit_UnaryOp�
visit_UAdd�
visit_USub�	visit_Not�visit_Invert�	visit_Add�	visit_Sub�
visit_Mult�	visit_Div�visit_FloorDiv�	visit_Pow�	visit_Mod�visit_LShift�visit_RShift�visit_BitOr�visit_BitXor�visit_BitAnd�visit_BoolOp�	visit_And�visit_Or�
visit_Compare�visit_Eq�visit_NotEq�visit_Lt�	visit_LtE�visit_Gt�	visit_GtE�visit_Is�visit_IsNot�visit_In�visit_NotIn�
visit_keyword�visit_IfExp�visit_Index�visit_Slice�visit_ExtSlice�visit_ListComp�
visit_SetComp�visit_GeneratorExp�visit_DictComp�visit_Raise�visit_Assert�visit_Delete�
visit_Pass�visit_alias�visit_If�visit_Break�visit_Continue�	visit_Try�visit_TryFinally�visit_TryExcept�visit_withitem�visit_arguments�	visit_arg�visit_Return�visit_Yield�visit_YieldFrom�visit_Global�visit_Module�visit_Param�
__classcell__)r<s@rr/r/Cs����?�����
G��>%�J�X�9�vb��@�.@�`�%�(#�"?�#�$	�(�TF�D(F�V+�Z)L�V��.�$���"	�
�!��
��!���M�B���M����������%����������
��
��������
����&��!��$������
����"����������
����
��
����
�� ��
��
��������������
������������
����
������������������ �� ����$�� ���������������� ��
��"��!�� ��!��
������!�������rr/c�Z�tjtj|�ddd��S)NT�)�annotate_fields�include_attributes�indent)r(�dump�copy�deepcopyr�s r�	astFormatr�9s!��������t�$�T�d�Z[�\�\rc�"�eZdZd�Zd�Zd�ZeZy)�__rl_SafeIter__c�H�|�j|�|_||_yr')�__rl_real_iter__�__rl_iter__�__rl_owner__)r;�it�owners   rrz__rl_SafeIter__.__init__=s���W�-�-�b�1�$���$�rc��|Sr'rr�s r�__iter__z__rl_SafeIter__.__iter__As��	
�+rc�h�|j�j�t|j�Sr')r��__rl_check__�nextr�r�s r�__next__z__rl_SafeIter__.__next__Ds(������"�"�$�	
�d���	�rN)rrr
rr�r�r�rrrr�r�<s���� �	�rr�c��|�-tjd�jj�}dD] }||vr||=tj�|d<�"|S)Nr>)�__annotations__�__doc__�
__loader__r�__package__�__spec__�__builtins__)�sys�	_getframe�	f_globalsr�__rl_safe_builtins__)�gr@s  r�
safer_globalsr�Ks[���I�	�m�m�A�� � �%�%�'�!�
`�2�T�	�Q�Y���w�*�/�/�1�!�N��2�	
�rc�8�eZdZejZejZee	d��Z
d(d�Zd�Zd�Z
d�Zd�Zd�Zd	�Zd)d
�Zd�Zd�Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z d�Z!d�Z"d�Z#dZ$dZ%dZ&d�Z'd �Z(d!�Z)d"�Z*d#�Z+d$�Z,d%�Z-d*d&�Z.d+d'�Z/y),�__RL_SAFE_ENV__rNc
�B��|�|n�j�_|r
|dk(rtn|ng�_ddl}|j
�_|j�_G�fd�dt�}Gd�d�}|�_
d|d�fd�jff�_tjd	j�D�cic]}|t!||���c}�t#|�D�cic]!}t%t!||��s�|||���#c}x�_}|jt��j(|d
<�j*|d<�j,|d<�j.|d
<�j0|d<�j2|d<�j4|d<�j|d<�j6|d<�j8|d<�j:|d<�j<|d<�fd�|d<t>|d<�j4|d<||d<�j|d<�j,|d<�j@|d<�jB|d<�jD|d<�jF|d<�jH|d <�jJ|d!<�jL|d"<�jN|d#<�jP|d$<�jR|d%<�jT|d&<�jV|d'<�jX|d(<�jZ|d)<�j\|d*<�j^|d+<�j`|d,<ycc}wcc}w)-NTrc���eZdZ�fd�Zy)�-__RL_SAFE_ENV__.__init__.<locals>.__rl_dict__c����t|�dk(r:t|dt�s'	�j|d�}�j	|�f}tj|g|��i|��S#t
$rY�$wxYw�Nr>r)rgrP�dict�
__real_iter__rJ�	TypeError�__new__)�clsrM�kwdsr�r;s    �rr�z5__RL_SAFE_ENV__.__init__.<locals>.__rl_dict__.__new__dsv���
�4�y�!�|�J�t�A�w�t�4�(����d�1�g�&�b��!�!�"�%�
'�d��<�<��)�T�)�D�)�)��	
��
��s�A#�#	A/�.A/N)rrr
r�r�s�r�__rl_dict__r�cs���*rr�c��eZdZd�Zd�Zy)�5__RL_SAFE_ENV__.__init__.<locals>.__rl_missing_func__c��||_yr')rr?s  rrz>__RL_SAFE_ENV__.__init__.<locals>.__rl_missing_func__.__init__os	���D�Mrc�2�td|jz��)Nzmissing global %s)r
r)r;rMr�s   r�__call__z>__RL_SAFE_ENV__.__init__.<locals>.__rl_missing_func__.__call__qs��
�%��
�
�5�
6�6rN)rrr
rr�rrr�__rl_missing_func__r�ns���7rr��openrWaNone False True abs bool callable chr complex divmod float hash hex id int
		isinstance issubclass len oct ord range repr round slice str tuple setattr
		classmethod staticmethod property divmod next object getattr dict iter pow list
		type max min sum enumerate zip hasattr filter map any all sorted reversed range
		set frozenset

		ArithmeticError AssertionError AttributeError BaseException BufferError BytesWarning
		DeprecationWarning EOFError EnvironmentError Exception FloatingPointError FutureWarning
		GeneratorExit IOError ImportError ImportWarning IndentationError IndexError KeyError
		KeyboardInterrupt LookupError MemoryError NameError NotImplementedError OSError
		OverflowError PendingDeprecationWarning ReferenceError RuntimeError RuntimeWarning
		StopIteration SyntaxError SyntaxWarning SystemError SystemExit TabError TypeError
		UnboundLocalError UnicodeDecodeError UnicodeEncodeError UnicodeError UnicodeTranslateError
		UnicodeWarning UserWarning ValueError Warning ZeroDivisionError
		__build_class__rr
rr�r�r�r�rJ�__rl_max_len__�__rl_max_pow_digits__rIrqc�*���j|||�Sr')r�)rLrMr�r;s   �r�<lambda>z*__RL_SAFE_ENV__.__init__.<locals>.<lambda>�s���d�>O�>O�PT�UY�Z^�>_�rr�r�rDr��pow�listr��max�min�sumri�zip�hasattr�filter�mapr��all�sortedr��range�set�	frozenset)1�__rl_tmax__�timeout�__allowed_magic_methods__�allowed_magic_methods�builtinsr��__rl_gen_range__rWr�r��real_birJ�
bi_replacer��update�splitrD�dir�callable�__rl_builtins__rr
rr�r�r�r�r�r�rIrqr��__rl_list__�__rl_type__�
__rl_max__�
__rl_min__�
__rl_sum__�__rl_enumerate__�
__rl_zip__�__rl_hasattr__�
__rl_filter__�
__rl_map__�
__rl_any__�
__rl_all__�
__rl_sorted__�__rl_reversed__�__rl_range__�
__rl_set__�__rl_frozenset__)r;r�r�r�r�r��_r�s`       rrz__RL_SAFE_ENV__.__init__Zs:���#�/��T�5E�5E�$�,�(=�>S�TX�=X� 9�#�2����"�.�.�$��"�-�-�$��	*�D�	*�7�7��$�,����'�(��D��� ��$�/�
�����e�g�!��q���!�!4�4���$OR�RZ�m�+}��_g�ho�px�yz�h{�_|�A�.A�!�.D�,D�+}�}�$������-�.�#'�/�/�/�,��#'�#3�#3�/�-� �"&�/�/�/�,��!%���/�+��(,�(=�(=�/�$�%�&*�&9�&9�/�"�#�&*�&9�&9�/�"�#�&*�&9�&9�/�"�#�&*�&9�&9�/�"�#�-1�-G�-G�/�)�*�37�3S�3S�/�/�0�.2�.I�.I�/�*�+�$_�/�.�!�'6�/�#�$� $�2�2�/�)��'�/�&�� �/�/�/�&���?�?�/�%�� �,�,�/�&�� �,�,�/�&���?�?�/�%���?�?�/�%���?�?�/�%��!%�!6�!6�/�+���?�?�/�%��#�2�2�/�)��"�0�0�/�(���?�?�/�%���?�?�/�%���?�?�/�%��"�0�0�/�(�� $� 4� 4�/�*��!�.�.�/�'���?�?�/�%��!%�!6�!6�/�+���u��$,~s�3L�L�6Lc�D�t|�dk(rt|�Std��)Nr>ztype call error)rgr�r
)r;rMs  rr�z__RL_SAFE_ENV__.__rl_type__�s"����Y��\�$��+�%��!�"�"rc�T�|j�|jk\rtd��y)NzResources exceeded)�
__time_time__�__rl_limit__r
r�s rr�z__RL_SAFE_ENV__.__rl_check__�s*��	����T�.�.�.�	�%�	&�&�/rc��|Sr'r)r;�objs  rr�z__RL_SAFE_ENV__.__rl_sd__�s��	�*rc�:�t||j|���S)N)r�)r��__weakref_ref__�r;r�s  rrJz__RL_SAFE_ENV__.__rl_getiter__�s��	��$�"6�"6�t�"<�	=�=rc�d�|r|g}|j|�t|j|�fi|��Sr')�extendr��__rl_args_iter__�r;r�rMr�s    rr�z__RL_SAFE_ENV__.__rl_max__��3��	�

��3��:�:�d��	�T�
"�
"�3�
'�	/�$�	/�/rc�d�|r|g}|j|�t|j|�fi|��Sr')r�r�r�r�s    rr�z__RL_SAFE_ENV__.__rl_min__�r�rc�8�t|j|�|�Sr')r�r�)r;�sequence�starts   rr�z__RL_SAFE_ENV__.__rl_sum__�s��	�T�
"�
"�8�
,�e�	4�4rc�6�t|j|��Sr')rir��r;�seqs  rr�z __RL_SAFE_ENV__.__rl_enumerate__�s��	�4�(�(��-�	.�.rc��ttt|��D�cgc]#}|j|j	||����%c}�Scc}wr')r�r�rgr�r��r;rM�is   rr�z__RL_SAFE_ENV__.__rl_zip__�s?��	�E�RU�VZ�R[�L\�]�q�t�$�$�T�%8�%8��q�%A�B�]�	^�^��]s�(Ac�^�	|j||�y#tttf$rYywxYw)NFT)r��AttributeErrorr
r�)r;r�r@s   rr�z__RL_SAFE_ENV__.__rl_hasattr__�s7������s�D�!�
���'�9�	-��
��s��,�,c�8�t||j|��Sr')r�r��r;�fr�s   rr�z__RL_SAFE_ENV__.__rl_filter__�s��	��$�'�'��,�	-�-rc�8�t||j|��Sr')r�r�r�s   rr�z__RL_SAFE_ENV__.__rl_map__�s��	�Q�t�$�$�S�)�	*�*rc�6�t|j|��Sr')r�r�r�s  rr�z__RL_SAFE_ENV__.__rl_any__����	�T�
"�
"�3�
'�	(�(rc�6�t|j|��Sr')r�r�r�s  rr�z__RL_SAFE_ENV__.__rl_all__�rrc�8�t|j|�fi|��Sr')r�r�)r;r�r�s   rr�z__RL_SAFE_ENV__.__rl_sorted__�s��	��%�%�c�*�	2�T�	2�2rc�6�|jt|��Sr')r�r�r�s  rr�z__RL_SAFE_ENV__.__rl_reversed__�s��	
�	�	�x��}�	-�-rc�8�|jt|g|����Sr')rJr�)r;r�rMs   rr�z__RL_SAFE_ENV__.__rl_range__�s��	
�	�	�U�5�/�$�/�	0�0rc�6�t|j|��Sr')r�r�r�s  rr�z__RL_SAFE_ENV__.__rl_set__�s��	�T�
"�
"�2�
&�	'�'rc�6�t|j|��Sr')r�r�r�s  rr�z __RL_SAFE_ENV__.__rl_frozenset__�s��	�4�(�(��,�	-�-rc#�PK�||�D]}|j|||����y�w)z�Protect sequence unpacking of targets in a 'for loop'.

		The target of a for loop could be a sequence.
		For example "for a, b in it"
		=> Each object from the iterator needs guarded sequence unpacking.
		N)rq)r;r�rX�	_getiter_r]s     rrIz+__RL_SAFE_ENV__.__rl_iter_unpack_sequence__�s0����
�b�M�:�b�	
�	$�	$�R��y�	9�9�:�r�c��t|j|��}t|�|dkr|S|dD]\}}|j||||�||<� |S)aProtect nested sequence unpacking.

		Protect the unpacking of 'it' by wrapping it with '_getiter_'.
		Furthermore for each child element, defined by spec,
		__rl_unpack_sequence__ is called again.

		Have a look at transformer.py 'gen_unpack_spec' for a more detailed
		explanation.
		rcrb)r��__rl__getiter__rgrq)r;r�rXr
�retrm�
child_specs       rrqz&__RL_SAFE_ENV__.__rl_unpack_sequence__sm��	
�T�
!�
!�"�
%�&�#�
	��X��Y���

�:� ��>�K��s�J��)�)�#�c�(�J�	�J�3�s�8�K�	�*rc��t|t�r=|tvs$|jd�r#|dk7r||jvrtd|z��yyyy)z�Check names if they are allowed.
		If ``allow_magic_methods is True`` names in `__allowed_magic_methods__`
		are additionally allowed although their names start with `_`.
		r�zunsafe access of %sN)rP�strTypes�
__rl_unsafe__r�r�r
r?s  r�__rl_is_allowed_name__z&__RL_SAFE_ENV__.__rl_is_allowed_name__s[��
��X��
�m������ 5��d�
��D�.�.�.�
�'�$�.�
/�/�	/�	�!6�rc��t|t�r|dk(rtdt|�z��|j	|�t||g|���S)N�formatz%s.format is not implemented)rPrr
r�rrD)r;r��arMs    rr�z__RL_SAFE_ENV__.__rl_getattr__)sG����X��1�h�;�	�/�$�s�)�;�	<�<����a� �	��Q�	��	�rc��t|�|jur?|j�||}|S|j}|j}|�d}|�||d}|S|||}|St|t�r|j|�||S||S)Nr)r��
__slicetype__r�r��stoprPrr)r;r�r�vr�rs      rr�z__RL_SAFE_ENV__.__rl_getitem__/s���	�!�W��"�"�"��f�f���A��A��8�
�G�G�E��6�6�D��}�
�U��|�	�U�V��Q��8�

�U�4��Q�
�8��!�H�����q�!�

�a�&�=�	�Q��-r�i���dc��t|d�r;t|d�r/t|�t|�z|jkDrtd��||zS�N�__len__zexcessive length�r�rgr�r
�r;r�bs   rrz__RL_SAFE_ENV__.__rl_add__FsD��
�a�����9� 5�	�Q��#�a�&��D�/�/�/�	�#�	$�$�	
�Q��,rc��t|d�r|t|�z|jkDs't|d�r&|t|�z|jkDrtd��||zSrrr s   rr
z__RL_SAFE_ENV__.__rl_mult__LsU���q�)���S��V��d�.A�.A�!A���9��!�c�!�f�*�t�/B�/B�"B�	�#�	$�$�	
�Q��,rc��	|dkDr-t|t|�zdz�|jkDrt�||zS#t|�d|�d���xYw)Nrr>z**z invalid or too large)�int�
math_log10r�r
r s   rrz__RL_SAFE_ENV__.__rl_pow__RsU��8���c�
�1�Z��]�?�1���d�8�8�8��]�
�a��-��8�	�!�A�6�	7�7�s	�29�Ac�B�|dk(r|j||�S|dk(r||z
S|dk(r|j||�S|dk(r||zS|dk(r||zS|dk(r|j||�S|dk(r||zS|dk(r||z	S|d	k(r||zS|d
k(r||zS|dk(r||zS|dk(r||zSy)
Nrrrrrrrrrrrr)rr
r)r;r�rr�s    rr�z __RL_SAFE_ENV__.__rl_augAssign__[s�����X�d�o�o�a��*�*���X�a��c�z���X�d�&�&�q��+�+���X�a��c�z���X�a��c�z���Y�t���q��+�+���Y�q�!�t����Y�q�!�t����X�a��c�z���X�a��c�z���X�a��c�z���Y�q�!�t��Yrc
�(�t|dd�}|r2t|t�r"|jdvr|j	|d�||j|�D�cgc]}|��c}i|j
�D��cic]\}}||��
c}}��Scc}wcc}}w)N�__self__)�pop�
setdefault�get�popitemr)rDrPr�rrrJr�)r;rLrMr�r�r�krs        rr�z__RL_SAFE_ENV__.__rl_apply__is�����Z��%�#����T��t�}�}�0U�U�����Q��(�	
�4�.�.�t�4�5�a��5�	W�����9V�#�!�A�!�A�#�9V�	W�W��5��9Vs�	B	�6
Bc���t|�dk(r>|d}t|t�r|St||j�s|j	|�S|j	t|��Sr�)rgrPr�r�rJrWr�s   rr�z __RL_SAFE_ENV__.__rl_args_iter__ps[����Y�!�^��A�w�1���O�$��H�
�Q�t�,�,�
-����q�!�!�	
�	�	�T�4�[�	)�)rc�6�t|j|��Sr')r�rJr�s  rr�z__RL_SAFE_ENV__.__rl_list__zs��	
�d�!�!�"�%�	&�&rc��i}|st|||||��}||fStj|||�}	tdkDrt	dt|	�z�||	�}	tdkDrt	dt|	�z�t|	||��}||fS)N)�mode�flags�dont_inheritrzpre:
%s
z	post:
%s
�r1)�compiler(r�r"r�r�)
r;�src�fnamer1r2�inheritrr4�bcode�astcs
          r�__rl_compile__z__RL_SAFE_ENV__.__rl_compile__}s����*�	��3��D���K�P�5�
�
�	���)�)�C���
%�4���l�	�,�y���
&�'�
��+�4���l�	�-�	�$��
'�(��4��T�*�5�	�
�	�rc
��|j|d|ddt|j��j��\}}	d||fvrRt	j
|�}
|�|
jj�n|}|�|
jj�n|}
n|}
|}d|
vr|
dfnd}|j|
d<|j�|�|n|jz|_|�|r
|dk(rtn|ng|_gj}
|j }|j"}|D]$\}}|
t%||��t'|||��&	t)||
|�|
j*}
t-|�D]\}\}}t'|||
|��|r	|d|
d<SS#|
j*}
t-|�D]\}\}}t'|||
|��|r	|d|
d<wwxYw)N�<string>rTr�)r7r1r2r8rr�F)r;r/rrr�r��f_localsrr�r�r�r�r�r�r�rer�r�rD�setattrr�r(ri)r;�exprr��lr1r�r��__frame_depth__r9�ns�G�L�obi�sbi�bi�bir�n�rr�s                   r�__rl_safe_eval__z __RL_SAFE_ENV__.__rl_safe_eval__�s����!�!�$�j�t�1�VZ�
!��0K�0K�
L�
R�
R�"�T�)�%��	�a��U�]�
�}�}�_�%�1��I�q�z�z����1�1��Y�q�{�{����A�1��1��1� .�!� 3��>�	���#��*�*�!�N���(�(�*��9L�g�RV�R^�R^�_�$���&�)>�@U�VZ�?Z�";�$�B���
�	�	�#��|�|�"����#���d�a���w�r�!�}��
�2�a��?���
�u�Q�q�/�	���3��c�N��y�q�&�1�a��B�q��Q����	��A��A�n��
��

���3��c�N��y�q�&�1�a��B�q��Q����	��A��A�n��
�s�<F�?Gr)r)r=r�rTN)NNr)0rrr
r8r��weakref�refr�r�r�rrr�r�r�rJr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rIrqrr�r�r�r�r�rr
rr�r�r�r�r;rLrrrr�r�Vs��������;�;���e�A�h���Z7�x#�'�
�>�0�0�5�/�_��.�+�)�)�3�.�1�(�.�	:�
�0	0���&����������X�*�'��rr�c�"�eZdZdZdZd�Zdd�Zy)rLz&creates one environment and re-uses itr�c��d|_yr')�envr�s rrz__rl_safe_eval__.__init__�s	��
�$�(rNc	��|jst||��|_|jj||||j||d��S)N)r�r�r)r�r�rB)rQr�rLr1)r;r@r�rAr�r�s      rr�z__rl_safe_eval__.__call__�sG��	
���o�g�Uj�k�4�8�	
���	"�	"�4��A�t�y�y�'�.��
#�
�r)NNNN)rrr
r�r1rr�rrrrLrL�s��-����rrLc��eZdZdZy)�__rl_safe_exec__r�N)rrr
r1rrrrTrT�s���rrTc����������i���i��j���jdddd��tj���tj���t	|t
�rt
j|d��}t	|tj�r|j}	tj�fd���fd������fd
���|�S#t$r
�fd���fd	��Y�%wxYw)NTF)r��True�Falser�r4c���t|tj�xs*t|tj�xr|j�vSr')rPr(rrUr��rJ�
safe_namess �rr�z*rl_extended_literal_eval.<locals>.<lambda>�s6���
�1�c�&6�&6�7�h�:�a����;Q�;h�VW�VZ�VZ�^h�Vh�rc�n��t|tj�r|jS�|jSr')rPr(rrrr�rYs �rr�z*rl_extended_literal_eval.<locals>.<lambda>�s*���j��3�3C�3C�&D�1�7�7��*�UV�UY�UY�JZ�rc�X��t|tj�xr|j�vSr')rPr(rUr�rYs �rr�z*rl_extended_literal_eval.<locals>.<lambda>�s ���
�1�c�h�h�/�F�A�D�D�J�4F�rc�"���|jSr')r�rYs �rr�z*rl_extended_literal_eval.<locals>.<lambda>�s���:�a�d�d�+�rc�*��t|tjtjf�r|jSt|tj
�r|jSt|tj�rtt�|j��St|tj�rtt�|j��St|tj�r2t�fd�t|j |j"�D��S�	|�r�|�St|tj$�r�t|j&tj(tj*f�rt|j,tj
tj$tj.f�r<�|j,�}t|j&tj(�r|�S|St|tj.��r&t|j&tj0tj2f�r�t|j4tj
tj$tj.f�r�t|j4jt6�r�t|j8tj
tj$t:f�rR�|j8�}�|j4�}t|j&tj0�r||zS||z
St|tj<�r�t|j>tj@�r�|j>jB�vrp�|j>jB|jDD�cgc]
}�|���c}i|jFD�cic]}|jH�|jJ���!c}��StMd��cc}wcc}w)Nc3�D�K�|]\}}�|��|�f���y�wr'r)r�r-r�_converts   �rr�z=rl_extended_literal_eval.<locals>._convert.<locals>.<genexpr>�s&�����&�d�a�����X�a�[�)�&�s� zBad expression)'rPr(rf�Bytes�srjrJrR�tupler�rh�Listr�rdr�r�r`ra�UnaryOpr��UAdd�USub�operand�BinOpr�Subr�complexr�astBinOprTrLrUr�rMrNr�rr�
ValueError)
rErhrrrJ�kwr`�safe_callables�safe_extract�	safe_tests
      ����rr`z*rl_extended_literal_eval.<locals>._convert�s������s�w�w��	�	�*�+�
�&�&�=��$���� �
�&�&�=��$��	�	�"�
��H�d�i�i�(�
)�)��$����!�
�s�8�T�Y�Y�'�
(�(��$����!�
�&�	�T�Y�Y����	$�&�&�&����
�t�
���$����$��t�w�w����3�8�8�,�-��t�|�|�c�g�g�s�{�{�C�I�I�>�?�
�d�l�l�
#�7�����#�(�(�#�
�9��
�9���$��	�	�"��t�w�w����#�'�'�*�+��t�z�z�C�G�G�S�[�[�#�)�)�<�=��t�z�z�|�|�W�%��t�y�y�3�7�7�C�K�K��:�;�
�4�9�9�
�4��D�J�J��5�����#�'�'�"��%�<���%�<���$����!��t�y�y�#�(�(�#��I�I�L�L�N�"�
&�.������
&��9�9�%�a�h�q�k�%�<�,0�M�M�:�b�r�v�v�x����!�!�:�<�<�	�#�$�$��&��:s�7P�$P)rr��types�MappingProxyTyperP�strr(r��
Expressionrwrr�)r@rorZr`rprqs ``@@@r�rl_extended_literal_evalrv�s�������.����*��o�o������D�$��?�@��$�$�Z�0���(�(��8���t�S��	���4�f�	%�$��t�S�^�^�$�	
���$�,����h�)�Z�,�
'%�P	�����Y	�,�F�)�+�,�,�s�+C�C+�*C+r'r)>r��osr(�rerMr8r�mathrrr$�environr+r"�bytesrtr�version_infor�r��haveNameConstantr�rmr
rrjr
�Div�Modr�LShift�RShift�BitOr�BitXor�BitAnd�FloorDiv�MatMultr�r�r�r�rr5�join�M�__rl_unsafe_re__r-�NodeTransformerr/r�r�r�r��log10r%�object�__rl_undef__r�rLrTrv�rl_safe_exec�rl_safe_evalrrr�<module>r�s���:�9�9�9�9�
�������S�1�
2�
��#�;��	�	�	�"�1�	�u�	$���3�~�.����j��
���$����$����4����$����$����%����U����U����D����T����T����u����d�
��$&�	'�	���F�GL�e�g��
��2�:�:�k�C�H�H�]�,C�C�B�D�D�I��%�t�c�1�1�t�l]�����
��Z�Z�
��x��R�R�h

�
��'��?�B �!���!�r

Zerion Mini Shell 1.0