Файловый менеджер - Редактировать - /opt/imh-python/lib/python3.9/site-packages/version_utils/__pycache__/rpm.cpython-39.pyc
Ðазад
a ]�h�A � @ s� d Z ddlmZmZmZmZ ddlmZ ddlm Z ddl m Z ddl m Z e d�Zee�ZdZd ZdZd&d d �Zd d� Zdd� Zdd� Zd'dd�Zd(dd�Zdd� Zdd� Zdd � Z d d � Z d d � Z d!d"� Z d#d$� Z d%S ))a) rpm module for version_utils Contains RPM parsing and comparison operations for version_utils. Public methods include: * :any:`compare_packages`: compare two RPM package strings, e.g. ``gcc-4.4.7-16.el6.x86_64`` and ``gcc-4.4.7-17.el6.x86_64`` * :any:`compare_versions`: compare two RPM version strings (the bit between the dashes in an RPM package string) * :any:`package`: parse an RPM package string to get name, epoch, version, release, and architecture information. Returns as a :any:`common.Package` object. � )�absolute_import�division�print_function�unicode_literals)� getLogger)�compile)�Package)�RpmErrorz#(\S+)-(?:(\d*):)?(.*)-(~?\w+[\w.]*)� ���Tc C s4 t �d| |� t| |�d }t||�d }t||�S )aD Compare two RPM strings to determine which is newer Parses version information out of RPM package strings of the form returned by the ``rpm -q`` command and compares their versions to determine which is newer. Provided strings *do not* require an architecture at the end, although if providing strings without architecture, the ``arch_provided`` parameter should be set to False. Note that the packages do not have to be the same package (i.e. they do not require the same name or architecture). :param str rpm_str_a: an rpm package string :param str rpm_str_b: an rpm package string :param bool arch_provided: whether package strings contain architecture information :return: 1 (``a`` is newer), 0 (versions are equivalent), or -1 (``b`` is newer) :rtype: int zresolve_versions(%s, %s)�EVR)�logger�debug� parse_package� labelCompare)Z rpm_str_aZ rpm_str_bZ arch_provided�evr_a�evr_b� r ��/root/rpmbuild/BUILDROOT/imh-python39-modules-3.9.7-92.el8.x86_64/opt/imh-python/lib/python3.9/site-packages/version_utils/rpm.py�compare_packages) s r c C sP | \}}}|\}}}||kr,||kr(t S tS t||�}|tkrB|S t||�} | S )a8 Compare two EVR tuples to determine which is newer This method compares the epoch, version, and release of the provided package strings, assuming that epoch is 0 if not provided. Comparison is performed on the epoch, then the version, and then the release. If at any point a non-equality is found, the result is returned without any remaining comparisons being performed (e.g. if the epochs of the packages differ, the versions are releases are not compared). :param tuple evr_a: an EVR tuple :param tuple evr_b: an EVR tuple )�a_newer�b_newer�compare_versions�a_eq_b) r r Za_epochZa_verZa_relZb_epochZb_verZb_relZver_compZrel_compr r r � compare_evrsD s r c C s t | |�S )a� Convenience function to provide the same behaviour as labelCompare from rpm-python. To be used as a drop-in replacement for labelCompare, thus the utilization of the non-standard camelCase variable name. To use the version_utils version and fall back to rpm: try: from version_utils.rpm import labelCompare except ImportError: from rpm import labelCompare :param tuple evr_a: an EVR tuple :param tuple evr_b: an EVR tuple )r )r r r r r r _ s r c C sx t �d| |� | |krtS zt| �t|� }}W n" tyR td�| |���Y n0 t|�dk�r t|�dk�r t �d||� t||� |d dkr�|d dkr�|� d� |� d� qTn |d dkr�t S |d dkr�t S t|�dks�t|�dkr�q t ||�}|tkrT|S qTt|�t|�k�r,t �d� tS t �d� t|�t|�k�r^|d dk�rZt S t S |d dk�rpt S t S dS ) a} Compare two RPM version strings Compares two RPM version strings and returns an integer indicating the result of the comparison. The method of comparison mirrors that used by RPM, so results should be the same for any standard RPM package. To perform the comparison, the strings are first checked for equality. If they are equal, the versions are equal. Otherwise, each string is converted to a character list, and a comparison loop is started using these lists. In the comparison loop, first any non-alphanumeric, non-~ characters are trimmed from the front of the list. Then if the first character from both ``a`` and ``b`` is a ~ (tilde), it is trimmed. The ~ (tilde) character indicates that a given package or version should be considered older (even if it is numerically larger), so if ``a`` begins with a tilde, ``b`` is newer, and vice-versa. At this point, if the length of either list has been reduced to 0, the loop is exited. If characters remain in the list, the :any:`_get_block_result` function is used to pop consecutive digits or letters from the front of hte list and compare them. The result of the block comparison is returned if the blocks are not equal. The loop then begins again. If the loop exits without returning a value, the lengths of the remaining character lists are compared. If they have the same length (usually 0, since all characters have been popped), they are considered to be equal. Otherwise, whichever is longer is considered to be newer, unless it starts with a ~, in which case it is considered be older. Generally, unequal length will be due to one character list having been completely consumed while some characters remain on the other, for example when comparing 1.05b to 1.05. :param unicode version_a: An RPM version or release string :param unicode version_b: An RPM version or release string :return: 1 (if ``a`` is newer), 0 (if versions are equal), or -1 (if ``b`` is newer) :rtype: int :raises RpmError: if an a type is passed that cannot be converted to a list zcompare_versions(%s, %s)z Could not compare {0} to {1}r z starting loop comparing %s to %s�~zversions are equalzversions not equalN) r r r �list� TypeErrorr �format�len�_check_leading�popr r �_get_block_result)Z version_aZ version_b�chars_a�chars_bZ block_resr r r r s sD + � � r c C sP t �d| |� t| |�}t|d |d d |d d |d d |d | d�}|S ) aH Parse an RPM version string Parses most (all tested) RPM version strings to get their name, epoch, version, release, and architecture information. Epoch (also called serial) is an optional component for RPM versions, and it is also optional when providing a version string to this function. RPM assumes the epoch to be 0 if it is not provided, so that behavior is mirrored here. :param str package_string: :param bool arch_included: :return: A :any:`common.Package` object containing all parsed information :rtype: common.Package zpackage(%s, %s)�namer r r � �arch)Z package_str)r r r r )�package_string� arch_included�pkg_info�pkgr r r �package� s �r, c C s� t �d| |� d}d}|r@t| �}t|�}d�|�} t �d| � zt�| ��� \}}}}W n tyx t d| ��Y n0 |dks�|du r�|}||||f|d�} t �d| � | S ) a] Parse an RPM version string to get name, version, and arch Splits most (all tested) RPM version strings into name, epoch, version, release, and architecture. Epoch (also called serial) is an optional component of RPM versioning and is also optional in version strings provided to this function. RPM assumes the epoch to be 0 if it is not provided, so that behavior is mirrored here. **Deprecated** since version 0.2.0. Use :any:`rpm.package` instead. :param str package_string: an RPM version string of the form returned by the ``rpm -q`` command :param bool arch_included: default True - version strings may optionally be provided without the trailing architecture. If providing such strings, set this option to False :return: a dictionary with all parsed package information :rtype: dict zparse_package(%s, %s)�0N� zupdated version_string: %sz"Could not parse package string: %s)r% r r' zparsed information: %s) r r r � _pop_arch�join�_rpm_re�match�groups�AttributeErrorr ) r( r) Z default_epochr' � char_listr% �epoch�version�release�infor r r r � s( � r c C sl t �d| � g }| �� }|dkrV|�d|� z | �� }W q tyR td��Y q0 qt �d|� d�|�S )aR Pop the architecture from a version string and return it Returns any portion of a string following the final period. In rpm version strings, this corresponds to the package architecture. :param list char_list: an rpm version string in character list form :return: the parsed architecture as a string :rtype: str z _pop_arch(%s)�.r zUCould not parse an architecture. Did you mean to set the arch_included flag to False?zarch chars: %sr. )r r r! �insert� IndexErrorr r0 )r5 Z arch_list�charr r r r/ s r/ c G sV t �d| � | D ]@}t|�dkrD|d �� sD|d dksD|�d� qt �d|� qdS )aX Remove any non-alphanumeric or non-~ leading characters Checks the beginning of any provided lists for non-alphanumeric or non-~ (tilde) leading characters and removes them if found. Operates on (and possibly alters) the passed list. :param list char_list: a list or lists of characters :return: None :rtype: None z_check_leading(%s)r r zupdated list: %sN)r r r �isalnumr! �Z char_listsr5 r r r r s � r c G sJ t �d| � | D ]4}t|�dkr8|d dkr8|�d� qt �d|� qdS )a& Trim any zeros from provided character lists Checks the beginning of any provided lists for '0's and removes any such leading zeros. Operates on (and possibly) alters the passed list :param list char_lists: a list or lists of characters :return: None :rtype: None z_trim_zeros(%s)r r- zupdated block: %sN)r r r r! r? r r r � _trim_zeros0 s r@ c C sV t �d| � g }t| �dkr:| d �� r:|�| �d�� qt �d|� t �d| � |S )ah Pop consecutive digits from the front of list and return them Pops any and all consecutive digits from the start of the provided character list and returns them as a list of string digits. Operates on (and possibly alters) the passed list. :param list char_list: a list of characters :return: a list of string digits :rtype: list z_pop_digits(%s)r zgot digits: %s�updated char list: %s)r r r �isdigit�appendr! )r5 �digitsr r r � _pop_digitsB s rE c C sV t �d| � g }t| �dkr:| d �� r:|�| �d�� qt �d|� t �d| � |S )ae Pop consecutive letters from the front of a list and return them Pops any and all consecutive letters from the start of the provided character list and returns them as a list of characters. Operates on (and possibly alters) the passed list :param list char_list: a list of characters :return: a list of characters :rtype: list z_pop_letters(%s)r zgot letters: %srA )r r r �isalpharC r! )r5 �lettersr r r � _pop_lettersV s rH c C s� t �d| |� | d �� rVt| |� t| �t|�krVt �d� t| �t|�krRtS tS | |krlt �d� tS t �d� | |kr�tS tS dS )a� Compare two blocks of characters Compares two blocks of characters of the form returned by either the :any:`_pop_digits` or :any:`_pop_letters` function. Blocks should be character lists containing only digits or only letters. Both blocks should contain the same character type (digits or letters). The method of comparison mirrors the method used by RPM. If the blocks are digit blocks, any leading zeros are trimmed, and whichever block is longer is assumed to be larger. If the resultant blocks are the same length, or if the blocks are non-numeric, they are checked for string equality and considered equal if the string equality comparison returns True. If not, whichever evaluates as greater than the other (again in string comparison) is assumed to be larger. :param list block_a: an all numeric or all alphabetic character list :param list block_b: an all numeric or all alphabetic character list. Alphabetic or numeric character should match ``block_a`` :return: 1 (if ``a`` is newer), 0 (if versions are equal) or -1 (if ``b`` is newer) :rtype: int z_compare_blocks(%s, %s)r zblock lengths are not equal�blocks are equalzblocks are not equalN)r r rB r@ r r r r )�block_a�block_br r r �_compare_blocksj s rL c C sh t �d| |� | d �� }|r"tnt}|r.tnt}|| �||� }}t|�dkr^t �d� |S t||�S )a� Get the first block from two character lists and compare If character list ``a`` begins with a digit, the :any:`_pop_digit` function is called on both lists to get blocks of all consecutive digits at the start of each list. If the length of the block returned when popping digits for ``b`` is zero (``b`` started with a letter), ``a`` is newer. If ``b`` is of nonzero length, the blocks are compared using :any:`_compare_blocks`. If character list ``a`` begins with a letter, the :any:`_pop_letter` function is called on both lists to get blocks of all consecutive letters at the start of each list. If the length of the block returned when popping letters for ``b`` is zero (``b`` started with a digit), ``b`` is newer. If ``b`` is of nonzero length, blocks ``a`` and ``b`` are compared using :any:`_compare_blocks`. :param list chars_a: a list of characters derived from a version string :param list chars_b: a list of characters derived from a version string :return: 1 (if ``a`` is newer), 0 (if versions are equal), or -1 (if ``b`` is newer) :rtype: int z_get_block_result(%s, %s)r rI ) r r rB rE rH r r r rL )r# r$ Zfirst_is_digitZpop_funcZreturn_if_no_brJ rK r r r r" � s r" N)T)T)T)!�__doc__� __future__r r r r �loggingr �rer Zversion_utils.commonr Zversion_utils.errorsr r1 �__name__r r r r r r r r r, r r/ r r@ rE rH rL r" r r r r �<module> s. O +(
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0 |
proxy
|
phpinfo
|
ÐаÑтройка