pybcsv 1.4.1__tar.gz → 1.4.3__tar.gz

{pybcsv-1.4.1 → pybcsv-1.4.3}/CMakeLists.txt

@@ -119,7 +119,6 @@ if(MSVC)
         /O2
         /std:c++20
     )
-    target_compile_definitions(_bcsv PRIVATE BCSV_HAS_BATCH_CODEC=1)
 elseif(APPLE)
     # Apple Clang ships LLVM 18-era libc++ where jthread/stop_token are
     # still experimental (guarded by _LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN).
@@ -129,15 +128,15 @@ elseif(APPLE)
         -fexperimental-library
         -mmacosx-version-min=13.3
     )
-    target_compile_definitions(_bcsv PRIVATE BCSV_HAS_BATCH_CODEC=1)
 else()
-    # Linux: full C++20 with batch codec + pthreads
+    # Linux: full C++20 with pthreads
     target_compile_options(_bcsv PRIVATE
         -O3 -Wall -Wextra
     )
-    target_compile_definitions(_bcsv PRIVATE BCSV_HAS_BATCH_CODEC=1)
     target_link_libraries(_bcsv PRIVATE pthread)
 endif()
 
+target_compile_definitions(_bcsv PRIVATE BCSV_HAS_BATCH_CODEC=1)
+
 # ── Install ─────────────────────────────────────────────────────────────
 install(TARGETS _bcsv LIBRARY DESTINATION pybcsv)

{pybcsv-1.4.1 → pybcsv-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybcsv
-Version: 1.4.1
+Version: 1.4.3
 Summary: High-performance Python bindings for the BCSV (Binary CSV) library with pandas integration
 Keywords: csv,binary,data-science,compression,performance,pandas,numpy,big-data,data-processing
 Author-Email: Tobias Weber <weber.tobias.md@gmail.com>
@@ -318,8 +318,6 @@ pybcsv.to_csv(bcsv_file, csv_file)
 pybcsv.read_columns(filename) -> dict[str, np.ndarray | list[str]]
 pybcsv.write_columns(filename, columns, col_order, col_types,
                      row_codec="delta", compression_level=1)
-pybcsv.read_to_dataframe(filename, columns=None) -> pd.DataFrame
-
 # Type utilities
 pybcsv.type_to_string(column_type) -> str
 ```

{pybcsv-1.4.1 → pybcsv-1.4.3}/README.md

@@ -272,8 +272,6 @@ pybcsv.to_csv(bcsv_file, csv_file)
 pybcsv.read_columns(filename) -> dict[str, np.ndarray | list[str]]
 pybcsv.write_columns(filename, columns, col_order, col_types,
                      row_codec="delta", compression_level=1)
-pybcsv.read_to_dataframe(filename, columns=None) -> pd.DataFrame
-
 # Type utilities
 pybcsv.type_to_string(column_type) -> str
 ```

{pybcsv-1.4.1 → pybcsv-1.4.3}/benchmarks/run_pybcsv_benchmarks.py

@@ -291,9 +291,9 @@ def write_dataframe_mode(file_path: Path, columns_spec, rows: list[list], row_co
 
 
 def read_dataframe_mode(file_path: Path) -> tuple[float, int]:
-    """Read using C++ read_to_dataframe (single call)."""
+    """Read using pybcsv.read_dataframe (Arrow fast-path)."""
     start = time.perf_counter()
-    df = pybcsv.read_to_dataframe(str(file_path))
+    df = pybcsv.read_dataframe(str(file_path))
     elapsed_ms = (time.perf_counter() - start) * 1000.0
     return elapsed_ms, len(df)
 

{pybcsv-1.4.1 → pybcsv-1.4.3}/include/bcsv/bcsv_c_api.h

@@ -339,6 +339,47 @@ size_t              bcsv_sampler_source_row_pos (const_bcsv_sampler_t sampler);
 // Last error/compile-error message (empty if no error)
 const char*         bcsv_sampler_error_msg      (const_bcsv_sampler_t sampler);
 
+// ============================================================================
+// Columnar Bulk I/O API
+// ============================================================================
+// Read up to max_rows rows from an opened reader into column-oriented buffers.
+// bufs is an array of num_cols pointers. For numeric columns, each pointer must
+// point to a pre-allocated buffer of element type matching the column type.
+// For string columns, the pointer is ignored (strings are stored internally
+// and retrieved via bcsv_reader_column_string).
+// Returns the number of rows actually read (may be less than max_rows at EOF).
+size_t              bcsv_reader_read_columns    (bcsv_reader_t reader, void** bufs,
+                                                 size_t num_cols, size_t max_rows);
+
+// Retrieve a string from the internal buffer after bcsv_reader_read_columns.
+// col is the column index, row is the row index (0-based within the batch).
+// Returns empty string if indices are out of range.
+const char*         bcsv_reader_column_string   (bcsv_reader_t reader, size_t col, size_t row);
+
+// Number of strings stored for a given column after bcsv_reader_read_columns.
+size_t              bcsv_reader_column_string_count(bcsv_reader_t reader, size_t col);
+
+// Pack all strings for a column into a contiguous null-terminated buffer.
+// Returns total bytes needed (including null terminators).
+// If out_buf is NULL or buf_size is 0, returns required size without writing.
+size_t              bcsv_reader_column_strings_packed(bcsv_reader_t reader, size_t col,
+                                                      char* out_buf, size_t buf_size);
+
+// Write num_rows rows from column-oriented buffers through an opened writer.
+// bufs is an array of num_cols pointers. For numeric columns, each pointer
+// must point to a buffer of element type matching the column type.
+// For string columns, bufs[c] must be a const char** (array of C string
+// pointers, one per row). Returns true on success.
+bool                bcsv_writer_write_columns   (bcsv_writer_t writer, const void** bufs,
+                                                 size_t num_cols, size_t num_rows);
+
+// Return the compact data size in bytes for a single row (sum of fixed-size
+// column widths — excludes strings).  Useful for buffer pre-allocation.
+size_t              bcsv_layout_row_data_size   (const_bcsv_layout_t layout);
+
+// Retrieve file flags as reported by the reader (only valid after open).
+int                 bcsv_reader_file_flags      (const_bcsv_reader_t reader);
+
 #ifdef __cplusplus
 }
 #endif

{pybcsv-1.4.1 → pybcsv-1.4.3}/include/bcsv/std_charconv_compat.h

@@ -113,19 +113,33 @@ namespace bcsv::compat {
         return std::to_chars(first, last, value);
     }
 
-    /// float fallback via snprintf.
+    /// float fallback via snprintf — shortest round-trip representation.
     inline std::to_chars_result to_chars(char* first, char* last, float value) {
         auto bufSize = static_cast<size_t>(last - first);
-        int n = std::snprintf(first, bufSize, "%.9g", value);
+        // Try digits10 first (6 digits); if round-trip fails, use max_digits10 (9).
+        int n = std::snprintf(first, bufSize, "%.6g", value);
+        if (n >= 0 && static_cast<size_t>(n) < bufSize) {
+            float check = std::strtof(first, nullptr);
+            if (check != value) {
+                n = std::snprintf(first, bufSize, "%.9g", value);
+            }
+        }
         if (n < 0 || static_cast<size_t>(n) >= bufSize)
             return {last, std::errc::value_too_large};
         return {first + n, std::errc{}};
     }
 
-    /// double fallback via snprintf.
+    /// double fallback via snprintf — shortest round-trip representation.
     inline std::to_chars_result to_chars(char* first, char* last, double value) {
         auto bufSize = static_cast<size_t>(last - first);
-        int n = std::snprintf(first, bufSize, "%.17g", value);
+        // Try digits10 first (15 digits); if round-trip fails, use max_digits10 (17).
+        int n = std::snprintf(first, bufSize, "%.15g", value);
+        if (n >= 0 && static_cast<size_t>(n) < bufSize) {
+            double check = std::strtod(first, nullptr);
+            if (check != value) {
+                n = std::snprintf(first, bufSize, "%.17g", value);
+            }
+        }
         if (n < 0 || static_cast<size_t>(n) >= bufSize)
             return {last, std::errc::value_too_large};
         return {first + n, std::errc{}};

{pybcsv-1.4.1 → pybcsv-1.4.3}/pybcsv/__init__.py

@@ -39,8 +39,6 @@ except ImportError:
         raise ImportError(_STUB_MSG)
     def write_columns(*args, **kwargs):
         raise ImportError(_STUB_MSG)
-    def read_to_dataframe(*args, **kwargs):
-        raise ImportError(_STUB_MSG)
     def type_to_string(*args, **kwargs):
         raise ImportError(_STUB_MSG)
     def read_to_arrow(*args, **kwargs):
@@ -101,7 +99,6 @@ __all__ = [
     # Columnar I/O
     "read_columns",
     "write_columns",
-    "read_to_dataframe",
     # Arrow interop
     "read_to_arrow",
     "write_from_arrow",

{pybcsv-1.4.1 → pybcsv-1.4.3}/pybcsv/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.4.1'
-__version_tuple__ = version_tuple = (1, 4, 1)
+__version__ = version = '1.4.3'
+__version_tuple__ = version_tuple = (1, 4, 3)
 
-__commit_id__ = commit_id = 'g85f1911cd'
+__commit_id__ = commit_id = 'gb295a0343'

{pybcsv-1.4.1 → pybcsv-1.4.3}/pybcsv/bindings.cpp

@@ -261,6 +261,40 @@ namespace {
         }
     }
 
+    // ── Shared columnar write loop ────────────────────────────────────
+    // Used by both write_columns and write_from_arrow.
+
+    inline void write_columnar_core(
+            const bcsv::Layout& layout,
+            const std::string& row_codec,
+            const std::string& filename,
+            size_t num_rows, size_t num_cols,
+            const std::vector<const void*>& bufs,
+            const std::vector<std::vector<std::string>>& string_cols,
+            const std::vector<bool>& is_string,
+            const std::vector<bcsv::ColumnType>& col_types,
+            size_t compression_level,
+            bcsv::FileFlags flags) {
+        PyWriter pw(layout, row_codec);
+        pw.visit([&](auto& w) {
+            nb::gil_scoped_release release;
+            if (!w.open(filename, true, compression_level, 64, flags))
+                throw std::runtime_error("Failed to open file for writing: " + filename);
+            for (size_t r = 0; r < num_rows; ++r) {
+                auto& row = w.row();
+                for (size_t c = 0; c < num_cols; ++c) {
+                    if (is_string[c]) {
+                        row.set(c, string_cols[c][r]);
+                    } else {
+                        set_from_numpy(row, c, col_types[c], bufs[c], r);
+                    }
+                }
+                w.writeRow();
+            }
+            w.close();
+        });
+    }
+
     // ── Shared binding helpers for reader-like / writer-like classes ───
     // Attaches read_row, read_all, __enter__, __exit__, __iter__, __next__
     // to any class that has .readNext(), .row(), .layout(), .close().
@@ -275,8 +309,18 @@ namespace {
         .def("read_all", [](ReaderT& r) -> nb::list {
             nb::list result;
             const auto& layout = r.layout();
-            while (r.readNext())
-                result.append(row_to_list(r.row(), layout));
+            const size_t n = layout.columnCount();
+            // Cache column types to avoid per-row layout lookups
+            std::vector<bcsv::ColumnType> col_types(n);
+            for (size_t i = 0; i < n; ++i)
+                col_types[i] = layout.columnType(i);
+            while (r.readNext()) {
+                const auto& row = r.row();
+                nb::list row_list;
+                for (size_t i = 0; i < n; ++i)
+                    row_list.append(extract_column_value(row, i, col_types[i]));
+                result.append(std::move(row_list));
+            }
             return result;
         })
         .def("__enter__", [](ReaderT& r) -> ReaderT& { return r; }, nb::rv_policy::reference)
@@ -602,7 +646,10 @@ NB_MODULE(_bcsv, m) {
             return success;
         }, nb::arg("filename"))
         .def("layout", &ReaderT::layout, nb::rv_policy::reference_internal)
-        .def("read_next", &ReaderT::readNext)
+        .def("read_next", [](ReaderT& r) {
+            nb::gil_scoped_release release;
+            return r.readNext();
+        })
         .def("close", [](ReaderT& reader) { nb::gil_scoped_release release; reader.close(); })
         .def("is_open", &ReaderT::isOpen)
         .def("file_flags", [](ReaderT& r) -> int { return static_cast<int>(r.fileFlags()); })
@@ -638,7 +685,81 @@ NB_MODULE(_bcsv, m) {
                 result[nb::cast(layout.columnName(i))] =
                     extract_column_value(row, i, layout.columnType(i));
             return result;
-        }, "Get the current row as a dict {column_name: value}");
+        }, "Get the current row as a dict {column_name: value}")
+        .def("read_batch", [](ReaderT& r, size_t batch_size) -> nb::object {
+            const auto& layout = r.layout();
+            const size_t num_cols = layout.columnCount();
+            if (num_cols == 0)
+                throw std::runtime_error("Reader has no columns");
+
+            // Cache column metadata
+            std::vector<bcsv::ColumnType> col_types(num_cols);
+            std::vector<std::string> col_names(num_cols);
+            std::vector<bool> is_str(num_cols, false);
+            for (size_t c = 0; c < num_cols; ++c) {
+                col_types[c] = layout.columnType(c);
+                col_names[c] = layout.columnName(c);
+                is_str[c] = (col_types[c] == bcsv::ColumnType::STRING);
+            }
+
+            // Allocate numpy arrays (numeric) and C++ string vectors (strings)
+            auto np = nb::module_::import_("numpy");
+            std::vector<nb::object> arrays(num_cols);
+            std::vector<void*> bufs(num_cols, nullptr);
+            std::vector<std::vector<std::string>> string_cols(num_cols);
+
+            for (size_t c = 0; c < num_cols; ++c) {
+                if (is_str[c]) {
+                    string_cols[c].reserve(batch_size);
+                } else {
+                    nb::object shape = nb::make_tuple(static_cast<int64_t>(batch_size));
+                    arrays[c] = np.attr("empty")(shape,
+                        "dtype"_a = bcsv_type_to_numpy_dtype(col_types[c]));
+                    bufs[c] = reinterpret_cast<void*>(
+                        nb::cast<intptr_t>(arrays[c].attr("ctypes").attr("data")));
+                }
+            }
+
+            // Read loop under GIL release
+            size_t rows_read = 0;
+            {
+                nb::gil_scoped_release release;
+                while (rows_read < batch_size && r.readNext()) {
+                    const auto& row = r.row();
+                    for (size_t c = 0; c < num_cols; ++c) {
+                        if (is_str[c]) {
+                            string_cols[c].emplace_back(row.template get<std::string>(c));
+                        } else {
+                            fill_numpy_cell(row, c, col_types[c], bufs[c], rows_read);
+                        }
+                    }
+                    ++rows_read;
+                }
+            }
+
+            if (rows_read == 0) return nb::none();
+
+            // Build result dict
+            nb::dict result;
+            for (size_t c = 0; c < num_cols; ++c) {
+                if (is_str[c]) {
+                    nb::list str_list;
+                    for (auto& s : string_cols[c])
+                        str_list.append(nb::cast(std::move(s)));
+                    result[nb::cast(col_names[c])] = std::move(str_list);
+                } else {
+                    if (rows_read < batch_size) {
+                        // Slice to actual row count
+                        auto stop = nb::int_(static_cast<int64_t>(rows_read));
+                        auto sl = nb::steal(PySlice_New(Py_None, stop.ptr(), Py_None));
+                        arrays[c] = arrays[c][sl];
+                    }
+                    result[nb::cast(col_names[c])] = std::move(arrays[c]);
+                }
+            }
+            return result;
+        }, nb::arg("batch_size") = 10000,
+           "Read up to batch_size rows into a dict of numpy arrays/lists. Returns None at EOF.");
     bind_reader_iteration<ReaderT>(reader_cls);
 
     // Utility functions
@@ -908,102 +1029,6 @@ NB_MODULE(_bcsv, m) {
     }, nb::arg("filename"),
        "Read a BCSV file into a dict of numpy arrays (numeric) and lists (strings)");
 
-    // ── Columnar I/O: read_to_dataframe ────────────────────────────────
-
-    m.def("read_to_dataframe", [](const std::string& filename,
-                                   const std::optional<nb::list>& columns) -> nb::object {
-        // Phase 1: Open via ReaderDirectAccess
-        bcsv::ReaderDirectAccess<bcsv::Layout> reader;
-        {
-            nb::gil_scoped_release release;
-            if (!reader.open(filename, true)) {
-                throw std::runtime_error("Failed to open file: " + filename);
-            }
-        }
-        const size_t num_rows = reader.rowCount();
-        const auto& layout = reader.layout();
-        const size_t num_cols = layout.columnCount();
-        if (num_cols == 0)
-            throw std::runtime_error("File has no columns: " + filename);
-
-        // Cache column metadata
-        std::vector<std::string> col_names(num_cols);
-        std::vector<bcsv::ColumnType> col_types(num_cols);
-        std::vector<bool> is_string(num_cols, false);
-        for (size_t i = 0; i < num_cols; ++i) {
-            col_names[i] = layout.columnName(i);
-            col_types[i] = layout.columnType(i);
-            is_string[i] = (col_types[i] == bcsv::ColumnType::STRING);
-        }
-
-        // Phase 2: Allocate numpy arrays / string vectors
-        auto np = nb::module_::import_("numpy");
-        std::vector<nb::object> arrays(num_cols);
-        std::vector<void*> bufs(num_cols, nullptr);
-        std::vector<std::vector<std::string>> string_cols(num_cols);
-
-        for (size_t c = 0; c < num_cols; ++c) {
-            if (is_string[c]) {
-                string_cols[c].reserve(num_rows);
-            } else {
-                nb::object shape = nb::make_tuple(static_cast<int64_t>(num_rows));
-                arrays[c] = np.attr("empty")(shape, "dtype"_a = bcsv_type_to_numpy_dtype(col_types[c]));
-                bufs[c] = reinterpret_cast<void*>(nb::cast<intptr_t>(arrays[c].attr("ctypes").attr("data")));
-            }
-        }
-
-        // Phase 3: Entire read loop under GIL release
-        {
-            nb::gil_scoped_release release;
-            size_t row_idx = 0;
-            while (reader.readNext()) {
-                const auto& row = reader.row();
-                for (size_t c = 0; c < num_cols; ++c) {
-                    if (is_string[c]) {
-                        string_cols[c].emplace_back(row.template get<std::string>(c));
-                    } else {
-                        fill_numpy_cell(row, c, col_types[c], bufs[c], row_idx);
-                    }
-                }
-                ++row_idx;
-            }
-            reader.close();
-        }
-
-        // Phase 4: Build column dict
-        nb::dict col_dict;
-        for (size_t c = 0; c < num_cols; ++c) {
-            if (is_string[c]) {
-                nb::list str_list;
-                for (size_t i = 0; i < string_cols[c].size(); ++i) {
-                    str_list.append(nb::cast(std::move(string_cols[c][i])));
-                }
-                col_dict[nb::cast(col_names[c])] = std::move(str_list);
-            } else {
-                col_dict[nb::cast(col_names[c])] = std::move(arrays[c]);
-            }
-        }
-
-        // Phase 5: Filter columns if requested
-        if (columns.has_value()) {
-            nb::dict filtered;
-            const nb::list& cols_list = columns.value();
-            for (size_t i = 0; i < cols_list.size(); ++i) {
-                nb::handle col_name = cols_list[i];
-                auto key = nb::cast<std::string>(col_name);
-                if (col_dict.contains(nb::cast(key))) {
-                    filtered[col_name] = col_dict[col_name];
-                }
-            }
-            col_dict = std::move(filtered);
-        }
-
-        // Phase 6: Construct pd.DataFrame in C++
-        auto pd = nb::module_::import_("pandas");
-        return pd.attr("DataFrame")(col_dict);
-    }, nb::arg("filename"), nb::arg("columns") = nb::none(),
-       "Read a BCSV file directly into a pandas DataFrame");
-
     // ── Columnar I/O: write_columns ────────────────────────────────────
 
     m.def("write_columns", [](const std::string& filename, const nb::dict& columns,
@@ -1063,26 +1088,10 @@ NB_MODULE(_bcsv, m) {
             }
         }
 
-        // Create writer and run entire write loop under GIL release
-        PyWriter pw(layout, row_codec);
-        pw.visit([&](auto& w) {
-            nb::gil_scoped_release release;
-            if (!w.open(filename, true, compression_level, 64, flags)) {
-                throw std::runtime_error("Failed to open file for writing: " + filename);
-            }
-            for (size_t r = 0; r < num_rows; ++r) {
-                auto& row = w.row();
-                for (size_t c = 0; c < num_cols; ++c) {
-                    if (is_string[c]) {
-                        row.set(c, string_cols[c][r]);
-                    } else {
-                        set_from_numpy(row, c, col_types[c], bufs[c], r);
-                    }
-                }
-                w.writeRow();
-            }
-            w.close();
-        });
+        // Write via shared helper
+        write_columnar_core(layout, row_codec, filename, num_rows, num_cols,
+                            bufs, string_cols, is_string, col_types,
+                            compression_level, flags);
     }, nb::arg("filename"), nb::arg("columns"), nb::arg("col_order"),
        nb::arg("col_types"), nb::arg("row_codec") = "delta",
        nb::arg("compression_level") = 1,
@@ -1493,25 +1502,12 @@ NB_MODULE(_bcsv, m) {
             }
         }
 
-        // Write under GIL release
-        PyWriter pw(layout, row_codec);
-        pw.visit([&](auto& w) {
-            nb::gil_scoped_release release;
-            if (!w.open(filename, true, compression_level, 64, flags))
-                throw std::runtime_error("Failed to open file for writing: " + filename);
-            for (int64_t r = 0; r < num_rows; ++r) {
-                auto& row = w.row();
-                for (int64_t c = 0; c < num_cols; ++c) {
-                    if (is_string[c]) {
-                        row.set(c, string_cols[c][r]);
-                    } else {
-                        set_from_numpy(row, c, col_types[c], bufs[c], static_cast<size_t>(r));
-                    }
-                }
-                w.writeRow();
-            }
-            w.close();
-        });
+        // Write via shared helper
+        write_columnar_core(layout, row_codec, filename,
+                            static_cast<size_t>(num_rows),
+                            static_cast<size_t>(num_cols),
+                            bufs, string_cols, is_string, col_types,
+                            compression_level, flags);
     }, nb::arg("filename"), nb::arg("table"),
        nb::arg("row_codec") = "delta",
        nb::arg("compression_level") = 1,

{pybcsv-1.4.1 → pybcsv-1.4.3}/pybcsv/pandas_utils.py

@@ -23,12 +23,10 @@ from . import Layout, ColumnType, Writer, Reader, FileFlags
 # Import columnar I/O if available (requires numpy headers in bindings)
 try:
     from ._bcsv import read_columns as _read_columns, write_columns as _write_columns
-    from ._bcsv import read_to_dataframe as _read_to_dataframe
     _COLUMNAR_AVAILABLE = True
 except ImportError:
     try:
         from _bcsv import read_columns as _read_columns, write_columns as _write_columns
-        from _bcsv import read_to_dataframe as _read_to_dataframe
         _COLUMNAR_AVAILABLE = True
     except ImportError:
         _COLUMNAR_AVAILABLE = False
@@ -185,10 +183,6 @@ def read_dataframe(filename: str,
         table = _read_to_arrow(filename, columns=columns)
         return table.to_pandas()
 
-    # Fast path: C++ read_to_dataframe (single call, constructs DataFrame in C++)
-    if _COLUMNAR_AVAILABLE:
-        return _read_to_dataframe(filename, columns)
-    
     reader = Reader()
     try:
         if not reader.open(filename):

pybcsv-1.4.1/tests/run_all_tests.py

@@ -1,233 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright (c) 2025-2026 Tobias Weber <weber.tobias.md@gmail.com>
-# 
-# This file is part of the BCSV library.
-# 
-# Licensed under the MIT License. See LICENSE file in the project root 
-# for full license information.
-
-"""
-Comprehensive test runner for PyBCSV unit tests.
-Runs all test suites and provides a summary report.
-"""
-
-import unittest
-import sys
-import os
-import time
-from io import StringIO
-
-# Add the parent directory to Python path to import tests
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-# Import all test modules
-from test_basic_functionality import TestBasicFunctionality
-from test_interoperability import TestInteroperability
-from test_error_handling_edge_cases import TestErrorHandling
-from test_pandas_integration import TestPandasIntegration
-from test_performance_edge_cases import TestPerformanceEdgeCases
-
-
-class ColoredTextTestResult(unittest.TextTestResult):
-    """Test result with colored output for better readability."""
-    
-    def startTest(self, test):
-        super().startTest(test)
-        self.stream.write(f"Running {test._testMethodName}... ")
-        self.stream.flush()
-    
-    def addSuccess(self, test):
-        super().addSuccess(test)
-        self.stream.write("✅ PASS\n")
-        self.stream.flush()
-    
-    def addError(self, test, err):
-        super().addError(test, err)
-        self.stream.write("❌ ERROR\n")
-        self.stream.flush()
-    
-    def addFailure(self, test, err):
-        super().addFailure(test, err)
-        self.stream.write("❌ FAIL\n")
-        self.stream.flush()
-    
-    def addSkip(self, test, reason):
-        super().addSkip(test, reason)
-        self.stream.write(f"⏭️  SKIP ({reason})\n")
-        self.stream.flush()
-
-
-def run_test_suite(test_class, suite_name):
-    """Run a specific test suite and return results."""
-    print(f"\n{'='*60}")
-    print(f"🧪 {suite_name}")
-    print(f"{'='*60}")
-    
-    # Create test suite
-    loader = unittest.TestLoader()
-    suite = loader.loadTestsFromTestCase(test_class)
-    
-    # Run tests with custom result class
-    stream = sys.stdout
-    runner = unittest.TextTestRunner(
-        stream=stream, 
-        verbosity=0,
-        resultclass=ColoredTextTestResult
-    )
-    
-    start_time = time.time()
-    result = runner.run(suite)
-    end_time = time.time()
-    
-    # Print summary for this suite
-    total_tests = result.testsRun
-    failures = len(result.failures)
-    errors = len(result.errors)
-    skipped = len(result.skipped)
-    passed = total_tests - failures - errors - skipped
-    
-    print(f"\n📊 Suite Summary:")
-    print(f"   ✅ Passed: {passed}/{total_tests}")
-    if failures > 0:
-        print(f"   ❌ Failed: {failures}")
-    if errors > 0:
-        print(f"   💥 Errors: {errors}")
-    if skipped > 0:
-        print(f"   ⏭️  Skipped: {skipped}")
-    print(f"   ⏱️  Time: {end_time - start_time:.2f}s")
-    
-    return result, end_time - start_time
-
-
-def print_detailed_failures(all_results):
-    """Print detailed information about failures and errors."""
-    has_failures = False
-    
-    for suite_name, result, _ in all_results:
-        if result.failures or result.errors:
-            if not has_failures:
-                print(f"\n{'='*60}")
-                print("🔍 DETAILED FAILURE/ERROR REPORT")
-                print(f"{'='*60}")
-                has_failures = True
-            
-            print(f"\n📋 {suite_name}:")
-            
-            for test, traceback in result.failures:
-                print(f"\n❌ FAILURE: {test}")
-                print("-" * 40)
-                print(traceback)
-            
-            for test, traceback in result.errors:
-                print(f"\n💥 ERROR: {test}")
-                print("-" * 40)
-                print(traceback)
-
-
-def main():
-    """Run all PyBCSV tests and provide comprehensive report."""
-    print("🚀 PyBCSV Comprehensive Test Suite")
-    print("Testing Python BCSV implementation for:")
-    print("  • Core functionality and data integrity")
-    print("  • C++/Python interoperability") 
-    print("  • Error handling and edge cases")
-    print("  • Pandas DataFrame integration")
-    print("  • Performance and boundary conditions")
-    
-    # Test suites to run
-    test_suites = [
-        (TestBasicFunctionality, "Basic Functionality Tests"),
-        (TestInteroperability, "C++/Python Interoperability Tests"),
-        (TestErrorHandling, "Error Handling & Edge Cases"),
-        (TestPandasIntegration, "Pandas Integration Tests"),
-        (TestPerformanceEdgeCases, "Performance & Edge Cases"),
-    ]
-    
-    # Run all test suites
-    all_results = []
-    total_start_time = time.time()
-    
-    for test_class, suite_name in test_suites:
-        try:
-            result, duration = run_test_suite(test_class, suite_name)
-            all_results.append((suite_name, result, duration))
-        except Exception as e:
-            print(f"❌ Failed to run {suite_name}: {e}")
-            continue
-    
-    total_end_time = time.time()
-    
-    # Calculate overall statistics
-    total_tests = sum(result.testsRun for _, result, _ in all_results)
-    total_failures = sum(len(result.failures) for _, result, _ in all_results)
-    total_errors = sum(len(result.errors) for _, result, _ in all_results)
-    total_skipped = sum(len(result.skipped) for _, result, _ in all_results)
-    total_passed = total_tests - total_failures - total_errors - total_skipped
-    total_time = total_end_time - total_start_time
-    
-    # Print overall summary
-    print(f"\n{'='*60}")
-    print("🎯 OVERALL TEST SUMMARY")
-    print(f"{'='*60}")
-    print(f"📊 Total Tests: {total_tests}")
-    print(f"✅ Passed: {total_passed} ({total_passed/total_tests*100:.1f}%)" if total_tests > 0 else "✅ Passed: 0")
-    print(f"❌ Failed: {total_failures}")
-    print(f"💥 Errors: {total_errors}")
-    print(f"⏭️  Skipped: {total_skipped}")
-    print(f"⏱️  Total Time: {total_time:.2f}s")
-    
-    # Success rate
-    if total_tests > 0:
-        success_rate = (total_passed / total_tests) * 100
-        if success_rate >= 95:
-            print(f"🎉 Excellent! {success_rate:.1f}% success rate")
-        elif success_rate >= 80:
-            print(f"✅ Good! {success_rate:.1f}% success rate")
-        elif success_rate >= 60:
-            print(f"⚠️  Acceptable: {success_rate:.1f}% success rate")
-        else:
-            print(f"❌ Needs improvement: {success_rate:.1f}% success rate")
-    
-    # Per-suite breakdown
-    print(f"\n📋 Per-Suite Results:")
-    for suite_name, result, duration in all_results:
-        total = result.testsRun
-        passed = total - len(result.failures) - len(result.errors) - len(result.skipped)
-        status = "✅" if len(result.failures) == 0 and len(result.errors) == 0 else "❌"
-        print(f"   {status} {suite_name}: {passed}/{total} passed ({duration:.2f}s)")
-    
-    # Print detailed failures if any
-    print_detailed_failures(all_results)
-    
-    # Final recommendations
-    print(f"\n{'='*60}")
-    print("📝 RECOMMENDATIONS")
-    print(f"{'='*60}")
-    
-    if total_failures == 0 and total_errors == 0:
-        print("🎉 All tests passed! PyBCSV implementation is working correctly.")
-        print("✅ The Python wrapper demonstrates:")
-        print("   • Correct basic functionality")
-        print("   • Proper error handling")
-        print("   • C++/Python interoperability")
-        print("   • Pandas integration")
-        print("   • Good performance characteristics")
-    else:
-        print("⚠️  Some tests failed. Please review the detailed failure report above.")
-        print("🔧 Recommended actions:")
-        if total_errors > 0:
-            print("   • Fix critical errors that prevent test execution")
-        if total_failures > 0:
-            print("   • Address test failures to ensure correct behavior")
-        if total_skipped > 0:
-            print("   • Review skipped tests and their skip reasons")
-    
-    # Return exit code
-    exit_code = 0 if (total_failures == 0 and total_errors == 0) else 1
-    return exit_code
-
-
-if __name__ == '__main__':
-    exit_code = main()
-    sys.exit(exit_code)

pybcsv-1.4.1/tests/run_tests.py

@@ -1,92 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test runner for the pybcsv test suite.
-
-This script runs all tests and provides a summary of results.
-"""
-
-import unittest
-import sys
-import os
-
-# Add the pybcsv package to the path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-
-def run_tests():
-    """Run all tests and return the result."""
-    # Discover and run all tests
-    loader = unittest.TestLoader()
-    start_dir = os.path.dirname(__file__)
-    suite = loader.discover(start_dir, pattern='test_*.py')
-    
-    # Run tests with verbose output
-    runner = unittest.TextTestRunner(verbosity=2, buffer=True)
-    result = runner.run(suite)
-    
-    return result
-
-def main():
-    """Main test runner function."""
-    print("=" * 60)
-    print("Running pybcsv test suite")
-    print("=" * 60)
-    
-    try:
-        import pybcsv
-        print(f"✓ pybcsv version {pybcsv.__version__} loaded successfully")
-    except ImportError as e:
-        print(f"❌ Failed to import pybcsv: {e}")
-        print("Make sure pybcsv is installed: pip install -e .")
-        return 1
-    
-    # Check optional dependencies
-    try:
-        import pandas
-        print(f"✓ pandas {pandas.__version__} available")
-    except ImportError:
-        print("⚠ pandas not available - some tests will be skipped")
-    
-    try:
-        import numpy
-        print(f"✓ numpy {numpy.__version__} available")
-    except ImportError:
-        print("⚠ numpy not available - some tests may fail")
-    
-    print("\n" + "=" * 60)
-    print("Starting tests...")
-    print("=" * 60)
-    
-    result = run_tests()
-    
-    print("\n" + "=" * 60)
-    print("Test Summary")
-    print("=" * 60)
-    
-    if result.wasSuccessful():
-        print(f"✅ All tests passed!")
-        print(f"   Tests run: {result.testsRun}")
-        if result.skipped:
-            print(f"   Tests skipped: {len(result.skipped)}")
-        return 0
-    else:
-        print(f"❌ Some tests failed")
-        print(f"   Tests run: {result.testsRun}")
-        print(f"   Failures: {len(result.failures)}")
-        print(f"   Errors: {len(result.errors)}")
-        if result.skipped:
-            print(f"   Tests skipped: {len(result.skipped)}")
-        
-        if result.failures:
-            print("\nFailures:")
-            for test, traceback in result.failures:
-                print(f"  - {test}")
-        
-        if result.errors:
-            print("\nErrors:")
-            for test, traceback in result.errors:
-                print(f"  - {test}")
-        
-        return 1
-
-if __name__ == '__main__':
-    sys.exit(main())