style: apply ruff format to entire codebase

Author: Solganis

assertpy2/assertpy.py

@@ -56,28 +56,31 @@
 from .snapshot import SnapshotMixin
 from .string import StringMixin
 
-__version__ = '2.0.0'
+__version__ = "2.0.0"
 
 __tracebackhide__ = True  # clean tracebacks via py.test integration
 contextlib.__tracebackhide__ = True  # monkey patch contextlib with clean py.test tracebacks
 
 # assertpy files
-ASSERTPY_FILES = [os.path.join('assertpy2', file) for file in [
-    'assertpy.py',
-    'base.py',
-    'collection.py',
-    'contains.py',
-    'date.py',
-    'dict.py',
-    'dynamic.py',
-    'exception.py',
-    'extracting.py',
-    'file.py',
-    'helpers.py',
-    'numeric.py',
-    'snapshot.py',
-    'string.py'
-]]
+ASSERTPY_FILES = [
+    os.path.join("assertpy2", file)
+    for file in [
+        "assertpy.py",
+        "base.py",
+        "collection.py",
+        "contains.py",
+        "date.py",
+        "dict.py",
+        "dynamic.py",
+        "exception.py",
+        "extracting.py",
+        "file.py",
+        "helpers.py",
+        "numeric.py",
+        "snapshot.py",
+        "string.py",
+    ]
+]
 
 # soft assertions
 _soft_ctx = 0
@@ -136,13 +139,13 @@ def soft_assertions() -> Iterator[None]:
         _soft_ctx -= 1
 
     if _soft_err and _soft_ctx == 0:
-        out = 'soft assertion failures:\n' + '\n'.join('%d. %s' % (i + 1, msg) for i, msg in enumerate(_soft_err))
+        out = "soft assertion failures:\n" + "\n".join("%d. %s" % (i + 1, msg) for i, msg in enumerate(_soft_err))
         _soft_err = []
         raise AssertionError(out)
 
 
 # factory methods
-def assert_that(val, description=''):
+def assert_that(val, description=""):
     """Set the value to be tested, plus an optional description, and allow assertions to be called.
 
     This is a factory method for the :class:`AssertionBuilder`, and the single most important
@@ -165,11 +168,11 @@ def test_something():
     """
     global _soft_ctx
     if _soft_ctx:
-        return _builder(val, description, 'soft')
+        return _builder(val, description, "soft")
     return _builder(val, description)
 
 
-def assert_warn(val, description='', logger=None):
+def assert_warn(val, description="", logger=None):
     """Set the value to be tested, and optional description and logger, and allow assertions to be
     called, but never fail, only log warnings.
 
@@ -211,10 +214,10 @@ def assert_warn(val, description='', logger=None):
         Use :meth:`assert_warn` if and only if you have a *really* good reason to log assertion
         failures instead of failing.
     """
-    return _builder(val, description, 'warn', logger=logger)
+    return _builder(val, description, "warn", logger=logger)
 
 
-def fail(msg=''):
+def fail(msg=""):
     """Force immediate test failure with the given message.
 
     Args:
@@ -239,10 +242,10 @@ def test_adder_bad_arg():
                 except TypeError as e:
                     assert_that(str(e)).contains('unsupported operand')
     """
-    raise AssertionError('Fail: %s!' % msg if msg else 'Fail!')
+    raise AssertionError("Fail: %s!" % msg if msg else "Fail!")
 
 
-def soft_fail(msg=''):
+def soft_fail(msg=""):
     """Within a :meth:`soft_assertions` context, append the failure message to the soft error list,
     but do not halt test execution.
 
@@ -273,7 +276,7 @@ def soft_fail(msg=''):
     global _soft_ctx
     if _soft_ctx:
         global _soft_err
-        _soft_err.append('Fail: %s!' % msg if msg else 'Fail!')
+        _soft_err.append("Fail: %s!" % msg if msg else "Fail!")
         return
     fail(msg)
 
@@ -311,7 +314,7 @@ def test_6():
                 # 6 is NOT 5!
     """
     if not callable(func):
-        raise TypeError('func must be callable')
+        raise TypeError("func must be callable")
     _extensions[func.__name__] = func
 
 
@@ -329,12 +332,12 @@ def remove_extension(func):
             remove_extension(is_5)
     """
     if not callable(func):
-        raise TypeError('func must be callable')
+        raise TypeError("func must be callable")
     if func.__name__ in _extensions:
         del _extensions[func.__name__]
 
 
-def _builder(val, description='', kind=None, expected=None, logger=None):
+def _builder(val, description="", kind=None, expected=None, logger=None):
     """Internal helper to build a new :class:`AssertionBuilder` instance and glue on any extension methods."""
     ab = AssertionBuilder(val, description, kind, expected, logger)
     if _extensions:
@@ -366,13 +369,13 @@ def _unwind(frame):
                 prev = frame
 
         filename, lineno = _unwind(inspect.currentframe())
-        return '[%s:%d]: %s' % (os.path.basename(filename), lineno, msg), kwargs
+        return "[%s:%d]: %s" % (os.path.basename(filename), lineno, msg), kwargs
 
 
-_logger = logging.getLogger('assertpy2')
+_logger = logging.getLogger("assertpy2")
 _handler = logging.StreamHandler(sys.stdout)
 _handler.setLevel(logging.WARNING)
-_format = logging.Formatter('%(asctime)s %(levelname)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+_format = logging.Formatter("%(asctime)s %(levelname)s %(message)s", datefmt="%Y-%m-%d %H:%M:%S")
 _handler.setFormatter(_format)
 _logger.addHandler(_handler)
 _default_logger = WarningLoggingAdapter(_logger, None)
@@ -391,7 +394,7 @@ class AssertionBuilder(
     DateMixin,
     ContainsMixin,
     CollectionMixin,
-    BaseMixin
+    BaseMixin,
 ):
     """The main assertion class.  Never call the constructor directly, always use the
     :meth:`assert_that` helper instead.  Or if you just want warning messages, use the
@@ -407,15 +410,15 @@ class AssertionBuilder(
         logger (Logger, optional): the logger for warning messages.  Defaults to ``None``
     """
 
-    def __init__(self, val, description='', kind=None, expected=None, logger=None):
+    def __init__(self, val, description="", kind=None, expected=None, logger=None):
         """Never call this constructor directly."""
         self.val = val
         self.description = description
         self.kind = kind
         self.expected = expected
         self.logger = logger if logger else _default_logger
 
-    def builder(self, val, description='', kind=None, expected=None, logger=None):
+    def builder(self, val, description="", kind=None, expected=None, logger=None):
         """Helper to build a new :class:`AssertionBuilder` instance. Use this only if not chaining to ``self``.
 
         Args:
@@ -453,11 +456,11 @@ def error(self, msg) -> Self:
             AssertionBuilder: returns this instance to chain to the next assertion, but only when
                 ``AssertionError`` is not raised, as is the case when ``kind`` is ``warn`` or ``soft``.
         """
-        out = '%s%s' % ('[%s] ' % self.description if len(self.description) > 0 else '', msg)
-        if self.kind == 'warn':
+        out = "%s%s" % ("[%s] " % self.description if len(self.description) > 0 else "", msg)
+        if self.kind == "warn":
             self.logger.warning(out)
             return self
-        elif self.kind == 'soft':
+        elif self.kind == "soft":
             global _soft_err
             _soft_err.append(out)
             return self

assertpy2/base.py

@@ -124,13 +124,14 @@ def is_equal_to(self, other, **kwargs) -> Self:
         See Also:
             :meth:`~assertpy.string.StringMixin.is_equal_to_ignoring_case` - for case-insensitive string equality
         """
-        if self._check_dict_like(self.val, check_values=False, return_as_bool=True) and \
-                self._check_dict_like(other, check_values=False, return_as_bool=True):
-            if self._dict_not_equal(self.val, other, ignore=kwargs.get('ignore'), include=kwargs.get('include')):
-                self._dict_err(self.val, other, ignore=kwargs.get('ignore'), include=kwargs.get('include'))
+        if self._check_dict_like(self.val, check_values=False, return_as_bool=True) and self._check_dict_like(
+            other, check_values=False, return_as_bool=True
+        ):
+            if self._dict_not_equal(self.val, other, ignore=kwargs.get("ignore"), include=kwargs.get("include")):
+                self._dict_err(self.val, other, ignore=kwargs.get("ignore"), include=kwargs.get("include"))
         else:
             if self.val != other:
-                return self.error('Expected <%s> to be equal to <%s>, but was not.' % (self.val, other))
+                return self.error("Expected <%s> to be equal to <%s>, but was not." % (self.val, other))
         return self
 
     def is_not_equal_to(self, other) -> Self:
@@ -160,7 +161,7 @@ def is_not_equal_to(self, other) -> Self:
             AssertionError: if actual **is** equal to expected
         """
         if self.val == other:
-            return self.error('Expected <%s> to be not equal to <%s>, but was.' % (self.val, other))
+            return self.error("Expected <%s> to be not equal to <%s>, but was." % (self.val, other))
         return self
 
     def is_same_as(self, other) -> Self:
@@ -202,7 +203,7 @@ def is_same_as(self, other) -> Self:
             AssertionError: if actual is **not** identical to expected
         """
         if self.val is not other:
-            return self.error('Expected <%s> to be identical to <%s>, but was not.' % (self.val, other))
+            return self.error("Expected <%s> to be identical to <%s>, but was not." % (self.val, other))
         return self
 
     def is_not_same_as(self, other) -> Self:
@@ -233,7 +234,7 @@ def is_not_same_as(self, other) -> Self:
             AssertionError: if actual **is** identical to expected
         """
         if self.val is other:
-            return self.error('Expected <%s> to be not identical to <%s>, but was.' % (self.val, other))
+            return self.error("Expected <%s> to be not identical to <%s>, but was." % (self.val, other))
         return self
 
     def is_true(self) -> Self:
@@ -258,7 +259,7 @@ def is_true(self) -> Self:
             AssertionError: if val **is** false
         """
         if not self.val:
-            return self.error('Expected <%s> to be <True>, but was not.' % self.val)
+            return self.error("Expected <%s> to be <True>, but was not." % self.val)
         return self
 
     def is_false(self) -> Self:
@@ -283,7 +284,7 @@ def is_false(self) -> Self:
             AssertionError: if val **is** true
         """
         if self.val:
-            return self.error('Expected <%s> to be <False>, but was not.' % self.val)
+            return self.error("Expected <%s> to be <False>, but was not." % self.val)
         return self
 
     def is_none(self) -> Self:
@@ -302,7 +303,7 @@ def is_none(self) -> Self:
             AssertionError: if val is **not** none
         """
         if self.val is not None:
-            return self.error('Expected <%s> to be <None>, but was not.' % self.val)
+            return self.error("Expected <%s> to be <None>, but was not." % self.val)
         return self
 
     def is_not_none(self) -> Self:
@@ -322,11 +323,11 @@ def is_not_none(self) -> Self:
             AssertionError: if val **is** none
         """
         if self.val is None:
-            return self.error('Expected not <None>, but was.')
+            return self.error("Expected not <None>, but was.")
         return self
 
     def _type(self, val):
-        if hasattr(val, '__name__'):
+        if hasattr(val, "__name__"):
             return val.__name__
         return val.__class__.__name__
 
@@ -355,10 +356,10 @@ def is_type_of(self, some_type) -> Self:
             AssertionError: if val is **not** of the given type
         """
         if type(some_type) is not type and not issubclass(type(some_type), type):
-            raise TypeError('given arg must be a type')
+            raise TypeError("given arg must be a type")
         if type(self.val) is not some_type:
             t = self._type(self.val)
-            return self.error('Expected <%s:%s> to be of type <%s>, but was not.' % (self.val, t, some_type.__name__))
+            return self.error("Expected <%s:%s> to be of type <%s>, but was not." % (self.val, t, some_type.__name__))
         return self
 
     def is_instance_of(self, some_class) -> Self:
@@ -395,9 +396,11 @@ class Foo: pass
         try:
             if not isinstance(self.val, some_class):
                 t = self._type(self.val)
-                return self.error('Expected <%s:%s> to be instance of class <%s>, but was not.' % (self.val, t, some_class.__name__))
+                return self.error(
+                    "Expected <%s:%s> to be instance of class <%s>, but was not." % (self.val, t, some_class.__name__)
+                )
         except TypeError:
-            raise TypeError('given arg must be a class') from None
+            raise TypeError("given arg must be a class") from None
         return self
 
     def is_length(self, length) -> Self:
@@ -424,9 +427,9 @@ def is_length(self, length) -> Self:
             AssertionError: if val is **not** the given length
         """
         if type(length) is not int:
-            raise TypeError('given arg must be an int')
+            raise TypeError("given arg must be an int")
         if length < 0:
-            raise ValueError('given arg must be a positive int')
+            raise ValueError("given arg must be a positive int")
         if len(self.val) != length:
-            return self.error('Expected <%s> to be of length <%d>, but was <%d>.' % (self.val, length, len(self.val)))
+            return self.error("Expected <%s> to be of length <%d>, but was <%d>." % (self.val, length, len(self.val)))
         return self