markdown_convert 1.2.13__tar.gz → 1.2.15__tar.gz

{markdown_convert-1.2.13 → markdown_convert-1.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: markdown_convert
-Version: 1.2.13
+Version: 1.2.15
 Summary: Convert Markdown files to PDF from your command line.
 Project-URL: homepage, https://github.com/Julynx/markdown_convert
 Author-email: Julio Cabria <juliocabria@tutanota.com>

markdown_convert-1.2.15/markdown_convert/__main__.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+
+"""
+CLI interface to convert markdown files to pdf.
+Author: @julynx
+"""
+
+
+from sys import exit as sys_exit
+
+from argsdict import args
+from .modules.constants import RED, OPTIONS, OPTIONS_MODES
+from .modules.convert import convert, live_convert
+from .modules.resources import get_css_path, get_output_path, get_usage
+from .modules.utils import color
+from .modules.validate import (validate_css_path, validate_markdown_path,
+                               validate_output_path)
+
+
+def main():
+    """
+    Convert a markdown file to a pdf file.
+    """
+    try:
+        # Load and validate arguments
+        arg = args(["markdown_file_path"])
+        for key in set(arg.keys()) - set(OPTIONS):
+            raise IndexError(f"Invalid option: '{key}'")
+
+        # Get the markdown path
+        try:
+            md_path = arg["markdown_file_path"]
+            validate_markdown_path(md_path)
+        except KeyError as key_err:
+            raise IndexError("Missing 'markdown_file_path' argument.") \
+                from key_err
+        except Exception as exc:
+            raise IndexError(f"Invalid 'markdown_file_path' argument: {exc}") \
+                from exc
+
+        # Get the mode
+        try:
+            mode = arg["--mode"]
+            if mode not in OPTIONS_MODES:
+                raise ValueError(f"Invalid mode: '{mode}'")
+        except KeyError:
+            mode = "once"
+
+        # Get the CSS path
+        try:
+            css_path = arg["--css"]
+            validate_css_path(css_path)
+        except KeyError:
+            css_path = get_css_path()
+        except Exception as exc:
+            raise IndexError(f"Invalid 'css_file_path' argument: {exc}") \
+                from exc
+
+        # Get the output path
+        output_path = None
+        try:
+            output_path = arg["--out"]
+            validate_output_path(output_path)
+            output_path = get_output_path(md_path, output_path)
+        except KeyError:
+            output_path = get_output_path(md_path, None)
+        except Exception as exc:
+            raise IndexError(f"Invalid 'output_path' argument: {exc}") \
+                from exc
+
+        # Compile the markdown file
+        print(f'\nGenerating PDF file from \'{md_path}\'...\n')
+        if mode == "once":
+            convert(md_path, css_path, output_path)
+        else:
+            live_convert(md_path, css_path, output_path)
+
+        sys_exit(0)
+
+    except Exception as err:
+
+        asked_for_help = "--help" in arg or "-h" in arg
+        show_usage = (isinstance(err, (IndexError, ValueError))
+                      or asked_for_help)
+
+        if show_usage:
+            print(get_usage())
+
+        if not asked_for_help:
+            print(color(RED, f"ERROR: {err}\n"))
+
+        sys_exit(1)
+
+
+if __name__ == '__main__':
+    main()

markdown_convert-1.2.15/markdown_convert/modules/__init__.py

@@ -0,0 +1,4 @@
+"""
+Empty file to make the folder a package.
+Author: @julynx
+"""

markdown_convert-1.2.15/markdown_convert/modules/constants.py

@@ -0,0 +1,26 @@
+"""
+This module contains the constants used in the markdown_convert package.
+Author: @julynx
+"""
+
+RED = '31'
+GREEN = '32'
+YELLOW = '33'
+BLUE = '34'
+MAGENTA = '35'
+CYAN = '36'
+
+OPTIONS = ('markdown_file_path',
+           "--mode",
+           '--css',
+           "--out",
+           "-h", "--help")
+
+OPTIONS_MODES = ('once', 'live')
+
+MD_EXTENSIONS = {
+    "fenced-code-blocks": None,
+    "header-ids": None,
+    "breaks": {"on_newline": True},
+    "tables": None
+}

markdown_convert-1.2.15/markdown_convert/modules/convert.py

@@ -0,0 +1,247 @@
+"""
+Module to convert a markdown file to a pdf file.
+Author: @julynx
+"""
+
+import os
+import sys
+import time
+import warnings
+from contextlib import redirect_stderr, redirect_stdout
+from datetime import datetime
+from io import StringIO
+from pathlib import Path
+
+import markdown2
+import weasyprint
+
+from .resources import get_css_path, get_code_css_path, get_output_path
+from .utils import drop_duplicates
+from .constants import MD_EXTENSIONS
+
+
+def _suppress_warnings():
+    """
+    Suppress all warnings in production while preserving critical error handling.
+    Only errors and exceptions will be shown.
+    """
+    # Suppress all warnings but keep errors
+    warnings.filterwarnings('ignore', category=UserWarning)
+    warnings.filterwarnings('ignore', category=DeprecationWarning)
+    warnings.filterwarnings('ignore', category=FutureWarning)
+    warnings.filterwarnings('ignore', category=PendingDeprecationWarning)
+    warnings.filterwarnings('ignore', category=ImportWarning)
+    warnings.filterwarnings('ignore', category=ResourceWarning)
+
+
+def _silent_pdf_generation(func, *args, **kwargs):
+    """
+    Execute PDF generation function while suppressing all non-critical output.
+    Preserves exceptions and critical errors.
+    """
+    _suppress_warnings()
+    
+    # Capture stdout and stderr to filter out warnings
+    stdout_capture = StringIO()
+    stderr_capture = StringIO()
+    
+    try:
+        with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture):
+            result = func(*args, **kwargs)
+        
+        # Check if there were any critical errors in stderr
+        stderr_content = stderr_capture.getvalue()
+        if stderr_content and any(keyword in stderr_content.lower()
+                                for keyword in ['error', 'exception', 'traceback', 'failed']):
+            # Print only critical errors, not warnings
+            print(stderr_content, file=sys.stderr)
+        
+        return result
+        
+    except Exception as exc:
+        # Always re-raise actual exceptions
+        raise exc
+
+
+def convert(md_path, css_path=None, output_path=None,
+            *, extend_default_css=True):
+    """
+    Convert a markdown file to a pdf file.
+
+    Args:
+        md_path (str): Path to the markdown file.
+        css_path (str=None): Path to the CSS file.
+        output_path (str=None): Path to the output file.
+        extend_default_css (bool=True): Extend the default CSS file.
+    """
+    if css_path is None:
+        css_path = get_css_path()
+
+    if output_path is None:
+        output_path = get_output_path(md_path, None)
+
+    if extend_default_css:
+        css_sources = [get_code_css_path(), get_css_path(), css_path]
+    else:
+        css_sources = [get_code_css_path(), css_path]
+
+    css_sources = drop_duplicates(css_sources)
+
+    try:
+        html = markdown2.markdown_path(md_path,
+                                       extras=MD_EXTENSIONS)
+
+        # Use silent PDF generation to suppress warnings
+        _silent_pdf_generation(
+            lambda: weasyprint
+            .HTML(string=html, base_url='.')
+            .write_pdf(target=output_path,
+                      stylesheets=list(css_sources))
+        )
+
+    except Exception as exc:
+        raise RuntimeError(exc) from exc
+
+
+def live_convert(md_path, css_path=None, output_path=None,
+                 *, extend_default_css=True):
+    """
+    Convert a markdown file to a pdf file and watch for changes.
+
+    Args:
+        md_path (str): Path to the markdown file.
+        css_path (str=None): Path to the CSS file.
+        output_path (str=None): Path to the output file.
+        extend_default_css (bool=True): Extend the default CSS file.
+    """
+    if css_path is None:
+        css_path = get_css_path()
+
+    if output_path is None:
+        output_path = get_output_path(md_path, None)
+
+    live_converter = LiveConverter(md_path, css_path, output_path,
+                                   extend_default_css=extend_default_css,
+                                   loud=True)
+    live_converter.observe()
+
+
+def convert_text(md_text, css_text=None,
+                 *, extend_default_css=True):
+    """
+    Convert markdown text to a pdf file.
+
+    Args:
+        md_text (str): Markdown text.
+        css_text (str=None): CSS text.
+        extend_default_css (bool=True): Extend the default CSS file.
+
+    Returns:
+        PDF file as bytes.
+    """
+    default_css = Path(get_css_path()).read_text(encoding='utf-8')
+    code_css = Path(get_code_css_path()).read_text(encoding='utf-8')
+
+    if css_text is None:
+        css_text = default_css
+
+    if extend_default_css:
+        css_sources = [code_css, default_css, css_text]
+    else:
+        css_sources = [code_css, css_text]
+
+    css_sources = [weasyprint.CSS(string=css)
+                   for css in drop_duplicates(css_sources)]
+
+    try:
+        html = markdown2.markdown(md_text,
+                                  extras=MD_EXTENSIONS)
+
+        # Use silent PDF generation to suppress warnings
+        return _silent_pdf_generation(
+            lambda: weasyprint
+            .HTML(string=html, base_url='.')
+            .write_pdf(stylesheets=css_sources)
+        )
+
+    except Exception as exc:
+        raise RuntimeError(exc) from exc
+
+
+class LiveConverter():
+    """
+    Class to convert a markdown file to a pdf file and watch for changes.
+    """
+
+    def __init__(self, md_path, css_path, output_path,
+                 *, extend_default_css=True,
+                 loud=False):
+        """
+        Initialize the LiveConverter class.
+
+        Args:
+            md_path (str): Path to the markdown file.
+            css_path (str): Path to the CSS file.
+            output_path (str): Path to the output file.
+            extend_default_css (bool): Extend the default CSS file.
+        """
+        self.md_path = Path(md_path).absolute()
+        self.css_path = Path(css_path).absolute()
+        self.output_path = output_path
+        self.extend_default_css = extend_default_css
+        self.loud = loud
+
+        self.md_last_modified = None
+        self.css_last_modified = None
+
+    def get_last_modified_date(self, file_path):
+        """
+        Get the last modified date of a file.
+
+        Args:
+            file_path (str): Path to the file.
+
+        Returns:
+            Last modified date of the file.
+        """
+        return os.path.getmtime(file_path)
+
+    def write_pdf(self):
+        """
+        Write the pdf file.
+        """
+        convert(self.md_path, self.css_path, self.output_path,
+                extend_default_css=self.extend_default_css)
+        if self.loud:
+            print(f"- PDF file updated: {datetime.now()}", flush=True)
+
+    def observe(self, poll_interval=1):
+        """
+        Observe the markdown and CSS files. Calls write_pdf() when a file is
+        modified.
+        """
+        self.write_pdf()
+
+        self.md_last_modified = self.get_last_modified_date(self.md_path)
+        self.css_last_modified = self.get_last_modified_date(self.css_path)
+
+        try:
+            while True:
+
+                md_modified = self.get_last_modified_date(self.md_path)
+                css_modified = self.get_last_modified_date(self.css_path)
+
+                if md_modified != self.md_last_modified or \
+                        css_modified != self.css_last_modified:
+
+                    self.write_pdf()
+
+                    self.md_last_modified = md_modified
+                    self.css_last_modified = css_modified
+
+                time.sleep(poll_interval)
+
+        except KeyboardInterrupt:
+            if self.loud:
+                print("\nInterrupted by user.\n", flush=True)
+            return

markdown_convert-1.2.15/markdown_convert/modules/resources.py

@@ -0,0 +1,92 @@
+"""
+This module contains functions that are used to get the output path, the CSS
+path, and the usage message.
+Author: @julynx
+"""
+
+from pathlib import Path
+
+try:
+    # Python 3.9+
+    from importlib.resources import files
+except ImportError:
+    # Fallback for older Python versions
+    from importlib_resources import files
+
+from .constants import BLUE, CYAN, GREEN, YELLOW, OPTIONS, OPTIONS_MODES
+from .utils import color
+
+
+def get_output_path(md_path, output_dir=None):
+    """
+    Get the output path for the pdf file.
+
+    Args:
+        md_path (str): The path to the markdown file.
+        output_dir (str): The output directory.
+
+    Returns:
+        str: The output path.
+    """
+    md_path = Path(md_path)
+
+    if output_dir is None:
+        return md_path.parent / f"{md_path.stem}.pdf"
+
+    output_dir = Path(output_dir)
+
+    if output_dir.suffix == ".pdf":
+        return output_dir
+
+    return output_dir.parent / f"{Path(md_path).stem}.pdf"
+
+
+def get_css_path():
+    """
+    Get the path to the default CSS file.
+
+    Returns:
+        str: The path to the default CSS file.
+    """
+    package_files = files('markdown_convert')
+    css_file = package_files / 'default.css'
+    return str(css_file)
+
+
+def get_code_css_path():
+    """
+    Get the path to the code CSS file.
+
+    Returns:
+        str: The path to the code CSS file.
+    """
+    package_files = files('markdown_convert')
+    css_file = package_files / 'code.css'
+    return str(css_file)
+
+
+def get_usage():
+    """
+    Returns a message describing how to use the program.
+
+    Returns:
+        str: The usage message.
+    """
+    commd = (f"{color(GREEN, 'markdown-convert')} "
+             f"[{color(YELLOW, OPTIONS[0])}] [{color(BLUE, 'options')}]")
+    opt_1 = f"{color(BLUE, OPTIONS[1])}{color(CYAN, '=')}{color(CYAN, '|'.join(OPTIONS_MODES))}"
+    opt_2 = f"{color(BLUE, OPTIONS[2])}{color(CYAN, '=')}[{color(CYAN, 'css_file_path')}]"
+    opt_3 = f"{color(BLUE, OPTIONS[3])}{color(CYAN, '=')}[{color(CYAN, 'output_file_path')}]"
+
+    usage = ("\n"
+             "Usage:\n"
+             f"  {commd}\n"
+             "\n"
+             "Options:\n"
+             f"  {opt_1}\n"
+             "    Convert the markdown file once (default) or live.\n"
+             f"  {opt_2}\n"
+             "    Use a custom CSS file.\n"
+             f"  {opt_3}\n"
+             "    Specify the output file path.\n")
+    return usage

markdown_convert-1.2.15/markdown_convert/modules/utils.py

@@ -0,0 +1,38 @@
+"""
+Utility functions for string manipulation.
+Author: @julynx
+"""
+
+import platform
+
+
+def color(color_code, text):
+    """
+    Colorize text.
+
+    Args:
+        text (str): The text to colorize.
+        color (str): The color code.
+
+    Returns:
+        str: The colorized text.
+    """
+
+    # Disable if running on Windows
+    if platform.system() == "Windows":
+        return text
+
+    return f"\033[{color_code}m{text}\033[0m"
+
+
+def drop_duplicates(lst):
+    """
+    Drops duplicates from the given list.
+
+    Args:
+        lst: List to remove duplicates from.
+
+    Returns:
+        List without duplicates.
+    """
+    return list(dict.fromkeys(lst))

markdown_convert-1.2.15/markdown_convert/modules/validate.py

@@ -0,0 +1,61 @@
+"""
+This module contains functions to validate the input paths.
+Author: @julynx
+"""
+
+from pathlib import Path
+
+
+def validate_markdown_path(md_path):
+    """
+    Validate the markdown file path.
+
+    Args:
+        md_path (str): The path to the markdown file.
+
+    Raises:
+        FileNotFoundError: If the file is not found.
+        ValueError: If the file is not a Markdown file.
+    """
+    if not Path(md_path).is_file():
+        raise FileNotFoundError(f"File not found: '{md_path}'")
+
+    if not md_path.endswith(".md"):
+        raise ValueError("File must be a Markdown file.")
+
+
+def validate_css_path(css_path):
+    """
+    Validate the CSS file path.
+
+    Args:
+        css_path (str): The path to the CSS file.
+
+    Raises:
+        FileNotFoundError: If the file is not found.
+        ValueError: If the file is not a CSS file.
+    """
+    if not Path(css_path).is_file():
+        raise FileNotFoundError(f"File not found: '{css_path}'")
+
+    if not css_path.endswith(".css"):
+        raise ValueError("File must be a CSS file.")
+
+
+def validate_output_path(output_dir):
+    """
+    Validate the output directory path.
+
+    Args:
+        output_dir (str): The path to the output directory.
+
+    Raises:
+        FileNotFoundError: If the directory is not found.
+    """
+    check_dir = Path(output_dir)
+
+    if output_dir.endswith(".pdf"):
+        check_dir = check_dir.parent
+
+    if not check_dir.is_dir():
+        raise FileNotFoundError(f"Directory not found: '{check_dir}'")

{markdown_convert-1.2.13 → markdown_convert-1.2.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "markdown_convert"
-version = "1.2.13"
+version = "1.2.15"
 description = "Convert Markdown files to PDF from your command line."
 authors = [
     { name = "Julio Cabria", email = "juliocabria@tutanota.com" },
@@ -32,9 +32,27 @@ markdown-convert = "markdown_convert.__main__:main"
 
 [tool.hatch.build.targets.sdist]
 include = [
+    "markdown_convert/__main__.py",
     "markdown_convert/default.css",
     "markdown_convert/code.css",
+    "markdown_convert/modules/__init__.py",
+    "markdown_convert/modules/constants.py",
+    "markdown_convert/modules/convert.py",
+    "markdown_convert/modules/resources.py",
+    "markdown_convert/modules/utils.py",
+    "markdown_convert/modules/validate.py",
 ]
 
 [tool.hatch.build.targets.wheel]
 packages = ["markdown_convert"]
+include = [
+    "markdown_convert/__main__.py",
+    "markdown_convert/default.css",
+    "markdown_convert/code.css",
+    "markdown_convert/modules/__init__.py",
+    "markdown_convert/modules/constants.py",
+    "markdown_convert/modules/convert.py",
+    "markdown_convert/modules/resources.py",
+    "markdown_convert/modules/utils.py",
+    "markdown_convert/modules/validate.py",
+]