relateby-pattern 0.4.2

Core pattern data structures
Documentation
�

��iu����dZddlZddlmcmZddlZd�Zd�Z	d�Z
d�Zd�Zd�Z
d	�Zd
�Zedk(rAe�e	�e
�e�e�e
�e�e�ed�yy)
zu
Tests for Pattern.para() - paramorphism operation

Validates structure-aware fold with access to pattern structure.
�Nc���tjjd�}|jd��}d}||k(}|s�t	j
d|fd||f�dt
j�vst	j|�rt	j|�ndt	j|�d�z}t	jd|���dzd	|iz}tt	j|���d
x}}y
)zATest para on atomic pattern - receives empty element_results list�c�2�|jt|�zS�N��value�sum��p�rss  �e/Users/akollegger/Developer/relateby/pattern-rs/crates/pattern-core/tests/python/test_paramorphism.py�<lambda>z*test_para_atomic_pattern.<locals>.<lambda>s��q�w�w��R��'8���==�z%(py0)s == %(py3)s�result��py0�py3zExpected 5, got �
>assert %(py5)s�py5N)
�pattern_core�Pattern�point�para�
@pytest_ar�_call_reprcompare�@py_builtins�locals�_should_repr_global_name�	_saferepr�_format_assertmsg�AssertionError�_format_explanation)�atomicr�@py_assert2�@py_assert1�@py_format4�@py_format6s      r
�test_para_atomic_patternr+
s���
�
!�
!�
'�
'��
*�F��[�[�8�
9�F��3�6�Q�;�3�3�3�6�Q�3�3�3�3�3�3�6�3�3�3�6�3�3�3�Q�3�3�3�*�6�(�3�3�3�3�3�3�3rc�^�tjjdtjjd�tjjd�g�}|j	d��}d}||k(}|s�tjd|fd||f�dtj�vstj|�rtj|�ndtj|�d	�z}tjd
|���dzd|iz}ttj|���d
x}}y
)z0Test para on simple pattern with atomic elements���c�2�|jt|�zSrrr
s  r
rz*test_para_simple_pattern.<locals>.<lambda>������#�b�'�(9r�rrrrzExpected 6, got rrN�rr�patternrrrrrr r!r"r#r$r%�r4rr'r(r)r*s      r
�test_para_simple_patternr6s����"�"�*�*�1����"�"�1�%����"�"�1�%�/��G��\�\�9�
:�F��3�6�Q�;�3�3�3�6�Q�3�3�3�3�3�3�6�3�3�3�6�3�3�3�Q�3�3�3�*�6�(�3�3�3�3�3�3�3rc
��tjjdtjjd�tjjdtjjd�g�g�}|j	d��}d}||k(}|s�tjd|fd||f�d	tj�vstj|�rtj|�nd	tj|�d
�z}tjd|���dzd
|iz}ttj|���dx}}y)z0Test para on nested pattern - depth-weighted sumr-r.r/�c�2�|jt|�zSrrr
s  r
rz*test_para_nested_pattern.<locals>.<lambda>8r1r�
rrrrzExpected 10, got rrNr3r5s      r
�test_para_nested_patternr;$s����"�"�*�*�1����"�"�1�%����$�$�Q�� � �&�&�q�)�)
�	�/��G��\�\�9�
:�F��5�6�R�<�5�5�5�6�R�5�5�5�5�5�5�6�5�5�5�6�5�5�5�R�5�5�5�,�V�H�5�5�5�5�5�5�5rc���tjjdtjjd�tjjd�tjjdtjjd�g�g�}|j	d��}|jdd��}||k(}|s�t
jd	|fd
||f�dtj�vst
j|�rt
j|�nddtj�vst
j|�rt
j|�ndd
�z}t
jd|�d|���dzd|iz}tt
j|���d}d}||k(}|s�t
jd	|fd||f�dtj�vst
j|�rt
j|�ndt
j|�d�z}t
jd|���dzd|iz}tt
j|���dx}}y)zGTest that para can replicate fold behavior for simple value aggregationr:���(�2c�2�|jt|�zSrrr
s  r
rz'test_para_fold_parity.<locals>.<lambda>Hs��Q�W�W�s�2�w�->rrc��||zSr�)�acc�vs  r
rz'test_para_fold_parity.<locals>.<lambda>Ks���q�rr)z%(py0)s == %(py2)s�para_result�fold_result)r�py2zPara z	 != Fold z
>assert %(py4)s�py4N�rrzExpected 150, got rr)rrr4rr�foldrrrr r!r"r#r$r%)	r4rFrGr(�@py_format3�@py_format5r'r)r*s	         r
�test_para_fold_parityrN=s����"�"�*�*�2����"�"�2�&����"�"�2�&����$�$�R�� � �&�&�r�*�*
�	�0��G��,�,�>�?�K��,�,�q�"8�9�K��+�%�R�R�R�;�+�R�R�R�R�R�R�;�R�R�R�;�R�R�R�R�R�R�+�R�R�R�+�R�R�R�R��{�m�9�[�M�'R�R�R�R�R�R�R��A�;�#��A�A�A�;�#�A�A�A�A�A�A�;�A�A�A�;�A�A�A�#�A�A�A�!3�K�=�A�A�A�A�A�A�Arc
��tjjdtjjd�tjjdtjjd�g�g�}d�}|j	|�}d}||k(}|s�tjd|fd||f�d	tj�vstj|�rtj|�nd	tj|�d
�z}tjd|���dzd
|iz}ttj|���dx}}y)zFTest computing multiple statistics (sum, count, max_depth) in one passr-r.r/r8c���|s|jddfStd�|D��}td�|D��}td�|D��}|j|z}d|z}d|z}|||fS)zReturns (sum, count, max_depth)r-rc3�&K�|]	}|d���y�w)rNrC��.0�ss  r
�	<genexpr>zDtest_para_multi_statistics.<locals>.compute_stats.<locals>.<genexpr>hs����3�]��q��t�]���c3�&K�|]	}|d���y�w)r-NrCrRs  r
rUzDtest_para_multi_statistics.<locals>.compute_stats.<locals>.<genexpr>is����5�}�!��1��}�rVc3�&K�|]	}|d���y�w)r.NrCrRs  r
rUzDtest_para_multi_statistics.<locals>.compute_stats.<locals>.<genexpr>js����9�=�a�Q�q�T�=�rV)rr	�max)r�
element_stats�elem_sum�
elem_count�elem_max_depth�	total_sum�total_count�	max_depths        r
�
compute_statsz1test_para_multi_statistics.<locals>.compute_statsasw����G�G�Q��?�"��3�]�3�3���5�}�5�5�
��9�=�9�9���G�G�h�&�	��*�n����&�	��;�	�2�2r)r:r8r.rrrrzExpected (10, 4, 2), got rrNr3)r4rarr'r(r)r*s       r
�test_para_multi_statisticsrbRs����"�"�*�*�1����"�"�1�%����$�$�Q�� � �&�&�q�)�)
�	�/��G�3�$�\�\�-�
(�F� �E�6�Z��E�E�E�6�Z�E�E�E�E�E�E�6�E�E�E�6�E�E�E�Z�E�E�E�#<�V�H�!E�E�E�E�E�E�Erc
���tjjdtjjd�tjjdtjjd�g�g�}d�}|j	|�}|j
}d}||k(}|s�t
jd|fd||f�dtj�vst
j|�rt
j|�ndt
j|�t
j|�d	�z}t
jd
|j
���dzd|iz}tt
j|���d
x}x}}|j}t!|�}d}	||	k(}
|
�s t
jd|
fd||	f�dtj�vst
jt �rt
jt �nddtj�vst
j|�rt
j|�ndt
j|�t
j|�t
j|	�d�z}t
jd�dzd|iz}tt
j|���d
x}x}x}
}	|jd}
|
j
}d}||k(}|s�t
jd|fd||f�t
j|
�t
j|�t
j|�d�z}dd|iz}tt
j|���d
x}
x}x}}|jd}
|
j"}|�}|s`dt
j|
�t
j|�t
j|�d�z}tt
j|���d
x}
x}}|jd}
|
j
}d}||k(}|s�t
jd|fd||f�t
j|
�t
j|�t
j|�d�z}dd|iz}tt
j|���d
x}
x}x}}|jd}|j}t!|�}d}||k(}	|	s�t
jd|	fd||f�dtj�vst
jt �rt
jt �ndt
j|�t
j|�t
j|�t
j|�d�z}dd|iz}tt
j|���d
x}x}x}x}	}|jdjd}
|
j
}d }||k(}|s�t
jd|fd||f�t
j|
�t
j|�t
j|�d�z}dd|iz}tt
j|���d
x}
x}x}}y
)!z3Test structure-preserving transformation using parar-r.r/r8c��|jdz}|stjj|�Stjj	||�S)z%Double the value, keep same structurer.)rrrrr4)r�transformed_elements�	new_values   r
�
double_valueszDtest_para_structure_preserving_transformation.<locals>.double_values�sE���G�G�a�K�	�#��'�'�-�-�i�8�8� �'�'�/�/�	�;O�P�Prr)z-%(py2)s
{%(py2)s = %(py0)s.value
} == %(py5)s�transformed)rrHrzRoot value should be 2, got z
>assert %(py7)s�py7N)zN%(py5)s
{%(py5)s = %(py0)s(%(py3)s
{%(py3)s = %(py1)s.elements
})
} == %(py8)s�len)r�py1rr�py8zRoot should have 2 elementsz
>assert %(py10)s�py10r)z-%(py3)s
{%(py3)s = %(py1)s.value
} == %(py6)s)rkr�py6zassert %(py8)srlzDassert %(py5)s
{%(py5)s = %(py3)s
{%(py3)s = %(py1)s.is_atomic
}()
})rkrrr2)zN%(py6)s
{%(py6)s = %(py0)s(%(py4)s
{%(py4)s = %(py2)s.elements
})
} == %(py9)s)rrHrIrn�py9zassert %(py11)s�py11�)rrr4rrrrrrr r!r"r#r$r%�elementsrj�	is_atomic)r4rgrhr(�@py_assert4�@py_assert3r*�@py_format8r'�@py_assert7�@py_assert6�@py_format9�@py_format11�@py_assert0�@py_assert5�@py_format7�@py_assert8�@py_format10�@py_format12s                   r
�-test_para_structure_preserving_transformationr�ys���"�"�*�*�1����"�"�1�%����$�$�Q�� � �&�&�q�)�)
�	�/��G�Q��,�,�}�-�K����U��U���!�U�U�U���U�U�U�U�U�U�;�U�U�U�;�U�U�U��U�U�U��U�U�U�%A�+�BS�BS�AT�#U�U�U�U�U�U�U�U��#�#�H�3�#�$�H��H�$��)�H�H�H�$��H�H�H�H�H�H�3�H�H�H�3�H�H�H�H�H�H�{�H�H�H�{�H�H�H�#�H�H�H�$�H�H�H��H�H�H�+H�H�H�H�H�H�H�H�����"�-�"�(�(�-�A�-�(�A�-�-�-�-�(�A�-�-�-�"�-�-�-�(�-�-�-�A�-�-�-�-�-�-�-�����"�.�"�,�,�.�,�.�.�.�.�.�"�.�.�.�,�.�.�.�.�.�.�.�.�.�.�����"�-�"�(�(�-�A�-�(�A�-�-�-�-�(�A�-�-�-�"�-�-�-�(�-�-�-�A�-�-�-�-�-�-�-��#�#�A�&�5�&�/�/�5�3�/�0�5�A�5�0�A�5�5�5�5�0�A�5�5�5�5�5�5�3�5�5�5�3�5�5�5�&�5�5�5�/�5�5�5�0�5�5�5�A�5�5�5�5�5�5�5�����"�+�+�A�.�9�.�4�4�9��9�4��9�9�9�9�4��9�9�9�.�9�9�9�4�9�9�9��9�9�9�9�9�9�9rc�0�tjjdtjjd�tjjd�g�}d�}|j	|�}d}||k(}|s�tjd|fd||f�dtj�vstj|�rtj|�ndtj|�d	�z}d
d|iz}ttj|���dx}}y)
z<Test that para callback has access to full pattern structure�root�a�bc�
�d}t||�}|s�ddtj�vstjt�rtj
t�nddtj�vstj|�rtj
|�ndtj
|�tj
|�d�z}t
tj|���dx}}d}t||�}|s�ddtj�vstjt�rtj
t�nddtj�vstj|�rtj
|�ndtj
|�tj
|�d�z}t
tj|���dx}}d}t||�}|s�ddtj�vstjt�rtj
t�nddtj�vstj|�rtj
|�ndtj
|�tj
|�d�z}t
tj|���dx}}d	}t||�}|s�ddtj�vstjt�rtj
t�nddtj�vstj|�rtj
|�ndtj
|�tj
|�d�z}t
tj|���dx}}|jd
k(�r�|j}|�}|}|s�ddtj�vstj|�rtj
|�ndtj
|�tj
|�d�z}t
tj|���dx}x}}|j}|�}d
}||k(}|s�tjd|fd||f�dtj�vstj|�rtj
|�ndtj
|�tj
|�tj
|�d�z}	dd|	iz}
t
tj|
���dx}x}x}}y|j}|�}|s�ddtj�vstj|�rtj
|�ndtj
|�tj
|�d�z}t
tj|���dx}}|j}|�}d}||k(}|s�tjd|fd||f�dtj�vstj|�rtj
|�ndtj
|�tj
|�tj
|�d�z}	dd|	iz}
t
tj|
���dx}x}x}}y)z&Verify we can access pattern structurerz5assert %(py5)s
{%(py5)s = %(py0)s(%(py1)s, %(py3)s)
}�hasattrr)rrkrrNrrrs�lengthr�zHassert not %(py4)s
{%(py4)s = %(py2)s
{%(py2)s = %(py0)s.is_atomic
}()
})rrHrIr.r)zE%(py4)s
{%(py4)s = %(py2)s
{%(py2)s = %(py0)s.length
}()
} == %(py7)s)rrHrIrizassert %(py9)srozDassert %(py4)s
{%(py4)s = %(py2)s
{%(py2)s = %(py0)s.is_atomic
}()
}rr-)r�rr rr!r"r$r%rrsr�r)rrr'rtr*r(rur|rxrvrrMs            r
�check_structurez>test_para_access_to_pattern_structure.<locals>.check_structure�s���"�"�w�q�'�"�"�"�"�"�"�"�"�w�"�"�"�w�"�"�"�"�"�"�q�"�"�"�q�"�"�"�'�"�"�"�"�"�"�"�"�"�"�%�%�w�q�*�%�%�%�%�%�%�%�%�w�%�%�%�w�%�%�%�%�%�%�q�%�%�%�q�%�%�%�*�%�%�%�%�%�%�%�%�%�%�&�&�w�q�+�&�&�&�&�&�&�&�&�w�&�&�&�w�&�&�&�&�&�&�q�&�&�&�q�&�&�&�+�&�&�&�&�&�&�&�&�&�&�"�#�w�q�(�#�#�#�#�#�#�#�#�w�#�#�#�w�#�#�#�#�#�#�q�#�#�#�q�#�#�#�(�#�#�#�#�#�#�#�#�#�#�
�7�7�f���{�{�$�{�}�$�}�$�$�$�$�$�$�$�$�q�$�$�$�q�$�$�$�{�$�$�$�}�$�$�$�$�$�$��8�8�"�8�:�"��"�:��?�"�"�"�:��"�"�"�"�"�"�1�"�"�"�1�"�"�"�8�"�"�"�:�"�"�"��"�"�"�"�"�"�"��	�;�;� �;�=� �=� � � � � �1� � � �1� � � �;� � � �=� � � � � � ��8�8�"�8�:�"��"�:��?�"�"�"�:��"�"�"�"�"�"�1�"�"�"�1�"�"�"�8�"�"�"�:�"�"�"��"�"�"�"�"�"�"�rr-rrrrzassert %(py5)srN)
rrr4rrrrrr r!r"r$r%)r4r�rr'r(r)r*s       r
�%test_para_access_to_pattern_structurer��s����"�"�*�*�6����"�"�3�'����"�"�3�'�4��G�
�0�\�\�/�
*�F���6�Q�;����6�Q�������6����6����Q�������rc��tjddhdtjjd�i��}tjddhdtjjd�i��}tjj|tjj
|�g�}d�}|j|�}d	}||k(}|s�tjd
|fd||f�dtj�vstj|�rtj|�ndtj|�d
�z}tjd|���dzd|iz}ttj |���dx}}y)z:Test para works with Pattern[Subject] (not PatternSubject)�alice�Person�ager>)�identity�labels�
properties�bob�c�\�|jjd�rdnd}|t|�zS)zCount how many Person subjectsr�r-r)r�	has_labelr	)r�counts�counts   r
�count_peoplez3test_para_with_subject_values.<locals>.count_people�s)���W�W�&�&�x�0��a���s�6�{�"�"rr.rrrrzExpected 2 people, got rrN)r�Subject�Value�intrr4rrrrrr r!r"r#r$r%)	r�r�r4r�rr'r(r)r*s	         r
�test_para_with_subject_valuesr��s��
� � ���z��<�-�-�1�1�"�5�6�
�E��
�
���z��<�-�-�1�1�"�5�6��C��"�"�*�*�5����"�"�3�'�3��G�#�
�\�\�,�
'�F��:�6�Q�;�:�:�:�6�Q�:�:�:�:�:�:�6�:�:�:�6�:�:�:�Q�:�:�:�1�&��:�:�:�:�:�:�:r�__main__u"✓ All paramorphism tests passed!)�__doc__�builtinsr�_pytest.assertion.rewrite�	assertion�rewriterrr+r6r;rNrbr�r�r��__name__�printrCrr
�<module>r�s�������4�
4� 6�2B�*$F�N!:�H �F;�:�z����������� �1�3�)�+�!�#�	�
.�/�r