markdown-to-confluence 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

{markdown_to_confluence-0.3.3.dist-info → markdown_to_confluence-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown-to-confluence
-Version: 0.3.3
+Version: 0.3.4
 Summary: Publish Markdown files to Confluence wiki
 Home-page: https://github.com/hunyadi/md2conf
 Author: Levente Hunyadi
@@ -62,13 +62,13 @@ Whenever possible, the implementation uses [Confluence REST API v2](https://deve
 
 ## Installation
 
-Install the core package from PyPI:
+**Required.** Install the core package from [PyPI](https://pypi.org/project/markdown-to-confluence/):
 
 ```sh
 pip install markdown-to-confluence
 ```
 
-Converting code blocks of Mermaid diagrams into Confluence image attachments requires [mermaid-cli](https://github.com/mermaid-js/mermaid-cli):
+**Optional.** Converting code blocks of Mermaid diagrams into Confluence image attachments requires [mermaid-cli](https://github.com/mermaid-js/mermaid-cli):
 
 ```sh
 npm install -g @mermaid-js/mermaid-cli
@@ -222,6 +222,13 @@ Files that don't have the extension `*.md` are skipped automatically. Hidden dir
 
 If a matching Confluence page already exists for a Markdown file, the page title in Confluence is left unchanged.
 
+### Converting diagrams
+
+You can include [Mermaid diagrams](https://mermaid.js.org/) in your Markdown documents to create visual representations of systems, processes, and relationships. When a Markdown document contains a code block with the language specifier `mermaid`, *md2conf* offers two options to publish the diagram:
+
+1. Pre-render into an image. The code block is interpreted by and converted into a PNG or SVG image with the Mermaid diagram utility [mermaid-cli](https://github.com/mermaid-js/mermaid-cli). The generated image is then uploaded to Confluence as an attachment to the page. This is the approach we use and support.
+2. Render on demand. The code block is transformed into a [diagram macro](https://atlasauthority.atlassian.net/wiki/spaces/MARKDOWNCLOUD/pages/2946826241/Diagram+Macro), which is processed by Confluence. You need a [Confluence plugin](https://marketplace.atlassian.com/apps/1211438/markdown-html-plantuml-latex-diagrams-open-api-mermaid) to turn macro definitions into images when a Confluence page is visited. This is a contributed feature. As authors of *md2conf*, we don't endorse or support any particular Confluence plugin.
+
 ### Running the tool
 
 You execute the command-line tool `md2conf` to synchronize the Markdown file with Confluence:

markdown_to_confluence-0.3.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+markdown_to_confluence-0.3.4.dist-info/licenses/LICENSE,sha256=Pv43so2bPfmKhmsrmXFyAvS7M30-1i1tzjz6-dfhyOo,1077
+md2conf/__init__.py,sha256=9gI6OYCv9-54FzxjNHLOH09H5quUDEMWq9pdbhnwoXM,402
+md2conf/__main__.py,sha256=bFcfmSnTWeuhmDm7bJ3jJabZ2S8W9biuAP6_R-Cc9As,8034
+md2conf/api.py,sha256=ZIYoBXclLbzrrQ_oFRllsTEnQIMbxqd9OD80-AC5qM0,22769
+md2conf/application.py,sha256=eIVeAGUzfdIq1uYLYpTg30UNSq-YcUIY-OgKKK3M4E4,6436
+md2conf/converter.py,sha256=2Sgq1WQd-dCtrdTVrBwhowPC8PmubMNCH1aAcRwntjs,39404
+md2conf/emoji.py,sha256=48QJtOD0F3Be1laYLvAOwe0GxrJS-vcfjtCdiBsNcAc,1960
+md2conf/entities.dtd,sha256=M6NzqL5N7dPs_eUA_6sDsiSLzDaAacrx9LdttiufvYU,30215
+md2conf/local.py,sha256=AOuwyvPOXrRRPGOTDeoVYkMPJ9MI2zqRGAvHuY35wy4,3884
+md2conf/matcher.py,sha256=FgMFPvGiOqGezCs8OyerfsVo-iIHFoI6LRMzdcjM5UY,3693
+md2conf/mermaid.py,sha256=un_KHBDpG5Zad_QD3HN1uBwUxp4I-HVJYhNKbH7KwcA,2312
+md2conf/metadata.py,sha256=9BtNRsICbKzPTs63P70XekNARePdW1DtdKNJqXh2ZFM,1013
+md2conf/processor.py,sha256=Ko_3WqLK6jM-bEN7OD9Vc3g3vhSjRYawz3fG6uoUsXc,6733
+md2conf/properties.py,sha256=TOCXLdTfYkKjRwZaMgvXw0mNCI4opEUwpBXro2Kv2B4,2467
+md2conf/puppeteer-config.json,sha256=-dMTAN_7kNTGbDlfXzApl0KJpAWna9YKZdwMKbpOb60,159
+md2conf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+markdown_to_confluence-0.3.4.dist-info/METADATA,sha256=PUtJXudDooVfwOzVtohxweWHMjgDv5CIrDvyqiJ0tlg,17745
+markdown_to_confluence-0.3.4.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+markdown_to_confluence-0.3.4.dist-info/entry_points.txt,sha256=F1zxa1wtEObtbHS-qp46330WVFLHdMnV2wQ-ZorRmX0,50
+markdown_to_confluence-0.3.4.dist-info/top_level.txt,sha256=_FJfl_kHrHNidyjUOuS01ngu_jDsfc-ZjSocNRJnTzU,8
+markdown_to_confluence-0.3.4.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+markdown_to_confluence-0.3.4.dist-info/RECORD,,

{markdown_to_confluence-0.3.3.dist-info → markdown_to_confluence-0.3.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.3.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

md2conf/__init__.py

@@ -5,7 +5,7 @@ Parses Markdown files, converts Markdown content into the Confluence Storage For
 Confluence API endpoints to upload images and content.
 """
 
-__version__ = "0.3.3"
+__version__ = "0.3.4"
 __author__ = "Levente Hunyadi"
 __copyright__ = "Copyright 2022-2025, Levente Hunyadi"
 __license__ = "MIT"

md2conf/__main__.py

@@ -22,8 +22,9 @@ import requests
 from . import __version__
 from .api import ConfluenceAPI
 from .application import Application
-from .converter import ConfluenceDocumentOptions, ConfluenceSiteMetadata
-from .processor import Processor
+from .converter import ConfluenceDocumentOptions, ConfluencePageID
+from .local import LocalConverter
+from .metadata import ConfluenceSiteMetadata
 from .properties import (
     ArgumentError,
     ConfluenceConnectionProperties,
@@ -199,7 +200,7 @@ def main() -> None:
         heading_anchors=args.heading_anchors,
         ignore_invalid_url=args.ignore_invalid_url,
         generated_by=args.generated_by,
-        root_page_id=args.root_page,
+        root_page_id=ConfluencePageID(args.root_page) if args.root_page else None,
         keep_hierarchy=args.keep_hierarchy,
         render_mermaid=args.render_mermaid,
         diagram_output_format=args.diagram_output_format,
@@ -219,7 +220,7 @@ def main() -> None:
             base_path=site_properties.base_path,
             space_key=site_properties.space_key,
         )
-        Processor(options, site_metadata).process(args.mdpath)
+        LocalConverter(options, site_metadata).process(args.mdpath)
     else:
         try:
             properties = ConfluenceConnectionProperties(
@@ -237,7 +238,7 @@ def main() -> None:
                 Application(
                     api,
                     options,
-                ).synchronize(args.mdpath)
+                ).process(args.mdpath)
         except requests.exceptions.HTTPError as err:
             logging.error(err)
 

md2conf/api.py

@@ -7,6 +7,7 @@ Copyright 2022-2025, Levente Hunyadi
 """
 
 import enum
+import functools
 import io
 import json
 import logging
@@ -21,6 +22,7 @@ from urllib.parse import urlencode, urlparse, urlunparse
 import requests
 
 from .converter import ParseError, sanitize_confluence
+from .metadata import ConfluenceSiteMetadata
 from .properties import (
     ArgumentError,
     ConfluenceConnectionProperties,
@@ -76,7 +78,7 @@ def build_url(base_url: str, query: Optional[dict[str, str]] = None) -> str:
 LOGGER = logging.getLogger(__name__)
 
 
-@dataclass
+@dataclass(frozen=True)
 class ConfluenceAttachment:
     id: str
     media_type: str
@@ -84,14 +86,18 @@ class ConfluenceAttachment:
     comment: str
 
 
-@dataclass
-class ConfluencePage:
+@dataclass(frozen=True)
+class ConfluencePageMetadata:
     id: str
     space_id: str
     parent_id: str
     parent_type: Optional[ConfluencePageParentContentType]
     title: str
     version: int
+
+
+@dataclass(frozen=True)
+class ConfluencePage(ConfluencePageMetadata):
     content: str
 
 
@@ -136,10 +142,12 @@ class ConfluenceAPI:
 
 
 class ConfluenceSession:
+    """
+    Information about an open session to a Confluence server.
+    """
+
     session: requests.Session
-    domain: str
-    base_path: str
-    space_key: Optional[str]
+    site: ConfluenceSiteMetadata
 
     _space_id_to_key: dict[str, str]
     _space_key_to_id: dict[str, str]
@@ -152,9 +160,7 @@ class ConfluenceSession:
         space_key: Optional[str] = None,
     ) -> None:
         self.session = session
-        self.domain = domain
-        self.base_path = base_path
-        self.space_key = space_key
+        self.site = ConfluenceSiteMetadata(domain, base_path, space_key)
 
         self._space_id_to_key = {}
         self._space_key_to_id = {}
@@ -178,7 +184,9 @@ class ConfluenceSession:
         :returns: A full URL.
         """
 
-        base_url = f"https://{self.domain}{self.base_path}{version.value}{path}"
+        base_url = (
+            f"https://{self.site.domain}{self.site.base_path}{version.value}{path}"
+        )
         return build_url(base_url, query)
 
     def _invoke(
@@ -251,6 +259,29 @@ class ConfluenceSession:
 
         return id
 
+    def get_space_id(
+        self, *, space_id: Optional[str] = None, space_key: Optional[str] = None
+    ) -> Optional[str]:
+        """
+        Coalesce a space ID or space key into a space ID, accounting for site default.
+
+        :param space_id: A Confluence space ID.
+        :param space_key: A Confluence space key.
+        """
+
+        if space_id is not None and space_key is not None:
+            raise ConfluenceError("either space ID or space key is required; not both")
+
+        if space_id is not None:
+            return space_id
+
+        space_key = space_key or self.site.space_key
+        if space_key is not None:
+            return self.space_key_to_id(space_key)
+
+        # space ID and key are unset, and no default space is configured
+        return None
+
     def get_attachment_by_name(
         self, page_id: str, filename: str
     ) -> ConfluenceAttachment:
@@ -393,6 +424,7 @@ class ConfluenceSession:
         self,
         title: str,
         *,
+        space_id: Optional[str] = None,
         space_key: Optional[str] = None,
     ) -> str:
         """
@@ -408,9 +440,9 @@ class ConfluenceSession:
         query = {
             "title": title,
         }
-        coalesced_space_key = space_key or self.space_key
-        if coalesced_space_key is not None:
-            query["space-id"] = self.space_key_to_id(coalesced_space_key)
+        space_id = self.get_space_id(space_id=space_id, space_key=space_key)
+        if space_id is not None:
+            query["space-id"] = space_id
 
         payload = self._invoke(ConfluenceVersion.VERSION_2, path, query)
         payload = typing.cast(dict[str, JsonType], payload)
@@ -425,10 +457,10 @@ class ConfluenceSession:
 
     def get_page(self, page_id: str) -> ConfluencePage:
         """
-        Retrieve Confluence wiki page details.
+        Retrieve Confluence wiki page details and content.
 
         :param page_id: The Confluence page ID.
-        :returns: Confluence page info.
+        :returns: Confluence page info and content.
         """
 
         path = f"/pages/{page_id}"
@@ -453,6 +485,33 @@ class ConfluenceSession:
             content=typing.cast(str, storage["value"]),
         )
 
+    @functools.cache
+    def get_page_metadata(self, page_id: str) -> ConfluencePageMetadata:
+        """
+        Retrieve Confluence wiki page details.
+
+        :param page_id: The Confluence page ID.
+        :returns: Confluence page info.
+        """
+
+        path = f"/pages/{page_id}"
+        payload = self._invoke(ConfluenceVersion.VERSION_2, path)
+        data = typing.cast(dict[str, JsonType], payload)
+        version = typing.cast(dict[str, JsonType], data["version"])
+
+        return ConfluencePageMetadata(
+            id=page_id,
+            space_id=typing.cast(str, data["spaceId"]),
+            parent_id=typing.cast(str, data["parentId"]),
+            parent_type=(
+                ConfluencePageParentContentType(typing.cast(str, data["parentType"]))
+                if data["parentType"] is not None
+                else None
+            ),
+            title=typing.cast(str, data["title"]),
+            version=typing.cast(int, version["number"]),
+        )
+
     def get_page_version(self, page_id: str) -> int:
         """
         Retrieve a Confluence wiki page version.
@@ -507,26 +566,21 @@ class ConfluenceSession:
 
     def create_page(
         self,
-        parent_page_id: str,
+        parent_id: str,
         title: str,
         new_content: str,
-        *,
-        space_key: Optional[str] = None,
     ) -> ConfluencePage:
         """
         Create a new page via Confluence API.
         """
 
-        coalesced_space_key = space_key or self.space_key
-        if coalesced_space_key is None:
-            raise ArgumentError("Confluence space key required for creating a new page")
-
+        parent_page = self.get_page_metadata(parent_id)
         path = "/pages/"
         query = {
-            "spaceId": self.space_key_to_id(coalesced_space_key),
+            "spaceId": parent_page.space_id,
             "status": "current",
             "title": title,
-            "parentId": parent_page_id,
+            "parentId": parent_id,
             "body": {"storage": {"value": new_content, "representation": "storage"}},
         }
 
@@ -584,13 +638,24 @@ class ConfluenceSession:
             response.raise_for_status()
 
     def page_exists(
-        self, title: str, *, space_key: Optional[str] = None
+        self,
+        title: str,
+        *,
+        space_id: Optional[str] = None,
+        space_key: Optional[str] = None,
     ) -> Optional[str]:
+        """
+        Check if a Confluence page exists with the given title.
+
+        :param title: Page title. Pages in the same Confluence space must have a unique title.
+        :param space_key: Identifies the Confluence space.
+        """
+
+        space_id = self.get_space_id(space_id=space_id, space_key=space_key)
         path = "/pages"
-        coalesced_space_key = space_key or self.space_key
         query = {"title": title}
-        if coalesced_space_key is not None:
-            query["space-id"] = self.space_key_to_id(coalesced_space_key)
+        if space_id is not None:
+            query["space-id"] = space_id
 
         LOGGER.info("Checking if page exists with title: %s", title)
 
@@ -609,14 +674,20 @@ class ConfluenceSession:
         else:
             return None
 
-    def get_or_create_page(
-        self, title: str, parent_id: str, *, space_key: Optional[str] = None
-    ) -> ConfluencePage:
-        page_id = self.page_exists(title)
+    def get_or_create_page(self, title: str, parent_id: str) -> ConfluencePage:
+        """
+        Find a page with the given title, or create a new page if no such page exists.
+
+        :param title: Page title. Pages in the same Confluence space must have a unique title.
+        :param parent_id: Identifies the parent page for a new child page.
+        """
+
+        parent_page = self.get_page_metadata(parent_id)
+        page_id = self.page_exists(title, space_id=parent_page.space_id)
 
         if page_id is not None:
             LOGGER.debug("Retrieving existing page: %s", page_id)
             return self.get_page(page_id)
         else:
             LOGGER.debug("Creating new page with title: %s", title)
-            return self.create_page(parent_id, title, "", space_key=space_key)
+            return self.create_page(parent_id, title, "")

md2conf/application.py

@@ -8,7 +8,6 @@ Copyright 2022-2025, Levente Hunyadi
 
 import hashlib
 import logging
-import os
 from pathlib import Path
 from typing import Optional
 
@@ -16,167 +15,43 @@ from .api import ConfluencePage, ConfluenceSession
 from .converter import (
     ConfluenceDocument,
     ConfluenceDocumentOptions,
-    ConfluencePageMetadata,
-    ConfluenceQualifiedID,
-    ConfluenceSiteMetadata,
+    ConfluencePageID,
     attachment_name,
     extract_frontmatter_title,
     extract_qualified_id,
-    read_qualified_id,
 )
-from .matcher import Matcher, MatcherOptions
-from .properties import ArgumentError, PageError
+from .metadata import ConfluencePageMetadata
+from .processor import Converter, Processor, ProcessorFactory
+from .properties import PageError
 
 LOGGER = logging.getLogger(__name__)
 
 
-class Application:
-    "The entry point for Markdown to Confluence conversion."
+class SynchronizingProcessor(Processor):
+    """
+    Synchronizes a single Markdown page or a directory of Markdown pages with Confluence.
+    """
 
     api: ConfluenceSession
-    options: ConfluenceDocumentOptions
 
     def __init__(
-        self, api: ConfluenceSession, options: ConfluenceDocumentOptions
-    ) -> None:
-        self.api = api
-        self.options = options
-
-    def synchronize(self, path: Path) -> None:
-        "Synchronizes a single Markdown page or a directory of Markdown pages."
-
-        path = path.resolve(True)
-        if path.is_dir():
-            self.synchronize_directory(path)
-        elif path.is_file():
-            self.synchronize_page(path)
-        else:
-            raise ArgumentError(f"expected: valid file or directory path; got: {path}")
-
-    def synchronize_page(
-        self, page_path: Path, root_dir: Optional[Path] = None
-    ) -> None:
-        "Synchronizes a single Markdown page with Confluence."
-
-        page_path = page_path.resolve(True)
-        if root_dir is None:
-            root_dir = page_path.parent
-        else:
-            root_dir = root_dir.resolve(True)
-
-        self._synchronize_page(page_path, root_dir, {})
-
-    def synchronize_directory(
-        self, local_dir: Path, root_dir: Optional[Path] = None
-    ) -> None:
-        "Synchronizes a directory of Markdown pages with Confluence."
-
-        local_dir = local_dir.resolve(True)
-        if root_dir is None:
-            root_dir = local_dir
-        else:
-            root_dir = root_dir.resolve(True)
-
-        LOGGER.info("Synchronizing directory: %s", local_dir)
-
-        # Step 1: build index of all page metadata
-        page_metadata: dict[Path, ConfluencePageMetadata] = {}
-        root_id = (
-            ConfluenceQualifiedID(self.options.root_page_id, self.api.space_key)
-            if self.options.root_page_id
-            else None
-        )
-        self._index_directory(local_dir, root_dir, root_id, page_metadata)
-        LOGGER.info("Indexed %d page(s)", len(page_metadata))
-
-        # Step 2: convert each page
-        for page_path in page_metadata.keys():
-            self._synchronize_page(page_path, root_dir, page_metadata)
-
-    def _synchronize_page(
-        self,
-        page_path: Path,
-        root_dir: Path,
-        page_metadata: dict[Path, ConfluencePageMetadata],
-    ) -> None:
-        base_path = page_path.parent
-
-        LOGGER.info("Synchronizing page: %s", page_path)
-        site_metadata = ConfluenceSiteMetadata(
-            domain=self.api.domain,
-            base_path=self.api.base_path,
-            space_key=self.api.space_key,
-        )
-
-        document = ConfluenceDocument.create(
-            page_path, self.options, root_dir, site_metadata, page_metadata
-        )
-        self._update_document(document, base_path)
-
-    def _index_directory(
-        self,
-        local_dir: Path,
-        root_dir: Path,
-        root_id: Optional[ConfluenceQualifiedID],
-        page_metadata: dict[Path, ConfluencePageMetadata],
+        self, api: ConfluenceSession, options: ConfluenceDocumentOptions, root_dir: Path
     ) -> None:
-        "Indexes Markdown files in a directory recursively."
-
-        LOGGER.info("Indexing directory: %s", local_dir)
-
-        matcher = Matcher(MatcherOptions(source=".mdignore", extension="md"), local_dir)
-
-        files: list[Path] = []
-        directories: list[Path] = []
-        for entry in os.scandir(local_dir):
-            if matcher.is_excluded(entry.name, entry.is_dir()):
-                continue
-
-            if entry.is_file():
-                files.append(Path(local_dir) / entry.name)
-            elif entry.is_dir():
-                directories.append(Path(local_dir) / entry.name)
-
-        # make page act as parent node in Confluence
-        parent_doc: Optional[Path] = None
-        if (Path(local_dir) / "index.md") in files:
-            parent_doc = Path(local_dir) / "index.md"
-        elif (Path(local_dir) / "README.md") in files:
-            parent_doc = Path(local_dir) / "README.md"
-        elif (Path(local_dir) / f"{local_dir.name}.md") in files:
-            parent_doc = Path(local_dir) / f"{local_dir.name}.md"
-
-        if parent_doc is None and self.options.keep_hierarchy:
-            parent_doc = Path(local_dir) / "index.md"
-
-            # create a blank page in Confluence for the directory entry
-            with open(parent_doc, "w"):
-                pass
-
-        if parent_doc is not None:
-            files.remove(parent_doc)
-
-            metadata = self._get_or_create_page(parent_doc, root_dir, root_id)
-            LOGGER.debug("Indexed parent %s with metadata: %s", parent_doc, metadata)
-            page_metadata[parent_doc] = metadata
-
-            parent_id = read_qualified_id(parent_doc) or root_id
-        else:
-            parent_id = root_id
+        """
+        Initializes a new processor instance.
 
-        for doc in files:
-            metadata = self._get_or_create_page(doc, root_dir, parent_id)
-            LOGGER.debug("Indexed %s with metadata: %s", doc, metadata)
-            page_metadata[doc] = metadata
+        :param api: Holds information about an open session to a Confluence server.
+        :param options: Options that control the generated page content.
+        :param root_dir: File system directory that acts as topmost root node.
+        """
 
-        for directory in directories:
-            self._index_directory(directory, root_dir, parent_id, page_metadata)
+        super().__init__(options, api.site, root_dir)
+        self.api = api
 
     def _get_or_create_page(
         self,
         absolute_path: Path,
-        root_dir: Path,
-        parent_id: Optional[ConfluenceQualifiedID],
+        parent_id: Optional[ConfluencePageID],
         *,
         title: Optional[str] = None,
     ) -> ConfluencePageMetadata:
@@ -186,13 +61,13 @@ class Application:
 
         # parse file
         with open(absolute_path, "r", encoding="utf-8") as f:
-            document = f.read()
+            text = f.read()
 
-        qualified_id, document = extract_qualified_id(document)
+        qualified_id, text = extract_qualified_id(text)
 
-        if qualified_id is not None:
-            confluence_page = self.api.get_page(qualified_id.page_id)
-        else:
+        overwrite = False
+        if qualified_id is None:
+            # create new Confluence page
             if parent_id is None:
                 raise PageError(
                     f"expected: parent page ID for Markdown file with no linked Confluence page: {absolute_path}"
@@ -200,29 +75,32 @@ class Application:
 
             # assign title from front-matter if present
             if title is None:
-                title, _ = extract_frontmatter_title(document)
+                title, _ = extract_frontmatter_title(text)
 
             # use file name (without extension) and path hash if no title is supplied
             if title is None:
-                relative_path = absolute_path.relative_to(root_dir)
+                overwrite = True
+                relative_path = absolute_path.relative_to(self.root_dir)
                 hash = hashlib.md5(relative_path.as_posix().encode("utf-8"))
                 digest = "".join(f"{c:x}" for c in hash.digest())
                 title = f"{absolute_path.stem} [{digest}]"
 
-            confluence_page = self._create_page(
-                absolute_path, document, title, parent_id
-            )
+            confluence_page = self._create_page(absolute_path, text, title, parent_id)
+        else:
+            # look up existing Confluence page
+            confluence_page = self.api.get_page(qualified_id.page_id)
 
         space_key = (
             self.api.space_id_to_key(confluence_page.space_id)
             if confluence_page.space_id
-            else self.api.space_key
+            else self.site.space_key
         )
 
         return ConfluencePageMetadata(
             page_id=confluence_page.id,
             space_key=space_key,
-            title=confluence_page.title or "",
+            title=confluence_page.title,
+            overwrite=overwrite,
         )
 
     def _create_page(
@@ -230,13 +108,13 @@ class Application:
         absolute_path: Path,
         document: str,
         title: str,
-        parent_id: ConfluenceQualifiedID,
+        parent_id: ConfluencePageID,
     ) -> ConfluencePage:
-        "Creates a new Confluence page when Markdown file doesn't have an embedded page ID yet."
+        """
+        Creates a new Confluence page when Markdown file doesn't have an embedded page ID yet.
+        """
 
-        confluence_page = self.api.get_or_create_page(
-            title, parent_id.page_id, space_key=parent_id.space_key
-        )
+        confluence_page = self.api.get_or_create_page(title, parent_id.page_id)
         self._update_markdown(
             absolute_path,
             document,
@@ -245,9 +123,14 @@ class Application:
         )
         return confluence_page
 
-    def _update_document(self, document: ConfluenceDocument, base_path: Path) -> None:
-        "Saves a new version of a Confluence document."
+    def _save_document(self, document: ConfluenceDocument, path: Path) -> None:
+        """
+        Saves a new version of a Confluence document.
+
+        Invokes Confluence REST API to persist the new version.
+        """
 
+        base_path = path.parent
         for image in document.images:
             self.api.upload_attachment(
                 document.id.page_id,
@@ -263,8 +146,12 @@ class Application:
             )
 
         content = document.xhtml()
+
+        # leave title as it is for existing pages, update title for pages with randomly assigned title
+        title = document.title if self.page_metadata[path].overwrite else None
+
         LOGGER.debug("Generated Confluence Storage Format document:\n%s", content)
-        self.api.update_page(document.id.page_id, content, title=document.title)
+        self.api.update_page(document.id.page_id, content, title=title)
 
     def _update_markdown(
         self,
@@ -273,7 +160,9 @@ class Application:
         page_id: str,
         space_key: Optional[str],
     ) -> None:
-        "Writes the Confluence page ID and space key at the beginning of the Markdown file."
+        """
+        Writes the Confluence page ID and space key at the beginning of the Markdown file.
+        """
 
         content: list[str] = []
 
@@ -293,3 +182,27 @@ class Application:
 
         with open(path, "w", encoding="utf-8") as file:
             file.write("\n".join(content))
+
+
+class SynchronizingProcessorFactory(ProcessorFactory):
+    api: ConfluenceSession
+
+    def __init__(
+        self, api: ConfluenceSession, options: ConfluenceDocumentOptions
+    ) -> None:
+        super().__init__(options, api.site)
+        self.api = api
+
+    def create(self, root_dir: Path) -> Processor:
+        return SynchronizingProcessor(self.api, self.options, root_dir)
+
+
+class Application(Converter):
+    """
+    The entry point for Markdown to Confluence conversion.
+    """
+
+    def __init__(
+        self, api: ConfluenceSession, options: ConfluenceDocumentOptions
+    ) -> None:
+        super().__init__(SynchronizingProcessorFactory(api, options))

md2conf/converter.py

@@ -26,6 +26,7 @@ import yaml
 from lxml.builder import ElementMaker
 
 from .mermaid import render_diagram
+from .metadata import ConfluencePageMetadata, ConfluenceSiteMetadata
 from .properties import PageError
 
 namespaces = {
@@ -142,8 +143,8 @@ def _elements_from_strings(dtd_path: Path, items: list[str]) -> ET._Element:
 
     try:
         return ET.fromstringlist(data, parser=parser)
-    except ET.XMLSyntaxError as e:
-        raise ParseError(e)
+    except ET.XMLSyntaxError as ex:
+        raise ParseError() from ex
 
 
 def elements_from_strings(items: list[str]) -> ET._Element:
@@ -240,20 +241,6 @@ _languages = [
 ]
 
 
-@dataclass
-class ConfluenceSiteMetadata:
-    domain: str
-    base_path: str
-    space_key: Optional[str]
-
-
-@dataclass
-class ConfluencePageMetadata:
-    page_id: str
-    space_key: Optional[str]
-    title: str
-
-
 class NodeVisitor:
     def visit(self, node: ET._Element) -> None:
         "Recursively visits all descendants of this node."
@@ -974,6 +961,14 @@ def extract_value(pattern: str, text: str) -> tuple[Optional[str], str]:
     return value, text
 
 
+@dataclass
+class ConfluencePageID:
+    page_id: str
+
+    def __init__(self, page_id: str):
+        self.page_id = page_id
+
+
 @dataclass
 class ConfluenceQualifiedID:
     page_id: str
@@ -1048,13 +1043,17 @@ class ConfluenceDocumentOptions:
     ignore_invalid_url: bool = False
     heading_anchors: bool = False
     generated_by: Optional[str] = "This page has been generated with a tool."
-    root_page_id: Optional[str] = None
+    root_page_id: Optional[ConfluencePageID] = None
     keep_hierarchy: bool = False
     render_mermaid: bool = False
     diagram_output_format: Literal["png", "svg"] = "png"
     webui_links: bool = False
 
 
+class ConversionError(RuntimeError):
+    "Raised when a Markdown document cannot be converted to Confluence Storage Format."
+
+
 class ConfluenceDocument:
     id: ConfluenceQualifiedID
     title: Optional[str]
@@ -1107,32 +1106,42 @@ class ConfluenceDocument:
         self.options = options
         self.id = qualified_id
 
+        # extract frontmatter
+        self.title, text = extract_frontmatter_title(text)
+
         # extract 'generated-by' tag text
         generated_by_tag, text = extract_value(
             r"<!--\s+generated-by:\s*(.*)\s+-->", text
         )
 
-        # extract frontmatter
-        self.title, text = extract_frontmatter_title(text)
-
         # convert to HTML
         html = markdown_to_html(text)
 
         # parse Markdown document
         if self.options.generated_by is not None:
-            generated_by = self.options.generated_by
             if generated_by_tag is not None:
-                generated_by = generated_by_tag
+                generated_by_text = generated_by_tag
+            else:
+                generated_by_text = self.options.generated_by
+        else:
+            generated_by_text = None
+
+        if generated_by_text is not None:
+            generated_by_html = markdown_to_html(generated_by_text)
 
             content = [
                 '<ac:structured-macro ac:name="info" ac:schema-version="1">',
-                f"<ac:rich-text-body><p>{generated_by}</p></ac:rich-text-body>",
+                f"<ac:rich-text-body>{generated_by_html}</ac:rich-text-body>",
                 "</ac:structured-macro>",
                 html,
             ]
         else:
             content = [html]
-        self.root = elements_from_strings(content)
+
+        try:
+            self.root = elements_from_strings(content)
+        except ParseError as ex:
+            raise ConversionError(path) from ex
 
         converter = ConfluenceStorageFormatConverter(
             ConfluenceConverterOptions(

md2conf/local.py

@@ -0,0 +1,132 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+import hashlib
+import logging
+import os
+from pathlib import Path
+from typing import Optional
+
+from .converter import (
+    ConfluenceDocument,
+    ConfluenceDocumentOptions,
+    ConfluencePageID,
+    ConfluenceQualifiedID,
+    extract_qualified_id,
+)
+from .metadata import ConfluencePageMetadata, ConfluenceSiteMetadata
+from .processor import Converter, Processor, ProcessorFactory
+from .properties import PageError
+
+LOGGER = logging.getLogger(__name__)
+
+
+class LocalProcessor(Processor):
+    """
+    Transforms a single Markdown page or a directory of Markdown pages into Confluence Storage Format (CSF) documents.
+    """
+
+    def __init__(
+        self,
+        options: ConfluenceDocumentOptions,
+        site: ConfluenceSiteMetadata,
+        *,
+        out_dir: Optional[Path],
+        root_dir: Path,
+    ) -> None:
+        """
+        Initializes a new processor instance.
+
+        :param options: Options that control the generated page content.
+        :param site: Data associated with a Confluence wiki site.
+        :param out_dir: File system directory to write generated CSF documents to.
+        :param root_dir: File system directory that acts as topmost root node.
+        """
+
+        super().__init__(options, site, root_dir)
+        self.out_dir = out_dir or root_dir
+
+    def _get_or_create_page(
+        self,
+        absolute_path: Path,
+        parent_id: Optional[ConfluencePageID],
+        *,
+        title: Optional[str] = None,
+    ) -> ConfluencePageMetadata:
+        """
+        Extracts metadata from a Markdown file.
+        """
+
+        # parse file
+        with open(absolute_path, "r", encoding="utf-8") as f:
+            text = f.read()
+
+        qualified_id, text = extract_qualified_id(text)
+
+        if qualified_id is None:
+            if parent_id is None:
+                raise PageError(
+                    f"expected: parent page ID for Markdown file with no linked Confluence page: {absolute_path}"
+                )
+
+            hash = hashlib.md5(text.encode("utf-8"))
+            digest = "".join(f"{c:x}" for c in hash.digest())
+            LOGGER.info("Identifier %s assigned to page: %s", digest, absolute_path)
+            qualified_id = ConfluenceQualifiedID(digest)
+
+        return ConfluencePageMetadata(
+            page_id=qualified_id.page_id,
+            space_key=qualified_id.space_key,
+            title="",
+            overwrite=True,
+        )
+
+    def _save_document(self, document: ConfluenceDocument, path: Path) -> None:
+        """
+        Saves a new version of a Confluence document.
+
+        A derived class may invoke Confluence REST API to persist the new version.
+        """
+
+        content = document.xhtml()
+        out_path = self.out_dir / path.relative_to(self.root_dir).with_suffix(".csf")
+        os.makedirs(out_path.parent, exist_ok=True)
+        with open(out_path, "w", encoding="utf-8") as f:
+            f.write(content)
+
+
+class LocalProcessorFactory(ProcessorFactory):
+    out_dir: Optional[Path]
+
+    def __init__(
+        self,
+        options: ConfluenceDocumentOptions,
+        site: ConfluenceSiteMetadata,
+        out_dir: Optional[Path] = None,
+    ) -> None:
+        super().__init__(options, site)
+        self.out_dir = out_dir
+
+    def create(self, root_dir: Path) -> Processor:
+        return LocalProcessor(
+            self.options, self.site, out_dir=self.out_dir, root_dir=root_dir
+        )
+
+
+class LocalConverter(Converter):
+    """
+    The entry point for Markdown to Confluence conversion.
+    """
+
+    def __init__(
+        self,
+        options: ConfluenceDocumentOptions,
+        site: ConfluenceSiteMetadata,
+        out_dir: Optional[Path] = None,
+    ) -> None:
+        super().__init__(LocalProcessorFactory(options, site, out_dir))

md2conf/metadata.py

@@ -0,0 +1,42 @@
+"""
+Publish Markdown files to Confluence wiki.
+
+Copyright 2022-2025, Levente Hunyadi
+
+:see: https://github.com/hunyadi/md2conf
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ConfluenceSiteMetadata:
+    """
+    Data associated with a Confluence wiki site.
+
+    :param domain: Confluence organization domain (e.g. `levente-hunyadi.atlassian.net`).
+    :param base_path: Base path for Confluence (default: `/wiki/`).
+    :param space_key: Confluence space key for new pages (e.g. `~hunyadi` or `INST`).
+    """
+
+    domain: str
+    base_path: str
+    space_key: Optional[str]
+
+
+@dataclass
+class ConfluencePageMetadata:
+    """
+    Data associated with a Confluence page.
+
+    :param page_id: Confluence page ID.
+    :param space_key: Confluence space key.
+    :param title: Document title.
+    :param overwrite: True if operations are allowed to update document properties (e.g. title).
+    """
+
+    page_id: str
+    space_key: Optional[str]
+    title: str
+    overwrite: bool

md2conf/processor.py

@@ -6,101 +6,96 @@ Copyright 2022-2025, Levente Hunyadi
 :see: https://github.com/hunyadi/md2conf
 """
 
-import hashlib
 import logging
 import os
+from abc import abstractmethod
 from pathlib import Path
 from typing import Optional
 
-from .converter import (
-    ConfluenceDocument,
-    ConfluenceDocumentOptions,
-    ConfluencePageMetadata,
-    ConfluenceQualifiedID,
-    ConfluenceSiteMetadata,
-    extract_qualified_id,
-)
+from .converter import ConfluenceDocument, ConfluenceDocumentOptions, ConfluencePageID
 from .matcher import Matcher, MatcherOptions
+from .metadata import ConfluencePageMetadata, ConfluenceSiteMetadata
 from .properties import ArgumentError
 
 LOGGER = logging.getLogger(__name__)
 
 
 class Processor:
+    """
+    Processes a single Markdown page or a directory of Markdown pages.
+    """
+
     options: ConfluenceDocumentOptions
-    site_metadata: ConfluenceSiteMetadata
+    site: ConfluenceSiteMetadata
+    root_dir: Path
+
+    page_metadata: dict[Path, ConfluencePageMetadata]
 
     def __init__(
-        self, options: ConfluenceDocumentOptions, site_metadata: ConfluenceSiteMetadata
+        self,
+        options: ConfluenceDocumentOptions,
+        site: ConfluenceSiteMetadata,
+        root_dir: Path,
     ) -> None:
         self.options = options
-        self.site_metadata = site_metadata
-
-    def process(self, path: Path) -> None:
-        "Processes a single Markdown file or a directory of Markdown files."
+        self.site = site
+        self.root_dir = root_dir
 
-        path = path.resolve(True)
-        if path.is_dir():
-            self.process_directory(path)
-        elif path.is_file():
-            self.process_page(path)
-        else:
-            raise ArgumentError(f"expected: valid file or directory path; got: {path}")
+        self.page_metadata = {}
 
-    def process_directory(
-        self, local_dir: Path, root_dir: Optional[Path] = None
-    ) -> None:
-        "Recursively scans a directory hierarchy for Markdown files."
+    def process_directory(self, local_dir: Path) -> None:
+        """
+        Recursively scans a directory hierarchy for Markdown files, and processes each, resolving cross-references.
+        """
 
         local_dir = local_dir.resolve(True)
-        if root_dir is None:
-            root_dir = local_dir
-        else:
-            root_dir = root_dir.resolve(True)
-
-        LOGGER.info("Synchronizing directory: %s", local_dir)
+        LOGGER.info("Processing directory: %s", local_dir)
 
         # Step 1: build index of all page metadata
-        page_metadata: dict[Path, ConfluencePageMetadata] = {}
-        self._index_directory(local_dir, page_metadata)
-        LOGGER.info("Indexed %d page(s)", len(page_metadata))
+        self._index_directory(local_dir, self.options.root_page_id)
+        LOGGER.info("Indexed %d page(s)", len(self.page_metadata))
 
         # Step 2: convert each page
-        for page_path in page_metadata.keys():
-            self._process_page(page_path, root_dir, page_metadata)
+        for page_path in self.page_metadata.keys():
+            self._process_page(page_path)
 
-    def process_page(self, path: Path, root_dir: Optional[Path] = None) -> None:
-        "Processes a single Markdown file."
+    def process_page(self, path: Path) -> None:
+        """
+        Processes a single Markdown file.
+        """
 
-        path = path.resolve(True)
-        if root_dir is None:
-            root_dir = path.parent
-        else:
-            root_dir = root_dir.resolve(True)
-
-        self._process_page(path, root_dir, {})
-
-    def _process_page(
-        self,
-        path: Path,
-        root_dir: Path,
-        page_metadata: dict[Path, ConfluencePageMetadata],
-    ) -> None:
-        "Processes a single Markdown file."
+        LOGGER.info("Processing page: %s", path)
+        self._index_page(path, self.options.root_page_id)
+        self._process_page(path)
 
+    def _process_page(self, path: Path) -> None:
         document = ConfluenceDocument.create(
-            path, self.options, root_dir, self.site_metadata, page_metadata
+            path, self.options, self.root_dir, self.site, self.page_metadata
         )
-        content = document.xhtml()
-        with open(path.with_suffix(".csf"), "w", encoding="utf-8") as f:
-            f.write(content)
+        self._save_document(document, path)
 
-    def _index_directory(
+    @abstractmethod
+    def _get_or_create_page(
         self,
-        local_dir: Path,
-        page_metadata: dict[Path, ConfluencePageMetadata],
+        absolute_path: Path,
+        parent_id: Optional[ConfluencePageID],
+        *,
+        title: Optional[str] = None,
+    ) -> ConfluencePageMetadata:
+        """
+        Creates a new Confluence page if no page is linked in the Markdown document.
+        """
+        ...
+
+    @abstractmethod
+    def _save_document(self, document: ConfluenceDocument, path: Path) -> None: ...
+
+    def _index_directory(
+        self, local_dir: Path, parent_id: Optional[ConfluencePageID]
     ) -> None:
-        "Indexes Markdown files in a directory recursively."
+        """
+        Indexes Markdown files in a directory hierarchy recursively.
+        """
 
         LOGGER.info("Indexing directory: %s", local_dir)
 
@@ -117,32 +112,107 @@ class Processor:
             elif entry.is_dir():
                 directories.append(Path(local_dir) / entry.name)
 
+        # make page act as parent node
+        parent_doc: Optional[Path] = None
+        if (Path(local_dir) / "index.md") in files:
+            parent_doc = Path(local_dir) / "index.md"
+        elif (Path(local_dir) / "README.md") in files:
+            parent_doc = Path(local_dir) / "README.md"
+        elif (Path(local_dir) / f"{local_dir.name}.md") in files:
+            parent_doc = Path(local_dir) / f"{local_dir.name}.md"
+
+        if parent_doc is None and self.options.keep_hierarchy:
+            parent_doc = Path(local_dir) / "index.md"
+
+            # create a blank page for directory entry
+            with open(parent_doc, "w"):
+                pass
+
+        if parent_doc is not None:
+            if parent_doc in files:
+                files.remove(parent_doc)
+
+            # use latest parent as parent for index page
+            metadata = self._get_or_create_page(parent_doc, parent_id)
+            LOGGER.debug("Indexed parent %s with metadata: %s", parent_doc, metadata)
+            self.page_metadata[parent_doc] = metadata
+
+            # assign new index page as new parent
+            parent_id = ConfluencePageID(metadata.page_id)
+
         for doc in files:
-            metadata = self._get_page(doc)
-            LOGGER.debug("Indexed %s with metadata: %s", doc, metadata)
-            page_metadata[doc] = metadata
+            self._index_page(doc, parent_id)
 
         for directory in directories:
-            self._index_directory(directory, page_metadata)
-
-    def _get_page(self, absolute_path: Path) -> ConfluencePageMetadata:
-        "Extracts metadata from a Markdown file."
-
-        with open(absolute_path, "r", encoding="utf-8") as f:
-            document = f.read()
-
-        qualified_id, document = extract_qualified_id(document)
-        if qualified_id is None:
-            if self.options.root_page_id is not None:
-                hash = hashlib.md5(document.encode("utf-8"))
-                digest = "".join(f"{c:x}" for c in hash.digest())
-                LOGGER.info("Identifier %s assigned to page: %s", digest, absolute_path)
-                qualified_id = ConfluenceQualifiedID(digest)
-            else:
-                raise ArgumentError("required: page ID for local output")
-
-        return ConfluencePageMetadata(
-            page_id=qualified_id.page_id,
-            space_key=qualified_id.space_key,
-            title="",
-        )
+            self._index_directory(directory, parent_id)
+
+    def _index_page(self, path: Path, parent_id: Optional[ConfluencePageID]) -> None:
+        """
+        Indexes a single Markdown file.
+        """
+
+        metadata = self._get_or_create_page(path, parent_id)
+        LOGGER.debug("Indexed %s with metadata: %s", path, metadata)
+        self.page_metadata[path] = metadata
+
+
+class ProcessorFactory:
+    options: ConfluenceDocumentOptions
+    site: ConfluenceSiteMetadata
+
+    def __init__(
+        self, options: ConfluenceDocumentOptions, site: ConfluenceSiteMetadata
+    ) -> None:
+        self.options = options
+        self.site = site
+
+    @abstractmethod
+    def create(self, root_dir: Path) -> Processor: ...
+
+
+class Converter:
+    factory: ProcessorFactory
+
+    def __init__(self, factory: ProcessorFactory) -> None:
+        self.factory = factory
+
+    def process(self, path: Path) -> None:
+        """
+        Processes a single Markdown file or a directory of Markdown files.
+        """
+
+        path = path.resolve(True)
+        if path.is_dir():
+            self.process_directory(path)
+        elif path.is_file():
+            self.process_page(path)
+        else:
+            raise ArgumentError(f"expected: valid file or directory path; got: {path}")
+
+    def process_directory(
+        self, local_dir: Path, root_dir: Optional[Path] = None
+    ) -> None:
+        """
+        Recursively scans a directory hierarchy for Markdown files, and processes each, resolving cross-references.
+        """
+
+        local_dir = local_dir.resolve(True)
+        if root_dir is None:
+            root_dir = local_dir
+        else:
+            root_dir = root_dir.resolve(True)
+
+        self.factory.create(root_dir).process_directory(local_dir)
+
+    def process_page(self, path: Path, root_dir: Optional[Path] = None) -> None:
+        """
+        Processes a single Markdown file.
+        """
+
+        path = path.resolve(True)
+        if root_dir is None:
+            root_dir = path.parent
+        else:
+            root_dir = root_dir.resolve(True)
+
+        self.factory.create(root_dir).process_page(path)

markdown_to_confluence-0.3.3.dist-info/RECORD

@@ -1,20 +0,0 @@
-markdown_to_confluence-0.3.3.dist-info/licenses/LICENSE,sha256=Pv43so2bPfmKhmsrmXFyAvS7M30-1i1tzjz6-dfhyOo,1077
-md2conf/__init__.py,sha256=NHoSu8tHMVLytWmla4BA_Uzkl-04rV_O8YkkFxUkT_E,402
-md2conf/__main__.py,sha256=aTRiXcvoIYMkwCGejL6MUriHXBo3qVP2Acr2I-XzMyg,7947
-md2conf/api.py,sha256=S5IB7j48wE9MHSj1jodHYmTE6scSXb80faULW6-5RjU,20376
-md2conf/application.py,sha256=FkJ9zYBLwYcCRkd_WiX6JI6nlw4QMETmrOXHeSzCwCE,9735
-md2conf/converter.py,sha256=B4Z8afTmhea6nSXhzDVxN55GfMvlY34tGqCLspQ_p5g,38983
-md2conf/emoji.py,sha256=48QJtOD0F3Be1laYLvAOwe0GxrJS-vcfjtCdiBsNcAc,1960
-md2conf/entities.dtd,sha256=M6NzqL5N7dPs_eUA_6sDsiSLzDaAacrx9LdttiufvYU,30215
-md2conf/matcher.py,sha256=FgMFPvGiOqGezCs8OyerfsVo-iIHFoI6LRMzdcjM5UY,3693
-md2conf/mermaid.py,sha256=un_KHBDpG5Zad_QD3HN1uBwUxp4I-HVJYhNKbH7KwcA,2312
-md2conf/processor.py,sha256=9jPswgPewh2glLSHdgxyXesGxkcxPVa_h7oUhM9EsA4,4740
-md2conf/properties.py,sha256=TOCXLdTfYkKjRwZaMgvXw0mNCI4opEUwpBXro2Kv2B4,2467
-md2conf/puppeteer-config.json,sha256=-dMTAN_7kNTGbDlfXzApl0KJpAWna9YKZdwMKbpOb60,159
-md2conf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-markdown_to_confluence-0.3.3.dist-info/METADATA,sha256=SiOfBvA3jMCn3Hjd_Let9R-DqcMuPG48xP-1x2pg_JI,16495
-markdown_to_confluence-0.3.3.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-markdown_to_confluence-0.3.3.dist-info/entry_points.txt,sha256=F1zxa1wtEObtbHS-qp46330WVFLHdMnV2wQ-ZorRmX0,50
-markdown_to_confluence-0.3.3.dist-info/top_level.txt,sha256=_FJfl_kHrHNidyjUOuS01ngu_jDsfc-ZjSocNRJnTzU,8
-markdown_to_confluence-0.3.3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-markdown_to_confluence-0.3.3.dist-info/RECORD,,