Makes article properties over writable by parser

src/fundus/parser/__init__.py

@@ -1,4 +1,10 @@
-from .base_parser import BaseParser, ParserProxy, attribute, function
+from .base_parser import (
+    BaseParser,
+    ParserProxy,
+    attribute,
+    function,
+    overwrite_attribute,
+)
 from .data import ArticleBody
 
-__all__ = ["ParserProxy", "BaseParser", "attribute", "function", "ArticleBody"]
+__all__ = ["ParserProxy", "BaseParser", "attribute", "function", "overwrite_attribute", "ArticleBody"]

src/fundus/parser/base_parser.py

@@ -76,8 +76,9 @@ def __repr__(self):
 
 
 class Attribute(RegisteredFunction):
-    def __init__(self, func: Callable[[object], Any], priority: Optional[int], validate: bool):
-        self.validate = validate
+    def __init__(self, func: Callable[[object], Any], priority: Optional[int], validate: bool, overwrite: bool = False):
+        self.validate = validate if not overwrite else False
+        self.overwrite = overwrite
         super(Attribute, self).__init__(func=func, priority=priority)
 
 
@@ -88,7 +89,10 @@ def __init__(self, func: Callable[[object], Any], priority: Optional[int]):
 
 def _register(cls, factory: Type[RegisteredFunction], **kwargs):
     def wrapper(func):
-        return functools.update_wrapper(factory(func, **kwargs), func)
+        try:
+            return functools.update_wrapper(factory(func, **kwargs), func)
+        except TypeError as err:
+            raise err
 
     # _register was called with parenthesis
     if cls is None:
@@ -102,6 +106,10 @@ def attribute(cls=None, /, *, priority: Optional[int] = None, validate: bool = T
     return _register(cls, factory=Attribute, priority=priority, validate=validate)
 
 
+def overwrite_attribute(cls):
+    return _register(cls, factory=Attribute, priority=None, validate=False, overwrite=True)
+
+
 def function(cls=None, /, *, priority: Optional[int] = None):
     return _register(cls, factory=Function, priority=priority)
 
@@ -137,7 +145,7 @@ def validated(self) -> "AttributeCollection":
 
     @property
     def unvalidated(self) -> "AttributeCollection":
-        return AttributeCollection(*[attr for attr in self.functions if not attr.validate])
+        return AttributeCollection(*[attr for attr in self.functions if not attr.validate and not attr.overwrite])
 
 
 class FunctionCollection(RegisteredFunctionCollection[Function]):

src/fundus/scraping/article.py

@@ -11,6 +11,7 @@
 from fundus.logging.logger import basic_logger
 from fundus.parser import ArticleBody
 from fundus.scraping.html import HTML
+from fundus.utils.caching import cached_attribute
 
 
 @dataclass(frozen=True)
@@ -41,12 +42,17 @@ def from_extracted(cls, html: HTML, extracted: Dict[str, Any], exception: Option
 
         return article
 
-    @property
+    @cached_attribute
     def plaintext(self) -> Optional[str]:
         return str(self.body) if self.body else None
 
-    @property
+    @cached_attribute
     def lang(self) -> Optional[str]:
+        """
+        computes used language
+        Returns:
+
+        """
         language: Optional[str] = None
 
         if self.plaintext:

src/fundus/utils/caching.py

@@ -0,0 +1,39 @@
+import functools
+
+
+class _CachedAttribute(object):
+    """Computes attribute value and caches it in the instance.
+    From https://stackoverflow.com/questions/7388258/replace-property-for-perfomance-gain?noredirect=1&lq=1
+    Tweaked a bit to be used with a wrapper.
+    """
+
+    def __init__(self, method):
+        self.method = method
+
+    def __get__(self, inst, cls):
+        if inst is None:
+            return self
+        result = self.method(inst)
+        object.__setattr__(inst, self.__name__, result)  # type: ignore[attr-defined]
+        return result
+
+
+# This was implemented in order to
+def cached_attribute(attribute):
+    """Decorate attributes to be cached.
+
+    This works like `cached_property`, but instead of `property` or `cached_property`, the decorated attribute
+    can be overwritten.
+
+    Args:
+        attribute: The attribute to decorate.
+
+    Returns:
+        A wrapped _CachedAttribute instance.
+
+    """
+
+    def wrapper(func):
+        return functools.update_wrapper(_CachedAttribute(func), func)
+
+    return wrapper(attribute)