stdfast 0.1.2__tar.gz → 0.2.0__tar.gz

{stdfast-0.1.2 → stdfast-0.2.0}/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+
+## 0.2.0
+
+- New append mode for StdfWriter
+
 ## 0.1.2
 
 - Bump version for new build files

{stdfast-0.1.2 → stdfast-0.2.0}/Cargo.lock

@@ -1922,7 +1922,7 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "stdfast"
-version = "0.1.2"
+version = "0.2.0"
 dependencies = [
  "clap",
  "itertools",

{stdfast-0.1.2 → stdfast-0.2.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "stdfast"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2024"
 description = "Parsing of STDF file format to DataFrame with Python bindings"
 license = "BSD-2"

{stdfast-0.1.2 → stdfast-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stdfast
-Version: 0.1.2
+Version: 0.2.0
 Requires-Dist: polars
 Requires-Dist: pydantic>=2.12.5
 License-File: LICENSE
@@ -107,7 +107,8 @@ sf.write_stdf("output.stdf", records)
 import stdfast as sf
 from stdfast.records import FAR, MIR, MRR, PIR, PTR, PRR
 
-with sf.StdfWriter("output.stdf") as w:
+# Creates new file or overwrites content if it exists
+with sf.StdfWriter("output.stdf", append=False) as w:
     w.write_record(FAR(cpu_type=2, stdf_ver=4))
     w.write_record(MIR(lot_id="LOT001", part_typ="MYPART", job_nam="MYJOB"))
     for i, result in enumerate(my_results):
@@ -115,6 +116,11 @@ with sf.StdfWriter("output.stdf") as w:
         w.write_record(PTR(test_num=1000 + i, head_num=1, site_num=1, result=result, test_txt=f"test_{i}"))
         w.write_record(PRR(head_num=1, site_num=1, hard_bin=1, soft_bin=1, num_test=1))
     w.write_record(MRR())
+
+# Creates new file or appends to content if it exists
+with sf.StdfWriter("output.stdf", append=True) as w:
+    ...
+
 ```
 
 `StdfWriter` is preferable when the number of records is large or unknown upfront, since it never holds more than one record in memory at a time.

{stdfast-0.1.2 → stdfast-0.2.0}/README.md

@@ -92,7 +92,8 @@ sf.write_stdf("output.stdf", records)
 import stdfast as sf
 from stdfast.records import FAR, MIR, MRR, PIR, PTR, PRR
 
-with sf.StdfWriter("output.stdf") as w:
+# Creates new file or overwrites content if it exists
+with sf.StdfWriter("output.stdf", append=False) as w:
     w.write_record(FAR(cpu_type=2, stdf_ver=4))
     w.write_record(MIR(lot_id="LOT001", part_typ="MYPART", job_nam="MYJOB"))
     for i, result in enumerate(my_results):
@@ -100,6 +101,11 @@ with sf.StdfWriter("output.stdf") as w:
         w.write_record(PTR(test_num=1000 + i, head_num=1, site_num=1, result=result, test_txt=f"test_{i}"))
         w.write_record(PRR(head_num=1, site_num=1, hard_bin=1, soft_bin=1, num_test=1))
     w.write_record(MRR())
+
+# Creates new file or appends to content if it exists
+with sf.StdfWriter("output.stdf", append=True) as w:
+    ...
+
 ```
 
 `StdfWriter` is preferable when the number of records is large or unknown upfront, since it never holds more than one record in memory at a time.

{stdfast-0.1.2 → stdfast-0.2.0}/src/write_py.rs

@@ -20,6 +20,7 @@
 //! ```
 
 use std::fs::File;
+use std::fs::OpenOptions;
 use std::io::{BufWriter, Write};
 use std::sync::Mutex;
 
@@ -576,8 +577,9 @@ pub struct StdfWriter {
 #[pymethods]
 impl StdfWriter {
     #[new]
-    pub fn open(fname: &str) -> PyResult<Self> {
-        let file = File::create(fname)
+    #[pyo3(signature = (fname, append = false))]
+    pub fn open(fname: &str, append: bool) -> PyResult<Self> {
+        let file = OpenOptions::new().write(true).create(true).truncate(!append).append(append).open(fname)
             .map_err(|e| pyo3::exceptions::PyIOError::new_err(e.to_string()))?;
         Ok(Self {
             inner: Mutex::new(Some(BufWriter::new(file))),

{stdfast-0.1.2 → stdfast-0.2.0}/stdfast/stdfast.pyi

@@ -114,12 +114,19 @@ class StdfWriter:
 
     Can be used as a context manager::
 
-        with sf.StdfWriter("out.stdf") as w:
+        # Create file or overwrites content if it exists
+        with sf.StdfWriter("out.stdf", append=False) as w:
             w.write_record(FAR(cpu_type=2, stdf_ver=4))
             w.write_record(MRR())
+
+        # Create file or appends to content if it exists
+        with sf.StdfWriter("out.stdf", append=True) as w:
+            w.write_record(FAR(cpu_type=2, stdf_ver=4))
+            w.write_record(MRR())
+
     """
 
-    def __init__(self, fname: str) -> None: ...
+    def __init__(self, fname: str, append: bool = False) -> None: ...
     def write_record(self, record) -> None: ...
     def close(self) -> None: ...
     def __enter__(self) -> "StdfWriter": ...

{stdfast-0.1.2 → stdfast-0.2.0}/stdfast/tests/test_roundtrip.py

@@ -3,6 +3,7 @@ Roundtrip tests: Python records → write_stdf → binary file → parse_stdf
 """
 
 import math
+import os
 
 import pytest
 
@@ -248,6 +249,217 @@ class TestStdfWriterRoundtrip:
         assert row["units"][0] == "mA"
 
 
+# ---------------------------------------------------------------------------
+# StdfWriter append mode
+# ---------------------------------------------------------------------------
+
+
+def _make_first_part():
+    """FAR + MIR + TSR + first PIR/PTR/PRR block (no MRR yet).
+
+    The TSR must precede PIR so that test_num 1000 is registered before the
+    second parse pass processes PTRs.
+    """
+    return [
+        FAR(cpu_type=2, stdf_ver=4),
+        MIR(lot_id="LOT_APPEND", part_typ="APPEND_PART", job_nam="APPEND_JOB"),
+        TSR(
+            test_num=1000,
+            head_num=1,
+            site_num=1,
+            test_typ="P",
+            test_nam="vdd",
+            exec_cnt=2,
+        ),
+        PIR(head_num=1, site_num=1),
+        PTR(
+            test_num=1000,
+            head_num=1,
+            site_num=1,
+            result=1.0,
+            test_txt="vdd",
+            lo_limit=0.9,
+            hi_limit=1.2,
+            units="V",
+        ),
+        PRR(
+            head_num=1,
+            site_num=1,
+            hard_bin=1,
+            soft_bin=1,
+            num_test=1,
+            part_id="PART_001",
+        ),
+    ]
+
+
+def _make_second_part():
+    """Second PIR/PTR/PRR block + MRR to close the file."""
+    return [
+        PIR(head_num=1, site_num=1),
+        PTR(
+            test_num=1000,
+            head_num=1,
+            site_num=1,
+            result=1.1,
+            test_txt="vdd",
+            lo_limit=0.9,
+            hi_limit=1.2,
+            units="V",
+        ),
+        PRR(
+            head_num=1,
+            site_num=1,
+            hard_bin=1,
+            soft_bin=1,
+            num_test=1,
+            part_id="PART_002",
+        ),
+        MRR(),
+    ]
+
+
+class TestStdfWriterAppend:
+    """Tests for StdfWriter append=True mode."""
+
+    def test_append_extends_raw_record_count(self, tmp_path):
+        """Appending records to an existing file increases the total record count."""
+        path = str(tmp_path / "append_count.stdf")
+        first = _make_first_part()
+        second = _make_second_part()
+
+        with sf.StdfWriter(path) as w:
+            for r in first:
+                w.write_record(r)
+
+        with sf.StdfWriter(path, append=True) as w:
+            for r in second:
+                w.write_record(r)
+
+        raw = sf.get_raw_records(path)
+        assert len(raw) == len(first) + len(second)
+
+    def test_append_record_order(self, tmp_path):
+        """Records appear in the file in exactly the order they were written."""
+        path = str(tmp_path / "append_order.stdf")
+        first = _make_first_part()  # FAR, MIR, PIR, PTR, PRR
+        second = _make_second_part()  # PIR, PTR, PRR, MRR
+
+        with sf.StdfWriter(path) as w:
+            for r in first:
+                w.write_record(r)
+
+        with sf.StdfWriter(path, append=True) as w:
+            for r in second:
+                w.write_record(r)
+
+        types = [r["record_type"] for r in sf.get_raw_records(path)]
+        assert types == ["FAR", "MIR", "PIR", "PTR", "PRR", "PIR", "PTR", "PRR", "MRR"]
+
+    def test_append_parses_both_parts(self, tmp_path):
+        """parse_stdf on a split-written STDF yields both parts as data rows."""
+        path = str(tmp_path / "append_parse.stdf")
+
+        with sf.StdfWriter(path) as w:
+            for r in _make_first_part():
+                w.write_record(r)
+
+        with sf.StdfWriter(path, append=True) as w:
+            for r in _make_second_part():
+                w.write_record(r)
+
+        result = sf.parse_stdf(path)
+        assert len(result["data"]) == 2
+
+    def test_append_part_ids(self, tmp_path):
+        """Both part IDs survive the split-write roundtrip."""
+        path = str(tmp_path / "append_part_ids.stdf")
+
+        with sf.StdfWriter(path) as w:
+            for r in _make_first_part():
+                w.write_record(r)
+
+        with sf.StdfWriter(path, append=True) as w:
+            for r in _make_second_part():
+                w.write_record(r)
+
+        part_ids = sf.parse_stdf(path)["data"]["part_id"].to_list()
+        assert "PART_001" in part_ids
+        assert "PART_002" in part_ids
+
+    def test_no_append_truncates_existing_file(self, tmp_path):
+        """Opening StdfWriter without append=True discards the original content."""
+        path = str(tmp_path / "no_append.stdf")
+
+        with sf.StdfWriter(path) as w:
+            for r in _make_first_part() + _make_second_part():
+                w.write_record(r)
+
+        # Overwrite with just a single FAR record
+        with sf.StdfWriter(path) as w:
+            w.write_record(FAR(cpu_type=2, stdf_ver=4))
+
+        raw = sf.get_raw_records(path)
+        assert len(raw) == 1
+        assert raw[0]["record_type"] == "FAR"
+
+    def test_append_preserves_original_bytes(self, tmp_path):
+        """Bytes written in the first session are not modified by an append."""
+        path = str(tmp_path / "bytes_preserved.stdf")
+
+        with sf.StdfWriter(path) as w:
+            for r in _make_first_part():
+                w.write_record(r)
+
+        original_bytes = open(path, "rb").read()
+
+        with sf.StdfWriter(path, append=True) as w:
+            for r in _make_second_part():
+                w.write_record(r)
+
+        all_bytes = open(path, "rb").read()
+        assert all_bytes[: len(original_bytes)] == original_bytes
+
+    def test_append_bytes_equal_manual_concat(self, tmp_path):
+        """Content of the appended file equals the manual concatenation of both parts."""
+        file_a = str(tmp_path / "part_a.stdf")
+        file_b = str(tmp_path / "part_b.stdf")
+        file_ab = str(tmp_path / "appended.stdf")
+
+        with sf.StdfWriter(file_a) as w:
+            for r in _make_first_part():
+                w.write_record(r)
+
+        with sf.StdfWriter(file_b) as w:
+            for r in _make_second_part():
+                w.write_record(r)
+
+        with sf.StdfWriter(file_ab) as w:
+            for r in _make_first_part():
+                w.write_record(r)
+
+        with sf.StdfWriter(file_ab, append=True) as w:
+            for r in _make_second_part():
+                w.write_record(r)
+
+        concat = open(file_a, "rb").read() + open(file_b, "rb").read()
+        appended = open(file_ab, "rb").read()
+        assert appended == concat
+
+    def test_append_creates_new_file(self, tmp_path):
+        """append=True on a nonexistent path creates the file."""
+        path = str(tmp_path / "new_via_append.stdf")
+        assert not os.path.exists(path)
+
+        records = _make_first_part() + _make_second_part()
+        with sf.StdfWriter(path, append=True) as w:
+            for r in records:
+                w.write_record(r)
+
+        assert os.path.exists(path)
+        assert len(sf.get_raw_records(path)) == len(records)
+
+
 class TestStdfWriterBytesMatchBatch:
     """StdfWriter must produce bit-for-bit identical output to write_stdf."""