obsitex 0.0.0__py3-none-any.whl

obsitex/__init__.py

@@ -0,0 +1 @@
+from obsitex.parser import ObsidianParser

obsitex/cli.py

@@ -0,0 +1,102 @@
+import argparse
+import logging
+from pathlib import Path
+
+from obsitex import ObsidianParser
+from obsitex.constants import DEFAULT_JINJA2_MAIN_TEMPLATE
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert Obsidian notes to LaTeX")
+
+    # Defines the inputs
+    parser.add_argument(
+        "--input",
+        "-i",
+        type=Path,
+        help="Path to the input file or folder containing the Obsidian notes.",
+        required=True,
+    )
+
+    parser.add_argument(
+        "--bibtex",
+        "-b",
+        type=Path,
+        help="Path to the BibTeX database file with all references.",
+    )
+    parser.add_argument(
+        "--graphics",
+        "-g",
+        type=Path,
+        help="Path to the graphics folder, where all images are assumed to be stored.",
+    )
+    parser.add_argument(
+        "--template",
+        "-t",
+        type=Path,
+        help="Path to the Jinja2 LaTeX template, won't use template if not provided.",
+    )
+
+    # Defines the outputs
+    parser.add_argument(
+        "--main-tex",
+        "-mt",
+        type=Path,
+        help="Path to the LaTeX file that will be generated, containing all compiled LaTeX.",
+        required=True,
+    )
+    parser.add_argument(
+        "--main-bibtex",
+        "-mb",
+        type=Path,
+        help="Path to the BibTeX file that will be generated, containing the references - only generated if citations are used.",
+    )
+
+    # Administrative options
+    parser.add_argument(
+        "--debug",
+        "-d",
+        action="store_true",
+        help="Enable debug mode, which will print additional information by enabling logging.",
+    )
+
+    args = parser.parse_args()
+
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+
+    if not args.input.exists():
+        raise FileNotFoundError(f"Input path {args.input} does not exist.")
+
+    # Read the template if it exists
+    if args.template is not None and args.template.is_file():
+        with open(args.template, "r") as file:
+            template = file.read()
+        logging.info(f"Using template from {args.template}.")
+    else:
+        template = DEFAULT_JINJA2_MAIN_TEMPLATE
+        logging.info("No template provided, using default template.")
+
+    # Create the parser
+    parser = ObsidianParser(
+        graphics_folder=args.graphics,
+        main_template=template,
+        bibtex_database_path=args.bibtex,
+        out_bitex_path=args.main_bibtex,
+    )
+
+    if args.input.is_dir():
+        parser.add_dir(args.input)
+    elif args.input.is_file():
+        parser.add_file(args.input)
+    else:
+        raise ValueError(f"Invalid path: {args.input}")
+
+    with open(args.main_tex, "w") as file:
+        file.write(parser.to_latex())
+
+    print(f"Output written to {args.main_tex}")
+
+
+if __name__ == "__main__":
+    main()

obsitex/constants.py

@@ -0,0 +1,41 @@
+DEFAULT_JINJA2_JOB_TEMPLATE = "{{ parsed_latex_content }}"
+DEFAULT_JINJA2_MAIN_TEMPLATE = """
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% This file was automatically generated by obsitex.
+%% A tool to convert Obsidian markdown files to LaTeX.
+%% https://github.com/ruipreis/obsitex
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+{{ parsed_latex_content }}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%% End of generated file
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+"""
+
+DEFAULT_HLEVEL_MAPPING = {
+    -2: "part",
+    -1: "chapter",
+    0: "section",
+    1: "subsection",
+    2: "subsubsection",
+    3: "paragraph",
+}
+
+# How markers are placed in parsed latex
+DEFAULT_APPENDIX_MARKER = """
+\\appendix
+"""
+
+DEFAULT_BIBLIOGRAPHY_MARKER = """
+\\bibliography{main}                         
+"""
+
+SPECIAL_CALLOUTS = [
+    "[!figure]",
+    "[!table]",
+    "[!chart]",
+]
+
+QUOTE_MARKER = "> "
+CALLOUT_CONFIG_MARKER = "%%"

obsitex/parser/__init__.py

@@ -0,0 +1,211 @@
+import logging
+from pathlib import Path
+from typing import Optional, Sequence
+
+import bibtexparser
+from jinja2 import Environment
+
+from obsitex.constants import (
+    DEFAULT_APPENDIX_MARKER,
+    DEFAULT_BIBLIOGRAPHY_MARKER,
+    DEFAULT_HLEVEL_MAPPING,
+    DEFAULT_JINJA2_JOB_TEMPLATE,
+    DEFAULT_JINJA2_MAIN_TEMPLATE,
+)
+from obsitex.parser.blocks import (
+    PARSEABLE_BLOCKS,
+    LaTeXBlock,
+    MarkerBlock,
+    Paragraph,
+    Section,
+)
+from obsitex.planner import ExecutionPlan
+from obsitex.planner.jobs import AddBibliography, AddHeader, AddText, PlannedJob
+
+# Increase logging level to bibtexparser - avoid warnings
+logging.getLogger("bibtexparser").setLevel(logging.ERROR)
+
+
+class ObsidianParser:
+    def __init__(
+        self,
+        bibtex_database_path: Optional[Path] = None,
+        implictly_add_bibtex: bool = True,
+        out_bitex_path: Optional[Path] = None,
+        graphics_folder: Optional[Path] = None,
+        job_template: str = DEFAULT_JINJA2_JOB_TEMPLATE,
+        main_template: str = DEFAULT_JINJA2_MAIN_TEMPLATE,
+        hlevel_mapping: dict = DEFAULT_HLEVEL_MAPPING,
+        appendix_marker: str = DEFAULT_APPENDIX_MARKER,
+        bibliography_marker: str = DEFAULT_BIBLIOGRAPHY_MARKER,
+        base_hlevel: int = 0,
+    ):
+        self.job_template = job_template
+        self.main_template = main_template
+        self.hlevel_mapping = hlevel_mapping
+        self.appendix_marker = appendix_marker
+        self.bibliography_marker = bibliography_marker
+        self.out_bitex_path = out_bitex_path
+
+        # Construct an execution plan, which will collect the jobs to run from
+        # the files and pths provided
+        self.execution_plan = ExecutionPlan(
+            bibtex_database_path=bibtex_database_path,
+            implictly_add_bibtex=implictly_add_bibtex,
+        )
+
+        # Extra arguments that should be injected when converting to latex
+        self.extra_args = {
+            "hlevel_mapping": self.hlevel_mapping,
+            "graphics_folder": graphics_folder,
+        }
+
+        # Flag to continuously check if in appendix
+        self.in_appendix = False
+
+        # Set of blocks that will be added to the main tex file
+        self.blocks: Sequence[LaTeXBlock] = []
+
+        # Keep track of the latest header level
+        self.base_hlevel = base_hlevel
+        self.latest_parsed_hlevel = base_hlevel
+
+    def add_file(self, file_path: Path, adjust_hlevel: bool = True):
+        # By default adding a file assumes a single file structure
+        if adjust_hlevel:
+            self.latest_parsed_hlevel = self.base_hlevel - 1
+
+        self.execution_plan.add_file(file_path)
+
+    def add_dir(self, dir_path: Path):
+        self.execution_plan.add_dir(dir_path)
+
+    def apply_jobs(self):
+        for job in self.execution_plan.iter_jobs():
+            self.parse_job(job)
+
+    def to_latex(self) -> str:
+        # Reset the parser blocks and apply
+        self.blocks = []
+        self.apply_jobs()
+
+        # Create template for job level and main
+        job_template = Environment().from_string(self.job_template)
+        main_template = Environment().from_string(self.main_template)
+
+        # Render each block onto the job template
+        rendered_blocks = "\n\n".join(
+            [
+                job_template.render(
+                    parsed_latex_content=block.formatted_text(**self.extra_args),
+                    **block.metadata,
+                )
+                for block in self.blocks
+            ]
+        )
+
+        # Render the main template with the rendered blocks
+        # the global variables are shared by all blocks, we use the first
+        # block for simplicity
+        if len(self.blocks) > 0:
+            global_configs = self.blocks[0].metadata
+        else:
+            global_configs = {}
+
+        return main_template.render(
+            parsed_latex_content=rendered_blocks,
+            **global_configs,
+        )
+
+    def parse_job(self, job: PlannedJob) -> str:
+        if not self.in_appendix:
+            self.in_appendix = job.is_in_appendix
+
+            # If in appendix, add the appendix marker
+            if self.in_appendix:
+                marker_block = MarkerBlock(self.appendix_marker)
+                marker_block.metadata = job.configs
+                self.blocks.append(marker_block)
+                logging.info("Added appendix marker to the parser.")
+
+        # Given a job, returns the corresponding latex code
+        if isinstance(job, AddHeader):
+            self.latest_parsed_hlevel = job.level
+            return self._parse_header(job)
+        elif isinstance(job, AddText):
+            return self._parse_text(job)
+        elif isinstance(job, AddBibliography):
+            return self._parse_bibliography(job)
+        else:
+            raise ValueError(f"Unknown job type {job}")
+
+    def _parse_header(self, job: AddHeader):
+        section_block = Section(job.level, job.header)
+        self.blocks.append(section_block)
+        logging.info(
+            f'Added header "{job.header}" with level {job.level} to the parser.'
+        )
+
+    def _parse_text(self, job: AddText):
+        lines = job.text.split("\n")
+        curr_i = 0
+        initial_block_count = len(self.blocks)
+
+        while curr_i < len(lines):
+            found_block = False
+
+            for block_class in PARSEABLE_BLOCKS:
+                block_instance = block_class.detect_block(lines, curr_i)
+
+                if block_instance is not None:
+                    block, curr_i = block_instance
+
+                    if isinstance(block, Section):
+                        block.hlevel += self.latest_parsed_hlevel
+
+                    found_block = True
+                    block.metadata = job.configs
+                    self.blocks.append(block)
+                    break
+
+            if not found_block:
+                # If remaining, assume it's a paragraph
+                paragraph_block = Paragraph(lines[curr_i])
+                paragraph_block.metadata = job.configs
+                self.blocks.append(paragraph_block)
+
+            curr_i += 1
+
+        logging.info(
+            f"Added {len(self.blocks) - initial_block_count} blocks to the parser, total {len(self.blocks)}."
+        )
+
+    def _parse_bibliography(self, job: AddBibliography):
+        if self.out_bitex_path is None:
+            raise ValueError("Bibliography was added but no output path was set.")
+
+        # Select the keys to be included in the bibliography, and export
+        with open(job.bibtex_path, "r") as file:
+            bib_database = bibtexparser.load(file)
+
+        # Index the bib tex keys and verify if all are present
+        bib_keys = {entry["ID"]: entry for entry in bib_database.entries}
+        missing_keys = [key for key in job.citations if key not in bib_keys]
+
+        if len(missing_keys) > 0:
+            raise ValueError(
+                f"Missing {len(missing_keys)} keys in bibliography: {missing_keys}"
+            )
+
+        # Write the selected entries to a new BibTeX file
+        new_db = bibtexparser.bparser.BibTexParser()  # Get a new BibDatabase instance
+        new_db.entries = [bib_keys[key] for key in job.citations]
+
+        with open(self.out_bitex_path, "w") as file:
+            bibtexparser.dump(new_db, file)
+
+        # Add the proper marker
+        marker_block = MarkerBlock(self.bibliography_marker)
+        marker_block.metadata = job.configs
+        self.blocks.append(marker_block)
+        logging.info("Added bibliography marker to the parser.")

obsitex/parser/blocks.py

@@ -0,0 +1,501 @@
+import re
+from abc import ABC, abstractmethod
+from io import StringIO
+from pathlib import Path
+from typing import Optional, Sequence, Tuple, Type
+
+import yaml
+
+from obsitex.constants import CALLOUT_CONFIG_MARKER, QUOTE_MARKER, SPECIAL_CALLOUTS
+from obsitex.parser.formatting import detect_command, find_next_index, format_text
+
+
+class LaTeXBlock(ABC):
+    def __init__(self, content, in_latex=False):
+        self.content = content
+        self.parent = None  # Only Section and Project objects can be parents
+        self.in_latex = in_latex
+        self._is_after_appendix = False
+        self.metadata = {}
+
+    @property
+    def is_after_appendix(self):
+        return self._is_after_appendix
+
+    @is_after_appendix.setter
+    def is_after_appendix(self, value):
+        self._is_after_appendix = value
+
+    def formatted_text(self, **kwargs):
+        if self.in_latex:
+            if isinstance(self.content, str):
+                return self.content
+            else:
+                return "\n".join(self.content)
+        else:
+            if isinstance(self.content, str):
+                text_lines = format_text([self.content])
+            else:
+                text_lines = format_text(self.content)
+
+        return "\n".join(text_lines)
+
+    @staticmethod
+    @abstractmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        """
+        Detects if the block is present in the lines starting from the index.
+
+        Returns the index of the last line of the block if the block is detected.
+        """
+        pass
+
+
+class Paragraph(LaTeXBlock):
+    def __init__(self, content):
+        super().__init__(content, in_latex=False)
+
+    @staticmethod
+    def detect_block(lines, index):
+        return None
+
+
+class MarkerBlock(LaTeXBlock):
+    def __init__(self, content):
+        super().__init__(content, in_latex=True)
+
+    # Used to inject latex code for flow control, e.g.: appendix, bibliography
+    @staticmethod
+    def detect_block(lines, index):
+        return None
+
+
+class Section(LaTeXBlock):
+    def __init__(self, hlevel: int, title: str):
+        super().__init__(None)
+        self.hlevel = hlevel
+        self.title = title
+
+    @property
+    def label(self):
+        reformatted_title = re.sub(r"\W", "_", self.title)
+        return f"sec:{reformatted_title}"
+
+    def __repr__(self):
+        return f'Section(hlevel={self.hlevel}, title="{self.title}")'
+
+    def formatted_text(self, **kwargs):
+        if "hlevel_mapping" not in kwargs:
+            raise ValueError("hlevel_mapping not provided in kwargs")
+        else:
+            hlevel_mapping = kwargs["hlevel_mapping"]
+
+        if self.hlevel not in hlevel_mapping:
+            raise ValueError(f"Header level {self.hlevel} not found in hlevel_mapping")
+
+        content = (
+            f"\\{hlevel_mapping[self.hlevel]}{{{self.title}}}\\label{{{self.label}}}"
+        )
+
+        return content
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["Section", int]]:
+        header_match = re.match(r"^(#+)\s*(.+)\s*", lines[index])
+
+        if header_match is not None:
+            hlevel = len(header_match.group(1))
+            title = header_match.group(2)
+
+            return Section(hlevel, title), index
+
+        return None
+
+
+class Equation(LaTeXBlock):
+    def __init__(self, content, label: Optional[str] = None):
+        super().__init__(content)
+        self.label = label
+
+    def formatted_text(self, **kwargs):
+        equation_text = "\\begin{equation}\n"
+
+        if self.label is not None:
+            equation_text += f"\t\\label{{{self.label}}}\n"
+
+        equation_text += f"\t{self.content}\n\\end{{equation}}\n"
+
+        return equation_text
+
+    def __repr__(self):
+        return f"Equation(content={self.content}, label={self.label})"
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        def _is_equation(line):
+            return line.startswith("$$")
+
+        if _is_equation(lines[index]):
+            # Get the label if it exists
+            label = detect_command(lines[index])
+
+            # Find the end of the equation
+            end_index = find_next_index(lines, _is_equation, index + 1)
+
+            # Extract the equation content
+            equation_content = "\n".join(lines[index + 1 : end_index])
+
+            return Equation(equation_content, label), end_index
+
+        return None
+
+
+class AbstractList(LaTeXBlock):
+    def __init__(self, lines: Sequence[str]):
+        super().__init__(lines)
+        self.lines = lines
+
+    @abstractmethod
+    def list_type(self):
+        pass
+
+    def formatted_text(self, **kwargs):
+        list_type = self.list_type()
+        content = f"\\begin{{{list_type}}}\n"
+
+        for line in format_text(self.lines):
+            content += f"\t\\item {line}\n"
+
+        content += f"\\end{{{list_type}}}\n"
+
+        return content
+
+    def __repr__(self):
+        return f"{self.list_type()} list (lines={self.lines})"
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str],
+        index: int,
+        item_regex_pattern: str,
+        instance_class: Type["LaTeXBlock"],
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        regex_pattern = item_regex_pattern
+
+        def _is_list_item(line):
+            return re.match(regex_pattern, line)
+
+        not_is_list_item = lambda line: not _is_list_item(line)
+
+        if _is_list_item(lines[index]):
+            # Find the end of the list
+            end_index = find_next_index(lines, not_is_list_item, index + 1)
+
+            # Extract the list content
+            item_lines = lines[index:end_index]
+
+            # Remove the list markers
+            list_content = [re.sub(regex_pattern, "", line) for line in item_lines]
+
+            return instance_class(list_content), end_index
+
+        return None
+
+
+class UnorderedList(AbstractList):
+    def list_type(self):
+        return "itemize"
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        return AbstractList.detect_block(lines, index, r"^-\s+", UnorderedList)
+
+
+class OrderedList(AbstractList):
+    def list_type(self):
+        return "enumerate"
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        return AbstractList.detect_block(lines, index, r"^\d+\.\s+", OrderedList)
+
+
+class Quote(LaTeXBlock):
+    def __init__(self, content):
+        super().__init__(content)
+        self.lines = content
+
+    def formatted_text(self, **kwargs):
+        content = "\\begin{displayquote}\n"
+
+        for line in format_text(self.lines):
+            content += f"\t{line}\n"
+
+        content += "\\end{displayquote}\n"
+
+        return content
+
+    def __repr__(self):
+        return f"Quote(content={self.content})"
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        def _is_quote(line):
+            return line.startswith(">")
+
+        if _is_quote(lines[index]) and not any(
+            v in lines[index] for v in SPECIAL_CALLOUTS
+        ):
+            end_index = find_next_index(
+                lines, lambda line: not _is_quote(line), index + 1
+            )
+            quote_lines = lines[index:end_index]
+            return Quote(quote_lines), end_index
+
+        return None
+
+
+class AbstractCallout(LaTeXBlock):
+    def __init__(self, caption: str, lines: Sequence[str], configs: dict):
+        super().__init__(lines)
+        self.caption = caption.strip()
+        self.lines = lines
+        self.configs = configs
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}(caption="{self.caption}", lines={self.lines}, configs={self.configs})'
+
+    @staticmethod
+    def detect_block(lines, index, callout: str, instance_class: Type["LaTeXBlock"]):
+        callout_pattern = re.compile(f"^>\s*\[!{callout}\]\s*(.*)\s*")
+        re_match = callout_pattern.match(lines[index])
+
+        if re_match is not None:
+            caption = re_match.group(1)
+            end_index = find_next_index(
+                lines, lambda line: not line.startswith(">"), index + 1
+            )
+            callout_lines = lines[index + 1 : end_index]
+
+            # Remove config marker from all
+            callout_lines = [l.replace(QUOTE_MARKER, "") for l in callout_lines]
+
+            # Might contain configurations in the callout, need to confirm
+            start_config_marker_index = find_next_index(
+                callout_lines, lambda line: line.startswith(CALLOUT_CONFIG_MARKER), 0
+            )
+
+            if start_config_marker_index < len(callout_lines):
+                # Then there could be properties
+                end_config_marker_index = find_next_index(
+                    callout_lines,
+                    lambda line: line.startswith(CALLOUT_CONFIG_MARKER),
+                    start_config_marker_index + 1,
+                )
+                config_lines = callout_lines[
+                    start_config_marker_index + 1 : end_config_marker_index
+                ]
+
+                try:
+                    configs = yaml.safe_load("\n".join(config_lines))
+                except:
+                    raise ValueError(
+                        f"Could not parse configurations in callout ({callout}): {config_lines}"
+                    )
+
+                # Change the end of the call out lines
+                callout_lines = callout_lines[:start_config_marker_index]
+            else:
+                configs = {}
+
+            return instance_class(caption, callout_lines, configs), end_index
+
+
+class Table(AbstractCallout):
+    def __init__(self, caption: str, lines: Sequence[str], configs: dict):
+        super().__init__(caption, lines, configs)
+
+        try:
+            import pandas as pd
+        except:
+            raise ImportError(
+                "You defined a table, but pandas is not installed. Please install pandas to use tables."
+            )
+
+        # Parse the table
+        table_content = "\n".join(format_text(self.lines))
+
+        df = (
+            pd.read_table(StringIO(table_content), sep="|", engine="python")
+            .dropna(how="all", axis=1)
+            .dropna(how="all")
+        )
+
+        # Clean up column names and content (strip leading/trailing whitespace)
+        df.columns = df.columns.str.strip()
+        df = df.apply(lambda x: x.str.strip() if x.dtype == "object" else x)
+
+        # Step 2: Filter out any rows filled with '----' (typically separators)
+        df = df[~df.apply(lambda row: row.str.contains("----").any(), axis=1)]
+
+        self.df = df
+
+        # Check for latex specific configurations in the configs
+        position = self.configs.get("position", None)
+        column_format = self.configs.get(
+            "column_format", "l" + "r" * (len(df.columns) - 1)
+        )
+        centering = self.configs.get("centering", True)
+
+        self.latex_content = df.to_latex(
+            index=False,
+            caption=caption,
+            position=position,
+            column_format=column_format,
+        )
+
+        if centering:
+            split_latex_content = self.latex_content.split("\n")
+            split_latex_content.insert(1, "\\centering")
+            self.latex_content = "\n".join(split_latex_content)
+
+    def formatted_text(self, **kwargs):
+        return self.latex_content
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        return AbstractCallout.detect_block(lines, index, "table", Table)
+
+
+class Figure(AbstractCallout):
+    def __init__(self, caption: str, lines: Sequence[str], configs: dict):
+        super().__init__(caption, lines, configs)
+        self.target_image = re.match(r"\s*\!\[\[(.*?)\]\]", self.lines[0])
+
+        if self.target_image is None:
+            raise ValueError(f"Could not find image in callout: {self.lines[0]}")
+
+        self.target_image = self.target_image.group(1)
+        self.target_image = self.target_image.split("|")[0]
+        self.target_image = self.target_image.split("/")[-1]
+
+        # Figure latex configs
+        self.label = self.configs.get("label", None)
+        self.position = self.configs.get("position", None)
+        self.centering = self.configs.get("centering", True)
+        self.width = self.configs.get("width", 0.5)
+
+    def formatted_text(self, **kwargs):
+        graphics_foler: Optional[Path] = kwargs.get("graphics_folder", None)
+
+        if graphics_foler is None:
+            raise ValueError(
+                "You defined a figure, but no graphics folder was provided."
+            )
+
+        image_path = (graphics_foler / self.target_image).resolve()
+
+        if not image_path.exists():
+            raise FileNotFoundError(f"Could not find image {image_path}")
+
+        content = "\\begin{figure}"
+
+        if self.position is not None:
+            content += f"[{self.position}]"
+
+        content += "\n"
+
+        if self.centering:
+            content += "\\centering\n"
+
+        content += f"\\includegraphics[width={self.width}\\textwidth]{{{image_path}}}\n"
+
+        # Format the caption, since it might contain citations
+        caption = format_text([self.caption])[0]
+        content += f"\\caption{{{caption}}}\n"
+
+        if self.label is not None:
+            content += f"\\label{{fig:{self.label}}}\n"
+
+        content += "\\end{figure}\n"
+
+        return content
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        return AbstractCallout.detect_block(lines, index, "figure", Figure)
+
+
+class RawLaTeXBlock(LaTeXBlock):
+    def __init__(self, content):
+        super().__init__(content, in_latex=True)
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        if lines[index].startswith("```latex"):
+            end_index = find_next_index(
+                lines, lambda line: line.startswith("```"), index + 1
+            )
+            raw_lines = lines[index + 1 : end_index]
+            return RawLaTeXBlock(raw_lines), end_index
+
+        return None
+
+
+class TikZBlock(LaTeXBlock):
+    def __init__(self, content):
+        super().__init__(content, in_latex=True)
+
+    @staticmethod
+    def detect_block(
+        lines: Sequence[str], index: int
+    ) -> Optional[Tuple["LaTeXBlock", int]]:
+        if lines[index].startswith("```tikz"):
+            end_index = find_next_index(
+                lines, lambda line: line.startswith("```"), index + 1
+            )
+            raw_lines = lines[index + 1 : end_index]
+            tikz_content = "\n".join(raw_lines)
+
+            # Remove tikz directive that are necessary to render in obsidian
+            tikz_content = tikz_content.replace("\\begin{document}", "")
+            tikz_content = tikz_content.replace("\\end{document}", "")
+
+            # Filter out any sort of usepackage
+            tikz_content = re.sub(r"\\usepackage.*\n", "", tikz_content)
+            tikz_content = re.sub(r"\\usetikzlibrary.*\n", "", tikz_content)
+
+            return TikZBlock(tikz_content), end_index
+
+        return None
+
+
+PARSEABLE_BLOCKS: Sequence[Type[LaTeXBlock]] = [
+    Section,
+    Equation,
+    UnorderedList,
+    OrderedList,
+    Table,
+    Quote,
+    Figure,
+    RawLaTeXBlock,
+    TikZBlock,
+]

obsitex/parser/formatting.py

@@ -0,0 +1,100 @@
+import copy
+import re
+from typing import Optional
+
+LATEX_SPECIAL_CHARS = r"$%_}&#{"
+
+
+def find_next_index(lst, expr, start=0):
+    for i in range(start, len(lst)):
+        if expr(lst[i]):
+            return i
+    return len(lst)
+
+
+def detect_command(line) -> Optional[str]:
+    match = re.match(r"\%\%\s*(.*)\s*\%\%", line)
+    command = None
+
+    if match is not None:
+        command = match.group(1)
+
+    return command
+
+
+# Function to group citations and replace
+def replace_adjacent_citations(text):
+    # Regex pattern to match adjacent citations
+    pattern_adjacent = r"(\[\[@[^\]]+?\]\](\s*,\s*)*)*\[\[@[^\]]+?\]\]"
+
+    # Find all matches for adjacent citations
+    matches = re.finditer(pattern_adjacent, text)
+
+    # Process each match
+    for match in matches:
+        # Extract the full matched string (group of adjacent citations)
+        full_match = match.group(0)
+
+        # Extract individual citations and combine them
+        citations = re.findall(r"\[\[@([^\]]+?)\]\]", full_match)
+        combined_citations = ",".join(citations)
+
+        # Replace the full matched string with the combined citations
+        text = text.replace(full_match, f"\\citep{{{combined_citations}}}")
+
+    return text
+
+
+def format_text(text_lines_origin):
+    # Inspired by Alejandro Daniel Noel
+    # In his code https://github.com/adanielnoel/Obsidian-to-latex/blob/master/parser_utils.py
+    # Modified by me to fit the needs of this project
+    text_lines = copy.deepcopy(text_lines_origin)
+
+    for i in range(len(text_lines)):
+        # ===== SPECIAL CHARACTERS =====
+        # Extract and replace by placeholders equations and links before making formatting
+        equations = re.findall(r"\$.*?\$", text_lines[i])
+        links = re.findall(r"\[\[.*?]]", text_lines[i])
+        codes = re.findall(r"`.*?`", text_lines[i])
+        text_lines[i] = re.sub(r"\$.*?\$", "<EQ-PLACEHOLDER>", text_lines[i])
+        text_lines[i] = re.sub(r"\[\[.*?]]", "<LINK-PLACEHOLDER>", text_lines[i])
+        text_lines[i] = re.sub(r"`.*?`", "<CODE-PLACEHOLDER>", text_lines[i])
+        # Format special chars that need to be escaped
+        for special_char in LATEX_SPECIAL_CHARS:
+            text_lines[i] = text_lines[i].replace(special_char, f"\\{special_char}")
+        # Put square brackets in a group so that they are not parsed in latex as block arguments
+        text_lines[i] = re.sub(r"(?<!\[)(\[.*])(?!])", r"{\1}", text_lines[i])
+        # put back equations and links
+        for link in links:
+            text_lines[i] = text_lines[i].replace(r"<LINK-PLACEHOLDER>", link, 1)
+        for equation in equations:
+            text_lines[i] = text_lines[i].replace(r"<EQ-PLACEHOLDER>", equation, 1)
+        for code in codes:
+            text_lines[i] = text_lines[i].replace(r"<CODE-PLACEHOLDER>", code, 1)
+
+        # Replace Markdown figure references by Latex references
+        text_lines[i] = re.sub(r"`(fig:\S*?)`", r"\\autoref{\1}", text_lines[i])
+        # Replace Markdown equation references by Latex references
+        text_lines[i] = re.sub(r"`(eq:\S*?)`", r"\\autoref{\1}", text_lines[i])
+        # Replace the markdown algorithm references by Latex references
+        text_lines[i] = re.sub(r"`(alg:\S*?)`", r"\\autoref{\1}", text_lines[i])
+
+        # ===== TEXT FORMATTING =====
+        # Replace Markdown monospace by latex monospace (note: do after other code blocks like refs and citations)
+        text_lines[i] = re.sub(r"`(.*?)`", r"\\texttt{\1}", text_lines[i])
+        # Replace Markdown italics with quote marks by Latex text quote
+        text_lines[i] = re.sub(
+            r'(?<!\*)\*"([^\*].*?)"\*(?!\*)', r"\\textquote{\1}", text_lines[i]
+        )
+        # Replace Markdown italics by Latex italics
+        text_lines[i] = re.sub(
+            r"(?<!\*)\*([^\*].*?)\*(?!\*)", r"\\textit{\1}", text_lines[i]
+        )
+        # Replace Markdown bold by Latex bold
+        text_lines[i] = re.sub(r"\*\*([^\*].*?)\*\*", r"\\textbf{\1}", text_lines[i])
+        # Replace Markdown highlight by Latex highlight
+        text_lines[i] = re.sub(r"==([^=].*?)==", r"\\hl{\1}", text_lines[i])
+        text_lines[i] = replace_adjacent_citations(text_lines[i])
+
+    return text_lines

obsitex/planner/__init__.py

@@ -0,0 +1,259 @@
+import logging
+import re
+from pathlib import Path
+from typing import Optional, Sequence, Set, Tuple
+
+import yaml
+
+from obsitex.planner.jobs import AddBibliography, AddHeader, AddText, PlannedJob
+from obsitex.planner.links import find_all_citations, find_all_links
+from obsitex.utils import assure_dir, assure_file, read_file
+
+
+def parse_yaml_properties(text: str) -> Tuple[str, dict]:
+    properties = {}
+
+    if text.startswith("---"):
+        # Find the end of the properties
+        end_properties = text.find("---", 3)
+
+        # Remove the properties from the file contents
+        yaml_configs = text[3:end_properties]
+
+        # Try to load the properties, if it doesn't work, ignore
+        properties = yaml.safe_load(yaml_configs)
+
+        # Clean the props from the text
+        text = text[end_properties + 3 :].strip()
+
+    return text, properties
+
+
+class ExecutionPlan:
+    def __init__(
+        self,
+        bibtex_database_path: Optional[Path] = None,
+        implictly_add_bibtex: bool = True,
+    ):
+        self.bibtex_database_path = bibtex_database_path
+        self.implictly_add_bibtex = implictly_add_bibtex
+
+        # Check that if the paths are provided, they are valid
+        assure_file(self.bibtex_database_path)
+
+        # Variables to store extracted data
+        self._citation_keys: Set[str] = set()
+        self._n_files_read = 0
+
+        # Used to specify the jobs that will run in the execution plan
+        self._jobs: Sequence[PlannedJob] = []
+
+    @property
+    def n_files_read(self) -> int:
+        return self._n_files_read
+
+    @property
+    def num_headers(self) -> int:
+        return len([job for job in self._jobs if isinstance(job, AddHeader)])
+
+    def iter_jobs(self):
+        # Find the first job in the appendix
+        appendix_job_idx = None
+
+        for idx, job in enumerate(self._jobs):
+            if job.is_in_appendix:
+                appendix_job_idx = idx
+                break
+
+        if appendix_job_idx is None:
+            appendix_job_idx = len(self._jobs)
+
+        # Iter through the non appendix job, add bibliography job and then the appendix jobs
+        for job in self._jobs[:appendix_job_idx]:
+            yield job
+
+        # When this is called, it's assumed that all files have been added
+        # to the execution plan. Thus we need to check if we should add the bibliography
+        # here or not. - should always be the last job
+        if self.implictly_add_bibtex and len(self._citation_keys) > 0:
+            if (
+                self.bibtex_database_path is None
+                or not self.bibtex_database_path.is_file()
+            ):
+                raise FileNotFoundError(
+                    f"BibTeX database not found at {self.bibtex_database_path}, please provide a valid path if you're using citations."
+                )
+
+            add_bib_job = AddBibliography(
+                self._citation_keys, self.bibtex_database_path
+            )
+            yield add_bib_job
+
+        for job in self._jobs[appendix_job_idx:]:
+            job.mark_as_appendix()
+            yield job
+
+    def add_citations(self, text: str):
+        self._citation_keys.update(find_all_citations(text))
+
+    def add_file(self, file_path: Path):
+        assure_file(file_path)
+
+        # Read the file contents
+        file_contents = read_file(file_path)
+        self._n_files_read += 1
+
+        # Extract citations from the file
+        self.add_citations(file_contents)
+
+        # If exist, parse the YAML properties
+        try:
+            file_contents, properties = parse_yaml_properties(file_contents)
+        except:
+            logging.error(
+                f"Error parsing YAML properties from {file_path}, ignoring..."
+            )
+            properties = {}
+
+        # Single files have no deps
+        add_text_job = AddText(file_contents)
+        add_text_job.update_configs(properties)
+
+        self._jobs.append(add_text_job)
+
+    def add_dir(
+        self,
+        dir_path: Path,
+        index_file: Optional[str] = None,
+        max_depth: int = 10,
+        base_hlevel: int = -2,
+    ):
+        assure_dir(dir_path)
+
+        if index_file is None:
+            index_file = "Index"
+
+        # Perform depth-first search to find all files
+        # Base hlevel is -1 because index doesn't produce headers
+        stack = [(dir_path, index_file, base_hlevel - 1, 0)]
+        global_configs, is_index = {}, True
+
+        while len(stack) > 0:
+            current_base_path, current_file, current_hlevel, current_depth = stack.pop()
+
+            if current_depth < max_depth:
+                file_contents = read_file(current_base_path / f"{current_file}.md")
+                self._n_files_read += 1
+
+                # Each file can have properties configured in YAML
+                properties = {}
+
+                # Find all links are remove them from the text
+                clean_text, links = find_all_links(file_contents)
+
+                if clean_text != "":
+                    try:
+                        clean_text, properties = parse_yaml_properties(clean_text)
+                    except:
+                        logging.error(
+                            f"Error parsing YAML properties from {current_file}.md, ignoring..."
+                        )
+                        properties = {}
+
+                    if is_index:
+                        global_configs.update(properties)
+
+                if not is_index:
+                    properties.update(global_configs)
+
+                # If not the index file, add a header
+                if current_hlevel >= base_hlevel:
+                    add_header_job = AddHeader(current_file, current_hlevel)
+                    add_header_job.update_configs(properties)
+
+                    self._jobs.append(add_header_job)
+
+                if clean_text != "":
+                    add_text_job = AddText(clean_text)
+                    add_text_job.update_configs(properties)
+
+                    self._jobs.append(add_text_job)
+                    self.add_citations(clean_text)
+
+                for link in reversed(links):
+                    # Might be pointing to a file in the same folder
+                    # or a subdirectory
+                    new_base_path = current_base_path / link
+
+                    if not new_base_path.is_dir():
+                        new_base_path = current_base_path
+
+                        if not (new_base_path / f"{link}.md").is_file():
+                            raise ValueError(
+                                f"File {link} not found in {new_base_path}"
+                            )
+
+                    stack.append(
+                        (new_base_path, link, current_hlevel + 1, current_depth + 1)
+                    )
+            else:
+                raise ValueError(
+                    f"Max depth of {max_depth} reached, please check for cycles in your links."
+                )
+
+            if is_index:
+                is_index = False
+
+        logging.info(f"Added {len(self._jobs)} jobs to the execution plan.")
+
+    def show(self, text_limit: int = 50, show_configs: bool = False):
+        for order, job in enumerate(self._jobs, start=1):
+            if isinstance(job, AddText):
+                if text_limit >= 0:
+                    text_content = job.text[:text_limit]
+                logging.info(f"{order}. Adding text: {text_content}...")
+            elif isinstance(job, AddHeader):
+                logging.info(
+                    f"{order}. Adding header: {job.header} with level {job.level}..."
+                )
+            else:
+                logging.warning(f"{order}. Unknown job type: {job}")
+
+        logging.info(f"Printing table of contents...")
+
+        if self.num_headers == 0:
+            hlevel_zero_adjusted = 0
+        else:
+            hlevel_zero_adjusted = min(
+                [job.level for job in self._jobs if isinstance(job, AddHeader)]
+            )
+
+            if hlevel_zero_adjusted < 0:
+                hlevel_zero_adjusted = -hlevel_zero_adjusted
+
+            # Used for add text jobs to know the header level above
+            prev_header_level = 0
+            header_regex = r"(#+)\s*(.+)\s*\n"
+            tob_content = []
+
+            for job in self._jobs:
+                if isinstance(job, AddHeader):
+                    level = job.level + hlevel_zero_adjusted + 1
+                    title = job.header
+                    prev_header_level = level
+                    tob_content.append((level, title, job.configs))
+                elif isinstance(job, AddText):
+                    level = prev_header_level
+
+                    # Find all the headers contains inside
+                    headers_in_text = re.findall(header_regex, job.text)
+
+                    for header_level, header_title in headers_in_text:
+                        level = len(header_level) + prev_header_level
+                        tob_content.append((level, header_title, None))
+
+            for level, header, configs in tob_content:
+                if configs is not None and show_configs:
+                    logging.info(f"{' '*(level-1)}| {header} {configs}")
+                else:
+                    logging.info(f"{' '*(level-1)}| {header}")

obsitex/planner/jobs.py

@@ -0,0 +1,38 @@
+from abc import ABC
+from pathlib import Path
+from typing import Set
+
+
+class PlannedJob(ABC):
+    def __init__(self):
+        self.configs = {}
+
+    def update_configs(self, kwargs: dict):
+        self.configs.update(kwargs)
+
+    @property
+    def is_in_appendix(self) -> bool:
+        return self.configs.get("appendix", False)
+
+    def mark_as_appendix(self):
+        self.configs["appendix"] = True
+
+
+class AddText(PlannedJob):
+    def __init__(self, text: str):
+        super().__init__()
+        self.text = text
+
+
+class AddHeader(PlannedJob):
+    def __init__(self, header: str, level: int):
+        super().__init__()
+        self.header = header
+        self.level = level
+
+
+class AddBibliography(PlannedJob):
+    def __init__(self, citations: Set[str], bibtex_path: Path):
+        super().__init__()
+        self.citations = citations
+        self.bibtex_path = bibtex_path

obsitex/planner/links.py

@@ -0,0 +1,36 @@
+import re
+from typing import Any, Sequence, Set, Tuple
+
+
+def find_all_citations(text: str) -> Set[Any]:
+    # Regex pattern to match each citation tag
+    citation_pattern = r"\[\[@([^\]]+?)\]\]"
+    matches = re.findall(citation_pattern, text)
+
+    # Return a set of unique citation keys
+    return set(matches)
+
+
+def find_all_links(text: str) -> Tuple[str, Sequence[str]]:
+    link_regex = r"(?<!\!)\[\[(.*?)\]\]"
+    all_links = re.findall(link_regex, text)
+
+    # Filter out links starting with @, which are used for citations
+    all_links = [link for link in all_links if not link.startswith("@")]
+    resulting_links = []
+
+    for link in all_links:
+        if "|" in link:
+            resulting_links.append(link.split("|")[1])
+        elif "/" in link:
+            resulting_links.append(link.split("/")[-1])
+        else:
+            resulting_links.append(link)
+
+    # Remove links from original text
+    for link in all_links:
+        text = text.replace(f"[[{link}]]", "")
+
+    text = text.strip()
+
+    return text, resulting_links

obsitex/utils.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from typing import Optional
+
+
+def assure_dir(path: Optional[Path]):
+    if path is not None and not path.is_dir():
+        raise ValueError(f"Path {path} is not a directory.")
+
+
+def assure_file(path: Optional[Path]):
+    if path is not None and not path.is_file():
+        raise ValueError(f"Path {path} is not a file.")
+
+
+def read_file(file_path: Path) -> str:
+    assure_file(file_path)
+
+    with open(file_path, "r") as file:
+        return file.read()

obsitex-0.0.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: obsitex
+Version: 0.0.0
+Author: Rui Reis
+Author-email: ruipedronetoreis12@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Requires-Dist: Jinja2 >=3.1.2
+Requires-Dist: bibtexparser >=1.4.3
+Requires-Dist: pandas >=2.1.3
+

obsitex-0.0.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+obsitex/__init__.py,sha256=w-YmpYAdbQPyJqO1JLEaRApy1M_FzAH7nN4VvlQku-U,42
+obsitex/cli.py,sha256=otjRQIoidXecJFQs6WCPFRUv8njgieEULQzJfMZMLYY,2797
+obsitex/constants.py,sha256=dgMZjokPOYHLLOvDbsOM4XiQvOK26BAHmRdeWHn8DTE,970
+obsitex/utils.py,sha256=hqLRvuaQx_Y5rVY8B8lD6rbkMagoc3MBtswwdt_34f0,481
+obsitex/parser/__init__.py,sha256=FPcfq6MaVpxyrhrdfWRVNSzdE9Gz9DUOh_DPlahYsEc,7494
+obsitex/parser/blocks.py,sha256=q7LJcctsM32sh5iR5Bp5aa2e1kLucRwT4IGnlEsqOyA,15525
+obsitex/parser/formatting.py,sha256=kfb_7PbdbW1QwE4HDbFrxkINejTOzwZqilgY1JCEZVE,4204
+obsitex/planner/__init__.py,sha256=4yf4scYeQ_jNO6nQZ0BboyILoA7su0LOe0KIrnCzn6U,9207
+obsitex/planner/jobs.py,sha256=UOnGMBlQFWy2nl7Zo_LcwNUiN9eqmdmhu8KeJnKWDjI,882
+obsitex/planner/links.py,sha256=SJqnJzyg2EtiZgtfZhzVBpqTVUSy87YZRObgltDv10M,1045
+obsitex-0.0.0.dist-info/METADATA,sha256=OQzNIbu1fSZSSJmjKewEdawlYzYsiYKMIofC2GvbSIw,326
+obsitex-0.0.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+obsitex-0.0.0.dist-info/entry_points.txt,sha256=0LF5Zjk-yBhL6_2o7JGiIXthwkGyhT4Snf4Waz2wRDA,45
+obsitex-0.0.0.dist-info/top_level.txt,sha256=Mi24FWCjxDXVa3wNtCN0NuT_dRgyN5haGA4IE8oHeLQ,8
+obsitex-0.0.0.dist-info/RECORD,,

obsitex-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

obsitex-0.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+obsitex = obsitex.cli:main

obsitex-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+obsitex