markdown-to-confluence 0.1.13__py3-none-any.whl → 0.2.1__py3-none-any.whl

md2conf/mermaid.py

@@ -0,0 +1,54 @@
+import os
+import os.path
+import shutil
+import subprocess
+from typing import Literal
+
+
+def has_mmdc() -> bool:
+    "True if Mermaid diagram converter is available on the OS."
+
+    if os.name == "nt":
+        executable = "mmdc.cmd"
+    else:
+        executable = "mmdc"
+    return shutil.which(executable) is not None
+
+
+def render(source: str, output_format: Literal["png", "svg"] = "png") -> bytes:
+    "Generates a PNG or SVG image from a Mermaid diagram source."
+
+    filename = f"tmp_mermaid.{output_format}"
+
+    if os.name == "nt":
+        executable = "mmdc.cmd"
+    else:
+        executable = "mmdc"
+    try:
+        cmd = [
+            executable,
+            "--input",
+            "-",
+            "--output",
+            filename,
+            "--outputFormat",
+            output_format,
+        ]
+        proc = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stdin=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=False,
+        )
+        proc.communicate(input=source.encode("utf-8"))
+        if proc.returncode:
+            raise RuntimeError(
+                f"failed to convert Mermaid diagram; exit code: {proc.returncode}"
+            )
+        with open(filename, "rb") as image:
+            return image.read()
+
+    finally:
+        if os.path.exists(filename):
+            os.remove(filename)

md2conf/processor.py

@@ -1,91 +1,113 @@
-import logging
-import os
-from pathlib import Path
-from typing import Dict
-
-from .converter import (
-    ConfluenceDocument,
-    ConfluenceDocumentOptions,
-    ConfluencePageMetadata,
-    extract_qualified_id,
-)
-from .properties import ConfluenceProperties
-
-LOGGER = logging.getLogger(__name__)
-
-
-class Processor:
-    options: ConfluenceDocumentOptions
-    properties: ConfluenceProperties
-
-    def __init__(
-        self, options: ConfluenceDocumentOptions, properties: ConfluenceProperties
-    ) -> None:
-        self.options = options
-        self.properties = properties
-
-    def process(self, path: Path) -> None:
-        "Processes a single Markdown file or a directory of Markdown files."
-
-        if path.is_dir():
-            self.process_directory(path)
-        elif path.is_file():
-            self.process_page(path, {})
-        else:
-            raise ValueError(f"expected: valid file or directory path; got: {path}")
-
-    def process_directory(self, local_dir: Path) -> None:
-        "Recursively scans a directory hierarchy for Markdown files."
-
-        page_metadata: Dict[Path, ConfluencePageMetadata] = {}
-        LOGGER.info(f"Synchronizing directory: {local_dir}")
-
-        # Step 1: build index of all page metadata
-        # NOTE: Pathlib.walk() is implemented only in Python 3.12+
-        # so sticking for old os.walk
-        for root, directories, files in os.walk(local_dir):
-            for file_name in files:
-                # Reconstitute Path object back
-                docfile = (Path(root) / file_name).absolute()
-
-                # Skip non-markdown files
-                if docfile.suffix.lower() != ".md":
-                    continue
-
-                metadata = self._get_page(docfile)
-                LOGGER.debug(f"indexed {docfile} with metadata: {metadata}")
-                page_metadata[docfile] = metadata
-
-        LOGGER.info(f"indexed {len(page_metadata)} pages")
-
-        # Step 2: Convert each page
-        for page_path in page_metadata.keys():
-            self.process_page(page_path, page_metadata)
-
-    def process_page(
-        self, path: Path, page_metadata: Dict[Path, ConfluencePageMetadata]
-    ) -> None:
-        "Processes a single Markdown file."
-
-        document = ConfluenceDocument(path, self.options, page_metadata)
-        content = document.xhtml()
-        with open(path.with_suffix(".csf"), "w", encoding="utf-8") as f:
-            f.write(content)
-
-    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:
-            raise ValueError("required: page ID for local output")
-
-        return ConfluencePageMetadata(
-            domain=self.properties.domain,
-            base_path=self.properties.base_path,
-            page_id=qualified_id.page_id,
-            space_key=qualified_id.space_key or self.properties.space_key,
-            title="",
-        )
+import hashlib
+import logging
+import os
+from pathlib import Path
+from typing import Dict, List
+
+from .converter import (
+    ConfluenceDocument,
+    ConfluenceDocumentOptions,
+    ConfluencePageMetadata,
+    ConfluenceQualifiedID,
+    extract_qualified_id,
+)
+from .properties import ConfluenceProperties
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Processor:
+    options: ConfluenceDocumentOptions
+    properties: ConfluenceProperties
+
+    def __init__(
+        self, options: ConfluenceDocumentOptions, properties: ConfluenceProperties
+    ) -> None:
+        self.options = options
+        self.properties = properties
+
+    def process(self, path: Path) -> None:
+        "Processes a single Markdown file or a directory of Markdown files."
+
+        if path.is_dir():
+            self.process_directory(path)
+        elif path.is_file():
+            self.process_page(path, {})
+        else:
+            raise ValueError(f"expected: valid file or directory path; got: {path}")
+
+    def process_directory(self, local_dir: Path) -> None:
+        "Recursively scans a directory hierarchy for Markdown files."
+
+        LOGGER.info(f"Synchronizing directory: {local_dir}")
+
+        # Step 1: build index of all page metadata
+        page_metadata: Dict[Path, ConfluencePageMetadata] = {}
+        self._index_directory(local_dir, page_metadata)
+        LOGGER.info(f"indexed {len(page_metadata)} page(s)")
+
+        # Step 2: convert each page
+        for page_path in page_metadata.keys():
+            self.process_page(page_path, page_metadata)
+
+    def process_page(
+        self, path: Path, page_metadata: Dict[Path, ConfluencePageMetadata]
+    ) -> None:
+        "Processes a single Markdown file."
+
+        document = ConfluenceDocument(path, self.options, page_metadata)
+        content = document.xhtml()
+        with open(path.with_suffix(".csf"), "w", encoding="utf-8") as f:
+            f.write(content)
+
+    def _index_directory(
+        self,
+        local_dir: Path,
+        page_metadata: Dict[Path, ConfluencePageMetadata],
+    ) -> None:
+        "Indexes Markdown files in a directory recursively."
+
+        LOGGER.info(f"Indexing directory: {local_dir}")
+
+        files: List[Path] = []
+        directories: List[Path] = []
+        for entry in os.scandir(local_dir):
+            if entry.is_file():
+                if entry.name.endswith(".md"):
+                    # skip non-markdown files
+                    files.append((Path(local_dir) / entry.name).absolute())
+            elif entry.is_dir():
+                if not entry.name.startswith("."):
+                    directories.append((Path(local_dir) / entry.name).absolute())
+
+        for doc in files:
+            metadata = self._get_page(doc)
+            LOGGER.debug(f"indexed {doc} with metadata: {metadata}")
+            page_metadata[doc] = metadata
+
+        for directory in directories:
+            self._index_directory(Path(local_dir) / 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(f"Identifier '{digest}' assigned to page: {absolute_path}")
+                qualified_id = ConfluenceQualifiedID(digest)
+            else:
+                raise ValueError("required: page ID for local output")
+
+        return ConfluencePageMetadata(
+            domain=self.properties.domain,
+            base_path=self.properties.base_path,
+            page_id=qualified_id.page_id,
+            space_key=qualified_id.space_key or self.properties.space_key,
+            title="",
+        )

md2conf/properties.py

@@ -1,52 +1,53 @@
-import os
-from typing import Optional
-
-
-class ConfluenceError(RuntimeError):
-    pass
-
-
-class ConfluenceProperties:
-    domain: str
-    base_path: str
-    space_key: str
-    user_name: Optional[str]
-    api_key: str
-
-    def __init__(
-        self,
-        domain: Optional[str] = None,
-        base_path: Optional[str] = None,
-        user_name: Optional[str] = None,
-        api_key: Optional[str] = None,
-        space_key: Optional[str] = None,
-    ) -> None:
-        opt_domain = domain or os.getenv("CONFLUENCE_DOMAIN")
-        opt_base_path = base_path or os.getenv("CONFLUENCE_PATH")
-        opt_user_name = user_name or os.getenv("CONFLUENCE_USER_NAME")
-        opt_api_key = api_key or os.getenv("CONFLUENCE_API_KEY")
-        opt_space_key = space_key or os.getenv("CONFLUENCE_SPACE_KEY")
-
-        if not opt_domain:
-            raise ConfluenceError("Confluence domain not specified")
-        if not opt_base_path:
-            opt_base_path = "/wiki/"
-        if not opt_api_key:
-            raise ConfluenceError("Confluence API key not specified")
-        if not opt_space_key:
-            raise ConfluenceError("Confluence space key not specified")
-
-        if opt_domain.startswith(("http://", "https://")) or opt_domain.endswith("/"):
-            raise ConfluenceError(
-                "Confluence domain looks like a URL; only host name required"
-            )
-        if not opt_base_path.startswith("/") or not opt_base_path.endswith("/"):
-            raise ConfluenceError("Confluence base path must start and end with a '/'")
-
-        self.domain = opt_domain
-        self.base_path = opt_base_path
-        self.user_name = opt_user_name
-        self.api_key = opt_api_key
-        self.space_key = opt_space_key
-        self.space_key = opt_space_key
-        self.space_key = opt_space_key
+import os
+from typing import Dict, Optional
+
+
+class ConfluenceError(RuntimeError):
+    pass
+
+
+class ConfluenceProperties:
+    domain: str
+    base_path: str
+    space_key: str
+    user_name: Optional[str]
+    api_key: str
+    headers: Optional[Dict[str, str]]
+
+    def __init__(
+        self,
+        domain: Optional[str] = None,
+        base_path: Optional[str] = None,
+        user_name: Optional[str] = None,
+        api_key: Optional[str] = None,
+        space_key: Optional[str] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> None:
+        opt_domain = domain or os.getenv("CONFLUENCE_DOMAIN")
+        opt_base_path = base_path or os.getenv("CONFLUENCE_PATH")
+        opt_user_name = user_name or os.getenv("CONFLUENCE_USER_NAME")
+        opt_api_key = api_key or os.getenv("CONFLUENCE_API_KEY")
+        opt_space_key = space_key or os.getenv("CONFLUENCE_SPACE_KEY")
+
+        if not opt_domain:
+            raise ConfluenceError("Confluence domain not specified")
+        if not opt_base_path:
+            opt_base_path = "/wiki/"
+        if not opt_api_key:
+            raise ConfluenceError("Confluence API key not specified")
+        if not opt_space_key:
+            raise ConfluenceError("Confluence space key not specified")
+
+        if opt_domain.startswith(("http://", "https://")) or opt_domain.endswith("/"):
+            raise ConfluenceError(
+                "Confluence domain looks like a URL; only host name required"
+            )
+        if not opt_base_path.startswith("/") or not opt_base_path.endswith("/"):
+            raise ConfluenceError("Confluence base path must start and end with a '/'")
+
+        self.domain = opt_domain
+        self.base_path = opt_base_path
+        self.user_name = opt_user_name
+        self.api_key = opt_api_key
+        self.space_key = opt_space_key
+        self.headers = headers

markdown_to_confluence-0.1.13.dist-info/RECORD

@@ -1,16 +0,0 @@
-md2conf/__init__.py,sha256=yAKxptdEAiSXE55X3TxhUYa2iMkbW9fo1CWVRX8FNUY,416
-md2conf/__main__.py,sha256=-ZztZII6QYeuukxlOkVm8Mh9M1_ksA-5I2e2o5mvKLI,4353
-md2conf/api.py,sha256=ghLdaQtltRJ2-SUjhOZNkohL-RJ0Y1h6SfT7RiLPPZM,15231
-md2conf/application.py,sha256=BuIWLWrU8yaMbQhK0n3SUEPjxc7XJ0RIUdE3ALw9umE,5411
-md2conf/converter.py,sha256=_wfhDG-8Q3iAtR28Hp_ja-jyRMeb4HOvjCBsg1YMSZM,18926
-md2conf/entities.dtd,sha256=6and_fCiCHKhC7XXX0Fs-AaC0k_YN6csRQ7RiqbwyuM,30752
-md2conf/processor.py,sha256=TRsDbrNswNUjkdP7vXEUPYZvC07P6QN92ddwTGXVljg,3175
-md2conf/properties.py,sha256=zjtOQ73gQa5clPC6Ep4WHVjYIjTwPfrAtGDK7CUqbyc,1863
-md2conf/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-markdown_to_confluence-0.1.13.dist-info/LICENSE,sha256=d0Kt_fnS_LlDYrLPPI5xUSDGXRWRZNv81uKvmHa3lZM,1098
-markdown_to_confluence-0.1.13.dist-info/METADATA,sha256=NcsPNl4S4PsKF_lM8tbxNbOjdpf1Be3OFec9AmdJrSs,8035
-markdown_to_confluence-0.1.13.dist-info/WHEEL,sha256=nCVcAvsfA9TDtwGwhYaRrlPhTLV9m-Ga6mdyDtuwK18,91
-markdown_to_confluence-0.1.13.dist-info/entry_points.txt,sha256=F1zxa1wtEObtbHS-qp46330WVFLHdMnV2wQ-ZorRmX0,50
-markdown_to_confluence-0.1.13.dist-info/top_level.txt,sha256=_FJfl_kHrHNidyjUOuS01ngu_jDsfc-ZjSocNRJnTzU,8
-markdown_to_confluence-0.1.13.dist-info/zip-safe,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-markdown_to_confluence-0.1.13.dist-info/RECORD,,