mrrc 0.9.1

A Rust library for reading, writing, and manipulating MARC bibliographic records in ISO 2709 binary format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

"""
Pytest configuration and fixtures for Python wrapper benchmarks.
"""

import io
from pathlib import Path

import pytest


@pytest.fixture(scope="session")
def fixture_dir():
    """Return path to test fixtures directory."""
    return Path(__file__).parent.parent / "data" / "fixtures"


@pytest.fixture(scope="session")
def fixture_1k(fixture_dir):
    """Load 1k record fixture as bytes."""
    path = fixture_dir / "1k_records.mrc"
    if not path.exists():
        pytest.skip(f"Fixture not found: {path}")
    with open(path, "rb") as f:
        return f.read()


@pytest.fixture(scope="session")
def fixture_10k(fixture_dir):
    """Load 10k record fixture as bytes."""
    path = fixture_dir / "10k_records.mrc"
    if not path.exists():
        pytest.skip(f"Fixture not found: {path}")
    with open(path, "rb") as f:
        return f.read()


@pytest.fixture(scope="session")
def fixture_1k_path(fixture_dir):
    """Path to the 1k record fixture file on disk."""
    path = fixture_dir / "1k_records.mrc"
    if not path.exists():
        pytest.skip(f"Fixture not found: {path}")
    return str(path)


@pytest.fixture(scope="session")
def fixture_10k_path(fixture_dir):
    """Path to the 10k record fixture file on disk."""
    path = fixture_dir / "10k_records.mrc"
    if not path.exists():
        pytest.skip(f"Fixture not found: {path}")
    return str(path)


@pytest.fixture(scope="session")
def fixture_small(fixture_1k):
    """Load small fixture (first 10 records from 1k fixture)."""
    # Create a small subset for quick tests
    from mrrc import MARCReader

    reader = MARCReader(io.BytesIO(fixture_1k))
    small_records = []
    for i, record in enumerate(reader):
        small_records.append(record)
        if i >= 9:  # 10 records
            break

    # Serialize back to bytes
    from mrrc import MARCWriter

    output = io.BytesIO()
    writer = MARCWriter(output)
    for record in small_records:
        writer.write_record(record)
    writer.close()
    return output.getvalue()


@pytest.fixture(scope="session")
def fixture_217(fixture_1k):
    """Create a fixture with exactly 217 records (tests partial batch at EOF)."""
    from mrrc import MARCReader, MARCWriter

    reader = MARCReader(io.BytesIO(fixture_1k))
    records = []
    for i, record in enumerate(reader):
        records.append(record)
        if i >= 216:  # 217 records (0-216 inclusive)
            break

    output = io.BytesIO()
    writer = MARCWriter(output)
    for record in records:
        writer.write_record(record)
    writer.close()
    return output.getvalue()


@pytest.fixture(scope="session")
def fixture_500(fixture_1k):
    """Create a fixture with exactly 500 records."""
    from mrrc import MARCReader, MARCWriter

    reader = MARCReader(io.BytesIO(fixture_1k))
    records = []
    for i, record in enumerate(reader):
        records.append(record)
        if i >= 499:  # 500 records
            break

    output = io.BytesIO()
    writer = MARCWriter(output)
    for record in records:
        writer.write_record(record)
    writer.close()
    return output.getvalue()


@pytest.fixture(scope="session")
def fixture_5k(fixture_1k, fixture_10k):
    """Create a fixture with 5k records (halfway between 1k and 10k)."""
    # Use first 5 copies of 1k fixture
    from mrrc import MARCReader, MARCWriter

    reader = MARCReader(io.BytesIO(fixture_10k))
    records = []
    for i, record in enumerate(reader):
        records.append(record)
        if i >= 4999:  # 5000 records
            break

    output = io.BytesIO()
    writer = MARCWriter(output)
    for record in records:
        writer.write_record(record)
    writer.close()
    return output.getvalue()


@pytest.fixture(scope="session")
def fixture_with_error(fixture_small):
    """Create a fixture that contains a malformed record for error testing."""
    # Append an incomplete record header to trigger error
    return fixture_small + b"00"  # Incomplete record length field


@pytest.fixture
def fixture_1k_io(fixture_1k):
    """Return 1k fixture as file-like object."""
    return io.BytesIO(fixture_1k)


@pytest.fixture
def fixture_10k_io(fixture_10k):
    """Return 10k fixture as file-like object."""
    return io.BytesIO(fixture_10k)


def pytest_configure(config):
    """Register custom markers."""
    config.addinivalue_line(
        "markers",
        "benchmark: mark test as a benchmark (deselect with '-m \"not benchmark\"')",
    )
    config.addinivalue_line(
        "markers", "slow: mark test as slow (deselect with '-m \"not slow\"')"
    )