lino 25.6.1__py3-none-any.whl → 25.7.0__py3-none-any.whl

lino/utils/soup.py

@@ -2,14 +2,45 @@
 # Copyright 2016-2025 Rumma & Ko Ltd
 # License: GNU Affero General Public License v3 (see file COPYING for details)
 
-# See https://dev.lino-framework.org/dev/bleach.html
+# See https://dev.lino-framework.org/src/lino/utils/soup.html
+
+# Inspired by
+# https://chase-seibert.github.io/blog/2011/01/28/sanitize-html-with-beautiful-soup.html
+# https://stackoverflow.com/questions/3809401/what-is-a-good-regular-expression-to-match-a-url
+# https://www.geeksforgeeks.org/python-check-url-string/
+
+# TODO: Explain why we don't use Django's Truncator instead of this.
+# from django.utils.text import Truncator
+# def truncate_comment(html_str, max_length=300):
+#     return Truncator(html_str).chars(max_length, html=True)
+
 
 import re
+from html import escape
+from urllib.parse import urlparse
 from bs4 import BeautifulSoup, NavigableString, Comment, Doctype
-from bs4.element import Tag
-import logging
-logger = logging.getLogger(__file__)
-# from lino.api import dd
+from django.conf import settings
+
+MORE_INDICATOR = "..."
+
+URL_REGEX = re.compile(
+    r'([^"]|^)(https?:\/\/)((www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*))'
+)
+
+# URL_REGEX = re.compile(r'([^"])(https?://\S+|www\.\S+)')
+
+
+def urlrepl(match):
+    url = match[2] + match[3]
+    # raise Exception(repr(url))
+    parsed = urlparse(url)
+    if parsed.scheme and parsed.netloc:
+        return match[1] + f'<a href="{url}" target="_blank">{match[3]}</a>'
+    return match[0]
+
+
+def url2a(s):
+    return URL_REGEX.sub(urlrepl, s)
 
 
 PARAGRAPH_TAGS = {
@@ -138,6 +169,8 @@ class TextCollector:
         # assert ch.name != "IMG"
         we_want_more = True
 
+        # print(f"20250207c add_chunk {ch.__class__} {ch}")
+
         # Ignore all images except the first one. And for the first one we
         # enforce our style.
         if ch.name == "img":
@@ -147,7 +180,7 @@ class TextCollector:
                 return True
             self.found_image = True
             style = Style(ch.get("style", None))
-            if not "float" in style:
+            if "float" not in style:
                 style["float"] = "right"
             style.adjust_size()
             if style.is_dirty:
@@ -156,45 +189,21 @@ class TextCollector:
 
         elif ch.string is not None:
             text = ch.string
+            if self.sep == "" and self.text == "":
+                text = text.lstrip()
             strlen = len(text)
-            # print(f"20250208b add_chunk {repr(ch)} len={strlen} remaining={self.remaining}")
-            # chop = self.remaining
             if strlen > self.remaining:
                 we_want_more = False
-                # ch.string = ch.string[: self.remaining] + "..."
-                end_text = text[:self.remaining] + "..."
+                text = text[:self.remaining] + MORE_INDICATOR
                 # raise Exception(f"20250208 {strlen} > {self.remaining} {end_text}")
-                if isinstance(ch, NavigableString):
-                    # ch = NavigableString(end_text)
-                    ch = end_text
-                else:
-                    ch.string.replace_with(end_text)
-                #     # ch = NavigableString(ch.string[:chop] + "...")
-                #     # self.text += self.sep + ch.string
-                #     self.text += self.sep + end_text
-                #     return False
-                # p = ch.string.parent
-                # previous_sibling = ch.previous_sibling
-                # ch = NavigableString(end_text)
-                # ch = previous_sibling.next_sibling
-                # raise Exception(f"20250208 Old {p} and new parent {ch.parent}")
-                # if isinstance(ch, NavigableString):
-                #     ch.replace_with(end_text)
-                # else:
-                #     ch.string.replace_with(end_text)
-                # self.text += self.sep + str(ch)
-                # for c in ch.children:
-                #     self.add_chunk(c)
-                # return False
-                # raise Exception(f"20250208 {end_text} -- {ch}")
-                # print(f"20250208c {repr(end_text)} in {ch}")
-                # print("20230927", ch.string, ch)
-                # self.text += str(ch.string) + "..."
-                # self.remaining = 0
-                # return True
-                # return we_want_more
             self.remaining -= strlen
-            # print(f"20250207c add_chunk {ch.__class__} {ch}")
+            # print(f"20250606 {text} becomes {escape(text, quote=False)}")
+            text = escape(text, quote=False)
+            if isinstance(ch, NavigableString):
+                # ch = NavigableString(end_text)
+                ch = text
+            else:
+                ch.string.replace_with(text)
 
         # if isinstance(ch, NavigableString):
         #     self.text += self.sep + ch.string
@@ -207,33 +216,6 @@ class TextCollector:
         return we_want_more
 
 
-def truncate_comment(html_str, max_length=300):
-    # Returns a single paragraph with a maximum number of visible chars.
-    # new implementation since 20230713
-    html_str = html_str.strip()  # remove leading or trailing newlines
-
-    if False:  # no longer need to test for specil case
-      if not html_str.startswith("<"):
-        # print("20231023 c", html_str)
-        if len(html_str) > max_length:
-            return html_str[:max_length] + "..."
-        return html_str
-
-    # if "choose one or the other" in html_str:
-    #     print(html_str)
-    #     raise Exception("20230928 {} {}".format(len(html_str), max_length))
-
-    # soup = BeautifulSoup(html_str, features="html.parser")
-    soup = BeautifulSoup(html_str, features="lxml")
-    # soup = sanitized_soup(html_str)
-    # truncate_soup(soup, max_length)
-    # return str(soup)
-    # return "".join([str(s) for s in walk(soup, max_length)])
-    tc = TextCollector(max_length)
-    tc.add_chunk(soup)
-    return tc.text
-
-
 # remove these tags including their content.
 blacklist = frozenset(["script", "style", "head"])
 
@@ -271,7 +253,7 @@ GENERALLY_ALLOWED_ATTRS = {"title", "style", "class"}
 
 # Map of allowed attributes by tag. Originally copied from bleach.sanitizer.
 ALLOWED_ATTRIBUTES = {
-    "a": {"href"} | GENERALLY_ALLOWED_ATTRS,
+    "a": {"href", "target"} | GENERALLY_ALLOWED_ATTRS,
     "img": {"src", "alt"} | GENERALLY_ALLOWED_ATTRS,
 }
 
@@ -292,16 +274,18 @@ ALLOWED_ATTRIBUTES["p"] = GENERALLY_ALLOWED_ATTRS | {"align"}
 #     return css
 
 
-def sanitized_soup(old):
+SANITIZERS = []
 
-    # Inspired by https://chase-seibert.github.io/blog/2011/01/28/sanitize-html-with-beautiful-soup.html
 
-    try:
-        soup = BeautifulSoup(old, features="lxml")
-    except HTMLParseError as e:
-        logger.warning("Could not sanitize %r : %s", old, e)
-        return f"Could not sanitize content ({e})"
+def register_sanitizer(func):
+    SANITIZERS.append(func)
 
+
+def sanitized_soup(htmlstr):
+    if not htmlstr.startswith("<"):
+        htmlstr = f"<p>{htmlstr}</p>"
+    htmlstr = url2a(htmlstr)
+    soup = BeautifulSoup(htmlstr, features="lxml")
     for tag in soup.find_all():
         # print(tag)
         tag_name = tag.name.lower()
@@ -324,21 +308,8 @@ def sanitized_soup(old):
             tag.name = "span"
             tag.attrs = dict()
 
-    links = soup.find_all('p', string=(expr := re.compile(
-        r"(?P<url>https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*))"
-    )))
-    if links:
-        for link in links:
-            m = re.search(expr, link.text)
-            url = m['url']
-            old_link = str(link).replace(url, "<a href=\"{0}\">{0}</a>".format(url))
-            link_soup = BeautifulSoup(old_link, features="lxml")
-            link.replaceWith(link_soup.p)
-
-
     # remove all comments because they might contain scripts
-    comments = soup.find_all(
-        text=lambda text: isinstance(text, (Comment, Doctype)))
+    comments = soup.find_all(text=lambda t: isinstance(t, (Comment, Doctype)))
     for comment in comments:
         comment.extract()
 
@@ -351,24 +322,22 @@ def sanitized_soup(old):
     return soup
 
 
-def sanitize(s, **kwargs):
-    s = s.strip()
-    if not s:
-        return s
-
-    soup = sanitized_soup(s)
-
+def sanitize(htmlstr, save=False, ar=None):
+    htmlstr = htmlstr.strip()
+    if htmlstr == "":
+        return htmlstr
+    soup = sanitized_soup(htmlstr)
     for func in SANITIZERS:
-        func(soup, **kwargs)
-
-    # do we want to remove whitespace between tags?
-    # s = re.sub(">\s+<", "><", s)
-    # return sanitized_soup(s).decode(formatter="html").strip()
+        func(soup, save=save, ar=ar)
     return str(soup).strip()
 
 
-SANITIZERS = []
-
-
-def register_sanitizer(func):
-    SANITIZERS.append(func)
+def truncate_comment(htmlstr, max_length=300):
+    # new implementation since 20230713
+    htmlstr = htmlstr.strip()  # remove leading or trailing newlines
+    if htmlstr == '':
+        return htmlstr
+    soup = sanitized_soup(htmlstr)
+    tc = TextCollector(max_length)
+    tc.add_chunk(soup)
+    return tc.text.strip()

{lino-25.6.1.dist-info → lino-25.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lino
-Version: 25.6.1
+Version: 25.7.0
 Summary: A framework for writing desktop-like web applications using Django and ExtJS or React
 Project-URL: Homepage, https://www.lino-framework.org
 Project-URL: Repository, https://gitlab.com/lino-framework/lino