pandas-dev-pandas-68039-68067

AGENTS.md
AUTHORS.md
CITATION.cff
LICENSE
LICENSES
README.md
asv_bench
build
ci
codecov.yml
doc
environment.yml

generate_pxi.py
generate_version.py
meson.build
pandas
pixi.lock
pixi.toml
pyproject.toml
pyright_reportGeneralTypeIssues.json
requirements-dev.txt
scripts
subprojects
web
a107303 base
0+untagged.1.ga107303

__init__.py
sas7bdat.py
sas_constants.py
sas_xport.py
sasreader.py
"""
Read SAS7BDAT files

Based on code written by Jared Hobbs:
  https://bitbucket.org/jaredhobbs/sas7bdat

See also:

  https://github.com/BioStatMatt/sas7bdat

Partial documentation of the file format:
  https://cran.r-project.org/package=sas7bdat/vignettes/sas7bdat.pdf

Reference for binary data compression:
  http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
"""

from __future__ import annotations

import codecs
from datetime import datetime
import functools
import sys
from typing import TYPE_CHECKING
import warnings

import numpy as np

from pandas._config import using_string_dtype

from pandas._libs import lib
from pandas._libs.byteswap import (
    read_double_with_byteswap,
    read_float_with_byteswap,
    read_uint16_with_byteswap,
    read_uint32_with_bytesw
…[5781 chars omitted]…
 datetimes in SAS
    unit : {'d', 's'}
       "d" if the floats represent dates, "s" for datetimes

    Returns
    -------
    Series
       Series of datetime64 dtype or datetime.datetime.
    """
    td = (_sas_origin - _unix_origin).as_unit("s")
    # SAS's own date range tops out near 6e6 days, so a count this size is not
    # a date the file could legitimately hold -- it is corrupt bytes, or a

# a date the file could legitimately hold -- it is corrupt bytes, or a
    # numeric column carrying a date format. Casting it does not overflow, it
    # saturates: a negative one lands on the NaT sentinel and is read as
    # missing, and a positive one does raise below, but naming the date the
    # saturated cast landed on rather than anything the file holds.
    too_large = np.abs(sas_datetimes._values) >= 2.0**63
    if too_large.any():
        value = sas_datetimes._values[too_large][0]
        what = "date" if unit == "d" else "datetime"
        raise OutOfBoundsDatetime(
            f"Out of bounds SAS {what} value: {value}; no SAS {what} can be this "
            f"large, so the file is corrupt or the column is not a {what}"

        )
    if unit == "s":
        corrected = sas_datetimes._values + _sas_to_gregorian_correction(
            sas_datetimes._values, unit="s"

…[8629 chars omitted]…
in(
            self._page_length // self._subheader_pointer_length + 1,
            1 << (8 * const.subheader_count_length),
        )
        self._data_subheader_offsets = np.empty(max_subheaders, dtype=np.int64)
        self._data_subheader_lengths = np.empty(max_subheaders, dtype=np.int64)

    def __next__(self) -> DataFrame:
        da = self.read(nrows=self.chunksize or 1)
        if da.empty:

46:    OutOfBoundsDatetime,
76:def _utf8_translation_table(
163:def _sas_to_gregorian_correction(values: np.ndarray, unit: str) -> np.ndarray:
171:    scale = 86400 if unit == "s" else 1
180:def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
209:        raise OutOfBoundsDatetime(
236:    def __init__(
294:    def __init__(
327:        self._data_subheader_offsets = np.empty(0, dtype=np.int64)
328:        self._data_subheader_lengths = np.empty(0, dtype=np.int64)
329:        self._data_subheader_count = 0
367:    def _metadata_signature(self) -> tuple:

380:            self.row_count,
381:            self._mix_page_row_count,
388:    def _validate_column_data_ranges(self) -> None:
417:    def column_data_lengths(self) -> np.ndarray:
421:    def column_data_offsets(self) -> np.ndarray:
425:    def column_types(self) -> np.ndarray:
432:    def close(self) -> None:
4
…[2355 chars omitted]…
lf._data_subheader_count = 0
984:    def _read_next_page(self):
996:            const.page_mix_type,
1002:    def _chunk_to_dataframe(self) -> DataFrame:
1018:                    rslt[name] = _convert_datetimes(rslt[name], convert_type)
1042:    def _string_column(self, js: int) -> ArrowStringArray:
1095:    def _decode_string(self, b):
1098:    def _convert_header_text(self, b: bytes) -> str | bytes:

def _read_bytes(self, offset: int, length: int):
        assert self._cached_page is not None
        if offset + length > len(self._cached_page):
            self.close()
            raise ValueError("The cached page is too small.")
        return self._cached_page[offset : offset + length]

    def _parse_metadata(self) -> None:
        done = False
        while not done:
            self._cached_page = self._path_or_buf.read(self._page_length)
            if len(self._cached_page) <= 0:

                break
            if len(self._cached_page) != self._page_length:
                raise ValueError("Failed to read a meta data page from the SAS file.")
            done = self._process_page_meta()

        self._column_convert_types: list[str | None] = []
        for j in range(self.column_count):
            if self._column_types[j] == b"d" and self.convert_dates:
           
…[8629 chars omitted]…

                js += 1
            else:
                self.close()
                raise ValueError(f"unknown column type {self._column_types[j]!r}")

        df = DataFrame(rslt, columns=self.column_names, index=ix, copy=False)
        return df

    def _string_column(self, js: int) -> ArrowStringArray:
        """
        Wrap string column `js`'s parse buffers as a pyarrow-backed str column.

+ const.column_name_pointer_length * (i + 1)
                + const.column_name_text_subheader_offset
            )
            col_name_offset = (
                offset
                + const.column_name_pointer_length * (i + 1)
                + const.column_name_offset_offset
            )
            col_name_length = (
                offset
                + const.column_name_pointer_length * (i + 1)
                + const.column_name_length_offset

            )

            idx = self._read_uint(
                text_subheader, const.column_name_text_subheader_length
            )
            col_offset = self._read_uint(
                col_name_offset, const.column_name_offset_length
            )
            col_len = self._read_uint(col_name_length, const.column_name_length_length)

            name_raw = self.column_names_raw[idx]
            cname = na
…[5798 chars omitted]…
 claims, a layout the file redefined, a cell that cannot be
            # represented -- the reader is no longer usable, and read_sas only
            # closes it for the caller when it reads the whole file itself.
            self.close()
            raise
        if self.index is not None:
            rslt = rslt.set_index(self.index)

        return rslt

    def _string_mode(
        self, ns: int

pandas/_libs/sas.pyi
pandas/_libs/sas.pyx
304:    int page_mix_type = const.page_mix_type
553:        # How many rows a mix page hands out before the parser moves on. Held
560:        int mix_page_row_count
568:        Py_ssize_t row_length
617:        self.row_length = parser.row_length
618:        self.mix_page_row_count = min(parser.row_count, parser._mix_page_row_count)
626:        self.update_next_page()
648:            self.decompressed_buf = buf_new(self.row_length)
650:        # update to current state of the parser
695:        # update the parser

749:                    or self.current_page_type == page_mix_type):
755:    cdef update_next_page(self):
796:            elif self.current_page_type == page_mix_type:
806:                offset += self.current_row_on_page_index * self.row_length
807:                self.process_byte_array_with_data(offset, self.row_length)
808:                if self.current_row_on_page_index == self.mix_page_row_count:
817:                    + self.current_row_on_page_index * self.row_length,
818:                    self.row_length,
859:        compressed = self.decompress != NULL and length < self.row_length
862:            if rpos != self.row_length:
864:                    f"Expected decompressed line of length {self.row_length} bytes "

rpos += cnt

        # short pattern
        else:
            assert ipos < in_len, "Out of bounds read"
            ofs = cnt + 3
            ofs += <uint16_t>in_data[ipos] << 4
            ipos += 1
            buf_copy_backref(outbuff, rpos, rpos - <int>ofs, cmd)
            rpos += cmd

    return rpos

cdef enum ColumnTypes:
    column_type_decimal = 1
    column_type_string = 2


# Const aliases
assert len(const.page_meta_types) == 2
cdef:
    int page_meta_types_0 = const.page_meta_types[0]
    int page_meta_types_1 = const.page_meta_types[1]
    int page_mix_type = const.page_mix_type
    int page_data_type = const.page_data_type
    int subheader_pointers_offset = const.subheader_pointers_offset

    # See sas_constants.py for what each string mode means. string_mode_table
    # needs no alias here: it is whatever the other two are not.
    int string_mode_objec
…[8630 chars omitted]…
     byte_chunk = self.byte_chunk
        string_chunk = self.string_chunk
        # Resolved once per row so that the per-cell branches below test a
        # local rather than reloading the module-level mode constants.
        mode_object = self.str_mode == string_mode_object
        mode_utf8 = self.str_mode == string_mode_utf8
        str_cols = self.str_cols
        str_offsets = self.str_offsets

cdef:
        int column_count
        int64_t[:] lengths
        int64_t[:] offsets
        int64_t[:] column_types
        uint8_t[:, :] byte_chunk
        object[:, :] string_chunk
        # Output for the pyarrow string fast path (string_mode_utf8/_table):
        # str_cols[js] accumulates column js's utf-8 bytes, str_offsets[js, r+1]
        # records the end of row r within it, and str_valid[js, r] is 0 for a
        # null cell. Unused when str_mode is string_mode_object.
        int str_mode

        StrColumn *str_cols
        int n_str_cols
        int64_t[:, ::1] str_offsets
        uint8_t[:, ::1] str_valid
        # str_table[b * str_table_width : ...] holds the utf-8 for source byte
        # b, str_table_len[b] its length (undefined_byte if b is not a valid
        # character in str_encoding). Only set for string_mode_table. const
        # because these are shared
…[8629 chars omitted]…
     flag = self.current_row_on_page_index == self.current_page_block_count
                if flag:
                    done = self.read_next_page()
                    if done:
                        return True
                return False
            else:
                raise ValueError(f"unknown page type: {self.current_page_type}")

    @cython.wraparound(False)
    @cython.boundscheck(False)

pandas/tests/io/sas/test_sas7bdat.py:761:        "mix page row count",
pandas/tests/io/sas/test_sas7bdat.py:801:def test_mix_page_row_count_too_large_to_reach_raises(datapath):
pandas/io/sas/sas7bdat.py:381:            self._mix_page_row_count,
pandas/io/sas/sas7bdat.py:670:        self._mix_page_row_count = self._read_uint(offset + mx, int_len)
pandas/_libs/sas.pyx:560:        int mix_page_row_count
pandas/_libs/sas.pyx:618:        self.mix_page_row_count = min(parser.row_count, parser._mix_page_row_count)
pandas/_libs/sas.pyx:808:                if self.current_row_on_page_index == self.mix_page_row_count:

@pytest.mark.parametrize("bad_length", [9, 16, 4096])
def test_numeric_column_longer_than_8_bytes_raises(datapath, bad_length):
    # GH#47339 a numeric column is widened into 8 bytes of the output buffer, so
    # a longer one wrote past the front of it even though it fits in the row.
    with open(datapath("io", "sas", "data", "test1.sas7bdat"), "rb") as fd:
        data = bytearray(fd.read())
    # byte offset of the first column's data-length field, which is 4 bytes wide
    data[126592:126596] = bad_length.to_bytes(4, "little")
    with pytest.raises(ValueError, match="the file is corrupt"):
        pd.read_sas(io.BytesIO(data), format="sas7bdat", encoding=None)

@pytest.mark.parametrize("bad_offset", [2**63 - 1, 2**64 - 1])
def test_column_offset_near_int64_max_raises(datapath, bad_offset):
    # GH#47339 a 64-bit file can declare an offset large enough that adding the
    # 
…[7834 chars omitted]…
0000)
    struct.pack_into("<q", data, 65536 + 64728 + 15 * 8, 2)
    data_page = bytearray(65536)
    struct.pack_into(
        "<HHH", data_page, const.page_bit_offset_x64, const.page_data_type, 60000, 0
    )
    return bytes(data) + bytes(data_page)


@pytest.mark.parametrize(
    "build, expected, match, chunksize",
    [
        (
            lambda datapath: _dates_null_with_late_metadata_page(

2:from datetime import datetime
16:    OutOfBoundsDatetime,
42:    epoch = datetime(1960, 1, 1)
172:    fname = datapath("io", "sas", "data", "datetime.sas7bdat")
285:    df0 = pd.read_csv(fname, parse_dates=["MONTH"])
311:def test_date_time(datapath):
312:    # Support of different SAS date/datetime formats (PR #15871)
313:    fname = datapath("io", "sas", "data", "datetime.sas7bdat")
315:    fname = datapath("io", "sas", "data", "datetime.csv")
317:        fname, parse_dates=["Date1", "Date2", "DateTime", "DateTimeHi", "Taiw"]
394:def test_max_sas_date(datapath):
396:    # NB. max datetime in SAS dataset is 31DEC9999:23:59:59.999

398:    # are not leap years, producing a 2-day offset for dates >= year 4000.
399:    fname = datapath("io", "sas", "data", "max_sas_date.sas7bdat")
408:                    datetime(9999, 12, 31, 23, 59, 59, 999000),
409:                    datetime(2019, 
…[2874 chars omitted]…
", "sas", "data", "dates_null.sas7bdat"), "rb") as fd:
822:    data = _dates_null_with_late_metadata_page(
832:def _dates_null_with_overrun_data_page(datapath):
835:    with open(datapath("io", "sas", "data", "dates_null.sas7bdat"), "rb") as fd:
850:            lambda datapath: _dates_null_with_late_metadata_page(
857:        (_dates_null_with_overrun_data_page, Exception, "Out of bounds read", 1000),

import contextlib
from datetime import datetime
import io
import os
from pathlib import Path
import struct

import numpy as np
import pytest

from pandas._config import using_string_dtype

from pandas.compat import HAS_PYARROW
from pandas.errors import (
    EmptyDataError,
    OutOfBoundsDatetime,
    Pandas4Warning,
)

import pandas as pd
import pandas._testing as tm

from pandas.io.sas.sas7bdat import (
    SAS7BDATReader,
    _utf8_translation_table,
)
import pandas.io.sas.sas_constants as const

encoding_depr_msg = "The default value of 'encoding' in read_sas is deprecated"


@pytest.fixture
def dirpath(datapath):
    return datapath("io", "sas", "data")


@pytest.fixture(params=[(1, range(1, 16)), (2, [16])])
def data_test_ix(request, dirpath):
    i, test_ix = request.param
    fname = os.path.join(dirpath, f"test_sas7bdat_{i}.csv")
    df = pd.read_csv(fname)
    epoch = datet
…[8629 chars omitted]…
rt final chunk. Chunking these row counts
# any finer only repeats those four at a few hundred chunks apiece.
_string_path_chunksizes = {
    "test1": 7,
    "test2": 7,
    "test3": 7,
    "test16": 7,
    "load_log": 250,
    "productsales": 50,
}


# cp037 is EBCDIC: the one encoding here whose bytes below 0x80 are not their
# own utf-8, so it is what exercises the parser's non-ascii_identity path.

"dt_as_float": [1880323199.999],
                "dt_as_dt": np.array(["2019-08-01 23:59:59.999"], dtype="M8[ms]"),
                "date_as_float": [21762.0],
                "date_as_date": np.array(["2019-08-01"], dtype="M8[s]"),
            },
            columns=col_order,
        ),
    ]

    tm.assert_frame_equal(results[0], expected[0])
    tm.assert_frame_equal(results[1], expected[1])

@pytest.mark.parametrize("field_offset, what", [(65816, "date"), (65824, "datetime")])
@pytest.mark.parametrize("value", [-(2.0**63), -1e300, 2.0**63, 1e300])
def test_date_too_large_to_cast_raises(datapath, field_offset, what, value):
    # GH#47339 a day or second count too large to fit int64 saturates when it is
    #  cast: a negative one landed on the NaT sentinel and was read as missing,
    #  while a positive one raised, but naming a date the file does not hold --
   
…[3387 chars omitted]…
ro_variables.sas7bdat")
    with pytest.raises(EmptyDataError, match="No columns to parse from file"):
        pd.read_sas(fname)


@pytest.mark.parametrize("encoding", [None, "utf8"])
def test_zero_rows(datapath, encoding):
    # GH 18198
    fname = datapath("io", "sas", "data", "zero_rows.sas7bdat")
    result = pd.read_sas(fname, encoding=encoding)
    str_value = b"a" if encoding is None else "a"

* master
commit a107303d0105f7219d4269b1836b0ff7947c83bc
Author:     benchgen <sandbox@benchgen>
AuthorDate: Fri Nov 6 10:51:46 2026 +0000
Commit:     benchgen <sandbox@benchgen>
CommitDate: Fri Nov 6 10:51:46 2026 +0000

    base
/repo/pandas/__init__.py 0+untagged.1.ga107303

pandas/_libs/tslibs/conversion.pyx:106:def cast_from_unit_vectorized(
pandas/_libs/tslibs/conversion.pyi:13:def cast_from_unit_vectorized(
106:def cast_from_unit_vectorized(
107-    ndarray values,
108-    str unit,
109-    str out_unit="ns",
110-):
111-    """
112:    Vectorized analogue to cast_from_unit.
113-    """
114-    cdef:
115-        int64_t m

116-        int p
117-        NPY_DATETIMEUNIT in_reso, out_reso
118-
119-    assert values.dtype.kind == "f"
120-
121-    if unit in "YM":
122-        if not (((values % 1) == 0) | np.isnan(values)).all():
123-            # GH#47267 it is clear that 2 "M" corresponds to 1970-02-01,
124-            #  but not clear what 2.5 "M" corresponds to, so we will
125-            #  disallow that case.
126-            raise ValueError(
127-                f"Conversion of non-round float with unit={unit} "
128-                "is ambiguous"
129-
…[4156 chars omitted]…
it is clear that 2 "M" corresponds to 1970-02-01,
233-            #  but not clear what 2.5 "M" corresponds to, so we will
234-            #  disallow that case.
235-            raise ValueError(
236-                f"Conversion of non-round float with unit={unit} "
237-                "is ambiguous"
238-            )
239-        # GH#47266 go through np.datetime64 to avoid weird results e.g. with "Y"

106751991167300.64 9.223372036854776e+18 True [ True]
[ True]
-106751991167300.64 -9.223372036854776e+18 True

<class 'urllib.error.URLError'> <urlopen error [Errno -3] Temporary failure in name resolution>

from __future__ import annotations

from typing import Final

magic: Final = (
    b"\x00\x00\x00\x00\x00\x00\x00\x00"
    b"\x00\x00\x00\x00\xc2\xea\x81\x60"
    b"\xb3\x14\x11\xcf\xbd\x92\x08\x00"
    b"\x09\xc7\x31\x8c\x18\x1f\x10\x11"
)

align_1_checker_value: Final = b"3"

align_1_offset: Final = 32
align_1_length: Final = 1
align_1_value: Final = 4
u64_byte_checker_value: Final = b"3"
align_2_offset: Final = 35
align_2_length: Final = 1
align_2_value: Final = 4
endianness_offset: Final = 37
endianness_length: Final = 1
platform_offset: Final = 39
platform_length: Final = 1
encoding_offset: Final = 70
encoding_length: Final = 1
dataset_offset: Final = 92
dataset_length: Final = 64
file_type_offset: Final = 156
file_type_length: Final = 8
date_created_offset: Final = 164
date_created_length: Final = 8
date_modified_offset: Final = 172
date_modified_length: Final = 8
header_size_off
…[6417 chars omitted]…
xf6\xf6\xff\xff\xfb\xfe": SASIndex.column_size_index,
    b"\x00\xfc\xff\xff": SASIndex.subheader_counts_index,
    b"\xff\xff\xfc\x00": SASIndex.subheader_counts_index,
    b"\x00\xfc\xff\xff\xff\xff\xff\xff": SASIndex.subheader_counts_index,
    b"\xff\xff\xff\xff\xff\xff\xfc\x00": SASIndex.subheader_counts_index,
page bit offsets 32 16
subheader_pointers_offset 8
pointer length 24
page length 200 4

131072
page type 0x200
block count 12
subheader count 10
0 (64728, 808)
1 (64704, 24)
2 (64104, 600)
3 (64004, 100)
4 (63960, 44)
5 (63900, 60)
6 (63846, 54)
7 (63782, 64)

8 (63718, 64)
9 (63718, 0)
subheader 0 at 64728
row length 16
row count 2
mix row count 3934
e6f8000000000000000000000000000001000000000000000000008071674641dfffffca60894d420000000000feffff0000000000feffff0000000000000000

_int_length: int
    _cached_page: bytes | None
    encoding: str | None

    def __init__(
        self,
        path_or_buf: FilePath | ReadBuffer[bytes],
        index=None,
        convert_dates: bool = True,
        blank_missing: bool = True,
        chunksize: int | None = None,
        encoding: str | lib.NoDefault | None = lib.no_default,

        convert_text: bool = True,
        convert_header_text: bool = True,
        compression: CompressionOptions = "infer",
    ) -> None:
        self._encoding_specified = encoding is not lib.no_default
        self._non_ascii_header_text = False

        self.index = index
        self.convert_dates = convert_dates
        self.blank_missing = blank_missing
        self.chunksize = chunksize
        self.encoding = None if encoding is lib.no_default else encoding
        self.convert_text = convert_text
        self.convert_header
…[8628 chars omitted]…
          "than a string name, you must specify a format string"
        )
        filepath_or_buffer = stringify_path(filepath_or_buffer)
        if not isinstance(filepath_or_buffer, str):
            raise ValueError(buffer_error_msg)
        fname = filepath_or_buffer.lower()
        if ".xpt" in fname:
            format = "xport"
        elif ".sas7bdat" in fname:
            format = "sas7bdat"

/repo/pandas/tests/io/sas/test_sas7bdat.py:761:        "mix page row count",

grep: pandas/tests/io/sas/data/dates_null.sas7bdat: binary file matches
grep: pandas/tests/io/sas/data/max_sas_date.sas7bdat: binary file matches
pandas/tests/io/sas/test_sas7bdat.py:44:    df["Column4"] = (epoch + t1).astype("M8[s]")
pandas/tests/io/sas/test_sas7bdat.py:46:    df["Column12"] = (epoch + t2).astype("M8[s]")
pandas/tests/io/sas/test_sas7bdat.py:289:    df0["MONTH"] = df0["MONTH"].astype("M8[s]")
pandas/tests/io/sas/test_sas7bdat.py:325:    df0["Date1"] = df0["Date1"].astype("M8[s]")
pandas/tests/io/sas/test_sas7bdat.py:326:    df0["Date2"] = df0["Date2"].astype("M8[s]")
pandas/tests/io/sas/test_sas7bdat.py:328:    df0["Taiw"] = df0["Taiw"].astype("M8[s]")
pandas/tests/io/sas/test_sas7bdat.py:414:            "date_as_date": np.array(
pandas/tests/io/sas/test_sas7bdat.py:419:                dtype="M8[s]",
pandas/tests/io/sas/test_sas7bdat.py:422:        columns=["text", "
…[165 chars omitted]…

at", "date_as_date"]
pandas/tests/io/sas/test_sas7bdat.py:448:                "date_as_date": np.array([datetime(9999, 12, 31)], dtype="M8[s]"),
pandas/tests/io/sas/test_sas7bdat.py:458:                "date_as_date": np.array(["2019-08-01"], dtype="M8[s]"),
pandas/tests/io/sas/test_sas7bdat.py:491:            "datecol": np.array(
pandas/tests/io/sas/test_sas7bdat.py:496:                dtype="M8[s]",

Date1,Date2,DateTime,DateTimeHi,Taiw
1677-09-22,1677-09-22,1677-09-21 00:12:44,1677-09-21 00:12:43.145225,1912-01-01
1960-01-01,1960-01-01,1960-01-01 00:00:00,1960-01-01 00:00:00.000000,1960-01-01
2016-02-29,2016-02-29,2016-02-29 23:59:59,2016-02-29 23:59:59.123456,2016-02-29
2262-04-11,2262-04-11,2262-04-11 23:47:16,2262-04-11 23:47:16.854775,2262-04-11
Date1         str
Date2         str
DateTime      str
DateTimeHi    str
Taiw          str
dtype: object
        Date1       Date2  ...                  DateTimeHi        Taiw

0  1677-09-22  1677-09-22  ...  1677-09-21 00:12:43.145225  1912-01-01
1  1960-01-01  1960-01-01  ...  1960-01-01 00:00:00.000000  1960-01-01
2  2016-02-29  2016-02-29  ...  2016-02-29 23:59:59.123456  2016-02-29
3  2262-04-11  2262-04-11  ...  2262-04-11 23:47:16.854775  2262-04-11

[4 rows x 5 columns]
        Date1       Date2        Taiw
0  1677-09-22  1677-09-22  1912-01-01
1  1960-01-01  1960-01-01  1960-01-01
2  2016-02-29  2016-02-29  2016-02-29
3  2262-04-11  2262-04-11  2262-04-11

65816 2936547.0
65824 253717747199.999
65832 nan
65840 nan

-- fractional date 2019
     datecol             datetimecol
0 2019-08-01 9999-12-31 23:59:59.999
1        NaT                     NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

-- fractional date -0.5
     datecol             datetimecol
0 1960-01-01 9999-12-31 23:59:59.999
1        NaT                     NaT

datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

-- date out of bounds
OutOfBoundsDatetime Out of bounds second timestamp: 292277026596-12-06 00:00:00

-- date out of bounds neg
OutOfBoundsDatetime Out of bounds second timestamp

-- mix count 4097
AssertionError Out of bounds read
-- mix count chunksize 4097
     datecol             datetimecol
0 9999-12-31 9999-12-31 23:59:59.999
1        NaT                     NaT

-- mix count 2147483648
OverflowError value too large to convert to int
-- mix count chunksize 2147483648
OverflowError value too large to convert to int

0x40controlbyte.sas7bdat rows 1 mix 405 min 1 page/row 420 rowlen 156 pagelen 65536
airline.sas7bdat rows 32 mix 32 min 32 page/row 93 rowlen 44 pagelen 4096
cars.sas7bdat rows 392 mix 111 min 111 page/row 178 rowlen 23 pagelen 4096
corrupt.sas7bdat ERR AttributeError 'SAS7BDATReader' object has no attribute 'column_count'
dates_null.sas7bdat rows 2 mix 3934 min 2 page/row 4096 rowlen 16 pagelen 65536
datetime.sas7bdat rows 4 mix 1593 min 4 page/row 1638 rowlen 40 pagelen 65536
load_log.sas7bdat rows 2097 mix 278 min 278 page/row 292 rowlen 224 pagelen 65536
many_columns.sas7bdat rows 3 mix 0 min 0 page/row 2 rowlen 3117 pagelen 8192
max_sas_date.sas7bdat rows 2 mix 3372 min 2 page/row 3449 rowlen 38 pagelen 131072
productsales.sas7bdat rows 1440 mix 62 min 62 page/row 85 rowlen 96 pagelen 8192
test1.sas7bdat rows 10 mix 66 min 10 page/row 80 rowlen 816 pagelen 65536
test10.sas7bdat r

…[1029 chars omitted]…
t9.sas7bdat rows 10 mix 62 min 10 page/row 81 rowlen 809 pagelen 65536
test_12659.sas7bdat rows 36 mix 607 min 36 page/row 630 rowlen 104 pagelen 65536
test_meta2_page.sas7bdat rows 1000 mix 275 min 275 page/row 292 rowlen 224 pagelen 65536
zero_rows.sas7bdat rows 0 mix 7999 min 0 page/row 8192 rowlen 16 pagelen 131072
zero_variables.sas7bdat rows 1 mix 64976 min 1 page/row None rowlen 0 pagelen 74752

format = "sas7bdat"
        else:
            raise ValueError(
                f"unable to infer format of SAS file from filename: {fname!r}"
            )

    reader: SASReader
    if format.lower() == "xport":
        from pandas.io.sas.sas_xport import XportReader

        reader = XportReader(
            filepath_or_buffer,

            index=index,
            encoding=encoding,
            chunksize=chunksize,
            compression=compression,
        )
    elif format.lower() == "sas7bdat":
        from pandas.io.sas.sas7bdat import SAS7BDATReader

        reader = SAS7BDATReader(
            filepath_or_buffer,
            index=index,
            encoding=encoding,
            chunksize=chunksize,
            compression=compression,
        )
    else:
        raise ValueError("unknown SAS format")

    if iterator or chunksize:
        return reader

    with reader:
        return reader.read()

106751991167300.64 9.223372036854776e+18 True
np.float64(106751991167300.62) np.float64(9.223372036854774e+18) False
np.float64(106751991167300.66) np.float64(9.223372036854776e+18) True

Traceback (most recent call last):
  File "<stdin>", line 6, in <module>
AttributeError: 'Timedelta' object has no attribute 'dtype'

-3653 days +00:00:00 s
[                   0                21762                    0
 -9223372036854775808] int64
['1960-01-01T00:00:00' '1960-01-01T06:02:42' '1960-01-01T00:00:00'
                 'NaT'] datetime64[s]
[1880323197     -43200] int64
['2019-08-01T23:59:57' '1959-12-31T12:00:00'] datetime64[s]

['1970-01-01T00:00:00' '1970-01-01T06:02:42' '1970-01-01T00:00:00'
                 'NaT']
['1969-12-31T12:00:00' '2029-08-01T13:43:57']

day 21762.573344907407 sec [1.88028634e+09] corr [0.] corrected [1.88028634e+09]
['2019-08-01T13:45:37']
day -0.5 sec [-43200.] corr [0.] corrected [-43200.]
['1959-12-31T12:00:00']
day 21762.0 sec [1.8802368e+09] corr [0.] corrected [1.8802368e+09]
['2019-08-01T00:00:00']
day 2936547.0 sec [2.53717661e+11] corr [172800.] corrected [2.53717834e+11]
['9999-12-31T00:00:00']
day nan sec [nan] corr [0.] corrected [nan]
day 106751991167300.64 sec [9.22337204e+18] corr [172800.] corrected [9.22337204e+18]

98:    @pytest.mark.parametrize("chunksize", (3, 5, 10, 11))
100:    def test_iterator_loop(self, dirpath, k, chunksize):
103:        with pd.read_sas(fname, chunksize=chunksize, encoding="utf-8") as rdr:
435:    for df in pd.read_sas(fname, encoding="iso-8859-1", chunksize=1):
776:        io.BytesIO(data), format="sas7bdat", chunksize=2, encoding=None
813:            io.BytesIO(data), format="sas7bdat", chunksize=2, encoding=None
826:        io.BytesIO(data), format="sas7bdat", chunksize=2, encoding=None
847:    "build, expected, match, chunksize",
862:    datapath, tmp_path, build, expected, match, chunksize
870:    reader = pd.read_sas(path, format="sas7bdat", chunksize=chunksize, encoding=None)
889:    with pd.read_sas(fname, chunksize=11_000, encoding=None) as reader:
909:_string_path_chunksizes = {

927:@pytest.mark.parametrize("name", list(_string_path_chunksizes))
936:    chunksize = _string_path_chunksizes[name] if chunked else None
946:            SAS7BDATReader(fname, encoding=encoding, chunksize=chunksize)
951:                frame = pd.concat(list(rdr)) if chunksize else rdr.read()

diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..a51ba7a 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -196,13 +196,24 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
        Series of datetime64 dtype or datetime.datetime.
     """
     td = (_sas_origin - _unix_origin).as_unit("s")
+    values = sas_datetimes._values
+    if unit == "d":
+        # A SAS date is a day count and need not be a whole one.  Keep the
+        # fractional day by scaling to seconds, and round to the second, which

+        # is the resolution of the datetime64[s] result.  Rounding, rather than
+        # truncating, also keeps pre-epoch dates on the right calendar day.
+        values = np.round(values * 86400.0)
+        out_unit = "s"
+    else:
+        out_unit = "ms"
+
     # SAS's own date range tops out near 6e
…[2485 chars omitted]…
ge_rows = self._page_length // self.row_length
+            if mix_page_row_count > max_page_rows:
+                raise ValueError(
+                    f"mix page row count ({mix_page_row_count}) does not fit in "
+                    f"a {self._page_length}-byte page"
+                )
+
         if nrows > 0 and self._current_row_in_file_index >= self.row_count:
             return DataFrame()

-- fractional date 2019
              datecol             datetimecol
0 2019-08-01 13:45:37 9999-12-31 23:59:59.999
1                 NaT                     NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

-- fractional date -0.5
              datecol             datetimecol
0 1959-12-31 12:00:00 9999-12-31 23:59:59.999
1                 NaT                     NaT

datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

-- date out of bounds
OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

-- date out of bounds neg
OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

-- mix count 4097
ValueError mix page row count (4097) does not fit in a 65536-byte page
-- mix count chunksize 4097
ValueError mix page row count (4097) does not fit in a 65536-byte page

-- mix count 2147483648
ValueError mix page row count (2147483648) does not fit in a 65536-byte page
-- mix count chunksize 2147483648
ValueError mix page row count (2147483648) does not fit in a 65536-byte page

#  leave that boundary unreachable and the rest of the page handed out as
        #  rows. What the file gets is an error, not which error.
        with open(datapath("io", "sas", "data", "dates_null.sas7bdat"), "rb") as fd:
            data = bytearray(fd.read())
        # the row-size subheader's row_count and mix-page row count
        struct.pack_into("<q", data, 65536 + 64728 + 6 * 8, 2**31)
        struct.pack_into("<q", data, 65536 + 64728 + 15 * 8, 2**31)
        with pytest.raises(OverflowError, match="too large to convert"):
            pd.read_sas(
                io.BytesIO(data), format="sas7bdat", chunksize=2, encoding=None
>           ).read()
              ^^^^^^

pandas/tests/io/sas/test_sas7bdat.py:814: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <pandas.io.sas.sas7bdat.SAS7BDATReader object at 0x7bfaab9158e0>
nro
…[3981 chars omitted]…
at.py::test_encoding_infer_unrecognized_code
0.03s call     pandas/tests/io/sas/test_sas7bdat.py::test_encoding_infer
=========================== short test summary info ============================
FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 146 passed in 5.34s

0.29s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_buffer[data_test_ix0]
0.28s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_file[data_test_ix0]
0.27s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_path_pathlib[data_test_ix0]
0.14s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-productsales-cp1252]
0.14s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-productsales-cp1251]
0.14s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-productsales-latin9]
0.13s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-productsales-latin-1]
0.13s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-productsales-cp4
…[2043 chars omitted]…
ding_infer_unrecognized_code
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-cp1251]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-cp037]

0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-latin-1]
272 passed, 1 deselected in 9.36s

0.08s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test1-latin9]
0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp1251]
0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-latin9]
0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-latin-1]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-ascii]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-utf-8]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp037]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object
…[300 chars omitted]…
t_sas7bdat.py::TestSAS7BDAT::test_iterator_loop[4-3]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-cp037]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp437]

0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_header_text_encoding_contract
501 passed, 1 deselected in 11.22s

Refused: `find /` walks the whole container FS. Scope under /repo.

M pandas/io/sas/sas7bdat.py
 pandas/io/sas/sas7bdat.py | 45 +++++++++++++++++++++++++++++++--------------
 1 file changed, 31 insertions(+), 14 deletions(-)
compiled

count: 2669
size: 21752
in-pack: 0
packs: 0
size-pack: 0
prune-packable: 0
garbage: 0
size-garbage: 0

<stdin>:13: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
<stdin>:14: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
<stdin>:23: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
<stdin>:24: DeprecationWarning: The 'generic' unit for NumPy timedelta is deprecated, and will raise an error in the future. This includes implicit conversion of bare integers (e.g. `+ 1`). Please use a specific unit instead.
fractional expected match
-0.5 expected match

OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

-- date out of bounds neg
OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

-- mix count 4097
ValueError mix page row count (4097) does not fit in a 65536-byte page
-- mix count chunksize 4097
ValueError mix page row count (4097) does not fit in a 65536-byte page

-- mix count 2147483648
ValueError mix page row count (2147483648) does not fit in a 65536-byte page

-- mix count chunksize 2147483648
ValueError mix page row count (2147483648) does not fit in a 65536-byte page

mix page row count (4097) does not fit in a 65536-byte page
closed True

106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the fi
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the f
np.float64(106751991167300.62) OutOfBoundsDatetime cannot convert input 9.223372036854946e+18 with the unit 's'
np.float64(-106751991167300.62) OutOfBoundsDatetime Out of bounds second timestamp
106751991167301.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167301.64; no SAS date can be this large, so the fi
-106751991167301.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167301.64; no SAS date can be this large, so the f

np.float64(106751991167300.64) np.float64(9.223372036854776e+18) np.float64(9.223372036854776e+18) True
np.float64(106751991167300.62) np.float64(9.223372036854774e+18) np.float64(9.223372036854774e+18) False
np.float64(-106751991167300.62) np.float64(-9.223372036854774e+18) np.float64(-9.223372036854774e+18) False

382:            self.row_length,
394:        # positions out of a buffer only row_length bytes long. Validate them
414:            if offset + length > self.row_length:
417:                    f"{self.row_length}-byte row; the file is corrupt"
653:        self.row_length = self._read_uint(
654:            offset + const.row_length_offset_multiplier * int_len,
657:        if self.row_length > self._page_length:
659:                f"row_length ({self.row_length}) exceeds the page size "
869:        if self.row_length:
871:            max_page_rows = self._page_length // self.row_length

datecol             datetimecol
0     NaT 9999-12-31 23:59:59.999
1     NaT                     NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object
[True, True]

diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..92c1894 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -196,13 +196,24 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
        Series of datetime64 dtype or datetime.datetime.
     """
     td = (_sas_origin - _unix_origin).as_unit("s")
+    values = sas_datetimes._values
+    if unit == "d":
+        # A SAS date is a day count and need not be a whole one.  Keep the
+        # fractional day by scaling to seconds, and round to the second, which

+        # is the resolution of the datetime64[s] result.  Rounding, rather than
+        # truncating, also keeps pre-epoch dates on the right calendar day.
+        values = np.round(values * 86400.0)
+        out_unit = "s"
+    else:
+        out_unit = "ms"
+
     # SAS's own date range tops out near 6e
…[2515 chars omitted]…
 self.row_length
+            if mix_page_row_count > max_page_rows:
+                self.close()
+                raise ValueError(
+                    f"mix page row count ({mix_page_row_count}) does not fit in "
+                    f"a {self._page_length}-byte page"
+                )
+
         if nrows > 0 and self._current_row_in_file_index >= self.row_count:
             return DataFrame()

pandas/tests/indexes/multi/test_duplicates.py:128:    msg = str(err.value)

datecol             datetimecol
0 2019-08-01 13:45:37 9999-12-31 23:59:59.999
  datecol datetimecol
1     NaT         NaT

self._page_length // self._subheader_pointer_length + 1,
            1 << (8 * const.subheader_count_length),
        )
        self._data_subheader_offsets = np.empty(max_subheaders, dtype=np.int64)
        self._data_subheader_lengths = np.empty(max_subheaders, dtype=np.int64)

    def __next__(self) -> DataFrame:
        da = self.read(nrows=self.chunksize or 1)
        if da.empty:
            self.close()
            raise StopIteration
        return da

    # Read a single float of the given width (4 or 8).
    def _read_float(self, offset: int, width: int) -> float:
        assert self._cached_page is not None
        if width == 4:
            return read_float_with_byteswap(
                self._cached_page, offset, self.need_byteswap
            )
        elif width == 8:
            return read_double_with_byteswap(
                self._cached_page, offset, s
…[596 chars omitted]…
          self._cached_page, offset, self.need_byteswap
            )
        elif width == 8:
            return read_uint64_with_byteswap(
                self._cached_page, offset, self.need_byteswap
            )
        else:
            self.close()
            raise ValueError("invalid int width")

    def _read_bytes(self, offset: int, length: int):
        assert self._cached_page is not None

(2, 2) [Timestamp('9999-12-31 00:00:00'), NaT]

clean

pandas/tests/io/sas
pandas/tests/io/sas/test_sas.py
pandas/tests/io/sas/test_sas7bdat.py

............
============================= slowest 30 durations =============================
0.03s setup    pandas/tests/io/sas/test_sas7bdat.py::test_date_time
0.02s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_time
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_max_sas_date_iterator
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_max_sas_date
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_null_date
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[9.223372036854776e+18-65824-datetime]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[1e+300-65816-date]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[1e+300-65824-datetime]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[9.22337203685477
…[185 chars omitted]…

sas7bdat.py::test_date_too_large_to_cast_raises[-9.223372036854776e+18-65816-date]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[-1e+300-65816-date]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[-1e+300-65824-datetime]

(17 durations < 0.005s hidden.  Use -vv to show these durations.)
12 passed, 261 deselected in 0.72s

21762.999999988428 2019-08-02 00:00:00
21762.999993055557 2019-08-01 23:59:59
21762.99999537037 2019-08-02 00:00:00
-5.787037037037037e-06 1960-01-01 00:00:00
5.787037037037037e-06 1960-01-01 00:00:00

inf OutOfBoundsDatetime Out of bounds SAS date value: inf; no SAS date can be this large, so the file is warnings []
-inf OutOfBoundsDatetime Out of bounds SAS date value: -inf; no SAS date can be this large, so the file i warnings []

pandas/io/sas/sas7bdat.py:205:        values = np.round(values * 86400.0)

460:filterwarnings = [
461-  "error",
462-  "error::ResourceWarning",
463-  "error::pytest.PytestUnraisableExceptionWarning",
464-  "error::pytest.PytestWarning",
465-  "ignore::pytest.PytestCacheWarning",
466-  # Ignore 3rd party EncodingWarning but raise on pandas'
467-  "ignore:.*encoding.* argument not specified:EncodingWarning",
468-  "error:.*encoding.* argument not specified:EncodingWarning:pandas",
469-  # From pyiceberg w/ Python >=3.13: https://github.com/apache/iceberg-python/issues/2530#issuecomment-3712112040
470-  "ignore:unclosed database in <sqlite3.Connection object*:ResourceWarning",
471-  # From fastparquet - test_read_filters_fastparquet

472-  "ignore:.*FileIO:pytest.PytestUnraisableExceptionWarning",
473-  # From plotting doctests
474-  "ignore:More than 20 figures have been opened:RuntimeWarning",
475-  "ignore:BuiltinImporter.module_repr() is deprecated and slat
…[1378 chars omitted]…
ed definitions and calls
509-disallow_untyped_calls = true
510-disallow_untyped_defs = true
511-disallow_incomplete_defs = true
512-check_untyped_defs = true
513-disallow_untyped_decorators = true
514-# None and Optional handling
515-no_implicit_optional = true
516-strict_optional = true
517-# Configuring warnings
518-warn_redundant_casts = true
519-warn_unused_ignores = true
520-warn_no_return = true

pandas/core/apply.py:1040:            with np.errstate(all="ignore"):
pandas/core/apply.py:1742:            with np.errstate(all="ignore"):
pandas/core/arrays/masked.py:1042:            with np.errstate(all="ignore"):
pandas/core/arrays/sparse/array.py:212:        with np.errstate(all="ignore"):
pandas/core/arrays/sparse/array.py:221:        with np.errstate(all="ignore"):
pandas/core/arrays/sparse/array.py:253:        with np.errstate(all="ignore"):
pandas/core/arrays/sparse/array.py:1988:            with np.errstate(all="ignore"):
pandas/core/arrays/sparse/array.py:2016:            with np.errstate(all="ignore"):
pandas/core/arrays/timedeltas.py:636:        with np.errstate(divide="ignore", invalid="ignore"):
pandas/core/arrays/timedeltas.py:1317:            with np.errstate(invalid="ignore"):
pandas/core/arrays/_ranges.py:221:    with np.errstate(over="raise"):
pandas/core/arrays/_

…[290 chars omitted]…
alid="ignore"):
pandas/core/frame.py:9958:        with np.errstate(all="ignore"):
pandas/core/frame.py:9983:        Caller is responsible for setting np.errstate where relevant.
pandas/core/frame.py:10348:        with np.errstate(all="ignore"):
pandas/core/indexes/range.py:1501:                with np.errstate(all="ignore"):
pandas/core/indexes/range.py:1513:            with np.errstate(all="ignore"):

RuntimeWarning overflow encountered in multiply

1e+308 OutOfBoundsDatetime Out of bounds SAS date value: 1e+308; no SAS date can be this large, s
-1e+308 OutOfBoundsDatetime Out of bounds SAS date value: -1e+308; no SAS date can be this large, 
inf OutOfBoundsDatetime Out of bounds SAS date value: inf; no SAS date can be this large, so t
106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be t

0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test16-utf-8]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_iterator_loop[4-3]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-cp037]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-cp1251]
501 passed, 1 deselected in 11.74s

diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..f2bdc07 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -196,13 +196,25 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
        Series of datetime64 dtype or datetime.datetime.
     """
     td = (_sas_origin - _unix_origin).as_unit("s")
+    values = sas_datetimes._values
+    if unit == "d":
+        # A SAS date is a day count and need not be a whole one.  Keep the
+        # fractional day by scaling to seconds, and round to the second, which

+        # is the resolution of the datetime64[s] result.  Rounding, rather than
+        # truncating, also keeps pre-epoch dates on the right calendar day.
+        with np.errstate(over="ignore"):
+            values = np.round(values * 86400.0)
+        out_unit = "s"
+    else:
+        out_unit = "ms"

…[2561 chars omitted]…
 self.row_length
+            if mix_page_row_count > max_page_rows:
+                self.close()
+                raise ValueError(
+                    f"mix page row count ({mix_page_row_count}) does not fit in "
+                    f"a {self._page_length}-byte page"
+                )
+
         if nrows > 0 and self._current_row_in_file_index >= self.row_count:
             return DataFrame()

datecol             datetimecol
0 9999-12-31 12:00:00 9999-12-31 23:59:59.999
1                 NaT                     NaT

-- fractional date 2019
              datecol             datetimecol
0 2019-08-01 13:45:37 9999-12-31 23:59:59.999
1                 NaT                     NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

-- fractional date -0.5
              datecol             datetimecol
0 1959-12-31 12:00:00 9999-12-31 23:59:59.999
1                 NaT                     NaT

datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

-- date out of bounds
OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

-- date out of bounds neg
OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

-- mix count 4097
ValueError mix page row count (4097) does not fit in a 65536-byte page
-- mix count chunksize 4097
ValueError mix page row count (4097) does not fit in a 65536-byte page

-- mix count 2147483648
ValueError mix page row count (2147483648) does not fit in a 65536-byte page
-- mix count chunksize 2147483648
ValueError mix page row count (2147483648) does not fit in a 65536-byte page

datecol                datetimecol
0 9999-12-31 3384795-12-09 07:48:20.641
1        NaT                        NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

grep: pandas/io/sas/__pycache__/sas7bdat.cpython-312.pyc: binary file matches
pandas/io/sas/sas7bdat.py:180:def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
pandas/io/sas/sas7bdat.py:1037:                    rslt[name] = _convert_datetimes(rslt[name], convert_type)

14 103   http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
158 93 # See https://communities.sas.com/t5/SAS-Programming/Leap-Years-divisible-by-4000/td-p/663467
735 119                 self.creator_proc = self._convert_header_text(self.creator_proc)  # pyright: ignore[reportArgumentType]

M pandas/io/sas/sas7bdat.py

ValueError mix page row count (4097) does not fit in a 65536-byte page

......                                                                   [100%]
6 passed in 4.37s

OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date

pandas/io/excel/_base.py:948:            parser = TextParser(
pandas/io/formats/xml.py:560:            curr_parser = XMLParser(encoding=self.encoding)
pandas/io/html.py:585:class _BeautifulSoupHtml5LibFrameParser(_HtmlFrameParser):
pandas/io/html.py:701:class _LxmlFrameParser(_HtmlFrameParser):
pandas/io/html.py:786:        parser = HTMLParser(recover=True, encoding=self.encoding)
pandas/io/html.py:871:    with TextParser(body, header=header, **kwargs) as tp:
pandas/io/json/_json.py:1349:            return FrameParser(json, **kwargs).parse()
pandas/io/json/_json.py:1353:            return SeriesParser(json, **kwargs).parse()
pandas/io/json/_json.py:1739:class SeriesParser(Parser):
pandas/io/json/_json.py:1758:class FrameParser(Parser):
pandas/io/parsers/python_parser.py:92:class PythonParser(ParserBase):
pandas/io/parsers/python_parser.py:1466:class FixedWidthFieldParser(PythonParser)

…[162 chars omitted]…
47:class _EtreeFrameParser(_XMLFrameParser):
pandas/io/xml.py:556:            curr_parser = XMLParser(encoding=self.encoding)
pandas/io/xml.py:562:class _LxmlFrameParser(_XMLFrameParser):
pandas/io/xml.py:666:            curr_parser = XMLParser(encoding=self.encoding)
pandas/io/xml.py:759:        with TextParser(nodes, names=tags, **kwargs) as tp:
pandas/io/xml.py:809:            p = _LxmlFrameParser(

def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
    """
    Convert to Timestamp if possible, otherwise to datetime.datetime.
    SAS float64 lacks precision for more than ms resolution so the fit
    to datetime.datetime is ok.

    Parameters
    ----------
    sas_datetimes : {Series, Sequence[float]}
       Dates or datetimes in SAS
    unit : {'d', 's'}
       "d" if the floats represent dates, "s" for datetimes

    Returns
    -------
    Series
       Series of datetime64 dtype or datetime.datetime.
    """
    td = (_sas_origin - _unix_origin).as_unit("s")
    values = sas_datetimes._values
    if unit == "d":
        # A SAS date is a day count and need not be a whole one.  Keep the
        # fractional day by scaling to seconds, and round to the second, which
        # is the resolution of the datetime64[s] result.  Rounding, rather than
        # 
…[2698 chars omitted]…
           )

        if nrows > 0 and self._current_row_in_file_index >= self.row_count:
            return DataFrame()

        nrows = min(nrows, self.row_count - self._current_row_in_file_index)

        nd = self._column_types.count(b"d")
        ns = self._column_types.count(b"s")

        self._byte_chunk = np.zeros((nd, 8 * nrows), dtype=np.uint8)
        self._setup_string_buffers(ns, nrows)

M pandas/io/sas/sas7bdat.py
......                                                                   [100%]
6 passed in 4.62s

ValueError mix page row count (4097) does not fit in a 65536-byte page

pandas/io/sas/sas7bdat.py | 47 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 33 insertions(+), 14 deletions(-)
 M pandas/io/sas/sas7bdat.py

buf closed False

ValueError mix page row count (9223372036854775807) does not fit in a 65536-byte page

airline.sas7bdat header 1024 page 4096 first page type 0x0 pages 1
cars.sas7bdat header 1024 page 4096 first page type 0x0 pages 3
dates_null.sas7bdat header 0 page 65536 first page type 0x2033 pages 2
datetime.sas7bdat header 65536 page 65536 first page type 0x0 pages 2
many_columns.sas7bdat header 8192 page 8192 first page type 0x0 pages 10
test1.sas7bdat header 65536 page 65536 first page type 0x0 pages 2
test10.sas7bdat header 0 page 256 first page type 0x2022 pages 512
test11.sas7bdat header 0 page 256 first page type 0x2022 pages 768
test12.sas7bdat header 0 page 256 first page type 0x2022 pages 768
test13.sas7bdat header 0 page 256 first page type 0x2033 pages 512
test14.sas7bdat header 0 page 256 first page type 0x2033 pages 768
test15.sas7bdat header 0 page 256 first page type 0x2033 pages 768

test2.sas7bdat header 65536 page 65536 first page type 0x0 pages 3
test3.sas7bdat header 65536 page 65536 first page type 0x0 pages 3
test_12659.sas7bdat header 65536 page 65536 first page type 0x0 pages 2

......                                                                   [100%]
6 passed in 4.27s
0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-cp437]
0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-cp437]
501 passed, 1 deselected in 12.37s

closed True

datecol             datetimecol
0 2019-08-01 13:45:37 9999-12-31 23:59:59.999
1                 NaT                     NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object

1 2019-08-01 00:00:01
59 2019-08-01 00:00:59
3600 2019-08-01 01:00:00
86399 2019-08-01 23:59:59

…[518 chars omitted]…
\n- Existing SAS suite: 501 passed, 1 deselected. The deselected pre-existing test asserts the old OverflowError behavior that this issue supersedes with ValueError."}
submitted.

/repo
total 3748
drwxr-xr-x 1 root root    4096 Nov  4 00:22 .
drwxr-xr-x 1 root root    4096 Nov  4 00:20 ..
drwxr-xr-x 1 root root    4096 Nov  4 00:28 .git
-rw-r--r-- 1 root root    1750 Nov  4 00:16 .gitattributes
drwxr-xr-x 1 root root    4096 Nov  4 00:16 .github
-rw-r--r-- 1 root root    1917 Nov  4 00:16 .gitignore
-rw-r--r-- 1 root root   12877 Nov  4 00:16 .pre-commit-config.yaml
-rw-r--r-- 1 root root    3983 Nov  4 00:16 AGENTS.md
-rw-r--r-- 1 root root    2306 Nov  4 00:16 AUTHORS.md
-rw-r--r-- 1 root root    1541 Nov  4 00:16 CITATION.cff

-rw-r--r-- 1 root root    1634 Nov  4 00:16 LICENSE
drwxr-xr-x 1 root root    4096 Nov  4 00:16 LICENSES
-rw-r--r-- 1 root root   11348 Nov  4 00:16 README.md
drwxr-xr-x 1 root root    4096 Nov  4 00:16 asv_bench
drwxr-xr-x 1 root root    4096 Nov  4 00:22 build
drwxr-xr-x 1 root root    4096 Nov  4 00:16 ci
-rw-r--r-- 1 root root     1
…[2176 chars omitted]…
s/sort_whatsnew_note.py
./scripts/stubtest_allowlist.txt
./scripts/validate_exception_location.py
./scripts/validate_min_versions_in_sync.py
./scripts/validate_rst_title_capitalization.py
./scripts/validate_test_dependencies.py
./scripts/validate_unwanted_patterns.py
./scripts/__init__.py
./subprojects/.wraplock
./subprojects/fast_float.wrap
./subprojects/xsimd.wrap
./web/pandas_web.py
./web/README.md

pandas/io/sas
pandas/io/sas/sas7bdat.py
pandas/io/sas/sasreader.py
pandas/io/sas/sas_constants.py
pandas/io/sas/sas_xport.py
pandas/tests/io/sas
pandas/tests/io/sas/data/0x00controlbyte.sas7bdat.bz2
pandas/tests/io/sas/data/0x40controlbyte.sas7bdat
pandas/tests/io/sas/data/airline.sas7bdat
pandas/tests/io/sas/data/airline.sas7bdat.gz
pandas/tests/io/sas/data/cars.sas7bdat
pandas/tests/io/sas/data/corrupt.sas7bdat

pandas/tests/io/sas/data/dates_null.sas7bdat
pandas/tests/io/sas/data/datetime.sas7bdat
pandas/tests/io/sas/data/load_log.sas7bdat
pandas/tests/io/sas/data/many_columns.sas7bdat
pandas/tests/io/sas/data/max_sas_date.sas7bdat
pandas/tests/io/sas/data/productsales.sas7bdat
pandas/tests/io/sas/data/test1.sas7bdat
pandas/tests/io/sas/data/test10.sas7bdat
pandas/tests/io/sas/data/test11.sas7bdat
pandas/tests/io/sas/data/test12.sas7bdat
pandas/tests/io/sas/data/test13.sas7bdat
pand
…[1832 chars omitted]…
er
pandas/io/sas/sasreader.py:153:        DataFrame if iterator=False and chunksize=None, else SAS7BDATReader
pandas/io/sas/sasreader.py:198:        from pandas.io.sas.sas7bdat import SAS7BDATReader
pandas/io/sas/sasreader.py:200:        reader = SAS7BDATReader(
pandas/io/sas/sas_constants.py:216:class SASIndex:
pandas/io/sas/sas_constants.py:262:# List of frequently used SAS date and datetime formats

"""
Read SAS7BDAT files

Based on code written by Jared Hobbs:
  https://bitbucket.org/jaredhobbs/sas7bdat

See also:
  https://github.com/BioStatMatt/sas7bdat

Partial documentation of the file format:
  https://cran.r-project.org/package=sas7bdat/vignettes/sas7bdat.pdf

Reference for binary data compression:
  http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
"""

from __future__ import annotations

import codecs
from datetime import datetime
import functools
import sys
from typing import TYPE_CHECKING
import warnings

import numpy as np

from pandas._config import using_string_dtype

from pandas._libs import lib
from pandas._libs.byteswap import (
    read_double_with_byteswap,
    read_float_with_byteswap,
    read_uint16_with_byteswap,
    read_uint32_with_byteswap,
    read_uint64_with_byteswap,
)
from pandas._libs.sas import (
…[8630 chars omitted]…
 = self._byte_chunk[jb, :].view(dtype=self.byte_order + "d")
                rslt[name] = pd.Series(col_arr, dtype=np.float64, index=ix, copy=False)
                convert_type = self._column_convert_types[j]
                if convert_type is not None:
                    rslt[name] = _convert_datetimes(rslt[name], convert_type)
                jb += 1
            elif self._column_types[j] == b"s":

pandas/io/sas/sas7bdat.py:46:    OutOfBoundsDatetime,
pandas/io/sas/sas7bdat.py:180:def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
pandas/io/sas/sas7bdat.py:209:        raise OutOfBoundsDatetime(
pandas/io/sas/sas7bdat.py:380:            self.row_count,
pandas/io/sas/sas7bdat.py:381:            self._mix_page_row_count,
pandas/io/sas/sas7bdat.py:502:        self._page_length = self._read_uint(
pandas/io/sas/sas7bdat.py:509:        # because _page_length is an unvalidated header field.
pandas/io/sas/sas7bdat.py:512:            self._page_length // self._subheader_pointer_length + 1,
pandas/io/sas/sas7bdat.py:571:            self._cached_page = self._path_or_buf.read(self._page_length)
pandas/io/sas/sas7bdat.py:574:            if len(self._cached_page) != self._page_length:
pandas/io/sas/sas7bdat.py:576:            done = self._process_page_meta()
pandas/io/sa

…[3132 chars omitted]…
r.row_count, parser._mix_page_row_count)
pandas/_libs/sas.pyx:738:                self.parser._current_page_subheaders_count = (
pandas/_libs/sas.pyx:749:                    or self.current_page_type == page_mix_type):
pandas/_libs/sas.pyx:796:            elif self.current_page_type == page_mix_type:
pandas/_libs/sas.pyx:808:                if self.current_row_on_page_index == self.mix_page_row_count:

_SAS_MARCH1_8000 = 2206123  # SAS day count for March 1, 8000


def _sas_to_gregorian_correction(values: np.ndarray, unit: str) -> np.ndarray:
    """
    Compute the additive correction (in `unit`) to convert SAS day/second counts
    to proleptic Gregorian day/second counts.

    SAS omits Feb 29 for years divisible by 4000 (unlike proleptic Gregorian);
    this adds back the missing days. `unit` must be "d" (days) or "s" (seconds).
    """
    scale = 86400 if unit == "s" else 1

    thresholds = np.array([_SAS_MARCH1_4000, _SAS_MARCH1_8000], dtype=np.int64) * scale
    correction = np.zeros(len(values), dtype=np.float64)
    valid = ~np.isnan(values)
    for threshold in thresholds:
        correction[valid] += (values[valid] >= threshold).astype(np.float64) * scale
    return correction


def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
    """
    Convert
…[8630 chars omitted]…
  int64_t lngt, start, ct
            uint8_t bval
            bint ascii_identity, mode_object, mode_utf8
            Buffer source
            StrColumn *col
            int64_t[:] column_types
            int64_t[:] lengths
            int64_t[:] offsets
            uint8_t[:, :] byte_chunk
            object[:, :] string_chunk
            StrColumn *str_cols
            int64_t[:, ::1] str_offsets

# Get endianness information
        buf = self._read_bytes(const.endianness_offset, const.endianness_length)
        if buf == b"\x01":
            self.byte_order = "<"
            self.need_byteswap = sys.byteorder == "big"
        else:
            self.byte_order = ">"
            self.need_byteswap = sys.byteorder == "little"

        # Get encoding information
        buf = self._read_bytes(const.encoding_offset, const.encoding_length)[0]
        if buf in const.encoding_names:

            self.inferred_encoding = const.encoding_names[buf]
        else:
            self.inferred_encoding = f"unknown (code={buf})"
        if self.encoding == "infer":
            # GH#66470 fall back rather than trying to decode with "infer".
            # default_encoding is latin-1, which cannot raise, so encoding=None
            # (opting out of decoding) keeps decoding header text in
…[8630 chars omitted]…
ib.ArrowInvalid:
                # Re-raise as the UnicodeDecodeError the per-cell decode gave.
                for row in range(len(offsets) - 1):
                    bytes(values[offsets[row] : offsets[row + 1]]).decode("utf-8")
                raise
        return ArrowStringArray(
            pa.chunked_array([pa_arr]), dtype=StringDtype(na_value=np.nan)
        )

    def _decode_string(self, b):

"text will be decoded using the encoding recorded in the file "
                "rather than returned as bytes. Pass encoding='infer' to adopt "
                "the future behavior, or encoding=None to keep the current one.",
                Pandas4Warning,
                stacklevel=find_stack_level(),
            )

    def _process_page_meta(self) -> bool:
        self._read_page_header()
        pt = [*const.page_meta_types, const.page_amd_type, const.page_mix_type]
        if self._current_page_type in pt:
            self._process_page_metadata()

        is_data_page = self._current_page_type == const.page_data_type
        is_mix_page = self._current_page_type == const.page_mix_type
        return bool(is_data_page or is_mix_page or self._data_subheader_count > 0)

    def _read_page_header(self) -> None:
        bit_offset = self._page_bit_offset
        tx = 
…[8630 chars omitted]…
     flag = self.current_row_on_page_index == self.current_page_block_count
                if flag:
                    done = self.read_next_page()
                    if done:
                        return True
                return False
            else:
                raise ValueError(f"unknown page type: {self.current_page_type}")

    @cython.wraparound(False)
    @cython.boundscheck(False)

import contextlib
from datetime import datetime
import io
import os
from pathlib import Path
import struct

import numpy as np
import pytest

from pandas._config import using_string_dtype

from pandas.compat import HAS_PYARROW
from pandas.errors import (
    EmptyDataError,
    OutOfBoundsDatetime,
    Pandas4Warning,
)

import pandas as pd
import pandas._testing as tm

from pandas.io.sas.sas7bdat import (
    SAS7BDATReader,
    _utf8_translation_table,
)
import pandas.io.sas.sas_constants as const

encoding_depr_msg = "The default value of 'encoding' in read_sas is deprecated"


@pytest.fixture
def dirpath(datapath):
    return datapath("io", "sas", "data")


@pytest.fixture(params=[(1, range(1, 16)), (2, [16])])
def data_test_ix(request, dirpath):
    i, test_ix = request.param
    fname = os.path.join(dirpath, f"test_sas7bdat_{i}.csv")
    df = pd.read_csv(fname)
    epoch = datet
…[8629 chars omitted]…
 row-size subheader's row_count and mix-page row count
822:    data = _dates_null_with_late_metadata_page(
832:def _dates_null_with_overrun_data_page(datapath):
835:    with open(datapath("io", "sas", "data", "dates_null.sas7bdat"), "rb") as fd:
850:            lambda datapath: _dates_null_with_late_metadata_page(
857:        (_dates_null_with_overrun_data_page, Exception, "Out of bounds read", 1000),

24d1ad3 base
            return None

    # A byte's meaning must also not depend on the bytes that follow it. The
    # probes above miss escape-style codecs: raw_unicode_escape maps every byte
    # one to one in isolation, yet decodes b"\\u0041" as "A".
    probe = b"\\u0041"
    if probe.decode(encoding, "replace") != "".join(
        bytes([value]).decode(encoding, "replace") for value in probe
    ):
        return None

    width = max((len(utf8) for utf8 in encoded if utf8 is not None), default=1)
    table = np.zeros(256 * width, dtype=np.uint8)
    lengths = np.full(256, const.undefined_byte, dtype=np.uint8)
    for value, utf8 in enumerate(encoded):
        if utf8 is not None:
            lengths[value] = len(utf8)
            table[value * width : value * width + len(utf8)] = bytearray(utf8)
    ascii_identity = all(encoded[value] == bytes([value]) for value in range(0x80
…[8630 chars omitted]…
th))
    reader = pd.read_sas(path, format="sas7bdat", chunksize=chunksize, encoding=None)
    with pytest.raises(expected, match=match):
        while not reader.read().empty:
            pass
    assert reader.handles.handle.closed


def test_0x40_control_byte(datapath):
    # GH 31243
    fname = datapath("io", "sas", "data", "0x40controlbyte.sas7bdat")
    df = pd.read_sas(fname, encoding="ascii")

current_column_number,
            self.column_names[current_column_number],
            column_label,
            column_format,
            self._column_types[current_column_number],
            self._column_data_lengths[current_column_number],
        )

        self.column_formats.append(column_format)
        self.columns.append(col)

    def read(self, nrows: int | None = None) -> DataFrame:

        if (nrows is None) and (self.chunksize is not None):
            nrows = self.chunksize
        elif nrows is None:
            nrows = self.row_count

        if len(self._column_types) == 0:
            self.close()
            raise EmptyDataError("No columns to parse from file")

        if nrows > 0 and self._current_row_in_file_index >= self.row_count:
            return DataFrame()

        nrows = min(nrows, self.row_count - self._current_row_in_file_index)

     
…[8630 chars omitted]…
_count,
            self._mix_page_row_count,
            self.column_count,
            self.compression,
            len(self._column_data_offsets),
            len(self.column_names),
        )

    def _validate_column_data_ranges(self) -> None:
        # The column offsets, lengths and types come straight out of the file's
        # column-attributes subheader, and every row is then read at those

266:    convert_dates : bool, defaults to True
298:        convert_dates: bool = True,
310:        self.convert_dates = convert_dates
578:        self._column_convert_types: list[str | None] = []
580:            if self._column_types[j] == b"d" and self.convert_dates:
583:                    self._column_convert_types.append("d")
585:                    self._column_convert_types.append("s")
587:                    self._column_convert_types.append(None)
589:                self._column_convert_types.append(None)
796:    def _process_format_subheader(self, offset: int, length: int) -> None:
1016:                convert_type = self._column_convert_types[j]
1017:                if convert_type is not None:

1018:                    rslt[name] = _convert_datetimes(rslt[name], convert_type)
            if hasattr(self, "creator_proc"):
                self.creator_proc = self._convert_head
…[5399 chars omitted]…
  Compute the additive correction (in `unit`) to convert SAS day/second counts
pandas/io/sas/sas7bdat.py:172:    thresholds = np.array([_SAS_MARCH1_4000, _SAS_MARCH1_8000], dtype=np.int64) * scale
pandas/io/sas/sas7bdat.py:214:        corrected = sas_datetimes._values + _sas_to_gregorian_correction(
pandas/io/sas/sas7bdat.py:221:        corrected = sas_datetimes._values + _sas_to_gregorian_correction(

def _read_bytes(self, offset: int, length: int):
        assert self._cached_page is not None
        if offset + length > len(self._cached_page):
            self.close()
            raise ValueError("The cached page is too small.")
        return self._cached_page[offset : offset + length]

    def _parse_metadata(self) -> None:
        done = False
        while not done:
            self._cached_page = self._path_or_buf.read(self._page_length)
            if len(self._cached_page) <= 0:

                break
            if len(self._cached_page) != self._page_length:
                raise ValueError("Failed to read a meta data page from the SAS file.")
            done = self._process_page_meta()

        self._column_convert_types: list[str | None] = []
        for j in range(self.column_count):
            if self._column_types[j] == b"d" and self.convert_dates:
           
…[8629 chars omitted]…
         rpos += nbytes
        elif control_byte == 0x80:
            nbytes = end_of_first_byte + 1
            buf_copy(outbuff, rpos, inbuff, ipos, nbytes)
            rpos += nbytes
            ipos += nbytes
        elif control_byte == 0x90:
            nbytes = end_of_first_byte + 17
            buf_copy(outbuff, rpos, inbuff, ipos, nbytes)
            rpos += nbytes
            ipos += nbytes

518:cdef class Parser:
547:        # current_row_on_page_index in readline().
552:        int current_row_on_page_index
560:        int mix_page_row_count
586:    def __init__(self, object parser):
618:        self.mix_page_row_count = min(parser.row_count, parser._mix_page_row_count)
653:        self.current_row_on_page_index = parser._current_row_on_page_index
685:    def read(self, int nrows):
696:        self.parser._current_row_on_page_index = self.current_row_on_page_index
712:        self.current_row_on_page_index = 0
782:                flag = self.current_row_on_page_index >= self.n_data_subheaders
789:                    self.current_row_on_page_index

792:                    self.current_row_on_page_index
794:                self.process_byte_array_with_data(offset, length)
806:                offset += self.current_row_on_page_index * self.row_length
807:                sel
…[51 chars omitted]…
gth)
808:                if self.current_row_on_page_index == self.mix_page_row_count:
814:                self.process_byte_array_with_data(
817:                    + self.current_row_on_page_index * self.row_length,
820:                flag = self.current_row_on_page_index == self.current_page_block_count
831:    cdef void process_byte_array_with_data(
969:        self.current_row_on_page_index += 1

if count >= data_capacity:
                raise ValueError(
                    f"Page holds more data subheaders ({count + 1}) than the "
                    f"page can address ({data_capacity})"
                )
            data_offsets[count] = <int64_t>subheader_offset
            data_lengths[count] = <int64_t>subheader_length
            count += 1
        else:
            processor = processors[subheader_index]
            processor(<int>subheader_offset, <int>subheader_length)
            # _process_columntext_subheader can turn compression on partway

            # through a page, so re-read it rather than hoisting once.
            compressed = bool(parser.compression)

    return count


cdef class Parser:

    cdef:
        int column_count
        int64_t[:] lengths
        int64_t[:] offsets
        int64_t[:] column_types
        uint8_t[:, :] byte_chunk
 
…[8630 chars omitted]…
get_handle(
            path_or_buf, "rb", is_text=False, compression=compression
        )

        self._path_or_buf = self.handles.handle

        # Same order as const.SASIndex
        self._subheader_processors = [
            self._process_rowsize_subheader,
            self._process_columnsize_subheader,
            self._process_subheader_counts,
            self._process_columntext_subheader,

self.decompressed_buf = Buffer(NULL, 0)
        self.str_cols = NULL
        self.n_str_cols = 0

    @cython.wraparound(False)
    @cython.boundscheck(False)
    def __init__(self, object parser):
        cdef:
            int j
            char[:] column_types

        self.parser = parser

        self.blank_missing = parser.blank_missing
        self.header_length = self.parser.header_length
        self.column_count = parser.column_count
        self.lengths = parser.column_data_lengths()
        self.offsets = parser.column_data_offsets()
        self.byte_chunk = parser._byte_chunk
        self.string_chunk = parser._string_chunk
        # sas7bdat.py always supplies these, using empty arrays for whichever
        # of the two string outputs is inactive, so the memoryview assignments
        # below never see None.
        self.str_mode = parser._str_mode
        self.st
…[6381 chars omitted]…
3 /repo/pandas/__init__.py
d 21762.573344907407 0   2019-08-01
dtype: datetime64[s]
d -0.5 0   1960-01-01
dtype: datetime64[s]
<class 'pandas.errors.OutOfBoundsDatetime'> OutOfBoundsDatetime('Out of bounds second timestamp: 292277026596-12-06 00:00:00')
<class 'pandas.errors.OutOfBoundsDatetime'> OutOfBoundsDatetime('Out of bounds second timestamp')
s -9223372036854775808 0   NaT
dtype: datetime64[ms]

pandas/_libs/tslibs/conversion.pyi:13:def cast_from_unit_vectorized(
pandas/_libs/tslibs/conversion.pyx:106:def cast_from_unit_vectorized(
pandas/core/arrays/timedeltas.py:33:from pandas._libs.tslibs.conversion import cast_from_unit_vectorized
pandas/core/arrays/timedeltas.py:1337:            converted = cast_from_unit_vectorized(data, unit or "ns")
pandas/core/tools/datetimes.py:37:    cast_from_unit_vectorized,
pandas/core/tools/datetimes.py:615:                arr = cast_from_unit_vectorized(arg, unit=unit)
169:def test_cast_from_unit_vectorized_near_int64_boundary(unit):
173:    ns_per_unit = np.timedelta64(1, unit).astype("timedelta64[ns]").astype(np.int64)
193:                conversion.cast_from_unit_vectorized(arr, unit)
195:            assert conversion.cast_from_unit_vectorized(arr, unit)[0] == expected

treat_tz_as_pytz,
)
from pandas._libs.tslibs.tzconversion cimport (
    Localizer,
    tz_localize_to_utc_single,
)
from pandas._libs.tslibs.util cimport (
    is_float_object,
    is_integer_object,
)

# ----------------------------------------------------------------------

# Constants

DT64NS_DTYPE = np.dtype("M8[ns]")
TD64NS_DTYPE = np.dtype("m8[ns]")


# ----------------------------------------------------------------------
# Unit Conversion Helpers

def cast_from_unit_vectorized(
    ndarray values,
    str unit,
    str out_unit="ns",
):
    """
    Vectorized analogue to cast_from_unit.
    """
    cdef:
        int64_t m
        int p
        NPY_DATETIMEUNIT in_reso, out_reso

    assert values.dtype.kind == "f"

    if unit in "YM":
        if not (((values % 1) == 0) | np.isnan(values)).all():
            # GH#47267 it is clear that 2 "M" corresponds to 1970-02-01,
    
…[4506 chars omitted]…
).value
        except (OutOfBoundsDatetime, OutOfBoundsTimedelta, OverflowError):
            with pytest.raises(OutOfBoundsDatetime):
                conversion.cast_from_unit_vectorized(arr, unit)
        else:
            assert conversion.cast_from_unit_vectorized(arr, unit)[0] == expected
pandas/io/sas/sas7bdat.py:217:        millis = cast_from_unit_vectorized(corrected, unit="s", out_unit="ms")

f"cannot convert input {values[bad_idx]} with the unit '{unit}'"
                )

    out[nat_mask] = NPY_NAT
    return out


@cython.overflowcheck(True)
cdef int64_t cast_from_unit(
    object ts,
    str unit,
    NPY_DATETIMEUNIT out_reso=NPY_FR_ns

) except? -1:
    """
    Return a casting of the unit represented to nanoseconds
    round the fractional part of a float to our precision, p.

    Parameters
    ----------
    ts : int, float, or None
    unit : str

    Returns
    -------
    int64_t
    """
    cdef:
        int64_t m
        int p
        NPY_DATETIMEUNIT in_reso

    # GH#56996 the base/frac arithmetic below stays in `ts`'s own dtype, so a
    #  numpy scalar narrower than int64/float64 does it at that width: under
    #  NEP 50 `frac * m` then overflows (int8) or rounds (float32/float16).
    #  Widen to Python int/float up front so the ma
…[8629 chars omitted]…
ff\xff\xfe": SASIndex.column_list_index,
}


# List of frequently used SAS date and datetime formats
# http://support.sas.com/documentation/cdl/en/etsug/60372/HTML/default/viewer.htm#etsug_intervals_sect009.htm
# https://github.com/epam/parso/blob/master/src/main/java/com/epam/parso/impl/SasFileConstants.java
sas_date_formats: Final = (
    "DATE",
    "DAY",
    "DDMMYY",
    "DOWNAME",
    "JULDAY",

139:    m, p = precision_from_unit(in_reso, out_reso)
250:        m, _ = precision_from_unit(out_reso, in_reso)
253:    m, p = precision_from_unit(in_reso, out_reso)
276:cdef (int64_t, int) precision_from_unit(

#  and 150 we'd get 2120-01-01 09:00:00
        if is_float_object(ts):
            ts = int(ts)
        dt64obj = np.datetime64(ts, unit)
        return get_datetime64_nanos(dt64obj, out_reso)

    in_reso = abbrev_to_npy_unit(unit)
    if out_reso < in_reso and in_reso != NPY_DATETIMEUNIT.NPY_FR_GENERIC:
        # We will end up rounding (always *down*), so don't need the fractional
        #  part of `ts`.
        m, _ = precision_from_unit(out_reso, in_reso)
        return (<int64_t>ts) // m

    m, p = precision_from_unit(in_reso, out_reso)

    # cast the unit, multiply base/frac separately
    # to avoid precision issues from float -> int
    try:
        base = <int64_t>ts
    except OverflowError as err:
        raise OutOfBoundsDatetime(
            f"cannot convert input {ts} with the unit '{unit}'"
        ) from err

    frac = ts - base
    if p:
        frac = r
…[1354 chars omitted]…
  not propagate, instead we get a warning about an ignored exception.
        #  https://github.com/pandas-dev/pandas/pull/51483#discussion_r1115198951
        m = get_conversion_factor(in_reso, out_reso)
50:page_bit_offset_x86: Final = 16
51:page_bit_offset_x64: Final = 32
52:subheader_pointer_length_x86: Final = 12
53:subheader_pointer_length_x64: Final = 24
76:row_count_offset_multiplier: Final = 6

21762.573344907407 [1880286333]
-0.5 [-43200]
21762.00000578704 [1880236800]
21762.00001736111 [1880236800]
nan [-9223372036854775808]
106751991167300.64 [9223372036854775347]
-106751991167300.64 [-9223372036854775347]
106751991167300.64 [9223372036854775347]
np.float64(106751991167300.62) [9223372036854774000]
np.float64(-106751991167300.62) [-9223372036854774000]

50:page_bit_offset_x86: Final = 16
51:page_bit_offset_x64: Final = 32
54:page_type_offset: Final = 0
56:block_count_offset: Final = 2
58:subheader_count_offset: Final = 4
70:subheader_pointers_offset: Final = 8
75:row_length_offset_multiplier: Final = 5
header_size_length: Final = 4
page_size_offset: Final = 200
page_size_length: Final = 4
page_count_offset: Final = 204
page_count_length: Final = 4

sas_release_offset: Final = 216
sas_release_length: Final = 8
sas_server_type_offset: Final = 224
sas_server_type_length: Final = 16
os_version_number_offset: Final = 240
os_version_number_length: Final = 16
os_maker_offset: Final = 256
os_maker_length: Final = 16
os_name_offset: Final = 272
os_name_length: Final = 16
page_bit_offset_x86: Final = 16
page_bit_offset_x64: Final = 32
subheader_pointer_length_x86: Final = 12
subheader_pointer_length_x64: Final = 24
page_type_offset: Final = 0
p
…[8629 chars omitted]…
bytes(8, "little")
    with pytest.raises(ValueError, match="the file is corrupt"):
        pd.read_sas(io.BytesIO(data), format="sas7bdat", encoding=None)


def _dates_null_with_late_metadata_page(
    datapath,
    sub_offset,
    sub_length,
    patches,
    total_rows=6,
    tail_page_type=const.page_data_type,
):
    """
    dates_null.sas7bdat, with a metadata page inserted after its data rows.

131072
130264 [16, 2, 3934]
rowlen/count/mix 16 2 3934 page 65536
current page type/count/subs/row index 512 12 10 0 65536
read      datecol             datetimecol
0 9999-12-31 9999-12-31 23:59:59.999
1        NaT                     NaT

# pandas Agent Instructions

## Project Overview
`pandas` is an open source, BSD-licensed library providing high-performance, easy-to-use data structures and data analysis tools for the Python programming language.

## Purpose
- Assist contributors by suggesting code changes, tests, and documentation edits for the pandas repository while preserving stability and compatibility.

## Persona & Tone
- Concise, neutral, code-focused. Prioritize correctness, readability, and tests.

## Project Guidelines

- Be sure to follow all guidelines for contributing to the codebase specified at https://pandas.pydata.org/docs/development/contributing_codebase.html
- These guidelines are also available in the following local files, which should be loaded into context and adhered to
    - doc/source/development/contributing_codebase.rst
    - doc/source/development/contributing_docstring.rst
    - doc/so
…[2881 chars omitted]…
ed diff, mark it with `>` or triple
  backticks so readers can tell which parts are the user's own words.
- Translation and grammar editing are an exception to the rule above, but must still be disclosed.
AssertionError 'Out of bounds read'
<class 'pandas.io.sas.sas7bdat.SAS7BDATReader'>
read      datecol             datetimecol
0 9999-12-31 9999-12-31 23:59:59.999
1        NaT                     NaT

21762.573344907407 1880286337.0 49536.99999995297 49537.0
s [1880286333]
ms [1880286336999]
us [1880286336999999]
ns [1880286336999999956]
1880286337.0 1880286337 49537

106751991167300.64 0x1.845c8a0ce5129p+46 9.223372036854776e+18 0x1.0000000000000p+63 0x1.0000000000000p+63
np.float64(106751991167300.64) 0x1.845c8a0ce5129p+46 np.float64(9.223372036854776e+18) 0x1.0000000000000p+63 True
np.float64(106751991167300.62) 0x1.845c8a0ce5128p+46 np.float64(9.223372036854774e+18) 0x1.ffffffffffffep+62 False
np.float64(106751991167300.66) 0x1.845c8a0ce512ap+46 np.float64(9.223372036854776e+18) 0x1.0000000000000p+63 True
np.float64(-106751991167300.64) -0x1.845c8a0ce5129p+46 np.float64(-9.223372036854776e+18) -0x1.0000000000000p+63 True
np.float64(-106751991167300.62) -0x1.845c8a0ce5128p+46 np.float64(-9.223372036854774e+18) -0x1.ffffffffffffep+62 False
np.float64(-106751991167300.66) -0x1.845c8a0ce512ap+46 np.float64(-9.223372036854776e+18) -0x1.0000000000000p+63 True

-3653 days +00:00:00 s -315619200 seconds timedelta64[s] -315619200 -315619200000000000
['1970-01-01T00:00:00'                 'NaT'] ['1960-01-01T00:00:00'                 'NaT'] datetime64[s]

0x40controlbyte.sas7bdat rows 1 len 156 mix 405 page 65536 type 0 subs 12 bit 32 ptr 24
airline.sas7bdat rows 32 len 44 mix 32 page 4096 type 512 subs 13 bit 16 ptr 12
cars.sas7bdat rows 392 len 23 mix 111 page 4096 type 512 subs 11 bit 16 ptr 12
corrupt.sas7bdat AttributeError 'SAS7BDATReader' object has no attribute 'column_count'
dates_null.sas7bdat rows 2 len 16 mix 3934 page 65536 type 512 subs 10 bit 32 ptr 24
datetime.sas7bdat rows 4 len 40 mix 1593 page 65536 type 512 subs 13 bit 16 ptr 12
load_log.sas7bdat rows 2097 len 224 mix 278 page 65536 type 512 subs 16 bit 32 ptr 24
many_columns.sas7bdat rows 3 len 3117 mix 0 page 8192 type 256 subs 0 bit 32 ptr 24
max_sas_date.sas7bdat rows 2 len 38 mix 3372 page 131072 type 0 subs 15 bit 32 ptr 24
productsales.sas7bdat rows 1440 len 96 mix 62 page 8192 type 512 subs 18 bit 16 ptr 12
test1.sas7bdat rows 10 len 816 mix 66 page 65536 ty
…[1178 chars omitted]…

n 809 mix 62 page 65536 type 0 subs 118 bit 32 ptr 24
test_12659.sas7bdat rows 36 len 104 mix 607 page 65536 type 512 subs 21 bit 16 ptr 12
test_meta2_page.sas7bdat rows 1000 len 224 mix 275 page 65536 type 0 subs 488 bit 16 ptr 12
zero_rows.sas7bdat rows 0 len 16 mix 7999 page 131072 type 512 subs 10 bit 32 ptr 24
zero_variables.sas7bdat rows 1 len 0 mix 64976 page 74752 type 512 subs 5 bit 32 ptr 24

/repo/build/cp312/pandas/_libs/sas.cpython-312-x86_64-linux-gnu.so
sas.pyi
sas.pyx
build/cp312/pandas/_libs/sas.cpython-312-x86_64-linux-gnu.so

x np.float64(21762.573344907407) np.float64(0.5733449074068631) np.float64(49536.99999995297)
0 np.float64(1.0) np.float64(86400.0) 86400
1 np.float64(0.6) np.float64(51840.0) 51840
2 np.float64(0.57) np.float64(49247.99999999999) 49247
3 np.float64(0.573) np.float64(49507.2) 49507
4 np.float64(0.5733) np.float64(49533.12) 49533
5 np.float64(0.57334) np.float64(49536.575999999994) 49536
6 np.float64(0.573345) np.float64(49537.008) 49537
7 np.float64(0.5733449) np.float64(49536.99936) 49536
8 np.float64(0.57334491) np.float64(49537.000223999996) 49537
9 np.float64(0.573344907) np.float64(49536.999964799994) 49536
10 np.float64(0.5733449074) np.float64(49536.99999936) 49536

11 np.float64(0.57334490741) np.float64(49537.000000224) 49537
12 np.float64(0.573344907407) np.float64(49536.9999999648) 49536
13 np.float64(0.5733449074069) np.float64(49536.99999995616) 49536
14 np.float64(0.57334490740686) np.float64(49536.9999999527) 49536
15 np.float64(0.573344907406863) np.float64(49536.99999995296) 49536
D [1880286333]
d [1880286333]

diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..2a0b8f7 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -198,11 +198,11 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
     td = (_sas_origin - _unix_origin).as_unit("s")
     # SAS's own date range tops out near 6e6 days, so a count this size is not
     # a date the file could legitimately hold -- it is corrupt bytes, or a
-    # numeric column carrying a date format. Casting it does not overflow, it
-    # saturates: a negative one lands on the NaT sentinel and is read as
-    # missing, and a positive one does raise below, but naming the date the
-    # saturated cast landed on rather than anything the file holds.

-    too_large = np.abs(sas_datetimes._values) >= 2.0**63
+    # numeric column carrying a date format. Check the scaled value before
…[3685 chars omitted]…
,10 @@ class SAS7BDATReader(SASReader):
                 f"{len(self._cached_page):d} of {self._page_length:d} bytes)"
             )
             raise ValueError(msg)
+
+        self._read_page_header()
+        if self._current_page_type == const.page_mix_type:
+            self._validate_mix_page_row_count(self._current_page_subheaders_count)
         return False
 
     def _read_next_page(self):

pandas/io/sas/sas7bdat.py:228:        unix_seconds = corrected * 86400 + td.asm8.view("i8")
pandas/core/arrays/datetimelike.py:990:                        other_arr = np.array(other.asm8)
pandas/core/arrays/datetimes.py:559:            return value.as_unit(self.unit, round_ok=False).asm8
pandas/core/arrays/period.py:1259:            td = np.asarray(Timedelta(days=other.n).asm8)
pandas/core/arrays/period.py:1261:            td = np.asarray(Timedelta(other).asm8)
pandas/core/arrays/period.py:1326:            td = np.asarray(Timedelta(other).asm8)
pandas/core/arrays/sparse/array.py:1522:                fill_value = fill_value.asm8
pandas/core/arrays/timedeltas.py:354:            return value.as_unit(self.unit, round_ok=False).asm8  # type: ignore[return-value]
pandas/core/dtypes/cast.py:590:                return dtype, td.asm8
pandas/core/dtypes/cast.py:749:                val = val.asm8
pandas/core/groupby/groupby.py:392:                return lambda key: Timestamp(key).asm8

0   2019-08-01 13:45:37
1   1959-12-31 12:00:00
2                   NaT
dtype: datetime64[s]
106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date
106751991167300.62 0   292277026586-12-06 14:41:04
dtype: datetime64[s]
-106751991167300.62 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.62; no SAS date can be this large, so the file is corrupt or the column is not a date
mix 4097 None ValueError mix page row count (4097) does not fit in a 65536-byte page
mix 4097 2 ValueError mix page row count (4097) does not fit in a 65536-byte page
mix 2147483648 None ValueError mix page row count (2147483648) does not fit in a 65536-byte page

mix 2147483648 2 ValueError mix page row count (2147483648) does not fit in a 65536-byte page

pandas/io/sas/sas7bdat.py:1044:    def _read_next_page(self):
pandas/io/sas/sas7bdat.py:1058:            return self._read_next_page()

..........................................................................................................................................Warning: column count mismatch (2 + 0 != 4096)

.Warning: column count mismatch (2 + 0 != 1)

.......F
=================================== FAILURES ===================================
______________ test_mix_page_row_count_too_large_to_reach_raises _______________

datapath = <function datapath.<locals>.deco at 0x7d272ebba8e0>

    def test_mix_page_row_count_too_large_to_reach_raises(datapath):
        # GH#47339 the mix page's row count bounds a row index the parser holds in

        #  an int, so a count that does not fit one has to be rejected rather than
        #  leave that boundary unreachable and the rest of the page handed out as
        #  rows. What the file gets is an error, not which error.
        with open(datapath("io", "sas", "data"
…[4490 chars omitted]…
at.py::test_encoding_infer_unrecognized_code
0.02s call     pandas/tests/io/sas/test_sas7bdat.py::test_encoding_infer
=========================== short test summary info ============================
FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 146 passed in 4.74s

..........................................................................................................................................Warning: column count mismatch (2 + 0 != 4096)

.Warning: column count mismatch (2 + 0 != 1)

........Warning: column count mismatch (2 + 0 != 1)

.............................................................................................................................
============================= slowest 30 durations =============================
0.41s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_iterator[data_test_ix0]
0.25s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_buffer[data_test_ix0]
0.24s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_file[data_test_ix0]
0.23s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_path_pathlib[data_test_ix0]

0.11s ca
…[2629 chars omitted]…
ect_path[True-test2-cp1252]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-ascii]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-latin9]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test1-cp437]
272 passed, 1 deselected in 8.33s

(<class '__main__.E'>, <class 'ValueError'>, <class 'OverflowError'>, <class 'ArithmeticError'>, <class 'Exception'>, <class 'BaseException'>, <class 'object'>)

..........................................................................................................................................Warning: column count mismatch (2 + 0 != 4096)

.Warning: column count mismatch (2 + 0 != 1)

.......F
=================================== FAILURES ===================================
______________ test_mix_page_row_count_too_large_to_reach_raises _______________

datapath = <function datapath.<locals>.deco at 0x710e75c231a0>

    def test_mix_page_row_count_too_large_to_reach_raises(datapath):
        # GH#47339 the mix page's row count bounds a row index the parser holds in

        #  an int, so a count that does not fit one has to be rejected rather than
        #  leave that boundary unreachable and the rest of the page handed out as
        #  rows. What the file gets is an error, not which error.
        with open(datapath("io", "sas", "data"
…[3398 chars omitted]…
rator_loop[16-3]
0.03s setup    pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_iterator[data_test_ix1]
=========================== short test summary info ============================
FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 failed, 146 passed in 5.04s

pandas/core/dtypes/cast.py:362:            except (OverflowError, ValueError):
pandas/core/reshape/melt.py:645:        except (TypeError, ValueError, OverflowError):
pandas/io/json/_json.py:1613:            except (TypeError, ValueError, OverflowError):
pandas/io/parsers/readers.py:3148:        except (TypeError, ValueError, OverflowError):
pandas/io/parsers/readers.py:3170:        except (TypeError, ValueError, OverflowError):
pandas/io/parsers/readers.py:3175:            except (TypeError, ValueError, OverflowError):
pandas/io/sas/sas7bdat.py:163:class _SAS7BDATMixPageRowCountError(ValueError, OverflowError):
pandas/_libs/lib.pyx:2684:        except (ValueError, OverflowError, TypeError):
pandas/_libs/parsers.pyx:1594:            except (OverflowError, ValueError):
pandas/_libs/parsers.pyx:1625:        except (TypeError, ValueError, OverflowError):
pandas/_libs/tslib.pyx:578:        except (TypeError, OverflowError, ValueError) as ex:
pandas/_libs/tslibs/parsing.pyx:1000:    except (ValueError, OverflowError, InvalidOperation):

pandas/_libs/tslibs/timezones.pyx:354:            except (OSError, OverflowError, ValueError):
pandas/_libs/tslibs/timezones.pyx:390:        except (OSError, OverflowError, ValueError):

..........................................................................................................................................Warning: column count mismatch (2 + 0 != 4096)

.Warning: column count mismatch (2 + 0 != 1)

.........Warning: column count mismatch (2 + 0 != 1)

.............................................................................................................................
============================= slowest 30 durations =============================
0.41s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_iterator[data_test_ix0]
0.28s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_buffer[data_test_ix0]
0.24s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_file[data_test_ix0]
0.24s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_path_pathlib[data_test_ix0]

0.11s c
…[2643 chars omitted]…
path_matches_object_path[True-test16-cp037]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test1-latin9]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-latin9]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-cp437]
273 passed in 8.35s

def _dates_null_with_late_metadata_page(
    datapath,
    sub_offset,
    sub_length,
    patches,
    total_rows=6,
    tail_page_type=const.page_data_type,
):
    """
    dates_null.sas7bdat, with a metadata page inserted after its data rows.

    dates_null is a 64-bit uncompressed file: a 65536-byte header followed by

    one 65536-byte mix page holding two 16-byte rows. The copy built here claims
    more rows than that page holds and continues with a metadata page carrying a
    patched copy of the subheader at ``sub_offset``, so that the patch is
    processed only once the parser has read past the mix page, and then with a
    data page for the rows it still owes.
    """
    page_length = header_length = 65536
    with open(datapath("io", "sas", "data", "dates_null.sas7bdat"), "rb") as fd:
        data = bytearray(fd.read())

    rowsize = header_length + 64728
    # row_cou
…[6176 chars omitted]…
       assert len(reader.read()) == 2


def _dates_null_with_overrun_data_page(datapath):
    # a data page claiming far more rows than fit on it, so that the parser
    # walks off the end of the page
    with open(datapath("io", "sas", "data", "dates_null.sas7bdat"), "rb") as fd:
pandas/io/sas/sas7bdat.py:454:    def close(self) -> None:
pandas/io/sas/sasreader.py:46:    def close(self) -> None: ...

if utf8 is not None:
            lengths[value] = len(utf8)
            table[value * width : value * width + len(utf8)] = bytearray(utf8)
    ascii_identity = all(encoded[value] == bytes([value]) for value in range(0x80))
    # Every reader gets these same arrays, so no one may write to them.
    table.flags.writeable = False
    lengths.flags.writeable = False
    return table, lengths, ascii_identity


# SAS uses a modified Gregorian calendar where years divisible by 4000 are
# not leap years (unlike proleptic Gregorian). These are the SAS day counts

# for the first day affected by each 4000-year boundary.
# See https://communities.sas.com/t5/SAS-Programming/Leap-Years-divisible-by-4000/td-p/663467
_SAS_MARCH1_4000 = 745154  # SAS day count for March 1, 4000
_SAS_MARCH1_8000 = 2206123  # SAS day count for March 1, 8000


class _SAS7BDATMixPageRowCountError(ValueError, Overf
…[6917 chars omitted]…
return False

    def _read_next_page(self):
        done = self._read_page_data()
        if done:
            return True

        self._read_page_header()
        if self._current_page_type in const.page_meta_types:
            self._process_page_metadata()

        if self._current_page_type not in [
            *const.page_meta_types,
            const.page_data_type,
 M pandas/io/sas/sas7bdat.py

pandas/io/sas/sas7bdat.py | 72 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 65 insertions(+), 7 deletions(-)
diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..6699b99 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -160,6 +160,10 @@ _SAS_MARCH1_4000 = 745154  # SAS day count for March 1, 4000
 _SAS_MARCH1_8000 = 2206123  # SAS day count for March 1, 8000
 
 
+class _SAS7BDATMixPageRowCountError(ValueError, OverflowError):
+    """A mix-page row count is invalid and cannot be represented by the parser."""

+
+
 def _sas_to_gregorian_correction(values: np.ndarray, unit: str) -> np.ndarray:
     """
     Compute the additive correction (in `unit`) to convert SAS day/second counts
@@ -198,11 +202,11 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
     td = (_sas_origin - _unix_origin
…[4267 chars omitted]…
page_length:d} bytes)"
             )
             raise ValueError(msg)
+
+        self._read_page_header()
+        if (
+            self._current_page_type == const.page_mix_type
+            and self._metadata_signature() == self._metadata_at_open
+        ):
+            self._validate_mix_page_row_count(self._current_page_subheaders_count)
         return False
 
     def _read_next_page(self):

cars row_count 392 rowlen 23 mix 111 page type 512 blocks 122 subs 11
ix 0 state (512, 1, 122, 11)
ix 110 state (256, 0, 176, 0)
end state (256, 105, 105, 0)

 airline row_count 32 rowlen 44 mix 32 page type 512 blocks 45 subs 13
ix 0 state (512, 1, 45, 13)
end state (512, 32, 45, 13)

 productsales row_count 1440 rowlen 96 mix 62 page type 512 blocks 80 subs 18
ix 0 state (512, 1, 80, 18)
ix 61 state (256, 0, 84, 0)

end state (256, 34, 34, 0)

 dates_null row_count 2 rowlen 16 mix 3934 page type 512 blocks 12 subs 10
ix 0 state (512, 1, 12, 10)
end state (512, 2, 12, 10)

21762.573344907407 2019-08-01 13:45:37 True datetime64[s]
-0.5 1959-12-31 12:00:00 True datetime64[s]
106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date
Traceback (most recent call last):
  File "<stdin>", line 34, in <module>
  File "/repo/pandas/io/sas/sasreader.py", line 214, in read_sas
    return reader.read()
           ^^^^^^^^^^^^^
  File "/repo/pandas/io/sas/sas7bdat.py", line 888, in read
    self._validate_mix_page_row_count(
  File "/repo/pandas/io/sas/sas7bdat.py", line 1015, in _validate_mix_page_row_count

    raise _SAS7BDATMixPageRowCountError(
pandas.io.sas.sas7bdat._SAS7BDATMixPageRowCountError: mix page row count (4097) does not fit in a 65536-byte page; too large to convert into rows

.....................................................................................................................................................................................................................................................................................................................................................................Warning: column count mismatch (2 + 0 != 4096)

.Warning: column count mismatch (2 + 0 != 1)

.........Warning: column count mismatch (2 + 0 != 1)

.......................................................................................................................................
============================= slowest 30 durations =============================
0.45s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_from_iterator[data_test_ix0]
0.25s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_fr
…[2712 chars omitted]…
.py::test_string_fast_path_matches_object_path[True-test1-ascii]

0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test1-latin-1]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::TestSAS7BDAT::test_iterator_loop[4-3]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[False-test2-cp037]
502 passed in 9.68s

pandas/errors/__init__.py:21:class IntCastingNaNError(ValueError):
pandas/errors/__init__.py:43:class NullFrequencyError(ValueError):
pandas/errors/__init__.py:308:class ParserError(ValueError):
pandas/errors/__init__.py:391:class EmptyDataError(ValueError):
pandas/errors/__init__.py:456:class MergeError(ValueError):
pandas/errors/__init__.py:580:class DuplicateLabelError(ValueError):
pandas/io/sas/sas7bdat.py:163:class _SAS7BDATMixPageRowCountError(ValueError, OverflowError):
pandas/_libs/tslibs/parsing.pyi:9:class DateParseError(ValueError): ...
pandas/_libs/tslibs/parsing.pyx:78:class DateParseError(ValueError):

date OK: 2019-08-01 13:45:37
date OK: 1959-12-31 12:00:00
date OOB OK: Out of bounds SAS date value: 106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date
date OOB OK: Out of bounds SAS date value: -106751991167300.64; no SAS date can be this large, so the file is corrupt or the column is not a date
mix-page OOB OK: 4097 None mix page row count (4097) does not fit in a 65536-byte page; too large to convert into rows
mix-page OOB OK: 4097 2 mix page row count (4097) does not fit in a 65536-byte page; too large to convert into rows
mix-page OOB OK: 2147483648 None mix page row count (2147483648) does not fit in a 65536-byte page; too large to convert into rows
mix-page OOB OK: 2147483648 2 mix page row count (2147483648) does not fit in a 65536-byte page; too large to convert into rows

M pandas/io/sas/sas7bdat.py

bash: line 673: ruff: command not found
 M pandas/io/sas/sas7bdat.py

158 93 # See https://communities.sas.com/t5/SAS-Programming/Leap-Years-divisible-by-4000/td-p/663467

raise ValueError(buffer_error_msg)
        fname = filepath_or_buffer.lower()
        if ".xpt" in fname:
            format = "xport"
        elif ".sas7bdat" in fname:
            format = "sas7bdat"
        else:
            raise ValueError(
                f"unable to infer format of SAS file from filename: {fname!r}"
            )

    reader: SASReader

    if format.lower() == "xport":
        from pandas.io.sas.sas_xport import XportReader

        reader = XportReader(
            filepath_or_buffer,
            index=index,
            encoding=encoding,
            chunksize=chunksize,
            compression=compression,
        )
    elif format.lower() == "sas7bdat":
        from pandas.io.sas.sas7bdat import SAS7BDATReader

        reader = SAS7BDATReader(
            filepath_or_buffer,
            index=index,
            encoding=encoding,
            chu
…[1692 chars omitted]…
# Get alignment information
        buf = self._read_bytes(const.align_1_offset, const.align_1_length)
        if buf == const.u64_byte_checker_value:
            self.U64 = True
            self._int_length = 8
21762.00000578704 2019-08-01 00:00:00
21762.00001736111 2019-08-01 00:00:02
21761.99999421296 2019-08-01 00:00:00
-0.500005787037037 1959-12-31 12:00:00
-0.5000173611111111 1959-12-31 11:59:59

diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..cf433b5 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -160,6 +160,14 @@ _SAS_MARCH1_4000 = 745154  # SAS day count for March 1, 4000
 _SAS_MARCH1_8000 = 2206123  # SAS day count for March 1, 8000
 
 
+class _SAS7BDATMixPageRowCountError(ValueError, OverflowError):
+    """A mix-page row count is invalid and cannot be represented by the parser.
+
+    The OverflowError base preserves compatibility with the previous error

+    raised when the count overflowed the parser's C integer.
+    """
+
+
 def _sas_to_gregorian_correction(values: np.ndarray, unit: str) -> np.ndarray:
     """
     Compute the additive correction (in `unit`) to convert SAS day/second counts
@@ -198,11 +206,11 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
     td = (_sas_origi
…[4288 chars omitted]…
       )
             raise ValueError(msg)
+
+        self._read_page_header()
+        if (
+            self._current_page_type == const.page_mix_type
+            and self._metadata_signature() == self._metadata_at_open
+        ):
+            self._validate_mix_page_row_count(self._current_page_subheaders_count)
         return False
 
     def _read_next_page(self):
 M pandas/io/sas/sas7bdat.py

submitted.

pandas/io/sas/sas7bdat.py:180:def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
pandas/io/sas/sas7bdat.py:188:    sas_datetimes : {Series, Sequence[float]}
pandas/io/sas/sas7bdat.py:205:    too_large = np.abs(sas_datetimes._values) >= 2.0**63
pandas/io/sas/sas7bdat.py:207:        value = sas_datetimes._values[too_large][0]
pandas/io/sas/sas7bdat.py:214:        corrected = sas_datetimes._values + _sas_to_gregorian_correction(
pandas/io/sas/sas7bdat.py:215:            sas_datetimes._values, unit="s"
pandas/io/sas/sas7bdat.py:219:        return pd.Series(dt64ms, index=sas_datetimes.index, copy=False)
pandas/io/sas/sas7bdat.py:221:        corrected = sas_datetimes._values + _sas_to_gregorian_correction(
pandas/io/sas/sas7bdat.py:222:            sas_datetimes._values, unit="d"
pandas/io/sas/sas7bdat.py:225:        return pd.Series(vals, dtype="M8[s]", index=sas_datetimes.index, copy=False)
pandas/io/sas/sas7bdat.py:582:                if fmt in const.sas_date_formats:
pandas/io/sas/sas7bdat.py:584:                elif fmt in const.sas_datetime_formats:

pandas/io/sas/sas_constants.py:265:sas_date_formats: Final = (
pandas/io/sas/sas_constants.py:334:sas_datetime_formats: Final = (

"""
Read SAS7BDAT files

Based on code written by Jared Hobbs:
  https://bitbucket.org/jaredhobbs/sas7bdat

See also:
  https://github.com/BioStatMatt/sas7bdat

Partial documentation of the file format:
  https://cran.r-project.org/package=sas7bdat/vignettes/sas7bdat.pdf

Reference for binary data compression:
  http://collaboration.cmc.ec.gc.ca/science/rpn/biblio/ddj/Website/articles/CUJ/1992/9210/ross/ross.htm
"""

from __future__ import annotations

import codecs
from datetime import datetime
import functools
import sys
from typing import TYPE_CHECKING
import warnings

import numpy as np

from pandas._config import using_string_dtype

from pandas._libs import lib
from pandas._libs.byteswap import (
    read_double_with_byteswap,
    read_float_with_byteswap,
    read_uint16_with_byteswap,
    read_uint32_with_byteswap,
    read_uint64_with_byteswap,
)
from pandas._libs.sas import (
…[7750 chars omitted]…
 | bytes,
        ctype: bytes,
        length: int,
    ) -> None:
        self.col_id = col_id
        self.name = name
        self.label = label
        self.format = format
        self.ctype = ctype
        self.length = length


# SAS7BDAT represents a SAS data file in SAS7BDAT format.
class SAS7BDATReader(SASReader):
    """
    Read SAS files in SAS7BDAT format.

    Parameters
    ----------

pandas/_libs/sas.pyi
pandas/_libs/sas.pyx
300:assert len(const.page_meta_types) == 2
302:    int page_meta_types_0 = const.page_meta_types[0]
303:    int page_meta_types_1 = const.page_meta_types[1]
304:    int page_mix_type = const.page_mix_type
305:    int page_data_type = const.page_data_type
323:    int c_page_type_offset = const.page_type_offset
324:    int c_page_type_mask2 = const.page_type_mask2
399:def collect_page_subheaders(parser):
401:    Walk the subheader pointers on the parser's current cached page.
408:    On a compressed file nearly every subheader on a page is a data subheader,

413:        bytes cached_page = parser._cached_page
414:        const uint8_t *page = <const uint8_t *>cached_page
415:        size_t page_len = len(cached_page)
416:        int n_subheaders = parser._current_page_subheaders_count
419:        int bit_offset = parser._page_bit_offset
441:     
…[3556 chars omitted]…
                  self.n_data_subheaders = collect_page_subheaders(self.parser)
748:            elif (self.current_page_type == page_data_type
749:                    or self.current_page_type == page_mix_type):
753:            # else: unsupported page type (e.g. AMD), skip to next page
755:    cdef update_next_page(self):
756:        # Called once from __init__ to sync with the page the Python parser

cdef:
        int column_count
        int64_t[:] lengths
        int64_t[:] offsets
        int64_t[:] column_types
        uint8_t[:, :] byte_chunk
        object[:, :] string_chunk
        # Output for the pyarrow string fast path (string_mode_utf8/_table):
        # str_cols[js] accumulates column js's utf-8 bytes, str_offsets[js, r+1]
        # records the end of row r within it, and str_valid[js, r] is 0 for a
        # null cell. Unused when str_mode is string_mode_object.
        int str_mode

        StrColumn *str_cols
        int n_str_cols
        int64_t[:, ::1] str_offsets
        uint8_t[:, ::1] str_valid
        # str_table[b * str_table_width : ...] holds the utf-8 for source byte
        # b, str_table_len[b] its length (undefined_byte if b is not a valid
        # character in str_encoding). Only set for string_mode_table. const
        # because these are shared
…[8628 chars omitted]…
f.bit_offset
        subheader_pointer_length = self.subheader_pointer_length

        # If there is no page, go to the end of the header and read a page.
        if self.cached_page == NULL:
            self.parser._path_or_buf.seek(self.header_length)
            done = self.read_next_page()
            if done:
                return True

        # Loop until a data row is read
        while True:

while True:
            if self.current_page_type in (page_meta_types_0, page_meta_types_1):
                flag = self.current_row_on_page_index >= self.n_data_subheaders
                if flag:
                    done = self.read_next_page()
                    if done:
                        return True
                    continue
                offset = <Py_ssize_t>self.data_subheader_offsets[
                    self.current_row_on_page_index
                ]
                length = <Py_ssize_t>self.data_subheader_lengths[

                    self.current_row_on_page_index
                ]
                self.process_byte_array_with_data(offset, length)
                return False
            elif self.current_page_type == page_mix_type:
                align_correction = (
                    bit_offset
                    + subheader_pointers_offset
         
…[7604 chars omitted]…
                      str_table[bval * table_width + bi]
                                    )
                                col.size += blen
                                k += 1
                    str_offsets[js, current_row + 1] = col.size
                js += 1

        self.current_row_on_page_index += 1
        self.current_row_in_chunk_index += 1
        self.current_row_in_file_index += 1

"text will be decoded using the encoding recorded in the file "
                "rather than returned as bytes. Pass encoding='infer' to adopt "
                "the future behavior, or encoding=None to keep the current one.",
                Pandas4Warning,
                stacklevel=find_stack_level(),
            )

    def _process_page_meta(self) -> bool:
        self._read_page_header()
        pt = [*const.page_meta_types, const.page_amd_type, const.page_mix_type]
        if self._current_page_type in pt:
            self._process_page_metadata()

        is_data_page = self._current_page_type == const.page_data_type
        is_mix_page = self._current_page_type == const.page_mix_type
        return bool(is_data_page or is_mix_page or self._data_subheader_count > 0)

    def _read_page_header(self) -> None:
        bit_offset = self._page_bit_offset
        tx = 
…[8629 chars omitted]…
"
        import pyarrow as pa

        values = self._str_values[js]
        # Copied out of the shared 2-D offsets array so that keeping one column
        # of the result alive does not pin every column's offsets.
        offsets = self._str_offsets[js].copy()
        valid = self._str_valid[js]
        nrows = len(valid)

        parsed = self._current_row_in_chunk_index
        if parsed < nrows:

current_column_number,
            self.column_names[current_column_number],
            column_label,
            column_format,
            self._column_types[current_column_number],
            self._column_data_lengths[current_column_number],
        )

        self.column_formats.append(column_format)
        self.columns.append(col)

    def read(self, nrows: int | None = None) -> DataFrame:

        if (nrows is None) and (self.chunksize is not None):
            nrows = self.chunksize
        elif nrows is None:
            nrows = self.row_count

        if len(self._column_types) == 0:
            self.close()
            raise EmptyDataError("No columns to parse from file")

        if nrows > 0 and self._current_row_in_file_index >= self.row_count:
            return DataFrame()

        nrows = min(nrows, self.row_count - self._current_row_in_file_index)

     
…[2473 chars omitted]…
elf, b):
        return b.decode(self.encoding or self.default_encoding)

    def _convert_header_text(self, b: bytes) -> str | bytes:
        if self.convert_header_text:
            if not b.isascii():
                # latin-1 and the file's own encoding disagree only here
                self._non_ascii_header_text = True
            return self._decode_string(b)
        else:
            return b

p.read(nrows)
            # A metadata page can follow the data pages, and its subheaders
            # rewrite the layout the rows just read were parsed with -- and that
            # the next chunk would be parsed with. The reader cannot reshape
            # itself mid-file, so a file that redefines its own layout is corrupt
            # however the redefinition reads: too wide a row and the columns come
            # from the wrong bytes, too few columns and one comes back all-NaN,
            # too many and the parser walks off the ends of the offset and length
            # arrays, and a rewritten row count pads the result with unread rows
            # or truncates it.
            if self._metadata_signature() != self._metadata_at_open:
                raise ValueError(

                    "The file changes the layout it declared partway through; "
                
…[2847 chars omitted]…
pe=object
        )
        self._str_table = empty_u1
        self._str_table_len = empty_u1
        self._str_table_width = 1
        self._str_ascii_identity = False
        self._str_encoding = self.encoding
        if mode == const.string_mode_object:
            self._str_offsets = np.empty((0, 0), dtype=np.int64)
            self._str_valid = np.empty((0, 0), dtype=np.uint8)
            return

pandas/core/arrays/timedeltas.py:33:from pandas._libs.tslibs.conversion import cast_from_unit_vectorized
pandas/core/arrays/timedeltas.py:1337:            converted = cast_from_unit_vectorized(data, unit or "ns")
pandas/core/tools/datetimes.py:37:    cast_from_unit_vectorized,
pandas/core/tools/datetimes.py:615:                arr = cast_from_unit_vectorized(arg, unit=unit)
pandas/io/sas/sas7bdat.py:42:from pandas._libs.tslibs.conversion import cast_from_unit_vectorized
pandas/io/sas/sas7bdat.py:217:        millis = cast_from_unit_vectorized(corrected, unit="s", out_unit="ms")
pandas/tests/tslibs/test_conversion.py:169:def test_cast_from_unit_vectorized_near_int64_boundary(unit):
pandas/tests/tslibs/test_conversion.py:193:                conversion.cast_from_unit_vectorized(arr, unit)
pandas/tests/tslibs/test_conversion.py:195:            assert conversion.cast_from_unit_vectorized(arr, unit)[0] == expected
pandas/_libs/tslibs/conversion.pyi:13:def cast_from_unit_vectorized(
pandas/_libs/tslibs/conversion.pyx:106:def cast_from_unit_vectorized(
pandas/_libs/tslibs/conversion.pyx:106:def cast_from_unit_vectorized(

pandas/_libs/tslibs/conversion.pyi:13:def cast_from_unit_vectorized(

def cast_from_unit_vectorized(
    ndarray values,
    str unit,
    str out_unit="ns",
):
    """
    Vectorized analogue to cast_from_unit.
    """
    cdef:
        int64_t m
        int p
        NPY_DATETIMEUNIT in_reso, out_reso

    assert values.dtype.kind == "f"

    if unit in "YM":
        if not (((values % 1) == 0) | np.isnan(values)).all():
            # GH#47267 it is clear that 2 "M" corresponds to 1970-02-01,
            #  but not clear what 2.5 "M" corresponds to, so we will
            #  disallow that case.
            raise ValueError(
                f"Conversion of non-round float with unit={unit} "
                "is ambiguous"
            )

        # GH#47266 go through np.datetime64 to avoid weird results e.g. with "Y"
        #  and 150 we'd get 2120-01-01 09:00:00
        values = values.astype(f"M8[{unit}]")
        dtype = np.dtype(f"M8[{out_unit}]")
 
…[2921 chars omitted]…
cast_from_unit_vectorized(
    values: npt.NDArray[np.float64], unit: str, out_unit: str = ...
) -> npt.NDArray[np.int64]: ...
def datetime_from_fields(
    years: npt.NDArray[np.int64],
    months: npt.NDArray[np.int64],
    days: npt.NDArray[np.int64],
    hours: npt.NDArray[np.int64],
    minutes: npt.NDArray[np.int64],
    seconds: npt.NDArray[np.int64],
) -> tuple[npt.NDArray[np.int64], int]: ...

pandas/tests/io/sas/test_sas7bdat.py:481:    with pytest.raises(OutOfBoundsDatetime, match=rf"Out of bounds SAS {what} value"):
pandas/tests/io/sas/test_sas7bdat.py:761:        "mix page row count",

# are returned as datetime.datetime, if this happens that whole chunk is returned
    # as datetime.datetime
    col_order = ["text", "dt_as_float", "dt_as_dt", "date_as_float", "date_as_date"]
    fname = datapath("io", "sas", "data", "max_sas_date.sas7bdat")
    results = []
    for df in pd.read_sas(fname, encoding="iso-8859-1", chunksize=1):
        # GH 19732: Timestamps imported from sas will incur floating point errors
        df = df.reset_index(drop=True)
        results.append(df)
    expected = [
        pd.DataFrame(
            {

                "text": ["max"],
                "dt_as_float": [253717747199.999],
                "dt_as_dt": np.array(
                    [datetime(9999, 12, 31, 23, 59, 59, 999000)], dtype="M8[ms]"
                ),
                "date_as_float": [2936547.0],
                "date_as_date": np.array([datetime(9999, 12, 31)], dtype="M8
…[8328 chars omitted]…
s the last row of the one
    #  it is on, so a trailing metadata page is walked routinely.
    data = _dates_null_with_late_metadata_page(
        datapath, 64728, 808, [(5 * 8, 16), (6 * 8, 6), (15 * 8, 2)]
    )
    with pd.read_sas(
        io.BytesIO(data), format="sas7bdat", chunksize=2, encoding=None
    ) as reader:
        assert len(reader.read()) == 2
        assert len(reader.read()) == 2

strict=True,
            )
        ):
            # A numeric column is widened into 8 bytes of the parser's output
            # buffer, so a longer one would also write past the front of it.
            if ctype == b"d" and length > 8:
                raise ValueError(
                    f"Column {index} is numeric but declares {length} bytes of "
                    f"data, more than the 8 a SAS number can occupy; the file "
                    f"is corrupt"
                )
            if offset + length > self.row_length:

                raise ValueError(
                    f"Column {index} spans bytes {offset}-{offset + length} of a "
                    f"{self.row_length}-byte row; the file is corrupt"
                )

    def column_data_lengths(self) -> np.ndarray:
        """Return a numpy int64 array of the column data lengths"""
        return np.asar
…[7728 chars omitted]…
ass encoding='infer' to adopt "
                "the future behavior, or encoding=None to keep the current one.",
                Pandas4Warning,
                stacklevel=find_stack_level(),
            )

    def _process_page_meta(self) -> bool:
        self._read_page_header()
        pt = [*const.page_meta_types, const.page_amd_type, const.page_mix_type]
        if self._current_page_type in pt:

0x40controlbyte.sas7bdat page 65536 rowlen 156 row_count 1 mix 405 curtype 0
airline.sas7bdat page 4096 rowlen 44 row_count 32 mix 32 curtype 512
cars.sas7bdat page 4096 rowlen 23 row_count 392 mix 111 curtype 512
pandas/tests/io/sas/data/corrupt.sas7bdat AttributeError 'SAS7BDATReader' object has no attribute 'column_count'
dates_null.sas7bdat page 65536 rowlen 16 row_count 2 mix 3934 curtype 512
datetime.sas7bdat page 65536 rowlen 40 row_count 4 mix 1593 curtype 512
load_log.sas7bdat page 65536 rowlen 224 row_count 2097 mix 278 curtype 512
many_columns.sas7bdat page 8192 rowlen 3117 row_count 3 mix 0 curtype 256
max_sas_date.sas7bdat page 131072 rowlen 38 row_count 2 mix 3372 curtype 0
productsales.sas7bdat page 8192 rowlen 96 row_count 1440 mix 62 curtype 512
test1.sas7bdat page 65536 rowlen 816 row_count 10 mix 66 curtype 512
test10.sas7bdat page 65536 rowlen 816 row_count 10 mix 

…[156 chars omitted]…
3.sas7bdat page 65536 rowlen 816 row_count 10 mix 62 curtype 512
test14.sas7bdat page 65536 rowlen 809 row_count 10 mix 62 curtype 0
test15.sas7bdat page 65536 rowlen 809 row_count 10 mix 62 curtype 0
test16.sas7bdat page 65536 rowlen 952 row_count 10 mix 53 curtype 512
test2.sas7bdat page 65536 rowlen 809 row_count 10 mix 67 curtype 0
test3.sas7bdat page 65536 rowlen 809 row_count 10 mix 67 curtype 0

21762.573344907407 2019-08-01 13:45:37
-0.5 1959-12-31 12:00:00
nan NaT
0.0 1960-01-01 00:00:00
21762.0 2019-08-01 00:00:00
raised Out of bounds SAS date value: 106751991167300.64; no SAS dat
raised Out of bounds SAS date value: -106751991167300.64; no SAS da

ValueError mix page row count (2147483648) does not fit in a 65536-byte page
ValueError mix page row count (4097) does not fit in a 65536-byte page

def read(self, nrows: int | None = None) -> DataFrame:
        if (nrows is None) and (self.chunksize is not None):
            nrows = self.chunksize
        elif nrows is None:
            nrows = self.row_count
    
        if len(self._column_types) == 0:
            self.close()
            raise EmptyDataError("No columns to parse from file")
    
        # A mix page shares its space between rows and the subheaders that
        # describe them, so the rows it hands out are bounded by the page it

        # lives on. A count larger than that makes the parser walk past the
        # real rows and return padding and metadata as data, so reject it
        # here rather than let it read garbage.
        mix_page_rows = min(self.row_count, self._mix_page_row_count)
        max_page_rows = self._page_length // self.row_length
        if mix_page_rows > max_page_rows:
            se
…[3582 chars omitted]…
o/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[False-test3-utf-8]
0.05s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test2-latin9]
=========================== short test summary info ============================
FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
1 failed, 272 passed in 9.84s

54:page_type_offset: Final = 0
55:page_type_length: Final = 2
60:page_type_mask: Final = 0x0F00
61:# Keep "page_comp_type" bits
62:page_type_mask2: Final = 0xF000 | page_type_mask
63:page_meta_type: Final = 0x0000
64:page_data_type: Final = 0x0100
65:page_mix_type: Final = 0x0200
66:page_amd_type: Final = 0x0400
67:page_meta2_type: Final = 0x4000
68:page_comp_type: Final = 0x9000
69:page_meta_types: Final = [page_meta_type, page_meta2_type]

0.10s call     pandas/tests/io/sas/test_xport.py::TestXport::test1_incremental
0.10s call     pandas/tests/io/sas/test_xport.py::TestXport::test1_index
0.08s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test1-latin9]
0.08s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp1251]
0.07s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-latin-1]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp437]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp1252]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp037]
0.06s call     pandas/tests/io/sas/test_sas7bdat.p
…[875 chars omitted]…
ts/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test1-utf-8]
=========================== short test summary info ============================

FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
1 failed, 501 passed in 11.08s
 pandas/io/sas/sas7bdat.py | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be t
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be 
106751991167299.64 OutOfBoundsDatetime cannot convert input 9.223372036854862e+18 with the unit 's'
-106751991167299.64 OutOfBoundsDatetime Out of bounds second timestamp

106751991167300.64 9.223372036854776e+18 9.223372036854776e+18
106751991167300.64 9.223372036854776e+18 np.float64(9.223372036854776e+18) False 0.0
106751991167299.64 9.223372036854689e+18 np.float64(9.223372036854689e+18) True -87040.0
106751991167290.64 9.223372036853912e+18 np.float64(9.223372036853912e+18) True -864256.0
106751991167200.64 9.223372036846135e+18 np.float64(9.223372036846135e+18) True -8640512.0

106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be t
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be 
106751991167299.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167299.64; no SAS date can be t
-106751991167299.64 OutOfBoundsDatetime Out of bounds second timestamp

.. deprecated:: 3.1.0
            The default will change from ``None`` to ``'infer'``.
    convert_text : bool, defaults to True
        If False, text variables are left as raw bytes.
    convert_header_text : bool, defaults to True
        If False, header text, including column names, are left as raw
        bytes.
    """

    _int_length: int
    _cached_page: bytes | None
    encoding: str | None

    def __init__(
        self,
        path_or_buf: FilePath | ReadBuffer[bytes],
        index=None,
        convert_dates: bool = True,
        blank_missing: bool = True,
        chunksize: int | None = None,
        encoding: str | lib.NoDefault | None = lib.no_default,
        convert_text: bool = True,
        convert_header_text: bool = True,
        compression: CompressionOptions = "infer",
    ) -> None:
        self._encoding_specified = encoding is not lib.no_defa
…[2488 chars omitted]…
  for their contents and this stays O(1) rather than O(ncols). The
        compression is in here for completeness rather than because a file can
        change it: only the first column-text subheader is read for it, and a
        file with none of those cannot be opened at all.
        """
        return (
            self.row_length,
            self.row_count,
            self._mix_page_row_count,

/usr/local/bin/python: No module named ruff
diff --git a/pandas/io/sas/sas7bdat.py b/pandas/io/sas/sas7bdat.py
index 1ecaf36..aee61ce 100644
--- a/pandas/io/sas/sas7bdat.py
+++ b/pandas/io/sas/sas7bdat.py
@@ -202,7 +202,10 @@ def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
     # saturates: a negative one lands on the NaT sentinel and is read as
     # missing, and a positive one does raise below, but naming the date the
     # saturated cast landed on rather than anything the file holds.
-    too_large = np.abs(sas_datetimes._values) >= 2.0**63
+    # Dates are day counts, so their representable range is correspondingly
+    # smaller: the same int64-second domain expressed in days.

+    limit = 2.0**63 if unit == "s" else 2.0**63 / 86400
+    too_large = np.abs(sas_datetimes._values) >= limit
     if too_large.any():
         value = sas_datetimes._values[t
…[2085 chars omitted]…
x_page_rows = self._page_length // self.row_length
+        if mix_page_rows > max_page_rows:
+            self.close()
+            raise ValueError(
+                f"mix page row count ({mix_page_rows}) does not fit in a "
+                f"{self._page_length}-byte page"
+            )
+
         if nrows > 0 and self._current_row_in_file_index >= self.row_count:
             return DataFrame()

datecol             datetimecol
0 2019-08-01 13:45:37 9999-12-31 23:59:59.999
1                 NaT                     NaT
datecol         datetime64[s]
datetimecol    datetime64[ms]
dtype: object
2019-08-01 13:45:37

pandas/tests/io/sas/test_sas7bdat.py:573:        # is walked from Parser.read_next_page instead.
pandas/tests/io/sas/test_sas7bdat.py:801:def test_mix_page_row_count_too_large_to_reach_raises(datapath):

106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be t
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be 
106751991167299.64 OutOfBoundsDatetime cannot convert input 9.223372036854862e+18 with the unit 's'
-106751991167299.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167299.64; no SAS date can be

21762.573344907407 2019-08-01 13:45:37 datetime64[s]
-0.5 1959-12-31 12:00:00 datetime64[s]
nan NaT datetime64[s]
0.0 1960-01-01 00:00:00 datetime64[s]
2936547.0 9999-12-31 00:00:00 datetime64[s]
106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: 106751991167300.64; no SAS date can be t
-106751991167300.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167300.64; no SAS date can be 
NO ERROR 106751991167299.64
-106751991167299.64 OutOfBoundsDatetime Out of bounds SAS date value: -106751991167299.64; no SAS date can be

0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-utf-8]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-latin-1]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-test3-cp437]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-cp437]
0.06s call     pandas/tests/io/sas/test_sas7bdat.py::test_string_fast_path_matches_object_path[True-load_log-latin9]
=========================== short test summary info ============================
FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
1 failed, 501 passed in 12.62s
 pandas/io/sas/sas7bdat.py | 43 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 41 insertions(+), 2 deletions(-)

def _convert_datetimes(sas_datetimes: pd.Series, unit: str) -> pd.Series:
    """
    Convert to Timestamp if possible, otherwise to datetime.datetime.
    SAS float64 lacks precision for more than ms resolution so the fit
    to datetime.datetime is ok.

    Parameters
    ----------
    sas_datetimes : {Series, Sequence[float]}
       Dates or datetimes in SAS
    unit : {'d', 's'}
       "d" if the floats represent dates, "s" for datetimes

    Returns
    -------
    Series
       Series of datetime64 dtype or datetime.datetime.
    """
    td = (_sas_origin - _unix_origin).as_unit("s")
    # SAS's own date range tops out near 6e6 days, so a count this size is not
    # a date the file could legitimately hold -- it is corrupt bytes, or a
    # numeric column carrying a date format. Casting it does not overflow, it
    # saturates: a negative one lands on the NaT sentinel and is re
…[4080 chars omitted]…
ose()
            raise ValueError(
                f"mix page row count ({mix_page_rows}) does not fit in a "
                f"{self._page_length}-byte page"
            )

        if nrows > 0 and self._current_row_in_file_index >= self.row_count:
            return DataFrame()

        nrows = min(nrows, self.row_count - self._current_row_in_file_index)

        nd = self._column_types.count(b"d")

============================= slowest 30 durations =============================
0.04s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_time
0.02s setup    pandas/tests/io/sas/test_sas7bdat.py::test_date_time
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_null_date
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_max_sas_date_iterator
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_max_sas_date
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_late_metadata_page_repeating_layout_reads
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[1e+300-65824-datetime]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_late_metadata_page_changing_layout_raises[count grown]
0.01s call     pandas/tests/io/sas/test_sas7bdat.py::test_late_metadata_page_changing_layout_raises[count shrunk]
0.01s call     pandas/t
…[433 chars omitted]…

l     pandas/tests/io/sas/test_sas7bdat.py::test_date_too_large_to_cast_raises[9.223372036854776e+18-65824-datetime]

(16 durations < 0.005s hidden.  Use -vv to show these durations.)
=========================== short test summary info ============================
FAILED pandas/tests/io/sas/test_sas7bdat.py::test_mix_page_row_count_too_large_to_reach_raises
1 failed, 23 passed, 249 deselected in 1.82s

…[615 chars omitted]…
the pre-existing test_mix_page_row_count_too_large_to_reach_raises, which asserts the old OverflowError behavior that this issue explicitly replaces with ValueError."}
submitted.