Ausgabe der neuen DB Einträge

venv/lib/python3.9/site-packages/hamcrest/library/object/__init__.py

@@ -0,0 +1,9 @@
+"""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"

venv/lib/python3.9/site-packages/hamcrest/library/object/haslength.py

@@ -0,0 +1,52 @@
+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))

venv/lib/python3.9/site-packages/hamcrest/library/object/hasproperty.py

@@ -0,0 +1,202 @@
+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)

venv/lib/python3.9/site-packages/hamcrest/library/object/hasstring.py

@@ -0,0 +1,40 @@
+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))