Upload images referenced in document in one go

Author: amotl

CHANGES.md

@@ -11,6 +11,6 @@
 - Add HubSpot "BlogPost" wrapper and "upload" feature
 - Add HubSpot "File" wrapper, with refactoring
 - Add "delete" operations for both "BlogPost", and "File" entities
-
+- Upload images referenced in document in one go
 
 ## 2023/09/xx 0.0.0

hubspot_tech_writing/core.py

@@ -1,3 +1,4 @@
+import functools
 import logging
 import typing as t
 import warnings
@@ -12,6 +13,7 @@
 from hubspot_tech_writing.html import postprocess
 from hubspot_tech_writing.hubspot_api import HubSpotAdapter, HubSpotBlogPost, HubSpotFile
 from hubspot_tech_writing.util.common import ContentTypeResolver
+from hubspot_tech_writing.util.html import HTMLImageTranslator
 from hubspot_tech_writing.util.io import to_io
 
 logger = logging.getLogger(__name__)
@@ -80,31 +82,46 @@ def upload(
     logger.info(f"Uploading file: {source}")
     hsa = HubSpotAdapter(access_token=access_token)
 
-    # Convert markup to HTML.
+    # Upload text files as blog posts.
     if ctr.is_text():
+        # Convert markup to HTML.
         if ctr.is_markup():
             html = convert(source)
         elif ctr.is_html():
             html = Path(source).read_text()
         else:
             raise ValueError(f"Unknown file type: {ctr.suffix}")
 
+        # Collect and converge images.
+        if not folder_id and not folder_path:
+            logger.warning("Images will not be uploaded, please supply folder id or folder name")
+        else:
+            uploader = functools.partial(
+                upload, access_token=access_token, folder_id=folder_id, folder_path=folder_path
+            )
+            hit = HTMLImageTranslator(html=html, source_path=source_path, uploader=uploader)
+            hit.discover().process()
+            html = hit.html_out
+
+        # Upload blog post.
         name = name or source_path.stem
         article = HubSpotBlogPost(hubspot_adapter=hsa, name=name, content_group_id=content_group_id)
         post: BlogPost = article.post
         post.post_body = html
-        article.save()
+        return article.save()
 
         # Only in emergency situations.
         # article.delete()  # noqa: ERA001
 
-    elif ctr.is_file():
+    # Upload other files as File objects.
+    elif ctr.is_file():  # noqa: RET505
         name = name or source_path.name
         file = HubSpotFile(hubspot_adapter=hsa, source=source, name=name, folder_id=folder_id, folder_path=folder_path)
-        file.save()
+        return file.save()
+    return None
 
-        # Only in emergency situations.
-        # file.delete()  # noqa: ERA001
+    # Only in emergency situations.
+    # file.delete()  # noqa: ERA001
 
 
 def delete_blogpost(access_token: str, identifier: t.Optional[str] = None, name: t.Optional[str] = None):

hubspot_tech_writing/hubspot_api.py

@@ -284,7 +284,10 @@ def __init__(
         self.load()
 
     def __str__(self):
-        return f"{self.__class__.__name__} identifier={self.identifier}, name={self.name}"
+        return (
+            f"{self.__class__.__name__} identifier={self.identifier}, "
+            f"name={self.name}, folder={self.folder_id or self.folder_path}"
+        )
 
     def load(self):
         """

hubspot_tech_writing/util/html.py

@@ -0,0 +1,104 @@
+import dataclasses
+import logging
+import typing as t
+from copy import deepcopy
+from pathlib import Path
+
+from bs4 import BeautifulSoup
+
+logger = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class HTMLImage:
+    alt: str
+    src: str
+
+
+class HTMLImageTranslator:
+    """
+    Translate local image references into remote ones, by uploading them.
+    After that, replace URLs in HTML document.
+    """
+
+    def __init__(self, html: str, source_path: t.Union[str, Path], uploader: t.Optional[t.Callable] = None):
+        self.html_in: str = html
+        self.html_out: t.Optional[str] = None
+        self.source_path = source_path
+        self.uploader = uploader
+        self.images_in: t.List[HTMLImage] = []
+        self.images_local: t.List[HTMLImage] = []
+        self.images_remote: t.List[HTMLImage] = []
+
+    def __str__(self):
+        return (
+            f"HTMLImageTranslator:\nin:     {self.images_in}\nlocal:  {self.images_local}\nremote: {self.images_remote}"
+        )
+
+    def discover(self):
+        self.scan().resolve()
+        return self
+
+    def process(self):
+        self.upload()
+        self.produce()
+        return self
+
+    def scan(self) -> "HTMLImageTranslator":
+        """
+        Scan input HTML for all <img ...> tags.
+        """
+        soup = BeautifulSoup(self.html_in, features="html.parser")
+        images = soup.find_all(name="img")
+        self.images_in = []
+        for image in images:
+            self.images_in.append(HTMLImage(src=image.get("src"), alt=image.get("alt")))
+        return self
+
+    def resolve(self) -> "HTMLImageTranslator":
+        """
+        Process discovered image elements, computing effective paths.
+        """
+        if self.source_path is None:
+            return self
+        parent_path = Path(self.source_path)
+        if parent_path.is_file():
+            parent_path = parent_path.parent
+        self.images_local = []
+        for image in self.images_in:
+            image_new = deepcopy(image)
+            if not image.src.startswith("http://") and not image.src.startswith("https://"):
+                # Use absolute paths 1:1.
+                if image.src.startswith("/"):
+                    pass
+
+                # Relative paths are relative to the original document.
+                else:
+                    image_new.src = str(Path(parent_path) / image.src)
+            self.images_local.append(image_new)
+        return self
+
+    def upload(self) -> "HTMLImageTranslator":
+        """
+        Upload images to HubSpot API, and store URLs.
+        """
+        if self.uploader is None:
+            logger.warning("No upload without uploader")
+            return self
+        for image_local in self.images_local:
+            hs_file = self.uploader(source=image_local.src, name=Path(image_local.src).name)
+            image_url = hs_file.url
+            image_remote: HTMLImage = deepcopy(image_local)
+            image_remote.src = image_url
+            self.images_remote.append(image_remote)
+        return self
+
+    def produce(self) -> "HTMLImageTranslator":
+        """
+        Produce HTML output, with all image references replaced by their remote targets.
+        """
+        html = self.html_in
+        for image_in, image_remote in zip(self.images_in, self.images_remote):
+            html = html.replace(image_in.src, image_remote.src)
+        self.html_out = html
+        return self

pyproject.toml

@@ -63,6 +63,7 @@ dynamic = [
 ]
 
 dependencies = [
+  "beautifulsoup4<5",
   "click<9",
   "click-aliases<2",
   "colorlog<7",