las_rs 0.2.1

High-performance parser and writer for LAS (Log ASCII Standard) well-log files — LAS 1.2 / 2.0 / 3.0. Pure-Rust core; the optional `python` feature adds the PyO3 bindings that back the `las-rs` PyPI wheel.
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

"""
Phase 5a tests — Character encoding detection and handling.

Covers reading LAS files with UTF-8, UTF-8 BOM, and Latin-1 encodings,
auto-detection of the encoding attribute, explicit encoding overrides,
the autodetect_encoding flag, and pathlib.Path input.

All tests are marked xfail because the `las_rs` Rust extension has not yet
been implemented.
"""

import os
import pathlib

import pytest

import las_rs

test_dir = os.path.dirname(__file__)


def fixture(*parts):
    return os.path.join(test_dir, "fixtures", *parts)


# ---------------------------------------------------------------------------
# File path constants
# ---------------------------------------------------------------------------

UTF8_FILE     = fixture("encodings", "utf8.las")
UTF8_BOM_FILE = fixture("encodings", "utf8_bom.las")
LATIN1_FILE   = fixture("encodings", "latin1.las")


# ---------------------------------------------------------------------------
# UTF-8 plain
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_utf8_reads():
    """A plain UTF-8 file containing non-ASCII characters (Ölbohrung GmbH in
    COMP) is read without raising an exception and the non-ASCII text is
    preserved in the well section."""
    las = las_rs.read(UTF8_FILE)
    comp = las.well["COMP"].value
    assert "Ölbohrung" in comp or "GmbH" in comp


# ---------------------------------------------------------------------------
# UTF-8 BOM
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_utf8_bom_reads():
    """A UTF-8 file that begins with a BOM (byte-order mark) is parsed without
    error; the well section contains the expected company name."""
    las = las_rs.read(UTF8_BOM_FILE)
    comp = las.well["COMP"].value
    assert "GmbH" in comp


@pytest.mark.xfail(reason="not yet implemented")
def test_utf8_bom_encoding_detected():
    """When a BOM is present the auto-detected encoding is reported as
    'utf-8-sig' (Python's name for UTF-8 with BOM)."""
    las = las_rs.read(UTF8_BOM_FILE)
    assert las.encoding is not None
    assert las.encoding.lower() == "utf-8-sig"


# ---------------------------------------------------------------------------
# Latin-1 / ISO 8859-1
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_latin1_reads():
    """A Latin-1 encoded file containing accented characters in the COMP field
    (Société Pétrolière) is read and the non-ASCII characters are present."""
    las = las_rs.read(LATIN1_FILE)
    comp = las.well["COMP"].value
    # The fixture encodes "Société Pétrolière"; at minimum the ASCII part
    # should be there even if decoding is approximate.
    assert comp is not None and len(comp) > 0


# ---------------------------------------------------------------------------
# encoding attribute
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_encoding_attribute_set():
    """After reading any LAS file the resulting LASFile has a non-None
    `encoding` attribute that is a plain string."""
    las = las_rs.read(UTF8_FILE)
    assert las.encoding is not None
    assert isinstance(las.encoding, str)


# ---------------------------------------------------------------------------
# Explicit encoding override
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_explicit_encoding():
    """Passing encoding='latin-1' explicitly causes the Latin-1 fixture to be
    decoded correctly; the company field contains expected text."""
    las = las_rs.read(LATIN1_FILE, encoding="latin-1")
    comp = las.well["COMP"].value
    # "Société Pétrolière" decoded from latin-1 should contain the accented chars
    assert "Soci" in comp and "troli" in comp


# ---------------------------------------------------------------------------
# autodetect_encoding=False
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_autodetect_encoding_false():
    """Passing autodetect_encoding=False disables charset sniffing; the file
    is still readable using a default common encoding (UTF-8 or ASCII)."""
    # The plain UTF-8 file is valid ASCII for the structural parts; it should
    # parse without error even with auto-detection disabled.
    las = las_rs.read(UTF8_FILE, autodetect_encoding=False)
    assert isinstance(las, las_rs.LASFile)
    assert len(las.curves) > 0


# ---------------------------------------------------------------------------
# pathlib.Path input
# ---------------------------------------------------------------------------


@pytest.mark.xfail(reason="not yet implemented")
def test_pathlib_path():
    """las_rs.read() accepts a pathlib.Path object in addition to plain
    strings; the result is an equivalent LASFile."""
    path = pathlib.Path(UTF8_FILE)
    las = las_rs.read(path)
    assert isinstance(las, las_rs.LASFile)
    dept = las.curves["DEPT"].data
    assert len(dept) == 3
    assert dept[0] == pytest.approx(100.0)