texmark 0.0.0__py3-none-any.whl

texmark/build.py

@@ -0,0 +1,178 @@
+#!/usr/bin/env python3
+import subprocess
+from pathlib import Path
+import os
+import sys
+import pypandoc
+import json
+import yaml
+import jinja2
+import frontmatter
+import argparse
+import texmark
+import json
+import panflute as pf
+import io
+from texmark.logs import logger
+
+rootpath = Path(texmark.__file__).resolve().parent
+
+def run(cmd, shell=False, check=True, **kwargs):
+    print(cmd if shell else ' '.join(cmd))
+    return subprocess.run(cmd, shell=shell, check=check, **kwargs)
+
+
+def normalize_metadata(meta):
+    """
+    Recursively convert panflute metadata into plain JSON-serializable Python dict.
+    (Plain strings, lists, dicts, no MetaInlines etc.)
+    """
+    if isinstance(meta, pf.MetaInlines) or isinstance(meta, pf.MetaBlocks):
+        return pf.stringify(meta)
+    elif isinstance(meta, pf.MetaString):
+        return meta.text
+    elif isinstance(meta, pf.MetaBool):
+        return bool(meta)
+    elif isinstance(meta, pf.MetaList):
+        return [normalize_metadata(item) for item in meta]
+    elif isinstance(meta, pf.MetaMap):
+        return {key: normalize_metadata(value) for key, value in meta.items()}
+    else:
+        # Primitive types (str, int, etc.) or unknown - return as is
+        return meta
+
+
+def build_tex(input_md, output_tex, template='', bib_file='', build_dir='build', filters=None, journal_template=None, filters_module=None):
+    # 1. Parse Markdown
+    input_text = open(input_md).read()
+    post = frontmatter.loads(input_text)
+    metadata = post.metadata
+    content = post.content
+
+    if not journal_template:
+        journal_template = metadata.get('journal', {}).get('template', 'default')
+        if not journal_template:
+            journal_template = "default"
+
+    metadata.setdefault('journal', {})['template'] = journal_template
+
+    if filters_module:
+        metadata['filters_module'] = filters_module
+
+    if not template:
+        template = metadata.get('template')
+        if not template:
+            template = f'templates/{journal_template}/template.tex'
+
+    template_folder = Path(template).parent
+    template_name = Path(template).name
+    resource_path = rootpath / template_folder
+
+    if not bib_file:
+        bib_file = metadata.get('bibliography', None)
+    if bib_file:
+        bib_args = ['--bibliography', bib_file]
+    args = bib_args + metadata.get('pandoc_args', []) + [
+        "--natbib",
+    ]
+
+    filters = [
+        "texmark-filter",
+        ] + (filters or metadata.get('filters', []))
+
+    # Step 1: Run pandoc to get JSON AST with filters applied, and updated metadata
+    cmd_json = []
+    for f in filters:
+        cmd_json.extend(['--filter', f])
+    cmd_json.extend(args)
+
+    post.metadata = metadata
+
+    ast_json_str = pypandoc.convert_text(
+        frontmatter.dumps(post),
+        format="markdown+footnotes",
+        to="json",
+        extra_args=cmd_json,
+    )
+
+    doc = pf.load(io.StringIO(ast_json_str))  # <-- no input_format argument
+    metadata.update(normalize_metadata(doc.metadata))
+
+    # Step 2. Render Jinja2 Template
+    env = jinja2.Environment(loader=jinja2.FileSystemLoader(resource_path))
+    template = env.get_template(template_name)
+
+    build_dir = Path(build_dir)
+    build_dir.mkdir(parents=True, exist_ok=True)
+
+    Path(output_tex).parent.mkdir(parents=True, exist_ok=True)
+
+    # Step 3: Render AST to LaTeX (filters not needed again)
+    body = pypandoc.convert_text(
+        ast_json_str,
+        format="json",
+        to="latex",
+        extra_args=['--template', rootpath / "templates" / "body.tex"] + args,
+    )
+
+    with open(output_tex, "w") as f:
+        f.write(template.render(body=body, **metadata))  # Includes authors/abstract
+
+    metadata["resource_path"] = str(resource_path)
+    return metadata
+
+
+def compile_pdf(input_tex, output_pdf, engine='pdflatex', build_dir='build', images_dir='images', bib_file='references.bib', resource_path=''):
+    """
+    Step 2: Compile LaTeX source into PDF.
+    """
+    if resource_path:
+        print(f"Resource path: {resource_path}")
+        run(f"rsync -r {resource_path}/ {build_dir}/", shell=True)
+        # os.environ['TEXINPUTS'] = f"{resource_path}:" + os.environ.get('TEXINPUTS', '')
+
+    run(f"rsync -r {Path(images_dir)} {build_dir}/", shell=True)
+    run(f"rsync {input_tex} {build_dir}/", shell=True)
+    run(f"rsync {bib_file} {build_dir}/", shell=True)
+    cmd = [engine, '-interaction=nonstopmode', Path(input_tex).name]
+    run(cmd, cwd=build_dir, check=False)
+    bibcmd = ["bibtex", Path(input_tex).with_suffix(".aux").name]
+    run(bibcmd, cwd=build_dir, check=False)
+    run(cmd, cwd=build_dir, check=False)
+    run(cmd, cwd=build_dir, check=False)
+    # Rename/move the generated PDF if needed
+    actual_pdf = Path(build_dir) / Path(input_tex).with_suffix(".pdf").name
+    if Path(output_pdf) != actual_pdf:
+        run(['mv', str(actual_pdf), output_pdf])
+
+
+def main():
+
+    parser = argparse.ArgumentParser(description='Two-step build: Markdown → LaTeX → PDF')
+    parser.add_argument('input', help='Input markdown file')
+    parser.add_argument('-j', '--journal-template', help='Pandoc LaTeX + filter template family. Update journal -> template yaml field)')
+    parser.add_argument('-t', '--template', help='Pandoc LaTeX template. Update template yaml field)')
+    parser.add_argument('-f', '--filters', nargs='*', help='Additional, custom filters. By default the pre-defined, custom filters for the journal are used via the `texmark-filter` utility.')
+    parser.add_argument('--filters-module', help='Load a custom filter module. This is a Python module that may extend the filters dict defined in the `texmark.shared` module.')
+    parser.add_argument('-o', '--output', help='Final PDF output filename')
+    parser.add_argument('-e', '--engine', default='pdflatex', help='LaTeX engine (e.g. pdflatex, xelatex)')
+    parser.add_argument('-d', '--build', default='build', help='build directory')
+    parser.add_argument('--bib', help='bibliography file')
+    parser.add_argument('--tex', help='LaTeX output filename')
+    parser.add_argument('--pdf', action="store_true")
+    parser.add_argument('--images', default='images', help='images directory')
+    args = parser.parse_args()
+
+    # Derive filenames
+    build_dir = Path(args.build)
+    tex_file = args.tex or build_dir / Path(args.input).with_suffix(".tex").name
+    pdf_file = args.output or build_dir / Path(args.input).with_suffix(".pdf").name
+
+    metadata = build_tex(args.input, tex_file, template=args.template, bib_file=args.bib, filters=args.filters, journal_template=args.journal_template, filters_module=args.filters_module)
+
+    if args.pdf:
+        compile_pdf(tex_file, pdf_file, args.engine, args.build, args.images, bib_file=metadata.get('bibliography'), resource_path=metadata.get('resource_path'))
+
+
+if __name__ == '__main__':
+    main()

texmark/filters.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+
+import sys
+import json
+import importlib
+import panflute as pf
+from texmark.logs import logger
+from texmark.shared import filters, default_filter
+from texmark.shared import JournalFilter, filters, logger, Processor
+from texmark.sectiontracker import SectionProcessor
+
+copernicus_filter = JournalFilter(
+        processors = [
+            SectionProcessor(
+                extract_sections=['abstract', 'appendix', 'acknowledgements', 'author-contributions', 'competing-interests'],
+                sections_map={
+                    'author-contributions': 'authorcontribution',
+                    'competing-interests': 'competinginterests',
+                },
+                remap_command_sections={
+                    'introduction': r'\introduction',
+                    'conclusions': r'\conclusions'
+                }
+            )
+        ])
+
+for journal in ["copernicus", "cp", "esd"]:
+    filters[journal] = [copernicus_filter]
+
+
+def force_cite(elem, doc):
+    if isinstance(elem, pf.Cite):
+        keys = [c.id for c in elem.citations]
+        key_str = ",".join(keys)
+        # Build as raw LaTeX \cite{}
+        return pf.RawInline(f'\\cite{{{key_str}}}', format='latex')
+
+def header_to_unnumbered(elem, doc):
+    if isinstance(elem, pf.Header):
+        # Convert header to raw LaTeX \section*{...}
+        level = elem.level
+        content = pf.stringify(elem)
+        latex_cmd = f'\\{"sub" * (level - 1)}section*{{{content}}}'
+        return pf.RawBlock(latex_cmd, format='latex')
+
+def header_to_paragraph(elem, doc):
+    if isinstance(elem, pf.Header):
+        # Convert header to raw LaTeX \section*{...}
+        level = elem.level
+        content = pf.stringify(elem)
+        latex_cmd = f'\\paragraph*{{{content+"."}}}'
+        return pf.RawBlock(latex_cmd, format='latex')
+
+
+science_filter = JournalFilter(
+        processors = [
+            SectionProcessor(
+                extract_sections=['abstract', 'appendix', 'acknowledgements', 'author-contributions',
+                                  'competing-interests', 'methods', 'materials-and-methods', 'supplementary-material'],
+                sections_map={
+                    'author-contributions': 'authorcontribution',
+                    'competing-interests': 'competinginterests',
+                    'supplementary-material': 'appendix',
+                    'methods': 'materialsandmethods',
+                    'materials-and-methods': 'materialsandmethods',
+                },
+                remap_command_sections={
+                    # 'introduction': r'\section*{Introduction}',
+                }
+            ),
+            force_cite,
+            header_to_paragraph,
+        ])
+
+filters['science'] = [science_filter]
+
+def run_filters(doc):
+
+    if doc is not None:
+        journal = doc.get_metadata('journal')
+    else:
+        logger.warning(f'doc is None')
+        journal = {'template': 'default'}
+
+    if doc.get_metadata('filters_module'):
+        filters_module = doc.get_metadata('filters_module')
+        logger.warning(f"Loading filters module: {filters_module}")
+        importlib.import_module(filters_module)
+
+
+    if journal.get("template") is None:
+        logger.warning(f'doc is None')
+
+    filters_ = filters.get(journal.get("template"))
+    if filters_ is None:
+        logger.warning(f'No filters found for journal template: {journal.get("template")}. Using default filter.')
+        filters_ = [default_filter]
+
+    for filter in filters_:
+        doc = pf.run_filter(action=filter.action,
+                   prepare=filter.prepare,
+                   finalize=filter.finalize, doc=doc)
+
+    return doc
+
+
+def main(doc=None):
+    doc = pf.load(sys.stdin)
+    doc = run_filters(doc)
+    return pf.dump(doc)
+
+
+if __name__ == '__main__':
+    main()

texmark/logs.py

@@ -0,0 +1,3 @@
+import logging
+logger = logging.getLogger("texmark")
+logger.setLevel(logging.DEBUG)

texmark/sectiontracker.py

@@ -0,0 +1,136 @@
+import json
+import panflute as pf
+from panflute import stringify, run_filter, Header, RawBlock, RawInline, convert_text, Block
+from texmark.logs import logger
+import io
+
+def panflute2latex(elements, wrap='none') -> str:
+    blocks = []
+    inline_buffer = []
+
+    for el in elements:
+        if isinstance(el, pf.Block):
+            # Flush any accumulated inlines before adding a block
+            if inline_buffer:
+                blocks.append(pf.Para(*inline_buffer))
+                inline_buffer = []
+            blocks.append(el)
+
+        elif isinstance(el, pf.Inline):
+            inline_buffer.append(el)
+
+        else:
+            raise TypeError(f"Unsupported element type: {type(el)}")
+
+    # Flush remaining inlines into a final paragraph
+    if inline_buffer:
+        blocks.append(pf.Para(*inline_buffer))
+
+    doc = pf.Doc(*blocks)
+
+    # Safer output buffering
+    buffer = io.BytesIO()
+    writer = io.TextIOWrapper(buffer, encoding='utf-8')
+    pf.dump(doc, writer)
+    writer.flush()
+
+    json_ast_str = buffer.getvalue().decode('utf-8')
+
+    latex = pf.convert_text(
+        json_ast_str,
+        input_format='json',
+        output_format='latex',
+        extra_args=[f'--wrap={wrap}']
+    )
+
+    return latex
+
+
+
+class SectionTracker:
+    def __init__(self):
+        self.active_section = None
+        self.section_content = []
+        self.section_level = 0
+        self.sections = {}
+
+    def reset(self):
+        if self.active_section:
+            self.sections[self.active_section] = {
+                'content': self.section_content,
+                'level': self.section_level
+            }
+        self.active_section = None
+        self.section_content = []
+        self.section_level = 0
+
+
+class SectionProcessor:
+    def __init__(self, extract_sections, sections_map={}, remap_command_sections={}):
+        self.extract_sections = extract_sections
+        self.sections_map = sections_map or {}
+        self.remap_command_sections = remap_command_sections or {}
+
+    def prepare(self, doc):
+        doc.tracker = SectionTracker()
+        doc.extract_sections = self.extract_sections
+        doc.sections_map = self.sections_map
+
+    def action(self, elem, doc):
+        tracker = doc.tracker
+        # logger.warning(f"check elem {elem} {stringify(elem)}")
+
+        # Header processing
+        if isinstance(elem, Header):
+            title = elem.identifier
+
+            # Check if we're entering a target section
+            if title in doc.extract_sections:
+                tracker.reset()
+                tracker.active_section = title
+                tracker.section_level = elem.level
+                # logger.warning(f"!!Remove {elem}")
+                return []  # Remove original header
+
+            # Check if we're exiting a section
+            if tracker.active_section and elem.level <= tracker.section_level:
+                # logger.warning(f"Exit {tracker.active_section} with {elem} {stringify(elem)}")
+                # logger.warning(f"Last element of {tracker.active_section} {tracker.section_content[-1]}")
+                # logger.warning(f"Remove last: {tracker.section_content[-1]} {stringify(tracker.section_content[-1])}")
+                tracker.section_content = tracker.section_content[:-1]
+                tracker.reset()
+
+            # Check if the header is a target section for remap header command
+            if title in self.remap_command_sections:
+                # Replace header with the remapped command
+                command = self.remap_command_sections[title]
+                return RawBlock(command, format='latex')
+
+
+        # Content collection
+        if tracker.active_section:
+            tracker.section_content.append(elem)
+            return []  # Remove from main flow
+
+
+    def finalize(self, doc):
+        tracker = doc.tracker
+        tracker.reset()  # Capture last section
+
+        # Convert collected sections to LaTeX
+        for section in doc.extract_sections:
+            meta_key = doc.sections_map.get(section, section)
+            if section in tracker.sections:
+                inline_elements = tracker.sections[section]['content']
+                latex = panflute2latex(inline_elements)
+                doc.metadata[meta_key] = RawInline(latex, format='latex')
+
+
+def main(doc=None):
+    extractor = SectionProcessor(
+        extract_sections=["introduction", "methods", "conclusions", "acknowledgements"],
+    )
+    return run_filter(extractor.action, prepare=extractor.prepare, finalize=extractor.finalize, doc=doc)
+
+if __name__ == '__main__':
+    main()

texmark/shared.py

@@ -0,0 +1,83 @@
+import sys
+import panflute as pf
+from panflute import Image, Table
+from texmark.logs import logger
+
+def _run_action(action, elem, doc):
+    result = action(elem, doc)
+    if result is None:
+        return elem
+    return result
+
+class Processor:
+    def __init__(self, action=None, prepare=None, finalize=None):
+        self._action = action
+        self._prepare = prepare
+        self._finalize = finalize
+
+    def action(self, elem, doc):
+        if self._action:
+            return _run_action(self._action, elem, doc)
+        return elem
+    def prepare(self, doc):
+        if self._prepare:
+            return _run_action(self._prepare, doc, doc)
+        return doc
+    def finalize(self, doc):
+        if self._finalize:
+            return _run_action(self._finalize, doc, doc)
+        return doc
+
+class JournalFilter:
+    def __init__(self, processors=None):
+        self.processors = processors or []
+
+    def prepare(self, doc):
+        for processor in self.processors:
+            if hasattr(processor, "prepare"):
+                processor.prepare(doc)
+
+    def action(self, elem, doc):
+
+        if hasattr(elem, 'url'):
+            if elem.url.startswith('/'):
+                # Remove leading slash to make it repo-root relative (like GitHub)
+                elem.url = elem.url.lstrip('/')
+
+        if isinstance(elem, Image):
+            elem = _run_action(self.transform_figure, elem, doc)
+
+        elif isinstance(elem, Table):
+            elem = _run_action(self.transform_table, elem, doc)
+
+        # if isinstance(elem, Header):
+        #     return self.transform_header(elem, doc)
+        for processor in self.processors:
+            elem = _run_action(processor if callable(processor) else processor.action, elem, doc)
+
+        return elem
+
+    def finalize(self, doc):
+        for processor in self.processors:
+            if hasattr(processor, "finalize"):
+                processor.finalize(doc)
+
+    # def transform_header(self, elem, doc):
+    #     pass
+
+    def transform_table(self, elem, doc):
+        pass
+
+    def transform_figure(self, elem, doc):
+        pass
+
+
+filters = {}
+
+def register(name):
+    def decorator(filter):
+        filters[name] = filter
+        return filter
+
+default_filter = JournalFilter()
+filters["default"] = [default_filter]

texmark/templates/body.tex

@@ -0,0 +1 @@
+$body$

texmark/templates/copernicus/README_copernicus_package_7_11.txt

@@ -0,0 +1,22 @@
+File: README_copernicus_package_7_11.txt
+-------------------------------------------------------------------------
+This is a README file for the Copernicus Publications LaTeX Macro Package 
+copernicus_package.zip in the version 7.11, 9 April 2025
+-------------------------------------------------------------------------
+It consists of several files, each with its separate copyright.
+This specific archive is collected for journals published by 
+Copernicus Publications (Copernicus GmbH).
+
+Copyright (C) 2025 Copernicus GmbH
+
+E-mail: publications@copernicus.org
+URL:   	https://publications.copernicus.org
+
+
+
+Content:
+- copernicus.cls: The LaTeX2e class file designed for Copernicus Publications journals. Current Version 10.1.26, 14 March 2025
+- copernicus.cfg: The configuration file containing journal-specific information used by the class file. Last update 9 March 2024
+- copernicus.bst: The bibliographic style file for BibTeX. Current Version 1.6, 20 October 2023 
+- pdfscreencop.sty / pdfscreen.sty
+- template.tex: A LaTeX template in journal style.