File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/collection.tar
Back
isdict_containingvalue.py 0000644 00000003453 15030502773 0011652 0 ustar 00 from typing import Any, Mapping, TypeVar, Union from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" V = TypeVar("V") class IsDictContainingValue(BaseMatcher[Mapping[Any, V]]): def __init__(self, value_matcher: Matcher[V]) -> None: self.value_matcher = value_matcher def _matches(self, item: Mapping[Any, V]) -> bool: if hasmethod(item, "values"): for value in item.values(): if self.value_matcher.matches(value): return True return False def describe_to(self, description: Description) -> None: description.append_text("a dictionary containing value ").append_description_of( self.value_matcher ) def has_value(value: Union[V, Matcher[V]]) -> Matcher[Mapping[Any, V]]: """Matches if dictionary contains an entry whose value satisfies a given matcher. :param value_match: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated dictionary, searching for any key-value entry whose value satisfies the given matcher. If a matching entry is found, ``has_value`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_value(equal_to('bar')) has_value('bar') """ return IsDictContainingValue(wrap_matcher(value)) __pycache__/issequence_containing.cpython-310.pyc 0000644 00000010224 15030502773 0016033 0 ustar 00 o (]^h � @ s� d dl mZmZmZmZ d dlmZ d dlmZ d dl m Z d dl m Z d dl mZ dZdZd Zed �ZG d d � d eee �ZG d d� deee �Zdeee ef deee fdd�Zdeee ef deee fdd�ZdS )� )�Sequence�TypeVar�Union�cast)� BaseMatcher)�all_of)� Description)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sJ e Zd Zdee ddfdd�Zdee defdd�Zd e ddfd d �Z dS ) �IsSequenceContaining�element_matcher�returnNc C s || _ d S �N)r )�selfr � r �S/usr/lib/python3/dist-packages/hamcrest/library/collection/issequence_containing.py�__init__ s z IsSequenceContaining.__init__�itemc C s: z|D ] }| j �|�r W dS qW dS ty Y dS w )NTF)r �matches� TypeError)r r �elementr r r �_matches s �� ��z IsSequenceContaining._matches� descriptionc C s |� d��| j� d S )Nza sequence containing )� append_text�append_description_ofr �r r r r r � describe_to s �z IsSequenceContaining.describe_to) �__name__� __module__� __qualname__r r r r �boolr r r r r r r r s r c @ sd e Zd Zdee ddfdd�Zdee defdd�Zdee d e ddfd d �Z d e ddfd d�Z dS )�IsSequenceContainingEvery�element_matchersr Nc G s dd� |D �}t |� | _d S )Nc S s" g | ] }t ttt t|���qS r )r r r r �has_item)�.0�er r r � <listcomp>) s " z6IsSequenceContainingEvery.__init__.<locals>.<listcomp>)r �matcher)r r# � delegatesr r r r ( s z"IsSequenceContainingEvery.__init__r c C s( z | j �t|��W S ty Y dS w )NF)r( r �listr )r r r r r r , s �z"IsSequenceContainingEvery._matches�mismatch_descriptionc C s | j �||� d S r )r( �describe_mismatch)r r r+ r r r r, 2 s z+IsSequenceContainingEvery.describe_mismatchr c C s | j �|� d S r )r( r r r r r r 5 s z%IsSequenceContainingEvery.describe_to) r r r r r r r r! r r r, r r r r r r" ' s r" �matchr c C s t t| ��S )a Matches if any element of sequence satisfies a given matcher. :param match: The matcher to satisfy, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated sequence, searching for any element that satisfies a given matcher. If a matching element is found, ``has_item`` is satisfied. If the ``match`` argument is not a matcher, it is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. )r r )r- r r r r$ 9 s r$ �itemsc G s$ g }| D ] }|� t|�� qt|� S )a� Matches if all of the given matchers are satisfied by any elements of the sequence. :param match1,...: A comma-separated list of matchers. This matcher iterates the given matchers, searching for any elements in the evaluated sequence that satisfy them. If each matcher is satisfied, then ``has_items`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. )�appendr r" )r. �matchersr r r r � has_itemsK s r1 N)�typingr r r r �hamcrest.core.base_matcherr �hamcrest.core.core.allofr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r" r$ r1 r r r r �<module> s &* __pycache__/isin.cpython-310.pyc 0000644 00000003103 15030502773 0012416 0 ustar 00 o (]^� � @ sz d dl mZmZ d dlmZ d dlmZ d dlmZ dZ dZ dZ ed�Z G d d � d ee �Z d ee d ee fd d�ZdS )� )�Sequence�TypeVar)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sF e Zd Zdee ddfdd�Zdedefdd�Zd eddfd d �Z dS ) �IsIn�sequence�returnNc C s || _ d S �N�r )�selfr � r �B/usr/lib/python3/dist-packages/hamcrest/library/collection/isin.py�__init__ � z IsIn.__init__�itemc C s || j v S r r )r r r r r �_matches r z IsIn._matches� descriptionc C s |� d��ddd| j� d S )Nzone of �(z, �))� append_text� append_listr )r r r r r � describe_to s zIsIn.describe_to) �__name__� __module__� __qualname__r r r �boolr r r r r r r r s r r r c C s t | �S )z�Matches if evaluated object is present in a given sequence. :param sequence: The sequence to search. This matcher invokes the ``in`` membership operator to determine if the evaluated object is a member of the sequence. )r r r r r �is_in s r N)�typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s __pycache__/isdict_containingvalue.cpython-310.pyc 0000644 00000004626 15030502773 0016214 0 ustar 00 o (]^+ � @ s� d dl mZmZmZmZ d dlmZ d dlmZ d dl m Z d dl m Z d dl mZ dZdZd Zed �ZG d d � d eeeef �Zd eeee f deeeef fdd�ZdS )� )�Any�Mapping�TypeVar�Union)� BaseMatcher)� Description)� hasmethod)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Vc @ sN e Zd Zdee ddfdd�Zdeeef defdd�Z d e ddfd d �Z dS ) �IsDictContainingValue� value_matcher�returnNc C s || _ d S )N)r )�selfr � r �T/usr/lib/python3/dist-packages/hamcrest/library/collection/isdict_containingvalue.py�__init__ s z IsDictContainingValue.__init__�itemc C s. t |d�r|�� D ] }| j�|�r dS q dS )N�valuesTF)r r r �matches)r r �valuer r r �_matches s �z IsDictContainingValue._matches� descriptionc C s |� d��| j� d S )Nz a dictionary containing value )� append_text�append_description_ofr )r r r r r � describe_to s �z!IsDictContainingValue.describe_to) �__name__� __module__� __qualname__r r r r r �boolr r r r r r r r s r r r c C s t t| ��S )a� Matches if dictionary contains an entry whose value satisfies a given matcher. :param value_match: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated dictionary, searching for any key-value entry whose value satisfies the given matcher. If a matching entry is found, ``has_value`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_value(equal_to('bar')) has_value('bar') )r r )r r r r � has_value! s r N)�typingr r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr � hamcrest.core.helpers.hasmethodr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s . __pycache__/issequence_onlycontaining.cpython-310.pyc 0000644 00000004537 15030502773 0016747 0 ustar 00 o (]^1 � @ s� d dl mZmZmZ d dlmZ d dlmZ d dlm Z d dl m Z d dl m Z dZdZd Zed �ZG d d � d eee �Zd ee e ef de ee fdd�ZdS )� )�Sequence�TypeVar�Union)� BaseMatcher)�any_of)� Description)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sJ e Zd Zdee ddfdd�Zdee defdd�Zd e ddfd d �Z dS ) �IsSequenceOnlyContaining�matcher�returnNc C s || _ d S )N)r )�selfr � r �W/usr/lib/python3/dist-packages/hamcrest/library/collection/issequence_onlycontaining.py�__init__ s z!IsSequenceOnlyContaining.__init__�itemc C sT z t |�}t|�dkrW dS |D ] }| j�|�s W dS qW dS ty) Y dS w )Nr FT)�list�lenr �matches� TypeError)r r �sequence�elementr r r �_matches s � �z!IsSequenceOnlyContaining._matches� descriptionc C s |� d��| j� d S )Nz%a sequence containing items matching )� append_text�append_description_ofr )r r r r r � describe_to s �z$IsSequenceOnlyContaining.describe_to) �__name__� __module__� __qualname__r r r r �boolr r r r r r r r s r �itemsr c G s( g }| D ] }|� t|�� qtt|� �S )a� Matches if each element of sequence satisfies any of the given matchers. :param match1,...: A comma-separated list of matchers. This matcher iterates the evaluated sequence, confirming whether each element satisfies any of the given matchers. Example:: only_contains(less_than(4)) will match ``[3,1,2]``. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. )�appendr r r )r" �matchersr r r r � only_contains& s r% N)�typingr r r �hamcrest.core.base_matcherr �hamcrest.core.core.anyofr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r% r r r r �<module> s * __pycache__/is_empty.cpython-310.pyc 0000644 00000002734 15030502773 0013316 0 ustar 00 o (]^4 � @ sj d dl mZmZ d dlmZ d dlmZ d dlmZ dZ dZ dZ G dd � d ee �Z d ee fd d �Z d S )� )�Optional�Sized)� BaseMatcher)� Description)�Matcherz Chris RosezCopyright 2012 hamcrest.orgzBSD, see License.txtc @ s: e Zd Zd dedee defdd�Zdeddfdd �ZdS ) �IsEmptyN�item�mismatch_description�returnc C s^ zt |�dkr W dS |r|�dt |� � W dS W dS ty. |r+|�d� Y dS Y dS w )Nr Tzhas %d item(s)zdoes not support lengthF)�len� append_text� TypeError)�selfr r � r �F/usr/lib/python3/dist-packages/hamcrest/library/collection/is_empty.py�matches s � � ��zIsEmpty.matches� descriptionc C s |� d� d S )Nzan empty collection)r )r r r r r � describe_to s zIsEmpty.describe_to)N) �__name__� __module__� __qualname__r r r �boolr r r r r r r s r r c C s t � S )zy This matcher matches any collection-like object that responds to the __len__ method, and has a length of 0. )r r r r r �empty s r N)�typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r �<module> s __pycache__/__init__.cpython-310.pyc 0000644 00000001624 15030502773 0013221 0 ustar 00 o (]^f � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZmZ dd lmZ dd lmZmZ dd lmZ d Zd ZdZdS )zMatchers of collections.� )�empty)� has_entry)� has_entries)�has_key)� has_value)�is_in)�has_item� has_items)�contains_inanyorder)�contains�contains_exactly)� only_containsz Chris RosezCopyright 2013 hamcrest.orgzBSD, see License.txtN)�__doc__�is_emptyr �isdict_containingr �isdict_containingentriesr �isdict_containingkeyr �isdict_containingvaluer �isinr �issequence_containingr r � issequence_containinginanyorderr � issequence_containinginorderr r �issequence_onlycontainingr � __author__� __copyright__� __license__� r r �F/usr/lib/python3/dist-packages/hamcrest/library/collection/__init__.py�<module> s __pycache__/isdict_containing.cpython-310.pyc 0000644 00000005353 15030502773 0015155 0 ustar 00 o (]^ � @ s� d dl mZmZmZmZ d dlmZ d dlmZ d dl m Z d dl m Z d dl mZ dZdZd Zed ed �Zed �ZG d d� deeeef �Zdeeee f deeee f deeeef fdd�ZdS )� )�Hashable�Mapping�TypeVar�Union)� BaseMatcher)� Description)� hasmethod)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�K)�bound�Vc @ sV e Zd Zdee dee ddfdd�Zdeeef defdd �Z d e ddfd d �Z dS ) �IsDictContaining� key_matcher� value_matcher�returnNc C s || _ || _d S )N)r r )�selfr r � r �O/usr/lib/python3/dist-packages/hamcrest/library/collection/isdict_containing.py�__init__ s zIsDictContaining.__init__�itemc C s> t |d�r |�� D ]\}}| j�|�r | j�|�r dS q dS )N�itemsTF)r r r �matchesr )r r �key�valuer r r �_matches s �zIsDictContaining._matches� descriptionc C s* |� d��| j�� d��| j�� d� d S )Nza dictionary containing [z: �])� append_text�append_description_ofr r )r r r r r � describe_to s �z IsDictContaining.describe_to) �__name__� __module__� __qualname__r r r r r �boolr r r r r r r r s r � key_match� value_matchr c C s t t| �t|��S )aO Matches if dictionary contains key-value entry satisfying a given pair of matchers. :param key_match: The matcher to satisfy for the key, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. :param value_match: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated dictionary, searching for any key-value entry that satisfies ``key_match`` and ``value_match``. If a matching entry is found, ``has_entry`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_entry(equal_to('foo'), equal_to(1)) has_entry('foo', 1) )r r )r% r& r r r � has_entry$ s r' N)�typingr r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr � hamcrest.core.helpers.hasmethodr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r' r r r r �<module> s& ��� __pycache__/issequence_containinginorder.cpython-310.pyc 0000644 00000010310 15030502773 0017412 0 ustar 00 o (]^� � @ s� d dl Z d dlmZmZmZmZ d dlmZ d dlm Z d dl m Z d dl m Z dZdZd Zed �ZG d d � d e�ZG d d� deee �Zdee e ef de ee fdd�Zdee e ef de ee fdd�ZdS )� N)�Optional�Sequence�TypeVar�Union)� BaseMatcher)� Description)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sr e Zd Zdeee dee ddfdd�Zdede fdd �Z de fd d �Z dede fd d �Z dede fdd�Z dS )�MatchingInOrder�matchers�mismatch_description�returnNc C s || _ || _d| _d S )Nr )r r �next_match_index)�selfr r � r �Z/usr/lib/python3/dist-packages/hamcrest/library/collection/issequence_containinginorder.py�__init__ s zMatchingInOrder.__init__�itemc C s | � |�o | �|�S �N)� isnotsurplus� ismatched�r r r r r �matches s zMatchingInOrder.matchesc C s8 | j t| j�k r| jr| j�d��| j| j � dS dS )NzNo item matched: FT)r �lenr r � append_text�append_description_of)r r r r � isfinished s �zMatchingInOrder.isfinishedc C sZ | j | j }|�|�s$| jr"| j�dt| j� d � |�|| j� dS | jd7 _dS )Nzitem z: F� T)r r r r r �str�describe_mismatch)r r �matcherr r r r $ s zMatchingInOrder.ismatchedc C s0 t | j�| jkr| jr| j�d��|� dS dS )Nz Not matched: FT)r r r r r r r r r r r . s z MatchingInOrder.isnotsurplus)�__name__� __module__� __qualname__r r r r r r �boolr r r r r r r r r s �� � r c s| e Zd Zdeee ddfdd�Z ddee dee de f� fdd � Z dee deddfd d �Z d eddfd d�Z � Z S )�IsSequenceContainingInOrderr r Nc C s || _ d S r )r )r r r r r r 7 s z$IsSequenceContainingInOrder.__init__r r c s^ zt | j|�}|D ] }|�|�s W dS q |�� W S ty. |r+tt| ��||� Y dS w )NF)r r r r � TypeError�superr& r )r r r � matchsequence�element�� __class__r r r : s � ��z#IsSequenceContainingInOrder.matchesc C s | � ||� d S r )r )r r r r r r r J s z-IsSequenceContainingInOrder.describe_mismatch� descriptionc C s |� d��ddd| j� d S )Nza sequence containing �[z, �])r � append_listr )r r- r r r � describe_toM s z'IsSequenceContainingInOrder.describe_tor )r" r# r$ r r r r r r r% r r r1 � __classcell__r r r+ r r& 6 s ����r& �itemsr c G s$ g }| D ] }|� t|�� qt|�S )a� Matches if sequence's elements satisfy a given list of matchers, in order. :param match1,...: A comma-separated list of matchers. This matcher iterates the evaluated sequence and a given list of matchers, seeing if each element satisfies its corresponding matcher. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. )�appendr r& )r3 r r r r r �contains_exactlyQ s r5 c G s t �dt� t| � S )z)Deprecated - use contains_exactly(*items)z)deprecated - use contains_exactly(*items))�warnings�warn�DeprecationWarningr5 )r3 r r r �containsd s r9 )r6 �typingr r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r �objectr r& r5 r9 r r r r �<module> s &&* __pycache__/isdict_containingkey.cpython-310.pyc 0000644 00000004632 15030502773 0015665 0 ustar 00 o (]^% � @ s� d dl mZmZmZmZmZ d dlmZ d dlm Z d dl m Z d dl m Z d dlmZ dZdZd Zed ed �ZG d d � d eeeef �Zdeeee f deeeef fdd�ZdS )� )�Any�Hashable�Mapping�TypeVar�Union)� BaseMatcher)� Description)� hasmethod)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�K)�boundc @ sN e Zd Zdee ddfdd�Zdeeef defdd�Z d e ddfd d �Z dS ) �IsDictContainingKey� key_matcher�returnNc C s || _ d S )N)r )�selfr � r �R/usr/lib/python3/dist-packages/hamcrest/library/collection/isdict_containingkey.py�__init__ s z IsDictContainingKey.__init__�itemc C s. t |d�r|�� D ] }| j�|�r dS q dS )N�keysTF)r r r �matches)r r �keyr r r �_matches s �z IsDictContainingKey._matches� descriptionc C s |� d��| j� d S )Nz a dictionary containing key )� append_text�append_description_ofr )r r r r r � describe_to s �z IsDictContainingKey.describe_to) �__name__� __module__� __qualname__r r r r r �boolr r r r r r r r s r � key_matchr c C s t t| ��S )a� Matches if dictionary contains an entry whose key satisfies a given matcher. :param key_match: The matcher to satisfy for the key, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated dictionary, searching for any key-value entry whose key satisfies the given matcher. If a matching entry is found, ``has_key`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_key(equal_to('foo')) has_key('foo') )r r )r" r r r �has_key! s r# N)�typingr r r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr � hamcrest.core.helpers.hasmethodr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r# r r r r �<module> s . __pycache__/isdict_containingentries.cpython-310.pyc 0000644 00000012341 15030502773 0016542 0 ustar 00 o (]^< � @ s" d dl mZmZmZmZmZmZmZ d dlm Z d dl m Z d dl m Z d dlmZ dZdZdZed ed �Zed �ZG d d � d e eeef �Zedeee ef deeeef fdd��Zedeeeee ef f deeeef fdd��Zededeeeef fdd��Zdd� ZdS )� )�Any�Hashable�Mapping�Optional�TypeVar�Union�overload)� BaseMatcher)� Description)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�K)�bound�Vc @ s� e Zd Zddd�Zdeeef dee de fdd�Z ddeeef dee de fd d �Z deeef deddfd d �Z d e dededdfdd�Zdeddfdd�ZdS )�IsDictContainingEntries�returnNc C s t |�� �| _d S �N)�sorted�items�value_matchers)�selfr � r �V/usr/lib/python3/dist-packages/hamcrest/library/collection/isdict_containingentries.py�__init__ s z IsDictContainingEntries.__init__�item�mismatch_descriptionc C s |r |� |��d� dS )Nz is not a mapping objectF��append_description_of� append_text�r r r r r r �_not_a_dictionary s z)IsDictContainingEntries._not_a_dictionaryc C s� | j D ]c\}}z||vr |r |�d��|��d��|� W dS W n ty2 | �||� Y S w z|| }W n tyJ | �||� Y S w |�|�sf|rc|�d��|��d� |�||� dS qdS )Nzno z key in Fz value for � T)r r r � TypeErrorr �matches�describe_mismatch)r r r �key� value_matcher� actual_valuer r r r# s8 �� � � � �z IsDictContainingEntries.matchesc C s | � ||� d S r )r# r r r r r$ 9 s z)IsDictContainingEntries.describe_mismatch�index�value� descriptionc C s |� |��d�� |� dS )z(Describes key-value pair at given index.z: Nr )r r( r) r* r r r �describe_keyvalue< s z)IsDictContainingEntries.describe_keyvaluec C sL |� d� d}| jD ]\}}|s|� d� | �|||� d}q |� d� d S )Nza dictionary containing {Tz, F�})r r r+ )r r* �firstr% r) r r r � describe_to@ s z#IsDictContainingEntries.describe_to)r Nr )�__name__� __module__� __qualname__r r r r r r �boolr r# r$ �intr+ r. r r r r r s( �� �� �� � r �keys_valuematchersr c K � d S r r �r4 r r r � has_entriesL � r7 c C r5 r r r6 r r r r7 R r8 c G r5 r r r6 r r r r7 X r8 c O s� t | �dkr'z| d �� }|D ] }t|| �||< qW n4 ty& td��w t | �d r1td��i }ttt | �d ��D ]}t| d| d �|| d| < q=|�� D ] \}}t|�||< qTt|�S )a% Matches if dictionary contains entries satisfying a dictionary of keys and corresponding value matchers. :param matcher_dict: A dictionary mapping keys to associated value matchers, or to expected values for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. Note that the keys must be actual keys, not matchers. Any value argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_entries({'foo':equal_to(1), 'bar':equal_to(2)}) has_entries({'foo':1, 'bar':2}) ``has_entries`` also accepts a list of keyword arguments: .. function:: has_entries(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]]) :param keyword1: A keyword to look up. :param valueMatcher1: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. Examples:: has_entries(foo=equal_to(1), bar=equal_to(2)) has_entries(foo=1, bar=2) Finally, ``has_entries`` also accepts a list of alternating keys and their value matchers: .. function:: has_entries(key1, value_matcher1[, ...]) :param key1: A key (not a matcher) to look up. :param valueMatcher1: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. Examples:: has_entries('foo', equal_to(1), 'bar', equal_to(2)) has_entries('foo', 1, 'bar', 2) � r zEsingle-argument calls to has_entries must pass a dict as the argument� z$has_entries requires key-value pairs) �len�copyr �AttributeError� ValueError�ranger3 r r )r4 �kv_args� base_dictr% r( r) r r r r7 ] s* . � �� �N)�typingr r r r r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r �strr7 r r r r �<module> s$ $ <,4 __pycache__/issequence_containinginanyorder.cpython-310.pyc 0000644 00000010413 15030502773 0020126 0 ustar 00 o (]^ � @ s� d dl mZmZmZmZmZmZ d dlmZ d dl m Z d dl m Z d dl mZ dZdZdZed �ZG d d � d e�ZG d d � d eee �Zdeee ef deee fdd�ZdS )� )�MutableSequence�Optional�Sequence�TypeVar�Union�cast)� BaseMatcher)� Description)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sz e Zd Zdeee dee ddfdd�Zdede fdd �Z dee de fd d �Z dede fd d �Z dede fdd�Z dS )�MatchInAnyOrder�matchers�mismatch_description�returnNc C s& t ttt |d d � �| _|| _d S �N)r r r r r r )�selfr r � r �]/usr/lib/python3/dist-packages/hamcrest/library/collection/issequence_containinginanyorder.py�__init__ s zMatchInAnyOrder.__init__�itemc C s | � |�o | �|�S r )� isnotsurplus� ismatched�r r r r r �matches s zMatchInAnyOrder.matchesc C s@ | j sdS | jr | j�d��ddd| j ��d��ddd|� dS ) NTzno item matches: � �, z in �[�]F)r r � append_text� append_listr r r r � isfinished s �zMatchInAnyOrder.isfinishedc C s& | j s| jr| j�d��|� dS dS )N� not matched: FT)r r r �append_description_ofr r r r r " s z MatchInAnyOrder.isnotsurplusc C sH t | j�D ]\}}|�|�r| j|= dS q| jr"| j�d��|� dS )NTr" F)� enumerater r r r r# )r r �index�matcherr r r r ) s �zMatchInAnyOrder.ismatched)�__name__� __module__� __qualname__r r r r r r �boolr r! r r r r r r r s �� � r c s| e Zd Zdeee ddfdd�Z ddee dee de f� fdd � Z dee deddfd d �Z d eddfd d�Z � Z S )� IsSequenceContainingInAnyOrderr r Nc C s || _ d S r )r )r r r r r r 5 s z'IsSequenceContainingInAnyOrder.__init__r r c sh z t |�}t| j|�}|D ] }|�|�s W dS q |�|�W S ty3 |r0tt| ��||� Y dS w )NF) �listr r r r! � TypeError�superr+ �describe_mismatch)r r r �sequence� matchsequence�element�� __class__r r r 8 s � ��z&IsSequenceContainingInAnyOrder.matchesc C s | � ||� d S r )r )r r r r r r r/ I s z0IsSequenceContainingInAnyOrder.describe_mismatch� descriptionc C s" |� d��ddd| j�� d� d S )Nza sequence over r r r z in any order)r r r )r r5 r r r � describe_toL s � z*IsSequenceContainingInAnyOrder.describe_tor )r' r( r) r r r r r r r* r r/ r6 � __classcell__r r r3 r r+ 4 s ����r+ �itemsr c G s$ g }| D ] }|� t|�� qt|�S )a� Matches if sequences's elements, in any order, satisfy a given list of matchers. :param match1,...: A comma-separated list of matchers. This matcher iterates the evaluated sequence, seeing if each element satisfies any of the given matchers. The matchers are tried from left to right, and when a satisfied matcher is found, it is no longer a candidate for the remaining elements. If a one-to-one correspondence is established between elements and matchers, ``contains_inanyorder`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. )�appendr r+ )r8 r r r r r �contains_inanyorderR s r: N)�typingr r r r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r �objectr r+ r: r r r r �<module> s %* isdict_containingentries.py 0000644 00000013074 15030502773 0012207 0 ustar 00 from typing import Any, Hashable, Mapping, Optional, TypeVar, Union, overload from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" K = TypeVar("K", bound=Hashable) V = TypeVar("V") class IsDictContainingEntries(BaseMatcher[Mapping[K, V]]): def __init__(self, value_matchers) -> None: self.value_matchers = sorted(value_matchers.items()) def _not_a_dictionary( self, item: Mapping[K, V], mismatch_description: Optional[Description] ) -> bool: if mismatch_description: mismatch_description.append_description_of(item).append_text(" is not a mapping object") return False def matches( self, item: Mapping[K, V], mismatch_description: Optional[Description] = None ) -> bool: for key, value_matcher in self.value_matchers: try: if not key in item: if mismatch_description: mismatch_description.append_text("no ").append_description_of( key ).append_text(" key in ").append_description_of(item) return False except TypeError: return self._not_a_dictionary(item, mismatch_description) try: actual_value = item[key] except TypeError: return self._not_a_dictionary(item, mismatch_description) if not value_matcher.matches(actual_value): if mismatch_description: mismatch_description.append_text("value for ").append_description_of( key ).append_text(" ") value_matcher.describe_mismatch(actual_value, mismatch_description) return False return True def describe_mismatch(self, item: Mapping[K, V], mismatch_description: Description) -> None: self.matches(item, mismatch_description) def describe_keyvalue(self, index: int, value: V, description: Description) -> None: """Describes key-value pair at given index.""" description.append_description_of(index).append_text(": ").append_description_of(value) def describe_to(self, description: Description) -> None: description.append_text("a dictionary containing {") first = True for key, value in self.value_matchers: if not first: description.append_text(", ") self.describe_keyvalue(key, value, description) first = False description.append_text("}") # Keyword argument form @overload def has_entries(**keys_valuematchers: Union[Matcher[V], V]) -> Matcher[Mapping[str, V]]: ... # Key to matcher dict form @overload def has_entries(keys_valuematchers: Mapping[K, Union[Matcher[V], V]]) -> Matcher[Mapping[K, V]]: ... # Alternating key/matcher form @overload def has_entries(*keys_valuematchers: Any) -> Matcher[Mapping[Any, Any]]: ... def has_entries(*keys_valuematchers, **kv_args): """Matches if dictionary contains entries satisfying a dictionary of keys and corresponding value matchers. :param matcher_dict: A dictionary mapping keys to associated value matchers, or to expected values for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. Note that the keys must be actual keys, not matchers. Any value argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_entries({'foo':equal_to(1), 'bar':equal_to(2)}) has_entries({'foo':1, 'bar':2}) ``has_entries`` also accepts a list of keyword arguments: .. function:: has_entries(keyword1=value_matcher1[, keyword2=value_matcher2[, ...]]) :param keyword1: A keyword to look up. :param valueMatcher1: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. Examples:: has_entries(foo=equal_to(1), bar=equal_to(2)) has_entries(foo=1, bar=2) Finally, ``has_entries`` also accepts a list of alternating keys and their value matchers: .. function:: has_entries(key1, value_matcher1[, ...]) :param key1: A key (not a matcher) to look up. :param valueMatcher1: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. Examples:: has_entries('foo', equal_to(1), 'bar', equal_to(2)) has_entries('foo', 1, 'bar', 2) """ if len(keys_valuematchers) == 1: try: base_dict = keys_valuematchers[0].copy() for key in base_dict: base_dict[key] = wrap_matcher(base_dict[key]) except AttributeError: raise ValueError( "single-argument calls to has_entries must pass a dict as the argument" ) else: if len(keys_valuematchers) % 2: raise ValueError("has_entries requires key-value pairs") base_dict = {} for index in range(int(len(keys_valuematchers) / 2)): base_dict[keys_valuematchers[2 * index]] = wrap_matcher( keys_valuematchers[2 * index + 1] ) for key, value in kv_args.items(): base_dict[key] = wrap_matcher(value) return IsDictContainingEntries(base_dict) isdict_containing.py 0000644 00000004401 15030502773 0010607 0 ustar 00 from typing import Hashable, Mapping, TypeVar, Union from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" K = TypeVar("K", bound=Hashable) # TODO - covariant? V = TypeVar("V") class IsDictContaining(BaseMatcher[Mapping[K, V]]): def __init__(self, key_matcher: Matcher[K], value_matcher: Matcher[V]) -> None: self.key_matcher = key_matcher self.value_matcher = value_matcher def _matches(self, item: Mapping[K, V]) -> bool: if hasmethod(item, "items"): for key, value in item.items(): if self.key_matcher.matches(key) and self.value_matcher.matches(value): return True return False def describe_to(self, description: Description) -> None: description.append_text("a dictionary containing [").append_description_of( self.key_matcher ).append_text(": ").append_description_of(self.value_matcher).append_text("]") def has_entry( key_match: Union[K, Matcher[K]], value_match: Union[V, Matcher[V]] ) -> Matcher[Mapping[K, V]]: """Matches if dictionary contains key-value entry satisfying a given pair of matchers. :param key_match: The matcher to satisfy for the key, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. :param value_match: The matcher to satisfy for the value, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated dictionary, searching for any key-value entry that satisfies ``key_match`` and ``value_match``. If a matching entry is found, ``has_entry`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_entry(equal_to('foo'), equal_to(1)) has_entry('foo', 1) """ return IsDictContaining(wrap_matcher(key_match), wrap_matcher(value_match)) issequence_containinginorder.py 0000644 00000007371 15030502773 0013070 0 ustar 00 import warnings from typing import Optional, Sequence, TypeVar, Union from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class MatchingInOrder(object): def __init__( self, matchers: Sequence[Matcher[T]], mismatch_description: Optional[Description] ) -> None: self.matchers = matchers self.mismatch_description = mismatch_description self.next_match_index = 0 def matches(self, item: T) -> bool: return self.isnotsurplus(item) and self.ismatched(item) def isfinished(self) -> bool: if self.next_match_index < len(self.matchers): if self.mismatch_description: self.mismatch_description.append_text("No item matched: ").append_description_of( self.matchers[self.next_match_index] ) return False return True def ismatched(self, item: T) -> bool: matcher = self.matchers[self.next_match_index] if not matcher.matches(item): if self.mismatch_description: self.mismatch_description.append_text("item " + str(self.next_match_index) + ": ") matcher.describe_mismatch(item, self.mismatch_description) return False self.next_match_index += 1 return True def isnotsurplus(self, item: T) -> bool: if len(self.matchers) <= self.next_match_index: if self.mismatch_description: self.mismatch_description.append_text("Not matched: ").append_description_of(item) return False return True class IsSequenceContainingInOrder(BaseMatcher[Sequence[T]]): def __init__(self, matchers: Sequence[Matcher[T]]) -> None: self.matchers = matchers def matches( self, item: Sequence[T], mismatch_description: Optional[Description] = None ) -> bool: try: matchsequence = MatchingInOrder(self.matchers, mismatch_description) for element in item: if not matchsequence.matches(element): return False return matchsequence.isfinished() except TypeError: if mismatch_description: super(IsSequenceContainingInOrder, self).describe_mismatch( item, mismatch_description ) return False def describe_mismatch(self, item: Sequence[T], mismatch_description: Description) -> None: self.matches(item, mismatch_description) def describe_to(self, description: Description) -> None: description.append_text("a sequence containing ").append_list("[", ", ", "]", self.matchers) def contains_exactly(*items: Union[Matcher[T], T]) -> Matcher[Sequence[T]]: """Matches if sequence's elements satisfy a given list of matchers, in order. :param match1,...: A comma-separated list of matchers. This matcher iterates the evaluated sequence and a given list of matchers, seeing if each element satisfies its corresponding matcher. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. """ matchers = [] for item in items: matchers.append(wrap_matcher(item)) return IsSequenceContainingInOrder(matchers) def contains(*items: Union[Matcher[T], T]) -> Matcher[Sequence[T]]: """Deprecated - use contains_exactly(*items)""" warnings.warn("deprecated - use contains_exactly(*items)", DeprecationWarning) return contains_exactly(*items) issequence_containinginanyorder.py 0000644 00000007435 15030502773 0013601 0 ustar 00 from typing import MutableSequence, Optional, Sequence, TypeVar, Union, cast from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class MatchInAnyOrder(object): def __init__( self, matchers: Sequence[Matcher[T]], mismatch_description: Optional[Description] ) -> None: self.matchers = cast(MutableSequence[Matcher[T]], matchers[:]) self.mismatch_description = mismatch_description def matches(self, item: T) -> bool: return self.isnotsurplus(item) and self.ismatched(item) def isfinished(self, item: Sequence[T]) -> bool: if not self.matchers: return True if self.mismatch_description: self.mismatch_description.append_text("no item matches: ").append_list( "", ", ", "", self.matchers ).append_text(" in ").append_list("[", ", ", "]", item) return False def isnotsurplus(self, item: T) -> bool: if not self.matchers: if self.mismatch_description: self.mismatch_description.append_text("not matched: ").append_description_of(item) return False return True def ismatched(self, item: T) -> bool: for index, matcher in enumerate(self.matchers): if matcher.matches(item): del self.matchers[index] return True if self.mismatch_description: self.mismatch_description.append_text("not matched: ").append_description_of(item) return False class IsSequenceContainingInAnyOrder(BaseMatcher[Sequence[T]]): def __init__(self, matchers: Sequence[Matcher[T]]) -> None: self.matchers = matchers def matches( self, item: Sequence[T], mismatch_description: Optional[Description] = None ) -> bool: try: sequence = list(item) matchsequence = MatchInAnyOrder(self.matchers, mismatch_description) for element in sequence: if not matchsequence.matches(element): return False return matchsequence.isfinished(sequence) except TypeError: if mismatch_description: super(IsSequenceContainingInAnyOrder, self).describe_mismatch( item, mismatch_description ) return False def describe_mismatch(self, item: Sequence[T], mismatch_description: Description) -> None: self.matches(item, mismatch_description) def describe_to(self, description: Description) -> None: description.append_text("a sequence over ").append_list( "[", ", ", "]", self.matchers ).append_text(" in any order") def contains_inanyorder(*items: Union[Matcher[T], T]) -> Matcher[Sequence[T]]: """Matches if sequences's elements, in any order, satisfy a given list of matchers. :param match1,...: A comma-separated list of matchers. This matcher iterates the evaluated sequence, seeing if each element satisfies any of the given matchers. The matchers are tried from left to right, and when a satisfied matcher is found, it is no longer a candidate for the remaining elements. If a one-to-one correspondence is established between elements and matchers, ``contains_inanyorder`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. """ matchers = [] for item in items: matchers.append(wrap_matcher(item)) return IsSequenceContainingInAnyOrder(matchers) is_empty.py 0000644 00000002064 15030502773 0006753 0 ustar 00 from typing import Optional, Sized from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.matcher import Matcher __author__ = "Chris Rose" __copyright__ = "Copyright 2012 hamcrest.org" __license__ = "BSD, see License.txt" class IsEmpty(BaseMatcher[Sized]): def matches(self, item: Sized, mismatch_description: Optional[Description] = None) -> bool: try: if len(item) == 0: return True if mismatch_description: mismatch_description.append_text("has %d item(s)" % len(item)) except TypeError: if mismatch_description: mismatch_description.append_text("does not support length") return False def describe_to(self, description: Description) -> None: description.append_text("an empty collection") def empty() -> Matcher[Sized]: """ This matcher matches any collection-like object that responds to the __len__ method, and has a length of 0. """ return IsEmpty() issequence_onlycontaining.py 0000644 00000003461 15030502773 0012403 0 ustar 00 from typing import Sequence, TypeVar, Union from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.core.anyof import any_of from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class IsSequenceOnlyContaining(BaseMatcher[Sequence[T]]): def __init__(self, matcher: Matcher[T]) -> None: self.matcher = matcher def _matches(self, item: Sequence[T]) -> bool: try: sequence = list(item) if len(sequence) == 0: return False for element in sequence: if not self.matcher.matches(element): return False return True except TypeError: return False def describe_to(self, description: Description) -> None: description.append_text("a sequence containing items matching ").append_description_of( self.matcher ) def only_contains(*items: Union[Matcher[T], T]) -> Matcher[Sequence[T]]: """Matches if each element of sequence satisfies any of the given matchers. :param match1,...: A comma-separated list of matchers. This matcher iterates the evaluated sequence, confirming whether each element satisfies any of the given matchers. Example:: only_contains(less_than(4)) will match ``[3,1,2]``. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. """ matchers = [] for item in items: matchers.append(wrap_matcher(item)) return IsSequenceOnlyContaining(any_of(*matchers)) issequence_containing.py 0000644 00000006550 15030502773 0011503 0 ustar 00 from typing import Sequence, TypeVar, Union, cast from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.core.allof import all_of from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class IsSequenceContaining(BaseMatcher[Sequence[T]]): def __init__(self, element_matcher: Matcher[T]) -> None: self.element_matcher = element_matcher def _matches(self, item: Sequence[T]) -> bool: try: for element in item: if self.element_matcher.matches(element): return True except TypeError: # not a sequence pass return False def describe_to(self, description: Description) -> None: description.append_text("a sequence containing ").append_description_of( self.element_matcher ) # It'd be great to make use of all_of, but we can't be sure we won't # be seeing a one-time sequence here (like a generator); see issue #20 # Instead, we wrap it inside a class that will convert the sequence into # a concrete list and then hand it off to the all_of matcher. class IsSequenceContainingEvery(BaseMatcher[Sequence[T]]): def __init__(self, *element_matchers: Matcher[T]) -> None: delegates = [cast(Matcher[Sequence[T]], has_item(e)) for e in element_matchers] self.matcher = all_of(*delegates) # type: Matcher[Sequence[T]] def _matches(self, item: Sequence[T]) -> bool: try: return self.matcher.matches(list(item)) except TypeError: return False def describe_mismatch(self, item: Sequence[T], mismatch_description: Description) -> None: self.matcher.describe_mismatch(item, mismatch_description) def describe_to(self, description: Description) -> None: self.matcher.describe_to(description) def has_item(match: Union[Matcher[T], T]) -> Matcher[Sequence[T]]: """Matches if any element of sequence satisfies a given matcher. :param match: The matcher to satisfy, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated sequence, searching for any element that satisfies a given matcher. If a matching element is found, ``has_item`` is satisfied. If the ``match`` argument is not a matcher, it is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. """ return IsSequenceContaining(wrap_matcher(match)) def has_items(*items: Union[Matcher[T], T]) -> Matcher[Sequence[T]]: """Matches if all of the given matchers are satisfied by any elements of the sequence. :param match1,...: A comma-separated list of matchers. This matcher iterates the given matchers, searching for any elements in the evaluated sequence that satisfy them. If each matcher is satisfied, then ``has_items`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. """ matchers = [] for item in items: matchers.append(wrap_matcher(item)) return IsSequenceContainingEvery(*matchers) isin.py 0000644 00000001721 15030502773 0006063 0 ustar 00 from typing import Sequence, TypeVar from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class IsIn(BaseMatcher[T]): def __init__(self, sequence: Sequence[T]) -> None: self.sequence = sequence def _matches(self, item: T) -> bool: return item in self.sequence def describe_to(self, description: Description) -> None: description.append_text("one of ").append_list("(", ", ", ")", self.sequence) def is_in(sequence: Sequence[T]) -> Matcher[T]: """Matches if evaluated object is present in a given sequence. :param sequence: The sequence to search. This matcher invokes the ``in`` membership operator to determine if the evaluated object is a member of the sequence. """ return IsIn(sequence) isdict_containingkey.py 0000644 00000003445 15030502773 0011327 0 ustar 00 from typing import Any, Hashable, Mapping, TypeVar, Union from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" K = TypeVar("K", bound=Hashable) class IsDictContainingKey(BaseMatcher[Mapping[K, Any]]): def __init__(self, key_matcher: Matcher[K]) -> None: self.key_matcher = key_matcher def _matches(self, item: Mapping[K, Any]) -> bool: if hasmethod(item, "keys"): for key in item.keys(): if self.key_matcher.matches(key): return True return False def describe_to(self, description: Description) -> None: description.append_text("a dictionary containing key ").append_description_of( self.key_matcher ) def has_key(key_match: Union[K, Matcher[K]]) -> Matcher[Mapping[K, Any]]: """Matches if dictionary contains an entry whose key satisfies a given matcher. :param key_match: The matcher to satisfy for the key, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher iterates the evaluated dictionary, searching for any key-value entry whose key satisfies the given matcher. If a matching entry is found, ``has_key`` is satisfied. Any argument that is not a matcher is implicitly wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher to check for equality. Examples:: has_key(equal_to('foo')) has_key('foo') """ return IsDictContainingKey(wrap_matcher(key_match)) __init__.py 0000644 00000001146 15030502773 0006661 0 ustar 00 """Matchers of collections.""" from .is_empty import empty from .isdict_containing import has_entry from .isdict_containingentries import has_entries from .isdict_containingkey import has_key from .isdict_containingvalue import has_value from .isin import is_in from .issequence_containing import has_item, has_items from .issequence_containinginanyorder import contains_inanyorder from .issequence_containinginorder import contains, contains_exactly from .issequence_onlycontaining import only_contains __author__ = "Chris Rose" __copyright__ = "Copyright 2013 hamcrest.org" __license__ = "BSD, see License.txt"
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings