Initial integration

docs/install_ocrmypdf.md

@@ -1,29 +0,0 @@
-## Linux
-
-- Run `apt-get install ocrmypdf`
-- Install ghostscript > 9.55 by following [these instructions](https://ghostscript.readthedocs.io/en/latest/Install.html) or running `scripts/install/ghostscript_install.sh`.
-- Run `pip install ocrmypdf`
-- Install any tesseract language packages that you want (example `apt-get install tesseract-ocr-eng`)
-- Set the tesseract data folder path
-  - Find the tesseract data folder `tessdata` with `find / -name tessdata`.  Make sure to use the one corresponding to the latest tesseract version if you have multiple.
-  - Create a `local.env` file in the root `marker` folder with `TESSDATA_PREFIX=/path/to/tessdata` inside it
-
-## Mac
-
-Only needed if using `ocrmypdf` as the ocr backend.
-
-- Run `brew install ocrmypdf`
-- Run `brew install tesseract-lang` to add language support
-- Run `pip install ocrmypdf`
-- Set the tesseract data folder path
-  - Find the tesseract data folder `tessdata` with `brew list tesseract`
-  - Create a `local.env` file in the root `marker` folder with `TESSDATA_PREFIX=/path/to/tessdata` inside it
-
-## Windows
-
-- Install `ocrmypdf` and ghostscript by following [these instructions](https://ocrmypdf.readthedocs.io/en/latest/installation.html#installing-on-windows)
-- Run `pip install ocrmypdf`
-- Install any tesseract language packages you want
-- Set the tesseract data folder path
-  - Find the tesseract data folder `tessdata` with `brew list tesseract`
-  - Create a `local.env` file in the root `marker` folder with `TESSDATA_PREFIX=/path/to/tessdata` inside it

marker/{v2/builders → builders}/__init__.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from marker.v2.util import assign_config
+from marker.util import assign_config
 
 
 class BaseBuilder:

marker/{v2/builders → builders}/document.py

@@ -1,15 +1,18 @@
 from marker.settings import settings
-from marker.v2.builders import BaseBuilder
-from marker.v2.builders.layout import LayoutBuilder
-from marker.v2.builders.ocr import OcrBuilder
-from marker.v2.providers.pdf import PdfProvider
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
-from marker.v2.schema.groups.page import PageGroup
-from marker.v2.schema.registry import get_block_class
+from marker.builders import BaseBuilder
+from marker.builders.layout import LayoutBuilder
+from marker.builders.ocr import OcrBuilder
+from marker.providers.pdf import PdfProvider
+from marker.schema import BlockTypes
+from marker.schema.document import Document
+from marker.schema.groups.page import PageGroup
+from marker.schema.registry import get_block_class
 
 
 class DocumentBuilder(BaseBuilder):
+    lowres_image_dpi: int = 96
+    highres_image_dpi: int = 192
+
     def __call__(self, provider: PdfProvider, layout_builder: LayoutBuilder, ocr_builder: OcrBuilder):
         document = self.build_document(provider)
         layout_builder(document, provider)
@@ -21,8 +24,8 @@ class DocumentBuilder(BaseBuilder):
         initial_pages = [
             PageGroupClass(
                 page_id=i,
-                lowres_image=provider.get_image(i, settings.IMAGE_DPI),
-                highres_image=provider.get_image(i, settings.HIGHRES_IMAGE_DPI),
+                lowres_image=provider.get_image(i, self.lowres_image_dpi),
+                highres_image=provider.get_image(i, self.highres_image_dpi),
                 polygon=provider.get_page_bbox(i)
             ) for i in provider.page_range
         ]

marker/{v2/builders → builders}/layout.py

@@ -5,14 +5,14 @@ from surya.schema import LayoutResult
 from surya.model.layout.encoderdecoder import SuryaLayoutModel
 
 from marker.settings import settings
-from marker.v2.builders import BaseBuilder
-from marker.v2.providers import ProviderOutput, ProviderPageLines
-from marker.v2.providers.pdf import PdfProvider
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
-from marker.v2.schema.groups.page import PageGroup
-from marker.v2.schema.polygon import PolygonBox
-from marker.v2.schema.registry import get_block_class
+from marker.builders import BaseBuilder
+from marker.providers import ProviderOutput, ProviderPageLines
+from marker.providers.pdf import PdfProvider
+from marker.schema import BlockTypes
+from marker.schema.document import Document
+from marker.schema.groups.page import PageGroup
+from marker.schema.polygon import PolygonBox
+from marker.schema.registry import get_block_class
 
 
 class LayoutBuilder(BaseBuilder):

marker/{v2/builders → builders}/ocr.py

@@ -3,15 +3,15 @@ from surya.model.recognition.encoderdecoder import OCREncoderDecoderModel
 from surya.ocr import run_ocr
 
 from marker.settings import settings
-from marker.v2.builders import BaseBuilder
-from marker.v2.providers import ProviderOutput, ProviderPageLines
-from marker.v2.providers.pdf import PdfProvider
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
-from marker.v2.schema.polygon import PolygonBox
-from marker.v2.schema.registry import get_block_class
-from marker.v2.schema.text.line import Line
-from marker.v2.schema.text.span import Span
+from marker.builders import BaseBuilder
+from marker.providers import ProviderOutput, ProviderPageLines
+from marker.providers.pdf import PdfProvider
+from marker.schema import BlockTypes
+from marker.schema.document import Document
+from marker.schema.polygon import PolygonBox
+from marker.schema.registry import get_block_class
+from marker.schema.text.line import Line
+from marker.schema.text.span import Span
 
 
 class OcrBuilder(BaseBuilder):

marker/{v2/builders → builders}/structure.py

@@ -1,9 +1,9 @@
-from marker.v2.builders import BaseBuilder
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
-from marker.v2.schema.groups import ListGroup
-from marker.v2.schema.groups.page import PageGroup
-from marker.v2.schema.registry import get_block_class
+from marker.builders import BaseBuilder
+from marker.schema import BlockTypes
+from marker.schema.document import Document
+from marker.schema.groups import ListGroup
+from marker.schema.groups.page import PageGroup
+from marker.schema.registry import get_block_class
 
 
 class StructureBuilder(BaseBuilder):

marker/cleaners/bullets.py

@@ -1,8 +0,0 @@
-import re
-
-
-def replace_bullets(text):
-    # Replace bullet characters with a -
-    bullet_pattern = r"(^|[\n ])[•●○■▪▫–—]( )"
-    replaced_string = re.sub(bullet_pattern, r"\1-\2", text)
-    return replaced_string

marker/cleaners/code.py

@@ -1,131 +0,0 @@
-from collections import Counter
-from statistics import mean, median
-
-from marker.schema.block import Span, Line
-from marker.schema.page import Page
-import re
-from typing import List
-
-
-def is_code_linelen(lines, thresh=80):
-    # Decide based on chars per newline threshold
-    total_alnum_chars = sum(len(re.findall(r'\w', line.prelim_text)) for line in lines)
-    total_newlines = max(len(lines) - 1, 1)
-
-    if total_alnum_chars == 0:
-        return False
-
-    ratio = total_alnum_chars / total_newlines
-    return ratio < thresh
-
-
-def comment_count(lines):
-    pattern = re.compile(r"^(//|#|'|--|/\*|'''|\"\"\"|--\[\[|<!--|%|%{|\(\*)")
-    return sum([1 for line in lines if pattern.match(line)])
-
-
-def identify_code_blocks(pages: List[Page]):
-    code_block_count = 0
-    font_sizes = []
-    line_heights = []
-    for page in pages:
-        font_sizes += page.get_font_sizes()
-        line_heights += page.get_line_heights()
-
-    avg_font_size = None
-    avg_line_height = None
-    if len(font_sizes) > 0:
-        avg_line_height = median(line_heights)
-        avg_font_size = mean(font_sizes)
-
-    for page in pages:
-        for block in page.blocks:
-            if block.block_type != "Text":
-                last_block = block
-                continue
-
-            # Ensure we have lines and spans
-            if len(block.lines) == 0:
-                continue
-            if sum([len(line.spans) for line in block.lines]) == 0:
-                continue
-
-            min_start = block.get_min_line_start()
-
-            is_indent = []
-            line_fonts = []
-            line_font_sizes = []
-            block_line_heights = []
-            for line in block.lines:
-                line_fonts += [span.font for span in line.spans]
-                line_font_sizes += [span.font_size for span in line.spans]
-                block_line_heights.append(line.bbox[3] - line.bbox[1])
-
-                is_indent.append(line.bbox[0] > min_start)
-
-            comment_lines = comment_count([line.prelim_text for line in block.lines])
-            is_code = [
-                len(block.lines) > 3,
-                is_code_linelen(block.lines),
-                sum(is_indent) + comment_lines > len(block.lines) * .7, # Indentation and comments are a majority
-            ]
-
-            if avg_font_size is not None:
-                font_checks = [
-                    mean(line_font_sizes) <= avg_font_size * .8, # Lower than average font size and line height
-                    mean(block_line_heights) < avg_line_height * .8
-                ]
-                is_code += font_checks
-
-            if all(is_code):
-                code_block_count += 1
-                block.block_type = "Code"
-
-    return code_block_count
-
-
-def indent_blocks(pages: List[Page]):
-    span_counter = 0
-    for page in pages:
-        for block in page.blocks:
-            if block.block_type != "Code":
-                continue
-
-            lines = []
-            min_left = 1000  # will contain x- coord of column 0
-            col_width = 0  # width of 1 char
-            for line in block.lines:
-                text = ""
-                min_left = min(line.bbox[0], min_left)
-                for span in line.spans:
-                    if col_width == 0 and len(span.text) > 0:
-                        col_width = (span.bbox[2] - span.bbox[0]) / len(span.text)
-                    text += span.text
-                lines.append((line.bbox, text))
-
-            block_text = ""
-            blank_line = False
-            for line in lines:
-                text = line[1]
-                if col_width == 0:
-                    prefix = ""
-                else:
-                    prefix = " " * int((line[0][0] - min_left) / col_width)
-                current_line_blank = len(text.strip()) == 0
-                if blank_line and current_line_blank:
-                    # Don't put multiple blank lines in a row
-                    continue
-
-                block_text += prefix + text + "\n"
-                blank_line = current_line_blank
-
-            new_span = Span(
-                text=block_text,
-                bbox=block.bbox,
-                span_id=f"{span_counter}_fix_code",
-                font=block.lines[0].spans[0].font,
-                font_weight=block.lines[0].spans[0].font_weight,
-                font_size=block.lines[0].spans[0].font_size,
-            )
-            span_counter += 1
-            block.lines = [Line(spans=[new_span], bbox=block.bbox)]

marker/cleaners/fontstyle.py

@@ -1,30 +0,0 @@
-from typing import List
-
-from marker.schema.page import Page
-
-
-def find_bold_italic(pages: List[Page], bold_min_weight=600):
-    font_weights = []
-    for page in pages:
-        for block in page.blocks:
-            # We don't want to bias our font stats
-            if block.block_type in ["Title", "Section-header"]:
-                continue
-            for line in block.lines:
-                for span in line.spans:
-                    if "bold" in span.font.lower():
-                        span.bold = True
-                    if "ital" in span.font.lower():
-                        span.italic = True
-
-                    font_weights.append(span.font_weight)
-
-    if len(font_weights) == 0:
-        return
-
-    for page in pages:
-        for block in page.blocks:
-            for line in block.lines:
-                for span in line.spans:
-                    if span.font_weight >= bold_min_weight:
-                        span.bold = True

marker/cleaners/headers.py

@@ -1,82 +0,0 @@
-import re
-from collections import Counter
-from rapidfuzz import fuzz
-
-from marker.schema.merged import FullyMergedBlock
-from typing import List, Tuple
-
-
-def filter_common_elements(lines, page_count, threshold=.6):
-    # We can't filter if we don't have enough pages to find common elements
-    if page_count < 3:
-        return []
-    text = [s.text for line in lines for s in line.spans if len(s.text) > 4]
-    counter = Counter(text)
-    common = [k for k, v in counter.items() if v > page_count * threshold]
-    bad_span_ids = [s.span_id for line in lines for s in line.spans if s.text in common]
-    return bad_span_ids
-
-
-def filter_header_footer(all_page_blocks, max_selected_lines=2):
-    first_lines = []
-    last_lines = []
-    for page in all_page_blocks:
-        nonblank_lines = page.get_nonblank_lines()
-        first_lines.extend(nonblank_lines[:max_selected_lines])
-        last_lines.extend(nonblank_lines[-max_selected_lines:])
-
-    bad_span_ids = filter_common_elements(first_lines, len(all_page_blocks))
-    bad_span_ids += filter_common_elements(last_lines, len(all_page_blocks))
-    return bad_span_ids
-
-
-def replace_leading_trailing_digits(string, replacement):
-    string = re.sub(r'^\d+', replacement, string)
-    string = re.sub(r'\d+$', replacement, string)
-    return string
-
-
-def find_overlap_elements(lst: List[Tuple[str, int]], string_match_thresh=.9, min_overlap=.05) -> List[int]:
-    # Initialize a list to store the elements that meet the criteria
-    result = []
-    titles = [l[0] for l in lst]
-
-    for i, (str1, id_num) in enumerate(lst):
-        overlap_count = 0  # Count the number of elements that overlap by at least 80%
-
-        for j, str2 in enumerate(titles):
-            if i != j and fuzz.ratio(str1, str2) >= string_match_thresh * 100:
-                overlap_count += 1
-
-        # Check if the element overlaps with at least 50% of other elements
-        if overlap_count >= max(3.0, len(lst) * min_overlap):
-            result.append(id_num)
-
-    return result
-
-
-def filter_common_titles(merged_blocks: List[FullyMergedBlock]) -> List[FullyMergedBlock]:
-    titles = []
-    for i, block in enumerate(merged_blocks):
-        if block.block_type in ["Title", "Section-header"]:
-            text = block.text
-            if text.strip().startswith("#"):
-                text = re.sub(r'#+', '', text)
-            text = text.strip()
-            # Remove page numbers from start/end
-            text = replace_leading_trailing_digits(text, "").strip()
-            titles.append((text, i))
-
-    bad_block_ids = find_overlap_elements(titles)
-
-    new_blocks = []
-    for i, block in enumerate(merged_blocks):
-        if i in bad_block_ids:
-            continue
-        new_blocks.append(block)
-
-    return new_blocks
-
-
-
-

marker/cleaners/headings.py

@@ -1,129 +0,0 @@
-from collections import defaultdict
-from typing import List
-import numpy as np
-from sklearn.cluster import KMeans
-
-from marker.settings import settings
-from marker.schema.bbox import rescale_bbox
-from marker.schema.block import bbox_from_lines
-from marker.schema.page import Page
-
-
-def split_heading_blocks(pages: List[Page]):
-    # Heading lines can be combined into regular text blocks sometimes by pdftext
-    # Split up heading lines into separate blocks properly
-    for page in pages:
-        page_heading_boxes = [b for b in page.layout.bboxes if b.label in ["Title", "Section-header"]]
-        page_heading_boxes = [(rescale_bbox(page.layout.image_bbox, page.bbox, b.bbox), b.label) for b in page_heading_boxes]
-
-        new_blocks = []
-        for block_idx, block in enumerate(page.blocks):
-            if block.block_type not in ["Text"]:
-                new_blocks.append(block)
-                continue
-
-            heading_lines = []
-            for line_idx, line in enumerate(block.lines):
-                for (heading_box, label) in page_heading_boxes:
-                    if line.intersection_pct(heading_box) > settings.BBOX_INTERSECTION_THRESH:
-                        heading_lines.append((line_idx, label))
-                        break
-
-            if len(heading_lines) == 0:
-                new_blocks.append(block)
-                continue
-
-            # Split up the block into separate blocks around headers
-            start = 0
-            for (heading_line, label) in heading_lines:
-                if start < heading_line:
-                    copied_block = block.copy()
-                    copied_block.lines = block.lines[start:heading_line]
-                    copied_block.bbox = bbox_from_lines(copied_block.lines)
-                    new_blocks.append(copied_block)
-
-                copied_block = block.copy()
-                copied_block.lines = block.lines[heading_line:heading_line + 1]
-                copied_block.block_type = label
-                copied_block.bbox = bbox_from_lines(copied_block.lines)
-                new_blocks.append(copied_block)
-
-                start = heading_line + 1
-                if start >= len(block.lines):
-                    break
-
-            # Add any remaining lines
-            if start < len(block.lines):
-                copied_block = block.copy()
-                copied_block.lines = block.lines[start:]
-                copied_block.bbox = bbox_from_lines(copied_block.lines)
-                new_blocks.append(copied_block)
-
-        page.blocks = new_blocks
-
-
-def bucket_headings(line_heights, num_levels=settings.HEADING_LEVEL_COUNT):
-    if len(line_heights) <= num_levels:
-        return []
-
-    data = np.asarray(line_heights).reshape(-1, 1)
-    labels = KMeans(n_clusters=num_levels, random_state=0, n_init="auto").fit_predict(data)
-    data_labels = np.concatenate([data, labels.reshape(-1, 1)], axis=1)
-    data_labels = np.sort(data_labels, axis=0)
-
-    cluster_means = {int(label): float(np.mean(data_labels[data_labels[:, 1] == label, 0])) for label in np.unique(labels)}
-    label_max = None
-    label_min = None
-    heading_ranges = []
-    prev_cluster = None
-    for row in data_labels:
-        value, label = row
-        value = float(value)
-        label = int(label)
-        if prev_cluster is not None and label != prev_cluster:
-            prev_cluster_mean = cluster_means[prev_cluster]
-            cluster_mean = cluster_means[label]
-            if cluster_mean * settings.HEADING_MERGE_THRESHOLD < prev_cluster_mean:
-                heading_ranges.append((label_min, label_max))
-                label_min = None
-                label_max = None
-
-        label_min = value if label_min is None else min(label_min, value)
-        label_max = value if label_max is None else max(label_max, value)
-        prev_cluster = label
-
-    if label_min is not None:
-        heading_ranges.append((label_min, label_max))
-
-    heading_ranges = sorted(heading_ranges, reverse=True)
-
-    return heading_ranges
-
-
-def infer_heading_levels(pages: List[Page], height_tol=.99):
-    all_line_heights = []
-    for page in pages:
-        for block in page.blocks:
-            if block.block_type not in ["Title", "Section-header"]:
-                continue
-
-            all_line_heights.extend([l.height for l in block.lines])
-
-    heading_ranges = bucket_headings(all_line_heights)
-
-    for page in pages:
-        for block in page.blocks:
-            if block.block_type not in ["Title", "Section-header"]:
-                continue
-
-            block_heights = [l.height for l in block.lines]
-            if len(block_heights) > 0:
-                avg_height = sum(block_heights) / len(block_heights)
-                for idx, (min_height, max_height) in enumerate(heading_ranges):
-                    if avg_height >= min_height * height_tol:
-                        block.heading_level = idx + 1
-                        break
-
-            if block.heading_level is None:
-                block.heading_level = settings.HEADING_DEFAULT_LEVEL
-

marker/cleaners/text.py

@@ -1,8 +0,0 @@
-import re
-
-
-def cleanup_text(full_text):
-    full_text = re.sub(r'\n{3,}', '\n\n', full_text)
-    full_text = re.sub(r'(\n\s){3,}', '\n\n', full_text)
-    full_text = full_text.replace('\xa0', ' ') # Replace non-breaking spaces
-    return full_text

marker/cleaners/toc.py

@@ -1,29 +0,0 @@
-from typing import List
-
-from marker.schema.page import Page
-
-
-def get_pdf_toc(doc, max_depth=15):
-    toc = doc.get_toc(max_depth=max_depth)
-    toc_list = []
-    for item in toc:
-        list_item = {
-            "title": item.title,
-            "level": item.level,
-            "page": item.page_index,
-        }
-        toc_list.append(list_item)
-    return toc_list
-
-
-def compute_toc(pages: List[Page]):
-    toc = []
-    for page in pages:
-        for block in page.blocks:
-            if block.block_type in ["Title", "Section-header"]:
-                toc.append({
-                    "title": block.prelim_text,
-                    "level": block.heading_level,
-                    "page": page.pnum
-                })
-    return toc

marker/convert.py

@@ -1,42 +1,10 @@
 import warnings
-
-from marker.pdf.images import render_image
-
 warnings.filterwarnings("ignore", category=UserWarning) # Filter torch pytree user warnings
 
 import os
 os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" # For some reason, transformers decided to use .isin for a simple op, which is not supported on MPS
 
 
-import pypdfium2 as pdfium # Needs to be at the top to avoid warnings
-from PIL import Image
-
-from marker.utils import flush_cuda_memory
-from marker.tables.table import format_tables
-from marker.debug.data import dump_bbox_debug_data, draw_page_debug_images
-from marker.layout.layout import surya_layout, annotate_block_types
-from marker.layout.order import surya_order, sort_blocks_in_reading_order
-from marker.ocr.lang import replace_langs_with_codes, validate_langs
-from marker.ocr.detection import surya_detection
-from marker.ocr.recognition import run_ocr
-from marker.pdf.extract_text import get_text_blocks
-from marker.cleaners.headers import filter_header_footer, filter_common_titles
-from marker.equations.equations import replace_equations
-from marker.pdf.utils import find_filetype
-from marker.cleaners.code import identify_code_blocks, indent_blocks
-from marker.cleaners.bullets import replace_bullets
-from marker.cleaners.headings import split_heading_blocks, infer_heading_levels
-from marker.cleaners.fontstyle import find_bold_italic
-from marker.postprocessors.markdown import merge_spans, merge_lines, get_full_text
-from marker.cleaners.text import cleanup_text
-from marker.images.extract import extract_images
-from marker.images.save import images_to_dict
-from marker.cleaners.toc import compute_toc
-
-from typing import List, Dict, Tuple, Optional
-from marker.settings import settings
-
-
 def convert_single_pdf(
         fname: str,
         model_lst: List,

marker/{v2/converters → converters}/__init__.py

@@ -2,7 +2,7 @@ from typing import Optional
 
 from pydantic import BaseModel
 
-from marker.v2.util import assign_config
+from marker.util import assign_config
 
 
 class BaseConverter:

marker/{v2/converters → converters}/pdf.py

@@ -1,13 +1,13 @@
 import json
 
 from marker.settings import settings
-from marker.v2.processors.code import CodeProcessor
-from marker.v2.processors.document_toc import DocumentTOCProcessor
-from marker.v2.providers.pdf import PdfProvider
+from marker.processors.code import CodeProcessor
+from marker.processors.document_toc import DocumentTOCProcessor
+from marker.providers.pdf import PdfProvider
 import os
 
-from marker.v2.renderers.json import JSONRenderer
-from marker.v2.util import parse_range_str
+from marker.renderers.json import JSONRenderer
+from marker.util import parse_range_str
 
 os.environ["TOKENIZERS_PARALLELISM"] = "false" # disables a tokenizers warning
 
@@ -17,24 +17,24 @@ from typing import Dict, Type, List, Any
 import click
 import inspect
 
-from marker.v2.builders.document import DocumentBuilder
-from marker.v2.builders.layout import LayoutBuilder
-from marker.v2.builders.ocr import OcrBuilder
-from marker.v2.builders.structure import StructureBuilder
-from marker.v2.converters import BaseConverter
-from marker.v2.models import setup_detection_model, setup_layout_model, \
+from marker.builders.document import DocumentBuilder
+from marker.builders.layout import LayoutBuilder
+from marker.builders.ocr import OcrBuilder
+from marker.builders.structure import StructureBuilder
+from marker.converters import BaseConverter
+from marker.models import setup_detection_model, setup_layout_model, \
     setup_recognition_model, setup_table_rec_model, setup_texify_model
-from marker.v2.processors.equation import EquationProcessor
-from marker.v2.processors.sectionheader import SectionHeaderProcessor
-from marker.v2.processors.text import TextProcessor
-from marker.v2.processors.table import TableProcessor
-from marker.v2.renderers.markdown import MarkdownRenderer
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.blocks import Block
-from marker.v2.schema.registry import register_block_class
-from marker.v2.processors.debug import DebugProcessor
-from marker.v2.processors import BaseProcessor
-from marker.v2.renderers import BaseRenderer
+from marker.processors.equation import EquationProcessor
+from marker.processors.sectionheader import SectionHeaderProcessor
+from marker.processors.text import TextProcessor
+from marker.processors.table import TableProcessor
+from marker.renderers.markdown import MarkdownRenderer
+from marker.schema import BlockTypes
+from marker.schema.blocks import Block
+from marker.schema.registry import register_block_class
+from marker.processors.debug import DebugProcessor
+from marker.processors import BaseProcessor
+from marker.renderers import BaseRenderer
 
 
 class PdfConverter(BaseConverter):

marker/debug/data.py

@@ -1,109 +0,0 @@
-import json
-import math
-import os
-from typing import List
-
-from marker.debug.render import render_on_image
-from marker.schema.bbox import rescale_bbox
-from marker.schema.page import Page
-from marker.settings import settings
-from PIL import Image
-
-
-def draw_layout_page_debug_images(fname, pages: List[Page]):
-    # Remove extension from doc name
-    doc_base = os.path.basename(fname).rsplit(".", 1)[0]
-
-    debug_folder = os.path.join(settings.DEBUG_DATA_FOLDER, doc_base)
-    os.makedirs(debug_folder, exist_ok=True)
-    for idx, page in enumerate(pages):
-        img_size = (int(math.ceil(page.text_lines.image_bbox[2])), int(math.ceil(page.text_lines.image_bbox[3])))
-        png_image = Image.new("RGB", img_size, color="white")
-
-        line_bboxes = []
-        line_text = []
-        for block in page.blocks:
-            for line in block.lines:
-                line_bboxes.append(rescale_bbox(page.bbox, page.text_lines.image_bbox, line.bbox))
-                line_text.append(line.prelim_text)
-
-        render_on_image(line_bboxes, png_image, labels=line_text, color="black", draw_bbox=False)
-        pdf_image = png_image.copy()
-
-        line_bboxes = [line.bbox for line in page.text_lines.bboxes]
-        render_on_image(line_bboxes, png_image, color="blue")
-
-        layout_boxes = [rescale_bbox(page.layout.image_bbox, page.text_lines.image_bbox, box.bbox) for box in page.layout.bboxes]
-        layout_labels = [box.label for box in page.layout.bboxes]
-
-        render_on_image(layout_boxes, png_image, labels=layout_labels, color="red")
-
-        order_labels = [str(i) for i in range(len(page.layout.bboxes))]
-        render_on_image(layout_boxes, png_image, labels=order_labels, color="green", draw_bbox=False, label_offset=5)
-
-        debug_file = os.path.join(debug_folder, f"layout_page_{idx}.png")
-        png_image.save(debug_file)
-
-        # PDF Image
-
-        block_bboxes = [rescale_bbox(page.bbox, page.text_lines.image_bbox, block.bbox) for block in page.blocks]
-        block_labels = [block.block_type for block in page.blocks]
-        render_on_image(block_bboxes, pdf_image, labels=block_labels, color="red")
-
-        block_order = [str(i) for i in range(len(page.blocks))]
-        render_on_image(block_bboxes, pdf_image, labels=block_order, color="green", draw_bbox=False, label_offset=5)
-
-        debug_file = os.path.join(debug_folder, f"pdf_page_{idx}.png")
-        pdf_image.save(debug_file)
-
-
-def draw_pdf_page_debug_images(fname, pages: List[Page]):
-    # Remove extension from doc name
-    doc_base = os.path.basename(fname).rsplit(".", 1)[0]
-
-    debug_folder = os.path.join(settings.DEBUG_DATA_FOLDER, doc_base)
-    os.makedirs(debug_folder, exist_ok=True)
-    for idx, page in enumerate(pages):
-        img_size = (int(math.ceil(page.text_lines.image_bbox[2])), int(math.ceil(page.text_lines.image_bbox[3])))
-        png_image = Image.new("RGB", img_size, color="white")
-
-        line_bboxes = []
-        line_text = []
-        for block in page.blocks:
-            for line in block.lines:
-                line_bboxes.append(rescale_bbox(page.bbox, page.text_lines.image_bbox, line.bbox))
-                line_text.append(line.prelim_text)
-
-
-
-
-def draw_page_debug_images(fname, pages: List[Page]):
-    if not settings.DEBUG:
-        return
-
-    draw_layout_page_debug_images(fname, pages)
-    draw_pdf_page_debug_images(fname, pages)
-
-
-
-def dump_bbox_debug_data(fname, pages: List[Page]):
-    if not settings.DEBUG:
-        return
-
-    # Remove extension from doc name
-    doc_base = os.path.basename(fname).rsplit(".", 1)[0]
-
-    debug_file = os.path.join(settings.DEBUG_DATA_FOLDER, f"{doc_base}_bbox.json")
-    debug_data = []
-    for idx, page_blocks in enumerate(pages):
-        page_data = page_blocks.model_dump(exclude=["images", "layout", "text_lines"])
-        page_data["layout"] = page_blocks.layout.model_dump(exclude=["segmentation_map"])
-        page_data["text_lines"] = page_blocks.text_lines.model_dump(exclude=["heatmap", "affinity_map"])
-        debug_data.append(page_data)
-
-    with open(debug_file, "w+") as f:
-        json.dump(debug_data, f)
-    print(f"Dumped bbox debug data to {debug_file}")
-
-
-

marker/debug/render.py

@@ -1,62 +0,0 @@
-import requests
-from PIL import ImageDraw, ImageFont, Image
-
-from marker.settings import settings
-import os
-
-
-def get_font_path() -> str:
-    font_path = settings.DEBUG_RENDER_FONT
-
-    if not os.path.exists(font_path):
-        os.makedirs(os.path.dirname(font_path), exist_ok=True)
-        font_dl_path = f"{settings.FONT_DL_BASE}/{os.path.basename(font_path)}"
-        with requests.get(font_dl_path, stream=True) as r, open(font_path, 'wb') as f:
-            r.raise_for_status()
-            for chunk in r.iter_content(chunk_size=8192):
-                f.write(chunk)
-
-    return font_path
-
-
-def get_text_size(text, font):
-    im = Image.new(mode="P", size=(0, 0))
-    draw = ImageDraw.Draw(im)
-    _, _, width, height = draw.textbbox((0, 0), text=text, font=font)
-    return width, height
-
-
-def render_on_image(bboxes, image, labels=None, label_offset=1, label_font_size=10, color: str | list='red', draw_bbox=True):
-    draw = ImageDraw.Draw(image)
-    font_path = get_font_path()
-    label_font = ImageFont.truetype(font_path, label_font_size)
-
-    for i, bbox in enumerate(bboxes):
-        bbox = [int(p) for p in bbox]
-        if draw_bbox:
-            draw.rectangle(bbox, outline=color[i] if isinstance(color, list) else color, width=1)
-
-        if labels is not None:
-            label = labels[i]
-            text_position = (
-                bbox[0] + label_offset,
-                bbox[1] + label_offset
-            )
-            text_size = get_text_size(label, label_font)
-            if text_size[0] <= 0 or text_size[1] <= 0:
-                continue
-            box_position = (
-                text_position[0],
-                text_position[1],
-                text_position[0] + text_size[0],
-                text_position[1] + text_size[1]
-            )
-            draw.rectangle(box_position, fill="white")
-            draw.text(
-                text_position,
-                label,
-                fill=color[i] if isinstance(color, list) else color,
-                font=label_font
-            )
-
-    return image

marker/equations/equations.py

@@ -1,179 +0,0 @@
-from collections import defaultdict
-from copy import deepcopy
-from typing import List
-
-from marker.equations.inference import get_total_texify_tokens, get_latex_batched
-from marker.pdf.images import render_bbox_image
-from marker.schema.bbox import rescale_bbox
-from marker.schema.page import Page
-from marker.schema.block import Line, Span, Block, split_block_lines, find_insert_block
-from marker.settings import settings
-
-
-def find_equation_blocks(page, processor):
-    equation_blocks = []
-    equation_regions = [l.bbox for l in page.layout.bboxes if l.label in ["Formula"]]
-    equation_regions = [rescale_bbox(page.layout.image_bbox, page.bbox, b) for b in equation_regions]
-
-    lines_to_remove = defaultdict(list)
-    insert_points = {}
-    equation_lines = defaultdict(list)
-    for region_idx, region in enumerate(equation_regions):
-        for block_idx, block in enumerate(page.blocks):
-            for line_idx, line in enumerate(block.lines):
-                if line.intersection_pct(region) > settings.BBOX_INTERSECTION_THRESH:
-                    # We will remove this line from the block
-                    lines_to_remove[region_idx].append((block_idx, line_idx))
-                    equation_lines[region_idx].append(line)
-
-                    if region_idx not in insert_points:
-                        insert_points[region_idx] = (block_idx, line_idx)
-
-    # Account for regions where the lines were not detected
-    for region_idx, region in enumerate(equation_regions):
-        if region_idx in insert_points:
-            continue
-
-        insert_points[region_idx] = (find_insert_block(page.blocks, region), 0)
-
-    block_lines_to_remove = defaultdict(set)
-    for region_idx, equation_region in enumerate(equation_regions):
-        if region_idx not in equation_lines or len(equation_lines[region_idx]) == 0:
-            block_text = ""
-            total_tokens = 0
-        else:
-            equation_block = equation_lines[region_idx]
-            block_text = " ".join([line.prelim_text for line in equation_block])
-            total_tokens = get_total_texify_tokens(block_text, processor)
-
-        equation_insert = insert_points[region_idx]
-        equation_insert_line_idx = equation_insert[1]
-        equation_insert_line_idx -= len(
-            [x for x in lines_to_remove[region_idx] if x[0] == equation_insert[0] and x[1] < equation_insert[1]])
-
-        selected_blocks = [equation_insert[0], equation_insert_line_idx, total_tokens, block_text, equation_region]
-        if total_tokens < settings.TEXIFY_MODEL_MAX:
-            # Account for the lines we're about to remove
-            for item in lines_to_remove[region_idx]:
-                block_lines_to_remove[item[0]].add(item[1])
-            equation_blocks.append(selected_blocks)
-
-    # Remove the lines from the blocks
-    for block_idx, bad_lines in block_lines_to_remove.items():
-        block = page.blocks[block_idx]
-        block.lines = [line for idx, line in enumerate(block.lines) if idx not in bad_lines]
-
-    return equation_blocks
-
-
-def increment_insert_points(page_equation_blocks, insert_block_idx, insert_count):
-    for idx, (block_idx, line_idx, token_count, block_text, equation_bbox) in enumerate(page_equation_blocks):
-        if block_idx >= insert_block_idx:
-            page_equation_blocks[idx][0] += insert_count
-
-
-def insert_latex_block(page_blocks: Page, page_equation_blocks, predictions, pnum, processor):
-    converted_spans = []
-    idx = 0
-    success_count = 0
-    fail_count = 0
-    for block_number, (insert_block_idx, insert_line_idx, token_count, block_text, equation_bbox) in enumerate(page_equation_blocks):
-        latex_text = predictions[block_number]
-        conditions = [
-            get_total_texify_tokens(latex_text, processor) < settings.TEXIFY_MODEL_MAX,  # Make sure we didn't get to the overall token max, indicates run-on
-            len(latex_text) > len(block_text) * .7,
-            len(latex_text.strip()) > 0
-        ]
-
-        new_block = Block(
-            lines=[Line(
-                spans=[
-                    Span(
-                        text=block_text.replace("\n", " "),
-                        bbox=equation_bbox,
-                        span_id=f"{pnum}_{idx}_fixeq",
-                        font="Latex",
-                        font_weight=0,
-                        font_size=0
-                    )
-                ],
-                bbox=equation_bbox
-            )],
-            bbox=equation_bbox,
-            block_type="Formula",
-            pnum=pnum
-        )
-
-        if not all(conditions):
-            fail_count += 1
-        else:
-            success_count += 1
-            new_block.lines[0].spans[0].text = latex_text.replace("\n", " ")
-            converted_spans.append(deepcopy(new_block.lines[0].spans[0]))
-
-        # Add in the new LaTeX block
-        if insert_line_idx == 0:
-            page_blocks.blocks.insert(insert_block_idx, new_block)
-            increment_insert_points(page_equation_blocks, insert_block_idx, 1)
-        elif insert_line_idx >= len(page_blocks.blocks[insert_block_idx].lines):
-            page_blocks.blocks.insert(insert_block_idx + 1, new_block)
-            increment_insert_points(page_equation_blocks, insert_block_idx + 1, 1)
-        else:
-            new_blocks = []
-            for block_idx, block in enumerate(page_blocks.blocks):
-                if block_idx == insert_block_idx:
-                    split_block = split_block_lines(block, insert_line_idx)
-                    new_blocks.append(split_block[0])
-                    new_blocks.append(new_block)
-                    new_blocks.append(split_block[1])
-                    increment_insert_points(page_equation_blocks, insert_block_idx, 2)
-                else:
-                    new_blocks.append(block)
-            page_blocks.blocks = new_blocks
-
-    return success_count, fail_count, converted_spans
-
-
-def replace_equations(doc, pages: List[Page], texify_model, batch_multiplier=1):
-    unsuccessful_ocr = 0
-    successful_ocr = 0
-
-    # Find potential equation regions, and length of text in each region
-    equation_blocks = []
-    for pnum, page in enumerate(pages):
-        equation_blocks.append(find_equation_blocks(page, texify_model.processor))
-
-    eq_count = sum([len(x) for x in equation_blocks])
-
-    images = []
-    token_counts = []
-    for page_idx, page_equation_blocks in enumerate(equation_blocks):
-        page_obj = doc[page_idx]
-        for equation_idx, (insert_block_idx, insert_line_idx, token_count, block_text, equation_bbox) in enumerate(page_equation_blocks):
-            png_image = render_bbox_image(page_obj, pages[page_idx], equation_bbox)
-
-            images.append(png_image)
-            token_counts.append(token_count)
-
-    # Make batched predictions
-    predictions = get_latex_batched(images, token_counts, texify_model, batch_multiplier=batch_multiplier)
-
-    # Replace blocks with predictions
-    page_start = 0
-    converted_spans = []
-    for page_idx, page_equation_blocks in enumerate(equation_blocks):
-        page_equation_count = len(page_equation_blocks)
-        page_predictions = predictions[page_start:page_start + page_equation_count]
-        success_count, fail_count, converted_span = insert_latex_block(
-            pages[page_idx],
-            page_equation_blocks,
-            page_predictions,
-            page_idx,
-            texify_model.processor
-        )
-        converted_spans.extend(converted_span)
-        page_start += page_equation_count
-        successful_ocr += success_count
-        unsuccessful_ocr += fail_count
-
-    return pages, {"successful_ocr": successful_ocr, "unsuccessful_ocr": unsuccessful_ocr, "equations": eq_count}

marker/equations/inference.py

@@ -1,51 +0,0 @@
-from texify.inference import batch_inference
-from tqdm import tqdm
-
-from marker.settings import settings
-import os
-
-os.environ["TOKENIZERS_PARALLELISM"] = "false"
-
-
-def get_batch_size():
-    if settings.TEXIFY_BATCH_SIZE is not None:
-        return settings.TEXIFY_BATCH_SIZE
-    elif settings.TORCH_DEVICE_MODEL == "cuda":
-        return 6
-    elif settings.TORCH_DEVICE_MODEL == "mps":
-        return 6
-    return 2
-
-def get_latex_batched(images, token_counts, texify_model, batch_multiplier=1):
-    if len(images) == 0:
-        return []
-
-    predictions = [""] * len(images)
-    batch_size = get_batch_size() * batch_multiplier
-
-    for i in tqdm(range(0, len(images), batch_size), desc="Recognizing equations"):
-        # Dynamically set max length to save inference time
-        min_idx = i
-        max_idx = min(min_idx + batch_size, len(images))
-        max_length = max(token_counts[min_idx:max_idx])
-        max_length = min(max_length, settings.TEXIFY_MODEL_MAX)
-        max_length += settings.TEXIFY_TOKEN_BUFFER
-
-        model_output = batch_inference(images[min_idx:max_idx], texify_model, texify_model.processor, max_tokens=max_length)
-
-        for j, output in enumerate(model_output):
-            token_count = get_total_texify_tokens(output, texify_model.processor)
-            if token_count >= max_length - 1:
-                output = ""
-
-            image_idx = i + j
-            predictions[image_idx] = output
-    return predictions
-
-
-def get_total_texify_tokens(text, processor):
-    tokenizer = processor.tokenizer
-    tokens = tokenizer(text)
-    return len(tokens["input_ids"])
-
-

marker/images/extract.py

@@ -1,77 +0,0 @@
-from marker.images.save import get_image_filename
-from marker.pdf.images import render_bbox_image
-from marker.schema.bbox import rescale_bbox
-from marker.schema.block import find_insert_block, Span, Line
-from marker.settings import settings
-
-
-def find_image_blocks(page):
-    image_blocks = []
-    image_regions = [l.bbox for l in page.layout.bboxes if l.label in ["Figure", "Picture"]]
-    image_regions = [rescale_bbox(page.layout.image_bbox, page.bbox, b) for b in image_regions]
-
-    insert_points = {}
-    for region_idx, region in enumerate(image_regions):
-        for block_idx, block in enumerate(page.blocks):
-            for line_idx, line in enumerate(block.lines):
-                if line.intersection_pct(region) > settings.BBOX_INTERSECTION_THRESH:
-                    line.spans = [] # We will remove this line from the block
-
-                    if region_idx not in insert_points:
-                        insert_points[region_idx] = (block_idx, line_idx)
-
-    # Account for images with no detected lines
-    for region_idx, region in enumerate(image_regions):
-        if region_idx in insert_points:
-            continue
-
-        insert_points[region_idx] = (find_insert_block(page.blocks, region), 0)
-
-    for region_idx, image_region in enumerate(image_regions):
-        image_insert = insert_points[region_idx]
-        image_blocks.append([image_insert[0], image_insert[1], image_region])
-
-    return image_blocks
-
-
-def extract_page_images(page_obj, page):
-    page.images = []
-    image_blocks = find_image_blocks(page)
-
-    for image_idx, (block_idx, line_idx, bbox) in enumerate(image_blocks):
-        if block_idx >= len(page.blocks):
-            block_idx = len(page.blocks) - 1
-        if block_idx < 0:
-            continue
-
-        block = page.blocks[block_idx]
-        image = render_bbox_image(page_obj, page, bbox)
-        image_filename = get_image_filename(page, image_idx)
-        image_markdown = f"\n\n![{image_filename}]({image_filename})\n\n"
-        image_span = Span(
-            bbox=bbox,
-            text=image_markdown,
-            font="Image",
-            rotation=0,
-            font_weight=0,
-            font_size=0,
-            image=True,
-            span_id=f"image_{image_idx}"
-        )
-
-        # Sometimes, the block has zero lines
-        if len(block.lines) > line_idx:
-            block.lines[line_idx].spans.append(image_span)
-        else:
-            line = Line(
-                bbox=bbox,
-                spans=[image_span]
-            )
-            block.lines.append(line)
-        page.images.append(image)
-
-
-def extract_images(doc, pages):
-    for page_idx, page in enumerate(pages):
-        page_obj = doc[page_idx]
-        extract_page_images(page_obj, page)

marker/images/save.py

@@ -1,18 +0,0 @@
-from typing import List
-
-from marker.schema.page import Page
-
-
-def get_image_filename(page: Page, image_idx):
-    return f"{page.pnum}_image_{image_idx}.png"
-
-
-def images_to_dict(pages: List[Page]):
-    images = {}
-    for page in pages:
-        if page.images is None:
-            continue
-        for image_idx, image in enumerate(page.images):
-            image_filename = get_image_filename(page, image_idx)
-            images[image_filename] = image
-    return images

marker/layout/layout.py

@@ -1,113 +0,0 @@
-from collections import defaultdict, Counter
-from typing import List
-
-from surya.layout import batch_layout_detection
-
-from marker.pdf.images import render_image
-from marker.schema.bbox import rescale_bbox
-from marker.schema.block import bbox_from_lines
-from marker.schema.page import Page
-from marker.settings import settings
-
-
-def get_batch_size():
-    if settings.LAYOUT_BATCH_SIZE is not None:
-        return settings.LAYOUT_BATCH_SIZE
-    elif settings.TORCH_DEVICE_MODEL == "cuda":
-        return 6
-    return 6
-
-
-def surya_layout(images: list, pages: List[Page], layout_model, batch_multiplier=1):
-    text_detection_results = [p.text_lines for p in pages]
-
-    processor = layout_model.processor
-    layout_results = batch_layout_detection(images, layout_model, processor, detection_results=text_detection_results, batch_size=int(get_batch_size() * batch_multiplier))
-    for page, layout_result in zip(pages, layout_results):
-        page.layout = layout_result
-
-
-def annotate_block_types(pages: List[Page]):
-    for page in pages:
-        max_intersections = {}
-        for i, block in enumerate(page.blocks):
-            for j, layout_block in enumerate(page.layout.bboxes):
-                layout_bbox = layout_block.bbox
-                layout_bbox = rescale_bbox(page.layout.image_bbox, page.bbox, layout_bbox)
-                intersection_pct = block.intersection_pct(layout_bbox)
-                if i not in max_intersections:
-                    max_intersections[i] = (intersection_pct, j)
-                elif intersection_pct > max_intersections[i][0]:
-                    max_intersections[i] = (intersection_pct, j)
-
-        for i, block in enumerate(page.blocks):
-            block = page.blocks[i]
-            block_type = None
-            if i in max_intersections and max_intersections[i][0] > 0.0:
-                j = max_intersections[i][1]
-                block_type = page.layout.bboxes[j].label
-            block.block_type = block_type
-
-        # Smarter block layout assignment - first assign same as closest block
-        # Next, fall back to text
-        for i, block in enumerate(page.blocks):
-            if block.block_type is not None:
-                continue
-            min_dist = None
-            min_dist_idx = None
-            for j, block2 in enumerate(page.blocks):
-                if j == i or block2.block_type is None:
-                    continue
-                dist = block.distance(block2.bbox)
-                if min_dist_idx is None or dist < min_dist:
-                    min_dist = dist
-                    min_dist_idx = j
-                for line in block2.lines:
-                    dist = block.distance(line.bbox)
-                    if dist < min_dist:
-                        min_dist = dist
-                        min_dist_idx = j
-
-            if min_dist_idx is not None:
-                block.block_type = page.blocks[min_dist_idx].block_type
-
-        for i, block in enumerate(page.blocks):
-            if block.block_type is None:
-                block.block_type = settings.DEFAULT_BLOCK_TYPE
-
-        def get_layout_label(block_labels: List[str]):
-            counter = Counter(block_labels)
-            return counter.most_common(1)[0][0]
-
-        def generate_block(block, block_labels):
-            block.bbox = bbox_from_lines(block.lines)
-            block.block_type = get_layout_label(block_labels)
-            return block
-
-        # Merge blocks together, preserving pdf order
-        curr_layout_idx = None
-        curr_layout_block = None
-        curr_block_labels = []
-        new_blocks = []
-        for i in range(len(page.blocks)):
-            if i not in max_intersections or max_intersections[i][0] == 0:
-                if curr_layout_block is not None:
-                    new_blocks.append(generate_block(curr_layout_block, curr_block_labels))
-                curr_layout_block = None
-                curr_layout_idx = None
-                curr_block_labels = []
-                new_blocks.append(page.blocks[i])
-            elif max_intersections[i][1] != curr_layout_idx:
-                if curr_layout_block is not None:
-                    new_blocks.append(generate_block(curr_layout_block, curr_block_labels))
-                curr_layout_block = page.blocks[i].copy()
-                curr_layout_idx = max_intersections[i][1]
-                curr_block_labels = [page.blocks[i].block_type]
-            else:
-                curr_layout_block.lines.extend(page.blocks[i].lines)
-                curr_block_labels.append(page.blocks[i].block_type)
-
-        if curr_layout_block is not None:
-            new_blocks.append(generate_block(curr_layout_block, curr_block_labels))
-
-        page.blocks = new_blocks

marker/layout/order.py

@@ -1,73 +0,0 @@
-from collections import defaultdict
-from typing import List
-
-from surya.ordering import batch_ordering
-
-from marker.pdf.images import render_image
-from marker.pdf.utils import sort_block_group
-from marker.schema.bbox import rescale_bbox
-from marker.schema.page import Page
-from marker.settings import settings
-
-
-def get_batch_size():
-    if settings.ORDER_BATCH_SIZE is not None:
-        return settings.ORDER_BATCH_SIZE
-    elif settings.TORCH_DEVICE_MODEL == "cuda":
-        return 6
-    elif settings.TORCH_DEVICE_MODEL == "mps":
-        return 6
-    return 6
-
-
-def surya_order(images: list, pages: List[Page], order_model, batch_multiplier=1):
-    # Get bboxes for all pages
-    bboxes = []
-    for page in pages:
-        bbox = [b.bbox for b in page.layout.bboxes][:settings.ORDER_MAX_BBOXES]
-        bboxes.append(bbox)
-
-    processor = order_model.processor
-    order_results = batch_ordering(images, bboxes, order_model, processor, batch_size=int(get_batch_size() * batch_multiplier))
-    for page, order_result in zip(pages, order_results):
-        page.order = order_result
-
-
-def sort_blocks_in_reading_order(pages: List[Page]):
-    for page in pages:
-        order = page.order
-        block_positions = {}
-        max_position = 0
-        for i, block in enumerate(page.blocks):
-            for order_box in order.bboxes:
-                order_bbox = order_box.bbox
-                position = order_box.position
-                order_bbox = rescale_bbox(order.image_bbox, page.bbox, order_bbox)
-                block_intersection = block.intersection_pct(order_bbox)
-                if i not in block_positions:
-                    block_positions[i] = (block_intersection, position)
-                elif block_intersection > block_positions[i][0]:
-                    block_positions[i] = (block_intersection, position)
-                max_position = max(max_position, position)
-        block_groups = defaultdict(list)
-        for i, block in enumerate(page.blocks):
-            if i in block_positions:
-                position = block_positions[i][1]
-            else:
-                max_position += 1
-                position = max_position
-
-            block_groups[position].append(block)
-
-        new_blocks = []
-        for position in sorted(block_groups.keys()):
-            block_group = sort_block_group(block_groups[position])
-            new_blocks.extend(block_group)
-
-        # Ensure we properly put footers at the end of the page
-        footer_blocks = [b for b in new_blocks if b.block_type in ["Footnote", "Page-footer"]]
-        header_blocks = [b for b in new_blocks if b.block_type in ["Page-header"]]
-        regular_blocks = [b for b in new_blocks if b.block_type not in ["Footnote", "Page-footer", "Page-header"]]
-        
-        new_blocks = header_blocks + regular_blocks + footer_blocks
-        page.blocks = new_blocks

marker/logger.py

@@ -5,8 +5,5 @@ import warnings
 def configure_logging():
     logging.basicConfig(level=logging.WARNING)
 
-    logging.getLogger('pdfminer').setLevel(logging.ERROR)
     logging.getLogger('PIL').setLevel(logging.ERROR)
-    logging.getLogger('fitz').setLevel(logging.ERROR)
-    logging.getLogger('ocrmypdf').setLevel(logging.ERROR)
     warnings.simplefilter(action='ignore', category=FutureWarning)

marker/models.py

@@ -1,21 +1,27 @@
 import os
+
 os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1" # For some reason, transformers decided to use .isin for a simple op, which is not supported on MPS
 
 
 from surya.model.detection.model import load_model as load_detection_model, load_processor as load_detection_processor
-from surya.model.layout.model import load_model as load_layout_model, load_processor as load_layout_processor
+from surya.model.layout.model import load_model as load_layout_model
+from surya.model.layout.processor import load_processor as load_layout_processor
 from texify.model.model import load_model as load_texify_model
 from texify.model.processor import load_processor as load_texify_processor
 from marker.settings import settings
 from surya.model.recognition.model import load_model as load_recognition_model
 from surya.model.recognition.processor import load_processor as load_recognition_processor
-from surya.model.ordering.model import load_model as load_order_model
-from surya.model.ordering.processor import load_processor as load_order_processor
 from surya.model.table_rec.model import load_model as load_table_model
 from surya.model.table_rec.processor import load_processor as load_table_processor
 
+from texify.model.model import GenerateVisionEncoderDecoderModel
+from surya.model.layout.encoderdecoder import SuryaLayoutModel
+from surya.model.detection.model import EfficientViTForSemanticSegmentation
+from surya.model.recognition.encoderdecoder import OCREncoderDecoderModel
+from surya.model.table_rec.encoderdecoder import TableRecEncoderDecoderModel
+
 
-def setup_table_rec_model(device=None, dtype=None):
+def setup_table_rec_model(device=None, dtype=None) -> TableRecEncoderDecoderModel:
     if device:
         table_model = load_table_model(device=device, dtype=dtype)
     else:
@@ -24,7 +30,7 @@ def setup_table_rec_model(device=None, dtype=None):
     return table_model
 
 
-def setup_recognition_model(device=None, dtype=None):
+def setup_recognition_model(device=None, dtype=None) -> OCREncoderDecoderModel:
     if device:
         rec_model = load_recognition_model(device=device, dtype=dtype)
     else:
@@ -33,7 +39,7 @@ def setup_recognition_model(device=None, dtype=None):
     return rec_model
 
 
-def setup_detection_model(device=None, dtype=None):
+def setup_detection_model(device=None, dtype=None) -> EfficientViTForSemanticSegmentation:
     if device:
         model = load_detection_model(device=device, dtype=dtype)
     else:
@@ -42,7 +48,7 @@ def setup_detection_model(device=None, dtype=None):
     return model
 
 
-def setup_texify_model(device=None, dtype=None):
+def setup_texify_model(device=None, dtype=None) -> GenerateVisionEncoderDecoderModel:
     if device:
         texify_model = load_texify_model(checkpoint=settings.TEXIFY_MODEL_NAME, device=device, dtype=dtype)
     else:
@@ -51,36 +57,10 @@ def setup_texify_model(device=None, dtype=None):
     return texify_model
 
 
-def setup_layout_model(device=None, dtype=None):
+def setup_layout_model(device=None, dtype=None) -> SuryaLayoutModel:
     if device:
         model = load_layout_model(device=device, dtype=dtype)
     else:
         model = load_layout_model()
     model.processor = load_layout_processor()
-    return model
-
-
-def setup_order_model(device=None, dtype=None):
-    if device:
-        model = load_order_model(device=device, dtype=dtype)
-    else:
-        model = load_order_model()
-    model.processor = load_order_processor()
-    return model
-
-
-def load_all_models(device=None, dtype=None):
-    if device is not None:
-        assert dtype is not None, "Must provide dtype if device is provided"
-
-    # langs is optional list of languages to prune from recognition MoE model
-    detection = setup_detection_model(device, dtype)
-    layout = setup_layout_model(device, dtype)
-    order = setup_order_model(device, dtype)
-
-    # Only load recognition model if we'll need it for all pdfs
-    ocr = setup_recognition_model(device, dtype)
-    texify = setup_texify_model(device, dtype)
-    table_model = setup_table_rec_model(device, dtype)
-    model_lst = [texify, layout, order, detection, ocr, table_model]
-    return model_lst
+    return model

marker/ocr/detection.py

@@ -1,28 +0,0 @@
-from typing import List
-
-from pypdfium2 import PdfDocument
-from surya.detection import batch_text_detection
-
-from marker.pdf.images import render_image
-from marker.schema.page import Page
-from marker.settings import settings
-
-
-def get_batch_size():
-    if settings.DETECTOR_BATCH_SIZE is not None:
-        return settings.DETECTOR_BATCH_SIZE
-    elif settings.TORCH_DEVICE_MODEL == "cuda":
-        return 4
-    return 4
-
-
-def surya_detection(images: list, pages: List[Page], det_model, batch_multiplier=1):
-    processor = det_model.processor
-
-    predictions = batch_text_detection(images, det_model, processor, batch_size=int(get_batch_size() * batch_multiplier))
-    for (page, pred) in zip(pages, predictions):
-        page.text_lines = pred
-
-
-
-

marker/ocr/heuristics.py

@@ -1,78 +0,0 @@
-import re
-from typing import List
-
-from marker.ocr.utils import alphanum_ratio
-from marker.schema.bbox import rescale_bbox, box_intersection_pct
-from marker.schema.page import Page
-from marker.settings import settings
-
-
-def should_ocr_page(page: Page, no_text: bool, ocr_all_pages=False):
-    detected_lines_found, total_lines = detected_line_coverage(page)
-
-    # No reason to OCR page if it has no text lines
-    if total_lines == 0:
-        return False
-
-    # OCR page if we got minimal text, or if we got too many spaces
-    conditions = [
-        no_text, # Full doc has no text, and needs full OCR
-        (len(page.prelim_text) > 0 and detect_bad_ocr(page.prelim_text)),  # Bad OCR
-        detected_lines_found is False, # didn't extract text for all detected lines
-    ]
-
-    return any(conditions) or ocr_all_pages
-
-
-def detect_bad_ocr(text, space_threshold=.7, newline_threshold=.6, alphanum_threshold=.3):
-    if len(text) == 0:
-        # Assume OCR failed if we have no text
-        return True
-
-    spaces = len(re.findall(r'\s+', text))
-    alpha_chars = len(re.sub(r'\s+', '', text))
-    if spaces / (alpha_chars + spaces) > space_threshold:
-        return True
-
-    newlines = len(re.findall(r'\n+', text))
-    non_newlines = len(re.sub(r'\n+', '', text))
-    if newlines / (newlines + non_newlines) > newline_threshold:
-        return True
-
-    if alphanum_ratio(text) < alphanum_threshold: # Garbled text
-        return True
-
-    invalid_chars = len([c for c in text if c in settings.INVALID_CHARS])
-    if invalid_chars > max(6.0, len(text) * .03):
-        return True
-
-    return False
-
-
-def no_text_found(pages: List[Page]):
-    full_text = ""
-    for page in pages:
-        full_text += page.prelim_text
-    return len(full_text.strip()) == 0
-
-
-def detected_line_coverage(page: Page, intersect_thresh=.5, detection_thresh=.4):
-    found_lines = 0
-    for detected_line in page.text_lines.bboxes:
-        # Get bbox and rescale to match dimensions of original page
-        detected_bbox = detected_line.bbox
-        detected_bbox = rescale_bbox(page.text_lines.image_bbox, page.bbox, detected_bbox)
-
-        total_intersection = 0
-        for block in page.blocks:
-            for line in block.lines:
-                intersection_pct = box_intersection_pct(detected_bbox, line.bbox)
-                total_intersection += intersection_pct
-        if total_intersection > intersect_thresh:
-            found_lines += 1
-
-    total_lines = len(page.text_lines.bboxes)
-    if total_lines == 0:
-        return True, 0
-
-    return found_lines / total_lines > detection_thresh, total_lines

marker/ocr/lang.py

@@ -1,44 +0,0 @@
-from typing import List
-
-from surya.languages import CODE_TO_LANGUAGE, LANGUAGE_TO_CODE
-from surya.model.recognition.tokenizer import _tokenize as lang_tokenize
-
-from marker.ocr.tesseract import LANGUAGE_TO_TESSERACT_CODE, TESSERACT_CODE_TO_LANGUAGE
-from marker.settings import settings
-
-
-def langs_to_ids(langs: List[str]):
-    unique_langs = list(set(langs))
-    _, lang_tokens = lang_tokenize("", unique_langs)
-    return lang_tokens
-
-
-def replace_langs_with_codes(langs):
-    if settings.OCR_ENGINE == "surya":
-        if langs is None:
-            return
-        for i, lang in enumerate(langs):
-            if lang.title() in LANGUAGE_TO_CODE:
-                langs[i] = LANGUAGE_TO_CODE[lang.title()]
-    else:
-        if langs is None:
-            langs = [settings.DEFAULT_LANG]
-            print(f"No languages specified for tesseract, defaulting to {settings.DEFAULT_LANG}.")
-
-        for i, lang in enumerate(langs):
-            if lang in LANGUAGE_TO_CODE:
-                langs[i] = LANGUAGE_TO_TESSERACT_CODE[lang]
-    return langs
-
-
-def validate_langs(langs):
-    if settings.OCR_ENGINE == "surya":
-        if langs is None:
-            return
-        for lang in langs:
-            if lang not in CODE_TO_LANGUAGE:
-                raise ValueError(f"Invalid language code {lang} for Surya OCR")
-    else:
-        for lang in langs:
-            if lang not in TESSERACT_CODE_TO_LANGUAGE:
-                raise ValueError(f"Invalid language code {lang} for Tesseract")

marker/ocr/recognition.py

@@ -1,182 +0,0 @@
-import tempfile
-from copy import deepcopy
-from itertools import repeat
-from typing import List, Optional, Dict
-
-import pypdfium2 as pdfium
-import io
-from concurrent.futures import ThreadPoolExecutor
-
-from surya.ocr import run_recognition
-
-from marker.models import setup_recognition_model
-from marker.ocr.heuristics import should_ocr_page, no_text_found, detect_bad_ocr
-from marker.ocr.lang import langs_to_ids
-from marker.pdf.images import render_image
-from marker.schema.bbox import rescale_bbox
-from marker.schema.page import Page
-from marker.schema.block import Block, Line, Span
-from marker.settings import settings
-from marker.pdf.extract_text import get_text_blocks
-
-
-def get_batch_size():
-    if settings.RECOGNITION_BATCH_SIZE is not None:
-        return settings.RECOGNITION_BATCH_SIZE
-    elif settings.TORCH_DEVICE_MODEL == "cuda":
-        return 32
-    elif settings.TORCH_DEVICE_MODEL == "mps":
-        return 32
-    return 32
-
-
-def run_ocr(doc, pages: List[Page], langs: List[str], rec_model, batch_multiplier=1, ocr_all_pages=False) -> (List[Page], Dict):
-    ocr_pages = 0
-    ocr_success = 0
-    ocr_failed = 0
-    no_text = no_text_found(pages)
-    ocr_idxs = []
-    for pnum, page in enumerate(pages):
-        ocr_needed = should_ocr_page(page, no_text, ocr_all_pages=ocr_all_pages)
-        if ocr_needed:
-            ocr_idxs.append(pnum)
-            ocr_pages += 1
-
-    # No pages need OCR
-    if ocr_pages == 0:
-        return pages, {"ocr_pages": 0, "ocr_failed": 0, "ocr_success": 0, "ocr_engine": "none"}
-
-    ocr_method = settings.OCR_ENGINE
-    if ocr_method is None or ocr_method == "None":
-        return pages, {"ocr_pages": 0, "ocr_failed": 0, "ocr_success": 0, "ocr_engine": "none"}
-    elif ocr_method == "surya":
-        new_pages = surya_recognition(doc, ocr_idxs, langs, rec_model, pages, batch_multiplier=batch_multiplier)
-    elif ocr_method == "ocrmypdf":
-        new_pages = tesseract_recognition(doc, ocr_idxs, langs)
-    else:
-        raise ValueError(f"Unknown OCR method {ocr_method}")
-
-    for orig_idx, page in zip(ocr_idxs, new_pages):
-        if detect_bad_ocr(page.prelim_text) or len(page.prelim_text) == 0:
-            ocr_failed += 1
-        else:
-            ocr_success += 1
-            pages[orig_idx] = page
-
-    return pages, {"ocr_pages": ocr_pages, "ocr_failed": ocr_failed, "ocr_success": ocr_success, "ocr_engine": ocr_method}
-
-
-def surya_recognition(doc, page_idxs, langs: List[str], rec_model, pages: List[Page], batch_multiplier=1) -> List[Optional[Page]]:
-    # Slice images in higher resolution than detection happened in
-    images = [render_image(doc[pnum], dpi=settings.SURYA_OCR_DPI) for pnum in page_idxs]
-    box_scale = settings.SURYA_OCR_DPI / settings.SURYA_DETECTOR_DPI
-
-    processor = rec_model.processor
-    selected_pages = [p for i, p in enumerate(pages) if i in page_idxs]
-
-    surya_langs = [langs] * len(page_idxs)
-    detection_results = [p.text_lines.bboxes for p in selected_pages]
-    polygons = deepcopy([[b.polygon for b in bboxes] for bboxes in detection_results])
-
-    # Scale polygons to get correct image slices
-    for j, poly in enumerate(polygons):
-        skip_idxs = []
-        for z, p in enumerate(poly):
-            for i in range(len(p)):
-                p[i] = [int(p[i][0] * box_scale), int(p[i][1] * box_scale)]
-            x_coords = [p[i][0] for i in range(len(p))]
-            y_coords = [p[i][1] for i in range(len(p))]
-            bbox = [min(x_coords), min(y_coords), max(x_coords), max(y_coords)]
-            if (bbox[2] - bbox[0]) * (bbox[3] - bbox[1]) == 0:
-                skip_idxs.append(z)
-        if len(skip_idxs) > 0:
-            polygons[j] = [p for i, p in enumerate(poly) if i not in skip_idxs]
-
-    results = run_recognition(images, surya_langs, rec_model, processor, polygons=polygons, batch_size=int(get_batch_size() * batch_multiplier))
-
-    new_pages = []
-    for idx, (page_idx, result, old_page) in enumerate(zip(page_idxs, results, selected_pages)):
-        text_lines = old_page.text_lines
-        ocr_results = result.text_lines
-        blocks = []
-        for i, line in enumerate(ocr_results):
-            scaled_bbox = rescale_bbox([0, 0, images[idx].size[0], images[idx].size[1]], old_page.text_lines.image_bbox, line.bbox)
-            block = Block(
-                bbox=scaled_bbox,
-                pnum=page_idx,
-                lines=[Line(
-                    bbox=scaled_bbox,
-                    spans=[Span(
-                        text=line.text,
-                        bbox=scaled_bbox,
-                        span_id=f"{page_idx}_{i}",
-                        font="",
-                        font_weight=0,
-                        font_size=0,
-                    )
-                    ]
-                )]
-            )
-            blocks.append(block)
-        page = Page(
-            blocks=blocks,
-            pnum=page_idx,
-            bbox=old_page.text_lines.image_bbox,
-            rotation=0,
-            text_lines=text_lines,
-            ocr_method="surya"
-        )
-        new_pages.append(page)
-    return new_pages
-
-
-def tesseract_recognition(doc, page_idxs, langs: List[str]) -> List[Optional[Page]]:
-    pdf_pages = generate_single_page_pdfs(doc, page_idxs)
-    with ThreadPoolExecutor(max_workers=settings.OCR_PARALLEL_WORKERS) as executor:
-        pages = list(executor.map(_tesseract_recognition, pdf_pages, repeat(langs, len(pdf_pages))))
-
-    return pages
-
-
-def generate_single_page_pdfs(doc, page_idxs) -> List[io.BytesIO]:
-    pdf_pages = []
-    for page_idx in page_idxs:
-        blank_doc = pdfium.PdfDocument.new()
-        blank_doc.import_pages(doc, pages=[page_idx])
-        assert len(blank_doc) == 1, "Failed to import page"
-
-        in_pdf = io.BytesIO()
-        blank_doc.save(in_pdf)
-        in_pdf.seek(0)
-        pdf_pages.append(in_pdf)
-    return pdf_pages
-
-
-def _tesseract_recognition(in_pdf, langs: List[str]) -> Optional[Page]:
-    import ocrmypdf
-    out_pdf = io.BytesIO()
-
-    ocrmypdf.ocr(
-        in_pdf,
-        out_pdf,
-        language=langs[0],
-        output_type="pdf",
-        redo_ocr=None,
-        force_ocr=True,
-        progress_bar=False,
-        optimize=False,
-        fast_web_view=1e6,
-        skip_big=15,  # skip images larger than 15 megapixels
-        tesseract_timeout=settings.TESSERACT_TIMEOUT,
-        tesseract_non_ocr_timeout=settings.TESSERACT_TIMEOUT,
-    )
-
-    with tempfile.NamedTemporaryFile() as f:
-        f.write(out_pdf.getvalue())
-        f.seek(0)
-        new_doc = pdfium.PdfDocument(f.name)
-        blocks, _ = get_text_blocks(new_doc, f.name, max_pages=1)
-
-    page = blocks[0]
-    page.ocr_method = "tesseract"
-    return page

marker/ocr/tesseract.py

@@ -1,97 +0,0 @@
-LANGUAGE_TO_TESSERACT_CODE = {
-    'Afrikaans': 'afr',
-    'Amharic': 'amh',
-    'Arabic': 'ara',
-    'Assamese': 'asm',
-    'Azerbaijani': 'aze',
-    'Belarusian': 'bel',
-    'Bulgarian': 'bul',
-    'Bengali': 'ben',
-    'Breton': 'bre',
-    'Bosnian': 'bos',
-    'Catalan': 'cat',
-    'Czech': 'ces',
-    'Welsh': 'cym',
-    'Danish': 'dan',
-    'German': 'deu',
-    'Greek': 'ell',
-    'English': 'eng',
-    'Esperanto': 'epo',
-    'Spanish': 'spa',
-    'Estonian': 'est',
-    'Basque': 'eus',
-    'Persian': 'fas',
-    'Finnish': 'fin',
-    'French': 'fra',
-    'Western Frisian': 'fry',
-    'Irish': 'gle',
-    'Scottish Gaelic': 'gla',
-    'Galician': 'glg',
-    'Gujarati': 'guj',
-    'Hausa': 'hau',
-    'Hebrew': 'heb',
-    'Hindi': 'hin',
-    'Croatian': 'hrv',
-    'Hungarian': 'hun',
-    'Armenian': 'hye',
-    'Indonesian': 'ind',
-    'Icelandic': 'isl',
-    'Italian': 'ita',
-    'Japanese': 'jpn',
-    'Javanese': 'jav',
-    'Georgian': 'kat',
-    'Kazakh': 'kaz',
-    'Khmer': 'khm',
-    'Kannada': 'kan',
-    'Korean': 'kor',
-    'Kurdish': 'kur',
-    'Kyrgyz': 'kir',
-    'Latin': 'lat',
-    'Lao': 'lao',
-    'Lithuanian': 'lit',
-    'Latvian': 'lav',
-    'Malagasy': 'mlg',
-    'Macedonian': 'mkd',
-    'Malayalam': 'mal',
-    'Mongolian': 'mon',
-    'Marathi': 'mar',
-    'Malay': 'msa',
-    'Burmese': 'mya',
-    'Nepali': 'nep',
-    'Dutch': 'nld',
-    'Norwegian': 'nor',
-    'Oromo': 'orm',
-    'Oriya': 'ori',
-    'Punjabi': 'pan',
-    'Polish': 'pol',
-    'Pashto': 'pus',
-    'Portuguese': 'por',
-    'Romanian': 'ron',
-    'Russian': 'rus',
-    'Sanskrit': 'san',
-    'Sindhi': 'snd',
-    'Sinhala': 'sin',
-    'Slovak': 'slk',
-    'Slovenian': 'slv',
-    'Somali': 'som',
-    'Albanian': 'sqi',
-    'Serbian': 'srp',
-    'Sundanese': 'sun',
-    'Swedish': 'swe',
-    'Swahili': 'swa',
-    'Tamil': 'tam',
-    'Telugu': 'tel',
-    'Thai': 'tha',
-    'Tagalog': 'tgl',
-    'Turkish': 'tur',
-    'Uyghur': 'uig',
-    'Ukrainian': 'ukr',
-    'Urdu': 'urd',
-    'Uzbek': 'uzb',
-    'Vietnamese': 'vie',
-    'Xhosa': 'xho',
-    'Yiddish': 'yid',
-    'Chinese': 'chi_sim',
-}
-
-TESSERACT_CODE_TO_LANGUAGE = {v:k for k,v in LANGUAGE_TO_TESSERACT_CODE.items()}

marker/pdf/extract_text.py

@@ -1,114 +0,0 @@
-import os
-from typing import List, Optional, Dict
-
-import pypdfium2 as pdfium
-
-from marker.cleaners.toc import get_pdf_toc
-from marker.pdf.utils import font_flags_decomposer
-from marker.settings import settings
-from marker.schema.block import Span, Line, Block
-from marker.schema.page import Page
-from pdftext.extraction import dictionary_output
-
-os.environ["TESSDATA_PREFIX"] = settings.TESSDATA_PREFIX
-
-
-def pdftext_format_to_blocks(page, pnum: int) -> Page:
-    page_blocks = []
-    span_id = 0
-    for block_idx, block in enumerate(page["blocks"]):
-        for l in block["lines"]:
-            block_lines = []
-            spans = []
-            for i, s in enumerate(l["spans"]):
-                block_text = s["text"]
-                # Remove trailing newlines and carriage returns (tesseract)
-                while len(block_text) > 0 and block_text[-1] in ["\n", "\r"]:
-                    block_text = block_text[:-1]
-
-                block_text = block_text.replace("-\n", "") # Remove hyphenated line breaks
-                span_obj = Span(
-                    text=block_text, # Remove end of line newlines, not spaces
-                    bbox=s["bbox"],
-                    span_id=f"{pnum}_{span_id}",
-                    font=f"{s['font']['name']}_{font_flags_decomposer(s['font']['flags'])}", # Add font flags to end of font
-                    font_weight=s["font"]["weight"],
-                    font_size=s["font"]["size"],
-                )
-                spans.append(span_obj)  # Text, bounding box, span id
-                span_id += 1
-            line_obj = Line(
-                spans=spans,
-                bbox=l["bbox"],
-            )
-            # Only select valid lines, with positive bboxes
-            if line_obj.area >= 0:
-                block_lines.append(line_obj)
-
-            # Each block is a single line
-            block_obj = Block(
-                lines=block_lines,
-                bbox=l["bbox"],
-                pnum=pnum
-            )
-            # Only select blocks with lines
-            if len(block_lines) > 0:
-                page_blocks.append(block_obj)
-
-    page_bbox = page["bbox"]
-    page_width = abs(page_bbox[2] - page_bbox[0])
-    page_height = abs(page_bbox[3] - page_bbox[1])
-    rotation = page["rotation"]
-
-    # Flip width and height if rotated
-    if rotation == 90 or rotation == 270:
-        page_width, page_height = page_height, page_width
-
-    char_blocks = page["blocks"]
-    page_bbox = [0, 0, page_width, page_height]
-    out_page = Page(
-        blocks=page_blocks,
-        pnum=page["page"],
-        bbox=page_bbox,
-        rotation=rotation,
-        char_blocks=char_blocks
-    )
-    return out_page
-
-
-def get_text_blocks(doc, fname, max_pages: Optional[int] = None, start_page: Optional[int] = None) -> (List[Page], Dict):
-    toc = get_pdf_toc(doc)
-
-    if start_page:
-        assert start_page < len(doc)
-    else:
-        start_page = 0
-
-    if max_pages:
-        if max_pages + start_page > len(doc):
-            max_pages = len(doc) - start_page
-    else:
-        max_pages = len(doc) - start_page
-
-    page_range = range(start_page, start_page + max_pages)
-
-    char_blocks = dictionary_output(fname, page_range=page_range, keep_chars=False, workers=settings.PDFTEXT_CPU_WORKERS, flatten_pdf=settings.FLATTEN_PDF)
-    marker_blocks = [pdftext_format_to_blocks(page, pnum) for pnum, page in enumerate(char_blocks)]
-
-    return marker_blocks, toc
-
-
-def naive_get_text(doc):
-    full_text = ""
-    for page_idx in range(len(doc)):
-        page = doc.get_page(page_idx)
-        text_page = page.get_textpage()
-        full_text += text_page.get_text_bounded() + "\n"
-    return full_text
-
-
-def get_length_of_text(fname: str) -> int:
-    doc = pdfium.PdfDocument(fname)
-    text = naive_get_text(doc).strip()
-
-    return len(text)

marker/pdf/images.py

@@ -1,27 +0,0 @@
-import pypdfium2 as pdfium
-from pypdfium2 import PdfPage
-
-from marker.schema.page import Page
-from marker.schema.bbox import rescale_bbox
-from marker.settings import settings
-
-
-def render_image(page: pdfium.PdfPage, dpi):
-    image = page.render(
-        scale=dpi / 72,
-        draw_annots=False
-    ).to_pil()
-    image = image.convert("RGB")
-    return image
-
-
-def render_bbox_image(page_obj: PdfPage, page: Page, bbox):
-    png_image = render_image(page_obj, settings.IMAGE_DPI)
-    # Rescale original pdf bbox bounds to match png image size
-    png_bbox = [0, 0, png_image.size[0], png_image.size[1]]
-    rescaled_merged = rescale_bbox(page.bbox, png_bbox, bbox)
-
-    # Crop out only the equation image
-    png_image = png_image.crop(rescaled_merged)
-    png_image = png_image.convert("RGB")
-    return png_image

marker/pdf/utils.py

@@ -1,75 +0,0 @@
-from typing import Optional
-
-import filetype
-
-from marker.settings import settings
-
-
-def find_filetype(fpath):
-    kind = filetype.guess(fpath)
-    if kind is None:
-        print(f"Could not determine filetype for {fpath}")
-        return "other"
-
-    mimetype = kind.mime
-
-    # Get extensions from mimetype
-    # The mimetype is not always consistent, so use in to check the most common formats
-    if "pdf" in mimetype:
-        return "pdf"
-    elif mimetype in settings.SUPPORTED_FILETYPES:
-        return settings.SUPPORTED_FILETYPES[mimetype]
-    else:
-        print(f"Found nonstandard filetype {mimetype}")
-        return "other"
-
-
-def font_flags_decomposer(flags: Optional[int]) -> str:
-    if flags is None:
-        return ""
-
-    flag_descriptions = []
-    if flags & (1 << 0):  # PDFFONT_FIXEDPITCH
-        flag_descriptions.append("fixed_pitch")
-    if flags & (1 << 1):  # PDFFONT_SERIF
-        flag_descriptions.append("serif")
-    if flags & (1 << 2):  # PDFFONT_SYMBOLIC
-        flag_descriptions.append("symbolic")
-    if flags & (1 << 3):  # PDFFONT_SCRIPT
-        flag_descriptions.append("script")
-    if flags & (1 << 5):  # PDFFONT_NONSYMBOLIC
-        flag_descriptions.append("non_symbolic")
-    if flags & (1 << 6):  # PDFFONT_ITALIC
-        flag_descriptions.append("italic")
-    if flags & (1 << 16): # PDFFONT_ALLCAP
-        flag_descriptions.append("all_cap")
-    if flags & (1 << 17): # PDFFONT_SMALLCAP
-        flag_descriptions.append("small_cap")
-    if flags & (1 << 18): # PDFFONT_FORCEBOLD
-        flag_descriptions.append("bold")
-    if flags & (1 << 19): # PDFFONT_USEEXTERNATTR
-        flag_descriptions.append("use_extern_attr")
-
-    return "_".join(flag_descriptions)
-
-
-def sort_block_group(blocks, tolerance=1.25):
-    vertical_groups = {}
-    for block in blocks:
-        if hasattr(block, "bbox"):
-            bbox = block.bbox
-        else:
-            bbox = block["bbox"]
-
-        group_key = round(bbox[1] / tolerance) * tolerance
-        if group_key not in vertical_groups:
-            vertical_groups[group_key] = []
-        vertical_groups[group_key].append(block)
-
-    # Sort each group horizontally and flatten the groups into a single list
-    sorted_blocks = []
-    for _, group in sorted(vertical_groups.items()):
-        sorted_group = sorted(group, key=lambda x: x.bbox[0] if hasattr(x, "bbox") else x["bbox"][0])
-        sorted_blocks.extend(sorted_group)
-
-    return sorted_blocks

marker/postprocessors/markdown.py

@@ -1,254 +0,0 @@
-from marker.schema.merged import MergedLine, MergedBlock, FullyMergedBlock
-from marker.schema.page import Page
-import re
-import regex
-from typing import List
-from copy import deepcopy
-
-from marker.settings import settings
-
-
-def escape_markdown(text):
-    # List of characters that need to be escaped in markdown
-    characters_to_escape = r"[#]"
-    # Escape each of these characters with a backslash
-    escaped_text = re.sub(characters_to_escape, r'\\\g<0>', text)
-    return escaped_text
-
-
-def surround_text(s, char_to_insert):
-    leading_whitespace = re.match(r'^(\s*)', s).group(1)
-    trailing_whitespace = re.search(r'(\s*)$', s).group(1)
-    stripped_string = s.strip()
-    modified_string = char_to_insert + stripped_string + char_to_insert
-    final_string = leading_whitespace + modified_string + trailing_whitespace
-    return final_string
-
-
-def merge_spans(pages: List[Page]) -> List[List[MergedBlock]]:
-    merged_blocks = []
-    for page in pages:
-        page_blocks = []
-        for blocknum, block in enumerate(page.blocks):
-            block_lines = []
-            for linenum, line in enumerate(block.lines):
-                line_text = ""
-                if len(line.spans) == 0:
-                    continue
-                fonts = []
-                for i, span in enumerate(line.spans):
-                    font = span.font.lower()
-                    next_span = None
-                    next_idx = 1
-                    while len(line.spans) > i + next_idx:
-                        next_span = line.spans[i + next_idx]
-                        next_idx += 1
-                        if len(next_span.text.strip()) > 2:
-                            break
-
-                    fonts.append(font)
-                    span_text = span.text
-
-                    # Don't bold or italicize very short sequences
-                    # Avoid bolding first and last sequence so lines can be joined properly
-                    if len(span_text) > 3 and 0 < i < len(line.spans) - 1:
-                        if span.italic and (not next_span or not next_span.italic):
-                            span_text = surround_text(span_text, "*")
-                        elif span.bold and (not next_span or not next_span.bold):
-                            span_text = surround_text(span_text, "**")
-                    line_text += span_text
-                block_lines.append(MergedLine(
-                    text=line_text,
-                    fonts=fonts,
-                    bbox=line.bbox
-                ))
-            if len(block_lines) > 0:
-                page_blocks.append(MergedBlock(
-                    lines=block_lines,
-                    pnum=page.pnum,
-                    bbox=block.bbox,
-                    block_type=block.block_type,
-                    heading_level=block.heading_level
-                ))
-        if len(page_blocks) == 0:
-            page_blocks.append(MergedBlock(
-                lines=[],
-                pnum=page.pnum,
-                bbox=page.bbox,
-                block_type="Text",
-                heading_level=None
-            ))
-        merged_blocks.append(page_blocks)
-
-    return merged_blocks
-
-
-def block_surround(text, block_type, heading_level):
-    if block_type == "Section-header":
-        if not text.startswith("#"):
-            asterisks = "#" * heading_level if heading_level is not None else "##"
-            text = f"\n{asterisks} " + text.strip().title() + "\n"
-    elif block_type == "Title":
-        if not text.startswith("#"):
-            text = "# " + text.strip().title() + "\n"
-    elif block_type == "Table":
-        text = "\n" + text + "\n"
-    elif block_type == "List-item":
-        text = escape_markdown(text.rstrip()) + "\n"
-    elif block_type == "Code":
-        text = "\n```\n" + text + "\n```\n"
-    elif block_type == "Text":
-        text = escape_markdown(text)
-    elif block_type == "Formula":
-        if text.strip().startswith("$$") and text.strip().endswith("$$"):
-            text = text.strip()
-            text = "\n" + text + "\n"
-    elif block_type == "Caption":
-        text = "\n" + escape_markdown(text) + "\n"
-    return text
-
-
-def line_separator(block_text: str, prev_line: MergedLine, line: MergedLine, block_type: str, new_column: bool, new_page: bool, new_block: bool) -> str:
-    lowercase_letters = r'\p{Ll}|\d'
-    hyphens = r'-—¬'
-
-    hyphen_regex = regex.compile(rf'.*[{hyphens}]\s?$', regex.DOTALL)
-    hyphens_lowercase_regex = regex.compile(rf'.*[{lowercase_letters}][{hyphens}]\s?$', regex.DOTALL)
-    line_starts_lowercase = regex.match(rf"^\s?[{lowercase_letters}]", line.text)
-    prev_has_reference = regex.match(r"^\[\d+\]\s+[A-Z]", prev_line.text)
-    has_reference = regex.match(r"^\[\d+\]\s+[A-Z]", line.text)
-    has_numbered_item = regex.match(r"^\d+:\s+", line.text)
-    
-    line_text = line.text.lstrip()
-    block_text = block_text.rstrip()
-
-    if block_type in ["Text", "List-item", "Footnote", "Caption", "Figure"]:
-        if has_reference or has_numbered_item:
-            return block_text + "\n\n" + line_text
-        elif hyphen_regex.match(block_text):
-            if line_starts_lowercase and hyphens_lowercase_regex.match(block_text):
-                return regex.split(rf"[{hyphens}]\s?$", block_text)[0].rstrip() + line_text
-            return block_text + line_text
-        elif new_page or new_column:
-            if line_starts_lowercase:
-                return block_text + " " + line_text
-            return block_text + "\n\n" + line_text
-        elif new_block:
-            if prev_has_reference:
-                return block_text + " " + line_text
-            return block_text + "\n\n" + line_text
-        else:
-            # General case for joining lines with a space
-            return block_text + " " + line_text
-    elif block_type in ["Title", "Section-header"]:
-        return block_text + " " + line_text
-    elif block_type in ["Formula"]:
-        return block_text + "\n" + line_text
-    elif block_type in ["Code", "Table"]:
-        return block_text + "\n\n" + line_text
-    else:
-        return block_text + " " + line_text
-
-
-def block_separator(prev_block: FullyMergedBlock, block: FullyMergedBlock):
-    sep = "\n"
-    if prev_block.block_type == "Text":
-        sep = "\n\n"
-
-    return sep + block.text
-
-def merge_lines(blocks: List[List[MergedBlock]], min_new_block_x_indent_percent=5.0):
-    text_blocks = []
-    prev_block = None
-    prev_type = None
-    prev_line = None
-    block_text = ""
-    block_type = ""
-    prev_heading_level = None
-    pnum = None
-
-    for page_id, page in enumerate(blocks):
-        # Insert pagination at every page boundary
-        if settings.PAGINATE_OUTPUT:
-            if block_text:
-                text_blocks.append(
-                    FullyMergedBlock(
-                        text=block_surround(block_text, prev_type, prev_heading_level),
-                        block_type=prev_type if prev_type else settings.DEFAULT_BLOCK_TYPE,
-                        page_start=False,
-                        pnum=pnum
-                    )
-                )
-                block_text = ""
-            text_blocks.append(
-                FullyMergedBlock(
-                    text="",
-                    block_type="Text",
-                    page_start=True,
-                    pnum=page[0].pnum
-                )
-            )
-        for block_id, block in enumerate(page):
-            first_block_in_page = block_id == 0
-            block_type = block.block_type
-            if (block_type != prev_type and prev_type) or (block.heading_level != prev_heading_level and prev_heading_level):
-                text_blocks.append(
-                    FullyMergedBlock(
-                        text=block_surround(block_text, prev_type, prev_heading_level),
-                        block_type=prev_type if prev_type else settings.DEFAULT_BLOCK_TYPE,
-                        page_start=False,
-                        pnum=block.pnum
-                    )
-                )
-                block_text = ""
-            # Join lines in the block together properly
-            for line_id, line in enumerate(block.lines):
-                first_line_in_block = line_id == 0
-                if prev_line is None:
-                    prev_line = deepcopy(line)
-                if prev_block is None:
-                    prev_block = deepcopy(block)
-                x_indent = line.x_start - prev_line.x_start 
-                y_indent = line.y_start - prev_line.y_start
-                new_line = y_indent > prev_line.height
-                new_column = line.x_start > prev_block.x_end
-                new_block = first_line_in_block or \
-                    ( # we consider it a new block when there's an x indent from the previous line and it's a new line (y indent)
-                        ((x_indent/block.width) * 100) > min_new_block_x_indent_percent and new_line
-                    )
-                new_page = first_line_in_block and first_block_in_page
-                if block_text:
-                    block_text = line_separator(block_text, prev_line, line, block_type, new_column, new_page, new_block)
-                else:
-                    block_text = line.text
-                prev_line = line
-                prev_block = block
-            prev_type = block_type
-            prev_heading_level = block.heading_level
-            pnum = block.pnum
-    # Append the final block
-    text_blocks.append(
-        FullyMergedBlock(
-            text=block_surround(block_text, prev_type, prev_heading_level),
-            block_type=block_type if block_type else settings.DEFAULT_BLOCK_TYPE,
-            page_start=False,
-            pnum=pnum
-        )
-    )
-
-    text_blocks = [block for block in text_blocks if (block.text.strip() or block.page_start)]
-    return text_blocks
-
-
-def get_full_text(text_blocks):
-    full_text = ""
-    prev_block = None
-    for block in text_blocks:
-        if block.page_start:
-            full_text += "\n\n{" + str(block.pnum) + "}" + settings.PAGE_SEPARATOR
-        elif prev_block:
-            full_text += block_separator(prev_block, block)
-        else:
-            full_text += block.text
-        prev_block = block
-    return full_text

marker/{v2/processors → processors}/__init__.py

@@ -2,9 +2,9 @@ from typing import Optional, Tuple
 
 from pydantic import BaseModel
 
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
-from marker.v2.util import assign_config
+from marker.schema import BlockTypes
+from marker.schema.document import Document
+from marker.util import assign_config
 
 
 class BaseProcessor:

marker/{v2/processors → processors}/code.py

@@ -1,7 +1,7 @@
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.blocks import Code
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.blocks import Code
+from marker.schema.document import Document
 
 
 class CodeProcessor(BaseProcessor):

marker/{v2/processors → processors}/debug.py

@@ -5,9 +5,9 @@ import requests
 from PIL import Image, ImageDraw, ImageFont
 
 from marker.settings import settings
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
 
 
 class DebugProcessor(BaseProcessor):

marker/{v2/processors → processors}/document_toc.py

@@ -1,6 +1,6 @@
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
 
 
 class DocumentTOCProcessor(BaseProcessor):

marker/{v2/processors → processors}/equation.py

@@ -5,9 +5,9 @@ from texify.model.model import GenerateVisionEncoderDecoderModel
 from tqdm import tqdm
 
 from marker.settings import settings
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
 
 
 class EquationProcessor(BaseProcessor):

marker/{v2/processors → processors}/ignoretext.py

@@ -1,8 +1,8 @@
 from collections import Counter
 
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
 
 
 class IgnoreTextProcessor(BaseProcessor):

marker/{v2/processors → processors}/sectionheader.py

@@ -1,6 +1,6 @@
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
 
 from typing import Dict, List
 import numpy as np

marker/{v2/processors → processors}/table.py

@@ -7,9 +7,9 @@ from tabled.assignment import assign_rows_columns
 from tabled.inference.recognition import get_cells, recognize_tables
 
 from marker.settings import settings
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
 
 
 class TableProcessor(BaseProcessor):

marker/{v2/processors → processors}/text.py

@@ -3,10 +3,10 @@ from typing import List
 
 import regex
 
-from marker.v2.processors import BaseProcessor
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.document import Document
-from marker.v2.schema.text.line import Line
+from marker.processors import BaseProcessor
+from marker.schema import BlockTypes
+from marker.schema.document import Document
+from marker.schema.text.line import Line
 
 
 class TextProcessor(BaseProcessor):

marker/{v2/providers → providers}/__init__.py

@@ -2,9 +2,9 @@ from typing import List, Optional, Dict
 
 from pydantic import BaseModel
 
-from marker.v2.schema.text import Span
-from marker.v2.schema.text.line import Line
-from marker.v2.util import assign_config
+from marker.schema.text import Span
+from marker.schema.text.line import Line
+from marker.util import assign_config
 
 
 class ProviderOutput(BaseModel):

marker/{v2/providers → providers}/pdf.py

@@ -1,18 +1,19 @@
 import atexit
 import functools
+import re
 from typing import List, Set
 
 import pypdfium2 as pdfium
 from pdftext.extraction import dictionary_output
 from PIL import Image
 
-from marker.ocr.heuristics import detect_bad_ocr
-from marker.v2.providers import BaseProvider, ProviderOutput, ProviderPageLines
-from marker.v2.schema.polygon import PolygonBox
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.registry import get_block_class
-from marker.v2.schema.text.line import Line
-from marker.v2.schema.text.span import Span
+from marker.providers.utils import alphanum_ratio
+from marker.providers import BaseProvider, ProviderOutput, ProviderPageLines
+from marker.schema.polygon import PolygonBox
+from marker.schema import BlockTypes
+from marker.schema.registry import get_block_class
+from marker.schema.text.line import Line
+from marker.schema.text.span import Span
 
 
 class PdfProvider(BaseProvider):
@@ -20,6 +21,10 @@ class PdfProvider(BaseProvider):
     pdftext_workers: int = 4
     flatten_pdf: bool = True
     force_ocr: bool = False
+    ocr_invalid_chars: tuple = (chr(0xfffd), "�")
+    ocr_space_threshold: float = .7
+    ocr_newline_threshold: float = .6
+    ocr_alphanum_threshold: float = .3
 
     def __init__(self, filepath: str, config=None):
         super().__init__(filepath, config)
@@ -153,10 +158,34 @@ class PdfProvider(BaseProvider):
             text = text + "\n"
         if len(text.strip()) == 0:
             return False
-        if detect_bad_ocr(text):
+        if self.detect_bad_ocr(text):
             return False
         return True
 
+    def detect_bad_ocr(self, text):
+        if len(text) == 0:
+            # Assume OCR failed if we have no text
+            return True
+
+        spaces = len(re.findall(r'\s+', text))
+        alpha_chars = len(re.sub(r'\s+', '', text))
+        if spaces / (alpha_chars + spaces) > self.ocr_space_threshold:
+            return True
+
+        newlines = len(re.findall(r'\n+', text))
+        non_newlines = len(re.sub(r'\n+', '', text))
+        if newlines / (newlines + non_newlines) > self.ocr_newline_threshold:
+            return True
+
+        if alphanum_ratio(text) < self.ocr_alphanum_threshold:  # Garbled text
+            return True
+
+        invalid_chars = len([c for c in text if c in self.ocr_invalid_chars])
+        if invalid_chars > max(6.0, len(text) * .03):
+            return True
+
+        return False
+
     @functools.lru_cache(maxsize=None)
     def get_image(self, idx: int, dpi: int) -> Image.Image:
         page = self.doc[idx]

marker/{ocr → providers}/utils.py

@@ -1,3 +1,6 @@
+import re
+
+
 def alphanum_ratio(text):
     text = text.replace(" ", "")
     text = text.replace("\n", "")
@@ -7,4 +10,4 @@ def alphanum_ratio(text):
         return 1
 
     ratio = alphanumeric_count / len(text)
-    return ratio
+    return ratio

marker/{v2/renderers → renderers}/__init__.py

@@ -6,9 +6,9 @@ from typing import Optional
 from bs4 import BeautifulSoup
 from pydantic import BaseModel
 
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.blocks.base import BlockOutput, BlockId
-from marker.v2.util import assign_config
+from marker.schema import BlockTypes
+from marker.schema.blocks.base import BlockOutput, BlockId
+from marker.util import assign_config
 
 
 class BaseRenderer:

marker/{v2/renderers → renderers}/html.py

@@ -3,9 +3,9 @@ import re
 from bs4 import BeautifulSoup, MarkupResemblesLocatorWarning
 from pydantic import BaseModel
 
-from marker.v2.renderers import BaseRenderer
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.blocks import BlockId
+from marker.renderers import BaseRenderer
+from marker.schema import BlockTypes
+from marker.schema.blocks import BlockId
 
 # Ignore beautifulsoup warnings
 import warnings

marker/{v2/renderers → renderers}/json.py

@@ -7,11 +7,11 @@ from typing import List, Dict
 from bs4 import BeautifulSoup
 from pydantic import BaseModel
 
-from marker.v2.schema.blocks import Block
-from marker.v2.renderers import BaseRenderer
-from marker.v2.schema import BlockTypes
-from marker.v2.schema.blocks import BlockId
-from marker.v2.schema.registry import get_block_class
+from marker.schema.blocks import Block
+from marker.renderers import BaseRenderer
+from marker.schema import BlockTypes
+from marker.schema.blocks import BlockId
+from marker.schema.registry import get_block_class
 
 
 class JSONBlockOutput(BaseModel):