OwlCyberSecurity - MANAGER
Edit File: versionpredicate.cpython-311.opt-1.pyc
� �����/�g ���������������������������d�Z�ddlZddlZddlZ�ej��������dej��������������������Z�ej��������d������������Z�ej��������d������������Z d��Z ej��������ej��������ej ��������ej��������ej��������ej��������d�Z�G�d��d ������������Zdad ��ZdS�)zBModule for parsing and testing package version predicate strings. �����Nz'(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)z^\s*\((.*)\)\s*$z%^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$c������������������������t��������������������������������|�������������}|st����������d|�z���������������|�����������������������������������\��}}|t����������j�����������������������������|������������fS�)zVParse a single version comparison. Return (comparison string, StrictVersion) z"bad package restriction syntax: %r)�re_splitComparison�match� ValueError�groups� distutils�version� StrictVersion)�pred�res�comp�verStrs��� �A/opt/alt/python311/lib64/python3.11/distutils/versionpredicate.py�splitUpr������sa������ �� "� "�4� (� (�C���F��=��D�E�E�E��:�:�<�<�L�D�&��)�#�1�1�&�9�9�:�:�����)�<z<=z==�>z>=z!=c��������������������$�����e�Zd�ZdZd��Zd��Zd��ZdS�)�VersionPredicatea���Parse and test package version predicates. >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)') The `name` attribute provides the full dotted name that is given:: >>> v.name 'pyepat.abc' The str() of a `VersionPredicate` provides a normalized human-readable version of the expression:: >>> print(v) pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3) The `satisfied_by()` method can be used to determine with a given version number is included in the set described by the version restrictions:: >>> v.satisfied_by('1.1') True >>> v.satisfied_by('1.4') True >>> v.satisfied_by('1.0') False >>> v.satisfied_by('4444.4') False >>> v.satisfied_by('1555.1b3') False `VersionPredicate` is flexible in accepting extra whitespace:: >>> v = VersionPredicate(' pat( == 0.1 ) ') >>> v.name 'pat' >>> v.satisfied_by('0.1') True >>> v.satisfied_by('0.2') False If any version numbers passed in do not conform to the restrictions of `StrictVersion`, a `ValueError` is raised:: >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)') Traceback (most recent call last): ... ValueError: invalid version number '1.2zb3' It the module or package name given does not conform to what's allowed as a legal module or package name, `ValueError` is raised:: >>> v = VersionPredicate('foo-bar') Traceback (most recent call last): ... ValueError: expected parenthesized list: '-bar' >>> v = VersionPredicate('foo bar (12.21)') Traceback (most recent call last): ... ValueError: expected parenthesized list: 'bar (12.21)' c������������������,����|������������������������������������}|st����������d�������������t�������������������������������|������������}|st����������d|z���������������|�����������������������������������\��|�_��������}|������������������������������������}|r�t�������������������������������|������������}|st����������d|z���������������|�����������������������������������d���������}d��|���������������������d������������D���������������|�_��������|�j��������st����������d|z���������������dS�g�|�_��������dS�) z*Parse a version predicate string. zempty package restrictionzbad package name in %rzexpected parenthesized list: %rr���c������������������,�����g�|�]}t����������|��������������S���)r���)�.0�aPreds��� r���� <listcomp>z-VersionPredicate.__init__.<locals>.<listcomp>t���s������D�D�D�E�����D�D�Dr����,zempty parenthesized list in %rN) �stripr����re_validPackager���r����name�re_paren�splitr���)�self�versionPredicateStrr����paren�strs��� r����__init__zVersionPredicate.__init__`���s%������2�7�7�9�9��"�� :��8�9�9�9��%�%�&9�:�:���� M��5�8K�K�L�L�L� �<�<�>�>��� �5���� � ���� ��N�N�5�)�)�E��� L� �!B�U�!J�K�K�K��,�,�.�.��#�C�D�D�S�Y�Y�s�^�^�D�D�D�D�I��9�� 8� �!A�#6�"7��8��8��8� 8�� 8���D�I�I�Ir���c�����������������������|�j���������r4d��|�j���������D���������������}|�j��������dz���d���������������������|������������z���dz���S�|�j��������S�)Nc������������������>�����g�|�]\��}}|d�z���t����������|������������z�����S�)� )r%���)r����cond�vers��� r���r���z,VersionPredicate.__str__.<locals>.<listcomp>}���s+������D�D�D�Y�T�3�4�#�:��C���(�D�D�Dr���z (z, �))r���r����join)r"����seqs��� r����__str__zVersionPredicate.__str__{���sJ�������9�� �D�D�$�)�D�D�D�C��9�t�#�d�i�i��n�n�4�s�:�:��9�r���c������������������R�����|�j���������D�]\��}}t����������|���������||������������s�dS��dS�)z�True if version is compatible with all the predicates in self. The parameter version must be acceptable to the StrictVersion constructor. It may be either a string or StrictVersion. FT)r����compmap)r"���r ���r*���r+���s��� r����satisfied_byzVersionPredicate.satisfied_by����s@������ ���� �� �I�D�#��4�=��#�.�.�� ��u�u� ��tr���N)�__name__� __module__�__qualname__�__doc__r&���r/���r2���r���r���r���r���r������sL��������������>��>�@�����6�������������r���r���c������������������p����t������������t����������j��������dt����������j��������������������a�|������������������������������������}�t��������������������������������|�������������}|st ����������d|�z���������������|���������������������d������������pd}|rt����������j ��������� ��������������������|������������}|���������������������d������������|fS�)a9��Return the name and optional version number of a provision. The version number, if given, will be returned as a `StrictVersion` instance, otherwise it will be `None`. >>> split_provision('mypkg') ('mypkg', None) >>> split_provision(' mypkg( 1.2 ) ') ('mypkg', StrictVersion ('1.2')) Nz=([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$z"illegal provides specification: %r��������)� _provision_rx�re�compile�ASCIIr���r���r����groupr���r ���r ���)�value�mr+���s��� r����split_provisionrA�������s����������� �L��H���� �� �K�K�M�M�E����E�"�"�A���G��=��E�F�F�F� �'�'�!�*�*� ��C� ��3���-�-�c�2�2���7�7�1�:�:�s�?�r���)r6���r;����distutils.versionr����operatorr<���r=���r���r ���r���r����lt�le�eq�gt�ge�ner1���r���r:���rA���r���r���r����<module>rJ������s���������� � � � ����������������"�*�G��H�������2�:�)�*�*���R�Z� H�I�I��� ;�� ;�� ;����8�;�h�k���8�;�h�k�C��C��k��k��k��k��k��k��k��k�\�� ���������r���