File manager - Edit - /home/newsbmcs.com/public_html/static/img/logo/hamcrest.zip
Back
PK e��Z���] ] $ __pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ s$ d dl T d dlT dZdZdZdZdS )� )�*z2.0.2z Chris RosezCopyright 2020 hamcrest.orgzBSD, see License.txtN)� hamcrest.core�hamcrest.library� __version__� __author__� __copyright__� __license__� r r �3/usr/lib/python3/dist-packages/hamcrest/__init__.py�<module> s PK e��Z py.typednu �[��� PK e��Z���~ ~ core/selfdescribing.pynu �[��� from hamcrest.core.description import Description __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class SelfDescribing: """The ability of an object to describe itself.""" def describe_to(self, description: Description) -> None: """Generates a description of the object. The description may be part of a description of a larger object of which this is just a component, so it should be worded appropriately. :param description: The description to be built or appended to. """ raise NotImplementedError("describe_to") PK e��Z^�mot t 1 core/__pycache__/base_description.cpython-310.pycnu �[��� o (]^� � @ sf d dl mZmZ d dlmZ d dlmZ d dlmZ dZ dZ dZ G dd � d e�Z d e d e fd d �ZdS )� )�Any�Iterable)� Description)� hasmethod)�ismockzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sz e Zd ZdZdedefdd�Zdedefdd�Zd ed ed ed e e def d d�Z deddfdd�Z deddfdd�Z dS )�BaseDescriptionz`Base class for all :py:class:`~hamcrest.core.description.Description` implementations. �text�returnc C s | � |� | S )N)�append)�selfr � r �@/usr/lib/python3/dist-packages/hamcrest/core/base_description.py� append_text s zBaseDescription.append_text�valuec C s� t |�st|d�r|�| � | S t|t�r | �t|�� | S t|�}|d d� dkr9|dd � dkr9| �|� | S | �d� | �|� | �d� | S )N� describe_to� �<����>)r r r � isinstance�strr �repr)r r � descriptionr r r �append_description_of s � � � z%BaseDescription.append_description_of�start� separator�end�listc C sB d}| � |� |D ]}|r| � |� | �|� d}q | � |� | S )NFT)r r )r r r r r �separate�itemr r r � append_list% s zBaseDescription.append_list�stringNc C s t d��)z%Append the string to the description.r )�NotImplementedError)r r! r r r r 1 s zBaseDescription.appendc C s0 | � d� |D ] }| � t|�� q| � d� d S )N�')r �character_in_python_syntax)r r! �chr r r � append_string_in_python_syntax5 s z.BaseDescription.append_string_in_python_syntax) �__name__� __module__� __qualname__�__doc__r r r r r r r r r& r r r r r s " r r% r c C s4 | dkrdS | dkr dS | dkrdS | dkrdS | S )Nr# � z\n� z\r� z\tr )r% r r r r$ < s r$ N)�typingr r �hamcrest.core.descriptionr � hamcrest.core.helpers.hasmethodr � hamcrest.core.helpers.ismockr � __author__� __copyright__� __license__r r r$ r r r r �<module> s 0PK e��Z a8� � 4 core/__pycache__/selfdescribingvalue.cpython-310.pycnu �[��� o (]^� � @ sL d dl Z d dlmZ d dlmZ d dlmZ dZdZdZ G dd � d e�Z dS ) � N)�Any)� Description)�SelfDescribingzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ s4 e Zd ZdZdeddfdd�Zdeddfdd �ZdS ) �SelfDescribingValuea( Wrap any value in a ``SelfDescribingValue`` to satisfy the :py:class:`~hamcrest.core.selfdescribing.SelfDescribing` interface. **Deprecated:** No need for this class now that :py:meth:`~hamcrest.core.description.Description.append_description_of` handles any type of value. �value�returnNc C s t �dt� || _d S )Nz$SelfDescribingValue no longer needed)�warnings�warn�DeprecationWarningr )�selfr � r �C/usr/lib/python3/dist-packages/hamcrest/core/selfdescribingvalue.py�__init__ s z SelfDescribingValue.__init__� descriptionc C s |� | j� dS )z%Generates a description of the value.N)�append_description_ofr )r r r r r � describe_to s z SelfDescribingValue.describe_to)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r ) r �typingr �hamcrest.core.descriptionr � hamcrest.core.selfdescribingr � __author__� __copyright__� __license__r r r r r �<module> s PK e��Z|� + + ( core/__pycache__/matcher.cpython-310.pycnu �[��� o (]^h � @ sZ d dl mZmZmZ d dlmZ ddlmZ dZdZ dZ ed�Z G d d � d ee e�Z d S ) � )�Generic�Optional�TypeVar)� Description� )�SelfDescribingzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sX e Zd ZdZd dedee defdd�Zdededdfdd �Z ded eddfd d �Z dS )�Matchera� A matcher over acceptable values. A matcher is able to describe itself to give feedback when it fails. Matcher implementations should *not* directly implement this protocol. Instead, *extend* the :py:class:`~hamcrest.core.base_matcher.BaseMatcher` class, which will ensure that the :py:class:`~hamcrest.core.matcher.Matcher` API can grow to support new features and remain compatible with all :py:class:`~hamcrest.core.matcher.Matcher` implementations. N�item�mismatch_description�returnc C � t d��)a� Evaluates the matcher for argument item. If a mismatch is detected and argument ``mismatch_description`` is provided, it will generate a description of why the matcher has not accepted the item. :param item: The object against which the matcher is evaluated. :param mismatch_description: :returns: ``True`` if ``item`` matches, otherwise ``False``. �matches��NotImplementedError��selfr r � r �7/usr/lib/python3/dist-packages/hamcrest/core/matcher.pyr s zMatcher.matchesc C r )a� Generates a description of why the matcher has not accepted the item. The description will be part of a larger description of why a matching failed, so it should be concise. This method assumes that ``matches(item)`` is ``False``, but will not check this. :param item: The item that the :py:class:`~hamcrest.core.matcher.Matcher` has rejected. :param mismatch_description: The description to be built or appended to. �describe_mismatchr r r r r r * s zMatcher.describe_mismatch�match_descriptionc C r )a� Generates a description of why the matcher has accepted the item. The description may be part of a larger description of why a matching failed, so it should be concise. This method assumes that ``matches(item)`` is ``True``, but will not check this. :param item: The item that the :py:class:`~hamcrest.core.matcher.Matcher` has accepted. :param match_description: The description to be built or appended to. �describe_matchr )r r r r r r r < s zMatcher.describe_match)N) �__name__� __module__� __qualname__�__doc__r r r �boolr r r r r r r r s r N) �typingr r r �hamcrest.core.descriptionr �selfdescribingr � __author__� __copyright__� __license__r r r r r r �<module> s PK e��Z��|l l ) core/__pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ s$ d dl mZ d dlT dZdZdZdS )� )� assert_that)�*zJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN)�hamcrest.core.assert_thatr �hamcrest.core.core� __author__� __copyright__� __license__� r r �8/usr/lib/python3/dist-packages/hamcrest/core/__init__.py�<module> s PK e��Z�f� - core/__pycache__/base_matcher.cpython-310.pycnu �[��� o (]^� � @ s` d dl mZmZ d dlmZ d dlmZ d dlmZ dZ dZ dZ ed�Z G d d � d ee �Z d S ) � )�Optional�TypeVar)� Description)�Matcher��tostringzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sx e Zd ZdZdefdd�Zdedefdd�Zdded e e defd d �Z ded e ddfd d �Z dede ddfdd�Z dS )� BaseMatchera� Base class for all :py:class:`~hamcrest.core.matcher.Matcher` implementations. Most implementations can just implement :py:obj:`_matches`, leaving the handling of any mismatch description to the ``matches`` method. But if it makes more sense to generate the mismatch description during the matching, override :py:meth:`~hamcrest.core.matcher.Matcher.matches` instead. �returnc C s t | �S �Nr )�self� r �</usr/lib/python3/dist-packages/hamcrest/core/base_matcher.py�__str__ � zBaseMatcher.__str__�itemc C s t d��)N�_matches)�NotImplementedError)r r r r r r r zBaseMatcher._matchesN�mismatch_descriptionc C s" | � |�}|s|r| �||� |S r )r �describe_mismatch)r r r � match_resultr r r �matches s zBaseMatcher.matchesc C � |� d��|� d S �Nzwas �� append_text�append_description_of)r r r r r r r % � z BaseMatcher.describe_mismatch�match_descriptionc C r r r )r r r r r r �describe_match( r zBaseMatcher.describe_matchr )�__name__� __module__� __qualname__�__doc__�strr r �boolr r r r r r r r r r r s r N)�typingr r �hamcrest.core.descriptionr �hamcrest.core.matcherr � hamcrest.core.string_descriptionr � __author__� __copyright__� __license__r r r r r r �<module> s PK e��Z��� � , core/__pycache__/description.cpython-310.pycnu �[��� o (]^ � @ s2 d dl mZmZmZ dZdZdZG dd� d�ZdS )� )�Any�Iterable�SequencezJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sV e Zd ZdZdedd fdd�Zdedd fdd�Zd ed ed ed ee dd f d d�Z dS )� Descriptionz�A description of a :py:class:`~hamcrest.core.matcher.Matcher`. A :py:class:`~hamcrest.core.matcher.Matcher` will describe itself to a description which can later be used for reporting. �text�returnc C � t d��)z_Appends some plain text to the description. :returns: ``self``, for chaining � append_text��NotImplementedError)�selfr � r �;/usr/lib/python3/dist-packages/hamcrest/core/description.pyr s zDescription.append_text�valuec C r )z�Appends description of given value to this description. If the value implements :py:meth:`~hamcrest.core.selfdescribing.SelfDescribing.describe_to`, then it will be used. :returns: ``self``, for chaining �append_description_ofr )r r r r r r s z!Description.append_description_of�start� separator�end�listc C r )az Appends a list of objects to the description. :param start: String that will begin the list description. :param separator: String that will separate each object in the description. :param end: String that will end the list description. :param list: List of objects to be described. :returns: ``self``, for chaining � append_listr )r r r r r r r r r $ s zDescription.append_listN) �__name__� __module__� __qualname__�__doc__�strr r r r r r r r r r s �����r N)�typingr r r � __author__� __copyright__� __license__r r r r r �<module> s PK e��Z�c�� / core/__pycache__/selfdescribing.cpython-310.pycnu �[��� o (]^~ � @ s* d dl mZ dZdZdZG dd� d�ZdS )� )� DescriptionzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ s" e Zd ZdZdeddfdd�ZdS )�SelfDescribingz,The ability of an object to describe itself.� description�returnNc C s t d��)a Generates a description of the object. The description may be part of a description of a larger object of which this is just a component, so it should be worded appropriately. :param description: The description to be built or appended to. � describe_to)�NotImplementedError)�selfr � r �>/usr/lib/python3/dist-packages/hamcrest/core/selfdescribing.pyr s zSelfDescribing.describe_to)�__name__� __module__� __qualname__�__doc__r r r r r r r s r N)�hamcrest.core.descriptionr � __author__� __copyright__� __license__r r r r r �<module> s PK e��Z䝮] ] , core/__pycache__/assert_that.cpython-310.pycnu �[��� o (]^ � @ s� d dl Z d dlmZmZmZmZ d dlmZ d dlm Z dZ dZ dZ dZ dZed �Zedd ed ee d eddfdd��Zedded eddfdd��Zddd�Zd ed ee d eddfdd�Zdded ee ddfdd�ZdS )� N)�Optional�TypeVar�cast�overload)�Matcher)�StringDescriptionzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtT�T� �actual�matcher�reason�returnc C � d S �N� �r r r r r �;/usr/lib/python3/dist-packages/hamcrest/core/assert_that.py� assert_that � r � assertionc C r r r �r r r r r r r c C sV t |t�rt| ||d� dS t | t�r t�d�t| ��� ttt | �tt |�d� dS )a� Asserts that actual value satisfies matcher. (Can also assert plain boolean condition.) :param actual: The object to evaluate as the actual value. :param matcher: The matcher to satisfy as the expected condition. :param reason: Optional explanation to include in failure description. ``assert_that`` passes the actual value to the matcher for evaluation. If the matcher is not satisfied, an exception is thrown describing the mismatch. ``assert_that`` is designed to integrate well with PyUnit and other unit testing frameworks. The exception raised for an unmet assertion is an :py:exc:`AssertionError`, which PyUnit reports as a test failure. With a different set of parameters, ``assert_that`` can also verify a boolean condition: .. function:: assert_that(assertion[, reason]) :param assertion: Boolean condition to verify. :param reason: Optional explanation to include in failure description. This is equivalent to the :py:meth:`~unittest.TestCase.assertTrue` method of :py:class:`unittest.TestCase`, but offers greater flexibility in test writing by being a standalone function. r z"arg1 should be boolean, but was {}r N) � isinstancer � _assert_match�warnings�warn�format�type� _assert_boolr �bool�strr r r r r s c C sN |� | �s%t� }|�|��d��|��d� |�| |� |�d� t|��d S )Nz Expected: z but: � )�matchesr � append_text�append_description_of�describe_mismatch�AssertionError)r r r � descriptionr r r r A s � �r c C s | s |sd}t |��d S )NzAssertion failed)r% r r r r r L s �r )r )Nr r )r �typingr r r r �hamcrest.core.matcherr � hamcrest.core.string_descriptionr � __author__� __copyright__� __license__� __unittest�__tracebackhide__r r r r r r r r r r �<module> s" " % PK e��Zu�6.% % 3 core/__pycache__/string_description.cpython-310.pycnu �[��� o (]^� � @ sJ d dl mZ ddlmZ dZdZdZdedefd d �ZG d d � d e�Z d S )� )�SelfDescribing� )�BaseDescriptionzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�selfdescribing�returnc C s t t� �| ��S )z�Returns the description of a :py:class:`~hamcrest.core.selfdescribing.SelfDescribing` object as a string. :param selfdescribing: The object to be described. :returns: The description of the object. )�str�StringDescription�append_description_of)r � r �B/usr/lib/python3/dist-packages/hamcrest/core/string_description.py�tostring s r c @ s: e Zd ZdZd dd�Zdefdd�Zdeddfd d �ZdS ) r zZA :py:class:`~hamcrest.core.description.Description` that is stored as a string. r Nc C s d| _ d S )N� ��out��selfr r r �__init__ s zStringDescription.__init__c C s | j S )zReturns the description.r r r r r �__str__ s zStringDescription.__str__�stringc C s | j t|�7 _ d S )N)r r )r r r r r �append" s zStringDescription.append)r N)�__name__� __module__� __qualname__�__doc__r r r r r r r r r s r N) � hamcrest.core.selfdescribingr �base_descriptionr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z �� core/description.pynu �[��� from typing import Any, Iterable, Sequence __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class Description: """A description of a :py:class:`~hamcrest.core.matcher.Matcher`. A :py:class:`~hamcrest.core.matcher.Matcher` will describe itself to a description which can later be used for reporting. """ def append_text(self, text: str) -> "Description": """Appends some plain text to the description. :returns: ``self``, for chaining """ raise NotImplementedError("append_text") def append_description_of(self, value: Any) -> "Description": """Appends description of given value to this description. If the value implements :py:meth:`~hamcrest.core.selfdescribing.SelfDescribing.describe_to`, then it will be used. :returns: ``self``, for chaining """ raise NotImplementedError("append_description_of") def append_list( self, start: str, separator: str, end: str, list: Iterable[Any] ) -> "Description": """Appends a list of objects to the description. :param start: String that will begin the list description. :param separator: String that will separate each object in the description. :param end: String that will end the list description. :param list: List of objects to be described. :returns: ``self``, for chaining """ raise NotImplementedError("append_list") PK e��ZC_> core/assert_that.pynu �[��� import warnings from typing import Optional, TypeVar, cast, overload from hamcrest.core.matcher import Matcher from hamcrest.core.string_description import StringDescription __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" # unittest integration; hide these frames from tracebacks __unittest = True # py.test integration; hide these frames from tracebacks __tracebackhide__ = True T = TypeVar("T") @overload def assert_that(actual: T, matcher: Matcher[T], reason: str = "") -> None: ... @overload def assert_that(assertion: bool, reason: str = "") -> None: ... def assert_that(actual, matcher=None, reason=""): """Asserts that actual value satisfies matcher. (Can also assert plain boolean condition.) :param actual: The object to evaluate as the actual value. :param matcher: The matcher to satisfy as the expected condition. :param reason: Optional explanation to include in failure description. ``assert_that`` passes the actual value to the matcher for evaluation. If the matcher is not satisfied, an exception is thrown describing the mismatch. ``assert_that`` is designed to integrate well with PyUnit and other unit testing frameworks. The exception raised for an unmet assertion is an :py:exc:`AssertionError`, which PyUnit reports as a test failure. With a different set of parameters, ``assert_that`` can also verify a boolean condition: .. function:: assert_that(assertion[, reason]) :param assertion: Boolean condition to verify. :param reason: Optional explanation to include in failure description. This is equivalent to the :py:meth:`~unittest.TestCase.assertTrue` method of :py:class:`unittest.TestCase`, but offers greater flexibility in test writing by being a standalone function. """ if isinstance(matcher, Matcher): _assert_match(actual=actual, matcher=matcher, reason=reason) else: if isinstance(actual, Matcher): warnings.warn("arg1 should be boolean, but was {}".format(type(actual))) _assert_bool(assertion=cast(bool, actual), reason=cast(str, matcher)) def _assert_match(actual: T, matcher: Matcher[T], reason: str) -> None: if not matcher.matches(actual): description = StringDescription() description.append_text(reason).append_text("\nExpected: ").append_description_of( matcher ).append_text("\n but: ") matcher.describe_mismatch(actual, description) description.append_text("\n") raise AssertionError(description) def _assert_bool(assertion: bool, reason: Optional[str] = None) -> None: if not assertion: if not reason: reason = "Assertion failed" raise AssertionError(reason) PK e��Z�<ެ � core/string_description.pynu �[��� from hamcrest.core.selfdescribing import SelfDescribing from .base_description import BaseDescription __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" def tostring(selfdescribing: SelfDescribing) -> str: """Returns the description of a :py:class:`~hamcrest.core.selfdescribing.SelfDescribing` object as a string. :param selfdescribing: The object to be described. :returns: The description of the object. """ return str(StringDescription().append_description_of(selfdescribing)) class StringDescription(BaseDescription): """A :py:class:`~hamcrest.core.description.Description` that is stored as a string. """ def __init__(self) -> None: self.out = "" def __str__(self) -> str: """Returns the description.""" return self.out def append(self, string: str) -> None: self.out += str(string) PK e��Z-� K� � core/selfdescribingvalue.pynu �[��� import warnings from typing import Any from hamcrest.core.description import Description from hamcrest.core.selfdescribing import SelfDescribing __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class SelfDescribingValue(SelfDescribing): """Wrap any value in a ``SelfDescribingValue`` to satisfy the :py:class:`~hamcrest.core.selfdescribing.SelfDescribing` interface. **Deprecated:** No need for this class now that :py:meth:`~hamcrest.core.description.Description.append_description_of` handles any type of value. """ def __init__(self, value: Any) -> None: warnings.warn("SelfDescribingValue no longer needed", DeprecationWarning) self.value = value def describe_to(self, description: Description) -> None: """Generates a description of the value.""" description.append_description_of(self.value) PK e��Z�2�'� � core/base_matcher.pynu �[��� from typing import Optional, TypeVar from hamcrest.core.description import Description from hamcrest.core.matcher import Matcher from hamcrest.core.string_description import tostring __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class BaseMatcher(Matcher[T]): """Base class for all :py:class:`~hamcrest.core.matcher.Matcher` implementations. Most implementations can just implement :py:obj:`_matches`, leaving the handling of any mismatch description to the ``matches`` method. But if it makes more sense to generate the mismatch description during the matching, override :py:meth:`~hamcrest.core.matcher.Matcher.matches` instead. """ def __str__(self) -> str: return tostring(self) def _matches(self, item: T) -> bool: raise NotImplementedError("_matches") def matches(self, item: T, mismatch_description: Optional[Description] = None) -> bool: match_result = self._matches(item) if not match_result and mismatch_description: self.describe_mismatch(item, mismatch_description) return match_result def describe_mismatch(self, item: T, mismatch_description: Description) -> None: mismatch_description.append_text("was ").append_description_of(item) def describe_match(self, item: T, match_description: Description) -> None: match_description.append_text("was ").append_description_of(item) PK e��Z�3H� core/core/allof.pynu �[��� from typing import Optional, 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 AllOf(BaseMatcher[T]): def __init__(self, *matchers: Matcher[T], **kwargs): self.matchers = matchers self.describe_matcher_in_mismatch = kwargs.pop( "describe_matcher_in_mismatch", True ) # No keyword-only args in 2.7 :-( self.describe_all_mismatches = kwargs.pop("describe_all_mismatches", False) def matches(self, item: T, mismatch_description: Optional[Description] = None) -> bool: found_mismatch = False for i, matcher in enumerate(self.matchers): if not matcher.matches(item): if mismatch_description: if self.describe_matcher_in_mismatch: mismatch_description.append_description_of(matcher).append_text(" ") matcher.describe_mismatch(item, mismatch_description) found_mismatch = True if not self.describe_all_mismatches: break elif i < len(self.matchers) - 1 and mismatch_description: mismatch_description.append_text(" and ") return not found_mismatch def describe_mismatch(self, item: T, mismatch_description: Description) -> None: self.matches(item, mismatch_description) def describe_to(self, description: Description) -> None: description.append_list("(", " and ", ")", self.matchers) def all_of(*items: Union[Matcher[T], T]) -> Matcher[T]: """Matches if all of the given matchers evaluate to ``True``. :param matcher1,...: A comma-separated list of matchers. The matchers are evaluated from left to right using short-circuit evaluation, so evaluation stops as soon as a matcher returns ``False``. 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. """ return AllOf(*[wrap_matcher(item) for item in items]) PK e��Z4�)4 4 core/core/anyof.pynu �[��� from typing import 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 AnyOf(BaseMatcher[T]): def __init__(self, *matchers: Matcher[T]) -> None: self.matchers = matchers def _matches(self, item: T) -> bool: for matcher in self.matchers: if matcher.matches(item): return True return False def describe_to(self, description: Description) -> None: description.append_list("(", " or ", ")", self.matchers) def any_of(*items: Union[Matcher[T], T]) -> Matcher[T]: """Matches if any of the given matchers evaluate to ``True``. :param matcher1,...: A comma-separated list of matchers. The matchers are evaluated from left to right using short-circuit evaluation, so evaluation stops as soon as a matcher returns ``True``. 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. """ return AnyOf(*[wrap_matcher(item) for item in items]) PK e��Zj�y�� � core/core/isinstanceof.pynu �[��� from typing import Type from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import is_matchable_type from hamcrest.core.matcher import Matcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class IsInstanceOf(BaseMatcher[object]): def __init__(self, expected_type: Type) -> None: if not is_matchable_type(expected_type): raise TypeError("IsInstanceOf requires type") self.expected_type = expected_type def _matches(self, item: object) -> bool: return isinstance(item, self.expected_type) def describe_to(self, description: Description) -> None: description.append_text("an instance of ").append_text(self.expected_type.__name__) def instance_of(atype: Type) -> Matcher[object]: """Matches if object is an instance of, or inherits from, a given type. :param atype: The type to compare against as the expected type. This matcher checks whether the evaluated object is an instance of ``atype`` or an instance of any class that inherits from ``atype``. Example:: instance_of(str) """ return IsInstanceOf(atype) PK e��Z@��M M + core/core/__pycache__/isnot.cpython-310.pycnu �[��� o (]^� � @ s* d dl mZmZmZmZ d dlmZ d dlmZ d dl m Z m Z d dl m Z ddlmZ dZd Zd Zed �ZG d d � d ee �Zedede e fdd��Zedede e fdd��Zdd� Zedede e fdd��Zedee e ef de e fdd��Zdd� Zdee e ef de e fdd�ZdS ) � )�Type�TypeVar�Union�overload)� BaseMatcher)� Description)�is_matchable_type� wrap_matcher)�Matcher� )� instance_ofzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ s\ e Zd Zdee ddfdd�Zdedefdd�Zd eddfd d �Z ded eddfd d�Z dS )�IsNot�matcher�returnNc C s || _ d S �N)r )�selfr � r �:/usr/lib/python3/dist-packages/hamcrest/core/core/isnot.py�__init__ s zIsNot.__init__�itemc C s | j �|� S r )r �matches)r r r r r �_matches s zIsNot._matches� descriptionc C s |� d��| j� d S )Nznot )� append_text�append_description_ofr )r r r r r � describe_to s zIsNot.describe_to�mismatch_descriptionc C s |� d� | j�||� d S )Nzbut )r r �describe_match)r r r r r r �describe_mismatch s zIsNot.describe_mismatch) �__name__� __module__� __qualname__r r r �boolr r r r r r r r r s r �xr c C � d S r r �r$ r r r �_wrap_value_or_type � r' c C r% r r r& r r r r' % r( c C s t | �rt| �S t| �S r )r r r r& r r r r' * s �matchc C r% r r �r) r r r �is_not1 r( r+ c C r% r r r* r r r r+ 6 r( c C s t t| ��S )a� Inverts the given matcher to its logical negation. :param match: The matcher to negate. This matcher compares the evaluated object to the negation of the given matcher. 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, and thus matches for inequality. Examples:: assert_that(cheese, is_not(equal_to(smelly))) assert_that(cheese, is_not(smelly)) )r r' r* r r r r+ ; s c C s t | �S )z�Alias of :py:func:`is_not` for better readability of negations. Examples:: assert_that(alist, not_(has_item(item))) )r+ r* r r r �not_N s r, N)�typingr r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr r �hamcrest.core.matcherr � isinstanceofr � __author__� __copyright__� __license__r r �objectr' r+ r, r r r r �<module> s, $&PK e��Z-Y 1 1 - core/core/__pycache__/isequal.cpython-310.pycnu �[��� o (]^ � @ sj d dl mZ d dlmZ d dlmZ d dlmZ dZdZ dZ G dd � d ee �Z d ed ee fd d �Z dS )� )�Any)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sB e Zd Zdeddfdd�Zdedefdd�Zd eddfd d �ZdS ) �IsEqual�equals�returnNc C s || _ d S �N��object)�selfr � r �</usr/lib/python3/dist-packages/hamcrest/core/core/isequal.py�__init__ � zIsEqual.__init__�itemc C s || j kS r r )r r r r r �_matches r zIsEqual._matches� descriptionc C s< t | jt�}|r |�d� |�| j� |r |�d� d S d S )N�<�>)� isinstancer r � append_text�append_description_of)r r �nested_matcherr r r � describe_to s �zIsEqual.describe_to) �__name__� __module__� __qualname__r r �boolr r r r r r r r s r �objr c C s t | �S )z�Matches if object is equal to a given object. :param obj: The object to compare against as the expected value. This matcher compares the evaluated object to ``obj`` for equality.)r )r r r r �equal_to s r N) �typingr �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r �<module> s PK e��Z��! ! 0 core/core/__pycache__/isanything.cpython-310.pycnu �[��� o (]^� � @ st d dl mZmZ d dlmZ d dlmZ d dlmZ dZ dZ dZ G dd � d ee �Z dd ee d ee fd d�Zd S )� )�Any�Optional)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sF e Zd Zdee ddfdd�Zdedefdd�Zde ddfd d �Z dS ) � IsAnything� description�returnNc C s |pd| _ d S )N�ANYTHING�r ��selfr � r �?/usr/lib/python3/dist-packages/hamcrest/core/core/isanything.py�__init__ s zIsAnything.__init__�itemc C s dS )NTr )r r r r r �_matches s zIsAnything._matchesc C s |� | j� d S �N)� append_textr r r r r � describe_to s zIsAnything.describe_to) �__name__� __module__� __qualname__r �strr r �boolr r r r r r r r s r Nr r c C s t | �S )z�Matches anything. :param description: Optional string used to describe this matcher. This matcher always evaluates to ``True``. Specify this in composite matchers when the value of a particular element is unimportant. )r r r r r �anything s r r )�typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z �x� � , core/core/__pycache__/raises.cpython-310.pycnu �[��� o (]^ � @ s� d dl Z d dlZd dlmZmZmZmZmZmZm Z d dl m Z d dl m Z d dlmZ d dlmZ dZdZd ZG d d � d e ed ef �Zdd ee deed ef fdd�ZG dd� de�Zded ef defdd�ZdS )� N)�Any�Callable�Mapping�Optional�Tuple�Type�cast)�ref)� BaseMatcher)� Description)�Matcherz Per FagrellzCopyright 2013 hamcrest.orgzBSD, see License.txtc @ s� e Zd Z ddee dee dee ddfdd�Zde d e f de fd d �Z de d e f de fd d �Z deddfdd�Zdeddfdd�Zdeddfdd�ZdS )�RaisesN�expected�pattern�matching�returnc C s" || _ || _|| _d | _d | _d S �N)r �matcherr �actual�function)�selfr r r � r �;/usr/lib/python3/dist-packages/hamcrest/core/core/raises.py�__init__ s zRaises.__init__r .c C s. t |�sdS ttdtf t|��| _| �|�S )NF.)�callabler r r r r �_call_function�r r r r r �_matches s zRaises._matchesc C s� d | _ z|� W dS tyG t�� d | _ t| j | j�rD| jd ur2t�| jt | j ��d u r2Y dS | j d urA| j � | j �sAY dS Y dS Y dS w )N� FT) r � BaseException�sys�exc_info� isinstancer r �re�search�strr �matchesr r r r r # s" � ��zRaises._call_function� descriptionc C s |� d| j � d S )Nz Expected a callable raising %s)� append_textr )r r' r r r � describe_to4 s zRaises.describe_toc C s. t |�s |�d| � d S | jd u rd n| �� }|d u s ||ur,t|�| _| �|�s,d S | jd u r8|�d� d S t| j| j�r�| jd usI| j d ur�|�d� | jd ur[|�d| j � | jd urj| j d urj|�d� | j d urz|� | j � |�d� |�dt | j� � d S d S |�d| jt | j�f � d S ) Nz%s is not callablezNo exception raised.z#Correct assertion type raised, but z the expected pattern ("%s") zand � z¬ found. Exception message was: "%s"z %r of type %s was raised instead) r r( r r r r r" r r r �append_description_ofr% �type)r �itemr' r r r r �describe_mismatch7 s2 � �zRaises.describe_mismatch�match_descriptionc C s( | � |� |�d| jt| j�f � d S )Nz%r of type %s was raised.)r r( r r, )r r- r/ r r r �describe_matchT s �zRaises.describe_match�NN)�__name__� __module__� __qualname__r � Exceptionr r% r r r r �boolr r r r) r. r0 r r r r r s" ���� � r .� exceptionr c C s t | ||�S )a� Matches if the called function raised the expected exception. :param exception: The class of the expected exception :param pattern: Optional regular expression to match exception message. :param matching: Optional Hamcrest matchers to apply to the exception. Expects the actual to be wrapped by using :py:func:`~hamcrest.core.core.raises.calling`, or a callable taking no arguments. Optional argument pattern should be a string containing a regular expression. If provided, the string representation of the actual exception - e.g. `str(actual)` - must match pattern. Examples:: assert_that(calling(int).with_args('q'), raises(TypeError)) assert_that(calling(parse, broken_input), raises(ValueError)) assert_that( calling(valid_user, bad_json), raises(HTTPError, matching=has_properties(status_code=500) ) )r )r7 r r r r r �raises[ s r8 c @ s2 e Zd Zdedef fdd�Zdd� Zdd� Zd S ) �DeferredCallable�func.c C s || _ t� | _i | _d S r )r: �tuple�args�kwargs)r r: r r r r t s zDeferredCallable.__init__c C s | j | ji | j�� d S r )r: r< r= )r r r r �__call__y s zDeferredCallable.__call__c O s || _ || _| S r )r< r= )r r< r= r r r � with_args| s zDeferredCallable.with_argsN)r2 r3 r4 r r r r> r? r r r r r9 s s r9 r: c C s t | �S )a� Wrapper for function call that delays the actual execution so that :py:func:`~hamcrest.core.core.raises.raises` matcher can catch any thrown exception. :param func: The function or method to be called The arguments can be provided with a call to the `with_args` function on the returned object:: calling(my_method).with_args(arguments, and_='keywords') )r9 )r: r r r �calling� s r@ r1 )r# r �typingr r r r r r r �weakrefr �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r5 r8 �objectr9 r@ r r r r �<module> s $ $L PK e��Z8�&� . core/core/__pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ s� d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ dd lmZmZ dd lmZmZ dd lmZ dd lmZmZ d ZdZdZ dS )zCFundamental matchers of objects and values, and composite matchers.� )�all_of)�any_of)� described_as)�is_)�anything)�equal_to)� instance_of)�none�not_none)�is_not�not_)� same_instance)�calling�raiseszJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN) �__doc__�hamcrest.core.core.allofr �hamcrest.core.core.anyofr � hamcrest.core.core.described_asr �hamcrest.core.core.is_r � hamcrest.core.core.isanythingr �hamcrest.core.core.isequalr � hamcrest.core.core.isinstanceofr �hamcrest.core.core.isnoner r �hamcrest.core.core.isnotr r �hamcrest.core.core.issamer �hamcrest.core.core.raisesr r � __author__� __copyright__� __license__� r r �=/usr/lib/python3/dist-packages/hamcrest/core/core/__init__.py�<module> s PK e��Zas3u/ / + core/core/__pycache__/allof.cpython-310.pycnu �[��� o (]^ � @ s� d dl mZmZmZ d dlmZ d dlmZ d dlm Z d dl m Z dZ dZ dZed �ZG d d � d ee �Zd ee e ef d e e fdd�ZdS )� )�Optional�TypeVar�Union)� BaseMatcher)� Description�� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sb e Zd Zdee fdd�Zddedee defdd �Z dededdfd d �Z d eddfd d�Z dS )�AllOf�matchersc O s& || _ |�dd�| _|�dd�| _d S )N� describe_matcher_in_mismatchT�describe_all_mismatchesF)r �popr r )�selfr �kwargs� r �:/usr/lib/python3/dist-packages/hamcrest/core/core/allof.py�__init__ s �zAllOf.__init__N�item�mismatch_description�returnc C s� d}t | j�D ]5\}}|�|�s<|r#| jr |�|��d� |�||� d}| js, | S |t| j�d k r<|r<|�d� q| S )NF� T� � and ) � enumerater �matchesr �append_description_of� append_text�describe_mismatchr �len)r r r �found_mismatch�i�matcherr r r r s � �z AllOf.matchesc C s | � ||� d S �N)r )r r r r r r r & s zAllOf.describe_mismatch� descriptionc C s |� ddd| j� d S )N�(r �))� append_listr )r r% r r r � describe_to) s zAllOf.describe_tor$ ) �__name__� __module__� __qualname__r r r r r �boolr r r) r r r r r s r �itemsr c G s t dd� | D �� S )a� Matches if all of the given matchers evaluate to ``True``. :param matcher1,...: A comma-separated list of matchers. The matchers are evaluated from left to right using short-circuit evaluation, so evaluation stops as soon as a matcher returns ``False``. 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. c S s g | ]}t |��qS r r )�.0r r r r � <listcomp>: s zall_of.<locals>.<listcomp>)r )r. r r r �all_of- s r1 N)�typingr r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r1 r r r r �<module> s & PK e��Z$E� � + core/core/__pycache__/anyof.cpython-310.pycnu �[��� o (]^4 � @ s� d dl mZmZ d dlmZ d dlmZ d dlmZ d dl m Z dZ dZ dZ ed �ZG d d � d ee �Zd ee e ef d e e fdd�ZdS )� )�TypeVar�Union)� BaseMatcher)� Description�� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sF e Zd Zdee ddfdd�Zdedefdd�Zd eddfd d �Z dS ) �AnyOf�matchers�returnNc G s || _ d S )N)r )�selfr � r �:/usr/lib/python3/dist-packages/hamcrest/core/core/anyof.py�__init__ s zAnyOf.__init__�itemc C s | j D ] }|�|�r dS qdS )NTF)r �matches)r r �matcherr r r �_matches s �zAnyOf._matches� descriptionc C s |� ddd| j� d S )N�(z or �))� append_listr )r r r r r � describe_to s zAnyOf.describe_to) �__name__� __module__� __qualname__r r r �boolr r r r r r r r s r �itemsr c G s t dd� | D �� S )a� Matches if any of the given matchers evaluate to ``True``. :param matcher1,...: A comma-separated list of matchers. The matchers are evaluated from left to right using short-circuit evaluation, so evaluation stops as soon as a matcher returns ``True``. 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. c S s g | ]}t |��qS r r )�.0r r r r � <listcomp>* s zany_of.<locals>.<listcomp>)r )r r r r �any_of s r! N)�typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r! r r r r �<module> s &PK e��Z{1nv v 2 core/core/__pycache__/described_as.cpython-310.pycnu �[��� o (]^� � @ s� d dl Z d dlmZmZmZ d dlmZ d dlmZ d dl m Z dZ dZ dZ e �d �ZG d d � d ee �Zd ed e e de e fdd�ZdS )� N)�Any�Optional�Tuple)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtz %([0-9]+)c @ sv e Zd Zdedee deedf ddfdd�Zdd ed ee de fd d �Z d ed e ddfd d�Z de ddfdd�Z dS )� DescribedAs�description_template�matcher�values.�returnNc G s || _ || _|| _d S �N)�templater r )�selfr r r � r �A/usr/lib/python3/dist-packages/hamcrest/core/core/described_as.py�__init__ s zDescribedAs.__init__�item�mismatch_descriptionc C s | j �||�S r )r �matches�r r r r r r r s zDescribedAs.matchesc C s | j �||� d S r )r �describe_mismatchr r r r r s z DescribedAs.describe_mismatch� descriptionc C s� d}t �t| j�D ]$}|�| j||�� � � t|�� dd � �}|�| j | � |� � }q |t | j�k rA|�| j|d � � d S d S )Nr � ) �re�finditer� ARG_PATTERNr � append_text�start�int�group�append_description_ofr �end�len)r r � text_start�match� arg_indexr r r � describe_to s �zDescribedAs.describe_tor )�__name__� __module__� __qualname__�strr r r r r r �boolr r r' r r r r r s �� � � r r r r c G s t | |g|�R � S )az Adds custom failure description to a given matcher. :param description: Overrides the matcher's description. :param matcher: The matcher to satisfy. :param value1,...: Optional comma-separated list of substitution values. The description may contain substitution placeholders %0, %1, etc. These will be replaced by any values that follow the matcher. )r )r r r r r r � described_as) s r- )r �typingr r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__�compiler r r+ r- r r r r �<module> s "PK e��Z�t�94 4 2 core/core/__pycache__/isinstanceof.cpython-310.pycnu �[��� o (]^� � @ sv d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z dZ dZ dZ G d d � d ee �Zd ed e e fd d�ZdS )� )�Type)� BaseMatcher)� Description)�is_matchable_type)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sB e Zd Zdeddfdd�Zdedefdd�Zd eddfd d �Z dS ) � IsInstanceOf� expected_type�returnNc C s t |�std��|| _d S )NzIsInstanceOf requires type)r � TypeErrorr )�selfr � r �A/usr/lib/python3/dist-packages/hamcrest/core/core/isinstanceof.py�__init__ s zIsInstanceOf.__init__�itemc C s t || j�S )N)� isinstancer )r r r r r �_matches s zIsInstanceOf._matches� descriptionc C s |� d�� | jj� d S )Nzan instance of )� append_textr �__name__)r r r r r � describe_to s zIsInstanceOf.describe_to) r � __module__� __qualname__r r �object�boolr r r r r r r r s r �atyper c C s t | �S )aH Matches if object is an instance of, or inherits from, a given type. :param atype: The type to compare against as the expected type. This matcher checks whether the evaluated object is an instance of ``atype`` or an instance of any class that inherits from ``atype``. Example:: instance_of(str) )r )r r r r � instance_of s r N)�typingr �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z�}; ; ) core/core/__pycache__/is_.cpython-310.pycnu �[��� o (]^� � @ s d dl mZmZmZmZmZ d dlmZ d dlm Z d dl m Z m Z d dl mZ ddlmZ dZd Zd Zed �ZG d d � d ee �Zededee fdd��Zededee fdd��Zdd� Zededee fdd��Zedeee ef dee fdd��Zdd� ZdS )� )�Optional�Type�TypeVar�Union�overload)� BaseMatcher)� Description)�is_matchable_type� wrap_matcher)�Matcher� )� instance_ofzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sb e Zd Zdee ddfdd�Zddedee defdd �Z dededdfd d �Z d efd d�Z dS )�Is�matcher�returnNc C s || _ d S �N)r )�selfr � r �8/usr/lib/python3/dist-packages/hamcrest/core/core/is_.py�__init__ s z Is.__init__�item�mismatch_descriptionc C � | j �||�S r )r �matches�r r r r r r r � z Is.matchesc C r r )r �describe_mismatchr r r r r r zIs.describe_mismatch� descriptionc C s |� | j� d S r )�append_description_ofr )r r r r r � describe_to s zIs.describe_tor ) �__name__� __module__� __qualname__r r r r r �boolr r r r r r r r s r �xr c C � d S r r �r% r r r �_wrap_value_or_type � r( c C r& r r r' r r r r( $ r) c C s t | �rt| �S t| �S r )r r r r' r r r r( ) s c C r& r r r' r r r �is_0 r) r* c C r& r r r' r r r r* 5 r) c C s t t| ��S )a= Decorates another matcher, or provides shortcuts to the frequently used ``is(equal_to(x))`` and ``is(instance_of(x))``. :param x: The matcher to satisfy, or a type for :py:func:`~hamcrest.core.core.isinstanceof.instance_of` matching, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher compares the evaluated object to the given matcher. .. note:: PyHamcrest's ``is_`` matcher is unrelated to Python's ``is`` operator. The matcher for object identity is :py:func:`~hamcrest.core.core.issame.same_instance`. If the ``x`` argument is a matcher, its behavior is retained, but the test may be more expressive. For example:: assert_that(value, less_than(5)) assert_that(value, is_(less_than(5))) If the ``x`` argument is a type, it is wrapped in an :py:func:`~hamcrest.core.core.isinstanceof.instance_of` matcher. This makes the following statements equivalent:: assert_that(cheese, instance_of(Cheddar)) assert_that(cheese, is_(instance_of(Cheddar))) assert_that(cheese, is_(Cheddar)) Otherwise, if the ``x`` argument is not a matcher, it is wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher. This makes the following statements equivalent:: assert_that(cheese, equal_to(smelly)) assert_that(cheese, is_(equal_to(smelly))) assert_that(cheese, is_(smelly)) Choose the style that makes your expression most readable. This will vary depending on context. )r r( r' r r r r* : s +N)�typingr r r r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr r �hamcrest.core.matcherr � isinstanceofr � __author__� __copyright__� __license__r r �objectr( r* r r r r �<module> s* $ PK e��Z%^[�V V , core/core/__pycache__/isnone.cpython-310.pycnu �[��� o (]^� � @ s� d dl mZmZ d dlmZ d dlmZ d dlmZ ddl m Z dZ dZ d Z G d d � d eee �Zd eee fd d�Zd eee fdd�ZdS )� )�Any�Optional)� BaseMatcher)� Description)�Matcher� )�is_notzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ s0 e Zd Zdedefdd�Zdeddfdd�ZdS ) �IsNone�item�returnc C s |d u S )N� )�selfr r r �;/usr/lib/python3/dist-packages/hamcrest/core/core/isnone.py�_matches s zIsNone._matches� descriptionNc C s |� d� d S )N�None)� append_text)r r r r r � describe_to s zIsNone.describe_to)�__name__� __module__� __qualname__r �boolr r r r r r r r s r r c C s t � S )z Matches if object is ``None``.)r r r r r �none s r c C s t t� �S )z"Matches if object is not ``None``.)r r r r r r �not_none s r N)�typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr �isnotr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��ZTe�� � , core/core/__pycache__/issame.cpython-310.pycnu �[��� o (]^@ � @ sr d dl mZ d dlmZ d dlmZ d dlmZ dZdZ dZ ed�Z G d d � d ee �Z d e d ee fd d�Z dS )� )�TypeVar)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�Tc @ sX e Zd Zdeddfdd�Zdedefdd�Zd eddfd d �Zded eddfd d�Z dS )�IsSame�obj�returnNc C s || _ d S �N��object)�selfr � r �;/usr/lib/python3/dist-packages/hamcrest/core/core/issame.py�__init__ � zIsSame.__init__�itemc C s || j u S r r )r r r r r �_matches r zIsSame._matches� descriptionc C s, |� d�� tt| j���� d��| j� d S )Nzsame instance as � )� append_text�hex�idr �append_description_of)r r r r r � describe_to s �zIsSame.describe_to�mismatch_descriptionc C s8 |� d� |d ur|� tt|���� d� |�|� d S )Nzwas r )r r r r )r r r r r r �describe_mismatch s zIsSame.describe_mismatch) �__name__� __module__� __qualname__r r �boolr r r r r r r r r s r r r c C s t | �S )a Matches if evaluated object is the same instance as a given object. :param obj: The object to compare against as the expected value. This matcher invokes the ``is`` identity operator to determine if the evaluated object is the the same object as ``obj``. )r )r r r r � same_instance! s r! N)�typingr �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r! r r r r �<module> s PK e��Zʒ.]� � core/core/described_as.pynu �[��� import re from typing import Any, Optional, Tuple 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" ARG_PATTERN = re.compile("%([0-9]+)") class DescribedAs(BaseMatcher[Any]): def __init__( self, description_template: str, matcher: Matcher[Any], *values: Tuple[Any, ...] ) -> None: self.template = description_template self.matcher = matcher self.values = values def matches(self, item: Any, mismatch_description: Optional[Description] = None) -> bool: return self.matcher.matches(item, mismatch_description) def describe_mismatch(self, item: Any, mismatch_description: Description) -> None: self.matcher.describe_mismatch(item, mismatch_description) def describe_to(self, description: Description) -> None: text_start = 0 for match in re.finditer(ARG_PATTERN, self.template): description.append_text(self.template[text_start : match.start()]) arg_index = int(match.group()[1:]) description.append_description_of(self.values[arg_index]) text_start = match.end() if text_start < len(self.template): description.append_text(self.template[text_start:]) def described_as(description: str, matcher: Matcher[Any], *values) -> Matcher[Any]: """Adds custom failure description to a given matcher. :param description: Overrides the matcher's description. :param matcher: The matcher to satisfy. :param value1,...: Optional comma-separated list of substitution values. The description may contain substitution placeholders %0, %1, etc. These will be replaced by any values that follow the matcher. """ return DescribedAs(description, matcher, *values) PK e��Z�A��@ @ core/core/issame.pynu �[��� from typing import 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 IsSame(BaseMatcher[T]): def __init__(self, obj: T) -> None: self.object = obj def _matches(self, item: T) -> bool: return item is self.object def describe_to(self, description: Description) -> None: description.append_text("same instance as ").append_text(hex(id(self.object))).append_text( " " ).append_description_of(self.object) def describe_mismatch(self, item: T, mismatch_description: Description) -> None: mismatch_description.append_text("was ") if item is not None: mismatch_description.append_text(hex(id(item))).append_text(" ") mismatch_description.append_description_of(item) def same_instance(obj: T) -> Matcher[T]: """Matches if evaluated object is the same instance as a given object. :param obj: The object to compare against as the expected value. This matcher invokes the ``is`` identity operator to determine if the evaluated object is the the same object as ``obj``. """ return IsSame(obj) PK e��ZiN�s� � core/core/isanything.pynu �[��� from typing import Any, Optional 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" class IsAnything(BaseMatcher[Any]): def __init__(self, description: Optional[str]) -> None: self.description = description or "ANYTHING" # type: str def _matches(self, item: Any) -> bool: return True def describe_to(self, description: Description) -> None: description.append_text(self.description) def anything(description: Optional[str] = None) -> Matcher[Any]: """Matches anything. :param description: Optional string used to describe this matcher. This matcher always evaluates to ``True``. Specify this in composite matchers when the value of a particular element is unimportant. """ return IsAnything(description) PK e��Z�3�� � core/core/isnot.pynu �[��� from typing import Type, TypeVar, Union, overload from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import is_matchable_type, wrap_matcher from hamcrest.core.matcher import Matcher from .isinstanceof import instance_of __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class IsNot(BaseMatcher[T]): def __init__(self, matcher: Matcher[T]) -> None: self.matcher = matcher def _matches(self, item: T) -> bool: return not self.matcher.matches(item) def describe_to(self, description: Description) -> None: description.append_text("not ").append_description_of(self.matcher) def describe_mismatch(self, item: T, mismatch_description: Description) -> None: mismatch_description.append_text("but ") self.matcher.describe_match(item, mismatch_description) @overload def _wrap_value_or_type(x: Type) -> Matcher[object]: ... @overload def _wrap_value_or_type(x: T) -> Matcher[T]: ... def _wrap_value_or_type(x): if is_matchable_type(x): return instance_of(x) else: return wrap_matcher(x) @overload def is_not(match: Type) -> Matcher[object]: ... @overload def is_not(match: Union[Matcher[T], T]) -> Matcher[T]: ... def is_not(match): """Inverts the given matcher to its logical negation. :param match: The matcher to negate. This matcher compares the evaluated object to the negation of the given matcher. 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, and thus matches for inequality. Examples:: assert_that(cheese, is_not(equal_to(smelly))) assert_that(cheese, is_not(smelly)) """ return IsNot(_wrap_value_or_type(match)) def not_(match: Union[Matcher[T], T]) -> Matcher[T]: """Alias of :py:func:`is_not` for better readability of negations. Examples:: assert_that(alist, not_(has_item(item))) """ return is_not(match) PK e��Z�) core/core/raises.pynu �[��� import re import sys from typing import Any, Callable, Mapping, Optional, Tuple, Type, cast from weakref import ref from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.matcher import Matcher __author__ = "Per Fagrell" __copyright__ = "Copyright 2013 hamcrest.org" __license__ = "BSD, see License.txt" class Raises(BaseMatcher[Callable[..., Any]]): def __init__( self, expected: Type[Exception], pattern: Optional[str] = None, matching: Optional[Matcher] = None, ) -> None: self.pattern = pattern self.matcher = matching self.expected = expected self.actual = None # type: Optional[BaseException] self.function = None # type: Optional[Callable[..., Any]] def _matches(self, function: Callable[..., Any]) -> bool: if not callable(function): return False self.function = cast(Callable[..., Any], ref(function)) return self._call_function(function) def _call_function(self, function: Callable[..., Any]) -> bool: self.actual = None try: function() except BaseException: self.actual = sys.exc_info()[1] if isinstance(self.actual, self.expected): if self.pattern is not None: if re.search(self.pattern, str(self.actual)) is None: return False if self.matcher is not None: if not self.matcher.matches(self.actual): return False return True return False def describe_to(self, description: Description) -> None: description.append_text("Expected a callable raising %s" % self.expected) def describe_mismatch(self, item, description: Description) -> None: if not callable(item): description.append_text("%s is not callable" % item) return function = None if self.function is None else self.function() if function is None or function is not item: self.function = ref(item) if not self._call_function(item): return if self.actual is None: description.append_text("No exception raised.") elif isinstance(self.actual, self.expected): if self.pattern is not None or self.matcher is not None: description.append_text("Correct assertion type raised, but ") if self.pattern is not None: description.append_text('the expected pattern ("%s") ' % self.pattern) if self.pattern is not None and self.matcher is not None: description.append_text("and ") if self.matcher is not None: description.append_description_of(self.matcher) description.append_text(" ") description.append_text('not found. Exception message was: "%s"' % str(self.actual)) else: description.append_text( "%r of type %s was raised instead" % (self.actual, type(self.actual)) ) def describe_match(self, item, match_description: Description) -> None: self._call_function(item) match_description.append_text( "%r of type %s was raised." % (self.actual, type(self.actual)) ) def raises(exception: Type[Exception], pattern=None, matching=None) -> Matcher[Callable[..., Any]]: """Matches if the called function raised the expected exception. :param exception: The class of the expected exception :param pattern: Optional regular expression to match exception message. :param matching: Optional Hamcrest matchers to apply to the exception. Expects the actual to be wrapped by using :py:func:`~hamcrest.core.core.raises.calling`, or a callable taking no arguments. Optional argument pattern should be a string containing a regular expression. If provided, the string representation of the actual exception - e.g. `str(actual)` - must match pattern. Examples:: assert_that(calling(int).with_args('q'), raises(TypeError)) assert_that(calling(parse, broken_input), raises(ValueError)) assert_that( calling(valid_user, bad_json), raises(HTTPError, matching=has_properties(status_code=500) ) """ return Raises(exception, pattern, matching) class DeferredCallable(object): def __init__(self, func: Callable[..., Any]): self.func = func self.args = tuple() # type: Tuple[Any, ...] self.kwargs = {} # type: Mapping[str, Any] def __call__(self): self.func(*self.args, **self.kwargs) def with_args(self, *args, **kwargs): self.args = args self.kwargs = kwargs return self def calling(func: Callable[..., Any]) -> DeferredCallable: """Wrapper for function call that delays the actual execution so that :py:func:`~hamcrest.core.core.raises.raises` matcher can catch any thrown exception. :param func: The function or method to be called The arguments can be provided with a call to the `with_args` function on the returned object:: calling(my_method).with_args(arguments, and_='keywords') """ return DeferredCallable(func) PK e��Z >�o core/core/isequal.pynu �[��� from typing import Any 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" class IsEqual(BaseMatcher[Any]): def __init__(self, equals: Any) -> None: self.object = equals def _matches(self, item: Any) -> bool: return item == self.object def describe_to(self, description: Description) -> None: nested_matcher = isinstance(self.object, Matcher) if nested_matcher: description.append_text("<") description.append_description_of(self.object) if nested_matcher: description.append_text(">") def equal_to(obj: Any) -> Matcher[Any]: """Matches if object is equal to a given object. :param obj: The object to compare against as the expected value. This matcher compares the evaluated object to ``obj`` for equality.""" return IsEqual(obj) PK e��Z�t�� � core/core/is_.pynu �[��� from typing import Optional, Type, TypeVar, Union, overload from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import is_matchable_type, wrap_matcher from hamcrest.core.matcher import Matcher from .isinstanceof import instance_of __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class Is(BaseMatcher[T]): def __init__(self, matcher: Matcher[T]) -> None: self.matcher = matcher def matches(self, item: T, mismatch_description: Optional[Description] = None) -> bool: return self.matcher.matches(item, mismatch_description) def describe_mismatch(self, item: T, mismatch_description: Description) -> None: return self.matcher.describe_mismatch(item, mismatch_description) def describe_to(self, description: Description): description.append_description_of(self.matcher) @overload def _wrap_value_or_type(x: Type) -> Matcher[object]: ... @overload def _wrap_value_or_type(x: T) -> Matcher[T]: ... def _wrap_value_or_type(x): if is_matchable_type(x): return instance_of(x) else: return wrap_matcher(x) @overload def is_(x: Type) -> Matcher[object]: ... @overload def is_(x: Union[Matcher[T], T]) -> Matcher[T]: ... def is_(x): """Decorates another matcher, or provides shortcuts to the frequently used ``is(equal_to(x))`` and ``is(instance_of(x))``. :param x: The matcher to satisfy, or a type for :py:func:`~hamcrest.core.core.isinstanceof.instance_of` matching, or an expected value for :py:func:`~hamcrest.core.core.isequal.equal_to` matching. This matcher compares the evaluated object to the given matcher. .. note:: PyHamcrest's ``is_`` matcher is unrelated to Python's ``is`` operator. The matcher for object identity is :py:func:`~hamcrest.core.core.issame.same_instance`. If the ``x`` argument is a matcher, its behavior is retained, but the test may be more expressive. For example:: assert_that(value, less_than(5)) assert_that(value, is_(less_than(5))) If the ``x`` argument is a type, it is wrapped in an :py:func:`~hamcrest.core.core.isinstanceof.instance_of` matcher. This makes the following statements equivalent:: assert_that(cheese, instance_of(Cheddar)) assert_that(cheese, is_(instance_of(Cheddar))) assert_that(cheese, is_(Cheddar)) Otherwise, if the ``x`` argument is not a matcher, it is wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher. This makes the following statements equivalent:: assert_that(cheese, equal_to(smelly)) assert_that(cheese, is_(equal_to(smelly))) assert_that(cheese, is_(smelly)) Choose the style that makes your expression most readable. This will vary depending on context. """ return Is(_wrap_value_or_type(x)) PK e��Z۾�� � core/core/isnone.pynu �[��� from typing import Any, Optional from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.matcher import Matcher from .isnot import is_not __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class IsNone(BaseMatcher[Optional[Any]]): def _matches(self, item: Any) -> bool: return item is None def describe_to(self, description: Description) -> None: description.append_text("None") def none() -> Matcher[Optional[Any]]: """Matches if object is ``None``.""" return IsNone() def not_none() -> Matcher[Optional[Any]]: """Matches if object is not ``None``.""" return is_not(none()) PK e��Z�l��� � core/core/__init__.pynu �[��� """Fundamental matchers of objects and values, and composite matchers.""" from hamcrest.core.core.allof import all_of from hamcrest.core.core.anyof import any_of from hamcrest.core.core.described_as import described_as from hamcrest.core.core.is_ import is_ from hamcrest.core.core.isanything import anything from hamcrest.core.core.isequal import equal_to from hamcrest.core.core.isinstanceof import instance_of from hamcrest.core.core.isnone import none, not_none from hamcrest.core.core.isnot import is_not, not_ from hamcrest.core.core.issame import same_instance from hamcrest.core.core.raises import calling, raises __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��ZI-�2. . 2 core/helpers/__pycache__/hasmethod.cpython-310.pycnu �[��� o (]^Z � @ s& d Z dZdZdededefdd�ZdS ) zJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�obj� methodname�returnc C s t | |�sdS t| |�}t|�S )z0Does ``obj`` have a method named ``methodname``?F)�hasattr�getattr�callable)r r �method� r �A/usr/lib/python3/dist-packages/hamcrest/core/helpers/hasmethod.py� hasmethod s r N)� __author__� __copyright__� __license__�object�str�boolr r r r r �<module> s PK e��Z� ? ? 1 core/helpers/__pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ s d Z dZdZdZdS )z Utilities for writing Matchers.zJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN)�__doc__� __author__� __copyright__� __license__� r r �@/usr/lib/python3/dist-packages/hamcrest/core/helpers/__init__.py�<module> s PK e��Z���2 2 / core/helpers/__pycache__/ismock.cpython-310.pycnu �[��� o (]^G � @ s� d dl mZmZmZ g Zz d dlmZ eeg7 ZW n ey" Y nw z d dlmZ eeg7 ZW n ey9 Y nw dede fdd�Z dS )� )�Any�List�Type)�Mock�obj�returnc C s t | tt��S )N)� isinstance�tuple� MOCKTYPES)r � r �>/usr/lib/python3/dist-packages/hamcrest/core/helpers/ismock.py�ismock s r N) �typingr r r r �mockr � ImportError� unittest.mock�boolr r r r r �<module> s � �PK e��Z8;d� 5 core/helpers/__pycache__/wrap_matcher.cpython-310.pycnu �[��� o (]^� � @ sx d dl mZmZmZ d dlmZ d dlmZ dZdZ dZ ed�Z deee e f d ee fd d �Z d ed e fd d�ZdS )� )�Type�TypeVar�Union)�Matcher)�equal_tozJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�T�x�returnc C s t | t�r| S t| �S )z�Wraps argument in a matcher, if necessary. :returns: the argument as-is if it is already a matcher, otherwise wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher. )� isinstancer r )r � r �D/usr/lib/python3/dist-packages/hamcrest/core/helpers/wrap_matcher.py� wrap_matcher s r � expected_typec C s t | t�rdS dS )NTF)r �type)r r r r �is_matchable_type s r N)�typingr r r �hamcrest.core.base_matcherr �hamcrest.core.core.isequalr � __author__� __copyright__� __license__r r �boolr r r r r �<module> s " PK e��Z����G G core/helpers/ismock.pynu �[��� from typing import Any, List, Type MOCKTYPES = [] # type: List[Type] try: from mock import Mock MOCKTYPES += [Mock] except ImportError: pass try: from unittest.mock import Mock MOCKTYPES += [Mock] except ImportError: pass def ismock(obj: Any) -> bool: return isinstance(obj, tuple(MOCKTYPES)) PK e��Z 7C_Z Z core/helpers/hasmethod.pynu �[��� __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" def hasmethod(obj: object, methodname: str) -> bool: """Does ``obj`` have a method named ``methodname``?""" if not hasattr(obj, methodname): return False method = getattr(obj, methodname) return callable(method) PK e��Z�&�� � core/helpers/wrap_matcher.pynu �[��� from typing import Type, TypeVar, Union from hamcrest.core.base_matcher import Matcher from hamcrest.core.core.isequal import equal_to __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") def wrap_matcher(x: Union[Matcher[T], T]) -> Matcher[T]: """Wraps argument in a matcher, if necessary. :returns: the argument as-is if it is already a matcher, otherwise wrapped in an :py:func:`~hamcrest.core.core.isequal.equal_to` matcher. """ if isinstance(x, Matcher): return x else: return equal_to(x) def is_matchable_type(expected_type: Type) -> bool: if isinstance(expected_type, type): return True return False PK e��ZmUD;� � core/helpers/__init__.pynu �[��� """Utilities for writing Matchers.""" __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Z�6�|h h core/matcher.pynu �[��� from typing import Generic, Optional, TypeVar from hamcrest.core.description import Description from .selfdescribing import SelfDescribing __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" T = TypeVar("T") class Matcher(Generic[T], SelfDescribing): """A matcher over acceptable values. A matcher is able to describe itself to give feedback when it fails. Matcher implementations should *not* directly implement this protocol. Instead, *extend* the :py:class:`~hamcrest.core.base_matcher.BaseMatcher` class, which will ensure that the :py:class:`~hamcrest.core.matcher.Matcher` API can grow to support new features and remain compatible with all :py:class:`~hamcrest.core.matcher.Matcher` implementations. """ def matches(self, item: T, mismatch_description: Optional[Description] = None) -> bool: """Evaluates the matcher for argument item. If a mismatch is detected and argument ``mismatch_description`` is provided, it will generate a description of why the matcher has not accepted the item. :param item: The object against which the matcher is evaluated. :param mismatch_description: :returns: ``True`` if ``item`` matches, otherwise ``False``. """ raise NotImplementedError("matches") def describe_mismatch(self, item: T, mismatch_description: Description) -> None: """Generates a description of why the matcher has not accepted the item. The description will be part of a larger description of why a matching failed, so it should be concise. This method assumes that ``matches(item)`` is ``False``, but will not check this. :param item: The item that the :py:class:`~hamcrest.core.matcher.Matcher` has rejected. :param mismatch_description: The description to be built or appended to. """ raise NotImplementedError("describe_mismatch") def describe_match(self, item: T, match_description: Description) -> None: """Generates a description of why the matcher has accepted the item. The description may be part of a larger description of why a matching failed, so it should be concise. This method assumes that ``matches(item)`` is ``True``, but will not check this. :param item: The item that the :py:class:`~hamcrest.core.matcher.Matcher` has accepted. :param match_description: The description to be built or appended to. """ raise NotImplementedError("describe_match") PK e��Z嬯?� � core/__init__.pynu �[��� from hamcrest.core.assert_that import assert_that from hamcrest.core.core import * __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Z�t�v� � core/base_description.pynu �[��� from typing import Any, Iterable from hamcrest.core.description import Description from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.helpers.ismock import ismock __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class BaseDescription(Description): """Base class for all :py:class:`~hamcrest.core.description.Description` implementations. """ def append_text(self, text: str) -> Description: self.append(text) return self def append_description_of(self, value: Any) -> Description: if not ismock(value) and hasmethod(value, "describe_to"): value.describe_to(self) elif isinstance(value, str): self.append(repr(value)) else: description = str(value) if description[:1] == "<" and description[-1:] == ">": self.append(description) else: self.append("<") self.append(description) self.append(">") return self def append_list(self, start: str, separator: str, end: str, list: Iterable[Any]) -> Description: separate = False self.append(start) for item in list: if separate: self.append(separator) self.append_description_of(item) separate = True self.append(end) return self def append(self, string: str) -> None: """Append the string to the description.""" raise NotImplementedError("append") def append_string_in_python_syntax(self, string: str) -> None: self.append("'") for ch in string: self.append(character_in_python_syntax(ch)) self.append("'") def character_in_python_syntax(ch: str) -> str: if ch == "'": return "'" elif ch == "\n": return "\\n" elif ch == "\r": return "\\r" elif ch == "\t": return "\\t" else: return ch PK e��Z m��+ + , library/collection/isdict_containingvalue.pynu �[��� 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)) PK e��Zۋ �� � D library/collection/__pycache__/issequence_containing.cpython-310.pycnu �[��� 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 &*PK e��Z2 �C C 3 library/collection/__pycache__/isin.cpython-310.pycnu �[��� 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 PK e��Z� _� � E library/collection/__pycache__/isdict_containingvalue.cpython-310.pycnu �[��� 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 .PK e��Z ��}_ _ H library/collection/__pycache__/issequence_onlycontaining.cpython-310.pycnu �[��� 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 *PK e��Z���{� � 7 library/collection/__pycache__/is_empty.cpython-310.pycnu �[��� 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 PK e��ZV�M� � 7 library/collection/__pycache__/__init__.cpython-310.pycnu �[��� 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 PK e��Z�{�� � @ library/collection/__pycache__/isdict_containing.cpython-310.pycnu �[��� 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& ���PK e��Z�i��� � K library/collection/__pycache__/issequence_containinginorder.cpython-310.pycnu �[��� 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 &&*PK e��Z6Q�_� � C library/collection/__pycache__/isdict_containingkey.cpython-310.pycnu �[��� 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 .PK e��Z���� � G library/collection/__pycache__/isdict_containingentries.cpython-310.pycnu �[��� 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 PK e��Z�t� N library/collection/__pycache__/issequence_containinginanyorder.cpython-310.pycnu �[��� 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 %* PK e��Z�[*< < . library/collection/isdict_containingentries.pynu �[��� 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) PK e��Z�C� ' library/collection/isdict_containing.pynu �[��� 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)) PK e��Z�I�w� � 2 library/collection/issequence_containinginorder.pynu �[��� 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) PK e��Zδ�| 5 library/collection/issequence_containinginanyorder.pynu �[��� 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) PK e��Z�Q��4 4 library/collection/is_empty.pynu �[��� 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() PK e��Z��01 1 / library/collection/issequence_onlycontaining.pynu �[��� 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)) PK e��Zq�h h + library/collection/issequence_containing.pynu �[��� 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) PK e��ZQ�H�� � library/collection/isin.pynu �[��� 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) PK e��Zh�ua% % * library/collection/isdict_containingkey.pynu �[��� 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)) PK e��Z�,>f f library/collection/__init__.pynu �[��� """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" PK e��Z�&�� � , library/__pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ sL d Z ddlT ddlT ddlT ddlT ddlT ddlT dZdZdZ g d�Z dS )z#Library of Matcher implementations.� )�*zJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt) � has_entry� has_entries�has_key� has_value�is_in�empty�has_item� has_items�contains_inanyorder�contains�contains_exactly� only_contains�match_equality�matches_regexp�close_to� greater_than�greater_than_or_equal_to� less_than�less_than_or_equal_to� has_length� has_property�has_properties� has_string�equal_to_ignoring_case� equal_to_ignoring_whitespace�contains_string� ends_with� starts_with�string_contains_in_orderN) �__doc__� hamcrest.core�hamcrest.library.collection� hamcrest.library.integration�hamcrest.library.number�hamcrest.library.object�hamcrest.library.text� __author__� __copyright__� __license__�__all__� r+ r+ �;/usr/lib/python3/dist-packages/hamcrest/library/__init__.py�<module> s PK e��Z� !�+ + % library/integration/match_equality.pynu �[��� from typing import Any from hamcrest.core.helpers.wrap_matcher import wrap_matcher from hamcrest.core.matcher import Matcher from hamcrest.core.string_description import tostring __author__ = "Chris Rose" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" __unittest = True class EqualityWrapper(object): def __init__(self, matcher: Matcher) -> None: self.matcher = matcher def __eq__(self, obj: Any) -> bool: return self.matcher.matches(obj) def __str__(self) -> str: return repr(self) def __repr__(self) -> str: return tostring(self.matcher) def match_equality(matcher: Matcher) -> EqualityWrapper: """Wraps a matcher to define equality in terms of satisfying the matcher. ``match_equality`` allows Hamcrest matchers to be used in libraries that are not Hamcrest-aware. They might use the equality operator:: assert match_equality(matcher) == object Or they might provide a method that uses equality for its test:: library.method_that_tests_eq(match_equality(matcher)) One concrete example is integrating with the ``assert_called_with`` methods in Michael Foord's `mock <http://www.voidspace.org.uk/python/mock/>`_ library. """ return EqualityWrapper(wrap_matcher(matcher)) PK e��Z�Y�� � 8 library/integration/__pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ s d Z ddlmZ dZdZdZdS )z8Utilities for integrating Hamcrest with other libraries.� )�match_equalityzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN)�__doc__r � __author__� __copyright__� __license__� r r �G/usr/lib/python3/dist-packages/hamcrest/library/integration/__init__.py�<module> s PK e��ZX�dK > library/integration/__pycache__/match_equality.cpython-310.pycnu �[��� o (]^+ � @ sf d dl mZ d dlmZ d dlmZ d dlmZ dZdZ dZ dZ G d d � d e �Z d ed e fd d�ZdS )� )�Any)� wrap_matcher)�Matcher)�tostringz Chris RosezCopyright 2011 hamcrest.orgzBSD, see License.txtTc @ sL e Zd Zdeddfdd�Zdedefdd�Zdefd d �Z defd d �Z dS ) �EqualityWrapper�matcher�returnNc C s || _ d S �N�r )�selfr � r �M/usr/lib/python3/dist-packages/hamcrest/library/integration/match_equality.py�__init__ � zEqualityWrapper.__init__�objc C s | j �|�S r )r �matches)r r r r r �__eq__ s zEqualityWrapper.__eq__c C s t | �S r )�repr�r r r r �__str__ s zEqualityWrapper.__str__c C s t | j�S r )r r r r r r �__repr__ r zEqualityWrapper.__repr__) �__name__� __module__� __qualname__r r r �boolr �strr r r r r r r s r r r c C s t t| ��S )a< Wraps a matcher to define equality in terms of satisfying the matcher. ``match_equality`` allows Hamcrest matchers to be used in libraries that are not Hamcrest-aware. They might use the equality operator:: assert match_equality(matcher) == object Or they might provide a method that uses equality for its test:: library.method_that_tests_eq(match_equality(matcher)) One concrete example is integrating with the ``assert_called_with`` methods in Michael Foord's `mock <http://www.voidspace.org.uk/python/mock/>`_ library. )r r r r r r �match_equality s r N)�typingr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � hamcrest.core.string_descriptionr � __author__� __copyright__� __license__� __unittest�objectr r r r r r �<module> s PK e��Z�,�b� � library/integration/__init__.pynu �[��� """Utilities for integrating Hamcrest with other libraries.""" from .match_equality import match_equality __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Zp��6� � 4 library/number/__pycache__/iscloseto.cpython-310.pycnu �[��� o (]^� � @ s� d dl mZ d dlmZ d dlmZmZmZ d dlm Z d dl m Z d dl m Z dZdZd Zeeef Zd ed efd d �ZG dd� de e �Zed eded e e fdd��Zed eded e e fdd��Zdd� ZdS )� )�Decimal)�fabs)�Any�Union�overload)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�value�returnc C sN t | tttf�r dS z t| �d d d }W dS ty! Y dS Y dS )zKConfirm that 'value' can be treated numerically; duck-test accordingly Tr � F)� isinstance�float�complex�intr �ArithmeticError)r �_� r �C/usr/lib/python3/dist-packages/hamcrest/library/number/iscloseto.py� isnumeric s r c sv e Zd Zdededdfdd�Zdedefdd �Zdedefd d �Zded e ddf� fd d� Z de ddfdd�Z � Z S )� IsCloseTor �deltar Nc C s0 t |�std��t |�std��|| _|| _d S )Nz IsCloseTo value must be numericz IsCloseTo delta must be numeric)r � TypeErrorr r )�selfr r r r r �__init__ s zIsCloseTo.__init__�itemc C s t |�sdS | �|�| jkS )NF)r �_diffr �r r r r r �_matches) s zIsCloseTo._matchesc C s t || j �S �N)r r r r r r r . s zIsCloseTo._diff�mismatch_descriptionc sB t |�stt| ��||� d S | �|�}|�|��d��|� d S )Nz differed by )r �superr �describe_mismatchr �append_description_of� append_text)r r r � actual_delta�� __class__r r r" 2 s � zIsCloseTo.describe_mismatch� descriptionc C s$ |� d��| j�� d��| j� d S )Nza numeric value within z of )r$ r# r r )r r( r r r � describe_to; s �zIsCloseTo.describe_to) �__name__� __module__� __qualname__�Numberr �boolr r r r r" r) � __classcell__r r r& r r s r r c C � d S r r �r r r r r �close_toA � r2 c C r0 r r r1 r r r r2 F r3 c C s t | |�S )a� Matches if object is a number close to a given value, within a given delta. :param value: The value to compare against as the expected value. :param delta: The maximum delta between the values for which the numbers are considered close. This matcher compares the evaluated object against ``value`` to see if the difference is within a positive ``delta``. Example:: close_to(3.0, 0.25) )r r1 r r r r2 K s N)�decimalr �mathr �typingr r r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r- r. r r r2 r r r r �<module> s" " PK e��Z��g�� � > library/number/__pycache__/ordering_comparison.cpython-310.pycnu �[��� o (]^� � @ s� d dl Z d dlmZmZ d dlmZ d dlmZ d dlm Z dZ dZ dZ G d d � d ee �Z d ed e e fd d�Zd ed e e fdd�Zd ed e e fdd�Zd ed e e fdd�ZdS )� N)�Any�Callable)� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sV e Zd Zdedeeegef deddfdd�Zdedefd d �Zd e ddfd d �Z dS )�OrderingComparison�value�comparison_function�comparison_description�returnNc C s || _ || _|| _d S �N)r r r )�selfr r r � r �M/usr/lib/python3/dist-packages/hamcrest/library/number/ordering_comparison.py�__init__ s zOrderingComparison.__init__�itemc C s | � || j�S r )r r )r r r r r �_matches s zOrderingComparison._matches� descriptionc C s$ |� d�� | j�� d��| j� d S )Nza value � )� append_textr �append_description_ofr )r r r r r � describe_to s �z OrderingComparison.describe_to) �__name__� __module__� __qualname__r r �bool�strr r r r r r r r r s ��� � r r r c C � t | tjd�S )zgMatches if object is greater than a given value. :param value: The value to compare against. z greater than)r �operator�gt�r r r r � greater_than! � r! c C r )zsMatches if object is greater than or equal to a given value. :param value: The value to compare against. zgreater than or equal to)r r �ger r r r �greater_than_or_equal_to* r" r$ c C r )zdMatches if object is less than a given value. :param value: The value to compare against. z less than)r r �ltr r r r � less_than3 r" r& c C r )zpMatches if object is less than or equal to a given value. :param value: The value to compare against. zless than or equal to)r r �ler r r r �less_than_or_equal_to< r" r( )r �typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r! r$ r& r( r r r r �<module> s PK e��Z$�� 3 library/number/__pycache__/__init__.cpython-310.pycnu �[��� o (]^= � @ s8 d Z ddlmZ ddlmZmZmZmZ dZdZ dZ dS )z*Matchers that perform numeric comparisons.� )�close_to)� greater_than�greater_than_or_equal_to� less_than�less_than_or_equal_tozJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN) �__doc__� isclosetor �ordering_comparisonr r r r � __author__� __copyright__� __license__� r r �B/usr/lib/python3/dist-packages/hamcrest/library/number/__init__.py�<module> s PK e��Z��R � � % library/number/ordering_comparison.pynu �[��� import operator from typing import Any, Callable 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" class OrderingComparison(BaseMatcher[Any]): def __init__( self, value: Any, comparison_function: Callable[[Any, Any], bool], comparison_description: str, ) -> None: self.value = value self.comparison_function = comparison_function self.comparison_description = comparison_description def _matches(self, item: Any) -> bool: return self.comparison_function(item, self.value) def describe_to(self, description: Description) -> None: description.append_text("a value ").append_text(self.comparison_description).append_text( " " ).append_description_of(self.value) def greater_than(value: Any) -> Matcher[Any]: """Matches if object is greater than a given value. :param value: The value to compare against. """ return OrderingComparison(value, operator.gt, "greater than") def greater_than_or_equal_to(value: Any) -> Matcher[Any]: """Matches if object is greater than or equal to a given value. :param value: The value to compare against. """ return OrderingComparison(value, operator.ge, "greater than or equal to") def less_than(value: Any) -> Matcher[Any]: """Matches if object is less than a given value. :param value: The value to compare against. """ return OrderingComparison(value, operator.lt, "less than") def less_than_or_equal_to(value: Any) -> Matcher[Any]: """Matches if object is less than or equal to a given value. :param value: The value to compare against. """ return OrderingComparison(value, operator.le, "less than or equal to") PK e��Z��� � library/number/iscloseto.pynu �[��� from decimal import Decimal from math import fabs from typing import Any, Union, overload 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" Number = Union[float, Decimal] # Argh, https://github.com/python/mypy/issues/3186 def isnumeric(value: Any) -> bool: """Confirm that 'value' can be treated numerically; duck-test accordingly """ if isinstance(value, (float, complex, int)): return True try: _ = (fabs(value) + 0 - 0) * 1 return True except ArithmeticError: return True except: return False class IsCloseTo(BaseMatcher[Number]): def __init__(self, value: Number, delta: Number) -> None: if not isnumeric(value): raise TypeError("IsCloseTo value must be numeric") if not isnumeric(delta): raise TypeError("IsCloseTo delta must be numeric") self.value = value self.delta = delta def _matches(self, item: Number) -> bool: if not isnumeric(item): return False return self._diff(item) <= self.delta def _diff(self, item: Number) -> float: # TODO - Fails for mixed floats & Decimals return fabs(item - self.value) # type: ignore def describe_mismatch(self, item: Number, mismatch_description: Description) -> None: if not isnumeric(item): super(IsCloseTo, self).describe_mismatch(item, mismatch_description) else: actual_delta = self._diff(item) mismatch_description.append_description_of(item).append_text( " differed by " ).append_description_of(actual_delta) def describe_to(self, description: Description) -> None: description.append_text("a numeric value within ").append_description_of( self.delta ).append_text(" of ").append_description_of(self.value) @overload def close_to(value: float, delta: float) -> Matcher[float]: ... @overload def close_to(value: Decimal, delta: Decimal) -> Matcher[Decimal]: ... def close_to(value, delta): """Matches if object is a number close to a given value, within a given delta. :param value: The value to compare against as the expected value. :param delta: The maximum delta between the values for which the numbers are considered close. This matcher compares the evaluated object against ``value`` to see if the difference is within a positive ``delta``. Example:: close_to(3.0, 0.25) """ return IsCloseTo(value, delta) PK e��Z �<O= = library/number/__init__.pynu �[��� """Matchers that perform numeric comparisons.""" from .iscloseto import close_to from .ordering_comparison import ( greater_than, greater_than_or_equal_to, less_than, less_than_or_equal_to, ) __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Z^�!� � % library/text/stringcontainsinorder.pynu �[��� from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.matcher import Matcher __author__ = "Romilly Cocking" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class StringContainsInOrder(BaseMatcher[str]): def __init__(self, *substrings) -> None: for substring in substrings: if not isinstance(substring, str): raise TypeError(self.__class__.__name__ + " requires string arguments") self.substrings = substrings def _matches(self, item: str) -> bool: if not hasmethod(item, "find"): return False from_index = 0 for substring in self.substrings: from_index = item.find(substring, from_index) if from_index == -1: return False return True def describe_to(self, description: Description) -> None: description.append_list("a string containing ", ", ", " in order", self.substrings) def string_contains_in_order(*substrings: str) -> Matcher[str]: """Matches if object is a string containing a given list of substrings in relative order. :param string1,...: A comma-separated list of strings. This matcher first checks whether the evaluated object is a string. If so, it checks whether it contains a given list of strings, in relative order to each other. The searches are performed starting from the beginning of the evaluated string. Example:: string_contains_in_order("bc", "fg", "jkl") will match "abcdefghijklm". """ return StringContainsInOrder(*substrings) PK e��Z.U��� � 1 library/text/__pycache__/__init__.cpython-310.pycnu �[��� o (]^� � @ sh d Z ddlmZ ddlmZ ddlmZ ddlmZ ddl m Z ddl m Z ddl mZ d Zd Zd Zd S ) z'Matchers that perform text comparisons.� )�equal_to_ignoring_case)� equal_to_ignoring_whitespace)�contains_string)�string_contains_in_order)� ends_with)�matches_regexp)� starts_withzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN)�__doc__�isequal_ignoring_caser �isequal_ignoring_whitespacer �stringcontainsr �stringcontainsinorderr �stringendswithr � stringmatchesr �stringstartswithr � __author__� __copyright__� __license__� r r �@/usr/lib/python3/dist-packages/hamcrest/library/text/__init__.py�<module> s PK e��Z�.L9� � > library/text/__pycache__/isequal_ignoring_case.cpython-310.pycnu �[��� o (]^O � @ s^ d dl mZ d dlmZ d dlmZ dZdZdZG dd� dee �Z d e d ee fd d �Z d S )� )� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sB e Zd Zdeddfdd�Zdedefdd�Zd eddfd d �ZdS ) �IsEqualIgnoringCase�string�returnNc C s& t |t�s td��|| _|�� | _d S )Nz#IsEqualIgnoringCase requires string)� isinstance�str� TypeError�original_string�lower�lowered_string)�selfr � r �M/usr/lib/python3/dist-packages/hamcrest/library/text/isequal_ignoring_case.py�__init__ s z IsEqualIgnoringCase.__init__�itemc C s t |t�sdS | j|�� kS )NF)r r r r )r r r r r �_matches s z IsEqualIgnoringCase._matches� descriptionc C s |� | j��d� d S )Nz ignoring case)�append_description_ofr � append_text)r r r r r � describe_to s z IsEqualIgnoringCase.describe_to) �__name__� __module__� __qualname__r r �boolr r r r r r r r s r r r c C s t | �S )a� Matches if object is a string equal to a given string, ignoring case differences. :param string: The string to compare against as the expected value. This matcher first checks whether the evaluated object is a string. If so, it compares it with ``string``, ignoring differences of case. Example:: equal_to_ignoring_case("hello world") will match "heLLo WorlD". )r )r r r r �equal_to_ignoring_case s r N) �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��ZG�S, , 9 library/text/__pycache__/substringmatcher.cpython-310.pycnu �[��� o (]^ � @ sP d dl mZmZ d dlmZ d dlmZ dZdZdZ G dd� dee ed �Z d S ) � )�ABCMeta�abstractmethod)� BaseMatcher)� DescriptionzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ s4 e Zd Zd dd�Zdeddfdd�Zedd � �ZdS ) �SubstringMatcher�returnNc C s$ t |t�s t| jjd ��|| _d S )Nz requires string)� isinstance�str� TypeError� __class__�__name__� substring)�selfr � r �H/usr/lib/python3/dist-packages/hamcrest/library/text/substringmatcher.py�__init__ s zSubstringMatcher.__init__� descriptionc C s& |� d�� | �� �� d��| j� d S )Nz a string � )� append_text� relationship�append_description_ofr )r r r r r � describe_to s �z SubstringMatcher.describe_toc C s d S )Nr )r r r r r s z SubstringMatcher.relationship)r N)r � __module__� __qualname__r r r r r r r r r r s r )� metaclassN) �abcr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr � __author__� __copyright__� __license__r r r r r r �<module> s PK e��Z/c�p� � 7 library/text/__pycache__/stringendswith.cpython-310.pycnu �[��� o (]^' � @ sZ d dl mZ d dlmZ d dlmZ dZdZdZG dd� de�Z d e d ee fd d �Z d S )� )� hasmethod)�Matcher)�SubstringMatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc s8 e Zd Zd � fdd� Zdedefdd�Zdd � Z� ZS ) �StringEndsWith�returnNc s t t| ��|� d S )N)�superr �__init__)�self� substring�� __class__� �F/usr/lib/python3/dist-packages/hamcrest/library/text/stringendswith.pyr s zStringEndsWith.__init__�itemc C s t |d�sdS |�| j�S )N�endswithF)r r r )r r r r r �_matches s zStringEndsWith._matchesc C s dS )Nz ending withr )r r r r � relationship s zStringEndsWith.relationship)r N) �__name__� __module__� __qualname__r �str�boolr r � __classcell__r r r r r s r �stringr c C s t | �S )aW Matches if object is a string ending with a given string. :param string: The string to search for. This matcher first checks whether the evaluated object is a string. If so, it checks if ``string`` matches the ending characters of the evaluated object. Example:: ends_with("bar") will match "foobar". )r )r r r r � ends_with s r N) � hamcrest.core.helpers.hasmethodr �hamcrest.core.matcherr �&hamcrest.library.text.substringmatcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z���1 1 6 library/text/__pycache__/stringmatches.cpython-310.pycnu �[��� o (]^� � @ s� d dl Z d dlmZmZ d dlmZ d dlmZ d dlm Z dZ dZ dZ G d d � d ee �Zd ee ee f d e e fd d�ZdS )� N)�Pattern�Union)� BaseMatcher)� Description)�Matcherz Chris RosezCopyright 2011 hamcrest.orgzBSD, see License.txtc @ s: e Zd Zd dd�Zdeddfdd�Zdedefd d �ZdS ) �StringMatchesPattern�returnNc C s || _ d S �N��pattern)�selfr � r �E/usr/lib/python3/dist-packages/hamcrest/library/text/stringmatches.py�__init__ s z StringMatchesPattern.__init__� descriptionc C s |� d�� | jj�� d� d S )Nza string matching '�')� append_textr )r r r r r � describe_to s � z StringMatchesPattern.describe_to�itemc C s | j �|�d uS r )r �search)r r r r r �_matches s z StringMatchesPattern._matches)r N) �__name__� __module__� __qualname__r r r �str�boolr r r r r r s r r r c C s t | t�r t�| �} t| �S )aK Matches if object is a string containing a match for a given regular expression. :param pattern: The regular expression to search for. This matcher first checks whether the evaluated object is a string. If so, it checks if the regular expression ``pattern`` matches anywhere within the evaluated object. )� isinstancer �re�compiler r r r r �matches_regexp s r )r �typingr r �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s & PK e��ZrBIȉ � 7 library/text/__pycache__/stringcontains.cpython-310.pycnu �[��� o (]^ � @ sZ d dl mZ d dlmZ d dlmZ dZdZdZG dd� de�Z d e d ee fd d �Z d S )� )� hasmethod)�Matcher)�SubstringMatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc s8 e Zd Zd � fdd� Zdedefdd�Zdd � Z� ZS ) �StringContains�returnNc s t t| ��|� d S )N)�superr �__init__)�self� substring�� __class__� �F/usr/lib/python3/dist-packages/hamcrest/library/text/stringcontains.pyr s zStringContains.__init__�itemc C s t |d�sdS |�| j�dkS )N�findFr )r r r )r r r r r �_matches s zStringContains._matchesc C s dS )N� containingr )r r r r � relationship s zStringContains.relationship)r N) �__name__� __module__� __qualname__r �str�boolr r � __classcell__r r r r r s r r r c C s t | �S )a4 Matches if object is a string containing a given string. :param string: The string to search for. This matcher first checks whether the evaluated object is a string. If so, it checks whether it contains ``string``. Example:: contains_string("def") will match "abcdefg". )r )r r r r �contains_string s r N) � hamcrest.core.helpers.hasmethodr �hamcrest.core.matcherr �&hamcrest.library.text.substringmatcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z�W� � > library/text/__pycache__/stringcontainsinorder.cpython-310.pycnu �[��� o (]^� � @ sj d dl mZ d dlmZ d dlmZ d dlmZ dZdZ dZ G dd � d ee �Z d e d ee fd d �Z dS )� )� BaseMatcher)� Description)� hasmethod)�MatcherzRomilly CockingzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ s: e Zd Zd dd�Zdedefdd�Zdeddfd d �ZdS ) �StringContainsInOrder�returnNc G s. |D ]}t |t�st| jjd ��q|| _d S )Nz requires string arguments)� isinstance�str� TypeError� __class__�__name__� substrings)�selfr � substring� r �M/usr/lib/python3/dist-packages/hamcrest/library/text/stringcontainsinorder.py�__init__ s � z StringContainsInOrder.__init__�itemc C s< t |d�sdS d}| jD ]}|�||�}|dkr dS q dS )N�findFr ���T)r r r )r r � from_indexr r r r �_matches s �z StringContainsInOrder._matches� descriptionc C s |� ddd| j� d S )Nza string containing z, z in order)� append_listr )r r r r r � describe_to s z!StringContainsInOrder.describe_to)r N) r � __module__� __qualname__r r �boolr r r r r r r r s r r r c G s t | � S )a Matches if object is a string containing a given list of substrings in relative order. :param string1,...: A comma-separated list of strings. This matcher first checks whether the evaluated object is a string. If so, it checks whether it contains a given list of strings, in relative order to each other. The searches are performed starting from the beginning of the evaluated string. Example:: string_contains_in_order("bc", "fg", "jkl") will match "abcdefghijklm". )r )r r r r �string_contains_in_order s r N)�hamcrest.core.base_matcherr �hamcrest.core.descriptionr � hamcrest.core.helpers.hasmethodr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��ZQ<9�� � 9 library/text/__pycache__/stringstartswith.cpython-310.pycnu �[��� o (]^B � @ sZ d dl mZ d dlmZ d dlmZ dZdZdZG dd� de�Z d e d ee fd d �Z d S )� )� hasmethod)�Matcher)�SubstringMatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc s8 e Zd Zd � fdd� Zdedefdd�Zdd � Z� ZS ) �StringStartsWith�returnNc s t t| ��|� d S )N)�superr �__init__)�self� substring�� __class__� �H/usr/lib/python3/dist-packages/hamcrest/library/text/stringstartswith.pyr s zStringStartsWith.__init__�itemc C s t |d�sdS |�| j�S )N� startswithF)r r r )r r r r r �_matches s zStringStartsWith._matchesc C s dS )Nz starting withr )r r r r � relationship s z StringStartsWith.relationship)r N) �__name__� __module__� __qualname__r �str�boolr r � __classcell__r r r r r s r r r c C s t | �S )a^ Matches if object is a string starting with a given string. :param string: The string to search for. This matcher first checks whether the evaluated object is a string. If so, it checks if ``string`` matches the beginning characters of the evaluated object. Example:: starts_with("foo") will match "foobar". )r )r r r r � starts_with s r N) � hamcrest.core.helpers.hasmethodr �hamcrest.core.matcherr �&hamcrest.library.text.substringmatcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z2�B�� � D library/text/__pycache__/isequal_ignoring_whitespace.cpython-310.pycnu �[��� o (]^� � @ sp d dl mZ d dlmZ d dlmZ dZdZdZde de fd d �Z G d d � d ee �Z de dee fd d�Z dS )� )� BaseMatcher)� Description)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txt�string�returnc C s@ d}d}| D ]}|� � r|s|d7 }d}q||7 }d}q|�� S )N� T� F)�isspace�strip)r �result�last_was_space� character� r �S/usr/lib/python3/dist-packages/hamcrest/library/text/isequal_ignoring_whitespace.py� stripspace s r c @ s: e Zd Zd dd�Zdedefdd�Zdeddfd d �ZdS ) �IsEqualIgnoringWhiteSpacer Nc C s& t |t�s td��|| _t|�| _d S )Nz)IsEqualIgnoringWhiteSpace requires string)� isinstance�str� TypeError�original_stringr �stripped_string)�selfr r r r �__init__ s z"IsEqualIgnoringWhiteSpace.__init__�itemc C s t |t�sdS | jt|�kS )NF)r r r r )r r r r r �_matches s z"IsEqualIgnoringWhiteSpace._matches� descriptionc C s |� | j��d� d S )Nz ignoring whitespace)�append_description_ofr � append_text)r r r r r � describe_to$ s z%IsEqualIgnoringWhiteSpace.describe_to)r N) �__name__� __module__� __qualname__r r �boolr r r r r r r r s r c C s t | �S )a� Matches if object is a string equal to a given string, ignoring differences in whitespace. :param string: The string to compare against as the expected value. This matcher first checks whether the evaluated object is a string. If so, it compares it with ``string``, ignoring differences in runs of whitespace. Example:: equal_to_ignoring_whitespace("hello world") will match ``"hello world"``. )r )r r r r � equal_to_ignoring_whitespace( s r# N) �hamcrest.core.base_matcherr �hamcrest.core.descriptionr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r# r r r r �<module> s PK e��Z��� � library/text/stringmatches.pynu �[��� import re from typing import Pattern, Union from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description from hamcrest.core.matcher import Matcher __author__ = "Chris Rose" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class StringMatchesPattern(BaseMatcher[str]): def __init__(self, pattern) -> None: self.pattern = pattern def describe_to(self, description: Description) -> None: description.append_text("a string matching '").append_text( self.pattern.pattern ).append_text("'") def _matches(self, item: str) -> bool: return self.pattern.search(item) is not None def matches_regexp(pattern: Union[str, Pattern[str]]) -> Matcher[str]: """Matches if object is a string containing a match for a given regular expression. :param pattern: The regular expression to search for. This matcher first checks whether the evaluated object is a string. If so, it checks if the regular expression ``pattern`` matches anywhere within the evaluated object. """ if isinstance(pattern, str): pattern = re.compile(pattern) return StringMatchesPattern(pattern) PK e��Z�{M�' ' library/text/stringendswith.pynu �[��� from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.matcher import Matcher from hamcrest.library.text.substringmatcher import SubstringMatcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class StringEndsWith(SubstringMatcher): def __init__(self, substring) -> None: super(StringEndsWith, self).__init__(substring) def _matches(self, item: str) -> bool: if not hasmethod(item, "endswith"): return False return item.endswith(self.substring) def relationship(self): return "ending with" def ends_with(string: str) -> Matcher[str]: """Matches if object is a string ending with a given string. :param string: The string to search for. This matcher first checks whether the evaluated object is a string. If so, it checks if ``string`` matches the ending characters of the evaluated object. Example:: ends_with("bar") will match "foobar". """ return StringEndsWith(string) PK e��Z�Ȃ�� � + library/text/isequal_ignoring_whitespace.pynu �[��� 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" def stripspace(string: str) -> str: result = "" last_was_space = True for character in string: if character.isspace(): if not last_was_space: result += " " last_was_space = True else: result += character last_was_space = False return result.strip() class IsEqualIgnoringWhiteSpace(BaseMatcher[str]): def __init__(self, string) -> None: if not isinstance(string, str): raise TypeError("IsEqualIgnoringWhiteSpace requires string") self.original_string = string self.stripped_string = stripspace(string) def _matches(self, item: str) -> bool: if not isinstance(item, str): return False return self.stripped_string == stripspace(item) def describe_to(self, description: Description) -> None: description.append_description_of(self.original_string).append_text(" ignoring whitespace") def equal_to_ignoring_whitespace(string: str) -> Matcher[str]: """Matches if object is a string equal to a given string, ignoring differences in whitespace. :param string: The string to compare against as the expected value. This matcher first checks whether the evaluated object is a string. If so, it compares it with ``string``, ignoring differences in runs of whitespace. Example:: equal_to_ignoring_whitespace("hello world") will match ``"hello world"``. """ return IsEqualIgnoringWhiteSpace(string) PK e��Z�3 library/text/substringmatcher.pynu �[��� from abc import ABCMeta, abstractmethod from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.description import Description __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class SubstringMatcher(BaseMatcher[str], metaclass=ABCMeta): def __init__(self, substring) -> None: if not isinstance(substring, str): raise TypeError(self.__class__.__name__ + " requires string") self.substring = substring def describe_to(self, description: Description) -> None: description.append_text("a string ").append_text(self.relationship()).append_text( " " ).append_description_of(self.substring) @abstractmethod def relationship(self): ... PK e��Z�OB B library/text/stringstartswith.pynu �[��� from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.matcher import Matcher from hamcrest.library.text.substringmatcher import SubstringMatcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class StringStartsWith(SubstringMatcher): def __init__(self, substring) -> None: super(StringStartsWith, self).__init__(substring) def _matches(self, item: str) -> bool: if not hasmethod(item, "startswith"): return False return item.startswith(self.substring) def relationship(self): return "starting with" def starts_with(substring: str) -> Matcher[str]: """Matches if object is a string starting with a given string. :param string: The string to search for. This matcher first checks whether the evaluated object is a string. If so, it checks if ``string`` matches the beginning characters of the evaluated object. Example:: starts_with("foo") will match "foobar". """ return StringStartsWith(substring) PK e��Z{���O O % library/text/isequal_ignoring_case.pynu �[��� 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" class IsEqualIgnoringCase(BaseMatcher[str]): def __init__(self, string: str) -> None: if not isinstance(string, str): raise TypeError("IsEqualIgnoringCase requires string") self.original_string = string self.lowered_string = string.lower() def _matches(self, item: str) -> bool: if not isinstance(item, str): return False return self.lowered_string == item.lower() def describe_to(self, description: Description) -> None: description.append_description_of(self.original_string).append_text(" ignoring case") def equal_to_ignoring_case(string: str) -> Matcher[str]: """Matches if object is a string equal to a given string, ignoring case differences. :param string: The string to compare against as the expected value. This matcher first checks whether the evaluated object is a string. If so, it compares it with ``string``, ignoring differences of case. Example:: equal_to_ignoring_case("hello world") will match "heLLo WorlD". """ return IsEqualIgnoringCase(string) PK e��Z���� � library/text/__init__.pynu �[��� """Matchers that perform text comparisons.""" from .isequal_ignoring_case import equal_to_ignoring_case from .isequal_ignoring_whitespace import equal_to_ignoring_whitespace from .stringcontains import contains_string from .stringcontainsinorder import string_contains_in_order from .stringendswith import ends_with from .stringmatches import matches_regexp from .stringstartswith import starts_with __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Z\o�� library/text/stringcontains.pynu �[��� from hamcrest.core.helpers.hasmethod import hasmethod from hamcrest.core.matcher import Matcher from hamcrest.library.text.substringmatcher import SubstringMatcher __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" class StringContains(SubstringMatcher): def __init__(self, substring) -> None: super(StringContains, self).__init__(substring) def _matches(self, item: str) -> bool: if not hasmethod(item, "find"): return False return item.find(self.substring) >= 0 def relationship(self): return "containing" def contains_string(substring: str) -> Matcher[str]: """Matches if object is a string containing a given string. :param string: The string to search for. This matcher first checks whether the evaluated object is a string. If so, it checks whether it contains ``string``. Example:: contains_string("def") will match "abcdefg". """ return StringContains(substring) PK e��Z��n� � library/object/hasproperty.pynu �[��� from typing import Any, Mapping, TypeVar, Union, overload from hamcrest import described_as from hamcrest.core import anything from hamcrest.core.base_matcher import BaseMatcher from hamcrest.core.core.allof import AllOf from hamcrest.core.description import Description from hamcrest.core.helpers.wrap_matcher import wrap_matcher as wrap_shortcut from hamcrest.core.matcher import Matcher from hamcrest.core.string_description import StringDescription __author__ = "Chris Rose" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" V = TypeVar("V") class IsObjectWithProperty(BaseMatcher[object]): def __init__(self, property_name: str, value_matcher: Matcher[V]) -> None: self.property_name = property_name self.value_matcher = value_matcher def _matches(self, item: object) -> bool: if item is None: return False if not hasattr(item, self.property_name): return False value = getattr(item, self.property_name) return self.value_matcher.matches(value) def describe_to(self, description: Description) -> None: description.append_text("an object with a property '").append_text( self.property_name ).append_text("' matching ").append_description_of(self.value_matcher) def describe_mismatch(self, item: object, mismatch_description: Description) -> None: if item is None: mismatch_description.append_text("was None") return if not hasattr(item, self.property_name): mismatch_description.append_description_of(item).append_text( " did not have the " ).append_description_of(self.property_name).append_text(" property") return mismatch_description.append_text("property ").append_description_of( self.property_name ).append_text(" ") value = getattr(item, self.property_name) self.value_matcher.describe_mismatch(value, mismatch_description) def __str__(self): d = StringDescription() self.describe_to(d) return str(d) def has_property(name: str, match: Union[None, Matcher[V], V] = None) -> Matcher[object]: """Matches if object has a property with a given name whose value satisfies a given matcher. :param name: The name of the property. :param match: Optional matcher to satisfy. This matcher determines if the evaluated object has a property with a given name. If no such property is found, ``has_property`` is not satisfied. If the property is found, its value is passed to a given matcher for evaluation. 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. If the ``match`` argument is not provided, the :py:func:`~hamcrest.core.core.isanything.anything` matcher is used so that ``has_property`` is satisfied if a matching property is found. Examples:: has_property('name', starts_with('J')) has_property('name', 'Jon') has_property('name') """ if match is None: match = anything() return IsObjectWithProperty(name, wrap_shortcut(match)) # Keyword argument form @overload def has_properties(**keys_valuematchers: Union[Matcher[V], V]) -> Matcher[object]: ... # Name to matcher dict form @overload def has_properties(keys_valuematchers: Mapping[str, Union[Matcher[V], V]]) -> Matcher[object]: ... # Alternating name/matcher form @overload def has_properties(*keys_valuematchers: Any) -> Matcher[object]: ... def has_properties(*keys_valuematchers, **kv_args): """Matches if an object has properties satisfying all of a dictionary of string property names 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_properties({'foo':equal_to(1), 'bar':equal_to(2)}) has_properties({'foo':1, 'bar':2}) ``has_properties`` also accepts a list of keyword arguments: .. function:: has_properties(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_properties(foo=equal_to(1), bar=equal_to(2)) has_properties(foo=1, bar=2) Finally, ``has_properties`` also accepts a list of alternating keys and their value matchers: .. function:: has_properties(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_properties('foo', equal_to(1), 'bar', equal_to(2)) has_properties('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_shortcut(base_dict[key]) except AttributeError: raise ValueError( "single-argument calls to has_properties must pass a dict as the argument" ) else: if len(keys_valuematchers) % 2: raise ValueError("has_properties requires key-value pairs") base_dict = {} for index in range(int(len(keys_valuematchers) / 2)): base_dict[keys_valuematchers[2 * index]] = wrap_shortcut( keys_valuematchers[2 * index + 1] ) for key, value in kv_args.items(): base_dict[key] = wrap_shortcut(value) if len(base_dict) > 1: description = StringDescription().append_text("an object with properties ") for i, (property_name, property_value_matcher) in enumerate(sorted(base_dict.items())): description.append_description_of(property_name).append_text( " matching " ).append_description_of(property_value_matcher) if i < len(base_dict) - 1: description.append_text(" and ") return described_as( str(description), AllOf( *[ has_property(property_name, property_value_matcher) for property_name, property_value_matcher in sorted(base_dict.items()) ], describe_all_mismatches=True, describe_matcher_in_mismatch=False, ), ) else: property_name, property_value_matcher = base_dict.popitem() return has_property(property_name, property_value_matcher) PK e��ZAx7n� � 3 library/object/__pycache__/__init__.cpython-310.pycnu �[��� o (]^ � @ s< d Z ddlmZ ddlmZmZ ddlmZ dZdZ dZ dS ) z*Matchers that inspect objects and classes.� )� has_length)�has_properties� has_property)� has_stringzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtN) �__doc__� haslengthr � haspropertyr r � hasstringr � __author__� __copyright__� __license__� r r �B/usr/lib/python3/dist-packages/hamcrest/library/object/__init__.py�<module> s PK e��Z�%� � 4 library/object/__pycache__/haslength.cpython-310.pycnu �[��� o (]^q � @ s� d dl mZ d dlmZ d dlmZ d dlmZ d dlm Z d dl m Z d dl m Z dZd Zd ZG d d � d ee �Zd eee e f de e fdd�ZdS )� )�Sized)�Union)� BaseMatcher)� Description)� hasmethod)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc sd e Zd Zdee ddfdd�Zdedefdd�Zded e ddf� fd d � Z d e ddfd d�Z � Z S )� HasLength� len_matcher�returnNc C s || _ d S )N)r )�selfr � r �C/usr/lib/python3/dist-packages/hamcrest/library/object/haslength.py�__init__ s zHasLength.__init__�itemc C s t |d�sdS | j�t|��S )N�__len__F)r r �matches�len)r r r r r �_matches s zHasLength._matches�mismatch_descriptionc s8 t t| ��||� t|d�r|�d��t|�� d S d S )Nr z with length of )�superr �describe_mismatchr � append_text�append_description_ofr )r r r �� __class__r r r s �zHasLength.describe_mismatch� descriptionc C s |� d��| j� d S )Nzan object with length of )r r r )r r r r r � describe_to s zHasLength.describe_to) �__name__� __module__� __qualname__r �intr r �boolr r r r � __classcell__r r r r r s r �matchr c C s t t| ��S )aM Matches if ``len(item)`` 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 invokes the :py:func:`len` function on the evaluated object to get its length, passing the result to a given matcher for evaluation. 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. Examples:: has_length(greater_than(6)) has_length(5) )r r )r$ r r r � has_length! s r% N)�collections.abcr �typingr �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 &PK e��Z=���� � 4 library/object/__pycache__/hasstring.cpython-310.pycnu �[��� o (]^s � @ sf d dl mZ d dlmZ d dlmZ d dlmZ dZdZ dZ G dd � d ee �Z d ee fd d �Z d S )� )� BaseMatcher)� Description)� wrap_matcher)�MatcherzJon ReidzCopyright 2011 hamcrest.orgzBSD, see License.txtc @ sF e Zd Zdee ddfdd�Zdedefdd�Zd e ddfd d �Z dS ) � HasString� str_matcher�returnNc C s || _ d S �N)r )�selfr � r �C/usr/lib/python3/dist-packages/hamcrest/library/object/hasstring.py�__init__ s zHasString.__init__�itemc C s | j �t|��S r )r �matches�str)r r r r r �_matches s zHasString._matches� descriptionc C s |� d��| j� d S )Nzan object with str )� append_text�append_description_ofr )r r r r r � describe_to s zHasString.describe_to) �__name__� __module__� __qualname__r r r �object�boolr r r r r r r r s r r c C s t t| ��S )aR Matches if ``str(item)`` 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 invokes the :py:func:`str` function on the evaluated object to get its length, passing the result to a given matcher for evaluation. 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. Examples:: has_string(starts_with('foo')) has_string('bar') )r r )�matchr r r � has_string s r N)�hamcrest.core.base_matcherr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr �hamcrest.core.matcherr � __author__� __copyright__� __license__r r r r r r r �<module> s PK e��Z�_ _ 6 library/object/__pycache__/hasproperty.cpython-310.pycnu �[��� o (]^� � @ sH d dl mZmZmZmZmZ d dlmZ d dlm Z d dl m Z d dl m Z d dlmZ d dlmZ d dlmZ d d lmZ d Zd Zd Zed �ZG dd� de e �Z d de dedee ef dee fdd�Z edeee ef dee fdd��Z edee eee ef f dee fdd��Z ededee fdd��Z dd� Z dS ) � )�Any�Mapping�TypeVar�Union�overload)� described_as)�anything)� BaseMatcher)�AllOf)� Description)� wrap_matcher)�Matcher)�StringDescriptionz Chris RosezCopyright 2011 hamcrest.orgzBSD, see License.txt�Vc @ sh e Zd Zdedee ddfdd�Zdedefdd �Z d e ddfd d �Z ded e ddfdd�Z dd� Z dS )�IsObjectWithProperty� property_name� value_matcher�returnNc C s || _ || _d S �N)r r )�selfr r � r �E/usr/lib/python3/dist-packages/hamcrest/library/object/hasproperty.py�__init__ s z IsObjectWithProperty.__init__�itemc C s4 |d u rdS t || j�sdS t|| j�}| j�|�S )NF)�hasattrr �getattrr �matches)r r �valuer r r �_matches s z IsObjectWithProperty._matches� descriptionc C s$ |� d�� | j�� d��| j� d S )Nzan object with a property 'z ' matching )� append_textr �append_description_ofr )r r r r r � describe_to" s �z IsObjectWithProperty.describe_to�mismatch_descriptionc C sz |d u r |� d� d S t|| j�s"|�|�� d��| j�� d� d S |� d��| j�� d� t|| j�}| j�||� d S )Nzwas Nonez did not have the z propertyz property � )r r r r! r r �describe_mismatch)r r r# r r r r r% ' s � � z&IsObjectWithProperty.describe_mismatchc C s t � }| �|� t|�S r )r r" �str)r �dr r r �__str__8 s z IsObjectWithProperty.__str__)�__name__� __module__� __qualname__r& r r r �object�boolr r r" r% r( r r r r r s r N�name�matchr c C s |du rt � }t| t|��S )a� Matches if object has a property with a given name whose value satisfies a given matcher. :param name: The name of the property. :param match: Optional matcher to satisfy. This matcher determines if the evaluated object has a property with a given name. If no such property is found, ``has_property`` is not satisfied. If the property is found, its value is passed to a given matcher for evaluation. 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. If the ``match`` argument is not provided, the :py:func:`~hamcrest.core.core.isanything.anything` matcher is used so that ``has_property`` is satisfied if a matching property is found. Examples:: has_property('name', starts_with('J')) has_property('name', 'Jon') has_property('name') N)r r � wrap_shortcut)r. r/ r r r � has_property> s r1 �keys_valuematchersc K � d S r r �r2 r r r �has_properties` � r5 c C r3 r r r4 r r r r5 f r6 c G r3 r r r4 r r r r5 l r6 c O sf 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 |�dkr�t� � d�}t t |�� ��D ] \}\}} |� |�� d�� | � |t |�d k r�|� d� qst t|�td d � t |�� �D �d d d ���S |�� \}} t|| �S )aX Matches if an object has properties satisfying all of a dictionary of string property names 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_properties({'foo':equal_to(1), 'bar':equal_to(2)}) has_properties({'foo':1, 'bar':2}) ``has_properties`` also accepts a list of keyword arguments: .. function:: has_properties(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_properties(foo=equal_to(1), bar=equal_to(2)) has_properties(foo=1, bar=2) Finally, ``has_properties`` also accepts a list of alternating keys and their value matchers: .. function:: has_properties(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_properties('foo', equal_to(1), 'bar', equal_to(2)) has_properties('foo', 1, 'bar', 2) � r zHsingle-argument calls to has_properties must pass a dict as the argument� z'has_properties requires key-value pairszan object with properties z matching z and c S s g | ] \}}t ||��qS r )r1 )�.0r �property_value_matcherr r r � <listcomp>� s ��z"has_properties.<locals>.<listcomp>TF)�describe_all_mismatches� describe_matcher_in_mismatch)�len�copyr0 �AttributeError� ValueError�range�int�itemsr r � enumerate�sortedr! r r& r �popitemr1 ) r2 �kv_args� base_dict�key�indexr r �ir r: r r r r5 q sT . � �� � � � ��� r ) �typingr r r r r �hamcrestr � hamcrest.corer �hamcrest.core.base_matcherr �hamcrest.core.core.allofr �hamcrest.core.descriptionr �"hamcrest.core.helpers.wrap_matcherr r0 �hamcrest.core.matcherr � hamcrest.core.string_descriptionr � __author__� __copyright__� __license__r r, r r& r1 r5 r r r r �<module> s, *+"$, PK e��Z���s s library/object/hasstring.pynu �[��� 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" class HasString(BaseMatcher[object]): def __init__(self, str_matcher: Matcher[str]) -> None: self.str_matcher = str_matcher def _matches(self, item: object) -> bool: return self.str_matcher.matches(str(item)) def describe_to(self, description: Description) -> None: description.append_text("an object with str ").append_description_of(self.str_matcher) def has_string(match) -> Matcher[object]: """Matches if ``str(item)`` 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 invokes the :py:func:`str` function on the evaluated object to get its length, passing the result to a given matcher for evaluation. 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. Examples:: has_string(starts_with('foo')) has_string('bar') """ return HasString(wrap_matcher(match)) PK e��Z X�q q library/object/haslength.pynu �[��� from collections.abc import Sized from typing import 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" class HasLength(BaseMatcher[Sized]): def __init__(self, len_matcher: Matcher[int]) -> None: self.len_matcher = len_matcher def _matches(self, item: Sized) -> bool: if not hasmethod(item, "__len__"): return False return self.len_matcher.matches(len(item)) def describe_mismatch(self, item: Sized, mismatch_description: Description) -> None: super(HasLength, self).describe_mismatch(item, mismatch_description) if hasmethod(item, "__len__"): mismatch_description.append_text(" with length of ").append_description_of(len(item)) def describe_to(self, description: Description) -> None: description.append_text("an object with length of ").append_description_of(self.len_matcher) def has_length(match: Union[int, Matcher[int]]) -> Matcher[Sized]: """Matches if ``len(item)`` 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 invokes the :py:func:`len` function on the evaluated object to get its length, passing the result to a given matcher for evaluation. 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. Examples:: has_length(greater_than(6)) has_length(5) """ return HasLength(wrap_matcher(match)) PK e��Z[�a library/object/__init__.pynu �[��� """Matchers that inspect objects and classes.""" from .haslength import has_length from .hasproperty import has_properties, has_property from .hasstring import has_string __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Z# ��� � library/__init__.pynu �[��� """Library of Matcher implementations.""" from hamcrest.core import * from hamcrest.library.collection import * from hamcrest.library.integration import * from hamcrest.library.number import * from hamcrest.library.object import * from hamcrest.library.text import * __author__ = "Jon Reid" __copyright__ = "Copyright 2011 hamcrest.org" __license__ = "BSD, see License.txt" __all__ = [ "has_entry", "has_entries", "has_key", "has_value", "is_in", "empty", "has_item", "has_items", "contains_inanyorder", "contains", "contains_exactly", "only_contains", "match_equality", "matches_regexp", "close_to", "greater_than", "greater_than_or_equal_to", "less_than", "less_than_or_equal_to", "has_length", "has_property", "has_properties", "has_string", "equal_to_ignoring_case", "equal_to_ignoring_whitespace", "contains_string", "ends_with", "starts_with", "string_contains_in_order", ] PK e��Zނ>� � __init__.pynu �[��� from hamcrest.core import * from hamcrest.library import * __version__ = "2.0.2" __author__ = "Chris Rose" __copyright__ = "Copyright 2020 hamcrest.org" __license__ = "BSD, see License.txt" PK e��Z���] ] $ __pycache__/__init__.cpython-310.pycnu �[��� PK e��Z � py.typednu �[��� PK e��Z���~ ~ � core/selfdescribing.pynu �[��� PK e��Z^�mot t 1 � core/__pycache__/base_description.cpython-310.pycnu �[��� PK e��Z a8� � 4 � core/__pycache__/selfdescribingvalue.cpython-310.pycnu �[��� PK e��Z|� + + ( � core/__pycache__/matcher.cpython-310.pycnu �[��� PK e��Z��|l l ) ! core/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z�f� - �" core/__pycache__/base_matcher.cpython-310.pycnu �[��� PK e��Z��� � , C+ core/__pycache__/description.cpython-310.pycnu �[��� PK e��Z�c�� / �3 core/__pycache__/selfdescribing.cpython-310.pycnu �[��� PK e��Z䝮] ] , 8 core/__pycache__/assert_that.cpython-310.pycnu �[��� PK e��Zu�6.% % 3 �C core/__pycache__/string_description.cpython-310.pycnu �[��� PK e��Z �� AJ core/description.pynu �[��� PK e��ZC_> �P core/assert_that.pynu �[��� PK e��Z�<ެ � �[ core/string_description.pynu �[��� PK e��Z-� K� � �_ core/selfdescribingvalue.pynu �[��� PK e��Z�2�'� � �c core/base_matcher.pynu �[��� PK e��Z�3H� �i core/core/allof.pynu �[��� PK e��Z4�)4 4 "s core/core/anyof.pynu �[��� PK e��Zj�y�� � �x core/core/isinstanceof.pynu �[��� PK e��Z@��M M + �} core/core/__pycache__/isnot.cpython-310.pycnu �[��� PK e��Z-Y 1 1 - v� core/core/__pycache__/isequal.cpython-310.pycnu �[��� PK e��Z��! ! 0 � core/core/__pycache__/isanything.cpython-310.pycnu �[��� PK e��Z �x� � , �� core/core/__pycache__/raises.cpython-310.pycnu �[��� PK e��Z8�&� . Ѭ core/core/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Zas3u/ / + L� core/core/__pycache__/allof.cpython-310.pycnu �[��� PK e��Z$E� � + ֻ core/core/__pycache__/anyof.cpython-310.pycnu �[��� PK e��Z{1nv v 2 /� core/core/__pycache__/described_as.cpython-310.pycnu �[��� PK e��Z�t�94 4 2 � core/core/__pycache__/isinstanceof.cpython-310.pycnu �[��� PK e��Z�}; ; ) �� core/core/__pycache__/is_.cpython-310.pycnu �[��� PK e��Z%^[�V V , 1� core/core/__pycache__/isnone.cpython-310.pycnu �[��� PK e��ZTe�� � , �� core/core/__pycache__/issame.cpython-310.pycnu �[��� PK e��Zʒ.]� � �� core/core/described_as.pynu �[��� PK e��Z�A��@ @ �� core/core/issame.pynu �[��� PK e��ZiN�s� � ( core/core/isanything.pynu �[��� PK e��Z�3�� � > core/core/isnot.pynu �[��� PK e��Z�) core/core/raises.pynu �[��� PK e��Z >�o U" core/core/isequal.pynu �[��� PK e��Z�t�� � �& core/core/is_.pynu �[��� PK e��Z۾�� � �2 core/core/isnone.pynu �[��� PK e��Z�l��� � �5 core/core/__init__.pynu �[��� PK e��ZI-�2. . 2 9 core/helpers/__pycache__/hasmethod.cpython-310.pycnu �[��� PK e��Z� ? ? 1 �; core/helpers/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z���2 2 / D= core/helpers/__pycache__/ismock.cpython-310.pycnu �[��� PK e��Z8;d� 5 �? core/helpers/__pycache__/wrap_matcher.cpython-310.pycnu �[��� PK e��Z����G G ND core/helpers/ismock.pynu �[��� PK e��Z 7C_Z Z �E core/helpers/hasmethod.pynu �[��� PK e��Z�&�� � ~G core/helpers/wrap_matcher.pynu �[��� PK e��ZmUD;� � �J core/helpers/__init__.pynu �[��� PK e��Z�6�|h h �K core/matcher.pynu �[��� PK e��Z嬯?� � 7V core/__init__.pynu �[��� PK e��Z�t�v� � 6W core/base_description.pynu �[��� PK e��Z m��+ + , j_ library/collection/isdict_containingvalue.pynu �[��� PK e��Zۋ �� � D �f library/collection/__pycache__/issequence_containing.cpython-310.pycnu �[��� PK e��Z2 �C C 3 �w library/collection/__pycache__/isin.cpython-310.pycnu �[��� PK e��Z� _� � E �~ library/collection/__pycache__/isdict_containingvalue.cpython-310.pycnu �[��� PK e��Z ��}_ _ H �� library/collection/__pycache__/issequence_onlycontaining.cpython-310.pycnu �[��� PK e��Z���{� � 7 �� library/collection/__pycache__/is_empty.cpython-310.pycnu �[��� PK e��ZV�M� � 7 Ę library/collection/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z�{�� � @ �� library/collection/__pycache__/isdict_containing.cpython-310.pycnu �[��� PK e��Z�i��� � K � library/collection/__pycache__/issequence_containinginorder.cpython-310.pycnu �[��� PK e��Z6Q�_� � C ]� library/collection/__pycache__/isdict_containingkey.cpython-310.pycnu �[��� PK e��Z���� � G j� library/collection/__pycache__/isdict_containingentries.cpython-310.pycnu �[��� PK e��Z�t� N �� library/collection/__pycache__/issequence_containinginanyorder.cpython-310.pycnu �[��� PK e��Z�[*< < . K� library/collection/isdict_containingentries.pynu �[��� PK e��Z�C� ' � library/collection/isdict_containing.pynu �[��� PK e��Z�I�w� � 2 = library/collection/issequence_containinginorder.pynu �[��� PK e��Zδ�| 5 � library/collection/issequence_containinginanyorder.pynu �[��� PK e��Z�Q��4 4 ) library/collection/is_empty.pynu �[��� PK e��Z��01 1 / �- library/collection/issequence_onlycontaining.pynu �[��� PK e��Zq�h h + ,5 library/collection/issequence_containing.pynu �[��� PK e��ZQ�H�� � �B library/collection/isin.pynu �[��� PK e��Zh�ua% % * G library/collection/isdict_containingkey.pynu �[��� PK e��Z�,>f f �N library/collection/__init__.pynu �[��� PK e��Z�&�� � , =Q library/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z� !�+ + % wU library/integration/match_equality.pynu �[��� PK e��Z�Y�� � 8 �Z library/integration/__pycache__/__init__.cpython-310.pycnu �[��� PK e��ZX�dK > �\ library/integration/__pycache__/match_equality.cpython-310.pycnu �[��� PK e��Z�,�b� � `e library/integration/__init__.pynu �[��� PK e��Zp��6� � 4 �f library/number/__pycache__/iscloseto.cpython-310.pycnu �[��� PK e��Z��g�� � > ls library/number/__pycache__/ordering_comparison.cpython-310.pycnu �[��� PK e��Z$�� 3 �} library/number/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z��R � � % � library/number/ordering_comparison.pynu �[��� PK e��Z��� � �� library/number/iscloseto.pynu �[��� PK e��Z �<O= = �� library/number/__init__.pynu �[��� PK e��Z^�!� � % � library/text/stringcontainsinorder.pynu �[��� PK e��Z.U��� � 1 library/text/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z�.L9� � > � library/text/__pycache__/isequal_ignoring_case.cpython-310.pycnu �[��� PK e��ZG�S, , 9 $� library/text/__pycache__/substringmatcher.cpython-310.pycnu �[��� PK e��Z/c�p� � 7 �� library/text/__pycache__/stringendswith.cpython-310.pycnu �[��� PK e��Z���1 1 6 ų library/text/__pycache__/stringmatches.cpython-310.pycnu �[��� PK e��ZrBIȉ � 7 \� library/text/__pycache__/stringcontains.cpython-310.pycnu �[��� PK e��Z�W� � > L� library/text/__pycache__/stringcontainsinorder.cpython-310.pycnu �[��� PK e��ZQ<9�� � 9 ]� library/text/__pycache__/stringstartswith.cpython-310.pycnu �[��� PK e��Z2�B�� � D � library/text/__pycache__/isequal_ignoring_whitespace.cpython-310.pycnu �[��� PK e��Z��� � �� library/text/stringmatches.pynu �[��� PK e��Z�{M�' ' �� library/text/stringendswith.pynu �[��� PK e��Z�Ȃ�� � + l� library/text/isequal_ignoring_whitespace.pynu �[��� PK e��Z�3 �� library/text/substringmatcher.pynu �[��� PK e��Z�OB B � library/text/stringstartswith.pynu �[��� PK e��Z{���O O % �� library/text/isequal_ignoring_case.pynu �[��� PK e��Z���� � O� library/text/__init__.pynu �[��� PK e��Z\o�� �� library/text/stringcontains.pynu �[��� PK e��Z��n� � � library/object/hasproperty.pynu �[��� PK e��ZAx7n� � 3 - library/object/__pycache__/__init__.cpython-310.pycnu �[��� PK e��Z�%� � 4 � library/object/__pycache__/haslength.cpython-310.pycnu �[��� PK e��Z=���� � 4 �) library/object/__pycache__/hasstring.cpython-310.pycnu �[��� PK e��Z�_ _ 6 42 library/object/__pycache__/hasproperty.cpython-310.pycnu �[��� PK e��Z���s s �L library/object/hasstring.pynu �[��� PK e��Z X�q q �R library/object/haslength.pynu �[��� PK e��Z[�a sZ library/object/__init__.pynu �[��� PK e��Z# ��� � �[ library/__init__.pynu �[��� PK e��Zނ>� � �_ __init__.pynu �[��� PK q q . �`
| ver. 1.4 |
Github
|
.
| PHP 8.2.28 | Generation time: 0.02 |
proxy
|
phpinfo
|
Settings