Esempi in Python per get_log_dir

Esempio n. 1

File: test_write_blobs.py Progetto: tieugene/ptext-release

from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import HSVColor
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import (
    Alignment, )
from ptext.pdf.canvas.layout.shape import Shape
from ptext.pdf.canvas.layout.table import Table, TableCell
from ptext.pdf.canvas.line_art.blob_factory import BlobFactory
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(filename=Path(get_log_dir(), "test-write-blobs.log"),
                    level=logging.DEBUG)


class TestWriteBlobs(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-blobs")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create document

Esempio n. 2

File: test_write_paragraph_justified_center_with_padding_and_border.py Progetto: tieugene/ptext-release

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.canvas.layout.paragraph import (
    Alignment,
    Paragraph,
)
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(
        get_log_dir(),
        "test-write-paragraph-justified-center-with-padding-and-border.log",
    ),
    level=logging.DEBUG,
)


class TestWriteParagraphJustifiedCenterWithPaddingAndBorder(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(
            get_output_dir(),
            "test-write-paragraph-justified-center-with-padding-and-border",
        )

    def test_write_document(self):

Esempio n. 3

import logging
import unittest
from pathlib import Path

from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(filename=Path(get_log_dir(),
                                  "test-write-empty-document.log"),
                    level=logging.DEBUG)


class TestWriteEmptyDocument(unittest.TestCase):
    """
    This test attempts to extract the text of each PDF in the corpus
    """
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-empty-document")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create empty document
        pdf: Document = Document()

Esempio n. 4

import logging
import time
import typing
from pathlib import Path

from ptext.pdf.pdf import PDF
from tests.test import Test
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-copy-document-compare-size.log"),
    level=logging.DEBUG,
)


class TestCopyDocumentCompareSize(Test):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.size_tuples: typing.Dictionary[str, typing.Tuple[int, int]] = {}
        self.output_dir = Path(get_output_dir(),
                               "test-copy-document-compare-size")

    def test_exact_document(self):
        self.test_document(Path("/home/joris/Code/pdf-corpus/0203.pdf"))

    def test_corpus(self):
        super(TestCopyDocumentCompareSize, self).test_corpus()

    def test_previous_fails(self):
        self.maximum_test_time = 60
        super(TestCopyDocumentCompareSize, self).test_previous_fails()

Esempio n. 5

File: test_write_paragraph_justified_right.py Progetto: tieugene/ptext-release

from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.canvas.layout.paragraph import (
    Alignment,
    Paragraph,
)
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-paragraph-justified-right.log"),
    level=logging.DEBUG,
)


class TestWriteParagraphJustifiedRight(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-paragraph-justified-right")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

Esempio n. 6

import logging
import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.canvas.layout.paragraph import ChunkOfText
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-chunk-of-text-e-aigu.log"),
    level=logging.DEBUG,
)


class TestWriteChunkOfTextEAigu(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-chunk-of-text-e-aigu")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create document

Esempio n. 7

File: test_write_100_star_shapes.py Progetto: tieugene/ptext-release

from ptext.pdf.canvas.color.color import X11Color, Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import (
    Paragraph,
)
from ptext.pdf.canvas.layout.shape import Shape
from ptext.pdf.canvas.layout.table import Table
from ptext.pdf.canvas.line_art.line_art_factory import LineArtFactory
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-100-star-shapes.log"), level=logging.DEBUG
)


class TestWrite100StarShapes(unittest.TestCase):

    COLORS = [
        X11Color("Red"),
        X11Color("Orange"),
        X11Color("Yellow"),
        X11Color("YellowGreen"),
        X11Color("Blue"),
        X11Color("Purple"),
    ]

    def __init__(self, methodName="runTest"):

Esempio n. 8

File: test_add_text_annotation.py Progetto: tieugene/ptext-release

import logging
import unittest
from decimal import Decimal
from pathlib import Path

from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.page.page import TextAnnotationIconType
from ptext.pdf.pdf import PDF
from tests.test import Test
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-add-text-annotation.log"),
    level=logging.DEBUG,
)


class TestAddTextAnnotation(Test):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-add-text-annotation")

    def test_exact_document(self):
        self._test_document(Path("/home/joris/Code/pdf-corpus/0200.pdf"))

    @unittest.skip
    def test_corpus(self):
        super(TestAddTextAnnotation, self).test_corpus()

    def _test_document(self, file):

Esempio n. 9

File: test_write_paragraphs_with_headings.py Progetto: tieugene/ptext-release

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.layout.page_layout import MultiColumnLayout
from ptext.pdf.canvas.layout.paragraph import (
    Alignment,
    Paragraph,
    Heading,
)
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-paragraphs-with-headings.log"),
    level=logging.DEBUG,
)


class TestWriteParagraphsWithHeadings(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-paragraphs-with-headings")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

Esempio n. 10

import logging
import unittest
from decimal import Decimal
from pathlib import Path

from ptext.pdf.canvas.color.color import HexColor
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-add-underline-annotation.log"),
    level=logging.DEBUG,
)


class TestAddUnderlineAnnotation(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.input_file = Path("/home/joris/Code/pdf-corpus/0203.pdf")
        self.output_file = Path(get_output_dir(),
                                "test-add-underline-annotation/output.pdf")

    def test_add_underline_annotation(self):

        # create output directory if it does not exist yet
        if not self.output_file.parent.exists():
            self.output_file.parent.mkdir()

        # attempt to read PDF
        doc = None

Esempio n. 11

import logging
import unittest
from pathlib import Path

from ptext.pdf.document import Document
from ptext.pdf.pdf import PDF
from tests.test import Test
from tests.util import get_output_dir, get_log_dir

logging.basicConfig(filename=Path(get_log_dir(), "test-concat-documents.log"),
                    level=logging.DEBUG)


class TestConcatDocuments(Test):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-concat-documents")
        self.input_file_b = self.input_dir / "0200.pdf"

    @unittest.skip
    def test_corpus(self):
        super(TestConcatDocuments, self).test_corpus()

    def _test_document(self, file):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # determine output location
        out_file = self.output_dir / (file.stem + "_out.pdf")

Esempio n. 12

File: test_add_strikeout_annotation.py Progetto: tieugene/ptext-release

import logging
import unittest
from decimal import Decimal
from pathlib import Path

from ptext.pdf.canvas.color.color import HexColor
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-add-strike-out-annotation.log"),
    level=logging.DEBUG,
)


class TestAddStrikeOutAnnotation(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.input_file = Path("/home/joris/Code/pdf-corpus/0203.pdf")
        self.output_file = Path(get_output_dir(),
                                "test-add-strike-out-annotation/output.pdf")

    def test_add_strike_out_annotation(self):

        # create output directory if it does not exist yet
        if not self.output_file.parent.exists():
            self.output_file.parent.mkdir()

        # attempt to read PDF
        doc = None

Esempio n. 13

File: test_write_multiple_pages.py Progetto: tieugene/ptext-release

import logging
import unittest
from pathlib import Path

from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import (
    Paragraph, )
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_output_dir, get_log_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-multiple-pages.log"),
    level=logging.DEBUG,
)


class TestWriteMultiplePages(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-multiple-pages")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create document
        pdf = Document()

Esempio n. 14

import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.canvas.layout.layout_element import Alignment
from ptext.pdf.canvas.layout.paragraph import (
    Paragraph, )
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-paragraph-alignment.log"),
    level=logging.DEBUG,
)


class TestWriteParagraphAlignment(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-paragraph-alignment")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

Esempio n. 15

import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.layout.image import Image
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.canvas.layout.table import Table
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-find-the-odd-one.log"), level=logging.DEBUG
)


class TestWriteFindTheOddOne(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-find-the-odd-one")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create document

Esempio n. 16

import unittest
from pathlib import Path

import requests
from PIL import Image as PILImage

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.layout.image import Image
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-simple-image.log"), level=logging.DEBUG
)


class TestWriteSimpleImage(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-simple-image")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create empty document

Esempio n. 17

import logging
import unittest
from decimal import Decimal
from pathlib import Path

from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.page.page import RubberStampAnnotationIconType
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-add-rubber-stamp-annotation.log"),
    level=logging.DEBUG,
)


class TestAddRubberStampAnnotation(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.input_file = Path("/home/joris/Code/pdf-corpus/0203.pdf")
        self.output_file = Path(get_output_dir(),
                                "test-add-rubber-stamp-annotation/output.pdf")

    def test_add_rubber_stamp_annotation(self):

        # create output directory if it does not exist yet
        if not self.output_file.parent.exists():
            self.output_file.parent.mkdir()

        # attempt to read PDF

Esempio n. 18

File: test_write_nonogram.py Progetto: tieugene/ptext-release

import logging
import typing
import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph, Alignment
from ptext.pdf.canvas.layout.table import Table, TableCell
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(filename=Path(get_log_dir(), "test-write-nonogram.log"),
                    level=logging.DEBUG)

import requests
from PIL import Image as PILImage  # type: ignore [import]


class Nonogram(Table):
    @staticmethod
    def _convert_png_to_jpg(image: PILImage.Image) -> PILImage.Image:

        # omit transparency
        fill_color = (255, 255, 255)  # new background color
        image_out = image.convert("RGBA")  # it had mode P after DL it from OP
        if image_out.mode in ("RGBA", "LA"):
            background = PILImage.new(image_out.mode[:-1], image_out.size,

Esempio n. 19

File: test_write_nested_unordered_list.py Progetto: tieugene/ptext-release

import logging
import unittest
from pathlib import Path

from ptext.pdf.canvas.layout.list import UnorderedList
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_output_dir, get_log_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-nested-unordered-list.log"),
    level=logging.DEBUG,
)


class TestWriteNestedUnorderedList(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-nested-unordered-list")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create document

Esempio n. 20

File: test_write_silhouette_maze.py Progetto: tieugene/ptext-release

                )
                black_dist = self._dist(pixels[(i, self.height - j - 1)], (0, 0, 0))
                if white_dist < black_dist:
                    self.cells[i][j] = -1
                    remaining_pixels -= 1
        # call super to fill maze
        self._build_maze()
        self._make_gap()
        self._make_gap(reverse_scan_order=True)

    def _dist(self, t0, t1):
        return (t0[0] - t1[0]) ** 2 + (t0[1] - t1[1]) ** 2 + (t0[2] - t1[2]) ** 2


logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-silhouette-maze.log"), level=logging.DEBUG
)


class TestWriteMaze(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-silhouette-maze")

    def _write_maze_page(self, pdf: Document, maze_url: str, title_color: str):

        # add page
        page = Page()
        pdf.append_page(page)

        # generate maze

Esempio n. 21

import logging
import unittest
from pathlib import Path

from ptext.pdf.canvas.layout.list import OrderedList
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_output_dir, get_log_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-simple-ordered-list.log"),
    level=logging.DEBUG,
)


class TestWriteSimpleOrderedList(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-simple-ordered-list")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create document

Esempio n. 22

from ptext.pdf.canvas.font.font import Font

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.font.simple_font.font_type_1 import StandardType1Font
from ptext.pdf.canvas.font.simple_font.true_type_font import TrueTypeFont
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph, Alignment
from ptext.pdf.canvas.layout.table import Table
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-simple-table-accents.log"),
    level=logging.DEBUG,
)


class TestWriteSimpleTableAccents(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-simple-table-accents")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

Esempio n. 23

File: test_write_alphabet_number_code_puzzle.py Progetto: tieugene/ptext-release

import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.layout.layout_element import Alignment
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.canvas.layout.table import Table, TableCell
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-alphabet-number-code-puzzle.log"),
    level=logging.DEBUG,
)


class TestWriteAlphabetNumberCodePuzzle(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(
            get_output_dir(), "test-write-alphabet-number-code-puzzle"
        )

    def _build_table_for_sentence(self, sentence: str) -> Table:
        t = Table(number_of_columns=len(sentence), number_of_rows=3)
        for c in sentence:
            if c in [".", "?", "!", ",", " "]:

Esempio n. 24

File: test_write_table_of_barcodes.py Progetto: tieugene/ptext-release

import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import HexColor
from ptext.pdf.canvas.layout.barcode import Barcode, BarcodeType
from ptext.pdf.canvas.layout.page_layout import SingleColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.canvas.layout.table import Table
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-table-of-barcodes.log"),
    level=logging.DEBUG,
)


class TestWriteTableOfBarcodes(unittest.TestCase):
    """
    This test attempts to extract the text of each PDF in the corpus
    """
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-table-of-barcodes")

    def test_write_document(self):

Esempio n. 25

import unittest
from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.canvas.layout.layout_element import Alignment
from ptext.pdf.canvas.layout.paragraph import (
    Paragraph, )
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-paragraph-with-background.log"),
    level=logging.DEBUG,
)


class TestWriteParagraphWithBackground(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-paragraph-with-background")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

Esempio n. 26

File: test_concat_documents_2.py Progetto: tieugene/ptext-release

import logging
import unittest
from pathlib import Path

from ptext.pdf.document import Document
from ptext.pdf.pdf import PDF
from tests.test import Test
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-concat-documents-2.log"), level=logging.DEBUG
)


class TestConcatDocuments2(Test):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-concat-documents-2")
        self.input_file_b = self.input_dir / "0118.pdf"

    @unittest.skip
    def test_corpus(self):
        super(TestConcatDocuments2, self).test_corpus()

    def test_exact_document(self):
        self._test_document(Path("/home/joris/Code/pdf-corpus/0203.pdf"))

    def _test_document(self, file):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():

Esempio n. 27

File: test_write_you_and_me.py Progetto: lzg440/ptext-release

from pathlib import Path

from PIL import Image as PILImage

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.layout.image import Image
from ptext.pdf.canvas.layout.page_layout import MultiColumnLayout
from ptext.pdf.canvas.layout.paragraph import Paragraph
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-you-and-me.log"), level=logging.DEBUG
)


class TestWriteYouAndMe(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(), "test-write-you-and-me")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

        # create empty document

Esempio n. 28

File: test_write_paragraph_force_split.py Progetto: tieugene/ptext-release

from pathlib import Path

from ptext.io.read.types import Decimal
from ptext.pdf.canvas.color.color import HexColor
from ptext.pdf.canvas.layout.page_layout import MultiColumnLayout
from ptext.pdf.canvas.layout.paragraph import (
    Alignment,
    Paragraph,
)
from ptext.pdf.document import Document
from ptext.pdf.page.page import Page
from ptext.pdf.pdf import PDF
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-write-paragraph-force-split.log"),
    level=logging.DEBUG,
)


class TestWriteParagraphForceSplit(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(get_output_dir(),
                               "test-write-paragraph-force-split")

    def test_write_document(self):

        # create output directory if it does not exist yet
        if not self.output_dir.exists():
            self.output_dir.mkdir()

Esempio n. 29

import logging
import unittest
from pathlib import Path

from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.pdf import PDF
from ptext.toolkit.text.regular_expression_text_extraction import (
    RegularExpressionTextExtraction, )
from tests.test import Test
from tests.util import get_log_dir, get_output_dir

logging.basicConfig(
    filename=Path(get_log_dir(),
                  "test-add-square-annotation-around-regular-expression.log"),
    level=logging.DEBUG,
)


class TestAddSquareAnnotationAroundRegularExpression(Test):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.output_dir = Path(
            get_output_dir(),
            "test-add-square-annotation-around-regular-expression")

    def test_exact_document(self):
        self._test_document(Path("/home/joris/Code/pdf-corpus/0203.pdf"))

    @unittest.skip
    def test_corpus(self):
        super(TestAddSquareAnnotationAroundRegularExpression,

Esempio n. 30

File: test_add_circle_annotation.py Progetto: tieugene/ptext-release

import logging
import unittest
from decimal import Decimal
from pathlib import Path

from ptext.pdf.canvas.color.color import X11Color
from ptext.pdf.canvas.geometry.rectangle import Rectangle
from ptext.pdf.pdf import PDF
from tests.util import get_output_dir, get_log_dir

logging.basicConfig(
    filename=Path(get_log_dir(), "test-add-circle-annotation.log"), level=logging.DEBUG
)


class TestAddCircleAnnotation(unittest.TestCase):
    def __init__(self, methodName="runTest"):
        super().__init__(methodName)
        self.input_file = Path("/home/joris/Code/pdf-corpus/0203.pdf")
        self.output_file = Path(
            get_output_dir(), "test-add-circle-annotation/output.pdf"
        )

    def test_add_circle_annotation(self):

        # create output directory if it does not exist yet
        if not self.output_file.parent.exists():
            self.output_file.parent.mkdir()

        # attempt to read PDF
        doc = None