'
+ )
+
+ body = (c.get("body", "") or "").strip()
+ if c.get("deleted"):
+ body = "_[comment deleted]_"
+ body_html = md_to_html_static(body)
+
+ children = c.get("children", []) or []
+ children_html = ""
+ if children:
+ inner = "".join(f"
{render_one(child)}
" for child in children)
+ children_html = f'
{inner}
'
+
+ return f'{header}
{body_html}
{children_html}'
+
+ total = count_all_comments(comments)
+ items = "".join(f"
{render_one(c)}
" for c in comments)
+ return (
+ f''
+ f'
Comments ({total})
'
+ f'
{items}
'
+ f''
+ )
+
+
+def md_to_html_static(md_content: str) -> str:
+ """Module-level Markdown โ HTML conversion (mirrors BaseSubstackScraper.md_to_html)."""
+ if not md_content:
+ return ""
+ return markdown.markdown(md_content, extensions=['extra'])
+
+
+# =============================================================================
+# STRUCTURED HEADER RENDERING (classic Substack article look)
+# =============================================================================
+
+def _format_header_date(date_str: str) -> str:
+ """Format an ISO date (``YYYY-MM-DD``) for display in the byline.
+
+ Falls back to the raw string (including the sentinel ``"Date not found"``).
+ Mirrors the legacy header date formatting in ``combine_metadata_and_content``.
+ """
+ if not date_str:
+ return ""
+ try:
+ return datetime.fromisoformat(date_str).strftime("%b %d, %Y")
+ except ValueError:
+ return date_str
+
+
+def build_post_header(meta: dict) -> str:
+ """Render a Substack-style centered post header from structured metadata.
+
+ ``meta`` is a dict that may contain: ``title``, ``subtitle``, ``author``,
+ ``date`` (ISO ``YYYY-MM-DD``), ``cover_image``. Any missing/empty field is
+ simply omitted. Returns an HTML string for a ````
+ block, or ``""`` if there is nothing to render (no title, subtitle, author
+ or date). The cover image is shown above the title when present.
+ """
+ if not isinstance(meta, dict) or not meta:
+ return ""
+
+ cover_image = (meta.get("cover_image") or "").strip()
+ title = (meta.get("title") or "").strip()
+ subtitle = (meta.get("subtitle") or "").strip()
+ author = (meta.get("author") or "").strip()
+ date_str = (meta.get("date") or "").strip()
+
+ if not (title or subtitle or author or date_str):
+ return ""
+
+ parts = []
+ if cover_image:
+ parts.append(
+ f''
+ )
+ if title:
+ parts.append(f'
{_html_escape(title)}
')
+ if subtitle:
+ parts.append(f'
{_html_escape(subtitle)}
')
+
+ byline_bits = []
+ if author:
+ byline_bits.append(_html_escape(author))
+ display_date = _format_header_date(date_str)
+ if display_date:
+ byline_bits.append(_html_escape(display_date))
+ if byline_bits:
+ parts.append(
+ f'
{" ยท ".join(byline_bits)}
'
+ )
+
+ return f'{"".join(parts)}'
+
+
+def split_metadata_and_body(md_content: str, frontmatter_format: str = "legacy") -> Tuple[dict, str]:
+ """Inverse of ``combine_metadata_and_content``: recover metadata + body.
+
+ Used by ``render_posts.py`` to re-render on-disk markdown into the structured
+ Substack look without re-scraping. Returns ``(meta_dict, body_md)`` where
+ ``meta_dict`` has keys ``title``, ``subtitle``, ``author``, ``date``,
+ ``cover_image``, and ``like_count`` (any that aren't found are absent).
+
+ - ``mdx``: strip the leading YAML frontmatter (``---\\nโฆ\\n---``) and parse it.
+ - ``legacy``: strip the leading ``# title`` line, an optional ``## subtitle``,
+ the ``****`` line, and the ``**Likes:** N`` line.
+
+ If the content doesn't match the expected pattern, it is returned unchanged as
+ the body with an empty metadata dict (so rendering is never destructive).
+ """
+ if not md_content:
+ return {}, ""
+
+ meta: dict = {}
+
+ if frontmatter_format == "mdx":
+ m = re.match(r'^---\s*\n(.*?)\n---\s*\n?(.*)$', md_content, re.DOTALL)
+ if m:
+ for line in m.group(1).splitlines():
+ if ":" not in line:
+ continue
+ key, _, raw = line.partition(":")
+ key = key.strip()
+ val = raw.strip()
+ # Strip surrounding YAML quotes.
+ if (val.startswith('"') and val.endswith('"')) \
+ or (val.startswith("'") and val.endswith("'")):
+ val = val[1:-1]
+ if key and val:
+ if key == "image":
+ meta["cover_image"] = val
+ else:
+ meta[key] = val
+ return meta, m.group(2).lstrip("\n")
+
+ # legacy format
+ lines = md_content.split("\n")
+ idx = 0
+
+ # Title: "# ..."
+ if idx < len(lines) and lines[idx].startswith("# "):
+ meta["title"] = lines[idx][2:].strip()
+ idx += 1
+ # Skip the blank line after the title.
+ if idx < len(lines) and lines[idx].strip() == "":
+ idx += 1
+ # Subtitle: "## ..."
+ if idx < len(lines) and lines[idx].startswith("## "):
+ meta["subtitle"] = lines[idx][3:].strip()
+ idx += 1
+ if idx < len(lines) and lines[idx].strip() == "":
+ idx += 1
+ # Date: "**...**"
+ date_match = re.match(r'^\*\*(.+?)\*\*$', lines[idx]) if idx < len(lines) else None
+ if date_match:
+ meta["date"] = date_match.group(1).strip()
+ idx += 1
+ if idx < len(lines) and lines[idx].strip() == "":
+ idx += 1
+ # Likes: "**Likes:** N"
+ likes_match = re.match(r'^\*\*Likes:\*\*\s*(\d+)\s*$', lines[idx]) if idx < len(lines) else None
+ if likes_match:
+ meta["like_count"] = likes_match.group(1)
+ idx += 1
+ if idx < len(lines) and lines[idx].strip() == "":
+ idx += 1
+
+ body = "\n".join(lines[idx:]).lstrip("\n")
+ return meta, body
+
+
+def build_post_document(
+ html_dir: str,
+ body_html: str,
+ comments_html: str = "",
+ header_html: str = "",
+ title: Optional[str] = None,
+) -> str:
+ """Assemble the full HTML document for a post page (classic Substack shell).
+
+ Shared by the scraper's ``save_to_html_file`` and the standalone ``render_posts.py``
+ so both produce identical markup: Spectral webfont, the essay stylesheet, an optional
+ structured header above the body, and optional comments below it.
+ """
+ css_path = os.path.relpath("./assets/css/essay-styles.css", html_dir)
+ css_path = css_path.replace("\\", "/")
+
+ doc_title = _html_escape(title) if title else "Markdown Content"
+ header_block = f"\n {header_html}" if header_html else ""
+ comments_block = f"\n {comments_html}" if comments_html else ""
+
+ return f"""
+
+
+
+
+
+ {doc_title}
+
+
+
+
+
+
+ {header_block}
+ {body_html}{comments_block}
+
+
+
+ """
+
+
+def render_post_to_html_file(
+ html_filepath: str,
+ body_md: str,
+ meta: Optional[dict] = None,
+ comments_list: Optional[list] = None,
+ frontmatter_format: str = "legacy",
+) -> None:
+ """Re-render a post page from markdown + structured metadata + cached comments.
+
+ Network-free: reads only local content. Used by ``render_posts.py`` (and the
+ ``--render-only`` CLI path) to apply the classic Substack look to posts that were
+ scraped before the structured renderer existed, without re-scraping.
+
+ ``body_md`` is rendered as the post body; ``meta`` (title/subtitle/author/date/
+ cover_image) becomes the header. If ``body_md`` still contains a legacy/mdx header
+ (i.e. it's the full on-disk markdown), pass ``split=True``... otherwise it is split
+ via ``split_metadata_and_body`` automatically when ``meta`` is empty.
+ """
+ body = body_md
+ header_meta = meta or {}
+
+ # If no structured meta was supplied, try to recover it from the markdown itself.
+ if not header_meta:
+ header_meta, body = split_metadata_and_body(body_md, frontmatter_format)
+
+ body_html = md_to_html_static(body)
+ comments_html = render_comments_html(comments_list) if comments_list else ""
+ header_html = build_post_header(header_meta)
+ title = header_meta.get("title")
+
+ html_dir = os.path.dirname(html_filepath)
+ document = build_post_document(
+ html_dir, body_html, comments_html=comments_html, header_html=header_html, title=title
+ )
+ with open(html_filepath, "w", encoding="utf-8") as f:
+ f.write(document)
+
+
def extract_main_part(url: str) -> str:
parts = urlparse(url).netloc.split('.')
return parts[1] if parts[0] == 'www' else parts[0]
@@ -224,17 +683,26 @@ def get_browser_version(browser: str) -> Optional[str]:
except Exception:
pass
else: # macOS/Linux
- try:
- result = subprocess.run(
- ['google-chrome', '--version'],
- capture_output=True, text=True, timeout=10
- )
- if result.returncode == 0:
- match = re.search(r'(\d+\.\d+\.\d+\.\d+)', result.stdout)
- if match:
- version = match.group(1)
- except Exception:
- pass
+ candidates = [
+ "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+ os.path.expanduser("~/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"),
+ "google-chrome", # Linux PATH fallback
+ "chromium",
+ "chromium-browser",
+ ]
+ for candidate in candidates:
+ try:
+ result = subprocess.run(
+ [candidate, "--version"],
+ capture_output=True, text=True, timeout=10
+ )
+ if result.returncode == 0:
+ match = re.search(r'(\d+\.\d+\.\d+\.\d+)', result.stdout)
+ if match:
+ version = match.group(1)
+ break
+ except Exception:
+ continue
elif browser == 'edge':
if os.name == 'nt': # Windows
@@ -255,17 +723,24 @@ def get_browser_version(browser: str) -> Optional[str]:
except Exception:
pass
else: # macOS/Linux
- try:
- result = subprocess.run(
- ['microsoft-edge', '--version'],
- capture_output=True, text=True, timeout=10
- )
- if result.returncode == 0:
- match = re.search(r'(\d+\.\d+\.\d+\.\d+)', result.stdout)
- if match:
- version = match.group(1)
- except Exception:
- pass
+ candidates = [
+ "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+ os.path.expanduser("~/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"),
+ "microsoft-edge", # Linux PATH fallback
+ ]
+ for candidate in candidates:
+ try:
+ result = subprocess.run(
+ [candidate, "--version"],
+ capture_output=True, text=True, timeout=10
+ )
+ if result.returncode == 0:
+ match = re.search(r'(\d+\.\d+\.\d+\.\d+)', result.stdout)
+ if match:
+ version = match.group(1)
+ break
+ except Exception:
+ continue
return version
@@ -321,9 +796,25 @@ def get_user_data_dir(browser: str) -> str:
if not os.path.exists(base_dir):
os.makedirs(base_dir)
return os.path.join(base_dir, f'{browser}_profile')
-
+
+ @staticmethod
+ def _driver_platform(browser: str) -> str:
+ """Return the Chrome-for-Testing / Edge driver platform string for the current OS/arch.
+
+ Detects ARM vs Intel on macOS so Apple Silicon gets mac-arm64 instead of mac-x64.
+ """
+ if os.name == 'nt':
+ return 'win64'
+ if sys.platform == 'darwin':
+ is_arm = os.uname().machine == 'arm64'
+ if browser == 'edge':
+ # Edge driver uses a different naming convention: mac64 vs mac64_m1
+ return 'mac64_m1' if is_arm else 'mac64'
+ return 'mac-arm64' if is_arm else 'mac-x64'
+ return 'linux64'
+
@classmethod
- def download_driver_with_requests(cls, browser: str, browser_version: str) -> Optional[str]:
+ def download_driver_with_requests(cls, browser: str, browser_version: str, quiet: bool = False) -> Optional[str]:
"""
Download the correct driver directly using requests.
This bypasses webdriver_manager issues and gives us full control.
@@ -344,12 +835,14 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
if os.path.exists(driver_path):
cached_version = cls.get_driver_version(driver_path)
if cached_version and cls.versions_compatible(browser_version, cached_version):
- print(f"Using cached chromedriver {cached_version}")
+ if not quiet:
+ print(f"Using cached chromedriver {cached_version}")
return driver_path
try:
# Get the latest driver version for this Chrome version
- print(f"Fetching Chrome driver info for version {major_version}...")
+ if not quiet:
+ print(f"Fetching Chrome driver info for version {major_version}...")
# Try the Chrome for Testing endpoints
endpoints = [
@@ -366,7 +859,7 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
if resp.ok:
driver_version = resp.text.strip()
# Construct download URL
- platform = 'win64' if os.name == 'nt' else ('mac-x64' if sys.platform == 'darwin' else 'linux64')
+ platform = cls._driver_platform(browser)
download_url = f"https://storage.googleapis.com/chrome-for-testing-public/{driver_version}/{platform}/chromedriver-{platform}.zip"
except Exception:
pass
@@ -382,7 +875,7 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
if driver_version.startswith(major_version):
downloads = stable.get('downloads', {}).get('chromedriver', [])
- platform = 'win64' if os.name == 'nt' else ('mac-x64' if sys.platform == 'darwin' else 'linux64')
+ platform = cls._driver_platform(browser)
for d in downloads:
if d.get('platform') == platform:
download_url = d.get('url')
@@ -392,7 +885,8 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
print(f"Could not find chromedriver download URL for Chrome {major_version}")
return None
- print(f"Downloading chromedriver {driver_version}...")
+ if not quiet:
+ print(f"Downloading chromedriver {driver_version}...")
resp = requests.get(download_url, timeout=120)
if not resp.ok:
print(f"Download failed: HTTP {resp.status_code}")
@@ -416,7 +910,8 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
# Make executable on Unix
if os.name != 'nt':
os.chmod(target_path, 0o755)
- print(f"[OK] Chromedriver downloaded to: {target_path}")
+ if not quiet:
+ print(f"[OK] Chromedriver downloaded to: {target_path}")
return target_path
print("Could not find chromedriver in downloaded archive")
@@ -434,15 +929,17 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
if os.path.exists(driver_path):
cached_version = cls.get_driver_version(driver_path)
if cached_version and cls.versions_compatible(browser_version, cached_version):
- print(f"Using cached msedgedriver {cached_version}")
+ if not quiet:
+ print(f"Using cached msedgedriver {cached_version}")
return driver_path
try:
# Get latest Edge driver version
- print(f"Fetching Edge driver info for version {major_version}...")
+ if not quiet:
+ print(f"Fetching Edge driver info for version {major_version}...")
# Edge driver download URL pattern
- platform = 'win64' if os.name == 'nt' else ('mac64' if sys.platform == 'darwin' else 'linux64')
+ platform = cls._driver_platform(browser)
# Try to get the exact version
version_url = f"https://msedgedriver.azureedge.net/LATEST_RELEASE_{major_version}"
@@ -457,7 +954,8 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
download_url = f"https://msedgedriver.azureedge.net/{driver_version}/edgedriver_{platform}.zip"
- print(f"Downloading msedgedriver {driver_version}...")
+ if not quiet:
+ print(f"Downloading msedgedriver {driver_version}...")
resp = requests.get(download_url, timeout=120)
if not resp.ok:
print(f"Download failed: HTTP {resp.status_code}")
@@ -478,7 +976,8 @@ def download_driver_with_requests(cls, browser: str, browser_version: str) -> Op
target.write(source.read())
if os.name != 'nt':
os.chmod(target_path, 0o755)
- print(f"[OK] msedgedriver downloaded to: {target_path}")
+ if not quiet:
+ print(f"[OK] msedgedriver downloaded to: {target_path}")
return target_path
print("Could not find msedgedriver in downloaded archive")
@@ -499,6 +998,7 @@ def create_driver(
browser_path: Optional[str] = None,
user_agent: Optional[str] = None,
use_persistent_profile: bool = False,
+ quiet: bool = False,
) -> webdriver.Remote:
"""
Creates a WebDriver instance with smart fallback logic.
@@ -509,6 +1009,10 @@ def create_driver(
3. Download driver directly to our cache (bypasses PATH issues)
4. Fall back to webdriver_manager
5. Fall back to Selenium Manager
+
+ Args:
+ quiet: Suppress informational prints (used during periodic driver restarts).
+ Warnings/errors are still printed.
"""
browser = browser.lower()
if browser not in cls.SUPPORTED_BROWSERS:
@@ -525,7 +1029,8 @@ def create_driver(
# Detect browser version
browser_version = cls.get_browser_version(browser)
- print(f"Detected {browser.title()} version: {browser_version or 'unknown'}")
+ if not quiet:
+ print(f"Detected {browser.title()} version: {browser_version or 'unknown'}")
if not browser_version:
print(f"WARNING: Could not detect {browser.title()} version. Make sure it's installed.")
@@ -548,7 +1053,8 @@ def create_driver(
if use_persistent_profile:
profile_dir = cls.get_user_data_dir(browser)
options.add_argument(f"user-data-dir={profile_dir}")
- print(f"Using persistent profile at: {profile_dir}")
+ if not quiet:
+ print(f"Using persistent profile at: {profile_dir}")
# Common options for stability
options.add_argument("--no-sandbox")
@@ -561,7 +1067,8 @@ def create_driver(
# Strategy 1: Explicit driver path
if driver_path and os.path.exists(driver_path):
try:
- print(f"Using explicit driver path: {driver_path}")
+ if not quiet:
+ print(f"Using explicit driver path: {driver_path}")
driver_version = cls.get_driver_version(driver_path)
if driver_version:
print(f"Driver version: {driver_version}")
@@ -580,11 +1087,13 @@ def create_driver(
# Strategy 2: Download to our cache (primary method - bypasses PATH issues)
if browser_version:
- print(f"\nDownloading driver to local cache (bypasses system PATH)...")
+ if not quiet:
+ print(f"\nDownloading driver to local cache (bypasses system PATH)...")
try:
- downloaded_path = cls.download_driver_with_requests(browser, browser_version)
+ downloaded_path = cls.download_driver_with_requests(browser, browser_version, quiet=quiet)
if downloaded_path and os.path.exists(downloaded_path):
- print(f"Using downloaded driver: {downloaded_path}")
+ if not quiet:
+ print(f"Using downloaded driver: {downloaded_path}")
if browser == 'chrome':
service = ChromeService(executable_path=downloaded_path)
return webdriver.Chrome(service=service, options=options)
@@ -596,29 +1105,43 @@ def create_driver(
print(f"[FAIL] Direct download failed: {e}")
# Strategy 3: webdriver_manager with explicit path
- print("\nTrying webdriver_manager...")
+ if not quiet:
+ print("\nTrying webdriver_manager...")
try:
if browser == 'chrome':
from webdriver_manager.chrome import ChromeDriverManager
from webdriver_manager.core.os_manager import ChromeType
mgr = ChromeDriverManager()
driver_path_wdm = mgr.install()
- print(f"webdriver_manager installed driver to: {driver_path_wdm}")
- service = ChromeService(executable_path=driver_path_wdm)
- return webdriver.Chrome(service=service, options=options)
+ if not quiet:
+ print(f"webdriver_manager installed driver to: {driver_path_wdm}")
+ # Reject known non-executable artifacts (THIRD_PARTY_NOTICES / LICENSE) returned
+ # by webdriver_manager on some platforms before trying to exec them.
+ if driver_path_wdm and os.path.isfile(driver_path_wdm) \
+ and not driver_path_wdm.endswith("THIRD_PARTY_NOTICES.chromedriver") \
+ and not driver_path_wdm.endswith("LICENSE.chromedriver"):
+ service = ChromeService(executable_path=driver_path_wdm)
+ return webdriver.Chrome(service=service, options=options)
+ print(f"[SKIP] webdriver_manager returned a non-driver file, falling through.")
else:
from webdriver_manager.microsoft import EdgeChromiumDriverManager
mgr = EdgeChromiumDriverManager()
driver_path_wdm = mgr.install()
- print(f"webdriver_manager installed driver to: {driver_path_wdm}")
- service = EdgeService(executable_path=driver_path_wdm)
- return webdriver.Edge(service=service, options=options)
+ if not quiet:
+ print(f"webdriver_manager installed driver to: {driver_path_wdm}")
+ if driver_path_wdm and os.path.isfile(driver_path_wdm) \
+ and not driver_path_wdm.endswith("THIRD_PARTY_NOTICES.msedgedriver") \
+ and not driver_path_wdm.endswith("LICENSE.msedgedriver"):
+ service = EdgeService(executable_path=driver_path_wdm)
+ return webdriver.Edge(service=service, options=options)
+ print(f"[SKIP] webdriver_manager returned a non-driver file, falling through.")
except Exception as e:
errors.append(f"webdriver_manager failed: {e}")
print(f"[FAIL] webdriver_manager failed: {e}")
# Strategy 4: Let Selenium Manager try (last resort)
- print("\nTrying Selenium Manager (last resort)...")
+ if not quiet:
+ print("\nTrying Selenium Manager (last resort)...")
try:
if browser == 'chrome':
return webdriver.Chrome(options=options)
@@ -735,6 +1258,8 @@ def __init__(
html_save_dir: str,
download_images: bool = False,
frontmatter_format: str = "legacy",
+ fetch_comments_flag: bool = False,
+ comments_sort: str = COMMENTS_SORT,
):
if frontmatter_format not in ("legacy", "mdx"):
raise ValueError("frontmatter_format must be 'legacy' or 'mdx'")
@@ -766,6 +1291,13 @@ def __init__(
self.download_images: bool = download_images
self.image_dir = Path(BASE_IMAGE_DIR) / self.writer_name
+ self.fetch_comments: bool = fetch_comments_flag
+ self.comments_sort: str = comments_sort
+ self.comments_save_dir: str = os.path.join(COMMENTS_DATA_DIR, self.writer_name)
+ if self.fetch_comments and not os.path.exists(self.comments_save_dir):
+ os.makedirs(self.comments_save_dir)
+ print(f"Created comments directory {self.comments_save_dir}")
+
if self.is_single_post:
self.post_urls: List[str] = [original_url]
else:
@@ -842,35 +1374,41 @@ def save_to_file(filepath: str, content: str) -> None:
@staticmethod
def md_to_html(md_content: str) -> str:
"""Converts Markdown to HTML."""
- return markdown.markdown(md_content, extensions=['extra'])
+ return md_to_html_static(md_content)
+
+ def save_to_html_file(
+ self,
+ filepath: str,
+ content: str,
+ comments_html: str = "",
+ header_html: str = "",
+ title: Optional[str] = None,
+ ) -> None:
+ """Saves HTML content to a file with a link to the external CSS file.
+
+ Renders the classic Substack article shell: Spectral webfont, the essay
+ stylesheet, and the body inside ````.
- def save_to_html_file(self, filepath: str, content: str) -> None:
- """Saves HTML content to a file with a link to an external CSS file."""
+ - ``header_html`` (optional): a structured post header block (see
+ ``build_post_header``) rendered above the body. When omitted the body is
+ rendered as-is (legacy flat-markdown behaviour).
+ - ``title`` (optional): used for ````/document title.
+ - ``comments_html`` (optional): appended inside ``<main>`` after the body
+ (renders the fetched comment thread on the individual post page).
+ """
if not isinstance(filepath, str):
raise ValueError("filepath must be a string")
if not isinstance(content, str):
raise ValueError("content must be a string")
html_dir = os.path.dirname(filepath)
- css_path = os.path.relpath("./assets/css/essay-styles.css", html_dir)
- css_path = css_path.replace("\\", "/")
-
- html_content = f"""
- <!DOCTYPE html>
- <html lang="en">
- <head>
- <meta charset="UTF-8">
- <meta name="viewport" content="width=device-width, initial-scale=1.0">
- <title>Markdown Content
-
-
-
-
- {content}
-
-
-
{inner}
' + + return f'{header}Comments ({total})
' + f'{items}
' + f'{_html_escape(title)}
') + if subtitle: + parts.append(f'{_html_escape(subtitle)}
') + + byline_bits = [] + if author: + byline_bits.append(_html_escape(author)) + display_date = _format_header_date(date_str) + if display_date: + byline_bits.append(_html_escape(display_date)) + if byline_bits: + parts.append( + f'{" ยท ".join(byline_bits)}
' + ) + + return f'