403Webshell
Server IP : 54.37.205.81  /  Your IP : 216.73.216.76
Web Server : nginx/1.22.1
System : Linux vps-249481fa 6.1.0-50-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.176-1 (2026-07-02) x86_64
User : debian ( 1000)
PHP Version : 8.2.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : OFF
Directory :  /lib/python3/dist-packages/nltk/ccg/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/nltk/ccg/__pycache__/chart.cpython-311.pyc
�

 T�cc5��~�dZddlZddlTddlmZmZmZmZmZmZm	Z	m
Z
mZddlm
Z
mZddlTddlmZddlmZmZmZddlTddlmZGd	�d
e��ZGd�de��ZGd
�de��ZGd�de��ZGd�de��Zee��ee��gZee	��ee��ee��gZee
��ee��gZ e��e��gZ!eeze ze!zZ"Gd�de��Z#Gd�de��Z$d�Z%d�Z&d�Z'ed��Z(d�Z)e*dkre)��dSdS)aB
The lexicon is constructed by calling
``lexicon.fromstring(<lexicon string>)``.

In order to construct a parser, you also need a rule set.
The standard English rules are provided in chart as
``chart.DefaultRuleSet``.

The parser can then be constructed by calling, for example:
``parser = chart.CCGChartParser(<lexicon>, <ruleset>)``

Parsing is then performed by running
``parser.parse(<sentence>.split())``.

While this returns a list of trees, the default representation
of the produced trees is not very enlightening, particularly
given that it uses the same tree class as the CFG parsers.
It is probably better to call:
``chart.printCCGDerivation(<parse tree extracted from list>)``
which should print a nice representation of the derivation.

This entire process is shown far more clearly in the demonstration:
python chart.py
�N)�*)	�BackwardApplication�
BackwardBx�BackwardComposition�
BackwardSx�	BackwardT�ForwardApplication�ForwardComposition�ForwardSubstitution�ForwardT)�Token�
fromstring)�ParserI)�AbstractChartRule�Chart�EdgeI)�Treec�\�eZdZd�Zd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�ZdS)�CCGEdgec�D�||_||_||_|||f|_dS�N)�_span�_categ�_rule�_comparison_key)�self�span�categ�rules    �0/usr/lib/python3/dist-packages/nltk/ccg/chart.py�__init__zCCGEdge.__init__;s,����
������
� $�e�T�2�����c��|jSr�r�rs r �lhszCCGEdge.lhsB�
���{�r"c��|jSr�rr%s r rzCCGEdge.spanE�
���z�r"c��|jdS�Nrr)r%s r �startz
CCGEdge.startH����z�!�}�r"c��|jdS�N�r)r%s r �endzCCGEdge.endKr.r"c�8�|jd|jdz
S)Nr1r)rrr%s r �lengthzCCGEdge.lengthNs���z�!�}�t�y��|�+�+r"c��dS)N�r6r%s r �rhszCCGEdge.rhsQs���rr"c��dSr,r6r%s r �dotzCCGEdge.dotT����qr"c��dS�NTr6r%s r �is_completezCCGEdge.is_completeW����tr"c��dS�NFr6r%s r �
is_incompletezCCGEdge.is_incompleteZ����ur"c��dSrr6r%s r �nextsymzCCGEdge.nextsym]r>r"c��|jSrr$r%s r rz
CCGEdge.categ`r'r"c��|jSr)rr%s r rzCCGEdge.rulecr*r"N)�__name__�
__module__�__qualname__r!r&rr-r2r4r7r9r=rArDrrr6r"r rr:s�������3�3�3�������������,�,�,�����������������������r"rc�f�eZdZdZd�Zd�Zd�Zd�Zd�Zd�Z	d�Z
d	�Zd
�Zd�Z
d�Zd
�Zd�Zd�ZdS)�CCGLeafEdgez<
    Class representing leaf edges in a CCG derivation.
    c�h�||_||_||_||���|f|_dSr)�_pos�_token�_leafrr)r�pos�token�leafs    r r!zCCGLeafEdge.__init__ls4����	������
� #�U�[�[�]�]�D�9����r"c�4�|j���Sr�rNrr%s r r&zCCGLeafEdge.lhss����{� � �"�"�"r"c�$�|j|jdzfSr0�rMr%s r rzCCGLeafEdge.spanvs���	�4�9�q�=�)�)r"c��|jSrrWr%s r r-zCCGLeafEdge.startys
���y�r"c��|jdzSr0rWr%s r r2zCCGLeafEdge.end|s���y�1�}�r"c��dSr0r6r%s r r4zCCGLeafEdge.lengthr:r"c��|jSr�rOr%s r r7zCCGLeafEdge.rhs�r*r"c��dSr,r6r%s r r9zCCGLeafEdge.dot�r:r"c��dSr<r6r%s r r=zCCGLeafEdge.is_complete�r>r"c��dSr@r6r%s r rAzCCGLeafEdge.is_incomplete�rBr"c��dSrr6r%s r rDzCCGLeafEdge.nextsym�r>r"c��|jSr)rNr%s r rQzCCGLeafEdge.token�r'r"c�4�|j���SrrTr%s r rzCCGLeafEdge.categ�rUr"c��|jSrr\r%s r rRzCCGLeafEdge.leaf�r*r"N)rGrHrI�__doc__r!r&rr-r2r4r7r9r=rArDrQrrRr6r"r rKrKgs���������:�:�:�#�#�#�*�*�*����������������������������#�#�#�����r"rKc�(�eZdZdZdZd�Zd�Zd�ZdS)�BinaryCombinatorRulezw
    Class implementing application of a binary combinator to a chart.
    Takes the directed combinator to apply.
    �c��||_dSr��_combinator)r�
combinators  r r!zBinaryCombinatorRule.__init__�s��%����r"c#�K�|���|���ksdS|j�|���|�����r�|j�|���|�����D]]}t
|���|���f||j���}|�|||f��r|V��\dSdS�N)rrr)r2r-rj�can_combiner�combiner�insert�r�chart�grammar�	left_edge�
right_edge�res�new_edges       r �applyzBinaryCombinatorRule.apply�s	�����
�
���:�#3�#3�#5�#5�5�5��F���'�'�	���(9�(9�:�;K�;K�;M�;M�N�N�	#��'�/�/�	���0A�0A�:�CS�CS�CU�CU�V�V�
#�
#��"�#�/�/�+�+�Z�^�^�-=�-=�>���)�����
�<�<��9�j�*A�B�B�#�"�N�N�N��	#�	#�
#�
#r"c��d|jzS�N�%srir%s r �__str__zBinaryCombinatorRule.__str__�����d�&�&�&r"N�rGrHrIrd�NUMEDGESr!rxr|r6r"r rfrf�sR��������
�H�&�&�&�#�#�#�$'�'�'�'�'r"rfc�(�eZdZdZdZd�Zd�Zd�ZdS)�ForwardTypeRaiseRulez1
    Class for applying forward type raising
    rgc��t|_dSr)rrjr%s r r!zForwardTypeRaiseRule.__init__�s��#����r"c#�nK�|���|���ksdS|j�|���|�����D]F}t|���||j���}|�||f��r|V��GdSrm�r2r-rjrorrrrprqs       r rxzForwardTypeRaiseRule.apply�s������
�
���:�#3�#3�#5�#5�5�5��F��#�+�+�I�O�O�,=�,=�z�?O�?O�?Q�?Q�R�R�	�	�C��I�N�N�$4�$4�C�d�FV�W�W�W�H��|�|�H�y�l�3�3�
������	�	r"c��d|jzSrzrir%s r r|zForwardTypeRaiseRule.__str__�r}r"Nr~r6r"r r�r��sR���������H�$�$�$����'�'�'�'�'r"r�c�(�eZdZdZdZd�Zd�Zd�ZdS)�BackwardTypeRaiseRulez3
    Class for applying backward type raising.
    rgc��t|_dSr)rrjr%s r r!zBackwardTypeRaiseRule.__init__�s��$����r"c#�nK�|���|���ksdS|j�|���|�����D]F}t|���||j���}|�||f��r|V��GdSrmr�rqs       r rxzBackwardTypeRaiseRule.apply�s������
�
���:�#3�#3�#5�#5�5�5��F��#�+�+�I�O�O�,=�,=�z�?O�?O�?Q�?Q�R�R�	�	�C��J�O�O�$5�$5�S�t�GW�X�X�X�H��|�|�H�z�m�4�4�
������	�	r"c��d|jzSrzrir%s r r|zBackwardTypeRaiseRule.__str__�r}r"Nr~r6r"r r�r��sR���������H�%�%�%����'�'�'�'�'r"r�c�&�eZdZdZdd�Zd�Zd�ZdS)�CCGChartParserzV
    Chart parser for CCGs.
    Based largely on the ChartParser class from NLTK.
    rc�0�||_||_||_dSr)�_lexicon�_rules�_trace)r�lexicon�rules�traces    r r!zCCGChartParser.__init__s����
��������r"c��|jSr)r�r%s r r�zCCGChartParser.lexicons
���}�r"c�n�t|��}tt|����}|j}t|�����D]g}|�|�|����D]<}t|||�|����}|�|d���=�htd|���dz��D]�}td|���|z
dz��D]�}td|��D]p}	|}
||	z}||z}|�	|
|f���D]I}
|�	||f���D].}|j
D]$}d}|�|||
|��D]}|dz
}��%�/�J�q����|�|�
����S)Nr6rgr1r)r)�list�CCGChartr��range�
num_leaves�
categoriesrRrKrp�selectr�rx�parsesr-)r�tokensrr�lex�indexrQrwrr-�part�lstart�mid�rend�left�rightr�edges_added_by_rule�newedges                  r �parsezCCGChartParser.parses����f������f���&�&���m���5�+�+�-�-�.�.�	+�	+�E�����
�
�5�(9�(9�:�:�
+�
+��&�u�e�U�Z�Z��5F�5F�G�G�����X�r�*�*�*�*�
+�
�!�U�-�-�/�/�!�3�4�4�	=�	=�D��q�%�"2�"2�"4�"4�t�";�a�"?�@�@�
=�
=��"�!�T�N�N�=�=�D�"�F��$�,�C� �4�<�D� %���6�3�-�� @� @�=�=��%*�\�\��T�{�\�%C�%C�=�=�E�(,��=�=��67� 3�/3�z�z�%��d�E�/R�/R�!=�!=�G�$7�1�$<�$7�$7�!=�=�=�=�=�
=�"�|�|�C�I�I�K�K�(�(�(r"N)r)rGrHrIrdr!r�r�r6r"r r�r�sP��������
����
���)�)�)�)�)r"r�c��eZdZd�Zd�ZdS)r�c�0�tj||��dSr)rr!)rr�s  r r!zCCGChart.__init__6s��
��t�V�$�$�$�$�$r"c
�������s
Jd���|�vr�|St|t��rf�|����j|���g��}�|���df|g��}|g�|<|gSg�|<g}��|��D]�}����fd�|D��}	t
j|	�D]�}
t�j|���|�	���|�
��t|
|����t|�
����f}|��||
��������|�|<|S)Nz&CCGChart cannot build incomplete trees�Leafc�@��g|]}��|�������Sr6)�_trees)�.0�cp�complete�memor�
tree_classs  ����r �
<listcomp>z#CCGChart._trees.<locals>.<listcomp>Ls+���W�W�W�R�T�[�[��X�t�Z�H�H�W�W�Wr")�
isinstancerKrQ�_tokensr-�child_pointer_lists�	itertools�productr
r2r&�compute_semantics�strr�append)r�edger�r�r��wordrR�trees�cpl�
child_choices�childrenr&s` ```       r r�zCCGChart._trees<s��������A�A�A�A�A�A��4�<�<���:���d�K�(�(�	��:�d�j�j�l�l�T�\�$�*�*�,�,�-G�,H�I�I�D��:�t�z�z�|�|�V�4�t�f�=�=�D���D��J��6�M���T�
����+�+�D�1�1�	8�	8�C�W�W�W�W�W�W�W�SV�W�W�W�M�%�-�}�=�	
8�	
8�����T�Z�Z�\�\�D�H�H�J�J�%>�?����
�
�)�(�D�9�9���
��	�	���$�$�
�����Z�Z��X�6�6�7�7�7�7�	
8���T�
��r"N)rGrHrIr!r�r6r"r r�r�5s2������%�%�%�����r"r�c��|d���d����dSt|��dk�r8t|���t
��r|d|dg}|���j}|d���d���}|d���d���}t|t��rt||��St|t��rt||��St|t��rt||��Std|zdz���t|d���d�����S)Nrrgr1zUnsupported combinator '�')�label�	semantics�lenr�r�BackwardCombinatorrj�UndirectedFunctionApplication�compute_function_semantics�UndirectedComposition�compute_composition_semantics�UndirectedSubstitution�compute_substitution_semantics�AssertionError�compute_type_raised_semantics)r�r�rk�function�arguments     r r�r�\s|����{�����1��'�'�)�)�1��t�
�8�}�}�����d�i�i�k�k�#5�6�6�	2� ���X�a�[�1�H��Y�Y�[�[�,�
��A�;�$�$�&�&�q�)�3�3�5�5���A�;�$�$�&�&�q�)�3�3�5�5���j�"?�@�@�	P�-�h��A�A�A�
�
�$9�
:�
:�	P�0��8�D�D�D�
�
�$:�
;�
;�	P�1�(�H�E�E�E� �!;�j�!H�3�!N�O�O�O�,�X�a�[�->�->�-@�-@��-C�-M�-M�-O�-O�P�P�Pr"c�F�|���}d}d}|D]�\}}d|z}dtt|��t|����z}|t|��z
dz}||t|��z
dzz}	|d|z|zd|	zzz
}|t|��z
dz}
|
|t|��z
dzz}|d|
z|zd|zzz
}��t|�����t|�����td|��dS)N�r{rg� r)rP�maxr��print�rstrip�printCCGTree)�tree�leafcats�leafstr�catstrrR�cat�str_cat�nextlen�lcatlen�rcatlen�lleaflen�rleaflens            r �printCCGDerivationr�ws5���x�x�z�z�H��G�
�F� �:�:���s���*���c�#�d�)�)�S��\�\�2�2�2���S��\�\�)�a�/���W�s�7�|�|�3�q�8�8���#��-�'�)�C�'�M�9�9���c�$�i�i�'�A�-���w��T���2�a�7�7���3��>�D�(�3��>�9�9���	�'�.�.�
�
����	�&�-�-�/�/������D�����r"c	� �|}t|t��sd|zt|��zS|D] }t|t	||����}�!t|���t��sRt|d|ztd|���z��zd|zt|d��z��S|���\}}|dkr|St|dz||z
dzzd|zz��d|���z}|�	���*|dt|�	����zdzz
}||z
t|��z
dz|z}t|dz|z��|S)	Nrgr{rr�r��-z {�})r�rr�r�r�r��tupler�rr�r�)�lwidthr��rwidth�childrQ�op�str_res�	respadlens        r r�r��s���
�F��d�D�!�!�&��6�z�C��I�I�%�%��:�:���V�\�&�%�8�8�9�9����d�j�j�l�l�E�*�*�
���A��J��T�D�J�J�L�L�%8�!9�!9�9�1�v�:��D�QR�G���;T�
�
�	
��*�*�,�,�K�U�B�	�V�|�|��
�
�&�3�,�&�6�/�S�0�
0�4�"�9�
<�=�=�=��e�k�k�m�m�$�G������$��4�#�e�o�o�/�/�0�0�0�3�6�6���&��3�w�<�<�/�A�5��>�I�	�)�c�/�G�
#�$�$�$��Mr"ar
    :- S, NP, N, VP    # Primitive categories, S is the target primitive

    Det :: NP/N         # Family of words
    Pro :: NP
    TV :: VP/NP
    Modal :: (S\NP)/VP # Backslashes need to be escaped

    I => Pro             # Word -> Category mapping
    you => Pro

    the => Det

    # Variables have the special keyword 'var'
    # '.' prevents permutation
    # ',' prevents composition
    and => var\.,var/.,var

    which => (N\N)/(S/NP)

    will => Modal # Categories can be either explicit, or families.
    might => Modal

    cook => TV
    eat => TV

    mushrooms => N
    parsnips => N
    bacon => N
    c��ttt��}|�d�����D]}t|���dS)NzI might cook and eat the bacon)r�r��DefaultRuleSetr��splitr�)�parserr�s  r �demor��sT��
�C��
0�
0�F����>�D�D�F�F�G�G�"�"���5�!�!�!�!�"�"r"�__main__)+rdr��nltk.ccg.combinatorrrrrrr	r
rr�nltk.ccg.lexiconr
r�nltk.ccg.logic�
nltk.parser�nltk.parse.chartrrr�nltk.sem.logic�	nltk.treerrrKrfr�r��ApplicationRuleSet�CompositionRuleSet�SubstitutionRuleSet�TypeRaiseRuleSetr�r�r�r�r�r�r�r�rGr6r"r �<module>rsw����2����!�!�!�!�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�
�/�.�.�.�.�.�.�.�����������<�<�<�<�<�<�<�<�<�<�����������*�*�*�*�*�e�*�*�*�Z1�1�1�1�1�%�1�1�1�h'�'�'�'�'�,�'�'�'�L'�'�'�'�'�,�'�'�'�.'�'�'�'�'�-�'�'�'�2��+�,�,���,�-�-���
��+�,�,���,�-�-����$�$�����,�-�-����$�$���)�(�*�*�,A�,A�,C�,C�D���+�+�.A�A�DT�T��
-)�-)�-)�-)�-)�W�-)�-)�-)�`$�$�$�$�$�u�$�$�$�NQ�Q�Q�6���2!�!�!�N�j�����D"�"�"��z����D�F�F�F�F�F��r"

Youez - 2016 - github.com/yon3zu
LinuXploit