everysk-lib 1.10.3__cp312-cp312-win_amd64.whl → 1.11.0__cp312-cp312-win_amd64.whl

everysk/core/object.py

@@ -9,6 +9,7 @@
 ###############################################################################
 from _collections_abc import dict_items, dict_keys, dict_values
 from collections.abc import Iterator
+from contextlib import suppress
 from copy import copy, deepcopy
 from inspect import isroutine
 from types import GenericAlias, UnionType
@@ -24,7 +25,7 @@ CONFIG_ATTRIBUTE_NAME: str = '_config'
 ###############################################################################
 #   Private functions Implementation
 ###############################################################################
-def __get_field_value__(obj: Any, attr: str, value: Any) -> Any:
+def __get_field_value__(obj: Any, attr: str, value: Any) -> Any:  # noqa: N807
     """
     Function that get the cleaned value for a Field and validate this value.
 
@@ -40,7 +41,7 @@ def __get_field_value__(obj: Any, attr: str, value: Any) -> Any:
     value = _transform_to_undefined(value)
 
     # Get all attributes that the object has
-    attributes = getattr(obj, MetaClass._attr_name)  # pylint: disable=protected-access
+    attributes = getattr(obj, MetaClass._attr_name)  # noqa: SLF001
     try:
         field = attributes[attr]
     except KeyError:
@@ -82,14 +83,19 @@ def _required(attr_name: str, value: Any) -> None:
     """
     Checks if value is required, required values can't be: None, '', [], {}.
 
+    Args:
+        attr_name (str): The name of the attribute being validated. This is used for generating error messages.
+        value (Any): The value to be validated against the required condition.
+
     Raises:
         RequiredError: When value is required and match with False conditions.
     """
     if value in (Undefined, None, '', (), [], {}):
-        raise RequiredError(f'The {attr_name} attribute is required.')
+        msg = f'The {attr_name} attribute is required.'
+        raise RequiredError(msg)
 
 
-def _validate(attr_name: str, value: Any, attr_type: type | UnionType) -> None:  # pylint: disable=too-many-branches, too-many-return-statements
+def _validate(attr_name: str, value: Any, attr_type: type | UnionType) -> None:  # noqa: PLR0911, PLR0912
     """
     Validates that the given value is of the expected attribute type. The function supports special type checks for
     Date and DateTime types and handles general type validation for other types. It allows the value to pass through
@@ -114,15 +120,13 @@ def _validate(attr_name: str, value: Any, attr_type: type | UnionType) -> None:
     if value is None or value is Undefined:
         return
 
-    if attr_type == Date:
-        # If we are expecting a Date we don't need to check other things
-        if Date.is_date(value):
-            return
+    # If we are expecting a Date we don't need to check other things
+    if attr_type == Date and Date.is_date(value):
+        return
 
-    if attr_type == DateTime:
-        # If we are expecting a DateTime we don't need to check other things
-        if DateTime.is_datetime(value):
-            return
+    # If we are expecting a DateTime we don't need to check other things
+    if attr_type == DateTime and DateTime.is_datetime(value):
+        return
 
     # TypeError: typing.Any cannot be used with isinstance()
     if attr_type is Any:
@@ -131,14 +135,12 @@ def _validate(attr_name: str, value: Any, attr_type: type | UnionType) -> None:
     # https://everysk.atlassian.net/browse/COD-4286
     # If we use 'class'/callable as a annotation, the isinstance will fail
     # because attr_type will be a string/function so we need to discard it first
-    if attr_type is callable:
-        if callable(value):
-            return
+    if attr_type is callable and callable(value):
+        return
 
     # If it is string, when we use classes as annotations we check if the name of the class is the same
-    if isinstance(attr_type, str):
-        if type(value).__name__ == attr_type:
-            return
+    if isinstance(attr_type, str) and type(value).__name__ == attr_type:
+        return
 
     try:
         # Check if value is an instance of the expected type
@@ -149,28 +151,30 @@ def _validate(attr_name: str, value: Any, attr_type: type | UnionType) -> None:
         pass
 
     ## Subscriptable types like List, Dict, Tuple, etc
-    if isinstance(attr_type, GenericAlias):
-        # We need to check if the value is a instance of the origin type
-        if isinstance(value, attr_type.__origin__):
-            # We not check the content of the list, dict, tuple, etc
-            return
+    # We need to check if the value is a instance of the origin type
+    if isinstance(attr_type, GenericAlias) and isinstance(value, attr_type.__origin__):
+        # We not check the content of the list, dict, tuple, etc
+        return
 
     if isinstance(attr_type, UnionType):
         # Try to validate with all members of the union
         for attr_type_ in get_args(attr_type):
             try:
                 _validate(attr_name, value, attr_type_)
-                return  # test passed with some member
+
             except FieldValueError:
                 pass
 
-    raise FieldValueError(f'Key {attr_name} must be {attr_type}.')
+            else:
+                return  # test passed with some member
+    msg = f'Key {attr_name} must be {attr_type}.'
+    raise FieldValueError(msg)
 
 
 ###############################################################################
 #   BaseField Class Implementation
 ###############################################################################
-class BaseField:
+class BaseField:  # noqa: PLW1641
     """Base class of all fields that will guarantee their type."""
 
     ## Public attributes
@@ -183,8 +187,9 @@ class BaseField:
 
     def __init__(
         self,
-        attr_type: type | UnionType = None,
+        attr_type: type | UnionType | None = None,
         default: Any = None,
+        *,
         readonly: bool = False,
         required: bool = False,
         required_lazy: bool = False,
@@ -268,7 +273,7 @@ class BaseField:
 
     def get_cleaned_value(self, value: Any) -> Any:
         """
-        This function first converts the value to None if needed, then
+        Function first converts the value to None if needed, then
         checks if the `value` is a callable. If it is, the function calls
         the `value` and stores its result by reassigning the `value` variable.
         Finally, the function calls the `clean_value` method.
@@ -286,13 +291,11 @@ class BaseField:
         value = self.get_value(value)
 
         # Then we run the clean_value method
-        value = self.clean_value(value)
-
-        return value
+        return self.clean_value(value)
 
     def get_value(self, value: Any) -> Any:
         """
-        This function checks if the `value` is a callable
+        Function checks if the `value` is a callable
         By either returning the `value` or returning the
         result of the callable function.
 
@@ -313,7 +316,7 @@ class BaseField:
 
     def clean_value(self, value: Any) -> Any:
         """
-        This method is always called when we assigned a value to some attribute.
+        Method is always called when we assigned a value to some attribute.
         Must be implemented in child classes to change the behavior of a given field.
         Below we have an example that reimplements the `clean_value()`.
 
@@ -344,7 +347,7 @@ class BaseField:
         """
         return value
 
-    def validate(self, attr_name: str, value: Any, attr_type: type | UnionType = None) -> None:
+    def validate(self, attr_name: str, value: Any, attr_type: type | UnionType | None = None) -> None:
         """
         Checks if value is required and if is of correct type.
         This method can be reimplemented in child classes to modify
@@ -373,10 +376,10 @@ class BaseField:
         if attr_type is None:
             attr_type = self.attr_type
 
-        if self.readonly:
-            # This is necessary to be able to at least assign the default value to the field
-            if value != self.default:
-                raise FieldValueError(f"The field '{attr_name}' value cannot be changed.")
+        # This is necessary to be able to at least assign the default value to the field
+        if self.readonly and value != self.default:
+            msg = f"The field '{attr_name}' value cannot be changed."
+            raise FieldValueError(msg)
 
         if self.required and not self.required_lazy:
             _required(attr_name, value)
@@ -385,7 +388,7 @@ class BaseField:
 
     def __getattr__(self, name: str) -> Any:
         """
-        This method is used to handle pylint errors where the method/attribute does not exist.
+        Method is used to handle pylint errors where the method/attribute does not exist.
         The problem is that we change the field in the MetaClass to the Field's default value,
         so StrField does not have the str methods but the result is a string.
         This method will only be executed if the method/attributes do not exist in the Field class.
@@ -405,7 +408,8 @@ class BaseField:
                 pass
 
         # If no attribute was found we raise the error
-        raise AttributeError(f"type object '{self.attr_type}' has no attribute '{name}'.")
+        msg = f"type object '{self.attr_type}' has no attribute '{name}'."
+        raise AttributeError(msg)
 
 
 ###############################################################################
@@ -420,14 +424,14 @@ def _silent(func: callable) -> callable:
         func (callable): The function to be decorated.
     """
 
-    def wrapper(self, *args, **kwargs):
+    def wrapper(self, *args, **kwargs) -> Any:  # noqa: ANN001
         # pylint: disable=broad-exception-caught, protected-access
         silent = kwargs.pop('silent', self._silent)
         try:
             return func(self, *args, **kwargs)
         except Exception as error:
             if not silent:
-                raise error
+                raise
             if self._errors is None:
                 self._errors = {}
             self._errors['init'] = deepcopy(error)
@@ -462,40 +466,40 @@ class MetaClass(type):
                 kwargs = dct
         except Exception as error:  # pylint: disable=broad-exception-caught
             if not silent:
-                raise error
+                raise
             errors['before_init'] = deepcopy(error)
 
         ## Here we create the object and initialize the silent for init must be inside the _silent function
         obj = super().__call__(*args, **kwargs)
-        if obj._errors:
-            errors['init'] = obj._errors['init']
+        if obj._errors:  # noqa: SLF001
+            errors['init'] = obj._errors['init']  # noqa: SLF001
 
         ## If the after init method is implemented we run it
         try:
             obj.__after_init__()
         except Exception as error:  # pylint: disable=broad-exception-caught
             if not silent:
-                raise error
+                raise
             errors['after_init'] = deepcopy(error)
 
         # Store the errors
         if any(errors.values()):
-            obj._errors = errors
+            obj._errors = errors  # noqa: SLF001
             # Execute the handler for errors
-            obj._init_error_handler(kwargs, errors)
+            obj._init_error_handler(kwargs, errors)  # noqa: SLF001
 
         # Set the instance to be Frozen or not
         try:
             config = getattr(obj, CONFIG_ATTRIBUTE_NAME)
-            obj._is_frozen = config.frozen  # pylint: disable=attribute-defined-outside-init
+            obj._is_frozen = config.frozen  # noqa: SLF001
         except AttributeError:
             pass
 
         return obj
 
-    def __new__(mcs, name: str, bases: tuple, attrs: dict) -> Self:
+    def __new__(mcs, name: str, bases: tuple, attrs: dict) -> Self:  # noqa: PLR0912
         """
-        This method is executed every time a BaseObject Class is created in the Python runtime.
+        Method is executed every time a BaseObject Class is created in the Python runtime.
         We changed this method to create the config and attributes properties and update the annotations.
 
         Example:
@@ -538,7 +542,7 @@ class MetaClass(type):
         # Creating the config property.
         if 'Config' in attrs:
             # If Config is in the class we just create it
-            Config = attrs.pop('Config')  # pylint: disable=invalid-name
+            Config = attrs.pop('Config')  # noqa: N806
             attrs[CONFIG_ATTRIBUTE_NAME] = Config()
         else:
             # If Config is not in the class we get the first one from the bases
@@ -589,13 +593,13 @@ class MetaClass(type):
                     attributes[attr_name] = type(attr_value)
 
                     # Now we update annotations for attributes that are not annotated
-                    # Ex: var = 1
+                    # Ex: var = 1  # noqa: ERA001
                     if attr_name not in annotations:
                         annotations[attr_name] = type(attr_value)
 
         # With both completed now we need to get the fields that are only annotations
         # class MyClass:
-        #     var: str
+        #     var: str  # noqa: ERA001
         for key in annotations.keys() - attributes.keys():
             attributes[key] = annotations[key]
             # We set the default value to None to avoid break the code
@@ -618,15 +622,26 @@ class MetaClass(type):
 
         return super().__new__(mcs, name, bases, attrs)
 
-    def __setattr__(cls, __name: str, __value: Any) -> None:
+    def __instancecheck__(cls, instance: object) -> bool:
+        """
+        Method that checks if instance is a BaseMapping or BaseObject.
+
+        Args:
+            instance (object): The instance to be checked.
+        """
+        from everysk.core.mapping import BaseMapping  # noqa: PLC0415
+
+        return isinstance(instance, BaseMapping) or super().__instancecheck__(instance)
+
+    def __setattr__(cls, name: str, value: Any) -> None:
         """
         Method that sets the values on fields of the class.
 
         Args:
-            __name (str): The attribute name.
-            __value (Any): The value that is set.
+            name (str): The attribute name.
+            value (Any): The value that is set.
         """
-        return super().__setattr__(__name, __get_field_value__(cls, __name, __value))
+        return super().__setattr__(name, __get_field_value__(cls, name, value))
 
 
 ###############################################################################
@@ -697,11 +712,10 @@ class _BaseObject(metaclass=MetaClass):
         """
 
     def __check_frozen__(self) -> None:
-        """
-        Method that checks if this class is a Frozen object and raises attribute error.
-        """
+        """Method that checks if this class is a Frozen object and raises attribute error."""
         if self._is_frozen:
-            raise AttributeError(f'Class {self.get_full_doted_class_path()} is frozen and cannot be modified.')
+            msg = f'Class {self.get_full_doted_class_path()} is frozen and cannot be modified.'
+            raise AttributeError(msg)
 
     def __copy__(self) -> Self:
         """
@@ -717,10 +731,9 @@ class _BaseObject(metaclass=MetaClass):
         obj.pop(CONFIG_ATTRIBUTE_NAME, None)
 
         # We create a new obj
-        obj = type(self)(**obj)
-        return obj
+        return type(self)(**obj)
 
-    def __deepcopy__(self, memo: dict = None) -> Self:
+    def __deepcopy__(self, memo: dict | None = None) -> Self:
         """
         A deep copy constructs a new compound object and then, recursively,
         inserts copies into it of the objects found in the original.
@@ -736,27 +749,24 @@ class _BaseObject(metaclass=MetaClass):
         obj.pop(CONFIG_ATTRIBUTE_NAME, None)
 
         # We create a new obj
-        obj = type(self)(**obj)
-        return obj
+        return type(self)(**obj)
 
-    def __delattr__(self, __name: str) -> None:
+    def __delattr__(self, name: str) -> None:
         """
-        Method that removes __name from the object.
+        Method that removes name from the object.
 
         Args:
-            __name (str): The name of the attribute that will be removed.
+            name (str): The name of the attribute that will be removed.
 
         Raises:
             AttributeError: If is frozen.
         """
         self.__check_frozen__()
-        super().__delattr__(__name)
+        super().__delattr__(name)
 
     def __get_attributes__(self) -> dict:
-        """
-        Get all attributes from this class.
-        """
-        return getattr(self, MetaClass._attr_name)  # pylint: disable=protected-access
+        """Get all attributes from this class."""
+        return getattr(self, MetaClass._attr_name)  # noqa: SLF001
 
     def __get_clean_value__(self, attr: str, value: Any) -> Any:
         """
@@ -769,27 +779,32 @@ class _BaseObject(metaclass=MetaClass):
 
     def _init_error_handler(self, kwargs: dict, errors: dict[str, Exception]) -> None:
         """
-        This method is called at the end of the init process if the silent param is True.
+        Method is called at the end of the init process if the silent param is True.
 
         Args:
+            kwargs (dict): The kwargs that were passed to the init.
             errors (dict): A dict {'before_init': None | Exception, 'init': None | Exception, 'after_init': None | Exception}
-        """
+        """  # noqa: E501
 
-    def __setattr__(self, __name: str, __value: Any) -> None:
+    def __setattr__(self, name: str, value: Any) -> None:
         """
         Method changed from BaseClass for check de integrity of data.
         This method is executed on setting attributes in the object.
         Ex: obj.attr = 1
 
+        Args:
+            name (str): The attribute name.
+            value (Any): The value that is set.
+
         Raises:
             AttributeError: If is frozen.
         """
         self.__check_frozen__()
 
         if getattr(self, '_need_validation', True):
-            __value = self.__get_clean_value__(__name, __value)
+            value = self.__get_clean_value__(name, value)
 
-        super().__setattr__(__name, __value)
+        super().__setattr__(name, value)
 
     @classmethod
     def __set_attribute__(cls, attr_name: str, attr_type: Any, attr_value: Any) -> None:
@@ -802,8 +817,8 @@ class _BaseObject(metaclass=MetaClass):
             attr_type (Any): The type for the new attribute.
             attr_value (Any): The value for the new attribute.
         """
-        attributes = getattr(cls, MetaClass._attr_name, {})  # pylint: disable=protected-access
-        annotations = getattr(cls, MetaClass._anno_name, {})  # pylint: disable=protected-access
+        attributes = getattr(cls, MetaClass._attr_name, {})  # noqa: SLF001
+        annotations = getattr(cls, MetaClass._anno_name, {})  # noqa: SLF001
         try:
             # For BaseFields
             annotations[attr_name] = attr_type.attr_type
@@ -889,7 +904,7 @@ class BaseObject(_BaseObject):
 
     def __getstate__(self) -> dict:
         """
-        This method is used by Pickle module to get the correct serialized data.
+        Method is used by Pickle module to get the correct serialized data.
         https://docs.python.org/3.11/library/pickle.html#handling-stateful-objects
         """
         # This generates a dictionary with all attributes
@@ -907,9 +922,9 @@ class BaseObject(_BaseObject):
 
         return dct
 
-    def __setstate__(self, state: dict = None) -> None:
+    def __setstate__(self, state: dict | None = None) -> None:
         """
-        This method is used by Pickle module to set back the correct serialized data.
+        Method is used by Pickle module to set back the correct serialized data.
         We need to iterate over every key and set the value to the object.
 
         Args:
@@ -924,7 +939,7 @@ class BaseObject(_BaseObject):
             # Set the original value to validate the attributes
             self._need_validation = old_need_validation
 
-    def to_native(self, add_class_path: str | None = None, recursion: bool = False) -> Any:
+    def to_native(self, add_class_path: str | None = None, *, recursion: bool = False) -> Any:
         """
         Converts the object to the specified Python type.
 
@@ -938,9 +953,9 @@ class BaseObject(_BaseObject):
         """
         return self.to_dict(add_class_path=add_class_path, recursion=recursion)
 
-    def to_dict(self, add_class_path: bool = False, recursion: bool = False) -> dict:
+    def to_dict(self, *, add_class_path: bool = False, recursion: bool = False) -> dict:
         """
-        This method is used to convert the object to a dictionary.
+        Method is used to convert the object to a dictionary.
         If add_class_path is True, the full doted class path will be added to the dictionary.
         If recursion is True, the method will call the to_dict method of the child objects.
 
@@ -966,7 +981,7 @@ class BaseObject(_BaseObject):
         for key in keys:
             value = getattr(self, key)
             func = getattr(self, f'_process_{key}', no_op)
-            key = config.key_mapping.get(key, key)
+            key = config.key_mapping.get(key, key)  # noqa: PLW2901
             result = func(value)
             if recursion and isinstance(result, BaseObject):
                 result = result.to_dict(add_class_path=add_class_path, recursion=recursion)
@@ -989,7 +1004,7 @@ class BaseDictConfig(BaseObjectConfig):
 ###############################################################################
 #   BaseDict Class Implementation
 ###############################################################################
-class BaseDict(BaseObject):
+class BaseDict(BaseObject):  # noqa: PLW1641
     """
     Extends BaseObject and also guarantees that BaseDict['key'] is equal to BaseDict.key
 
@@ -1059,7 +1074,7 @@ class BaseDict(BaseObject):
         """
         return key in self.__data__
 
-    def __delattr__(self, name: str, caller: str = None) -> None:
+    def __delattr__(self, name: str, caller: str | None = None) -> None:
         """
         Removes an atribute from self.
 
@@ -1076,13 +1091,11 @@ class BaseDict(BaseObject):
         # Caller not None means this method was called from __delitem__
         # then we do not call the method again avoiding infinite loop
         if caller is None:
-            try:
+            with suppress(KeyError):
                 # Some times the attribute will not exists
                 self.__delitem__(name, caller='__delattr__')
-            except KeyError:
-                pass
 
-    def __delitem__(self, key: Any, caller: str = None) -> None:
+    def __delitem__(self, key: Any, caller: str | None = None) -> None:
         """
         Removes an key from self.
 
@@ -1127,7 +1140,8 @@ class BaseDict(BaseObject):
             except AttributeError:
                 pass
 
-        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'.")
+        msg = f"'{self.__class__.__name__}' object has no attribute '{name}'."
+        raise AttributeError(msg)
 
     def __getitem__(self, key: str) -> Any:
         """
@@ -1152,9 +1166,9 @@ class BaseDict(BaseObject):
 
         raise KeyError(key)  # pylint: disable=raise-missing-from
 
-    def __ior__(self, other: Any) -> Any:
+    def __ior__(self, other: Any) -> Self:
         """
-        This method performs an in-place merge of two objects using the `|=` operator.
+        Method performs an in-place merge of two objects using the `|=` operator.
         If `other` is an instance of the same class, it merges the attributes of `other` into the `self` class.
         Otherwise, it tries to merge the `other` dictionary into the `self` class.
 
@@ -1200,9 +1214,9 @@ class BaseDict(BaseObject):
         """
         return not self.__eq__(other)
 
-    def __or__(self, other: Any) -> Any:
+    def __or__(self, other: Any) -> 'BaseDict':
         """
-        This method is used to merge two objects using the `|` operator.
+        Method is used to merge two objects using the `|` operator.
         It merges both objects using the `self.__dict__` method if `other` is an instance of the same class.
         Otherwise, if `other` is a dictionary, it merges `self.__dict__` with the `other` dictionary.
 
@@ -1223,17 +1237,17 @@ class BaseDict(BaseObject):
 
     def __repr__(self) -> str:
         """
-        This method returns the representation of the object in a string format.
+        Method returns the representation of the object in a string format.
 
         Returns:
             str: The string representation of the object.
         """
         return self.__data__.__repr__()
 
-    def __ror__(self, other: Any) -> Any:
+    def __ror__(self, other: Any) -> 'BaseDict':
         """
-        This method is used to merge two objects using the `|` operator, with the current object being on the right-hand side.
-        It merges the current object with `other` using the `__dict__` method if `other` is an instance of the same class.
+        Method is used to merge two objects using the `|` operator, with the current object being on the right side.
+        It merges the current object with `other` using the `__dict__` method if `other` is an instance of the class.
         If `other` is a dictionary, it merges the `other` dictionary with `self.__dict__`.
 
         Args:
@@ -1251,7 +1265,7 @@ class BaseDict(BaseObject):
         # don't attempt to compare against unrelated types
         return NotImplemented
 
-    def __setattr__(self, name: str, value: Any, caller: str = None) -> None:
+    def __setattr__(self, name: str, value: Any, caller: str | None = None) -> None:
         """
         Method changed from BaseClass for guarantee de integrity of data attributes.
         This method is executed on setting attributes in the object.
@@ -1272,7 +1286,7 @@ class BaseDict(BaseObject):
             # For integrity guarantee writes the value to the dictionary key as well.
             self.__setitem__(name, new_value, caller='__setattr__')
 
-    def __setitem__(self, key: str, item: Any, caller: str = None) -> None:
+    def __setitem__(self, key: str, item: Any, caller: str | None = None) -> None:
         """
         Method changed from BaseClass for guarantee de integrity of data keys.
         This method is executed on setting items in the dictionary.
@@ -1285,7 +1299,8 @@ class BaseDict(BaseObject):
             raise KeyError("Keys can't start with '_'.")
         config = getattr(self, CONFIG_ATTRIBUTE_NAME)
         if key in config.keys_blacklist:
-            raise KeyError(f'The key cannot be called "{key}".')
+            msg = f'The key cannot be called "{key}".'
+            raise KeyError(msg)
 
         # When value is associated:
         # directly on the key Ex dict['key'] = value then caller will be None
@@ -1301,9 +1316,9 @@ class BaseDict(BaseObject):
         if not isinstance(getattr(type(self), key, None), property):
             self.__data__.__setitem__(key, item)
 
-    def __setstate__(self, state: dict = None) -> None:
+    def __setstate__(self, state: dict | None = None) -> None:
         """
-        This method is used by Pickle module to set back the correct serialized data.
+        Method is used by Pickle module to set back the correct serialized data.
         We need to iterate over every key and set the value to the object.
 
         Args:
@@ -1319,7 +1334,7 @@ class BaseDict(BaseObject):
     ## Public Methods
     def clear(self) -> None:
         """
-        This method clears the dictionary.
+        Method clears the dictionary.
 
         Raises:
             AttributeError: If is frozen.
@@ -1376,7 +1391,7 @@ class BaseDict(BaseObject):
 
     def is_valid_key(self, key: str) -> bool:
         """
-        This method checks if the key is valid.
+        Method checks if the key is valid.
         Valid keys are the ones that not starts with '_' and
         are not in the config.keys_blacklist.
 
@@ -1390,15 +1405,11 @@ class BaseDict(BaseObject):
         return not key.startswith('_') and key not in config.keys_blacklist
 
     def items(self) -> dict_items:
-        """
-        Return a new view of the dictionary's items ((key, value) pairs).
-        """
+        """Return a new view of the dictionary's items ((key, value) pairs)."""
         return self.__data__.items()
 
     def keys(self) -> dict_keys:
-        """
-        Return a new view of the dictionary's keys.
-        """
+        """Return a new view of the dictionary's keys."""
         return self.__data__.keys()
 
     def pop(self, *args) -> Any:
@@ -1417,11 +1428,9 @@ class BaseDict(BaseObject):
         self.__check_frozen__()
         ret = self.__data__.pop(*args)
 
-        try:
+        with suppress(AttributeError):
             # Some times the attribute will not exists
             self.__delattr__(args[0])  # pylint: disable=unnecessary-dunder-call
-        except AttributeError:
-            pass
 
         return ret
 
@@ -1460,10 +1469,9 @@ class BaseDict(BaseObject):
             if self.is_valid_key(key=key):
                 self[key] = value
             else:
-                raise KeyError(f'The key cannot be called "{key}".')
+                msg = f'The key cannot be called "{key}".'
+                raise KeyError(msg)
 
     def values(self) -> dict_values:
-        """
-        Return a new view of the dictionary's values.
-        """
+        """Return a new view of the dictionary's values."""
         return self.__data__.values()