wordpress-to-markdown 0.1.0__py3-none-any.whl

wordpress_to_markdown/__init__.py

@@ -0,0 +1,3 @@
+"""Export WordPress content to Markdown."""
+
+__version__ = "0.1.0"

wordpress_to_markdown/__main__.py

@@ -0,0 +1,4 @@
+from wordpress_to_markdown.cli import main
+
+if __name__ == "__main__":
+    main()

wordpress_to_markdown/assembler.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+import yaml
+from markdownify import markdownify
+
+from wordpress_to_markdown.core.models import Post, DocumentUnit
+
+
+def assemble(posts: list[Post],
+             mode: str = "per_post",
+             verbose: bool = False,
+             include_frontmatter: bool = False,
+             include_excerpt: bool = False,
+             content_format: str = "markdown",
+             ) -> list[DocumentUnit]:
+    """
+    Assemble processed posts into write-ready document units.
+    """
+    if content_format not in {"markdown", "html"}:
+        raise ValueError(f"Unsupported content format: {content_format}")
+
+    if mode == "per_post":
+        return _assemble_per_post(
+            posts,
+            verbose=verbose,
+            include_frontmatter=include_frontmatter,
+            include_excerpt=include_excerpt,
+            content_format=content_format,
+        )
+
+    if mode == "book":
+         return _assemble_book(
+             posts,
+             verbose=verbose,
+             include_frontmatter=include_frontmatter,
+             include_excerpt=include_excerpt,
+             content_format=content_format,
+         )
+
+    raise ValueError(f"Unsupported assembly mode: {mode}")
+
+
+def _process_frontmatter(data: dict) -> str:
+    yaml_str = yaml.dump(data, sort_keys=False, allow_unicode=True)
+    return f"---\n{yaml_str}---\n"
+
+
+def _process_content(
+    post: Post,
+    include_excerpt: bool = False,
+    content_format: str = "markdown",
+) -> str:
+    convert = markdownify if content_format == "markdown" else lambda value: value
+    content = convert(post.content)
+    if include_excerpt and post.excerpt:
+        excerpt = convert(post.excerpt).strip()
+        if excerpt:
+            return f"{excerpt}\n\n{content}"
+    return content
+
+
+def _assemble_per_post(posts: list[Post],
+                       verbose: bool = False,
+                       include_frontmatter: bool = False,
+                       include_excerpt: bool = False,
+                       content_format: str = "markdown",
+                       ) -> list[DocumentUnit]:
+    """
+    Convert each post into its own DocumentUnit.
+    """
+    units: list[DocumentUnit] = []
+
+    for post in posts:
+        if include_frontmatter:
+            frontmatter_str = _process_frontmatter(post.frontmatter)
+        filename = f"{post.slug or 'untitled'}.md"
+
+        unit = DocumentUnit(
+            filename=filename,
+            title=post.title,
+            content=_process_content(post, include_excerpt=include_excerpt, content_format=content_format),
+            frontmatter=frontmatter_str if include_frontmatter else "",
+            meta = {
+                    **post.meta,
+                    "date": post.date,
+                    "slug": post.slug,
+                    }
+        )
+        units.append(unit)
+
+        if verbose:
+            print(f"Assembled: {filename}")
+
+    return units
+
+def _assemble_book(posts: list[Post],
+                   verbose: bool = False,
+                   filename: str = "book.md",
+                   include_frontmatter: bool = False,
+                   include_excerpt: bool = False,
+                   content_format: str = "markdown",
+                   ) -> list[DocumentUnit]:
+    """
+    Convert all posts into a single DocumentUnit.
+    """
+
+    FILENAME = filename
+    book_content : list[str] = []
+
+    for post in posts:
+        frontmatter_prefix = ""
+        if include_frontmatter:
+            frontmatter_prefix = f"{_process_frontmatter(post.frontmatter)}\n"
+
+        content = _process_content(
+            post,
+            include_excerpt=include_excerpt,
+            content_format=content_format,
+        )
+        title = post.title
+        book_content.append(f"# {title}\n\n{frontmatter_prefix}{content}")
+
+    if verbose:
+            print(f"Assembled: {filename}")
+
+    book = DocumentUnit(
+        filename=FILENAME,
+        content="\n\n".join(book_content)
+        )
+
+    return list([book])

wordpress_to_markdown/cli.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+from pathlib import Path
+
+from wordpress_to_markdown.config.loader import load_config
+from wordpress_to_markdown.importer.wordpress_api import ensure_json_export
+from wordpress_to_markdown.sources.imported_json import load_imported_json
+from wordpress_to_markdown.processors.pipeline import process_posts
+from wordpress_to_markdown.assembler import assemble
+from wordpress_to_markdown.writer import write
+
+import argparse
+
+
+def parse_args(argv: list[str] | None = None):
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--config", default="config.json", help="Path to configuration JSON file")
+
+    parser.add_argument(
+        "--order",
+        choices=["newest", "oldest"],
+        default="newest",
+        help="Order posts by date, when pulling from JSON"
+    )
+
+    parser.add_argument(
+        "--write_order",
+        choices=["newest", "oldest"],
+        default="oldest",
+        help="Order posts by date, when writing to document"
+    )
+
+    parser.add_argument(
+        "--limit",
+        type=int,
+        help="Limit number of posts"
+    )
+
+    parser.add_argument(
+        "--refresh",
+        action="store_true",
+        help="Fetch fresh data from WordPress"
+    )
+
+    parser.add_argument(
+        "--mode",
+        choices=["per_post", "book"],
+        default="per_post",
+        help="Output mode"
+    )
+
+    parser.add_argument(
+        "--frontmatter",
+        action="store_true",
+        help="Include frontmatter"
+    )
+
+    parser.add_argument(
+        "--excerpt",
+        action="store_true",
+        default=False,
+        help="Include the WordPress excerpt before post content"
+    )
+
+
+    parser.add_argument(
+        "--content-format", choices=["markdown", "html"], default="markdown",
+        help="Format post and excerpt content (default: markdown)"
+    )
+
+    return parser.parse_args(argv)
+
+
+def order_and_limit_posts(posts, order: str = "newest", limit: int | None = None):
+    # sort posts by date order, for pulling
+    reverse = order == "newest"
+    posts = sorted(posts, key=lambda p: p.date or "", reverse=reverse)
+
+    # limit the number of posts
+    if limit is not None:
+        posts = posts[:limit]
+
+    return posts
+
+def write_order(posts, order: str = "oldest", limit: int | None = None):
+    # sort posts by date order for writing
+    reverse = order == "newest"
+    posts = sorted(posts, key=lambda p: p.date or "", reverse=reverse)
+
+    return posts
+
+
+def main() -> None:
+    args = parse_args()
+    config = load_config(args.config)
+    json_path = Path(config["paths"]["json_file"])
+    base_url = config["wordpress"]["base_url"]
+    output_dir = config["paths"].get("output_dir", str(json_path.parent.parent / "output"))
+
+    ensure_json_export(
+        base_url=base_url,
+        json_path=json_path,
+        refresh=args.refresh,
+    )
+
+    print("Starting build...")
+
+    posts = load_imported_json(input_file=json_path, verbose=True, frontmatter_fields=config["frontmatter"]["fields"])
+    posts = process_posts(posts, verbose=True)
+
+    posts = order_and_limit_posts(
+        posts,
+        order=args.order,
+        limit=args.limit
+    )
+
+    posts = write_order(posts, order=args.write_order)
+
+    units = assemble(posts, 
+                     mode=args.mode, 
+                     verbose=True, 
+                     include_frontmatter=args.frontmatter if args.frontmatter 
+                     else config["frontmatter"]["include_frontmatter"],
+                     include_excerpt=args.excerpt,
+                     content_format=args.content_format,
+                     )
+
+    print(f"[INFO] Writing {len(units)} markdown files...")
+    print(f"[INFO] Output mode: {args.mode}")
+    write(
+        units,
+        format="md",
+        output_dir=output_dir,
+        verbose=True,
+        mode=args.mode,
+    )
+
+    print("Build completed. ✅")
+
+
+if __name__ == "__main__":
+    main()