コード例 #1
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_get_elements_by_page(template_with_radiobutton_stream):
    expected = {
        1: {
            "test": False,
            "check": False,
            "radio_1": False,
        },
        2: {
            "test_2": False,
            "check_2": False,
            "radio_2": False,
        },
        3: {
            "test_3": False,
            "check_3": False,
            "radio_3": False,
        },
    }

    for page, elements in (TemplateCore().get_elements_by_page(
            template_with_radiobutton_stream).items()):
        for each in elements:
            expected[page][TemplateCore().get_element_key(each)] = True

    for page, elements in expected.items():
        for k in elements.keys():
            assert expected[page][k]
コード例 #2
0
def test_fill(template_stream, data_dict):
    elements = TemplateMiddleware().build_elements(template_stream)

    for k, v in data_dict.items():
        if k in elements:
            elements[k].value = v

            if elements[k].type == ElementType.text:
                elements[k].font = TextConstants().global_font
                elements[k].font_size = TextConstants().global_font_size
                elements[k].font_color = TextConstants().global_font_color
                elements[k].text_x_offset = TextConstants(
                ).global_text_x_offset
                elements[k].text_y_offset = TextConstants(
                ).global_text_y_offset
                elements[k].text_wrap_length = TextConstants(
                ).global_text_wrap_length
            elements[k].validate_constants()
            elements[k].validate_value()
            elements[k].validate_text_attributes()

    result_stream = Filler().fill(template_stream, elements)

    assert result_stream != template_stream

    for element in TemplateCore().iterate_elements(result_stream):
        key = TemplateCore().get_element_key(element)

        assert element[
            TemplateConstants().field_editable_key] == pdfrw.PdfObject(1)

        if isinstance(data_dict[key], bool):
            assert element[TemplateConstants().checkbox_field_value_key] == (
                pdfrw.PdfName.Yes if data_dict[key] else pdfrw.PdfName.Off)
コード例 #3
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_iterate_elements_and_get_element_key(template_with_radiobutton_stream,
                                              data_dict):
    for each in TemplateCore().iterate_elements(
            template_with_radiobutton_stream):
        data_dict[TemplateCore().get_element_key(each)] = True

    for k in data_dict.keys():
        assert data_dict[k]
コード例 #4
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_iterate_elements_and_get_element_key_sejda(sejda_template,
                                                    sejda_data):
    data_dict = {key: False for key in sejda_data.keys()}
    for each in TemplateCore().iterate_elements(sejda_template, sejda=True):
        data_dict[TemplateCore().get_element_key(each, sejda=True)] = True

    for k in data_dict.keys():
        assert data_dict[k]
コード例 #5
0
def test_fill_with_radiobutton(template_with_radiobutton_stream, data_dict):
    elements = TemplateMiddleware().build_elements(
        template_with_radiobutton_stream)

    data_dict["radio_1"] = 0
    data_dict["radio_2"] = 1
    data_dict["radio_3"] = 2

    radio_button_tracker = {}

    for k, v in data_dict.items():
        if k in elements:
            elements[k].value = v

            if elements[k].type == ElementType.text:
                elements[k].font = TextConstants().global_font
                elements[k].font_size = TextConstants().global_font_size
                elements[k].font_color = TextConstants().global_font_color
                elements[k].text_x_offset = TextConstants(
                ).global_text_x_offset
                elements[k].text_y_offset = TextConstants(
                ).global_text_y_offset
                elements[k].text_wrap_length = TextConstants(
                ).global_text_wrap_length
            elements[k].validate_constants()
            elements[k].validate_value()
            elements[k].validate_text_attributes()

    result_stream = Filler().fill(template_with_radiobutton_stream, elements)

    assert result_stream != template_with_radiobutton_stream

    for element in TemplateCore().iterate_elements(result_stream):
        key = TemplateCore().get_element_key(element)

        if isinstance(data_dict[key], bool) or isinstance(data_dict[key], str):
            assert element[
                TemplateConstants().field_editable_key] == pdfrw.PdfObject(1)
        else:
            assert element[TemplateConstants().parent_key][
                TemplateConstants().field_editable_key] == pdfrw.PdfObject(1)

        if isinstance(data_dict[key], bool):
            assert element[TemplateConstants().checkbox_field_value_key] == (
                pdfrw.PdfName.Yes if data_dict[key] else pdfrw.PdfName.Off)
        elif isinstance(data_dict[key], int):
            if key not in radio_button_tracker:
                radio_button_tracker[key] = 0
            radio_button_tracker[key] += 1

            if data_dict[key] == radio_button_tracker[key] - 1:
                assert element[TemplateConstants().
                               checkbox_field_value_key] == BasePdfName(
                                   "/" + str(data_dict[key]), False)
            else:
                assert (element[TemplateConstants().checkbox_field_value_key]
                        == pdfrw.PdfName.Off)
コード例 #6
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_get_draw_text_coordinates(template_stream):
    for element in TemplateCore().iterate_elements(template_stream):
        assert TemplateCore().get_draw_text_coordinates(element) == (
            float(
                element[TemplateCoreConstants().annotation_rectangle_key][0]),
            (float(element[TemplateCoreConstants().annotation_rectangle_key]
                   [1]) + float(element[TemplateCoreConstants().
                                        annotation_rectangle_key][3])) / 2 - 2,
        )
コード例 #7
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_get_draw_checkbox_radio_coordinates(sejda_template):
    for element in TemplateCore().iterate_elements(sejda_template):
        assert TemplateCore().get_draw_checkbox_radio_coordinates(element) == (
            (float(element[TemplateCoreConstants().annotation_rectangle_key]
                   [0]) + float(element[TemplateCoreConstants().
                                        annotation_rectangle_key][2])) / 2 - 5,
            (float(element[TemplateCoreConstants().annotation_rectangle_key]
                   [1]) + float(element[TemplateCoreConstants().
                                        annotation_rectangle_key][3])) / 2 - 4,
        )
コード例 #8
0
def test_merge_two_pdfs(template_stream, data_dict):
    template = TemplateCore().get_elements_by_page(template_stream)
    result = TemplateCore().get_elements_by_page(Utils().merge_two_pdfs(
        template_stream, template_stream))

    page_count = len(template.keys())
    merged_page_count = len(result.keys())
    for elements in result.values():
        for element in elements:
            assert TemplateCore().get_element_key(element) in data_dict

    assert page_count * 2 == merged_page_count
コード例 #9
0
def test_generate_stream(template_stream, data_dict):
    template = TemplateCore().get_elements_by_page(template_stream)
    result = TemplateCore().get_elements_by_page(
        Utils.generate_stream(pdfrw.PdfReader(fdata=template_stream)))

    page_count = len(template.keys())
    result_page_count = len(result.keys())
    for elements in result.values():
        for element in elements:
            assert TemplateCore().get_element_key(element) in data_dict

    assert page_count == result_page_count
コード例 #10
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_assign_uuid(template_with_radiobutton_stream, data_dict):
    for element in TemplateCore().iterate_elements(
            TemplateCore().assign_uuid(template_with_radiobutton_stream)):
        key = TemplateCore().get_element_key(element)
        assert MergeCoreConstants().separator in key

        key, _uuid = key.split(MergeCoreConstants().separator)

        assert len(_uuid) == len(uuid.uuid4().hex)
        data_dict[key] = True

    for k in data_dict.keys():
        assert data_dict[k]
コード例 #11
0
def test_addition_operator_3_times_sejda(sejda_template, pdf_samples, sejda_data):
    with open(os.path.join(pdf_samples, "sample_added_3_copies_sejda.pdf"), "rb+") as f:
        result = PyPDFForm()
        expected = f.read()

        for i in range(3):
            result += PyPDFForm(sejda_template, sejda=True).fill(sejda_data)

        page_count = len(TemplateCore().get_elements_by_page(expected).keys())
        result_page_count = len(
            TemplateCore().get_elements_by_page(result.stream).keys()
        )
        assert page_count == result_page_count
        assert result.read() == expected
コード例 #12
0
def test_simple_fill(template_stream, data_dict):
    result_stream = Filler().simple_fill(template_stream, data_dict, False)

    assert result_stream != template_stream

    for element in TemplateCore().iterate_elements(result_stream):
        key = TemplateCore().get_element_key(element)

        if isinstance(data_dict[key], bool):
            assert element[TemplateConstants().checkbox_field_value_key] == (
                pdfrw.PdfName.Yes if data_dict[key] else pdfrw.PdfName.Off)
        else:
            assert (element[TemplateConstants().text_field_value_key][1:-1] ==
                    data_dict[key])
        assert element[
            TemplateConstants().field_editable_key] == pdfrw.PdfObject(1)
コード例 #13
0
def test_fill_sejda(sejda_template, sejda_data):
    elements = TemplateMiddleware().build_elements(sejda_template, sejda=True)

    for k, v in elements.items():
        if k in sejda_data:
            v.value = sejda_data[k]

        if elements[k].type == ElementType.text:
            elements[k].font = TextConstants().global_font
            elements[k].font_size = TextConstants().global_font_size
            elements[k].font_color = TextConstants().global_font_color
            elements[k].text_x_offset = TextConstants().global_text_x_offset
            elements[k].text_y_offset = TextConstants().global_text_y_offset
            elements[k].text_wrap_length = TextConstants(
            ).global_text_wrap_length
        elements[k].validate_constants()
        elements[k].validate_value()
        elements[k].validate_text_attributes()

    result_stream = Filler().fill(sejda_template, elements, sejda=True)

    assert result_stream != template_stream

    for element in TemplateCore().iterate_elements(result_stream):
        assert element[TemplateConstants().parent_key][
            TemplateConstants().field_editable_key] == pdfrw.PdfObject(1)
コード例 #14
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_get_elements_by_page_sejda(sejda_template):
    expected = {
        1: {
            "date": False,
            "year": False,
            "buyer_name": False,
            "buyer_address": False,
            "seller_name": False,
            "seller_address": False,
            "make": False,
            "model": False,
            "caliber": False,
            "serial_number": False,
            "purchase_option": False,
            "date_of_this_bill": False,
            "at_future_date": False,
            "other": False,
            "other_reason": False,
            "future_date": False,
            "future_year": False,
            "exchange_for": False,
        },
        2: {
            "buyer_name_printed": False,
            "seller_name_printed": False,
            "buyer_signed_date": False,
            "seller_signed_date": False,
            "buyer_dl_number": False,
            "seller_dl_number": False,
            "buyer_dl_state": False,
            "seller_dl_state": False,
        },
    }

    for page, elements in (TemplateCore().get_elements_by_page(
            sejda_template, sejda=True).items()):
        for each in elements:
            expected[page][TemplateCore().get_element_key(each,
                                                          sejda=True)] = True

    for page, elements in expected.items():
        for k in elements.keys():
            assert expected[page][k]
コード例 #15
0
def test_addition_operator_3_times(template_stream, pdf_samples, data_dict):
    with open(os.path.join(pdf_samples, "sample_added_3_copies.pdf"), "rb+") as f:
        result = PyPDFForm()

        for i in range(3):
            result += PyPDFForm(template_stream).fill(data_dict, editable=True)

        page_count = len(TemplateCore().get_elements_by_page(f.read()).keys())
        result_page_count = len(
            TemplateCore().get_elements_by_page(result.stream).keys()
        )
        assert page_count == result_page_count

        for elements in TemplateCore().get_elements_by_page(result.stream).values():
            for element in elements:
                assert (
                    TemplateCore()
                    .get_element_key(element)
                    .split(MergeConstants().separator)[0]
                    in data_dict
                )
コード例 #16
0
ファイル: test_v2.py プロジェクト: chinapandaman/PyPDFForm
def test_fill_v2(template_stream, pdf_samples, data_dict):
    with open(os.path.join(pdf_samples, "sample_filled.pdf"), "rb+") as f:
        obj = PyPDFForm2(template_stream).fill(data_dict, )
        assert len(obj.read()) == len(obj.stream)
        assert obj.read() == obj.stream

        expected = f.read()

        assert len(obj.stream) == len(expected)
        assert obj.stream == expected

        for page, elements in (TemplateCore().get_elements_by_page_v2(
                obj.read()).items()):
            assert not elements
コード例 #17
0
def test_simple_fill_with_radiobutton(template_with_radiobutton_stream,
                                      data_dict):
    data_dict["radio_1"] = 0
    data_dict["radio_2"] = 1
    data_dict["radio_3"] = 2

    radio_button_tracker = {}

    result_stream = Filler().simple_fill(template_with_radiobutton_stream,
                                         data_dict, True)

    assert result_stream != template_with_radiobutton_stream

    for element in TemplateCore().iterate_elements(result_stream):
        key = TemplateCore().get_element_key(element)

        if isinstance(data_dict[key], bool):
            assert element[TemplateConstants().checkbox_field_value_key] == (
                pdfrw.PdfName.Yes if data_dict[key] else pdfrw.PdfName.Off)
        elif isinstance(data_dict[key], int):
            if key not in radio_button_tracker:
                radio_button_tracker[key] = 0
            radio_button_tracker[key] += 1

            if data_dict[key] == radio_button_tracker[key] - 1:
                assert element[TemplateConstants().
                               checkbox_field_value_key] == BasePdfName(
                                   "/" + str(data_dict[key]), False)
            else:
                assert (element[TemplateConstants().checkbox_field_value_key]
                        == pdfrw.PdfName.Off)
        else:
            assert (element[TemplateConstants().text_field_value_key][1:-1] ==
                    data_dict[key])
        assert element[
            TemplateConstants().field_editable_key] != pdfrw.PdfObject(1)
コード例 #18
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_get_element_type(template_stream):
    type_mapping = {
        "test": ElementType.text,
        "check": ElementType.checkbox,
        "test_2": ElementType.text,
        "check_2": ElementType.checkbox,
        "test_3": ElementType.text,
        "check_3": ElementType.checkbox,
    }

    for each in TemplateCore().iterate_elements(template_stream):
        assert type_mapping[TemplateCore().get_element_key(
            each)] == TemplateCore().get_element_type(each)

    read_template_stream = pdfrw.PdfReader(fdata=template_stream)

    for each in TemplateCore().iterate_elements(read_template_stream):
        assert type_mapping[TemplateCore().get_element_key(
            each)] == TemplateCore().get_element_type(each)
コード例 #19
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_get_element_type_sejda(sejda_template):
    type_mapping = {
        "date": ElementType.text,
        "year": ElementType.text,
        "buyer_name": ElementType.text,
        "buyer_address": ElementType.text,
        "seller_name": ElementType.text,
        "seller_address": ElementType.text,
        "make": ElementType.text,
        "model": ElementType.text,
        "caliber": ElementType.text,
        "serial_number": ElementType.text,
        "purchase_option": ElementType.radio,
        "date_of_this_bill": ElementType.checkbox,
        "at_future_date": ElementType.checkbox,
        "other": ElementType.checkbox,
        "other_reason": ElementType.text,
        "payment_amount": ElementType.text,
        "future_date": ElementType.text,
        "future_year": ElementType.text,
        "exchange_for": ElementType.text,
        "buyer_name_printed": ElementType.text,
        "seller_name_printed": ElementType.text,
        "buyer_signed_date": ElementType.text,
        "seller_signed_date": ElementType.text,
        "buyer_dl_number": ElementType.text,
        "seller_dl_number": ElementType.text,
        "buyer_dl_state": ElementType.text,
        "seller_dl_state": ElementType.text,
    }

    for each in TemplateCore().iterate_elements(sejda_template, sejda=True):
        assert type_mapping[TemplateCore().get_element_key(
            each, sejda=True)] == TemplateCore().get_element_type(each,
                                                                  sejda=True)

    read_template_stream = pdfrw.PdfReader(fdata=sejda_template)

    for each in TemplateCore().iterate_elements(read_template_stream):
        assert type_mapping[TemplateCore().get_element_key(
            each, sejda=True)] == TemplateCore().get_element_type(each,
                                                                  sejda=True)
コード例 #20
0
ファイル: test_template.py プロジェクト: Anzrz-Inc/PyPDFForm
def test_remove_all_elements(template_stream):
    result = TemplateCore().remove_all_elements(template_stream)
    assert not TemplateCore().iterate_elements(result)