%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /lib/python3/dist-packages/setuptools/config/__pycache__/
Upload File :
Create Path :
Current File : //lib/python3/dist-packages/setuptools/config/__pycache__/setupcfg.cpython-312.pyc

�


_�dHf���dZddlZddlZddlZddlmZddlmZddlmZddlm	Z	m
Z
mZmZm
Z
mZmZmZmZmZmZmZddlmZmZdd	lmZdd
lmZmZddlmZddl m!Z!m"Z"dd
l#m$Z$ddl%m&Z&e	rddl'm(Z(ddl)m*Z*ee+ejXfZ-ededeffZ.	ede.fZ/eded��Z0	d8de-de1fd�Z2ddde-ddfd�Z3		d9ddde-dee-de4dedf
d�Z5d e0d!e+fd"�Z6d#edde1fd$�Z7	d:d%dd&e/ded'fd(�Z8d)e+d*e+d+e9fd,�Z:Gd-�d.e
e0�Z;Gd/�d0e;d1�Z<Gd2�d3e;d�Z=Gd4�d5e$�Z>Gd6�d7e$�Z?y);a<
Load setuptools configuration from ``setup.cfg`` files.

**API will be made private in the future**

To read project metadata, consider using
``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
For simple scenarios, you can also try parsing the file directly
with the help of ``configparser``.
�N)�defaultdict)�partial��wraps)�
TYPE_CHECKING�Callable�Any�Dict�Generic�Iterable�List�Optional�Set�Tuple�TypeVar�Union�)�	FileError�OptionError)�default_environment)�InvalidRequirement�Requirement)�SpecifierSet)�InvalidVersion�Version)�SetuptoolsDeprecationWarning�)�expand)�DistributionMetadata��Distribution�str�Target)r!r)�bound�filepath�returnc�v�ddlm}|�}|r|j�ng}t||||�}t	|�S)a,Read given configuration file and returns options from it as a dict.

    :param str|unicode filepath: Path to configuration file
        to get options from.

    :param bool find_others: Whether to search for other configuration files
        which could be on in various places.

    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.

    :rtype: dict
    rr )�setuptools.distr!�find_config_files�_apply�configuration_to_dict)r%�find_others�ignore_option_errorsr!�dist�	filenames�handlerss       �</usr/lib/python3/dist-packages/setuptools/config/setupcfg.py�read_configurationr28s<��$-��>�D�,7��&�&�(�R�I��d�H�i�1E�F�H� ��*�*�r.r!c�>�t||�|j�|S)z`Apply the configuration from a ``setup.cfg`` file into an existing
    distribution object.
    )r*�_finalize_requires)r.r%s  r1�apply_configurationr6Rs���4��������Kr3�other_filesr-)�
ConfigHandler.c��ddlm}tjj	|�}tjj|�st
d|�d���tj�}tjtjj|��g|�|�}	|j||��t||j|��}|j�tj|�|S#tj|�wxYw)zHRead configuration from ``filepath`` and applies to the ``dist`` object.r)�
_DistributionzConfiguration file z does not exist.)r/)r-)r(r:�os�path�abspath�isfiler�getcwd�chdir�dirname�parse_config_files�parse_configuration�command_options�_finalize_license_files)r.r%r7r-r:�current_directoryr/r0s        r1r*r*[s���.��w�w���x�(�H�
�7�7�>�>�(�#��-�h�Z�7G�H�I�I��	�	����H�H�R�W�W�_�_�X�
&�'�(�+�(�x�(�I�$��(�(���(�C�&��$�&�&�=Q�
��	
�$�$�&�
���"�#��O��	���"�#�s�!;C3�3D
�
target_obj�keyc�j�d|��}tjt||�}t|||�}|�S)z�
    Given a target object and option key, get that option from
    the target object, either through a get_{key} method or
    from an attribute directly.
    �get_)�	functoolsr�getattr)rGrH�getter_name�by_attribute�getters     r1�_get_optionrPys8�����,�K��$�$�W�j�#�>�L�
�Z��l�
;�F��8�Or3r0c��tt�}|D];}|jD]*}t|j|�}|||j
|<�,�=|S)z�Returns configuration data gathered by given handlers as a dict.

    :param list[ConfigHandler] handlers: Handlers list,
        usually from parse_configuration()

    :rtype: dict
    )r�dict�set_optionsrPrG�section_prefix)r0�config_dict�handler�option�values     r1r+r+�se��$�D�)�K��@���)�)�	@�F��� 2� 2�F�;�E�:?�K��.�.�/��7�	@�@�
�r3�distributionrD)�ConfigMetadataHandler�ConfigOptionsHandlerc	��tj|�5}t||||�}|j�|js|j|_t|j||||j|j�}|j�|jj|j|j�ddd�||fS#1swYfSxYw)a�Performs additional parsing of configuration options
    for a distribution.

    Returns a list of used option handlers.

    :param Distribution distribution:
    :param dict command_options:
    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.
    :rtype: list
    N)
r�EnsurePackagesDiscoveredr[�parse�package_dirrZ�metadata�src_root�_referenced_files�update)rYrDr-�ensure_discovered�options�metas      r1rCrC�s���$
�	(�	(��	6�
�:K�&��� ��	
��	�
�
���'�'�'.�':�':�L�$�$��!�!�� ���$�$��!�!�

��	
�
�
���&�&�-�-��%�%�t�'=�'=�	
�+
�2��=��3
�2��=��s�B*C�C�label�
orig_value�parsedc�l��d|vst��dk7ryt�j�}	t�d�}|j|vrt
j
|�d��yy#t$rD}t�fd�|D��r&t
j|�d��}t|�|�Yd}~yd}~wwxYw)amBecause users sometimes misinterpret this configuration:

    [options.extras_require]
    foo = bar;python_version<"4"

    It looks like one requirement with an environment marker
    but because there is no newline, it's parsed as two requirements
    with a semicolon as separator.

    Therefore, if:
        * input string does not contain a newline AND
        * parsed result contains two requirements AND
        * parsing of the two parts from the result ("<first>;<second>")
        leads in a valid Requirement with a valid marker
    a UserWarning is shown to inform the user about the possible problem.
    �
rNr)�field�reqc3�F�K�|]}�dj|����y�w)rN)�
startswith)�.0�markerris  �r1�	<genexpr>z8_warn_accidental_env_marker_misconfig.<locals>.<genexpr>�s �����B��v�a�y�#�#�F�+�B�s�!)
�len�
marker_env�keysr�name�_AmbiguousMarker�emitr�any�message)rgrhri�markersrm�ex�msgs  `    r1�%_warn_accidental_env_marker_misconfigr~�s����"�z��S��[�A�-���l���!�G�2��&��)�$���8�8�w���!�!��6�!�9�!�=����2��B�'�B�B�"�*�*��F�1�I�*�F�C�$�S�)�r�1�C��2�s�6A&�&	B3�/:B.�.B3c�*�eZdZUdZeed<	iZeeefed<	dede	de
jfd�Ze
de	fd��Zed	��Zd
�Ze
dd��Ze
d��Ze
d
��Ze
d��Zdefd�Zdefd�Ze
d��Ze
d��Ze
dd��Zd�Zd�Zd�Zy)r8z1Handles metadata supplied in configuration files.rT�aliasesrGrerdc��||_||_t|j|��|_g|_||_t�|_y�N)	r-rGrR�_section_options�sectionsrSrd�setrb)�selfrGrer-rds     r1�__init__zConfigHandler.__init__�sI��%9��!�$����T�2�2�7�;�<��
�&(���!2���+.�5���	r3c#�K�|j�D]<\}}|j|j�\}}}|r�(|jd�|f���>y�w)N�.)�items�	partitionrT�lstrip)�clsre�	full_namerX�pre�seprvs       r1r�zConfigHandler._section_optionssV���� '�
�
��	*��I�u�&�0�0��1C�1C�D�N�C��d����+�+�c�"�E�)�)�		*�s�AAc�F�td|jjz��)�.Metadata item name to parser function mapping.z!%s must provide .parsers property)�NotImplementedError�	__class__�__name__)r�s r1�parserszConfigHandler.parserss#��"�/�$�.�.�2I�2I�I�
�	
r3c���|j}|jj||�}	t||�}|ry	|jj|d��|�}tj|j|�}t|d|z|�}||�|jj|�y#t$rt|��wxYw#tf|jz$rYywxYw)Nc��|Sr��)�xs r1�<lambda>z+ConfigHandler.__setitem__.<locals>.<lambda>%s��Q�r3zset_%s)rGr��getrL�AttributeError�KeyErrorr��	Exceptionr-rKr�__setattr__rS�append)r��option_namerXrG�
current_valueri�
simple_setter�setters        r1�__setitem__zConfigHandler.__setitem__s����_�_�
��l�l�&�&�{�K�@��	(�#�J��<�M���	�?�T�\�\�%�%�k�;�?��F�F�"�)�)�*�*@�*@�+�N�
���X��%;�]�K���v��������,��!�	(��;�'�'�	(���|�d�7�7�7�	��	�s�B1�#C	�1C�	C#�"C#c���t|t�r|Sd|vr|j�}n|j|�}|D�cgc]#}|j	�s�|j	���%c}Scc}w)z�Represents value as a list.

        Value is split either by separator (defaults to comma) or by lines.

        :param value:
        :param separator: List items separator character.
        :rtype: list
        rk)�
isinstance�list�
splitlines�split�strip)r�rX�	separator�chunks    r1�_parse_listzConfigHandler._parse_list/sX���e�T�"��L��5�=��$�$�&�E��K�K�	�*�E�+0�B�%�E�K�K�M����
�B�B��Bs�A(�A(c���d}i}|j|�D]K}|j|�\}}}||k7rtd|����|j�||j�<�M|S)zPRepresents value as a dict.

        :param value:
        :rtype: dict
        �=z&Unable to parse option value to dict: )r�r�rr�)r�rXr��result�linerHr��vals        r1�_parse_dictzConfigHandler._parse_dictCsr���	����O�O�E�*�	.�D� �N�N�9�5�M�C��c��i��!�$J�5�'�"R�S�S�"%�)�)�+�F�3�9�9�;��		.��
r3c�*�|j�}|dvS)zQRepresents value as boolean.

        :param value:
        :rtype: bool
        )�1�true�yes)�lower�r�rXs  r1�_parse_boolzConfigHandler._parse_boolTs�����
���,�,�,r3c����fd�}|S)z�Returns a parser function to make sure field inputs
        are not files.

        Parses a value after getting the key so error messages are
        more informative.

        :param key:
        :rtype: callable
        c�b��d}|j|�rtdj����|S)N�file:zCOnly strings are accepted for the {0} field, files are not accepted)ro�
ValueError�format)rX�exclude_directiverHs  �r1�parserz3ConfigHandler._exclude_files_parser.<locals>.parserjs:��� '����� 1�2� �-�-3�V�C�[����Lr3r�)r�rHr�s ` r1�_exclude_files_parserz#ConfigHandler._exclude_files_parser^s���	��
r3�root_dirc�0�d}t|t�s|S|j|�s|S|t|�d}|j	d�D�cgc]}|j���}}|jj|�tj||�Scc}w)aORepresents value as a string, allowing including text
        from nearest files using `file:` directive.

        Directive is sandboxed and won't reach anything outside
        directory with setup.py.

        Examples:
            file: README.rst, CHANGELOG.md, src/file.txt

        :param str value:
        :rtype: str
        r�N�,)
r�r"rorsr�r�rbrcr�
read_files)r�rXr��include_directive�specr<�	filepathss       r1�_parse_filezConfigHandler._parse_fileus���$���%��%��L���� 1�2��L��S�*�+�-�.��.2�j�j��o�>�d�T�Z�Z�\�>�	�>����%�%�i�0�� � ��H�5�5��?s�	Bc���d}|j|�s|S|j|d�}|j|jj�tj|||�S)z�Represents value as a module attribute.

        Examples:
            attr: package.attr
            attr: package.module.attr

        :param str value:
        :rtype: str
        zattr:�)ro�replacercrdr_r�	read_attr)r�rXr_r��attr_directive�	attr_descs      r1�_parse_attrzConfigHandler._parse_attr�s]��!������/��L��M�M�.�"�5�	�	���4�1�1�=�=�>����	�;��A�Ar3c����fd�}|S)z�Returns parser function to represents value as a list.

        Parses a value applying given methods one after another.

        :param parse_methods:
        :rtype: callable
        c�*��|}�D]
}||�}�|Sr�r�)rXri�method�
parse_methodss   �r1r^z1ConfigHandler._get_parser_compound.<locals>.parse�s'����F�'�
(������
(��Mr3r�)r�r�r^s ` r1�_get_parser_compoundz"ConfigHandler._get_parser_compound�s���	��r3c�X�i}|j�D]\}\}}|||�||<�|S)aParses section options into a dictionary.

        Applies a given parser to each option in a section.

        :param dict section_options:
        :param callable values_parser: function with 2 args corresponding to key, value
        :rtype: dict
        )r�)r��section_options�
values_parserrXrH�_r�s       r1�_parse_section_to_dict_with_keyz-ConfigHandler._parse_section_to_dict_with_key�s>����,�2�2�4�	1�M�C��!�S�&�s�C�0�E�#�J�	1��r3Nc�<���r�fd�nd�}|j||�S)aParses section options into a dictionary.

        Optionally applies a given parser to each value.

        :param dict section_options:
        :param callable values_parser: function with 1 arg corresponding to option value
        :rtype: dict
        c����|�Sr�r�)r��vr�s  �r1r�z6ConfigHandler._parse_section_to_dict.<locals>.<lambda>�s���}�Q�/�r3c��|Sr�r�)r�r�s  r1r�z6ConfigHandler._parse_section_to_dict.<locals>.<lambda>�s��UV�r3�r�)r�r�r�r�s  ` r1�_parse_section_to_dictz$ConfigHandler._parse_section_to_dict�s#���5B�/����2�2�?�F�K�Kr3c��|j�D]/\}\}}tjt�5|||<ddd��1y#1swY�<xYw)zQParses configuration file section.

        :param dict section_options:
        N)r��
contextlib�suppressr�)r�r�rvr�rXs     r1�
parse_sectionzConfigHandler.parse_section�sV��
!0� 5� 5� 7�	#��D�*�1�e��$�$�X�.�
#�"��T�
�
#�
#�	#�
#�
#�s�A�A
	c���|jj�D]T\}}d}|rd|z}t|d|zjdd�d�}|�t	d|j
�d|�d���||��Vy)	zTParses configuration file items from one
        or more related sections.

        r�z_%szparse_section%sr��__Nz*Unsupported distribution option section: [�])r�r�rLr�rrT)r��section_namer��method_postfix�section_parser_methods     r1r^zConfigHandler.parse�s���
.2�]�]�-@�-@�-B�	3�)�L�/��N��!&��!5��8?��"�^�3�<�<�S�$�G��	9�!�%�,�!���+�+�,�A�l�^�1�>���

"�/�2�%	3r3c�6����t�����fd��}|S)z�this function will wrap around parameters that are deprecated

        :param msg: deprecation message
        :param func: function to be wrapped around
        c�f���jdd�tjd�fi����|i|��S)N�
stacklevelrz Deprecated config in `setup.cfg`)�
setdefault�_DeprecatedConfigrx)�args�kwargs�func�kwr}s  ���r1�config_handlerz@ConfigHandler._deprecated_config_handler.<locals>.config_handler�s7����M�M�,��*��"�"�#E�s�Q�b�Q���(��(�(r3r)r�r�r}r�r�s ``` r1�_deprecated_config_handlerz(ConfigHandler._deprecated_config_handler�s#���
�t��	)�
�	)�
�r3)r�r�)r��
__module__�__qualname__�__doc__r"�__annotations__r�r
r#�AllCommandOptionsrr]r��classmethodr��propertyr�r�r�r�r�r��_Pathr�r�r�r�r�r�r^r�r�r3r1r8r8�s>��;����
!�G�T�#�s�(�^� �����#��
"�:�:��"�*�'8�*��*��
��
�-�4�C��C�&���� �-��-�����,6�5�6�4B��B�(����&�����
L��
L�#�3�2
r3r8c
���eZdZdZddddd�ZdZ	dejfd	d
dede	d
e
jdee
def�fd�
Zed��Zd�Z�xZS)rZr`�url�description�classifiers�	platforms)�	home_page�summary�
classifier�platformFNrGrrer-rdr_r�c�F��t�|�||||�||_||_yr�)�superr�r_r�)r�rGrer-rdr_r�r�s       �r1r�zConfigMetadataHandler.__init__s)���	����W�.B�DU�V�&��� ��
r3c�@�|j}t|j|j��}|j}|j
}||||j
|dd��||j||�|d�|j
|d�dd��||||j|d�
S)	r��r�z[The requires parameter is deprecated, please use install_requires for runtime dependencies.)i��
�)�due_date�license�license_filezDThe license_file parameter is deprecated, use license_files instead.)
r�keywords�provides�requires�	obsoletesrrr�
license_filesr�long_description�version�project_urls)	r�rr�r�r�r�r�r��_parse_version)r��
parse_list�
parse_file�
parse_dict�exclude_files_parsers     r1r�zConfigMetadataHandler.parsers#s����%�%�
��T�-�-��
�
�F�
��%�%�
�#�9�9��$�"�"��7�7��=�'�	8��$��4�4�Z��L�+�I�6� �;�;�$�^�4�-�'�	<��(�%� *��*�*�&�3
�	
r3c�0�|j||j�}||k7r|j�}	t|�|St
j|j||j|j��S#t$rtd|�d|����wxYw)zSParses `version` option value.

        :param value:
        :rtype: str

        zVersion loaded from z does not comply with PEP 440: )
r�r�r�rrrrrr�r_)r�rXrs   r1rz$ConfigMetadataHandler._parse_versionGs����"�"�5�$�-�-�8���e���m�m�o�G�
��� ��N��~�~�d�.�.�u�d�6F�6F��
�
�V�W�W��"�
�!�*�5�'�2,�,3�9�6���
�s�A:�:B)r�r�r�rTr��strict_moder;�curdirr��boolrr]rrRrr�r�r�r�
__classcell__�r�s@r1rZrZs�����N�� �#��	�G��K��'+��)�)�!�*�!�#�!�#�	!�
"�:�:�!��d�^�
!��!��!
��!
�FXr3rZrc���eZdZdZdddededejf�fd�Ze	d��Z
d�Zd	ed
efd�Z
ed��Zd
�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Zd�Z�xZS)r[rerGr!r-rdc�Z��t�|�||||�|j|_i|_yr�)rr�rar�r_)r�rGrer-rdr�s     �r1r�zConfigOptionsHandler.__init__ds/���	����W�.B�DU�V�"�+�+��
�+-��r3c�(�|j|d��S)N�;)r�)r�r�s  r1�_parse_list_semicolonz*ConfigOptionsHandler._parse_list_semicolonos�����u���4�4r3c�<�|j||j��S)Nr
)r�r�)r�rXs  r1�_parse_file_in_rootz(ConfigOptionsHandler._parse_file_in_rootss�������
�
��>�>r3rgrXc��|j|j|��}t|||�|D�cgc]}|jd�r�|��c}Scc}w)N�#)r*r,r~ro)r�rgrXrir�s     r1�_parse_requirements_listz-ConfigOptionsHandler._parse_requirements_listvsJ���+�+�D�,D�,D�U�,K�L��-�e�U�F�C�"(�D��t���s�/C��D�D��Ds�A�	Ac�&�|j}|j}|j}|j}|||||||j	|d�t|jd�|j|j|j|j|t|d�S)r�zeThe namespace_packages parameter is deprecated, consider using implicit namespaces instead (PEP 420).�install_requires)�zip_safe�include_package_datar_�scripts�eager_resources�dependency_links�namespace_packagesr1�setup_requires�
tests_require�packages�entry_points�
py_modules�python_requires�cmdclass)r�r�r��_parse_cmdclassr�rr/r*�_parse_packagesr,r)r�r�
parse_boolr�parse_cmdclasss     r1r�zConfigOptionsHandler.parsers~s����%�%�
��%�%�
��%�%�
��-�-��#�$.�%�!�)� *�"&�"A�"A��H�#�!(��-�-�/A�!�#�8�8�!�7�7��,�,� �4�4�$�+�&�-
�	
r3c��|jj}tj|j	|�||j
�Sr�)rdr_rr>r�r�)r�rXr_s   r1r?z$ConfigOptionsHandler._parse_cmdclass�s5���,�,�8�8�����t�/�/��6��T�]�]�S�Sr3c�0�ddg}|j�}||vr|j|�S|j|jj	di��}|j||dk(|j|j��tjdi|��S)zTParses `packages` option value.

        :param value:
        :rtype: list
        zfind:zfind_namespace:z
packages.findr)�
namespacesr��fill_package_dirr�)
r�r��parse_section_packages__findr�r�rcr�r_r�
find_packages)r�rX�find_directives�
trimmed_value�find_kwargss     r1r@z$ConfigOptionsHandler._parse_packages�s���#�$5�6�����
�
���/��#�#�E�*�*��7�7��M�M���o�r�2�
��	���%���);�;��]�]�!�-�-�	�	
��#�#�2�k�2�2r3c���|j||j�}gd�}t|j�D��cgc]\}}||vs�|s�||f��c}}�}|j	d�}|�|d|d<|Scc}}w)z�Parses `packages.find` configuration file section.

        To be used in conjunction with _parse_packages().

        :param dict section_options:
        )�where�include�excluderMr)r�r�rRr�r�)r�r��section_data�
valid_keys�kr�rKrMs        r1rGz1ConfigOptionsHandler.parse_section_packages__find�s����2�2�?�D�DT�DT�U��4�
�� ,� 2� 2� 4�N���1��Z��A�a��V�N�
������(����#(��8�K�� ����
Os�A4
�A4
�	A4
c�F�|j||j�}||d<y)z`Parses `entry_points` configuration file section.

        :param dict section_options:
        r;N)r�r��r�r�ris   r1�parse_section_entry_pointsz/ConfigOptionsHandler.parse_section_entry_points�s&��
�,�,�_�d�>N�>N�O��%��^�r3c�d�|j||j�}tj|�Sr�)r�r�r�canonic_package_data)r�r��package_datas   r1�_parse_package_dataz(ConfigOptionsHandler._parse_package_data�s+���2�2�?�D�DT�DT�U���*�*�<�8�8r3c�,�|j|�|d<y)z`Parses `package_data` configuration file section.

        :param dict section_options:
        rXN�rY�r�r�s  r1�parse_section_package_dataz/ConfigOptionsHandler.parse_section_package_data�s��
 $�7�7��H��^�r3c�,�|j|�|d<y)zhParses `exclude_package_data` configuration file section.

        :param dict section_options:
        �exclude_package_dataNr[r\s  r1�"parse_section_exclude_package_dataz7ConfigOptionsHandler.parse_section_exclude_package_data�s��
(,�'?�'?��'P��
#�$r3c�:���j|�fd��}|�d<y)zbParses `extras_require` configuration file section.

        :param dict section_options:
        c�0���jd|�d�|�S)Nzextras_require[r�)r/)rRr�r�s  �r1r�zCConfigOptionsHandler.parse_section_extras_require.<locals>.<lambda>�s����6�6����1�7M�q�Q�r3�extras_requireNr�rTs`  r1�parse_section_extras_requirez1ConfigOptionsHandler.parse_section_extras_require�s(���
�5�5��Q�
��
"(��
�r3c��|j||j�}tj||j�|d<y)z^Parses `data_files` configuration file section.

        :param dict section_options:
        �
data_filesN)r�r�r�canonic_data_filesr�rTs   r1�parse_section_data_filesz-ConfigOptionsHandler.parse_section_data_files�s7��
�,�,�_�d�>N�>N�O��#�6�6�v�t�}�}�M��\�r3)r�r�r�rTr�r#rr]r�r�r*r,r"r/r�r�r?r@rGrUrYr]r`rdrhr$r%s@r1r[r[as�����N�	.�"�	.�#�	.�#�		.�
"�:�:�	.��5��5�?�E�c�E�#�E��
��
�@T�3�2�*&�9�I�Q�
(�Nr3r[c�(�eZdZdZdZdZed��Zy)rwzAmbiguous requirement marker.z�
    One of the parsed requirements in `{field}` looks like a valid environment marker:

        {req!r}

    Please make sure that the configuration file is correct.
    You can use dangling lines to avoid this problem.
    z'userguide/declarative_config.html#opt-2c�r�d|j��}|j|j|j||��S)Nz%https://setuptools.pypa.io/en/latest/)�see_url�format_args)�	_SEE_DOCS�_format�_SUMMARY�_DETAILS)r�r��docss   r1rzz_AmbiguousMarker.messages2��6�s�}�}�o�F���{�{�3�<�<����t�QS�{�T�Tr3N)r�r�r�rorprmr�rzr�r3r1rwrws+��.�H��H�:�I��U��Ur3rwc��eZdZdZy)r�z!userguide/declarative_config.htmlN)r�r�r�rmr�r3r1r�r�s��3�Ir3r�)FF)r�F)F)@r�r�rKr;�collectionsrrr�typingrrr	r
rrr
rrrrr�errorsrr�extern.packaging.markersrrt�extern.packaging.requirementsrr�extern.packaging.specifiersr�extern.packaging.versionrr�warningsrr�r�distutils.distrr(r!r"�PathLiker�SingleCommandOptionsr�r#rRr2r6r#r*rPr+rCr�r~r8rZr[rwr�r�r3r1�<module>r~s���	���	�#���
�
�
�
�,�H�K�6�>�3���3�,�
�c�2�;�;�����E�5����#4�4�5���
�� 4�4�5��	���'M�!N�	O��>C�+��+�	�+�4�n����.��$&�!&�	�
�����%����	�
�� ��<	�F�	��	��E�*>�$?��D��*�+� �+�&�+��:�;�	+�\2��2�#�2�t�2�@^�G�F�O�^�B	XX�M�*@�A�XX�v\N�=��8�\N�~U�3�U�(4�4�4r3

Zerion Mini Shell 1.0